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

---

Detailed Description

Contains functions for handling user-specified exclusion of coverage results.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

6/22/2006

#include "defines.h"

Go to the source code of this file.

Functions
bool	exclude_is_line_excluded (func_unit *funit, int line)
	Returns TRUE if the specified line is excluded in the given functional unit.
void	exclude_set_line_exclude (func_unit *funit, int line, int value, char *reason, statistic *stat)
	Sets the excluded bit for all expressions in the given functional unit with the specified line number and recalculates the summary coverage information.
bool	exclude_is_toggle_excluded (func_unit *funit, char *sig_name)
	Returns TRUE if the specified signal is excluded in the given functional unit.
void	exclude_set_toggle_exclude (func_unit *funit, const char *sig_name, int value, char type, char *reason, statistic *stat)
	Sets the excluded bit for the specified signal in the given functional unit and recalculates the summary coverage information.
bool	exclude_is_comb_excluded (func_unit *funit, int expr_id, int uline_id)
void	exclude_set_comb_exclude (func_unit *funit, int expr_id, int uline_id, int value, char *reason, statistic *stat)
	Sets the excluded bit for the specified expression in the given functional unit and recalculates the summary coverage information.
bool	exclude_is_fsm_excluded (func_unit *funit, int expr_id, char *from_state, char *to_state)
	Returns TRUE if the specified FSM is excluded in the given functional unit.
void	exclude_set_fsm_exclude (func_unit *funit, int expr_id, char *from_state, char *to_state, int value, char *reason, statistic *stat)
	Sets the excluded bit for the specified state transition in the given functional unit and recalculates the summary coverage information.
bool	exclude_is_assert_excluded (func_unit *funit, char *inst_name, int expr_id)
	Returns TRUE if given assertion is excluded from coverage.
void	exclude_set_assert_exclude (func_unit *funit, char *inst_name, int expr_id, int value, char *reason, statistic *stat)
	Sets the excluded bit for the specified expression in the given functional unit and recalculates the summary coverage information.
exclude_reason *	exclude_find_exclude_reason (char type, int id, func_unit *funit)
	Returns a pointer to the found exclude reason if one is found for the given type and ID; otherwise, returns NULL.
char *	exclude_format_reason (const char *old_str)
	Formats the reason string for storage purposes.
void	exclude_db_write (exclude_reason *er, FILE *ofile)
	Outputs the given exclude reason structure to the specified file stream.
void	exclude_db_read (char **line, func_unit *curr_funit)
	Reads the given exclude reason from the specified line and stores its information in the curr_funit structure.
void	exclude_db_merge (func_unit *base, char **line)
	Reads the given exclude reason from the specified line and merges its information with the base functional unit.
void	exclude_merge (func_unit *base, exclude_reason *er)
	Performs exclusion reason merging.
void	command_exclude (int argc, int last_arg, const char **argv)
	Allows the user to exclude coverage points from reporting.

---

Function Documentation

void command_exclude (  int  argc, int  last_arg, const char **  argv )

Allows the user to exclude coverage points from reporting. Performs the exclude command. Parameters: argc  Number of arguments in command-line to parse last_arg  Index of last parsed argument from list argv  List of arguments from command-line to parse { PROFILE(COMMAND_EXCLUDE); unsigned int rv; comp_cdd_cov** comp_cdds = NULL; unsigned int comp_cdd_num = 0; bool error = FALSE; /* Output header information */ rv = snprintf( user_msg, USER_MSG_LENGTH, COVERED_HEADER ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, NORMAL, __FILE__, __LINE__ ); Try { unsigned int rv; /* Parse score command-line */ if( !exclude_parse_args( argc, last_arg, argv ) ) { /* Read in database */ rv = snprintf( user_msg, USER_MSG_LENGTH, "Reading CDD file \"%s\"", exclude_cdd ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, NORMAL, __FILE__, __LINE__ ); db_read( exclude_cdd, READ_MODE_REPORT_NO_MERGE ); bind_perform( TRUE, 0 ); /* Apply the specified exclusion IDs */ if( exclude_apply_exclusions() ) { rv = snprintf( user_msg, USER_MSG_LENGTH, "Writing CDD file \"%s\"", exclude_cdd ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, NORMAL, __FILE__, __LINE__ ); db_write( exclude_cdd, FALSE, FALSE, TRUE ); } } } Catch_anonymous { error = TRUE; } /* Close down the database */ db_close(); /* Deallocate other allocated variables */ str_link_delete_list( excl_ids_head ); free_safe( exclude_cdd, (strlen( exclude_cdd ) + 1) ); if( error ) { Throw 0; } PROFILE_END; }

