Beispiel #1
0
/*
 * Translate options related to C++ and not to C.
 */
static void c_plus_plus_opts( struct XlatStatus *status, OPT_STORAGE *cmdOpts,
                              CmdLine *compCmdLine )
/**************************************************************************/
{
    status = status;
    AppendCmdLine( compCmdLine, CL_C_CPP_OPTS_SECTION, "-xs" );
    if( cmdOpts->_10x ) {
        AppendCmdLine( compCmdLine, CL_C_CPP_OPTS_SECTION, "-zo" );
    }
}
Beispiel #2
0
/*
 * Translate options related to precompiled headers.
 */
static void precomp_header_opts( struct XlatStatus *status,
                                 OPT_STORAGE *cmdOpts, CmdLine *compCmdLine )
/***************************************************************************/
{
    char *              newpath;

    status = status;
    if( cmdOpts->Fp ) {
        newpath = PathConvert( cmdOpts->Fp_value->data, '"' );
        AppendFmtCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-fhq=%s", newpath );
    } else {
        switch( cmdOpts->precomp_headers ) {
          case OPT_precomp_headers_Yc:
            /* fall through */
          case OPT_precomp_headers_Yu:
            /* fall through */
          case OPT_precomp_headers_YX:
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-fhq" );
            break;
          case OPT_precomp_headers_default:
            break;
          default:
            Zoinks();
        }
    }

    if( cmdOpts->Yd ) {
        /* done by default */
    }
}
Beispiel #3
0
/*
 * Link any object and library files.  Returns LINK_NOACTION if there was no
 * file to compile, LINK_ERROR if the linker returned a bad status code or
 * if the compiler could not be spawned, or else LINK_SUCCESS if everything
 * went smoothly.
 */
static int link( const OPT_STORAGE *cmdOpts, CmdLine *linkCmdLine )
/*****************************************************************/
{
    char **             args;
    char *              filename;
    int                 fileType;
    int                 numFiles;
    int                 rc;
    char *              defFile;
    char *              prevDefFile = NULL;

    cmdOpts = cmdOpts;
    /*** Process all object and library file names ***/
    for( numFiles=0; ; numFiles++ ) {
        filename = GetNextFile( &fileType, TYPE_OBJ_FILE, TYPE_LIB_FILE, TYPE_RES_FILE, TYPE_INVALID_FILE );
        if( filename == NULL )  break;
        AppendCmdLine( linkCmdLine, CL_L_FILENAMES_SECTION, filename );
    }

    /*** Process .def files ***/
    for( ;; ) {
        defFile = GetNextFile( NULL, TYPE_DEF_FILE, TYPE_INVALID_FILE );
        if( defFile == NULL )  break;
        if( prevDefFile != NULL ) {
            Warning( "Overriding %s with %s", prevDefFile, defFile );
        }
        prevDefFile = defFile;
    };
    if( prevDefFile != NULL ) {
        AppendFmtCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/DEF:%s", prevDefFile );
    } else {
        if( numFiles == 0 )  return( LINK_NOACTION );
    }

    /*** Spawn the linker ***/
    AppendCmdLine( linkCmdLine, CL_L_PROGNAME_SECTION, LINKER );
    args = MergeCmdLine( linkCmdLine, INVALID_MERGE_CMDLINE );
    rc = spawnvp( P_WAIT, LINKER, (const char **)args );
    if( rc != 0 ) {
        if( rc == -1  ||  rc == 255 ) {
            FatalError( "Unable to execute '%s'", LINKER );
        } else {
            return( LINK_ERROR );
        }
    }
    return( LINK_SUCCESS );
}
Beispiel #4
0
/*
 * Spawn the Watcom wmake.  Returns NMAKE_ERROR if wmake returned a bad
 * status code or if it could not be spawned, or else NMAKE_SUCCESS if
 * everything went smoothly.
 */
