instance.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "arc.h"
#include "db.h"
#include "defines.h"
#include "expr.h"
#include "func_unit.h"
#include "gen_item.h"
#include "instance.h"
#include "link.h"
#include "param.h"
#include "static.h"
#include "util.h"

Functions
static bool	instance_resolve_inst (funit_inst *, funit_inst *)
static void	instance_dealloc_single (funit_inst *)
static void	instance_display_tree_helper (funit_inst *root, char *prefix)
void	instance_display_tree (funit_inst *root)
	Displays the current state of the instance tree.
funit_inst *	instance_create (func_unit *funit, char *inst_name, bool name_diff, bool ignore, bool gend_scope, vector_width *range)
	Creates a new instance with the given information.
void	instance_gen_scope (char *scope, funit_inst *leaf, bool flatten)
	Builds full hierarchy from leaf node to root.
static bool	instance_compare (char *inst_name, const funit_inst *inst)
funit_inst *	instance_find_scope (funit_inst *root, char *scope, bool rm_unnamed)
	Finds specified scope in functional unit instance tree.
funit_inst *	instance_find_by_funit (funit_inst *root, const func_unit *funit, int *ignore)
	Returns instance that points to specified functional unit for each instance.
static void	instance_find_by_funit_name (funit_inst *root, const char *funit_name, funit_inst **match_inst, unsigned int *matches)
static funit_inst *	instance_find_by_funit_name_if_one (funit_inst *root, const char *funit_name)
vsignal *	instance_find_signal_by_exclusion_id (funit_inst *root, int id, func_unit **found_funit)
	Returns signal that matches the given exclusion ID.
expression *	instance_find_expression_by_exclusion_id (funit_inst *root, int id, func_unit **found_funit)
	Returns expression that matches the given exclusion ID.
int	instance_find_fsm_arc_index_by_exclusion_id (funit_inst *root, int id, fsm_table **found_fsm, func_unit **found_funit)
	Returns FSM that matches the given exclusion ID.
static funit_inst *	instance_add_child (funit_inst *inst, func_unit *child, char *name, vector_width *range, bool resolve, bool ignore_child, bool gend_scope)
static funit_inst *	instance_copy_helper (funit_inst *from_inst, funit_inst *to_inst, char *name, vector_width *range, bool resolve, bool is_root)
funit_inst *	instance_copy (funit_inst *from_inst, funit_inst *to_inst, char *name, vector_width *range, bool resolve)
	Copies the given from_inst as a child of the given to_inst.
bool	instance_parse_add (funit_inst **root, func_unit *parent, func_unit *child, char *inst_name, vector_width *range, bool resolve, bool child_gend, bool ignore_child, bool gend_scope)
	Adds new instance to specified instance tree during parse.
static void	instance_resolve_helper (funit_inst *root, funit_inst *curr)
void	instance_resolve (funit_inst *root)
	Resolves all instance arrays.
bool	instance_read_add (funit_inst **root, char *parent, func_unit *child, char *inst_name)
	Adds new instance to specified instance tree during CDD read.
static bool	instance_merge_tree (funit_inst *root1, funit_inst *root2)
void	instance_get_leading_hierarchy (funit_inst *root, char *leading_hierarchy, funit_inst **top_inst)
	Gets the leading hierarchy scope and instance for a particular instance tree.
static void	instance_mark_lhier_diffs (funit_inst *root1, funit_inst *root2)
bool	instance_merge_two_trees (funit_inst *root1, funit_inst *root2)
	Performs complex instance tree merging for two instance trees.
void	instance_db_write (funit_inst *root, FILE *file, char *scope, bool parse_mode, bool issue_ids)
	Displays contents of functional unit instance tree to specified file.
void	instance_only_db_read (char **line)
	Reads in and handles an instance-only line from the database.
void	instance_only_db_merge (char **line)
	Reads in and merges an instance-only line from the database.
void	instance_remove_stmt_blks_calling_stmt (funit_inst *root, statement *stmt)
	Removes all statement blocks that contain expressions that call the given statement.
void	instance_remove_parms_with_expr (funit_inst *root, statement *stmt)
	Removes expressions from instance parameters within the given instance that match the given expression.
void	instance_output_dumpvars (FILE *vfile, funit_inst *root)
	Outputs dumpvars to the given file for the given instance.
void	instance_dealloc_tree (funit_inst *root)
	Recursively deallocates all memory for the associated instance tree.
void	instance_dealloc (funit_inst *root, char *scope)
	Removes specified instance from tree.
Variables
int	curr_expr_id
db **	db_list
unsigned int	curr_db
char	user_msg [USER_MSG_LENGTH]
bool	debug_mode
int	curr_sig_id = 1

---

Detailed Description

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

3/11/2002

---

Function Documentation

static funit_inst* instance_add_child	(	funit_inst *	inst,
		func_unit *	child,
		char *	name,
		vector_width *	range,
		bool	resolve,
		bool	ignore_child,
		bool	gend_scope
	)			[static]

Returns:

Returns pointer to newly created functional unit instance if this instance name isn't already in use in the current instance; otherwise, returns NULL.

Generates new instance, adds it to the child list of the inst functional unit instance, and resolves any parameters.

Parameters:

	inst	Pointer to instance to add child instance to
	child	Pointer to child functional unit to create instance for
	name	Name of instance to add
	range	For arrays of instances, contains the range of the instance array
	resolve	Set to TRUE if newly added instance should be immediately resolved
	ignore_child	Set to TRUE if the child to be added should not be written to a CDD file
	gend_scope	Set to TRUE if the child scope is a generated scope

References funit_inst_s::child_head, funit_inst_s::child_tail, curr_db, FALSE, funit_inst_s::funit, funit_inst_s::ignore, inst_link_s::inst, db_s::inst_head, instance_create(), instance_resolve_inst(), funit_inst_s::name, inst_link_s::next, funit_inst_s::next, funit_inst_s::parent, PROFILE, PROFILE_END, and funit_inst_s::suppl.

Referenced by instance_copy_helper(), and instance_parse_add().

  { PROFILE(INSTANCE_ADD_CHILD);

  funit_inst* new_inst;  /* Pointer to newly created instance to add */

  /* Check to see if this instance already exists */
  new_inst = inst->child_head;
  while( (new_inst != NULL) && ((strcmp( new_inst->name, name ) != 0) || (new_inst->funit != child)) ) {
    new_inst = new_inst->next;
  }

  /* If this instance already exists (unless the existing and new child is a placeholder), don't add it again */
  if( (new_inst == NULL) || (new_inst->suppl.ignore && ignore_child) ) {

    /* Generate new instance */
    new_inst = instance_create( child, name, FALSE, ignore_child, gend_scope, range );

    /* Add new instance to inst child instance list */
    if( inst->child_head == NULL ) {
      inst->child_head       = new_inst;
      inst->child_tail       = new_inst;
    } else {
      inst->child_tail->next = new_inst;
      inst->child_tail       = new_inst;
    }

    /* Point this instance's parent pointer to its parent */
    new_inst->parent = inst;

    // inst_link_display( db_list[curr_db]->inst_head );

    /* If the new instance needs to be resolved now, do so */
    if( resolve ) {
      inst_link* instl = db_list[curr_db]->inst_head;
      while( (instl != NULL) && !instance_resolve_inst( instl->inst, new_inst ) ) {
        instl = instl->next;
      }
    }

  } else {

    /* Set the ignore value in the instance to FALSE */
    new_inst->suppl.ignore = FALSE;

    new_inst = NULL;

  }

  PROFILE_END;

  return( new_inst );

}

static bool instance_compare	(	char *	inst_name,
		const funit_inst *	inst
	)			[static]

Returns:

Returns TRUE if the given instance name and instance match. If the specified instance is a part of an array of instances and the base name matches the base name of inst_name, we also check to make sure that the index of inst_name falls within the legal range of this instance.

Parameters:

	inst_name	Instance name to compare to this instance's name (may contain array information)
	inst	Pointer to instance to compare name against

References FALSE, vector_width_s::left, funit_inst_s::name, PROFILE, PROFILE_END, funit_inst_s::range, vector_width_s::right, scope_compare(), and static_expr_calc_lsb_and_width_post().