void exclude_db_merge (  func_unit *  base, char **  line )

Reads the given exclude reason from the specified line and merges its information with the base functional unit. Reads the given exclude reason structure information from the line read from the CDD file. Parameters: base  Pointer to base functional unit to merge into line  Pointer to the line read from the CDD file { PROFILE(EXCLUDE_DB_MERGE); char type; /* Specifies the type of exclusion this structure represents */ int id; /* ID of signal/expression/FSM */ int chars_read; /* Number of characters read from line */ time_t timestamp; /* Reason timestamp */ char* reason; /* Pointer to the exclusion reason from the CDD file */ /*@+longintegral@*/ if( sscanf( *line, " %c %d %ld%n", &type, &id, &timestamp, &chars_read ) == 3 ) { /*@=longintegral@*/ exclude_reason* er; *line = *line + chars_read; /* Get the reason string and remove leading whitespace */ while( (*line)[0] == ' ' ) { (*line)++; } reason = *line; assert( reason != NULL ); assert( reason[0] != '\0' ); /* If the exclusion reason does not exist in the base CDD, go ahead and add it */ if( (er = exclude_find_exclude_reason( type, id, base )) == NULL ) { /* Allocate and initialize the exclude reason structure */ er = (exclude_reason*)malloc_safe( sizeof( exclude_reason ) ); er->type = type; er->id = id; er->timestamp = timestamp; er->reason = strdup_safe( reason ); er->next = NULL; /* Add the given exclude reason to the current functional unit list */ if( base->er_head == NULL ) { base->er_head = base->er_tail = er; } else { base->er_tail->next = er; base->er_tail = er; } /* Otherwise, if the exclusion reason does exist, check for a conflict and handle it */ } else { /* If the exclusion reason string does not match the current string, resolve the conflict appropriately (otherwise, just use the reason in the base functional unit). */ if( strcmp( er->reason, reason ) != 0 ) { exclude_resolve_reason( er, base, merge_er_value, reason, timestamp ); } } } else { print_output( "CDD being read is not compatible with this version of Covered", FATAL, __FILE__, __LINE__ ); Throw 0; } PROFILE_END; }

void exclude_db_read (  char **  line, func_unit *  curr_funit )

Reads the given exclude reason from the specified line and stores its information in the curr_funit structure. Reads the given exclude reason structure information from the line read from the CDD file. Parameters: line  Pointer to the line read from the CDD file curr_funit  Pointer to the current functional unit { PROFILE(EXCLUDE_DB_READ); char type; /* Specifies the type of exclusion this structure represents */ int id; /* ID of signal/expression/FSM */ int chars_read; /* Number of characters read from line */ time_t timestamp; /* Reason timestamp */ /*@+longintegral@*/ if( sscanf( *line, " %c %d %ld%n", &type, &id, &timestamp, &chars_read ) == 3 ) { /*@=longintegral@*/ exclude_reason* er; *line = *line + chars_read; /* Allocate and initialize the exclude reason structure */ er = (exclude_reason*)malloc_safe( sizeof( exclude_reason ) ); er->type = type; er->id = id; er->reason = NULL; er->timestamp = timestamp; er->next = NULL; /* Remove leading whitespace */ while( (*line)[0] == ' ' ) { (*line)++; } er->reason = strdup_safe( *line ); /* Add the given exclude reason to the current functional unit list */ if( curr_funit->er_head == NULL ) { curr_funit->er_head = curr_funit->er_tail = er; } else { curr_funit->er_tail->next = er; curr_funit->er_tail = er; } } else { print_output( "CDD being read is not compatible with this version of Covered", FATAL, __FILE__, __LINE__ ); Throw 0; } PROFILE_END; }

