fsm_var.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "binding.h"
#include "codegen.h"
#include "db.h"
#include "defines.h"
#include "expr.h"
#include "fsm.h"
#include "fsm_var.h"
#include "link.h"
#include "obfuscate.h"
#include "statement.h"
#include "util.h"

Functions

static void fsm_var_remove (fsm_var *)
fsm_varfsm_var_add (const char *funit_name, int line, expression *in_state, expression *out_state, char *name, bool exclude)
 Allocates, initializes and adds FSM variable to global list.
static fsm_varfsm_var_is_output_state (expression *expr)
static void fsm_var_bind_expr (char *sig_name, expression *expr, char *funit_name)
static void fsm_var_add_expr (expression *expr, func_unit *funit)
static bool fsm_var_bind_stmt (statement *stmt, const char *funit_name)
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.
static void fsm_var_dealloc (fsm_var *fv)
void fsm_var_cleanup ()
 Cleans up the global lists used in this file.

Variables

char user_msg [USER_MSG_LENGTH]
db ** db_list
unsigned int curr_db
func_unitcurr_funit
static fsm_varfsm_var_head = NULL
static fsm_varfsm_var_tail = NULL
static fv_bindfsm_var_bind_head = NULL
static fv_bindfsm_var_bind_tail = NULL
static fv_bindfsm_var_stmt_head = NULL
static fv_bindfsm_var_stmt_tail = NULL

Detailed Description

Author:
Trevor Williams (phase1geo@gmail.com)
Date:
10/3/2003

Function Documentation

