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

---

Detailed Description

Contains functions for handling generate items.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

7/10/2006

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

Go to the source code of this file.

Functions
void	gen_item_display (gen_item *gi)
	Displays the specified generate item to standard output.
void	gen_item_display_block (gen_item *root)
	Displays an entire generate block.
gen_item *	gen_item_find (gen_item *root, gen_item *gi)
	Searches for a generate item in the generate block of root that matches gi.
void	gen_item_remove_if_contains_expr_calling_stmt (gen_item *gi, statement *stmt)
	Searches for an expression in the generate list that calls the given statement.
bool	gen_item_varname_contains_genvar (char *name)
	Returns TRUE if the specified variable name contains a generate variable within it.
char *	gen_item_calc_signal_name (const char *name, func_unit *funit, int line, bool no_genvars)
	Returns the actual signal name specified by the given signal name which references a generated hierarchy.
gen_item *	gen_item_create_expr (expression *expr)
	Creates a generate item for an expression.
gen_item *	gen_item_create_sig (vsignal *sig)
	Creates a generate item for a signal.
gen_item *	gen_item_create_stmt (statement *stmt)
	Creates a generate item for a statement.
gen_item *	gen_item_create_inst (funit_inst *inst)
	Creates a generate item for an instance.
gen_item *	gen_item_create_tfn (funit_inst *inst)
	Creates a generate item for a namespace.
gen_item *	gen_item_create_bind (const char *name, expression *expr)
	Creates a generate item for a binding.
void	gen_item_resize_stmts_and_sigs (gen_item *gi, func_unit *funit)
	Resizes all statements and signals in the given generate item block.
void	gen_item_assign_ids (gen_item *gi, func_unit *funit)
	Assigns unique signal ID or expression IDs to all expressions for specified statement block.
void	gen_item_db_write (gen_item *gi, uint32 type, FILE *file)
	Outputs the current generate item to the given output file if it matches the type specified.
void	gen_item_db_write_expr_tree (gen_item *gi, FILE *file)
	Outputs the entire expression tree from the given generate statement.
bool	gen_item_connect (gen_item *gi1, gen_item *gi2, int conn_id, bool stop_on_null)
	Connects a generate item block to a new generate item.
void	gen_item_bind (gen_item *gi)
	Checks generate item and if it is a bind, adds it to binding pool and returns TRUE.
void	generate_resolve (funit_inst *inst)
	Resolves all generate items in the design.
bool	generate_remove_stmt (statement *stmt)
	Removes the given generate statement from the correct instance.
void	gen_item_dealloc (gen_item *gi, bool rm_elem)
	Deallocates all associated memory for the given generate item.

---

Function Documentation

void gen_item_assign_ids (  gen_item *  gi, func_unit *  funit )

Assigns unique signal ID or expression IDs to all expressions for specified statement block. Exceptions: anonymous  statement_assign_expr_ids Assigns unique expression and signal IDs to each expression in the tree given for a generated statement or for the given signal. Parameters: gi  Pointer to generate item to check and assign expression IDs for funit  Pointer to functional unit containing this generate item { PROFILE(GEN_ITEM_ASSIGN_IDS); if( gi->suppl.part.removed == 0 ) { /* Assign expression IDs if this is a statement */ if( gi->suppl.part.type == GI_TYPE_STMT ) { statement_assign_expr_ids( gi->elem.stmt, funit ); } else if( gi->suppl.part.type == GI_TYPE_SIG ) { gi->elem.sig->id = curr_sig_id; curr_sig_id++; } } PROFILE_END; }

void gen_item_bind (  gen_item *  gi  )

Checks generate item and if it is a bind, adds it to binding pool and returns TRUE. Updates the specified expression name to be that of the generate item name if the current generate item is a BIND type. Parameters: gi  Pointer to generate item to examine { PROFILE(GEN_ITEM_BIND); if( gi->suppl.part.type == GI_TYPE_BIND ) { /* Remove the current name */ free_safe( gi->elem.expr->name, (strlen( gi->elem.expr->name ) + 1) ); /* Assign the new name */ gi->elem.expr->name = strdup_safe( gi->varname ); } PROFILE_END; }

char* gen_item_calc_signal_name (  const char *  name, func_unit *  funit, int  line, bool  no_genvars )

