link.h File Reference

Contains functions to manipulate a linked lists. More...

#include "defines.h"

Go to the source code of this file.

Functions
str_link *	str_link_add (char *str, str_link **head, str_link **tail)
	Adds specified string to str_link element at the end of the list.
stmt_link *	stmt_link_add (statement *stmt, bool rm_stmt, stmt_link **head, stmt_link **tail)
	Adds specified statement to stmt_link element at the beginning of the list.
void	exp_link_add (expression *expr, exp_link **head, exp_link **tail)
	Adds specified expression to exp_link element at the end of the list.
void	sig_link_add (vsignal *sig, sig_link **head, sig_link **tail)
	Adds specified signal to sig_link element at the end of the list.
void	fsm_link_add (fsm *table, fsm_link **head, fsm_link **tail)
	Adds specified FSM to fsm_link element at the end of the list.
void	funit_link_add (func_unit *funit, funit_link **head, funit_link **tail)
	Adds specified functional unit to funit_link element at the end of the list.
void	gitem_link_add (gen_item *gi, gitem_link **head, gitem_link **tail)
	Adds specified generate item to the end of specified gitem list.
inst_link *	inst_link_add (funit_inst *inst, inst_link **head, inst_link **tail)
	Adds specified functional unit instance to inst_link element at the end of the list.
void	str_link_display (str_link *head)
	Displays specified string list to standard output.
void	stmt_link_display (stmt_link *head)
	Displays specified statement list to standard output.
void	exp_link_display (exp_link *head)
	Displays specified expression list to standard output.
void	sig_link_display (sig_link *head)
	Displays specified signal list to standard output.
void	funit_link_display (funit_link *head)
	Displays specified functional unit list to standard output.
void	gitem_link_display (gitem_link *head)
	Displays specified generate item list to standard output.
void	inst_link_display (inst_link *head)
	Displays specified instance list to standard output.
str_link *	str_link_find (const char *value, str_link *head)
	Finds specified string in the given str_link list.
stmt_link *	stmt_link_find (int id, stmt_link *head)
	Finds specified statement in the given stmt_link list.
stmt_link *	stmt_link_find_by_pos (unsigned int ppline, uint32 first_col, stmt_link *head)
	Finds specified statement in the given stmt_link list.
exp_link *	exp_link_find (int id, exp_link *head)
	Finds specified expression in the given exp_link list.
exp_link *	exp_link_find_by_pos (exp_op_type op, int line, unsigned int col, exp_link *head)
	Finds specified expression in the given exp_link list.
sig_link *	sig_link_find (const char *name, sig_link *head)
	Finds specified signal in given sig_link list.
fsm_link *	fsm_link_find (const char *name, fsm_link *head)
	Finds specified FSM structure in fsm_link list.
fsm_link *	fsm_link_find_by_pos (int line, fsm_link *head)
	Finds specified FSM structure in fsm_link list based on file position.
funit_link *	funit_link_find (const char *name, int type, funit_link *head)
	Finds specified functional unit in given funit_link list.
gitem_link *	gitem_link_find (gen_item *gi, gitem_link *head)
	Finds specified generate item in given gitem_link list.
funit_inst *	inst_link_find_by_scope (char *scope, inst_link *head)
	Finds specified functional unit instance in given inst_link list.
funit_inst *	inst_link_find_by_funit (const func_unit *funit, inst_link *head, int *ignore)
	Finds specified functional unit instance in given inst_link list.
void	str_link_remove (char *str, str_link **head, str_link **tail)
	Searches for and removes specified string link from list.
void	exp_link_remove (expression *exp, exp_link **head, exp_link **tail, bool recursive)
	Searches for and removes specified expression link from list.
void	gitem_link_remove (gen_item *gi, gitem_link **head, gitem_link **tail)
	Searches for and removes specified generate item link from list.
void	funit_link_remove (func_unit *funit, funit_link **head, funit_link **tail, bool rm_funit)
	Searches for and removes specified functional unit link from list.
void	str_link_delete_list (str_link *head)
	Deletes entire list specified by head pointer.
void	stmt_link_unlink (statement *stmt, stmt_link **head, stmt_link **tail)
	Unlinks the stmt_link specified by the specified statement.
void	stmt_link_delete_list (stmt_link *head)
	Deletes entire list specified by head pointer.
void	exp_link_delete_list (exp_link *head, bool del_exp)
	Deletes entire list specified by head pointer.
void	sig_link_delete_list (sig_link *head, bool del_sig)
	Deletes entire list specified by head pointer.
void	fsm_link_delete_list (fsm_link *head)
	Deletes entire list specified by head pointer.
void	funit_link_delete_list (funit_link **head, funit_link **tail, bool rm_funit)
	Deletes entire list specified by head pointer.
void	gitem_link_delete_list (gitem_link *head, bool rm_elems)
	Deletes entire list specified by head pointer.
void	inst_link_delete_list (inst_link *head)
	Deletes entire list specified by head pointer.

---

Detailed Description

Contains functions to manipulate a linked lists.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

11/28/2001

---

Function Documentation

void exp_link_add	(	expression *	expr,
		exp_link **	head,
		exp_link **	tail
	)

Adds specified expression to exp_link element at the end of the list.

Creates a new exp_link element with the value specified for expr. Sets next pointer of element to NULL, sets the tail element to point to the new element and sets the tail value to the new element.

Parameters:

	expr	Expression to add to specified expression list
	head	Pointer to head exp_link element of list
	tail	Pointer to tail exp_link element of list

References exp_link_s::exp, malloc_safe, exp_link_s::next, PROFILE, and PROFILE_END.

Referenced by bind_param(), bind_signal(), bind_task_function_namedblock(), db_add_expression(), expression_db_read(), expression_find_params(), fsm_arg_parse_value(), fsm_var_add_expr(), inst_parm_add(), param_find_and_set_expr_value(), vsignal_add_expression(), and vsignal_duplicate().

  { PROFILE(EXP_LINK_ADD);

  exp_link* tmp;  /* Temporary pointer to newly created exp_link element */

  tmp = (exp_link*)malloc_safe( sizeof( exp_link ) );

  tmp->exp  = expr;
  tmp->next = NULL;

  if( *head == NULL ) {
    *head = *tail = tmp;
  } else {
    (*tail)->next = tmp;
    *tail         = tmp;
  }

  PROFILE_END;

}

