util.h File Reference

Contains miscellaneous global functions used by many functions. More...

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

Go to the source code of this file.

Defines
#define	malloc_safe(x)   malloc_safe1(x,__FILE__,__LINE__,profile_index)
#define	malloc_safe_nolimit(x)   malloc_safe_nolimit1(x,__FILE__,__LINE__,profile_index)
#define	strdup_safe(x)   strdup_safe1(x,__FILE__,__LINE__,profile_index)
#define	realloc_safe(x, y, z)   realloc_safe1(x,(((x)!=NULL)?y:0),z,__FILE__,__LINE__,profile_index)
#define	calloc_safe(x, y)   calloc_safe1(x,y,__FILE__,__LINE__,profile_index)
#define	free_safe(x, y)   free_safe1(x,profile_index)
Functions
void	set_quiet (bool value)
	Sets quiet output variable to specified value.
void	set_terse (bool value)
	Sets terse output variable to specified value.
void	set_debug (bool value)
	Sets global debug flag to specified value.
void	set_testmode ()
	Sets the testmode global variable for outputting purposes.
void	print_output (const char *msg, int type, const char *file, int line)
	Displays error message to standard output.
bool	check_option_value (int argc, const char **argv, int option_index)
	Checks to make sure that a value was properly specified for a given option.
bool	is_variable (const char *token)
	Returns TRUE if the specified string is a legal variable name.
bool	is_legal_filename (const char *token)
	Returns TRUE if the specified string could be a valid filename.
bool	is_func_unit (const char *token)
	Returns TRUE if the specified string is a legal functional unit value.
const char *	get_basename (const char *str)
	Extracts filename from file pathname.
char *	get_dirname (char *str)
	Extracts directory path from file pathname.
char *	get_absolute_path (const char *filename)
	Allocates memory for and gets the absolute pathname for a given filename.
char *	get_relative_path (const char *abs_path)
	Allocates memory for and gets the relative pathname for a given absolute filename.
bool	directory_exists (const char *dir)
	Returns TRUE if the specified directory exists.
void	directory_load (const char *dir, const str_link *ext_head, str_link **file_head, str_link **file_tail)
	Loads contents of specified directory to file list if extension is part of list.
bool	file_exists (const char *file)
	Returns TRUE if the specified file exists.
bool	util_readline (FILE *file, char **line, unsigned int *line_size)
	Reads line from file and returns it in string form.
bool	get_quoted_string (FILE *file, char *line)
	Reads in line from file and returns the contents of the quoted string following optional whitespace.
char *	substitute_env_vars (const char *value)
	Searches the specified string for environment variables and substitutes their value if found.
void	scope_extract_front (const char *scope, char *front, char *rest)
	Extracts highest level of hierarchy from specified scope.
void	scope_extract_back (const char *scope, char *back, char *rest)
	Extracts lowest level of hierarchy from specified scope.
void	scope_extract_scope (const char *scope, const char *front, char *back)
	Extracts rest of scope not included in front.
char *	scope_gen_printable (const char *str)
	Generates printable version of given signal/instance string.
bool	scope_compare (const char *str1, const char *str2)
	Compares two signal names or two instance names.
bool	scope_local (const char *scope)
	Returns TRUE if specified scope is local (contains no periods).
str_link *	get_next_vfile (str_link *curr, const char *mod)
	Returns next Verilog file to parse.
void *	malloc_safe1 (size_t size, const char *file, int line, unsigned int profile_index)
	Performs safe malloc call.
void *	malloc_safe_nolimit1 (size_t size, const char *file, int line, unsigned int profile_index)
	Performs safe malloc call without upper bound on byte allocation.
void	free_safe1 (void *ptr, unsigned int profile_index)
	Performs safe deallocation of heap memory.
void	free_safe2 (void *ptr, size_t size, const char *file, int line, unsigned int profile_index)
	Performs safe deallocation of heap memory.
char *	strdup_safe1 (const char *str, const char *file, int line, unsigned int profile_index)
	Safely allocates heap memory by performing a call to strdup.
void *	realloc_safe1 (void *ptr, size_t old_size, size_t size, const char *file, int line, unsigned int profile_index)
	Safely reallocates heap memory by performing a call to realloc.
void *	calloc_safe1 (size_t num, size_t size, const char *file, int line, unsigned int profile_index)
	Safely callocs heap memory by performing a call to calloc.
void	gen_char_string (char *spaces, char c, int num_spaces)
	Creates a string containing space characters.
char *	remove_underscores (char *str)
	Removes underscores from the specified string.
const char *	get_funit_type (int type)
	Returns string representation of the specified functional unit type.
void	calc_miss_percent (int hits, int total, int *misses, float *percent)
	Calculates miss and percent information from given hit and total information.
void	set_timestep (sim_time *st, char *value)
	Sets the given timestep to the correct value from VCD simulation file.
void	read_command_file (const char *cmd_file, char ***arg_list, int *arg_num)
	Reads in contents of command file, substitutes environment variables and stores them to the arg_list array.
void	gen_exclusion_id (char *excl_id, char type, int id)
	Generates the exclusion identifier.

---

Detailed Description

Contains miscellaneous global functions used by many functions.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

11/27/2001

---

Define Documentation

#define calloc_safe	(	x,
		y		)	calloc_safe1(x,y,__FILE__,__LINE__,profile_index)

Overload for the calloc_safe1 function which includes profiling information

Referenced by rank_create_comp_cdd_cov(), and rank_perform().

#define free_safe	(	x,
		y		)	free_safe1(x,profile_index)

Overload for the free-safe function which includes profiling information

Referenced by add_sym_values_to_sim(), arc_dealloc(), arc_display(), arc_state_hits(), assertion_funit_summary(), assertion_funit_verbose(), assertion_instance_summary(), assertion_instance_verbose(), attribute_dealloc(), bind_dealloc(), bind_find_sig_name(), bind_perform(), bind_remove(), codegen_create_expr_helper(), codegen_gen_expr(), combination_funit_verbose(), combination_get_expression(), combination_instance_summary(), combination_instance_verbose(), combination_list_missed(), combination_multi_var_exprs(), combination_multi_vars(), combination_prep_line(), combination_underline(), combination_underline_tree(), command_exclude(), command_merge(), command_rank(), command_report(), command_score(), covered_end_of_sim(), covered_parse_instance(), covered_parse_task_func(), db_add_function_task_namedblock(), db_add_signal(), db_assign_symbol(), db_close(), db_create_expr_from_static(), db_parallelize_statement(), db_read(), db_sync_curr_instance(), db_vcd_upscope(), defparam_dealloc(), directory_load(), enumerate_dealloc(), exclude_get_message(), exclude_handle_exclude_reason(), exclude_parse_args(), exclude_remove_exclude_reason(), exclude_resolve_reason(), exp_link_delete_list(), exp_link_remove(), expression_create_tmp_vecs(), expression_create_value(), expression_dealloc(), expression_find_rhs_sigs(), expression_op_func__test_plusargs(), expression_op_func__value_plusargs(), fsm_arg_parse(), fsm_arg_parse_attr(), fsm_arg_parse_trans(), fsm_dealloc(), fsm_display_arc_verbose(), fsm_display_state_verbose(), fsm_display_verbose(), fsm_funit_summary(), fsm_funit_verbose(), fsm_get_coverage(), fsm_instance_summary(), fsm_instance_verbose(), fsm_link_delete_list(), fsm_var_bind(), fsm_var_cleanup(), fsm_var_dealloc(), fst_parse(), func_iter_dealloc(), funit_clean(), funit_db_inst_merge(), funit_db_mod_merge(), funit_dealloc(), funit_link_delete_list(), funit_link_remove(), gen_item_bind(), gen_item_calc_signal_name(), gen_item_dealloc(), gen_item_resolve(), gen_item_stringify(), gen_item_varname_contains_genvar(), get_absolute_path(), gitem_link_delete_list(), gitem_link_remove(), info_dealloc(), inst_link_delete_list(), inst_parm_dealloc(), instance_dealloc_single(), instance_display_tree_helper(), instance_only_db_merge(), instance_only_db_read(), instance_resolve_inst(), is_func_unit(), line_display_verbose(), line_funit_summary(), line_funit_verbose(), line_instance_summary(), line_instance_verbose(), lxt2_rd_close(), lxt2_rd_iter_radix(), lxt2_rd_iter_radix0(), lxt2_rd_process_block(), lxt_parse(), memory_ae_funit_summary(), memory_ae_instance_summary(), memory_display_verbose(), memory_get_mem_coverage(), memory_instance_verbose(), memory_toggle_funit_summary(), memory_toggle_instance_summary(), merge_parse_args(), merged_cdd_db_read(), mod_parm_dealloc(), obfuscate_name(), ovl_display_verbose(), parser_dealloc_sig_range(), profiler_dealloc(), profiler_report(), profiler_set_filename(), race_blk_delete_list(), race_check_modules(), rank_dealloc_comp_cdd_cov(), rank_gather_fsm_cov(), rank_output(), rank_parse_args(), rank_perform(), reentrant_dealloc(), report_output_exclusion_reason(), report_parse_args(), report_print_header(), scope_compare(), scope_find_param(), scope_find_signal(), scope_get_parent_funit(), scope_get_parent_module(), score_generate_pli_tab_file(), score_generate_top_dumpvars_module(), score_generate_top_vpi_module(), score_parse_args(), score_parse_define(), sig_link_delete_list(), sim_dealloc(), statement_dealloc(), statement_dealloc_recursive(), statement_queue_compare(), static_expr_dealloc(), statistic_dealloc(), stmt_link_delete_list(), stmt_link_unlink(), str_link_delete_list(), str_link_remove(), struct_union_dealloc(), struct_union_member_dealloc(), substitute_env_vars(), symtable_dealloc(), toggle_display_verbose(), toggle_funit_summary(), toggle_instance_summary(), toggle_instance_verbose(), tree_add(), tree_dealloc(), tree_remove(), util_readline(), vcd_parse(), vector_db_read(), vector_dealloc(), vector_dealloc_value(), vector_from_string(), vector_to_string(), vsignal_create_vec(), vsignal_db_read(), and vsignal_dealloc().