void exclude_db_write (  exclude_reason *  er, FILE *  ofile )

Outputs the given exclude reason structure to the specified file stream. Writes the given exclude reason to the specified output stream. Parameters: er  Pointer to exclude reason structure to output ofile  Pointer to output file stream { PROFILE(EXCLUDE_DB_WRITE); /*@+longintegral@*/ fprintf( ofile, "%d %c %d %ld %s\n", DB_TYPE_EXCLUDE, er->type, er->id, er->timestamp, er->reason ); /*@=longintegral@*/ PROFILE_END; }

exclude_reason* exclude_find_exclude_reason (  char  type, int  id, func_unit *  funit )

Returns a pointer to the found exclude reason if one is found for the given type and ID; otherwise, returns NULL. Returns: Returns a pointer to the found exclusion reason that matches the given type and ID; otherwise, returns a value of NULL. { PROFILE(EXCLUDE_FIND_EXCLUDE_REASON); exclude_reason* er; /* Pointer to current exclude reason structure */ er = funit->er_head; while( (er != NULL) && ((er->type != type) || (er->id != id)) ) { er = er->next; } PROFILE_END; return( er ); }

char* exclude_format_reason (  const char *  old_str  )

Formats the reason string for storage purposes. Returns: Returns the reformatted string that removes all newlines and extra spaces. Parameters: old_str  Pointer to string that needs to be formatted { PROFILE(EXCLUDE_FORMAT_REASON); char* msg; /* Pointer to the reformatted message */ unsigned int msg_size; /* Current size of message array */ char c; /* Current character */ bool sp_just_seen = TRUE; /* Set to TRUE if a space character was just seen */ char str[100]; /* Temporary string */ unsigned int i; /* Loop iterator */ unsigned int index = 0; /* Index into str array to store next character */ msg = strdup_safe( "" ); msg_size = 1; str[0] = '\0'; if( old_str != NULL ) { for( i=0; i<strlen( old_str ); i++ ) { c = old_str[i]; /* Convert any formatting characters to spaces */ c = ((c == '\n') || (c == '\t') || (c == '\r')) ? ' ' : c; /* If the user has specified multiple formatting characters together, ignore all but the first. */ if( (c != ' ') || !sp_just_seen ) { sp_just_seen = (c == ' ') ? TRUE : FALSE; str[(index % 99) + 0] = c; str[(index % 99) + 1] = '\0'; if( ((index + 1) % 99) == 0 ) { msg = (char*)realloc_safe( msg, msg_size, (msg_size + strlen( str )) ); msg_size += strlen( str ); strcat( msg, str ); str[0] = '\0'; } index++; } } } /* Take what's left in the str array and put it into the msg array */ if( strlen( str ) > 0 ) { msg = (char*)realloc_safe( msg, msg_size, (msg_size + strlen( str )) ); strcat( msg, str ); msg[strlen(msg)] = '\0'; } PROFILE_END; return( msg ); }

bool exclude_is_assert_excluded (  func_unit *  funit, char *  inst_name, int  expr_id )

