brmwrite.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 908 行 · 第 1/3 页

                          , BRI_TC_PtrToMember
                          , 2
                          , host_type
                          , sub_type );
            break;

            default:
                // do nothing
            break;
        }
    }

    return result;
}


static void writeDefinition     // WRITE A DEFINITION
    ( TOKEN_LOCN* tl            // - location
    , BRI_SymbolID id )         // - id
{
    BRIAddDefinition( bri_handle
                    , addStringFile( tl->src_file )
                    , tl->line
                    , tl->column
                    , id );
}


static void writeSymbolLocn     // WRITE A DEFINITION FOR A SYMBOL
    ( SYMBOL sym
    , BRI_SymbolID sym_id )              // - the symbol
{
    writeDefinition( &sym->locn->tl, sym_id );
}


static void writeClassHdr       // WRITE BROWSE DEFN FOR CLASS HEADER
    ( TYPE cltype )             // - class type
{
    BRI_TypeID  type_id;
    BRI_SymbolAttributes        sym_attribs;

    if( bri_handle != NULL ) {
        type_id = writeType( cltype );
        sym_attribs = BRI_SA_Class;
        if( cltype->flag & TF1_INSTANTIATION ){
            sym_attribs = (BRI_SymbolAttributes)(sym_attribs|BRI_SA_TempInst);
        }
        BRIAddSymbol( bri_handle
                      , symbolIDForClass( cltype->u.c.info )
                      , addString( cltype->u.c.info->name )
                      , type_id
                      , sym_attribs
                      , BRI_SA_AccessNone );
    }
}


static void writeClassEnd       // WRITE BROWSE DEFN FOR CLASS HEADER
    ( TYPE cltype )             // - class type
{
    cltype = cltype;
}


static void writeClassBases     // WRITE BROWSE DEFN FOR BASES
    ( TYPE cltype )             // - class type
{
    CLASSINFO* inf;             // - class information
    BASE_CLASS* base;           // - current base
    CLASSINFO* binf;            // - class information for base

    inf = cltype->u.c.info;
    RingIterBeg( inf->bases, base ) {
        binf = base->type->u.c.info;
        if( bri_handle != NULL ) {
            BRIAddReference( bri_handle
                           , BRI_NO_CHANGE
                           , BRI_NO_CHANGE
                           , BRI_NO_CHANGE
                           , symbolIDForClass( binf )
                           , BRI_RT_InheritFrom );
        }
#if 0
        IfDbgToggle( browse ) {
            DbgStmt( printf( "Br-inf-def: base is %s\n", binf->name ) );
        }
#endif
    } RingIterEnd( base );
}


static void writeClassFriends   // WRITE BROWSE DEFN FOR FRIENDS
    ( TYPE cltype )             // - class type
{
    CLASSINFO* inf;             // - class information
    FRIEND* friend;             // - current friend
    SYMBOL sym;                 // - symbol for friend

    inf = cltype->u.c.info;
    RingIterBeg( inf->friends, friend ) {
        sym = friend->sym;
        if( bri_handle != NULL ) {
            BRIAddReference( bri_handle
                           , BRI_NO_CHANGE
                           , BRI_NO_CHANGE
                           , BRI_NO_CHANGE
                           , (BRI_SymbolID) SymbolGetIndex( sym )
                           , BRI_RT_Friend );
        }
    } RingIterEnd( friend );
}


static void writeClassMembers   // WRITE BROWSE DEFN FOR MEMBERS
    ( TYPE cltype )             // - class type
{
    SCOPE scope;                // - scope for class
    SYMBOL last;                // - last symbol
    SYMBOL sym;                 // - current symbol
    BRI_SymbolID sym_id;
    BRI_TypeID type_id;
    BRI_SymbolAttributes sym_type;

    scope = cltype->u.c.scope;
    sym = ScopeOrderedFirst( scope );
    if( NULL != sym ) {
        last = ScopeOrderedLast( scope );
        for( ; sym != NULL ; sym = ScopeOrderedNext( last, sym ) ) {
            type_id = writeType( sym->sym_type );
            if( sym->sym_type->id == TYP_FUNCTION ){
                sym_type = BRI_SA_Function;
            } else if( sym->id == SC_TYPEDEF ) {
                sym_type = BRI_SA_Typedef;
            } else {
                sym_type = BRI_SA_Variable;
            }
            sym_id = (BRI_SymbolID) SymbolGetIndex( sym );
            BRIAddSymbol( bri_handle
                          , sym_id
                          , addString( sym->name->name )
                          , type_id
                          , sym_type
                          , BRI_SA_AccessNone );
            if( sym->locn != NULL ){
                writeSymbolLocn( sym, sym_id );
            }
        }
    }
}


