
\subsection{Test generation}

\begin{verbatim}
int add_line(user_name)
char *user_name ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parser.y}.

\noindent
The function calls
\begin{enumerate}
\item gen\_err()
\item hash\_name()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item The {\em Yacc} output.
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_x\_reference[]
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item line\_list[]
\item line\_x\_reference[]
\item number\_of\_lines
\end{enumerate}
\end{quotation}


\begin{verbatim}
add_to_d_front(gate)
int gate ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em lists.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item drive\_act()
\item imply\_and\_check()
\item undo()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item d\_front\_last
\item gate\_list[]
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item d\_front\_last
\item d\_front\_count
\item d\_out\_count
\end{enumerate}
\end{quotation}

\begin{verbatim}
add_to_dom_list(fault,line)
int fault , line ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fc\_lists.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item fc()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item dominant\_list
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item dominant\_list
\end{enumerate}
\end{quotation}

\begin{verbatim}
add_to_eq_list(fault,line)
int fault , line ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fc\_lists.c}.

\noindent
The function calls no other function.

\noindent
The function is called by
\begin{enumerate}
\item fc()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item equivalence\_list
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item equivalence\_list
\end{enumerate}
\end{quotation}

\begin{verbatim}
add_to_eq_reps(fault,line)
int fault , line ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fc\_lists.c}.

\noindent
The function calls no other function.

\noindent
The function is called by
\begin{enumerate}
\item fc()
\item The {\em Yacc} output.
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item equivalence\_reps
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item equivalence\_reps
\end{enumerate}
\end{quotation}

\begin{verbatim}
add_to_f_list(fault,line)
int fault , line ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fc\_lists.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item fc()
\item test\_set()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item fault\_list
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item fault\_list
\end{enumerate}
\end{quotation}

\begin{verbatim}
add_to_gate_list((gate,type)
int gate , type ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parser.y}.

\noindent
The function calls
\begin{enumerate}
\item gen\_err()
\item gen\_warn()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item The {\em Yacc} output.
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item fan\_table[][]
\item gate\_list[]
\item line\_list[]
\end{enumerate}
\end{quotation}

\begin{verbatim}
add_to_imply_list(line,val,action)
int line , va , action ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em lists.c}.

\noindent
The function calls
\begin{enumerate}
\item add\_to\_j\_front()
\item do\_message()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item imply\_and\_check()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item imply\_ptr
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item gate\_list[]
\item imply\_ptr
\item line\_list[]
\end{enumerate}
\end{quotation}

\begin{verbatim}
add_to_j_front(site)
int site ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em lists.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item add\_to\_imply\_list()
\item just\_act\_gate()
\item just\_act\_xor()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item j\_front\_last
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item j\_front\_count
\item j\_front\_last
\end{enumerate}
\end{quotation}

\begin{verbatim}
add_to_red_list()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em test\_set.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item test\_set()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item redundant\_list
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item redundant\_list
\end{enumerate}
\end{quotation}

\begin{verbatim}
imply_rec  choose_next_action()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em choose.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item d\_alg()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item d\_front\_last
\item d\_out\_count
\item j\_front\_last
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int compute_val(gate)
int gate ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em compute\_val.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item imply\_and\_check()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item fan\_table[][]
\item gate\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
d_alg()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em d\_alg.c}.

\noindent
The function calls
\begin{enumerate}
\item choose\_next\_action()
\item do\_message()
\item drive\_act()
\item just\_act()
\item print\_fronts()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item drive\_fault()
\item gen\_test()
\item just\_act()
\item just\_act\_gate()
\item just\_act\_xor()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item d\_front\_count
\item d\_out\_count
\item j\_front\_count
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item imply\_ptr
\end{enumerate}
\end{quotation}

\begin{verbatim}
dangling_lines()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parser.y}.

\noindent
The function calls
\begin{enumerate}
\item gen\_err()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item parse().
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item number\_of\_lines
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int drive_act(imply_list,gate)
imply_rec *imply_list ;
int gate ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em drive\_act.c}.

\noindent
The function calls
\begin{enumerate}
\item add\_to\_d\_front()
\item drive\_fault()
\item remove\_from\_d\_front()
\item undo()
\item undo\_message()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item d\_alg()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item gate\_list[]
\end{enumerate}
\end{quotation}

\begin{verbatim}
int drive_fault(gate,dval,c,i)
int gate , dval , c , i ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em drive\_act.c}.

\noindent
The function calls
\begin{enumerate}
\item d\_alg()
\item imply\_and\_check()
\item remove\_from\_d\_front()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item drive\_act()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item fan\_table[][]
\item gate\_list[]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
do_message(num, site,val)
int num , site , val ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item add\_to\_imply\_list()
\item drive\_act()
\item d\_alg()
\item just\_act()
\item just\_act\_gate()
\item just\_act\_xor()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\item trace
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
fail_message(num,line)
int num , line ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item imply\_and\_check()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item trace
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
fc()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fc.c}.

