coptions.c

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

    { "wo",     0,              Set_WO },
    { "wx",     0,              Set_WX },
    { "w=#",    0,              SetWarningLevel },
#if _CPU == 386
    { "xgv",    0,              Set_XGV },
#endif
    { "xbsa",   0,              Set_XBSA },
#if _CPU == _AXP
    { "xd",     0,              Set_XD },
#endif
    { "za99",   0,              Set_ZA99 },
    { "zA",     0,              SetStrictANSI },
    { "za",     0,              Set_ZA },
#if _CPU == 8086 || _CPU == 386
    { "zc",     0,              Set_ZC },
    { "zdf",    0,              Set_ZDF },
    { "zdp",    0,              Set_ZDP },
    { "zdl",    0,              Set_ZDL },
    { "zff",    0,              Set_ZFF },
    { "zfp",    0,              Set_ZFP },
    { "zgf",    0,              Set_ZGF },
    { "zgp",    0,              Set_ZGP },
#endif
    { "ze",     0,              Set_ZE },
#if _CPU == 8086 || _CPU == 386
    { "zfw",    0,              Set_ZFW },
#endif
    { "zg",     0,              Set_ZG },
    { "zi",     0,              Set_ZI },
    { "zk0u",   0,              Set_ZK0U },
    { "zk0",    0,              Set_ZK0 },
    { "zk1",    0,              Set_ZK1 },
    { "zk2",    0,              Set_ZK2 },
    { "zk3",    0,              Set_ZK3 },
    { "zkl",    0,              Set_ZKL },
    { "zku=#",  0,              Set_ZKU },
    { "zk",     0,              Set_ZK },
    { "zld",    0,              Set_ZLD },
    { "zlf",    0,              Set_ZLF },
    { "zls",    0,              Set_ZLS },
    { "zl",     0,              Set_ZL },
    { "zm",     0,              Set_ZM },
    { "zpw",    0,              Set_ZPW },
    { "zp=#",   1,              SetPackAmount },
#if _CPU == _AXP
    { "zps",    0,              SetStructPack },
#endif
#if _CPU == 8086 || _CPU == 386
    { "zro",    0,              Set_ZRO },
#endif
#if _CPU == 386
    { "zri",    0,              Set_ZRI },
#endif
    { "zs",     0,              Set_ZS },
    { "zt=#",   256,            SetDataThreshHold },
#if _CPU == 8086 || _CPU == 386
    { "zu",     0,              Set_ZU },
#endif
    { "zev",    0,              Set_ZEV },
#if _CPU == 8086
    { "zW*",    0,              SetCheapWindows },
    { "zw*",    0,              SetWindows },
#endif
#if _CPU == 386
    { "zw",     0,              SetWindows },
    { "zz",     0,              Set_ZZ },
#endif
    { 0,        0,              0 },
};

static char *ProcessOption( struct option const *op_table, char *p, char *option_start )
{
    int         i;
    int         j;
    char        *opt;
    char        c;

    for( i = 0; ; i++ ) {
        opt = op_table[i].option;
        if( opt == NULL ) break;
        c = tolower( *p );
        if( c == *opt ) {
            OptValue = op_table[i].value;
            j = 1;
            for(;;) {
                ++opt;
                if( *opt == '\0' || *opt == '*' ) {
                    if( *opt == '\0' ) {
                        if( p - option_start == 1 ) {
                            // make sure end of option
                            if( !OptionDelimiter( p[j] ) ) break;
                        }
                    }
                    OptScanPtr = p + j;
                    op_table[i].function();
                    return( OptScanPtr );
                }
                if( *opt == '#' ) {             // collect a number
                    if( p[j] >= '0' && p[j] <= '9' ) {
                        OptValue = 0;
                        for(;;) {
                            c = p[j];
                            if( c < '0' || c > '9' ) break;
                            OptValue = OptValue * 10 + c - '0';
                            ++j;
                        }
                    }
                } else if( *opt == '$' ) {      // collect an identifer
                    OptParm = &p[j];
                    for(;;) {
                        c = p[j];
                        if( c == '\0' ) break;
                        if( c == '-' ) break;
                        if( c == ' ' ) break;
                        if( c == SwitchChar ) break;
                        ++j;
                    }
                } else if( *opt == '@' ) {      // collect a filename
                    OptParm = &p[j];
                    c = p[j];
                    if( c == '"' ){ // "filename"
                        for(;;){
                            c = p[++j];
                            if( c == '"' ){
                                ++j;
                                break;
                            }
                            if( c == '\0' )break;
                            if( c == '\\' ){
                                ++j;
                            }
                        }
                    }else{
                        for(;;) {
                            c = p[j];
                            if( c == '\0' ) break;
                            if( c == ' ' ) break;
                            if( c == '\t' ) break;
                            #if ! defined( __UNIX__ )
                                if( c == SwitchChar ) break;
                            #endif
                            ++j;
                        }
                    }
                } else if( *opt == '=' ) {      // collect an optional '='
                    if( p[j] == '=' || p[j] == '#' ) ++j;
                } else {
                    c = tolower( p[j] );
                    if( *opt != c ) {
                        if( *opt < 'A' || *opt > 'Z' ) break;
                        if( *opt != p[j] ) break;
                    }
                    ++j;
                }
            }
        }
    }
    if( op_table == Optimization_Options ) {
        p = BadCmdLine( ERR_INVALID_OPTIMIZATION, p );
    } else {
        p = BadCmdLine( ERR_INVALID_OPTION, option_start );
    }
    return( p );
}

