coptions.c

Open Watcom 的 C 编译器源代码

static int OptionDelimiter( char c )
{
    if( c == ' ' || c == '-' || c == '\0' || c == '\t' || c == SwitchChar ) {
        return( 1 );
    }
    return( 0 );
}

static void EnsureEndOfSwitch()
{
    char        c;

    if( !OptionDelimiter( *OptScanPtr ) ) {
        for(;;) {                       // find start of switch
            c = *OptScanPtr;
            if( c == '-' || c == SwitchChar ) break;
            --OptScanPtr;
        }
        OptScanPtr = BadCmdLine( ERR_INVALID_OPTION, OptScanPtr );
    }
}

#if _MACHINE == _ALPHA
static void SetStructPack()    { CompFlags.align_structs_on_qwords = 1; }
#endif

static void SetPackAmount()    { PackAmount = OptValue; }
static void Set_DbgFmt()       { SwData.dbg_fmt = OptValue; }

#if _CPU == 8086 || _CPU == 386
static void SetCPU()           { SwData.cpu = OptValue; }
#endif
#if _CPU == 386
static void SetCPU_xR(){ SwData.cpu = OptValue; CompFlags.register_conventions = 1; }
static void SetCPU_xS(){ SwData.cpu = OptValue; CompFlags.register_conventions = 0; }
#endif
#if _CPU == 8086 || _CPU == 386
static void SetFPU()           { SwData.fpu = OptValue; }
static void Set_FPR()          { Stack87 = 4; }
static void Set_FPI87()        { SwData.fpt = SW_FPT_INLINE; }
static void Set_Emu()          { SwData.fpt = SW_FPT_EMU; }
static void Set_FPC()          { SwData.fpt = SW_FPT_CALLS; }
static void Set_FPD()          { TargetSwitches |= P5_DIVIDE_CHECK; }

static void SetMemoryModel()   { SwData.mem = OptValue; }
#endif

static void Set_BD()           { CompFlags.bd_switch_used = 1; GenSwitches |= DLL_RESIDENT_CODE; }
static void Set_BC()           { CompFlags.bc_switch_used = 1; }
static void Set_BG()           { CompFlags.bg_switch_used = 1; }
static void Set_BM()           { CompFlags.bm_switch_used = 1; }

#if _CPU != 8086
static void Set_BR()           { CompFlags.br_switch_used = 1; }
#endif

static void Set_BW()           { CompFlags.bw_switch_used = 1; }
static void Set_BT()           { SetTargName( OptParm,  OptScanPtr - OptParm ); }

static void SetExtendedDefines()
{
    CompFlags.extended_defines = 1;
    EnsureEndOfSwitch();
}
static void SetBrowserInfo()   { CompFlags.emit_browser_info = 1; }

#if _MACHINE == _ALPHA
static void Set_AS()
{
    TargetSwitches |= ALIGNED_SHORT;
}
#endif

static void Set_AA()           { CompFlags.auto_agg_inits = 1; }
static void Set_AI()           { CompFlags.no_check_inits = 1; }
static void Set_AQ()           { CompFlags.no_check_qualifiers = 1; }
static void Set_D0()
{
    GenSwitches &= ~(NUMBERS | DBG_TYPES | DBG_LOCALS | NO_OPTIMIZATION);
    CompFlags.debug_info_some = 0;
    CompFlags.no_debug_type_names = 0;
    EnsureEndOfSwitch();
}
static void Set_D1()
{
    GenSwitches |= NUMBERS;
    if( *OptScanPtr == '+' ) {
        ++OptScanPtr;
        CompFlags.debug_info_some = 1;
        GenSwitches |= DBG_TYPES | DBG_LOCALS;
    }
    EnsureEndOfSwitch();
}
static void Set_D2()
{
    GenSwitches |= NUMBERS | DBG_TYPES | DBG_LOCALS | NO_OPTIMIZATION;
    CompFlags.inline_functions = 0;
    if( *OptScanPtr == '~' ) {
        ++OptScanPtr;
        CompFlags.no_debug_type_names = 1;
    }
    EnsureEndOfSwitch();
}
static void Set_D3()
{
    CompFlags.dump_types_with_names = 1;
    Set_D2();
}
static void Set_D9()           { CompFlags.use_full_codegen_od = 1; }
static void DefineMacro()      { OptScanPtr = Define_UserMacro( OptScanPtr ); }

static void SetErrorLimit()    { ErrLimit = OptValue; }

#if _CPU == 8086 || _CPU == 386
static void Set_EC()           { CompFlags.ec_switch_used = 1; }
#endif

static void Set_EE()           { CompFlags.ee_switch_used = 1; }
static void Set_EF()           { CompFlags.ef_switch_used = 1; }
static void Set_EN()           { CompFlags.emit_names = 1; }
static void Set_EI()           { CompFlags.make_enums_an_int = 1;
                                 CompFlags.original_enum_setting = 1;}