\noindent
The function calls
\begin{enumerate}
\item add\_to\_dom\_list()
\item add\_to\_eq\_list()
\item add\_to\_eq\_reps()
\item add\_to\_f\_list()
\item fc\_warn()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item main() (in {\em collapse.c})
\item main() (in {\em gen\_test\_set.c})
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item active
\item dominant
\item equivalence\_hdr
\item equivalence\_list
\item equivalence\_reps
\item fan\_table[][]
\item first
\item gate\_list[]
\item reps\_hdr
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item active
\item dominant
\item equivalence\_list
\item equivalence\_reps
\item equivalence\_table[][]
\item first
\end{enumerate}
\end{quotation}

\begin{verbatim}
fc_warn(num,site)
int num , site ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fc.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item fc()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int find_gate_name(s)
char *s ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parser.y}.

\noindent
The function calls
\begin{enumerate}
\item gen\_err()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item The {\em Yacc} output.
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item number\_of\_gates
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item gate\_list[]
\item number\_of\_gates
\end{enumerate}
\end{quotation}

\begin{verbatim}
gen_err(err_num,site_name,line_num)
int err_num ;
char *site_name ;
int line_num ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parser.y}.

\noindent
The function calls no other function.

\noindent
The function is called by
\begin{enumerate}
\item add\_line()
\item add\_to\_gate\_list()
\item find\_gate\_name()
\item get\_line()
\item The {\em Yacc} output.
\end{enumerate}

\noindent
The function reads no global variables.

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
gen_lex_err()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em lex.l}.

\noindent
The function calls no other function.

\noindent
The function is called by
\begin{enumerate}
\item lex.l, the {\em Lex} specification file.
\end{enumerate}

\noindent
The function reads no global variables.

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
gen_lex_warn()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em lex.l}.

\noindent
The function calls no other function.

\noindent
The function is called by
\begin{enumerate}
\item lex.l, the {\em Lex} specification file.
\end{enumerate}

\noindent
The function reads no global variables.

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int gen_test(site,flt)
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em test\_gen.c}.

\noindent
The function calls
\begin{enumerate}
\item d\_alg()
\item imply\_and\_check()
\item init\_search()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item gen\_tests()
\item test\_set()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item number\_of\_gates
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item fault\_gate
\item gate\_list[]
\item imply\_ptr
\item line\_list[]
\end{enumerate}
\end{quotation}

\begin{verbatim}
gen_tests(fault_list)
FILE *fault_list ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em test\_gen.c}.

\noindent
The function calls
\begin{enumerate}
\item gen\_test()
\item gen\_tests\_init()
\item print\_test()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item main() (in {\em gen\_tests.c})
\end{enumerate}

\noindent
The function reads no global variables.

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
gen_tests_init()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em test\_gen.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item gen\_tests()
\item test\_set()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item d\_front\_hdr
\item j\_front\_hdr
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item d\_front\_hdr
\item d\_front\_last
\item j\_front\_hdr
\item j\_front\_last
\end{enumerate}
\end{quotation}

\begin{verbatim}
gen_warn(warn_num,site_name,line_num)
int warn_num ;
char *site_name ;
int line_num ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parser.y}.

\noindent
The function calls no other function.

\noindent
The function is called by
\begin{enumerate}
\item add\_to\_gate\_list()
\end{enumerate}

\noindent
The function reads no global variables.

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int get_gate(site)
int site ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em choose.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item show\_step()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item number\_of\_gates
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int get_line(user_name)
char *user_name ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parser.y}.

\noindent
The function calls 
\begin{enumerate}
\item gen\_err()
\item hash\_name()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item show\_step()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item line\_x\_reference[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int hash_name(user_name)
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parser.y}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item add\_line()
\item get\_line()
\end{enumerate}

\noindent
The function reads no global variables.

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
imply_and_check(line,val,action)
int line , val , action ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em imply\_and\_check.c}.

\noindent
The function calls
\begin{enumerate}
\item add\_to\_d\_front()
\item add\_to\_imply\_list()
\item compute\_val()
\item fail\_message()
\item imply\_and\_check()
\item imply\_free\_input()
\item remove\_from\_d\_front()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item drive\_fault()
\item gen\_test()
\item imply\_and\_check()
\item imply\_free\_input()
\item just\_act\_gate()
\item just\_act\_xor()
\item just\_xor()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item fan\_table[][]
\item fault\_gate
\item gate\_list[]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item d\_alg\_error
\end{enumerate}
\end{quotation}

\begin{verbatim}
imply_free_input(gate)
int gate ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em imply\_and\_check.c}.

\noindent
The function calls
\begin{enumerate}
\item imply\_and\_check()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item imply\_and\_check()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item fan\_table[][]
\item gate\_list[]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item d\_alg\_error
\end{enumerate}
\end{quotation}

\begin{verbatim}
init()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parser.y}.

\noindent
The function calls no other function.

\noindent
The function is called by
\begin{enumerate}
\item parse()
\end{enumerate}

\noindent
The function reads no global variables.

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item clk\_cntr[]
\item clk\_names[][]
\item line\_list[]
\item line\_x\_reference[]
\end{enumerate}
\end{quotation}

\begin{verbatim}
init_fc()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fc\_list.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by

