srcfile.c

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

            int c;
            char ch;
        } u;

        for(;;) {
            // codegen can't do this optimization so we have to
            u.c = 0;
            act = activeSrc();
            p = act->nextc;
            for(;;) {
                u.ch = *p++;
                if( CharSet[u.c] != C_WS ) break;
                u.ch = *p++;
                if( CharSet[u.c] != C_WS ) break;
                u.ch = *p++;
                if( CharSet[u.c] != C_WS ) break;
                u.ch = *p++;
                if( CharSet[u.c] != C_WS ) break;
                u.ch = *p++;
                if( CharSet[u.c] != C_WS ) break;
                u.ch = *p++;
                if( CharSet[u.c] != C_WS ) break;
                u.ch = *p++;
                if( CharSet[u.c] != C_WS ) break;
                u.ch = *p++;
                if( CharSet[u.c] != C_WS ) break;
            }
            act->column += p - act->nextc;
            act->nextc = p;
            if(( CharSet[u.c] & C_EX ) == 0 ) break;
            if( u.c == '\n' ) {
                act->line++;
                act->column = 0;
                break;
            }
            // act->column is one too many at this point
            if( u.c == '\t' ) {
                act->column = (( act->column - 1 ) + tabWidth ) & - tabWidth;
            } else if( u.c != '\r' ) {
                --act->column;
                u.c = getCharCheck( act, u.c );
                if(( CharSet[u.c] & C_WS ) == 0 ) break;
            }
        }
        CurrChar = u.c;
    } else {
        int c;

        for(;;) {
            c = NextChar();
            if(( CharSet[c] & C_WS ) == 0 ) break;
            c = NextChar();
            if(( CharSet[c] & C_WS ) == 0 ) break;
        }
    }
    return( T_WHITE_SPACE );
}

void SrcFileScanCppComment()
{
    char        *p;
    OPEN_FILE   *act;

    if( NextChar == GetNextChar ) {
        union {
            int c;
            char ch;
        } u;

        for(;;) {
            // codegen can't do this optimization so we have to
            u.c = 0;
            act = activeSrc();
            p = act->nextc;
            for(;;) {
                u.ch = *p++;
                if( CharSet[u.c] & C_EX ) break;
                u.ch = *p++;
                if( CharSet[u.c] & C_EX ) break;
                u.ch = *p++;
                if( CharSet[u.c] & C_EX ) break;
                u.ch = *p++;
                if( CharSet[u.c] & C_EX ) break;
            }
            // we don't have to keep the column up to date, because once
            // we get to the end of the line, we will be starting the
            // next line at column 0.
            // act->column += p - act->nextc;
            act->nextc = p;
            if( u.c == '\n' ) {
                act->line++;
                act->column = 0;
                break;
            }
            if( u.c != '\t' && u.c != '\r' ) {
                u.c = getCharCheck( act, u.c );
                if( u.c == '\n' || u.c == LCHR_EOF ) {
                    return;
                }
                // might be a '?' in which case, NextChar has been changed
                // to a special routine. In that case, keep calling it
                // until we get back to scanning normal characters
                while( NextChar != GetNextChar ) {
                    u.c = NextChar();
                    if( u.c == '\n' || u.c == LCHR_EOF ) {
                        return;
                    }
                }
            }
        }
        CurrChar = u.c;
    } else {
        int c;

        for(;;) {
            c = NextChar();
            if( c == LCHR_EOF ) break;
            if( c == '\n' ) break;
        }
    }
}

boolean IsSrcFilePrimary(       // DETERMINE IF PRIMARY SOURCE FILE
    SRCFILE sf )                // - a source file
{
    return(( sf != NULL ) && sf->primary );
}


void SrcFileLibrary(            // MARK CURRENT SOURCE FILE AS A LIBRARY FILE
    void )
{
    srcFile->lib_inc = TRUE;
}


SRCFILE SrcFileEnclosingPrimary(// FIND ENCLOSING PRIMARY SOURCE FILE
    SRCFILE src )               // - a source file
{
    SRCFILE primary;

    DbgAssert( src != NULL );
    primary = src;
    while( src != NULL ) {
        if( src->primary ) {
            primary = src;
        }
        src = src->parent;
    }
    DbgAssert( primary != NULL );
    _FIND_ACTUAL( primary );
    return( primary );
}


