Esempio n. 1
0
static void declareAuto(        // DECLARE AN AUTO SYMBOL
    SYMBOL sym )                // - symbol to be declared
{
    CGAutoDecl( (cg_sym_handle)sym, CgTypeSym( sym ) );
    if( SymRequiresDtoring( sym ) ) {
        SymScope( sym )->u.s.dtor_reqd = true;
    }
}
Esempio n. 2
0
static SYMBOL getSymInScope(    // GET A SYMBOL IN A SCOPE
    SCOPE scope,                // - the scope
    SYMBOL orig )               // - original symbol
{
    SEARCH_RESULT *result;      // - search result for symbol
    SYMBOL sym;                 // - the symbol
    arg_list *alist;            // - arguments for function
    NAME name;                  // - symbol name

    name = orig->name->name;
    alist = SymFuncArgList( orig );
    if( name == CppConversionName() ) {
        result = ScopeFindScopedMemberConversion( scope
                                                , scope
                                                , SymFuncReturnType( orig )
                                                , alist->qualifier
                                                );
        if( result == NULL ) {
            sym = NULL;
        } else {
            sym = result->sym;
            ScopeFreeResult( result );
            if( sym != NULL ) {
                if( SymScope( sym ) != scope ) {
                    sym = NULL;
                }
            }
        }
    } else {
        result = ScopeContainsMember( scope, name );
        if( result == NULL ) {
            sym = NULL;
        } else {
            sym = result->sym_name->name_syms;
            // we may have found a type-name, so check for NULL
            if( sym != NULL && SymIsFunction( sym ) ) {
                switch( FuncOverloaded( &sym
                                      , result
                                      , sym
                                      , alist
                                      , NULL ) ) {
                case FNOV_NONAMBIGUOUS :
                    break;
                default :
                    sym = NULL;
                    break;
                }
            } else {
                sym = NULL;
            }
            ScopeFreeResult( result );
        }
    }
    return( sym );
}
Esempio n. 3
0
void VfnAncestralWalk(          // WALK ANCESTRAL VIRTUAL FUNCTIONS
    SYMBOL sym,                 // - a virtual function
    void (*rtn)(                // - routine called for self, ancestors
        SYMBOL orig,            // - - original virtual function
        SYMBOL vfun,            // - - self or ancestor
        void *data ),           // - - data passed
    void *data )                // - data passed to routine
{
    struct walk_data wdata;     // - internal data for walker

    wdata.vfun = sym;
    wdata.data = data;
    wdata.rtn = rtn;
    ScopeWalkAncestry( SymScope( sym ), &classVisit, &wdata );
}
Esempio n. 4
0
back_handle FEBack(             // GET BACK HANDLE FOR A SYMBOL
    SYMBOL sym )                // - the symbol
{
    SCOPE scope;                // - scope for symbol
    SYMBOL check_sym;           // - SYMBOL temp
    void* cg_handle;            // - handle for symbol
#ifndef NDEBUG
    SYMBOL orig                 // - original symbol
        = sym;
#endif

    check_sym = SymIsAnonymous( sym );
    if( check_sym != NULL ) {
        sym = check_sym;
    }
    if( sym->flag2 & SF2_CG_HANDLE ) {
        cg_handle = sym->locn->u.cg_handle;
    } else {
        cg_handle = BENewBack( (cg_sym_handle)sym );
        if( NULL != cg_handle ) {
            SYM_TOKEN_LOCN* locn = SymbolLocnAlloc( &sym->locn );
            locn->u.cg_handle = cg_handle;
            scope = SymScope( sym );
            if( scope != NULL ) {
                switch( scope->id ) {
                  case SCOPE_CLASS :
                    cgBackStatHandleAdd( sym );
                    break;
                  case SCOPE_FUNCTION :
                  case SCOPE_BLOCK :
                    if( SymIsStaticData( sym ) ) {
                        cgBackStatHandleAdd( sym );
                    }
                    break;
                }
            }
            sym->flag2 &= ~SF2_HDL_MASK;
            sym->flag2 |= SF2_CG_HANDLE;
        }
    }
#ifndef NDEBUG
    if( PragDbgToggle.auxinfo ) {
        printf( "FEBack( %p ) -> bh[%p]\n", orig, cg_handle );
    }
#endif
    return cg_handle;
}
Esempio n. 5
0
void DgInitBegin(               // START INITIALIZATION OF SYMBOL
    SYMBOL sym )                // - the symbol
{
    CGFILE_GEN *gen;            // - generation data

    ins_init_beg.value.pvalue = sym;
    gen = getGenData();
    flags.init_data_beg = TRUE;
    flags.init_data_end = FALSE;
    gen->init_sym = sym;
    if( sym->id == SC_STATIC && ScopeId( SymScope( sym ) ) != SCOPE_FILE ) {
        emitDataCGFILE = &codeCGFILE;
    } else {
        gen->emit_init_beg = TRUE;
        gen->emit_init_end = FALSE;
    }
}
Esempio n. 6
0
static void formatScopedSym( SYMBOL sym, VBUF *pvbuf, FMT_CONTROL control )
/*************************************************************************/
{
    VBUF    prefix;
    boolean ctordtor;

    VbufInit( &prefix );
    if( sym->name == NULL ) {
        ctordtor = fmtSymName( sym, NULL, &prefix, pvbuf, control );
    } else {
        ctordtor = fmtSymName( sym, sym->name->name, &prefix, pvbuf, control );
    }
    if( !SymIsAnonymous( sym ) ) {
        fmtSymScope( SymScope( sym ), pvbuf, TRUE );
    }
    if( !ctordtor ) {
        VbufConcVbuf( pvbuf, &prefix );
    }
    VbufFree( &prefix );
}
Esempio n. 7
0
static TYPE getThisBaseType( SYMBOL sym )
{
    SCOPE scope;                // - scope for symbol
    TYPE class_type;            // - type from function's class scope
    TYPE base;                  // - return: NULL or TYPE of "this" for symbol

    base = NULL;
    if( sym != NULL ) {
        scope = ScopeNearestNonTemplate( SymScope( sym ) );
        if( scope != NULL ) {
            class_type = ScopeClass( scope );
            if( class_type != NULL ) {
                if( sym->id != SC_STATIC ) {
                    base = class_type;
                }
            }
        }
    }
    return( base );
}
Esempio n. 8
0
static char *formatScopedSym( SYMBOL sym, VBUF *pvbuf, FMT_CONTROL control )
/**************************************************************************/
{
    VBUF    prefix;
    bool    ctordtor;

    VbufInit( &prefix );
    if( sym->name == NULL ) {
        ctordtor = fmtSymName( sym, NULL, &prefix, pvbuf, control );
    } else {
        ctordtor = fmtSymName( sym, sym->name->name, &prefix, pvbuf, control );
    }
    if( !SymIsAnonymous( sym ) ) {
        fmtSymScope( SymScope( sym ), pvbuf, true );
    }
    if( !ctordtor ) {
        VbufConcVbuf( pvbuf, &prefix );
    }
    VbufFree( &prefix );
    return( VbufString( pvbuf ) );
}
Esempio n. 9
0
static bool fmtSymName( SYMBOL sym, NAME name, VBUF *pvprefix, VBUF *pvbuf, FMT_CONTROL control )
/***********************************************************************************************/
// returns true if sym is CTOR/DTOR so that the caller drop the return type
{
    VBUF    prefix, suffix, op_name;
    CGOP    oper;
    bool    ctordtor = false;

    if( CppLookupOperatorName( name, &oper ) ) {
        switch( oper ) {
        case CO_CONVERT:
            if( sym == NULL ) {
                VbufConcStrRev( pvbuf, operatorSuffix );
                VbufConcStrRev( pvbuf, operatorUnknown );
            } else {
                fmtSymOpName( sym, &op_name );
                fmtSymFunction( sym, &prefix, &suffix, (FormatTypeDefault & ~FF_USE_VOID) | FF_DROP_RETURN );
                VbufConcVbufRev( pvbuf, &suffix );
                VbufConcVbuf( pvbuf, &op_name );
                VbufConcStrRev( pvbuf, operatorPrefix );
                VbufConcVbufRev( pvbuf, &prefix );
                VbufFree( &op_name );
                VbufFree( &prefix );
                VbufFree( &suffix );
            }
            break;
        case CO_CTOR:
            if( sym == NULL ) {
                VbufConcStrRev( pvbuf, constructorName );
            } else {
                name = SimpleTypeName( ScopeClass( SymScope( sym ) ) );
                ctordtor = true;
                fmtSymFunction( sym, &prefix, &suffix, FormatTypeDefault );
                VbufConcVbufRev( pvbuf, &suffix );
                if( name != NULL ) {
                    VbufConcStrRev( pvbuf, NameStr( name ) );
                }
                VbufConcVbufRev( pvprefix, &prefix );
                VbufFree( &prefix );
                VbufFree( &suffix );
            }
            break;
        case CO_DTOR:
            if( sym == NULL ) {
                VbufConcStrRev( pvbuf, destructorName );
            } else {
                name = SimpleTypeName( ScopeClass( SymScope( sym ) ) );
                ctordtor = true;
                fmtSymFunction( sym, &prefix, &suffix, FormatTypeDefault );
                VbufConcVbufRev( pvbuf, &suffix );
                if( name != NULL ) {
                    VbufConcStrRev( pvbuf, NameStr( name ) );
                }
                VbufConcStrRev( pvbuf, dtorPrefix );
                VbufConcVbufRev( pvprefix, &prefix );
                VbufFree( &prefix );
                VbufFree( &suffix );
            }
            break;
        default:
            if( sym == NULL ) {
                VbufConcStrRev( pvbuf, fmtSymCgop( oper ) );
                VbufConcStrRev( pvbuf, operatorPrefix );
            } else {
                fmtSymFunction( sym, &prefix, &suffix, FormatTypeDefault | control );
                VbufConcVbufRev( pvbuf, &suffix );
                VbufConcStrRev( pvbuf, fmtSymCgop( oper ) );
                VbufConcStrRev( pvbuf, operatorPrefix );
                VbufConcVbufRev( pvprefix, &prefix );
                VbufFree( &prefix );
                VbufFree( &suffix );
            }
            break;
        }
    } else if( sym != NULL ) {
        if( SymIsFunction( sym ) ) {
            fmtSymFunction( sym, &prefix, &suffix, FormatTypeDefault | control );
        } else if( !SymIsTypedef( sym ) ) {
            FormatType( sym->sym_type, &prefix, &suffix );
        } else {
            VbufInit( &prefix );
            VbufInit( &suffix );
        }
        VbufConcVbufRev( pvbuf, &suffix );
        if( name == NULL ) {
            VbufConcStrRev( pvbuf, nullSymname );
        } else {
            VbufConcStrRev( pvbuf, NameStr( name ) );
        }
        VbufConcVbufRev( pvprefix, &prefix );
        VbufFree( &prefix );
        VbufFree( &suffix );
    } else if( name != NULL ) {
        VbufConcStrRev( pvbuf, NameStr( name ) );
    } else {
        VbufConcStrRev( pvbuf, nullSymname );
    }
    return( ctordtor );
}
Esempio n. 10
0
static void verifyFileScopeSym( SYMBOL sym )
{
    if( ! ScopeType( SymScope( sym ), SCOPE_FILE ) ) {
        CFatal( "linkage symbol is not from file-scope" );
    }
}
Esempio n. 11
0
boolean RunTimeIsThrow(         // TEST IF FUNCTION IS A C++ THROW
    SYMBOL func )               // - function symbol
{
    return GetInternalScope() == SymScope( func ) && ( func->flag & SF_IS_THROW ) != 0;
}