\noindent
The function reads the global variables
\begin{enumerate}
\item dominant\_list
\item equivalence\_list
\item equivalence\_reps
\item fault\_list
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item dominant\_list
\item dominant\_hdr
\item equivalence\_hdr
\item equivalence\_list
\item equivalence\_reps
\item fault\_hdr
\item fault\_list
\item reps\_hdr
\end{enumerate}
\end{quotation}

\begin{verbatim}
init_red_list()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em test\_set.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item test\_set()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item redundant\_list
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item redundant\_hdr
\item redundant\_list
\end{enumerate}
\end{quotation}

\begin{verbatim}
init_search()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em test\_gen.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item gen\_test()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item d\_front\_hdr
\item fan\_table[][]
\item first\_pi
\item j\_front\_hdr
\item number\_of\_lines
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item d\_alg\_error
\item d\_front\_count
\item d\_front\_hdr
\item d\_front\_last
\item d\_out\_count
\item gate\_list[]
\item j\_front\_count
\item j\_front\_hdr
\item j\_front\_last
\item line\_list[]
\end{enumerate}
\end{quotation}

\begin{verbatim}
int just_act(imply_list,line)
imply_rec *imply_list ;
int line ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em just\_act.c}.

\noindent
The function calls
\begin{enumerate}
\item d\_alg()
\item do\_message()
\item just\_act\_gate()
\item just\_act\_xor()
\item remove\_from\_j\_front()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item d\_alg()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int just_act_gate(imply_list,line,val)
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em just\_act.c}.

\noindent
The function calls
\begin{enumerate}
\item add\_to\_j\_front()
\item d\_alg()
\item do\_message()
\item imply\_and\_check()
\item just\_and()
\item just\_nand()
\item just\_nor()
\item just\_or()
\item remove\_from\_j\_list()
\item undo()
\item undo\_message()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item just\_act()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int just_act_xor(imply_list,line,val)
imply_rec *imply_list ;
int line , val ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em just\_act.c}.

\noindent
The function calls
\begin{enumerate}
\item add\_to\_j\_front()
\item d\_alg()
\item do\_message()
\item imply\_and\_check()
\item just\_xor()
\item remove\_from\_j\_front()
\item undo()
\item undo\_message()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item just\_act()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item fan\_table[][]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int just_and(gate)
int gate ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em justify.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item just\_act\_gate()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item fan\_table[][]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int just_nand(gate)
int gate ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em justify.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item just\_act\_gate()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item fan\_table[][]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int just_nor(gate)
int gate ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em justify.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item just\_act\_gate()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item fan\_table[][]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int just_or(gate)
int gate ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em justify.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item just\_act\_gate()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item fan\_table[][]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int just_xor(gate,val,t)
int gate , val , t ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em justify.c}.

\noindent
The function calls
\begin{enumerate}
\item imply\_and\_check()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item just\_act\_xor()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item fan\_table[][]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
lex.l - the Lex specification file.
\end{verbatim}
\begin{quotation}
\noindent
This is the file given to {\em Lex} from which he generates the lexical 
analyzer.

\noindent
The function calls
\begin{enumerate}
\item gen\_lex\_err()
\item gen\_lex\_warn()
\end{enumerate}

\noindent
The functions created by {\em Lex}, from this file, are called by the parser
generated by {\em Yacc}.

\noindent
The function reads no global variables.

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
main(argc,argv)   /* in collapse.c  */
int argc ;
char *argv[] ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em collapse.c}.

\noindent
The function calls
\begin{enumerate}
\item fc()
\item parse()
\item print\_eq\_table()
\item print\_fc()
\end{enumerate}

\noindent
The function is called by no other functions.

\noindent
The function reads no global variables.

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
main(argc,argv)   /* in gen_test_set.c  */
int argc ;
char *argv[] ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em gen\_test\_set.c}.

\noindent
The function calls
\begin{enumerate}
\item fc()
\item parse()
\item test\_set()
\end{enumerate}

\noindent
The function is called by no other functions.

\noindent
The function reads no global variables.

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
main(argc,argv)   /* in gen_tests.c  */
int argc ;
char *argv[] ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em gen\_tests.c}.

\noindent
The function calls
\begin{enumerate}
\item gen\_tests()
\item parse()
\end{enumerate}

\noindent
The function is called by no other functions.

\noindent
The function reads no global variables.

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item step
\item trace
\end{enumerate}
\end{quotation}

\begin{verbatim}
main(argc,argv)   /* in parse.c  */
int argc ;
char *argv[] ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parse.c}.

\noindent
The function calls
\begin{enumerate}
\item parse()
\item print\_tables()
\end{enumerate}

\noindent
The function is called by no other functions.

\noindent
The function reads no global variables.

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
int parse(circuit)
FILE *circuit ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parser.y}.

\noindent
The function calls
\begin{enumerate}
\item dangling\_lines()
\item init()
\item yyparse()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item main() (in {\em collapse.c})
\item main() (in {\em gen\_test\_set.c})
\item main() (in {\em gen\_tests.c})
\item main() (in {\em parse.c})
\end{enumerate}

