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

---

Detailed Description

Contains functions for handling FSM arc arrays.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

8/25/2003

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

Go to the source code of this file.

Functions
fsm_table *	arc_create ()
	Allocates and initializes new state transition array.
void	arc_add (fsm_table *table, const vector *fr_st, const vector *to_st, int hit, bool exclude)
	Adds new state transition arc entry to specified table.
int	arc_find_from_state (const fsm_table *table, const vector *st)
	Finds the specified FROM state in the given FSM table.
int	arc_find_to_state (const fsm_table *table, const vector *st)
	Finds the specified TO state in the given FSM table.
int	arc_find_arc (const fsm_table *table, unsigned int fr_index, unsigned int to_index)
	Finds the specified state transition in the given FSM table.
int	arc_find_arc_by_exclusion_id (const fsm_table *table, int id)
	Finds the specified state transition in the given FSM table by the exclusion ID.
void	arc_get_stats (const fsm_table *table, int *state_hits, int *state_total, int *arc_hits, int *arc_total, int *arc_excluded)
	Calculates all state and state transition values for reporting purposes.
void	arc_db_write (const fsm_table *table, FILE *file)
	Writes specified arc array to specified CDD file.
void	arc_db_read (fsm_table **table, char **line)
	Reads in arc array from CDD database string.
void	arc_db_merge (fsm_table *table, char **line)
	Merges contents of arc table from line to specified base array.
void	arc_merge (fsm_table *base, const fsm_table *other)
	Merges two FSM arcs, placing the results in the base arc.
void	arc_get_states (char ***fr_states, unsigned int *fr_state_size, char ***to_states, unsigned int *to_state_size, const fsm_table *table, bool hit, bool any)
	Stores arc array state values to specified string array.
void	arc_get_transitions (char ***from_states, char ***to_states, int **ids, int **excludes, char ***reasons, int *arc_size, const fsm_table *table, func_unit *funit, bool hit, bool any)
	Outputs arc array state transition values to specified output stream.
bool	arc_are_any_excluded (const fsm_table *table)
	Specifies if any state transitions have been excluded from coverage.
void	arc_dealloc (fsm_table *table)
	Deallocates memory for specified arcs array.

---

Function Documentation

void arc_add (  fsm_table *  table, const vector *  fr_st, const vector *  to_st, int  hit, bool  exclude )

