ccmain.c

Open Watcom 的 C 编译器源代码

{
    #if _OS != _CMS
        char buff[ _MAX_PATH2 ];
        char *drive;
        char *dir;
        char *fname;
        char *ext;
        char *path;

        path = (template == NULL) ? WholeFName : template;

        _splitpath2( path, buff, &drive, &dir, &fname, &ext );
        if( forceext || template == NULL || ext[0] == '\0' ) {
            ext = extension;
        }
        if( fname[0] == '\0' || fname[0] == '*' ) {
            fname = ModuleName;
        }
        if( template == NULL ) {
            /* default object file goes in current directory */
            drive = "";
            dir = "";
        }
        _makepath( Buffer, drive, dir, fname, ext );
    #else
        char    *p;
        if( template == NULL )  template = WholeFName;
        strcpy( Buffer, template  );
        p = Buffer;
        while( *p != '\0' && *p != ' ' ) ++p;
        strcpy( p, extension );
    #endif
    return( Buffer );
}

char *GetSourceDepName( void )
{
    char buff[ _MAX_PATH2 ];
    char *drive;
    char *dir;
    char *fname;
    char *ext;

    _splitpath2( WholeFName, buff, &drive, &dir, &fname, &ext );

    return CreateFileName( SrcDepName, ext, FALSE );
}


char *ObjFileName( char *ext )
{
    return( CreateFileName( ObjectFileName, ext, FALSE ) );
}

char *DepFileName()
{
    return( CreateFileName( DependFileName, DEP_EXT, FALSE ) );
}

char *ErrFileName()
{
    if( ErrorFileName == NULL ) return( NULL );
    return( CreateFileName( ErrorFileName, ERR_EXT, FALSE ) );
}

void PrtChar( int c )
{
    if( ! CppPrinting() ) return;
    CppPutc( c );
}


static unsigned CppColumn = 0;
static unsigned CppWidth = 0;
static unsigned CommentChar = 0;
static unsigned CppFirstChar = 0;

void SetCppWidth( unsigned width )
{
    CppWidth = width - 1;
}

void CppComment( int ch )
{
    if( !CompFlags.cpp_output ) return;
    if( !CompFlags.keep_comments ) return;
    if( !CppPrinting() ) return;
    if( ch != 0 ) {
        if( CppColumn+2 >= CppWidth ) CppPutc( '\n' );
        CppPutc( '/' );
        CppPutc( ch );
    } else if( CommentChar == '*' ) {
        if( CppColumn+2 >= CppWidth ) CppPutc( '\n' );
        CppPutc( '*' );
        CppPutc( '/' );
//  } else if( CommentChar == '/' ) {
//      CppPutc( '\n' );
    }
    CommentChar = ch;
}


void CppPutc( int ch )
{

    if( CppFirstChar ) {
        CppFirstChar = 0;
        if( ch == '\n' ) {
            return;
        }
    }
    if( ch == '\n' ) {
        CppColumn = 0;
    } else if( CppColumn >= CppWidth ) {
        if( CommentChar == 0 ) {
           if( fputc( '\\', CppFile ) < 0 )goto werror;
        }
        if( fputc( '\n', CppFile ) < 0 )goto werror;
        if( CommentChar == '/' ) {
            if( fputc( '/', CppFile ) < 0 )goto werror;
            if( fputc( '/', CppFile ) < 0 )goto werror;
            CppColumn = 3;
        } else {
            CppColumn = 1;
        }
    } else {
        ++CppColumn;
    }
    if( fputc( ch, CppFile ) < 0 )goto werror;
    return;
werror:
    CloseFiles();   /* get rid of temp file */
    MyExit( 1 );     /* exit to DOS do not pass GO */
    return;
}


void CppPrtf( char *fmt, ... )
{
    va_list     arg;
    char        *p;
    char        *buff;

    buff = CMemAlloc( BufSize );
    va_start( arg, fmt );
    vsnprintf( buff, BufSize, fmt, arg );
    for( p = buff; *p != '\0'; ++p ) {
        CppPutc( *p );
    }
    va_end( arg );
    CMemFree( buff );
}


void OpenCppFile()
{
    char  *name = NULL;

    if( CompFlags.cpp_output_to_file ) {                /* 29-sep-90 */
        name = ObjFileName( CPP_EXT );
        CppFile = fopen( name, "w" );
    } else {
        CppFile = stdout;
    }
    CppColumn = 0;
    CppFirstChar = 1;
    if( CppFile == NULL ) {
        CantOpenFile( name );
        MyExit( 1 );
    } else {
        if( CppWidth == 0 ) {
            #if _OS == _CMS
                CppWidth = lrecl( fileno( CppFile ) )-1;
            #else
                CppWidth = ~0;
            #endif
        }
        setvbuf( CppFile, CPermAlloc( 512 ), _IOFBF, 512 );
    }
}