static int nmake( const OPT_STORAGE *cmdOpts, CmdLine *cmdLine )
/**************************************************************/
{
    char **             args;
    int                 rc;
    int                 count;
    char *              cwd;
    char                flagstmp[32] = {0};

    /*** get value for MAKEDIR field ***/
    cwd = getcwd( NULL, 0 );

    /*** construct MAKEFLAGS field ***/
    if( cmdOpts->a )      strcat(flagstmp, "A");
    if( cmdOpts->c )      strcat(flagstmp, "C");
    if( cmdOpts->d )      strcat(flagstmp, "D");
    if( cmdOpts->e )      strcat(flagstmp, "E");
    if( cmdOpts->nologo ) strcat(flagstmp, "L");
    if( cmdOpts->n )      strcat(flagstmp, "N");
    if( cmdOpts->p )      strcat(flagstmp, "P");
    if( cmdOpts->r )      strcat(flagstmp, "R");
    if( cmdOpts->s )      strcat(flagstmp, "S");
    if( cmdOpts->u )      strcat(flagstmp, "U");
    if( cmdOpts->y )      strcat(flagstmp, "Y");

    /*** pass builtin macros to wmake, so nmake wrapper gets called in recursive actions ***/
    AppendFmtCmdLine( cmdLine, NMAKE_OPTS_SECTION, "MAKE=\"%s\"", "nmake" );
    AppendFmtCmdLine( cmdLine, NMAKE_OPTS_SECTION, "MAKEDIR=\"%s\"", cwd );
    AppendFmtCmdLine( cmdLine, NMAKE_OPTS_SECTION, "MAKEFLAGS=\"%s\"", flagstmp );

    /*** merge commands ***/
    AppendCmdLine( cmdLine, NMAKE_PROGNAME_SECTION, MAKE );
    args = MergeCmdLine( cmdLine, INVALID_MERGE_CMDLINE );

    /*** Spawn the wmake ***/
    if( cmdOpts->showwopts ) {
        for( count=0; args[count]!=NULL; count++ ) {
            fprintf( stderr, "%s ", args[count] );
        }
        fprintf( stderr, "\n" );
    }
    if( !cmdOpts->noinvoke ) {
        rc = spawnvp( P_WAIT, MAKE, (const char **)args );
        if( rc != 0 ) {
            if( rc == -1  ||  rc == 255 ) {
                FatalError( "Unable to execute '%s'", MAKE );
            } else {
                return( NMAKE_ERROR );
            }
        }
    }
    DestroyCmdLine( cmdLine );

    return( NMAKE_SUCCESS );
}
Beispiel #5
0
/*
 * Spawn the resource compiler.
 */
static int res_compile( const OPT_STORAGE *cmdOpts, CmdLine *cmdLine )
/********************************************************************/
{
    char **             args;
    char *              filename;
    char *              nextFilename;
    int                 rc;
    int                 count;

    /*** Get the name of the .rc file to compiler ***/
    filename = GetNextFile( NULL, TYPE_RC_FILE, TYPE_INVALID_FILE );
    if( filename == NULL )  return( RC_NOACTION );
    nextFilename = GetNextFile( NULL, TYPE_RC_FILE, TYPE_INVALID_FILE );
    if( nextFilename != NULL ) {
        FatalError( "Can only compile one file at a time" );
    }

    /*** Prepare to spawn the resource compiler ***/
    AppendCmdLine( cmdLine, RC_PROGNAME_SECTION, RESCOMPILER );
    AppendCmdLine( cmdLine, RC_FILENAMES_SECTION, filename );
    args = MergeCmdLine( cmdLine, RC_PROGNAME_SECTION, RC_OPTS_SECTION,
                         RC_FILENAMES_SECTION, INVALID_MERGE_CMDLINE );

    /*** Spawn the compiler ***/
    if( cmdOpts->showwopts ) {
        for( count=0; args[count]!=NULL; count++ ) {
            fprintf( stderr, "%s ", args[count] );
        }
        fprintf( stderr, "\n" );
    }
    if( !cmdOpts->noinvoke ) {
        rc = spawnvp( P_WAIT, RESCOMPILER, (const char **)args );
        if( rc != 0 ) {
            if( rc == -1  ||  rc == 255 ) {
                FatalError( "Error executing '%s'", RESCOMPILER );
            } else {
                return( RC_ERROR );
            }
        }
    }
    return( RC_SUCCESS );
}
Beispiel #6
0
/*
 * Activate default options.
 */