Returns TRUE if given assertion is excluded from coverage. Returns: Returns TRUE if the given assertion is excluded from coverage consideration; otherwise, returns FALSE. Parameters: funit  Pointer to functional unit containing the assertion to exclude/include inst_name  Name of assertion instance to exclude/include expr_id  Expression ID to exclude/include { PROFILE(EXCLUDE_IS_ASSERT_EXCLUDED); funit_inst* inst; /* Pointer to found functional unit instance */ funit_inst* curr_child; /* Pointer to current child functional instance */ exp_link* expl; /* Pointer to current expression link */ int ignore = 0; /* Number of instances to ignore */ statement* stmt; /* Pointer to current statement */ /* Find the functional unit instance that matches the description */ if( (inst = inst_link_find_by_funit( funit, db_list[curr_db]->inst_head, &ignore )) != NULL ) { func_iter fi; /* Find child instance */ curr_child = inst->child_head; while( (curr_child != NULL) && (strcmp( curr_child->name, inst_name ) != 0) ) { curr_child = curr_child->next; } assert( curr_child != NULL ); /* Initialize the functional unit iterator */ func_iter_init( &fi, curr_child->funit, TRUE, FALSE ); while( ((stmt = func_iter_get_next_statement( &fi )) != NULL) && (stmt->exp->id != expr_id) ); /* Deallocate functional unit statement iterator */ func_iter_dealloc( &fi ); } PROFILE_END; return( (inst == NULL) || (stmt == NULL) || (stmt->exp->id != expr_id) || (stmt->exp->suppl.part.excluded == 1) ); }

bool exclude_is_comb_excluded (  func_unit *  funit, int  expr_id, int  uline_id )

Returns: Returns TRUE if specified underlined expression is excluded from coverage; otherwise, returns FALSE. Parameters: funit  Pointer to functional unit containing the expression to exclude/include expr_id  Expression ID of the root expression to exclude/include uline_id  Underline ID of expression to exclude/include { PROFILE(EXCLUDE_IS_COMB_EXCLUDED); func_iter fi; /* Functional unit iterator */ statement* stmt; /* Pointer to found statement */ expression* subexp; /* Pointer to found expression */ /* Find the matching root expression */ func_iter_init( &fi, funit, TRUE, FALSE ); while( ((stmt = func_iter_get_next_statement( &fi )) != NULL) && (stmt->exp->id != expr_id) ); func_iter_dealloc( &fi ); if( stmt != NULL ) { subexp = expression_find_uline_id( stmt->exp, uline_id ); } PROFILE_END; return( (stmt == NULL) || (subexp == NULL) || (subexp->suppl.part.excluded == 1) ); }

bool exclude_is_fsm_excluded (  func_unit *  funit, int  expr_id, char *  from_state, char *  to_state )

Returns TRUE if the specified FSM is excluded in the given functional unit. Returns: Returns TRUE if the given FSM state transition was excluded from coverage; otherwise, returns FALSE. Parameters: funit  Pointer to functional unit containing FSM to exclude/include expr_id  Expression ID of FSM from_state  String form of the from_state value to_state  String form of the to_state value { PROFILE(EXCLUDE_IS_FSM_EXCLUDED); fsm_link* curr_fsm; /* Pointer to current FSM structure */ int found_index; /* Index of found state transition */ /* Find the corresponding table */ curr_fsm = funit->fsm_head; while( (curr_fsm != NULL) && (curr_fsm->table->to_state->id != expr_id) ) { curr_fsm = curr_fsm->next; } if( curr_fsm != NULL ) { vector* from_vec; vector* to_vec; int from_base, to_base; /* Convert from/to state strings into vector values */ vector_from_string( &from_state, FALSE, &from_vec, &from_base ); vector_from_string( &to_state, FALSE, &to_vec, &to_base ); /* Find the arc entry and perform the exclusion assignment and coverage recalculation */ found_index = arc_find_arc( curr_fsm->table->table, arc_find_from_state( curr_fsm->table->table, from_vec ), arc_find_to_state( curr_fsm->table->table, to_vec ) ); /* Deallocate vectors */ vector_dealloc( from_vec ); vector_dealloc( to_vec ); } PROFILE_END; return( (curr_fsm == NULL) || (found_index == -1) || (curr_fsm->table->table->arcs[found_index]->suppl.part.excluded == 1) ); }

bool exclude_is_line_excluded (  func_unit *  funit, int  line )

