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

---

Detailed Description

Contains functions for determining/reporting FSM coverage.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

3/31/2002

#include <stdio.h>
#include "defines.h"

Go to the source code of this file.

Functions
fsm *	fsm_create (expression *from_state, expression *to_state, bool exclude)
	Creates and initializes new FSM structure.
void	fsm_add_arc (fsm *table, expression *from_state, expression *to_state)
	Adds new FSM arc structure to specified FSMs arc list.
void	fsm_create_tables (fsm *table)
	Sets sizes of tables in specified FSM structure.
void	fsm_db_write (fsm *table, FILE *file, bool ids_issued)
	Outputs contents of specified FSM to CDD file.
void	fsm_db_read (char **line, func_unit *funit)
	Reads in contents of specified FSM.
void	fsm_db_merge (fsm *base, char **line)
	Reads and merges two FSMs, placing result into base FSM.
void	fsm_merge (fsm *base, fsm *other)
	Merges two FSMs, placing the result into the base FSM.
void	fsm_table_set (expression *expr, const sim_time *time)
	Sets the bit in set table based on the values of last and curr.
void	fsm_get_stats (fsm_link *table, int *state_hit, int *state_total, int *arc_hit, int *arc_total, int *arc_excluded)
	Gathers statistics about the current FSM.
void	fsm_get_funit_summary (func_unit *funit, int *hit, int *excluded, int *total)
	Retrieves the FSM summary information for the specified functional unit.
void	fsm_get_inst_summary (funit_inst *inst, int *hit, int *excluded, int *total)
	Retrieves the FSM summary information for the specified functional unit.
void	fsm_collect (func_unit *funit, int cov, sig_link **sig_head, sig_link **sig_tail, int **expr_ids, int **excludes)
	Retrieves covered or uncovered FSMs from the specified functional unit.
void	fsm_get_coverage (func_unit *funit, int expr_id, char ***total_fr_states, unsigned int *total_fr_state_num, char ***total_to_states, unsigned int *total_to_state_num, char ***hit_fr_states, unsigned int *hit_fr_state_num, char ***hit_to_states, unsigned int *hit_to_state_num, char ***total_from_arcs, char ***total_to_arcs, int **total_ids, int **excludes, char ***reasons, int *total_arc_num, char ***hit_from_arcs, char ***hit_to_arcs, int *hit_arc_num, char ***input_state, unsigned int *input_size, char ***output_state, unsigned int *output_size)
	Collects all coverage information for the specified FSM.
void	fsm_report (FILE *ofile, bool verbose)
	Generates report output for FSM coverage.
void	fsm_dealloc (fsm *table)
	Deallocates specified FSM structure.

---

Function Documentation

void fsm_add_arc (  fsm *  table, expression *  from_state, expression *  to_state )

Adds new FSM arc structure to specified FSMs arc list. Adds new FSM arc structure to specified FSMs arc list. Parameters: table  Pointer to FSM structure to add new arc to from_state  Pointer to from_state expression to add to_state  Pointer to to_state expression to add { PROFILE(FSM_ADD_ARC); fsm_arc* arc; /* Pointer to newly created FSM arc structure */ /* Create an initialize specified arc */ arc = (fsm_arc*)malloc_safe( sizeof( fsm_arc ) ); arc->from_state = from_state; arc->to_state = to_state; arc->next = NULL; /* Add new arc to specified FSM structure */ if( table->arc_head == NULL ) { table->arc_head = table->arc_tail = arc; } else { table->arc_tail->next = arc; table->arc_tail = arc; } PROFILE_END; }

void fsm_collect (  func_unit *  funit, int  cov, sig_link **  sig_head, sig_link **  sig_tail, int **  expr_ids, int **  excludes )