void exp_link_delete_list	(	exp_link *	head,
		bool	del_exp
	)

Deletes entire list specified by head pointer.

Deletes each element of the specified list.

Parameters:

	head	Pointer to head exp_link element of list
	del_exp	If set to TRUE, deallocates the expression; otherwise, leaves expression alone

References exp_link_s::exp, expression_dealloc(), free_safe, exp_link_s::next, PROFILE, PROFILE_END, and TRUE.

Referenced by funit_clean(), mod_parm_dealloc(), sim_add_statics(), sim_dealloc(), and vsignal_dealloc().

  { PROFILE(EXP_LINK_DELETE_LIST);

  exp_link* tmp;  /* Pointer to current expression link to remove */
  
  while( head != NULL ) {

    tmp  = head;
    head = head->next;
    
    /* Deallocate expression */
    if( del_exp ) {
      expression_dealloc( tmp->exp, TRUE );
      tmp->exp = NULL;
    }
    
    /* Deallocate exp_link element itself */
    free_safe( tmp, sizeof( exp_link ) );
    
  }

  PROFILE_END;

}

void exp_link_display

(

exp_link *

head

)

Displays specified expression list to standard output.

Displays the string contents of the exp_link list pointed to by head to standard output. This function is mainly used for debugging purposes.

Parameters:

head

Pointer to head of exp_link list

References exp_link_s::exp, expression_string_op(), expression_s::id, expression_s::line, exp_link_s::next, and expression_s::op.

Referenced by mod_parm_display().

  {

  exp_link* curr;    /* Pointer to current expression link */

  printf( "Expression list:\n" );

  curr = head;
  while( curr != NULL ) {
    printf( "  id: %d, op: %s, line: %d\n", curr->exp->id, expression_string_op( curr->exp->op ), curr->exp->line );
    curr = curr->next;
  }

}

exp_link* exp_link_find	(	int	id,
		exp_link *	head
	)

Finds specified expression in the given exp_link list.

Returns:

Returns the pointer to the found exp_link or NULL if the search was unsuccessful.

Iteratively searches the exp_link list specified by the head exp_link element. If a matching expression is found, the pointer to this element is returned. If the specified expression could not be matched, the value of NULL is returned.

Parameters:

	id	Expression ID to find
	head	Pointer to head of exp_link list to search

References exp_link_s::exp, expression_s::id, exp_link_s::next, PROFILE, and PROFILE_END.

