Gabriele Cosmo
1301 lines
36 KiB
C++
1301 lines
36 KiB
C++
|
|
/*
|
|
* NIST STEP Core Class Library
|
|
* clstepcore/sdaiApplication_instance.cc
|
|
* July, 1997
|
|
* K. C. Morris
|
|
* David Sauder
|
|
|
|
* Development of this software was funded by the United States Government,
|
|
* and is not subject to copyright.
|
|
*/
|
|
|
|
/* $Id: sdaiApplication_instance.cc,v 1.3 2003/06/06 17:07:35 gcosmo Exp $ */
|
|
|
|
//static char rcsid[] ="$Id: sdaiApplication_instance.cc,v 1.3 2003/06/06 17:07:35 gcosmo Exp $";
|
|
|
|
#include <sdai.h>
|
|
//#include <STEPentity.h>
|
|
#include <instmgr.h>
|
|
#include <STEPcomplex.h>
|
|
#include <STEPattribute.h>
|
|
|
|
SCLP23(Application_instance) NilSTEPentity;
|
|
|
|
/******************************************************************
|
|
** Functions for manipulating entities
|
|
|
|
** KNOWN BUGs: the SCLP23(Application_instance) is not aware of the STEPfile;
|
|
** therefore it can not read comments which may be embedded in the instance.
|
|
** The following are known problems:
|
|
** -- does not handle comments embedded in an instance ==> bombs
|
|
** -- ignores embedded entities ==> does not bomb
|
|
** -- error reporting does not include line number information
|
|
**/
|
|
|
|
SCLP23(Application_instance)::SCLP23_NAME(Application_instance) ()
|
|
: _cur(0), STEPfile_id(0), p21Comment(0), headMiEntity(0), nextMiEntity(0),
|
|
_complex(0)
|
|
{
|
|
}
|
|
|
|
SCLP23(Application_instance)::SCLP23_NAME(Application_instance) (int fileid, int complex)
|
|
: _cur(0), STEPfile_id(fileid), p21Comment(0),
|
|
headMiEntity(0), nextMiEntity(0), _complex (complex)
|
|
{
|
|
}
|
|
|
|
SCLP23(Application_instance)::~SCLP23_NAME(Application_instance) ()
|
|
{
|
|
STEPattribute * next =0;
|
|
ResetAttributes ();
|
|
while (next = NextAttribute ())
|
|
delete next;
|
|
|
|
if(MultipleInheritance())
|
|
{
|
|
delete nextMiEntity;
|
|
}
|
|
|
|
delete p21Comment;
|
|
|
|
/*
|
|
// this is not necessary since each will call delete on its
|
|
// own nextMiEntity - DAS
|
|
SCLP23(Application_instance) * nextMI = nextMiEntity;
|
|
SCLP23(Application_instance) * nextMItrail = 0;
|
|
while(nextMI)
|
|
{
|
|
nextMItrail = nextMI;
|
|
nextMI = nextMI->nextMiEntity;
|
|
// this is ok since STEPattribute doesn't explicitly delete its attr
|
|
delete nextMItrail;
|
|
}
|
|
*/
|
|
}
|
|
|
|
#ifdef PART26
|
|
//SCLP26(Application_instance_ptr)
|
|
IDL_Application_instance_ptr
|
|
SCLP23(Application_instance)::create_TIE()
|
|
{
|
|
G4cout << "ERROR SCLP23(Application_instance)::create_TIE() called." << G4endl;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
SCLP23(Application_instance) *
|
|
SCLP23(Application_instance)::Replicate()
|
|
{
|
|
char errStr[BUFSIZ];
|
|
if(IsComplex())
|
|
{
|
|
G4cerr << "STEPcomplex::Replicate() should be called: " << __FILE__
|
|
<< __LINE__ << "\n" << _POC_ "\n";
|
|
sprintf(errStr,
|
|
"SCLP23(Application_instance)::Replicate(): %s - entity #%d.\n",
|
|
"Programming ERROR - STEPcomplex::Replicate() should be called",
|
|
STEPfile_id);
|
|
_error.AppendToDetailMsg(errStr);
|
|
_error.AppendToUserMsg(errStr);
|
|
_error.GreaterSeverity(SEVERITY_BUG);
|
|
return S_ENTITY_NULL;
|
|
}
|
|
else
|
|
{
|
|
#ifdef __OSTORE__
|
|
SCLP23(Application_instance) *seNew = eDesc->NewSTEPentity(os_database::of(this));
|
|
#else
|
|
SCLP23(Application_instance) *seNew = eDesc->NewSTEPentity();
|
|
#endif
|
|
seNew -> CopyAs (this);
|
|
return seNew;
|
|
}
|
|
}
|
|
|
|
void SCLP23(Application_instance)::AddP21Comment(const char *s, int replace)
|
|
{
|
|
if(replace)
|
|
{
|
|
delete p21Comment;
|
|
p21Comment = 0;
|
|
}
|
|
if(s)
|
|
{
|
|
if(!p21Comment)
|
|
{
|
|
#ifdef __OSTORE__
|
|
p21Comment = new (os_segment::of(this), SCLstring::get_os_typespec())
|
|
SCLstring;
|
|
#else
|
|
p21Comment = new SCLstring;
|
|
#endif
|
|
}
|
|
else
|
|
p21Comment->set_null();
|
|
p21Comment->Append( s );
|
|
}
|
|
}
|
|
|
|
void
|
|
SCLP23(Application_instance)::AddP21Comment(SCLstring &s, int replace)
|
|
{
|
|
if(replace)
|
|
{
|
|
delete p21Comment;
|
|
p21Comment = 0;
|
|
}
|
|
if(!s.is_null())
|
|
{
|
|
if(!p21Comment)
|
|
{
|
|
#ifdef __OSTORE__
|
|
p21Comment = new (os_segment::of(this),
|
|
SCLstring::get_os_typespec())
|
|
SCLstring;
|
|
#else
|
|
p21Comment = new SCLstring;
|
|
#endif
|
|
}
|
|
else
|
|
p21Comment->set_null();
|
|
p21Comment->Append( s.chars() );
|
|
}
|
|
}
|
|
|
|
void
|
|
SCLP23(Application_instance)::STEPwrite_reference (std::ostream& out)
|
|
{
|
|
out << "#" << STEPfile_id;
|
|
}
|
|
|
|
const char *
|
|
SCLP23(Application_instance)::STEPwrite_reference (SCLstring &buf)
|
|
{
|
|
char tmp[64];
|
|
sprintf ( tmp,"#%d", STEPfile_id);
|
|
buf = tmp;
|
|
return buf.chars();
|
|
}
|
|
|
|
void
|
|
SCLP23(Application_instance)::AppendMultInstance(SCLP23(Application_instance) *se)
|
|
{
|
|
if(nextMiEntity == 0)
|
|
nextMiEntity = se;
|
|
else
|
|
{
|
|
SCLP23(Application_instance) *link = nextMiEntity;
|
|
SCLP23(Application_instance) *linkTrailing = 0;
|
|
while(link)
|
|
{
|
|
linkTrailing = link;
|
|
link = link->nextMiEntity;
|
|
}
|
|
linkTrailing->nextMiEntity = se;
|
|
}
|
|
}
|
|
|
|
// BUG implement this
|
|
|
|
SCLP23(Application_instance) *
|
|
SCLP23(Application_instance)::GetMiEntity(char *EntityName)
|
|
{
|
|
SCLstring s1, s2;
|
|
|
|
const EntityDescLinkNode *edln = 0;
|
|
const EntityDescriptor *ed = eDesc;
|
|
|
|
// compare up the *leftmost* parent path
|
|
while(ed)
|
|
{
|
|
if( !strcmp( StrToLower(ed->Name(),s1), StrToLower(EntityName,s2) ) )
|
|
return this; // return this parent path
|
|
edln = (EntityDescLinkNode *)( ed->Supertypes().GetHead() );
|
|
if(edln)
|
|
ed = edln->EntityDesc();
|
|
else
|
|
ed = 0;
|
|
}
|
|
// search alternate parent path since didn't find it in this one.
|
|
if(nextMiEntity)
|
|
return nextMiEntity->GetMiEntity(EntityName);
|
|
return 0;
|
|
}
|
|
|
|
|
|
#ifdef __OSTORE__
|
|
void Application_instance_access_hook_in(void *object,
|
|
enum os_access_reason reason, void *user_data,
|
|
void *start_range, void *end_range)
|
|
{
|
|
G4cout << "ObjectStore called non-member function Application_instance Access_hook"
|
|
<< G4endl;
|
|
SCLP23(Application_instance) *ent = (SCLP23(Application_instance) *)object;
|
|
G4cout << "STEPfile_id: " << ent->STEPfile_id << G4endl;
|
|
ent->Access_hook_in(object, reason, user_data, start_range, end_range);
|
|
|
|
// SdaiEb_person *ent = (SdaiEb_person *)object;
|
|
// SdaiEb_person_access_hook_in(object, reason, user_data,
|
|
// start_range, end_range);
|
|
}
|
|
|
|
void
|
|
SCLP23(Application_instance)::Access_hook_in(void *object,
|
|
enum os_access_reason reason, void *user_data,
|
|
void *start_range, void *end_range)
|
|
{
|
|
SCLP23(Application_instance) *ent = (SCLP23(Application_instance) *)object;
|
|
G4cout << "****WARNING: virtual SCLP23(Application_instance)::Access_hook_in() called" << G4endl;
|
|
ent->Access_hook_in(object, reason, user_data, start_range, end_range);
|
|
}
|
|
#endif
|
|
|
|
STEPattribute *
|
|
SCLP23(Application_instance)::GetSTEPattribute (const char * nm)
|
|
{
|
|
if (!nm) return 0;
|
|
STEPattribute *a =0;
|
|
|
|
ResetAttributes();
|
|
while ((a = NextAttribute () )
|
|
&& strcmp (nm, a ->Name()))
|
|
; // keep going until no more attributes or attribute is found
|
|
|
|
return a;
|
|
}
|
|
|
|
STEPattribute *
|
|
SCLP23(Application_instance)::MakeRedefined (STEPattribute *redefiningAttr, const char * nm)
|
|
{
|
|
// find the attribute being redefined
|
|
STEPattribute * a = GetSTEPattribute (nm);
|
|
|
|
// assign its pointer to the redefining attribute
|
|
if (a) a->RedefiningAttr(redefiningAttr);
|
|
return a;
|
|
}
|
|
|
|
STEPattribute *
|
|
SCLP23(Application_instance)::MakeDerived (const char * nm)
|
|
{
|
|
STEPattribute * a = GetSTEPattribute (nm);
|
|
if (a) a ->Derive ();
|
|
return a;
|
|
}
|
|
|
|
void
|
|
SCLP23(Application_instance)::CopyAs (SCLP23(Application_instance) * other)
|
|
{
|
|
int numAttrs = AttributeCount();
|
|
ResetAttributes();
|
|
other -> ResetAttributes();
|
|
|
|
STEPattribute *this_attr = 0;
|
|
STEPattribute *other_attr = 0;
|
|
while((this_attr = NextAttribute()) && numAttrs)
|
|
{
|
|
other_attr = other -> NextAttribute();
|
|
this_attr -> ShallowCopy(other_attr);
|
|
numAttrs--;
|
|
}
|
|
}
|
|
|
|
|
|
const char *
|
|
SCLP23(Application_instance)::EntityName( const char *schnm) const
|
|
{
|
|
return eDesc->Name( schnm );
|
|
}
|
|
|
|
/*****************************************************************
|
|
Checks if a given SCLP23(Application_instance) is the same type as this one
|
|
****************************************************************/
|
|
|
|
const EntityDescriptor* SCLP23(Application_instance)::IsA(const EntityDescriptor *ed) const
|
|
{
|
|
return (eDesc->IsA(ed));
|
|
}
|
|
|
|
/******************************************************************
|
|
// Checks the validity of the current attribute values for the entity
|
|
******************************************************************/
|
|
|
|
Severity SCLP23(Application_instance)::ValidLevel(ErrorDescriptor *error, InstMgr *im,
|
|
int clearError)
|
|
{
|
|
ErrorDescriptor err;
|
|
if(clearError)
|
|
ClearError();
|
|
int n = attributes.list_length();
|
|
SCLstring tmp;
|
|
for (int i = 0 ; i < n; i++) {
|
|
if( !(attributes[i].aDesc->AttrType() == AttrType_Redefining) )
|
|
error->GreaterSeverity(attributes[i].ValidLevel(
|
|
attributes[i].asStr(tmp), &err, im, 0));
|
|
}
|
|
return error->severity();
|
|
}
|
|
|
|
/******************************************************************
|
|
// clears all attr's errors
|
|
******************************************************************/
|
|
void SCLP23(Application_instance)::ClearAttrError()
|
|
{
|
|
int n = attributes.list_length();
|
|
for (int i = 0 ; i < n; i++) {
|
|
attributes[i].Error().ClearErrorMsg();
|
|
}
|
|
}
|
|
|
|
/******************************************************************
|
|
// clears entity's error and optionally all attr's errors
|
|
******************************************************************/
|
|
|
|
void SCLP23(Application_instance)::ClearError(int clearAttrs)
|
|
{
|
|
_error.ClearErrorMsg();
|
|
if(clearAttrs)
|
|
ClearAttrError();
|
|
}
|
|
|
|
/******************************************************************
|
|
******************************************************************/
|
|
|
|
/*
|
|
void SCLP23(Application_instance)::EnforceOptionality(int on)
|
|
{
|
|
Enforcement e;
|
|
if(on) e = ENFORCE_OPTIONALITY;
|
|
else e = ENFORCE_OFF;
|
|
|
|
Error().enforcement(e);
|
|
int n = attributes.list_length();
|
|
for (int i = 0 ; i < n; i++) {
|
|
attributes[i].Error().enforcement(e);
|
|
}
|
|
}
|
|
*/
|
|
/******************************************************************
|
|
** Procedure: beginSTEPwrite
|
|
** Parameters: std::ostream& out -- stream to write to
|
|
** Returns:
|
|
** Side Effects: writes out the SCOPE section for an entity
|
|
** Status: stub
|
|
******************************************************************/
|
|
|
|
void SCLP23(Application_instance)::beginSTEPwrite(std::ostream& out)
|
|
{
|
|
out << "begin STEPwrite ... \n" ;
|
|
out.flush();
|
|
|
|
int n = attributes.list_length();
|
|
for (int i = 0 ; i < n; i++) {
|
|
if (attributes[i].Type () == ENTITY_TYPE
|
|
&& *(attributes[i].ptr.c) != S_ENTITY_NULL)
|
|
(*(attributes[i].ptr.c)) -> STEPwrite();
|
|
}
|
|
}
|
|
|
|
/******************************************************************
|
|
** Procedure: STEPwrite
|
|
** Parameters: std::ostream& out -- stream to write to
|
|
** Returns:
|
|
** Side Effects: writes out the data associated with an instance
|
|
in STEP format
|
|
** Problems: does not print out the SCOPE section of an entity
|
|
**
|
|
******************************************************************/
|
|
|
|
void
|
|
SCLP23(Application_instance)::STEPwrite(std::ostream& out, const char *currSch,
|
|
int writeComments)
|
|
{
|
|
SCLstring tmp;
|
|
if(writeComments && p21Comment && !p21Comment->is_null() )
|
|
out << p21Comment->chars();
|
|
out << "#" << STEPfile_id << "=" << StrToUpper(EntityName( currSch ), tmp)
|
|
<< "(";
|
|
int n = attributes.list_length();
|
|
|
|
for (int i = 0 ; i < n; i++) {
|
|
if( !(attributes[i].aDesc->AttrType() == AttrType_Redefining) )
|
|
{
|
|
if (i > 0) out << ",";
|
|
(attributes[i]).STEPwrite( out, currSch );
|
|
}
|
|
}
|
|
out << ");\n";
|
|
}
|
|
|
|
void SCLP23(Application_instance)::endSTEPwrite(std::ostream& out)
|
|
{
|
|
out << "end STEPwrite ... \n" ;
|
|
out.flush();
|
|
}
|
|
|
|
void
|
|
SCLP23(Application_instance)::WriteValuePairs(std::ostream& out,
|
|
const char *currSch,
|
|
int writeComments, int mixedCase)
|
|
{
|
|
/*
|
|
const EntityDescriptorList &edl = eDesc->Supertypes();
|
|
EntityDescItr &edi((EntityDescriptorList &)(eDesc->Supertypes()));
|
|
|
|
int count = 1;
|
|
const EntityDescriptor * ed = 0;
|
|
while(ed = edi.NextEntityDesc())
|
|
{
|
|
if(count > 1)
|
|
{
|
|
out << "&";
|
|
}
|
|
out << ed->Name();
|
|
count++;
|
|
}
|
|
*/
|
|
|
|
// const AttrDescriptorList& adl = ed->ExplicitAttr();
|
|
|
|
/*
|
|
out << "Attributes are: " << G4endl;
|
|
edi.ResetItr();
|
|
AttrDescItr *adi = 0;
|
|
const AttrDescriptor * ad;
|
|
while(ed = edi.NextEntityDesc())
|
|
{
|
|
adi = new AttrDescItr((AttrDescriptorList&)ed->ExplicitAttr());
|
|
ad = 0;
|
|
while(ad = adi->NextAttrDesc())
|
|
{
|
|
out << ed->Name() << "." << ad->Name() << G4endl;
|
|
}
|
|
delete adi;
|
|
}
|
|
out << G4endl;
|
|
out << "finished writing attribute names." << G4endl;
|
|
edi.ResetItr();
|
|
*/
|
|
SCLstring s;
|
|
// out << eDesc->QualifiedName(s) << G4endl;
|
|
|
|
SCLstring tmp, tmp2;
|
|
if(writeComments && p21Comment && !p21Comment->is_null() )
|
|
out << p21Comment->chars();
|
|
if(mixedCase)
|
|
{
|
|
out << "#" << STEPfile_id << " "
|
|
<< eDesc->QualifiedName(s) << G4endl;
|
|
}
|
|
else
|
|
{
|
|
out << "#" << STEPfile_id << " "
|
|
<< StrToUpper(eDesc->QualifiedName(s),tmp) << G4endl;
|
|
}
|
|
int n = attributes.list_length();
|
|
|
|
for (int i = 0 ; i < n; i++) {
|
|
if( !(attributes[i].aDesc->AttrType() == AttrType_Redefining) )
|
|
{
|
|
// if (i > 0) out << ",";
|
|
if(mixedCase)
|
|
{
|
|
out << "\t"
|
|
<< attributes[i].aDesc->Owner().Name(s)
|
|
<< "." << attributes[i].aDesc->Name() << " ";
|
|
}
|
|
else
|
|
{
|
|
out << "\t"
|
|
<< StrToUpper(attributes[i].aDesc->Owner().Name(s),tmp)
|
|
<< "." << StrToUpper(attributes[i].aDesc->Name(),tmp2) << " ";
|
|
}
|
|
(attributes[i]).STEPwrite( out, currSch );
|
|
out << G4endl;
|
|
}
|
|
}
|
|
out << G4endl;
|
|
}
|
|
|
|
|
|
/******************************************************************
|
|
** Procedure: STEPwrite
|
|
** Problems: does not print out the SCOPE section of an entity
|
|
**
|
|
******************************************************************/
|
|
|
|
const char *
|
|
SCLP23(Application_instance)::STEPwrite(SCLstring &buf, const char *currSch)
|
|
{
|
|
buf.set_null();
|
|
|
|
char instanceInfo[BUFSIZ];
|
|
|
|
SCLstring tmp;
|
|
sprintf(instanceInfo, "#%d=%s(", STEPfile_id,
|
|
(char *)StrToUpper( EntityName( currSch ), tmp ) );
|
|
buf.Append(instanceInfo);
|
|
|
|
int n = attributes.list_length();
|
|
|
|
for (int i = 0 ; i < n; i++) {
|
|
if( !(attributes[i].aDesc->AttrType() == AttrType_Redefining) )
|
|
{
|
|
if (i > 0) buf.Append( ',' );
|
|
attributes[i].asStr( tmp, currSch ) ;
|
|
buf.Append (tmp);
|
|
}
|
|
}
|
|
buf.Append( ");" );
|
|
return buf.chars();
|
|
}
|
|
|
|
void
|
|
SCLP23(Application_instance)::PrependEntityErrMsg()
|
|
{
|
|
char errStr[BUFSIZ];
|
|
errStr[0] = '\0';
|
|
|
|
if(_error.severity() == SEVERITY_NULL)
|
|
{ // if there is not an error already
|
|
sprintf(errStr, "\nERROR: ENTITY #%d %s\n", GetFileId(),
|
|
EntityName());
|
|
_error.PrependToDetailMsg(errStr);
|
|
}
|
|
}
|
|
|
|
/******************************************************************
|
|
** Procedure: SCLP23(Application_instance)::STEPread_error
|
|
** Parameters: char c -- character which caused error
|
|
** int i -- index of attribute which caused error
|
|
** std::istream& in -- input stream for recovery
|
|
** Returns:
|
|
** Description: reports the error found, reads until it finds the end of an
|
|
** instance. i.e. a close quote followed by a semicolon optionally having
|
|
** whitespace between them.
|
|
******************************************************************/
|
|
void
|
|
SCLP23(Application_instance)::STEPread_error(char c, int i, std::istream& in)
|
|
{
|
|
char errStr[BUFSIZ];
|
|
errStr[0] = '\0';
|
|
|
|
if(_error.severity() == SEVERITY_NULL)
|
|
{ // if there is not an error already
|
|
sprintf(errStr, "\nERROR: ENTITY #%d %s\n", GetFileId(),
|
|
EntityName());
|
|
_error.PrependToDetailMsg(errStr);
|
|
}
|
|
|
|
/* sprintf(errStr, " for instance #%d : %s\n", STEPfile_id, EntityName());*/
|
|
/* _error.AppendToDetailMsg(errStr);*/
|
|
|
|
if ( (i >= 0) && (i < attributes.list_length())) // i is an attribute
|
|
{
|
|
Error ().GreaterSeverity (SEVERITY_WARNING);
|
|
sprintf(errStr, " invalid data before type \'%s\'\n",
|
|
attributes[i].TypeName());
|
|
_error.AppendToDetailMsg(errStr);
|
|
}
|
|
else
|
|
{
|
|
Error ().GreaterSeverity (SEVERITY_INPUT_ERROR);
|
|
_error.AppendToDetailMsg(" No more attributes were expected.\n");
|
|
}
|
|
|
|
SCLstring tmp;
|
|
STEPwrite (tmp); // STEPwrite writes to a static buffer inside function
|
|
sprintf(errStr,
|
|
" The invalid instance to this point looks like :\n%s\n",
|
|
tmp.chars() );
|
|
_error.AppendToDetailMsg(errStr);
|
|
|
|
// _error.AppendToDetailMsg(" data lost looking for end of entity:");
|
|
|
|
// scan over the rest of the instance and echo it
|
|
// G4cerr << " ERROR Trying to find the end of the ENTITY to recover...\n";
|
|
// G4cerr << " skipping the following input:\n";
|
|
|
|
#ifdef OBSOLETE
|
|
in.clear();
|
|
int foundEnd = 0;
|
|
tmp = "";
|
|
|
|
// Search until a close paren is found followed by (skipping optional
|
|
// whitespace) a semicolon
|
|
while( in.good() && !foundEnd )
|
|
{
|
|
while ( in.good() && (c != ')') )
|
|
{
|
|
in.get(c);
|
|
tmp.Append(c);
|
|
// G4cerr << c;
|
|
}
|
|
if(in.good() && (c == ')') )
|
|
{
|
|
in >> std::ws; // skip whitespace
|
|
in.get(c);
|
|
tmp.Append(c);
|
|
// G4cerr << c;
|
|
// G4cerr << "\n";
|
|
if(c == ';')
|
|
{
|
|
foundEnd = 1;
|
|
}
|
|
}
|
|
}
|
|
_error.AppendToDetailMsg( tmp.chars() );
|
|
#endif
|
|
sprintf (errStr, "\nfinished reading #%d\n", STEPfile_id);
|
|
_error.AppendToDetailMsg(errStr);
|
|
return;
|
|
}
|
|
|
|
/******************************************************************
|
|
** Procedure: STEPread
|
|
** Returns: Severity, error information
|
|
** SEVERITY_NULL - no errors
|
|
** SEVERITY_USERMSG - checked as much as possible, could still
|
|
** be error - e.g. entity didn't match base entity type.
|
|
** SEVERITY_INCOMPLETE - data is missing and required.
|
|
** SEVERITY_WARNING - errors, but can recover
|
|
** <= SEVERITY_INPUT_ERROR - fatal error, can't recover
|
|
** Description: reads the values for an entity from an input stream
|
|
** in STEP file format starting at the open paren and
|
|
** ending with the semi-colon
|
|
** Parameters: int id
|
|
** int idIncrement
|
|
** InstMgr instances
|
|
** std::istream& in
|
|
** Side Effects: gobbles up input stream
|
|
** Status:
|
|
******************************************************************/
|
|
|
|
Severity
|
|
SCLP23(Application_instance)::STEPread(int id, int idIncr,
|
|
InstMgr * instance_set, std::istream& in,
|
|
const char *currSch, int useTechCor)
|
|
{
|
|
STEPfile_id = id;
|
|
char c ='\0';
|
|
char errStr[BUFSIZ];
|
|
errStr[0] = '\0';
|
|
Severity severe;
|
|
int i = 0;
|
|
|
|
ClearError(1);
|
|
|
|
in >> std::ws;
|
|
in >> c; // read the open paren
|
|
if( c != '(' )
|
|
{
|
|
PrependEntityErrMsg();
|
|
_error.AppendToDetailMsg(
|
|
" Missing initial open paren... Trying to recover.\n");
|
|
in.putback(c); // assume you can recover by reading 1st attr value
|
|
}
|
|
in >> std::ws;
|
|
|
|
int n = attributes.list_length();
|
|
if( n == 0) // no attributes
|
|
{
|
|
in >> c; // look for the close paren
|
|
if( c == ')' )
|
|
return _error.severity();
|
|
}
|
|
|
|
for (i = 0 ; i < n; i++) {
|
|
if( attributes[i].aDesc->AttrType() == AttrType_Redefining )
|
|
{
|
|
in >> std::ws;
|
|
c = in.peek();
|
|
if(!useTechCor) // i.e. use pre-technical corrigendum encoding
|
|
{
|
|
in >> c; // read what should be the '*'
|
|
in >> std::ws;
|
|
if(c == '*')
|
|
{
|
|
in >> c; // read the delimiter i.e. ',' or ')'
|
|
}
|
|
else
|
|
{
|
|
severe = SEVERITY_INCOMPLETE;
|
|
PrependEntityErrMsg(); // adds entity info if necessary
|
|
|
|
// set the severity for this entity
|
|
_error.GreaterSeverity(severe);
|
|
sprintf (errStr, " %s : ", attributes[i].Name());
|
|
_error.AppendToDetailMsg(errStr); // add attr name
|
|
_error.AppendToDetailMsg(
|
|
"Since using pre-technical corrigendum... missing asterisk for redefined attr.\n");
|
|
_error.AppendToUserMsg(
|
|
"Since using pre-technical corrigendum... missing asterisk for redefined attr. ");
|
|
}
|
|
/*
|
|
if( ! ( (c == ',') || (c == ')') ) )
|
|
{ // input is not a delimiter - an error
|
|
PrependEntityErrMsg();
|
|
|
|
_error.AppendToDetailMsg(
|
|
"Delimiter expected after redefined asterisk attribute encoding (since using pre-technical corregendum.\n");
|
|
CheckRemainingInput(in, &_error, "ENTITY", ",)");
|
|
if(!in.good())
|
|
return _error.severity();
|
|
if(_error.severity() <= SEVERITY_INPUT_ERROR)
|
|
{
|
|
// STEPread_error(c,i,in);
|
|
return _error.severity();
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
else // using technical corrigendum
|
|
{
|
|
// should be nothing to do except loop again unless...
|
|
// if at end need to have read the closing paren.
|
|
if(c == ')') // assume you are at the end so read last char
|
|
in >> c;
|
|
G4cout << "Entity #" << STEPfile_id
|
|
<< " skipping redefined attribute "
|
|
<< attributes[i].aDesc->Name() << G4endl << G4endl << std::flush;
|
|
}
|
|
// increment counter to read following attr since these attrs
|
|
// aren't written or read => there won't be a delimiter either
|
|
// i++;
|
|
}
|
|
else
|
|
{
|
|
attributes[i].STEPread(in, instance_set, idIncr, currSch);
|
|
in >> c; // read the , or ) following the attr read
|
|
|
|
severe = attributes[i].Error().severity();
|
|
|
|
if(severe <= SEVERITY_USERMSG)
|
|
{ // if there is some type of error
|
|
PrependEntityErrMsg();
|
|
|
|
// set the severity for this entity
|
|
_error.GreaterSeverity(severe);
|
|
sprintf (errStr, " %s : ", attributes[i].Name());
|
|
_error.AppendToDetailMsg(errStr); // add attr name
|
|
_error.AppendToDetailMsg((char *) // add attr error
|
|
attributes[i].Error().DetailMsg());
|
|
_error.AppendToUserMsg((char*)attributes[i].Error().UserMsg());
|
|
}
|
|
}
|
|
|
|
/*
|
|
if(severe <= SEVERITY_INPUT_ERROR)
|
|
{ // attribute\'s error is non-recoverable
|
|
// I believe if this error occurs then you cannot recover
|
|
|
|
// TODO: can you just read to the next comma and try to continue ?
|
|
STEPread_error(c,i,in);
|
|
return _error.severity();
|
|
}
|
|
*/
|
|
// if technical corrigendum redefined, input is at next attribute value
|
|
// if pre-technical corrigendum redefined, don't process
|
|
if ( (!( attributes[i].aDesc->AttrType() == AttrType_Redefining ) ||
|
|
!useTechCor) &&
|
|
! ((c == ',') || (c == ')' )) ) { // input is not a delimiter
|
|
PrependEntityErrMsg();
|
|
|
|
_error.AppendToDetailMsg(
|
|
"Delimiter expected after attribute value.\n");
|
|
if(!useTechCor)
|
|
{
|
|
_error.AppendToDetailMsg(
|
|
"I.e. since using pre-technical corrigendum, redefined ");
|
|
_error.AppendToDetailMsg(
|
|
"attribute is mapped as an asterisk so needs delimiter.\n");
|
|
}
|
|
CheckRemainingInput(in, &_error, "ENTITY", ",)");
|
|
if(!in.good())
|
|
return _error.severity();
|
|
if(_error.severity() <= SEVERITY_INPUT_ERROR)
|
|
{
|
|
// STEPread_error(c,i,in);
|
|
return _error.severity();
|
|
}
|
|
}
|
|
else if(c == ')')
|
|
{
|
|
while (i < n-1)
|
|
{
|
|
i++; // check if following attributes are redefined
|
|
if( !(attributes[i].aDesc->AttrType() == AttrType_Redefining) )
|
|
{
|
|
PrependEntityErrMsg();
|
|
_error.AppendToDetailMsg("Missing attribute value[s].\n");
|
|
// recoverable error
|
|
_error.GreaterSeverity(SEVERITY_WARNING);
|
|
return _error.severity();
|
|
}
|
|
i++;
|
|
}
|
|
return _error.severity();
|
|
}
|
|
}
|
|
STEPread_error(c,i,in);
|
|
// code fragment imported from STEPread_error
|
|
// for some currently unknown reason it was commented out of STEPread_error
|
|
errStr[0] = '\0';
|
|
in.clear();
|
|
int foundEnd = 0;
|
|
SCLstring tmp;
|
|
tmp = "";
|
|
|
|
// Search until a close paren is found followed by (skipping optional
|
|
// whitespace) a semicolon
|
|
while( in.good() && !foundEnd )
|
|
{
|
|
while ( in.good() && (c != ')') )
|
|
{
|
|
in.get(c);
|
|
tmp.Append(c);
|
|
// G4cerr << c;
|
|
}
|
|
if(in.good() && (c == ')') )
|
|
{
|
|
in >> std::ws; // skip whitespace
|
|
in.get(c);
|
|
tmp.Append(c);
|
|
// G4cerr << c;
|
|
// G4cerr << "\n";
|
|
if(c == ';')
|
|
{
|
|
foundEnd = 1;
|
|
}
|
|
}
|
|
}
|
|
_error.AppendToDetailMsg( tmp.chars() );
|
|
sprintf (errStr, "\nfinished reading #%d\n", STEPfile_id);
|
|
_error.AppendToDetailMsg(errStr);
|
|
// end of imported code
|
|
return _error.severity();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// read an entity reference and return a pointer to the SCLP23(Application_instance)
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
SCLP23(Application_instance) *
|
|
ReadEntityRef(std::istream &in, ErrorDescriptor *err, char *tokenList,
|
|
InstMgr * instances, int addFileId)
|
|
{
|
|
char c;
|
|
char errStr[BUFSIZ];
|
|
errStr[0] = '\0';
|
|
|
|
in >> std::ws;
|
|
in >> c;
|
|
switch (c)
|
|
{
|
|
case '@':
|
|
err->AppendToDetailMsg(
|
|
"Use of @ instead of # to identify entity.\n");
|
|
err->GreaterSeverity(SEVERITY_WARNING);
|
|
// no break statement here on purpose
|
|
case '#':
|
|
{
|
|
int id = -1;
|
|
// int n = 0;
|
|
in >> id;
|
|
if (in.fail ()) // there's been an error in input
|
|
{
|
|
// in.clear();
|
|
sprintf(errStr,"Invalid entity reference value.\n");
|
|
err->AppendToDetailMsg(errStr);
|
|
err->AppendToUserMsg(errStr);
|
|
err->GreaterSeverity(SEVERITY_WARNING);
|
|
CheckRemainingInput(in, err, "Entity Reference", tokenList);
|
|
return S_ENTITY_NULL;
|
|
}
|
|
else // found an entity id
|
|
{
|
|
// check to make sure garbage does not follow the id
|
|
CheckRemainingInput(in, err, "Entity Reference", tokenList);
|
|
|
|
id += addFileId;
|
|
if (!instances)
|
|
{
|
|
G4cerr << "Internal error: " << __FILE__ << __LINE__
|
|
<< "\n" << _POC_ "\n";
|
|
sprintf(errStr,
|
|
"STEPread_reference(): %s - entity #%d %s.\n",
|
|
"BUG - cannot read reference without the InstMgr",
|
|
id, "is unknown");
|
|
err->AppendToDetailMsg(errStr);
|
|
err->AppendToUserMsg(errStr);
|
|
err->GreaterSeverity(SEVERITY_BUG);
|
|
return S_ENTITY_NULL;
|
|
}
|
|
|
|
// lookup which object has id as its instance id
|
|
SCLP23(Application_instance)* inst;
|
|
/* If there is a ManagerNode it should have a SCLP23(Application_instance) */
|
|
MgrNode* mn =0;
|
|
mn = instances->FindFileId(id);
|
|
if (mn)
|
|
{
|
|
inst = mn->GetSTEPentity() ;
|
|
if (inst) { return (inst); }
|
|
else
|
|
{
|
|
G4cerr << "Internal error: " << __FILE__ << __LINE__
|
|
<< "\n" << _POC_ "\n";
|
|
sprintf(errStr,
|
|
"STEPread_reference(): %s - entity #%d %s.\n",
|
|
"BUG - MgrNode::GetSTEPentity returned NULL pointer",
|
|
id, "is unknown");
|
|
err->AppendToDetailMsg(errStr);
|
|
err->AppendToUserMsg(errStr);
|
|
err->GreaterSeverity(SEVERITY_BUG);
|
|
return S_ENTITY_NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sprintf(errStr,"Reference to non-existent ENTITY #%d.\n",
|
|
id);
|
|
err->AppendToDetailMsg(errStr);
|
|
err->AppendToUserMsg(errStr);
|
|
err->GreaterSeverity(SEVERITY_WARNING);
|
|
return S_ENTITY_NULL;
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
{
|
|
in.putback(c);
|
|
// read past garbage up to delim in tokenList
|
|
// if tokenList is null it will not read anything
|
|
CheckRemainingInput(in, err, "Entity Reference", tokenList);
|
|
return S_ENTITY_NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// same as above but reads from a const char *
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
SCLP23(Application_instance) *
|
|
ReadEntityRef(const char * s, ErrorDescriptor *err, char *tokenList,
|
|
InstMgr * instances, int addFileId)
|
|
{
|
|
std::istrstream in((char *)s);
|
|
return ReadEntityRef(in, err, tokenList, instances, addFileId);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// return SEVERITY_NULL if se's entity type matches the supplied entity type
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
Severity
|
|
EntityValidLevel(SCLP23(Application_instance) *se,
|
|
const TypeDescriptor *ed, // entity type that entity se needs
|
|
// to match. (this must be an
|
|
// EntityDescriptor)
|
|
ErrorDescriptor *err)
|
|
{
|
|
char messageBuf [BUFSIZ];
|
|
messageBuf[0] = '\0';
|
|
|
|
if( !ed || (ed->NonRefType() != ENTITY_TYPE) )
|
|
{
|
|
err->GreaterSeverity(SEVERITY_BUG);
|
|
sprintf(messageBuf,
|
|
" BUG: EntityValidLevel() called with %s",
|
|
"missing or invalid EntityDescriptor\n");
|
|
err->AppendToUserMsg(messageBuf);
|
|
err->AppendToDetailMsg(messageBuf);
|
|
G4cerr << "Internal error: " << __FILE__ << __LINE__
|
|
<< "\n" << _POC_ "\n";
|
|
return SEVERITY_BUG;
|
|
}
|
|
if(!se || (se == S_ENTITY_NULL))
|
|
{
|
|
err->GreaterSeverity(SEVERITY_BUG);
|
|
sprintf(messageBuf,
|
|
" BUG: EntityValidLevel() called with null pointer %s\n",
|
|
"for SCLP23(Application_instance) argument.");
|
|
err->AppendToUserMsg(messageBuf);
|
|
err->AppendToDetailMsg(messageBuf);
|
|
G4cerr << "Internal error: " << __FILE__ << __LINE__
|
|
<< "\n" << _POC_ "\n";
|
|
return SEVERITY_BUG;
|
|
}
|
|
|
|
// DAVE: Can an entity be used in an Express TYPE so that this
|
|
// EntityDescriptor would have type REFERENCE_TYPE -- it looks like NO
|
|
|
|
else if(se->eDesc)
|
|
{
|
|
// is se a descendant of ed?
|
|
if ( se->eDesc->IsA(ed) )
|
|
{
|
|
return SEVERITY_NULL;
|
|
}
|
|
else
|
|
{
|
|
if(se->IsComplex())
|
|
{
|
|
// This way assumes that the complex has all it's parts i.e. the
|
|
// complete hierarchy so it should be able to find ed's part if
|
|
// it is an ed.
|
|
STEPcomplex *sc = ((STEPcomplex *)se)->sc;
|
|
if(sc->EntityExists(ed->Name()))
|
|
return SEVERITY_NULL;
|
|
/*
|
|
*/
|
|
|
|
// This way checks to see if it is an ed based on the dictionary
|
|
// It is much less efficient but does not depend on the instance
|
|
// having all the parts it needs to be valid.
|
|
/*
|
|
STEPcomplex *sc = ((STEPcomplex *)se)->sc;
|
|
while (sc)
|
|
{
|
|
if( sc->eDesc->IsA(ed) )
|
|
return SEVERITY_NULL;
|
|
sc = sc->sc;
|
|
}
|
|
*/
|
|
}
|
|
err->GreaterSeverity(SEVERITY_WARNING);
|
|
sprintf(messageBuf,
|
|
" Entity #%d exists but is not a %s or descendant.\n",
|
|
se->STEPfile_id, ed->Name());
|
|
err->AppendToUserMsg(messageBuf);
|
|
err->AppendToDetailMsg(messageBuf);
|
|
return SEVERITY_WARNING;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
err->GreaterSeverity(SEVERITY_BUG);
|
|
sprintf(messageBuf,
|
|
" BUG: EntityValidLevel(): SCLP23(Application_instance) #%d has a %s",
|
|
se->STEPfile_id, "missing or invalid EntityDescriptor\n");
|
|
err->AppendToUserMsg(messageBuf);
|
|
err->AppendToDetailMsg(messageBuf);
|
|
G4cerr << "Internal error: " << __FILE__ << __LINE__
|
|
<< "\n" << _POC_ "\n";
|
|
return SEVERITY_BUG;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// return 1 if attrValue has the equivalent of a null value.
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
int
|
|
SetErrOnNull (const char *attrValue, ErrorDescriptor *error)
|
|
{
|
|
// DAVE: Is this needed will sscanf return 1 if assignment suppression is used?
|
|
char scanBuf[BUFSIZ];
|
|
scanBuf[0] = '\0';
|
|
|
|
int numFound = sscanf((char *)attrValue," %s", scanBuf);
|
|
if (numFound == EOF) {
|
|
/*
|
|
if(Nullable()) {
|
|
error->GreaterSeverity (SEVERITY_NULL);
|
|
}
|
|
else {
|
|
error->GreaterSeverity (SEVERITY_INCOMPLETE);
|
|
}
|
|
*/
|
|
error->GreaterSeverity (SEVERITY_INCOMPLETE);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// return SEVERITY_NULL if attrValue has a valid entity reference
|
|
// This function accepts an entity reference in two forms that is with or
|
|
// without the # sign: e.g. either #23 or 23 will be read.
|
|
// If non-whitespace characters follow the entity reference an error is set.
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
Severity
|
|
EntityValidLevel(const char *attrValue, // string contain entity ref
|
|
const TypeDescriptor *ed, // entity type that entity in
|
|
// attrValue (if it exists) needs
|
|
// to match. (this must be an
|
|
// EntityDescriptor)
|
|
ErrorDescriptor *err, InstMgr *im, int clearError)
|
|
{
|
|
char tmp [BUFSIZ];
|
|
tmp[0] = '\0';
|
|
char messageBuf [BUFSIZ];
|
|
messageBuf[0] = '\0';
|
|
|
|
if(clearError)
|
|
err->ClearErrorMsg();
|
|
|
|
/*
|
|
// the problem with doing this is that it will require having a # in front
|
|
// of the entity ref.
|
|
SCLP23(Application_instance) se = ReadEntityRef(attrValue, err, 0, im, 0);
|
|
return EntityValidLevel(se, ed, err);
|
|
*/
|
|
|
|
int fileId;
|
|
MgrNode *mn = 0;
|
|
|
|
// check for both forms: #id or id
|
|
int found1 = sscanf((char *)attrValue, " #%d %s", &fileId, tmp);
|
|
int found2 = sscanf((char *)attrValue, " %d %s", &fileId, tmp);
|
|
|
|
if( (found1 > 0) || (found2 > 0) )
|
|
{
|
|
if ( (found1 == 2) || (found2 == 2) )
|
|
{
|
|
sprintf(messageBuf,
|
|
" Attribute's Entity Reference %s is %s data \'%s\'.\n",
|
|
attrValue, "followed by invalid", tmp);
|
|
err->AppendToUserMsg(messageBuf);
|
|
err->AppendToDetailMsg(messageBuf);
|
|
err->GreaterSeverity(SEVERITY_WARNING);
|
|
}
|
|
mn = im->FindFileId(fileId);
|
|
if(mn)
|
|
{
|
|
SCLP23(Application_instance) *se = mn->GetSTEPentity();
|
|
return EntityValidLevel(se, ed, err);
|
|
}
|
|
else {
|
|
sprintf(messageBuf,
|
|
" Attribute's Entity Reference %s does not exist.\n",
|
|
attrValue);
|
|
err->AppendToUserMsg(messageBuf);
|
|
err->AppendToDetailMsg(messageBuf);
|
|
err->GreaterSeverity(SEVERITY_WARNING);
|
|
return SEVERITY_WARNING;
|
|
}
|
|
}
|
|
|
|
// if the attrValue contains no value return
|
|
if (SetErrOnNull (attrValue, err))
|
|
return err->severity();
|
|
|
|
sprintf(messageBuf, "Invalid attribute entity reference value: '%s'.\n",
|
|
attrValue);
|
|
err->AppendToUserMsg(messageBuf);
|
|
err->AppendToDetailMsg(messageBuf);
|
|
err->GreaterSeverity(SEVERITY_WARNING);
|
|
return SEVERITY_WARNING;
|
|
}
|
|
|
|
/******************************************************************
|
|
** Procedure: NextAttribute
|
|
** Parameters:
|
|
** Returns: reference to an attribute pointer
|
|
** Description: used to cycle through the list of attributes
|
|
** Side Effects: increments the current position in the attribute list
|
|
** Status: untested 7/31/90
|
|
******************************************************************/
|
|
|
|
STEPattribute *
|
|
SCLP23(Application_instance)::NextAttribute () {
|
|
int i = AttributeCount ();
|
|
++_cur;
|
|
if (i < _cur) return 0;
|
|
return &attributes [_cur-1];
|
|
|
|
}
|
|
|
|
int
|
|
SCLP23(Application_instance)::AttributeCount () {
|
|
return attributes.list_length ();
|
|
}
|
|
|
|
#ifdef OBSOLETE
|
|
Severity
|
|
SCLP23(Application_instance)::ReadAttrs(int id, int addFileId,
|
|
class InstMgr * instance_set, std::istream& in)
|
|
{
|
|
char c ='\0';
|
|
char errStr[BUFSIZ];
|
|
errStr[0] = '\0';
|
|
Severity severe;
|
|
|
|
ClearError(1);
|
|
|
|
int n = attributes.list_length();
|
|
for (int i = 0 ; i < n; i++) {
|
|
attributes[i].STEPread(in, instance_set, addFileId);
|
|
|
|
severe = attributes[i].Error().severity();
|
|
|
|
if(severe <= SEVERITY_USERMSG)
|
|
{ // if there\'s some type of error
|
|
if(_error.severity() == SEVERITY_NULL)
|
|
{ // if there is not an error already
|
|
sprintf(errStr, "\nERROR: ENTITY #%d %s\n", GetFileId(),
|
|
EntityName());
|
|
_error.PrependToDetailMsg(errStr);
|
|
}
|
|
// set the severity for this entity
|
|
sprintf (errStr, " %s : ", attributes[i].Name());
|
|
_error.AppendToDetailMsg(errStr);
|
|
_error.GreaterSeverity(severe);
|
|
_error.AppendToDetailMsg((char *)
|
|
attributes[i].Error().DetailMsg());
|
|
_error.AppendToUserMsg((char *)attributes[i].Error().UserMsg());
|
|
|
|
}
|
|
/*
|
|
if(severe <= SEVERITY_INPUT_ERROR)
|
|
{ // attribute\'s error is non-recoverable
|
|
// I believe if this error occurs then you cannot recover
|
|
|
|
// TODO: can you just read to the next comma and try to continue ?
|
|
STEPread_error(c,i,in);
|
|
return _error.severity();
|
|
}
|
|
*/
|
|
in >> c;
|
|
if ( ! ((c == ',') || (c == ')' ))) { // input is not a delimiter
|
|
if(_error.severity() == SEVERITY_NULL)
|
|
{ // if there is not an error already
|
|
sprintf(errStr, "\nERROR: ENTITY #%d %s\n", GetFileId(),
|
|
EntityName());
|
|
_error.PrependToDetailMsg(errStr);
|
|
}
|
|
_error.AppendToDetailMsg(
|
|
"delimiter expected after attribute value.\n");
|
|
CheckRemainingInput(in, &_error, "ENTITY", ",)");
|
|
if(!in.good())
|
|
return _error.severity();
|
|
if(_error.severity() <= SEVERITY_INPUT_ERROR)
|
|
{
|
|
STEPread_error(c,i,in);
|
|
return _error.severity();
|
|
}
|
|
}
|
|
else if(c == ')')
|
|
{
|
|
in >> std::ws;
|
|
char z = in.peek();
|
|
if (z == ';')
|
|
{
|
|
in.get(c);
|
|
return _error.severity();
|
|
}
|
|
}
|
|
}
|
|
if(c != ')' )
|
|
{
|
|
STEPread_error(c,i,in);
|
|
return _error.severity();
|
|
}
|
|
return SEVERITY_NULL;
|
|
}
|
|
#endif
|