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 / SENTITY.CPP < prev    next >
C/C++ Source or Header  |  1994-10-03  |  22KB  |  747 lines
  1.  
  2. /*
  3. * NIST STEP Core Class Library
  4. * clstepcore/STEPentity.cc
  5. * February, 1994
  6. * K. C. Morris
  7. * David Sauder
  8.  
  9. * Development of this software was funded by the United States Government,
  10. * and is not subject to copyright.
  11. */
  12.  
  13. /* $Id: STEPentity.cc,v 2.0.1.2 1994/05/10 21:03:10 kc Exp $ */
  14.  
  15. //static char rcsid[] ="$Id: STEPentity.cc,v 2.0.1.2 1994/05/10 21:03:10 kc Exp $";
  16.  
  17. #include <Sentity.h>
  18. #include <instmgr.h>
  19.  
  20. STEPentity NilSTEPentity;
  21.  
  22. /******************************************************************
  23. **      Functions for manipulating entities
  24.  
  25. **  KNOWN BUGs:  the STEPentity is not aware of the STEPfile; therefore
  26. **    it can not read comments which may be embedded in the instance.
  27. **    The following are known problems:
  28. **    -- does not handle comments embedded in an instance ==> bombs
  29. **    -- ignores embedded entities ==> does not bomb 
  30. **    -- error reporting does not include line number information  
  31. **/
  32.  
  33. STEPentity::STEPentity ()  
  34. :  _cur (0), STEPfile_id (0) 
  35. {
  36. }    
  37.  
  38. STEPentity::~STEPentity ()  
  39. {
  40.   STEPattribute * next =0;
  41.   ResetAttributes ();
  42.   while (next = NextAttribute ())  
  43.     delete next;
  44. }
  45.  
  46. STEPentity *STEPentity::Replicate()
  47. {
  48.     STEPentity *seNew = EntityDescriptor->NewSTEPentity();
  49.     seNew -> CopyAs (this);
  50.     return seNew;
  51. }
  52.  
  53. void 
  54. STEPentity::STEPwrite_reference (ostream& out)
  55. {  
  56.   out << "#" << STEPfile_id; 
  57. }
  58.  
  59. const char * 
  60. STEPentity::STEPwrite_reference (SCLstring &buf)
  61. {  
  62.     char tmp[64];
  63.     sprintf ( tmp,"#%d", STEPfile_id);
  64.     buf = tmp;
  65.     return buf.chars();
  66. }
  67.  
  68. STEPattribute * 
  69. STEPentity::GetSTEPattribute (const char * nm)
  70. {
  71.   if (!nm) return 0;
  72.   STEPattribute *a =0;
  73.  
  74.   ResetAttributes();    
  75.   while ((a = NextAttribute () )
  76.      && strcmp (nm, a ->Name()))
  77.     ;  // keep going untill no more attribute or attribute found
  78.  
  79.   return a;
  80. }
  81.  
  82. STEPattribute * 
  83. STEPentity::MakeDerived (const char * nm)
  84. {
  85.   STEPattribute * a = GetSTEPattribute (nm);
  86.   if (a)  a ->Derive ();
  87.   return a;
  88. }
  89.  
  90. void
  91. STEPentity::CopyAs (STEPentity * other)  
  92. {
  93.     int numAttrs = AttributeCount();
  94.     ResetAttributes();    
  95.     other -> ResetAttributes();    
  96.  
  97.     STEPattribute *this_attr = 0;
  98.     STEPattribute *other_attr = 0;
  99.     while((this_attr = NextAttribute()) && numAttrs)
  100.     {
  101.     other_attr = other -> NextAttribute();
  102.     this_attr -> ShallowCopy(other_attr);
  103.     numAttrs--;
  104.     }
  105. }
  106.  
  107. /******************************************************************
  108. // Checks the validity of the current attribute values for the entity
  109.  ******************************************************************/
  110.  
  111. Severity STEPentity::ValidLevel(ErrorDescriptor *error, InstMgr *im, 
  112.                      int clearError)
  113. {
  114.     ErrorDescriptor err;
  115.     if(clearError)
  116.     ClearError();
  117.     int n = attributes.list_length();
  118.     SCLstring tmp;
  119.     for (register int i = 0 ; i < n; i++) {
  120.     error->GreaterSeverity(attributes[i].ValidLevel(attributes[i].asStr(tmp),
  121.                             &err, im, 0));
  122.     }
  123.     return error->severity();
  124. }
  125.  
  126. /******************************************************************
  127.     // clears all attr's errors
  128.  ******************************************************************/
  129. void STEPentity::ClearAttrError()
  130. {
  131.     int n = attributes.list_length();
  132.     for (register int i = 0 ; i < n; i++) {
  133.     attributes[i].Error().ClearErrorMsg();
  134.     }
  135. }
  136.  
  137. /******************************************************************
  138.     // clears entity's error and optionally all attr's errors
  139.  ******************************************************************/
  140.  
  141. void STEPentity::ClearError(int clearAttrs)
  142. {
  143.     _error.ClearErrorMsg();
  144.     if(clearAttrs)
  145.     ClearAttrError();
  146. } 
  147.  
  148. /******************************************************************
  149.  ******************************************************************/
  150.  
  151. /*
  152. void STEPentity::EnforceOptionality(int on) 
  153. {
  154.     Enforcement e;
  155.     if(on) e = ENFORCE_OPTIONALITY;
  156.     else   e = ENFORCE_OFF;
  157.  
  158.     Error().enforcement(e); 
  159.     int n = attributes.list_length();
  160.     for (int i = 0 ; i < n; i++) {
  161.     attributes[i].Error().enforcement(e); 
  162.     }
  163. }
  164. */
  165. /******************************************************************
  166.  ** Procedure:  beginSTEPwrite
  167.  ** Parameters:  ostream& out -- stream to write to
  168.  ** Returns:  
  169.  ** Side Effects:  writes out the SCOPE section for an entity
  170.  ** Status:  stub 
  171.  ******************************************************************/
  172.  
  173. void STEPentity::beginSTEPwrite(ostream& out)
  174. {
  175.     out << "begin STEPwrite ... \n" ;
  176.     out.flush();
  177.     
  178.     int n = attributes.list_length();
  179.     for (register int i = 0 ; i < n; i++) {
  180.     if (attributes[i].Type () == ENTITY_TYPE
  181.         && *(attributes[i].ptr.c) != S_ENTITY_NULL)
  182.         (*(attributes[i].ptr.c)) -> STEPwrite();
  183.     }
  184. }
  185.  
  186. /******************************************************************
  187.  ** Procedure:  STEPwrite
  188.  ** Parameters:  ostream& out -- stream to write to
  189.  ** Returns:  
  190.  ** Side Effects:  writes out the data associated with an instance 
  191.                    in STEP format
  192.  ** Problems:  does not print out the SCOPE section of an entity
  193.  **
  194.  ******************************************************************/
  195.  
  196. void STEPentity::STEPwrite(ostream& out)
  197. {
  198.     SCLstring tmp;
  199.     out << "#" << STEPfile_id << "=" << StrToUpper (EntityName(), tmp) << "(";
  200.     int n = attributes.list_length();
  201.  
  202.     for (register int i = 0 ; i < n; i++) {
  203.     (attributes[i]).STEPwrite(out);
  204.     if (i < n-1) out << ",";
  205.     }
  206.     out << ");\n";
  207. }
  208.  
  209. void STEPentity::endSTEPwrite(ostream& out)
  210. {
  211.     out << "end STEPwrite ... \n" ;
  212.     out.flush();
  213. }
  214.  
  215.  
  216. /******************************************************************
  217.  ** Procedure:  STEPwrite
  218.  ** Problems:  does not print out the SCOPE section of an entity
  219.  **
  220.  ******************************************************************/
  221.  
  222. const char * 
  223. STEPentity::STEPwrite(SCLstring &buf)
  224. {
  225.     buf.set_null();
  226.  
  227.     char instanceInfo[BUFSIZ];
  228.     
  229.     SCLstring tmp;
  230.     sprintf(instanceInfo, "#%d=%s(", STEPfile_id, 
  231.         (char *)StrToUpper( EntityName(), tmp ) );
  232.     buf.Append(instanceInfo);
  233.  
  234.     int n = attributes.list_length();
  235.  
  236.     for (register int i = 0 ; i < n; i++) {
  237.       attributes[i].asStr(tmp) ;
  238.       buf.Append (tmp);
  239.     if (i < n-1) {
  240.         buf.Append( ',' );
  241.     }
  242.     }    
  243.     buf.Append( ");" );
  244.     return buf.chars();
  245. }
  246.  
  247. /******************************************************************
  248.  ** Procedure:  STEPentity::STEPread_error
  249.  ** Parameters:  char c --  character which caused error
  250.  **     int i --  index of attribute which caused error
  251.  **     istream& in  --  input stream for recovery
  252.  ** Returns:  
  253.  ** Description:  reports the error found, reads until it finds the end of an
  254.  **     instance. i.e. a close quote followed by a semicolon optionally having
  255.  **     whitespace between them.
  256.  ******************************************************************/
  257. void
  258. STEPentity::STEPread_error(char c, int i, istream& in)
  259. {
  260.     char errStr[BUFSIZ];
  261.     errStr[0] = '\0';
  262.  
  263. /*    sprintf(errStr, " for instance #%d : %s\n", STEPfile_id, EntityName());*/
  264. /*    _error.AppendToDetailMsg(errStr);*/
  265.  
  266.     if ( (i >= 0) && (i < attributes.list_length()))  // i is an attribute 
  267.     {
  268.       Error ().GreaterSeverity (SEVERITY_WARNING);
  269.       sprintf(errStr, "  invalid data for type \'%s\'\n", 
  270.           attributes[i].TypeName()); 
  271.       _error.AppendToDetailMsg(errStr);
  272.     }
  273.     else
  274.       {
  275.     Error ().GreaterSeverity (SEVERITY_INPUT_ERROR);
  276.     _error.AppendToDetailMsg("  No more attributes were expected.\n");
  277.       }
  278.  
  279.     SCLstring tmp;
  280.     STEPwrite (tmp);  // STEPwrite writes to a static buffer inside function
  281.     sprintf(errStr, 
  282.         "  The invalid instance to this point looks like :\n%s\n", 
  283.         tmp.chars() );
  284.     _error.AppendToDetailMsg(errStr);
  285.     
  286.     _error.AppendToDetailMsg("  data lost looking for end of entity:");
  287.  
  288.     //  scan over the rest of the instance and echo it
  289. //    cerr << "  ERROR Trying to find the end of the ENTITY to recover...\n";
  290. //    cerr << "  skipping the following input:\n";
  291.  
  292.     in.clear();
  293.     int foundEnd = 0;
  294.     tmp = "";
  295.  
  296.     // Search until a close paren is found followed by (skipping optional 
  297.     // whitespace) a semicolon
  298.     while( in.good() && !foundEnd )
  299.     {
  300.     while ( in.good() && (c != ')') )  
  301.     {
  302.         in.get(c);
  303.         tmp.Append(c);
  304. //        cerr << c;
  305.     }
  306.     if(in.good() && (c == ')') )
  307.     {
  308.         in >> ws; // skip whitespace
  309.         in.get(c);
  310.         tmp.Append(c);
  311. //        cerr << c;
  312. //        cerr << "\n";
  313.         if(c == ';')
  314.         {
  315.         foundEnd = 1;
  316.         }
  317.     }
  318.     }
  319.     _error.AppendToDetailMsg( tmp.chars() );
  320.     sprintf (errStr, "\nfinished reading #%d\n", STEPfile_id);
  321.     _error.AppendToDetailMsg(errStr);
  322.     return;
  323. }
  324.  
  325. /******************************************************************
  326.  ** Procedure:  STEPread
  327.  ** Returns:    Severity, error information
  328.  **             SEVERITY_NULL - no errors
  329.  **             SEVERITY_USERMSG - checked as much as possible, could still 
  330.  **            be error - e.g. entity didn't match base entity type.
  331.  **             SEVERITY_INCOMPLETE - data is missing and required.
  332.  **             SEVERITY_WARNING - errors, but can recover
  333.  **             <= SEVERITY_INPUT_ERROR - fatal error, can't recover
  334.  ** Description:  reads the values for an entity from an input stream
  335.  **               in STEP file format starting at the open paren and
  336.  **               ending with the semi-colon
  337.  ** Parameters:  int id
  338.  **              int idIncrement
  339.  **              InstMgr instances
  340.  **              istream& in
  341.  ** Side Effects:  gobbles up input stream
  342.  ** Status:
  343.  ******************************************************************/
  344.  
  345. Severity
  346. STEPentity::STEPread(int id,  int idIncr, InstMgr * instance_set, istream& in)
  347. {
  348.     STEPfile_id = id;
  349.     char c ='\0';
  350.     char errStr[BUFSIZ];
  351.     errStr[0] = '\0';
  352.     Severity severe;
  353.  
  354.     ClearError(1);
  355.  
  356.     int n = attributes.list_length();
  357.     for (register int i = 0 ; i < n; i++) {
  358.         attributes[i].STEPread(in, instance_set, idIncr);
  359.  
  360.     severe = attributes[i].Error().severity();
  361.  
  362.         if(severe <= SEVERITY_USERMSG)
  363.     {  // if there\'s some type of error
  364.         if(_error.severity() == SEVERITY_NULL)
  365.         {  //  if there is not an error already
  366.         sprintf(errStr, "\nERROR:  ENTITY #%d %s\n", GetFileId(), 
  367.             EntityName());
  368.         _error.PrependToDetailMsg(errStr);
  369.         }
  370.         // set the severity for this entity
  371.         sprintf (errStr, "  %s :  ", attributes[i].Name());
  372.         _error.AppendToDetailMsg(errStr);
  373.         _error.GreaterSeverity(severe);
  374.         _error.AppendToDetailMsg((char *)
  375.                      attributes[i].Error().DetailMsg());
  376.         _error.AppendToUserMsg((char *)attributes[i].Error().UserMsg());
  377.  
  378.     }
  379. /*
  380.     if(severe <= SEVERITY_INPUT_ERROR)
  381.     {    // attribute\'s error is non-recoverable 
  382.         // I believe if this error occurs then you cannot recover
  383.  
  384.       //  TODO: can you just read to the next comma and try to continue ?
  385.         STEPread_error(c,i,in);
  386.         return _error.severity();
  387.     }
  388. */
  389.     in >> c;
  390.     if ( ! ((c == ',') || (c == ')' ))) { //  input is not a delimiter
  391.         if(_error.severity() == SEVERITY_NULL)
  392.         {  //  if there is not an error already
  393.         sprintf(errStr, "\nERROR:  ENTITY #%d %s\n", GetFileId(), 
  394.             EntityName());
  395.         _error.PrependToDetailMsg(errStr);
  396.         }
  397.         _error.AppendToDetailMsg(
  398.                 "delimiter expected after attribute value.\n");
  399.         CheckRemainingInput(in, &_error, "ENTITY", ",)");
  400.         if(!in.good())
  401.         return _error.severity();
  402.         if(_error.severity() <= SEVERITY_INPUT_ERROR)
  403.         {
  404.         STEPread_error(c,i,in);
  405.         return _error.severity();
  406.         }
  407.     }
  408.     else if(c == ')')
  409.     {
  410.         char z = in.peek();
  411.         if (z == ';')
  412.         {
  413.         in.get(c);
  414.         return _error.severity();
  415.         }
  416.     }
  417.     }
  418.     if(c != ')' )
  419.     {
  420.     STEPread_error(c,i,in);
  421.     return _error.severity();
  422.     }
  423.     in >> ws;
  424.     in >> c;
  425.     if (c != ';')
  426.     {
  427.     STEPread_error(c,i,in);
  428.     return _error.severity();
  429.     }
  430.     return _error.severity();
  431. }
  432.  
  433.  
  434. ///////////////////////////////////////////////////////////////////////////////
  435. // read an entity reference and return a pointer to the STEPentity
  436. ///////////////////////////////////////////////////////////////////////////////
  437.  
  438. STEPentity *
  439. ReadEntityRef(istream &in, ErrorDescriptor *err, char *tokenList, 
  440.           InstMgr * instances, int addFileId)
  441. {
  442.     char c;
  443.     char errStr[BUFSIZ];
  444.     errStr[0] = '\0';
  445.     
  446.     in >> ws;
  447.     in >> c;
  448.     switch (c)
  449.     {
  450.       case '@':
  451.         err->AppendToDetailMsg(
  452.                 "Use of @ instead of # to identify entity.\n");
  453.         err->GreaterSeverity(SEVERITY_WARNING);
  454.         // no break statement here on purpose
  455.       case '#':
  456.     {
  457.         int id = -1; 
  458.         int n = 0;
  459.         in >>  id;
  460.         if (in.fail ())  //  there's been an error in input
  461.         {
  462. //        in.clear();
  463.         sprintf(errStr,"Invalid entity reference value.\n");
  464.         err->AppendToDetailMsg(errStr);
  465.         err->AppendToUserMsg(errStr);
  466.         err->GreaterSeverity(SEVERITY_WARNING);
  467.         CheckRemainingInput(in, err, "Entity Reference", tokenList);
  468.         return S_ENTITY_NULL;
  469.         }
  470.         else // found an entity id
  471.         {
  472.         // check to make sure garbage does not follow the id
  473.         CheckRemainingInput(in, err, "Entity Reference", tokenList);
  474.  
  475.         id += addFileId;
  476.         if (!instances)
  477.         {
  478.             cerr << "Internal error:  " << __FILE__ <<  __LINE__
  479.              << "\n" << _POC_ "\n";
  480.             sprintf(errStr, 
  481.                 "STEPread_reference(): %s - entity #%d %s.\n",
  482.                 "BUG - cannot read reference without the InstMgr", 
  483.                  id, "is unknown");
  484.             err->AppendToDetailMsg(errStr);
  485.             err->AppendToUserMsg(errStr);
  486.             err->GreaterSeverity(SEVERITY_BUG);
  487.             return S_ENTITY_NULL;
  488.         }
  489.     
  490.         //  lookup which object has id as its instance id
  491.         STEPentity* inst;
  492.         /* If there is a ManagerNode it should have a STEPentity */
  493.         MgrNode* mn =0;
  494.         mn = instances->FindFileId(id);
  495.         if (mn)
  496.         {
  497.             inst =  mn->GetSTEPentity() ;
  498.             if (inst) { return (inst); }
  499.             else
  500.             {
  501.             cerr << "Internal error:  " << __FILE__ <<  __LINE__
  502.                  << "\n" << _POC_ "\n";
  503.             sprintf(errStr, 
  504.                 "STEPread_reference(): %s - entity #%d %s.\n",
  505.               "BUG - MgrNode::GetSTEPentity returned NULL pointer",
  506.                 id, "is unknown");
  507.             err->AppendToDetailMsg(errStr);
  508.             err->AppendToUserMsg(errStr);
  509.             err->GreaterSeverity(SEVERITY_BUG);
  510.             return S_ENTITY_NULL;
  511.             }
  512.         }
  513.         else
  514.         {
  515.             sprintf(errStr,"Reference to non-existent ENTITY #%d.\n", 
  516.                 id);
  517.             err->AppendToDetailMsg(errStr);
  518.             err->AppendToUserMsg(errStr);
  519.             err->GreaterSeverity(SEVERITY_WARNING);
  520.             return S_ENTITY_NULL;
  521.         }
  522.         }
  523.     }
  524.       default:
  525.     {
  526.         in.putback(c);
  527.         // read past garbage up to delim in tokenList
  528.         // if tokenList is null it will not read anything
  529.         CheckRemainingInput(in, err, "Entity Reference", tokenList);
  530.         return S_ENTITY_NULL;
  531.     }
  532.     }
  533. }
  534.  
  535. ///////////////////////////////////////////////////////////////////////////////
  536. // same as above but reads from a const char *
  537. ///////////////////////////////////////////////////////////////////////////////
  538.  
  539. STEPentity *
  540. ReadEntityRef(const char * s, ErrorDescriptor *err, char *tokenList, 
  541.           InstMgr * instances, int addFileId)
  542. {
  543.     istrstream in((char *)s);
  544.     return ReadEntityRef(in, err, tokenList, instances, addFileId);
  545. }
  546.  
  547. ///////////////////////////////////////////////////////////////////////////////
  548. // return SEVERITY_NULL if se's entity type matches the supplied entity type
  549. ///////////////////////////////////////////////////////////////////////////////
  550.  
  551. Severity 
  552. EntityValidLevel(STEPentity *se, 
  553.          const TypeDescriptor *ed, // entity type that entity se needs 
  554.                        // to match. (this must be an
  555.                        // EntityDescriptor)
  556.          ErrorDescriptor *err)
  557. {
  558.     char messageBuf [BUFSIZ];
  559.     messageBuf[0] = '\0';
  560.  
  561.     if( !ed || (ed->NonRefType() != ENTITY_TYPE) )
  562.     {
  563.     err->GreaterSeverity(SEVERITY_BUG);
  564.     sprintf(messageBuf, 
  565.         " BUG: EntityValidLevel() called with %s", 
  566.         "missing or invalid EntityDescriptor\n");
  567.     err->AppendToUserMsg(messageBuf);
  568.     err->AppendToDetailMsg(messageBuf);
  569.     cerr << "Internal error:  " << __FILE__ <<  __LINE__
  570.            << "\n" << _POC_ "\n";
  571.     return SEVERITY_BUG;
  572.     }
  573.     if(!se || (se == S_ENTITY_NULL))
  574.     {
  575.     err->GreaterSeverity(SEVERITY_BUG);
  576.     sprintf(messageBuf, 
  577.         " BUG: EntityValidLevel() called with null pointer %s\n", 
  578.         "for STEPentity argument.");
  579.     err->AppendToUserMsg(messageBuf);
  580.     err->AppendToDetailMsg(messageBuf);
  581.     cerr << "Internal error:  " << __FILE__ <<  __LINE__
  582.            << "\n" << _POC_ "\n";
  583.     return SEVERITY_BUG;
  584.     }
  585.  
  586.     // DAVE: Can an entity be used in an Express TYPE so that this 
  587.     // EntityDescriptor would have type REFERENCE_TYPE -- it looks like NO
  588.  
  589.     else if(se->EntityDescriptor)
  590.     {
  591.     // is se a descendant of ed?
  592.     if ( se->EntityDescriptor->IsA(ed) )
  593.     {
  594.         return SEVERITY_NULL;
  595.     }
  596.     else
  597.     {
  598.         err->GreaterSeverity(SEVERITY_WARNING);
  599.         sprintf(messageBuf,
  600.             " Entity #%d exists but is not a %s or descendant.\n", 
  601.             se->STEPfile_id, ed->Name());
  602.         err->AppendToUserMsg(messageBuf);
  603.         err->AppendToDetailMsg(messageBuf);
  604.         return SEVERITY_WARNING;
  605.     }
  606.     }
  607.     else
  608.     {
  609.     err->GreaterSeverity(SEVERITY_BUG);
  610.     sprintf(messageBuf, 
  611.         " BUG: EntityValidLevel(): STEPentity #%d has a %s", 
  612.         se->STEPfile_id, "missing or invalid EntityDescriptor\n");
  613.     err->AppendToUserMsg(messageBuf);
  614.     err->AppendToDetailMsg(messageBuf);
  615.     cerr << "Internal error:  " << __FILE__ <<  __LINE__
  616.            << "\n" << _POC_ "\n";
  617.     return SEVERITY_BUG;
  618.     }
  619. }
  620.  
  621. ///////////////////////////////////////////////////////////////////////////////
  622. // return 1 if attrValue has the equivalent of a null value.
  623. ///////////////////////////////////////////////////////////////////////////////
  624.  
  625. int 
  626. SetErrOnNull  (const char *attrValue, ErrorDescriptor *error)
  627. {
  628. // DAVE: Is this needed will sscanf return 1 if assignment suppression is used?
  629.     char scanBuf[BUFSIZ];
  630.     scanBuf[0] = '\0';
  631.  
  632.     int numFound = sscanf((char *)attrValue," %s", scanBuf);
  633.     if (numFound == EOF) {
  634. /*
  635.     if(Nullable()) {
  636.         error->GreaterSeverity (SEVERITY_NULL);
  637.     }
  638.     else {
  639.         error->GreaterSeverity (SEVERITY_INCOMPLETE);
  640.     }
  641. */
  642.     error->GreaterSeverity (SEVERITY_INCOMPLETE);
  643.     return 1;
  644.     }
  645.     return 0;
  646. }
  647.  
  648. ///////////////////////////////////////////////////////////////////////////////
  649. // return SEVERITY_NULL if attrValue has a valid entity reference
  650. // This function accepts an entity reference in two forms that is with or 
  651. // without the # sign: e.g. either #23 or 23 will be read.
  652. // If non-whitespace characters follow the entity reference an error is set.
  653. ///////////////////////////////////////////////////////////////////////////////
  654.  
  655. Severity 
  656. EntityValidLevel(const char *attrValue, // string contain entity ref
  657.          const TypeDescriptor *ed, // entity type that entity in 
  658.                        // attrValue (if it exists) needs 
  659.                        // to match. (this must be an
  660.                        // EntityDescriptor)
  661.            ErrorDescriptor *err, InstMgr *im, int clearError)
  662. {
  663.     char tmp [BUFSIZ];
  664.     tmp[0] = '\0';
  665.     char messageBuf [BUFSIZ];
  666.     messageBuf[0] = '\0';
  667.  
  668.     if(clearError)
  669.     err->ClearErrorMsg();
  670.  
  671. /*
  672.   // the problem with doing this is that it will require having a # in front
  673.   // of the entity ref.
  674.     STEPentity se = ReadEntityRef(attrValue, err, 0, im, 0);
  675.     return EntityValidLevel(se, ed, err);
  676. */
  677.  
  678.     int fileId;
  679.     MgrNode *mn = 0;
  680.  
  681.     // check for both forms:  #id or id
  682.     int found1 = sscanf((char *)attrValue, " #%d %s", &fileId, tmp);
  683.     int found2 = sscanf((char *)attrValue, " %d %s", &fileId, tmp);
  684.  
  685.     if( (found1 > 0) || (found2 > 0) )
  686.     {
  687.     if ( (found1 == 2) || (found2 == 2) )
  688.     {
  689.         sprintf(messageBuf, 
  690.            " Attribute's Entity Reference %s is %s data \'%s\'.\n",
  691.             attrValue, "followed by invalid", tmp);
  692.         err->AppendToUserMsg(messageBuf);
  693.         err->AppendToDetailMsg(messageBuf);
  694.         err->GreaterSeverity(SEVERITY_WARNING);
  695.     }
  696.     mn = im->FindFileId(fileId);
  697.     if(mn)
  698.     {
  699.         STEPentity *se = mn->GetSTEPentity();
  700.         return EntityValidLevel(se, ed, err);
  701.     }
  702.     else { 
  703.         sprintf(messageBuf, 
  704.            " Attribute's Entity Reference %s does not exist.\n",
  705.             attrValue);
  706.         err->AppendToUserMsg(messageBuf);
  707.         err->AppendToDetailMsg(messageBuf);
  708.         err->GreaterSeverity(SEVERITY_WARNING);
  709.         return SEVERITY_WARNING;
  710.     }
  711.     }
  712.  
  713.     // if the attrValue contains no value return
  714.     if (SetErrOnNull (attrValue, err))
  715.     return err->severity();
  716.  
  717.     sprintf(messageBuf, "Invalid attribute entity reference value: '%s'.\n", 
  718.         attrValue);
  719.     err->AppendToUserMsg(messageBuf);
  720.     err->AppendToDetailMsg(messageBuf);
  721.     err->GreaterSeverity(SEVERITY_WARNING);
  722.     return SEVERITY_WARNING;
  723. }
  724.  
  725. /******************************************************************
  726.  ** Procedure:  NextAttribute
  727.  ** Parameters:  
  728.  ** Returns:  reference to an attribute pointer
  729.  ** Description:  used to cycle through the list of attributes
  730.  ** Side Effects:  increments the current position in the attribute list
  731.  ** Status:   7/31/90
  732.  ******************************************************************/
  733.  
  734. STEPattribute *
  735. STEPentity::NextAttribute ()  {
  736.     int i = AttributeCount ();
  737.     ++_cur;
  738.     if (i < _cur) return 0;
  739.     return &attributes [_cur-1];
  740.  
  741. }
  742.     
  743. int 
  744. STEPentity::AttributeCount ()  {
  745.     return  attributes.list_length ();
  746. }
  747.