search.c File Reference

#include <stdlib.h>
#include <sys/types.h>
#include <dirent.h>
#include "defines.h"
#include "search.h"
#include "link.h"
#include "func_unit.h"
#include "util.h"
#include "instance.h"

Functions
void	search_init ()
	Initializes search maintained pointers.
void	search_add_include_path (const char *path)
	Adds an include directory to the list of directories to search for `include directives.
void	search_add_directory_path (const char *path)
	Adds a directory to the list of directories to find unspecified Verilog modules.
void	search_add_file (const char *file)
	Adds a specific Verilog module to the list of modules to score.
void	search_add_no_score_funit (const char *funit)
	Adds specified functional unit to list of functional units not to score.
void	search_add_extensions (const char *ext_list)
	Adds specified extensions to allowed file extension list.
void	search_free_lists ()
	Deallocates all used memory for search lists.
Variables
str_link *	inc_paths_head = NULL
static str_link *	inc_paths_tail = NULL
str_link *	use_files_head = NULL
static str_link *	use_files_tail = NULL
str_link *	no_score_head = NULL
static str_link *	no_score_tail = NULL
static str_link *	extensions_head = NULL
static str_link *	extensions_tail = NULL
db **	db_list
unsigned int	db_size
unsigned int	curr_db
char *	top_module
char *	top_instance
char	user_msg [USER_MSG_LENGTH]
func_unit *	global_funit
func_unit *	curr_funit
unsigned int	flag_global_generation

---

Detailed Description

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

11/27/2001

---

Function Documentation

void search_add_directory_path

(

const char *

path

)

Adds a directory to the list of directories to find unspecified Verilog modules.

Parameters:

path

Name of directory to find unspecified Verilog files

Exceptions:

anonymous

directory_load

Adds the given library directory path to the list if the pathname is valid.

References directory_exists(), directory_load(), print_output(), PROFILE, str_link_add(), strdup_safe, user_msg, USER_MSG_LENGTH, and WARNING.

Referenced by score_parse_args().

  { PROFILE(SEARCH_ADD_DIRECTORY_PATH);

  if( directory_exists( path ) ) {
    /* If no library extensions have been specified, assume *.v */
    if( extensions_head == NULL ) {
      (void)str_link_add( strdup_safe( "v" ), &(extensions_head), &(extensions_tail) );
    }
    directory_load( path, extensions_head, &(use_files_head), &(use_files_tail) );
  } else {
    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Library directory %s does not exist", path );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, WARNING, __FILE__, __LINE__ );
  }

}

void search_add_extensions

(

const char *

ext_list

)

Adds specified extensions to allowed file extension list.

Parameters:

ext_list

String containing extensions to allow in search.

Exceptions:

anonymous

Throw Throw

Parses the given +libext argument, extracting all extensions listed and storing them into the globally accessible extensions list.

References FATAL, FATAL_WRAP, gen_char_string(), print_output(), PROFILE, str_link_add(), strdup_safe, Throw, user_msg, and USER_MSG_LENGTH.

Referenced by score_parse_args().

  { PROFILE(SEARCH_ADD_EXTENSIONS);

  char        ext[30];               /* Holder for extension */
  int         ext_index = 0;         /* Index to ext array */
  const char* tmp       = ext_list;  /* Temporary extension name */

  assert( ext_list != NULL );

  while( *tmp != '\0' ) {
    assert( ext_index < 30 );
    if( *tmp == '+' ) { 
      ext[ext_index] = '\0';
      ext_index      = 0;
      (void)str_link_add( strdup_safe( ext ), &extensions_head, &extensions_tail );
    } else if( *tmp == '.' ) {
      if( ext_index > 0 ) {
        Throw 0;
      }
    } else {
      ext[ext_index] = *tmp;
      ext_index++;
    }
    tmp++;
  }

  /* If extension list is not empty, we have hit a parsing error */
  if( (strlen( tmp ) > 0) || (ext_index > 0) ) {
    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Parsing error in +libext+%s  ", ext_list );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, FATAL, __FILE__, __LINE__ );
    gen_char_string( user_msg, ' ', (25 + (strlen( ext_list ) - strlen( tmp ))) );
    strcat( user_msg, "^" );
    print_output( user_msg, FATAL_WRAP, __FILE__, __LINE__ );
    Throw 0;
  }

}

void search_add_file

(

const char *

file

)

Adds a specific Verilog module to the list of modules to score.

Parameters:

file

Name of Verilog file to add to scoring list.

Exceptions:

anonymous

Throw

Adds the given file to the search path list if the file exists.

References FATAL, file_exists(), print_output(), PROFILE, str_link_add(), str_link_find(), strdup_safe, str_link_s::suppl, Throw, user_msg, and USER_MSG_LENGTH.

Referenced by score_parse_args().

  { PROFILE(SEARCH_ADD_FILE);

  char* tmp;  /* Temporary filename */

  if( file_exists( file ) ) {

    str_link* strl;

    if( (strl = str_link_find( file, use_files_head )) == NULL ) {
      tmp = strdup_safe( file );
      (void)str_link_add( tmp, &use_files_head, &use_files_tail );
    } else {
      strl->suppl = 0x0;
    }

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

}

void search_add_include_path

(

const char *

path

)

Adds an include directory to the list of directories to search for `include directives.