static void Set_EM()           { CompFlags.make_enums_an_int = 0;
                                 CompFlags.original_enum_setting = 0;}

#if _CPU == 8086 || _CPU == 386
static void Set_ET()           { TargetSwitches |= P5_PROFILING; }
static void Set_ETP()          { TargetSwitches |= NEW_P5_PROFILING; }
static void Set_ESP()          { TargetSwitches |= STATEMENT_COUNTING; }
#endif

#if _CPU == 386
static void Set_EZ()           { TargetSwitches |= EZ_OMF; }
#endif

static void Set_EP()
{
    CompFlags.ep_switch_used = 1;
    ProEpiDataSize = OptValue;
}

void SetNoCurrInc( void ) { CompFlags.curdir_inc = 0;}

static void StripQuotes( char *fname )
{
    char *s;
    char *d;

    if( *fname == '"' ) {
        // string will shrink so we can reduce in place
        d = fname;
        for( s = d + 1; *s && *s != '"'; ++s ) {
            // collapse double backslashes, only then look for escaped quotes
            if( s[0] == '\\' && s[1] == '\\' ) {
                ++s;
            } else if( s[0] == '\\' && s[1] == '"' ) {
                ++s;
            }
            *d++ = *s;
        }
        *d = '\0';
    }
}

static char *CopyOfParm()
{
    char        *p;
    unsigned    len;

    len = OptScanPtr - OptParm;
    p = (char *) CMemAlloc( len + 1 );
    memcpy( p, OptParm, len );
    p[ len ] = '\0';
    return( p );
}

static char *GetAFileName()
{
    char *fname;
    fname = CopyOfParm();
    StripQuotes( fname );
    return( fname );
}

static void Set_FH()
{
    if( OptParm == OptScanPtr ) {
        PCH_FileName = DEFAULT_PCH_NAME;
    } else {
        PCH_FileName = GetAFileName();
    }
}

static void Set_FHQ()
{
    CompFlags.no_pch_warnings = 1;
    Set_FH();
}

static void Set_FI()
{
    ForceInclude = GetAFileName();
}

static void Set_FLD()
{
    CompFlags.use_long_double = 1;
}

static void Set_FO()
{
    CMemFree( ObjectFileName );
    ObjectFileName = GetAFileName();
    CompFlags.cpp_output_to_file = 1;   /* in case '-p' option */
}

static void Set_FR()
{
    CMemFree( ErrorFileName );
    ErrorFileName = GetAFileName();
    if( *ErrorFileName == '\0' ){
        CMemFree( ErrorFileName );
        ErrorFileName = NULL;
    }
}

#if _CPU == 8086 || _CPU == 386
static void SetCodeClass()     { CodeClassName = CopyOfParm(); }
static void SetDataSegName()
{
    SwData.nd_used = 1;
    DataSegName = CopyOfParm();
    SegData = -1;
    if( *DataSegName == '\0' ) {
        CMemFree( DataSegName );
        DataSegName = NULL;
    }
}
static void SetTextSegName()   { TextSegName = CopyOfParm(); }
static void SetGroup()         { GenCodeGroup = CopyOfParm(); }
#endif
static void SetModuleName()    { ModuleName = CopyOfParm(); }

static void SetAPILogging()    { GenSwitches |= ECHO_API_CALLS; }

#ifndef NDEBUG
#ifdef ASM_OUTPUT
static void SetAsmListing()    { TargetSwitches |= ASM_OUTPUT; }
#endif
#ifdef OWL_LOGGING
static void SetOwlLogging()    { TargetSwitches |= OWL_LOGGING; }
#endif
#endif

static void SetInclude()
{
    char *fname;

    fname = GetAFileName();
    AddIncList( fname );
    CMemFree( fname );
}

static void SetReadOnlyDir(){
    char *dirpath;

    dirpath = GetAFileName();
    SrcFileReadOnlyDir( dirpath );
    CMemFree( dirpath );
}

static void SetCharType()
{
    SetSignedChar();
    CompFlags.signed_char = 1;
}

#if _CPU == 8086 || _CPU == 386
static void Set_RE()           { CompFlags.rent = 1; }
static void Set_RI()           { CompFlags.returns_promoted = 1; }
static void Set_R()            { CompFlags.save_restore_segregs = 1; }
static void Set_SG()           { CompFlags.sg_switch_used = 1; }
static void Set_ST()           { CompFlags.st_switch_used = 1; }
#endif
#if _MACHINE == _ALPHA
static void Set_SI()           { TargetSwitches |= STACK_INIT; }
#endif
static void Set_S()            { Toggles &= ~TOGGLE_CHECK_STACK; }

static void Set_TP()
{
    char *togname;
    togname = CopyOfParm();
    SetToggleFlag( togname, TRUE );
    CMemFree( togname );
}