fsm_var* fsm_var_add ( const char *  funit_name,
int  line,
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
line First line of FSM 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

References curr_db, fsm_var_s::exclude, fsm_create(), func_unit_s::fsm_head, fsm_link_add(), func_unit_s::fsm_tail, funit_link_s::funit, fsm_var_s::funit, funit_head, funit_link_find(), FUNIT_MODULE, fsm_var_s::iexp, fsm_var_s::ivar, fsm_var_s::line, malloc_safe, fsm_s::name, fsm_var_s::name, fsm_var_s::next, fsm_var_s::ovar, PROFILE, strdup_safe, expression_s::table, and fsm_var_s::table.

Referenced by fsm_arg_parse(), and fsm_arg_parse_attr().

00109   { PROFILE(FSM_VAR_ADD);
00110 
00111   fsm_var*    new_var = NULL;  /* Pointer to newly created FSM variable */
00112   funit_link* funitl;          /* Pointer to functional unit link found */
00113   fsm*        table;           /* Pointer to newly create FSM */
00114 
00115   /* If we have not parsed design, add new FSM variable to list */
00116   if( db_list[curr_db]->funit_head == NULL ) {
00117 
00118     new_var          = (fsm_var*)malloc_safe( sizeof( fsm_var ) );
00119     new_var->funit   = strdup_safe( funit_name );
00120     new_var->name    = NULL;
00121     new_var->ivar    = in_state;
00122     new_var->ovar    = out_state;
00123     new_var->iexp    = NULL;
00124     new_var->table   = NULL;
00125     new_var->exclude = exclude;
00126     new_var->line    = line;
00127     new_var->next    = NULL;
00128 
00129     if( fsm_var_head == NULL ) {
00130       fsm_var_head = fsm_var_tail = new_var;
00131     } else {
00132       fsm_var_tail->next = new_var;
00133       fsm_var_tail       = new_var;
00134     }
00135 
00136   } else {
00137 
00138     if( (funitl = funit_link_find( funit_name, FUNIT_MODULE, db_list[curr_db]->funit_head )) != NULL ) {
00139       table = fsm_create( in_state, out_state, line, exclude );
00140       if( name != NULL ) {
00141         table->name = strdup_safe( name );
00142       }
00143       in_state->table  = table;
00144       out_state->table = table;
00145       fsm_link_add( table, &(funitl->funit->fsm_head), &(funitl->funit->fsm_tail) );
00146     } else {
00147       assert( funitl != NULL );
00148     }
00149 
00150   }
00151 
00152   return( new_var );
00153 
00154 }

static void fsm_var_add_expr ( expression expr,
func_unit funit 
) [static]

Iterates through specified expression tree, adding each expression to the specified functional unit if the expression does not already exist in the functional unit.

Parameters:
expr Pointer to expression to add to the specified functional unit
funit Pointer to functional unit structure to add expression to

References db_add_expression(), func_unit_s::exp_head, exp_link_add(), exp_link_find(), func_unit_s::exp_tail, expression_s::id, expression_s::left, PROFILE, PROFILE_END, and expression_s::right.

Referenced by fsm_var_bind_stmt().

00225   { PROFILE(FSM_VAR_ADD_EXPR);
00226 
00227   if( expr != NULL ) {
00228 
00229     if( exp_link_find( expr->id, funit->exp_head ) == NULL ) {
00230 
00231       /* Set the global curr_funit to the expression's functional unit */
00232       curr_funit = funit;
00233 
00234       /* Add expression's children first. */
00235       db_add_expression( expr->right );
00236       db_add_expression( expr->left );
00237 
00238       /* Now add this expression to the list. */
00239       exp_link_add( expr, &(funit->exp_head), &(funit->exp_tail) );
00240 
00241       /* Now clear the curr_funit */
00242       curr_funit = NULL;
00243 
00244     }
00245 
00246   }
00247 
00248   PROFILE_END;
00249 
00250 }

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.

References Catch_anonymous, fv_bind_s::expr, free_safe, fsm_var_bind_expr(), fsm_var_bind_stmt(), fv_bind_s::funit_name, fv_bind_s::next, PROFILE, PROFILE_END, fv_bind_s::sig_name, fv_bind_s::stmt, Throw, and Try.

Referenced by parse_design().

00394                     { PROFILE(FSM_VAR_BIND);
00395 
00396   fv_bind* curr = NULL;  /* Pointer to current FSM variable */
00397   fv_bind* tmp;          /* Temporary pointer to FSM bind structure */
00398 
00399   Try {
00400 
00401     curr = fsm_var_bind_head;
00402     while( curr != NULL ) {
00403 
00404       /* Perform binding */
00405       fsm_var_bind_expr( curr->sig_name, curr->expr, curr->funit_name );
00406 
00407       tmp = curr->next;
00408 
00409       /* Deallocate memory for this bind structure */
00410       free_safe( curr->sig_name, (strlen( curr->sig_name ) + 1) );
00411       free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
00412       free_safe( curr, sizeof( fv_bind ) );
00413 
00414       curr = tmp;
00415 
00416     }
00417 
00418   } Catch_anonymous {
00419     while( curr != NULL ) {
00420       tmp = curr->next;
00421       free_safe( curr->sig_name, (strlen( curr->sig_name ) + 1) );
00422       free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
00423       free_safe( curr, sizeof( fv_bind ) );
00424       curr = tmp;
00425     } 
00426     curr = fsm_var_stmt_head;
00427     while( curr != NULL ) {
00428       tmp = curr->next;
00429       free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
00430       free_safe( curr, sizeof( fv_bind ) );
00431       curr = tmp;
00432     }
00433     Throw 0;
00434   }
00435 
00436   curr = fsm_var_stmt_head;
00437   while( curr != NULL ) {
00438 
00439     /* Bind statement to functional unit */
00440     (void)fsm_var_bind_stmt( curr->stmt, curr->funit_name );
00441 
00442     tmp = curr->next;
00443 
00444     /* Deallocate memory for this bind structure */
00445     free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
00446     free_safe( curr, sizeof( fv_bind ) );
00447 
00448     curr = tmp;
00449 
00450   }
00451 
00452   PROFILE_END;
00453 
00454 }

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

References curr_db, fv_bind_s::expr, fsm_var_bind_expr(), funit_head, fv_bind_s::funit_name, malloc_safe, fv_bind_s::next, PROFILE, PROFILE_END, fv_bind_s::sig_name, and strdup_safe.

Referenced by fsm_arg_parse_state().

00319   { PROFILE(FSM_VAR_BIND_ADD);
00320 
00321   fv_bind* fvb;  /* Pointer to new FSM variable binding structure */
00322 
00323   /* If the functional unit list does not exist yet, we need to bind this later; otherwise, bind now */
00324   if( db_list[curr_db]->funit_head == NULL ) {
00325 
00326     /* Allocate and initialize FSM variable bind structure */
00327     fvb             = (fv_bind*)malloc_safe( sizeof( fv_bind ) );
00328     fvb->sig_name   = strdup_safe( sig_name );
00329     fvb->expr       = expr;
00330     fvb->funit_name = strdup_safe( funit_name );
00331     fvb->next       = NULL;
00332 
00333     /* Add new structure to the global list */
00334     if( fsm_var_bind_head == NULL ) {
00335       fsm_var_bind_head = fsm_var_bind_tail = fvb;
00336     } else {
00337       fsm_var_bind_tail->next = fvb;
00338       fsm_var_bind_tail       = fvb;
00339     }
00340 
00341   } else {
00342 
00343     fsm_var_bind_expr( sig_name, expr, funit_name );
00344 
00345   }
00346 
00347   PROFILE_END;
00348 
00349 }

static void fsm_var_bind_expr ( char *  sig_name,
expression expr,
char *  funit_name 
) [static]
Exceptions:
anonymous Throw Throw

Searches the functional unit list for the functional unit called funit_name. If the functional unit is found in the design, searches this functional unit for the signal called sig_name. If the signal is found, the signal and specified expression expr are bound to each other and this function returns a value of TRUE. If the signal name could not be found or the functional unit name could not be found in the design, no binding occurs and the function displays an error message and returns a value of FALSE to the calling function.

Parameters:
sig_name String name of signal to bind to specified expression
expr Pointer to expression to bind to signal called sig_name
funit_name String name of functional unit that contains the expression pointed to by expr

References bind_signal(), curr_db, FALSE, FATAL, funit_link_s::funit, funit_head, funit_link_find(), FUNIT_MODULE, expression_s::id, expression_s::line, obf_funit, obf_sig, print_output(), PROFILE, PROFILE_END, Throw, TRUE, user_msg, and USER_MSG_LENGTH.

Referenced by fsm_var_bind(), and fsm_var_bind_add().

00195   { PROFILE(FSM_VAR_BIND_EXPR);
00196 
00197   funit_link* funitl;  /* Pointer to found functional unit link element */
00198 
00199   if( (funitl = funit_link_find( funit_name, FUNIT_MODULE, db_list[curr_db]->funit_head )) != NULL ) {
00200     if( !bind_signal( sig_name, expr, funitl->funit, TRUE, FALSE, FALSE, expr->line, FALSE ) ) {
00201       unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Unable to bind FSM-specified signal (%s) to expression (%d) in module (%s)",
00202                                   obf_sig( sig_name ), expr->id, obf_funit( funit_name ) );
00203       assert( rv < USER_MSG_LENGTH );
00204       print_output( user_msg, FATAL, __FILE__, __LINE__ );
00205       Throw 0;
00206     }
00207   } else {
00208     unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Unable to find FSM-specified module (%s) in design", obf_funit( funit_name ) ); 
00209     assert( rv < USER_MSG_LENGTH );
00210     print_output( user_msg, FATAL, __FILE__, __LINE__ );
00211     Throw 0;
00212   }
00213 
00214   PROFILE_END;
00215 
00216 }

