/Users/trevorw/projects/release/covered-0.7.4/src/fsm_var.h File Reference

---

Detailed Description

Contains functions for handling FSM variable structure.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

10/3/2003

#include "defines.h"

Go to the source code of this file.

Functions
fsm_var *	fsm_var_add (const char *funit_name, expression *in_state, expression *out_state, char *name, bool exclude)
	Allocates, initializes and adds FSM variable to global list.
void	fsm_var_bind_add (char *sig_name, expression *expr, char *funit_name)
	Adds specified signal and expression to binding list.
void	fsm_var_stmt_add (statement *stmt, char *funit_name)
	Add specified functional unit and statement to binding list.
void	fsm_var_bind ()
	Performs FSM signal/expression binding process.
void	fsm_var_cleanup ()
	Cleans up the global lists used in this file.

---

Function Documentation

fsm_var* fsm_var_add (  const char *  funit_name, expression *  in_state, expression *  out_state, char *  name, bool  exclude )

Allocates, initializes and adds FSM variable to global list. Returns: Returns pointer to newly allocated FSM variable. Adds the specified Verilog hierarchical scope to a list of FSM scopes to find during the parsing phase. Parameters: funit_name  String containing functional unit containing FSM state variable in_state  Pointer to expression containing input state out_state  Pointer to expression containing output state name  Name of this FSM (only valid for attributes exclude  If TRUE, excludes the FSM from coverage consideration { PROFILE(FSM_VAR_ADD); fsm_var* new_var = NULL; /* Pointer to newly created FSM variable */ funit_link* funitl; /* Pointer to functional unit link found */ fsm* table; /* Pointer to newly create FSM */ /* If we have not parsed design, add new FSM variable to list */ if( db_list[curr_db]->funit_head == NULL ) { new_var = (fsm_var*)malloc_safe( sizeof( fsm_var ) ); new_var->funit = strdup_safe( funit_name ); new_var->name = NULL; new_var->ivar = in_state; new_var->ovar = out_state; new_var->iexp = NULL; new_var->table = NULL; new_var->exclude = exclude; new_var->next = NULL; if( fsm_var_head == NULL ) { fsm_var_head = fsm_var_tail = new_var; } else { fsm_var_tail->next = new_var; fsm_var_tail = new_var; } } else { if( (funitl = funit_link_find( funit_name, FUNIT_MODULE, db_list[curr_db]->funit_head )) != NULL ) { table = fsm_create( in_state, out_state, exclude ); if( name != NULL ) { table->name = strdup_safe( name ); } in_state->table = table; out_state->table = table; fsm_link_add( table, &(funitl->funit->fsm_head), &(funitl->funit->fsm_tail) ); } else { assert( funitl != NULL ); } } return( new_var ); }

void fsm_var_bind (   )

Performs FSM signal/expression binding process. Exceptions: anonymous  fsm_var_bind_expr Throw After Verilog parsing has completed, this function should be called to bind all signals to their associated FSM state expressions and functional units. For each entry in the FSM binding list the signal name is looked in the functional unit specified in the binding entry. If the signal is found, the associated expression pointer is added to the signal's expression list and the expression's signal pointer is set to point at the found signal structure. If the signal was not found, an error message is reported to the user, specifying the signal did not exist in the design. After the signals and expressions have been bound, the FSM statement binding list is iterated through binding all statements containing FSM state expressions to the functional unit that it is a part of. If the statement contains an FSM state expression that is an output state expression, create the FSM structure for this FSM and add it to the design. { PROFILE(FSM_VAR_BIND); fv_bind* curr = NULL; /* Pointer to current FSM variable */ fv_bind* tmp; /* Temporary pointer to FSM bind structure */ Try { curr = fsm_var_bind_head; while( curr != NULL ) { /* Perform binding */ fsm_var_bind_expr( curr->sig_name, curr->expr, curr->funit_name ); tmp = curr->next; /* Deallocate memory for this bind structure */ free_safe( curr->sig_name, (strlen( curr->sig_name ) + 1) ); free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) ); free_safe( curr, sizeof( fv_bind ) ); curr = tmp; } } Catch_anonymous { while( curr != NULL ) { tmp = curr->next; free_safe( curr->sig_name, (strlen( curr->sig_name ) + 1) ); free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) ); free_safe( curr, sizeof( fv_bind ) ); curr = tmp; } curr = fsm_var_stmt_head; while( curr != NULL ) { tmp = curr->next; free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) ); free_safe( curr, sizeof( fv_bind ) ); curr = tmp; } Throw 0; } curr = fsm_var_stmt_head; while( curr != NULL ) { /* Bind statement to functional unit */ (void)fsm_var_bind_stmt( curr->stmt, curr->funit_name ); tmp = curr->next; /* Deallocate memory for this bind structure */ free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) ); free_safe( curr, sizeof( fv_bind ) ); curr = tmp; } PROFILE_END; }

