/** *****************************************************************

** \file selects.c

** FedEx parser output module for generating C++ class definitions

** December 5, 1989

** release 2 17-Feb-1992

** release 3 March 1993

** release 4 December 1993

** K. C. Morris

**

** Development of FedEx was funded by the United States Government,

** and is not subject to copyright.

*******************************************************************

The conventions used in this binding follow the proposed specification

for the STEP Standard Data Access Interface as defined in document

N350 ( August 31, 1993 ) of ISO 10303 TC184/SC4/WG7.

*******************************************************************/

extern int multiple_inheritance;

/**************************************************************************

******** The functions in this file generate C++ code for representing

******** EXPRESS SELECT types.

**************************************************************************/

#include <sc_memmgr.h>

#include <stdlib.h>

#include "classes.h"

#include <sc_trace_fprintf.h>

int isAggregateType( const Type t );

char * generate_attribute_name( Variable a, char * out );

void ATTRsign_access_methods( Variable a, FILE * file );

char * generate_attribute_func_name( Variable a, char * out );

void ATTRprint_access_methods_get_head( const char * classnm, Variable a, FILE * file );

void ATTRprint_access_methods_put_head( const char * entnm, Variable a, FILE * file );

#define BASE_SELECT "SDAI_Select"

#define TYPEis_primitive(t) ( !( TYPEis_entity(t) || \

TYPEis_select (t) || \

TYPEis_aggregate(t) ) )

#define TYPEis_numeric(t) ( ((t)->u.type->body->type == real_) || \

((t)->u.type->body->type == integer_) || \

((t)->u.type->body->type == number_) )

#define PRINT_BUG_REPORT \

fprintf( f, " std::cerr << __FILE__ << \":\" << __LINE__ << \": ERROR" \

" in schema library: \\n\" \n << _POC_ << \"\\n\\n\";\n");

#define PRINT_SELECTBUG_WARNING(f) \

fprintf( (f), "\n severity( SEVERITY_WARNING );\n" ); \

fprintf( (f), " std::cerr << __FILE__ << \":\" << __LINE__ << \": "); \

fprintf( (f), "WARNING: possible misuse of\"\n << \" SELECT "); \

fprintf( (f), "TYPE from schema library.\\n\";\n"); \

fprintf( (f), " Error( \"Mismatch in underlying type.\" );\n" );

#define print_error_msg() \

fprintf( f, "\n severity( SEVERITY_BUG );\n" ); \

PRINT_BUG_REPORT \

fprintf( f, " Error( \"This 'argument' is of the incorrect type\" );\n" );

#define TRUE 1

#define FALSE 0

static void initSelItems( const Type, FILE * );

const char *

SEL_ITEMget_enumtype( Type t ) {

return StrToUpper( TYPEget_name( t ) );

}

/******************************************************************

** Procedure: TYPEget_utype

** Parameters: Type t

** Returns: type used to represent the underlying type in a select class

** Description:

** Side Effects:

** Status:

******************************************************************/

const char *

TYPEget_utype( Type t ) {

return ( TYPEis_entity( t ) ? "SDAI_Application_instance_ptr" : TYPEget_ctype( t ) );

}

/*******************

LISTmember

determines if the given entity is a member of the list.

RETURNS the member if it is a member; otherwise 0 is returned.

*******************/

Generic

LISTmember( const Linked_List list, Generic e ) {

Link node;

for( node = list->mark->next; node != list->mark; node = node->next )

if( e == node -> data ) {

return e;

}

return ( 0 );

}

/*******************

compareOrigTypes

Specialized function to catch if two enumerations, two selects, or two aggrs

of either, are of the same type. The issue is that e.g. select B may be a

rename of sel A (i.e., TYPE B = A;). Such renamed types are implemented by

exp2cxx with typedefs, so that they are in fact the same type. TYPEget_-

ctype() is used for most type comparisons and does not consider renamed types

equivalent. This function is called in instances when they should be consi-

dered equivalent. One such case is the generation of duplicate lists.

*******************/

static int

