owcc.c

Open Watcom 的 C 编译器源代码

            } else if( strcmp( Word, "d" ) == 0 ) {
                DebugFlag = 5;
            }
            break;
        case 'c':           /* compile only */
            if( strcmp( Word, "c" ) == 0 ) {
                Flags.force_c = TRUE;
            } else if( strcmp( Word, "c++" ) == 0 ) {
                Flags.force_c_plus = TRUE;
            } else {
                Flags.no_link = TRUE;
            }
            /* fall through */
        case 'y':
            wcc_option = 0;
            break;
        case 'm':           /* memory model */
            if( Cmd[1] == 't' || Cmd[1] == 'T' ) { /* tiny model*/
                Word[0] = 's';              /* change to small */
                Flags.tiny_model = TRUE;
            }
            break;
        case 'p':
            Flags.no_link = TRUE;
            break;      /* this is a preprocessor option */
        case 'z':                   /* 12-jan-89 */
            switch( tolower( Cmd[1] ) ) {
            case 's':
                Flags.no_link = TRUE;
                break;
            case 'q':
                Flags.be_quiet = TRUE;
                break;
            case 'w':
                Flags.windows = TRUE;
            }
            break;
        case 'E':
            Flags.no_link = TRUE;
            c = 'p';
            Word = "l";
            break;
        case 'O':
            if (!OptArg)
                Word = "il";
            else if (isdigit(OptArg[0])) {
                int d = OptArg[0] - '0';
                if (d == 0)
                    OptArg = "d";
                else if (d == 1)
                    OptArg = "il";
                else if (d == 2)
                    OptArg = "natx";
                else if (d == 3)
                    OptArg = "natxl+";
                else
                    break;
                strcpy(Word, OptArg);
            } else
                break;
            break;
        case 'o':
            O_Name = strdup(OptArg);
            wcc_option = 0;
            break;
        case 'g':
            if ( !OptArg )
                Word = "2";
            else if ( !isdigit( OptArg[0] ) ) {
                c = 'h';
                goto parse_h;
            }
            c = 'd';
            goto parse_d;
        case 'S':
            Flags.do_disas = TRUE;
            Flags.no_link = TRUE;
            if ( DebugFlag == 0 ) {
                c = 'd';
                Word = "1";
                goto parse_d;
            }
            break;
        case 's':
            Flags.strip_all = 1;
            DebugFlag = 0;
            wcc_option = 0;
            break;
        case 'v':
            Flags.be_quiet = 0;
            wcc_option = 0;
            break;
        case 'W':
            if ( OptArg ) {
                if( strcmp( OptArg, "all" ) == 0 ) {
                    c = 'w';
                    strcpy( Word, "x" );
                }
                else if( strncmp( OptArg, "l,", 2 ) == 0 ) {
                    AddDirective( OptArg + 2 );
                    wcc_option = 0;
                }
                else if( strncmp( OptArg, "c,", 2 ) == 0 &&
                         strlen( OptArg ) >= 4 ) {
                    c = OptArg[3];
                    strcpy( Word, OptArg + 4 );
                }
            }
            break;
        }
        /* don't add linker-specific options */
        /* to compiler command line:     */

        if( wcc_option ) {
            addccopt( c, Word );
        }
        if (OptArg)
            free(Word);
    }
    if (Flags.be_quiet)
        addccopt('z', "q");
    if ( O_Name ) {
        if (Flags.no_link && !Flags.do_disas) {
            free(Obj_Name);
            Obj_Name = O_Name;
            strcat( CC_Opts, " -fo=" );
            strcat( CC_Opts, O_Name );
        } else {
            strcpy( Exe_Name, O_Name );
        }
        O_Name = NULL;
    }
    for ( i = 1; i < argc ; i++ ) {
        Word = argv[i];
        if( FileExtension( Word, ".lib" ) || FileExtension( Word, ".a" )) {
            strcat( Libs, Libs[0] != '\0' ? "," : " " );
            strcat( Libs, Word );
        } else {
            strcat( Files, Word );
            strcat( Files, " " );
        }
    }
    return( 0 );
}

