/Users/trevorw/projects/release/covered-0.7.4/src/link.c File Reference

---

Detailed Description

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

11/28/2001

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "link.h"
#include "defines.h"
#include "vsignal.h"
#include "expr.h"
#include "func_unit.h"
#include "util.h"
#include "statement.h"
#include "iter.h"
#include "fsm.h"
#include "gen_item.h"
#include "obfuscate.h"
#include "instance.h"

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.
void	stmt_link_add_head (statement *stmt, stmt_link **head, stmt_link **tail)
	Adds specified statement to stmt_link element at the beginning of the list.
void	stmt_link_add_tail (statement *stmt, stmt_link **head, stmt_link **tail)
	Adds specified statement to stmt_link element at the end of the list.
void	stmt_link_merge (stmt_link **base_head, stmt_link **base_tail, stmt_link *other_head, stmt_link *other_tail)
	Joins two statement links together.
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.
exp_link *	exp_link_find (int id, 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.
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.

---

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 { 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 { 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 { 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 { 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 ); }

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 { 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 { 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 { 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 { 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 ); }

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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { gitem_link* curr; /* Pointer to current gitem_link to display */ printf( "Generate item list:\n" ); curr = head; while( curr != NULL ) { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 ); }

void stmt_link_add_head (  statement *  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 head  Pointer to head str_link element of list tail  Pointer to tail str_link element of list { PROFILE(STMT_LINK_ADD_HEAD); stmt_link* tmp; /* Temporary pointer to newly created stmt_link element */ tmp = (stmt_link*)malloc_safe( sizeof( stmt_link ) ); tmp->stmt = stmt; if( *head == NULL ) { *head = *tail = tmp; tmp->ptr = NULL; } else { tmp->ptr = (stmt_link*)((long int)(*head) ^ (long int)NULL); (*head)->ptr = (stmt_link*)((long int)((*head)->ptr) ^ (long int)tmp); *head = tmp; } PROFILE_END; }

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

Adds specified statement to stmt_link element at the end of the list. Creates a new stmt_link element with the value specified for stmt. Sets next pointer of element to NULL and sets the tail value to the new element. Parameters: stmt  Pointer to statement to add to specified statement list head  Pointer to head str_link element of list tail  Pointer to tail str_link element of list { PROFILE(STMT_LINK_ADD_TAIL); stmt_link* tmp; /* Temporary pointer to newly created stmt_link element */ tmp = (stmt_link*)malloc_safe( sizeof( stmt_link ) ); tmp->stmt = stmt; if( *head == NULL ) { *head = *tail = tmp; tmp->ptr = NULL; } else { tmp->ptr = (stmt_link*)((long int)(*tail) ^ (long int)NULL); (*tail)->ptr = (stmt_link*)((long int)((*tail)->ptr) ^ (long int)tmp); *tail = tmp; } PROFILE_END; }

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 { PROFILE(STMT_LINK_DELETE_LIST); stmt_iter curr; /* Statement list iterator */ stmt_iter_reset( &curr, head ); while( curr.curr != NULL ) { /* Deallocate statement */ statement_dealloc( curr.curr->stmt ); curr.curr->stmt = NULL; head = (stmt_link*)((long int)(curr.curr->ptr) ^ (long int)(curr.last)); if( head != NULL ) { head->ptr = (stmt_link*)((long int)(curr.curr) ^ (long int)(head->ptr)); } /* Deallocate stmt_link element itself */ free_safe( curr.curr, sizeof( stmt_link ) ); stmt_iter_reset( &curr, head ); } 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 { stmt_iter curr; /* Statement list iterator */ printf( "Statement list:\n" ); stmt_iter_reset( &curr, head ); while( curr.curr != NULL ) { assert( curr.curr->stmt != NULL ); assert( curr.curr->stmt->exp != NULL ); printf( " id: %d, line: %d, stmt_head: %u\n", curr.curr->stmt->exp->id, curr.curr->stmt->exp->line, curr.curr->stmt->suppl.part.head ); stmt_iter_next( &curr ); } }

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 { PROFILE(STMT_LINK_FIND); stmt_iter curr; /* Statement list iterator */ stmt_iter_reset( &curr, head ); while( (curr.curr != NULL) && (curr.curr->stmt->exp->id != id) ) { stmt_iter_next( &curr ); } PROFILE_END; return( curr.curr ); }

void stmt_link_merge (  stmt_link **  base_head, stmt_link **  base_tail, stmt_link *  other_head, stmt_link *  other_tail )

Joins two statement links together. Joins two statement links together such that the statements are stored in line order. Assumes that the base list contains at least one statement link. Parameters: base_head  Pointer to head of statement link of first statement link list to merge into base_tail  Pointer to tail of statement link of first statement link list to merge into other_head  Pointer to head of statement link of second statement link list to merge other_tail  Pointer to tail of statement link of second statement link list to merge { PROFILE(STMT_LINK_MERGE); stmt_iter si_base; /* Statement iterator for the base list */ stmt_iter si_base2; /* Statement iterator for the base list */ stmt_iter si_other; /* Statement iterator for the other list */ /* Get next to last statement link in tail list */ stmt_iter_reset( &si_base, *base_head ); stmt_iter_get_line_before( &si_base, other_head->stmt->exp->line ); stmt_iter_reset( &si_other, other_head ); /* The other list should succeed the base list */ if( si_base.curr == NULL ) { stmt_iter_reverse( &si_base ); stmt_iter_next( &si_base ); stmt_iter_reverse( &si_base ); stmt_iter_next( &si_other ); si_base.curr->ptr = (stmt_link*)((long int)(si_base.last) ^ (long int)si_other.last); si_other.last->ptr = (stmt_link*)((long int)(si_other.curr) ^ (long int)si_base.curr); *base_tail = other_tail; /* The other list should precede the base list */ } else if( si_base.last == NULL ) { stmt_iter_next( &si_base ); stmt_iter_next( &si_base ); while( si_other.curr != NULL ) { stmt_iter_next( &si_other ); } stmt_iter_reverse( &si_other ); stmt_iter_next( &si_other ); stmt_iter_reverse( &si_other ); si_base.last->ptr = (stmt_link*)((long int)(si_base.curr) ^ (long int)si_other.curr); si_other.curr->ptr = (stmt_link*)((long int)(si_other.last) ^ (long int)si_base.last); *base_head = other_head; /* Otherwise, the other list needs to be merged into the base list */ } else { stmt_iter_next( &si_other ); stmt_iter_copy( &si_base2, &si_base ); stmt_iter_next( &si_base2 ); stmt_iter_reverse( &si_base ); stmt_iter_next( &si_base ); stmt_iter_reverse( &si_base ); /* Tie up the front of the other list */ si_base.curr->ptr = (stmt_link*)((long int)(si_base.last) ^ (long int)si_other.last); si_other.last->ptr = (stmt_link*)((long int)(si_other.curr) ^ (long int)si_base.curr); while( si_other.curr != NULL ) { stmt_iter_next( &si_other ); } stmt_iter_reverse( &si_other ); stmt_iter_next( &si_other ); stmt_iter_reverse( &si_other ); /* Now tie up the tail */ si_other.curr->ptr = (stmt_link*)((long int)(si_base2.last) ^ (long int)si_other.last); si_base2.last->ptr = (stmt_link*)((long int)(si_other.curr) ^ (long int)si_base2.curr); } /* Finally, clear the IS_STMT_HEAD bit */ other_head->stmt->suppl.part.head = 0; PROFILE_END; }

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 { PROFILE(STMT_LINK_UNLINK); stmt_iter curr; /* Statement list iterator */ stmt_link* next; /* Pointer to next stmt_link in list */ stmt_link* next2; /* Pointer to next after next stmt_link in list */ stmt_link* last2; /* Pointer to last before last stmt_link in list */ stmt_iter_reset( &curr, *head ); while( (curr.curr != NULL) && (curr.curr->stmt != stmt) ) { stmt_iter_next( &curr ); } if( curr.curr != NULL ) { if( (curr.curr == *head) && (curr.curr == *tail) ) { *head = *tail = NULL; } else if( curr.curr == *head ) { next = (stmt_link*)((long int)curr.curr->ptr ^ (long int)curr.last); next2 = (stmt_link*)((long int)next->ptr ^ (long int)curr.curr); next->ptr = next2; *head = next; } else if( curr.curr == *tail ) { last2 = (stmt_link*)((long int)curr.last->ptr ^ (long int)curr.curr); curr.last->ptr = last2; *tail = curr.last; } else { next = (stmt_link*)((long int)curr.curr->ptr ^ (long int)curr.last); next2 = (stmt_link*)((long int)next->ptr ^ (long int)curr.curr); last2 = (stmt_link*)((long int)curr.last->ptr ^ (long int)curr.curr); next->ptr = (stmt_link*)((long int)curr.last ^ (long int)next2); curr.last->ptr = (stmt_link*)((long int)last2 ^ (long int)next); } /* Deallocate the stmt_link */ free_safe( curr.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 { 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 { 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 { 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 { 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 { 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; }

---