\noindent
The function reads no global variables.

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
parser.y - the Yacc specification file.
\end{verbatim}
\begin{quotation}
\noindent
This file is given to {\em Yacc}, from which it generates a parser.

\noindent
The function calls made by the semantic routines are
\begin{enumerate}
\item add\_line()
\item add\_to\_eq\_reps()
\item add\_to\_gate\_list()
\item find\_gate\_name()
\item gen\_err()
\end{enumerate}

\noindent
The functions created by {\em Yacc} from this file are called by the generated
parser.

\noindent
The function reads the global variables
\begin{enumerate}
\item clk\_cntr
\item gate\_list[]
\item number\_of\_gates
\item number\_of\_lines
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item clk\_cntr
\item clk\_names[][]
\item clk\_table
\item first\_pi
\item first\_po
\end{enumerate}
\end{quotation}

\begin{verbatim}
print_d_front()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item print\_fronts()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item d\_front\_last
\item gate\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables
\end{quotation}

\begin{verbatim}
print_eq_tab()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fc.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item main() (in {\em collapse.c})
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item equivalence\_table[][]
\item line\_list[]
\item number\_of\_lines
\end{enumerate}

\noindent
The function assigns values to no global variables
\end{quotation}

\begin{verbatim}
print_fc()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fc.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item main() (in {\em collapse.c})
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item dominant\_hdr
\item dominant\_list
\item equivalence\_table[][]
\item fault\_hdr
\item fault\_list
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
print_fronts()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls
\begin{enumerate}
\item print\_d\_front()
\item print\_j\_front()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item d\_alg()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item trace
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
print_j_front()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item print\_fronts()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item j\_front\_last
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
print_red_list()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em test\_set.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item test\_set()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list
\item redundant\_hdr
\item redundant\_list
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
print_tables()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em parser.y}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item main() (in {\em parse.c})
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item clk\_cntr[]
\item clk\_names[][]
\item clk\_table[][]
\item fan\_table[][]
\item gate\_list[]
\item line\_list[]
\item number\_of\_gates
\item number\_of\_lines
\item reps\_hdr
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
print_test(ok,line_name,flt)
int ok ;
char *line_name ;
int flt ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item gen\_tests()
\item test\_set()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item first\_pi
\item first\_po
\item gate\_list[]
\item line\_list
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
remove_from_d_front(gate)
int gate ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em lists.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item drive\_act()
\item drive\_fault()
\item imply\_and\_check()
\item undo()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item d\_front\_count
\item d\_front\_hdr
\item d\_front\_last
\item gate\_list[]
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item d\_front\_hdr
\item d\_front\_count
\item d\_out\_count
\end{enumerate}
\end{quotation}

\begin{verbatim}
remove_from_j_front(line)
int line ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em lists.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item just\_act()
\item just\_act\_gate()
\item just\_act\_xor()
\item undo()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item j\_front\_hdr
\item j\_front\_last
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item j\_front\_count
\item j\_front\_hdr
\end{enumerate}
\end{quotation}

\begin{verbatim}
show_step(action)
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em choose.c}.

\noindent
The function calls
\begin{enumerate}
\item get\_gate()
\item get\_line()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item d\_alg()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item d\_front\_hdr
\item d\_front\_last
\item gate\_list[]
\item j\_front\_hdr
\item j\_front\_last
\item line\_list[]
\item step
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
test_set()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em test\_set.c} .

\noindent
The function calls
\begin{enumerate}
\item add\_to\_f\_list()
\item add\_to\_red\_list() 
\item gen\_test()
\item gen\_tests\_init()
\item init\_red\_list()
\item print\_red\_list()
\item print\_test()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item main() (in {\em gen\_test\_set.c})
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item equivalence\_table[][]
\item fault\_hdr
\item fault\_list
\item line\_list
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item equivalence\_table[][]
\item fault\_list
\end{enumerate}
\end{quotation}

\begin{verbatim}
undo(imply_list)
imply_rec *imply_list ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em undo.c}.

\noindent
The function calls
\begin{enumerate}
\item add\_to\_d\_front()
\item remove\_from\_d\_front()
\item remove\_from\_j\_front()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item drive\_act()
\item just\_act\_gate()
\item just\_act\_xor()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list
\end{enumerate}

\noindent
The function assigns values to the global variables
\begin{enumerate}
\item gate\_list[]
\item imply\_ptr
\item line\_list[]
\end{enumerate}
\end{quotation}

\begin{verbatim}
undo_message(num,site,val)
int num , site , val ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item drive\_act()
\item just\_act\_gate()
\item just\_act\_xor()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\item trace
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}

\begin{verbatim}
yyparse()
\end{verbatim}
\begin{quotation}
\noindent
The function is a {\em Yacc} generated function.
\end{quotation}




\subsection{Circuit simulation}

\begin{verbatim}
void add_act_set(act_gate)
int act_gate;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em event\_processor.c}.

\noindent
The function calls  no other functions.

\noindent
The function is called by
\begin{enumerate}
\item event\_processor()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item activated\_set
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item activated\_set
\end{enumerate}
\end{quotation}




\begin{verbatim}
void add_events()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em event\_list\_mngr.c}.

\noindent
The function calls  no other functions.

