typetable Class Reference

Named types are represented by the sym_type class. More...

#include <typetable.h>

Collaboration diagram for typetable:

[legend]List of all members.

Public Member Functions
	typetable (pool *p=NULL)
void	set_pool (pool *p)
type *	new_type (uint kind, uint time_scale=time_bad_time)
	The new_type class function returns a type based on its "kind" argument.
void	pr ()
	Debug print for the type table.
Private Member Functions
	typetable (const typetable &ty)
type *	find_time (const uint time_scale)
Private Attributes
LIST< type_range * >	range_list
LIST< type_real * >	real_list
LIST< type_array * >	array_list
LIST< type_record * >	rec_list
LIST< type_file * >	file_list
pool *	alloc_pool
Static Private Attributes
LIST< type_time * >	time_list

---

Detailed Description

Named types are represented by the sym_type class.

A sym_type object has a pointer to a type, which is an unnamed object described by the classes in type.h. The type table class provides a way to encapsulate these allocated types.

Two allocation scopes are used for types: the global allocation scope, where types defined in packages will be entered and the component allocation scope. Types in the global scope will be allocated from the global pool. Types in the component scope will be allocated from the component pool.

The types in the type table are ordered as lists of a given type class (e.g., type_range, type_real, type_array, type_record, type_file). Types in the type table are not currently unique. There are two reasons for this: its a pain to make show that two types are the same in all cases and I can't think of a reason to do this extra work.

Definition at line 39 of file typetable.h.

---

Constructor & Destructor Documentation

typetable::typetable (  const typetable &  ty  )  [inline, private]

Definition at line 52 of file typetable.h. References FALSE. { assert( FALSE ); }

typetable::typetable (  pool *  p = NULL  )  [inline]

Definition at line 57 of file typetable.h. References alloc_pool. { alloc_pool = p; }

---

Member Function Documentation

type * typetable::find_time (  const uint  time_scale  )  [private]

Definition at line 20 of file typetable.C. References LIST< type_time * >::add(), LIST< type_time * >::first(), LIST< type_time * >::get_item(), type_time::get_unit(), global_mem, LIST< type_time * >::next(), NULL, time_bad_time, and time_list. Referenced by new_type(). { type_time *pT; type_time *time_elem; LIST<type_time *>::handle h; pT = NULL; if (time_scale != time_bad_time) { for (h = time_list.first(); h != NULL; h = time_list.next( h )) { time_elem = time_list.get_item( h ); if (time_elem->get_unit() == time_scale) { pT = time_elem; break; } } // If pT is NULL then a type with that time scale is not in the // type list. Allocate the type from the global memory pool. if (pT == NULL) { pT = new( &global_mem ) type_time( time_scale ); time_list.add( pT ); } } return pT; } // find_time

type * typetable::new_type (  uint  kind, uint  time_scale = time_bad_time )

The new_type class function returns a type based on its "kind" argument. The time_scale argument is only needed in the case that kind == ty_time. There are a very large number of possible range types and an infinite number of possible array, record and file types. However, this is only one REAL type. The time type is also special. There are a limited number of time types reflecting the various resolutions. These types are stored in a list that is shared by all instances of the typetable class. When the component is processed it can he quickly determined what the smallest time resolution is by searching this list. Of course the time resolution must be done across components as well. Definition at line 66 of file typetable.C. References alloc_pool, FALSE, find_time(), NULL, REAL, ty_array, ty_file, ty_range, ty_real, ty_record, and ty_time. { pType pT; assert( alloc_pool != NULL ); pT = NULL; switch (kind) { case ty_time: pT = find_time( time_scale ); break; case ty_range: pT = new( alloc_pool ) type_range( ); break; case ty_real: pT = ℜ // there is only one real type break; case ty_array: pT = new( alloc_pool ) type_array( ); break; case ty_record: pT = new( alloc_pool ) type_record( ); break; case ty_file: pT = new( alloc_pool ) type_file( ); break; default: assert( FALSE ); break; } // switch return pT; } // new_type

void typetable::pr (  void   )

Debug print for the type table. Definition at line 106 of file typetable.C. { // To Be Done } // pr

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

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

---

Member Data Documentation

pool* typetable::alloc_pool [private]

Definition at line 48 of file typetable.h. Referenced by new_type(), set_pool(), and typetable().

LIST<type_array *> typetable::array_list [private]

Definition at line 44 of file typetable.h.

LIST<type_file *> typetable::file_list [private]

Definition at line 46 of file typetable.h.

LIST<type_range *> typetable::range_list [private]

Definition at line 42 of file typetable.h.

LIST<type_real *> typetable::real_list [private]

Definition at line 43 of file typetable.h.

LIST<type_record *> typetable::rec_list [private]

Definition at line 45 of file typetable.h.

LIST< type_time * > typetable::time_list [static, private]

Definition at line 36 of file globals.C. Referenced by find_time().

---

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

• typetable.h
• globals.C
• typetable.C

---