Adds new state transition arc entry to specified table. If specified arcs array has not been created yet (value is set to NULL), allocate enough memory in the arc array to hold width number of state transitions. If the specified arcs array has been created but is currently full (arc array max_size and curr_size are equal to each other), add width number of more arc array entries to the current array. After memory has been allocated, create a state transition entry from the fr_st and to_st expressions, setting the hit bits in the entry to 0. Parameters: table  Pointer to FSM table to add state transition arc array to fr_st  Pointer to vector containing the from state to_st  Pointer to vector containing the to state hit  Specifies if arc entry should be marked as hit exclude  If new arc is created, sets the exclude bit to this value { PROFILE(ARC_ADD); int from_index; /* Index of found from_state in states array */ int to_index; /* Index of found to_state in states array */ int arcs_index; /* Index of found state transition in arcs array */ assert( table != NULL ); if( (hit == 0) || (!vector_is_unknown( fr_st ) && !vector_is_unknown( to_st )) ) { /* Search for the from_state vector in the states array */ if( (from_index = arc_find_from_state( table, fr_st )) == -1 ) { table->fr_states = (vector**)realloc_safe( table->fr_states, (sizeof( vector* ) * table->num_fr_states), (sizeof( vector* ) * (table->num_fr_states + 1)) ); from_index = table->num_fr_states; table->fr_states[from_index] = vector_create( fr_st->width, VTYPE_VAL, fr_st->suppl.part.data_type, TRUE ); vector_copy( fr_st, table->fr_states[from_index] ); table->num_fr_states++; } /* Search for the to_state vector in the states array */ if( (to_index = arc_find_to_state( table, to_st )) == -1 ) { table->to_states = (vector**)realloc_safe( table->to_states, (sizeof( vector* ) * table->num_to_states), (sizeof( vector* ) * (table->num_to_states + 1)) ); to_index = table->num_to_states; table->to_states[to_index] = vector_create( to_st->width, VTYPE_VAL, to_st->suppl.part.data_type, TRUE ); vector_copy( to_st, table->to_states[to_index] ); table->num_to_states++; } /* If we need to add a new arc, do so now */ if( (arcs_index = arc_find_arc( table, from_index, to_index )) == -1 ) { table->arcs = (fsm_table_arc**)realloc_safe( table->arcs, (sizeof( fsm_table_arc* ) * table->num_arcs), (sizeof( fsm_table_arc* ) * (table->num_arcs + 1)) ); table->arcs[table->num_arcs] = (fsm_table_arc*)malloc_safe( sizeof( fsm_table_arc ) ); table->arcs[table->num_arcs]->suppl.all = 0; table->arcs[table->num_arcs]->suppl.part.hit = hit; table->arcs[table->num_arcs]->suppl.part.excluded = exclude; table->arcs[table->num_arcs]->from = from_index; table->arcs[table->num_arcs]->to = to_index; arcs_index = table->num_arcs; table->num_arcs++; /* Otherwise, adjust hit and exclude information */ } else { table->arcs[arcs_index]->suppl.part.hit |= hit; table->arcs[arcs_index]->suppl.part.excluded |= exclude; } /* If we have set a side with hit equal to 0, we are specifying a known transition. */ if( hit == 0 ) { table->suppl.part.known = 1; } } PROFILE_END; }

bool arc_are_any_excluded (  const fsm_table *  table  )

Specifies if any state transitions have been excluded from coverage. Returns: Returns TRUE if any state transitions were excluded from coverage; otherwise, returns FALSE. Parameters: table  Pointer to state transition arc array { PROFILE(ARC_ARE_ANY_EXCLUDED); unsigned int i = 0; /* Loop iterator */ assert( table != NULL ); while( (i < table->num_arcs) && (table->arcs[i]->suppl.part.excluded == 0) ) i++; PROFILE_END; return( i < table->num_arcs ); }

fsm_table* arc_create (   )

Allocates and initializes new state transition array. Returns: Returns a pointer to the newly created arc transition structure. Allocates memory for a new state transition arc array and initializes its contents. { PROFILE(ARC_CREATE); fsm_table* table; /* Pointer to newly created FSM table */ /* Allocate memory for the new table here */ table = (fsm_table*)malloc_safe( sizeof( fsm_table ) ); /* Initialize */ table->suppl.all = 0; table->id = 0; table->fr_states = NULL; table->num_fr_states = 0; table->to_states = NULL; table->num_to_states = 0; table->arcs = NULL; table->num_arcs = 0; PROFILE_END; return( table ); }

void arc_db_merge (  fsm_table *  base, char **  line )

Merges contents of arc table from line to specified base array. Exceptions: anonymous  Throw arc_db_read Merges the specified FSM arc information from the current line into the base FSM arc information. Parameters: base  Pointer to arc table to merge data into line  Pointer to read in line from CDD file to merge { PROFILE(ARC_DB_MERGE); /*@-mustfreeonly -mustfreefresh@*/ fsm_table* table; /* Currently read FSM table */ unsigned int i; /* Loop iterator */ /* Read in the table */ arc_db_read( &table, line ); /* Merge state transitions */ for( i=0; i<table->num_arcs; i++ ) { arc_add( base, table->fr_states[table->arcs[i]->from], table->to_states[table->arcs[i]->to], table->arcs[i]->suppl.part.hit, table->arcs[i]->suppl.part.excluded ); } /* Deallocate the merged table */ arc_dealloc( table ); PROFILE_END; /*@=mustfreeonly =mustfreefresh@*/ }

