brinfo.c

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

                           , DbgSymNameFull( sym )
                           )
                   );
            DbgStmt( DbgDumpTokenLocn( locn ) );
            DbgStmt( printf( "\n" ) );
        }
        if( SymIsFunction( sym ) ) {
            ExtraRptIncrementCtr( ctr_ref_func );
            if( CompFlags.optbr_f ) {
                brinfIcReference( IC_BR_REF_FUN, sym, locn );
            }
        } else if( SymIsData( sym ) ) {
            if( SymIsClassMember( sym ) ) {
                if( SymIsThisMember( sym ) ) {
                    ExtraRptIncrementCtr( ctr_ref_data_memb_this );
                    if( CompFlags.optbr_m ) {
                        brinfIcReference( IC_BR_REF_CLM, sym, locn );
                    }
                } else {
                    ExtraRptIncrementCtr( ctr_ref_data_memb_static );
                    if( CompFlags.optbr_v
                     || CompFlags.optbr_m ) {
                        brinfIcReference( IC_BR_REF_VAR, sym, locn );
                    }
                }
            } else {
            #ifndef NDEBUG
                if( SymIsAutomatic( sym ) ) {
                    ExtraRptIncrementCtr( ctr_ref_data_bare_auto );
                } else {
                    ExtraRptIncrementCtr( ctr_ref_data_bare_static );
                }
            #endif
                if( CompFlags.optbr_v ) {
                    brinfIcReference( IC_BR_REF_VAR, sym, locn );
                }
            }
        } else if( SymIsTypedef( sym ) ) {
            ExtraRptIncrementCtr( ctr_ref_typedef );
            if( CompFlags.optbr_t ) {
                brinfIcReference( IC_BR_REF_TYPE, sym->sym_type, locn );
            }
        } else if( SymIsEnumeration( sym ) ) {
            ExtraRptIncrementCtr( ctr_ref_eval );
            if( CompFlags.optbr_v ) {
                brinfIcReference( IC_BR_REF_EVAL, sym, locn );
            }
        } else if( SymIsEnumDefinition( sym ) ) {
            ExtraRptIncrementCtr( ctr_ref_evar );
            if( CompFlags.optbr_v ) {
                brinfIcReference( IC_BR_REF_EVAR, sym, locn );
            }
        } else {
            ExtraRptIncrementCtr( ctr_ref_other );
        }
    }
}


MEPTR BrinfDeclMacro            // DECLARE MACRO
    ( MEPTR mac )               // - the macro
{
    if( NULL != mac
     && CompFlags.optbr_p ) {
        if( canWriteIc() ) {
            MACVALUE* val = BrinfMacAddValue( mac );
            ExtraRptIncrementCtr( ctr_defn_macro );
            BrinfSrcMacDecl( val );
        }
    }
    return mac;
}


void BrinfDependsMacroValue     // DEPENDENCY: MACRO VALUE
    ( MEPTR mac )               // - the macro
{
    MACVALUE* val;              // - value for macro

    if( BrinfActive() ) {
        ExtraRptIncrementCtr( ctr_dep_macro_value );
        val = BrinfMacAddValue( mac );
        BrinfDepMacAdd( mac, val, MVT_VALUE );
    }
}


MEPTR BrinfReferenceMacro       // REFERENCE A MACRO VALUE
    ( MEPTR mac )               // - the macro
{
    if( enableMacRefs
     && CompFlags.optbr_p ) {
        MACVALUE* val = BrinfMacAddValue( mac );
        ExtraRptIncrementCtr( ctr_ref_macro );
        // the following is over-conservative, since a reference is also
        // generated for #ifdef, #ifndef
        BrinfDependsMacroValue( mac );
        BrinfSrcMacReference( val );
    }
    return mac;
}


boolean BrinfDependsMacroDefined // DEPENDENCY: MACRO DEFINED OR NOT
    ( boolean defed             // - whether defined or not
    , char const * name         // - characters in name
    , unsigned nlen )           // - name length
{
    MACVALUE* val;              // - value for macro
    MAC_VTYPE type;             // - type of dependency
    MEPTR mac;                  // - NULL or entry def'ed or undef'ed

    if( BrinfActive() ) {
        ExtraRptIncrementCtr( ctr_dep_macro_defined );
        if( defed ) {
            val = BrinfMacAddDefin( name, nlen );
            enableMacRefs = FALSE;
            mac = MacroLookup( name, nlen );
            enableMacRefs = TRUE;
            type = MVT_DEFINED;
        } else {
            val = BrinfMacAddUndef( name, nlen );
            mac = NULL;
            type = MVT_UNDEFED;
        }
        BrinfDepMacAdd( mac, val, type );
    }
    return defed;
}


void BrinfUndefMacro            // UNDEFINE A MACRO
    ( MEPTR mac )               // - that macro
{
    if( BrinfActive() ) {
        BrinfMacUndef( mac, SrcFileCurrent() );
    }
}


void BrinfOpenScope             // OPEN A SCOPE
    ( SCOPE scope )             // - the scope
{
    scope = scope;
}


