symtable Class Reference

This class implements a symbol table for the VHDL compiler. More...

#include <symtable.h>

Inheritance diagram for symtable:

[legend]Collaboration diagram for symtable:

[legend]List of all members.

Public Member Functions
void	init (uint size=SQRT_SYMTAB)
	symtable (unsigned int size=SQRT_SYMTAB, pool *p=NULL)
void	dealloc ()
	~symtable ()
void	set_pool (pool *p)
void	set_owner (sym *parent)
sym *	get_owner (void)
sym *	enter_sym (STRING str, uint kind)
	Enter a symbol in the symbol table.
sym *	enter_sym (const char *pChar, uint kind)
sym *	find_sym (STRING name)
	Search for a symbol in the symbol table whose name is in the STRING object name.
sym *	find_sym (const char *pChar)
unsigned int	get_percent_alloced (void)
unsigned int	get_max_list (void)
void	pr (FILE *fp=stdout)
	Print the contents of the string table.
void	dealloc_sub_tables ()
	Traverse the symbol table and find sub-symbols that have scope (e.g., symbol tables).
sym *	first (void)
	The functions first and get_item are used to iterate through the string table.
sym *	get_sym (void)
	get_str is used to iterate through the string table.
Private Member Functions
sym *	new_sym (STRING str, uint kind)
	Allocate a new symbol.
	symtable (const symtable &st)
Private Attributes
unsigned int	table_size
unsigned int	hash_slot
LIST< sym * >::handle	list_handle
sparse_array< chain_elem > *	hash
pool *	alloc_pool
sym *	owner

---

Detailed Description

This class implements a symbol table for the VHDL compiler.

The symbol table consists of symbols with unique names (contained in the STRING class, entered in the string table).

This class was originally a generic template (HASH) for building hash tables. However, this template uses other templates (e.g., the sparse_array and LIST templates). C++ compilers (especially the HP C++ compiler) tend to have trouble with nested templates. So this class has been changed to be a specific class, instead of a template.

Definition at line 59 of file symtable.h.

---

Constructor & Destructor Documentation

symtable::symtable (  const symtable &  st  )  [inline, private]

Definition at line 104 of file symtable.h. References FALSE. { assert( FALSE ); }

symtable::symtable (  unsigned int  size = SQRT_SYMTAB, pool *  p = NULL )  [inline]

Definition at line 113 of file symtable.h. References alloc_pool, init(), NULL, and owner. { owner = NULL; alloc_pool = p; init( size ); }

symtable::~symtable (   )  [inline]

