cmdlnany.c

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

/***********************************************/
{
    char *p;

    p = reduceToOneString( h );
    if( o != NULL ) {
        CMemFree( *o );
        *o = p;
    }
    return( p );
}

int MergeIncludeFromEnv( char *env )
/**********************************/
{
    char *env_value;

    env_value = CppGetEnv( env );
    if( NULL != env_value ) {
        HFileAppend( env_value, strlen( env_value ) );
        return( 1 );
    }
    return( 0 );
}

void DefSwitchMacro( char *n )
/****************************/
{
    char *p;
    char buff[64];

    p = stpcpy( buff, "__SW_" );
    strcpy( p, n );
    PreDefineStringMacro( buff );
}

void ConcatBase10( char *buff, unsigned num )
/*******************************************/
{
    size_t len;
    char *dest;

    len = strlen( buff );
    dest = &buff[len];
    utoa( num, dest, 10 );
}

static void setTarget( char **n, char *t )
{
    if( *n ) {
        CMemFree( *n );
    }
    *n = strupr( t );
}

void SetTargetLiteral( char **n, char *t )
/****************************************/
{
    if( t != NULL ) {
        setTarget( n, strsave( t ) );
    } else {
        *n = t;
    }
}

int OPT_GET_ID( OPT_STRING **p )
{
    size_t len;
    char const *id;

    CmdRecogEquals();
    CmdScanChar();
    len = CmdScanId( &id );
    if( len != 0 ) {
        addString( p, id, len );
        return( 1 );
    }
    BadCmdLine( ERR_INVALID_OPTION_ID );
    return( 0 );
}

int OPT_GET_ID_OPT( OPT_STRING **p )
{
    if( CmdRecogEquals() || ! CmdDelimitChar() ) {
        return OPT_GET_ID( p );
    }
    addString( p, "", 0 );
    return( 1 );
}

int OPT_GET_FILE( OPT_STRING **p )
{
    size_t len;
    char const *fname;

    CmdRecogEquals();
    len = CmdScanFilename( &fname );
    if( len != 0 ) {
        addString( p, fname, len );
        stripQuotes( (*p)->data );
        return( 1 );
    }
    BadCmdLine( ERR_INVALID_OPTION_FILE );
    return( 0 );
}

int OPT_GET_FILE_OPT( OPT_STRING **p )
{
    size_t len;
    char const *fname;

    // handle leading option char specially
    if( CmdRecogEquals() || ! CmdDelimitChar() ) {
        // specified an '=' so accept -this-is-a-file-name.fil or /tmp/ack.tmp
        len = CmdScanFilename( &fname );
        if( len != 0 ) {
            addString( p, fname, len );
            stripQuotes( (*p)->data );
        } else {
            OPT_CLEAN_STRING( p );
        }
    }
    return( 1 );
}

int OPT_GET_PATH( OPT_STRING **p )
{
    size_t len;
    char const *path;

    CmdRecogEquals();
    len = CmdScanFilename( &path );
    if( len != 0 ) {
        addString( p, path, len );
        stripQuotes( (*p)->data );
        return( 1 );
    }
    BadCmdLine( ERR_INVALID_OPTION_PATH );
    return( 0 );
}

static void handleOptionEW( OPT_STORAGE *data, int value )
{
    data = data;
    CompFlags.ew_switch_used = value;
}

static void handleOptionEQ( OPT_STORAGE *data, int value )
{
    data = data;
    CompFlags.eq_switch_used = value;
}

static void procOptions(        // PROCESS AN OPTIONS LINE
    OPT_STORAGE *data,          // - options data
    char *str );                // - scan position in command line

static void handleOptionFC( OPT_STORAGE *data, int value )
{
    value = value;
    if( data->fc ) {
        data->fc = FALSE;
        if( CompFlags.batch_file_primary ) {
            if( CompFlags.batch_file_processing ) {
                BadCmdLine( ERR_FC_IN_BATCH_FILE );
            } else {
                BadCmdLine( ERR_FC_MORE_THAN_ONCE );
            }
        } else {
            CompFlags.batch_file_primary = TRUE;
            if( CompFlags.batch_file_processing ) {
                VBUF buf;
                if( CmdLnBatchRead( &buf ) ) {
                    CmdLnCtxPush( CTX_CLTYPE_FC );
                    procOptions( data, buf.buf );
                    CmdLnCtxPop();
                }
                CmdLnBatchFreeRecord( &buf );
            } else {
                CmdLnBatchOpen( data->fc_value->data );
                CMemFreePtr( &data->fc_value );
            }
        }
    }
}

#include "cmdlnpr2.gh"