Retrieves covered or uncovered FSMs from the specified functional unit. Gathers the covered or uncovered FSM information, storing their expressions in the sig_head/sig_tail signal list. Used by the GUI for verbose FSM output. Parameters: funit  Pointer to functional unit cov  Specifies if we are attempting to get uncovered (0) or covered (1) FSMs sig_head  Pointer to the head of the signal list of covered FSM output states sig_tail  Pointer to the tail of the signal list of covered FSM output states expr_ids  Pointer to array of expression IDs for each uncovered signal excludes  Pointer to array of exclude values for each uncovered signal { PROFILE(FSM_COLLECT); fsm_link* curr_fsm; /* Pointer to current FSM link being evaluated */ int size = 0; /* Number of expressions IDs stored in expr_ids array */ /* Initialize list pointers */ *sig_tail = *sig_head = NULL; *expr_ids = *excludes = NULL; curr_fsm = funit->fsm_head; while( curr_fsm != NULL ) { /* Get the state and arc statistics */ int state_hit = 0; int state_total = 0; int arc_hit = 0; int arc_total = 0; int arc_excluded = 0; arc_get_stats( curr_fsm->table->table, &state_hit, &state_total, &arc_hit, &arc_total, &arc_excluded ); /* Allocate some more memory for the excluded array */ *excludes = (int*)realloc_safe( *excludes, (sizeof( int ) * size), (sizeof( int ) * (size + 1)) ); /* If the total number of arcs is not known, consider this FSM as uncovered */ if( (cov == 0) && ((arc_total == -1) || (arc_total != arc_hit)) ) { (*excludes)[size] = 0; fsm_gather_signals( curr_fsm->table->to_state, sig_head, sig_tail, curr_fsm->table->to_state->id, expr_ids, &size ); } else { if( (cov == 0) && arc_are_any_excluded( curr_fsm->table->table ) ) { fsm_gather_signals( curr_fsm->table->to_state, sig_head, sig_tail, curr_fsm->table->to_state->id, expr_ids, &size ); (*excludes)[size] = 1; } else if( cov == 1 ) { fsm_gather_signals( curr_fsm->table->to_state, sig_head, sig_tail, -1, expr_ids, &size ); } } curr_fsm = curr_fsm->next; } PROFILE_END; }

fsm* fsm_create (  expression *  from_state, expression *  to_state, bool  exclude )

Creates and initializes new FSM structure. Returns: Returns a pointer to the newly allocated FSM structure. Allocates and initializes an FSM structure. Parameters: from_state  Pointer to expression that is input state variable for this FSM to_state  Pointer to expression that is output state variable for this FSM exclude  Value to set the exclude bit to { PROFILE(FSM_CREATE); fsm* table; /* Pointer to newly created FSM */ table = (fsm*)malloc_safe( sizeof( fsm ) ); table->name = NULL; table->from_state = from_state; table->to_state = to_state; table->arc_head = NULL; table->arc_tail = NULL; table->table = NULL; table->exclude = exclude; return( table ); }

void fsm_create_tables (  fsm *  table  )

Sets sizes of tables in specified FSM structure. After the FSM signals are sized, this function is called to size an FSM structure (allocate memory for its tables) and the associated FSM arc list is parsed, setting the appropriate bit in the valid table. Parameters: table  Pointer to FSM structure to set table sizes to { PROFILE(FSM_CREATE_TABLES); fsm_arc* curr_arc; /* Pointer to current FSM arc structure */ bool set = TRUE; /* Specifies if specified bit was set */ sim_time time; /* Current simulation time */ /* Create the FSM arc transition table */ assert( table != NULL ); assert( table->to_state != NULL ); assert( table->to_state->value != NULL ); assert( table->table == NULL ); table->table = arc_create( table->to_state->value->width ); /* Initialize the current time */ time.lo = 0; time.hi = 0; time.full = 0; time.final = FALSE; /* Set valid table */ curr_arc = table->arc_head; while( (curr_arc != NULL) && set ) { /* Evaluate from and to state expressions */ (void)expression_operate( curr_arc->from_state, NULL, &time ); (void)expression_operate( curr_arc->to_state, NULL, &time ); /* Set table entry in table, if possible */ arc_add( table->table, curr_arc->from_state->value, curr_arc->to_state->value, 0, table->exclude ); curr_arc = curr_arc->next; } PROFILE_END; }

void fsm_db_merge (  fsm *  base, char **  line )