void arc_db_read (  fsm_table **  table, char **  line )

Reads in arc array from CDD database string. Exceptions: anonymous  Throw Reads in specified state transition arc table, allocating the appropriate space to hold the table. Returns TRUE if the specified line contained an appropriately written arc transition table; otherwise, returns FALSE. Parameters: table  Pointer to state transition arc array line  String containing current CDD line of arc information { PROFILE(ARC_DB_READ); /* Allocate table */ *table = arc_create(); Try { unsigned int num_fr_states; unsigned int num_to_states; int chars_read; /*@-formatcode@*/ if( sscanf( *line, "%hhx %u %u%n", &((*table)->suppl.all), &num_fr_states, &num_to_states, &chars_read ) == 3 ) { /*@=formatcode@*/ unsigned int i; unsigned int num_arcs; *line += chars_read; /* Set exclusion ID */ (*table)->id = curr_arc_id; /* Allocate and initialize fr_states array */ (*table)->fr_states = (vector**)malloc_safe( sizeof( vector* ) * num_fr_states ); (*table)->num_fr_states = num_fr_states; for( i=0; i<num_fr_states; i++ ) { (*table)->fr_states[i] = NULL; } /* Read in from vectors */ for( i=0; i<num_fr_states; i++ ) { vector_db_read( &((*table)->fr_states[i]), line ); } /* Allocate and initialize to_states array */ (*table)->to_states = (vector**)malloc_safe( sizeof( vector* ) * num_to_states ); (*table)->num_to_states = num_to_states; for( i=0; i<num_to_states; i++ ) { (*table)->to_states[i] = NULL; } /* Read in vectors */ for( i=0; i<num_to_states; i++ ) { vector_db_read( &((*table)->to_states[i]), line ); } if( sscanf( *line, "%u%n", &num_arcs, &chars_read ) == 1 ) { *line += chars_read; /* Allocate arcs array */ (*table)->arcs = (fsm_table_arc**)malloc_safe( sizeof( fsm_table_arc* ) * num_arcs ); (*table)->num_arcs = num_arcs; for( i=0; i<num_arcs; i++ ) { (*table)->arcs[i] = NULL; } for( i=0; i<num_arcs; i++ ) { /* Allocate fsm_table_arc */ (*table)->arcs[i] = (fsm_table_arc*)malloc_safe( sizeof( fsm_table_arc ) ); /*@-formatcode@*/ if( sscanf( *line, "%u %u %hhx%n", &((*table)->arcs[i]->from), &((*table)->arcs[i]->to), &((*table)->arcs[i]->suppl.all), &chars_read ) != 3 ) { /*@=formatcode@*/ print_output( "Unable to parse FSM table information from database. Unable to read.", FATAL, __FILE__, __LINE__ ); Throw 0; } else { *line += chars_read; curr_arc_id++; } } } else { print_output( "Unable to parse FSM table information from database. Unable to read.", FATAL, __FILE__, __LINE__ ); Throw 0; } } else { print_output( "Unable to parse FSM table information from database. Unable to read.", FATAL, __FILE__, __LINE__ ); Throw 0; } } Catch_anonymous { arc_dealloc( *table ); *table = NULL; Throw 0; } PROFILE_END; }

void arc_db_write (  const fsm_table *  table, FILE *  file )

Writes specified arc array to specified CDD file. Writes the specified arcs array to the specified CDD output file. An arc array is output in a special format that is described in the above documentation for this file. Parameters: table  Pointer to state transition arc array to write file  Pointer to CDD file to write { PROFILE(ARC_DB_WRITE); unsigned int i; /* Loop iterator */ assert( table != NULL ); /*@-formatcode@*/ fprintf( file, " %hhx %u %u ", table->suppl.all, table->num_fr_states, table->num_to_states ); /*@=formatcode@*/ /* Output state information */ for( i=0; i<table->num_fr_states; i++ ) { vector_db_write( table->fr_states[i], file, TRUE, FALSE ); fprintf( file, " " ); } for( i=0; i<table->num_to_states; i++ ) { vector_db_write( table->to_states[i], file, TRUE, FALSE ); fprintf( file, " " ); } /* Output arc information */ fprintf( file, " %u", table->num_arcs ); for( i=0; i<table->num_arcs; i++ ) { /*@-formatcode@*/ fprintf( file, " %u %u %hhx", table->arcs[i]->from, table->arcs[i]->to, table->arcs[i]->suppl.all ); /*@=formatcode@*/ } PROFILE_END; }