compareOrigTypes( Type a, Type b ) {

Type t, u;

if( ( TYPEis_select( a ) && TYPEis_select( b ) )

|| ( TYPEis_enumeration( a ) && TYPEis_enumeration( b ) ) ) {

t = a;

u = b;

} else if( TYPEis_aggregate( a ) && TYPEis_aggregate( b ) ) {

t = TYPEget_base_type( a );

u = TYPEget_base_type( b );

if( !( ( TYPEis_select( t ) && TYPEis_select( u ) )

|| ( TYPEis_enumeration( t ) && TYPEis_enumeration( u ) ) ) ) {

return FALSE;

/* Only go further with 1D aggregates of sels or enums. Note that

for 2D aggrs and higher we do not continue. These are all recog-

nized to be the same type ("GenericAggregate") by TYPEget_ctype(),

and do not have to be handled specially here. */

}

} else {

return FALSE;

}

if( TYPEget_head( t ) ) {

t = TYPEget_ancestor( t );

}

if( TYPEget_head( u ) ) {

u = TYPEget_ancestor( u );

}

return ( !strcmp( TYPEget_name( t ), TYPEget_name( u ) ) );

}

/*******************

utype_member

determines if the given "link's" underlying type is a member of the list.

RETURNS the underlying type if it is a member; otherwise 0 is returned.

If "rename" is TRUE, we also consider check to match in certain cases where

list already has an item that check is a renaming of (see header comments to

compareOrigTypes() above).

*******************/

const char *

utype_member( const Linked_List list, const Type check, int rename ) {

static char r [BUFSIZ];

bool checkIsEntity = TYPEis_entity( check );

LISTdo( list, t, Type ) {

if( TYPEis_entity( t ) && checkIsEntity ) {

return "SDAI_Application_instance_ptr";

}

/* string returned by TYPEget_utype isn't necessarily static so we

* need to copy between calls

* */

strncpy( r, TYPEget_ctype( t ), BUFSIZ );

if( strcmp( r, TYPEget_ctype( check ) ) == 0 || ( rename && compareOrigTypes( check, t ) ) ) {

return r;

}

}

LISTod;

return 0;

}

/**

*** SELgetnew_dmlist (const Type type)

*** Returns a list of types which have unique underlying types

*** The returned list includes all the types which have a data members

*** in the select type.

***

*** The list that is returned needs to be freed by the caller.

***/

Linked_List

SELgetnew_dmlist( const Type type ) {

Linked_List complete = SEL_TYPEget_items( type );

Linked_List newlist = LISTcreate();

LISTdo( complete, t, Type )

/* if t\'s underlying type is not already in newlist, */

if( ! utype_member( newlist, t, 0 ) ) {

LISTadd_last( newlist, ( Generic ) t );

}

LISTod;

return newlist;

}

const char *

SEL_ITEMget_dmtype( Type t, const Linked_List l ) {

const char * r = utype_member( l, t, 0 );

return StrToLower( r ? r : TYPEget_utype( t ) );

}

/**

*** SEL_ITEMget_dmname (Type t)

*** Returns the name of the data member in the select class for the item of

*** the select having the type t.

*** Logical and boolean are handled as exceptions because TYPEget_utype()

*** returns "PSDAI::..." for them which is not a legal variable name.

***/

const char *

SEL_ITEMget_dmname( Type t ) {

Class_Of_Type class = TYPEget_type( t );

if( class == integer_ ) {

return "integer";

}

if( class == real_ ) {

return "real";

}

if( class == number_ ) {

return "real";

}

if( class == string_ ) {

return "string";

}

if( class == binary_ ) {

return "binary";

}

if( class == logical_ ) {

return "logical";

}

if( class == boolean_ ) {

return "boolean";

}

if( class == entity_ ) {

return "app_inst";

}

return ( StrToLower( TYPEget_utype( t ) ) );

}

/*******************

duplicate_in_express_list

determines if the given "link's" underlying type is a multiple member

of the list.

RETURNS 1 if true, else 0.

*******************/

int

duplicate_in_express_list( const Linked_List list, const Type check ) {

if( TYPEis_entity( check ) ) {

return FALSE;

}

/* entities are never the same */

LISTdo( list, t, Type )

if( t == check ) {

; /* don't compare check to itself */

} else {

return TRUE; /* other things in the list conflict */

}

LISTod;

return FALSE;

}

/*******************

unique_types ( const Linked_List list )

determines if any of the types in a select type resolve to the same

underlying Express type.

RETURNS 1 if true, else 0.

*******************/

