414 lines
11 KiB
C++
414 lines
11 KiB
C++
|
|
/*
|
|
* NIST STEP Core Class Library
|
|
* clstepcore/ExpDict.inline.cc
|
|
* April 1997
|
|
* K. C. Morris
|
|
* David Sauder
|
|
|
|
* Development of this software was funded by the United States Government,
|
|
* and is not subject to copyright.
|
|
*/
|
|
|
|
#include <ExpDict.h>
|
|
#include "sc_memmgr.h"
|
|
|
|
Dictionary_instance::~Dictionary_instance() {
|
|
}
|
|
|
|
|
|
Schema::Schema( const char * schemaName )
|
|
: _use_interface_list( new Interface_spec__set ),
|
|
_ref_interface_list( new Interface_spec__set ),
|
|
_function_list( 0 ), _procedure_list( 0 ), _global_rules( 0 ) {
|
|
_name = schemaName;
|
|
}
|
|
|
|
Schema::~Schema() {
|
|
TypeDescLinkNode * node;
|
|
|
|
if( _use_interface_list != 0 ) {
|
|
delete _use_interface_list;
|
|
}
|
|
if( _ref_interface_list != 0 ) {
|
|
delete _ref_interface_list;
|
|
}
|
|
if( _global_rules != 0 ) {
|
|
delete _global_rules;
|
|
}
|
|
node = ( TypeDescLinkNode * ) _unnamed_typeList.GetHead();
|
|
while( node ) {
|
|
delete node->TypeDesc();
|
|
node = ( TypeDescLinkNode * ) node->NextNode();
|
|
}
|
|
}
|
|
|
|
Interfaced_item::Interfaced_item() {
|
|
}
|
|
|
|
Interfaced_item::Interfaced_item( const Interfaced_item & ii ) {
|
|
_foreign_schema = ii._foreign_schema;
|
|
}
|
|
|
|
Interfaced_item::Interfaced_item( const char * foreign_schema )
|
|
: _foreign_schema( foreign_schema ) {
|
|
}
|
|
|
|
Interfaced_item::~Interfaced_item() {
|
|
}
|
|
|
|
const Express_id Interfaced_item::foreign_schema_() {
|
|
return _foreign_schema;
|
|
}
|
|
|
|
void Interfaced_item::foreign_schema_( const Express_id & fs ) {
|
|
_foreign_schema = fs;
|
|
}
|
|
|
|
Explicit_item_id::Explicit_item_id() {
|
|
_local_definition = 0;
|
|
}
|
|
|
|
Explicit_item_id::Explicit_item_id( const Explicit_item_id & eii )
|
|
: Interfaced_item( eii ) {
|
|
_local_definition = eii._local_definition;
|
|
_original_id = eii._original_id;
|
|
_new_id = eii._new_id;
|
|
}
|
|
|
|
Explicit_item_id::~Explicit_item_id() {
|
|
_local_definition = 0;
|
|
}
|
|
|
|
Used_item::~Used_item() {
|
|
}
|
|
|
|
Referenced_item::~Referenced_item() {
|
|
}
|
|
|
|
Implicit_item_id::Implicit_item_id() {
|
|
_local_definition = 0;
|
|
}
|
|
|
|
Implicit_item_id::Implicit_item_id( Implicit_item_id & iii )
|
|
: Interfaced_item( iii ) {
|
|
_local_definition = iii._local_definition;
|
|
}
|
|
|
|
Implicit_item_id::~Implicit_item_id() {
|
|
_local_definition = 0;
|
|
}
|
|
|
|
EntityDescLinkNode::EntityDescLinkNode() {
|
|
_entityDesc = 0;
|
|
}
|
|
|
|
EntityDescLinkNode::~EntityDescLinkNode() {
|
|
}
|
|
|
|
EntityDescriptorList::EntityDescriptorList() {
|
|
}
|
|
|
|
EntityDescriptorList::~EntityDescriptorList() {
|
|
}
|
|
|
|
EntityDescItr::EntityDescItr( const EntityDescriptorList & edList ) : edl( edList ) {
|
|
cur = ( EntityDescLinkNode * )( edl.GetHead() );
|
|
}
|
|
EntityDescItr::~EntityDescItr() {
|
|
}
|
|
|
|
AttrDescLinkNode::AttrDescLinkNode() {
|
|
_attrDesc = 0;
|
|
}
|
|
|
|
AttrDescLinkNode::~AttrDescLinkNode() {
|
|
if( _attrDesc ) {
|
|
delete _attrDesc;
|
|
}
|
|
}
|
|
|
|
AttrDescItr::AttrDescItr( const AttrDescriptorList & adList ) : adl( adList ) {
|
|
cur = ( AttrDescLinkNode * )( adl.GetHead() );
|
|
}
|
|
|
|
AttrDescItr::~AttrDescItr() {
|
|
}
|
|
|
|
Inverse_attributeLinkNode::Inverse_attributeLinkNode() {
|
|
_invAttr = 0;
|
|
}
|
|
|
|
Inverse_attributeLinkNode::~Inverse_attributeLinkNode() {
|
|
}
|
|
|
|
Inverse_attributeList::Inverse_attributeList() {
|
|
}
|
|
|
|
Inverse_attributeList::~Inverse_attributeList() {
|
|
Inverse_attributeLinkNode * node;
|
|
|
|
node = ( Inverse_attributeLinkNode * ) head;
|
|
while( node ) {
|
|
delete node->Inverse_attr();
|
|
node = ( Inverse_attributeLinkNode * ) node->NextNode();
|
|
}
|
|
}
|
|
|
|
Inverse_attributeLinkNode * Inverse_attributeList::AddNode( Inverse_attribute * ad ) {
|
|
Inverse_attributeLinkNode * node = ( Inverse_attributeLinkNode * ) NewNode();
|
|
node->Inverse_attr( ad );
|
|
SingleLinkList::AppendNode( node );
|
|
return node;
|
|
}
|
|
|
|
InverseAItr::InverseAItr( const Inverse_attributeList & iaList )
|
|
: ial( iaList ) {
|
|
cur = ( Inverse_attributeLinkNode * )( ial.GetHead() );
|
|
}
|
|
|
|
InverseAItr::~InverseAItr() {
|
|
}
|
|
|
|
TypeDescLinkNode::TypeDescLinkNode() {
|
|
_typeDesc = 0;
|
|
}
|
|
|
|
TypeDescLinkNode::~TypeDescLinkNode() {
|
|
}
|
|
|
|
TypeDescriptorList::TypeDescriptorList() {
|
|
}
|
|
|
|
TypeDescriptorList::~TypeDescriptorList() {
|
|
}
|
|
|
|
TypeDescItr::TypeDescItr( const TypeDescriptorList & tdList ) : tdl( tdList ) {
|
|
cur = ( TypeDescLinkNode * )( tdl.GetHead() );
|
|
}
|
|
|
|
TypeDescItr::~TypeDescItr() {
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// TypeDescriptor functions
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
AttrDescriptorList::AttrDescriptorList() {
|
|
}
|
|
|
|
AttrDescriptorList::~AttrDescriptorList() {
|
|
}
|
|
|
|
AttrDescLinkNode *
|
|
AttrDescriptorList::AddNode( AttrDescriptor * ad ) {
|
|
AttrDescLinkNode * node = ( AttrDescLinkNode * ) NewNode();
|
|
node->AttrDesc( ad );
|
|
SingleLinkList::AppendNode( node );
|
|
return node;
|
|
}
|
|
|
|
TypeDescriptor::TypeDescriptor( )
|
|
: _name( 0 ), altNames( 0 ), _fundamentalType( UNKNOWN_TYPE ),
|
|
_originatingSchema( 0 ), _referentType( 0 ), _description( 0 ), _where_rules( 0 ) {
|
|
}
|
|
|
|
TypeDescriptor::TypeDescriptor
|
|
( const char * nm, PrimitiveType ft, Schema * origSchema,
|
|
const char * d )
|
|
: _name( nm ), altNames( 0 ), _fundamentalType( ft ),
|
|
_originatingSchema( origSchema ), _referentType( 0 ), _description( d ),
|
|
_where_rules( 0 ) {
|
|
}
|
|
|
|
TypeDescriptor::~TypeDescriptor() {
|
|
if( _where_rules ) {
|
|
delete _where_rules;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determines the current name of this. Normally, this is simply _name.
|
|
* If "schnm" is set to a value, however, then this function becomes a
|
|
* request for our name when referenced by schnm. (This will be diff from
|
|
* our original name if schnm USEs or REFERENCEs us and renames us (e.g.,
|
|
* "USE (xx as yy)").) In such a case, this function searches through our
|
|
* altNames list to see if schema schnm refers to us with a different name
|
|
* and returns the new name if found. (See header comments to function
|
|
* SchRename::rename().)
|
|
*/
|
|
const char * TypeDescriptor::Name( const char * schnm ) const {
|
|
if( schnm == NULL ) {
|
|
return _name;
|
|
}
|
|
if( altNames && altNames->rename( schnm, ( char * )_altname ) ) {
|
|
// If our altNames list has an alternate for schnm, copy it into
|
|
// _altname, and return it:
|
|
return _altname;
|
|
}
|
|
return _name;
|
|
}
|
|
|
|
const char * TypeDescriptor::BaseTypeName() const {
|
|
return BaseTypeDescriptor() ? BaseTypeDescriptor() -> Name() : 0;
|
|
}
|
|
|
|
const TypeDescriptor * TypeDescriptor::BaseTypeIsA( const TypeDescriptor * td ) const {
|
|
switch( NonRefType() ) {
|
|
case AGGREGATE_TYPE:
|
|
return AggrElemTypeDescriptor() -> IsA( td );
|
|
case ENTITY_TYPE:
|
|
case SELECT_TYPE:
|
|
default:
|
|
return IsA( td );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if our "current" name = other. CurrName may be different from
|
|
* _name if schNm tells us the current schema is a different one from the
|
|
* one in which we're defined. If so, we may have an alternate name for
|
|
* that schema (it may be listed in our altNames list). This would be the
|
|
* case if schNm USEs or REFERENCEs type and renames it in the process
|
|
* (e.g., "USE (X as Y)".
|
|
*/
|
|
bool TypeDescriptor::CurrName( const char * other, const char * schNm ) const {
|
|
if( !schNm || *schNm == '\0' ) {
|
|
// If there's no current schema, accept any possible name of this.
|
|
// (I.e., accept its actual name or any substitute):
|
|
return ( PossName( other ) );
|
|
}
|
|
if( altNames && altNames->rename( schNm, ( char * )_altname ) ) {
|
|
// If we have a different name when the current schema = schNm, then
|
|
// other better = the alt name.
|
|
return ( !StrCmpIns( _altname, other ) );
|
|
} else {
|
|
// If we have no desginated alternate name when the current schema =
|
|
// schNm, other must = our _name.
|
|
return ( OurName( other ) );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* return true if nm is either our name or one of the possible alternates.
|
|
*/
|
|
bool TypeDescriptor::PossName( const char * nm ) const {
|
|
return ( OurName( nm ) || AltName( nm ) );
|
|
}
|
|
|
|
bool TypeDescriptor::OurName( const char * nm ) const {
|
|
return !StrCmpIns( nm, _name );
|
|
}
|
|
|
|
bool TypeDescriptor::AltName( const char * nm ) const {
|
|
if( altNames ) {
|
|
return ( altNames->choice( nm ) );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Creates a SchRename consisting of schnm & newnm. Places it in alphabe-
|
|
* tical order in this's altNames list.
|
|
*/
|
|
void TypeDescriptor::addAltName( const char * schnm, const char * newnm ) {
|
|
SchRename * newpair = new SchRename( schnm, newnm ),
|
|
*node = ( SchRename * )altNames, *prev = NULL;
|
|
|
|
while( node && *node < *newpair ) {
|
|
prev = node;
|
|
node = node->next;
|
|
}
|
|
newpair->next = node; // node may = NULL
|
|
if( prev ) {
|
|
// Will be the case if new node should not be first (and above while
|
|
// loop was entered).
|
|
prev->next = newpair;
|
|
} else {
|
|
// put newpair first
|
|
altNames = newpair;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* See if nm = one of our choices (either ours or that of a SchRename
|
|
* later in the list.
|
|
*/
|
|
bool SchRename::choice( const char * nm ) const {
|
|
if( !StrCmpIns( nm, newName ) ) {
|
|
return true;
|
|
}
|
|
if( next ) {
|
|
return ( next->choice( nm ) );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if this SchRename represents the rename of its owning TypeDesc for
|
|
* schema schnm. (This will be the case if schnm = schName.) If so, the
|
|
* new name is returned and copied into newnm. If not, ::rename is called
|
|
* on next. Thus, this function will tell us if this or any later SchRe-
|
|
* name in this list provide a new name for TypeDesc for schema schnm.
|
|
*/
|
|
char * SchRename::rename( const char * schnm, char * newnm ) const {
|
|
if( !StrCmpIns( schnm, schName ) ) {
|
|
strcpy( newnm, newName );
|
|
return newnm;
|
|
}
|
|
if( next ) {
|
|
return ( next->rename( schnm, newnm ) );
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// AttrDescriptor functions
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
AttrDescriptor::AttrDescriptor( const char * name, const TypeDescriptor * domainType,
|
|
Logical optional, Logical unique, AttrType_Enum at,
|
|
const EntityDescriptor & owner )
|
|
: _name( name ), _domainType( domainType ), _optional( optional ),
|
|
_unique( unique ), _attrType( at ), _owner( ( EntityDescriptor & )owner ) {
|
|
}
|
|
|
|
AttrDescriptor::~AttrDescriptor() {
|
|
}
|
|
|
|
Logical AttrDescriptor::Explicit() const {
|
|
if( _attrType == AttrType_Explicit ) {
|
|
return LTrue;
|
|
}
|
|
return LFalse;
|
|
}
|
|
|
|
Logical AttrDescriptor::Inverse() const {
|
|
if( _attrType == AttrType_Inverse ) {
|
|
return LTrue;
|
|
}
|
|
return LFalse;
|
|
}
|
|
|
|
Logical AttrDescriptor::Redefining() const {
|
|
if( _attrType == AttrType_Redefining ) {
|
|
return LTrue;
|
|
}
|
|
return LFalse;
|
|
}
|
|
|
|
Logical AttrDescriptor::Deriving() const {
|
|
if( _attrType == AttrType_Deriving ) {
|
|
return LTrue;
|
|
}
|
|
return LFalse;
|
|
}
|
|
|
|
Derived_attribute::Derived_attribute( const char * name, const TypeDescriptor * domainType,
|
|
Logical optional, Logical unique, AttrType_Enum at, const EntityDescriptor & owner )
|
|
: AttrDescriptor( name, domainType, optional, unique, at, owner ) {
|
|
_initializer = ( const char * )0;
|
|
}
|
|
|
|
Derived_attribute::~Derived_attribute() {
|
|
}
|