void BrinfCloseScope            // CLOSE A SCOPE
    ( SCOPE scope )             // - the scope
{
    if( BrinfActive() ) {
#ifdef XTRA_RPT
        _dbgScope( scope, "Br-inf-end" );
        if( ! ScopeType( scope, SCOPE_CLASS )
         && scope->keep
         && NULL != scope->ordered ) {
            ExtraRptIncrementCtr( ctr_nontrivial_scopes );
        }
        if( scope == PstkTopElement( &active_scopes ) ) {
            scope = PstkPopElement( &active_scopes );
            closeScopeIc( scope );
        }
        endBlkScope( scope );
#endif
    }
}


void BrinfIncludeSource         // INCLUDE A SOURCE FILE
    ( char const * fname        // - file name (scanned)
    , TOKEN_LOCN * locn )       // - place
{
    IfDbgToggle( browse ) {
        DbgStmt( printf( "Br-include-source: %s"
                       , fname
                       )
               );
        DbgStmt( DbgDumpTokenLocn( locn ) );
        DbgStmt( printf( "\n" ) );
    }
    if( BrinfActive() ) {
        BrinfSrcInc( (void*)fname, locn );
    }
}


void BrinfOpenSource            // OPEN A SOURCE FILE
    ( SRCFILE srcfile )         // - source file
{
    ExtraRptIncrementCtr( ctr_open_source );
    IfDbgToggle( browse ) {
        DbgStmt( printf( "Br-open-source: %s\n"
                       , SrcFileFullName( srcfile )
                       )
               );
    }
    if( BrinfActive() ) {
        BrinfSrcBeg( srcfile );
    }
}

void BrinfCloseSource           // CLOSE A SOURCE FILE
    ( SRCFILE srcfile )         // - file being closed
{
    IfDbgToggle( browse ) {
        DbgStmt( printf( "Br-close-source\n" ) );
    }
    if( BrinfActive() ) {
        BrinfDepSrcEnd();
        BrinfSrcEndFile( srcfile );
    }
}


static void completeInputPhase  // COMPLETION OF INPUT PHASE
    ( void )
{
    activeScopesClose();
    BrinfSrcFini();
    CgioCloseOutputFile( virtual_file );
}


void BrinfWrite                 // WRITE OUT BROWSE INFORMATION
    ( void )
{
    if( BrinfActive() ) {
        completeInputPhase();
        brinfo_state = BRS_COLLECTED;
        brinfOpen();
        brinfo_state = BRS_WRITING;
        CgioOpenInput( virtual_file );
        BrinfWriteFile( virtual_file, &rtns, usage_file, bri_handle );
        CgioCloseInputFile( virtual_file );
        brinfClose();
        CgioFreeFile( virtual_file );
        BrinfMacroRelease();
    }
}


static void startBrinfPCH       // START A BROWSE-FILE WHICH HAS PCH REFERENCE
    ( void )
{
    char full_name[ _MAX_PATH ];
    char *fname;
    SRCFILE srcf;
    TOKEN_LOCN start = { 0, 0, 0 };

    BrinfInit( FALSE );
    fname = IoSuppFullPath( PCHFileName(), full_name, sizeof( full_name ) );
    fname = FNameAdd( fname );
    BrinfWriteIns( IC_BR_PCH, fname );
    srcf = SrcFileCurrent();
    BrinfSrcInc( SrcFileName( srcf ), &start );
    BrinfSrcBeg( srcf );
}


unsigned long BrinfPch          // WRITE OUT PCH IF REQ'D
    ( int handle )              // - file handle
{
    unsigned long retn;         // - posn for browse info in PCH file

    if( BrinfActive() ) {
        PCHFlushBuffer();
        retn = tell( handle );
// error return ?
        completeInputPhase();   // - note: this destroys a carver in brinfsrc
        brinfo_state = BRS_WRITING;
        CgioOpenInput( virtual_file );
        bri_handle = BrinfWritePchFile( virtual_file
                                      , &rtns_pch
                                      , (void*)handle
                                      , retn );
        CgioCloseInputFile( virtual_file );
        CgioFreeFile( virtual_file );
        BrinfSrcInit();         // - to restart the carver in brinfsrc
        startBrinfPCH();
    } else {
        retn = 0;
    }
    return retn;
}


void BrinfPchRead               // INSERT PCH REFERENCE INTO BROWSING
    ( void )
{
    BRI_PCH_CTL         ctl;
    BRI_PCHRtns         pchrtns = {
        &brinfReadPch1,
        &brinfReadPch4,
        &brinfReadPch
    };

    if( BrinfActive() ) {
        brinfo_state = BRS_PCH_RESTART;
        destroyBrinfData();
        BrinfDepRestart();
        BrinfMacRestart();
        BrinfSrcRestart();
        DbgAssert( bri_handle == NULL );
        bri_handle = BrinfCreateFile( &rtns );
        startBrinfPCH();
        brinfPchInit( &ctl );
        BrinfReadPchFile( &pchrtns, &ctl );
        brinfPchFini( &ctl );
    }
}