int

unique_types( const Linked_List list ) {

LISTdo( list, t, Type )

if( duplicate_in_express_list( list, t ) ) {

return FALSE;

}

LISTod;

return TRUE;

}

/*******************

duplicate_utype_member

determines if the given "link's" C++ representation is used again in the list.

RETURNS 1 if true, else 0.

*******************/

int

duplicate_utype_member( const Linked_List list, const Type check ) {

char b [BUFSIZ];

if( TYPEis_entity( check ) ) {

return FALSE;

}

/* entities are never the same */

LISTdo( list, t, Type )

if( t == check ) {

;

}

/* don't compare check to itself */

else { /* continue looking */

strncpy( b, TYPEget_utype( t ), BUFSIZ );

if( ( !strcmp( b, TYPEget_utype( check ) ) )

|| ( compareOrigTypes( t, check ) ) )

/* if the underlying types are the same */

{

return TRUE;

}

if( ! strcmp( b, "SDAI_Integer" ) &&

( ! strcmp( TYPEget_utype( check ), "SDAI_Real" ) ) )

/* integer\'s and real\'s are not unique */

{

return TRUE;

}

}

LISTod;

return FALSE;

}

/*******************

any_duplicates_in_select

determines if any of the types in a select type resolve to the same

C++ representation for the underlying Express type.

RETURNS 1 if true, else 0.

*******************/

int

any_duplicates_in_select( const Linked_List list ) {

LISTdo( list, t, Type )

if( duplicate_utype_member( list, t ) ) {

return TRUE;

}

LISTod;

return FALSE;

}

/*******************

find_duplicate_list

finds an instance of each kind of duplicate type found in the given list.

This list is returned as dup_list. If a duplicate exists, the function

returns TRUE, else FALSE.

list should be unbound before calling, and freed afterwards.

*******************/

int

find_duplicate_list( const Type type, Linked_List * duplicate_list ) {

Linked_List temp; /** temporary list for comparison **/

*duplicate_list = LISTcreate();

if( any_duplicates_in_select( SEL_TYPEget_items( type ) ) ) {

/** if there is a dup somewhere **/

temp = LISTcreate();

LISTdo( SEL_TYPEget_items( type ), u, Type )

if( !utype_member( *duplicate_list, u, 1 ) ) {

/** if not already a duplicate **/

if( utype_member( temp, u, 1 ) ) {

LISTadd_first( *duplicate_list, ( Generic ) u );

} else {

LISTadd_first( temp, ( Generic ) u );

}

}

LISTod;

LISTfree( temp );

return TRUE;

}

return FALSE;

}

/*******************

non_unique_types_string ( const Type type )

returns a string containing the non-unique EXPRESS types deriveable

from a select. the returned string is in the form (TYPE | TYPE |...)

*******************/

/* In the functions below, we use a vector of ints to count paths in the

select-graph to base types. The names in this enum correspond to the

indices in the vector, i.e., tvec[treal] == tvec[1], and contains the

number of paths to REAL in the graph

*/

enum __types {

tint = 0, /* INTEGER */

treal, /* REAL */

tstring, /* STRING */

tbinary, /* BINARY */

tenum, /* ENUMERATION, also LOGICAL, BOOLEAN */

tselect, /* SELECT */

tentity, /* ENTITY */

taggr, /* AGGREGATE, also ARRAY, BAG, SET, LIST */

tnumber /* NUMBER */

};

/* This function gets called recursively, to follow a select-graph to its

leaves. It passes around the vector described above, to track paths to

the leaf nodes.

*/

void

non_unique_types_vector( const Type type, int * tvec ) {

LISTdo( SEL_TYPEget_items( type ), t, Type )

switch( TYPEget_body( t )->type ) {

case integer_:

tvec[tint]++;

break;

case real_:

tvec[treal]++;

break;

case string_:

tvec[tstring]++;

break;

case binary_:

tvec[tbinary]++;

break;

case enumeration_:

case logical_:

case boolean_:

tvec[tenum]++;

break;

case select_:

/* SELECT, ergo recurse! */

non_unique_types_vector( t, tvec );

break;

case entity_:

tvec[tentity]++;

break;

case aggregate_:

case array_:

case list_:

case bag_:

case set_:

tvec[taggr]++;

break;

case number_:

tvec[tnumber]++;

break;

default:

fprintf( stderr, "non_unique_types_vector: can't handle unknow type %d\n",

TYPEget_body( t )->type );

abort();

}

LISTod;

}