static int useCPlusPlus( char *p )
{
    return
        strfcmp( p, ".cp" ) == 0 ||
        strfcmp( p, ".cpp" ) == 0 ||
#ifdef __UNIX__
        strcmp( p, ".c++" ) == 0 ||
        strcmp( p, ".C" ) == 0 ||
#endif
        strfcmp( p, ".cxx" ) == 0 ||
        strfcmp( p, ".cc" )  == 0 ||
        strfcmp( p, ".hpp" ) == 0 ||
        strfcmp( p, ".hxx" ) == 0 ;
}


static char *SrcName( char *name )
/********************************/
{
    char        *cc_name;
    char        *exename;
    char        *p;

    p = strrchr( name, '.' );
    if ( p == NULL || strpbrk( p, PATH_SEP_STR ) )
        p = name + strlen( name );
    if( strfcmp( p, ".asm" ) == 0 || stricmp( p, ".s" ) == 0 ) {
        exename = "wasm" EXE_EXT;
        cc_name = "wasm";
    } else {
        exename = CC EXE_EXT;            // assume C compiler
        cc_name = CC;
        if( ! Flags.force_c ) {
            if( Flags.force_c_plus || useCPlusPlus( p ) ) {
                exename = CCXX EXE_EXT;  // use C++ compiler
                cc_name = CCXX;
            }
        }
    }
    FindPath( exename, CC_Path );
    return( cc_name );
}

