statement.h File Reference

Contains functions to create, manipulate and deallocate statements. More...

#include "defines.h"

Go to the source code of this file.

Functions
statement *	statement_create (expression *exp, func_unit *funit, unsigned int ppline)
	Creates new statement structure.
void	statement_size_elements (statement *stmt, func_unit *funit)
	Sizes all expressions for the given statement block.
void	statement_db_write (statement *stmt, FILE *ofile, bool ids_issued)
	Writes specified statement to the specified output file.
void	statement_db_write_tree (statement *stmt, FILE *ofile)
	Writes specified statement tree to the specified output file.
void	statement_db_write_expr_tree (statement *stmt, FILE *ofile)
	Writes specified expression trees for given statement block to specified output file.
void	statement_db_read (char **line, func_unit *curr_funit, int read_mode)
	Reads in statement line from specified string and stores statement in specified functional unit.
void	statement_assign_expr_ids (statement *stmt, func_unit *funit)
	Assigns unique expression IDs to each expression in the given statement block.
bool	statement_connect (statement *curr_stmt, statement *next_stmt, int conn_id)
	Connects statement sequence to next statement and sets stop bit.
int	statement_get_last_line (statement *stmt)
	Calculates the last line of the specified statement tree.
void	statement_find_rhs_sigs (statement *stmt, str_link **head, str_link **tail)
	Creates a list of all signals on the RHS of expressions in the given statement block.
statement *	statement_find_statement (statement *curr, int id)
	Searches for statement with ID in the given statement block.
bool	statement_contains_expr_calling_stmt (statement *curr, statement *stmt)
	Searches the specified statement block for expression that calls the given stmt.
void	statement_dealloc_recursive (statement *stmt, bool rm_stmt_blks)
	Recursively deallocates specified statement tree.
void	statement_dealloc (statement *stmt)
	Deallocates statement memory and associated expression tree from the heap.

---

Detailed Description

Contains functions to create, manipulate and deallocate statements.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

5/1/2002

---

Function Documentation

void statement_assign_expr_ids	(	statement *	stmt,
		func_unit *	funit
	)

Assigns unique expression IDs to each expression in the given statement block.

Parameters:

	stmt	Pointer to statement block to traverse
	funit	Pointer to functional unit containing this statement block

Exceptions:

anonymous

statement_assign_expr_ids statement_assign_expr_ids statement_assign_expr_ids expression_assign_expr_ids

Recursively traverses the entire statement block and assigns unique expression IDs for each expression tree that it finds.

References statement_s::exp, expression_assign_expr_ids(), statement_s::next_false, statement_s::next_true, statement_s::part, PROFILE, PROFILE_END, statement_assign_expr_ids(), and statement_s::suppl.

Referenced by gen_item_assign_ids(), and statement_assign_expr_ids().

  { PROFILE(STATEMENT_ASSIGN_EXPR_IDS);

  if( stmt != NULL ) {

    /* Assign unique expression IDs */
    expression_assign_expr_ids( stmt->exp, funit );

    /* Traverse down the rest of the statement block */
    if( (stmt->next_true == stmt->next_false) && (stmt->suppl.part.stop_true == 0) ) {
      statement_assign_expr_ids( stmt->next_true, funit );
    } else {
      if( stmt->suppl.part.stop_false == 0 ) {
        statement_assign_expr_ids( stmt->next_false, funit );
      }
      if( stmt->suppl.part.stop_true == 0 ) {
        statement_assign_expr_ids( stmt->next_true, funit );
      }
    }

  }

  PROFILE_END;

}

bool statement_connect	(	statement *	curr_stmt,
		statement *	next_stmt,
		int	conn_id
	)

Connects statement sequence to next statement and sets stop bit.

Parameters:

	curr_stmt	Pointer to statement sequence to traverse.
	next_stmt	Pointer to statement to connect ends to.
	conn_id	Current connection identifier (used to eliminate infinite looping and connection overwrite)

Returns:

Returns TRUE if statement was connected to the given statement list; otherwise, returns FALSE.

Recursively traverses the specified stmt sequence. When it reaches a statement that has either next_true or next_false set to NULL, sets next_true and/or next_false of that statement to point to the next_stmt statement.