Returns the actual signal name specified by the given signal name which references a generated hierarchy. Parameters: name  Name of signal that we possibly need to convert if it contains generate variable(s) funit  Pointer to current functional unit line  Line number in which the signal's expression exists no_genvars  If set to TRUE, we need to make sure that we do not see a generate variable in the generate hierarchical expression. Returns: Returns allocated string containing the signal name with embedded generate variables evaluated Exceptions: anonymous  parse_static_expr Throw Iterates through the given name, substituting any found generate variables with their current value. { PROFILE(GEN_ITEM_CALC_SIGNAL_NAME); char* new_name = NULL; /* Return value of this function */ char* tmpname; /* Temporary name of current part of variable */ char* pre; /* String prior to the generate variable */ char* genvar; /* Generate variable */ char* post; /* String after the generate variable */ char intstr[20]; /* String containing an integer value */ char* ptr; /* Pointer to allocated memory for name */ /* Allocate memory */ tmpname = strdup_safe( name ); ptr = tmpname; new_name = strdup_safe( "" ); Try { do { gen_item_get_genvar( tmpname, &pre, &genvar, &post ); if( genvar != NULL ) { unsigned int rv = snprintf( intstr, 20, "%d", parse_static_expr( genvar, funit, line, no_genvars ) ); assert( rv < 20 ); new_name = (char*)realloc_safe( new_name, (strlen( new_name ) + 1), (strlen( new_name ) + strlen( pre ) + strlen( intstr ) + 3) ); strncat( new_name, pre, strlen( pre ) ); strncat( new_name, "[", 1 ); strncat( new_name, intstr, strlen( intstr ) ); strncat( new_name, "]", 1 ); tmpname = post; } else { new_name = (char*)realloc_safe( new_name, (strlen( new_name ) + 1), (strlen( new_name ) + strlen( pre ) + 1) ); strncat( new_name, pre, strlen( pre ) ); } } while( genvar != NULL ); } Catch_anonymous { free_safe( new_name, (strlen( new_name ) + 1) ); free_safe( ptr, (strlen( name ) + 1) ); Throw 0; } /* Deallocate memory */ free_safe( ptr, (strlen( name ) + 1) ); /* Make sure that the new_name is set to something */ assert( new_name != NULL ); return( new_name ); }

bool gen_item_connect (  gen_item *  gi1, gen_item *  gi2, int  conn_id, bool  stop_on_null )

Connects a generate item block to a new generate item. Returns: Returns TRUE if the connection was successful; otherwise, returns FALSE. Parameters: gi1  Pointer to generate item block to connect to gi2 gi2  Pointer to generate item to connect to gi1 conn_id  Connection ID stop_on_null  Sets stop bit(s) if a NULL next_true/next_false pointer is found { PROFILE(GEN_ITEM_CONNECT); bool retval = FALSE; /* Return value for this function */ /* Set the connection ID */ gi1->suppl.part.conn_id = conn_id; /* If both paths go to the same destination, only parse one path */ if( gi1->next_true == gi1->next_false ) { /* If the TRUE path is NULL, connect it to the new statement */ if( gi1->next_true == NULL ) { gi1->next_true = gi2; gi1->next_false = gi2; if( (gi1->next_true->suppl.part.conn_id == conn_id) || stop_on_null ) { gi1->suppl.part.stop_true = 1; gi1->suppl.part.stop_false = 1; } retval = TRUE; } else if( gi1->next_true->suppl.part.conn_id == conn_id ) { gi1->suppl.part.stop_true = 1; gi1->suppl.part.stop_false = 1; /* If the TRUE path leads to a loop/merge, stop traversing */ } else if( gi1->next_true != gi2 ) { retval |= gen_item_connect( gi1->next_true, gi2, conn_id, stop_on_null ); } } else { /* Traverse FALSE path */ if( gi1->next_false == NULL ) { gi1->next_false = gi2; if( (gi1->next_false->suppl.part.conn_id == conn_id) || stop_on_null ) { gi1->suppl.part.stop_false = 1; } else { gi1->next_false->suppl.part.conn_id = conn_id; } retval = TRUE; } else if( gi1->next_false->suppl.part.conn_id == conn_id ) { gi1->suppl.part.stop_false = 1; } else if( gi1->next_false != gi2 ) { retval |= gen_item_connect( gi1->next_false, gi2, conn_id, stop_on_null ); } /* Traverse TRUE path */ if( gi1->next_true == NULL ) { gi1->next_true = gi2; if( (gi1->next_true->suppl.part.conn_id == conn_id) || stop_on_null ) { gi1->suppl.part.stop_true = 1; } retval = TRUE; } else if( gi1->next_true->suppl.part.conn_id == conn_id ) { gi1->suppl.part.stop_true = 1; } else if( (gi1->next_true != gi2) && (gi1->suppl.part.type != GI_TYPE_TFN) && (gi1->varname == NULL) ) { retval |= gen_item_connect( gi1->next_true, gi2, conn_id, TRUE ); } } PROFILE_END; return( retval ); }

