/net/fileserver/nas/home/mdh/vrq/src/csymtab.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 1997-2007, Mark Hummel
 * This file is part of Vrq.
 *
 * Vrq is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * Vrq is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, 
 * Boston, MA  02110-1301  USA
 *****************************************************************************
 */
/******************************************************************************
 *
 *
 *         csymtab.hpp
 *              - class definition for symbol tables 
 *
 *
 ******************************************************************************
 */

#ifndef CSYMTAB_HPP
#define CSYMTAB_HPP

#include "glue.h"
#include "cdecl.h"
#include <map>
#include <algorithm>



class CSymbol;
                        
template<class T1>
class CSymtabEntry : public map<CSymbol*,T1*>
{
private:
        CSymtabEntry*   previous;
public:

/*********************************************************
        Constructor
**********************************************************/
CSymtabEntry( CSymtabEntry* parent ) 
{
        previous     = parent;
}

/*********************************************************
        GetPrevious
        - return previous level 
**********************************************************/
CSymtabEntry*   GetPrevious() {
        return previous;
}

/*********************************************************
        Lookup
        - find symbol by recursively searching table 
**********************************************************/

T1* Lookup( CSymbol* key )
{
        T1*                         result;
        typename map<CSymbol*,T1*>::iterator ptr;

        result = NULL;
        ptr = this->find( key );
        if( ptr != this->end() ) {
                return ptr->second;
        }
        if( previous ) {
                result = previous->Lookup( key );
        }
        return result;
}       

/*********************************************************
        LookupTop
        - find symbol at top level only 
**********************************************************/

T1* LookupTop( CSymbol* key )
{
        T1*                         result;
        typename map<CSymbol*,T1*>::iterator ptr;

        result = NULL;
        ptr = this->find( key );
        if( ptr != this->end() ) {
                result = ptr->second;
        } 
        return result;
}       

void    Dump( FILE *f, int recurse ) 
{
        typename map<CSymbol*,T1*>::iterator ptr;

        for( ptr = this->begin(); ptr != this->end(); ++ptr) {
                printf( "\t%s => ", ptr->first->GetName() );
                ptr->second->DumpDeclInfo( f );
        }
        if( recurse && previous != NULL ) {
                previous->Dump( f, recurse );
        }
}
                
};
template<class T1>
class CSymtab
{
private:
        CSymtabEntry<T1>*       table;          
public:

CSymtab() 
{
        table        = new CSymtabEntry<T1>( NULL );
}
void PopScope()
{
        MASSERT( table != NULL );

        table = table->GetPrevious();
}       
void PushScope()
{
        table = new CSymtabEntry<T1>( table );
}

void    Add( CSymbol* sym, T1* obj )
{
        (*table)[sym] = obj;
}
                
T1*     LookupTop( CSymbol* sym )
{

        return table->LookupTop( sym );
}
                
T1*     Lookup( CSymbol* sym )
{
        return table->Lookup( sym );
}
                
void    Dump( FILE *f, int recurse ) 
{
        table->Dump( f, recurse );
}

};

#endif // CSYMTAB_HPP