static void default_opts(struct XlatStatus *status, OPT_STORAGE *cmdOpts,
                         CmdLine *compCmdLine, CmdLine *linkCmdLine )
{
    OPT_STRING *curr;

    status = status;
    /*** Emit default options if so desired ***/
    if (!cmdOpts->nowopts)
    {
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-bt=nt" );
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-zlf" );

        #ifdef __TARGET_386__
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-ei" );
        #endif

        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-zq" );
        AppendCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/nologo" );
    } /* if */

    /*** Add any options meant for the Watcom tools ***/
    if (cmdOpts->passwopts)
    {
        for (curr = cmdOpts->passwopts_value; curr; curr = curr->next)
        {
            AppendCmdLine(compCmdLine, CL_C_OPTS_SECTION, curr->data);
        }
    }
} /* default_opts() */
Beispiel #7
0
/*
 * Add one more parameter to the section specified by block.  Reallocates
 * memory if necessary, and does all necessary bookkeeping.  The stored
 * string is generated using the printf-style format string and any
 * additional parmameters.
 */
void AppendFmtCmdLine( CmdLine *cmdLine, int section, const char *format, ... )
/*****************************************************************************/
{
    static char         buf[BUFFER_SIZE];
    va_list             args;

    /*** Format it, then pass it though to AppendCmdLine ***/
    if( section < 0  ||  section >= cmdLine->numSections )  Zoinks();
    va_start( args, format );
    vsnprintf( buf, BUFFER_SIZE, format, args );
    va_end( args );
    AppendCmdLine( cmdLine, section, buf );
}
Beispiel #8
0
/*
 * Make a completely separate copy of a CmdLine.
 */
CmdLine *CloneCmdLine( const CmdLine *oldCmdLine )
/************************************************/
{
    CmdLine *           newCmdLine;
    int                 countSection;
    int                 countArg;

    newCmdLine = InitCmdLine( oldCmdLine->numSections );
    for( countSection=0; countSection<oldCmdLine->numSections; countSection++ ) {
        for( countArg=0; countArg<oldCmdLine[countSection].curItems; countArg++ ) {
            AppendCmdLine( newCmdLine, countSection, oldCmdLine[countSection].args[countArg] );
        }
    }

    return( newCmdLine );
}
Beispiel #9
0
/*
 * Spawn the Watcom linker.  Returns LINK_NOACTION if there was no file to
 * link, LINK_ERROR if the linker returned a bad status code or if it could
 * not be spawned, or else LINK_SUCCESS if everything went smoothly.
 */
static int link( const OPT_STORAGE *cmdOpts, CmdLine *cmdLine )
/*************************************************************/
{
    char **             args;
    int                 rc;
    char *              cmdFileName;
    FILE *              fp;
    int                 count;
    CmdLine *           spawnCmdLine;

    /*** Make the command file ***/
    args = MergeCmdLine( cmdLine, INVALID_MERGE_CMDLINE );
    cmdFileName = tmpnam( NULL );
    if( !cmdOpts->noinvoke ) {
        fp = fopen( cmdFileName, "wt" );
        if( fp == NULL ) {
            FatalError( "Cannot open temporary file '%s' -- aborting", cmdFileName );
        }
    }
    for( count=0; args[count]!=NULL; count++ ) {
        if( !cmdOpts->noinvoke ) {
            fprintf( fp, "%s\n", args[count] );
        }
        if( cmdOpts->showwopts ) {
            fprintf( stderr, "echo.%s%s%s\n",
                args[count], (count == 0 ? ">" : ">>"), cmdFileName );
        }
    }
    if( !cmdOpts->noinvoke ) {
        fclose( fp );
    }

    /*** Spawn the linker ***/
    spawnCmdLine = InitCmdLine( LINK_NUM_SECTIONS );
    AppendCmdLine( spawnCmdLine, LINK_PROGNAME_SECTION, LINKER );
    AppendFmtCmdLine( spawnCmdLine, LINK_OPTS_SECTION, "@%s", cmdFileName );
    args = MergeCmdLine( spawnCmdLine, INVALID_MERGE_CMDLINE );
    if( cmdOpts->showwopts ) {
        for( count=0; args[count]!=NULL; count++ ) {
            fprintf( stderr, "%s ", args[count] );
        }
        fprintf( stderr, "\n" );
    }
    if( !cmdOpts->noinvoke ) {
        rc = spawnvp( P_WAIT, LINKER, (const char **)args );
    }
    if( cmdOpts->showwopts ) {
        fprintf( stderr, "del %s\n", cmdFileName );
    }
    if( !cmdOpts->noinvoke ) {
        remove( cmdFileName );
        if( rc != 0 ) {
            if( rc == -1  ||  rc == 255 ) {
                FatalError( "Unable to execute '%s'", LINKER );
            } else {
                return( LINK_ERROR );
            }
        }
    }
    DestroyCmdLine( spawnCmdLine );

    return( LINK_SUCCESS );
}
Beispiel #10
0
/*
 * Compile any C and C++ files.  Returns COMPILE_NOACTION if there was no
 * file to compile, COMPILE_ERROR if the compiler returned a bad status code
 * or if the compiler could not be spawned, or else COMPILE_SUCCESS if
 * everything went smoothly.
 */