Definition at line 126 of file symtable.h. References dealloc(), and dealloc_sub_tables(). { dealloc_sub_tables(); // Deallocate all the "child" symbol tables. dealloc(); // Deallocate the sparse array and list memory for // this symbol table. }

---

Member Function Documentation

void symtable::dealloc (  void   )  [inline]

Definition at line 120 of file symtable.h. References sparse_array< chain_elem >::dealloc(), and hash. Referenced by sym_scope::dealloc(), sym_component::proc_list_dealloc(), and ~symtable(). { hash->dealloc(); delete hash; }

void symtable::dealloc_sub_tables (   )

Traverse the symbol table and find sub-symbols that have scope (e.g., symbol tables). For each of these, call dealloc_sub_tables, and then dealloc. Definition at line 227 of file symtable.C. References sym::dealloc(), sym::get_symtab(), sym::has_scope(), hash, LIST< T >::list, NULL, sparse_array< chain_elem >::probe(), table_size, and uint. Referenced by sym_component::proc_list_dealloc(), and ~symtable(). { 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

sym* symtable::enter_sym (  const char *  pChar, uint  kind )  [inline]

Definition at line 158 of file symtable.h. References enter_sym(), pChar, and STRING::SetText(). { STRING str; str.SetText( pChar ); return enter_sym( str, kind ); } // enter_sym

sym * symtable::enter_sym (  STRING  name, uint  kind )

Enter a symbol in the symbol table. If "name" is not entered in the string table, enter it as well. Definition at line 174 of file symtable.C. References strtable::find_string(), STRING::GetText(), hash, hash_services::hash_value(), sparse_array< chain_elem >::insert(), new_sym(), NULL, sparse_array< chain_elem >::probe(), strtab, sy_process, table_size, and TRUE. Referenced by enter_sym(). { 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

sym* symtable::find_sym (  const char *  pChar  )  [inline]

Definition at line 170 of file symtable.h. References find_sym(), pChar, and STRING::SetText(). { STRING str; str.SetText( pChar ); return find_sym( str ); } // find_sym with a char * argument

sym * symtable::find_sym (  STRING  name  )

Search for a symbol in the symbol table whose name is in the STRING object name. Definition at line 139 of file symtable.C. References FALSE, strtable::find_string(), STRING::GetText(), hash, hash_services::hash_value(), NULL, sparse_array< chain_elem >::probe(), strtab, and table_size. Referenced by find_sym(). { 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::first (  void   )  [inline]

The functions first and get_item are used to iterate through the string table. Note that the strings will be returned in hash order, which is pseudorandom. An example is shown below: sym *pSym; for (pSym = symtab.first(); pSym != NULL; pSym = symtab.get_str()) { printf("%s\n", sym->get_name().GetText() ); } Definition at line 220 of file symtable.h. References get_sym(), hash_slot, list_handle, and NULL. { hash_slot = 0; list_handle = NULL; return get_sym(); }

unsigned int symtable::get_max_list (  void   )  [inline]

Definition at line 182 of file symtable.h. References hash, sparse_array< chain_elem >::probe(), table_size, and uint. { uint i; uint max, len; max = 0; for (i = 0; i < table_size; i++) { if (hash->probe( i )) { len = (*hash)[i].list_len(); if (len > max) { max = len; } } } return max; } // get_max_list

sym* symtable::get_owner (  void   )  [inline]

Definition at line 144 of file symtable.h. References NULL, and owner. Referenced by new_sym(). { assert( owner != NULL ); return owner; }

unsigned int symtable::get_percent_alloced (  void   )  [inline]

Definition at line 180 of file symtable.h. References sparse_array< chain_elem >::get_percent_alloced(), and hash. { return hash->get_percent_alloced(); }

sym * symtable::get_sym (  void   )

get_str is used to iterate through the string table. See symtable.h. Definition at line 275 of file symtable.C. References hash, hash_slot, list_handle, NULL, sparse_array< chain_elem >::probe(), and table_size. Referenced by first(). { 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

void symtable::init (  uint  size = SQRT_SYMTAB  )  [inline]

Definition at line 107 of file symtable.h. References sparse_array< chain_elem >::get_total_size(), hash, and table_size. Referenced by symtable(). { hash = new sparse_array<chain_elem>( (const unsigned int)size ); table_size = hash->get_total_size(); }

sym * symtable::new_sym (  STRING  str, uint  kind )  [private]

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. Definition at line 59 of file symtable.C. References alloc_pool, bad_symbol, FALSE, get_owner(), sym::get_symtab(), sym::get_typtab(), NULL, set_owner(), typetable::set_pool(), set_pool(), sym::set_scope(), sy_block_label, sy_component, sy_const, sy_ident, sy_package, sy_process, sy_subprog, and sy_type. Referenced by enter_sym(). { 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

void symtable::pr (  FILE *  fp = stdout  )

Print the contents of the string table. Definition at line 250 of file symtable.C. References sym::get_name(), hash, LIST< T >::list, NULL, STRING::pr(), sparse_array< chain_elem >::probe(), table_size, and uint. { 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

void symtable::set_owner (  sym *  parent  )  [inline]

Definition at line 138 of file symtable.h. References owner. Referenced by new_sym(). { owner = parent; }

void symtable::set_pool (  pool *  p  )  [inline]

Definition at line 133 of file symtable.h. References alloc_pool. Referenced by sym_component::init(), and new_sym(). { alloc_pool = p; }

---

Member Data Documentation

pool* symtable::alloc_pool [private]

Definition at line 93 of file symtable.h. Referenced by new_sym(), set_pool(), and symtable().

sparse_array<chain_elem>* symtable::hash [private]

Definition at line 92 of file symtable.h. Referenced by dealloc(), dealloc_sub_tables(), enter_sym(), find_sym(), get_max_list(), get_percent_alloced(), get_sym(), init(), and pr().

unsigned int symtable::hash_slot [private]

Definition at line 89 of file symtable.h. Referenced by first(), and get_sym().

LIST<sym *>::handle symtable::list_handle [private]

Definition at line 90 of file symtable.h. Referenced by first(), and get_sym().

sym* symtable::owner [private]

Definition at line 95 of file symtable.h. Referenced by get_owner(), set_owner(), and symtable().

unsigned int symtable::table_size [private]

Definition at line 88 of file symtable.h. Referenced by dealloc_sub_tables(), enter_sym(), find_sym(), get_max_list(), get_sym(), init(), and pr().

---

The documentation for this class was generated from the following files:

• symtable.h
• symtable.C

---