#define malloc_safe

(

x

)

malloc_safe1(x,__FILE__,__LINE__,profile_index)

Overload for the malloc_safe function which includes profiling information

Referenced by arc_add(), arc_create(), arc_db_read(), arc_state_hits(), attribute_create(), bind_add(), bind_find_sig_name(), bind_signal(), codegen_create_expr(), codegen_create_expr_helper(), codegen_gen_expr(), combination_event(), combination_get_expression(), combination_multi_expr_output(), combination_multi_var_exprs(), combination_multi_vars(), combination_prep_line(), combination_two_vars(), combination_unary(), combination_underline_tree(), command_report(), covered_end_of_sim(), db_add_signal(), db_add_typedef(), db_create(), db_gen_curr_inst_scope(), db_gen_exclusion_id(), defparam_add(), directory_load(), enumerate_add_item(), exclude_add_exclude_reason(), exclude_db_merge(), exclude_db_read(), exclude_merge(), exp_link_add(), expression_create(), expression_create_nba(), expression_create_tmp_vecs(), expression_create_value(), expression_set_value(), fsm_add_arc(), fsm_create(), fsm_display_arc_verbose(), fsm_link_add(), fsm_var_add(), fsm_var_bind_add(), fsm_var_stmt_add(), func_iter_init(), funit_add_thread(), funit_create(), funit_link_add(), gen_item_create_bind(), gen_item_create_expr(), gen_item_create_inst(), gen_item_create_sig(), gen_item_create_stmt(), gen_item_create_tfn(), gen_item_resolve(), get_absolute_path(), gitem_link_add(), inst_link_add(), inst_parm_add(), inst_parm_add_genvar(), instance_create(), instance_resolve_inst(), line_collect(), lxt_parse(), memory_get_coverage(), memory_get_mem_coverage(), mod_parm_add(), obfuscate_name(), ovl_get_coverage(), parser_copy_curr_range(), parser_copy_range_to_curr_range(), parser_implicitly_set_curr_range(), perf_gen_stats(), race_blk_create(), race_check_modules(), rank_create_comp_cdd_cov(), rank_gather_fsm_cov(), rank_output(), read_command_file(), reentrant_create(), report_output_exclusion_reason(), scope_find_param(), scope_find_signal(), scope_get_parent_funit(), score_generate_pli_tab_file(), sig_link_add(), sim_create_thread(), sim_initialize(), statement_create(), statement_queue_add(), static_expr_gen(), statistic_create(), stmt_link_add(), str_link_add(), struct_union_add_member_enum(), struct_union_add_member_sig(), struct_union_add_member_struct_union(), struct_union_add_member_typedef(), struct_union_add_member_void(), struct_union_create(), substitute_env_vars(), sym_value_store(), symtable_add_sym_sig(), symtable_create(), symtable_init(), tree_add(), util_readline(), vector_create(), vector_get_toggle01_ulong(), vector_get_toggle10_ulong(), vector_to_string(), vsignal_create(), vsignal_db_read(), vsignal_duplicate(), and vsignal_from_string().

#define malloc_safe_nolimit

(

x

)

malloc_safe_nolimit1(x,__FILE__,__LINE__,profile_index)

Overload for the malloc_safe_nolimit function which includes profiling information

Referenced by covered_sim_calltf(), fst_parse(), gen_item_stringify(), lxt2_rd_process_block(), lxt_parse(), rank_perform(), and vcd_parse().

#define realloc_safe	(	x,
		y,
		z		)	realloc_safe1(x,(((x)!=NULL)?y:0),z,__FILE__,__LINE__,profile_index)

Overload for the realloc_safe1 function which includes profiling information

Referenced by arc_add(), arc_get_states(), arc_get_transitions(), combination_collect(), combination_get_exclude_list(), combination_get_expression(), combination_prep_line(), db_create(), db_set_vcd_scope(), db_vcd_upscope(), exclude_format_reason(), exclude_get_message(), exclude_resolve_reason(), fsm_collect(), fsm_gather_signals(), gen_item_calc_signal_name(), info_db_read(), line_collect(), memory_create_pdim_bit_array(), memory_get_coverage(), memory_get_mem_coverage(), merged_cdd_db_read(), ovl_collect(), parser_explicitly_set_curr_range(), parser_implicitly_set_curr_range(), race_collect_lines(), rank_read_cdd(), search_init(), substitute_env_vars(), and util_readline().

#define strdup_safe

(

x

)

strdup_safe1(x,__FILE__,__LINE__,profile_index)

Overload for the strdup_safe function which includes profiling information

Referenced by arc_get_transitions(), attribute_create(), bind_add(), bind_find_sig_name(), bind_perform(), codegen_create_expr_helper(), codegen_gen_expr(), combination_get_exclude_list(), combination_multi_vars(), combination_prep_line(), combination_underline_tree(), command_report(), command_score(), covered_parse_instance(), covered_parse_task_func(), db_add_file_version(), db_add_function_task_namedblock(), db_add_instance(), db_add_module(), db_add_typedef(), db_create_unnamed_scope(), db_parallelize_statement(), db_read(), db_set_vcd_scope(), exclude_db_merge(), exclude_db_read(), exclude_format_reason(), exclude_get_message(), exclude_merge(), exclude_parse_args(), exclude_resolve_reason(), fsm_arg_parse(), fsm_var_add(), fsm_var_bind_add(), fsm_var_stmt_add(), funit_db_write(), funit_gen_task_function_namedblock_name(), funit_version_db_read(), gen_item_bind(), gen_item_calc_signal_name(), gen_item_create_bind(), gen_item_varname_contains_genvar(), gen_next_symbol(), get_absolute_path(), get_relative_path(), info_db_read(), inst_parm_add(), instance_create(), instance_only_db_merge(), instance_only_db_read(), instance_resolve_inst(), is_func_unit(), line_collect(), lxt2_rd_iter_radix(), lxt2_rd_iter_radix0(), memory_get_coverage(), merge_parse_args(), merged_cdd_db_read(), message_db_read(), mod_parm_add(), ovl_collect(), ovl_get_coverage(), parse_design(), profiler_set_filename(), rank_create_comp_cdd_cov(), rank_parse_args(), read_command_file(), report_output_exclusion_reason(), report_parse_args(), scope_find_param(), scope_find_signal(), scope_gen_printable(), scope_get_parent_module(), score_add_args(), score_generate_pli_tab_file(), score_generate_top_dumpvars_module(), score_generate_top_vpi_module(), score_parse_args(), score_parse_define(), search_add_directory_path(), search_add_extensions(), search_add_file(), search_add_include_path(), search_add_no_score_funit(), search_init(), struct_union_create(), sym_value_store(), sys_task_store_plusarg(), toggle_get_coverage(), tree_add(), vector_copy(), vector_db_read(), vector_from_string(), vector_init_r32(), vector_init_r64(), vector_to_string(), vsignal_create(), and vsignal_duplicate().

---

Function Documentation

void calc_miss_percent	(	int	hits,
		int	total,
		int *	misses,
		float *	percent
	)

Calculates miss and percent information from given hit and total information.

Calculates the number of misses and hit percentage information from the given hit and total information, storing the results in the misses and percent storage elements.

Note:

If the total number of items is 0, the hit percentage will be calculated as 100% covered.

Parameters:

	hits	Number of items hit during simulation
	total	Number of total items
	misses	Pointer to a storage element which will contain the calculated number of items missed during simulation
	percent	Pointer to a storage element which will contain the calculated hit percent information

References PROFILE, and PROFILE_END.

Referenced by assertion_display_funit_summary(), assertion_display_instance_summary(), combination_display_funit_summary(), combination_display_instance_summary(), fsm_display_funit_summary(), fsm_display_instance_summary(), line_display_funit_summary(), line_display_instance_summary(), memory_display_ae_funit_summary(), memory_display_ae_instance_summary(), memory_display_toggle_funit_summary(), memory_display_toggle_instance_summary(), toggle_display_funit_summary(), and toggle_display_instance_summary().

  { PROFILE(CALC_MISS_PERCENT);

  if( total == 0 ) {
    *percent = 100;
  } else {
    *percent = ((hits / (float)total) * 100);
  }

  *misses = (total - hits);

  PROFILE_END;

}

