gen_item.h File Reference

Contains functions for handling generate items. More...

#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.
int	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_inst (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.

---

Detailed Description

Contains functions for handling generate items.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

7/10/2006

---

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

References curr_sig_id, gen_item_s::elem, GI_TYPE_SIG, GI_TYPE_STMT, vsignal_s::id, gen_item_s::part, PROFILE, PROFILE_END, gen_item_s::sig, statement_assign_expr_ids(), gen_item_s::stmt, and gen_item_s::suppl.

Referenced by instance_db_write().

  { 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

References gen_item_s::elem, gen_item_s::expr, free_safe, GI_TYPE_BIND, expression_s::name, gen_item_s::part, PROFILE, PROFILE_END, strdup_safe, gen_item_s::suppl, and gen_item_s::varname.

Referenced by funit_size_elements().

  { 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.

References Catch_anonymous, free_safe, gen_item_get_genvar(), parse_static_expr(), PROFILE, realloc_safe, strdup_safe, Throw, and Try.

Referenced by gen_item_resolve().

  { 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

References FALSE, gen_item_connect(), GI_TYPE_TFN, gen_item_s::next_false, gen_item_s::next_true, gen_item_s::part, PROFILE, PROFILE_END, gen_item_s::suppl, TRUE, and gen_item_s::varname.

Referenced by db_gen_item_connect(), and gen_item_connect().

  { 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.

References gen_item_s::all, DEBUG, debug_mode, gen_item_s::elem, gen_item_s::expr, gen_item_stringify(), GI_TYPE_BIND, malloc_safe, gen_item_s::next_false, gen_item_s::next_true, gen_item_s::part, print_output(), PROFILE, strdup_safe, gen_item_s::suppl, user_msg, USER_MSG_LENGTH, and gen_item_s::varname.

Referenced by db_create_expression(), and gen_item_resolve().

  { 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.

References gen_item_s::all, DEBUG, debug_mode, gen_item_s::elem, gen_item_s::expr, gen_item_stringify(), GI_TYPE_EXPR, malloc_safe, gen_item_s::next_false, gen_item_s::next_true, gen_item_s::part, print_output(), PROFILE, gen_item_s::suppl, user_msg, USER_MSG_LENGTH, and gen_item_s::varname.

Referenced by db_add_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.

References gen_item_s::all, DEBUG, debug_mode, gen_item_s::elem, gen_item_stringify(), GI_TYPE_INST, gen_item_s::inst, malloc_safe, gen_item_s::next_false, gen_item_s::next_true, gen_item_s::part, print_output(), PROFILE, gen_item_s::suppl, user_msg, USER_MSG_LENGTH, and gen_item_s::varname.

Referenced by db_add_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.

References gen_item_s::all, DEBUG, debug_mode, gen_item_s::elem, gen_item_stringify(), GI_TYPE_SIG, malloc_safe, gen_item_s::next_false, gen_item_s::next_true, gen_item_s::part, print_output(), PROFILE, gen_item_s::sig, gen_item_s::suppl, user_msg, USER_MSG_LENGTH, and gen_item_s::varname.

Referenced by db_add_signal(), funit_find_signal(), and gen_item_resolve().

  { 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.

References gen_item_s::all, DEBUG, debug_mode, gen_item_s::elem, gen_item_stringify(), GI_TYPE_STMT, malloc_safe, gen_item_s::next_false, gen_item_s::next_true, gen_item_s::part, print_output(), PROFILE, gen_item_s::stmt, gen_item_s::suppl, user_msg, USER_MSG_LENGTH, and gen_item_s::varname.

Referenced by db_add_statement(), and gen_item_resolve().

  { 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.

References gen_item_s::all, DEBUG, debug_mode, gen_item_s::elem, gen_item_stringify(), GI_TYPE_TFN, gen_item_s::inst, malloc_safe, gen_item_s::next_false, gen_item_s::next_true, gen_item_s::part, print_output(), PROFILE, gen_item_s::suppl, user_msg, USER_MSG_LENGTH, and gen_item_s::varname.

  { 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

References gen_item_s::elem, GI_TYPE_SIG, GI_TYPE_STMT, gen_item_s::part, PROFILE, PROFILE_END, gen_item_s::sig, statement_db_write_tree(), gen_item_s::stmt, gen_item_s::suppl, and vsignal_db_write().

Referenced by funit_db_write().

  { 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

References gen_item_s::elem, GI_TYPE_STMT, gen_item_s::part, PROFILE, PROFILE_END, statement_db_write_expr_tree(), gen_item_s::stmt, and gen_item_s::suppl.

Referenced by funit_db_write().

  { 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

References gen_item_s::elem, gen_item_s::expr, expression_dealloc(), FALSE, free_safe, gen_item_dealloc(), GI_TYPE_BIND, GI_TYPE_EXPR, GI_TYPE_INST, GI_TYPE_SIG, GI_TYPE_STMT, GI_TYPE_TFN, gen_item_s::inst, instance_dealloc_tree(), gen_item_s::next_false, gen_item_s::next_true, gen_item_s::part, PROFILE, PROFILE_END, gen_item_s::sig, statement_dealloc_recursive(), gen_item_s::stmt, gen_item_s::suppl, gen_item_s::varname, and vsignal_dealloc().

Referenced by db_find_gen_item(), funit_find_signal(), gen_item_dealloc(), and gitem_link_delete_list().

  { 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

References gen_item_stringify(), PROFILE, and PROFILE_END.

Referenced by gen_item_display_block_helper().

  { PROFILE(GEN_ITEM_DISPLAY);

  char str[4096];  /* String to store data into */

  gen_item_stringify( gi, str, 4096 );

  printf( "  %s\n", str );

  PROFILE_END;

}

int gen_item_display_block

(

gen_item *

root

)

Displays an entire generate block.

Returns:

Returns a value of 1 so that this function can be called within an expression.

Displays an entire generate block to standard output (used for debugging purposes).

Parameters:

root

Pointer to starting generate item to display

References gen_item_display_block_helper(), PROFILE, and PROFILE_END.

Referenced by gitem_link_display().

  { PROFILE(GEN_ITEM_DISPLAY_BLOCK);

  printf( "Generate block:\n" );

  gen_item_display_block_helper( root );

  PROFILE_END;

  return( 1 );

}

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

References gen_item_compare(), gen_item_find(), gen_item_s::next_false, gen_item_s::next_true, gen_item_s::part, PROFILE, PROFILE_END, and gen_item_s::suppl.

Referenced by db_find_gen_item(), funit_find_signal(), gen_item_find(), and gitem_link_find().

  { 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

References gen_item_s::elem, gen_item_remove_if_contains_expr_calling_stmt(), GI_TYPE_STMT, gen_item_s::next_false, gen_item_s::next_true, gen_item_s::part, PROFILE, PROFILE_END, statement_contains_expr_calling_stmt(), gen_item_s::stmt, and gen_item_s::suppl.

Referenced by gen_item_remove_if_contains_expr_calling_stmt(), and instance_remove_stmt_blks_calling_stmt().

  { 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

References gen_item_s::elem, gen_item_resize_stmts_and_sigs(), GI_TYPE_SIG, GI_TYPE_STMT, gen_item_s::next_false, gen_item_s::next_true, gen_item_s::part, PROFILE, PROFILE_END, gen_item_s::sig, statement_size_elements(), gen_item_s::stmt, gen_item_s::suppl, and vsignal_create_vec().

Referenced by funit_size_elements(), and gen_item_resize_stmts_and_sigs().

  { 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.

References FALSE, free_safe, gen_item_get_genvar(), PROFILE, strdup_safe, and TRUE.

Referenced by db_create_expression().

                                                    { 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

References curr_db, FALSE, generate_remove_stmt_helper(), inst_link_s::inst, db_s::inst_head, inst_link_s::next, PROFILE, and PROFILE_END.

Referenced by stmt_blk_add_to_remove_list().

  { 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_inst

(

funit_inst *

inst

)

Resolves all generate items in the design.

Exceptions:

anonymous

generate_resolve gen_item_resolve

Resolves all generate items in the given instance. This is called at a specific point in the binding process.

Parameters:

inst

Pointer to current instance in instance tree to resolve for

References funit_inst_s::funit, gen_item_resolve(), gitem_link_s::gi, func_unit_s::gitem_head, gitem_link_s::next, PROFILE, and PROFILE_END.

Referenced by instance_resolve_helper().

  { PROFILE(GENERATE_RESOLVE_INST);

  if( inst != NULL ) {

    /* Resolve ourself */
    if( inst->funit != NULL ) {
      gitem_link* curr_gi = inst->funit->gitem_head;
      while( curr_gi != NULL ) {
        gen_item_resolve( curr_gi->gi, inst );
        curr_gi = curr_gi->next;
      }
    }

  }

  PROFILE_END;

}