symtable.c

vdhl and matlab, i think it good for you

#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"


/**
   Search for a symbol in the hash chain list, using its STRING field
   as a key.

   The strings should have been entered in the string table.
   As a result, an address compare can be used, since all strings
   are unique in the string table.

   Note that there must be a symbol table for each unique scope.

 */
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



/**
   Allocate a new symbol.  The STRING should have already
   been entered in the string table.  Note that as
   different derived symbol types are added to dsym.h this
   function must be changed as well.

 */
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


/**
   Search for a symbol in the symbol table whose
   name is in the STRING object name.

 */
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



/**
   Enter a symbol in the symbol table.  If "name" is not entered
   in the string table, enter it as well.

 */
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


/**
   Traverse the symbol table and find any symbol that has scope (e.g.,
   its own symbol table).  Recursively call dealloc_sub_tables for
   each of these symbols and then call dealloc to recover sparse array
   and list memory.

 */
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

/**
   Print the contents of the string table.
 */
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



/**
   get_str is used to iterate through the string table.
   See symtable.h.
 */
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