void* calloc_safe1	(	size_t	num,
		size_t	size,
		const char *	file,
		int	line,
		unsigned int	profile_index
	)

Safely callocs heap memory by performing a call to calloc.

Returns:

Returns a pointer to the newly allocated/initialized data

Verifies that the specified size is not oversized, callocs the memory, verifies that the memory pointer returned is not NULL, and performs some memory statistic handling.

Parameters:

	num	Number of elements to allocate
	size	Size of each element that is allocated
	file	Name of file that called this function
	line	Line number of file that called this function
	profile_index	Profile index of function that called this function

References curr_malloc_size, largest_malloc_size, MALLOC_CALL, and test_mode.

  {

  void*  obj;
  size_t total = (num * size);

  assert( total > 0 );

  curr_malloc_size += total;

  if( curr_malloc_size > largest_malloc_size ) {
    largest_malloc_size = curr_malloc_size;
  }

  obj = calloc( num, size );
#ifdef TESTMODE
  if( test_mode ) {
    printf( "CALLOC (%p) %d bytes (file: %s, line: %d) - %" FMT64 "d\n", obj, (int)total, file, line, curr_malloc_size );
  }
#endif
  assert( obj != NULL );

  MALLOC_CALL(profile_index);

  return( obj );

}

bool check_option_value	(	int	argc,
		const char **	argv,
		int	option_index
	)

Checks to make sure that a value was properly specified for a given option.

Returns:

Returns TRUE if the specified option has a valid argument; otherwise, returns FALSE to indicate that there was an error in parsing the command-line.

This function is called whenever a command-line argument requires a value. It verifies that a value was specified (however, it does not make sure that the value is the correct type). Outputs an error message and returns a value of FALSE if a value was not specified; otherwise, returns TRUE.

Parameters:

	argc	Number of arguments in the argv parameter list
	argv	List of arguments being parsed
	option_index	Index of current option being parsed

References FALSE, FATAL, print_output(), PROFILE, PROFILE_END, TRUE, user_msg, and USER_MSG_LENGTH.

Referenced by exclude_parse_args(), merge_parse_args(), rank_parse_args(), report_parse_args(), and score_parse_args().

  { PROFILE(CHECK_OPTION_VALUE);

  bool retval = TRUE;  /* Return value for this function */

  if( ((option_index + 1) >= argc) || ((argv[option_index+1][0] == '-') && (strlen(argv[option_index+1]) > 1)) ) {
    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Missing option value to the right of the %s option", argv[option_index] );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, FATAL, __FILE__, __LINE__ );
    retval = FALSE;
  }

  PROFILE_END;

  return( retval );

}

bool directory_exists

(

const char *

dir

)

Returns TRUE if the specified directory exists.

Returns:

Returns TRUE if the specified directory exists; otherwise, returns FALSE.

Checks to see if the specified directory actually exists in the file structure. If the directory is found to exist, returns TRUE; otherwise, returns FALSE.

Parameters:

dir

Name of directory to check for existence

References FALSE, PROFILE, PROFILE_END, and TRUE.

Referenced by merge_parse_args(), rank_parse_args(), search_add_directory_path(), and search_add_include_path().

  { PROFILE(DIRECTORY_EXISTS);

  bool        retval = FALSE;  /* Return value for this function */
  struct stat filestat;        /* Statistics of specified directory */

  if( stat( dir, &filestat ) == 0 ) {

    if( S_ISDIR( filestat.st_mode ) ) {

      retval = TRUE;

    }

  }

  PROFILE_END;

  return( retval );

}

void directory_load	(	const char *	dir,
		const str_link *	ext_head,
		str_link **	file_head,
		str_link **	file_tail
	)

Loads contents of specified directory to file list if extension is part of list.

Bug:

Need to order files according to extension first instead of filename.

Exceptions:

anonymous

Throw

Opens the specified directory for reading and loads (in order) all files that contain the specified extensions (if ext_head is NULL, load only *.v files). Stores all string filenames to the specified string list.

Parameters:

	dir	Name of directory to read files from
	ext_head	Pointer to extension list
	file_head	Pointer to head element of filename string list
	file_tail	Pointer to tail element of filename string list

References FATAL, free_safe, malloc_safe, str_link_s::next, print_output(), PROFILE, PROFILE_END, str_link_s::str, str_link_add(), str_link_find(), str_link_s::suppl, Throw, user_msg, and USER_MSG_LENGTH.

Referenced by merge_parse_args(), rank_parse_args(), and search_add_directory_path().

  { PROFILE(DIRECTORY_LOAD);

  DIR*            dir_handle;  /* Pointer to opened directory */
  struct dirent*  dirp;        /* Pointer to current directory entry */
  const str_link* curr_ext;    /* Pointer to current extension string */
  char*           ptr;         /* Pointer to current character in filename */
  unsigned int    tmpchars;    /* Number of characters needed to store full pathname for file */
  char*           tmpfile;     /* Temporary string holder for full pathname of file */

  if( (dir_handle = opendir( dir )) == NULL ) {

    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Unable to read directory %s", dir );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, FATAL, __FILE__, __LINE__ );
    Throw 0;

  } else {

    unsigned int rv;

    while( (dirp = readdir( dir_handle )) != NULL ) {
      ptr = dirp->d_name + strlen( dirp->d_name ) - 1;
      /* Work backwards until a dot is encountered */
      while( (ptr >= dirp->d_name) && (*ptr != '.') ) {
        ptr--;
      }
      if( *ptr == '.' ) {
        ptr++;
        curr_ext = ext_head;
        while( (curr_ext != NULL) && (strcmp( ptr, curr_ext->str ) != 0) ) {
          curr_ext = curr_ext->next;
        }
        if( curr_ext != NULL ) {
          unsigned int rv;
          /* Found valid extension, add to list */
          tmpchars = strlen( dirp->d_name ) + strlen( dir ) + 2;
          tmpfile  = (char*)malloc_safe( tmpchars );
          rv = snprintf( tmpfile, tmpchars, "%s/%s", dir, dirp->d_name );
          assert( rv < tmpchars );
          if( str_link_find( tmpfile, *file_head ) == NULL ) {
            (void)str_link_add( tmpfile, file_head, file_tail );
            (*file_tail)->suppl = 0x1;
          } else {
            free_safe( tmpfile, (strlen( tmpfile ) + 1) );
          }
        }
      }
    }

    rv = closedir( dir_handle );
    assert( rv == 0 );

  }

  PROFILE_END;

}

bool file_exists

(

const char *

file

)

Returns TRUE if the specified file exists.

Returns:

Returns TRUE if the specified file exists; otherwise, returns FALSE.

Checks to see if the specified file actually exists in the file structure. If the file is found to exist, returns TRUE; otherwise, returns FALSE.

Parameters:

file

Name of file to check for existence

References FALSE, PROFILE, PROFILE_END, and TRUE.

Referenced by exclude_parse_args(), merge_parse_args(), rank_parse_args(), read_command_file(), report_parse_args(), score_parse_args(), and search_add_file().

  { PROFILE(FILE_EXISTS);

  bool        retval = FALSE;  /* Return value for this function */
  struct stat filestat;        /* Statistics of specified directory */

  if( stat( file, &filestat ) == 0 ) {

    if( S_ISREG( filestat.st_mode ) || S_ISFIFO( filestat.st_mode ) ) {

      retval = TRUE;

    }

  }

  PROFILE_END;

  return( retval );

}

void free_safe1	(	void *	ptr,
		unsigned int	profile_index
	)

Performs safe deallocation of heap memory.

Safely performs a free function of heap memory. Also keeps track of current memory usage for output information at end of program life.

Parameters:

	ptr	Pointer to object to deallocate
	profile_index	Profile index of function that called this function

References FREE_CALL.

  {

  if( ptr != NULL ) {
    free( ptr );
  }

  /* Profile the free */
  FREE_CALL(profile_index);

}

void free_safe2	(	void *	ptr,
		size_t	size,
		const char *	file,
		int	line,
		unsigned int	profile_index
	)

Performs safe deallocation of heap memory.

Safely performs a free function of heap memory. Also keeps track of current memory usage for output information at end of program life.

Parameters:

	ptr	Pointer to object to deallocate
	size	Number of bytes that will be deallocated
	file	File that is calling this function
	line	Line number in file that is calling this function
	profile_index	Profile index of function that called this function

References curr_malloc_size, FREE_CALL, and test_mode.

  {

  if( ptr != NULL ) {
    curr_malloc_size -= size;
#ifdef TESTMODE
    if( test_mode ) {
      printf( "FREE (%p) %d bytes (file: %s, line: %d) - %" FMT64 "d\n", ptr, (int)size, file, line, curr_malloc_size );
    }
#endif
    free( ptr );
  }

  /* Profile the free */
  FREE_CALL(profile_index);

}

void gen_char_string	(	char *	str,
		char	c,
		int	num_chars
	)

Creates a string containing space characters.

Creates a string that contains num_chars number of characters specified by the value of c, adding a NULL character at the end of the string to allow for correct usage by the strlen and other string functions.

Parameters:

	str	Pointer to string to places spaces into
	c	Character to write
	num_chars	Number of spaces to place in string