static void processMacroDefness     // PROCESS MACRO DEFINED/UNDEFINED
    ( MACVALUE const * mptr         // - macro ptr
    , BRI_GuardTypes   gtype )      // - id
{
    char const * string = BrinfMacValueName( mptr );

    BRIAddGuard( bri_handle
               , gtype
               , addString( string )
               , 0
               , 0
               , NULL );
}


static void processMacroValue       // PROCESS MACRO VALUE
    ( MACVALUE const * mptr         // - macro ptr
    , BRI_GuardTypes   gtype )      // - id
{
    char const *     string = BrinfMacValueName( mptr );
    unsigned         num_parms = BrinfMacValueParmCount( mptr );
    unsigned         length;
    uint_8 const *   defn = BrinfMacValueDefn( mptr, &length );

    BRIAddGuard( bri_handle
               , gtype
               , addString( string )
               , num_parms
               , length
               , defn );
}


void BrinfWriteDepMacDefed          // WRITE DEPENDENCY ON MACRO DEFINED
    ( MACVALUE const * value )      // - value
{
    processMacroDefness( value, BRI_GT_Defined );
}


void BrinfWriteDepMacUndefed        // WRITE DEPENDENCY ON MACRO UNDEFINED
    ( MACVALUE const * value )      // - value
{
    processMacroDefness( value, BRI_GT_NotDefined );
}


void BrinfWriteDepMacVal            // WRITE DEPENDENCY ON MACRO VALUE
    ( MACVALUE const * value )      // - value
{
    processMacroValue( value, BRI_GT_Value );
}


static void brinfWriteFileContents  // WRITE OUT BROWSE INFORMATION CONTENTS
    ( CGFILE *virtual_file )
{
    CGINTER *ins;               // - current instruction
    TOKEN_LOCN locn_ref = {NULL, 0, 0};

    // Initialize static data used by writeType
    type_ops_size = 4;
    type_ops = (uint_32 *) CMemAlloc( type_ops_size * sizeof( uint_32 ) );

    for( ; ; ) {
    // The following comment is a trigger for the ICMASK program to start
    // scanning for case IC_* patterns.
    // ICMASK BEGIN BRINFO (do not remove)
        unsigned not_used;

        ins = CgioReadICMaskCount( virtual_file
                                 , ICOPM_BRINFO
                                 , 0
                                 , &not_used );
        switch( ins->opcode ) {
                                        // NO OPERATION
            case IC_BR_NO_OP:           // - no parameter
            continue;
                                        // SET REFERENCE SOURCE FILE
            case IC_BR_REFTO_FILE :     // - SRCFILE
                locn_ref.src_file = ins->value.pvalue;
            continue;
                                        // SET REFERENCE LINE
            case IC_BR_REFTO_LINE :     // - line #
                locn_ref.line = ins->value.uvalue;
            continue;
                                        // SET REFERENCE COLUMN
            case IC_BR_REFTO_COL :      // - column #
                locn_ref.column = ins->value.uvalue;
            continue;
                                        // SET REFERENCE LINE, COLUMN
            case IC_BR_REFTO_LINECOL :  // - line #
                locn_ref.line = ins->value.uvalue >> 8;
                locn_ref.column = ins->value.uvalue & 0xFF;
            continue;
                                        // SCOPE: OPEN
            case IC_BR_SCOPE_OPN :      // - scope
            {
                SCOPE           scope = ins->value.pvalue;
                uint_32         owner;
                BRI_ScopeType   flags;
                SYMBOL          template_sym;
                BRI_StringID    string_id;

                switch( scope->id ) {
                    case SCOPE_FILE:
                        flags = BRI_ST_File;
                        owner = 0x0;
                    break;

                    case SCOPE_CLASS:
                        flags = BRI_ST_Class;
                        owner = writeType( scope->owner.type );
                    break;

                    case SCOPE_FUNCTION:
                        flags = BRI_ST_Function;
                        owner = (uint_32) scope->owner.sym;
                        DbgAssert( owner != NULL );
                    break;

                    case SCOPE_BLOCK:
                        flags = BRI_ST_Block;
                        owner = 0x0;
                    break;

                    case SCOPE_TEMPLATE_DECL:
                        flags = BRI_ST_TemplateDecl;
                        owner = 0x0;
                    break;

                    case SCOPE_TEMPLATE_INST:
                        flags = BRI_ST_TemplateInst;
                        owner = 0x0;
                    break;

                    case SCOPE_TEMPLATE_PARM:
                        flags = BRI_ST_TemplateParm;
                        if( scope->fn_template ) {
                            template_sym = scope->owner.defn->sym;
                        } else {
                            template_sym = scope->owner.tinfo->sym;
                        }
                        if( template_sym->locn != NULL ){
                            TOKEN_LOCN  *decl_locn;
                            decl_locn = &template_sym->locn->tl;
                            string_id = addStringFile( decl_locn->src_file );
                        } else {
                            string_id = (BRI_StringID) 0;
                        }
                        BRIStartTemplate( bri_handle