void OpenDefFile()
{
#if _OS != _CMS
    char buff[_MAX_PATH2];
    char name[_MAX_PATH ];
    char *fname;

    if( DefFName == NULL ) {
        _splitpath2( SrcFName, buff, NULL, NULL, &fname, NULL );
        _makepath( name, NULL, NULL, fname, DEF_EXT );
        DefFile = fopen( name, "w" );
    } else {
        DefFile = fopen( DefFName, "w" );
    }
    if( DefFile != NULL ) {
        setvbuf( DefFile, CPermAlloc( 32 ), _IOFBF, 32 );
    }
#else
    DefFile = fopen( DefFName, "w" );
#endif
}

FILE *OpenBrowseFile()
{
    char        buff[_MAX_PATH2];
    char        name[_MAX_PATH];
    char        *fname;
    FILE        *mbr_file;

    if( CompFlags.cpp_output_to_file ) {                /* 29-sep-90 */
        strcpy(   name,  CreateFileName( ObjectFileName, MBR_EXT, TRUE ) );
    } else {
        _splitpath2( SrcFName, buff, NULL, NULL, &fname, NULL );
        _makepath( name, NULL, NULL, fname, MBR_EXT );
    }
    mbr_file = fopen( name, "wb" );
    if( mbr_file == NULL ) {
        CantOpenFile( name );
    }
    return( mbr_file );
}


static void DelErrFile(void)
{
    char        *name;

    name = ErrFileName();
    if( name != NULL ) remove( name );
}

static void DelDepFile( void )
{
    char        *name;

    name = DepFileName();
    if( name != NULL ) remove( name );
}

int OpenSrcFile( char *filename, int delimiter )
{
    int         i;
    char        *p;
    char        buff[_MAX_PATH2];
    char        try[_MAX_PATH];
    char        *drive;
    char        *dir;
    char        *name;
    char        *ext;
    int         save;
    FCB         *curr;

    _splitpath2( filename, buff, &drive, &dir, &name, &ext );
    if( drive[0] != '\0' || IS_PATH_SEP(dir[0]) ) {
        // 14-sep-94 if drive letter given or path from root given
        if( TryOpen( "", "", filename, "" ) != 0 ) return( 1 );
        goto cant_open_file;
    }
    if( delimiter != '<' ) {                                /* 17-mar-91 */
        if( CompFlags.curdir_inc ) {  // try current directory
            if( TryOpen( "", "", filename, "" ) != 0 ) return( 1 );
        }
        if( drive[0] == '\0' && !IS_PATH_SEP( dir[0] ) ) {
            for( curr = SrcFile; curr!= NULL; curr = curr->prev_file ) {
                _splitpath2( curr->src_name, buff, &drive, &dir, &name, &ext );
                _makepath( try, drive, dir, filename, NULL );
                if( TryOpen( "", "", try, "" ) != 0 ) return(1);
            }
        }
    }
    if( HFileList != NULL ) {
        p = HFileList;
        do {
            i = 0;
            while( *p == ' ' ) ++p;                     /* 28-feb-95 */
            for(;;) {
                if( *p == INCLUDE_SEP || *p == ';' ) break;
                if( *p == '\0' ) break;
                if( i < sizeof(buff)-2 ) {
                    buff[i++] = *p;
                }
                ++p;
            }
            while( i != 0 ) {                           /* 28-feb-95 */
                if( buff[i-1] != ' ' ) break;
                --i;
            }
#define SEP_LEN (sizeof( PATH_SEP ) - 1)
            buff[i] = '\0';
            if( i>=SEP_LEN && strcmp( &buff[i-SEP_LEN], PATH_SEP )==0 ) {
                buff[i-SEP_LEN] = '\0';
            }
            if( TryOpen( buff, PATH_SEP, filename, "" ) != 0 ) return(1);
            if( *p == INCLUDE_SEP || *p == ';' ) ++p;
        } while( *p != '\0' );
    }
    if( delimiter != '<' ) {                        /* 17-mar-91 */
        if( TryOpen( H_PATH, PATH_SEP, filename, "" ) != 0 ) return( 1 );
    }
cant_open_file:
    save = CompFlags.cpp_output;
    if( CompFlags.cpp_output ) {                        /* 18-aug-91 */
        if( delimiter == '<' ) {
            CppPrtf( "#include <%s>", filename );
        } else {
            CppPrtf( "#include \"%s\"", filename );
        }
        CompFlags.cpp_output = 0;
    }
    CErr2p( ERR_CANT_OPEN_FILE, filename );
    CompFlags.cpp_output = save;
    return( 0 );
}