/* Uses non_unique_types_vector on the select to get a vector of base-type

reference counts, then uses that to make a string of types, of the form

(FOO_TYPE | BAR_TYPE | BAZ_TYPE), where FOO, BAR, and BAZ are EXPRESS

types. If all types are unique, the string (0) is generated.

*/

char *

non_unique_types_string( const Type type ) {

int tvec[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};

char * typestr;

int first = 1;

int i;

non_unique_types_vector( type, tvec );

/* build type string from vector */

typestr = ( char * )sc_malloc( BUFSIZ );

typestr[0] = '\0';

strcat( typestr, ( char * )"(" );

for( i = 0; i <= tnumber; i++ ) {

if( tvec[i] < 2 ) {

continue; /* skip, this one is unique */

}

if( !first ) {

strcat( typestr, ( char * )" | " );

} else {

first = 0;

}

switch( i ) {

case tint :

strcat( typestr, ( char * )"sdaiINTEGER" );

break;

case treal :

strcat( typestr, ( char * )"sdaiREAL" );

break;

case tstring:

strcat( typestr, ( char * )"sdaiSTRING" );

break;

case tbinary:

strcat( typestr, ( char * )"sdaiBINARY" );

break;

case tenum :

strcat( typestr, ( char * )"sdaiENUMERATION" );

break;

case tentity:

strcat( typestr, ( char * )"sdaiINSTANCE" );

break;

case taggr :

strcat( typestr, ( char * )"sdaiAGGR" );

break;

case tnumber:

strcat( typestr, ( char * )"sdaiNUMBER" );

break;

}

}

if( first ) {

strcat( typestr, ( char * )"0" );

}

strcat( typestr, ( char * )")" );

return typestr;

}

/******************************************************************

** Procedure: ATTR_LISTmember

** Parameters: Linked_List l, Variable check

** Returns: the attribute if an attribute with the same name as "check"

** is on the list, 0 otherwise

** Description: checks to see if an attribute is a member of the list

** Side Effects:

** Status: 26-Oct-1993 done

******************************************************************/

Variable

ATTR_LISTmember( Linked_List l, Variable check ) {

char nm [BUFSIZ];

char cur [BUFSIZ];

generate_attribute_name( check, nm );

LISTdo( l, a, Variable )

generate_attribute_name( a, cur );

if( ! strcmp( nm, cur ) ) {

return check;

}

LISTod;

return ( 0 );

}

/******************************************************************

** Procedure: SEL_TYPEgetnew_attribute_list

** Parameters: const Type type

** Returns: Returns a list of all the attributes for a select type.

** The list is the union of all the attributes of the underlying types.

** Description:

** Side Effects:

*** The list that is returned needs to be freed by the caller.

** Status:

******************************************************************/

Linked_List

SEL_TYPEgetnew_attribute_list( const Type type ) {

Linked_List complete = SEL_TYPEget_items( type );

Linked_List newlist = LISTcreate();

Linked_List attrs;

Entity cur;

LISTdo( complete, t, Type ) {

if( TYPEis_entity( t ) ) {

cur = ENT_TYPEget_entity( t );

attrs = ENTITYget_all_attributes( cur );

LISTdo_n( attrs, a, Variable, b ) {

if( ! ATTR_LISTmember( newlist, a ) ) {

LISTadd_first( newlist, ( Generic ) a );

}

} LISTod

}

} LISTod

return newlist;

}

/** prints the class 'definition', that is, the objects

* and the constructor(s)/destructor for a select class.

*/