Returns TRUE if the specified line is excluded in the given functional unit. Returns: Returns TRUE if the specified line is excluded in the given functional unit; otherwise, returns FALSE. Parameters: funit  Pointer to functional unit to check line  Line number of line to check { PROFILE(EXCLUDE_IS_LINE_EXCLUDED); func_iter fi; /* Functional unit iterator */ statement* stmt; /* Pointer to current statement */ func_iter_init( &fi, funit, TRUE, FALSE ); while( ((stmt = func_iter_get_next_statement( &fi )) != NULL) && (stmt->exp->line != line) ); func_iter_dealloc( &fi ); PROFILE_END; return( (stmt == NULL) || (stmt->suppl.part.excluded == 1) ); }

bool exclude_is_toggle_excluded (  func_unit *  funit, char *  sig_name )

Returns TRUE if the specified signal is excluded in the given functional unit. Returns: Returns TRUE if the specified signal is excluded from coverage consideration; otherwise, returns FALSE. Parameters: funit  Pointer to functional unit to check sig_name  Name of signal to search for { PROFILE(EXCLUDE_IS_TOGGLE_EXCLUDED); func_iter fi; /* Functional unit iterator */ vsignal* sig; /* Pointer to current signal */ func_iter_init( &fi, funit, FALSE, TRUE ); while( ((sig = func_iter_get_next_signal( &fi )) != NULL) && (strcmp( sig->name, sig_name ) != 0) ); func_iter_dealloc( &fi ); PROFILE_END; return( (sig == NULL) || (sig->suppl.part.excluded == 1) ); }

void exclude_merge (  func_unit *  base, exclude_reason *  er )

Performs exclusion reason merging. Reads the given exclude reason structure information from the line read from the CDD file. Parameters: base  Pointer to base functional unit to merge into er  Pointer to exclusion reason to merge { PROFILE(EXCLUDE_MERGE); exclude_reason* found_er; /* If the exclusion reason does not exist in the base CDD, go ahead and add it */ if( (found_er = exclude_find_exclude_reason( er->type, er->id, base )) == NULL ) { exclude_reason* new_er; /* Allocate and initialize the exclude reason structure */ new_er = (exclude_reason*)malloc_safe( sizeof( exclude_reason ) ); new_er->type = er->type; new_er->id = er->id; new_er->timestamp = er->timestamp; new_er->reason = strdup_safe( er->reason ); new_er->next = NULL; /* Add the given exclude reason to the current functional unit list */ if( base->er_head == NULL ) { base->er_head = base->er_tail = new_er; } else { base->er_tail->next = new_er; base->er_tail = new_er; } /* Otherwise, if the exclusion reason does exist, check for a conflict and handle it */ } else { /* If the exclusion reason string does not match the current string, resolve the conflict appropriately (otherwise, just use the reason in the base functional unit). */ if( strcmp( found_er->reason, er->reason ) != 0 ) { exclude_resolve_reason( found_er, base, merge_er_value, er->reason, er->timestamp ); } } PROFILE_END; }

void exclude_set_assert_exclude (  func_unit *  funit, char *  inst_name, int  expr_id, int  value, char *  reason, statistic *  stat )

Sets the excluded bit for the specified expression in the given functional unit and recalculates the summary coverage information. Finds the expression and functional unit instance for the given name, type and sig_name and calls the exclude_expr_assign_and_recalc function for the matching expression, setting the excluded bit of the expression and recalculating the summary coverage information. Parameters: funit  Pointer to functional unit inst_name  Name of child instance to find in given functional unit expr_id  Expression ID of expression to set exclude value for value  Specifies if we should exclude (1) or include (0) the specified line reason  Reason for the exclusion (if value is 1) stat  Pointer to statistic structure to update { PROFILE(EXCLUDE_SET_ASSERT_EXCLUDE); funit_inst* inst; /* Pointer to found functional unit instance */ funit_inst* curr_child; /* Pointer to current child functional instance */ exp_link* expl; /* Pointer to current expression link */ int ignore = 0; /* Number of instances to ignore */ /* Find the functional unit instance that matches the description */ if( (inst = inst_link_find_by_funit( funit, db_list[curr_db]->inst_head, &ignore )) != NULL ) { func_iter fi; statement* stmt; /* Find child instance */ curr_child = inst->child_head; while( (curr_child != NULL) && (strcmp( curr_child->name, inst_name ) != 0) ) { curr_child = curr_child->next; } assert( curr_child != NULL ); /* Initialize the functional unit iterator */ func_iter_init( &fi, curr_child->funit, TRUE, FALSE ); while( ((stmt = func_iter_get_next_statement( &fi )) != NULL) && (stmt->exp->id != expr_id) ); /* Find the signal that matches the given signal name and sets its excluded bit */ if( stmt->exp->id == expr_id ) { /* Exclude/include the assertion and recalculate the summary information */ exclude_expr_assign_and_recalc( stmt->exp, curr_child->funit, (value == 1), FALSE, stat ); /* Handle the exclusion reason */ if( value == 1 ) { if( reason != NULL ) { exclude_add_exclude_reason( 'A', stmt->exp->id, reason, curr_child->funit ); } } else { exclude_remove_exclude_reason( 'A', stmt->exp->id, curr_child->funit ); } } /* Deallocate functional unit statement iterator */ func_iter_dealloc( &fi ); } PROFILE_END; }

