usage.cpp

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

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/


#include "wpch.hpp"
#include "handle.hpp"
#include "reindex.hpp"
#include "scopes.hpp"
#include "usage.hpp"
#include "cache.hpp"

// Silence the compiler warning about taking the "sizeof" a
// class with virtual functions
#pragma warning 549 9
static Pool UsageRec::_usagePool( UsagePool, sizeof(UsageRec) );
#pragma warning 549 3


UsageList::UsageList()
/********************/
{
    _count = 0;
    _firstFile = NULL;
    _curFile = NULL;
}


UsageList::~UsageList()
/*********************/
{
    FileData *  currFile;
    FileData *  prevFile;
    UsageRec *  currLine;
    UsageRec *  currCol;
    UsageRec *  prevCol;

    prevFile = NULL;
    currFile = _firstFile;
    while( currFile != NULL ){
        currLine = currFile->lines.First();
        while( currLine != NULL ) {
            prevCol = NULL;
            currCol = currLine->next;
            while( currCol != NULL ){
                prevCol = currCol;
                currCol = currCol->next;
                delete prevCol;
            }
            delete currLine;
            currLine = currFile->lines.Next();
        }
        prevFile = currFile;
        currFile = currFile->next;
        delete prevFile;
    }
}


void UsageList::Insert( UsageRec * data )
/***************************************/
{
    UsageRec *  current;
    UsageRec *  prev;

    if( _firstFile == NULL ){
        _firstFile = new FileData;
        _firstFile->next = NULL;
        _firstFile->filename = (BRI_StringID) 0;
        _firstFile->curLine = 0;
        _firstFile->curColumn = 0;
        _curFile = _firstFile;
    }

    data->column = _curFile->curColumn;

    // Find the right line and column...
    current = _curFile->lines.Find( _curFile->curLine );
    prev = NULL;
    while( current != NULL && current->column < _curFile->curColumn ){
        prev = current;
        current = current->next;
    }
    data->next = current;
    if( prev == NULL ){
        _curFile->lines.Insert( _curFile->curLine, data, TRUE );
    } else {
        prev->next = data;
    }
    _count += 1;
}


void UsageList::Delta( int_8 dcol, int_16 dline )
/***********************************************/
{
    _curFile->curLine += dline;
    _curFile->curColumn += dcol;
}


void UsageList::SetFile( BRI_StringID filename )
/**********************************************/
{
    FileData *  curr;
    FileData *  prev;
    FileData *  newfile;

    prev = NULL;
    curr = _firstFile;
    while( curr != NULL && curr->filename < filename ){
        prev = curr;
        curr = curr->next;
    }
    if( _curFile != NULL ){
        _openFileStack.Push( _curFile );
    }
    if( curr == NULL || curr->filename > filename ){
        newfile = new FileData;
        newfile->next = curr;
        newfile->filename = filename;
        newfile->curLine = 0;
        newfile->curColumn = 0;
        if( prev == NULL ){
            _firstFile = newfile;
        } else {
            prev->next = newfile;
        }
        _curFile = newfile;
    } else {
        curr->curLine = 0;
        curr->curColumn = 0;
        _curFile = curr;
    }
}


void UsageList::EndFile()
/***********************/
{
    _curFile = _openFileStack.Pop();
}


UsageRec * UsageList::First()
/***************************/
{
    UsageRec *  result = NULL;

    _curFile = _firstFile;
    while( _curFile != NULL && _curFile->lines.Empty() ){
        _curFile = _curFile->next;
    }
    if( _curFile != NULL ){
        result = _curFile->lines.First();
        _curUsage = result;
    }
    return result;
}


UsageRec * UsageList::Next()
/**************************/
{
    UsageRec *  result = NULL;

    if( _curFile != NULL ){
        if( _curUsage != NULL ){
            _curUsage = _curUsage->next;
            if( _curUsage != NULL ){
                _curFile->curColumn = _curUsage->column;
                result = _curUsage;
            } else {
                _curUsage = _curFile->lines.Next();
                if( _curUsage != NULL ){
                    _curFile->curLine = _curFile->lines.CurrentKey();
                    _curFile->curColumn = _curUsage->column;
                    result = _curUsage;
                } else {
                    do {
                        _curFile = _curFile->next;
                    } while( _curFile != NULL && _curFile->lines.Empty() );

                    if( _curFile != NULL ){
                        _curUsage = _curFile->lines.First();
                        _curFile->curLine = _curFile->lines.CurrentKey();
                        _curFile->curColumn = _curUsage->column;
                        result = _curUsage;
                    }
                }
            }
        }
    }
    return result;
}


BRI_StringID UsageList::GetFileName()
/***********************************/
{
    if( _curFile == NULL ){
        return (BRI_StringID) 0;
    } else {
        return _curFile->filename;
    }
}


uint_32 UsageList::GetLine()
/**************************/
{
    if( _curFile == NULL ){
        return 0;
    } else {
        return _curFile->curLine;
    }
}


uint_32 UsageList::GetColumn()
/****************************/
{
    if( _curFile == NULL ){
        return 0;
    } else {
        return _curFile->curColumn;
    }
}


UsageRec * UsageList::At( BRI_StringID fname, uint_32 line,
                          uint_32 column )
/*********************************************************/
{
    UsageRec *  result;
    FileData *  curFile;
    UsageRec *  curLine;
    UsageRec *  curColumn;
    UsageRec *  prevColumn;
    WBool       found = FALSE;

    // Find the right file...
    curFile = _firstFile;
    while( curFile != NULL && curFile->filename != fname ){
        curFile = curFile->next;
    }

    if( curFile != NULL ){
        curLine = curFile->lines.Find( line );
        curColumn = curLine;