void TYPEselect_inc_print_vars( const Type type, FILE * f, Linked_List dups ) {

int size, j;

Linked_List data_members = SELgetnew_dmlist( type );

char dmname [BUFSIZ],

classnm [BUFSIZ],

tdnm [BUFSIZ];

strncpy( classnm, SelectName( TYPEget_name( type ) ), BUFSIZ );

classnm[BUFSIZ-1] = '\0';

strncpy( tdnm, TYPEtd_name( type ), BUFSIZ );

tdnm[BUFSIZ-1] = '\0';

size = strlen( classnm ) + 2; /* for formatting output */

fprintf( f, "\n////////// SELECT TYPE %s\n", SelectName( TYPEget_name( type ) ) );

fprintf( f, "class %s : public " BASE_SELECT " {\n", classnm );

fprintf( f, " protected:\n" );

fprintf( f, " // types in SELECT \n" );

LISTdo( SEL_TYPEget_items( type ), t, Type ) {

fprintf( f, " // %s -- %s\n", SEL_ITEMget_enumtype( t ), FundamentalType( t, 0 ) );

}

LISTod;

LISTdo( data_members, t, Type ) {

strncpy( dmname, SEL_ITEMget_dmname( t ), BUFSIZ );

fprintf( f, " %s%s _%s;\n", TYPEget_utype( t ), TYPEis_aggregate( t ) ? "_ptr" : "", dmname );

}

LISTod;

fprintf( f, "\n public:\n" );

fprintf( f,

" virtual const TypeDescriptor * AssignEntity (SDAI_Application_instance * se);\n"

" virtual SDAI_Select * NewSelect ();\n"

);

fprintf( f, "\n virtual BASE_TYPE ValueType() const;\n" );

fprintf( f, "\n\n// STEP Part 21\n" );

fprintf( f, " virtual void STEPwrite_content (ostream& out =std::cout,\n"

" const char *currSch =0) const;\n" );

fprintf( f, " virtual void STEPwrite_verbose (ostream& out =std::cout,\n"

" const char *currSch =0) const;\n" );

fprintf( f, " virtual Severity STEPread_content (istream& in =cin,\n"

" InstMgr * instances =0, const char *utype =0,\n"

" int addFileId =0, const char *currSch =0);\n" );

/* read StrToVal_content */

fprintf( f, " virtual Severity StrToVal_content "

"(const char *,\n InstMgr * instances =0);\n" );

/* constructor(s) */

fprintf( f, "\n// STEP Part 22: SDAI\n" );

fprintf( f, "\n// constructors\n" );

fprintf( f, " %s( const SelectTypeDescriptor * =%s );\n",

classnm, tdnm );

fprintf( f, " // part 1\n" );

LISTdo( SEL_TYPEget_items( type ), t, Type )

if( ( TYPEis_entity( t ) )

|| ( !utype_member( dups, t, 1 ) ) ) {

/** if an entity or not in the dup list **/

fprintf( f, " %s( const %s&,\n ",

SelectName( TYPEget_name( type ) ), AccessType( t ) );

for( j = 0; j < size; j++ ) {

fprintf( f, " " );

}

fprintf( f, "const SelectTypeDescriptor * =%s );\n", tdnm );

}

LISTod;

LISTdo( dups, t, Type )

if( ! TYPEis_entity( t ) ) { /* entities were done already */

fprintf( f, " %s( const %s&,\n ",

SelectName( TYPEget_name( type ) ),

isAggregateType( t ) ? AccessType( t ) : TYPEget_utype( t ) );

for( j = 0; j < size; j++ ) {

fprintf( f, " " );

}

fprintf( f, "const SelectTypeDescriptor * =%s );\n", tdnm );

}

LISTod;

/* destructor */

fprintf( f, " virtual ~%s();\n", classnm );

LISTfree( data_members );

}

/*******************

TYPEselect_inc_print prints the class member function declarations of a select

class.

*******************/

void