Referenced by instance_find_scope().

  { PROFILE(INSTANCE_COMPARE);

  bool         retval = FALSE;  /* Return value of this function */
  char         bname[4096];     /* Base name of inst_name */
  int          index;           /* Index of inst_name */
  unsigned int width;           /* Width of instance range */
  int          lsb;             /* LSB of instance range */
  int          big_endian;      /* Specifies endianness */

  /* If this instance has a range, handle it */
  if( inst->range != NULL ) {

    /* Extract the index portion of inst_name if there is one */
    if( sscanf( inst_name, "%[a-zA-Z0-9_]\[%d]", bname, &index ) == 2 ) {
      
      /* If the base names compare, check that the given index falls within this instance range */
      if( scope_compare( bname, inst->name ) ) {

        /* Get range information from instance */
        static_expr_calc_lsb_and_width_post( inst->range->left, inst->range->right, &width, &lsb, &big_endian );
        assert( width != 0 );
        assert( lsb   != -1 );

        retval = (index >= lsb) && (index < (lsb + (int)width));

      }
      
    }

  } else {

    retval = scope_compare( inst_name, inst->name );

  }

  PROFILE_END;

  return( retval );

}

funit_inst* instance_copy	(	funit_inst *	from_inst,
		funit_inst *	to_inst,
		char *	name,
		vector_width *	range,
		bool	resolve
	)

Copies the given from_inst as a child of the given to_inst.

Recursively copies the instance tree of from_inst to the instance to_inst, allocating memory for the new instances and resolving parameters.

Parameters:

	from_inst	Pointer to instance tree to copy
	to_inst	Pointer to instance to copy tree to
	name	Instance name of current instance being copied
	range	For arrays of instances, indicates the array range
	resolve	Set to TRUE if newly added instance should be immediately resolved

References instance_copy_helper(), PROFILE, PROFILE_END, and TRUE.

Referenced by gen_item_resolve(), and instance_parse_add().

  { PROFILE(INSTANCE_COPY);

  funit_inst* new_inst;

  new_inst = instance_copy_helper( from_inst, to_inst, name, range, resolve, TRUE );

  PROFILE_END;

  return( new_inst );

}

static funit_inst* instance_copy_helper	(	funit_inst *	from_inst,
		funit_inst *	to_inst,
		char *	name,
		vector_width *	range,
		bool	resolve,
		bool	is_root
	)			[static]

Recursively copies the instance tree of from_inst to the instance to_inst, allocating memory for the new instances and resolving parameters.

Parameters:

	from_inst	Pointer to instance tree to copy
	to_inst	Pointer to instance to copy tree to
	name	Instance name of current instance being copied
	range	For arrays of instances, indicates the array range
	resolve	Set to TRUE if newly added instance should be immediately resolved
	is_root	Set to TRUE if the from_inst is the root instance

References funit_inst_s::child_head, FALSE, funit_inst_s::funit, funit_inst_s::gend_scope, funit_inst_s::ignore, instance_add_child(), funit_inst_s::name, funit_inst_s::next, PROFILE, PROFILE_END, funit_inst_s::range, and funit_inst_s::suppl.

Referenced by instance_copy().

  { PROFILE(INSTANCE_COPY_HELPER);

  funit_inst* curr;      /* Pointer to current functional unit instance to copy */
  funit_inst* new_inst;  /* Pointer to newly created functional unit instance */

  assert( from_inst != NULL );
  assert( to_inst   != NULL );
  assert( name      != NULL );

  /* Add new child instance */
  new_inst = instance_add_child( to_inst, from_inst->funit, name, range, resolve, (from_inst->suppl.ignore && from_inst->suppl.gend_scope && !is_root), from_inst->suppl.gend_scope );

  /* Do not add children if no child instance was created */
  if( new_inst != NULL ) {

    /* Iterate through rest of current child's list of children */
    curr = from_inst->child_head;
    while( curr != NULL ) {
      (void)instance_copy_helper( curr, new_inst, curr->name, curr->range, resolve, FALSE );
      curr = curr->next;
    }

  }

  PROFILE_END;

  return( new_inst );

}

funit_inst* instance_create	(	func_unit *	funit,
		char *	inst_name,
		bool	name_diff,
		bool	ignore,
		bool	gend_scope,
		vector_width *	range
	)

Creates a new instance with the given information.

Returns:

Returns pointer to newly created functional unit instance.

Creates a new functional unit instance from heap, initializes its data and returns a pointer to it.

Parameters:

	funit	Pointer to functional unit to store in this instance
	inst_name	Instantiated name of this instance
	name_diff	Specifies if the inst_name provided is not accurate due to merging
	ignore	Specifies that this instance is just a placeholder, not to be written to CDD
	gend_scope	Specifies if this instance is a generated scope
	range	For arrays of instances, contains range information for this array

References funit_inst_s::child_head, funit_inst_s::child_tail, static_expr_s::exp, funit_inst_s::funit, funit_inst_s::gend_scope, funit_inst_s::gitem_head, funit_inst_s::gitem_tail, funit_inst_s::ignore, vector_width_s::left, malloc_safe, funit_inst_s::name, funit_inst_s::name_diff, funit_inst_s::next, static_expr_s::num, funit_inst_s::param_head, funit_inst_s::param_tail, funit_inst_s::parent, PROFILE, PROFILE_END, funit_inst_s::range, vector_width_s::right, funit_inst_s::stat, strdup_safe, and funit_inst_s::suppl.

Referenced by db_add_instance(), db_read(), instance_add_child(), instance_only_db_merge(), instance_only_db_read(), instance_parse_add(), instance_read_add(), and search_init().

  { PROFILE(INSTANCE_CREATE);

  funit_inst* new_inst;  /* Pointer to new functional unit instance */

  new_inst                   = (funit_inst*)malloc_safe( sizeof( funit_inst ) );
  new_inst->funit            = funit;
  new_inst->name             = strdup_safe( inst_name );
  new_inst->suppl.name_diff  = name_diff;
  new_inst->suppl.ignore     = ignore;
  new_inst->suppl.gend_scope = gend_scope;
  new_inst->stat             = NULL;
  new_inst->param_head       = NULL;
  new_inst->param_tail       = NULL;
  new_inst->gitem_head       = NULL;
  new_inst->gitem_tail       = NULL;
  new_inst->parent           = NULL;
  new_inst->child_head       = NULL;
  new_inst->child_tail       = NULL;
  new_inst->next             = NULL;

  /* Create range (get a copy since this memory is managed by the parser) */
  if( range == NULL ) {
    new_inst->range = NULL;
  } else {
    assert( range->left  != NULL );
    assert( range->right != NULL );
    new_inst->range             = (vector_width*)malloc_safe( sizeof( vector_width ) );
    new_inst->range->left       = (static_expr*)malloc_safe( sizeof( static_expr ) );
    new_inst->range->left->num  = range->left->num;
    new_inst->range->left->exp  = range->left->exp;
    new_inst->range->right      = (static_expr*)malloc_safe( sizeof( static_expr ) );
    new_inst->range->right->num = range->right->num;
    new_inst->range->right->exp = range->right->exp;
  }

  PROFILE_END;

  return( new_inst );

}

void instance_db_write	(	funit_inst *	root,
		FILE *	file,
		char *	scope,
		bool	parse_mode,
		bool	issue_ids
	)

Displays contents of functional unit instance tree to specified file.

Exceptions:

anonymous

gen_item_assign_expr_ids instance_db_write funit_db_write

Calls each functional unit display function in instance tree, starting with the root functional unit and ending when all of the leaf functional units are output. Note: the function that calls this function originally should set the value of scope to NULL.

Parameters:

	root	Root of functional unit instance tree to write
	file	Output file to display contents to
	scope	Scope of this functional unit
	parse_mode	Specifies if we are parsing or scoring
	issue_ids	Specifies that we need to issue expression and signal IDs

References funit_inst_s::child_head, curr_expr_id, curr_sig_id, DB_TYPE_INST_ONLY, exp_link_s::exp, func_unit_s::exp_head, FALSE, funit_inst_s::funit, funit_db_write(), FUNIT_NO_SCORE, gen_item_assign_ids(), gitem_link_s::gi, funit_inst_s::gitem_head, vsignal_s::id, funit_inst_s::ignore, instance_db_write(), funit_inst_s::name, funit_inst_s::name_diff, funit_inst_s::next, gitem_link_s::next, sig_link_s::next, exp_link_s::next, PROFILE, PROFILE_END, sig_link_s::sig, func_unit_s::sig_head, funit_inst_s::suppl, TRUE, func_unit_s::type, and expression_s::ulid.