References statement_s::conn_id, statement_s::exp, EXPR_IS_CONTEXT_SWITCH, FALSE, statement_s::next_false, statement_s::next_true, statement_s::part, PROFILE, PROFILE_END, statement_connect(), statement_s::suppl, and TRUE.

Referenced by db_statement_connect(), and statement_connect().

  { PROFILE(STATEMENT_CONNECT);

  bool retval = FALSE;  /* Return value for this function */

  assert( curr_stmt != NULL );
  assert( next_stmt != NULL );

  /* Specify that this statement has been traversed */
  curr_stmt->conn_id = conn_id;

  //display( "In statement_connect", curr_stmt, next_stmt, conn_id );

  /* If both paths go to the same destination, only parse one path */
  if( curr_stmt->next_true == curr_stmt->next_false ) {
    
    /* If the TRUE path is NULL, connect it to the new statement */
    if( curr_stmt->next_true == NULL ) {
      //display( "Setting next_true to next_stmt", curr_stmt, next_stmt, conn_id );
      curr_stmt->next_true  = next_stmt;
      /* If the current statement is a wait statement, don't connect next_false path */
      if( !EXPR_IS_CONTEXT_SWITCH( curr_stmt->exp ) ) {
        //display( "Setting next_false to next_stmt", curr_stmt, next_stmt, conn_id );
        curr_stmt->next_false = next_stmt;
      }
      if( curr_stmt->next_true->conn_id == conn_id ) {
        //display( "Setting stop_true and stop_false", curr_stmt, next_stmt, conn_id );
        curr_stmt->suppl.part.stop_true  = 1;
        curr_stmt->suppl.part.stop_false = 1;
      } else {
        curr_stmt->next_true->conn_id = conn_id;
      }
      retval = TRUE;
    /* If the TRUE path leads to a loop/merge, set the stop bit and stop traversing */
    } else if( curr_stmt->next_true->conn_id == conn_id ) {
      //display( "Setting stop_true and stop_false", curr_stmt, next_stmt, conn_id );
      curr_stmt->suppl.part.stop_true  = 1;
      curr_stmt->suppl.part.stop_false = 1;
    /* Continue to traverse the TRUE path if the next_stmt does not match this statement */
    } else if( curr_stmt->next_true != next_stmt ) {
      //display( "Traversing next_true path", curr_stmt, next_stmt, conn_id );
      retval |= statement_connect( curr_stmt->next_true, next_stmt, conn_id );
    }

  } else {

    /* Traverse FALSE path */
    if( curr_stmt->next_false == NULL ) {
      if( !EXPR_IS_CONTEXT_SWITCH( curr_stmt->exp ) ) {
        //display( "Setting next_false to next_stmt", curr_stmt, next_stmt, conn_id );
        curr_stmt->next_false = next_stmt;
        if( curr_stmt->next_false->conn_id == conn_id ) {
          //display( "Setting stop_false", curr_stmt, next_stmt, conn_id );
          curr_stmt->suppl.part.stop_false = 1;
        } else {
          curr_stmt->next_false->conn_id = conn_id; 
        }
        retval = TRUE;
      }
    /* If the FALSE path leads to a loop/merge, set the stop bit and stop traversing */
    } else if( curr_stmt->next_false->conn_id == conn_id ) {
      //display( "Setting stop_false", curr_stmt, next_stmt, conn_id );
      curr_stmt->suppl.part.stop_false = 1;
    /* Continue to traverse the FALSE path if the next statement does not match this statement */
    } else if( (curr_stmt->next_false != next_stmt) ) {
      //display( "Traversing next_false path", curr_stmt, next_stmt, conn_id );
      retval |= statement_connect( curr_stmt->next_false, next_stmt, conn_id );
    }

    /* Traverse TRUE path */
    if( curr_stmt->next_true == NULL ) {
      //display( "Setting next_true to next_stmt", curr_stmt, next_stmt, conn_id );
      curr_stmt->next_true = next_stmt;
      if( curr_stmt->next_true->conn_id == conn_id ) {
        //display( "Setting stop_true", curr_stmt, next_stmt, conn_id );
        curr_stmt->suppl.part.stop_true = 1;
      } else {
        curr_stmt->next_true->conn_id = conn_id;
      }
      retval = TRUE;
    /* If the TRUE path leads to a loop/merge, set the stop bit and stop traversing */
    } else if( curr_stmt->next_true->conn_id == conn_id ) {
      //display( "Setting stop_true", curr_stmt, next_stmt, conn_id );
      curr_stmt->suppl.part.stop_true = 1;
    /* Continue to traverse the TRUE path if the next statement does not match this statement */
    } else if( curr_stmt->next_true != next_stmt ) {
      //display( "Traversing next_true path", curr_stmt, next_stmt, conn_id );
      retval |= statement_connect( curr_stmt->next_true, next_stmt, conn_id );
    }

  }

  PROFILE_END;

  return( retval );

}