Parameters:

path

Name of include path to search for `include directives.

Adds the given include directory path to the include path list if the pathname exists.

References directory_exists(), print_output(), PROFILE, str_link_add(), strdup_safe, user_msg, USER_MSG_LENGTH, and WARNING.

Referenced by score_parse_args().

  { PROFILE(SEARCH_ADD_INCLUDE_PATH);

  char* tmp;  /* Temporary directory name */

  if( directory_exists( path ) ) {
    tmp = strdup_safe( path );
    (void)str_link_add( tmp, &inc_paths_head, &inc_paths_tail );
  } else {
    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Include directory %s does not exist", path );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, WARNING, __FILE__, __LINE__ );
  }

}

void search_add_no_score_funit

(

const char *

funit

)

Adds specified functional unit to list of functional units not to score.

Parameters:

funit

Name of functional unit to specifically not score

Exceptions:

anonymous

Throw

Checks the given functional unit name and adds this name to the list of functional units to exclude from coverage.

References FATAL, is_func_unit(), print_output(), PROFILE, str_link_add(), strdup_safe, Throw, user_msg, and USER_MSG_LENGTH.

Referenced by ovl_add_assertions_to_no_score_list(), and score_parse_args().

  { PROFILE(SEARCH_ADD_NO_SCORE_FUNIT);

  char* tmp;  /* Temporary module name */

  if( is_func_unit( funit ) ) {
    tmp = strdup_safe( funit );
    (void)str_link_add( tmp, &no_score_head, &no_score_tail );
  } else {
    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Value of -e option (%s) is not a valid block name", funit );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, FATAL, __FILE__, __LINE__ );
    Throw 0;
  }

}

void search_free_lists

(

)

Deallocates all used memory for search lists.

This function should be called after all parsing is completed. Deletes all initialized lists.

References PROFILE, PROFILE_END, and str_link_delete_list().

Referenced by command_score().

                         { PROFILE(SEARCH_FREE_LISTS);

  str_link_delete_list( inc_paths_head );
  str_link_delete_list( use_files_head );
  str_link_delete_list( extensions_head );
  str_link_delete_list( no_score_head );

  PROFILE_END;

}

void search_init

(

)

Initializes search maintained pointers.

Exceptions:

anonymous

Throw

Creates root module for module_node tree. If a module_node points to this node as its parent, that node is considered the root node of the tree.

References funit_inst_s::child_head, funit_inst_s::child_tail, curr_db, FALSE, FATAL, func_unit_s::filename, flag_global_generation, funit_create(), funit_head, funit_link_add(), FUNIT_MODULE, db_s::funit_tail, GENERATION_SV, inst_link_s::inst, inst_head, db_s::inst_head, inst_link_add(), instance_create(), db_s::leading_hier_num, db_s::leading_hierarchies, func_unit_s::name, funit_inst_s::next, funit_inst_s::parent, print_output(), PROFILE, realloc_safe, scope_extract_back(), scope_extract_front(), strdup_safe, Throw, top_instance, top_module, func_unit_s::ts_unit, and func_unit_s::type.

Referenced by command_score().

                   { PROFILE(SEARCH_INIT);

  func_unit* mod;            /* Pointer to newly created module node from top module */
  char       dutname[4096];  /* Instance name of top-level DUT module */
  char       lhier[4096];    /* Temporary storage of leading hierarchy */

  /* Check to make sure that the user specified a -t option value */
  if( top_module == NULL ) {
    print_output( "No top module was specified with the -t option.  Please see \"covered -h\" for usage.",
                  FATAL, __FILE__, __LINE__ );
    Throw 0;
  }

  /* If the global generation type is SystemVerilog support, create the global $root module space */
  if( flag_global_generation == GENERATION_SV ) {

    /* Create the global functional unit */
    global_funit           = funit_create();
    global_funit->name     = strdup_safe( "$root" );
    global_funit->type     = FUNIT_MODULE;
    global_funit->filename = strdup_safe( "NA" );
    global_funit->ts_unit  = 2;
    (void)funit_link_add( global_funit, &(db_list[curr_db]->funit_head), &(db_list[curr_db]->funit_tail) );
    curr_funit = global_funit;

    /* Add it in the first instance tree */
    (void)inst_link_add( instance_create( global_funit, "$root", FALSE, FALSE, FALSE, NULL ), &(db_list[curr_db]->inst_head), &(db_list[curr_db]->inst_tail) );
  }

  /* Now create top-level module of design */
  mod       = funit_create();
  mod->type = FUNIT_MODULE;
  mod->name = strdup_safe( top_module );

  /* Initialize functional unit linked list */
  (void)funit_link_add( mod, &(db_list[curr_db]->funit_head), &(db_list[curr_db]->funit_tail) );

  /* Initialize instance tree */
  if( top_instance == NULL ) {
    top_instance = strdup_safe( top_module );
    (void)inst_link_add( instance_create( mod, top_instance, FALSE, FALSE, FALSE, NULL ), &(db_list[curr_db]->inst_head), &(db_list[curr_db]->inst_tail) );
    db_list[curr_db]->leading_hierarchies = (char**)realloc_safe( db_list[curr_db]->leading_hierarchies, (sizeof( char* ) * db_list[curr_db]->leading_hier_num), (sizeof( char* ) * (db_list[curr_db]->leading_hier_num + 1)) );
    db_list[curr_db]->leading_hierarchies[db_list[curr_db]->leading_hier_num] = strdup_safe( "*" );
    db_list[curr_db]->leading_hier_num++;
  } else {
    scope_extract_back( top_instance, dutname, lhier );
    if( lhier[0] == '\0' ) {
      db_list[curr_db]->leading_hierarchies = (char**)realloc_safe( db_list[curr_db]->leading_hierarchies, (sizeof( char* ) * db_list[curr_db]->leading_hier_num), (sizeof( char* ) * (db_list[curr_db]->leading_hier_num + 1)) );
      db_list[curr_db]->leading_hierarchies[db_list[curr_db]->leading_hier_num] = strdup_safe( "*" );
      db_list[curr_db]->leading_hier_num++;
      (void)inst_link_add( instance_create( mod, dutname, FALSE, FALSE, FALSE, NULL ), &(db_list[curr_db]->inst_head), &(db_list[curr_db]->inst_tail) );
    } else {
      char        tmp1[4096];
      char        tmp2[4096];
      char        tmp3[4096];
      inst_link*  instl;
      funit_inst* parent;
      funit_inst* child;
      (void)strcpy( tmp1, lhier );
      scope_extract_front( tmp1, tmp2, tmp3 );
      instl  = inst_link_add( instance_create( NULL, tmp2, FALSE, FALSE, FALSE, NULL ), &(db_list[curr_db]->inst_head), &(db_list[curr_db]->inst_tail) );
      parent = instl->inst;
      while( tmp3[0] != '\0' ) {
        (void)strcpy( tmp1, tmp3 );
        scope_extract_front( tmp1, tmp2, tmp3 );
        child = instance_create( NULL, tmp2, FALSE, FALSE, FALSE, NULL );
        child->parent = parent;
        if( parent->child_head == NULL ) {
          parent->child_head       = child;
          parent->child_tail       = child;
        } else {
          parent->child_tail->next = child;
          parent->child_tail       = child;
        }
        parent = child;
      }
      child = instance_create( mod, dutname, FALSE, FALSE, FALSE, NULL );
      child->parent = parent;
      if( parent->child_head == NULL ) {
        parent->child_head       = child;
        parent->child_tail       = child;
      } else {
        parent->child_tail->next = child;
        parent->child_tail       = child;
      }
      // (void)inst_link_add( instance_create( mod, dutname, FALSE, FALSE, FALSE, NULL ), &(db_list[curr_db]->inst_head), &(db_list[curr_db]->inst_tail) );
      db_list[curr_db]->leading_hierarchies = (char**)realloc_safe( db_list[curr_db]->leading_hierarchies, (sizeof( char* ) * db_list[curr_db]->leading_hier_num), (sizeof( char* ) * (db_list[curr_db]->leading_hier_num + 1)) );
      db_list[curr_db]->leading_hierarchies[db_list[curr_db]->leading_hier_num] = strdup_safe( lhier );
      db_list[curr_db]->leading_hier_num++;
    }
  }

}

---

Variable Documentation

unsigned int curr_db

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

func_unit* curr_funit

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

db** db_list

Array of database pointers storing all currently loaded databases.

unsigned int db_size

Size of the db_list array.

Referenced by db_close(), db_create(), and report_read_cdd_and_ready().

str_link* extensions_head = NULL [static]

Pointer to head element of extensions list

str_link* extensions_tail = NULL [static]

Pointer to tail element of extensions list

unsigned int flag_global_generation

Specifies the supported global generation value

func_unit* global_funit

Pointer to the global function unit that is available in SystemVerilog.

str_link* inc_paths_head = NULL

Pointer to head element of include paths list

str_link* inc_paths_tail = NULL [static]

Pointer to tail element of include paths list

str_link* no_score_head = NULL

Pointer to head element of functional units not-to-score list

str_link* no_score_tail = NULL [static]

Pointer to tail element of functional units not-to-score list

char* top_instance

Name of top-level instance name

char* top_module

Name of top-level module to score

str_link* use_files_head = NULL

Pointer to head element of used files list

str_link* use_files_tail = NULL [static]

Pointer to tail element of used files list

char user_msg[USER_MSG_LENGTH]

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