Referenced by combination_get_coverage(), combination_get_expression(), expression_db_read(), fsm_db_read(), fsm_var_add_expr(), funit_find_by_id(), param_find_and_set_expr_value(), and statement_db_read().

  { PROFILE(EXP_LINK_FIND);

  exp_link* curr;   /* Expression list iterator */

  curr = head;
  while( (curr != NULL) && (curr->exp->id != id) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( curr );

}

exp_link* exp_link_find_by_pos	(	exp_op_type	op,
		int	line,
		unsigned int	col,
		exp_link *	head
	)

Finds specified expression in the given exp_link list.

void exp_link_remove	(	expression *	exp,
		exp_link **	head,
		exp_link **	tail,
		bool	recursive
	)

Searches for and removes specified expression link from list.

Searches specified list for expression that matches the specified expression. If a match is found, remove it from the list and deallocate the link memory.

Parameters:

	exp	Pointer to expression to find and remove
	head	Pointer to head of expression list
	tail	Pointer to tail of expression list
	recursive	If TRUE, recursively removes expression tree and expressions

References exp_link_s::exp, exp_link_remove(), EXPR_LEFT_DEALLOCABLE, EXPR_RIGHT_DEALLOCABLE, expression_dealloc(), free_safe, expression_s::id, expression_s::left, exp_link_s::next, PROFILE, PROFILE_END, expression_s::right, and TRUE.

Referenced by db_remove_statement_from_current_funit(), exp_link_remove(), expression_dealloc(), instance_remove_parms_with_expr(), and mod_parm_find_expr_and_remove().

  { PROFILE(EXP_LINK_REMOVE);

  exp_link* curr;  /* Pointer to current expression link */
  exp_link* last;  /* Pointer to last expression link */

  assert( exp != NULL );

  /* If recursive mode is set, remove children first */
  if( recursive ) {
    if( (exp->left != NULL) && EXPR_LEFT_DEALLOCABLE( exp ) ) {
      exp_link_remove( exp->left, head, tail, recursive );
    }
    if( (exp->right != NULL) && EXPR_RIGHT_DEALLOCABLE( exp ) ) {
      exp_link_remove( exp->right, head, tail, recursive );
    }
  }

  curr = *head;
  last = NULL;
  while( (curr != NULL) && (curr->exp->id != exp->id) ) {
    last = curr;
    curr = curr->next;
    if( curr != NULL ) {
      assert( curr->exp != NULL );
    }
  }

  if( curr != NULL ) {

    if( (curr == *head) && (curr == *tail) ) {
      *head = *tail = NULL;
    } else if( curr == *head ) {
      *head = curr->next;
    } else if( curr == *tail ) {
      last->next = NULL;
      *tail      = last;
    } else {
      last->next = curr->next;
    }

    free_safe( curr, sizeof( exp_link ) );

  }

  /* If recursive flag set, remove expression as well */
  if( recursive ) {
    expression_dealloc( exp, TRUE );
  }

  PROFILE_END;

}

void fsm_link_add	(	fsm *	table,
		fsm_link **	head,
		fsm_link **	tail
	)

Adds specified FSM to fsm_link element at the end of the list.

Creates a new fsm_link element with the value specified for table. Sets next pointer of element to NULL, sets the tail element to point to the new element and sets the tail value to the new element.

Parameters:

	table	Pointer to FSM structure to store
	head	Pointer to head of FSM list
	tail	Pointer to tail of FSM list

References malloc_safe, fsm_link_s::next, PROFILE, PROFILE_END, and fsm_link_s::table.

Referenced by fsm_db_read(), fsm_var_add(), and fsm_var_bind_stmt().

  { PROFILE(FSM_LINK_ADD);

  fsm_link* tmp;  /* Temporary pointer to newly created fsm_link element */

  tmp = (fsm_link*)malloc_safe( sizeof( fsm_link ) );

  tmp->table = table;
  tmp->next  = NULL;

  if( *head == NULL ) {
    *head = *tail = tmp;
  } else {
    (*tail)->next = tmp;
    *tail         = tmp;
  }

  PROFILE_END;

}

void fsm_link_delete_list

(

fsm_link *

head

)

Deletes entire list specified by head pointer.

Deletes each element of the specified list.

Parameters:

head

Pointer to head fsm_link element of list

References free_safe, fsm_dealloc(), fsm_link_s::next, PROFILE, PROFILE_END, and fsm_link_s::table.

Referenced by funit_clean().

  { PROFILE(FSM_LINK_DELETE_LIST);

  fsm_link* tmp;  /* Temporary pointer to current link in list */

  while( head != NULL ) {

    tmp  = head;
    head = tmp->next;

    /* Deallocate FSM structure */
    fsm_dealloc( tmp->table );
    tmp->table = NULL;

    /* Deallocate fsm_link element itself */
    free_safe( tmp, sizeof( fsm_link ) );

  }

  PROFILE_END;

}

fsm_link* fsm_link_find	(	const char *	name,
		fsm_link *	head
	)

Finds specified FSM structure in fsm_link list.

Returns:

Returns the pointer to the found fsm_link, or NULL if the search was unsuccessful.

Iteratively searches the fsm_link list specified by the head fsm_link element. If a matching FSM is found, the pointer to this element is returned. If the specified FSM structure could not be matched, the value of NULL is returned.

Parameters:

	name	Name of FSM structure to find
	head	Pointer to head of fsm_link list to search

References fsm_s::name, fsm_link_s::next, PROFILE, PROFILE_END, and fsm_link_s::table.

Referenced by fsm_arg_parse_attr().

  { PROFILE(FSM_LINK_FIND);

  fsm_link* curr;  /* Pointer to current fsm_link element */

  curr = head;
  while( (curr != NULL) && (strcmp( curr->table->name, name ) != 0) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( curr );

}

fsm_link* fsm_link_find_by_pos	(	int	line,
		fsm_link *	head
	)

Finds specified FSM structure in fsm_link list based on file position.

Returns:

Returns the pointer to the found fsm_link, or NULL if the search was unsuccessful.

Iteratively searches the fsm_link list specified by the head fsm_link element. If a matching FSM is found, the pointer to this element is returned. If the specified FSM structure could not be matched, the value of NULL is returned.

Parameters:

	line	Line number
	head	Pointer to head of fsm_link list to search

References fsm_s::line, fsm_link_s::next, PROFILE, PROFILE_END, and fsm_link_s::table.

Referenced by funit_db_mod_merge().

  { PROFILE(FSM_LINK_FIND_BY_POS);

  fsm_link* curr;  /* Pointer to current fsm_link element */

  curr = head;
  while( (curr != NULL) && (curr->table->line != line) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( curr );

}

void funit_link_add	(	func_unit *	funit,
		funit_link **	head,
		funit_link **	tail
	)

Adds specified functional unit to funit_link element at the end of the list.

Creates a new funit_link element with the value specified for functional unit. Sets next pointer of element to NULL, sets the tail element to point to the new element and sets the tail value to the new element.

Parameters:

	funit	Functional unit to add to specified functional unit list
	head	Pointer to head funit_link element of list
	tail	Pointer to tail funit_link element of list

References funit_link_s::funit, malloc_safe, funit_link_s::next, PROFILE, and PROFILE_END.

Referenced by db_add_function_task_namedblock(), db_add_instance(), db_read(), and search_init().

  { PROFILE(FUNIT_LINK_ADD);
        
  funit_link* tmp;   /* Temporary pointer to newly created funit_link element */
        
  tmp = (funit_link*)malloc_safe( sizeof( funit_link ) );
        
  tmp->funit = funit;
  tmp->next  = NULL;
        
  if( *head == NULL ) {
    *head = *tail = tmp;
  } else {
    (*tail)->next = tmp;
    *tail         = tmp;
  }

  PROFILE_END;
  
}

void funit_link_delete_list	(	funit_link **	head,
		funit_link **	tail,
		bool	rm_funit
	)

Deletes entire list specified by head pointer.

Deletes each element of the specified list.

Parameters:

	head	Pointer to head funit_link element of list
	tail	Pointer to tail funit_link element of list
	rm_funit	If TRUE, deallocates specified functional unit; otherwise, just deallocates the links

References free_safe, funit_link_s::funit, funit_dealloc(), funit_link_s::next, PROFILE, and PROFILE_END.

Referenced by db_close(), and funit_clean().

  { PROFILE(FUNIT_LINK_DELETE_LIST);

  funit_link* tmp;   /* Temporary pointer to current link in list */

  while( *head != NULL ) {

    tmp   = *head;
    *head = tmp->next;

    /* Deallocate signal */
    if( rm_funit ) {
      funit_dealloc( tmp->funit );
      tmp->funit = NULL;
    }

    /* Deallocate funit_link element itself */
    free_safe( tmp, sizeof( funit_link ) );

  }

  *tail = NULL;

  PROFILE_END;

}

void funit_link_display

(

funit_link *

head

)

Displays specified functional unit list to standard output.

Displays the string contents of the funit_link list pointed to by head to standard output. This function is mainly used for debugging purposes.

Parameters:

head

Pointer to head of funit_link list

References funit_link_s::funit, get_funit_type(), func_unit_s::name, funit_link_s::next, obf_funit, and func_unit_s::type.

  {

  funit_link* curr;    /* Pointer to current funit_link link to display */

  printf( "Functional unit list:\n" );

  curr = head;
  while( curr != NULL ) {
    printf( "  name: %s, type: %s\n", obf_funit( curr->funit->name ), get_funit_type( curr->funit->type ) );
    curr = curr->next;
  }

}

funit_link* funit_link_find	(	const char *	name,
		int	type,
		funit_link *	head
	)

Finds specified functional unit in given funit_link list.

Returns:

Returns the pointer to the found funit_link or NULL if the search was unsuccessful.

Iteratively searches the funit_link list specified by the head funit_link element. If a matching functional unit is found, the pointer to this element is returned. If the specified functional unit could not be matched, the value of NULL is returned.

Parameters:

	name	Name of functional unit to find
	type	Type of functional unit to find
	head	Pointer to head of funit_link list to search

References funit_link_s::funit, func_unit_s::name, funit_link_s::next, PROFILE, PROFILE_END, scope_compare(), and func_unit_s::type.

Referenced by db_add_instance(), db_add_module(), db_read(), fsm_var_add(), fsm_var_bind_expr(), fsm_var_bind_stmt(), and gen_item_resolve().

  { PROFILE(FUNIT_LINK_FIND);

  funit_link* curr;    /* Pointer to current funit_link link */

  curr = head;
  while( (curr != NULL) && (!scope_compare( curr->funit->name, name ) || (curr->funit->type != type)) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( curr );

}

void funit_link_remove	(	func_unit *	funit,
		funit_link **	head,
		funit_link **	tail,
		bool	rm_funit
	)

Searches for and removes specified functional unit link from list.

Searches for and removes the given functional unit from the given list and adjusts list as necessary.

Parameters:

	funit	Pointer to functional unit to find and remove
	head	Pointer to head of functional unit list to remove functional unit from
	tail	Pointer to tail of functional unit list to remove functional unit from
	rm_funit	If set to TRUE, deallocates functional unit as well

References free_safe, funit_link_s::funit, funit_dealloc(), funit_link_s::next, PROFILE, and PROFILE_END.

  { PROFILE(FUNIT_LINK_REMOVE);

  funit_link* curr = *head;  /* Pointer to current functional unit link */
  funit_link* last = NULL;   /* Pointer to last functional unit link traversed */

  assert( funit != NULL );

  /* Search for matching functional unit */
  while( (curr != NULL) && (curr->funit != funit) ) {
    last = curr;
    curr = curr->next;
  }

  if( curr != NULL ) {

    /* Remove the functional unit from the list */
    if( (curr == *head) && (curr == *tail) ) {
      *head = *tail = NULL;
    } else if( curr == *head ) {
      *head = curr->next;
    } else if( curr == *tail ) {
      last->next = NULL;
      *tail      = last;
    } else {
      last->next = curr->next;
    }

    /* Remove the functional unit, if necessary */
    if( rm_funit ) {
      funit_dealloc( curr->funit );
    }

    /* Deallocate the link */
    free_safe( curr, sizeof( funit_link ) );

  }

  PROFILE_END;

}

void gitem_link_add	(	gen_item *	gi,
		gitem_link **	head,
		gitem_link **	tail
	)

Adds specified generate item to the end of specified gitem list.

Creates a new gitem_link element with the value specified for generate item. Sets next pointer of element to NULL, sets the tail element to point to the new element and sets the tail value to the new element.

Parameters:

	gi	Generate item to add to specified gitem_link list
	head	Pointer to head gitem_link element of list
	tail	Pointer to tail gitem_link element of list

References gitem_link_s::gi, malloc_safe, gitem_link_s::next, PROFILE, and PROFILE_END.

Referenced by db_add_gen_item_block(), and gen_item_resolve().

  { PROFILE(GITEM_LINK_ADD);

  gitem_link* tmp;  /* Temporary pointer to newly created gitem_link element */

  tmp = (gitem_link*)malloc_safe( sizeof( gitem_link ) );

  tmp->gi   = gi;
  tmp->next = NULL;

  if( *head == NULL ) {
    *head = *tail = tmp;
  } else {
    (*tail)->next = tmp;
    *tail         = tmp;
  }

  PROFILE_END;

}

void gitem_link_delete_list	(	gitem_link *	head,
		bool	rm_elems
	)

Deletes entire list specified by head pointer.

Deletes each element of the specified list.

Parameters:

	head	Pointer to head gitem_link element of list
	rm_elems	If TRUE, deallocates specified generate item

References free_safe, gen_item_dealloc(), gitem_link_s::gi, gitem_link_s::next, PROFILE, and PROFILE_END.

Referenced by funit_clean(), and instance_dealloc_single().

  { PROFILE(GITEM_LINK_DELETE_LIST);

  gitem_link* tmp;  /* Temporary pointer to current link in list */

  while( head != NULL ) {

    tmp  = head;
    head = tmp->next;

    /* Deallocate generate item */
    gen_item_dealloc( tmp->gi, rm_elems );

    /* Deallocate gitem_link element itself */
    free_safe( tmp, sizeof( gitem_link ) );

  }

  PROFILE_END;

}

void gitem_link_display

(

gitem_link *

head

)

Displays specified generate item list to standard output.

Displays the contents of the gitem_link list pointed to by head to standard output. This function is mainly used for debugging purposes.

Parameters:

head

Pointer to head of gitem_link list

References gen_item_display_block(), gitem_link_s::gi, and gitem_link_s::next.

  {

  gitem_link* curr;  /* Pointer to current gitem_link to display */

  printf( "Generate item list:\n" );

  curr = head;
  while( curr != NULL ) {
    (void)gen_item_display_block( curr->gi );
    curr = curr->next;
  }

}

gitem_link* gitem_link_find	(	gen_item *	gi,
		gitem_link *	head
	)

Finds specified generate item in given gitem_link list.

Returns:

Returns the pointer to the found gitem_link or NULL if the search was unsuccessful.

Iteratively searches the gitem_link list specified by the head gitem_link element. If a matching generate item is found, the pointer to this element is returned. If the specified generate item could not be matched, the value of NULL is returned.

Parameters:

	gi	Pointer to generate item to find
	head	Pointer to head of gitem_link list to search

References gen_item_find(), gitem_link_s::gi, gitem_link_s::next, PROFILE, and PROFILE_END.

Referenced by funit_find_signal().

  { PROFILE(GITEM_LINK_FIND);

  gitem_link* curr;  /* Pointer to current gitem_link */

  curr = head;
  while( (curr != NULL) && (gen_item_find( curr->gi, gi ) == NULL) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( curr );

}

void gitem_link_remove	(	gen_item *	gi,
		gitem_link **	head,
		gitem_link **	tail
	)

Searches for and removes specified generate item link from list.

Deletes specified generate item from the given list, adjusting the head and tail pointers accordingly.

Parameters:

	gi	Pointer to specified generate item to remove
	head	Pointer to head of generate item list
	tail	Pointer to tail of generate item list

References free_safe, gitem_link_s::gi, gitem_link_s::next, PROFILE, and PROFILE_END.

  { PROFILE(GITEM_LINK_REMOVE);

  gitem_link* gil;   /* Pointer to current generate item link */
  gitem_link* last;  /* Pointer to last generate item link traversed */

  gil = *head;
  while( (gil != NULL) && (gil->gi != gi) ) {
    last = gil;
    gil  = gil->next;
  }

  if( gil != NULL ) {

    if( (gil == *head) && (gil == *tail) ) {
      *head = *tail = NULL;
    } else if( gil == *head ) {
      *head = gil->next;
    } else if( gil == *tail ) {
      last->next = NULL;
      *tail      = last;
    } else {
      last->next = gil->next;
    }

    free_safe( gil, sizeof( gitem_link ) );

  }

  PROFILE_END;

}

inst_link* inst_link_add	(	funit_inst *	inst,
		inst_link **	head,
		inst_link **	tail
	)

Adds specified functional unit instance to inst_link element at the end of the list.

Returns:

Returns pointer to newly allocated instance link.

Creates a new inst_link element with the value specified for functional unit instance. Sets next pointer of element to NULL, sets the tail element to point to the new element and sets the tail value to the new element.

Parameters:

	inst	Functional unit instance root to add
	head	Pointer to head inst_link element of list
	tail	Pointer to tail inst_link element of list

References inst_link_s::base, FALSE, inst_link_s::ignore, inst_link_s::inst, malloc_safe, inst_link_s::next, PROFILE, and PROFILE_END.

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

  { PROFILE(INST_LINK_ADD);

  inst_link* tmp;  /* Temporary pointer to newly created inst_link element */

  tmp = (inst_link*)malloc_safe( sizeof( inst_link ) );

  tmp->inst   = inst;
  tmp->ignore = FALSE;
  tmp->base   = FALSE;
  tmp->next   = NULL;

  if( *head == NULL ) {
    *head = *tail = tmp;
  } else {
    (*tail)->next = tmp;
    *tail         = tmp;
  }

  PROFILE_END;

  return( tmp );

}

void inst_link_delete_list

(

inst_link *

head

)

Deletes entire list specified by head pointer.

Deletes each element of the specified list.

Parameters:

head

Pointer to head inst_link element of list

References free_safe, inst_link_s::inst, instance_dealloc(), funit_inst_s::name, inst_link_s::next, PROFILE, and PROFILE_END.

Referenced by db_close().

  { PROFILE(INST_LINK_DELETE_LIST);

  inst_link* tmp;  /* Temporary pointer to current link in list */

  while( head != NULL ) {

    tmp  = head;
    head = tmp->next;

    /* Deallocate instance item */
    instance_dealloc( tmp->inst, tmp->inst->name );

    /* Deallocate inst_link element itself */
    free_safe( tmp, sizeof( inst_link ) );

  }

  PROFILE_END;

}

void inst_link_display

(

inst_link *

head

)

Displays specified instance list to standard output.

Displays the contents of the inst_link list pointed to by head to standard output. This function is mainly used for debugging purposes.

Parameters:

head

Pointer to head of inst_link list

References inst_link_s::inst, instance_display_tree(), and inst_link_s::next.

Referenced by db_read().

  {

  inst_link* curr;  /* Pointer to current inst_link to display */

  printf( "Instance list:\n" );

  curr = head;
  while( curr != NULL ) {
    instance_display_tree( curr->inst );
    curr = curr->next;
  }

}

funit_inst* inst_link_find_by_funit	(	const func_unit *	funit,
		inst_link *	head,
		int *	ignore
	)

Finds specified functional unit instance in given inst_link list.

Returns:

Returns the pointer to the found funit_inst or NULL if the search was unsuccessful.

Iteratively searches the inst_link list specified by the head inst_link element. If a matching instance is found, the pointer to this element is returned. If the specified generate item could not be matched, the value of NULL is returned.

Parameters:

	funit	Functional unit to search for
	head	Pointer to head of inst_link list to search
	ignore	Pointer to integer specifying the number of instances to ignore that match the given functional unit

References inst_link_s::inst, instance_find_by_funit(), inst_link_s::next, PROFILE, and PROFILE_END.

Referenced by exclude_is_assert_excluded(), exclude_set_assert_exclude(), expression_resize(), gen_item_resolve(), ovl_collect(), ovl_display_verbose(), ovl_get_coverage(), ovl_get_funit_stats(), race_check_modules(), and scope_find_funit_from_scope().

  { PROFILE(INST_LINK_FIND_BY_FUNIT);

  inst_link*  curr;         /* Pointer to current inst_link */
  funit_inst* inst = NULL;  /* Pointer to found instance */

  curr = head;
  while( (curr != NULL) && ((inst = instance_find_by_funit( curr->inst, funit, ignore )) == NULL) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( inst );

}

funit_inst* inst_link_find_by_scope	(	char *	scope,
		inst_link *	head
	)

Finds specified functional unit instance in given inst_link list.

Returns:

Returns the pointer to the found funit_inst or NULL if the search was unsuccessful.

Iteratively searches the inst_link list specified by the head inst_link element. If a matching instance is found, the pointer to this element is returned. If the specified generate item could not be matched, the value of NULL is returned.

Parameters:

	scope	Hierarchical scope to search for
	head	Pointer to head of inst_link list to search

References inst_link_s::inst, instance_find_scope(), inst_link_s::next, PROFILE, PROFILE_END, and TRUE.

Referenced by db_read(), db_sync_curr_instance(), instance_only_db_merge(), and instance_only_db_read().

  { PROFILE(INST_LINK_FIND_BY_SCOPE);

  inst_link*  curr;         /* Pointer to current inst_link */
  funit_inst* inst = NULL;  /* Pointer to found instance */

  curr = head;
  while( (curr != NULL) && ((inst = instance_find_scope( curr->inst, scope, TRUE )) == NULL) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( inst );

}

void sig_link_add	(	vsignal *	sig,
		sig_link **	head,
		sig_link **	tail
	)

Adds specified signal to sig_link element at the end of the list.

Creates a new sig_link element with the value specified for sig. Sets next pointer of element to NULL, sets the tail element to point to the new element and sets the tail value to the new element.

Parameters:

	sig	Signal to add to specified signal list
	head	Pointer to head sig_link element of list
	tail	Pointer to tail sig_link element of list

References malloc_safe, sig_link_s::next, PROFILE, PROFILE_END, and sig_link_s::sig.

Referenced by bind_signal(), db_add_signal(), fsm_gather_signals(), memory_collect(), toggle_collect(), and vsignal_db_read().

  { PROFILE(SIG_LINK_ADD);

  sig_link* tmp;   /* Temporary pointer to newly created sig_link element */

  tmp = (sig_link*)malloc_safe( sizeof( sig_link ) );

  tmp->sig  = sig;
  tmp->next = NULL;

  if( *head == NULL ) {
    *head = *tail = tmp;
  } else {
    (*tail)->next = tmp;
    *tail         = tmp;
  }

  PROFILE_END;

}

void sig_link_delete_list	(	sig_link *	head,
		bool	del_sig
	)

Deletes entire list specified by head pointer.

Deletes each element of the specified list.

Parameters:

	head	Pointer to head sig_link element of list
	del_sig	If set to TRUE, deallocates the signal; otherwise, leaves signal alone

References free_safe, sig_link_s::next, PROFILE, PROFILE_END, sig_link_s::sig, and vsignal_dealloc().

Referenced by funit_clean().

  { PROFILE(SIG_LINK_DELETE_LIST);

  sig_link* tmp;   /* Temporary pointer to current link in list */

  while( head != NULL ) {

    tmp  = head;
    head = tmp->next;

    /* Deallocate signal */
    if( del_sig ) {
      vsignal_dealloc( tmp->sig );
      tmp->sig = NULL;
    }

    /* Deallocate sig_link element itself */
    free_safe( tmp, sizeof( sig_link ) );

  }

  PROFILE_END;

}

void sig_link_display

(

sig_link *

head

)

Displays specified signal list to standard output.

Displays the string contents of the sig_link list pointed to by head to standard output. This function is mainly used for debugging purposes.

Parameters:

head

Pointer to head of sig_link list

References vsignal_s::name, sig_link_s::next, obf_sig, and sig_link_s::sig.

  {

  sig_link* curr;    /* Pointer to current sig_link link to display */

  printf( "Signal list:\n" );

  curr = head;
  while( curr != NULL ) {
    printf( "  name: %s\n", obf_sig( curr->sig->name ) );
    curr = curr->next;
  }

}

sig_link* sig_link_find	(	const char *	name,
		sig_link *	head
	)

Finds specified signal in given sig_link list.

Returns:

Returns the pointer to the found sig_link or NULL if the search was unsuccessful.

Iteratively searches the sig_link list specified by the head sig_link element. If a matching signal is found, the pointer to this element is returned. If the specified signal could not be matched, the value of NULL is returned.

Parameters:

	name	Name of signal to find
	head	Pointer to head of sig_link list to search

References vsignal_s::name, sig_link_s::next, PROFILE, PROFILE_END, scope_compare(), and sig_link_s::sig.

Referenced by bind_task_function_namedblock(), covered_create_value_change_cb(), db_add_signal(), db_assign_symbol(), funit_db_mod_merge(), and funit_find_signal().

  { PROFILE(SIG_LINK_FIND);

  sig_link* curr;    /* Pointer to current sig_link link */

  curr = head;
  while( (curr != NULL) && !scope_compare( curr->sig->name, name ) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( curr );

}

stmt_link* stmt_link_add	(	statement *	stmt,
		bool	rm_stmt,
		stmt_link **	head,
		stmt_link **	tail
	)

Adds specified statement to stmt_link element at the beginning of the list.

Creates a new stmt_link element with the value specified for stmt. Sets next pointer of element to head, sets the head element to point to the new element and (possibly) sets the tail value to the new element.

Parameters:

	stmt	Pointer to statement to add to specified statement list
	rm_stmt	Value to specify if statement should be removed when the statement link is deleted
	head	Pointer to head str_link element of list
	tail	Pointer to tail str_link element of list

References expression_s::col, statement_s::exp, malloc_safe, stmt_link_s::next, expression_s::part, statement_s::ppline, PROFILE, PROFILE_END, stmt_link_s::rm_stmt, and stmt_link_s::stmt.

Referenced by db_add_statement(), fsm_var_bind_stmt(), statement_db_read(), and stmt_blk_add_to_remove_list().

  { PROFILE(STMT_LINK_ADD_HEAD);

  stmt_link* tmp;  /* Temporary pointer to newly created stmt_link element */
  stmt_link* curr;

  tmp = (stmt_link*)malloc_safe( sizeof( stmt_link ) );

  tmp->stmt    = stmt;
  tmp->rm_stmt = rm_stmt;
  tmp->next    = NULL;

  if( *head == NULL ) {

    *head = *tail = tmp;

  } else {

    stmt_link* curr = *head;
    stmt_link* last = NULL;

    /* Insert the new statement in order (based on ppline) - start at tail the tail and work to the head */
    while( (curr != NULL) &&
           ((curr->stmt->ppline < stmt->ppline) ||
            ((curr->stmt->ppline == stmt->ppline) &&
             (curr->stmt->exp->col.part.first < stmt->exp->col.part.first))) ) {
      last = curr;
      curr = curr->next;
    }

    if( curr == *head ) {
      tmp->next = *head;
      *head     = tmp;
    } else if( curr == NULL ) {
      (*tail)->next = tmp;
      *tail         = tmp;
    } else {
      tmp->next  = curr;
      last->next = tmp;
    }

  }

  PROFILE_END;

  return( tmp );

}

void stmt_link_delete_list

(

stmt_link *

head

)

Deletes entire list specified by head pointer.

Deletes each element of the specified list.

Parameters:

head

Pointer to head stmt_link element of list

References free_safe, stmt_link_s::next, PROFILE, PROFILE_END, stmt_link_s::rm_stmt, statement_dealloc(), and stmt_link_s::stmt.

Referenced by funit_clean().

  { PROFILE(STMT_LINK_DELETE_LIST);

  stmt_link* curr = head;
  stmt_link* tmp;

  while( curr != NULL ) {

    tmp  = curr;
    curr = curr->next;

    /* Deallocate statement */
    if( tmp->rm_stmt ) {
      statement_dealloc( tmp->stmt );
    }
    tmp->stmt = NULL;

    /* Deallocate stmt_link element itself */
    free_safe( tmp, sizeof( stmt_link ) );

  }

  PROFILE_END;

}

void stmt_link_display

(

stmt_link *

head

)

Displays specified statement list to standard output.

Displays the string contents of the stmt_link list pointed to by head to standard output. This function is mainly used for debugging purposes.

Parameters:

head

Pointer to head of stmt_link list

References statement_s::exp, expression_s::id, expression_s::line, stmt_link_s::next, statement_s::part, stmt_link_s::stmt, and statement_s::suppl.

  {

  stmt_link* curr;   /* Statement list iterator */

  printf( "Statement list:\n" );

  curr = head;
  while( curr != NULL ) {
    assert( curr->stmt != NULL );
    assert( curr->stmt->exp != NULL );
    printf( "  id: %d, line: %d, stmt_head: %u\n", curr->stmt->exp->id, curr->stmt->exp->line, curr->stmt->suppl.part.head );
    curr = curr->next;
  }

}

stmt_link* stmt_link_find	(	int	id,
		stmt_link *	head
	)

Finds specified statement in the given stmt_link list.

Returns:

Returns the pointer to the found stmt_link or NULL if the search was unsuccessful.

Iteratively searches the stmt_link list specified by the head stmt_link element. If a matching statement is found, the pointer to this element is returned. If the specified statement could not be matched, the value of NULL is returned.

Parameters:

	id	ID of statement to find
	head	Pointer to head of stmt_link list to search

References statement_s::exp, expression_s::id, stmt_link_s::next, PROFILE, PROFILE_END, and stmt_link_s::stmt.

Referenced by statement_db_read(), and stmt_blk_add_to_remove_list().

  { PROFILE(STMT_LINK_FIND);

  stmt_link* curr;   /* Statement list iterator */

  curr = head;
  while( (curr != NULL) && (curr->stmt->exp->id != id) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( curr );

}

stmt_link* stmt_link_find_by_pos	(	unsigned int	ppline,
		uint32	first_col,
		stmt_link *	head
	)

Finds specified statement in the given stmt_link list.

Returns:

Returns the pointer to the found stmt_link or NULL if the search was unsuccessful.

Iteratively searches the stmt_link list specified by the head stmt_link element. If a matching statement is found, the pointer to this element is returned. If the specified statement could not be matched, the value of NULL is returned.

Parameters:

	first_col	Preprocessor line number of statement to find First column of statement to find
	head	Pointer to head of stmt_link list to search

References expression_s::col, statement_s::exp, stmt_link_s::next, expression_s::part, statement_s::ppline, PROFILE, PROFILE_END, and stmt_link_s::stmt.

Referenced by funit_db_mod_merge().

  { PROFILE(STMT_LINK_FIND_BY_POS);

  stmt_link* curr;   /* Statement list iterator */

  curr = head;
  while( (curr != NULL) && ((curr->stmt->ppline != ppline) || (curr->stmt->exp->col.part.first != first_col)) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( curr );

}

void stmt_link_unlink	(	statement *	stmt,
		stmt_link **	head,
		stmt_link **	tail
	)

Unlinks the stmt_link specified by the specified statement.

Iterates through given statement list searching for the given statement. When the statement link is found that matches, removes that link from the list and repairs the list.

Parameters:

	stmt	Pointer to the statement to unlink from the given statement list
	head	Pointer to the head of a statement list
	tail	Pointer to the tail of a statement list

References free_safe, stmt_link_s::next, PROFILE, PROFILE_END, and stmt_link_s::stmt.

Referenced by db_remove_statement_from_current_funit(), and stmt_blk_remove().

  { PROFILE(STMT_LINK_UNLINK);

  stmt_link* curr = *head;
  stmt_link* last = NULL;

  while( (curr != NULL) && (curr->stmt != stmt) ) {
    last = curr;
    curr = curr->next;
  }

  if( curr != NULL ) {

    if( (curr == *head) && (curr == *tail) ) {
      *head = *tail = NULL;
    } else if( curr == *head ) {
      *head = (*head)->next;
    } else if( curr == *tail ) {
      last->next = NULL;
      *tail      = last;
    } else {
      last->next = curr->next;
    }

    /* Deallocate the stmt_link */
    free_safe( curr, sizeof( stmt_link ) );

  }

  PROFILE_END;

}

str_link* str_link_add	(	char *	str,
		str_link **	head,
		str_link **	tail
	)

Adds specified string to str_link element at the end of the list.

Returns:

Returns a pointer to newly created string link.

Creates a new str_link element with the value specified for str. Sets next pointer of element to NULL, sets the tail element to point to the new element and sets the tail value to the new element.

Parameters:

	str	String to add to specified list
	head	Pointer to head str_link element of list
	tail	Pointer to tail str_link element of list

References malloc_safe, str_link_s::next, PROFILE, PROFILE_END, str_link_s::range, str_link_s::str, str_link_s::str2, str_link_s::suppl, str_link_s::suppl2, and str_link_s::suppl3.

Referenced by db_add_file_version(), db_add_instance(), directory_load(), exclude_parse_args(), expression_find_rhs_sigs(), merge_parse_args(), merged_cdd_db_read(), ovl_get_coverage(), parse_design(), rank_parse_args(), read_command_file(), score_add_args(), score_parse_args(), search_add_directory_path(), search_add_extensions(), search_add_file(), search_add_include_path(), search_add_no_score_funit(), and sys_task_store_plusarg().

  { PROFILE(STR_LINK_ADD);

  str_link* tmp;  /* Temporary pointer to newly created str_link element */

  tmp = (str_link*)malloc_safe( sizeof( str_link ) );

  tmp->str    = str;
  tmp->str2   = NULL;
  tmp->suppl  = 0x0;
  tmp->suppl2 = 0x0;
  tmp->suppl3 = 0x0;
  tmp->range  = NULL;
  tmp->next   = NULL;

  if( *head == NULL ) {
    *head = *tail = tmp;
  } else {
    (*tail)->next = tmp;
    *tail         = tmp;
  }

  PROFILE_END;

  return( tmp );

}

void str_link_delete_list

(

str_link *

head

)

Deletes entire list specified by head pointer.

Deletes each element of the specified list.

Parameters:

head

Pointer to head str_link element of list

References free_safe, str_link_s::next, PROFILE, PROFILE_END, str_link_s::str, and str_link_s::str2.

Referenced by command_exclude(), command_merge(), command_rank(), command_score(), db_close(), db_create_sensitivity_list(), info_dealloc(), merge_parse_args(), rank_parse_args(), read_command_file(), search_free_lists(), and sys_task_dealloc().

  { PROFILE(STR_LINK_DELETE_LIST);

  str_link* tmp;   /* Temporary pointer to current link in list */

  while( head != NULL ) {

    tmp  = head;
    head = tmp->next;

    /* Deallocate memory for stored string(s) */
    free_safe( tmp->str,  (strlen( tmp->str )  + 1) );
    free_safe( tmp->str2, (strlen( tmp->str2 ) + 1) );

    tmp->str  = NULL;
    tmp->str2 = NULL;

    /* Deallocate str_link element itself */
    free_safe( tmp, sizeof( str_link ) );

  }

  PROFILE_END;

}

void str_link_display

(

str_link *

head

)

Displays specified string list to standard output.

Displays the string contents of the str_link list pointed to by head to standard output. This function is mainly used for debugging purposes.

Parameters:

head

Pointer to head of str_link list

References str_link_s::next, and str_link_s::str.

  {

  str_link* curr;    /* Pointer to current str_link link to display */

  printf( "String list:\n" );

  curr = head;
  while( curr != NULL ) {
    printf( "  str: %s\n", curr->str );
    curr = curr->next;
  }

}

str_link* str_link_find	(	const char *	value,
		str_link *	head
	)

Finds specified string in the given str_link list.

Returns:

Returns the pointer to the found str_link or NULL if the search was unsuccessful.

Iteratively searches the str_link list specifed by the head str_link element. If a matching string is found, the pointer to this element is returned. If the specified string could not be matched, the value of NULL is returned.

Parameters:

	value	String to find in str_link list
	head	Pointer to head link in str_link list to search

References str_link_s::next, PROFILE, PROFILE_END, and str_link_s::str.

Referenced by db_add_instance(), directory_load(), expression_find_rhs_sigs(), funit_db_write(), merged_cdd_db_read(), parser_check_generation(), race_check_modules(), rank_parse_args(), search_add_file(), and sys_task_test_plusargs().

  { PROFILE(STR_LINK_FIND);

  str_link* curr;    /* Pointer to current str_link link */
  
  curr = head;
  while( (curr != NULL) && (strcmp( curr->str, value ) != 0) ) {
    curr = curr->next;
  }

  PROFILE_END;

  return( curr );

}

void str_link_remove	(	char *	str,
		str_link **	head,
		str_link **	tail
	)

Searches for and removes specified string link from list.

Searches specified list for string that matches the specified string. If a match is found, remove it from the list and deallocate the link memory.

Parameters:

	str	Pointer to string to find and remove
	head	Pointer to head of string list
	tail	Pointer to tail of string list

References free_safe, str_link_s::next, PROFILE, PROFILE_END, and str_link_s::str.

Referenced by db_end_module().

  { PROFILE(STR_LINK_REMOVE);

  str_link* curr;  /* Pointer to current string link */
  str_link* last;  /* Pointer to last string link */

  curr = *head;
  last = NULL;
  while( (curr != NULL) && (strcmp( str, curr->str ) != 0) ) {
    last = curr;
    curr = curr->next;
    assert( (curr == NULL) || (curr->str != NULL) );
  }

  if( curr != NULL ) {

    if( (curr == *head) && (curr == *tail) ) {
      *head = *tail = NULL;
    } else if( curr == *head ) {
      *head = curr->next;
    } else if( curr == *tail ) {
      last->next = NULL;
      *tail      = last;
    } else {
      last->next = curr->next;
    }

    /* Deallocate associated string */
    free_safe( curr->str, (strlen( curr->str ) + 1) );

    /* Now deallocate this link itself */
    free_safe( curr, sizeof( str_link ) );

  }

  PROFILE_END;

}