void SetSrcFilePrimary(         // MARK CURRENT SOURCE FILE AS THE PRIMARY FILE
    void )
{
    srcFile->primary = TRUE;
    DbgAssert( primarySrcFile == NULL );
    primarySrcFile = srcFile;
}

SRCFILE SrcFileGetPrimary(      // GET PRIMARY SOURCE FILE
    void )
{
    DbgAssert( primarySrcFile != NULL );
    return( primarySrcFile );
}


void SrcFileCommand(            // MARK CURRENT SOURCE FILE AS A COMMAND FILE
    void )
{
    srcFile->cmdline   = TRUE;
    srcFile->read_only = TRUE;  // To exclude file from dependency list
}


boolean IsSrcFileLibrary(       // DETERMINE IF SOURCE FILE IS #include <file.h>
    SRCFILE sf )                // - a source file
{
    return(( sf != NULL ) && sf->lib_inc );
}


boolean IsSrcFileCmdLine(       // DETERMINE IF SOURCE FILE IS FOR CMD-LINE
    SRCFILE sf )                // - a source file
{
    return ( sf != NULL ) && sf->cmdline;
}


boolean SrcFilesOpen(           // DETERMINE IF ANY SOURCE FILES OPEN
    void )
{
    return ( srcFile != NULL ) && ( ! srcFile->cmdline );
}


void SrcFileGetTokenLocn(       // FILL IN TOKEN_LOCN FROM CURRENCY
    TOKEN_LOCN *tgt )           // - to be filled in
{
    tgt->src_file = srcFile;
    tgt->line = TokenLine;
    tgt->column = TokenColumn;
}

void SrcFileResetTokenLocn(     // RESET TOKEN_LOCN
    TOKEN_LOCN *tgt )           // - from SrcFileGetTokenLocn
{
    set_srcFile( tgt->src_file );
    TokenLine = tgt->line;
    TokenColumn = tgt->column;
}

boolean SrcFileAreTLSameLine(   // CHECK WHETHER TOKEN_LOCNs ARE THE SAME LINE
    TOKEN_LOCN *l1,             // - location one
    TOKEN_LOCN *l2 )            // - location two
{
    if( ! SrcFileSame( l1->src_file, l2->src_file ) ) {
        return( FALSE );
    }
    if( l1->line != l2->line ) {
        return( FALSE );
    }
    return( TRUE );
}


SRCFILE SrcFileCurrent(         // GET CURRENT SRCFILE
    void )
{
    return srcFile;
}


void SrcFilePoint(              // SET CURRENT SRCFILE
    SRCFILE srcfile )           // - source file to be set as current
{
    set_srcFile( srcfile );
}


time_t SrcFileTimeStamp(       // GET TIME STAMP FOR FILE
    SRCFILE srcfile )           // - source file
{
    return srcfile->time_stamp;
}


SRCFILE SrcFileWalkInit(        // START WALK OF SOURCE FILES
    void )
{
    return srcFilesUnique;
}


SRCFILE SrcFileWalkNext(        // NEXT FILE IN WALK OF SOURCE FILES
    SRCFILE curr )              // - previous file
{
    return curr->unique;
}

SRCFILE SrcFileNotReadOnly(     // GET NEXT NON-READ-ONLY SOURCE FILE
    SRCFILE curr )              // - current source file
{
    DIR_LIST* srch;             // - search R/O entry
    boolean read_only;          // - TRUE ==> file is in read-only directory
    char const *file_name;      // - file name of current entry

    for( ; ; curr = curr->unique ) {
        if( NULL == curr ) break;
        if( curr->read_only ) continue;
        read_only = FALSE;
        file_name = SrcFileFullName( curr );
        RingIterBeg( roDirs, srch ) {
            if( 0 == strnicmp( srch->name
                             , file_name
                             , strlen( srch->name ) ) ) {
                read_only = TRUE;
                break;
            }
        } RingIterEnd( srch );
        if( ! read_only ) break;
    }
    return curr;
}

static void addRoDir( const char *dirname )
{
    DIR_LIST* curr;             // - new R/O dir entry

    curr = RingCarveAlloc( carveRoDir, &roDirs );
    curr->name = FNameAdd( dirname );
}