static void SetDataThreshHold(){ DataThreshold = OptValue; }

static void Set_U()
{
    char *name;
    name = CopyOfParm();
    AddUndefName( name );
    CMemFree( name );
}
static void Set_V()            { CompFlags.generate_prototypes = 1; }

static void Set_WE()           { CompFlags.warnings_cause_bad_exit = 1; }
static void Set_WO()           { CompFlags.using_overlays = 1; }
static void Set_WX()           { WngLevel = 4; }
static void SetWarningLevel()  { WngLevel = OptValue; }
static void Set_WCD()          { EnableDisableMessage( 0, OptValue ); }
static void Set_WCE()          { EnableDisableMessage( 1, OptValue ); }

#if _CPU == 386
static void Set_XGV()          { GenSwitches |= INDEXED_GLOBALS; }
#endif

static void Set_XBSA()
{
    CompFlags.unaligned_segs = 1;
}

#if _MACHINE == _ALPHA
static void Set_XD()           { TargetSwitches |= EXCEPT_FILTER_USED; }
#endif

static void Set_ZA99()
{
    PreDefine_Macro( "__STDC_VERSION__=199901L" );
    CompFlags.c99_extensions = 1;
}

static void Set_ZA()
{
    CompFlags.extensions_enabled = 0;
    CompFlags.unique_functions = 1;
    TargetSwitches &= ~I_MATH_INLINE;
}

static void SetStrictANSI()
{
    CompFlags.strict_ANSI = 1;
    Set_ZA();
}

#if _CPU == 8086 || _CPU == 386
static void Set_ZC()
{
    CompFlags.strings_in_code_segment = 1;
    CompFlags.zc_switch_used = 1;       /* 04-jun-91 */
    TargetSwitches |= CONST_IN_CODE;
}
static void Set_ZDF()          { SwData.peg_ds_used = 1; SwData.peg_ds_on = 0; }
static void Set_ZDP()          { SwData.peg_ds_used = 1; SwData.peg_ds_on = 1; }
static void Set_ZDL()          { TargetSwitches |= LOAD_DS_DIRECTLY; }
static void Set_ZFF()          { SwData.peg_fs_used = 1; SwData.peg_fs_on = 0; }
static void Set_ZFP()          { SwData.peg_fs_used = 1; SwData.peg_fs_on = 1; }
static void Set_ZGF()          { SwData.peg_gs_used = 1; SwData.peg_gs_on = 0; }
static void Set_ZGP()          { SwData.peg_gs_used = 1; SwData.peg_gs_on = 1; }
#endif
static void Set_ZE()           { CompFlags.extensions_enabled = 1; }
static void Set_ZG()
{
    CompFlags.generate_prototypes = 1;
    CompFlags.dump_prototypes     = 1;
}

static void Set_ZI()           { CompFlags.extra_stats_wanted = 1; }

static void Set_ZK()           { character_encoding = ENC_ZK; }
static void Set_ZK0()          { character_encoding = ENC_ZK0; }
static void Set_ZK1()          { character_encoding = ENC_ZK1; }
static void Set_ZK2()          { character_encoding = ENC_ZK2; }
static void Set_ZK3()          { character_encoding = ENC_ZK3; }
static void Set_ZKL()          { character_encoding = ENC_ZKL; }
static void Set_ZKU()
{
    character_encoding = ENC_ZKU;
    unicode_CP = OptValue;
}
static void Set_ZK0U()         { character_encoding = ENC_ZK0U; }

static void Set_ZL()           { CompFlags.emit_library_with_main = 0; }
static void Set_ZLF()          { CompFlags.emit_library_any  = 1; }
static void Set_ZLD()          { CompFlags.emit_dependencies = 0; }
static void Set_ZLS()          { CompFlags.emit_targimp_symbols = 0; }
static void Set_ZEV()          { CompFlags.unix_ext = 1; }
static void Set_ZM()
{
    CompFlags.multiple_code_segments = 1;
    CompFlags.zm_switch_used = 1;
}
static void Set_ZPW()          { CompFlags.slack_byte_warning = 1; }

#if _CPU == 8086 || _CPU == 386
static void Set_ZRO()
{
    GenSwitches |= FPU_ROUNDING_OMIT;
    GenSwitches &= ~FPU_ROUNDING_INLINE;
}
#endif

#if _CPU == 386
static void Set_ZRI()
{
    GenSwitches |= FPU_ROUNDING_INLINE;
    GenSwitches &= ~FPU_ROUNDING_OMIT;
}
#endif

static void Set_ZQ()           { CompFlags.quiet_mode = 1; }
static void Set_ZS()           { CompFlags.check_syntax = 1; }

#if _CPU == 8086 || _CPU == 386
static void Set_EQ()           { CompFlags.no_conmsg  = 1; }