static bool fsm_var_bind_stmt ( statement stmt,
const char *  funit_name 
) [static]
Returns:
Returns a value of TRUE if the statement was successfully bound to the specified functional unit name; otherwise, returns a value of FALSE.

Searches the design functional unit list for a functional unit called funit_name. If the functional unit is found in the design, adds the statement's expression tree to the design, sets the STMT_ADDED bit in the statement's supplemental field, adds this statement to the found functional unit structure, and finally creates an FSM table if the statement contains an output state FSM expression tree and returns a value of TRUE to the calling function. If the functional unit could not be found, this function, returns a value of FALSE to the calling function.

Parameters:
stmt Pointer to statement to bind
funit_name String name of functional unit which will contain stmt

References curr_db, fsm_var_s::exclude, statement_s::exp, FALSE, fsm_create(), func_unit_s::fsm_head, fsm_link_add(), func_unit_s::fsm_tail, fsm_var_add_expr(), fsm_var_is_output_state(), fsm_var_remove(), statement_s::funit, funit_link_s::funit, funit_head, funit_link_find(), FUNIT_MODULE, fsm_var_s::ivar, fsm_var_s::line, fsm_var_s::ovar, statement_s::part, PROFILE, PROFILE_END, func_unit_s::stmt_head, stmt_link_add(), func_unit_s::stmt_tail, statement_s::suppl, expression_s::table, fsm_var_s::table, and TRUE.