Reads and merges two FSMs, placing result into base FSM. Parameters: base  Pointer to FSM structure to merge data into. line  Pointer to read in line from CDD file to merge. Exceptions: anonymous  arc_db_merge Throw Parses specified line for FSM information and performs merge of the base and in FSMs, placing the resulting merged FSM into the base signal. If the FSMs are found to be unalike (names are different), an error message is displayed to the user. If both FSMs are the same, perform the merge on the FSM's tables. { PROFILE(FSM_DB_MERGE); int iid; /* Input state variable expression ID */ int oid; /* Output state variable expression ID */ int chars_read; /* Number of characters read from line */ int is_table; /* Holds value of is_table signifier */ assert( base != NULL ); assert( base->from_state != NULL ); assert( base->to_state != NULL ); if( sscanf( *line, "%d %d %d%n", &iid, &oid, &is_table, &chars_read ) == 3 ) { *line = *line + chars_read + 1; if( is_table == 1 ) { arc_db_merge( base->table, line ); } } else { print_output( "Database being merged is not compatible with the original database.", FATAL, __FILE__, __LINE__ ); Throw 0; } PROFILE_END; }

void fsm_db_read (  char **  line, func_unit *  funit )

Reads in contents of specified FSM. Parameters: line  Pointer to current line being read from the CDD file. funit  Pointer to current functional unit. Exceptions: anonymous  expression_create Throw Throw Throw Throw arc_db_read Reads in contents of FSM line from CDD file and stores newly created FSM into the specified functional unit. { PROFILE(FSM_DB_READ); int iexp_id; /* Input expression ID */ int oexp_id; /* Output expression ID */ exp_link* iexpl; /* Pointer to found state variable */ exp_link* oexpl; /* Pointer to found state variable */ int chars_read; /* Number of characters read from sscanf */ fsm* table; /* Pointer to newly created FSM structure from CDD */ int is_table; /* Holds value of is_table entry of FSM output */ if( sscanf( *line, "%d %d %d%n", &iexp_id, &oexp_id, &is_table, &chars_read ) == 3 ) { *line = *line + chars_read + 1; if( funit == NULL ) { print_output( "Internal error: FSM in database written before its functional unit", FATAL, __FILE__, __LINE__ ); Throw 0; } else { /* Find specified signal */ if( ((iexpl = exp_link_find( iexp_id, funit->exp_head )) != NULL) && ((oexpl = exp_link_find( oexp_id, funit->exp_head )) != NULL) ) { /* Create new FSM */ table = fsm_create( iexpl->exp, oexpl->exp, FALSE ); /* If the input state variable is the same as the output state variable, create the new expression now. */ if( iexp_id == oexp_id ) { Try { table->from_state = expression_create( NULL, NULL, EXP_OP_STATIC, FALSE, iexp_id, 0, 0, 0, FALSE ); } Catch_anonymous { fsm_dealloc( table ); Throw 0; } vector_dealloc( table->from_state->value ); bind_append_fsm_expr( table->from_state, iexpl->exp, funit ); } else { table->from_state = iexpl->exp; } /* Set input/output expression tables to point to this FSM */ table->from_state->table = table; table->to_state->table = table; /* Now read in set table */ if( is_table == 1 ) { Try { arc_db_read( &(table->table), line ); } Catch_anonymous { fsm_dealloc( table ); Throw 0; } } /* Add fsm to current functional unit */ fsm_link_add( table, &(funit->fsm_head), &(funit->fsm_tail) ); } else { unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Unable to find state variable expressions (%d, %d) for current FSM", iexp_id, oexp_id ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, FATAL, __FILE__, __LINE__ ); Throw 0; } } } else { print_output( "Unable to parse FSM line in database file. Unable to read.", FATAL, __FILE__, __LINE__ ); Throw 0; } PROFILE_END; }

void fsm_db_write (  fsm *  table, FILE *  file, bool  ids_issued )

Outputs contents of specified FSM to CDD file. Outputs the contents of the specified FSM to the specified CDD file. Parameters: table  Pointer to FSM structure to output file  Pointer to file output stream to write to ids_issued  Set to TRUE if expression IDs were just issued { PROFILE(FSM_DB_WRITE); fprintf( file, "%d %d %d ", DB_TYPE_FSM, expression_get_id( table->from_state, ids_issued ), expression_get_id( table->to_state, ids_issued ) ); /* Print set table */ if( table->table != NULL ) { fprintf( file, "1 " ); arc_db_write( table->table, file ); /* Deallocate the given table after writing it */ if( table->table != NULL ) { arc_dealloc( table->table ); table->table = NULL; } } else { fprintf( file, "0" ); } fprintf( file, "\n" ); PROFILE_END; }

void fsm_dealloc (  fsm *  table  )

Deallocates specified FSM structure. Deallocates all allocated memory for the specified FSM structure. Parameters: table  Pointer to FSM structure to deallocate { PROFILE(FSM_DEALLOC); fsm_arc* tmp; /* Temporary pointer to current FSM arc structure to deallocate */ if( table != NULL ) { /* Free name if one was specified */ if( table->name != NULL ) { free_safe( table->name, (strlen( table->name ) + 1) ); } /* Deallocate tables */ arc_dealloc( table->table ); /* Deallocate FSM arc structure */ while( table->arc_head != NULL ) { tmp = table->arc_head; table->arc_head = table->arc_head->next; expression_dealloc( tmp->to_state, FALSE ); expression_dealloc( tmp->from_state, FALSE ); free_safe( tmp, sizeof( fsm_arc ) ); } /* Deallocate from_state if it is the same expression ID as the to_state expression and is not the same expression structure */ if( (table->from_state != NULL) && (table->to_state != NULL) && (table->from_state != table->to_state ) && (table->from_state->id == table->to_state->id) ) { expression_dealloc( table->from_state, FALSE ); } /* Deallocate this structure */ free_safe( table, sizeof( fsm ) ); } PROFILE_END; }

void fsm_get_coverage (  func_unit *  funit, int  expr_id, char ***  total_fr_states, unsigned int *  total_fr_state_num, char ***  total_to_states, unsigned int *  total_to_state_num, char ***  hit_fr_states, unsigned int *  hit_fr_state_num, char ***  hit_to_states, unsigned int *  hit_to_state_num, char ***  total_from_arcs, char ***  total_to_arcs, int **  total_ids, int **  excludes, char ***  reasons, int *  total_arc_num, char ***  hit_from_arcs, char ***  hit_to_arcs, int *  hit_arc_num, char ***  input_state, unsigned int *  input_size, char ***  output_state, unsigned int *  output_size )

Collects all coverage information for the specified FSM. Gets the FSM coverage information for the specified FSM in the specified functional unit. Used by the GUI for creating the contents of the verbose FSM viewer. Parameters: funit  Pointer to functional unit expr_id  Expression ID of output state expression to find total_fr_states  Pointer to a string array containing all possible from states in this FSM total_fr_state_num  Pointer to the number of elements in the total_fr_states array total_to_states  Pointer to a string array containing all possible to states in this FSM total_to_state_num  Pointer to the number of elements in the total_to_states array hit_fr_states  Pointer to a string array containing the hit fr_states in this FSM hit_fr_state_num  Pointer to the number of elements in the hit_fr_states array hit_to_states  Pointer to a string array containing the hit to_states in this FSM hit_to_state_num  Pointer to the number of elements in the hit_to_states array total_from_arcs  Pointer to a string array containing all possible state transition from states total_to_arcs  Pointer to a string array containing all possible state transition to states total_ids  Pointer to an integer array containing the arc transition IDs for each transition excludes  Pointer to an integer array containing the exclude values for each state transition reasons  Pointer to a string array containing exclusion reasons total_arc_num  Pointer to the number of elements in both the total_from_arcs, total_to_arcs and excludes arrays hit_from_arcs  Pointer to a string array containing the hit state transition from states hit_to_arcs  Pointer to a string array containing the hit state transition to states hit_arc_num  Pointer to the number of elements in both the hit_from_arcs and hit_to_arcs arrays input_state  Pointer to a string array containing the code for the input state expression input_size  Pointer to the number of elements stored in the input state array output_state  Pointer to a string array containing the code for the output state expression output_size  Pointer to the number of elements stored in the output state array { PROFILE(FSM_GET_COVERAGE); fsm_link* curr_fsm; /* Pointer to current FSM link */ int* tmp_ids; /* Temporary integer array */ int* tmp; /* Temporary integer array */ char** tmp_reasons; /* Temporary reason array */ curr_fsm = funit->fsm_head; while( (curr_fsm != NULL) && (curr_fsm->table->to_state->id != expr_id) ) { curr_fsm = curr_fsm->next; } assert( curr_fsm != NULL ); /* Get state information */ arc_get_states( total_fr_states, total_fr_state_num, total_to_states, total_to_state_num, curr_fsm->table->table, TRUE, TRUE ); arc_get_states( hit_fr_states, hit_fr_state_num, hit_to_states, hit_to_state_num, curr_fsm->table->table, TRUE, FALSE ); /* Get state transition information */ arc_get_transitions( total_from_arcs, total_to_arcs, total_ids, excludes, reasons, total_arc_num, curr_fsm->table->table, funit, TRUE, TRUE ); arc_get_transitions( hit_from_arcs, hit_to_arcs, &tmp_ids, &tmp, &tmp_reasons, hit_arc_num, curr_fsm->table->table, funit, TRUE, FALSE ); /* Get input state code */ codegen_gen_expr( curr_fsm->table->from_state, curr_fsm->table->from_state->op, input_state, input_size, NULL ); /* Get output state code */ codegen_gen_expr( curr_fsm->table->to_state, curr_fsm->table->to_state->op, output_state, output_size, NULL ); /* Deallocate unused state information */ if( *hit_arc_num > 0 ) { unsigned int i; free_safe( tmp_ids, (sizeof( int ) * (*hit_arc_num)) ); free_safe( tmp, (sizeof( int ) * (*hit_arc_num)) ); for( i=0; i<(*hit_arc_num); i++ ) { free_safe( tmp_reasons[i], (strlen( tmp_reasons[i] ) + 1) ); } free_safe( tmp_reasons, (sizeof( char* ) * (*hit_arc_num)) ); } PROFILE_END; }

void fsm_get_funit_summary (  func_unit *  funit, int *  hit, int *  excluded, int *  total )

Retrieves the FSM summary information for the specified functional unit. Retrieves the FSM summary information for the specified functional unit. Parameters: funit  Pointer to functional unit hit  Pointer to location to store the number of hit state transitions for the specified functional unit excluded  Pointer to number of excluded arcs total  Pointer to location to store the total number of state transitions for the specified functional unit { PROFILE(FSM_GET_FUNIT_SUMMARY); *hit = funit->stat->arc_hit; *excluded = funit->stat->arc_excluded; *total = funit->stat->arc_total; PROFILE_END; }

void fsm_get_inst_summary (  funit_inst *  inst, int *  hit, int *  excluded, int *  total )

Retrieves the FSM summary information for the specified functional unit. Retrieves the FSM summary information for the specified functional unit instance. Parameters: inst  Pointer to functional unit instance hit  Pointer to location to store the number of hit state transitions for the specified functional unit excluded  Pointer to number of excluded arcs total  Pointer to location to store the total number of state transitions for the specified functional unit { PROFILE(FSM_GET_INST_SUMMARY); *hit = inst->stat->arc_hit; *excluded = inst->stat->arc_excluded; *total = inst->stat->arc_total; PROFILE_END; }

void fsm_get_stats (  fsm_link *  table, int *  state_hit, int *  state_total, int *  arc_hit, int *  arc_total, int *  arc_excluded )

Gathers statistics about the current FSM. Gathers the FSM state and state transition statistics for the given table and assigns this information to the specified pointers. Parameters: table  Pointer to FSM to get statistics from state_hit  Number of states reached in this FSM state_total  Total number of states within this FSM arc_hit  Number of arcs reached in this FSM arc_total  Total number of arcs within this FSM arc_excluded  Total number of excluded arcs { PROFILE(FSM_GET_STATS); fsm_link* curr; /* Pointer to current FSM in table list */ curr = table; while( curr != NULL ) { arc_get_stats( curr->table->table, state_hit, state_total, arc_hit, arc_total, arc_excluded ); curr = curr->next; } PROFILE_END; }

void fsm_merge (  fsm *  base, fsm *  other )

Merges two FSMs, placing the result into the base FSM. Merges two FSMs, placing the resulting FSM into the base. This function is called when merging modules for the GUI. Parameters: base  Base FSM to store merged results other  Other FSM that will be merged with the base FSM { PROFILE(FSM_MERGE); assert( base != NULL ); assert( base->from_state != NULL ); assert( base->to_state != NULL ); assert( other != NULL ); assert( other->from_state != NULL ); assert( other->to_state != NULL ); if( base->table != NULL ) { assert( other->table != NULL ); arc_merge( base->table, other->table ); } PROFILE_END; }

void fsm_report (  FILE *  ofile, bool  verbose )

Generates report output for FSM coverage. After the design is read into the functional unit hierarchy, parses the hierarchy by functional unit, reporting the FSM coverage for each functional unit encountered. The parent functional unit will specify its own FSM coverage along with a total FSM coverage including its children. Parameters: ofile  Pointer to file to output results to verbose  Specifies whether or not to provide verbose information { PROFILE(FSM_REPORT); bool missed_found = FALSE; /* If set to TRUE, FSM cases were found to be missed */ inst_link* instl; /* Pointer to current instance link */ int acc_st_hits = 0; /* Accumulated number of states hit */ int acc_st_total = 0; /* Accumulated number of states in design */ int acc_arc_hits = 0; /* Accumulated number of arcs hit */ int acc_arc_total = 0; /* Accumulated number of arcs in design */ fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ FINITE STATE MACHINE COVERAGE RESULTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); if( report_instance ) { fprintf( ofile, " State Arc\n" ); fprintf( ofile, "Instance Hit/Miss/Total Percent hit Hit/Miss/Total Percent hit\n" ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); instl = db_list[curr_db]->inst_head; while( instl != NULL ) { missed_found |= fsm_instance_summary( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*"), &acc_st_hits, &acc_st_total, &acc_arc_hits, &acc_arc_total ); instl = instl->next; } fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); (void)fsm_display_instance_summary( ofile, "Accumulated", acc_st_hits, acc_st_total, acc_arc_hits, acc_arc_total ); if( verbose && (missed_found || report_covered || report_exclusions) ) { fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); instl = db_list[curr_db]->inst_head; while( instl != NULL ) { fsm_instance_verbose( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*") ); instl = instl->next; } } } else { fprintf( ofile, " State Arc\n" ); fprintf( ofile, "Module/Task/Function Filename Hit/Miss/Total Percent Hit Hit/Miss/Total Percent hit\n" ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); missed_found = fsm_funit_summary( ofile, db_list[curr_db]->funit_head, &acc_st_hits, &acc_st_total, &acc_arc_hits, &acc_arc_total ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); (void)fsm_display_funit_summary( ofile, "Accumulated", "", acc_st_hits, acc_st_total, acc_arc_hits, acc_arc_total ); if( verbose && (missed_found || report_covered || report_exclusions) ) { fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); fsm_funit_verbose( ofile, db_list[curr_db]->funit_head ); } } fprintf( ofile, "\n\n" ); PROFILE_END; }

void fsm_table_set (  expression *  expr, const sim_time *  time )

Sets the bit in set table based on the values of last and curr. Taking the from and to state signal values, a new table entry is added to the specified FSM structure arc array (if an entry does not already exist in the array). Parameters: expr  Pointer to expression that contains FSM table to modify time  Pointer to current simulation time { PROFILE(FSM_TABLE_SET); /* If the expression is the input state expression, make sure that the output state expression is simulated this clock period */ if( (expr->table->from_state->id == expr->id) && (expr->table->from_state->id != expr->table->to_state->id) ) { sim_expr_changed( expr->table->to_state, time ); /* Otherwise, add the state/state transition */ } else { /* Add the states and state transition */ arc_add( expr->table->table, expr->table->from_state->value, expr->table->to_state->value, 1, expr->table->exclude ); /* If from_state was not specified, we need to copy the current contents of to_state to from_state */ if( expr->table->from_state->id == expr->id ) { vector_copy( expr->value, expr->table->from_state->value ); } } PROFILE_END; }

---