home *** CD-ROM | disk | FTP | other *** search
/ ftptest.leeds.ac.uk / 2015.02.ftptest.leeds.ac.uk.tar / ftptest.leeds.ac.uk / bionet / CAE-GROUP / SCL-WIN3x / SCL.EXE / ATTRIBUT.CPP < prev    next >
C/C++ Source or Header  |  1994-08-29  |  26KB  |  1,010 lines
  1. /*
  2. * NIST STEP Core Class Library
  3. * clstepcore/STEPattribute.cc
  4. * February, 1994
  5. * K. C. Morris
  6. * David Sauder
  7.  
  8. * Development of this software was funded by the United States Government,
  9. * and is not subject to copyright.
  10. */
  11.  
  12. /* $Id: STEPattribute.cc,v 2.0.1.2 1994/04/05 16:39:30 sauderd Exp $ */
  13.  
  14. //static char rcsid[] ="$Id: STEPattribute.cc,v 2.0.1.2 1994/04/05 16:39:30 sauderd Exp $";
  15.  
  16.  
  17. #include <read_func.h>
  18. #include <attribute.h>
  19. #include <sdai.h>
  20. #include <instmgr.h>
  21. #include <undefined.h>
  22. #include <aggregate.h>
  23. #include <Sentity.h>
  24. #include <select.h>
  25. #include <Binary.h>
  26.  
  27. const int Real_Num_Precision = 15;
  28.  
  29. /******************************************************************
  30. **      Functions for manipulating attribute
  31.  
  32. **  KNOWN BUGS:  
  33. **    -- error reporting does not include line number information
  34. **    -- null attributes are only handled through the attribute pointer class
  35. **       direct access of a null attribute will not indicate whether the 
  36. **       attribute is null in all cases (although a null value is available
  37. **       for entities and enumerations.) 
  38. **/
  39.  
  40.  
  41. ///////////////////////////////////////////////////////////////////////////////
  42. ///////////////////////////////////////////////////////////////////////////////
  43. // STEPattribute Functions
  44. ///////////////////////////////////////////////////////////////////////////////
  45. ///////////////////////////////////////////////////////////////////////////////
  46.  
  47. /******************************************************************
  48. // the value of the attribute is assigned from the supplied string
  49.  ******************************************************************/
  50.  
  51. Severity 
  52. STEPattribute::StrToVal (const char* s, InstMgr * instances, int addFileId)
  53. {
  54.     _error.ClearErrorMsg();    // also sets Severity to SEVERITY_NULL
  55.  
  56.     //  set the value to be null (reinitialize the attribute value)
  57.     set_null();
  58.  
  59.     int nullable = (AttrDescriptor->Optional().asInt() == sdaiTRUE);
  60.  
  61.     // an empty str gets assigned NULL
  62.     if (!s || (s[0] == '\0') )
  63.     {
  64.     if(nullable)
  65.         return SEVERITY_NULL;
  66.     else
  67.         _error.severity(SEVERITY_INCOMPLETE);
  68.         return SEVERITY_INCOMPLETE;
  69.     }
  70.  
  71.     istrstream in ((char *)s); // sz defaults to length of s
  72.     int valAssigned = 0;
  73.  
  74.     // read in value for attribute
  75.     switch (NonRefType())
  76.     {
  77.       case INTEGER_TYPE:
  78.       {
  79.       valAssigned = ReadInteger(*(ptr.i), s, &_error, 0);
  80.       break;
  81.       }
  82.       case REAL_TYPE:
  83.       {
  84.       valAssigned = ReadReal(*(ptr.r), s, &_error, 0);
  85.       break;
  86.       }
  87.       case NUMBER_TYPE:
  88.       {
  89.       valAssigned = ReadNumber(*(ptr.r), s, &_error, 0);
  90.       break;
  91.       }
  92.  
  93.       case ENTITY_TYPE:
  94.       {
  95.       STEPentity *se = ReadEntityRef(s, &_error, 0, instances, addFileId);
  96.       if( se != S_ENTITY_NULL )
  97.       {
  98.           if(EntityValidLevel(se, AttrDescriptor->NonRefTypeDescriptor(), 
  99.                   &_error) 
  100.          == SEVERITY_NULL)
  101.           *(ptr.c) = se;
  102.           else
  103.           *(ptr.c) = S_ENTITY_NULL;
  104.       }
  105.       else
  106.           *(ptr.c) = S_ENTITY_NULL;
  107.       break;
  108.       }
  109.  
  110.       case BINARY_TYPE:
  111.       {
  112.       ptr.b->StrToVal(s, &_error); // call class SdaiBinary::StrToVal()
  113.       break;
  114.       }
  115.       case STRING_TYPE:
  116.       {
  117.       *(ptr.S) = s; // using string class - don't need to declare space
  118.       break;
  119.       }
  120.  
  121.       case BOOLEAN_TYPE:
  122.       case LOGICAL_TYPE:
  123.       case ENUM_TYPE:
  124.     {
  125.         ptr.e->StrToVal (s, &_error, nullable);
  126.         break;
  127.     }
  128.  
  129.       case AGGREGATE_TYPE:
  130.         ptr.a -> StrToVal (s, &_error, 
  131.                AttrDescriptor -> AggrElemTypeDescriptor (), 
  132.                instances, addFileId);
  133.     break;
  134.  
  135.       case SELECT_TYPE:
  136.     if (_error.severity( ptr.sh->STEPread(in, &_error, instances) ) 
  137.         != SEVERITY_NULL)
  138.     _error.AppendToDetailMsg (ptr.sh ->Error ());
  139.         break;
  140.  
  141. //      case UNKNOWN_TYPE: // should never have this case
  142.       case GENERIC_TYPE:
  143.       default:
  144.     // other cases are the same for StrToVal and file
  145.     return STEPread(in, instances, addFileId);
  146.       }
  147.     return _error.severity();
  148. }
  149.  
  150.  
  151. /******************************************************************
  152.  ** Procedure:  STEPread
  153.  ** Returns:  Severity, which indicates success, or failure
  154.  **         value >= SEVERITY_WARNING means program can continue parsing input,
  155.  **         value <= SEVERITY_INPUT_ERROR  is fatal read error
  156.  ** Description:  the value of the attribute is read from istream
  157.  **               the format expected is STEP exchange file
  158.  **          modified to accept '$' as value for OPTIONAL ATTRIBUTE,
  159.  **             (since this function is used for reading files in both
  160.  **              formats, the function accepts either '$' (new format),
  161.  **              or nothing (old format)) 31-Jul-1992
  162.  ******************************************************************/
  163. // does not read the delimiter separating individual attributes (i.e. ',') or 
  164. // the delim separating the last attribute from the end of the entity (')').
  165.  
  166. Severity
  167. STEPattribute::STEPread (istream& in, InstMgr * instances, int addFileId)
  168. {
  169.  
  170.     char errStr[BUFSIZ];
  171.     errStr[0] = '\0';
  172.     char c ='\0';
  173.  
  174.     _error.ClearErrorMsg();    // also sets Severity to SEVERITY_NULL
  175.  
  176.     //  set the value to be null (reinitialize the attribute value)
  177.     set_null();
  178.  
  179.     in >> ws; // skip whitespace
  180.     in >> c;
  181.     in.putback (c);    //  leave input stream alone
  182.  
  183.     //  check for NULL or derived attribute value, return if either
  184.     switch (c)
  185.     {
  186.       case '$':
  187.       case ',':
  188.       case ')':
  189.     if (c == '$') 
  190.     {
  191.         in.get(c);
  192.         CheckRemainingInput(in, &_error, AttrDescriptor->TypeName(), ",)");
  193.     }
  194.     if(Nullable())  {
  195.         _error.severity(SEVERITY_NULL);
  196.     }
  197.     else {
  198.         _error.severity(SEVERITY_INCOMPLETE);
  199.         sprintf(errStr, " missing and required\n");
  200. //            " Warning: attribute '%s : %s' is missing and required.\n",
  201. //            Name(), TypeName());
  202.         _error.AppendToDetailMsg(errStr);
  203.     }
  204.     return _error.severity();
  205.  
  206.       case '*':
  207.     in.get(c);  // take * off the istream
  208.     if (IsDerived ())  
  209.         _error.severity(SEVERITY_NULL);
  210.     else {
  211.         _error.severity(SEVERITY_INCOMPLETE);
  212.         sprintf(errStr, " attribute not derived\n");
  213.         _error.AppendToDetailMsg(errStr);
  214.     }
  215.     CheckRemainingInput(in, &_error, AttrDescriptor->TypeName(), ",)");
  216.     return _error.severity();
  217.     }
  218.  
  219.     enum BASE_TYPE attrBaseType = NonRefType();
  220.     switch( attrBaseType )
  221.     {
  222.       case INTEGER_TYPE:
  223.       {
  224.         int valAssigned = ReadInteger(*(ptr.i), in, &_error, ",)");
  225.         return _error.severity();
  226.     }
  227.       case REAL_TYPE:
  228.       {
  229.         int valAssigned = ReadReal(*(ptr.r), in, &_error, ",)");
  230.         return _error.severity();
  231.     }
  232.       case NUMBER_TYPE:
  233.       {
  234.         int valAssigned = ReadNumber(*(ptr.r), in, &_error, ",)");
  235.         return _error.severity();
  236.     }
  237.       case STRING_TYPE: 
  238.       {
  239.         ptr.S->STEPread (in, &_error);
  240.         CheckRemainingInput(in, &_error, "string", ",)");
  241.         return _error.severity();
  242.     }
  243.       case BINARY_TYPE:
  244.     {    // call class SdaiBinary::STEPread()
  245.         ptr.b->STEPread(in, &_error);
  246.         CheckRemainingInput(in, &_error, "binary", ",)");
  247.         return _error.severity();
  248.     }
  249.       case BOOLEAN_TYPE:
  250.       {
  251. //        int nullable = (AttrDescriptor->Optional().asInt() == sdaiTRUE);
  252.         ptr.e->STEPread (in, &_error,  Nullable());
  253.         CheckRemainingInput(in, &_error, "boolean", ",)");
  254.         return _error.severity();
  255.     }
  256.       case LOGICAL_TYPE:
  257.       {
  258.         ptr.e->STEPread (in, &_error,  Nullable());
  259.         CheckRemainingInput(in, &_error, "logical", ",)");
  260.         return _error.severity();
  261.     }
  262.       case ENUM_TYPE:
  263.       {
  264.         ptr.e->STEPread (in, &_error,  Nullable());
  265.         CheckRemainingInput(in, &_error, "enumeration", ",)");
  266.         return _error.severity();
  267.     }
  268.       case AGGREGATE_TYPE:
  269.       {
  270.         ptr.a->STEPread(in, &_error, 
  271.                 AttrDescriptor->AggrElemTypeDescriptor(), 
  272.                 instances, addFileId);
  273.  
  274.         // cannot recover so give up and let STEPentity recover
  275.         if(_error.severity() < SEVERITY_WARNING)
  276.         return _error.severity();
  277.  
  278.         // check for garbage following the aggregate
  279.         CheckRemainingInput(in, &_error, "aggregate", ",)");
  280.         return _error.severity();
  281.     }
  282.       case ENTITY_TYPE:
  283.       {
  284.         STEPentity *se = ReadEntityRef(in, &_error, ",)", instances, 
  285.                        addFileId);
  286.         if( se != S_ENTITY_NULL )
  287.         {
  288.         if(EntityValidLevel(se, 
  289.                     AttrDescriptor->NonRefTypeDescriptor(), 
  290.                     &_error) == SEVERITY_NULL)
  291.             *(ptr.c) = se;
  292.         else
  293.         {
  294.             *(ptr.c) = S_ENTITY_NULL;
  295.         }
  296.         }
  297.         else
  298.         *(ptr.c) = S_ENTITY_NULL;
  299. //        CheckRemainingInput(in, &_error, "enumeration", ",)");
  300.         return _error.severity();
  301.  
  302.     }
  303.       case SELECT_TYPE:
  304.         if (_error.severity( ptr.sh->STEPread(in, &_error, instances, addFileId) ) 
  305.           != SEVERITY_NULL)
  306.         _error.AppendToDetailMsg (ptr.sh ->Error ());
  307.         CheckRemainingInput(in, &_error, "select", ",)");
  308.         return _error.severity();
  309.  
  310.       case GENERIC_TYPE:
  311.       {
  312.        cerr << "Internal error:  " << __FILE__ <<  __LINE__
  313.            << "\n" << _POC_ "\n";
  314.        _error.GreaterSeverity (SEVERITY_BUG);
  315.         return _error.severity();
  316.     }
  317.  
  318.       case UNKNOWN_TYPE:
  319.       case REFERENCE_TYPE:
  320.       default:
  321.       {
  322.         // bug
  323.        cerr << "Internal error:  " << __FILE__ <<  __LINE__
  324.            << "\n" << _POC_ "\n";
  325.        _error.GreaterSeverity (SEVERITY_BUG);
  326.         return _error.severity();
  327.     }
  328.     }
  329. }
  330.  
  331. /******************************************************************
  332.  ** Procedure:  asStr
  333.  ** Parameters:  
  334.  ** Returns:  
  335.  ** Description:  the value of the attribute is returned as a string.
  336.  ** Side Effects:  
  337.  ** Status:  complete 3/91
  338.  ******************************************************************/
  339. const char *
  340. STEPattribute::asStr (SCLstring& str) const
  341. {
  342. //  char attrVal[BUFSIZ];
  343. //  attrVal[0] = '\0';
  344.  
  345.     str.set_null();
  346.     if (is_null ()) return str = "";
  347.  
  348.     switch (NonRefType()) {
  349.       case INTEGER_TYPE:
  350.       str.Append (*(ptr.i));
  351. //    sprintf ( attrVal,"%ld",*(ptr.i));
  352.     break;
  353.  
  354.       case NUMBER_TYPE:
  355.       case REAL_TYPE:
  356.       str.Append (*(ptr.r));
  357. //    sprintf (attrVal, "%.*g", (int) Real_Num_Precision, *(ptr.r));
  358.     break;      
  359.  
  360.       case ENTITY_TYPE:
  361.     // print instance id only if not empty pointer
  362.     // and has value assigned
  363.     if ((*(ptr.c) == S_ENTITY_NULL) || (*(ptr.c) == 0))
  364.         break;
  365.     else
  366.     {
  367.         (*(ptr.c))->STEPwrite_reference (str);
  368. //        strncpy(attrVal, str.chars(), str.Length()+1);
  369.     }
  370.     break;      
  371.     
  372.       case BINARY_TYPE:
  373.     if( !( (ptr.b)->is_null() ) )
  374.         (ptr.b) -> STEPwrite (str);
  375. //        strncpy(attrVal, str.chars(), str.Length()+1);
  376.     break;
  377.  
  378.       case STRING_TYPE:
  379.     if( !( (ptr.S)->is_null() ) )
  380.         return (ptr.S) -> asStr (str);
  381.     break;
  382.     
  383.       case AGGREGATE_TYPE:
  384.       return  ptr.a->asStr(str) ;
  385. //    sprintf ( attrVal, "%s", ptr.a->asStr() );
  386.  
  387.       case ENUM_TYPE:
  388.       case BOOLEAN_TYPE:
  389.       case LOGICAL_TYPE:
  390.         return ptr.e -> asStr(str);
  391.  
  392.       case SELECT_TYPE:
  393.       ptr.sh -> STEPwrite (str);
  394.       return str;
  395. //      strncpy (attrVal, tmp.chars(), BUFSIZ);
  396.  
  397.       case REFERENCE_TYPE:
  398.       case GENERIC_TYPE:
  399.        cerr << "Internal error:  " << __FILE__ <<  __LINE__
  400.            << "\n" << _POC_ "\n";
  401.        return 0;
  402.  
  403.       case UNKNOWN_TYPE:
  404.       default:
  405.     return (ptr.u -> asStr (str));
  406.     }
  407. //    return (attrVal);
  408.     return str;
  409. }
  410.  
  411. // The value of the attribute is printed to the output stream specified by out.
  412. // The output is in physical file format.
  413.  
  414. void
  415. STEPattribute::STEPwrite (ostream& out) 
  416. { 
  417.     if (is_null ()) {
  418.     out << "$";
  419.     return;
  420.     }
  421.  
  422.     if (IsDerived ())  {
  423.       out << "*";
  424.       return;
  425.     }
  426.  
  427.     switch (NonRefType())
  428.     {
  429.       case INTEGER_TYPE:
  430.     out << *(ptr.i);
  431.     break;
  432.  
  433.       case NUMBER_TYPE:
  434.       case REAL_TYPE:
  435.       {
  436.       real tmp = *(ptr.r) ; 
  437.       char* temp=new char[100];
  438.       if(tmp > -.00000001 && tmp < .00000001){
  439.       sprintf (temp, "%#.2g", *(ptr.r));
  440.       out << temp;
  441.       }
  442.       else{
  443.       sprintf (temp, "%#g", *(ptr.r));
  444.          out << temp;
  445.          }
  446.     break; 
  447.       }
  448.  
  449.       case ENTITY_TYPE:
  450.     // print instance id only if not empty pointer
  451.     if ((*(ptr.c) == 0) ||  
  452.         // no value was assigned  <-- this would be a BUG
  453.         (*(ptr.c) == S_ENTITY_NULL) )
  454.     {
  455.         out << "$";
  456.         cerr << "Internal error:  " << __FILE__ <<  __LINE__
  457.          << "\n" << _POC_ "\n";
  458.  
  459.         char errStr[BUFSIZ];
  460.         errStr[0] = '\0';
  461.         _error.GreaterSeverity(SEVERITY_BUG);
  462.         sprintf(errStr,
  463.            " Warning: attribute '%s : %s' is null and shouldn't be.\n",
  464.             Name(), TypeName());
  465.         _error.AppendToUserMsg(errStr);
  466.         _error.AppendToDetailMsg(errStr);
  467.     }
  468.     else  (*(ptr.c)) -> STEPwrite_reference (out);
  469.     break;      
  470.  
  471.       case STRING_TYPE:
  472.     // if null pointer or pointer to a string of length zero
  473.     if(ptr.S)
  474.         (ptr.S) -> STEPwrite (out);
  475.     else
  476.     {
  477.         out << "$";
  478.         cerr << "Internal error:  " << __FILE__ <<  __LINE__
  479.          << "\n" << _POC_ "\n";
  480.  
  481.         char errStr[BUFSIZ];
  482.         errStr[0] = '\0';
  483.         _error.GreaterSeverity(SEVERITY_BUG);
  484.         sprintf(errStr,
  485.            " Warning: attribute '%s : %s' should be pointing at %s",
  486.             Name(), TypeName(), "an SdaiString.\n");
  487.         _error.AppendToUserMsg(errStr);
  488.         _error.AppendToDetailMsg(errStr);
  489.     }
  490.     break;
  491.  
  492.       case BINARY_TYPE:    
  493.     // if null pointer or pointer to a string of length zero
  494.     if(ptr.b)
  495.         (ptr.b) -> STEPwrite (out);
  496.     else
  497.     {
  498.         out << "$";
  499.         cerr << "Internal error:  " << __FILE__ << ": " <<  __LINE__
  500.          << "\n" << _POC_ "\n";
  501.  
  502.         char errStr[BUFSIZ];
  503.         errStr[0] = '\0';
  504.         _error.GreaterSeverity(SEVERITY_BUG);
  505.         sprintf(errStr,
  506.            " Warning: attribute '%s : %s' should be pointing at %s",
  507.             Name(), TypeName(), "an SdaiBinary.\n");
  508.         _error.AppendToUserMsg(errStr);
  509.         _error.AppendToDetailMsg(errStr);
  510.     }
  511.     break;
  512.  
  513.       case AGGREGATE_TYPE:
  514.     ptr.a -> STEPwrite (out);
  515.     break;
  516.  
  517.       case ENUM_TYPE:
  518.       case BOOLEAN_TYPE:
  519.       case LOGICAL_TYPE:
  520.     if(ptr.e)
  521.         ptr.e -> STEPwrite (out);
  522.     else
  523.     {
  524.         out << "$";
  525.         cerr << "Internal error:  " << __FILE__ << ": " <<  __LINE__
  526.          << "\n" << _POC_ "\n";
  527.  
  528.         char errStr[BUFSIZ];
  529.         errStr[0] = '\0';
  530.         _error.GreaterSeverity(SEVERITY_BUG);
  531.         sprintf(errStr,
  532.            " Warning: attribute '%s : %s' should be pointing at %s",
  533.             Name(), TypeName(), "a STEPenumeration class.\n");
  534.         _error.AppendToUserMsg(errStr);
  535.         _error.AppendToDetailMsg(errStr);
  536.     }
  537.     break;
  538.  
  539.       case SELECT_TYPE:
  540.     if(ptr.sh)
  541.         ptr.sh -> STEPwrite (out);
  542.     else
  543.     {
  544.         out << "$";
  545.         cerr << "Internal error:  " << __FILE__ <<  __LINE__
  546.          << "\n" << _POC_ "\n";
  547.  
  548.         char errStr[BUFSIZ];
  549.         errStr[0] = '\0';
  550.         _error.GreaterSeverity(SEVERITY_BUG);
  551.         sprintf(errStr,
  552.            " Warning: attribute '%s : %s' should be pointing at %s",
  553.             Name(), TypeName(), "a STEPselect class.\n");
  554.         _error.AppendToUserMsg(errStr);
  555.         _error.AppendToDetailMsg(errStr);
  556.     }
  557.     break;
  558.  
  559.       case REFERENCE_TYPE:
  560.       case GENERIC_TYPE:
  561.     cerr << "Internal error:  " << __FILE__ << ": " <<  __LINE__
  562.          << "\n" << _POC_ "\n";
  563.     _error.GreaterSeverity (SEVERITY_BUG);
  564.     return;
  565.  
  566.       case UNKNOWN_TYPE:
  567.       default:
  568.     ptr.u -> STEPwrite (out);
  569.     break;
  570.       
  571.     }
  572. }
  573.  
  574.  
  575. BOOLEAN 
  576. STEPattribute::ShallowCopy(STEPattribute *sa)
  577. {
  578.     switch(sa->NonRefType())
  579.     {
  580.       case INTEGER_TYPE:
  581.         *ptr.i = *(sa->ptr.i);
  582.         break;
  583.       case BINARY_TYPE:
  584.         *(ptr.b) = *(sa->ptr.b);
  585.         break;
  586.       case STRING_TYPE:
  587.         *(ptr.S) = *(sa->ptr.S);
  588.         break;
  589.       case REAL_TYPE:
  590.       case NUMBER_TYPE:
  591.         *ptr.r = *(sa->ptr.r);
  592.         break;
  593.       case ENTITY_TYPE:
  594.         *ptr.c = *(sa->ptr.c);
  595.         break;
  596.       case AGGREGATE_TYPE:
  597.         ptr.a -> ShallowCopy (*(sa -> ptr.a));
  598.         break;
  599.       case SELECT_TYPE:
  600.         *ptr.sh = *(sa->ptr.sh);
  601.         break;
  602.       case ENUM_TYPE:
  603.       case BOOLEAN_TYPE:
  604.       case LOGICAL_TYPE:
  605.         ptr.e->put(sa->ptr.e->asInt());
  606.         break;
  607.  
  608.       default:
  609.         *ptr.u = *(sa->ptr.u);
  610.         break;
  611.     }
  612.     return 1;
  613. }
  614.  
  615. Severity 
  616. STEPattribute::set_null()
  617. {  
  618.     switch (NonRefType()) {
  619.       case INTEGER_TYPE:
  620.     *(ptr.i) = S_INT_NULL;
  621.     break;
  622.  
  623.       case NUMBER_TYPE:
  624.     *(ptr.r) = S_NUMBER_NULL;
  625.     break;      
  626.  
  627.       case REAL_TYPE:
  628.     *(ptr.r) = S_REAL_NULL;
  629.     break;      
  630.  
  631.       case ENTITY_TYPE:
  632.     *(ptr.c) = S_ENTITY_NULL;
  633.     break;
  634.     
  635.       case STRING_TYPE:
  636.     ptr.S -> set_null ();
  637.     break;
  638.  
  639.       case BINARY_TYPE:
  640.     ptr.b -> set_null ();
  641.     break;
  642.  
  643.       case AGGREGATE_TYPE:
  644.       {
  645.     ptr.a -> Empty ();
  646.     break;
  647.       }
  648.  
  649.       case ENUM_TYPE:
  650.       case BOOLEAN_TYPE:
  651.       case LOGICAL_TYPE:
  652.     ptr.e -> set_null();
  653.     break;
  654.  
  655.       case SELECT_TYPE:
  656.     ptr.sh -> set_null();
  657.     break;
  658.  
  659.       case REFERENCE_TYPE:  
  660.       case GENERIC_TYPE:    
  661.     cerr << "Internal error:  " << __FILE__ <<  __LINE__
  662.          << "\n" << _POC_ "\n";
  663.     return SEVERITY_BUG;
  664.  
  665.       case UNKNOWN_TYPE:
  666.       default:
  667.       {
  668.     ptr.u -> set_null();
  669.     char errStr[BUFSIZ];
  670.     errStr[0] = '\0';
  671.     sprintf(errStr, " Warning: attribute '%s : %s : %d' - %s.\n",
  672.         Name(), TypeName(), Type(),
  673.         "Don't know how to make attribute NULL");
  674.     _error.AppendToDetailMsg(errStr);
  675.     _error.GreaterSeverity(SEVERITY_WARNING);
  676.     return SEVERITY_WARNING;
  677.       }
  678.     }
  679.     if(Nullable())
  680.     return SEVERITY_NULL;
  681.     else
  682.     return SEVERITY_INCOMPLETE;
  683. }
  684.  
  685. BOOLEAN
  686. STEPattribute::is_null ()  const
  687. {
  688.     switch ( NonRefType() )  
  689.       {
  690.     case INTEGER_TYPE:
  691.       return (*(ptr.i) == S_INT_NULL);
  692.  
  693.     case NUMBER_TYPE:
  694.       return  (*(ptr.r) == S_NUMBER_NULL);
  695.  
  696.     case REAL_TYPE:
  697.       return  (*(ptr.r) == S_REAL_NULL);
  698.  
  699.     case ENTITY_TYPE:
  700.       return  (*(ptr.c) == S_ENTITY_NULL);
  701.  
  702.     case STRING_TYPE:
  703.       return ptr.S -> is_null ();
  704.  
  705.     case BINARY_TYPE:
  706.       return ptr.b -> is_null ();
  707.  
  708.     case AGGREGATE_TYPE:
  709.     {
  710.       return  ( ptr.a -> is_null() );
  711.     }
  712.  
  713.     case ENUM_TYPE:
  714.     case BOOLEAN_TYPE:
  715.     case LOGICAL_TYPE:
  716.       return ( ptr.e -> is_null() );
  717.  
  718.     case SELECT_TYPE:
  719.       return( ptr.sh->is_null() );
  720.  
  721.     case REFERENCE_TYPE:
  722.     case GENERIC_TYPE:
  723.       cerr << "Internal error:  " << __FILE__ << ": " <<  __LINE__
  724.            << "\n" << _POC_ "\n";
  725.       return SEVERITY_BUG;
  726.  
  727.         case UNKNOWN_TYPE:
  728.     default:
  729.       return (ptr.u -> is_null());
  730.       }
  731. }    
  732.  
  733. /******************************************************************
  734.  ** Procedure:  operator == 
  735.  ** Parameters:  STEPattribute & a1 and a2
  736.  ** Returns:  int -- if 0 => not equal
  737.  ** Description:  evaluates the equality of two attributes
  738.  ** Side Effects:  none
  739.  ** Status:  stub -- needs alot of work
  740.  ******************************************************************/
  741.  
  742. //    equality for STEPattribute
  743. int operator == (STEPattribute &a1, STEPattribute &a2)
  744. {
  745.   cerr << "Internal error:  " << __FILE__ << ": " <<  __LINE__
  746.        << "\n" << _POC_ "\n";
  747.     if (a1.AttrDescriptor->NonRefType() == a2.AttrDescriptor->NonRefType()) 
  748.     ;
  749.     return 0;
  750. }    
  751.  
  752.  
  753.  
  754. ///////////////////////////////////////////////////////////////////////////////
  755. // returns the severity level that the parameter attrValue would pass at if it 
  756. // was the value for this attribute.
  757. ///////////////////////////////////////////////////////////////////////////////
  758.  
  759. Severity 
  760. STEPattribute::ValidLevel (const char *attrValue, ErrorDescriptor *error, 
  761.               InstMgr *im, int clearError)
  762. {
  763.     if(clearError)
  764.     ClearErrorMsg();
  765.  
  766.     int optional = Nullable();
  767.  
  768.     if( !attrValue || (attrValue[0] == '\0') )
  769.     {
  770.     if(optional)
  771.         return error->severity();
  772.     else
  773.     {
  774.         error->GreaterSeverity(SEVERITY_INCOMPLETE);
  775.         return SEVERITY_INCOMPLETE;
  776.     }
  777.     }
  778.  
  779.     switch (NonRefType() ) {
  780.       case INTEGER_TYPE:
  781.         return IntValidLevel(attrValue, error, clearError, optional, 0);
  782.  
  783.       case STRING_TYPE:
  784.         // if a value exists (checked above) then that is the string value
  785.         return SEVERITY_NULL;
  786.     
  787.       case REAL_TYPE:
  788.         return RealValidLevel(attrValue, error, clearError, optional, 0);
  789.  
  790.       case NUMBER_TYPE:
  791.         return NumberValidLevel(attrValue, error, clearError, optional, 0);
  792.  
  793.       case ENTITY_TYPE:
  794.         return EntityValidLevel(attrValue, 
  795.                     AttrDescriptor->NonRefTypeDescriptor(), 
  796.                     error, im, 0);
  797.       case BINARY_TYPE:
  798.         return ptr.b->BinaryValidLevel(attrValue, &_error, optional, 0);
  799.  
  800.       case AGGREGATE_TYPE:
  801.       {
  802.     return ptr.a->AggrValidLevel(attrValue, error, 
  803.                   AttrDescriptor->AggrElemTypeDescriptor(), im, 
  804.                   optional, 0, 0, 0);
  805.       }
  806.       case ENUM_TYPE:
  807.       case BOOLEAN_TYPE:
  808.       case LOGICAL_TYPE:
  809.         return ptr.e->EnumValidLevel(attrValue, error, optional, 0, 0, 1);
  810.       case SELECT_TYPE:
  811.         return ptr.sh->SelectValidLevel(attrValue, error, im, 0);
  812.  
  813.       default:
  814.         cerr << "Internal error:  " << __FILE__ <<  __LINE__
  815.          << "\n" << _POC_ "\n";
  816.         return error->severity();
  817.     }
  818. }
  819.   
  820. /******************************************************************
  821.  ** Procedure:  operator <<
  822.  ** Parameters:  ostream & out -- output stream
  823.  **              STEPattribute & a -- attribute to output
  824.  ** Returns:  ostream &
  825.  ** Description:  overloads the output operator to print an attribute 
  826.  ******************************************************************/
  827.  
  828. ostream &operator<< ( ostream& out, STEPattribute& a )
  829. {
  830.     a.STEPwrite (out);
  831.     return out;
  832.  
  833. }
  834.  
  835.  
  836. ///////////////////////////// AddErrorInfo() //////////////////////////////////
  837. // This adds prepends attribute information to the detailed error msg.  This 
  838. // is intended to add information to the error msgs written by Enumerations, 
  839. // Aggregates, and STEPstrings which don't know they are a STEPattribute value.
  840. ///////////////////////////////////////////////////////////////////////////////
  841.  
  842. void 
  843. STEPattribute::AddErrorInfo()
  844. {
  845.     char errStr[BUFSIZ];
  846.     errStr[0] = '\0';
  847.  
  848.     if(SEVERITY_INPUT_ERROR < _error.severity() &&
  849.        _error.severity() < SEVERITY_NULL)
  850.     {
  851.     sprintf(errStr, " Warning: ATTRIBUTE '%s : %s : %d' - ",
  852.         Name(), TypeName(), Type());
  853.     _error.PrependToDetailMsg(errStr);
  854.     }
  855.     else if(_error.severity() == SEVERITY_INPUT_ERROR)
  856.     {
  857.     sprintf(errStr, " Error: ATTRIBUTE '%s : %s : %d' - ",
  858.         Name(), TypeName(), Type());
  859.     _error.PrependToDetailMsg(errStr);
  860.     }
  861.     else if(_error.severity() <= SEVERITY_BUG)
  862.     {
  863.     sprintf(errStr, " BUG: ATTRIBUTE '%s : %s : %d' - ",
  864.         Name(), TypeName(), Type());
  865.     _error.PrependToDetailMsg(errStr);
  866.     }
  867. }
  868.  
  869. ///////////////////////////////////////////////////////////////////////////////
  870.  
  871. // this function reads until it hits eof or one of the StopChars.
  872. // if it hits one of StopChars it puts it back.
  873. // RETURNS: the last char it read.
  874. char
  875. STEPattribute::SkipBadAttr(istream& in, char *StopChars)
  876. {
  877.     //int sk = in.skip(0);  //turn skipping whitespace off
  878.  
  879.     // read bad data until end of this attribute or entity.
  880.     char *foundCh = 0;
  881.     char c = '\0';
  882.     char errStr[BUFSIZ];
  883.     errStr[0] = '\0';
  884.  
  885.     _error.GreaterSeverity(SEVERITY_WARNING);
  886.     in >> c;
  887.     while( !in.eof() && !(foundCh = strchr(StopChars, c)) )
  888.       in >> c;
  889.     if(in.eof())
  890.     {
  891.     _error.GreaterSeverity(SEVERITY_INPUT_ERROR);
  892.     sprintf(errStr, " Error: attribute '%s : %s : %d' - %s.\n",
  893.         Name(), TypeName(), Type(),
  894.         "Unexpected EOF when skipping bad attr value");
  895.     _error.AppendToDetailMsg(errStr);
  896.     }
  897.     else
  898.     {
  899.     sprintf(errStr, " Error: attribute '%s : %s : %d' - %s.\n",
  900.         Name(), TypeName(), Type(), "Invalid value");
  901.     _error.AppendToDetailMsg(errStr);
  902.     }
  903.     in.putback (c);
  904.    // in.skip(sk);     //set skip whitespace to its original state
  905.     return c;
  906. }
  907.  
  908.  
  909. /////////////////// READ 
  910.  
  911. #ifdef OBSOLETE
  912.  
  913. // appends char 'c' to char * 's' starting at index 'index'.  'index' is 
  914. // incremented by one and returned.  If assigning 'c' will cause 's' to be 
  915. // larger than size 'sSize' then 's' is deleted and reallocated and 's' and 
  916. // 'sSize' are changed and returned appropriately.
  917.  
  918. void
  919. AppendChar(char c, int& index, char *&s, int& sSize)
  920. {
  921.     if(index >= sSize - 1)
  922.     {
  923.     char *tmp = s;
  924.     s = new char[sSize * 2];
  925.     strcpy(s, tmp);
  926.     delete [] tmp;
  927.     sSize = sSize * 2;
  928.     }
  929.     s[index] = c;
  930.     index++;
  931.     s[index] = '\0';
  932. }
  933.  
  934.  
  935. /////////////////// STEPread_reference()
  936.  
  937. STEPentity *
  938. STEPread_reference (const char * s, ErrorDescriptor *err, InstMgr * instances, 
  939.              int addFileId)
  940. {
  941.     char errStr[BUFSIZ];
  942.     errStr[0] = '\0';
  943.  
  944.     int fileId = -1;
  945.     int numfound;
  946.     if( numfound = sscanf((char *)s, " #%d ", &fileId) )
  947.     ;
  948.     else ( numfound = sscanf((char *)s, " @%d ", &fileId) )
  949.     ;
  950.     if( (numfound != EOF) && (numfound > 0) )
  951.     {
  952.     fileId = fileId + addFileId;
  953.  
  954.     if (!instances)
  955.     {
  956.         sprintf(errStr, "STEPread_reference(): %s - entity #%d %s.\n",
  957.             "BUG - cannot read reference without the InstMgr", fileId, 
  958.             "is unknown to attribute");
  959.         err->AppendToDetailMsg(errStr);
  960.         err->GreaterSeverity(SEVERITY_BUG);
  961.         return S_ENTITY_NULL;
  962.     }
  963.     
  964.     //  lookup which object has id as its instance fileId
  965.     STEPentity* inst;
  966.     /* If there is a ManagerNode it should have a STEPentity */
  967.     MgrNode* mn = 0;
  968.     mn = instances->FindFileId(fileId);
  969.     if (mn)
  970.     {
  971.         inst =  mn->GetSTEPentity() ;
  972.         if (inst) { return (inst); }
  973.         else
  974.         {
  975.         sprintf(errStr, 
  976.             "%s - entity #%d %s.\n",
  977.                 "BUG - MgrNode::GetSTEPentity returned NULL pointer",
  978.             fileId, "is unknown to attribute");
  979.         err->AppendToDetailMsg(errStr);
  980.         err->GreaterSeverity(SEVERITY_BUG);
  981.         return S_ENTITY_NULL;
  982.         }
  983.     }
  984.     else
  985.     {
  986.         sprintf(errStr,"Reference to non-existent ENTITY #%d.\n", fileId);
  987.         err->AppendToDetailMsg(errStr);
  988.         err->GreaterSeverity(SEVERITY_WARNING);
  989.         return S_ENTITY_NULL;
  990.     }
  991.     }
  992.     else
  993.     {
  994.     numfound = sscanf((char *)s, " %*s ");
  995.     if(numfound == EOF)
  996.     {
  997.         err->GreaterSeverity(SEVERITY_INCOMPLETE);
  998.     }
  999.     else 
  1000.     {
  1001.         sprintf(errStr,"  Invalid entity identifier # %s.\n", s);
  1002.         err->AppendToDetailMsg(errStr);
  1003.         err->GreaterSeverity(SEVERITY_WARNING);
  1004.     }
  1005.     return S_ENTITY_NULL;
  1006.     }
  1007. }
  1008.  
  1009. #endif
  1010.