void fsm_var_bind_add (  char *  sig_name, expression *  expr, char *  funit_name )

Adds specified signal and expression to binding list. Exceptions: anonymous  fsm_var_bind_expr Creates a new FSM binding structure and initializes it with the specified information. The FSM binding structure is then added to the global list of FSM binding structures to be bound after parsing is complete. Parameters: sig_name  Name of signal to bind expr  Pointer to expression to bind funit_name  Name of functional unit that will contain the expression and signal being bound { PROFILE(FSM_VAR_BIND_ADD); fv_bind* fvb; /* Pointer to new FSM variable binding structure */ /* If the functional unit list does not exist yet, we need to bind this later; otherwise, bind now */ if( db_list[curr_db]->funit_head == NULL ) { /* Allocate and initialize FSM variable bind structure */ fvb = (fv_bind*)malloc_safe( sizeof( fv_bind ) ); fvb->sig_name = strdup_safe( sig_name ); fvb->expr = expr; fvb->funit_name = strdup_safe( funit_name ); fvb->next = NULL; /* Add new structure to the global list */ if( fsm_var_bind_head == NULL ) { fsm_var_bind_head = fsm_var_bind_tail = fvb; } else { fsm_var_bind_tail->next = fvb; fsm_var_bind_tail = fvb; } } else { fsm_var_bind_expr( sig_name, expr, funit_name ); } PROFILE_END; }

void fsm_var_cleanup (   )

Cleans up the global lists used in this file. Iterates through the various global lists in this file, deallocating all memory. This function is called when an error has occurred during the parsing stage. { PROFILE(FSM_VAR_CLEANUP); fsm_var* curr_fv; /* Pointer to the current fsm_var structure */ fsm_var* tmp_fv; /* Temporary pointer */ fv_bind* curr_fvb = fsm_var_bind_head; /* Pointer to the current fv_bind structure */ fv_bind* tmp_fvb; /* Temporary pointer */ /* Deallocate fsm_var list */ curr_fv = fsm_var_head; while( curr_fv != NULL ) { tmp_fv = curr_fv; curr_fv = curr_fv->next; free_safe( tmp_fv->funit, (strlen( curr_fv->funit ) + 1) ); expression_dealloc( tmp_fv->ivar, FALSE ); expression_dealloc( tmp_fv->ovar, FALSE ); free_safe( tmp_fv, sizeof( fsm_var ) ); } fsm_var_head = fsm_var_tail = NULL; /* Deallocate fsm_var_bind list */ curr_fvb = fsm_var_bind_head; while( curr_fvb != NULL ) { tmp_fvb = curr_fvb; curr_fvb = curr_fvb->next; free_safe( tmp_fvb->sig_name, (strlen( tmp_fvb->sig_name ) + 1) ); free_safe( tmp_fvb->funit_name, (strlen( tmp_fvb->funit_name ) + 1) ); expression_dealloc( tmp_fvb->expr, FALSE ); free_safe( tmp_fvb, sizeof( fv_bind ) ); } fsm_var_bind_head = fsm_var_bind_tail = NULL; /* Deallocate fsm_var_stmt list */ curr_fvb = fsm_var_stmt_head; while( curr_fvb != NULL ) { tmp_fvb = curr_fvb; curr_fvb = curr_fvb->next; free_safe( tmp_fvb->funit_name, (strlen( tmp_fvb->funit_name ) + 1) ); expression_dealloc( tmp_fvb->stmt->exp, FALSE ); statement_dealloc( tmp_fvb->stmt ); free_safe( tmp_fvb, sizeof( fv_bind ) ); } fsm_var_stmt_head = fsm_var_stmt_tail = NULL; PROFILE_END; }

void fsm_var_stmt_add (  statement *  stmt, char *  funit_name )

Add specified functional unit and statement to binding list. Allocates and initializes an FSM variable binding entry and adds it to the fsm_var_stmt list for later processing. Parameters: stmt  Pointer to statement containing FSM state expression funit_name  Name of functional unit that will contain stmt { PROFILE(FSM_VAR_STMT_ADD); fv_bind* fvb; /* Pointer to new FSM variable binding structure */ fvb = (fv_bind*)malloc_safe( sizeof( fv_bind ) ); fvb->stmt = stmt; fvb->funit_name = strdup_safe( funit_name ); fvb->next = NULL; /* Add new structure to the head of the global list */ if( fsm_var_stmt_head == NULL ) { fsm_var_stmt_head = fsm_var_stmt_tail = fvb; } else { fvb->next = fsm_var_stmt_head; fsm_var_stmt_head = fvb; } PROFILE_END; }

---