\noindent
The function is called by
\begin{enumerate}
\item event\_list\_mngr()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item scheduled\_event\_set
\item event\_list[]
\item time
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item event\_list[]
\item next\_event
\item scheduled\_event\_set
\end{enumerate}
\end{quotation}




\begin{verbatim}
void add_input_event(time, line, value)
int time, line, value;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em event\_list\_mngr.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item record\_ip\_events()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item event\_list[]
\item time
\end{enumerate}

\noindent
The function assigns values to  global variables.
\begin{enumerate}
\item event\_list[]
\end{enumerate}
\end{quotation}




\begin{verbatim}
void add_sched_event (line, value)
int line, value;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em evaluator.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item evaluator()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item scheduled\_event\_set
\item number\_of\_events
\item number\_gates\_act
\end{enumerate}

\noindent
The function assigns values to  global variables.
\begin{enumerate}
\item scheduled\_event\_set
\end{enumerate}
\end{quotation}



\begin{verbatim}
void ask_step()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls 
\begin{enumerate}
\item get\_line()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item simulate()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item step
\item trace
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item observe\_lines[]
\item act\_flag
\item event\_flag
\item list\_flag
\item list\_flag
\end{enumerate}
\end{quotation}



\begin{verbatim}
int compute_level(gate_index)
int gate_index;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em init\_ckt.c}.

\noindent
The function calls 
\begin{enumerate}
\item compute\_level()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item levelize()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\item first\_pi
\item first\_po
item number\_of\_lines
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item gate\_list[]
\end{enumerate}
\end{quotation}




\begin{verbatim}
void evaluator()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em evaluator.c}.

\noindent
The function calls 
\begin{enumerate}
\item compute\_val()
\item add\_sched\_event()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item simulate()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item fan\_table[][]
\item activated\_set
\end{enumerate}

\noindent
The function assigns values to  global variables.
\begin{enumerate}
\item activated\_set
\end{enumerate}
\end{quotation}



\begin{verbatim}
void event_list_mngr(task)
int task;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em event\_list\_mngr.c}.

\noindent
The function calls 
\begin{enumerate}
\item initialize\_event\_list()
\item add\_events()
\item pick\_events()
\item show\_step()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item simulate()
\end{enumerate}

\noindent
The function reads no global variables

\noindent
The function assigns values to no global variables
\end{quotation}



\begin{verbatim}
void event_processor()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em event\_processor.c}.

\noindent
The function calls  
\begin{enumerate}
\item update\_value()
\item add\_act\_set()
\item shoe\_step()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item simulate()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item present\_event
\item first\_pi
\item number\_gates\_act
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item present\_event
\item number\_gates\_act
\end{enumerate}
\end{quotation}




\begin{verbatim}
void initialize(pi_events)
FILE *pi_events;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em init.c}.

\noindent
The function calls  
\begin{enumerate}
\item get\_line()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item simulate()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item number\_of\_lines
\item number\_of\_gates
\item gate\_list[]
\item line\_list[]
\item fan\_table[][]
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item observe\_lines[]
\item gate\_list[]
\item line\_list[]
\end{enumerate}
\end{quotation}



\begin{verbatim}
void initialize_ckt()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em init\_ckt.c}.

\noindent
The function calls 
\begin{enumerate}
\item levelize()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item simulate()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item first\_pi
\item first\_po
\item logic\_values
\item gate\_list[]
\item line\_list[]
\item number\_of\_gates
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item line\_list[]
\item gate\_list[]
\item scheduled\_event\_set
\item activated\_set
\end{enumerate}
\end{quotation}



\begin{verbatim}
void initialize_event_list()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em event\_list\_mngr.c}.

\noindent
The function calls 
\begin{enumerate}
\item record\_ip\_events()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item event\_list\_mngr()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item event\_list[]
\item first\_pi
\item first\_po
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item event\_list[]
\item number\_of\_events
\item number\_gates\_act
\end{enumerate}
\end{quotation}





\begin{verbatim}
int levelize()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em init\_ckt.c}.

\noindent
The function calls 
\begin{enumerate}
\item compute\_level()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item initialize\_ckt()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item first\_po
item number\_of\_gates
\end{enumerate}

\noindent
The function assigns values to no global variables
\end{quotation}




\begin{verbatim}
main(argc,argv)    
int argc ;
char *argv[] ;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em gsim.c}.

\noindent
The function calls  
\begin{enumerate}
\item parse()
\item simulate()
\end{enumerate}

\noindent
The function is called by no other functions.

\noindent
The function reads no global variables

\noindent
The function assigns values to global variables
\begin{enumerate}
\item step
\item trace
\end{enumerate}
\end{quotation}




\begin{verbatim}
void pick_events()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em event\_list\_mngr.c}.

\noindent
The function calls  no other functions.

\noindent
The function is called by
\begin{enumerate}
\item event\_list\_mngr()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item present\_event
\item time
\item number\_of\_events
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item event\_list[]
\item number\_of\_events
\end{enumerate}
\end{quotation}