Referenced by db_write(), and instance_db_write().

  { PROFILE(INSTANCE_DB_WRITE);

  bool stop_recursive = FALSE;

  assert( root != NULL );

  if( root->funit != NULL ) {

    if( (root->funit->type != FUNIT_NO_SCORE) && !root->suppl.ignore ) {

      funit_inst* curr = parse_mode ? root : NULL;

      assert( scope != NULL );

      /* If we are in parse mode, re-issue expression IDs (we use the ulid field since it is not used in parse mode) */
      if( issue_ids && (root->funit != NULL) ) {

        exp_link*   expl;
        sig_link*   sigl;
#ifndef VPI_ONLY
        gitem_link* gil;
#endif

        /* First issue IDs to the expressions within the functional unit */
        expl = root->funit->exp_head;
        while( expl != NULL ) {
          expl->exp->ulid = curr_expr_id;
          curr_expr_id++;
          expl = expl->next;
        }

        sigl = root->funit->sig_head;
        while( sigl != NULL ) {
          sigl->sig->id = curr_sig_id;
          curr_sig_id++;
          sigl = sigl->next;
        }
    
#ifndef VPI_ONLY
        /* Then issue IDs to any generated expressions/signals */
        gil = root->gitem_head;
        while( gil != NULL ) {
          gen_item_assign_ids( gil->gi, root->funit );
          gil = gil->next;
        }
#endif

      }

      /* Display root functional unit */
      funit_db_write( root->funit, scope, root->suppl.name_diff, file, curr, issue_ids );

    } else {

      stop_recursive = TRUE;

    }

  } else {

    /*@-formatcode@*/
    fprintf( file, "%d %s %hhu\n", DB_TYPE_INST_ONLY, scope, root->suppl.name_diff );
    /*@=formatcode@*/

  }

  if( !stop_recursive ) {
 
    char tscope[4096];

    /* Display children */
    funit_inst* curr = root->child_head;
    while( curr != NULL ) {
      unsigned int rv = snprintf( tscope, 4096, "%s.%s", scope, curr->name );
      assert( rv < 4096 );
      instance_db_write( curr, file, tscope, parse_mode, issue_ids );
      curr = curr->next;
    }

  }

  PROFILE_END;

}

void instance_dealloc	(	funit_inst *	root,
		char *	scope
	)

Removes specified instance from tree.

Searches tree for specified functional unit. If the functional unit instance is found, the functional unit instance is removed from the tree along with all of its child functional unit instances.

Parameters:

	root	Root of functional unit instance tree
	scope	Scope of functional unit to remove from tree

References funit_inst_s::child_head, funit_inst_s::child_tail, instance_dealloc_tree(), instance_find_scope(), funit_inst_s::name, funit_inst_s::next, PROFILE, PROFILE_END, scope_compare(), scope_extract_back(), and TRUE.

Referenced by inst_link_delete_list().

  { PROFILE(INSTANCE_DEALLOC);
  
  funit_inst* inst;        /* Pointer to instance to remove */
  funit_inst* curr;        /* Pointer to current child instance to remove */
  funit_inst* last;        /* Last current child instance */
  char        back[256];   /* Highest level of hierarchy in hierarchical reference */
  char        rest[4096];  /* Rest of scope value */
  
  assert( root  != NULL );
  assert( scope != NULL );
  
  if( scope_compare( root->name, scope ) ) {
    
    /* We are the root so just remove the whole tree */
    instance_dealloc_tree( root );
    
  } else {
    
    /* 
     Find parent instance of given scope and remove this instance
     from its child list.
    */  
    scope_extract_back( scope, back, rest );
    assert( rest[0] != '\0' );

    inst = instance_find_scope( root, rest, TRUE );
    assert( inst != NULL );

    curr = inst->child_head;
    last = NULL;
    while( (curr != NULL) && !scope_compare( curr->name, scope ) ) {
      last = curr;
      curr = curr->next;
    }

    if( curr != NULL ) {
      if( last != NULL ) {
        last->next = curr->next;
      }
      if( curr == inst->child_head ) {
        /* Move parent head pointer */
        inst->child_head = curr->next;
      }
      if( curr == inst->child_tail ) {
        /* Move parent tail pointer */
        inst->child_tail = last;
      }
    }

    instance_dealloc_tree( curr );

  }

  PROFILE_END;

}

void instance_dealloc_single

(

funit_inst *

inst

)

[static]

Deallocates all memory allocated for the given instance.

Parameters:

inst

Pointer to instance to deallocate memory for

References FALSE, free_safe, funit_inst_s::gitem_head, gitem_link_delete_list(), inst_parm_dealloc(), vector_width_s::left, funit_inst_s::name, funit_inst_s::param_head, PROFILE, PROFILE_END, funit_inst_s::range, vector_width_s::right, funit_inst_s::stat, static_expr_dealloc(), and TRUE.

Referenced by instance_dealloc_tree().

  { PROFILE(INSTANCE_DEALLOC_SINGLE);

  if( inst != NULL ) {

    /* Free up memory allocated for name */
    free_safe( inst->name, (strlen( inst->name ) + 1) );

    /* Free up memory allocated for statistic, if necessary */
    free_safe( inst->stat, sizeof( statistic ) );

    /* Free up memory for range, if necessary */
    if( inst->range != NULL ) {
      static_expr_dealloc( inst->range->left,  FALSE );
      static_expr_dealloc( inst->range->right, FALSE );
      free_safe( inst->range, sizeof( vector_width ) );
    }

    /* Deallocate memory for instance parameter list */
    inst_parm_dealloc( inst->param_head, TRUE );

#ifndef VPI_ONLY
    /* Deallocate memory for generate item list */
    gitem_link_delete_list( inst->gitem_head, FALSE );
#endif

    /* Free up memory for this functional unit instance */
    free_safe( inst, sizeof( funit_inst ) );

  }

  PROFILE_END;

}

void instance_dealloc_tree

(

funit_inst *

root

)

Recursively deallocates all memory for the associated instance tree.

Recursively traverses instance tree, deallocating heap memory used to store the the tree.

Parameters:

root

Pointer to root instance of functional unit instance tree to remove

References funit_inst_s::child_head, instance_dealloc_single(), instance_dealloc_tree(), funit_inst_s::next, PROFILE, and PROFILE_END.

Referenced by gen_item_dealloc(), instance_dealloc(), and instance_dealloc_tree().

  { PROFILE(INSTANCE_DEALLOC_TREE);

  funit_inst* curr;  /* Pointer to current instance to evaluate */
  funit_inst* tmp;   /* Temporary pointer to instance */

  if( root != NULL ) {

    /* Remove instance's children first */
    curr = root->child_head;
    while( curr != NULL ) {
      tmp = curr->next;
      instance_dealloc_tree( curr );
      curr = tmp;
    }

    /* Deallocate the instance memory */
    instance_dealloc_single( root );

  }

  PROFILE_END;

}

void instance_display_tree

(

funit_inst *

root

)

Displays the current state of the instance tree.

Displays the given instance tree to standard output in a hierarchical format. Shows instance names as well as associated module name.

Parameters:

root

Pointer to root instance to display

References instance_display_tree_helper(), PROFILE, and PROFILE_END.

Referenced by inst_link_display().

  { PROFILE(INSTANCE_DISPLAY_TREE);

  instance_display_tree_helper( root, "" );

  PROFILE_END;

}

static void instance_display_tree_helper	(	funit_inst *	root,
		char *	prefix
	)			[static]

Helper function for the instance_display_tree function.

Parameters:

	root	Pointer to functional unit instance to display
	prefix	Prefix string to be used when outputting (used to indent children)

References funit_inst_s::child_head, free_safe, funit_inst_s::funit, funit_inst_s::gend_scope, funit_inst_s::ignore, func_unit_s::name, funit_inst_s::name, funit_inst_s::next, PROFILE, PROFILE_END, scope_gen_printable(), and funit_inst_s::suppl.