static  int  CompLink( void )
/***************************/
{
    int         rc;
    char        *p;
    char        *end;
    char        *file;
    char        *path;
    char        *cc_name;
    struct directives *d_list;
    char        errors_found;

    if( Flags.be_quiet ) {
        Fputnl( "option quiet", Fp );
    }

    fputs( DebugOptions[ DebugFlag ], Fp );
    Fputnl( "option dosseg", Fp );
    if( StackSize != NULL ) {
        fputs( "option stack=", Fp );
        Fputnl( StackSize, Fp );
    }
    if( Flags.link_for_sys ) {                  /* 10-jun-91 */
        fputs( "system ", Fp );
        Fputnl( SystemName, Fp );
    } else if ( Flags.is32bit ) {
  #if defined(__OS2__)
        Fputnl( "system os2v2", Fp );           /* 04-feb-92 */
  #elif defined(__NT__)
        Fputnl( "system nt", Fp );
  #elif defined(__LINUX__)
        Fputnl( "system linux", Fp );
        if ( ! Flags.strip_all )
            Fputnl( "option exportall", Fp );
  #else
        Fputnl( "system dos4g", Fp );
  #endif
    } else {
        if( Flags.windows ) {                   /* 15-mar-90 */
            Fputnl( "system windows", Fp );
        } else if( Flags.tiny_model ) {
            Fputnl( "system com", Fp );
        } else if( Flags.link_for_dos ) {
            Fputnl( "system dos", Fp );
        } else if( Flags.link_for_os2 ) {
            Fputnl( "system os2", Fp );
        } else {
#if defined(__OS2__)
            Fputnl( "system os2", Fp );
#else
            Fputnl( "system dos", Fp );
#endif
        }
    }
    for( d_list = Directive_List; d_list; d_list = d_list->next ) {
        Fputnl( d_list->directive, Fp );
    }

    errors_found = 0;                   /* 21-jan-92 */
    p = Files;
    while( *p != '\0' ) {
        if( *p == '"' ) {
            end = strpbrk(++p, "\"");        /* get quoted filespec */
        } else {
            end = strpbrk(p, " ");         /* get filespec */
        }
        if( end != NULL ) {
            *(end++) = 0;
            if( *end == ' ' ) end++;
        }
        strcpy( Word, p );
        cc_name = SrcName( Word );      /* if no extension, assume .c */

        file = GetName( Word );         /* get first matching filename */
        path = MakePath( Word );        /* isolate path portion of filespec */
        while( file != NULL ) {         /* while more filenames: */
            strcpy( Word, path );
            strcat( Word, file );
            if( ! FileExtension( Word, OBJ_EXT ) ) { // if not .obj, compile
                if( ! Flags.be_quiet ) {
                    PrintMsg( "       %s %s %s\n", cc_name, Word, CC_Opts );
                    fflush( stdout );
                }
                rc = spawnlp( P_WAIT, CC_Path, cc_name, Word, CC_Opts, NULL );
                if( rc != 0 ) {
                    if( rc == -1  ||  rc == 255 ) {
                        PrintMsg( WclMsgs[ UNABLE_TO_INVOKE_EXE ], CC_Path );
                    } else {
                        PrintMsg( WclMsgs[ COMPILER_RETURNED_A_BAD_STATUS ],
                                    Word );
                    }
                    errors_found = 1;           /* 21-jan-92 */
                }
                p = strrchr( file, '.' );
                if( p != NULL )  *p = NULLCHAR;
                strcpy( Word, file );
            }
            AddName( Word, Fp );
            if( Obj_List != NULL && Flags.do_disas ) {
                char *sfile;
                char *ofile = file;
                if (Exe_Name[0])
                    sfile = Exe_Name;
                else {
                    if( FileExtension( Word, OBJ_EXT ) ) { // if not .obj, compile
                        p = strrchr( file, '.' );
                        if( p != NULL )  *p = NULLCHAR;
                        strcpy( Word, file );
                    }
                    sfile = Word;
                    strcat( Word, ".s" );
                }
                memmove(sfile + 3, sfile, strlen(sfile) + 1);
                sfile[0] = '-';
                sfile[1] = 'l';
                sfile[2] = '=';
                if( ! Flags.be_quiet ) {
                    PrintMsg( "       %s -s -a %s %s\n", DIS, ofile, sfile );
                    fflush( stdout );
                }
                rc = spawnlp( P_WAIT, DIS, "-s", "-a", ofile, sfile, NULL );
                if( rc != 0 ) {
                    if( rc == -1  ||  rc == 255 ) {
                        PrintMsg( WclMsgs[ UNABLE_TO_INVOKE_EXE ], CC_Path );
                    } else {
                        PrintMsg( WclMsgs[ COMPILER_RETURNED_A_BAD_STATUS ],
                                    Word );
                    }
                }
            }
            if( Exe_Name[0] == '\0' ) {
#ifdef __UNIX__
                strcpy( Exe_Name, OUTPUTFILE );
#else
                p = strrchr( Word, '.' );
                if( p != NULL )  *p = NULLCHAR;
                strcpy( Exe_Name, Word );
#endif
            }
            file = GetName( NULL );     /* get next filename */
        }
        p = end;        /* get next filespec */
    }
    if( errors_found ) {
        puts( "" );
        return( 1 );            /* 21-jan-92 */
    }
    BuildLinkFile();

    if( ( Obj_List != NULL || Flags.do_link )  &&  Flags.no_link == FALSE ) {
        FindPath( "wlink" EXE_EXT, PathBuffer );
        if( ! Flags.be_quiet ) {
            puts( "" );
        }
        fflush( stdout );
        rc = spawnlp( P_WAIT, PathBuffer, LINK, Temp_Link, NULL );
        if( rc != 0 ) {
            if( rc == -1  ||  rc == 255 ) {
                PrintMsg( WclMsgs[ UNABLE_TO_INVOKE_EXE ], PathBuffer );
            } else {
                PrintMsg( WclMsgs[ LINKER_RETURNED_A_BAD_STATUS ] );
            }
            puts( "" );
            return( 2 );        /* return 2 to show Temp_File already closed */
        }
        if( Flags.do_cvpack ){
            FindPath( "cvpack" EXE_EXT, PathBuffer );
            rc = spawnlp( P_WAIT, PathBuffer, "cvpack", Exe_Name, NULL );
            if( rc != 0 ) {
                if( rc == -1  ||  rc == 255 ) {
                    PrintMsg( WclMsgs[ UNABLE_TO_INVOKE_EXE ], PathBuffer );
                } else {
                    PrintMsg( WclMsgs[ CVPACK_RETURNED_A_BAD_STATUS ] );
                }
                return( 2 );  /* return 2 to show Temp_File already closed */
            }
        }
    }
    return( 0 );
}


static  void  MakeName( char *name, char *ext )
/*********************************************/
{
    if( strrchr( name, '.' ) <= strpbrk( name, PATH_SEP_STR ) ) {
        strcat( name, ext );
    }
}