References PROFILE, and PROFILE_END.

Referenced by combination_event(), combination_multi_expr_output(), combination_multi_vars(), combination_two_vars(), combination_unary(), combination_underline_tree(), fsm_display_arc_verbose(), ovl_display_verbose(), rank_output(), report_output_exclusion_reason(), search_add_extensions(), and toggle_display_verbose().

  { PROFILE(GEN_SPACE);

  int i;     /* Loop iterator */

  for( i=0; i<num_chars; i++ ) {
    str[i] = c;
  }

  str[i] = '\0';

  PROFILE_END;
  
}

void gen_exclusion_id	(	char *	excl_id,
		char	type,
		int	id
	)

Generates the exclusion identifier.

char* get_absolute_path

(

const char *

filename

)

Allocates memory for and gets the absolute pathname for a given filename.

Returns:

Returns absolute path of the given absolute pathname to the current path.

Parameters:

filename

Filename to get the absolute pathname of

References free_safe, get_dirname(), malloc_safe, PROFILE, PROFILE_END, and strdup_safe.

Referenced by merge_parse_args().

  { PROFILE(GET_ABSOLUTE_PATH);

  char*        abs_path = NULL;
  char*        tmp;
  char*        dir;
  char         this_cwd[4096];
  char*        srv;
  unsigned int irv;

  /* Get a copy of the filename and calculate its directory and basename */
  tmp = strdup_safe( filename );
  dir = get_dirname( tmp );

  /* Get the original working directory so that we can return there */
  srv = getcwd( this_cwd, 4096 );
  assert( srv != NULL );

  /* If we have a directory to go to, change to the directory */
  if( dir[0] != '\0' ) {

    char         cwd[4096];
    unsigned int slen;
    char*        file = dir + strlen( dir ) + 1;

    /* Change to the specified directory */
    irv = chdir( dir );
    assert( irv == 0 );

    /* Get the current working directory and create the absolute path */
    srv = getcwd( cwd, 4096 );
    assert( srv != NULL );

    slen     = strlen( cwd ) + strlen( file ) + 2;
    abs_path = (char*)malloc_safe( slen );
    irv      = snprintf( abs_path, slen, "%s/%s", cwd, file );
    assert( irv < slen );

    /* Return to the original directory */
    irv = chdir( this_cwd );
    assert( irv == 0 );

  /* Otherwise, the file is in this directory */
  } else {

    unsigned int slen;

    slen = strlen( this_cwd ) + strlen( filename ) + 2;

    abs_path = (char*)malloc_safe( slen );
    irv      = snprintf( abs_path, slen, "%s/%s", this_cwd, filename );
    assert( irv < slen );

  }

  /* Deallocate used memory */
  free_safe( tmp, (strlen( filename ) + 1) );

  PROFILE_END;

  return( abs_path );

}

const char* get_basename

(

const char *

str

)

Extracts filename from file pathname.

Returns:

Returns pointer to string containing only base filename.

Extracts the file basename of the specified filename string.

Parameters:

str

String containing pathname to file

References PROFILE, and PROFILE_END.

Referenced by assertion_funit_summary(), combination_funit_summary(), fsm_funit_summary(), line_funit_summary(), memory_ae_funit_summary(), memory_toggle_funit_summary(), race_report_summary(), and toggle_funit_summary().

  { PROFILE(GET_BASENAME);

  const char* ptr;  /* Pointer to current character in str */

  ptr = (str + strlen( str )) - 1;

  while( (ptr > str) && (*ptr != '/') ) {
    ptr--;
  }

  if( *ptr == '/' ) {
    ptr++;
  }

  PROFILE_END;

  return( ptr );

}

char* get_dirname

(

char *

str

)

Extracts directory path from file pathname.

Returns:

Returns pointer to string containing only the directory path

Extracts the directory path from the specified filename (or returns NULL if there is no directory path).

Warning:

Modifies the given string!

Parameters:

str

String containing pathname to file

References PROFILE, and PROFILE_END.

Referenced by get_absolute_path().

  { PROFILE(GET_DIRNAME);

  char* ptr;  /* Pointer to current character in str */

  ptr = (str + strlen( str )) - 1;

  while( (ptr > str) && (*ptr != '/') ) {
    ptr--;
  }

  *ptr = '\0';
  
  PROFILE_END;

  return( str );

}

const char* get_funit_type

(

int

type

)

Returns string representation of the specified functional unit type.

Returns:

Returns a string giving the user-readable name of the given functional unit type

Parameters:

type

Type of functional unit (see Functional Unit Types for legal values)

References funit_types, FUNIT_TYPES, PROFILE, and PROFILE_END.

Referenced by bind_task_function_namedblock(), db_add_function_task_namedblock(), db_add_instance(), funit_db_write(), funit_display_expressions(), funit_display_signals(), funit_link_display(), gen_item_stringify(), perf_output_mod_stats(), scope_find_param(), scope_find_signal(), and scope_find_task_function_namedblock().

  { PROFILE(GET_FUNIT_TYPE);

  const char* type_str;

  if( (type >= 0) && (type < FUNIT_TYPES) ) {
    type_str = funit_types[type];
  } else {
    type_str = funit_types[FUNIT_TYPES];
  }

  PROFILE_END;

  return( type_str );

}

str_link* get_next_vfile	(	str_link *	curr,
		const char *	mod
	)

Returns next Verilog file to parse.

Returns:

Returns pointer to next Verilog file to parse or NULL if no files were found.

Iterates through specified file list, searching for next Verilog file to parse. If a file is a library file (suppl field is 'D'), the name of the module to search for is compared with the name of the file.

Parameters:

	curr	Pointer to current file in list
	mod	Name of module searching for

References convert_file_to_module(), str_link_s::next, PROFILE, PROFILE_END, str_link_s::str, str_link_s::suppl, and str_link_s::suppl2.

  { PROFILE(GET_NEXT_VFILE);

  str_link* next = NULL;  /* Pointer to next Verilog file to parse */
  char      name[256];    /* String holder for module name of file */

  while( (curr != NULL) && (next == NULL) ) {
    if( (curr->suppl & 0x1) != 0x1 ) {
      next = curr;
    } else {
      convert_file_to_module( name, 256, curr->str );
      if( strcmp( name, mod ) == 0 ) {
        next = curr;
      } else {
        curr = curr->next;
      }
    }
  }

  /* Specify that the returned file will be parsed */
  if( next != NULL ) {
    next->suppl2 = 1;
  }

  PROFILE_END;

  return( next );

}

bool get_quoted_string	(	FILE *	file,
		char *	line
	)

Reads in line from file and returns the contents of the quoted string following optional whitespace.

Returns:

Returns TRUE if a quoted string was properly parsed; otherwise, returns FALSE.

Parses a double-quoted string from the file pointer if one exists. Removes quotes.

Parameters:

	file	Pointer to file to parse
	line	User supplied character array to hold quoted string

References FALSE, PROFILE, PROFILE_END, and TRUE.

Referenced by read_command_file().

  { PROFILE(GET_QUOTED_STRING);

  bool found = FALSE;  /* Return value for this function */
  char c[128];         /* Temporary whitespace storage */
  int  i     = 0;      /* Loop iterator */

  /* First, remove any whitespace and temporarily store it */
  while( ((c[i] = getc( file )) != EOF) && isspace( c[i] ) ) i++;

  /* If the character we are looking at is a double-quote, continue parsing */
  if( c[i] == '"' ) {

    i = 0;
    while( ((line[i] = getc( file )) != EOF) && (line[i] != '"') ) i++;
    line[i]  = '\0';
    found = TRUE;

  /* Otherwise, ungetc the collected characters */
  } else {

    for( ; i >= 0; i-- ) {
      (void)ungetc( c[i], file );
    }

  }

  PROFILE_END;

  return( found );

}

char* get_relative_path

(

const char *

abs_path

)

Allocates memory for and gets the relative pathname for a given absolute filename.

Returns:

Returns relative path of the given absolute pathname to the current path.

Parameters:

abs_path

Absolute pathname of file to get relative path for

References PROFILE, PROFILE_END, and strdup_safe.

Referenced by merged_cdd_db_read(), and report_print_header().

  { PROFILE(GET_RELATIVE_PATH);

  char*        rel_path = NULL;
  char         cwd[4096];
  char*        rv;
  unsigned int i;

  /* Get the current working directory */
  rv = getcwd( cwd, 4096 );
  assert( rv != NULL );

  /*
   Compare the absolute path to the current working directory path and stop when we see a
   miscompare or run into the end of a path string.
  */
  i = 0;
  while( (i < strlen( cwd )) && (i < strlen( abs_path )) && (abs_path[i] == cwd[i]) ) i++;

  /* We should have never gotten to the end of the absolute path */
  assert( i < strlen( abs_path ) );

  /*
   If the current working directory is completely a part of the absolute path, the relative pathname
   is beneath the current working directory.
  */
  if( i == strlen( cwd ) ) {
    rel_path = strdup_safe( abs_path + i + 1 );

  /*
   Otherwise, we need to back up and go forward.
  */
  } else {

    unsigned int save_i;
    char         trel[4096];

    /* Find the previous backslash */
    while( (i > 0) && (cwd[i] != '/') ) i--;
    assert( cwd[i] == '/' );
    
    /* Save the current position of i */
    save_i = i + 1; 

    /* Create back portion of path */
    trel[0] = '\0';
    for( ; i<strlen( cwd ); i++ ) {
      if( cwd[i] == '/' ) {
        strcat( trel, "../" );
      }
    }

    /* Now append the absolute path */
    strcat( trel, (abs_path + save_i) );

    /* Finally, make a copy of the calculated relative path */
    rel_path = strdup_safe( trel );

  }

  PROFILE_END;

  return( rel_path );

}