static boolean openCmdFile(     // OPEN A COMMAND FILE
    char const *filename,       // - file name
    size_t size )               // - size of name
{
    char fnm[ _MAX_PATH ];      // - buffer for name

    stvcpy( fnm, filename, size );
    stripQuotes( fnm );
    return IoSuppOpenSrc( fnm, FT_CMD );
}

static char *get_env(           // GET ENVIRONMENT VAR
    const char *var,            // - variable name
    unsigned len )              // - length of name
{
    char buf[128];              // - used to make a string
    char *env;                  // - environment name

    if( len >= sizeof( buf ) ) {
        env = NULL;
    } else {
        stvcpy( buf, var, len );
        env = CppGetEnv( buf );
    }
    return env;
}

static void scanInputFile(       // PROCESS NAME OF INPUT FILE
    void )
{
    char filename[ _MAX_PATH ]; // - scanned file name
    size_t len;                 // - length of file name
    char const *fnm;            // - file name in command line

    len = CmdScanFilename( &fnm );
    ++CompInfo.compfile_max;
    if( CompInfo.compfile_max == CompInfo.compfile_cur ) {
        if( WholeFName == NULL ) {
            stvcpy( filename, fnm, len );
            stripQuotes( filename );
            WholeFName = FNameAdd( filename );
        } else {
            CErr1( ERR_CAN_ONLY_COMPILE_ONE_FILE );
        }
    }
}


static void processCmdFile(     // PROCESS A COMMAND FILE
    OPT_STORAGE *data )         // - option data
;


static void procOptions(        // PROCESS AN OPTIONS LINE
    OPT_STORAGE *data,          // - options data
    char *str )                 // - scan position in command line
{
    int c;                      // - next character
    char const *fnm;            // - scanned @ name
    char *env;                  // - environment name
    unsigned len;               // - length of file name

    if( indirectionLevel >= MAX_INDIRECTION ) {
        BadCmdLine( ERR_MAX_CMD_INDIRECTION );
    } else if( str != NULL ) {
        ++ indirectionLevel;
        CtxSwitchAddr( str );
        CmdScanInit( str );
        for(;;) {
            c = CmdScanWhiteSpace();
            if( c == '\0' ) break;
            CmdScanSwitchBegin();
            CmdLnCtxSwitch( CmdScanAddr() - 1 );
            if( c == '-'  ||  c == SwitchChar ) {
                if( OPT_PROCESS( data ) ) {
                    BadCmdLine( ERR_INVALID_OPTION );
                }
            } else if( c == '@' ) {
                CmdScanWhiteSpace();
                CmdScanUngetChar();
                len = CmdScanFilename( &fnm );
                env = get_env( fnm, len );
                if( NULL == env ) {
                    if( openCmdFile( fnm, len ) ) {
                        CmdLnCtxPushCmdFile( SrcFileCurrent() );
                        processCmdFile( data );
                        CmdLnCtxPop();
                    } else {
                        CmdLnCtxPushEnv( fnm );
                        BadCmdLine( ERR_BAD_CMD_INDIRECTION );
                        CmdLnCtxPop();
                    }
                } else {
                    CmdLnCtxPushEnv( fnm );
                    procOptions( data, env );
                    CmdLnCtxPop();
                }
            } else {
                CmdScanUngetChar();
                scanInputFile();
            }
        }
        -- indirectionLevel;
    }
}

static void processCmdFile(     // PROCESS A COMMAND FILE
    OPT_STORAGE *data )         // - option data
{
    VBUF rec;                   // - record for file
    int c;                      // - next character

    VbufInit( &rec );
    VStrNull( &rec );
    for(;;) {
        for(;;) {
            c = NextChar();
            if( c == LCHR_EOF ) break;
            if( c == '\n' ) break;
            if( c == '\r' ) break;
            VStrConcChr( &rec, c );
        }
        if( rec.used > 1 ) {
            procOptions( data, rec.buf );
        }
        for( ; ( c == '\n' ) || ( c == '\r' ); c = NextChar() );
        if( c == LCHR_EOF ) break;
        VStrNull( &rec );
        VStrConcChr( &rec, c );
    }
    VbufFree( &rec );
}

static int openUnicodeFile( char *filename )
{
    int fh;
    char fullpath[ _MAX_PATH ];

#if defined(__QNX__)
    _searchenv( filename, "ETC_PATH", fullpath );
    if( fullpath[0] == '\0' ) {
        #define ETC "/usr/watcom"
        strcpy( fullpath, ETC );
        strcpy( &fullpath[ sizeof( ETC ) - 1 ], filename );
    }
#else
    _searchenv( filename, "PATH", fullpath );
#endif
    fh = -1;
    if( fullpath[0] != '\0' ) {
        fh = open( fullpath, O_RDONLY | O_BINARY );
    }
    return( fh );
}