Referenced by instance_display_tree().

  { PROFILE(INSTANCE_DISPLAY_TREE_HELPER);

  char         sp[4096];  /* Contains prefix for children */
  funit_inst*  curr;      /* Pointer to current child instance */
  unsigned int rv;        /* Return value from snprintf calls */

  assert( root != NULL );

  /* Get printable version of this instance and functional unit name */
  if( root->funit != NULL ) {
    char* piname = scope_gen_printable( root->name );
    char* pfname = scope_gen_printable( root->funit->name );
    /*@-formatcode@*/
    printf( "%s%s (%s) - %p (ign: %hhu, gend: %hhu)\n", prefix, piname, pfname, root, root->suppl.ignore, root->suppl.gend_scope );
    /*@=formatcode@*/
    free_safe( piname, (strlen( piname ) + 1) );
    free_safe( pfname, (strlen( pfname ) + 1) );
  } else {
    char* piname = scope_gen_printable( root->name );
    /*@-formatcode@*/
    printf( "%s%s () - %p (ign: %hhu, gend: %hhu)\n", prefix, piname, root, root->suppl.ignore, root->suppl.gend_scope );
    /*@=formatcode@*/
    free_safe( piname, (strlen( piname ) + 1) );
  }

  /* Calculate prefix */
  rv = snprintf( sp, 4096, "%s   ", prefix );
  assert( rv < 4096 );

  /* Display our children */
  curr = root->child_head;
  while( curr != NULL ) {
    instance_display_tree_helper( curr, sp );
    curr = curr->next;
  }


  PROFILE_END;

}

funit_inst* instance_find_by_funit	(	funit_inst *	root,
		const func_unit *	funit,
		int *	ignore
	)

Returns instance that points to specified functional unit for each instance.

Returns:

Returns pointer to functional unit instance found by scope.

Searches the specified functional unit instance tree for the specified functional unit. When a functional unit instance is found that points to the specified functional unit and the ignore value is 0, a pointer to that functional unit instance is passed back to the calling function; otherwise, the ignore count is decremented and the searching continues.

Parameters:

	root	Pointer to root functional unit instance of tree
	funit	Pointer to functional unit to find in tree
	ignore	Pointer to number of matches to ignore

References funit_inst_s::child_head, funit_inst_s::funit, instance_find_by_funit(), funit_inst_s::next, PROFILE, and PROFILE_END.

Referenced by inst_link_find_by_funit(), instance_find_by_funit(), instance_parse_add(), and param_expr_eval().

  { PROFILE(INSTANCE_FIND_BY_FUNIT);

  funit_inst* match_inst = NULL;  /* Pointer to functional unit instance that found a match */
  funit_inst* curr_child;         /* Pointer to current instances child functional unit instance */

  if( root != NULL ) {

    if( root->funit == funit ) {

      if( *ignore == 0 ) {
        match_inst = root;
      } else {
        (*ignore)--;
      }

    } else {

      curr_child = root->child_head;
      while( (curr_child != NULL) && (match_inst == NULL) ) {
        match_inst = instance_find_by_funit( curr_child, funit, ignore );
        curr_child = curr_child->next;
      }

    }
    
  }

  PROFILE_END;

  return( match_inst );

}

static void instance_find_by_funit_name	(	funit_inst *	root,
		const char *	funit_name,
		funit_inst **	match_inst,
		unsigned int *	matches
	)			[static]

Recursively searches the given instance tree, setting match_inst and matches if a matched functional unit name was found.

Parameters:

	root	Pointer to root functional unit instance to search
	funit_name	Name of module to find
	match_inst	Pointer to matched functional unit instance
	matches	Specifies the number of matched modules

References funit_inst_s::child_head, funit_inst_s::funit, func_unit_s::name, funit_inst_s::next, PROFILE, and PROFILE_END.

Referenced by instance_find_by_funit_name_if_one().

  { PROFILE(INSTANCE_FIND_BY_FUNIT_NAME_IF_ONE_HELPER);

  if( root != NULL ) {

    funit_inst* child;

    if( strcmp( root->funit->name, funit_name ) == 0 ) {
      (*matches)++;
      *match_inst = root;
    }

    child = root->child_head;
    while( child != NULL ) {
      instance_find_by_funit_name( child, funit_name, match_inst, matches );
      child = child->next;
    }

  }

  PROFILE_END;

}

static funit_inst* instance_find_by_funit_name_if_one	(	funit_inst *	root,
		const char *	funit_name
	)			[static]

Returns:

Returns a pointer to the found instance, if one exists; otherwise, returns NULL.

Parameters:

	root	Pointer to root functional unit instance to search
	funit_name	Name of module to find

References instance_find_by_funit_name(), PROFILE, and PROFILE_END.

Referenced by instance_merge_two_trees().

  { PROFILE(INSTANCE_FIND_BY_FUNIT_NAME_IF_ONE);

  funit_inst*  match_inst = NULL;
  unsigned int matches    = 0;

  instance_find_by_funit_name( root, funit_name, &match_inst, &matches );

  PROFILE_END;

  return( (matches == 1) ? match_inst : NULL );

}

expression* instance_find_expression_by_exclusion_id	(	funit_inst *	root,
		int	id,
		func_unit **	found_funit
	)

Returns expression that matches the given exclusion ID.

Returns:

Returns the pointer to the expression that contains the same exclusion ID.

Recursively searches the given instance tree to find the expression that has the same exclusion ID as the one specified.

Parameters:

	root	Pointer to root instance
	id	Exclusion ID to search for
	found_funit	Pointer to functional unit containing this expression

References funit_inst_s::child_head, exp_link_s::exp, func_unit_s::exp_head, func_unit_s::exp_tail, funit_inst_s::funit, expression_s::id, instance_find_expression_by_exclusion_id(), funit_inst_s::next, exp_link_s::next, PROFILE, and PROFILE_END.

Referenced by exclude_find_expression(), and instance_find_expression_by_exclusion_id().

  { PROFILE(INSTANCE_FIND_EXPRESSION_BY_EXCLUSION_ID); 
    
  expression* exp = NULL;  /* Pointer to found expression */
    
  if( root != NULL ) {

    if( (root->funit != NULL) &&
        (root->funit->exp_head != NULL) && 
        (root->funit->exp_head->exp->id <= id) && 
        (root->funit->exp_tail->exp->id >= id) ) {

      exp_link* expl = root->funit->exp_head;

      while( (expl != NULL) && (expl->exp->id != id) ) {
        expl = expl->next;           
      }
      assert( expl != NULL );
      assert( expl->exp != NULL );
      exp          = expl->exp;
      *found_funit = root->funit;

    } else {

      funit_inst* child = root->child_head;
      while( (child != NULL) && ((exp = instance_find_expression_by_exclusion_id( child, id, found_funit )) == NULL) ) {
        child = child->next;
      }

    }
    
  }
  
  PROFILE_END; 
  
  return( exp );
  
}

int instance_find_fsm_arc_index_by_exclusion_id	(	funit_inst *	root,
		int	id,
		fsm_table **	found_fsm,
		func_unit **	found_funit
	)

Returns FSM that matches the given exclusion ID.

Returns:

Returns the index of the state transition in the arcs array of the found_fsm in the found_funit that matches the given exclusion ID (if one is found); otherwise, returns -1.

References arc_find_arc_by_exclusion_id(), funit_inst_s::child_head, func_unit_s::fsm_head, funit_inst_s::funit, instance_find_fsm_arc_index_by_exclusion_id(), funit_inst_s::next, fsm_link_s::next, PROFILE, PROFILE_END, fsm_s::table, and fsm_link_s::table.

Referenced by exclude_find_fsm_arc(), and instance_find_fsm_arc_index_by_exclusion_id().

  { PROFILE(INSTANCE_FIND_FSM_ARC_INDEX_BY_EXCLUSION_ID);

  int arc_index = -1;  /* Index of found FSM arc */

  if( root != NULL ) {

    fsm_link* fsml;

    if( root->funit != NULL ) {
      fsml = root->funit->fsm_head;
      while( (fsml != NULL) && ((arc_index = arc_find_arc_by_exclusion_id( fsml->table->table, id )) == -1) ) {
        fsml = fsml->next;
      }
    }

    if( arc_index != -1 ) {
      *found_fsm   = fsml->table->table;
      *found_funit = root->funit;
    } else {
      funit_inst* child = root->child_head;
      while( (child != NULL) && ((arc_index = instance_find_fsm_arc_index_by_exclusion_id( child, id, found_fsm, found_funit )) == -1) ) {
        child = child->next;
      }
    }

  }

  PROFILE_END;

  return( arc_index );

}

funit_inst* instance_find_scope	(	funit_inst *	root,
		char *	scope,
		bool	rm_unnamed
	)

Finds specified scope in functional unit instance tree.

Returns:

Returns pointer to functional unit instance found by scope.