bool is_func_unit

(

const char *

token

)

Returns TRUE if the specified string is a legal functional unit value.

Returns:

Returns TRUE if the specified token is a valid argument representing a functional unit.

Parameters:

token

Pointer to string to parse

References FALSE, free_safe, is_variable(), PROFILE, PROFILE_END, scope_extract_front(), and strdup_safe.

Referenced by search_add_no_score_funit().

  { PROFILE(IS_FUNC_UNIT);

  char* orig;                          /* Temporary string */
  char* rest;                          /* Temporary string */
  char* front;                         /* Temporary string */
  bool  okay = (strlen( token ) > 0);  /* Specifies if this token is a functional unit value or not */

  /* Allocate memory */
  orig  = strdup_safe( token );
  rest  = strdup_safe( token );
  front = strdup_safe( token );

  /* Check to make sure that each value between '.' is a valid variable */
  while( (strlen( orig ) > 0) && okay ) {
    scope_extract_front( orig, front, rest );
    if( !is_variable( front ) ) {
      okay = FALSE;
    } else {
      strcpy( orig, rest );
    }
  }

  /* Deallocate memory */
  free_safe( orig, (strlen( token ) + 1) );
  free_safe( rest, (strlen( token ) + 1) );
  free_safe( front, (strlen( token ) + 1) );

  PROFILE_END;

  return( okay );

}

bool is_legal_filename

(

const char *

token

)

Returns TRUE if the specified string could be a valid filename.

Returns:

Returns TRUE if the specified string would be a legal filename to write to; otherwise, returns FALSE.

Parameters:

token

String to check for valid pathname-ness

References FALSE, PROFILE, PROFILE_END, and TRUE.

Referenced by merge_parse_args(), rank_parse_args(), report_parse_args(), and score_parse_args().

  { PROFILE(IS_LEGAL_FILENAME);

  bool  retval = FALSE;  /* Return value for this function */
  FILE* tmpfile;         /* Temporary file pointer */

  if( (tmpfile = fopen( token, "w" )) != NULL ) {
    unsigned int rv = fclose( tmpfile );
    assert( rv == 0 );
    retval = TRUE;
  }

  PROFILE_END;

  return( retval );

}

bool is_variable

(

const char *

token

)

Returns TRUE if the specified string is a legal variable name.

Returns:

Returns TRUE if the specified string is a legal variable name; otherwise, returns FALSE.

