usage.cpp

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C++ 代码 · 共 553 行 · 第 1/2 页

        prevColumn = NULL;
        while( curColumn != NULL && curColumn->column < column ){
            prevColumn = curColumn;
            curColumn = curColumn->next;
        }

        if( curColumn == NULL ){
            _right = curFile->lines.FindRight( line );
        } else {
            _right = curColumn;
            if( curColumn->column == column ){
                found = TRUE;
            }
        }
        if( !found ){
            if( prevColumn != NULL ){
                _left = curLine;
                while( _left->column < prevColumn->column ){
                    _left = _left->next;
                }
            } else {
                prevColumn = curFile->lines.FindLeft( line );
                if( prevColumn != NULL ){
                    _left = prevColumn;
                    while( prevColumn->next != NULL ){
                        prevColumn = prevColumn->next;
                        if( prevColumn->column != _left->column ){
                            _left = prevColumn;
                        }
                    }
                } else {
                    _left = NULL;
                }
            }
        }
    } else {
        _left = _right = NULL;
    }


    // If we found the exact line/column requested, return the
    // first reference at that position.  Otherwise, return NULL
    // and prepare to iterate over the references at the next
    // valid line/column positions to the right and left.

    if( found ){
        result = _right;
        _right = _right->next;
    } else {
        result = NULL;
    }
    return result;
}


UsageRec * UsageList::NextAt()
/****************************/
{
    UsageRec *  result = NULL;
    uint_32     column;

    // Return the next reference at the same line/column.
    // Assumes that a previous call to UsageList::At returned
    // a non-NULL value.

    result = _right;
    if( result != NULL ){
        column = result->column;
        _right = result->next;
        if( _right != NULL && _right->column != column ){
            _right = NULL;
        }
    }
    return result;
}


UsageRec * UsageList::NextAtLeft()
/********************************/
{
    UsageRec *  result = NULL;
    uint_32     column;

    // Return the next reference at the line/column position
    // to the left.  Assumes that a previous call to UsageList::At
    // returned NULL.

    result = _left;
    if( result != NULL ){
        column = result->column;
        _left = result->next;
        if( _left != NULL && _left->column != column ){
            _left = NULL;
        }
    }
    return result;
}


UsageRec * UsageList::NextAtRight()
/*********************************/
{
    UsageRec *  result = NULL;
    uint_32     column;

    // Return the next reference at the line/column position
    // to the right.  Assumes that a previous call to UsageList::At
    // returned NULL.

    result = _right;
    if( result != NULL ){
        column = result->column;
        _right = result->next;
        if( _right != NULL && _right->column != column ){
            _right = NULL;
        }
    }
    return result;
}


void UsageList::Reset()
/*********************/
{
    FileData    *current;

    _curFile = NULL;
    _curUsage = NULL;
    _left = NULL;
    _right = NULL;

    current = _firstFile;
    while( current != NULL ){
        current->curLine = 0;
        current->curColumn = 0;
        current = current->next;
    }
}


// Flags used by SaveTo and LoadFrom
enum  SaveLoadFlags {
    END_FLAG    = 0x00,
    FILE_FLAG   = 0x01,
    LINE_FLAG   = 0x02,
    COLUMN_FLAG = 0x03,
};

static const int SIZE_SL_FLAGS = 1;


WBool UsageList::SaveTo( CacheOutFile *cache )
/******************************************/
{
    FileData    *current;
    UsageRec    *currLine;
    UsageRec    *currColumn;

    cache->StartComponent( "Usages" );
    cache->AddDword( _count );
    current = _firstFile;
    while( current != NULL ){
        cache->AddByte( FILE_FLAG );
        cache->AddDword( current->filename );
        cache->AddDword( current->curLine );
        cache->AddDword( current->curColumn );
        currLine = current->lines.First();
        while( currLine != NULL ){
            cache->AddByte( LINE_FLAG );
            cache->AddDword( current->lines.CurrentKey() );
            cache->AddDword( currLine->column );
            cache->AddData( &currLine->type, BRI_SIZE_REFERENCETYPE );
            cache->AddDword( currLine->targetID );
            cache->AddDword( currLine->enclosing );
            currColumn = currLine->next;
            while( currColumn != NULL ){
                cache->AddByte( COLUMN_FLAG );
                cache->AddDword( currColumn->column );
                cache->AddData( &currColumn->type, BRI_SIZE_REFERENCETYPE );
                cache->AddDword( currColumn->targetID );
                cache->AddDword( currColumn->enclosing );
                currColumn = currColumn->next;
            }
            currLine = current->lines.Next();
        }
        current = current->next;
    }
    cache->EndComponent();
    return TRUE;
}


WBool UsageList::LoadFrom( CacheInFile *cache )
/*******************************************/
{
    WBool               result;
    uint_8              flag;
    uint_32             count;
    uint_32             lineNum;
    FileData            *current;
    UsageRec            *lastColumn;
    FileData            *newFile;
    UsageRec            *newLine;
    UsageRec            *newColumn;

    result = cache->OpenComponent( "Usages" );

    if( !result ){
        return result;
    }

    if( _openFileStack.Count() > 0 ){
        _openFileStack.Clear();
    }

    cache->ReadDword( &count );
    _count = count;
    current = NULL;
    lastColumn = NULL;
    while( count > 0 ){
        cache->ReadByte( flag );
        switch( flag ){
            case FILE_FLAG:
                if( lastColumn != NULL ){
                    lastColumn->next = NULL;
                }
                newFile = new FileData;
                cache->ReadDword( &newFile->filename );
                cache->ReadDword( &newFile->curLine );
                cache->ReadDword( &newFile->curColumn );
                newFile->next = NULL;
                if( current != NULL ){
                    current->next = newFile;
                } else {
                    _firstFile = newFile;
                }
                current = newFile;
            break;

            case LINE_FLAG:
                if( lastColumn != NULL ){
                    lastColumn->next = NULL;
                }
                newLine = new UsageRec;
                cache->ReadDword( &lineNum );
                cache->ReadDword( &newLine->column );
                newLine->type = (BRI_ReferenceType) 0;
                cache->ReadData( &newLine->type, BRI_SIZE_REFERENCETYPE );
                cache->ReadDword( &newLine->targetID );
                cache->ReadDword( &newLine->enclosing );
                current->lines.Insert( lineNum, newLine );
                lastColumn = newLine;
                count--;
            break;

            case COLUMN_FLAG:
                newColumn = new UsageRec;
                cache->ReadDword( &newColumn->column );
                newColumn->type = (BRI_ReferenceType) 0;
                cache->ReadData( &newColumn->type, BRI_SIZE_REFERENCETYPE );
                cache->ReadDword( &newColumn->targetID );
                cache->ReadDword( &newColumn->enclosing );
                lastColumn->next = newColumn;
                lastColumn = newColumn;
                count--;
            break;
        }
    }
    if( lastColumn != NULL ){
        lastColumn->next = NULL;
    }
    cache->CloseComponent();

    return result;
}