Searches the specified functional unit instance tree for the specified scope. When the functional unit instance is found, a pointer to that functional unit instance is passed back to the calling function.

Parameters:

	root	Root of funit_inst tree to parse for scope
	scope	Scope to search for
	rm_unnamed	Set to TRUE if we need to remove unnamed scopes

References funit_inst_s::child_head, db_is_unnamed_scope(), funit_inst_s::funit, funit_is_unnamed(), instance_compare(), instance_find_scope(), funit_inst_s::name, funit_inst_s::next, PROFILE, PROFILE_END, and scope_extract_front().

Referenced by gen_item_resolve(), inst_link_find_by_scope(), instance_dealloc(), instance_find_scope(), instance_read_add(), scope_find_funit_from_scope(), scope_get_parent_funit(), and scope_get_parent_module().

  { PROFILE(INSTANCE_FIND_SCOPE);
 
  char        front[256];   /* Front of scope value */
  char        rest[4096];   /* Rest of scope value */
  funit_inst* inst = NULL;  /* Pointer to found instance */
  funit_inst* child;        /* Pointer to current child instance being traversed */

  assert( root != NULL );

  /* First extract the front scope */
  scope_extract_front( scope, front, rest );

  /* Skip this instance and move onto the children if we are an unnamed scope that does not contain signals */
  if( !rm_unnamed && db_is_unnamed_scope( root->name ) && !funit_is_unnamed( root->funit ) ) {
    child = root->child_head;
    while( (child != NULL) && ((inst = instance_find_scope( child, scope, rm_unnamed )) == NULL) ) {
      child = child->next;
    }

  /* Keep traversing if our name matches */
  } else if( instance_compare( front, root ) ) {
    if( rest[0] == '\0' ) {
      inst = root;
    } else {
      child = root->child_head;
      while( (child != NULL) && ((inst = instance_find_scope( child, rest, rm_unnamed )) == NULL) ) {
        child = child->next;
      }
    }
  }

  PROFILE_END;

  return( inst );

}

vsignal* instance_find_signal_by_exclusion_id	(	funit_inst *	root,
		int	id,
		func_unit **	found_funit
	)

Returns signal that matches the given exclusion ID.

Returns:

Returns the pointer to the signal that contains the same exclusion ID.

Recursively searches the given instance tree to find the signal that has the same exclusion ID as the one specified.

Parameters:

	root	Pointer to root instance
	id	Exclusion ID to search for
	found_funit	Pointer to functional unit containing this signal

References funit_inst_s::child_head, funit_inst_s::funit, vsignal_s::id, instance_find_signal_by_exclusion_id(), funit_inst_s::next, sig_link_s::next, PROFILE, PROFILE_END, sig_link_s::sig, func_unit_s::sig_head, and func_unit_s::sig_tail.

Referenced by exclude_find_signal(), and instance_find_signal_by_exclusion_id().

  { PROFILE(INSTANCE_FIND_SIGNAL_BY_EXCLUSION_ID);
 
  vsignal* sig = NULL;  /* Pointer to found signal */

  if( root != NULL ) {

    if( (root->funit != NULL) &&
        (root->funit->sig_head != NULL) &&
        (root->funit->sig_head->sig->id <= id) &&
        (root->funit->sig_tail->sig->id >= id) ) {

      sig_link* sigl = root->funit->sig_head;

      while( (sigl != NULL) && (sigl->sig->id != id) ) {
        sigl = sigl->next;
      }
      assert( sigl != NULL );
      assert( sigl->sig != NULL );
      sig          = sigl->sig;
      *found_funit = root->funit;

    } else {

      funit_inst* child = root->child_head;
      while( (child != NULL) && ((sig = instance_find_signal_by_exclusion_id( child, id, found_funit )) == NULL) ) {
        child = child->next;
      }

    }
    
  }

  PROFILE_END;

  return( sig );

}

void instance_gen_scope	(	char *	scope,
		funit_inst *	leaf,
		bool	flatten
	)

Builds full hierarchy from leaf node to root.

Recursively travels up to the root of the instance tree, building the scope string as it goes. When the root instance is reached, the string is returned. Assumes that scope is initialized to the NULL character.

Parameters:

	scope	String pointer to store generated scope (assumed to be allocated)
	leaf	Pointer to leaf instance in scope
	flatten	Causes all unnamed scopes to be removed from generated scope if set to TRUE

References db_is_unnamed_scope(), instance_gen_scope(), funit_inst_s::name, funit_inst_s::parent, PROFILE, and PROFILE_END.

Referenced by instance_gen_scope(), instance_output_dumpvars(), and param_has_defparam().

  { PROFILE(INSTANCE_GEN_SCOPE);

  if( leaf != NULL ) {

    /* Call parent instance first */
    instance_gen_scope( scope, leaf->parent, flatten );

    if( !flatten || !db_is_unnamed_scope( leaf->name ) ) {
      if( scope[0] != '\0' ) {
        strcat( scope, "." );
        strcat( scope, leaf->name );
      } else {
        strcpy( scope, leaf->name );
      }
    }

  }

  PROFILE_END;

}

void instance_get_leading_hierarchy	(	funit_inst *	root,
		char *	leading_hierarchy,
		funit_inst **	top_inst
	)

Gets the leading hierarchy scope and instance for a particular instance tree.

Retrieves the leading hierarchy string and the pointer to the top-most populated instance given the specified instance tree.

Note:

This function requires that the leading_hierarchy string be previously allocated and initialized to the NULL string.

Parameters:

	root	Pointer to instance tree to get information from
	leading_hierarchy	Leading hierarchy to first populated instance
	top_inst	Pointer to first populated instance

References funit_inst_s::child_head, funit_inst_s::funit, funit_inst_s::name, PROFILE, and PROFILE_END.

Referenced by db_check_for_top_module(), and instance_merge_two_trees().

  { PROFILE(INSTANCE_GET_LEADING_HIERARCHY);

  if( leading_hierarchy != NULL ) {
    strcat( leading_hierarchy, root->name );
  }

  *top_inst = root;

  if( root->funit == NULL ) {

    do {
      root = root->child_head;
      if( leading_hierarchy != NULL ) {
        strcat( leading_hierarchy, "." );
        strcat( leading_hierarchy, root->name );
      }
      *top_inst = root;
    } while( (root != NULL) && (root->funit == NULL) );

  }

  PROFILE_END;

}

static void instance_mark_lhier_diffs	(	funit_inst *	root1,
		funit_inst *	root2
	)			[static]

Iterates up the scope for both functional unit

References funit_inst_s::name, funit_inst_s::name_diff, funit_inst_s::parent, PROFILE, PROFILE_END, funit_inst_s::suppl, and TRUE.

Referenced by instance_merge_two_trees().

  { PROFILE(INSTANCE_MARK_LHIER_DIFFS);

  /* Move up the scope hierarchy looking for a difference in instance names */
  while( (root1 != NULL) && (root2 != NULL) && (strcmp( root1->name, root2->name ) == 0) ) {
    root1 = root1->parent;
    root2 = root2->parent;
  }

  /*
   Iterate up root1 instance, setting the name_diff variable to TRUE to specify that the instance name is really
   not accurate since its child tree with a child tree with a differen parent scope.
  */
  while( root1 != NULL ) {
    root1->suppl.name_diff = TRUE;
    root1 = root1->parent;
  }

  PROFILE_END;

}

static bool instance_merge_tree	(	funit_inst *	root1,
		funit_inst *	root2
	)			[static]

Returns:

Returns TRUE if the instance merge was successful.

Merges to instance trees that have the same instance root.

Parameters:

	root1	Pointer to root of first instance tree to merge
	root2	Pointer to root of second instance tree to merge

References funit_inst_s::child_head, funit_inst_s::child_tail, FALSE, funit_inst_s::funit, funit_merge(), funit_inst_s::name, func_unit_s::name, funit_inst_s::next, funit_inst_s::parent, PROFILE, PROFILE_END, and TRUE.

