static void init( // INITIALIZATION FOR MODULE
INITFINI* defn ) // - definition
{
defn = defn;
VstkOpen( &stack_switches, sizeof( SW_CTL ), 4 );
VstkOpen( &stack_labs_sw, sizeof( label_handle ), 32 );
}
static void init( // INITIALIZATION FOR MODULE
INITFINI* defn ) // - definition
{
defn = defn;
VstkOpen( &stack_inline_args, sizeof( struct symbol ), 16 );
VstkOpen( &stack_symbol_name, sizeof( struct symbol_name ), 16 );
}
static void symTransInit( // INITIALIZE CGBKSTRN
INITFINI* defn ) // - definition
{
defn = defn;
sym_trans_id = 0;
VstkOpen( &stack_sym_trans, sizeof( SYM_TRANS ), 16 );
}
static void brinfMacInit // INITALIZATION
( INITFINI* defn ) // - definition
{
defn = defn;
values = NULL;
carveMacVals = CarveCreate( sizeof( MACVALUE ), 1024 );
VstkOpen( &undefs, sizeof( MACUNDEF ), 32 );
}
static void callStackInit( // INITIALIZE CGBKCSTK
INITFINI* defn ) // - definition
{
defn = defn;
ind_call_stack = NULL;
ind_call_free = NULL;
VstkOpen( &stack_calls, sizeof( CALL_STK ), 4 );
}
void CgDeclParms( // DEFINE ARGS FOR CURRENT FN IN CORRECT ORDER
FN_CTL *fctl, // - current function control pointer
SCOPE scope ) // - argument scope
{
SYMBOL curr;
SYMBOL stop;
SYMBOL *psym; // - addr[ parameter symbol ]
TYPE fn_type;
auto VSTK_CTL sym_stack;
SYMBOL ret_sym;
NAME ret_name;
fn_type = FunctionDeclarationType( fctl->func->sym_type );
VstkOpen( &sym_stack, sizeof( SYMBOL ), 16 );
stop = ScopeOrderedStart( scope );
ret_name = CppSpecialName( SPECIAL_RETURN_VALUE );
ret_sym = NULL;
curr = NULL;
for(;;) {
curr = ScopeOrderedNext( stop, curr );
if( curr == NULL ) break;
if( ( curr->name != NULL ) && ( ret_name == curr->name->name ) ) {
ret_sym = curr;
} else {
psym = VstkPush( &sym_stack );
*psym = curr;
}
}
IbpDefineParms();
declareParameter( fctl->this_sym );
declareParameter( fctl->cdtor_sym );
declareParameter( ret_sym );
switch( PcCallImpl( fn_type ) ) {
case CALL_IMPL_REV_CPP :
case CALL_IMPL_REV_C :
for(;;) {
psym = VstkPop( &sym_stack );
if( psym == NULL ) break;
declareParameter( *psym );
}
break;
case CALL_IMPL_CPP :
case CALL_IMPL_C :
case CALL_IMPL_ELL_CPP :
case CALL_IMPL_ELL_C :
{ unsigned index; // - parameter index
unsigned max_parms; // - # parameters
SYMBOL *psym1; // - addr[ parameter symbol ]
max_parms = VstkDimension( &sym_stack );
for( index = 0; index < max_parms; ++index ) {
psym1 = VstkIndex( &sym_stack, index );
declareParameter( *psym1 );
}
} break;
}
VstkClose( &sym_stack );
CGLastParm();
}
static void extraRptInit( // INITIALIZATION FOR EXTRA REPORTING
INITFINI* defn ) // - definition
{
defn = defn;
rpt_registrations = NULL;
carve_ctr = CarveCreate( sizeof( RPTREG_CTR ), 32 );
carve_avg = CarveCreate( sizeof( RPTREG_AVG ), 32 );
carve_tab = CarveCreate( sizeof( RPTREG_TAB ), 4 );
carve_sf = CarveCreate( sizeof( REPO_STAT ), 32 );
VstkOpen( &srcFiles, sizeof( SYMBOL ), 32 );
}
static REPO_STAT* reposStat // GET REPOSITORY STATISTICS FOR SRCFILE
( SRCFILE sf ) // - the source file
{
REPO_STAT** last; // - addr[ REPO_STAT ]
REPO_STAT* retn; // - REPO_STAT for source file
for( last = VstkTop( &srcFiles ); ; last = VstkNext( &srcFiles, last ) ) {
if( NULL == last ) {
retn = CarveAlloc( carve_sf );
*(REPO_STAT**)VstkPush( &srcFiles ) = retn;
VstkOpen( &retn->refset, sizeof( SYMBOL ), 32 );
VstkOpen( &retn->typeset, sizeof( TYPE ), 32 );
retn->srcfile = sf;
retn->defns = 0;
break;
}
retn = *last;
if( sf == retn->srcfile ) break;
}
return retn;
}
void DumpObjectModelClass( // DUMP OBJECT MODEL: CLASS
TYPE type ) // - structure type
{
DUMP_INFO di; // - dump information
if( ! type->u.c.info->corrupted ) {
CompFlags.log_note_msgs = TRUE;
di.original = type;
di.offset = 0;
VbufInit( &di.buffer );
VstkOpen( &di.stack, sizeof( char* ), 16 );
dumpStruct( type, &di, "Object Model for:", DS_NULL );
VbufFree( &di.buffer );
VstkClose( &di.stack );
CompFlags.log_note_msgs = FALSE;
}
}
static void dumpPTreeNode( // DUMP A PARSE TREE NODE
PTREE node ) // - node in parse tree
{
static char buffer[128]; // - debugging buffer
char *node_name; // - name of node
VSTK_CTL ctl; // - VSTK control information (nodes)
VSTK_CTL dup; // - VSTK control information (duplicates)
int dup_out; // - last duplicate printed
VstkOpen( &ctl, sizeof( PTREE ), 32 );
VstkOpen( &dup, sizeof( PTREE ), 8 );
dup_out = -1;
for( ; ; ) {
switch( node->op ) {
case PT_ERROR :
printf( "PT_ERROR" F_BADDR
" ***** ERROR TREE *****" F_EOL
, node
);
break;
case PT_INT_CONSTANT :
node_name = "PT_INT_CONSTANT";
printf( F_NAME F_BADDR
" flags" F_HEX_4
" type" F_PTR
, node_name
, node
, node->flags
, node->type
);
if( NULL == Integral64Type( node->type ) ) {
printf( " integer" F_HEX_4
, node->u.int_constant
);
} else {
printf( " integer-64" F_S64
, VAL64( node->u.int64_constant )
);
}
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_FLOATING_CONSTANT : {
char buffer[256];
BFCnvFS( node->u.floating_constant, buffer, 256 );
printf( "PT_FLOATING_CONSTANT" F_BADDR
" flags" F_HEX_4
" float" F_CPP_FLOAT
, node
, node->flags
, buffer
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
}
break;
case PT_STRING_CONSTANT :
stvcpy( buffer, node->u.string->string, node->u.string->len );
printf( "PT_STRING_CONSTANT" F_BADDR
" flags" F_HEX_4
" string" F_STRING
, node
, node->flags
, buffer
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_ID :
printf( "PT_ID" F_BADDR
" flags" F_HEX_4
" cgop" F_STRING F_NL
" id" F_PTR
"=" F_STRING
" id_cgop" F_STRING
" u.id.scope" F_PTR
, node
, node->flags
, DbgOperator( node->cgop )
, node->u.id.name
, NameStr( node->u.id.name )
, DbgOperator( node->id_cgop )
, node->u.id.scope
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_TYPE :
printf( "PT_TYPE" F_BADDR
" cgop" F_STRING
" flags" F_HEX_4
" next" F_PTR
" scope" F_PTR
, node
, DbgOperator( node->cgop )
, node->flags
, node->u.type.next
, node->u.type.scope
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_SYMBOL :
if( node->cgop == CO_NAME_THIS ) {
printf( "PT_SYMBOL" F_BADDR
" flags" F_HEX_4
" this "
, node
, node->flags
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
} else if( node->cgop == CO_NAME_CDTOR_EXTRA ) {
printf( "PT_SYMBOL" F_BADDR
" flags" F_HEX_4
" cdtor_extra_parm "
, node
, node->flags
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
} else {
printf( "PT_SYMBOL" F_BADDR
" flags" F_HEX_4
" cgop" F_STRING F_NL
" symbol" F_PTR
" result" F_PTR
, node
, node->flags
, DbgOperator( node->cgop )
, node->u.symcg.symbol
, node->u.symcg.result
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
DumpSymbol( node->u.symcg.symbol );
}
break;
case PT_UNARY :
printf( "PT_UNARY" F_BADDR
F_POINTS F_ADDR
" flags" F_HEX_4
" cgop" F_STRING
, node
, node->u.subtree[0]
, node->flags
, DbgOperator( node->cgop )
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
PUSH_NODE( ctl, node->u.subtree[0] );
break;
case PT_BINARY :
printf( "PT_BINARY" F_BADDR
F_POINTS F_ADDR
"," F_ADDR
" flags" F_HEX_4
" cgop" F_STRING
, node
, node->u.subtree[0]
, node->u.subtree[1]
, node->flags
, DbgOperator( node->cgop )
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
PUSH_NODE( ctl, node->u.subtree[1] );
PUSH_NODE( ctl, node->u.subtree[0] );
break;
case PT_DUP_EXPR :
{ PTREE *duped; // - duplicated expression
printf( "PT_DUP_EXPR" F_BADDR
F_POINTS F_ADDR
" flags" F_HEX_4
" node" F_ADDR
, node
, node->u.dup.subtree[0]
, node->flags
, node->u.dup.node
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
if( node->u.subtree[0] != NULL ) {
for( duped = VstkTop( &dup )
;
; duped = VstkNext( &dup, duped ) ) {
if( duped == NULL ) {
PUSH_NODE( dup, node->u.subtree[0] );
} else if( *duped == node->u.subtree[0] ) {
break;
}
}
}
} break;
case PT_IC :
printf( "PT_IC" F_BADDR
" " F_NAME
" value" F_ADDR
, node
, DbgIcOpcode( node->u.ic.opcode )
, node->u.ic.value.pvalue
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
default :
printf( "***INVALID***" F_BADDR
" flags" F_HEX_4
" op" F_HEX_1
, node
, node->flags
, node->op
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
}
{
PTREE *next; // - addr[next node]
next = VstkPop( &ctl );
if( next != NULL ) {
node = *next;
} else {
++dup_out;
if( dup_out > VstkDimension( &dup ) ) break;
next = VstkIndex( &dup, dup_out );
printf( "--------------- duplicate ------------\n" );
node = *next;
}
}
}
VstkClose( &ctl );
VstkClose( &dup );
}
void BrinfSrcInit // BrinfSrc INITIALIZATION
( void )
{
carvePpIns = CarveCreate( sizeof( PP_INS ), 32 );
VstkOpen( &open_src, sizeof( TOKEN_LOCN ), 16 );
}
void CmdLnCtxInit( // INITIALIZE CMD-LN CONTEXT
void )
{
VstkOpen( &cmdLnContexts, sizeof( CTX_CL ), 8 );
}
static void init( // INITIALIZATION
INITFINI* defn ) // - definition
{
defn = defn;
VstkOpen( &expressions, sizeof( CGEXPR ), 128 );
}