\begin{verbatim}
void print_act_set()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by 
\begin{enumerate}
\item show\_step()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item activated\_set
\item gate\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void print_curr\_event()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by 
\begin{enumerate}
\item show\_step()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item line\_list[]
\item present\_event
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void print_event_list()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by 
\begin{enumerate}
\item show\_step()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item event\_list[]
\item line\_list[]
\item time
\item simulation\_length
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}


\begin{verbatim}
void print_lines()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by 
\begin{enumerate}
\item show\_step()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item line\_list[]
\item observe\_lines[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void print_line_results()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by 
\begin{enumerate}
\item print\_results()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item line\_list[]
\item observe\_lines[]
\item simulation\_length
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void print_results()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls 
\begin{enumerate}
\item print\_line\_results()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item simulate()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item line\_list[]
\item gate\_list[]
\item fan\_table[][]
\item simulation\_length
\item trace
\item first\_pi
\item first\_po
\item number\_of\_gates
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void print_sched_set()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by 
\begin{enumerate}
\item show\_step()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item scheduled\_event\_set
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}


\begin{verbatim}
void read_input(ifp)
FILE *ifp;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em read.c}.

\noindent
The function calls  no other functions.

\noindent
The function is called by
\begin{enumerate}
\item simulate()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item first\_pi
\item first\_po
\item gate\_list[]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item line\_list[]
\item simulation\_length
\end{enumerate}
\end{quotation}




\begin{verbatim}
void record_ip_events(input_gate)
int input_gate;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em event\_list\_mngr.c}.

\noindent
The function calls 
\begin{enumerate}
\item add\_input\_event()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item initialize\_event\_list()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void scheduler()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em scheduler.c}.

\noindent
The function calls  
\begin{enumerate}
\item transport\_delay()
\item show\_step()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item controller()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item scheduled\_event\_set
\end{enumerate}

\noindent
The function assigns values to no global variables
\end{quotation}


\begin{verbatim}
void show_step(num)
int num;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls 
\begin{enumerate}
\item print\_act\_set()
\item print\_sched\_set()
\item print\_event\_list()
\item print\_lines()
\item print\_curr\_event()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item simulate()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item step
\item act\_flag
\item event\_flag
\item list\_flag
\item line\_flag
\item time
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}


\begin{verbatim}
void simulate(pi_events)
FILE *pi_events;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em controller.c}.

\noindent
The function calls 
\begin{enumerate}
\item read\_input()
\item initialize()
\item ask\_step()
\item event\_list\_mngr()
\item event\_processor()
\item evaluator()
\item scheduler()
\item show\_step()
\item print\_results()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item main()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item event\_list[]
\item time
\item next\_event
\end{enumerate}

\noindent
The function assigns values to global variables.
\begin{enumerate}
\item present\_event
\end{enumerate}
\end{quotation}




\begin{verbatim}
int transport_delay(line, value)
int line, value;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em delay\_models.c}.

\noindent
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item scheduler()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item gate\_list[]
\item time
\item next\_event
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void update_value()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em event\_processor.c}.

\noindent
The function calls  no other functions.

\noindent
The function is called by
\begin{enumerate}
\item event\_processor()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item present\_event
\item line\_list[]
\item gate\_list[]
\item time
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item line\_list[]
\item gate\_event
\end{enumerate}
\end{quotation}


\subsection{Fault simulation}


\begin{verbatim}
void activate_faults()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fault\_sim.c}.

\noindent
The function calls  macros
\begin{enumerate}
\item ZEROUT()
\item SETBIT()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item fault\_sim()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item number\_of\_lines
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item line\_list[]
\end{enumerate}
\end{quotation}



\begin{verbatim}
void ask_lists()
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em options.c}.

\noindent
The function calls no  macros.

\noindent
The function calls other functions
\begin{enumerate}
\item get\_line()
\item print\_observe\_lists()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item ask\_options()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item number\_of\_lines
\item trace
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item observe\_list[]
\end{enumerate}
\end{quotation}




\begin{verbatim}
void ask_options()
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em options.c}.

\noindent
The function calls no  macros.

\noindent
The function calls other functions
\begin{enumerate}
\item ask\_lists()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item print\_det\_faults()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item trace

\end{enumerate}

\noindent
The function assigns values to no global variables
\end{quotation}



\begin{verbatim}
void assign_ip_vector(vector)
char *vector;
\end{verbatim}

\begin{quotation}

\noindent
The function appears in the file {\em readnew.c}.

\noindent
The function calls  no macros.

\noindent
The function calls no other functions.

\noindent
The function is called by 
\begin{enumerate}
\item read\_in()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item first\_pi
\item first\_po
\item gate\_list[]
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item line\_list[]
\end{enumerate}
\end{quotation}



\begin{verbatim}
int compute_level(gate_index)
int gate_index;
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em init.c}.

\noindent
The function calls no  macros.

\noindent
The function calls no other functions

\noindent
The function is called by 
\begin{enumerate}
\item levelize()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item first\_po
\item first\_pi
\item gate\_list[]
\item line\_list[]
\item number\_of\_lines
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item gate\_list[]
\end{enumerate}
\end{quotation}



\begin{verbatim}
void change_d_db()
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em init.c}.