void BrinfInit                  // START OF PROCESSING FOR BROWSE INFO
    ( boolean primary )         // - TRUE ==> primary initialization
{
    if( primary ) {
        bri_handle = NULL;
    }
    usage_file = NULL;
    usage_name = NULL;
    virtual_file = NULL;
    brinfo_state = BRS_INACTIVE;
    if( BrinfActive() ) {
        ring_active_blks = NULL;
        carve_blk_scope = CarveCreate( sizeof( ACTBLK ), 32 );
        carve_scope_ins = CarveCreate( sizeof( SCPINS ), 64 );
        if( primary ) {
            BrinfDepInit();
        }
        virtual_file = CgioCreateFile( BRINF_SYMBOL );
        if( primary ) {
            BrinfSrcInit();
        }
        brinfo_state = BRS_COLLECTING;
        PstkOpen( &active_scopes );
        PstkOpen( &sym_scopes );
        ref_file = NULL;
        ref_line = 0;
        ref_col = 0;
        enableMacRefs = TRUE;
        if( primary ) {
            MacroWriteBrinf();
        }
    } else {
        activeScopesClose();
    }
}


static void brinfInit           // START OF PROCESSING FOR BROWSE INFO
    ( INITFINI* defn )          // - definition
{
    ExtraRptRegisterCtr( &ctr_namespace_decl
                       , "BrowseInfo: # namespace declarations" );
    ExtraRptRegisterCtr( &ctr_symbol_decl
                       , "BrowseInfo: # other symbol declarations" );
    ExtraRptRegisterCtr( &ctr_template_class_decl
                       , "BrowseInfo: # template class declarations" );
    ExtraRptRegisterCtr( &ctr_typedef
                       , "BrowseInfo: # declarations" );
    ExtraRptRegisterCtr( &ctr_defn_macro
                       , "BrowseInfo: # macro declarations" );
    ExtraRptRegisterCtr( &ctr_class_decl
                       , "BrowseInfo: # class declarations" );
    ExtraRptRegisterCtr( &ctr_class_base
                       , "BrowseInfo: # class bases" );
    ExtraRptRegisterCtr( &ctr_class_memb
                       , "BrowseInfo: # class members" );
    ExtraRptRegisterCtr( &ctr_class_fr
                       , "BrowseInfo: # class friends" );
    ExtraRptRegisterCtr( &ctr_ref_func
                       , "BrowseInfo: # ref. to functions" );
    ExtraRptRegisterCtr( &ctr_ref_data_memb_this
                       , "BrowseInfo: # ref. to this data members" );
    ExtraRptRegisterCtr( &ctr_ref_data_memb_static
                       , "BrowseInfo: # ref. to static data members" );
    ExtraRptRegisterCtr( &ctr_ref_data_bare_auto
                       , "BrowseInfo: # ref. to auto data variables" );
    ExtraRptRegisterCtr( &ctr_ref_data_bare_static
                       , "BrowseInfo: # ref. to static data variables" );
    ExtraRptRegisterCtr( &ctr_ref_typedef
                       , "BrowseInfo: # ref. to typedefs" );
    ExtraRptRegisterCtr( &ctr_ref_eval
                       , "BrowseInfo: # ref. to enumeration values" );
    ExtraRptRegisterCtr( &ctr_ref_evar
                       , "BrowseInfo: # ref. to enumeration variables" );
    ExtraRptRegisterCtr( &ctr_ref_other
                       , "BrowseInfo: # ref. to unknown stuff" );
    ExtraRptRegisterCtr( &ctr_ref_macro
                       , "BrowseInfo: # ref. to macros" );
    ExtraRptRegisterCtr( &ctr_dep_macro_defined
                       , "BrowseInfo: # dep. on macro (un)defined" );
    ExtraRptRegisterCtr( &ctr_dep_macro_value
                       , "BrowseInfo: # dep. on macro values" );
    ExtraRptRegisterCtr( &ctr_open_scope
                       , "BrowseInfo: # opened scopes" );
    ExtraRptRegisterCtr( &ctr_nontrivial_scopes
                       , "BrowseInfo: # non-trivial scopes" );
    ExtraRptRegisterCtr( &ctr_open_source
                       , "BrowseInfo: # opened source files" );
}


static void brinfFini           // COMPLETION OF PROCESSING FOR BROWSE INFO
    ( INITFINI* defn )          // - definition
{
    defn = defn;
    if( brinfo_state != BRS_CMDLINE
     && brinfo_state != BRS_INACTIVE ) {
        switch( brinfo_state ) {
          DbgDefault( "impossible brinfo state" );
          case BRS_COLLECTING :
            completeInputPhase();
            BrinfDepFini();
            break;
          case BRS_COLLECTED :
            BrinfDepFini();
            break;
          case BRS_WRITING :
            brinfClose();
            BrinfDepFini();
            break;
        }
        CgioFreeFile( virtual_file );
        virtual_file = NULL;
        brinfo_state = BRS_INACTIVE;
    }
    CMemFreePtr( &usage_name );
}


INITDEFN( browse_info, brinfInit, brinfFini );


void BrinfCmdLine               // INDICATE CMD-LINE BEING PROCESSED
    ( void )
{
    brinfo_state = BRS_CMDLINE;
}


#endif