Referenced by instance_merge_two_trees().

  { PROFILE(INSTANCE_MERGE);

  funit_inst* child2;
  funit_inst* last2  = NULL;
  bool        retval = TRUE;

  /* Perform functional unit merging */
  if( root1->funit != NULL ) {
    if( root2->funit != NULL ) {
      if( strcmp( root1->funit->name, root2->funit->name ) == 0 ) {
        funit_merge( root1->funit, root2->funit );
      } else {
        retval = FALSE;
      }
    }
  } else if( root2->funit != NULL ) {
    root1->funit = root2->funit;
    root2->funit = NULL;
  }

  /* Recursively merge the child instances */
  child2 = root2->child_head;
  while( (child2 != NULL) && retval ) {
    funit_inst* child1 = root1->child_head;
    while( (child1 != NULL) && (strcmp( child1->name, child2->name ) != 0) ) {
      child1 = child1->next;
    }
    if( child1 != NULL ) {
      retval = instance_merge_tree( child1, child2 );
      last2  = child2;
      child2 = child2->next;
    } else {
      funit_inst* tmp = child2->next;
      child2->next   = NULL;
      child2->parent = root1;
      if( root1->child_head == NULL ) {
        root1->child_head = child2;
        root1->child_tail = child2;
      } else {
        root1->child_tail->next = child2;
        root1->child_tail       = child2;
      }
      if( last2 == NULL ) {
        root2->child_head = tmp;
        if( tmp == NULL ) {
          root2->child_tail = NULL;
        }
      } else if( tmp == NULL ) {
        root2->child_tail = last2;
        last2->next = NULL;
      } else {
        last2->next = tmp;
      }
      child2 = tmp;
    }
  }

  PROFILE_END;

  return( retval );

}

bool instance_merge_two_trees	(	funit_inst *	root1,
		funit_inst *	root2
	)

Performs complex instance tree merging for two instance trees.

Returns:

Returns TRUE if the second instance tree should have its link removed from the instance tree list for the current database; otherwise, returns FALSE.

Performs comples merges two instance trees into one instance tree.

Parameters:

	root1	Pointer to first instance tree to merge
	root2	Pointer to second instance tree to merge

References FALSE, funit_inst_s::funit, instance_find_by_funit_name_if_one(), instance_get_leading_hierarchy(), instance_mark_lhier_diffs(), instance_merge_tree(), funit_inst_s::name, func_unit_s::name, PROFILE, PROFILE_END, and TRUE.

Referenced by db_merge_instance_trees().

  { PROFILE(INSTANCE_MERGE_TWO_TREES);

  bool        retval = TRUE;
  char        lhier1[4096];
  char        lhier2[4096];
  funit_inst* tinst1 = NULL;
  funit_inst* tinst2 = NULL;

  lhier1[0] = '\0';
  lhier2[0] = '\0';

  /* Get leading hierarchy information */
  instance_get_leading_hierarchy( root1, lhier1, &tinst1 );
  instance_get_leading_hierarchy( root2, lhier2, &tinst2 );

  /* If the top-level modules are the same, just merge them */
  if( (tinst1->funit != NULL) && (tinst2->funit != NULL) && (strcmp( tinst1->funit->name, tinst2->funit->name ) == 0) ) {

    if( strcmp( lhier1, lhier2 ) == 0 ) {

      bool rv = instance_merge_tree( tinst1, tinst2 );
      assert( rv );

    } else if( strcmp( root1->name, root2->name ) == 0 ) {

      bool rv = instance_merge_tree( root1, root2 );
      assert( rv );

    } else {
      
      bool rv = instance_merge_tree( tinst1, tinst2 );
      assert( rv );
      instance_mark_lhier_diffs( tinst1, tinst2 );

    }

  /* If the two trees share the same root name, merge them */
  } else if( (strcmp( root1->name, root2->name ) == 0) && instance_merge_tree( root1, root2 ) ) {

    /* We've already merged so we don't have anything else to do */

  /* Check to see if the module pointed to by tinst1 exists within the tree of tinst2 */
  } else if( (tinst1->funit != NULL) && ((root2 = instance_find_by_funit_name_if_one( tinst2, tinst1->funit->name )) != NULL) ) {

    bool rv = instance_merge_tree( tinst1, root2 );
    assert( rv );
    instance_mark_lhier_diffs( tinst1, root2 );

  /* Check to see if the module pointed to by tinst2 exists within the tree of tinst1 */
  } else if( (tinst2->funit != NULL) && ((root1 = instance_find_by_funit_name_if_one( tinst1, tinst2->funit->name )) != NULL) ) {

    bool rv = instance_merge_tree( root1, tinst2 );
    assert( rv );
    instance_mark_lhier_diffs( root1, tinst2 );

  /* Otherwise, we cannot merge the two CDD files so don't */
  } else {

    retval = FALSE;

  }

  PROFILE_END;

  return( retval );

}

void instance_only_db_merge

(

char **

line

)

Reads in and merges an instance-only line from the database.

Merges instance-only constructs from two CDD files.

Parameters:

line

Pointer to line being read from database file

References funit_inst_s::child_head, funit_inst_s::child_tail, curr_db, FALSE, FATAL, free_safe, inst_head, inst_link_add(), inst_link_find_by_scope(), db_s::inst_tail, instance_create(), funit_inst_s::next, funit_inst_s::parent, print_output(), PROFILE, PROFILE_END, scope_extract_back(), strdup_safe, and Throw.

Referenced by db_read().

  { PROFILE(INSTANCE_ONLY_DB_MERGE);

  char scope[4096];
  int  chars_read;
  bool name_diff;

  if( sscanf( *line, "%s %d%n", scope, (int*)&name_diff, &chars_read ) == 2 ) {

    char*       back = strdup_safe( scope );
    char*       rest = strdup_safe( scope );
    funit_inst* child;

    *line += chars_read;

    scope_extract_back( scope, back, rest );

    /* Create "placeholder" instance */
    child = instance_create( NULL, back, name_diff, FALSE, FALSE, NULL );

    /* If we are the top-most instance, just add ourselves to the instance link list */
    if( rest[0] == '\0' ) {

      /* Add a new instance link if was not able to be found in the instance linked list */
      if( inst_link_find_by_scope( scope, db_list[curr_db]->inst_head ) == NULL ) {
        (void)inst_link_add( child, &(db_list[curr_db]->inst_head), &(db_list[curr_db]->inst_tail) );
      }

    /* Otherwise, find our parent instance and attach the new instance to it */
    } else {
      funit_inst* parent;
      if( (parent = inst_link_find_by_scope( rest, db_list[curr_db]->inst_head )) != NULL ) {
        if( parent->child_head == NULL ) {
          parent->child_head = parent->child_tail = child;
        } else {
          parent->child_tail->next = child;
          parent->child_tail       = child;
        }
        child->parent = parent;
      } else {
        print_output( "Unable to find parent instance of instance-only line in database file.", FATAL, __FILE__, __LINE__ );
        Throw 0;
      }
    }

    /* Deallocate memory */
    free_safe( back, (strlen( scope ) + 1) );
    free_safe( rest, (strlen( scope ) + 1) );

  } else {

    print_output( "Unable to merge instance-only line in database file.", FATAL, __FILE__, __LINE__ );
    Throw 0;

  }

  PROFILE_END;

}

void instance_only_db_read

(

char **

line

)

Reads in and handles an instance-only line from the database.

Parses an instance-only database line and adds a "placeholder" instance in the instance tree.

Parameters:

line

Pointer to line being read from database file

References funit_inst_s::child_head, funit_inst_s::child_tail, curr_db, FALSE, FATAL, free_safe, inst_head, inst_link_add(), inst_link_find_by_scope(), db_s::inst_tail, instance_create(), funit_inst_s::next, funit_inst_s::parent, print_output(), PROFILE, PROFILE_END, scope_extract_back(), strdup_safe, and Throw.

Referenced by db_read().

  { PROFILE(INSTANCE_ONLY_DB_READ);

  char  scope[4096];
  int   chars_read;
  bool  name_diff;

  if( sscanf( *line, "%s %d%n", scope, (int*)&name_diff, &chars_read ) == 2 ) {

    char*       back = strdup_safe( scope );
    char*       rest = strdup_safe( scope );
    funit_inst* child;

    *line += chars_read;

    scope_extract_back( scope, back, rest ); 

    /* Create "placeholder" instance */
    child = instance_create( NULL, back, name_diff, FALSE, FALSE, NULL );

    /* If we are the top-most instance, just add ourselves to the instance link list */
    if( rest[0] == '\0' ) {
      (void)inst_link_add( child, &(db_list[curr_db]->inst_head), &(db_list[curr_db]->inst_tail) );

    /* Otherwise, find our parent instance and attach the new instance to it */
    } else {
      funit_inst* parent;
      if( (parent = inst_link_find_by_scope( rest, db_list[curr_db]->inst_tail )) != NULL ) {
        if( parent->child_head == NULL ) {
          parent->child_head = parent->child_tail = child;
        } else {
          parent->child_tail->next = child;
          parent->child_tail       = child;
        }
        child->parent = parent;
      } else {
        print_output( "Unable to find parent instance of instance-only line in database file.", FATAL, __FILE__, __LINE__ );
        Throw 0;
      }
    }

    /* Deallocate memory */
    free_safe( back, (strlen( scope ) + 1) );
    free_safe( rest, (strlen( scope ) + 1) );

  } else {

    print_output( "Unable to read instance-only line in database file.", FATAL, __FILE__, __LINE__ );
    Throw 0;

  }

  PROFILE_END;

}