Referenced by fsm_var_bind().

00267   { PROFILE(FSM_VAR_BIND_STMT);
00268 
00269   bool        retval = FALSE;  /* Return value for this function */
00270   funit_link* funitl;          /* Pointer to found functional unit link element */
00271   fsm_var*    fv;              /* Pointer to found FSM variable */
00272 
00273   if( (funitl = funit_link_find( funit_name, FUNIT_MODULE, db_list[curr_db]->funit_head )) != NULL ) {
00274 
00275     /* First, add expression tree to found functional unit expression list */
00276     fsm_var_add_expr( stmt->exp, funitl->funit );
00277 
00278     /* Set ADDED bit of this statement */
00279     stmt->suppl.part.added = 1;
00280 
00281     /* Second, add our statement to this functional unit's statement list */
00282     (void)stmt_link_add( stmt, TRUE, &(funitl->funit->stmt_head), &(funitl->funit->stmt_tail) );
00283 
00284     /* Third, add the functional unit to this statement's pointer */
00285     stmt->funit = funitl->funit;
00286 
00287     /* Finally, create the new FSM if we are the output state */
00288     if( (fv = fsm_var_is_output_state( stmt->exp )) != NULL ) {
00289       fv->table       = fsm_create( fv->ivar, fv->ovar, fv->line, fv->exclude );
00290       fv->ivar->table = fv->table;
00291       fv->ovar->table = fv->table;
00292       fsm_link_add( fv->table, &(funitl->funit->fsm_head), &(funitl->funit->fsm_tail) );
00293       fsm_var_remove( fv );
00294     }
00295 
00296   } else {
00297 
00298     retval = FALSE;
00299 
00300   }
00301 
00302   PROFILE_END;
00303 
00304   return( retval );
00305 
00306 }

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.

References statement_s::exp, fv_bind_s::expr, expression_dealloc(), FALSE, free_safe, fsm_var_s::funit, fv_bind_s::funit_name, fsm_var_s::ivar, fv_bind_s::next, fsm_var_s::next, fsm_var_s::ovar, PROFILE, PROFILE_END, fv_bind_s::sig_name, statement_dealloc(), and fv_bind_s::stmt.

Referenced by command_score(), and parse_design().