bool statement_contains_expr_calling_stmt	(	statement *	curr,
		statement *	stmt
	)

Searches the specified statement block for expression that calls the given stmt.

Returns:

Returns TRUE if the given statement contains the given expression; otherwise, returns FALSE.

Parameters:

	curr	Pointer to current statement to traverse
	stmt	Pointer to statement to find in the associated expression tree

References statement_s::exp, expression_contains_expr_calling_stmt(), statement_s::next_false, statement_s::next_true, statement_s::part, PROFILE, PROFILE_END, statement_contains_expr_calling_stmt(), and statement_s::suppl.

Referenced by funit_remove_stmt_blks_calling_stmt(), gen_item_remove_if_contains_expr_calling_stmt(), and statement_contains_expr_calling_stmt().

  { PROFILE(STATEMENT_CONTAINS_EXPR_CALLING_STMT);

  bool contains = (curr != NULL) &&
                  (expression_contains_expr_calling_stmt( curr->exp, stmt ) ||
                  ((curr->suppl.part.stop_true == 0) &&
                    statement_contains_expr_calling_stmt( curr->next_true, stmt )) ||
                  ((curr->next_false != curr->next_false) &&
                   (curr->suppl.part.stop_false == 0) &&
                    statement_contains_expr_calling_stmt( curr->next_false, stmt )));

  PROFILE_END;

  return( contains );

}

statement* statement_create	(	expression *	exp,
		func_unit *	funit,
		unsigned int	ppline
	)

Creates new statement structure.

Returns:

Returns pointer to the newly created statement.

Creates a new statement structure from heap memory and initializes it with the specified parameter information.

Parameters:

	exp	Pointer to root expression of expression tree for this statement
	funit	Pointer to functional unit that this statement exists in
	ppline	File line from the preprocessed file

References statement_s::all, statement_s::conn_id, statement_s::exp, statement_s::funit, statement_s::head, malloc_safe, statement_s::next_false, statement_s::next_true, expression_s::parent, statement_s::ppline, PROFILE, PROFILE_END, expr_stmt_u::stmt, and statement_s::suppl.

Referenced by db_create_statement(), fsm_arg_parse_state(), and statement_db_read().

  { PROFILE(STATEMENT_CREATE);

  statement* stmt;  /* Pointer to newly created statement */

  stmt                    = (statement*)malloc_safe( sizeof( statement ) );
  stmt->exp               = exp;
  stmt->exp->parent->stmt = stmt;
  stmt->next_true         = NULL;
  stmt->next_false        = NULL;
  stmt->head              = NULL;
  stmt->conn_id           = 0;
  stmt->suppl.all         = 0;
  stmt->funit             = funit;
  stmt->ppline            = ppline;

  PROFILE_END;

  return( stmt );

}

void statement_db_read	(	char **	line,
		func_unit *	curr_funit,
		int	read_mode
	)

Reads in statement line from specified string and stores statement in specified functional unit.

Parameters:

	line	Pointer to current line of file being read.
	curr_funit	Pointer to current module.
	read_mode	If set to REPORT, adds statement to head of list; otherwise, adds statement to tail.

Exceptions:

anonymous

Throw Throw

Reads in the contents of the statement from the specified line, creates a statement structure to hold the contents.

References statement_s::all, exp_link_s::exp, func_unit_s::exp_head, exp_link_find(), FALSE, FATAL, func_unit_s::first_stmt, FUNIT_AFUNCTION, FUNIT_ANAMED_BLOCK, FUNIT_ATASK, FUNIT_FUNCTION, FUNIT_NAMED_BLOCK, FUNIT_TASK, statement_s::head, statement_s::next_false, statement_s::next_true, statement_s::part, print_output(), PROFILE, PROFILE_END, READ_MODE_NO_MERGE, sim_add_thread(), statement_create(), statement_queue_add(), statement_queue_compare(), stmt_link_s::stmt, func_unit_s::stmt_head, stmt_link_add(), stmt_link_find(), func_unit_s::stmt_tail, statement_s::suppl, Throw, TRUE, and func_unit_s::type.