\noindent
The function calls no  macros.

\noindent
The function calls no other functions

\noindent
The function is called by 
\begin{enumerate}
\item fault\_sim()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item number\_of\_lines
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item line\_list[]
\end{enumerate}
\end{quotation}



\begin{verbatim}
void ch_dest_gate_lcount(line_ind, gate_ind)
int line_ind, gate_ind;
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em init.c}.

\noindent
The function calls no  macros.

\noindent
The function calls other functions
\begin{enumerate}
\item compute\_val()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item initialize\_ckt()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\end{enumerate}
\end{quotation}



\begin{verbatim}
void drop_fault(linenum, sa_value)
int linenum, sa_value;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fault\_sim.c}.

\noindent
The function calls  macros
\begin{enumerate}
\item ZEROUT()
\item SETBIT()
\item FCOMPLEMENT()
\item FINTERSECT()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item print\_faults()
\item print\_det\_faults()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item sim\_f\_list0
\item sim\_f\_list1
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item sim\_f\_list0
\item sim\_f\_list1
\end{enumerate}
\end{quotation}



\begin{verbatim}
float fault_coverage(faults_detected)
int faults_detected;
\end{verbatim}

\begin{quotation}

\noindent
The function appears in the file {\em stats.c}.

\noindent
The function calls  no macros.

\noindent
The function calls no other functions.

\noindent
The function is called by 
\begin{enumerate}
\item print\_faults()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item number\_of\_lines
\end{enumerate}


\noindent
The function assigns values to no global variables.
\end{quotation}


\begin{verbatim}
void fault_sim()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fault\_sim.c}.

\noindent
The function calls  functions
\begin{enumerate}
\item change\_d\_db()
\item activate\_faults()
\item levelize()
\item fpropogate()
\item print\_det\_faults()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item main() (file {\em fsim.c})
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item ckt\_depth
\item first\_pi
\end{enumerate}

\noindent
The function assigns values to no global variables
\end{quotation}



\begin{verbatim}
void fpropogate(gate)
int gate;
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fault\_sim.c}.

\noindent
The function calls  macros
\begin{enumerate}
\item FUNION()
\item FCOPY()
\item FINTERSECT()
\item FCOMPLEMENT()
\end{enumerate}

\noindent
The function calls functions
\begin{enumerate}
\item get\_f\_list()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item fpropagate()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\item fan\_table[][]
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item line\_list[]
\end{enumerate}
\end{quotation}



\begin{verbatim}
void gen_exhaust_test()
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em gen\_test.c}.

\noindent
The function calls  macros
\begin{enumerate}
\item FINTERSECT()
\item SETBIT()
\item BITSET()
\item COPY()
\end{enumerate}

\noindent 
The function calls no other functions.

\noindent
The function is called by
\begin{enumerate}
\item show\_step()
\item set\_trace\_options()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item first\_po
\item first\_pi
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void gen_random_test()
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em gen\_test.c}.

\noindent
The function calls no  macros.

\noindent
The function calls functions
\begin{enumerate}
\item rand\_vector()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item show\_step()
\item set\_trace\_options()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item first\_po
\item first\_pi
\item step
\item v\_number
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void gen_wtd_test()
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em gen\_test.c}.

\noindent
The function calls no  macros.

\noindent
The function calls functions
\begin{enumerate}
\item rand\_vector()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item show\_step()
\item set\_trace\_options()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item first\_po
\item first\_pi
\item step
\item v\_number
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void get_f_list(gate, f_list_c, f_list_nc)
int gate;
int f_list_c[MAXINTS], f_list_nc[MAXINTS];
\end{verbatim}
\begin{quotation}
\noindent
The function appears in the file {\em fault\_sim.c}.

\noindent
The function calls  macros
\begin{enumerate}
\item ZEROUT()
\item FUNION()
\item FCOMPLEMENT()
\item FINTERSECT()
\end{enumerate}

\noindent
The function is called by
\begin{enumerate}
\item fpropagate()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\item fan\_table[][]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void initialize_ckt()
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em init.c}.

\noindent
The function calls no  macros.

\noindent
The function calls other functions
\begin{enumerate}
\item levelize()
\item ch\_dest\_gate\_lcount()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item fault\_sim()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\item first\_pi
\item first\_po
\item ckt\_depth
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item gate\_list[]
\item line\_list[]
\end{enumerate}
\end{quotation}



\begin{verbatim}
int levelize()
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em init.c}.

\noindent
The function calls no  macros.

\noindent
The function calls other functions
\begin{enumerate}
\item compute\_level()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item fault\_sim()
\item initialize\_ckt()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item first\_po
\item first\_pi
\item gate\_list[]
\item number\_of\_gates
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item gate\_list[]
\end{enumerate}
\end{quotation}


\begin{verbatim}
void print_det_faults()
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls macros
\begin{enumerate}
\item ZEROUT()
\item FINTERSECT()
\end{enumerate}