void exclude_set_comb_exclude (  func_unit *  funit, int  expr_id, int  uline_id, int  value, char *  reason, statistic *  stat )

Sets the excluded bit for the specified expression in the given functional unit and recalculates the summary coverage information. Finds the expression and functional unit instance for the given name, type and sig_name and calls the exclude_expr_assign_and_recalc function for the matching expression, setting the excluded bit of the expression and recalculating the summary coverage information. Parameters: funit  Pointer to functional unit expr_id  Expression ID of root expression to set exclude value for uline_id  Underline ID of expression to set exclude value for value  Specifies if we should exclude (1) or include (0) the specified line reason  Reason for the exclusion (if value is 1) stat  Pointer to statistic structure to update { PROFILE(EXCLUDE_SET_COMB_EXCLUDE); func_iter fi; /* Functional unit iterator */ statement* stmt; /* Pointer to current statement */ /* Find the root expression */ func_iter_init( &fi, funit, TRUE, FALSE ); while( ((stmt = func_iter_get_next_statement( &fi )) != NULL) && (stmt->exp->id != expr_id) ); func_iter_dealloc( &fi ); if( stmt != NULL ) { expression* subexp; if( (subexp = expression_find_uline_id( stmt->exp, uline_id )) != NULL ) { /* Exclude/include the expression and recalculate the summary information */ exclude_expr_assign_and_recalc( subexp, funit, (value == 1), FALSE, stat ); /* Handle the exclusion reason */ if( value == 1 ) { if( reason != NULL ) { exclude_add_exclude_reason( 'E', subexp->id, reason, funit ); } } else { exclude_remove_exclude_reason( 'E', subexp->id, funit ); } } } PROFILE_END; }

void exclude_set_fsm_exclude (  func_unit *  funit, int  expr_id, char *  from_state, char *  to_state, int  value, char *  reason, statistic *  stat )

Sets the excluded bit for the specified state transition in the given functional unit and recalculates the summary coverage information. Finds the FSM table associated with the specified expr_id and sets the include/exclude status of the given from_state/to_state transition appropriately. Parameters: funit  Pointer to functional unit expr_id  Expression ID of output state variable from_state  String containing input state value to_state  String containing output state value value  Specifies if we should exclude (1) or include (0) the specified line reason  Reason for the exclusion (if value is 1) stat  Pointer to statistics structure to update { PROFILE(EXCLUDE_SET_FSM_EXCLUDE); fsm_link* curr_fsm; /* Find the corresponding table */ curr_fsm = funit->fsm_head; while( (curr_fsm != NULL) && (curr_fsm->table->to_state->id != expr_id) ) { curr_fsm = curr_fsm->next; } if( curr_fsm != NULL ) { vector* from_vec; vector* to_vec; int found_index; int from_base, to_base; /* Convert from/to state strings into vector values */ vector_from_string( &from_state, FALSE, &from_vec, &from_base ); vector_from_string( &to_state, FALSE, &to_vec, &to_base ); /* Find the arc entry and perform the exclusion assignment and coverage recalculation */ if( (found_index = arc_find_arc( curr_fsm->table->table, arc_find_from_state( curr_fsm->table->table, from_vec ), arc_find_to_state( curr_fsm->table->table, to_vec ) )) != -1 ) { /* Handle the exclusion and recalculate the summary values */ exclude_arc_assign_and_recalc( curr_fsm->table->table, found_index, (value == 1), stat ); /* Handle the exclusion reason */ if( value == 1 ) { if( reason != NULL ) { exclude_add_exclude_reason( 'F', (curr_fsm->table->table->id + found_index), reason, funit ); } } else { exclude_remove_exclude_reason( 'F', (curr_fsm->table->table->id + found_index), funit ); } } /* Deallocate vectors */ vector_dealloc( from_vec ); vector_dealloc( to_vec ); } PROFILE_END; }