00522                        { PROFILE(FSM_VAR_CLEANUP);
00523 
00524   fsm_var* curr_fv;   /* Pointer to the current fsm_var structure */
00525   fsm_var* tmp_fv;    /* Temporary pointer */
00526   fv_bind* curr_fvb;  /* Pointer to the current fv_bind structure */ 
00527   fv_bind* tmp_fvb;   /* Temporary pointer */
00528 
00529   /* Deallocate fsm_var list */
00530   curr_fv = fsm_var_head;
00531   while( curr_fv != NULL ) {
00532     tmp_fv  = curr_fv;
00533     curr_fv = curr_fv->next;
00534 
00535     free_safe( tmp_fv->funit, (strlen( curr_fv->funit ) + 1) );
00536     expression_dealloc( tmp_fv->ivar, FALSE );
00537     expression_dealloc( tmp_fv->ovar, FALSE );
00538     free_safe( tmp_fv, sizeof( fsm_var ) );
00539   }
00540   fsm_var_head = fsm_var_tail = NULL;
00541 
00542   /* Deallocate fsm_var_bind list */
00543   curr_fvb = fsm_var_bind_head;
00544   while( curr_fvb != NULL ) {
00545     tmp_fvb  = curr_fvb;
00546     curr_fvb = curr_fvb->next;
00547 
00548     free_safe( tmp_fvb->sig_name,   (strlen( tmp_fvb->sig_name ) + 1) );
00549     free_safe( tmp_fvb->funit_name, (strlen( tmp_fvb->funit_name ) + 1) );
00550     expression_dealloc( tmp_fvb->expr, FALSE );
00551     free_safe( tmp_fvb, sizeof( fv_bind ) );
00552   }
00553   fsm_var_bind_head = fsm_var_bind_tail = NULL;
00554 
00555   /* Deallocate fsm_var_stmt list */
00556   curr_fvb = fsm_var_stmt_head;
00557   while( curr_fvb != NULL ) {
00558     tmp_fvb  = curr_fvb;
00559     curr_fvb = curr_fvb->next;
00560     
00561     free_safe( tmp_fvb->funit_name, (strlen( tmp_fvb->funit_name ) + 1) );
00562     expression_dealloc( tmp_fvb->stmt->exp, FALSE );
00563     statement_dealloc( tmp_fvb->stmt );
00564     free_safe( tmp_fvb, sizeof( fv_bind ) );
00565   }
00566   fsm_var_stmt_head = fsm_var_stmt_tail = NULL;
00567 
00568   PROFILE_END;
00569 
00570 }

static void fsm_var_dealloc ( fsm_var fv  )  [static]

Deallocates an FSM variable entry from memory.

Parameters:
fv Pointer to FSM variable to deallocate

References free_safe, fsm_var_s::funit, PROFILE, and PROFILE_END.

Referenced by fsm_var_remove().

00461   { PROFILE(FSM_VAR_DEALLOC);
00462 
00463   if( fv != NULL ) {
00464 
00465     /* Deallocate the functional unit name string */
00466     free_safe( fv->funit, (strlen( fv->funit ) + 1) );
00467 
00468     /* Finally, deallocate ourself */
00469     free_safe( fv, sizeof( fsm_var ) );
00470 
00471   }
00472 
00473   PROFILE_END;
00474 
00475 }

static fsm_var* fsm_var_is_output_state ( expression expr  )  [static]
Returns:
Returns pointer to found FSM variable that contains this expression as an output expression.

Searches the FSM variable list for the FSM variable that contains the specified expression as its output state expression. If no FSM variable was found, returns a value of NULL to the calling function.

Parameters:
expr Pointer to expression to evaluate

References fsm_var_s::next, fsm_var_s::ovar, PROFILE, and PROFILE_END.

Referenced by fsm_var_bind_stmt().

00166   { PROFILE(FSM_VAR_IS_OUTPUT_STATE);
00167 
00168   fsm_var* curr;  /* Pointer to current FSM variable structure */
00169 
00170   curr = fsm_var_head;
00171   while( (curr != NULL) && (curr->ovar != expr) ) {
00172     curr = curr->next;
00173   }
00174 
00175   PROFILE_END;
00176 
00177   return( curr );
00178 
00179 }

void fsm_var_remove ( fsm_var fv  )  [static]

Searches global FSM variable list for matching FSM variable structure. When match is found, remove the structure and deallocate it from memory being sure to keep the global list intact.

Parameters:
fv Pointer to FSM variable structure to remove from global list

References fsm_var_dealloc(), fsm_var_s::next, PROFILE, and PROFILE_END.

Referenced by fsm_var_bind_stmt().

