symtable.C

Go to the documentation of this file.

#include <assert.h>
#include <string.h>
#include <stdio.h>
#include "stdtypes.h"
#include "blockpool.h"
#include "pools.h"
#include "str.h"
#include "list.h"
#include "fifo_list.h"
#include "hash_serv.h"
#include "sparse.h"
#include "strtable.h"
#include "sym.h"
#include "type.h"
#include "const.h"
#include "symtable.h"
#include "typetable.h"
#include "dsym.h"


sym *symtable::chain_elem::search_list( STRING item )
{
    LIST<sym *>::handle h;
    sym *list_sym, *sym;
    
    sym = NULL;
    for (h = list.first(); h != NULL; h = list.next(h)) {
        list_sym = list.get_item( h );
        if ( list_sym->get_name().GetText() == item.GetText() ) {
            sym = list_sym;
            break;
        }  // if
    } // for
    
    return sym;
} // search_list



sym *symtable::new_sym( STRING str, uint kind )
{
    sym *pNewSym;

    assert( alloc_pool != NULL );

    switch ( kind ) {
    // IDENT: has scope
    case sy_ident:
        pNewSym = new( alloc_pool ) sym_ident( str );
        pNewSym->set_scope( get_owner() );
        break;
    // TYPE : no scope
    case sy_type:
        pNewSym = new( alloc_pool ) sym_type( str );
        break;
    // CONST: no scope
    case sy_const:
        pNewSym = new( alloc_pool ) sym_const( str );
        break;

    // SUBPROG: local symbol table
    case sy_subprog:
        pNewSym = new( alloc_pool ) sym_subprog( str );

        // the subprogram is in the scope of the owner of this symbol table
        pNewSym->set_scope( get_owner() );
        // A function or procedure will allocate memory from
        // from the same pool as its parent scope (which will be
        // either a component or the global scope, in the case of
        // a function in a package).
        //
        pNewSym->get_symtab()->set_pool( alloc_pool );
        // Set the allocation pool for the type table
        pNewSym->get_typtab()->set_pool( alloc_pool );  
        // The symbol table is owned by the subprogram
        pNewSym->get_symtab()->set_owner( pNewSym );
        break;

    // COMPONENT: local memory pool and local symbol table
    case sy_component:
        pNewSym = new( alloc_pool ) sym_component( str );

        // symbols in the component scope are owned by the component
        pNewSym->get_symtab()->set_owner( pNewSym  );
        break;

    // PROCESS: local symbol table
    case sy_process:
        pNewSym = new( alloc_pool ) sym_process( str );

        // the process is in the scope of its component
        pNewSym->set_scope( get_owner() );
        // set the memory pool to the pool of the parent
        pNewSym->get_symtab()->set_pool( alloc_pool );
        // Set the allocation pool for the type table
        pNewSym->get_typtab()->set_pool( alloc_pool );  
        // The symbol table is owned by the process
        pNewSym->get_symtab()->set_owner( pNewSym );
        break;
    case sy_package:   // its not currently clear what to do about packages
    case sy_block_label:
    case bad_symbol:
    default:
        // bad symbol kind
        assert( FALSE );
        break;
    } // switch

    assert( pNewSym != NULL );

    return pNewSym;
} // new_sym


sym *symtable::find_sym( STRING name )
{
    STRING str;
    sym *retsym;
    
    retsym = NULL;
    if (name.GetText() != NULL) {
        // If the name is not entered into the string table then
        // its not in the symbol table.  Of course the name could
        // be in the string table and not in the symbol table, since
        // the string table is global and symbol could be out of scope.
        str = strtab.find_string( name, FALSE );
        if (str.GetText() != NULL) {
            unsigned int ix, val;

            val = hash_value( str.GetText() );
            // table size should always be a power of 2, so
            // table_size - 1 is likely to be a prime.
            ix = val % (table_size - 1);
            if (hash->probe( ix )) { 
                retsym =  (*hash)[ ix ].search_list( str );
            }   
        }
    }

    return retsym;
} // find_sym



sym *symtable::enter_sym( STRING name, uint kind )
{
    unsigned int ix, val;
    sym *retsym;
    STRING str;

    retsym = NULL;

    if (kind == sy_process) {
        // Processes are special cases.  They are allocated by the
        // symbol table class, since they are derived from the
        // symbol type.  But they are not entered into the symbol
        // table, since in VHDL a process name can't be referenced.
        // Allocation of processes by the symbol table allows uniform
        // allocation of all symbol derived objects.
        retsym = new_sym( name, kind);
    }
    else {

        assert( name.GetText() != NULL );

        val = hash_value( name.GetText() );
        str = strtab.find_string( name, TRUE );  // insert into table if its not there.
        // table size should always be a power of 2, so
        // table_size - 1 is likely to be a prime.
        ix = val % (table_size - 1);
        if (! hash->probe( ix ) ) {

            hash->insert( chain_elem(), ix );
            
            retsym = new_sym( str, kind );
            (*hash)[ix].list.add( retsym );
        }
        else {
            retsym = (*hash)[ix].search_list( str );
            if ( retsym == NULL) {
                retsym = new_sym( str, kind );
                (*hash)[ix].list.add( retsym );
            }
        }
    }

    return retsym;
} // enter_sym


void symtable::dealloc_sub_tables(void)
{
    uint i;

    for (i = 0; i < table_size; i++) {
        if (hash->probe( i )) {
            LIST<sym *>::handle h;
            sym * pListSym;
            
            for (h = (*hash)[i].list.first(); h != NULL; h = (*hash)[i].list.next(h)) {
                pListSym = (*hash)[i].list.get_item( h );
                if (pListSym->has_scope()) {
                    pListSym->get_symtab()->dealloc_sub_tables();
                    pListSym->dealloc();
                }
            } // for
        } // if
    } // for
} // dealloc_sub_tables

void symtable::pr(FILE *fp)
{
    uint i;

    for (i = 0; i < table_size; i++) {
        if (hash->probe( i )) {
            LIST<sym *>::handle h;
            sym * pListSym;
            
            for (h = (*hash)[i].list.first(); h != NULL; h = (*hash)[i].list.next(h)) {
                // fprintf(fp, "hash_label::pr: i = %d, ", i );
                pListSym = (*hash)[i].list.get_item( h );
                pListSym->get_name().pr(fp);
                fprintf(fp, "\n");
            } // for
        } // if
    } // for
} // pr



sym *symtable::get_sym(void)
{
    sym * pHashSym;

    pHashSym = NULL;

    while (list_handle == NULL && hash_slot < table_size) {
        if (hash->probe( hash_slot )) {
            list_handle = (*hash)[hash_slot].list.first();
        }
        if (list_handle == NULL) {
            hash_slot++;
        }
    } // while

    if (list_handle != NULL && hash_slot < table_size) {

        pHashSym = (*hash)[hash_slot].list.get_item( list_handle );

        list_handle = (*hash)[hash_slot].list.next(list_handle);

        // if we've hit the end of the list, increment the
        // slot so we're not stuck in the same place
        if (list_handle == NULL)
            hash_slot++;        
    }

    return pHashSym;
} // get_str

---