void CClose( FILE *fp )
/*********************/
{
    if( fp == NULL ) {
        /* nothing to do */
    } else if( fp != stdin ) {
        fclose( fp );
    }
}

void CloseSrcFile( FCB *srcfcb )
{
    ++IncFileDepth;
    if( srcfcb->src_fp != NULL ) {          /* not in-memory buffer */
        CClose( srcfcb->src_fp );
    }
    FEfree( srcfcb->src_buf );
    --srcfcb->src_line;
    if( CompFlags.scanning_comment ) {
        CErr1( ERR_INCOMPLETE_COMMENT );
    }
    SrcFile = srcfcb->prev_file;
    CurrChar = srcfcb->prev_currchar;
    if( SrcFile == MainSrcFile ) {
        if( CompFlags.make_precompiled_header ) {
            CompFlags.make_precompiled_header = 0;
            if( ErrCount == 0  ) {
                BuildPreCompiledHeader( PCH_FileName );
            }
        }
    }
    if( SrcFile != NULL ) {
        if(  SrcFile->src_fp == NULL ) {
            SrcFile->src_fp = fopen( SrcFile->src_name, "rb" );
            fseek( SrcFile->src_fp, SrcFile->rseekpos, SEEK_SET );
        }
        ScanCharPtr = SrcFile->src_ptr; // get scan ptr from prev file
        TokenFno = SrcFile->src_fno;
        ErrFName = SrcFile->src_name;
        IncLineCount += srcfcb->src_line;
        SrcFileLineNum = SrcFile->src_line;
        if( CompFlags.cpp_output ) {
            EmitPoundLine( SrcFile->src_line, SrcFile->src_name, 1 );
        }
    } else {
        SrcLineCount = srcfcb->src_line;
        CurrChar = EOF_CHAR;
    }
    CMemFree( srcfcb );
}

static int OpenFCB( FILE *fp, char *filename )
{
    if( FCB_Alloc( fp, filename ) == 0 ) {       /* split apart 19-sep-89 */
        CErr1( ERR_OUT_OF_MEMORY );
        return( FALSE );
    }
    return( TRUE );
}

bool FreeSrcFP( void )
/*************/
{
    FCB *src_file;
    FCB *next;
    bool ret;

    src_file = SrcFile;
    ret = FALSE;
    while( src_file != NULL ) {
        next = src_file->prev_file;
        if( next == NULL || next->src_fp == NULL )break;
        src_file = next;
    }
    if( src_file != NULL && src_file->src_fp != NULL ) {
        src_file->rseekpos = ftell( src_file->src_fp );
        CClose( src_file->src_fp );
        src_file->src_fp = NULL;
        ret = TRUE;
    }
    return( ret );
}

static int TryOpen( char *prefix, char *separator, char *filename, char *suffix )
{
    int         i, j;
    FILE        *fp;
    auto char   buf[2*130];

    if( IncFileDepth == 0 ) {
        CErr2( ERR_INCDEPTH, 255 );
        CSuicide();
        return( 0 );
    }
    i = 0;
    while( (buf[i] = *prefix++) )    ++i;
    while( (buf[i] = *separator++) ) ++i;
    j = i;
    while( (buf[i] = *filename++) )  ++i;
    while( (buf[i] = *suffix++) )    ++i;
    filename = &buf[0];                 /* point to the full name */
    if( IsFNameOnce( filename ) ) {
        return( 1 );
    }
    for(;;) {
        fp = fopen( filename, "rb" );
        if( fp != NULL )break;
        if( errno != ENOMEM && errno != ENFILE && errno != EMFILE ) break;
        if( !FreeSrcFP() )break;      // try closing an include file
    }
    if( fp == NULL )  return( 0 );

    if( CompFlags.use_precompiled_header ) {
        CompFlags.use_precompiled_header = 0;
        if( UsePreCompiledHeader( filename ) == 0 ) {
            fclose( fp );
            return( 1 );
        }
    }
    if( OpenFCB( fp, filename ) ) {
        return( 1 );
    }
    fclose( fp );
    return( 0 );
}

static FNAMEPTR FindFlist( char const *filename )
{ // find a flist
    FNAMEPTR    flist;

    flist = FNames;
    while( flist  != NULL ) {
        if( strcmp( filename, flist->name ) == 0 ) break;
        flist = flist->next;
    }
    return( flist );