If the specified string follows all of the rules for a legal program variable (doesn't start with a number, contains only a-zA-Z0-9_ characters), returns a value of TRUE; otherwise, returns a value of FALSE.

Parameters:

token

String to check for valid variable name

References FALSE, PROFILE, PROFILE_END, and TRUE.

Referenced by is_func_unit(), and score_parse_args().

  { PROFILE(IS_VARIABLE);

  bool retval = TRUE;   /* Return value of this function */

  if( token != NULL ) {

    if( (token[0] >= '0') && (token[0] <= '9') ) {

      retval = FALSE;

    } else {

      while( (token[0] != '\0') && retval ) {
        if( !(((token[0] >= 'a') && (token[0] <= 'z')) ||
             ((token[0] >= 'A') && (token[0] <= 'Z')) ||
             ((token[0] >= '0') && (token[0] <= '9')) ||
              (token[0] == '_')) ) {
          retval = FALSE;
        }
        token++;
      }

    }

  } else {

    retval = FALSE;

  }

  PROFILE_END;

  return( retval );

}

void* malloc_safe1	(	size_t	size,
		const char *	file,
		int	line,
		unsigned int	profile_index
	)

Performs safe malloc call.

Returns:

Pointer to allocated memory.

Allocated memory like a malloc() call but performs some pre-allocation and post-allocation checks to be sure that the malloc call works properly.

Parameters:

	size	Number of bytes to allocate
	file	File that called this function
	line	Line number of file that called this function
	profile_index	Profile index of function that called this function

References curr_malloc_size, largest_malloc_size, MALLOC_CALL, MAX_MALLOC_SIZE, and test_mode.

  {

  void* obj;  /* Object getting malloc address */

  assert( size <= MAX_MALLOC_SIZE );

  curr_malloc_size += size;

  if( curr_malloc_size > largest_malloc_size ) {
    largest_malloc_size = curr_malloc_size;
  }

  obj = malloc( size );
#ifdef TESTMODE
  if( test_mode ) {
    printf( "MALLOC (%p) %d bytes (file: %s, line: %d) - %" FMT64 "d\n", obj, (int)size, file, line, curr_malloc_size );
  }
#endif
  assert( obj != NULL );

  /* Profile the malloc */
  MALLOC_CALL(profile_index);

  return( obj );

}

void* malloc_safe_nolimit1	(	size_t	size,
		const char *	file,
		int	line,
		unsigned int	profile_index
	)

Performs safe malloc call without upper bound on byte allocation.

Returns:

Pointer to allocated memory.

Allocated memory like a malloc() call but performs some pre-allocation and post-allocation checks to be sure that the malloc call works properly. Unlike malloc_safe, there is no upper bound on the amount of memory to allocate.

Parameters:

	size	Number of bytes to allocate
	file	Name of file that called this function
	line	Line number of file that called this function
	profile_index	Profile index of function that called this function

References curr_malloc_size, largest_malloc_size, MALLOC_CALL, and test_mode.

  {

  void* obj;  /* Object getting malloc address */

  curr_malloc_size += size;

  if( curr_malloc_size > largest_malloc_size ) {
    largest_malloc_size = curr_malloc_size;
  }

  obj = malloc( size );
#ifdef TESTMODE
  if( test_mode ) {
    printf( "MALLOC (%p) %d bytes (file: %s, line: %d) - %" FMT64 "d\n", obj, (int)size, file, line, curr_malloc_size );
  }
#endif
  assert( obj != NULL );

  /* Profile the malloc */
  MALLOC_CALL(profile_index);

  return( obj );

}

void print_output	(	const char *	msg,
		int	type,
		const char *	file,
		int	line
	)

Displays error message to standard output.

Displays the specified message to standard output based on the type of message being output.

Parameters:

	msg	Message to display
	type	Type of message to output (see Output type for legal values)
	file	Name of file that called this function
	line	Line number that this function was called in

References cli_debug_mode, DEBUG, debug_mode, FATAL, FATAL_WRAP, flag_use_command_line_debug, HEADER, interp, NORMAL, obf_file, quiet_mode, terse_mode, USER_MSG_LENGTH, vpi_print_output(), WARNING, WARNING_WRAP, and warnings_suppressed.

Referenced by arc_db_read(), args_db_read(), bind_perform(), bind_signal(), bind_task_function_namedblock(), check_option_value(), combination_underline_tree(), command_exclude(), command_merge(), command_rank(), command_report(), command_score(), covered_create_value_change_cb(), covered_parse_instance(), covered_parse_signals(), covered_parse_task_func(), covered_value_change_bin(), covered_value_change_real(), db_add_declared_param(), db_add_defparam(), db_add_enum(), db_add_expression(), db_add_file_version(), db_add_function_task_namedblock(), db_add_instance(), db_add_module(), db_add_override_param(), db_add_signal(), db_add_statement(), db_add_typedef(), db_add_vector_param(), db_assign_symbol(), db_bind_expr_tree(), db_check_dumpfile_scopes(), db_connect_statement_false(), db_connect_statement_true(), db_create_attr_param(), db_create_expr_from_static(), db_create_expression(), db_create_statement(), db_do_timestep(), db_end_enum_list(), db_end_function_task_namedblock(), db_end_module(), db_find_gen_item(), db_find_signal(), db_find_typedef(), db_gen_item_connect(), db_gen_item_connect_false(), db_gen_item_connect_true(), db_get_curr_gen_block(), db_merge_instance_trees(), db_parallelize_statement(), db_parse_attribute(), db_read(), db_remove_statement(), db_remove_statement_from_current_funit(), db_set_symbol_char(), db_set_symbol_string(), db_set_vcd_scope(), db_statement_connect(), db_vcd_upscope(), db_write(), defparam_add(), directory_load(), enumerate_resolve(), exclude_apply_exclusions(), exclude_assert_from_id(), exclude_db_merge(), exclude_db_read(), exclude_expr_from_id(), exclude_fsm_from_id(), exclude_get_message(), exclude_line_from_id(), exclude_memory_from_id(), exclude_parse_args(), exclude_toggle_from_id(), expression_assign(), expression_create_value(), expression_db_merge(), expression_db_read(), expression_dealloc(), expression_op_func__bitstoreal(), expression_op_func__bitstoshortreal(), expression_op_func__itor(), expression_op_func__realtobits(), expression_op_func__rtoi(), expression_op_func__shortrealtobits(), expression_op_func__test_plusargs(), expression_op_func__urandom_range(), expression_op_func__value_plusargs(), expression_operate(), expression_resize(), fsm_arg_parse(), fsm_arg_parse_attr(), fsm_arg_parse_trans(), fsm_db_merge(), fsm_db_read(), fsm_var_bind_expr(), fst_parse(), funit_db_inst_merge(), funit_db_mod_merge(), funit_db_read(), funit_db_write(), gen_item_create_bind(), gen_item_create_expr(), gen_item_create_inst(), gen_item_create_sig(), gen_item_create_stmt(), gen_item_create_tfn(), gen_item_resolve(), info_db_read(), info_set_vector_elem_size(), instance_only_db_merge(), instance_only_db_read(), instance_resolve_helper(), lxt2_rd_init(), lxt2_rd_iter_radix(), lxt2_rd_iter_radix0(), lxt2_rd_process_block(), lxt_parse(), main(), merge_check(), merge_parse_args(), merged_cdd_db_read(), param_find_and_set_expr_value(), parse_and_score_dumpfile(), parse_design(), parse_readline(), profiler_report(), race_check_modules(), race_check_race_count(), race_db_read(), race_handle_race_condition(), rank_check_index(), rank_output(), rank_parse_args(), rank_perform(), rank_read_cdd(), read_command_file(), report_parse_args(), report_parse_metrics(), report_read_cdd_and_ready(), scope_find_param(), scope_find_signal(), scope_find_task_function_namedblock(), score_generate_pli_tab_file(), score_generate_top_dumpvars_module(), score_generate_top_vpi_module(), score_parse_args(), search_add_directory_path(), search_add_extensions(), search_add_file(), search_add_include_path(), search_add_no_score_funit(), search_init(), sim_expr_changed(), sim_expression(), sim_thread(), statement_db_read(), stmt_blk_specify_removal_reason(), substitute_env_vars(), vcd_parse(), vcd_parse_def(), vcd_parse_def_scope(), vcd_parse_def_var(), vcd_parse_sim(), vcd_parse_sim_ignore(), vcd_parse_sim_real(), vcd_parse_sim_vector(), vector_db_merge(), vector_db_read(), VLerror(), VLwarn(), vsignal_db_merge(), vsignal_db_read(), and vsignal_vcd_assign().

  {

  FILE* outf = debug_mode ? stdout : stderr;
  char  tmpmsg[USER_MSG_LENGTH];

  switch( type ) {
    case DEBUG:
      if( debug_mode && (!flag_use_command_line_debug || cli_debug_mode) ) {
#ifdef VPI_ONLY
        vpi_print_output( msg );
#else
        unsigned int rv;
        printf( "%s\n", msg );  rv = fflush( stdout );  assert( rv == 0 );
#endif
      }
      break;
    case HEADER:
      if( !quiet_mode || terse_mode || debug_mode ) {
#ifdef VPI_ONLY
        vpi_print_output( msg );
#else
        printf( "%s\n", msg );
#endif
      }
      break;
    case NORMAL:
      if( (!quiet_mode && !terse_mode) || debug_mode ) {
#ifdef VPI_ONLY
        vpi_print_output( msg );
#else
        printf( "%s\n", msg );
#endif
      }
      break;
    case WARNING:
      if( (!quiet_mode || terse_mode) && !warnings_suppressed ) {
        if( interp != NULL ) {
          unsigned int rv = snprintf( tmpmsg, USER_MSG_LENGTH, "WARNING!  %s\n", msg );
          assert( rv < USER_MSG_LENGTH );
#ifndef VPI_ONLY
#ifdef HAVE_TCLTK
          Tcl_SetResult( interp, tmpmsg, TCL_VOLATILE );
#endif
#endif
        } else {
          fprintf( outf, "    WARNING!  %s\n", msg );
        }
      } else if( debug_mode ) {
        if( interp != NULL ) {
          unsigned int rv = snprintf( tmpmsg, USER_MSG_LENGTH, "WARNING!  %s (file: %s, line: %d)\n", msg, file, line );
          assert( rv < USER_MSG_LENGTH );
#ifndef VPI_ONLY
#ifdef HAVE_TCLTK
          Tcl_SetResult( interp, tmpmsg, TCL_VOLATILE );
#endif
#endif
        } else {
          fprintf( outf, "    WARNING!  %s (file: %s, line: %d)\n", msg, obf_file( file ), line );
        }
      }
      break;
    case WARNING_WRAP:
      if( ((!quiet_mode || terse_mode) && !warnings_suppressed) || debug_mode ) {
        if( interp != NULL ) {
          unsigned int rv = snprintf( tmpmsg, USER_MSG_LENGTH, "              %s\n", msg );
          assert( rv < USER_MSG_LENGTH );
#ifndef VPI_ONLY
#ifdef HAVE_TCLTK
          Tcl_AppendElement( interp, tmpmsg );
#endif
#endif
        } else {
          fprintf( outf, "              %s\n", msg );
        }
      }
      break; 
    case FATAL:
      (void)fflush( outf );
      if( debug_mode ) {
        if( interp != NULL ) {
          unsigned int rv = snprintf( tmpmsg, USER_MSG_LENGTH, "%s (file: %s, line: %d)\n", msg, file, line );
          assert( rv < USER_MSG_LENGTH );
#ifndef VPI_ONLY
#ifdef HAVE_TCLTK
          Tcl_SetResult( interp, tmpmsg, TCL_VOLATILE );
          fprintf( stderr, "ERROR!  %s (file: %s, line: %d)\n", msg, obf_file( file ), line );
#endif
#endif
        } else {
          fprintf( stderr, "ERROR!  %s (file: %s, line: %d)\n", msg, obf_file( file ), line );
        }
      } else {
        if( interp != NULL ) {
          unsigned int rv = snprintf( tmpmsg, USER_MSG_LENGTH, "%s\n", msg );
          assert( rv < USER_MSG_LENGTH );
#ifndef VPI_ONLY
#ifdef HAVE_TCLTK
          Tcl_SetResult( interp, tmpmsg, TCL_VOLATILE );
          fprintf( stderr, "ERROR!  %s\n", msg );
#endif
#endif
        } else {
          fprintf( stderr, "ERROR!  %s\n", msg );
        }
      }
      break;
    case FATAL_WRAP:
      if( interp != NULL ) {
        unsigned int rv = snprintf( tmpmsg, USER_MSG_LENGTH, "%s\n", msg );
        assert( rv < USER_MSG_LENGTH );
#ifndef VPI_ONLY
#ifdef HAVE_TCLTK
        Tcl_AppendElement( interp, tmpmsg );
#endif
#endif
      } else { 
        fprintf( stderr, "        %s\n", msg );
      }
      break;
    default:  break;
  }

}

void read_command_file	(	const char *	cmd_file,
		char ***	arg_list,
		int *	arg_num
	)

Reads in contents of command file, substitutes environment variables and stores them to the arg_list array.

Exceptions:

anonymous

Throw Throw Throw substitute_env_vars

Parses the given file specified by the '-f' option to one of Covered's commands which can contain any command-line arguments. Performs environment variable substitution to any $... variables that are found in the file.

Parameters:

	cmd_file	Name of file to read commands from
	arg_list	List of arguments found in specified command file
	arg_num	Number of arguments in arg_list array

References Catch_anonymous, FATAL, file_exists(), get_quoted_string(), malloc_safe, str_link_s::next, print_output(), PROFILE, str_link_s::str, str_link_add(), str_link_delete_list(), strdup_safe, substitute_env_vars(), Throw, Try, user_msg, and USER_MSG_LENGTH.

Referenced by exclude_parse_args(), merge_parse_args(), rank_parse_args(), report_parse_args(), and score_parse_args().

  { PROFILE(READ_COMMAND_FILE);

  str_link* head    = NULL;  /* Pointer to head element of arg list */
  str_link* tail    = NULL;  /* Pointer to tail element of arg list */
  FILE*     cmd_handle;      /* Pointer to command file */
  char      tmp_str[4096];   /* Temporary holder for read argument */
  str_link* curr;            /* Pointer to current str_link element */
  int       tmp_num = 0;     /* Temporary argument number holder */
  bool      use_stdin;       /* If set to TRUE, uses stdin for the cmd_handle */

  /* Figure out if we should use stdin */
  use_stdin = (strcmp( "-", cmd_file ) == 0);

  if( use_stdin || file_exists( cmd_file ) ) {

    if( (cmd_handle = (use_stdin ? stdin : fopen( cmd_file, "r" ))) != NULL ) {

      unsigned int rv;

      Try {

        while( get_quoted_string( cmd_handle, tmp_str ) || fscanf( cmd_handle, "%s", tmp_str ) == 1 ) {
          (void)str_link_add( substitute_env_vars( tmp_str ), &head, &tail );
          tmp_num++;
        }

      } Catch_anonymous {
        rv = fclose( cmd_handle );
        assert( rv == 0 );
        str_link_delete_list( head );
        Throw 0;
      }

      rv = fclose( cmd_handle );
      assert( rv == 0 );

      /* Set the argument list number now */
      *arg_num = tmp_num;

      /*
       If there were any arguments found in the file, create an argument list and pass it to the
       command-line parser.
      */
      if( tmp_num > 0 ) {

        /* Create argument list */
        *arg_list = (char**)malloc_safe( sizeof( char* ) * tmp_num );
        tmp_num   = 0;

        curr = head;
        while( curr != NULL ) {
          (*arg_list)[tmp_num] = strdup_safe( curr->str );
          tmp_num++;
          curr = curr->next;
        } 
        
        /* Delete list */
        str_link_delete_list( head );
        
      } 
        
    } else {

      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Unable to open command file %s for reading", cmd_file );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, FATAL, __FILE__, __LINE__ );
      Throw 0;

    }

  } else {

    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Command file %s does not exist", cmd_file );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, FATAL, __FILE__, __LINE__ );
    Throw 0;
        
  }

}

void* realloc_safe1	(	void *	ptr,
		size_t	old_size,
		size_t	size,
		const char *	file,
		int	line,
		unsigned int	profile_index
	)

Safely reallocates heap memory by performing a call to realloc.

Calls the realloc() function for the specified memory and size, making sure that the memory size doesn't exceed a threshold value and that the requested memory was allocated.

Parameters:

	ptr	Pointer to old memory to copy
	old_size	Size of originally allocated memory (in bytes)
	size	Size of new allocated memory (in bytes)
	file	Name of file that called this function
	line	Line number of file that called this function
	profile_index	Profile index of function that called this function

References curr_malloc_size, largest_malloc_size, MALLOC_CALL, MAX_MALLOC_SIZE, and test_mode.

  {

  void* newptr;

  assert( size <= MAX_MALLOC_SIZE );

  curr_malloc_size -= old_size;
  curr_malloc_size += size;
  if( curr_malloc_size > largest_malloc_size ) {
    largest_malloc_size = curr_malloc_size;
  }
 
  if( size == 0 ) {
    if( ptr != NULL ) {
      free( ptr );
    }
    newptr = NULL;
  } else {
    newptr = realloc( ptr, size );
    assert( newptr != NULL );
  }
#ifdef TESTMODE
  if( test_mode ) {
    printf( "REALLOC (%p -> %p) %d (%d) bytes (file: %s, line: %d) - %" FMT64 "d\n", ptr, newptr, (int)size, (int)old_size, file, line, curr_malloc_size );
  }
#endif

  MALLOC_CALL(profile_index);

  return( newptr );

}

char* remove_underscores

(

char *

str

)

Removes underscores from the specified string.

Returns:

Returns a pointer to the modified string (or NULL if the string only contains underscores).

Parameters:

str

String to remove underscore characters from

References PROFILE, and PROFILE_END.

Referenced by vector_db_read(), and vector_from_string().

  { PROFILE(REMOVE_UNDERSCORES);

  char*        start = NULL;
  unsigned int i;
  unsigned int cur   = 1;

  for( i=0; i<strlen( str ); i++ ) {
    if( str[i] != '_' ) {
      if( start == NULL ) {
        start = str + i;
      } else {
        start[cur++] = str[i];
      }
    }
  }

  if( start != NULL ) {
    start[cur] = '\0';
  }

  PROFILE_END;

  return( start );

}

bool scope_compare	(	const char *	str1,
		const char *	str2
	)

Compares two signal names or two instance names.

Returns:

Returns TRUE if the two strings are equal, properly handling the case where one or both are escaped names (start with an escape character and end with a space).

Parameters:

	str1	Pointer to signal/instance name
	str2	Pointer to signal/instance name

References free_safe, PROFILE, PROFILE_END, and scope_gen_printable().

Referenced by funit_link_find(), gen_item_compare(), instance_compare(), instance_dealloc(), sig_link_find(), vsignal_db_merge(), and vsignal_merge().

  { PROFILE(SCOPE_COMPARE);

  bool  retval;    /* Return value for this function */
  char* new_str1;  /* New form of str1 with escaped sequences removed */
  char* new_str2;  /* New form of str1 with escaped sequences removed */

  /* Create printable versions of the strings */
  new_str1 = scope_gen_printable( str1 );
  new_str2 = scope_gen_printable( str2 );

  /* Perform the compare */
  retval = (strcmp( new_str1, new_str2 ) == 0);

  /* Deallocate the memory */
  free_safe( new_str1, (strlen( new_str1 ) + 1) );
  free_safe( new_str2, (strlen( new_str2 ) + 1) );

  PROFILE_END;

  return( retval );

}

void scope_extract_back	(	const char *	scope,
		char *	back,
		char *	rest
	)

Extracts lowest level of hierarchy from specified scope.

Extracts the lowest level of hierarchy from the specified scope, returning that instance name to the value of back and the the rest of the hierarchy in the value of rest.

Parameters:

	scope	Full scope to extract from
	back	Lowest level of hierarchy extracted
	rest	Hierarchy left after extraction

References PROFILE, and PROFILE_END.

Referenced by bind_task_function_namedblock(), codegen_gen_expr(), combination_underline_tree(), db_read(), funit_is_unnamed(), instance_dealloc(), instance_only_db_merge(), instance_only_db_read(), lxt_parse(), scope_find_param(), scope_find_signal(), scope_get_parent_funit(), scope_get_parent_module(), and search_init().

  { PROFILE(SCOPE_EXTRACT_BACK);

  const char* ptr;      /* Pointer to current character */
  char        endchar;  /* Set to the character we are searching for */

  ptr = scope + strlen( scope ) - 1;

  /* Figure out if we are looking for a '.' or a ' ' character */
  endchar = (*ptr == ' ') ? '\\' : '.';

  while( (ptr > scope) && (*ptr != endchar) ) {
    ptr--;
  }

  /* If this is a literal, keep going until we see the '.' character */
  if( endchar == '\\' ) {
    while( (ptr > scope) && (*ptr != '.') ) {
      ptr--;
    }
  }

  strncpy( rest, scope, (ptr - scope) );
  rest[ (ptr - scope) ] = '\0';

  if( *ptr == '.' ) {
    ptr++;
  }

  strncpy( back, ptr, ((strlen( scope ) + scope) - ptr) );
  back[ ((strlen( scope ) + scope) - ptr) ] = '\0';

  PROFILE_END;
  
}

void scope_extract_front	(	const char *	scope,
		char *	front,
		char *	rest
	)

Extracts highest level of hierarchy from specified scope.

Extracts the highest level of hierarchy from the specified scope, returning that instance name to the value of front and the the rest of the hierarchy in the value of rest.

Parameters:

	scope	Full scope to extract from
	front	Highest level of hierarchy extracted
	rest	Hierarchy left after extraction

References PROFILE, and PROFILE_END.

Referenced by bind_find_sig_name(), funit_flatten_name(), instance_find_scope(), is_func_unit(), score_generate_pli_tab_file(), score_generate_top_dumpvars_module(), score_generate_top_vpi_module(), and search_init().

  { PROFILE(SCOPE_EXTRACT_FRONT);
  
  const char* ptr;      /* Pointer to current character */
  char        endchar;  /* Set to the character we are searching for */
  
  ptr = scope;

  /* Figure out if we are looking for a '.' or a ' ' character */
  endchar = (*ptr == '\\') ? ' ' : '.';
  
  while( (*ptr != '\0') && (*ptr != endchar) ) {
    ptr++;
  }

  /* If this is a literal, keep going until we see the '.' character */
  if( endchar == ' ' ) {
    while( (*ptr != '\0') && (*ptr != '.') ) {
      ptr++;
    }
  }
  
  strncpy( front, scope, (ptr - scope) );
  front[ (ptr - scope) ] = '\0';
  
  if( *ptr == '.' ) {
    ptr++;
    strncpy( rest, ptr, (strlen( scope ) - (ptr - scope)) );
    rest[ (strlen( scope ) - (ptr - scope)) ] = '\0';
  } else {
    rest[0] = '\0';
  }

  PROFILE_END;
  
}

void scope_extract_scope	(	const char *	scope,
		const char *	front,
		char *	back
	)

Extracts rest of scope not included in front.

Parses the given scope and removes the front portion of this scope (if the front portion of the scope matches the beginning portion of scope) and returns the remaining scope in the array pointed to by back. If front does not exist within scope, back is set to a value of the null string. Assumes that the length of back is allocated and large enough to hold the full value of scope, if necessary.

Parameters:

	scope	Full scope to search
	front	Leading portion of scope to exclude
	back	Following portion of scope that is in scope that is not in front

References PROFILE, and PROFILE_END.

  { PROFILE(SCOPE_EXTRACT_SCOPE);

  back[0] = '\0';

  if( (strncmp( scope, front, strlen( front ) ) == 0) && (strlen( scope ) > strlen( front )) ) {
    strcpy( back, (scope + strlen( front ) + 1) );
  }

  PROFILE_END;

}

char* scope_gen_printable

(

const char *

str

)

Generates printable version of given signal/instance string.

Returns:

Returns printable version of the given string (with any escaped sequences removed)

Allocates memory for and generates a printable version of the given string (a signal or instance name). The calling function is responsible for deallocating the string returned.

Parameters:

str

String to create printable version of

References obf_sig, PROFILE, PROFILE_END, and strdup_safe.

Referenced by assertion_funit_summary(), assertion_funit_verbose(), assertion_instance_summary(), assertion_instance_verbose(), codegen_gen_expr(), combination_funit_verbose(), combination_instance_summary(), combination_instance_verbose(), combination_underline_tree(), fsm_funit_summary(), fsm_funit_verbose(), fsm_instance_summary(), fsm_instance_verbose(), instance_display_tree_helper(), line_funit_summary(), line_funit_verbose(), line_instance_summary(), line_instance_verbose(), memory_ae_funit_summary(), memory_ae_instance_summary(), memory_display_verbose(), memory_instance_verbose(), memory_toggle_funit_summary(), memory_toggle_instance_summary(), scope_compare(), toggle_display_verbose(), toggle_funit_summary(), toggle_instance_summary(), and toggle_instance_verbose().

  { PROFILE(SCOPE_GEN_PRINTABLE);

  char* new_str;  /* New version of string with escaped sequences removed */

  assert( strlen( obf_sig( str ) ) < 4096 );

  /* Remove escape sequences, if any */
  if( str[0] == '\\' ) {
    char         tmp_str[4096];
    unsigned int rv = sscanf( str, "\\%[^ \n\t\r\b]", tmp_str );
    assert( rv == 1 );
    new_str = strdup_safe( tmp_str );
  } else {
    new_str = strdup_safe( obf_sig( str ) );
  }

  PROFILE_END;

  return( new_str );

} 

bool scope_local

(

const char *

scope

)

Returns TRUE if specified scope is local (contains no periods).

Parameters:

scope

Scope of some signal

References FALSE, PROFILE, PROFILE_END, and TRUE.

Referenced by bind_param(), bind_signal(), bind_task_function_namedblock(), funit_db_write(), scope_find_param(), and scope_find_signal().

  { PROFILE(SCOPE_LOCAL);

  const char* ptr;             /* Pointer to current character */
  bool        esc;             /* Set to TRUE if current is escaped */
  bool        wspace = FALSE;  /* Set if last character seen was a whitespace */

  assert( scope != NULL );

  ptr = scope;
  esc = (*ptr == '\\');
  while( (*ptr != '\0') && ((*ptr != '.') || esc) ) {
    if( (*ptr == ' ') || (*ptr == '\n') || (*ptr == '\t') || (*ptr == '\b') || (*ptr == '\r') ) {
      esc    = FALSE;
      wspace = TRUE;
    } else {
      if( wspace && (*ptr == '\\') ) {
        esc = TRUE;
      }
    }
    ptr++;
  }

  PROFILE_END;

  return( *ptr == '\0' );

}

void set_debug

(

bool

value

)

Sets global debug flag to specified value.

Sets the global debug mode to the specified value.

Parameters:

value

Boolean value of debug mode

References debug_mode.

Referenced by main().

  {

  debug_mode = value;

}

void set_quiet

(

bool

value

)

Sets quiet output variable to specified value.

Sets the global quiet_mode variable to the specified value.

Parameters:

value

Boolean value of suppression

References quiet_mode.

Referenced by main().

  {

  quiet_mode = value;

}

void set_terse

(

bool

value

)

Sets terse output variable to specified value.

Set the global terse_mode variable to the given value.

Parameters:

value

Boolean value of terse mode

References terse_mode.

Referenced by main().

  {

  terse_mode = value;

}

void set_testmode

(

)

Sets the testmode global variable for outputting purposes.

Looks at the user's environment and searches for COVERED_TESTMODE, if the environment variable is set, sets the global test_mode variable to TRUE; otherwise, sets it to FALSE.

References test_mode.

Referenced by main().

                    {

  test_mode = (getenv( "COVERED_TESTMODE" ) != NULL);

}

void set_timestep	(	sim_time *	st,
		char *	value
	)

Sets the given timestep to the correct value from VCD simulation file.

char* strdup_safe1	(	const char *	str,
		const char *	file,
		int	line,
		unsigned int	profile_index
	)

Safely allocates heap memory by performing a call to strdup.

Calls the strdup() function for the specified string, making sure that the string to allocate is a healthy string (contains NULL character).

Parameters:

	str	String to duplicate
	file	Name of file that called this function
	line	Line number of file that called this function
	profile_index	Profile index of function that called this function

References curr_malloc_size, largest_malloc_size, MALLOC_CALL, MAX_MALLOC_SIZE, and test_mode.

  {

  char* new_str;
  int   str_len = strlen( str ) + 1;

  assert( str_len <= MAX_MALLOC_SIZE );
  curr_malloc_size += str_len;
  if( curr_malloc_size > largest_malloc_size ) {
    largest_malloc_size = curr_malloc_size;
  }
  new_str = strdup( str );
#ifdef TESTMODE
  if( test_mode ) {
    printf( "STRDUP (%p) %d bytes (file: %s, line: %d) - %" FMT64 "d\n", new_str, str_len, file, line, curr_malloc_size );
  }
#endif
  assert( new_str != NULL );

  /* Profile the malloc */
  MALLOC_CALL(profile_index);

  return( new_str );

}

char* substitute_env_vars

(

const char *

value

)

Searches the specified string for environment variables and substitutes their value if found.

Returns:

Returns the given value with environment variables substituted in. This value should be freed by the calling function.

Exceptions:

anonymous

Throw

Parameters:

value

Input string that will be searched for environment variables

References Catch_anonymous, FALSE, FATAL, free_safe, malloc_safe, print_output(), PROFILE, PROFILE_END, realloc_safe, Throw, TRUE, Try, user_msg, and USER_MSG_LENGTH.

Referenced by read_command_file().

  { PROFILE(SUBSTITUTE_ENV_VARS);

  char*       newvalue      = NULL;   /* New value */
  int         newvalue_index;         /* Current index into newvalue */
  const char* ptr;                    /* Pointer to current character in value */
  char        env_var[4096];          /* Name of found environment variable */
  int         env_var_index = 0;      /* Current index to write into env_var string */
  bool        parsing_var   = FALSE;  /* Set to TRUE when we are parsing an environment variable */
  char*       env_value;              /* Environment variable value */

  newvalue       = (char*)malloc_safe( 1 );
  newvalue[0]    = '\0';
  ptr            = value;
  newvalue_index = 0;

  Try {

    while( *ptr != '\0' || parsing_var ) {
      if( parsing_var ) {
        if( isalnum( *ptr ) || (*ptr == '_') ) {
          env_var[env_var_index] = *ptr;
          env_var_index++;
        } else {
          env_var[env_var_index] = '\0';
          if( (env_value = getenv( env_var )) != NULL ) {
            newvalue = (char*)realloc_safe( newvalue, (strlen( newvalue ) + 1), (newvalue_index + strlen( env_value ) + 1) );
            strcat( newvalue, env_value );
            newvalue_index += strlen( env_value );
            parsing_var = FALSE;
            ptr--;
          } else {
            unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Unknown environment variable $%s in string \"%s\"", env_var, value );
            assert( rv < USER_MSG_LENGTH );
            print_output( user_msg, FATAL, __FILE__, __LINE__ );
            Throw 0;
          }
        }
      } else if( *ptr == '$' ) {
        parsing_var   = TRUE;
        env_var_index = 0;
      } else {
        newvalue = (char*)realloc_safe( newvalue, (strlen( newvalue ) + 1), (newvalue_index + 2) );
        newvalue[newvalue_index]   = *ptr;
        newvalue[newvalue_index+1] = '\0';
        newvalue_index++;
      }
      ptr++;
    }

  } Catch_anonymous {
    free_safe( newvalue, (strlen( newvalue ) + 1) );
    Throw 0;
  }

  PROFILE_END;

  return( newvalue );

}