void exclude_set_line_exclude (  func_unit *  funit, int  line, int  value, char *  reason, statistic *  stat )

Sets the excluded bit for all expressions in the given functional unit with the specified line number and recalculates the summary coverage information. Finds the expression(s) and functional unit instance for the given name, type and line number and calls the exclude_expr_assign_and_recalc function for each matching expression, setting the excluded bit of the expression and recalculating the summary coverage information. Parameters: funit  Pointer to functional unit line  Line number of expression that needs to be set value  Specifies if we should exclude (1) or include (0) the specified line reason  Reason for the exclusion if value is 1 stat  Pointer to statistics structure to update { PROFILE(EXCLUDE_SET_LINE_EXCLUDE); func_iter fi; /* Functional unit iterator */ statement* stmt; /* Pointer to current statement */ func_iter_init( &fi, funit, TRUE, FALSE ); do { while( ((stmt = func_iter_get_next_statement( &fi )) != NULL) && (stmt->exp->line != line) ); if( stmt != NULL ) { exclude_expr_assign_and_recalc( stmt->exp, funit, (value == 1), TRUE, stat ); /* Handle the exclusion reason */ if( value == 1 ) { if( reason != NULL ) { exclude_add_exclude_reason( 'L', stmt->exp->id, reason, funit ); } } else { exclude_remove_exclude_reason( 'L', stmt->exp->id, funit ); } } } while( stmt != NULL ); func_iter_dealloc( &fi ); PROFILE_END; }

void exclude_set_toggle_exclude (  func_unit *  funit, const char *  sig_name, int  value, char  type, char *  reason, statistic *  stat )

Sets the excluded bit for the specified signal in the given functional unit and recalculates the summary coverage information. Finds the signal and functional unit instance for the given name, type and sig_name and calls the exclude_sig_assign_and_recalc function for the matching signal, setting the excluded bit of the signal and recalculating the summary coverage information. Parameters: funit  Pointer to functional unit sig_name  Name of signal to set the toggle exclusion for value  Specifies if we should exclude (1) or include (0) the specified line type  Exclusion ID type (T=toggle, M=memory) reason  Reason for exclusion (if value is 1) stat  Pointer to statistics structure to update { PROFILE(EXCLUDE_SET_TOGGLE_EXCLUDE); func_iter fi; /* Functional unit iterator */ vsignal* sig; /* Pointer to current signal */ /* Find the signal that matches the given signal name, if it exists */ func_iter_init( &fi, funit, FALSE, TRUE ); while( ((sig = func_iter_get_next_signal( &fi )) != NULL) && (strcmp( sig->name, sig_name ) != 0) ); func_iter_dealloc( &fi ); /* Set its exclude bit if it exists */ if( sig != NULL ) { /* Exclude/include the signal and recalculate the summary information */ exclude_sig_assign_and_recalc( sig, (value == 1), stat ); /* Handle the exclusion reason */ if( value == 1 ) { if( reason != NULL ) { exclude_add_exclude_reason( type, sig->id, reason, funit ); } } else { exclude_remove_exclude_reason( type, sig->id, funit ); } } PROFILE_END; }

---