void arc_dealloc (  fsm_table *  table  )

Deallocates memory for specified arcs array. Deallocates all allocated memory for the specified state transition arc array. Parameters: table  Pointer to state transition arc array { PROFILE(ARC_DEALLOC); if( table != NULL ) { unsigned int i; /* Deallocate fr_states */ for( i=0; i<table->num_fr_states; i++ ) { vector_dealloc( table->fr_states[i] ); } free_safe( table->fr_states, (sizeof( vector* ) * table->num_fr_states) ); /* Deallocate to_states */ for( i=0; i<table->num_to_states; i++ ) { vector_dealloc( table->to_states[i] ); } free_safe( table->to_states, (sizeof( vector* ) * table->num_to_states) ); /* Deallocate arcs */ for( i=0; i<table->num_arcs; i++ ) { free_safe( table->arcs[i], sizeof( fsm_table_arc ) ); } free_safe( table->arcs, (sizeof( fsm_table_arc* ) * table->num_arcs) ); /* Now deallocate ourself */ free_safe( table, sizeof( fsm_table ) ); } PROFILE_END; }

int arc_find_arc (  const fsm_table *  table, unsigned int  fr_index, unsigned int  to_index )

Finds the specified state transition in the given FSM table. Returns: Returns the index of the found arc in the arcs array if it is found; otherwise, returns -1. Searches for the arc in the arcs array of the given FSM table specified by the given state indices. Parameters: table  Pointer to FSM table to search in fr_index  Index of from state to find to_index  Index of to state to find { PROFILE(ARC_FIND_ARC); int index = -1; unsigned int i = 0; while( (i < table->num_arcs) && (index == -1) ) { if( (table->arcs[i]->from == fr_index) && (table->arcs[i]->to == to_index) ) { index = i; } i++; } PROFILE_END; return( index ); }

int arc_find_arc_by_exclusion_id (  const fsm_table *  table, int  id )

Finds the specified state transition in the given FSM table by the exclusion ID. Returns: Returns the index of the found arc in the arcs array if it is found; otherwise, returns -1. Parameters: table  Pointer to FSM table structure to search id  Exclusion ID to search for { PROFILE(ARC_FIND_ARC_BY_EXCLUSION_ID); int index = -1; if( (table->id <= id) && ((table->id + table->num_arcs) > id) ) { index = id - table->id; } PROFILE_END; return( index ); }

int arc_find_from_state (  const fsm_table *  table, const vector *  st )

Finds the specified FROM state in the given FSM table. Returns: Returns the index of the found from_state in the fr_states array if one is found; otherwise, returns -1 to indicate that a match could not be found. Searches the list of FROM states for a match to the given vector value. Parameters: table  Pointer to FSM table to search in st  State to search for { PROFILE(ARC_FIND_FROM_STATE); int index = -1; /* Return value for this function */ unsigned int i = 0; /* Loop iterator */ assert( table != NULL ); while( (i < table->num_fr_states) && !vector_ceq_ulong( st, table->fr_states[i] ) ) i++; if( i < table->num_fr_states ) { index = i; } PROFILE_END; return( index ); }

int arc_find_to_state (  const fsm_table *  table, const vector *  st )