void SrcFileReadOnlyDir(        // SPECIFY DIRECTORY AS READ-ONLY
    char const *dir )           // - the directory
{
    char *full;                 // - full path
    auto char path[_MAX_PATH];  // - used to extract directory
    auto char buff[_MAX_PATH];  // - expanded path for directory
    DIR_LIST* curr;             // - current R/O entry
    DIR_LIST* srch;             // - search R/O entry

    for(;;) {
        if( *dir == '\0' ) break;
        dir = IoSuppIncPathElement( dir, path );
        full = IoSuppFullPath( path, buff, sizeof( buff ) );
        curr = NULL;
        RingIterBeg( roDirs, srch ) {
            if( 0 == stricmp( full, srch->name ) ) {
                curr = srch;
                break;
            }
        } RingIterEnd( srch );
        if( curr == NULL ) {
            addRoDir( full );
        }
    }
}


void SrcFileReadOnlyFile(       // SPECIFY FILE AS READ-ONLY
    char const *file )          // - the file
{
    SRCFILE srcfile;            // - current source file

    if( NULL == file ) {
        srcfile = srcFile;
    } else {
        srcfile = srcFileGetUnique( file );
    }
    if( NULL != srcfile ) {
        srcfile->read_only = TRUE;
    }
}

SRCFILE SrcFileIncluded(        // FILE THAT INCLUDES THIS FILE
    SRCFILE curr,               // - current file
    LINE_NO *line )             // - line that contains #include
{
    SRCFILE parent;

    *line = 0;
    parent = curr->parent;
    if( parent != NULL ) {
        *line = curr->parent_locn;
    }
    return( parent );
}


static void srcFileGuardReject( // SIGNAL REJECTION OF GUARDED FILE
    void )
{
    setGuardState( GUARD_INCLUDE );
}


void SrcFileGuardPpIf(          // #IF DETECTED IN SOURCE FILE
    void )
{
    unsigned guard_state = getGuardState();

    if( ( guard_state != GUARD_INCLUDE )
      &&( guard_state != GUARD_IF )
      &&( 0 == IfDepthInSrcFile() ) ) {
        if( guard_state == GUARD_TOP ) {
            setGuardState( GUARD_MID );
        } else {
            srcFileGuardReject();
        }
    }
}


void SrcFileGuardPpIfndef(      // SUPPLY #IFNDEF NAME
    char *name,                 // - macro name
    unsigned len )              // - length of name
{
    SRCFILE src;

    src = srcFile;
    _FIND_ACTUAL( src );
    if( src->ifndef_name == NULL ) {
        /* only need the first #ifndef in the file */
        src->ifndef_len = len;
        src->ifndef_name = CPermAlloc( len + 1 );
        strcpy( src->ifndef_name, name );
    }
}


void SrcFileGuardPpElse(        // #ELSE DETECTED IN SOURCE FILE
    void )
{
    if( IfDepthInSrcFile() <= 1 ) {
        srcFileGuardReject();
    }
}


void SrcFileGuardPpEndif(       // #ENDIF DETECTED IN SOURCE FILE
    void )
{
    if( ( 0 == IfDepthInSrcFile() )
      &&( getGuardState() == GUARD_MID ) ) {
        setGuardState( GUARD_BOT );
    }
}


void SrcFileGuardStateSig(      // SIGNAL SIGNIFICANCE (TOKEN, ETC) IN FILE
    void )
{
    SRCFILE src_file;

    /* NYI: needs to be able to handle a NULL srcFile! */
    if( PPState == PPS_NORMAL ) {
        src_file = srcFile;
        _FIND_ACTUAL( src_file );
        if( src_file->guard_state != GUARD_MID ) {
            src_file->guard_state = GUARD_INCLUDE;
        }
    }
}


boolean SrcFileGuardedIf(       // SKIP REST OF GUARDED FILE, IF POSSIBLE
    int value )                 // - <value> in #if <value>
{
    if( getGuardState() == GUARD_IF ) {
        if( value == 0 ) {
            if( ! readBuffer( TRUE ) ) {
                GetNextChar();
            }
            return( TRUE );
        }
        setGuardState( GUARD_INCLUDE );
    }
    return( FALSE );
}