static void fmtSymScope( SCOPE scope, VBUF *pvbuf, boolean include_function )
/***************************************************************************/
{
TYPE class_type;
NAME name;
char *sname;
SYMBOL sym;
VBUF prefix;
while( scope != NULL ) {
switch( scope->id ) {
case SCOPE_FILE:
sname = ScopeNameSpaceFormatName( scope );
if( sname != NULL ) {
VbufConcStrRev( pvbuf, scopeSep );
VbufConcStrRev( pvbuf, sname );
}
break;
case SCOPE_CLASS:
class_type = ScopeClass( scope );
name = SimpleTypeName( class_type );
if( name != NULL ) {
VbufConcStrRev( pvbuf, scopeSep );
if( class_type->flag & TF1_INSTANTIATION ) {
fmtTemplateParms( pvbuf, class_type );
}
VbufConcStrRev( pvbuf, NameStr( name ) );
}
break;
case SCOPE_FUNCTION:
if( include_function ) {
VbufInit( &prefix );
sym = ScopeFunction( scope );
formatScopedSym( sym, &prefix, FF_NULL );
if( VbufLen( &prefix ) > 0 ) {
VbufConcStrRev( &prefix, functionDelim );
VbufPrepVbuf( pvbuf, &prefix );
}
VbufFree( &prefix );
}
return; // function scope resolved on function name
case SCOPE_BLOCK:
case SCOPE_TEMPLATE_DECL:
case SCOPE_TEMPLATE_INST:
case SCOPE_TEMPLATE_PARM:
case SCOPE_TEMPLATE_SPEC_PARM:
break;
case SCOPE_MAX:
default:
VbufConcStrRev( pvbuf, scopeSep );
VbufConcStrRev( pvbuf, scopeError );
break;
}
scope = scope->enclosing;
}
}
static PTREE transformVaStart // TRANSFORM TO CO_VASTART OPCODE
( PTREE expr ) // - va_start expression
{
SYMBOL pre_ellipsis_sym;
SYMBOL stop;
SYMBOL curr;
SYMBOL fn;
SCOPE caller_arg_scope;
unsigned offset;
target_size_t arg_size;
PTREE arg1;
PTREE arg2;
PTREE arg3;
PTREE valist;
// second argument -- must be pre-... parameter
arg1 = expr->u.subtree[1];
arg2 = arg1->u.subtree[0];
arg3 = arg2->u.subtree[0];
pre_ellipsis_sym = PTreeOp( &arg2->u.subtree[1] )->u.symcg.symbol;
caller_arg_scope = ScopeFunctionScopeInProgress();
fn = ScopeFunction( caller_arg_scope );
offset = 0;
if( ObjModelFunctionReturn( fn->sym_type ) == OMR_CLASS_VAL ) {
offset += TARGET_PACKING;
}
if( SymIsThisMember( fn ) ) {
offset += TARGET_PACKING;
if( SymCDtorExtraParm( fn ) ) {
offset += TARGET_PACKING;
}
}
stop = ScopeOrderedStart( caller_arg_scope );
curr = NULL;
for(;;) {
curr = ScopeOrderedNext( stop, curr );
if( curr == NULL ) {
PTreeErrorExpr( expr, ERR_INVALID_VASTART_SYMBOL );
return( expr );
}
if( ObjModelArgument( curr->sym_type ) == OMR_CLASS_REF ) {
arg_size = TARGET_PACKING;
} else {
arg_size = CgMemorySize( curr->sym_type );
arg_size += TARGET_PACKING - 1;
arg_size &= ~( TARGET_PACKING - 1 );
}
offset += arg_size;
if( curr == pre_ellipsis_sym ) break;
}
if( ScopeOrderedNext( stop, curr ) != NULL ) {
PTreeErrorExpr( expr, ERR_INVALID_VASTART_SYMBOL );
return( expr );
}
// third argument -- va_list symbol
valist = arg1->u.subtree[1];
arg1->u.subtree[1] = NULL;
if( arg3->u.subtree[1]->u.int_constant == 0 ) {
// compensate for "void *__alist;" arg in <varargs.h>
offset -= TARGET_PACKING;
}
NodeFreeDupedExpr( expr );
expr = NodeBinary( CO_VASTART, valist, NodeOffset( offset ) );
return expr;
}