bool util_readline	(	FILE *	file,
		char **	line,
		unsigned int *	line_size
	)

Reads line from file and returns it in string form.

Returns:

Returns FALSE if feof is encountered; otherwise, returns TRUE.

Reads in a single line of information from the specified file and returns a string containing the read line to the calling function.

Parameters:

	file	File to read next line from
	line	Pointer to string which will contain read line minus newline character
	line_size	Pointer to number of characters allocated for line

References free_safe, malloc_safe, PROFILE, PROFILE_END, and realloc_safe.

Referenced by db_read(), funit_db_inst_merge(), and funit_db_mod_merge().

  { PROFILE(UTIL_READLINE);

  char         c;      /* Character recently read from file */
  unsigned int i = 0;  /* Current index of line */

  *line_size = 128;
  *line      = (char*)malloc_safe( *line_size );

  while( !feof( file ) && ((c = (char)fgetc( file )) != '\n') ) {

    if( i == (*line_size - 1) ) {
      *line_size *= 2;
      *line       = (char*)realloc_safe( *line, (*line_size / 2), *line_size );
    }

    (*line)[i] = c;
    i++;

  }

  if( !feof( file ) ) {
    (*line)[i] = '\0';
  } else {
    free_safe( *line, *line_size );
    *line = NULL;
  }

  PROFILE_END;

  return( !feof( file ) );

}