Referenced by db_read(), and funit_db_mod_merge().

  { PROFILE(STATEMENT_DB_READ);

  int          id;             /* ID of root expression that is associated with this statement */
  int          true_id;        /* ID of root expression that is associated with the next_true statement */
  int          false_id;       /* ID of root expression that is associated with the next_false statement */
  int          head_id;
  statement*   stmt;           /* Pointer to newly created statement */
  exp_link*    expl;           /* Pointer to found expression link */
  stmt_link*   stmtl;          /* Pointer to found statement link */
  int          chars_read;     /* Number of characters read from line */
  uint32       suppl;          /* Supplemental field value */
  unsigned int ppline;         /* Preprocessor file line */
  uint32       first_col;     /* First column */

  if( sscanf( *line, "%d %u %u %x %d %d %d%n", &id, &ppline, &first_col, &suppl, &true_id, &false_id, &head_id, &chars_read ) == 7 ) {

    *line = *line + chars_read;

    if( curr_funit == NULL ) {

      print_output( "Internal error:  statement in database written before its functional unit", FATAL, __FILE__, __LINE__ );
      Throw 0;

    } else {

      /* Find associated root expression */
      expl = exp_link_find( id, curr_funit->exp_head );
      assert( expl != NULL );

      stmt = statement_create( expl->exp, curr_funit, ppline );
      stmt->suppl.all = suppl;

      /*
       If this statement is a head statement and the current functional unit is a task, function or named block,
       set the curr_funit->first_stmt pointer to this statement.
      */
      if( (stmt->suppl.part.head == 1) &&
          ((curr_funit->type == FUNIT_TASK)        ||
           (curr_funit->type == FUNIT_ATASK)       ||
           (curr_funit->type == FUNIT_FUNCTION)    ||
           (curr_funit->type == FUNIT_AFUNCTION)   ||
           (curr_funit->type == FUNIT_NAMED_BLOCK) ||
           (curr_funit->type == FUNIT_ANAMED_BLOCK)) ) {
        curr_funit->first_stmt = stmt;
      }

      /* Find and link next_true */
      if( true_id == id ) {
        stmt->next_true = stmt;
      } else if( true_id != 0 ) {
        stmtl = stmt_link_find( true_id, curr_funit->stmt_head );
        if( stmtl == NULL ) {
          /* Add to statement loop queue */
          statement_queue_add( stmt, true_id, 0 );
        } else {
          stmt->next_true = stmtl->stmt;
        }
        /* Check against statement queue */
        statement_queue_compare( stmt );
      }

      /* Find and link next_false */
      if( false_id == id ) {
        stmt->next_false = stmt;
      } else if( false_id != 0 ) {
        stmtl = stmt_link_find( false_id, curr_funit->stmt_head );
        if( stmtl == NULL ) {
          statement_queue_add( stmt, false_id, 1 );
        } else {
          stmt->next_false = stmtl->stmt;
        }
        statement_queue_compare( stmt );
      }

      /* Find and link head */
      if( head_id == id ) {
        stmt->head = stmt;
      } else if( head_id != 0 ) {
        stmtl = stmt_link_find( head_id, curr_funit->stmt_head );
        if( stmtl == NULL ) {
          statement_queue_add( stmt, head_id, 2 );
        } else {
          stmt->head = stmtl->stmt;
        }
        statement_queue_compare( stmt );
      }

      /* Add the statement to the functional unit list */
      (void)stmt_link_add( stmt, TRUE, &(curr_funit->stmt_head), &(curr_funit->stmt_tail) );

      /*
       Possibly add statement to presimulation queue (if the current functional unit is a task
       or function, do not add this to the presimulation queue (this will be added when the expression
       is called.
      */
      if( (read_mode == READ_MODE_NO_MERGE) && (stmt->suppl.part.is_called == 0) ) {
        sim_time tmp_time = {0,0,0,FALSE};
        (void)sim_add_thread( NULL, stmt, curr_funit, &tmp_time );
      }

    }

  } else {

    print_output( "Unable to read statement value", FATAL, __FILE__, __LINE__ );
    Throw 0;

  }

  PROFILE_END;

}