static int compile( const OPT_STORAGE *cmdOpts, CmdLine *compCmdLine )
/********************************************************************/
{
    CmdLine *           cloneCmdLine;
    char **             args = NULL;
    char *              filename;
    int                 fileType;
    char *              compiler = NULL;
    int                 rc;
    int                 alive = 1;
    int                 numCompiled = 0;
    char                drive[_MAX_DRIVE];
    char                dir[_MAX_DIR];
    char                fname[_MAX_FNAME];
    char                ext[_MAX_EXT];
    char                fullPath[_MAX_PATH];
    int                 count;

    /*** Process all the source files, in the order they were given ***/
    while( alive ) {
        filename = GetNextFile( &fileType, TYPE_C_FILE, TYPE_CPP_FILE,
                                TYPE_INVALID_FILE );
        if( filename == NULL )  break;

        /*** Prepare to spawn the compiler ***/
        cloneCmdLine = CloneCmdLine( compCmdLine );
        HandleFileTranslate( filename, cloneCmdLine, NULL );
        switch( fileType ) {
          case TYPE_C_FILE:
            compiler = C_COMPILER;
            AppendCmdLine( cloneCmdLine, CL_C_PROGNAME_SECTION, compiler );
            AppendCmdLine( cloneCmdLine, CL_C_FILENAMES_SECTION, filename );
            if( !cmdOpts->nowopts ) {
                AppendCmdLine( cloneCmdLine, CL_C_OPTS_SECTION, "-aa" );
            }
            args = MergeCmdLine( cloneCmdLine, CL_C_PROGNAME_SECTION,
                                 CL_C_MACROS_SECTION, CL_C_OPTS_SECTION,
                                 CL_C_FILENAMES_SECTION,
                                 INVALID_MERGE_CMDLINE );
            break;
          case TYPE_CPP_FILE:
            compiler = CPP_COMPILER;
            AppendCmdLine( cloneCmdLine, CL_C_PROGNAME_SECTION, compiler );
            AppendCmdLine( cloneCmdLine, CL_C_FILENAMES_SECTION, filename );
            args = MergeCmdLine( cloneCmdLine, CL_C_PROGNAME_SECTION,
                                 CL_C_MACROS_SECTION, CL_C_OPTS_SECTION,
                                 CL_C_CPP_OPTS_SECTION,
                                 CL_C_FILENAMES_SECTION,
                                 INVALID_MERGE_CMDLINE );
            break;
          default:
            Zoinks();
        }

        /*** Spawn the compiler ***/
        _splitpath( filename, drive, dir, fname, ext );
        fprintf( stderr, "%s%s\n", fname, ext ); /* print name of file we're compiling */
        if( cmdOpts->showwopts ) {
            for( count=0; args[count]!=NULL; count++ ) {
                fprintf( stderr, "%s ", args[count] );
            }
            fprintf( stderr, "\n" );
        }
        if( !cmdOpts->noinvoke ) {
            rc = spawnvp( P_WAIT, compiler, (const char **)args );
            if( rc != 0 ) {
                if( rc == -1  ||  rc == 255 ) {
                    FatalError( "Unable to execute '%s'", compiler );
                } else {
                    return( COMPILE_ERROR );
                }
            }
        }

        /*** Add the object file to the linker list, observe -Fo ***/
        if( cmdOpts->Fo ) {
            AddFile( TYPE_OBJ_FILE, PathConvert( cmdOpts->Fo_value->data, '"' ) );
        } else {
            _makepath( fullPath, NULL, NULL, fname, ".obj" );
            AddFile( TYPE_OBJ_FILE, fullPath );
        }

        /*** Prepare for the next iteration ***/
        DestroyCmdLine( cloneCmdLine );
        numCompiled++;
    }

    if( numCompiled > 0 ) {
        return( COMPILE_SUCCESS );
    } else {
        return( COMPILE_NOACTION );
    }
}
Beispiel #11
0
/*
 * Activate options which have been parsed but not yet turned on.
 */
