static SYMBOL segDefineLabel( // DEFINE LABEL FOR SEGMENT, IF REQ'D
PC_SEGMENT *seg ) // - current segment
{
SYMBOL label; // - reference symbol
char *name; // - label's name
SYMBOL func; // - function being compiled
label = seg->label;
if( label == NULL ) {
func = ScopeFunctionInProgress();
if( ( func != NULL ) && ( func->segid == seg->seg_id ) ) {
label = func;
}
}
if( label == NULL ) {
label = SymMakeDummy( GetBasicType( TYP_CHAR ), &name );
label->segid = seg->seg_id;
if( label->segid == SEG_STACK ) {
label->id = SC_AUTO;
} else {
label->id = SC_STATIC;
InsertSymbol( GetFileScope(), label, name );
}
seg->label = label;
_markUsed( seg, TRUE );
}
return label;
}
void RtnGenerate( void )
/**********************/
{
RTN_GEN *c;
bool keep_going = true;
SetCurrScope( GetFileScope() );
while( keep_going ) {
keep_going = false;
CtxSetCurrContext( CTX_FUNC_GEN );
keep_going = ClassDefineRefdDefaults();
ScopeEmitIndexMappings();
while( useSYMBOL != NULL ) {
c = useSYMBOL;
useSYMBOL = c->next;
keep_going = true;
(*execSYMBOL[c->index])( c->parm );
CarveFree( carveRTN_GEN, c );
}
while( useTYPE != NULL ) {
c = useTYPE;
useTYPE = c->next;
keep_going = true;
(*execTYPE[c->index])( c->parm );
CarveFree( carveRTN_GEN, c );
}
CtxSetCurrContext( CTX_SOURCE );
keep_going = TemplateProcessInstantiations() || keep_going;
SetCurrScope( GetFileScope() );
}
TemplateFreeDefns();
}
static SYMBOL lookupOptSym( // LOOK UP OPTIMIZATION SYMBOL
OPT_DEFN *odef ) // - optimization definition
{
SEARCH_RESULT* result; // - lookup result
SYMBOL var; // - name defined in compiled code
result = ScopeFindNaked( GetFileScope(), optName( odef ) );
if( result == NULL ) {
var = NULL;
} else {
var = result->sym_name->name_syms;
odef->sym = var;
ScopeFreeResult( result );
}
return var;
}
void ModuleInitInit( // START MODULE-INITIALIZATION FUNCTION
void )
{
SYMBOL module_init; // - SYMBOL for mod-init. function
SCOPE curr_scope; // - current scope
TYPE fn_type; // - type for init function
curr_scope = moduleInitSave();
fn_type = TypeVoidFunOfVoid();
module_init = SymCreateFileScope( fn_type
, SC_STATIC
, 0
, CppSpecialName( SPECIAL_INIT_FUNCTION ) );
module_init_func = module_init;
SetCurrScope(GetFileScope());
ScopeBeginFunction( module_init );
FunctionBodyStartup( module_init, &module_fd, FUNC_NULL );
module_fd.retn_opt = false;
module_init_scope = GetCurrScope();
ScopeKeep( module_init_scope );
moduleInitRestore( curr_scope );
}
static SYMBOL makeTemporary( // ALLOCATE A TEMPORARY
TYPE type, // - type of temporary
boolean storage ) // - allocate storage if needed
{
SYMBOL sym; // - symbol for temporary
char *name; // - name for temporary
symbol_class id; // - class for symbol
#if 0
if( ( type->id == TYP_POINTER ) && ( type->flag & TF1_REFERENCE ) ) {
type = type->of;
}
#endif
sym = SymMakeDummy( type, &name );
switch( tempClass ) {
case TEMP_TYPE_EXPR :
case TEMP_TYPE_BLOCK :
id = SC_AUTO;
break;
case TEMP_TYPE_STATIC :
id = SC_STATIC;
break;
DbgDefault( "makeTemporary -- bad tempClass" );
}
sym->id = id;
if( id == SC_STATIC ) {
ScopeInsert( GetFileScope(), sym, name );
if( storage ) {
CgSegIdData( sym, SI_ALL_ZERO );
DgSymbol( sym );
}
} else {
ScopeInsert( ScopeForTemps(), sym, name );
}
return sym;
}
void CgBackFreeFileHandles( // FREE HANDLES FOR FILE SCOPE
void )
{
ScopeWalkSymbols( GetFileScope(), &CgBackFreeHandle );
cgBackStatHandlesFree();
}
SCOPE ModuleFnScope( // SCOPE MOD-INIT FN IS DEF'D IN
void )
{
return GetFileScope();
}
TYPE_SIG *TypeSigFind( // FIND TYPE SIGNATURE
TYPE_SIG_ACCESS acc, // - access type
TYPE type, // - type for signature
TOKEN_LOCN* err_locn, // - error location for access errors
bool *error_occurred ) // - to set error indication
{
TYPE_SIG *srch; // - signature for searching
TYPE_SIG *sig; // - signature
SYMBOL sym; // - symbol
unsigned size; // - size of R/O data
NAME typesig_name; // - name of type signature
TYPE typesig_type; // - type of type signature
bool err_this_time; // - true ==> we have error
TYPE_SIG_ACCESS acc_ind; // - indirect access
err_this_time = false;
type = TypeCanonicalThr( type );
sig = NULL;
RingIterBeg( type_sigs, srch ) {
if( TypesSameExclude( srch->type, type, TC1_NOT_ENUM_CHAR ) ) {
sig = srch;
break;
}
} RingIterEnd( srch );
if( sig == NULL ) {
THROBJ thr; // - category of object
DbgVerify( 0 == ( acc & TSA_GEN )
, "TypeSigFind -- no type signature & TSA_GEN" );
sig = RingCarveAlloc( carveTYPE_SIG, &type_sigs );
sig->type = type;
sig->default_ctor = NULL;
sig->copy_ctor = NULL;
sig->dtor = NULL;
sig->sym = NULL;
sig->base = NULL;
sig->cgref = false;
sig->cggen = false;
sig->free = false;
thr = ThrowCategory( type );
if( acc & TSA_INDIRECT ) {
acc_ind = acc | TSA_INDIRECT_ACCESS;
} else if( acc & TSA_INDIRECT_ACCESS ) {
acc_ind = ( acc & ~ TSA_INDIRECT ) | TSA_INDIRECT_GEN;
} else {
acc_ind = acc;
}
size = 0;
switch( thr ) {
case THROBJ_PTR_SCALAR :
case THROBJ_PTR_CLASS :
sig->base = TypeSigFind( acc_ind & TSA_INDIRECT
, TypePointedAtModified( type )
, err_locn
, &err_this_time );
size = typeSigHdrSize();
break;
case THROBJ_SCALAR :
case THROBJ_PTR_FUN :
case THROBJ_VOID_STAR :
size = typeSigHdrSize() + SizeTargetSizeT();
break;
case THROBJ_REFERENCE :
sig->base = TypeSigFind( acc_ind
, TypeReference( type )
, err_locn
, &err_this_time );
break;
case THROBJ_CLASS :
case THROBJ_CLASS_VIRT :
size = 3 * CgCodePtrSize() + CgDataPtrSize() + typeSigHdrSize();
break;
case THROBJ_ANYTHING :
break;
default :
DbgStmt( CFatal( "cgTypeSignature -- invalid throw category" ) );
}
size += typeSigNameSize( thr );
if( size == 0 ) {
sym = NULL;
} else { // - type for TYPE SIGNATURE variable
typesig_name = CppNameTypeSig( type );
sym = ScopeAlreadyExists( GetFileScope(), typesig_name );
if( sym == NULL ) {
typesig_type = MakeInternalType( size );
typesig_type = MakeCompilerConstCommonData( typesig_type );
sym = SymCreateFileScope( typesig_type
, SC_PUBLIC
, SF_REFERENCED | SF_ADDR_TAKEN
, typesig_name );
LinkageSet( sym, "C++" );
CgSegId( sym );
}
}
sig->sym = sym;
}
if( err_this_time ) {
*error_occurred = true;
} else {
if( NULL != sig->sym ) {
SegmentMarkUsed( sig->sym->segid );
}
*error_occurred = false;
typeSigAccess( acc, sig, err_locn, error_occurred );
}
return( sig );
}