void statement_db_write	(	statement *	stmt,
		FILE *	ofile,
		bool	ids_issued
	)

Writes specified statement to the specified output file.

Recursively writes the contents of the specified statement tree (and its associated expression trees to the specified output stream.

Parameters:

	stmt	Pointer to statement to write out value
	ofile	Pointer to output file to write statement line to
	ids_issued	Specifies that IDs were issued just prior to calling this function

References statement_s::all, expression_s::col, DB_TYPE_STATEMENT, statement_s::exp, expression_get_id(), statement_s::head, statement_s::next_false, statement_s::next_true, expression_s::part, statement_s::ppline, PROFILE, PROFILE_END, and statement_s::suppl.

Referenced by funit_db_write(), and statement_db_write_tree().

  { PROFILE(STATEMENT_DB_WRITE);

  assert( stmt != NULL );

  /* Write out contents of this statement last */
  fprintf( ofile, "%d %d %u %u %x %d %d %d",
    DB_TYPE_STATEMENT,
    expression_get_id( stmt->exp, ids_issued ),
    stmt->ppline,
    stmt->exp->col.part.first,
    (stmt->suppl.all & 0xff),
    ((stmt->next_true   == NULL) ? 0 : expression_get_id( stmt->next_true->exp, ids_issued )),
    ((stmt->next_false  == NULL) ? 0 : expression_get_id( stmt->next_false->exp, ids_issued )),
    ((stmt->head        == NULL) ? 0 : expression_get_id( stmt->head->exp, ids_issued ))
  );

  fprintf( ofile, "\n" );

  PROFILE_END;

}

void statement_db_write_expr_tree	(	statement *	stmt,
		FILE *	ofile
	)

Writes specified expression trees for given statement block to specified output file.

Parameters:

	stmt	Pointer to specified statement tree to display
	ofile	Pointer to output file to write

Traverses the specified statement block, writing all expression trees to specified output file.

References statement_s::exp, expression_db_write_tree(), statement_s::next_false, statement_s::next_true, statement_s::part, PROFILE, PROFILE_END, statement_db_write_expr_tree(), and statement_s::suppl.

Referenced by gen_item_db_write_expr_tree(), and statement_db_write_expr_tree().

  { PROFILE(STATEMENT_DB_WRITE_EXPR_TREE);

  if( stmt != NULL ) {

    /* Output ourselves first */
    expression_db_write_tree( stmt->exp, ofile );

    /* Traverse down the rest of the statement block */
    if( (stmt->next_true == stmt->next_false) && (stmt->suppl.part.stop_true == 0) ) {
      statement_db_write_expr_tree( stmt->next_true, ofile );
    } else {
      if( stmt->suppl.part.stop_false == 0 ) {
        statement_db_write_expr_tree( stmt->next_false, ofile );
      }
      if( stmt->suppl.part.stop_true == 0 ) {
        statement_db_write_expr_tree( stmt->next_true, ofile );
      }
    }

  }

  PROFILE_END;

}

void statement_db_write_tree	(	statement *	stmt,
		FILE *	ofile
	)

Writes specified statement tree to the specified output file.

Parameters:

	stmt	Pointer to root of statement tree to output
	ofile	Pointer to output file to write statements to

Traverses specified statement tree, outputting all statements within that tree.

References statement_s::next_false, statement_s::next_true, statement_s::part, PROFILE, PROFILE_END, statement_db_write(), statement_db_write_tree(), statement_s::suppl, and TRUE.

Referenced by gen_item_db_write(), and statement_db_write_tree().

  { PROFILE(STATEMENT_DB_WRITE_TREE);

  if( stmt != NULL ) {

    /* Traverse down the rest of the statement block */
    if( (stmt->next_true == stmt->next_false) && (stmt->suppl.part.stop_true == 0) ) {
      statement_db_write_tree( stmt->next_true, ofile );
    } else {
      if( stmt->suppl.part.stop_false == 0 ) {
        statement_db_write_tree( stmt->next_false, ofile );
      }
      if( stmt->suppl.part.stop_true == 0 ) {
        statement_db_write_tree( stmt->next_true, ofile );
      }
    }

    /* Output ourselves first */
    statement_db_write( stmt, ofile, TRUE );

  }

  PROFILE_END;

}

void statement_dealloc

(

statement *

stmt

)

Deallocates statement memory and associated expression tree from the heap.

Deallocates specified statement from heap memory. Does not remove attached expression (this is assumed to be cleaned up by the expression list removal function).

Parameters:

stmt

Pointer to statement to deallocate

References free_safe, PROFILE, and PROFILE_END.

Referenced by db_create_statement(), fsm_var_cleanup(), and stmt_link_delete_list().

  { PROFILE(STATEMENT_DEALLOC);

  if( stmt != NULL ) {
 
    /* Finally, deallocate this statement */
    free_safe( stmt, sizeof( statement ) );

  }

  PROFILE_END;

}

void statement_dealloc_recursive	(	statement *	stmt,
		bool	rm_stmt_blk
	)

Recursively deallocates specified statement tree.

Parameters:

	stmt	Pointer to head of statement tree to deallocate
	rm_stmt_blk	If set to TRUE, removes the statement block this statement points to (if any)

References db_remove_statement_from_current_funit(), expression_s::elem, ESUPPL_TYPE, ETYPE_FUNIT, statement_s::exp, EXP_OP_FORK, EXP_OP_NB_CALL, func_unit_s::first_stmt, free_safe, expression_s::funit, FUNIT_NO_SCORE, statement_s::next_false, statement_s::next_true, expression_s::op, statement_s::part, PROFILE, PROFILE_END, statement_dealloc_recursive(), stmt_blk_add_to_remove_list(), statement_s::suppl, expression_s::suppl, and func_unit_s::type.

Referenced by db_remove_statement(), gen_item_dealloc(), statement_dealloc_recursive(), and stmt_blk_remove().

  { PROFILE(STATEMENT_DEALLOC_RECURSIVE);
    
  if( stmt != NULL ) {
  
    assert( stmt->exp != NULL );

    /* If we are a named block or fork call statement, remove that statement block */
    if( (stmt->exp->op == EXP_OP_NB_CALL) || (stmt->exp->op == EXP_OP_FORK) ) {

      if( rm_stmt_blk && (ESUPPL_TYPE( stmt->exp->suppl ) == ETYPE_FUNIT) && (stmt->exp->elem.funit->type != FUNIT_NO_SCORE) ) {
        stmt_blk_add_to_remove_list( stmt->exp->elem.funit->first_stmt );
      }

    }

    /* Remove TRUE path */
    if( stmt->next_true == stmt->next_false ) {

      if( stmt->suppl.part.stop_true == 0 ) {
        statement_dealloc_recursive( stmt->next_true, rm_stmt_blk );
      }

    } else {

      if( stmt->suppl.part.stop_true == 0 ) {
        statement_dealloc_recursive( stmt->next_true, rm_stmt_blk );
      }
  
      /* Remove FALSE path */
      if( stmt->suppl.part.stop_false == 0 ) {
        statement_dealloc_recursive( stmt->next_false, rm_stmt_blk );
      }

    }

    /* Disconnect statement from current functional unit */
    db_remove_statement_from_current_funit( stmt );

    free_safe( stmt, sizeof( statement ) );
    
  }

  PROFILE_END;
  
}

void statement_find_rhs_sigs	(	statement *	stmt,
		str_link **	head,
		str_link **	tail
	)

Creates a list of all signals on the RHS of expressions in the given statement block.

Searches the specified statement block and returns a list of all signals on the right-hand-side of expressions.

Parameters:

	stmt	Pointer to current statement block to traverse
	head	Pointer to head of signal name list that will contain a list of all RHS signals
	tail	Pointer to tail of signal name list that will contain a list of all RHS signals

References expression_s::elem, statement_s::exp, EXP_OP_FORK, EXP_OP_NB_CALL, expression_find_rhs_sigs(), func_unit_s::first_stmt, expression_s::funit, statement_s::next_false, statement_s::next_true, expression_s::op, statement_s::part, PROFILE, PROFILE_END, statement_find_rhs_sigs(), and statement_s::suppl.

Referenced by db_create_sensitivity_list(), and statement_find_rhs_sigs().

  { PROFILE(STATEMENT_FIND_RHS_SIGS);

  if( stmt != NULL ) {

    if( (stmt->exp->op == EXP_OP_NB_CALL) || (stmt->exp->op == EXP_OP_FORK) ) {

      statement_find_rhs_sigs( stmt->exp->elem.funit->first_stmt, head, tail );

    } else {

      /* Find all RHS signals in this statement's expression tree */
      expression_find_rhs_sigs( stmt->exp, head, tail );

    }

    /* If both true and false paths lead to same statement, just traverse the true path */
    if( stmt->next_true == stmt->next_false ) {

      if( stmt->suppl.part.stop_true == 0 ) {
        statement_find_rhs_sigs( stmt->next_true, head, tail );
      }

    /* Otherwise, traverse both true and false paths */
    } else {

      if( stmt->suppl.part.stop_true == 0 ) {
        statement_find_rhs_sigs( stmt->next_true, head, tail );
      }

      if( stmt->suppl.part.stop_false == 0 ) {
        statement_find_rhs_sigs( stmt->next_false, head, tail );
      }

    }

  }

  PROFILE_END;

}

statement* statement_find_statement	(	statement *	curr,
		int	id
	)

Searches for statement with ID in the given statement block.

Returns:

Returns a pointer to the found statement found within the given statement block. If the statement ID could not be found, returns NULL.

Recursively searches the given statement block for the expression that matches the given ID.

Parameters:

	curr	Pointer to current statement in statement block being evaluated
	id	Statement ID to find

References statement_s::exp, expression_s::id, statement_s::next_false, statement_s::next_true, statement_s::part, PROFILE, PROFILE_END, statement_find_statement(), and statement_s::suppl.

Referenced by generate_remove_stmt_helper(), and statement_find_statement().

  { PROFILE(STATEMENT_FIND_STATEMENT);

  statement* found = NULL;  /* Pointer to found statement */

  if( curr != NULL ) {

    if( curr->exp->id == id ) {

      found = curr;

    } else {

      /* If both true and false paths lead to same item, just traverse the true path */
      if( curr->next_true == curr->next_false ) {

        if( curr->suppl.part.stop_true == 0 ) {
          found = statement_find_statement( curr->next_true, id );
        }

      /* Otherwise, traverse both true and false paths */
      } else if( (curr->suppl.part.stop_true == 0) &&
                 ((found = statement_find_statement( curr->next_true, id )) == NULL) ) {

        if( curr->suppl.part.stop_false == 0 ) {
          found = statement_find_statement( curr->next_false, id );
        }

      }

    }

  }

  PROFILE_END;

  return( found );

}

int statement_get_last_line

(

statement *

stmt

)

Calculates the last line of the specified statement tree.

Returns:

Returns the last line number in the given statement.

Parameters:

stmt

Pointer to statement to get last line number for

References PROFILE, PROFILE_END, and statement_get_last_line_helper().

Referenced by race_handle_race_condition().

  { PROFILE(STATEMENT_GET_LAST_LINE);

  int retval = statement_get_last_line_helper( stmt, stmt );

  PROFILE_END;

  return( retval );

}

void statement_size_elements	(	statement *	stmt,
		func_unit *	funit
	)

Sizes all expressions for the given statement block.

Parameters:

	stmt	Pointer to statement block to size elements for
	funit	Pointer to functional unit containing this statement block

Exceptions:

anonymous

expression_resize statement_size_elements statement_size_elements statement_size_elements

Recursively sizes all elements for the given statement block.

References statement_s::exp, expression_resize(), FALSE, statement_s::next_false, statement_s::next_true, statement_s::part, PROFILE, PROFILE_END, statement_size_elements(), statement_s::suppl, and TRUE.

Referenced by gen_item_resize_stmts_and_sigs(), and statement_size_elements().

  { PROFILE(STATEMENT_SIZE_ELEMENTS);

  if( stmt != NULL ) {

    /* Size the current statement */
    expression_resize( stmt->exp, funit, TRUE, FALSE );

    /* Iterate to the next statement */
    if( stmt->next_true == stmt->next_false ) {
      if( stmt->suppl.part.stop_true == 0 ) {
        statement_size_elements( stmt->next_true, funit );
      }
    } else {
      if( stmt->suppl.part.stop_false == 0 ) {
        statement_size_elements( stmt->next_false, funit );
      }
      if( stmt->suppl.part.stop_true == 0 ) {
        statement_size_elements( stmt->next_true, funit );
      }
    }

  }

  PROFILE_END;

}