gen_item* gen_item_create_bind (  const char *  name, expression *  expr )

Creates a generate item for a binding. Parameters: name  Name of signal to bind to expr  Pointer to expression to bind signal to Returns: Returns a pointer to create generate item. Create a new generate item for a namespace. { PROFILE(GEN_ITEM_CREATE_BIND); gen_item* gi; /* Create the generate item for a namespace */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.expr = expr; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_BIND; gi->varname = strdup_safe( name ); gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_bind, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

gen_item* gen_item_create_expr (  expression *  expr  )

Creates a generate item for an expression. Parameters: expr  Pointer to root expression to create (this is an expression from a FOR, IF or CASE statement) Returns: Returns a pointer to created generate item. Creates a new generate item for an expression. { PROFILE(GEN_ITEM_CREATE_EXPR); gen_item* gi; /* Create the generate item for an expression */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.expr = expr; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_EXPR; gi->varname = NULL; gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_expr, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

gen_item* gen_item_create_inst (  funit_inst *  inst  )

Creates a generate item for an instance. Parameters: inst  Pointer to instance to create a generate item for (instantiations) Returns: Returns a pointer to create generate item. Create a new generate item for an instance. { PROFILE(GEN_ITEM_CREATE_INST); gen_item* gi; /* Create the generate item for an instance */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.inst = inst; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_INST; gi->varname = NULL; gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_inst, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

gen_item* gen_item_create_sig (  vsignal *  sig  )

Creates a generate item for a signal. Parameters: sig  Pointer to signal to create a generate item for (wire/reg instantions) Returns: Returns a pointer to created generate item. Creates a new generate item for a signal. { PROFILE(GEN_ITEM_CREATE_SIG); gen_item* gi; /* Create the generate item for a signal */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.sig = sig; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_SIG; gi->varname = NULL; gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_sig, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

gen_item* gen_item_create_stmt (  statement *  stmt  )

Creates a generate item for a statement. Parameters: stmt  Pointer to statement to create a generate item for (assign, always, initial blocks) Returns: Returns a pointer to create generate item. Create a new generate item for a statement. { PROFILE(GEN_ITEM_CREATE_STMT); gen_item* gi; /* Create the generate item for a statement */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.stmt = stmt; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_STMT; gi->varname = NULL; gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_stmt, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

gen_item* gen_item_create_tfn (  funit_inst *  inst  )

Creates a generate item for a namespace. Parameters: inst  Pointer to namespace to create a generate item for (named blocks, functions or tasks) Returns: Returns a pointer to create generate item. Create a new generate item for a namespace. { PROFILE(GEN_ITEM_CREATE_TFN); gen_item* gi; /* Create the generate item for a namespace */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.inst = inst; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_TFN; gi->varname = NULL; gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_tfn, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

void gen_item_db_write (  gen_item *  gi, uint32  type, FILE *  ofile )

Outputs the current generate item to the given output file if it matches the type specified. Checks the given generate item against the supplied type. If they match, outputs the given generate item to the specified output file. If they do not match, nothing is done. Parameters: gi  Pointer to current generate item to test and output type  Specifies the type of the generate item to output ofile  Output file to display generate item to { PROFILE(GEN_ITEM_DB_WRITE); /* If the types match, output based on type */ if( (gi->suppl.part.type == type) && (gi->suppl.part.removed == 0) ) { switch( type ) { case GI_TYPE_SIG : vsignal_db_write( gi->elem.sig, ofile ); break; case GI_TYPE_STMT : statement_db_write_tree( gi->elem.stmt, ofile ); break; default : /* Should never be called */ assert( (type == GI_TYPE_SIG) || (type == GI_TYPE_STMT) ); break; } } PROFILE_END; }

void gen_item_db_write_expr_tree (  gen_item *  gi, FILE *  ofile )

Outputs the entire expression tree from the given generate statement. Outputs all expressions for the statement contained in the specified generate item. Parameters: gi  Pointer to current generate item to test and output ofile  Output file to display generate item to { PROFILE(GEN_ITEM_DB_WRITE_EXPR_TREE); /* Only do this for statements */ if( (gi->suppl.part.type == GI_TYPE_STMT) && (gi->suppl.part.removed == 0) ) { statement_db_write_expr_tree( gi->elem.stmt, ofile ); } PROFILE_END; }

void gen_item_dealloc (  gen_item *  gi, bool  rm_elem )

Deallocates all associated memory for the given generate item. Recursively deallocates the gen_item structure tree. Parameters: gi  Pointer to gen_item structure to deallocate rm_elem  If set to TRUE, removes the associated element { PROFILE(GEN_ITEM_DEALLOC); if( gi != NULL ) { /* Deallocate children first */ if( gi->next_true == gi->next_false ) { if( gi->suppl.part.stop_true == 0 ) { gen_item_dealloc( gi->next_true, rm_elem ); } } else { if( gi->suppl.part.stop_false == 0 ) { gen_item_dealloc( gi->next_false, rm_elem ); } if( gi->suppl.part.stop_true == 0 ) { gen_item_dealloc( gi->next_true, rm_elem ); } } /* If we need to remove the current element, do so now */ if( rm_elem ) { switch( gi->suppl.part.type ) { case GI_TYPE_EXPR : expression_dealloc( gi->elem.expr, FALSE ); break; case GI_TYPE_SIG : vsignal_dealloc( gi->elem.sig ); break; case GI_TYPE_STMT : statement_dealloc_recursive( gi->elem.stmt, FALSE ); break; case GI_TYPE_INST : case GI_TYPE_TFN : instance_dealloc_tree( gi->elem.inst ); break; case GI_TYPE_BIND : break; default : break; } } /* Remove the varname if necessary */ free_safe( gi->varname, (strlen( gi->varname ) + 1) ); /* Now deallocate ourselves */ free_safe( gi, sizeof( gen_item ) ); } PROFILE_END; }

void gen_item_display (  gen_item *  gi  )

Displays the specified generate item to standard output. Displays the contents of the specified generate item to standard output (used for debugging purposes). Parameters: gi  Pointer to generate item to display { PROFILE(GEN_ITEM_DISPLAY); char str[4096]; /* String to store data into */ gen_item_stringify( gi, str, 4096 ); printf( " %s\n", str ); PROFILE_END; }

void gen_item_display_block (  gen_item *  root  )

Displays an entire generate block. Displays an entire generate block to standard output (used for debugging purposes). Parameters: root  Pointer to starting generate item to display { PROFILE(GEN_ITEM_DISPLAY_BLOCK); printf( "Generate block:\n" ); gen_item_display_block_helper( root ); PROFILE_END; }

gen_item* gen_item_find (  gen_item *  root, gen_item *  gi )

Searches for a generate item in the generate block of root that matches gi. Returns: Returns a pointer to the generate item that matches the given generate item in the given generate item block. Returns NULL if it was not able to find a matching item. Recursively traverses the specified generate item block searching for a generate item that matches the specified generate item. Parameters: root  Pointer to root of generate item block to search in gi  Pointer to generate item to search for { PROFILE(GEN_ITEM_FIND); gen_item* found = NULL; /* Return value for this function */ assert( gi != NULL ); if( root != NULL ) { if( gen_item_compare( root, gi ) ) { found = root; } else { /* If both true and false paths lead to same item, just traverse the true path */ if( root->next_true == root->next_false ) { if( root->suppl.part.stop_true == 0 ) { found = gen_item_find( root->next_true, gi ); } /* Otherwise, traverse both true and false paths */ } else if( (root->suppl.part.stop_true == 0) && ((found = gen_item_find( root->next_true, gi )) == NULL) ) { if( root->suppl.part.stop_false == 0 ) { found = gen_item_find( root->next_false, gi ); } } } } PROFILE_END; return( found ); }

void gen_item_remove_if_contains_expr_calling_stmt (  gen_item *  gi, statement *  stmt )

Searches for an expression in the generate list that calls the given statement. Removes the given generate item if it contains an expressions that calls a statement. Parameters: gi  Pointer to generate item list to search stmt  Pointer to statement to search for { PROFILE(GEN_ITEM_REMOVE_IF_CONTAINS_EXPR_CALLING_STMT); if( gi != NULL ) { if( gi->suppl.part.type == GI_TYPE_STMT ) { if( statement_contains_expr_calling_stmt( gi->elem.stmt, stmt ) ) { gi->suppl.part.removed = 1; } } else { /* If both true and false paths lead to same item, just traverse the true path */ if( gi->next_true == gi->next_false ) { if( gi->suppl.part.stop_true == 0 ) { gen_item_remove_if_contains_expr_calling_stmt( gi->next_true, stmt ); } /* Otherwise, traverse both true and false paths */ } else { if( gi->suppl.part.stop_true == 0 ) { gen_item_remove_if_contains_expr_calling_stmt( gi->next_true, stmt ); } if( gi->suppl.part.stop_false == 0 ) { gen_item_remove_if_contains_expr_calling_stmt( gi->next_false, stmt ); } } } } PROFILE_END; }

void gen_item_resize_stmts_and_sigs (  gen_item *  gi, func_unit *  funit )

Resizes all statements and signals in the given generate item block. Exceptions: anonymous  vsignal_create_vec statement_size_elements gen_item_resize_stmts_and_sigs gen_item_resize_stmts_and_sigs gen_item_resize_stmts_and_sigs Recursively iterates the the specified generate item block, resizing all statements within that block. Parameters: gi  Pointer to generate item block to check funit  Pointer to functional unit that contains this generate item { PROFILE(GEN_ITEM_RESIZE_STMTS_AND_SIGS); if( gi != NULL ) { /* Resize our statement, if we are one */ if( gi->suppl.part.type == GI_TYPE_STMT ) { statement_size_elements( gi->elem.stmt, funit ); } else if( gi->suppl.part.type == GI_TYPE_SIG ) { vsignal_create_vec( gi->elem.sig ); } /* Go to the next generate item */ if( gi->next_true == gi->next_false ) { if( gi->suppl.part.stop_true == 0 ) { gen_item_resize_stmts_and_sigs( gi->next_true, funit ); } } else { if( gi->suppl.part.stop_false == 0 ) { gen_item_resize_stmts_and_sigs( gi->next_false, funit ); } if( gi->suppl.part.stop_true == 0 ) { gen_item_resize_stmts_and_sigs( gi->next_true, funit ); } } } PROFILE_END; }

bool gen_item_varname_contains_genvar (  char *  name  )

Returns TRUE if the specified variable name contains a generate variable within it. Parameters: name  Variable name to check Returns: Returns TRUE if the specified variable name contains a generate variable within it; otherwise, returns FALSE. This function is called by db_create_expression() just before it places its signal name in the binding list. If the specified signal name contains a generate variable, we need to create a generate item binding element so that we can properly substitute the generate variable name with its current value. { PROFILE(GEN_ITEM_VARNAME_CONTAINS_GENVAR); bool retval = FALSE; /* Return value for this function */ char* pre; /* String prior to the generate variable */ char* genvar; /* Generate variable */ char* post; /* String after the generate variable */ char* tmpname; /* Copy of the given name */ /* Allocate memory */ tmpname = strdup_safe( name ); /* Find the first generate variable */ gen_item_get_genvar( tmpname, &pre, &genvar, &post ); if( genvar != NULL ) { retval = TRUE; } /* Deallocate memory */ free_safe( tmpname, (strlen( name ) + 1) ); return( retval ); }

bool generate_remove_stmt (  statement *  stmt  )

Removes the given generate statement from the correct instance. Returns: Returns TRUE if we found at least one match; otherwise, returns FALSE. Iterates through the entire instance tree finding and "removing" all statement generate items that match the given statement ID. This will get called by the stmt_blk_remove() function when a statement has been found that does not exist in a functional unit. Parameters: stmt  Statement to set "remove" bit on { PROFILE(GENERATE_REMOVE_STMT); bool retval = FALSE; /* Return value for this function */ inst_link* instl; /* Pointer to current instance list to parse */ /* Search for the generate item in the instance lists */ instl = db_list[curr_db]->inst_head; while( instl != NULL ) { retval |= generate_remove_stmt_helper( instl->inst, stmt ); instl = instl->next; } PROFILE_END; return( retval ); }

void generate_resolve (  funit_inst *  root  )

Resolves all generate items in the design. Exceptions: anonymous  generate_resolve gen_item_resolve Recursively resolves all generate items in the design. This is called at a specific point in the binding process. Parameters: root  Pointer to current instance in instance tree to resolve for { PROFILE(GENERATE_RESOLVE); funit_inst* curr_child; /* Pointer to current child to resolve for */ if( root != NULL ) { /* Resolve ourself */ if( root->funit != NULL ) { gitem_link* curr_gi = root->funit->gitem_head; while( curr_gi != NULL ) { gen_item_resolve( curr_gi->gi, root ); curr_gi = curr_gi->next; } } /* Resolve children */ curr_child = root->child_head; while( curr_child != NULL ) { generate_resolve( curr_child ); curr_child = curr_child->next; } } PROFILE_END; }

---