Finds the specified TO state in the given FSM table. Returns: Returns the index of the found to_state in the to_states array if one is found; otherwise, returns -1 to indicate that a match could not be found. that no match occurred. Searches the list of TO states for a match to the given vector value. Parameters: table  Pointer to FSM table to search in st  State to search for { PROFILE(ARC_FIND_TO_STATE); int index = -1; /* Return value for this function */ unsigned int i = 0; /* Loop iterator */ assert( table != NULL ); while( (i < table->num_to_states) && !vector_ceq_ulong( st, table->to_states[i] ) ) i++; if( i < table->num_to_states ) { index = i; } PROFILE_END; return( index ); }

void arc_get_states (  char ***  fr_states, unsigned int *  fr_state_size, char ***  to_states, unsigned int *  to_state_size, const fsm_table *  table, bool  hit, bool  any )

Stores arc array state values to specified string array. Traverses entire arc array, storing all states that were hit during simulation (if hit parameter is true or the any parameter is true) or missed during simulation (if hit parameter is false or the any parameter is true). Parameters: fr_states  Pointer to string array containing stringified state information fr_state_size  Pointer to number of elements stored in states array to_states  Pointer to string array containing stringified state information to_state_size  Pointer to number of elements stored in states array table  Pointer to FSM table hit  Specifies if hit or missed transitions should be gathered any  Specifies if we should gather any transition or only the type specified by hit { PROFILE(ARC_GET_STATES); unsigned int i, j; /* Loop iterator */ /*@-nullstate@*/ assert( fr_states != NULL ); assert( fr_state_size != NULL ); assert( to_states != NULL ); assert( to_state_size != NULL ); /* Initialize states array pointers and sizes */ *fr_states = NULL; *fr_state_size = 0; *to_states = NULL; *to_state_size = 0; /* Iterate through the fr_states array, gathering all matching states */ for( i=0; i<table->num_fr_states; i++ ) { bool state_hit = any; for( j=0; j<table->num_arcs; j++ ) { if( table->arcs[j]->from == i ) { state_hit = state_hit || (table->arcs[j]->suppl.part.hit == 1); } } if( state_hit == hit ) { *fr_states = (char**)realloc_safe( *fr_states, (sizeof( char* ) * (*fr_state_size)), (sizeof( char* ) * ((*fr_state_size) + 1)) ); (*fr_states)[(*fr_state_size)] = vector_to_string( table->fr_states[i], HEXIDECIMAL, TRUE ); (*fr_state_size)++; } } /* Iterate through the to_states array, gathering all matching states */ for( i=0; i<table->num_to_states; i++ ) { bool state_hit = any; for( j=0; j<table->num_arcs; j++ ) { if( table->arcs[j]->to == i ) { state_hit = state_hit || (table->arcs[j]->suppl.part.hit == 1); } } if( state_hit == hit ) { *to_states = (char**)realloc_safe( *to_states, (sizeof( char* ) * (*to_state_size)), (sizeof( char* ) * ((*to_state_size) + 1)) ); (*to_states)[(*to_state_size)] = vector_to_string( table->to_states[i], HEXIDECIMAL, TRUE ); (*to_state_size)++; } } PROFILE_END; }

void arc_get_stats (  const fsm_table *  table, int *  state_hits, int *  state_total, int *  arc_hits, int *  arc_total, int *  arc_excluded )

Calculates all state and state transition values for reporting purposes. Calculates values for all specified totals from given state transition arc array. If the state and state transition totals are not known (i.e., user specified state variables without specifying legal states and state transitions and/or the user specified state variables and state table was not able to be automatically extracted), return a value of -1 for total values to indicate to the calling function that a different report output is required. Parameters: table  Pointer to FSM table state_hits  Pointer to total number of states hit during simulation state_total  Pointer to total number of states in table arc_hits  Pointer to total number of state transitions hit during simulation arc_total  Pointer to total number of state transitions in table arc_excluded  Pointer to total number of excluded arcs { PROFILE(ARC_GET_STATS); /* First get hits */ *state_hits += arc_state_hits( table ); *arc_hits += arc_transition_hits( table ); *arc_excluded += arc_transition_excluded( table ); /* If the state transitions are known, calculate them; otherwise, return -1 for totals */ if( table->suppl.part.known == 0 ) { *state_total = -1; *arc_total = -1; } else { *state_total += table->num_fr_states; *arc_total += table->num_arcs; } PROFILE_END; }