void instance_output_dumpvars	(	FILE *	vfile,
		funit_inst *	root
	)

Outputs dumpvars to the given file for the given instance.

Outputs dumpvars to the specified file.

Parameters:

	vfile	Pointer to file to output dumpvars to
	root	Pointer to current instance

References funit_inst_s::child_head, FALSE, funit_inst_s::funit, funit_output_dumpvars(), instance_gen_scope(), instance_output_dumpvars(), funit_inst_s::next, PROFILE, and PROFILE_END.

Referenced by db_output_dumpvars(), and instance_output_dumpvars().

  { PROFILE(INSTANCE_OUTPUT_DUMPVARS);

  funit_inst* child = root->child_head;
  char        scope[4096];

  /* Generate instance scope */
  scope[0] = '\0';
  instance_gen_scope( scope, root, FALSE );

  /* Outputs dumpvars for the given functional unit */
  funit_output_dumpvars( vfile, root->funit, scope );

  /* Outputs all children instances */
  while( child != NULL ) {
    instance_output_dumpvars( vfile, child );
    child = child->next;
  }

  PROFILE_END;

}

bool instance_parse_add	(	funit_inst **	root,
		func_unit *	parent,
		func_unit *	child,
		char *	inst_name,
		vector_width *	range,
		bool	resolve,
		bool	child_gend,
		bool	ignore_child,
		bool	gend_scope
	)

Adds new instance to specified instance tree during parse.

Returns:

Returns TRUE if specified instance was successfully added to the specified instance tree; otherwise, returns FALSE.

Adds the child functional unit to the child functional unit pointer list located in the functional unit specified by the scope of parent in the functional unit instance tree pointed to by root. This function is used by the db_add_instance function during the parsing stage.

Parameters:

	root	Root funit_inst pointer of functional unit instance tree
	parent	Pointer to parent functional unit of specified child
	child	Pointer to child functional unit to add
	inst_name	Name of new functional unit instance
	range	For array of instances, specifies the name range
	resolve	If set to TRUE, resolve any added instance
	child_gend	If set to TRUE, specifies that child is a generated instance and should only be added once
	ignore_child	If set to TRUE, causes the child instance to be ignored when writing to CDD file
	gend_scope	If set to TRUE, the child instance is a generated scope

References FALSE, func_unit_s::filename, funit_inst_s::funit, instance_add_child(), instance_copy(), instance_create(), instance_find_by_funit(), PROFILE, PROFILE_END, and TRUE.

Referenced by db_add_instance(), gen_item_resolve(), and instance_resolve_inst().

  { PROFILE(INSTANCE_PARSE_ADD);
  
  bool        retval = TRUE;  /* Return value for this function */
  funit_inst* inst;           /* Temporary pointer to functional unit instance to add to */
  funit_inst* cinst;          /* Pointer to instance of child functional unit */
  int         i;              /* Loop iterator */
  int         ignore;         /* Number of matched instances to ignore */

  if( *root == NULL ) {

    *root = instance_create( child, inst_name, FALSE, ignore_child, gend_scope, range );

  } else {

    assert( parent != NULL );

    i      = 0;
    ignore = 0;

    /*
     Check to see if the child functional unit has already been parsed and, if so, find
     one of its instances for copying the instance tree below it.
    */
    cinst = instance_find_by_funit( *root, child, &ignore);
    
    /* Filename will be set to a value if the functional unit has been parsed */
    if( (cinst != NULL) && (cinst->funit->filename != NULL) ) { 

      ignore = 0;
      while( (ignore >= 0) && ((inst = instance_find_by_funit( *root, parent, &ignore )) != NULL) ) {
        (void)instance_copy( cinst, inst, inst_name, range, resolve );
        i++;
        ignore = child_gend ? -1 : i;
      }

    } else {

      ignore = 0;
      while( (ignore >= 0) && ((inst = instance_find_by_funit( *root, parent, &ignore )) != NULL) ) {
        cinst = instance_add_child( inst, child, inst_name, range, resolve, ignore_child, gend_scope );
        i++;
        ignore = (child_gend && (cinst != NULL)) ? -1 : i;
      }

    }

    /* Everything went well with the add if we found at least one parent instance */
    retval = (i > 0);

  }

  PROFILE_END;

  return( retval );

}

bool instance_read_add	(	funit_inst **	root,
		char *	parent,
		func_unit *	child,
		char *	inst_name
	)

Adds new instance to specified instance tree during CDD read.

Returns:

Returns TRUE if instance was added to the specified functional unit instance tree; otherwise, returns FALSE (indicates that the instance is from a different hierarchy).

Adds the child functional unit to the child functional unit pointer list located in the functional unit specified by the scope of parent in the functional unit instance tree pointed to by root. This function is used by the db_read function during the CDD reading stage.

Parameters:

	root	Pointer to root instance of functional unit instance tree
	parent	String scope of parent instance
	child	Pointer to child functional unit to add to specified parent's child list
	inst_name	Instance name of this child functional unit instance

References funit_inst_s::child_head, funit_inst_s::child_tail, FALSE, instance_create(), instance_find_scope(), funit_inst_s::next, funit_inst_s::parent, PROFILE, PROFILE_END, and TRUE.

Referenced by db_read().

  { PROFILE(INSTANCE_READ_ADD);

  bool        retval = TRUE;  /* Return value for this function */
  funit_inst* inst;           /* Temporary pointer to functional unit instance to add to */
  funit_inst* new_inst;       /* Pointer to new functional unit instance to add */

  if( *root == NULL ) {

    *root = instance_create( child, inst_name, FALSE, FALSE, FALSE, NULL );

  } else {

    assert( parent != NULL );
  
    if( (inst = instance_find_scope( *root, parent, TRUE )) != NULL ) {

      /* Create new instance */
      new_inst = instance_create( child, inst_name, FALSE, FALSE, FALSE, NULL );

      if( inst->child_head == NULL ) {
        inst->child_head = new_inst;
        inst->child_tail = new_inst;
      } else {
        inst->child_tail->next = new_inst;
        inst->child_tail       = new_inst;
      }

      /* Set parent pointer of new instance */
      new_inst->parent = inst;

    } else {

      /* Unable to find parent of this child, needs to be added to a different instance tree */
      retval = FALSE;

    }
 
  }

  PROFILE_END;

  return( retval );

}

void instance_remove_parms_with_expr	(	funit_inst *	root,
		statement *	stmt
	)

Removes expressions from instance parameters within the given instance that match the given expression.

Recursively traverses the given instance tree, removing the given statement.

Parameters:

	root	Pointer to functional unit instance to remove expression from
	stmt	Pointer to statement to remove from list

References funit_inst_s::child_head, exp_link_s::exp, statement_s::exp, mod_parm_s::exp_head, vsignal_s::exp_head, exp_link_remove(), vsignal_s::exp_tail, mod_parm_s::exp_tail, expression_find_expr(), FALSE, instance_remove_parms_with_expr(), inst_parm_s::mparm, funit_inst_s::next, inst_parm_s::next, exp_link_s::next, funit_inst_s::param_head, PROFILE, PROFILE_END, and inst_parm_s::sig.