static void ProcessSubOption( struct option const *op_table )
{
    char        *option_start;

    option_start = OptScanPtr - 2;
    for(;;) {
        OptScanPtr = ProcessOption( op_table, OptScanPtr, option_start );
        if( OptionDelimiter( *OptScanPtr ) ) break;
    }
}

static void SetOptimization( void )
{
    ProcessSubOption( Optimization_Options );
}

static void SetPreprocessOptions( void )
{
    CompFlags.cpp_output_requested = 1;
    if( !OptionDelimiter( *OptScanPtr ) ) {
        ProcessSubOption( Preprocess_Options );
    }
}

static char *CollectEnvOrFileName( char *str )
{
    char        *env;
    char        ch;

    while( *str == ' ' || *str == '\t' ) ++str;
    env = TokenBuf;
    for( ;; ) {
        ch = *str;
        if( ch == '\0' ) break;
        ++str;
        if( ch == ' ' ) break;
        if( ch == '\t' ) break;
        #if ! defined( __UNIX__ )
            if( ch == '-' ) break;
            if( ch == SwitchChar ) break;
        #endif
        *env++ = ch;
    }
    *env = '\0';
    return( str );
}

static char *ReadIndirectFile( void )
{
    char        *env;
    char        *str;
    int         handle;
    int         len;
    char        ch;

    env = NULL;
    handle = open( TokenBuf, O_RDONLY | O_BINARY );
    if( handle != -1 ) {
        len = filelength( handle );
        env = CMemAlloc( len + 1 );
        read( handle, env, len );
        env[len] = '\0';
        close( handle );
        // zip through characters changing \r, \n etc into ' '
        str = env;
        while( *str ) {
            ch = *str;
            if( ch == '\r' || ch == '\n' ) {
                *str = ' ';
            }
            #if ! defined( __UNIX__ )
                if( ch == 0x1A ) {      // if end of file
                    *str = '\0';        // - mark end of str
                    break;
                }
            #endif
            ++str;
        }
    }
    return( env );
}

#define MAX_NESTING 32

local void ProcOptions( char *str )
{
    unsigned    level;
    char        *save[MAX_NESTING];
    char        *buffers[MAX_NESTING];

    if( str != NULL ) {
        level = 0;
        buffers[0] = NULL;
        for(;;) {
            while( *str == ' ' || *str == '\t' ) ++str;     /* 16-mar-91 */
            if( *str == '@' && level < MAX_NESTING ) {
                save[level] = CollectEnvOrFileName( str + 1 );
                ++level;
                buffers[level] = NULL;
                str = FEGetEnv( TokenBuf );
                if( str == NULL ) {
                    str = ReadIndirectFile();
                    buffers[level] = str;
                }
                if( str != NULL )  continue;
                str = save[--level];
            }
            if( *str == '\0' ) {
                if( level == 0 ) break;
                if( buffers[level] != NULL ) {
                    CMemFree( buffers[level] );
                    buffers[level] = NULL;
                }
                str = save[--level];
                continue;
            }
            if( *str == '-'  ||  *str == SwitchChar ) {
                str = ProcessOption( CFE_Options, str + 1, str );
            } else {  /* collect  file name */
                char *beg, *p;
                int len;

                beg = str;
                if( *str == '"' ){
                    for(;;){
                        ++str;
                        if( *str == '"' ){
                            ++str;
                            break;
                        }
                        if( *str == '\0' ) break;
                        if( *str == '\\' ){
                            ++str;
                        }
                    }
                }else{
                    for(;;) {
                        if( *str == '\0' ) break;
                        if( *str == ' '  ) break;
                        if( *str == '\t'  ) break;              /* 16-mar-91 */
                        #if ! defined( __UNIX__ )
                            if( *str == SwitchChar ) break;
                        #endif
                        ++str;
                    }
                }
                len = str-beg;
                p = (char *) CMemAlloc( len + 1 );
                memcpy( p, beg, len );
                p[ len ] = '\0';
                StripQuotes( p );
                if( WholeFName != NULL ) {
                    /* more than one file to compile ? */
                    CBanner();
                    CErr1( ERR_CAN_ONLY_COMPILE_ONE_FILE );
                    CMemFree( WholeFName );
                }
                WholeFName = p;
            }
        }
    }
}