static void merge_opts( struct XlatStatus *status, OPT_STORAGE *cmdOpts,
                        CmdLine *compCmdLine, CmdLine *linkCmdLine )
/**********************************************************************/
{
    char                buf[128];
    char *              macro;

    /*** Handle /D and /U ***/
    for( ;; ) {                                 /* defines */
        macro = GetNextDefineMacro();
        if( macro == NULL )  break;
        AppendFmtCmdLine( compCmdLine, CL_C_MACROS_SECTION, "-d%s", macro );
    }
    for( ;; ) {                                 /* undefines */
        macro = GetNextUndefineMacro();
        if( macro == NULL )  break;
        AppendFmtCmdLine( compCmdLine, CL_C_MACROS_SECTION, "-u%s", macro );
    }

    /*** Merge optimization options ***/
    if( status->opt_od ) {
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-od" );
    } else {
        strcpy( buf, "-o" );
        #ifdef __TARGET_386__
            if( status->opt_of )   strcat( buf, "f" );
            if( status->opt_or )   strcat( buf, "r" );
        #endif
        if( status->opt_oa )       strcat( buf, "a" );
        if( status->opt_oi )       strcat( buf, "i" );
        if( status->opt_ol )       strcat( buf, "l" );
        if( status->opt_ol_plus )  strcat( buf, "l+" );
        if( status->opt_om )       strcat( buf, "m" );
        if( status->opt_on )       strcat( buf, "n" );
        if( status->opt_op )       strcat( buf, "p" );
        if( status->opt_os )       strcat( buf, "s" );
        if( status->opt_ot )       strcat( buf, "t" );
        if( status->opt_ox )       strcat( buf, "x" );
        if( strcmp( buf, "-o" ) != 0 ) {
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, buf );
        }
    }

    /*** Handle debugging options ***/
    switch( status->debugLevel ) {
      case 0:
        /* no debugging info */
        break;
      case 1:
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-d1" );
        break;
      case 2:
        if (!cmdOpts->lesswd) {
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-d2" );
        } else {
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-d1" );
        }
        break;
      default:
        Zoinks();
    }

    if( !status->charTypeUnsigned ) {
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-j" );
    }
    AppendFmtCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-w%d", status->warnLevel );

    if( cmdOpts->showwopts ) {
        AppendCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/showwopts" );
    }

    if( cmdOpts->noinvoke ) {
        AppendCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/noinvoke" );
    }

    if( cmdOpts->nowopts ) {
        AppendCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/nowopts" );
    }
}
Beispiel #12
0
/*
 * Parse linker options.
 */
static void linker_opts( struct XlatStatus *status, OPT_STORAGE *cmdOpts,
                         CmdLine *linkCmdLine )
/***********************************************************************/
{
    OPT_STRING *        optStr;
    char *              newpath;

    if( cmdOpts->F ) {
        AppendFmtCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/STACK:%s",
                          cmdOpts->F_value->data );
    }

    if( cmdOpts->Fe ) {
        AppendFmtCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/OUT:%s",
                          cmdOpts->Fe_value->data );
    }

    optStr = cmdOpts->o_value;
    if( cmdOpts->o_value != NULL ) {
        newpath = PathConvert( optStr->data, '"' );
        AppendFmtCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/OUT:%s",
        newpath );
    }

    if( cmdOpts->Fm ) {
        if( cmdOpts->Fm_value != NULL ) {
            AppendFmtCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/MAP:%s",
                              cmdOpts->Fm_value->data );
        } else {
            AppendCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/MAP" );
        }
    }

    if( cmdOpts->LD ) {
        AppendCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/DLL" );
    }

    if( cmdOpts->link ) {
        optStr = cmdOpts->link_value;
        while( optStr != NULL ) {
            AppendFmtCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "%s",
                              optStr->data );
            optStr = optStr->next;
        }
    }

    switch( cmdOpts->debug_info ) {
      case OPT_debug_info_Zd:
        AppendCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/DEBUG" );
        status->debugLevel = 1;
        break;
      case OPT_debug_info_Z7:
        /* fall through */
      case OPT_debug_info_Zi:
        AppendCmdLine( linkCmdLine, CL_L_OPTS_SECTION, "/DEBUG" );
        status->debugLevel = 2;
        break;
      case OPT_debug_info_default:
        /* do nothing */
        break;
      default:
        Zoinks();
    }
}
Beispiel #13
0
/*
 * Translate options related to optimization.
 */