Referenced by db_remove_statement_from_current_funit(), and instance_remove_parms_with_expr().

  { PROFILE(INSTANCE_REMOVE_PARMS_WITH_EXPR);

  funit_inst* curr_child;  /* Pointer to current child instance to traverse */
  inst_parm*  iparm;       /* Pointer to current instance parameter */
  exp_link*   expl;        /* Pointer to current expression link */
  exp_link*   texpl;       /* Temporary pointer to current expression link */

  /* Search for the given expression within the given instance parameter */
  iparm = root->param_head;
  while( iparm != NULL ) {
    if( iparm->sig != NULL ) {
      expl = iparm->sig->exp_head;
      while( expl != NULL ) {
        texpl = expl;
        expl  = expl->next;
        if( expression_find_expr( stmt->exp, texpl->exp ) ) {
          if( iparm->mparm != NULL ) {
            exp_link_remove( texpl->exp, &(iparm->mparm->exp_head), &(iparm->mparm->exp_tail), FALSE );
          }
          exp_link_remove( texpl->exp, &(iparm->sig->exp_head), &(iparm->sig->exp_tail), FALSE );
        }
      }
    }
    iparm = iparm->next;
  }

  /* Traverse children */
  curr_child = root->child_head;
  while( curr_child != NULL ) {
    instance_remove_parms_with_expr( curr_child, stmt );
    curr_child = curr_child->next;
  }

  PROFILE_END;

}

void instance_remove_stmt_blks_calling_stmt	(	funit_inst *	root,
		statement *	stmt
	)

Removes all statement blocks that contain expressions that call the given statement.

Removes all statement blocks in the design that call that specified statement.

Parameters:

	root	Pointer to root instance to remove statements from
	stmt	Pointer to statement to match

References funit_inst_s::child_head, funit_inst_s::funit, funit_remove_stmt_blks_calling_stmt(), gen_item_remove_if_contains_expr_calling_stmt(), gitem_link_s::gi, funit_inst_s::gitem_head, instance_remove_stmt_blks_calling_stmt(), funit_inst_s::next, gitem_link_s::next, PROFILE, and PROFILE_END.

Referenced by db_remove_stmt_blks_calling_statement(), and instance_remove_stmt_blks_calling_stmt().

  { PROFILE(INSTANCE_REMOVE_STMT_BLKS_CALLING_STMT);

  funit_inst* curr_child;  /* Pointer to current child instance to parse */
#ifndef VPI_ONLY
  gitem_link* gil;         /* Pointer to current generate item link */
#endif

  if( root != NULL ) {

    /* First, handle the current functional unit */
    funit_remove_stmt_blks_calling_stmt( root->funit, stmt );

#ifndef VPI_ONLY
    /* Second, handle all generate items in this instance */
    gil = root->gitem_head;
    while( gil != NULL ) {
      gen_item_remove_if_contains_expr_calling_stmt( gil->gi, stmt );
      gil = gil->next;
    }
#endif

    /* Parse children */
    curr_child = root->child_head;
    while( curr_child != NULL ) {
      instance_remove_stmt_blks_calling_stmt( curr_child, stmt );
      curr_child = curr_child->next;
    }

  }

  PROFILE_END;

}

void instance_resolve

(

funit_inst *

root

)

Resolves all instance arrays.

Recursively iterates through entire instance tree, resolving any instance arrays that are found.

Parameters:

root

Pointer to current functional unit instance to resolve

References instance_resolve_helper(), PROFILE, and PROFILE_END.

Referenced by bind_perform().

  { PROFILE(INSTANCE_RESOLVE);

  /* Resolve all instance names */
  instance_resolve_helper( root, root );

  PROFILE_END;

}

static void instance_resolve_helper	(	funit_inst *	root,
		funit_inst *	curr
	)			[static]

Recursively iterates through the entire instance tree

Parameters:

	root	Pointer to root of instance tree
	curr	Pointer to current instance

References funit_inst_s::child_head, DEBUG, debug_mode, generate_resolve_inst(), instance_resolve_inst(), funit_inst_s::name, funit_inst_s::next, param_resolve_inst(), print_output(), PROFILE, PROFILE_END, user_msg, and USER_MSG_LENGTH.

Referenced by instance_resolve().

  { PROFILE(INSTANCE_RESOLVE_HELPER);

  funit_inst* curr_child;  /* Pointer to current child */

  if( curr != NULL ) {

    /* Resolve parameters */
#ifdef DEBUG_MODE
    if( debug_mode ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Resolving parameters for instance %s...", curr->name );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, DEBUG, __FILE__, __LINE__ );
    }
#endif
    param_resolve_inst( curr );

    /* Resolve generate blocks */
#ifdef DEBUG_MODE
    if( debug_mode ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Resolving generate statements for instance %s...", curr->name );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, DEBUG, __FILE__, __LINE__ );
    }
#endif
    generate_resolve_inst( curr );

    /* Resolve children */
    curr_child = curr->child_head;
    while( curr_child != NULL ) {
      instance_resolve_helper( root, curr_child );
      curr_child = curr_child->next;
    }

    /* Now resolve this instance's arrays */
#ifdef DEBUG_MODE
    if( debug_mode ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Resolving instance arrays for instance %s...", curr->name );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, DEBUG, __FILE__, __LINE__ );
    }
#endif
    (void)instance_resolve_inst( root, curr );

  }

  PROFILE_END;

}

bool instance_resolve_inst	(	funit_inst *	root,
		funit_inst *	curr
	)			[static]

Returns:

Returns TRUE if instance was resolved; otherwise, returns FALSE.

Checks the given instance to see if a range was specified in its instantiation. If a range was found, create all of the instances for this range and add them to the instance tree.

Parameters:

	root	Pointer to root functional unit to traverse
	curr	Pointer to current instance to resolve

References FALSE, free_safe, funit_inst_s::funit, instance_parse_add(), vector_width_s::left, malloc_safe, funit_inst_s::name, funit_inst_s::parent, PROFILE, PROFILE_END, funit_inst_s::range, vector_width_s::right, static_expr_calc_lsb_and_width_post(), static_expr_dealloc(), strdup_safe, and TRUE.

Referenced by instance_add_child(), and instance_resolve_helper().

  { PROFILE(INSTANCE_RESOLVE_INST);

  unsigned int width = 0;   /* Width of the instance range */
  int          lsb;         /* LSB of the instance range */
  int          big_endian;  /* Unused */
  char*        name_copy;   /* Copy of the instance name being resolved */
  char*        new_name;    /* New hierarchical name of the instance(s) being resolved */
  unsigned int i;           /* Loop iterator */

  assert( curr != NULL );

  if( curr->range != NULL ) {

    unsigned int rv;
    unsigned int slen;

    /* Get LSB and width information */
    static_expr_calc_lsb_and_width_post( curr->range->left, curr->range->right, &width, &lsb, &big_endian );
    assert( width != 0 );
    assert( lsb != -1 );

    /* Remove the range information from this instance */
    static_expr_dealloc( curr->range->left,  FALSE );
    static_expr_dealloc( curr->range->right, FALSE );
    free_safe( curr->range, sizeof( vector_width ) );
    curr->range = NULL;

    /* Copy and deallocate instance name */
    name_copy = strdup_safe( curr->name );
    free_safe( curr->name, (strlen( curr->name ) + 1) );

    /* For the first instance, just modify the name */
    slen     = strlen( name_copy ) + 23;
    new_name = (char*)malloc_safe( slen );
    rv = snprintf( new_name, slen, "%s[%d]", name_copy, lsb );
    assert( rv < slen );
    curr->name = strdup_safe( new_name );

    /* For all of the rest of the instances, do the instance_parse_add function call */
    for( i=1; i<width; i++ ) {

      /* Create the new name */
      rv = snprintf( new_name, slen, "%s[%d]", name_copy, (lsb + i) );
      assert( rv < slen );

      /* Add the instance */
      (void)instance_parse_add( &root, ((curr->parent == NULL) ? NULL : curr->parent->funit), curr->funit, new_name, NULL, TRUE, FALSE, FALSE, FALSE );

    }

    /* Deallocate the new_name and name_copy pointers */
    free_safe( name_copy, (strlen( name_copy ) + 1) );
    free_safe( new_name, slen );

  }

  PROFILE_END;
  
  return( width != 0 );

}

---

Variable Documentation

unsigned int curr_db

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

int curr_expr_id

This static value contains the current expression ID number to use for the next expression found, it is incremented by one when an expression is found. This allows us to have a unique expression ID for each expression (since expressions have no intrinsic names).

int curr_sig_id = 1

Signal ID that is used for identification purposes (each signal will receive a unique ID).

Referenced by db_get_exclusion_id_size(), gen_item_assign_ids(), instance_db_write(), and param_db_write().

db** db_list

Array of database pointers storing all currently loaded databases.

bool debug_mode

If set to TRUE, causes debug information to be spewed to screen.

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.