TYPEselect_inc_print( const Type type, FILE * f ) {

char n[BUFSIZ]; /* class name */

char tdnm [BUFSIZ]; /* TypeDescriptor name */

Linked_List dups;

int dup_result;

Linked_List attrs;

dup_result = find_duplicate_list( type, &dups );

strncpy( n, SelectName( TYPEget_name( type ) ), BUFSIZ );

strncpy( tdnm, TYPEtd_name( type ), BUFSIZ );

TYPEselect_inc_print_vars( type, f, dups );

fprintf( f, "\n // part 2\n" );

LISTdo( SEL_TYPEget_items( type ), t, Type )

if( ( TYPEis_entity( t ) )

|| ( !utype_member( dups, t, 1 ) ) ) {

/** if an entity or not in the dup list **/

fprintf( f, " operator %s();\n", AccessType( t ) );

}

LISTod;

LISTdo( dups, t, Type )

/* do the dups once only */

if( ! TYPEis_entity( t ) ) /* entities were done already */

fprintf( f, " operator %s ();\n",

( TYPEis_aggregate( t ) || TYPEis_select( t ) ) ?

AccessType( t ) : TYPEget_utype( t ) );

LISTod;

fprintf( f, "\n // part 3\n" );

attrs = SEL_TYPEgetnew_attribute_list( type );

/* get the list of unique attributes from the entity items */

LISTdo( attrs, a, Variable )

if( VARget_initializer( a ) == EXPRESSION_NULL ) {

ATTRsign_access_methods( a, f );

}

LISTod;

LISTfree( attrs );

fprintf( f, "\n // part 4\n" );

LISTdo( SEL_TYPEget_items( type ), t, Type )

if( ( TYPEis_entity( t ) )

|| ( !utype_member( dups, t, 1 ) ) ) {

/** if an entity or not in the dup list **/

fprintf( f, " %s& operator =( const %s& );\n",

SelectName( TYPEget_name( type ) ), AccessType( t ) );

}

LISTod;

LISTdo( dups, t, Type )

if( ! TYPEis_entity( t ) ) { /* entities were done already */

fprintf( f, " %s& operator =( const %s& );\n",

SelectName( TYPEget_name( type ) ),

isAggregateType( t ) ? AccessType( t ) : TYPEget_utype( t ) );

}

LISTod;

fprintf( f, " // not in SDAI\n"

" %s& ShallowCopy ( const %s& );\n",

n, n );

fprintf( f, "\n#ifdef COMPILER_DEFINES_OPERATOR_EQ\n#else\n" );

fprintf( f, " %s& operator =( %s * const & );\n", n, n );

fprintf( f, " SDAI_Select& operator =( const SDAI_Select& );\n" );

fprintf( f, "#endif\n" );

fprintf( f, "\n // part 5\n" );

LISTdo( SEL_TYPEget_items( type ), t, Type )

fprintf( f, " Logical Is%s() const;\n",

FirstToUpper( TYPEget_name( t ) ) );

LISTod;

fprintf( f, "\n // part 6 ... UnderlyingTypeName () implemented in"

" SDAI_Select class ...\n" );

if( dup_result ) {

/** if there are duplicate underlying types **/

fprintf( f, "\n // part 7\n" );

fprintf( f, " const TypeDescriptor *"

"SetUnderlyingType ( const TypeDescriptor * td );\n" );

} else {

fprintf( f, "\n // part 7 ... NONE only for complex selects...\n" );

}

#ifdef PART8

fprintf( f, "\n // part 8\n" );

fprintf( f, " %s* operator->();\n", n );

#endif

fprintf( f, "};\n" );

fprintf( f, "\ninline SDAI_Select * create_%s () { return new %s; }\n", n, n );

/* DAR - moved from SCOPEPrint() */

fprintf( f, "typedef %s * %sH;\n", n, n );

fprintf( f, "typedef %s_ptr %s_var;\n\n", n, n );

/* print things for aggregate class */

fprintf( f, "\nclass %s_agg : public SelectAggregate {\n", n );

fprintf( f, " protected:\n" );

fprintf( f, " SelectTypeDescriptor *sel_type;\n\n" );

fprintf( f, " public:\n" );

fprintf( f, " %s_agg( SelectTypeDescriptor * =%s );\n", n, tdnm );

fprintf( f, " ~%s_agg();\n", n );

fprintf( f, " virtual SingleLinkNode * NewNode()\n" );

fprintf( f, " { return new SelectNode (new %s( sel_type )); }\n", n );

fprintf( f, "};\n" );

/* DAS creation function for select aggregate class */

fprintf( f, "inline STEPaggregate * create_%s_agg () { return new %s_agg; }\n",

n, n );

fprintf( f, "typedef %s_agg_ptr %s_agg_var;\n", n, n );

fprintf( f, "\n///// END SELECT TYPE %s\n\n", TYPEget_name( type ) );

LISTfree( dups );

}

/*******************

TYPEselect_lib_print_part_one prints constructor(s)/destructor of a select

class.

*******************/