static void InitCPUModInfo( void )
{
    CodeClassName = NULL;
    PCH_FileName  = NULL;
    TargetSwitches = 0;
    TargSys = TS_OTHER;
#if _CPU == _AXP || _CPU == _PPC || _CPU == _SPARC || _CPU == _MIPS
    TextSegName   = ".text";
    DataSegName   = ".data";
    GenCodeGroup  = "";
    DataPtrSize   = TARGET_POINTER;
    CodePtrSize   = TARGET_POINTER;
    GenSwitches   = MEMORY_LOW_FAILS;
  #if _CPU == _AXP
    GenSwitches  |= OBJ_COFF;
  #else
    GenSwitches  |= OBJ_ELF;
  #endif
#elif _CPU == 386 || _CPU == 8086
    Stack87 = 8;
    TextSegName   = "";
    DataSegName   = "";
    GenCodeGroup  = "";
    CompFlags.register_conv_set = 0;
    CompFlags.register_conventions = 1;
    GenSwitches = MEMORY_LOW_FAILS;
#else
    #error InitCPUModInfo not configured for system
#endif
}

local void Define_Memory_Model( void )
{
#if _CPU == 8086 || _CPU == 386
    char        model;
#endif

    DataPtrSize = TARGET_POINTER;
    CodePtrSize = TARGET_POINTER;
    #if _CPU == 8086 || _CPU == 386
    switch( TargetSwitches & (BIG_CODE|BIG_DATA) ) {
    case 0:                     /* -ms */
        model = 's';
        if( TargetSwitches & FLAT_MODEL ) {     /* 06-apr-89 */
            Define_Macro( "__FLAT__" );
        } else {
            Define_Macro( "M_I86SM" );
            Define_Macro( "__SMALL__" );
            CompFlags.strings_in_code_segment = 0;      /* 01-sep-89 */
        }
        TargetSwitches &= ~CONST_IN_CODE;
        break;
    case BIG_CODE:                      /* -mm */
        model = 'm';
        WatcallInfo.cclass |= FAR;
        CodePtrSize = TARGET_FAR_POINTER;
        Define_Macro( "M_I86MM" );
        Define_Macro( "__MEDIUM__" );
        CompFlags.strings_in_code_segment = 0;  /* 01-sep-89 */
        TargetSwitches &= ~CONST_IN_CODE;
        break;
    case BIG_DATA:                      /* -mc */
        model = 'c';
        Define_Macro( "M_I86CM" );
        Define_Macro( "__COMPACT__" );
        DataPtrSize = TARGET_FAR_POINTER;                       /* 04-may-90 */
        break;
    case BIG_CODE | BIG_DATA:
        WatcallInfo.cclass |= FAR;
        CodePtrSize = TARGET_FAR_POINTER;                       /* 04-may-90 */
        if( TargetSwitches & CHEAP_POINTER ) {
            model = 'l';
            Define_Macro( "M_I86LM" );      /* -ml */
            Define_Macro( "__LARGE__" );
        } else {
            model = 'h';
            Define_Macro( "M_I86HM" );      /* -mh */
            Define_Macro( "__HUGE__" );
        }
        DataPtrSize = TARGET_FAR_POINTER;                       /* 04-may-90 */
        break;
    }
    #endif
    #if _CPU == 8086
        strcpy( CLIB_Name, "1clib?" );                          /* 15-may-00 */
        if( CompFlags.bm_switch_used ) {
            strcpy( CLIB_Name, "1clibmt?" );
        }
        if( CompFlags.bd_switch_used ) {
            if( TargSys == TS_WINDOWS ||
                TargSys == TS_CHEAP_WINDOWS ) {