\noindent
The function calls other functions
\begin{enumerate}
\item drop\_fault()
\item ask\_options()
\item print\_faults()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item fault\_sim()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item gate\_list[]
\item number\_of\_gates
\item faults\_to\_drop[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void print_fault_list(fault_vector0, fault_vector1)
int *fault_vector0, *fault_vector1;\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls macros
\begin{enumerate}
\item BITSET()
\end{enumerate}

\noindent
The function calls no other functions

\noindent
The function is called by 
\begin{enumerate}
\item fault\_sim()
\item print\_observe\_lists()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item number\_of\_lines
\item faults\_to\_drop[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void print_faults(fault_vector0, fault_vector1)
int *fault_vector0, *fault_vector1;
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls macros
\begin{enumerate}
\item BITSET()
\end{enumerate}

\noindent
The function calls other functions
\begin{enumerate}
\item drop\_fault()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item print\_det\_faults()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item line\_list[]
\item number\_of\_lines
\item faults\_to\_drop[]
\item number\_detected\_faults
\item step
\item trace
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item faults\_to\_drop[]
\item number\_detected\_faults
\end{enumerate}
\end{quotation}



\begin{verbatim}
void print_observe_lists(observe_list)
int observe_list[];
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em print.c}.

\noindent
The function calls macros
\begin{enumerate}
\item ZEROUT()
\item FINTERSECT()
\end{enumerate}

\noindent
The function calls other functions
\begin{enumerate}
\item print\_fault\_list()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item ask\_lists()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item observe\_list[]
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
char* rand_vector(seed,sig_pr)
int *seed;
float sig_pr[];
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em gen\_test.c}.

\noindent
The function calls no  macros.

\noindent
The function calls no other functions.

\noindent
The function is called by 
\begin{enumerate}
\item gen\_wtd\_test()
\item gen\_random\_test()
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item first\_po
\item first\_pi
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void read_flist(flist)
FILE  *flist;
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em read.c}.

\noindent
The function calls macros
\begin{enumerate}
\item SETBIT()
\end{enumerate}

\noindent
The function calls other functions
\begin{enumerate}
\item get\_line()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item main() (file {\em fsim.c})
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item number\_of\_lines
\end{enumerate}

\noindent
The function assigns values to no global variables.
\end{quotation}


\begin{verbatim}
void read_in(test_vector_file)
FILE *test_vector_file;
\end{verbatim}

\begin{quotation}

\noindent
The function appears in the file {\em readnew.c}.

\noindent
The function calls  no macros.

\noindent
The function calls other functions
\begin{enumerate}
\item assign\_ip\_vector()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item main() (file {\em fsim.c})
\end{enumerate}

\noindent
The function reads no global variables.


\noindent
The function assigns values to no global variables.
\end{quotation}



\begin{verbatim}
void read_vector(vector)
char vector[];
\end{verbatim}
\begin{quotation}

\noindent
The function appears in the file {\em read.c}.

\noindent
The function calls no macros.

\noindent
The function calls no other functions.

\noindent
The function is called by 
\begin{enumerate}
\item main() (file {\em fsim.c})
\end{enumerate}

\noindent
The function reads the global variables
\begin{enumerate}
\item first\_pi
\item first\_po
\item line\_list[]
\item gate\_list[]
\item number\_test\_vectors
\end{enumerate}

\noindent
The function assigns values to global variables
\begin{enumerate}
\item line\_list[]
\end{enumerate}
\end{quotation}


\begin{verbatim}
void set_trace_options(trace_arg)
char * trace_arg;
\end{verbatim}

\begin{quotation}

\noindent
The function appears in the file {\em show\_step.c}.

\noindent
The function calls  no macros.

\noindent
The function calls other functions
\begin{enumerate}
\item gen\_exhaust\_test()
\item gen\_random\_test()
\item gen\_wtd\_test()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item main() (file {\em fsim.c})
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item trace
\end{enumerate}


\noindent
The function assigns values to global variables
\begin{enumerate}
\item vector\_file
\end{enumerate}
\end{quotation}




\begin{verbatim}
void show_step()
\end{verbatim}

\begin{quotation}

\noindent
The function appears in the file {\em show\_step.c}.

\noindent
The function calls  no macros.

\noindent
The function calls other functions
\begin{enumerate}
\item gen\_exhaust\_test()
\item gen\_random\_test()
\item gen\_wtd\_test()
\end{enumerate}

\noindent
The function is called by 
\begin{enumerate}
\item main() (file {\em fsim.c})
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item step
\end{enumerate}


\noindent
The function assigns values to global variables
\begin{enumerate}
\item vector\_file
\end{enumerate}
\end{quotation}




\begin{verbatim}
void sig_prob_query(sig_pr)
float sig_pr[];
\end{verbatim}

\begin{quotation}

\noindent
The function appears in the file {\em show\_step.c}.

\noindent
The function calls  no macros.

\noindent
The function calls no other functions.

\noindent
The function is called by 
\begin{enumerate}
\item gen\_wtd\_test()
\end{enumerate}

\noindent
The function reads global variables
\begin{enumerate}
\item trace
\item first\_pi
\item first\_po
\item gate\_list[]
\end{enumerate}


\noindent
The function assigns values to global variables
\begin{enumerate}
\item line\_list[]
\item sig\_pr[]
\end{enumerate}
\end{quotation}