void TYPEselect_lib_print_part_one( const Type type, FILE * f,

Linked_List dups, char * n ) {

#define schema_name SCHEMAget_name(schema)

char tdnm[BUFSIZ],

nm[BUFSIZ];

int size = strlen( n ) * 2 + 4, j; /* size - for formatting output */

strncpy( tdnm, TYPEtd_name( type ), BUFSIZ );

strncpy( nm, SelectName( TYPEget_name( type ) ), BUFSIZ );

/* constructor(s) */

/* null constructor */

fprintf( f, "\n// STEP Part 22: SDAI\n" );

fprintf( f, "\n // part 0\n" );

fprintf( f, "%s::%s( const SelectTypeDescriptor *typedescript )\n", n, n );

fprintf( f, " : " BASE_SELECT " (typedescript)" );

/* Initialize the select members with their correct typedescriptors: */

initSelItems( type, f );

fprintf( f, "\n{\n" );

fprintf( f, "#ifdef SC_LOGGING\n if( *logStream )\n {\n" );

fprintf( f, " *logStream << \"DAVE ERR entering %s constructor.\" << std::endl;\n", n );

fprintf( f, " }\n#endif\n" );

/* create objects for data member pointers. also in two more ctors below, and deleted in dtor which is printed at end of this function. */

LISTdo( dups, t, Type ) {

if( isAggregateType( t ) && t->u.type->body->base ) {

fprintf( f, " _%s = new %s;\n", SEL_ITEMget_dmname( t ), TYPEget_utype( t ) );

}

}

LISTod;

fprintf( f, " nullify();\n" );

fprintf( f, "#ifdef SC_LOGGING\n if( *logStream )\n {\n" );

fprintf( f, "// *logStream << \"DAVE ERR exiting %s constructor.\" << std::endl;\n", n );

fprintf( f, " }\n#endif\n" );

fprintf( f, "}\n" );

/* constructors with underlying types */

fprintf( f, "\n // part 1\n" );

LISTdo( SEL_TYPEget_items( type ), t, Type )

if( ( TYPEis_entity( t ) )

|| ( !utype_member( dups, t, 1 ) ) ) {

/* if there is not more than one underlying type that maps to the same

* base type print out the constructor using the type from the TYPE

* statement as the underlying type. Also skip enums/sels which are

* renames of other items. That would create redundant constructors

* since renames are typedef'ed to the original type.

*/

fprintf( f, "%s::%s( const %s& o,\n", n, n, AccessType( t ) );

for( j = 0; j < size; j++ ) {

fprintf( f, " " );

}

/* Did this for the heck of it, and to show how easy it would have

been to make it all pretty - DAR. ;-) */

fprintf( f, "const SelectTypeDescriptor *typedescript )\n" );

fprintf( f, " : " BASE_SELECT " (typedescript, %s)",

TYPEtd_name( t ) );

initSelItems( type, f );

fprintf( f, "\n{\n" );

fprintf( f, "#ifdef SC_LOGGING\n if( *logStream )\n {\n" );

fprintf( f,

" *logStream << \"DAVE ERR entering %s constructor.\""

" << std::endl;\n", n );

fprintf( f, " }\n#endif\n" );

if( isAggregateType( t ) ) {

if( t->u.type->body->base ) {

fprintf( f, " _%s = new %s;\n", SEL_ITEMget_dmname( t ), TYPEget_utype( t ) );

}

fprintf( f, " _%s%sShallowCopy (*o);\n", SEL_ITEMget_dmname( t ),

( ( t->u.type->body->base ) ? "->" : "." ) );

} else {

fprintf( f, " _%s = o;\n", SEL_ITEMget_dmname( t ) );

}

fprintf( f, "#ifdef SC_LOGGING\n if( *logStream )\n {\n" );

fprintf( f,

"// *logStream << \"DAVE ERR exiting %s constructor.\""

" << std::endl;\n", n );

fprintf( f, " }\n#endif\n" );

fprintf( f, "}\n\n" );

}

LISTod;

LISTdo( dups, t, Type )

/* if there is more than one underlying type that maps to the

* same base type, print a constructor using the base type.

*/

if( ! TYPEis_entity( t ) ) { /* entities were done already */

if( isAggregateType( t ) ) {

fprintf( f, "%s::%s( const %s& o,\n", n, n, AccessType( t ) );

for( j = 0; j < size; j++ ) {

fprintf( f, " " );

}

fprintf( f, "const SelectTypeDescriptor *typedescript )\n" );

fprintf( f, " : " BASE_SELECT " ( typedescript, %s )",

TYPEtd_name( t ) );

initSelItems( type, f );

fprintf( f, "\n{\n" );

fprintf( f, "#ifdef SC_LOGGING\n if( *logStream )\n {\n" );

fprintf( f,

" *logStream << \"DAVE ERR entering %s constructor.\""

" << std::endl;\n", n );

fprintf( f, " }\n#endif\n" );

if( t->u.type->body->base ) {

fprintf( f, " _%s = new %s;\n", SEL_ITEMget_dmname( t ), TYPEget_utype( t ) );

}

fprintf( f, " _%s%sShallowCopy (*o);\n", SEL_ITEMget_dmname( t ), ( ( t->u.type->body->base ) ? "->" : "." ) );

} else {

fprintf( f, "%s::%s( const %s& o,\n", n, n, TYPEget_utype( t ) );

for( j = 0; j < size; j++ ) {

fprintf( f, " " );

}

fprintf( f, "const SelectTypeDescriptor *typedescript )\n" );

fprintf( f, " : " BASE_SELECT " ( typedescript, %s )",

TYPEtd_name( t ) );

initSelItems( type, f );

fprintf( f, "\n{\n" );

fprintf( f, " _%s = o;\n", SEL_ITEMget_dmname( t ) );

}

fprintf( f,

"// NOTE: Underlying type defaults to %s instead of NULL\n",

TYPEtd_name( t ) );

fprintf( f, "#ifdef SC_LOGGING\n if( *logStream )\n {\n" );

fprintf( f,

"// *logStream << \"DAVE ERR exiting %s constructor.\""

" << std::endl;\n", n );

fprintf( f, " }\n#endif\n" );

fprintf( f, "}\n\n" );

}

LISTod;

/* dtor */

fprintf( f, "%s::~%s()\n{\n", n, n );

/* delete objects that data members point to */

LISTdo( dups, t, Type ) {

if( isAggregateType( t ) && t->u.type->body->base ) {

fprintf( f, " if( _%s ) {\n", SEL_ITEMget_dmname( t ) );

fprintf( f, " delete _%s;\n", SEL_ITEMget_dmname( t ) );

fprintf( f, " _%s = 0;\n }\n", SEL_ITEMget_dmname( t ) );

}

}

LISTod;

fprintf( f, "}\n\n" );

fprintf( f, "%s_agg::%s_agg( SelectTypeDescriptor *s)\n"

" : SelectAggregate(), sel_type(s)\n{\n}\n\n", n, n );

fprintf( f, "%s_agg::~%s_agg() { }\n\n", n, n );

#undef schema_name

}