void arc_get_transitions (  char ***  from_states, char ***  to_states, int **  ids, int **  excludes, char ***  reasons, int *  arc_size, const fsm_table *  table, func_unit *  funit, bool  hit, bool  any )

Outputs arc array state transition values to specified output stream. Traverses entire arc array, storing all state transitions that were hit during simulation (if hit parameter is true or the any parameter is true) or missed during simulation (if hit parameter is false or the any parameter is true). Parameters: from_states  Pointer to string array containing from_state values to_states  Pointer to string array containing to_state values ids  List of arc IDs excludes  Pointer to integer array containing exclude values reasons  Pointer to string array containing exclude reasons arc_size  Number of elements in both the from_states and to_states arrays table  Pointer to FSM table funit  Pointer to functional unit containing this FSM hit  Specifies if hit or missed transitions should be gathered any  Specifies if all arc transitions or just the ones that meet the hit criteria should be gathered { PROFILE(ARC_GET_TRANSITIONS); unsigned int i; /* Loop iterator */ assert( table != NULL ); /* Initialize state arrays and arc_size */ *from_states = NULL; *to_states = NULL; *ids = NULL; *excludes = NULL; *reasons = NULL; *arc_size = 0; /* Iterate through arc transitions */ for( i=0; i<table->num_arcs; i++ ) { if( (table->arcs[i]->suppl.part.hit == hit) || any ) { exclude_reason* er; *from_states = (char**)realloc_safe( *from_states, (sizeof( char* ) * (*arc_size)), (sizeof( char* ) * (*arc_size + 1)) ); *to_states = (char**)realloc_safe( *to_states, (sizeof( char* ) * (*arc_size)), (sizeof( char* ) * (*arc_size + 1)) ); *ids = (int*)realloc_safe( *ids, (sizeof( int ) * (*arc_size)), (sizeof( int ) * (*arc_size + 1)) ); *excludes = (int*)realloc_safe( *excludes, (sizeof( int ) * (*arc_size)), (sizeof( int ) * (*arc_size + 1)) ); *reasons = (char**)realloc_safe( *reasons, (sizeof( char* ) * (*arc_size)), (sizeof( char* ) * (*arc_size + 1)) ); (*from_states)[(*arc_size)] = vector_to_string( table->fr_states[table->arcs[i]->from], HEXIDECIMAL, TRUE ); (*to_states)[(*arc_size)] = vector_to_string( table->to_states[table->arcs[i]->to], HEXIDECIMAL, TRUE ); (*ids)[(*arc_size)] = table->id + i; (*excludes)[(*arc_size)] = table->arcs[i]->suppl.part.excluded; /* If the assertion is currently excluded, check to see if there's a reason associated with it */ if( (table->arcs[i]->suppl.part.excluded == 1) && ((er = exclude_find_exclude_reason( 'F', (table->id + i), funit )) != NULL) ) { (*reasons)[(*arc_size)] = strdup_safe( er->reason ); } else { (*reasons)[(*arc_size)] = NULL; } (*arc_size)++; } } PROFILE_END; }

void arc_merge (  fsm_table *  base, const fsm_table *  other )

Merges two FSM arcs, placing the results in the base arc. Merges two FSM arcs into one, placing the result back into the base FSM arc. This function is used to calculate module coverage for the GUI. { PROFILE(ARC_MERGE); unsigned int i; /* Loop iterator */ /* Merge state transitions */ for( i=0; i<other->num_arcs; i++ ) { arc_add( base, other->fr_states[other->arcs[i]->from], other->to_states[other->arcs[i]->to], other->arcs[i]->suppl.part.hit, other->arcs[i]->suppl.part.excluded ); } PROFILE_END; }

---