static void optimization_opts( struct XlatStatus *status,
                               OPT_STORAGE *cmdOpts, CmdLine *compCmdLine )
/*************************************************************************/
{
    if( cmdOpts->opt_level != OPT_opt_level_Od ) {
        status->opt_od = 0;

        switch( cmdOpts->opt_level ) {
          case OPT_opt_level_O1:                /* minimize size */
            cmdOpts->Og = 1;
            cmdOpts->opt_size_time = OPT_opt_size_time_Os;
            cmdOpts->Oy = 1;
            cmdOpts->Ob_value = 1;
            cmdOpts->stack_probes = OPT_stack_probes_Gs;
            cmdOpts->Gf = 1;
            cmdOpts->GF = 1;
            cmdOpts->Gy = 1;
            break;
          case OPT_opt_level_O2:                /* maximize speed */
            cmdOpts->Og = 1;
            cmdOpts->Oi = 1;
            cmdOpts->opt_size_time = OPT_opt_size_time_Ot;
            cmdOpts->Oy = 1;
            cmdOpts->Ob_value = 1;
            cmdOpts->stack_probes = OPT_stack_probes_Gs;
            cmdOpts->Gf = 1;
            cmdOpts->GF = 1;
            cmdOpts->Gy = 1;
            break;
          case OPT_opt_level_Ox:
            cmdOpts->Ob_value = 1;
            cmdOpts->Og = 1;
            cmdOpts->Oi = 1;
            cmdOpts->opt_size_time = OPT_opt_size_time_Ot;
            cmdOpts->Oy = 1;
            cmdOpts->stack_probes = OPT_stack_probes_Gs;
            status->opt_ol_plus = 1;
            status->opt_om = 1;
            status->opt_on = 1;
            status->opt_ox = 1;
          case OPT_opt_level_default:
            /* let the compiler use its default */
            break;
          default:
            Zoinks();
        }


        if( cmdOpts->Oa ) {
            status->opt_oa = 1;
        }

        if( cmdOpts->Ob_value == 0 ) {
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-oe=0" );
        }

        if( cmdOpts->Og ) {
            status->opt_ol = 1;
            status->opt_ot = 1;
        }

        if( cmdOpts->Oi ) {
            status->opt_oi = 1;
        }

        if( cmdOpts->Op ) {
            status->opt_op = 1;
        }

        #ifdef __TARGET_386__
            if( cmdOpts->Oy ) {
                status->opt_of = 0;
            }
        #endif
    }

    switch( cmdOpts->opt_size_time ) {
      case OPT_opt_size_time_Os:
        status->opt_os = 1;
        break;
      case OPT_opt_size_time_Ot:
        status->opt_ot = 1;
        break;
      case OPT_opt_size_time_default:
        break;
      default:
        Zoinks();
    }
}
Beispiel #14
0
/*
 * Translate options related to object files.
 */
static void object_opts( struct XlatStatus *status, OPT_STORAGE *cmdOpts,
                         CmdLine *compCmdLine )