static void

initSelItems( const Type type, FILE * f )

/*

* Creates initialization functions for the select items of a select. The

* selects must have their typedescriptors set properly. If a select is a

* renaming of another select ("TYPE selB = selA") its td would default to

* selA's, so it must be set specifically.

*/

{

Linked_List data_members = SELgetnew_dmlist( type );

LISTdo( data_members, t, Type )

if( TYPEis_select( t ) ) {

fprintf( f, ",\n _%s (%s)", SEL_ITEMget_dmname( t ),

TYPEtd_name( t ) );

}

LISTod;

}

Linked_List

ENTITYget_expanded_entities( Entity e, Linked_List l ) {

Linked_List supers;

Entity super;

if( ! LISTmember( l, ( Generic ) e ) ) {

LISTadd_first( l, ( Generic ) e );

}

if( multiple_inheritance ) {

int super_cnt = 0;

supers = ENTITYget_supertypes( e );

LISTdo( supers, s, Entity )

/* ignore the more than one supertype

since multiple inheritance isn\'t implemented */

if( super_cnt == 0 ) {

ENTITYget_expanded_entities( s, l );

}

++ super_cnt;

LISTod;

} else {

/* ignore the more than one supertype

since multiple inheritance isn\'t implemented */

super = ENTITYget_superclass( e );

ENTITYget_expanded_entities( super, l );

}

return l;

}

Linked_List

SELget_entity_itemlist( const Type type ) {

Linked_List complete = SEL_TYPEget_items( type );

Linked_List newlist = LISTcreate();

Entity cur;