static void loadUnicodeTable( unsigned code_page )
{
    size_t amt;
    int fh;
    char filename[ _MAX_PATH ];
    char cp[ 16 ];

    ultoa( code_page, cp, 10 );
    strcpy( filename, "unicode." );
    strcat( filename, cp );
    fh = openUnicodeFile( filename );
    if( fh != -1 ) {
        amt = 256 * sizeof( unsigned short );
        if( read( fh, UniCode, amt ) != amt ) {
            CErr( ERR_IO_ERR, filename, strerror( errno ) );
        }
        close( fh );
    } else {
        CErr2p( ERR_CANT_OPEN_FILE, filename );
    }
}

static int debugOptionAfterOptOption( OPT_STORAGE *data )
{
    if( data->debug_info_timestamp > data->opt_level_timestamp ) {
        if( data->debug_info_timestamp > data->opt_size_time_timestamp ) {
            return( 1 );
        }
    }
    return( 0 );
}

static void analyseAnyTargetOptions( OPT_STORAGE *data )
{
    // quickly do the quiet option so the banner can be printed
    if( data->q || data->zq ) {
        CompFlags.quiet_mode = 1;
    }
    switch( data->char_set ) {
    case OPT_char_set_zku:
        CompFlags.use_unicode = 1;
        loadUnicodeTable( data->zku_value );
        break;
    case OPT_char_set_zk0u:
        CompFlags.jis_to_unicode = 1;
        /* fall through */
    case OPT_char_set_zk0:
        SetDBChar( 0 );
        break;
    case OPT_char_set_zk1:
        SetDBChar( 1 );
        break;
    case OPT_char_set_zk2:
        SetDBChar( 2 );
        break;
    case OPT_char_set_zkl:
        SetDBChar( -1 );
        break;
    }
    switch( data->exc_level ) {
    case OPT_exc_level_xs:
        CompFlags.excs_enabled = TRUE;
        CompInfo.dt_method_speced = DTM_TABLE;
        break;
    case OPT_exc_level_xst:
        CompFlags.excs_enabled = TRUE;
        CompInfo.dt_method_speced = DTM_DIRECT_TABLE;
        break;
    case OPT_exc_level_xss:
        CompFlags.excs_enabled = TRUE;
        CompInfo.dt_method_speced = DTM_TABLE_SMALL;
        break;
    case OPT_exc_level_xds:
        CompFlags.excs_enabled = FALSE;
        CompInfo.dt_method_speced = DTM_DIRECT_SMALL;
        break;
    case OPT_exc_level_xd:
    case OPT_exc_level_xdt:
    default:
        CompFlags.excs_enabled = FALSE;
        CompInfo.dt_method_speced = DTM_DIRECT;
        break;
    }
    switch( data->warn_level ) {
    case OPT_warn_level_w:
        WngLevel = data->w_value;
        break;
    case OPT_warn_level_wx:
        WngLevel = WLEVEL_MAX;
        break;
    default:
        WngLevel = WLEVEL_DEFAULT;
        break;
    }
    switch( data->file_83 ) {
    case OPT_file_83_fx:
        CompFlags.check_truncated_fnames = 0;
        break;
    case OPT_file_83_ft:
    default:
        CompFlags.check_truncated_fnames = 1;
        break;
    }
    switch( data->opt_level ) {
    case OPT_opt_level_ox:  /* -ox => -obmiler -s */
        GenSwitches &= ~ NO_OPTIMIZATION;
        GenSwitches |= BRANCH_PREDICTION;       // -ob
        GenSwitches |= LOOP_OPTIMIZATION;       // -ol
        GenSwitches |= INS_SCHEDULING;          // -or
        CmdSysSetMaxOptimization();             // -om
        CompFlags.inline_intrinsics = 1;        // -oi
#if 0   // Disabled - introduces too many problems which no one is ready to fix
        if( ! data->oe ) {
            data->oe = 1;                       // -oe
            // keep in sync with options.gml
            data->oe_value = 100;
        }
#endif
        PragToggle.check_stack = 0;             // -s
        break;
    case OPT_opt_level_od:
        GenSwitches |= NO_OPTIMIZATION;
        break;
    }
    switch( data->opt_size_time ) {
    case OPT_opt_size_time_ot:
        OptSize = 0;
        GenSwitches &= ~ NO_OPTIMIZATION;
        break;
    case OPT_opt_size_time_os:
        OptSize = 100;
        GenSwitches &= ~ NO_OPTIMIZATION;
        break;
    default:
        OptSize = 50;
        break;
    }
    switch( data->iso ) {
    case OPT_iso_za: