/*****************************************************************************
* multpass.c *
* *
* Description: *
* Adds multi-schema support enhancement to exp2python parser. Allows the *
* generation of C++ representations for multiple EXPRESS schemas without *
* creating conflicting header files. Previously, exp2python would gene- *
* rate a single set of files (.h, .cc, .init.cc) for each schema found in *
* the processed EXPRESS file. A number of problem situations occurred: *
* *
* (1) Two schemas which USE or REFERENCE entities from one another. If *
* e.g. schema A USEs entity 1 from schema B and defines ent 2 subtype *
* of 1, and schema B USEs ent 2 from A and defines ents 1 and 3 sub- *
* type of 2, neither include file could be compiled first. *
* (2) An entity which has a select or enumeration attribute which is de- *
* fined in another schema. *
* (3) A select type which has a select or enum member item which is de- *
* fined in another schema.
* (4) An enumeration type which is a redefinition of an enum defined in *
* another schema. *
* *
* The functions in multpass.c provide for the processing of each schema *
* in multiple passes. At each pass, only entities and types which are *
* not dependent on undefined objects are processed. With each pass, more *
* entities and types become defined and more dependent entities and types *
* will become processable. At each state of processing, a separate set *
* of C++ files is generated. Lastly, multpass processes certain aggre- *
* gate and redefined objects after all the fundamental types are defined. *
* *
* Created by: David Rosenfeld *
* Date: 04/09/97 *
*****************************************************************************/
#include
#include "classes.h"
#define FALSE 0
#define TRUE 1
int isAggregateType( const Type t );
/* Local function prototypes: */
static void initializeMarks( Express );
static void unsetObjs( Schema );
static int checkTypes( Schema );
static int checkEnts( Schema );
static void markDescs( Entity );
static int checkItem( Type, Scope, Schema, int *, int );
static int ENUMcanBeProcessed( Type, Schema );
static int inSchema( Scope, Scope );
/* static void addRenameTypedefs( Schema, FILE * ); */
static void addAggrTypedefs( Schema schema );
static void addUseRefNames( Schema, FILE * );
void print_schemas_separate( Express express, FILES * files )
/*
* Generates the C++ files corresponding to a list of schemas. Does so in
* multiple passes through the schemas. In each pass it checks for enti-
* ties which are subtypes of entities in other schemas which have not yet
* been processed. Such entities cannot be processed in that pass until
* their supertypes have been defined. It also checks for entities which
* have enum or select attributes which have not been processed, and for
* select types which have enum or select items (or entities containing
* enums) which have not been processed.
*/
{
int complete = FALSE, val1, val2, suffix;
DictionaryEntry de;
Schema schema;
/* First set all marks we'll be using to UNPROCESSED/NOTKNOWN: */
initializeMarks( express );
/* FIXME SdaiAll.cc:12:24: warning: unused variable ‘is’ [-Wunused-variable] (also for ui & ri) */
/* fprintf( files->create, " Interface_spec_ptr is;\n Used_item_ptr ui;\n Referenced_item_ptr ri;\n Uniqueness_rule_ptr ur;\n Where_rule_ptr wr;\n Global_rule_ptr gr;\n" ); */
while( !complete ) {
complete = TRUE;
DICTdo_type_init( express->symbol_table, &de, OBJ_SCHEMA );
while( ( schema = ( Scope )DICTdo( &de ) ) != 0 ) {
if( schema->search_id == UNPROCESSED ) {
/* i.e., if the schema has more ents/types to process in it */
unsetObjs( schema );
/* Unset the ones which had search_id = CANTPROCESS. We're
// going to check that again since things may have changed by
// this pass. The ones with search_id = PROCESSED do not
// change since we're done with them. */
schema->search_id = PROCESSED;
/* We assume this is the case unless something goes wrong. */
val1 = checkTypes( schema );
val2 = checkEnts( schema );
/* The check functions recheck all the ents, types, USEd, and
// REFs which are still NOTKNOWN to see if we can process any
// more this pass. If any returns TRUE, we'll process again
// this round. */
if( val1 || val2 ) {
if( schema->search_id == UNPROCESSED ||
*( int * )schema->clientData > 0 ) {
/* What we're trying to determine here is if we will
// need to print multiple files for this schema. If
// we're already beyond a first file (2nd condition)
// or we're at the first but there are more entities
// which couldn't be processed yet (and thus search_id
// was still set to UNPROCESSED), this schema will be
// printed in multiple files. If so, SCHEMAprint()
// will create files with the suffixes "_1", "_2", etc.
// If not, no file suffix will be added. */
suffix = ++*( int * )schema->clientData;
SCHEMAprint( schema, files, suffix );
} else {
SCHEMAprint( schema, files, 0 );
}
}
complete = complete && ( schema->search_id == PROCESSED );
/* Job's not complete so long as schema still has entities it
// had to skip. */
}
}
}
/*
DICTdo_type_init( express->symbol_table, &de, OBJ_SCHEMA );
while( ( schema = ( Scope )DICTdo( &de ) ) != 0 ) {
//fprintf( files->create,
// "\t//////////////// USE statements\n" );
//USEREFout( schema, schema->u.schema->usedict, schema->u.schema->use_schemas, "USE", files->create );
//fprintf( files->create,
// "\t//////////////// REFERENCE statements\n" );
//USEREFout( schema, schema->u.schema->refdict, schema->u.schema->ref_schemas, "REFERENCE", files->create );
}
*/
/* Before closing, we have three more situations to deal with (i.e., three
// types of declarations etc. which could only be printed at the end).
// Each is explained in the header section of its respective function. */
DICTdo_type_init( express->symbol_table, &de, OBJ_SCHEMA );
while( ( schema = ( Scope )DICTdo( &de ) ) != 0 ) {
/* (These two tasks are totally unrelated but are done in the same loop
// for efficiency.) */
addUseRefNames( schema, files->create );
}
/* Third situation: (Must be dealt with after first, see header comments
// of addAggrTypedefs.) */
DICTdo_type_init( express->symbol_table, &de, OBJ_SCHEMA );
while( ( schema = ( Scope )DICTdo( &de ) ) != 0 ) {
/* addAggrTypedefs( schema, files->classes ); */
addAggrTypedefs( schema );
}
/* On our way out, print the necessary statements to add support for
// complex entities. (The 1st line below is a part of SchemaInit(),
// which hasn't been closed yet. (That's done on 2nd line below.)) * /
//fprintf( files->initall, "\t reg.SetCompCollect( gencomplex() );\n" );
//fprintf( files->initall, "}\n\n" );
//fprintf( files->incall, "\n#include \"core/complexSupport.h\"\n" );
//fprintf( files->incall, "ComplexCollect *gencomplex();\n" ); */
/* Function GetModelContents() is printed at the end of the schema.xx
// files. This is done in a separate loop through the schemas, in function
// below. * /
//getMCPrint( express, files->incall, files->initall ); */
}
/**
* Set all schema->search_id's to UNPROCESSED, meaning we haven't processed
* all the ents and types in it yet. Also, put an int=0 in each schema's
* clientData field. We'll use it to record what # file we're generating
* for each schema. Set all entity and type search_id's to NOTKNOWN mean-
* we don't know if we can process it yet. (An ent & select type may have
* an attribute/item which comes from another schema. All other types can
* be processed the first time, but that will be caught in checkTypes().)
*/
static void initializeMarks( Express express ) {
DictionaryEntry de_sch, de_ent, de_type;
Schema schema;
DICTdo_type_init( express->symbol_table, &de_sch, OBJ_SCHEMA );
while( ( schema = ( Scope )DICTdo( &de_sch ) ) != 0 ) {
schema->search_id = UNPROCESSED;
schema->clientData = ( int * )malloc( sizeof( int ) );
*( int * )schema->clientData = 0;
SCOPEdo_entities( schema, ent, de_ent )
ent->search_id = NOTKNOWN;
SCOPEod
SCOPEdo_types( schema, t, de_type )
t->search_id = NOTKNOWN;
SCOPEod
}
}
/**
* Resets all the ents & types of schema which had been set to CANTPROCRSS
* to NOTKNOWN. This function is called every time print_schemas_separate
* iterates through the schemas, printing to file what can be printed. At
* each pass we re-examine what ents/types can be processed. Ones which
* couldn't be processed at the last pass may be processable now. Ents/
* types which have already been marked PROCESSED will not have to be
* revisited, and are not changed.
*/
static void unsetObjs( Schema schema ) {
DictionaryEntry de;
SCOPEdo_types( schema, t, de )
if( t->search_id == CANTPROCESS ) {
t->search_id = NOTKNOWN;
}
SCOPEod
SCOPEdo_entities( schema, ent, de )
if( ent->search_id == CANTPROCESS ) {
ent->search_id = NOTKNOWN;
}
SCOPEod
}
/**
* Goes through the types contained in this schema checking for ones which
* can't be processed. This may be the case if: (1) We have a select type
* which has enumeration or select items which have not yet been defined
* (are defined in a different schema we haven't processed yet). (2) We
* have a select which has an entity item which contains unprocessed enums.
* (Unproc'ed selects, however, do not pose a problem here for reasons
* beyond the scope.) (3) We have an enum type which is a redefinition of
* an enum not yet defined. If we find any such type, we set its mark to
* CANTPROCESS. If some types in schema *can* be processed now, we return
* TRUE. (See relevant header comments of checkEnts() below.)
*/
static int checkTypes( Schema schema ) {
DictionaryEntry de;
int retval = FALSE, unknowncnt;
Type i;
Entity ent;
Linked_List attribs;
do {
unknowncnt = 0;
SCOPEdo_types( schema, type, de )
if( type->search_id != NOTKNOWN ) {
continue;
}
/* We're only interested in the ones which haven't been processed
// already or accepted (set to CANPROCESS in a previous pass thru
// the do loop) already. */
type->search_id = CANPROCESS;
/* Assume this until disproven. */
if( TYPEis_enumeration( type ) && TYPEget_head( type ) ) {
i = TYPEget_ancestor( type );
if( !sameSchema( i, type ) && i->search_id != PROCESSED ) {
/* Note - if, however, i is in same schema, we're safe: We
// know it'll be processed this pass because enum's are
// always processed on the first pass. (We do have to take
// care to process the original enum before the redefined.
// This is done in SCOPEPrint, in classes_wrapper.cc.) */
type->search_id = CANTPROCESS;
schema->search_id = UNPROCESSED;
}
} else if( TYPEis_select( type ) ) {
LISTdo( SEL_TYPEget_items( type ), ii, Type ) {
if( !TYPEis_entity( ii ) ) {
if( checkItem( ii, type, schema, &unknowncnt, 0 ) ) {
break;
}
/* checkItem does most of the work of determining if
// an item of a select will make the select type un-
// processable. It checks for conditions which would
// make this true and sets values in type, schema, and
// unknowncnt accordingly. (See checkItem's commenting
// below.) It also return TRUE if ii has made type un-
// processable. If so, we break - there's no point
// checking the other items of type any more. */
} else {
/* Check if our select has an entity item which itself
// has unprocessed selects or enums. */
ent = ENT_TYPEget_entity( ii );
if( ent->search_id == PROCESSED ) {
continue;
}
/* If entity has been processed already, things must be
// okay. (Note - but if it hasn't been processed yet we
// may still be able to process type. This is because
// a sel type will only contain a pointer to an entity-
// item (and we can create a pointer to a not-yet-pro-
// cessed object), while it will contain actual objects
// for the enum and select attributes of ent.) */
attribs = ENTITYget_all_attributes( ent );
LISTdo_n( attribs, attr, Variable, b ) {
if( checkItem( attr->type, type, schema,
&unknowncnt, 1 ) ) {
break;
}
} LISTod
LISTfree( attribs );
}
} LISTod
/* One more condition - if we're a select which is a rename of
// another select - we must also make sure the original select
// is in this schema or has been processed. Since a rename-
// select is defined with typedef's to the original, we can't
// do that if the original hasn't been defined. */
if( ( type->search_id == CANPROCESS )
&& ( ( i = TYPEget_ancestor( type ) ) != NULL )
&& ( !sameSchema( i, type ) )
&& ( i->search_id != PROCESSED ) ) {
type->search_id = CANTPROCESS;
schema->search_id = UNPROCESSED;
}
}
if( type->search_id == CANPROCESS ) {
/* NOTE - This condition will be met if type isn't a select or
// enum at all and above if was never entered (and it's our
// first pass so type hasn't been processed). So for non-enums
// and selects, checkTypes() will simply check the type off and
// go on. */
retval = TRUE;
}
SCOPEod
} while( unknowncnt > 0 );
/* We loop to deal with the following situation: Say sel A contains enum B
// as an item, but A appears earlier in the EXPRESS file than B. In such a
// case, we really can process A now since it doesn't depend on anything
// which won't be processed till later. But when we first reach A, item B
// will have value NOTKNOWN, and at the time we won't know if B will be set
// to CANPROCESS when we get to it. To deal with this, checkItem() below
// increments unknowncnt for every item which is in this schema and still
// has search_id = NOTKNOWN. (Not if id = CANTPROCESS, which means we've
// tried already this pass and B still can't be processed.) Here, we keep
// looping until all the unknowns are resolved. (It may take may passes if
// selX has item selY which has item selZ.) (I take all the trouble with
// this so as not to generate mult files in unnecessary cases where e.g.
// the EXPRESS is in a single schema.) */
return retval;
}
static int checkEnts( Schema schema )
/*
* Goes through the entities contained in this schema checking for ones
* which can't be processed. It checks for two situations: (1) If we find
* an entity which is a subtype of a not-yet-processed entity in another
* schema. (2) If an entity has an attribute which is an enumeration or
* select type (which is implemented by exp2python as a C++ class), and the
* enum or select class has not yet been defined. For each entity which
* satisfies one of the above conditions, we set its mark and the marks of
* all its subtype descendents to CANTPROCESS. Later, when C++ files are
* generated for this schema, the ents marked CANTPROCESS will be skipped.
* checkEnts() will return TRUE if there are some ents/types which *can* be
* processed now. This will tell later functions that there are some pro-
* cessable entities at this pass and C++ files should be generated. (Some
* of the inline commenting of checkTypes() is applicable here and is not
* repeated.)
*/
{
DictionaryEntry de;
int retval = FALSE, ignore = 0;
/* Loop through schema's entities: */
SCOPEdo_entities( schema, ent, de )
if( ent->search_id != NOTKNOWN ) {
continue;
}
/* ent->search_id may = CANTPROCESS signifying we've already determined
// that this ent is dependent on an undefined external one. (It got
// its mark already because it was the descendent of a parent entity we
// already checked and rejected.) ent->search_id may = PROCESSED. In
// such a case there of course is also nothing to check now. */
ent->search_id = CANPROCESS;
/* First traverse ent's supertypes. If any is from a different schema
// and is not yet defined, ent will have to wait. */
LISTdo( ENTITYget_supertypes( ent ), super, Entity )
if( ( !sameSchema( ent, super ) )
&& ( super->search_id != PROCESSED ) ) {
markDescs( ent );
schema->search_id = UNPROCESSED;
break;
/* Exit the LISTdo loop. Since we found an unprocessed
// parent, we're done with this entity. */
}
LISTod
/* Next traverse ent's attributes, looking for attributes which are
// not yet defined (more explanation in checkItem()). */
if( ent->search_id == CANPROCESS ) {
/* Only do next test if ent hasn't already failed the 1st. */
LISTdo( ENTITYget_attributes( ent ), attr, Variable )
if( checkItem( attr->type, ent, schema, &ignore, 0 ) ) {
markDescs( ent );
break;
}
LISTod
}
if( ent->search_id == CANPROCESS ) {
/* If ent's mark still = CANPROCESS and not CANTPROCESS, it
// must still be processable. Set retval to TRUE signifying
// that there are ent's we'll be able to process. */
retval = TRUE;
}
SCOPEod
/* NOTE - We don't have to loop here as in checkTypes() (see long comment
// there). It was necessary there because we may have processed type
// sel1 before its member enum1. Whereas here, since all types are done
// before selects (checkTypes() is called before checkEnts()), there is
// no such concern. */
return retval;
}
static void markDescs( Entity ent )
/*
* Sets the mark value of ent and all its subtypes to CANTPROCESS. This
* function is called if we've determined that ent is a subtype of an
* entity defined in a different schema which has not yet been processed.
*/
{
ent->search_id = CANTPROCESS;
LISTdo( ENTITYget_subtypes( ent ), sub, Entity )
markDescs( sub );
LISTod
}
static int checkItem( Type t, Scope parent, Schema schema, int * unknowncnt,
int noSel )
/*
* Function with a lot of side effects: Checks if type t, a member of
* `parent' makes parent unprocessable. parent may be an entity and t is
* its attribute. parent may be a select type and t is one of its items.
* parent may be a select type and t an attribute of one of its entity
* items. Lastly, parent may be an aggregate and t its base type. t will
* make parent unprocessable if it is an enum or sel which hasn't been
* processed yet, see inline commenting. If so, parent->search_id is set
* to CANTPROCESS, and schema->search_id is set to UNPROCESSED (i.e., we're
* not done yet). Also, if one of parent's items is still NOTKNOWN (caused
* if it's in our schema and we haven't gotten to it yet - see comment, end
* of checkTypes()), parent is set to NOTKNOWN and unknowncnt is incremen-
* ted to tell us that we'll have to try parent again after its item has
* been processed (i.e., we have to repeat the do-loop in checkTypes()).
* checkItem returns TRUE if parent became unprocessable; FALSE otherwise.
*
* NOTE: noSel deals with the following: Say selA has member entX. If
* entX has attribute enumP, it creates a problem, while if entX has attr
* selB, it is not. When using checkItem for an ent member of a select,
* noSel is set to 1 to tell it to worry about t if it's an enum but not
* if it's a select.
*/
{
Type i = t;
if( isAggregateType( t ) ) {
i = TYPEget_base_type( t );
/* NOTE - If t is a 2D aggregate or higher, we do not go down to its
// lowest base type. An item which is a higher dimension aggregates
// does not make its parent unprocessable. All an e.g. entity needs
// defined to have a 2D aggr attribute is GenericAggregate (built in)
// and a typedef for a pointer to the type name, which is declared in
// Sdaiclasses.h. */
}
if( TYPEis_enumeration( i ) && !ENUMcanBeProcessed( i, schema ) ) {
/* Enum's are usually processed on the first try. ENUMcanBeProcessed()
// checks for cases of renamed enum's, which must wait for the enum i
// is a rename of. */
if( parent->search_id == NOTKNOWN ) {
/* We had thought parent's val was going to be NOTKNOWN - i.e.,
// dependent on other selects in this schema which haven't been
// processed. When we set it to NOTKNOWN we also incremented
// unknowncnt. Now we see it's not going to be unknown so we
// decrement the count: */
( *unknowncnt )--;
}
parent->search_id = CANTPROCESS;
schema->search_id = UNPROCESSED;
return TRUE;
} else if( TYPEis_select( i ) && !noSel ) {
if( !sameSchema( i, parent ) ) {
if( i->search_id != PROCESSED ) {
if( parent->search_id == NOTKNOWN ) {
( *unknowncnt )--;
}
parent->search_id = CANTPROCESS;
schema->search_id = UNPROCESSED;
return TRUE;
}
} else {
/* We have another sel in the same schema. This gets complicated -
// it may be processable but we just haven't gotten to it yet. So
// we may have to wait on parent. */
if( i->search_id == CANTPROCESS ) {
/* We *have* checked i already and it can't be processed. */
if( parent->search_id == NOTKNOWN ) {
( *unknowncnt )--;
}
parent->search_id = CANTPROCESS;
schema->search_id = UNPROCESSED;
return TRUE;
} else if( i->search_id == NOTKNOWN ) {
/* We haven't processed i this pass. */
if( parent->search_id != NOTKNOWN ) {
parent->search_id = NOTKNOWN;
/* We lower parent's value. But don't return TRUE. That
// would tell checkTypes() that there's nothing more to
// check. But checkTypes should keep looping through the re-
// maining items of parent - maybe one of them will tell us
// that parent definitely can't be processed this pass. */
( *unknowncnt )++;
}
}
}
}
return FALSE;
}
static int ENUMcanBeProcessed( Type e, Schema s )
/*
* Tells us if an enumeration type has been processed already, or if not
* will be processed this pass through schema s. As always, I take great
* pains to avoid breaking up a schema into >1 file unnecessarily. In
* cases where a user is building a library based on a single schema, we
* shouldn't cause him to suffer side-effects of the mult schema support,
* because of a case that "looks like" it may require multiple files.
*/
{
Type a;
if( !inSchema( e, s ) ) {
/* If e is not in s - the schema we're processing now - things are
// fairly simple. Nothing is going to change by the time we finish
// with this schema. Base the return val on whether or not e *was*
// processed already. */
return ( e->search_id == PROCESSED );
}
if( e->search_id != NOTKNOWN ) {
/* Next case: e is in our schema, but either it's been processed
// already, or we've determined that it can or can't be processed.
// This case is also relatively simple - we have nothing more to
// figure out here. */
return ( e->search_id >= CANPROCESS );
/* PROC/CANPROC - TRUE; UNPROC'ED/CANTPROC - FALSE */
}
/* Remaining case: e is in our schema and still = NOTKNOWN. I.e., we
// haven't gotten to e this pass and don't yet know whether it'll be
// processable. Figure that out now: */
if( ( a = TYPEget_ancestor( e ) ) == NULL ) {
/* If e is not a rename of anything, it should be processed now. */
return TRUE;
}
if( inSchema( a, s ) || a->search_id == PROCESSED ) {
/* If e's ancestor (the one it's a rename of) is in our schema it will
// be processed now. If not, it must have been processed already. */
return TRUE;
}
return FALSE;
}
int sameSchema( Scope sc1, Scope sc2 )
/*
* Checks if sc1 and sc2 are in the same superscope. Normally called for
* two types to see if they're in the same schema.
*/
{
return ( !strcmp( SCOPEget_name( sc1->superscope ),
SCOPEget_name( sc2->superscope ) ) );
}
static int inSchema( Scope scope, Scope super )
/*
* Checks if scope is contained in super's scope.
*/
{
return ( !strcmp( SCOPEget_name( scope->superscope ),
SCOPEget_name( super ) ) );
}
static void addAggrTypedefs( Schema schema )
/*
* Print typedefs at the end of Sdiaclasses.h for aggregates of enum's and
* selects. Since the underlying enum/sel may appear in any schema, this
* must be done at the end of all the schemas. Note that this function is
* called after addRenameTypedefs() since an aggregate may also be based on
* one of the renamed enum/sel's defined there.
*/
{
DictionaryEntry de;
Type i;
SCOPEdo_types( schema, t, de )
if( TYPEis_aggregate( t ) ) {
i = TYPEget_base_type( t );
if( TYPEis_enumeration( i ) || TYPEis_select( i ) ) {
/* This if will pass if t was a 1D aggregate only. They are
// the only types which had to wait for their underlying type.
// 2D aggr's and higher only need type GenericAggr defined
// which is built-in. */
printf( "in addAggrTypedefs. %s is enum or select.\n", TYPEget_name( t ) );
/* strncpy( nm, ClassName( TYPEget_name( t ) ), BUFSIZ );
//printf("%s;%s",nm,TYPEget_ctype( t ));
//if( firsttime ) {
// fprintf( classes, "The first TIME\n" );
// firsttime = FALSE;
//}
//fprintf(classes,"in addAggrTypedefs. %s is enum or select.\n",TYPEget_name(t));
//strncpy( nm, ClassName( TYPEget_name( t ) ), BUFSIZ );
//fprintf( classes, "typedef %s\t%s;\n",
// TYPEget_ctype( t ), nm );
//fprintf( classes, "typedef %s *\t%sH;\n", nm, nm );
//fprintf( classes, "typedef %s *\t%s_ptr;\n", nm, nm ); */
}
}
SCOPEod
}
static void addUseRefNames( Schema schema, FILE * create )
/*
* Checks the USE and REFERENCE dicts contained in schema. If either dict
* contains items (types or entities) which are renamed in this schema,
* code is written to add another member to the "altNames" list of the
* corresponding TypeDescriptor or EntityDescriptor object in the SCL. The
* list will be used in the SCL to use the correct name of this type or
* entity when reading and writing files.
*/
{
Dictionary useRefDict;
DictionaryEntry de;
Rename * rnm;
char * oldnm, schNm[BUFSIZ+1];
static int firsttime = TRUE;
if( ( useRefDict = schema->u.schema->usedict ) != NULL ) {
DICTdo_init( useRefDict, &de );
while( ( rnm = ( Rename * )DICTdo( &de ) ) != 0 ) {
oldnm = ( ( Scope )rnm->object )->symbol.name;
if( ( strcmp( oldnm, rnm->nnew->name ) ) ) {
/* strcmp != 0, so old and new names different.
// Note: can't just check if nnew != old. That wouldn't
// catch following: schema C USEs obj Y from schema B
// (not renamed). B USEd it from schema A and renamed it
// from X. nnew would = old, but name would not be same
// as rnm->object's name. */
if( firsttime ) {
fprintf( create, "\t// Alternate names for types and " );
fprintf( create, "entities when used in other schemas:\n" );
firsttime = FALSE;
}
if( rnm->type == OBJ_TYPE ) {
fprintf( create, "\t%s", TYPEtd_name( ( Type )rnm->object ) );
} else {
/* must be an entity */
fprintf( create, "\t%s%s%s",
SCOPEget_name( ( ( Entity )rnm->object )->superscope ),
ENT_PREFIX, ENTITYget_name( ( Entity )rnm->object ) );
}
strcpy( schNm, PrettyTmpName( SCHEMAget_name( schema ) ) );
fprintf( create, "->addAltName( \"%s\", \"%s\" );\n",
schNm, PrettyTmpName( rnm->nnew->name ) );
}
}
}
if( ( useRefDict = schema->u.schema->refdict ) != NULL ) {
DICTdo_init( useRefDict, &de );
while( ( rnm = ( Rename * )DICTdo( &de ) ) != 0 ) {
oldnm = ( ( Scope )rnm->object )->symbol.name;
if( ( strcmp( oldnm, rnm->nnew->name ) ) ) {
if( firsttime ) {
fprintf( create, "\t// Alternate names for types and " );
fprintf( create, "entities when used in other schemas:\n" );
firsttime = FALSE;
}
if( rnm->type == OBJ_TYPE ) {
fprintf( create, "\t%s", TYPEtd_name( ( Type )rnm->object ) );
} else {
fprintf( create, "\t%s%s%s",
SCOPEget_name( ( ( Entity )rnm->object )->superscope ),
ENT_PREFIX, ENTITYget_name( ( Entity )rnm->object ) );
}
strcpy( schNm, PrettyTmpName( SCHEMAget_name( schema ) ) );
fprintf( create, "->addAltName( \"%s\", \"%s\" );\n",
schNm, PrettyTmpName( rnm->nnew->name ) );
}
}
}
}