00484   { PROFILE(FSM_VAR_REMOVE);
00485 
00486   fsm_var* curr;  /* Pointer to current FSM variable structure in list */
00487   fsm_var* last;  /* Pointer to last FSM variable structure evaluated */
00488 
00489   /* Find matching FSM variable structure */
00490   curr = fsm_var_head;
00491   last = NULL;
00492   while( (curr != NULL) && (curr != fv) ) {
00493     last = curr;
00494     curr = curr->next;
00495   }
00496 
00497   /* If a matching FSM variable structure was found, remove it from the global list. */
00498   if( curr != NULL ) {
00499 
00500     if( (curr == fsm_var_head) && (curr == fsm_var_tail) ) {
00501       fsm_var_head = fsm_var_tail = NULL;
00502     } else if( curr == fsm_var_head ) {
00503       fsm_var_head = curr->next;
00504     } else if( curr == fsm_var_tail ) {
00505       fsm_var_tail = last;
00506     } else {
00507       last->next = curr->next;
00508     }
00509 
00510     fsm_var_dealloc( curr );
00511 
00512   }
00513 
00514   PROFILE_END;
00515 
00516 }

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

References fv_bind_s::funit_name, malloc_safe, fv_bind_s::next, PROFILE, PROFILE_END, fv_bind_s::stmt, and strdup_safe.

Referenced by fsm_arg_parse_state().

00358   { PROFILE(FSM_VAR_STMT_ADD);
00359 
00360   fv_bind* fvb;  /* Pointer to new FSM variable binding structure */
00361 
00362   fvb             = (fv_bind*)malloc_safe( sizeof( fv_bind ) );
00363   fvb->stmt       = stmt;
00364   fvb->funit_name = strdup_safe( funit_name );
00365   fvb->next       = NULL;
00366 
00367   /* Add new structure to the head of the global list */
00368   if( fsm_var_stmt_head == NULL ) {
00369     fsm_var_stmt_head = fsm_var_stmt_tail = fvb;
00370   } else {
00371     fvb->next         = fsm_var_stmt_head;
00372     fsm_var_stmt_head = fvb;
00373   }
00374 
00375   PROFILE_END;
00376 
00377 }


Variable Documentation

unsigned int curr_db

Index of current database in db_list array that is being handled.

Pointer to the functional unit structure for the functional unit that is currently being parsed.

Array of database pointers storing all currently loaded databases.

fv_bind* fsm_var_bind_head = NULL [static]

Pointer to the head of the list of FSM variable bindings between signal names and expression pointers. During the command-line parse of FSM variables, bindings will be submitted into this list for processing after Verilog parsing has completed. After Verilog parsing has completed, the FSM bind function needs to be called to bind all FSM signals/expressions to each other.

fv_bind* fsm_var_bind_tail = NULL [static]

Pointer to the tail of the list of FSM variable bindings.

fsm_var* fsm_var_head = NULL [static]

Pointer to the head of the list of FSM scopes in the design. To extract an FSM, the user must specify the scope to the FSM state variable of the FSM to extract. When the parser finds this signal in the design, the appropriate FSM is created and initialized. As a note, we may make the FSM extraction more automatic (smarter) in the future, but we will always allow the user to make these choices with the -F option to the score command.

fv_bind* fsm_var_stmt_head = NULL [static]

Pointer to the head of the list of FSM variable statement/functional unit bindings. During the command-line parse of FSM variables, bindings will be submitted into this list for processing after Verilog parsing has completed. After Verilog parsing has completed, the FSM bind function needs to be called to bind all FSM statements/functional units to each other.

fv_bind* fsm_var_stmt_tail = NULL [static]

Pointer to the tail of the list of FSM statement/functional unit bindings.

fsm_var* fsm_var_tail = NULL [static]

Pointer to the tail of the list of FSM scopes in the design.

char user_msg[USER_MSG_LENGTH]

Holds some output that will be displayed via the print_output command. This is created globally so that memory does not need to be reallocated for each function that wishes to use it.

Generated on Sun Nov 21 00:55:38 2010 for Covered by  doxygen 1.6.3