/***********************************************************************/
{
    char *              newpath;

    if( cmdOpts->Fo && !status->disable_Fo ) {
        newpath = PathConvert( cmdOpts->Fo_value->data, '"' );
        AppendFmtCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-fo=%s", newpath );
    }

    if( cmdOpts->Gh ) {
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-ep" );
    }

    if( cmdOpts->Gy ) {
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-zm" );
    }

    if( cmdOpts->LD ) {
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-bd" );
        if( cmdOpts->threads_linking==OPT_threads_linking_default ) {
            cmdOpts->threads_linking = OPT_threads_linking_MT;
        }
    }

    switch( cmdOpts->threads_linking ) {
      case OPT_threads_linking_MD:
      case OPT_threads_linking_MDd:
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-bm" );
        if( !cmdOpts->_10x ) {
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-br" );
        }
        break;
      case OPT_threads_linking_ML:
      case OPT_threads_linking_MLd:
        break;
      case OPT_threads_linking_MT:
      case OPT_threads_linking_MTd:
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-bm" );
        break;
      case OPT_threads_linking_default:
        /* let the compiler use its default */
        break;
      default:
        Zoinks();
    }

    switch( cmdOpts->debug_info ) {
      case OPT_debug_info_Z7:
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-hd" );
        status->debugLevel = 2;
        break;
      case OPT_debug_info_Zd:
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-hd" );
        status->debugLevel = 1;
        break;
      case OPT_debug_info_Zi:
        /* unsupported */
      case OPT_debug_info_default:
        /* do nothing */
        break;
      default:
        Zoinks();
    }

    if( cmdOpts->Zl ) {
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-zl" );
    }

    if( cmdOpts->Zp ) {
        AppendFmtCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-zp%d",
                          cmdOpts->Zp_value );
    }
}
Beispiel #15
0
/*
 * Parse various options which defy categorization.
 */
static void misc_opts( struct XlatStatus *status, OPT_STORAGE *cmdOpts,
                       CmdLine *compCmdLine )
/*********************************************************************/
{
    if( cmdOpts->J ) {
        status->charTypeUnsigned = 1;
    }

    switch( cmdOpts->warn_level ) {
      case OPT_warn_level_w:
        status->warnLevel = 0;
        break;
      case OPT_warn_level_W:
        status->warnLevel = cmdOpts->W_value;
        break;
      case OPT_warn_level_default:
        /* use default value */
        break;
      default:
        Zoinks();
    }

    switch( cmdOpts->iso ) {
      case OPT_iso_Za:
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-za" );
        if( cmdOpts->iso_timestamp > cmdOpts->Op_timestamp ) {
            status->opt_op = 1;
        }
        break;
      case OPT_iso_Ze:
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-ze" );
        break;
      case OPT_iso_default:
        /* use default value */
        break;
      default:
        Zoinks();
    }

    if( cmdOpts->Zs ) {
        status->disable_c = 1;
        status->disable_FA = 1;
        status->disable_Fa = 1;
        status->disable_Fm = 1;
        status->disable_Fo = 1;
        AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-zs" );
    }

    if( !status->disable_c ) {
        if( cmdOpts->FR ) {
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-db" );
        }

        #ifdef __TARGET_386__
            switch( cmdOpts->arch_i86 ) {   /* what is the CPU */
              case OPT_arch_i86_G3:
                if( status->parmsInRegs ) {
                    AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-3r" );
                } else {
                    AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-3s" );
                }
                break;
              case OPT_arch_i86_G4:
              case OPT_arch_i86_GB:
              default:
                if( status->parmsInRegs ) {
                    AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-4r" );
                } else {
                    AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-4s" );
                }
                break;
              case OPT_arch_i86_G5:
                if( status->parmsInRegs ) {
                    AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-5r" );
                } else {
                    AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-5s" );
                }
                break;
            }
        #endif

        switch( cmdOpts->stack_probes ) {
          case OPT_stack_probes_Ge:
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-st" );
            break;
          case OPT_stack_probes_Gs:
        #ifndef __TARGET_AXP__
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-sg" );
        #else
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-s" );
        #endif
            break;
          case OPT_stack_probes_default:
            break;
          default:
            Zoinks();
        }

        if( cmdOpts->WX ) {
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-we" );
        }

        if( cmdOpts->Zg ) {
            status->disable_c = 1;
            status->disable_FA = 1;
            status->disable_Fa = 1;
            status->disable_Fm = 1;
            status->disable_Fo = 1;
            Warning( "Prototypes will be output to .def file(s), not standard output" );
            AppendCmdLine( compCmdLine, CL_C_OPTS_SECTION, "-v" );
        }
    }
}