fsm_var.h File Reference

Contains functions for handling FSM variable structure. More...

#include "defines.h"

Go to the source code of this file.

Functions
fsm_var *	fsm_var_add (const char *funit_name, int line, expression *in_state, expression *out_state, char *name, bool exclude)
	Allocates, initializes and adds FSM variable to global list.
void	fsm_var_bind_add (char *sig_name, expression *expr, char *funit_name)
	Adds specified signal and expression to binding list.
void	fsm_var_stmt_add (statement *stmt, char *funit_name)
	Add specified functional unit and statement to binding list.
void	fsm_var_bind ()
	Performs FSM signal/expression binding process.
void	fsm_var_cleanup ()
	Cleans up the global lists used in this file.

---

Detailed Description

Contains functions for handling FSM variable structure.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

10/3/2003

---

Function Documentation

fsm_var* fsm_var_add	(	const char *	funit_name,
		int	line,
		expression *	in_state,
		expression *	out_state,
		char *	name,
		bool	exclude
	)

Allocates, initializes and adds FSM variable to global list.

Returns:

Returns pointer to newly allocated FSM variable.

Adds the specified Verilog hierarchical scope to a list of FSM scopes to find during the parsing phase.

Parameters:

	funit_name	String containing functional unit containing FSM state variable
	line	First line of FSM variable
	in_state	Pointer to expression containing input state
	out_state	Pointer to expression containing output state
	name	Name of this FSM (only valid for attributes
	exclude	If TRUE, excludes the FSM from coverage consideration

References curr_db, fsm_var_s::exclude, fsm_create(), func_unit_s::fsm_head, fsm_link_add(), func_unit_s::fsm_tail, funit_link_s::funit, fsm_var_s::funit, funit_head, funit_link_find(), FUNIT_MODULE, fsm_var_s::iexp, fsm_var_s::ivar, fsm_var_s::line, malloc_safe, fsm_s::name, fsm_var_s::name, fsm_var_s::next, fsm_var_s::ovar, PROFILE, strdup_safe, expression_s::table, and fsm_var_s::table.

Referenced by fsm_arg_parse(), and fsm_arg_parse_attr().

  { PROFILE(FSM_VAR_ADD);

  fsm_var*    new_var = NULL;  /* Pointer to newly created FSM variable */
  funit_link* funitl;          /* Pointer to functional unit link found */
  fsm*        table;           /* Pointer to newly create FSM */

  /* If we have not parsed design, add new FSM variable to list */
  if( db_list[curr_db]->funit_head == NULL ) {

    new_var          = (fsm_var*)malloc_safe( sizeof( fsm_var ) );
    new_var->funit   = strdup_safe( funit_name );
    new_var->name    = NULL;
    new_var->ivar    = in_state;
    new_var->ovar    = out_state;
    new_var->iexp    = NULL;
    new_var->table   = NULL;
    new_var->exclude = exclude;
    new_var->line    = line;
    new_var->next    = NULL;

    if( fsm_var_head == NULL ) {
      fsm_var_head = fsm_var_tail = new_var;
    } else {
      fsm_var_tail->next = new_var;
      fsm_var_tail       = new_var;
    }

  } else {

    if( (funitl = funit_link_find( funit_name, FUNIT_MODULE, db_list[curr_db]->funit_head )) != NULL ) {
      table = fsm_create( in_state, out_state, line, exclude );
      if( name != NULL ) {
        table->name = strdup_safe( name );
      }
      in_state->table  = table;
      out_state->table = table;
      fsm_link_add( table, &(funitl->funit->fsm_head), &(funitl->funit->fsm_tail) );
    } else {
      assert( funitl != NULL );
    }

  }

  return( new_var );

}

void fsm_var_bind

(

)

Performs FSM signal/expression binding process.

Exceptions:

anonymous

fsm_var_bind_expr Throw

After Verilog parsing has completed, this function should be called to bind all signals to their associated FSM state expressions and functional units. For each entry in the FSM binding list the signal name is looked in the functional unit specified in the binding entry. If the signal is found, the associated expression pointer is added to the signal's expression list and the expression's signal pointer is set to point at the found signal structure. If the signal was not found, an error message is reported to the user, specifying the signal did not exist in the design.

After the signals and expressions have been bound, the FSM statement binding list is iterated through binding all statements containing FSM state expressions to the functional unit that it is a part of. If the statement contains an FSM state expression that is an output state expression, create the FSM structure for this FSM and add it to the design.

References Catch_anonymous, fv_bind_s::expr, free_safe, fsm_var_bind_expr(), fsm_var_bind_stmt(), fv_bind_s::funit_name, fv_bind_s::next, PROFILE, PROFILE_END, fv_bind_s::sig_name, fv_bind_s::stmt, Throw, and Try.

Referenced by parse_design().

                    { PROFILE(FSM_VAR_BIND);

  fv_bind* curr = NULL;  /* Pointer to current FSM variable */
  fv_bind* tmp;          /* Temporary pointer to FSM bind structure */

  Try {

    curr = fsm_var_bind_head;
    while( curr != NULL ) {

      /* Perform binding */
      fsm_var_bind_expr( curr->sig_name, curr->expr, curr->funit_name );

      tmp = curr->next;

      /* Deallocate memory for this bind structure */
      free_safe( curr->sig_name, (strlen( curr->sig_name ) + 1) );
      free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
      free_safe( curr, sizeof( fv_bind ) );

      curr = tmp;

    }

  } Catch_anonymous {
    while( curr != NULL ) {
      tmp = curr->next;
      free_safe( curr->sig_name, (strlen( curr->sig_name ) + 1) );
      free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
      free_safe( curr, sizeof( fv_bind ) );
      curr = tmp;
    } 
    curr = fsm_var_stmt_head;
    while( curr != NULL ) {
      tmp = curr->next;
      free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
      free_safe( curr, sizeof( fv_bind ) );
      curr = tmp;
    }
    Throw 0;
  }

  curr = fsm_var_stmt_head;
  while( curr != NULL ) {

    /* Bind statement to functional unit */
    (void)fsm_var_bind_stmt( curr->stmt, curr->funit_name );

    tmp = curr->next;

    /* Deallocate memory for this bind structure */
    free_safe( curr->funit_name, (strlen( curr->funit_name ) + 1) );
    free_safe( curr, sizeof( fv_bind ) );

    curr = tmp;

  }

  PROFILE_END;

}

void fsm_var_bind_add	(	char *	sig_name,
		expression *	expr,
		char *	funit_name
	)

Adds specified signal and expression to binding list.

Exceptions:

anonymous

fsm_var_bind_expr

Creates a new FSM binding structure and initializes it with the specified information. The FSM binding structure is then added to the global list of FSM binding structures to be bound after parsing is complete.

Parameters:

	sig_name	Name of signal to bind
	expr	Pointer to expression to bind
	funit_name	Name of functional unit that will contain the expression and signal being bound

References curr_db, fv_bind_s::expr, fsm_var_bind_expr(), funit_head, fv_bind_s::funit_name, malloc_safe, fv_bind_s::next, PROFILE, PROFILE_END, fv_bind_s::sig_name, and strdup_safe.

Referenced by fsm_arg_parse_state().

  { PROFILE(FSM_VAR_BIND_ADD);

  fv_bind* fvb;  /* Pointer to new FSM variable binding structure */

  /* If the functional unit list does not exist yet, we need to bind this later; otherwise, bind now */
  if( db_list[curr_db]->funit_head == NULL ) {

    /* Allocate and initialize FSM variable bind structure */
    fvb             = (fv_bind*)malloc_safe( sizeof( fv_bind ) );
    fvb->sig_name   = strdup_safe( sig_name );
    fvb->expr       = expr;
    fvb->funit_name = strdup_safe( funit_name );
    fvb->next       = NULL;

    /* Add new structure to the global list */
    if( fsm_var_bind_head == NULL ) {
      fsm_var_bind_head = fsm_var_bind_tail = fvb;
    } else {
      fsm_var_bind_tail->next = fvb;
      fsm_var_bind_tail       = fvb;
    }

  } else {

    fsm_var_bind_expr( sig_name, expr, funit_name );

  }

  PROFILE_END;

}

void fsm_var_cleanup

(

)

Cleans up the global lists used in this file.

Iterates through the various global lists in this file, deallocating all memory. This function is called when an error has occurred during the parsing stage.

References statement_s::exp, fv_bind_s::expr, expression_dealloc(), FALSE, free_safe, fsm_var_s::funit, fv_bind_s::funit_name, fsm_var_s::ivar, fv_bind_s::next, fsm_var_s::next, fsm_var_s::ovar, PROFILE, PROFILE_END, fv_bind_s::sig_name, statement_dealloc(), and fv_bind_s::stmt.

Referenced by command_score(), and parse_design().

                       { PROFILE(FSM_VAR_CLEANUP);

  fsm_var* curr_fv;   /* Pointer to the current fsm_var structure */
  fsm_var* tmp_fv;    /* Temporary pointer */
  fv_bind* curr_fvb;  /* Pointer to the current fv_bind structure */ 
  fv_bind* tmp_fvb;   /* Temporary pointer */

  /* Deallocate fsm_var list */
  curr_fv = fsm_var_head;
  while( curr_fv != NULL ) {
    tmp_fv  = curr_fv;
    curr_fv = curr_fv->next;

    free_safe( tmp_fv->funit, (strlen( curr_fv->funit ) + 1) );
    expression_dealloc( tmp_fv->ivar, FALSE );
    expression_dealloc( tmp_fv->ovar, FALSE );
    free_safe( tmp_fv, sizeof( fsm_var ) );
  }
  fsm_var_head = fsm_var_tail = NULL;

  /* Deallocate fsm_var_bind list */
  curr_fvb = fsm_var_bind_head;
  while( curr_fvb != NULL ) {
    tmp_fvb  = curr_fvb;
    curr_fvb = curr_fvb->next;

    free_safe( tmp_fvb->sig_name,   (strlen( tmp_fvb->sig_name ) + 1) );
    free_safe( tmp_fvb->funit_name, (strlen( tmp_fvb->funit_name ) + 1) );
    expression_dealloc( tmp_fvb->expr, FALSE );
    free_safe( tmp_fvb, sizeof( fv_bind ) );
  }
  fsm_var_bind_head = fsm_var_bind_tail = NULL;

  /* Deallocate fsm_var_stmt list */
  curr_fvb = fsm_var_stmt_head;
  while( curr_fvb != NULL ) {
    tmp_fvb  = curr_fvb;
    curr_fvb = curr_fvb->next;
    
    free_safe( tmp_fvb->funit_name, (strlen( tmp_fvb->funit_name ) + 1) );
    expression_dealloc( tmp_fvb->stmt->exp, FALSE );
    statement_dealloc( tmp_fvb->stmt );
    free_safe( tmp_fvb, sizeof( fv_bind ) );
  }
  fsm_var_stmt_head = fsm_var_stmt_tail = NULL;

  PROFILE_END;

}

void fsm_var_stmt_add	(	statement *	stmt,
		char *	funit_name
	)

Add specified functional unit and statement to binding list.

Allocates and initializes an FSM variable binding entry and adds it to the fsm_var_stmt list for later processing.

Parameters:

	stmt	Pointer to statement containing FSM state expression
	funit_name	Name of functional unit that will contain stmt

References fv_bind_s::funit_name, malloc_safe, fv_bind_s::next, PROFILE, PROFILE_END, fv_bind_s::stmt, and strdup_safe.

Referenced by fsm_arg_parse_state().

  { PROFILE(FSM_VAR_STMT_ADD);

  fv_bind* fvb;  /* Pointer to new FSM variable binding structure */

  fvb             = (fv_bind*)malloc_safe( sizeof( fv_bind ) );
  fvb->stmt       = stmt;
  fvb->funit_name = strdup_safe( funit_name );
  fvb->next       = NULL;

  /* Add new structure to the head of the global list */
  if( fsm_var_stmt_head == NULL ) {
    fsm_var_stmt_head = fsm_var_stmt_tail = fvb;
  } else {
    fvb->next         = fsm_var_stmt_head;
    fsm_var_stmt_head = fvb;
  }

  PROFILE_END;

}