param.h File Reference

Contains functions and structures necessary to handle parameters. More...

#include <stdio.h>
#include "defines.h"

Go to the source code of this file.

Functions
mod_parm *	mod_parm_find (const char *name, mod_parm *parm)
	Searches specified module parameter list for matching parameter.
mod_parm *	mod_parm_add (char *scope, static_expr *msb, static_expr *lsb, bool is_signed, expression *expr, int type, func_unit *funit, char *inst_name)
	Creates new module parameter and adds it to the specified list.
void	mod_parm_display (mod_parm *mparm)
	Outputs contents of module parameter list to standard output.
void	inst_parm_add_genvar (vsignal *sig, funit_inst *inst)
	Creates a new instance parameter for a generate variable.
void	inst_parm_bind (inst_parm *iparm)
	Performs bind of signal and expressions for the given instance parameter.
void	defparam_add (const char *scope, vector *expr)
	Adds parameter override to defparam list.
void	defparam_dealloc ()
	Deallocates all memory associated with defparam storage from command-line.
void	param_set_sig_size (vsignal *sig, inst_parm *icurr)
	Sets the specified signal size according to the specified instance parameter.
void	param_expr_eval (expression *expr, funit_inst *inst)
	Evaluates parameter expression for the given instance.
void	param_resolve_inst (funit_inst *inst)
	Resolves all parameters for the specified instance.
void	param_resolve (funit_inst *inst)
	Resolves all parameters for the specified instance tree.
void	param_db_write (inst_parm *iparm, FILE *file)
	Outputs specified instance parameter to specified output stream.
void	mod_parm_dealloc (mod_parm *parm, bool recursive)
	Deallocates specified module parameter and possibly entire module parameter list.
void	inst_parm_dealloc (inst_parm *parm, bool recursive)
	Deallocates specified instance parameter and possibly entire instance parameter list.

---

Detailed Description

Contains functions and structures necessary to handle parameters.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

8/22/2002

---

Function Documentation

void defparam_add	(	const char *	scope,
		vector *	value
	)

Adds parameter override to defparam list.

Exceptions:

anonymous

inst_parm_add Throw

Scans list of all parameters to make sure that specified parameter isn't already being set to a new value. If no match occurs, adds the new defparam to the defparam list. This function is called for each -P option to the score command.

Parameters:

	scope	Full hierarchical reference to specified scope to change value to
	value	User-specified parameter override value

References Catch_anonymous, vsuppl_u::data_type, static_expr_s::exp, FALSE, FATAL, inst_parm_add(), inst_parm_find(), malloc_safe, static_expr_s::num, obf_sig, funit_inst_s::param_head, funit_inst_s::param_tail, vsuppl_u::part, print_output(), PROFILE, PROFILE_END, vector_s::suppl, Throw, Try, user_msg, USER_MSG_LENGTH, VDATA_R32, VDATA_R64, VDATA_UL, and vector_dealloc().

Referenced by score_parse_args().

  { PROFILE(DEFPARAM_ADD);

  static_expr msb;  /* MSB of this defparam (forced to be 31) */
  static_expr lsb;  /* LSB of this defparam (forced to be 0) */

  assert( scope != NULL );

  /* If the defparam instance doesn't exist, create it now */
  if( defparam_list == NULL ) {
    defparam_list = (funit_inst*)malloc_safe( sizeof( funit_inst ) );
    defparam_list->param_head = NULL;
    defparam_list->param_tail = NULL;
  }

  if( inst_parm_find( scope, defparam_list->param_head ) == NULL ) {

    /* Generate MSB and LSB information */
    switch( value->suppl.part.data_type ) {
      case VDATA_UL  :  msb.num = 31;  break;
      case VDATA_R64 :  msb.num = 63;  break;
      case VDATA_R32 :  msb.num = 31;  break;
      default        :  assert( 0 );   break;
    }
    msb.exp = NULL;
    lsb.num = 0;
    lsb.exp = NULL;

    Try {
      (void)inst_parm_add( scope, NULL, &msb, &lsb, FALSE, value, NULL, defparam_list );
    } Catch_anonymous {
      vector_dealloc( value );
      Throw 0;
    }

    vector_dealloc( value );

  } else {

    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Parameter (%s) value is assigned more than once", obf_sig( scope ) );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, FATAL, __FILE__, __LINE__ );
    Throw 0;

  }

  PROFILE_END;

}

void defparam_dealloc

(

)

Deallocates all memory associated with defparam storage from command-line.

Deallocates all memory used for storing defparam information.

References free_safe, inst_parm_dealloc(), funit_inst_s::param_head, PROFILE, PROFILE_END, and TRUE.

Referenced by command_score().

                        { PROFILE(DEFPARAM_DEALLOC);

  if( defparam_list != NULL ) {

    /* Deallocate the instance parameters in the defparam_list structure */
    inst_parm_dealloc( defparam_list->param_head, TRUE );

    /* Now free the defparam_list structure itself */
    free_safe( defparam_list, sizeof( funit_inst ) );

  }

  PROFILE_END;

}

void inst_parm_add_genvar	(	vsignal *	sig,
		funit_inst *	inst
	)

Creates a new instance parameter for a generate variable.

Creates an instance parameter for a generate variable and adds it to the given instance parameter list.

Parameters:

	sig	Pointer to generate signal to copy
	inst	Pointer to instance to add this instance parameter to

References inst_parm_s::inst_name, malloc_safe, inst_parm_s::mparm, inst_parm_s::next, funit_inst_s::param_head, funit_inst_s::param_tail, ssuppl_u::part, PROFILE, PROFILE_END, inst_parm_s::sig, SSUPPL_TYPE_PARAM, vsignal_s::suppl, ssuppl_u::type, and vsignal_duplicate().

Referenced by gen_item_resolve().

  { PROFILE(INST_PARM_ADD_GENVAR);

  inst_parm* iparm;  /* Pointer to the newly allocated instance parameter */

  assert( inst != NULL );

  /* Allocate the new instance parameter */
  iparm = (inst_parm*)malloc_safe( sizeof( inst_parm ) );

  /* Initialize the instance parameter */
  iparm->inst_name            = NULL;
  iparm->sig                  = vsignal_duplicate( sig ); 
  iparm->sig->suppl.part.type = SSUPPL_TYPE_PARAM;
  iparm->mparm                = NULL;
  iparm->next                 = NULL;

  /* Add the instance parameter to the parameter list */
  if( inst->param_head == NULL ) {
    inst->param_head = inst->param_tail = iparm;
  } else {
    inst->param_tail->next = iparm;
    inst->param_tail       = iparm;
  }

  PROFILE_END;

}

void inst_parm_bind

(

inst_parm *

iparm

)

Performs bind of signal and expressions for the given instance parameter.

Binds the instance parameter signal to its list of expressions. This is called by funit_size_elements.

Parameters:

iparm

Pointer to instance parameter to bind

References exp_link_s::exp, mod_parm_s::exp_head, inst_parm_s::mparm, exp_link_s::next, PROFILE, PROFILE_END, inst_parm_s::sig, and expression_s::sig.

Referenced by funit_size_elements().

  { PROFILE(INST_PARM_BIND);

  exp_link* expl;  /* Pointer to current expression link in list */

  /* Bind the module parameter expression list to this signal */
  if( iparm->mparm != NULL ) {
    expl = iparm->mparm->exp_head;
    while( expl != NULL ) {
      expl->exp->sig = iparm->sig;
      expl = expl->next;
    }
  }

  PROFILE_END;

}

void inst_parm_dealloc	(	inst_parm *	iparm,
		bool	recursive
	)

Deallocates specified instance parameter and possibly entire instance parameter list.

Deallocates allocated memory from heap for the specified instance parameter. If the value of recursive is set to TRUE, perform this deallocation for the entire list of instance parameters.

Parameters:

	iparm	Pointer to instance parameter to remove
	recursive	If TRUE, removes entire instance parameter list; otherwise, just remove me

References free_safe, inst_parm_s::inst_name, inst_parm_dealloc(), inst_parm_s::next, PROFILE, PROFILE_END, inst_parm_s::sig, and vsignal_dealloc().

Referenced by defparam_dealloc(), inst_parm_add(), inst_parm_dealloc(), and instance_dealloc_single().

  { PROFILE(INST_PARM_DEALLOC);

  if( iparm != NULL ) {

    /* If the user wants to deallocate the entire module parameter list, do so now */
    if( recursive ) {
      inst_parm_dealloc( iparm->next, recursive );
    }

    /* Deallocate parameter signal */
    vsignal_dealloc( iparm->sig );

    /* Deallocate instance name, if specified */
    if( iparm->inst_name != NULL ) {
      free_safe( iparm->inst_name, (strlen( iparm->inst_name ) + 1) );
    }
    
    /* Deallocate parameter itself */
    free_safe( iparm, sizeof( inst_parm ) );

  }

  PROFILE_END;

}

mod_parm* mod_parm_add	(	char *	scope,
		static_expr *	msb,
		static_expr *	lsb,
		bool	is_signed,
		expression *	expr,
		int	type,
		func_unit *	funit,
		char *	inst_name
	)

Creates new module parameter and adds it to the specified list.

Returns:

Returns pointer to newly created module parameter.

Creates a new module parameter with the specified information and adds it to the module parameter list.

Parameters:

	scope	Full hierarchical name of parameter value
	msb	Static expression containing the MSB of this module parameter
	lsb	Static expression containing the LSB of this module parameter
	is_signed	Specifies if this parameter needs to be handled as a signed value
	expr	Expression tree for current module parameter
	type	Specifies type of module parameter (declared/override)
	funit	Functional unit to add this module parameter to
	inst_name	Name of instance (used for parameter overridding)

References psuppl_u::all, static_expr_s::exp, mod_parm_s::exp_head, mod_parm_s::exp_tail, mod_parm_s::expr, funit_get_curr_module(), mod_parm_s::inst_name, mod_parm_s::is_signed, mod_parm_s::lsb, malloc_safe, mod_parm_s::msb, mod_parm_s::name, mod_parm_s::next, static_expr_s::num, psuppl_u::order, esuppl_u::owned, psuppl_u::owns_expr, func_unit_s::param_head, func_unit_s::param_tail, PARAM_TYPE_DECLARED, PARAM_TYPE_DECLARED_LOCAL, PARAM_TYPE_INST_LSB, PARAM_TYPE_INST_MSB, PARAM_TYPE_OVERRIDE, PARAM_TYPE_SIG_LSB, PARAM_TYPE_SIG_MSB, esuppl_u::part, psuppl_u::part, PROFILE, PROFILE_END, mod_parm_s::sig, strdup_safe, expression_s::suppl, mod_parm_s::suppl, and psuppl_u::type.

Referenced by db_add_declared_param(), db_add_instance(), db_add_override_param(), and db_add_vector_param().

  { PROFILE(MOD_PARM_ADD);

  mod_parm*  parm;       /* Temporary pointer to instance parameter */
  mod_parm*  curr;       /* Pointer to current module parameter for ordering purposes */
  int        order = 0;  /* Current order of parameter */
  func_unit* mod_funit;  /* Pointer to module containing this functional unit (used for ordering purposes) */
  
  assert( (type == PARAM_TYPE_OVERRIDE) || (expr != NULL) );  /* An expression can be NULL if we are an override type */
  assert( (type == PARAM_TYPE_DECLARED)       || 
          (type == PARAM_TYPE_DECLARED_LOCAL) ||
          (type == PARAM_TYPE_OVERRIDE)       ||
          (type == PARAM_TYPE_SIG_LSB)        ||
          (type == PARAM_TYPE_SIG_MSB)        ||
          (type == PARAM_TYPE_INST_LSB)       ||
          (type == PARAM_TYPE_INST_MSB) );

  /* Find module containing this functional unit */
  mod_funit = funit_get_curr_module( funit );

  /* Determine parameter order */
  if( type == PARAM_TYPE_DECLARED ) {
    curr  = mod_funit->param_head;
    order = 0;
    while( curr != NULL ) {
      if( curr->suppl.part.type == PARAM_TYPE_DECLARED ) {
        order++;
      }
      curr = curr->next;
    }
  } else if( type == PARAM_TYPE_OVERRIDE ) {
    curr  = mod_funit->param_head;
    order = 0;
    while( curr != NULL ) {
      if( (curr->suppl.part.type == PARAM_TYPE_OVERRIDE) &&
          (strcmp( inst_name, curr->inst_name ) == 0) ) {
        order++;
      }
      curr = curr->next;
    }
  }

  /* Create new signal/expression binding */
  parm = (mod_parm*)malloc_safe( sizeof( mod_parm ) );
  if( scope != NULL ) {
    parm->name = strdup_safe( scope );
  } else {
    parm->name = NULL;
  }
  if( inst_name != NULL ) {
    parm->inst_name = strdup_safe( inst_name );
  } else {
    parm->inst_name = NULL;
  }
  if( msb != NULL ) {
    parm->msb      = (static_expr*)malloc_safe( sizeof( static_expr ) );
    parm->msb->num = msb->num;
    parm->msb->exp = msb->exp;
  } else {
    parm->msb = NULL;
  }
  if( lsb != NULL ) {
    parm->lsb      = (static_expr*)malloc_safe( sizeof( static_expr ) );
    parm->lsb->num = lsb->num;
    parm->lsb->exp = lsb->exp;
  } else {
    parm->lsb = NULL;
  }
  parm->is_signed             = is_signed;
  parm->expr                  = expr;
  parm->suppl.all             = 0;
  parm->suppl.part.type       = type;
  parm->suppl.part.order      = order;
  if( expr != NULL ) {
    if( expr->suppl.part.owned == 0 ) {
      parm->suppl.part.owns_expr = 1;
      expr->suppl.part.owned = 1;
    }
  }
  parm->exp_head              = NULL;
  parm->exp_tail              = NULL;
  parm->sig                   = NULL;
  parm->next                  = NULL;

  /* Now add the parameter to the current expression */
  if( funit->param_head == NULL ) {
    funit->param_head = funit->param_tail = parm;
  } else {
    funit->param_tail->next = parm;
    funit->param_tail       = parm;
  }

  PROFILE_END;

  return( parm );

}

void mod_parm_dealloc	(	mod_parm *	parm,
		bool	recursive
	)

Deallocates specified module parameter and possibly entire module parameter list.

Deallocates allocated memory from heap for the specified module parameter. If the value of recursive is set to TRUE, perform this deallocation for the entire list of module parameters.

Parameters:

	parm	Pointer to module parameter to remove
	recursive	If TRUE, removes entire module parameter list; otherwise, just remove me

References mod_parm_s::exp_head, exp_link_delete_list(), mod_parm_s::expr, expression_dealloc(), FALSE, free_safe, mod_parm_s::inst_name, mod_parm_s::lsb, mod_parm_dealloc(), mod_parm_s::msb, mod_parm_s::name, mod_parm_s::next, psuppl_u::owns_expr, psuppl_u::part, PROFILE, PROFILE_END, static_expr_dealloc(), mod_parm_s::suppl, and TRUE.

Referenced by funit_clean(), and mod_parm_dealloc().

  { PROFILE(MOD_PARM_DEALLOC);

  if( parm != NULL ) {

    /* If the user wants to deallocate the entire module parameter list, do so now */
    if( recursive ) {
      mod_parm_dealloc( parm->next, recursive );
    }

    /* Deallocate MSB and LSB static expressions */
    static_expr_dealloc( parm->msb, TRUE );
    static_expr_dealloc( parm->lsb, TRUE );

    /* Remove the attached expression tree */
    if( parm->suppl.part.owns_expr == 1 ) {
      expression_dealloc( parm->expr, FALSE );
    }

    /* Remove the expression list that this parameter is used in */
    exp_link_delete_list( parm->exp_head, FALSE );

    /* Remove the parameter name */
    free_safe( parm->name, (strlen( parm->name ) + 1) );

    /* Remove instance name, if specified */
    free_safe( parm->inst_name, (strlen( parm->inst_name ) + 1) );

    /* Remove the parameter itself */
    free_safe( parm, sizeof( mod_parm ) );

  }

  PROFILE_END;

}

void mod_parm_display

(

mod_parm *

mparm

)

Outputs contents of module parameter list to standard output.

Outputs contents of specified module parameter to standard output. For debugging purposes only.

Parameters:

mparm

Pointer to module parameter list to display

References mod_parm_s::exp_head, exp_link_display(), mod_parm_s::expr, expression_s::id, mod_parm_s::name, mod_parm_s::next, obf_sig, psuppl_u::order, psuppl_u::owns_expr, PARAM_TYPE_DECLARED, PARAM_TYPE_DECLARED_LOCAL, PARAM_TYPE_INST_LSB, PARAM_TYPE_INST_MSB, PARAM_TYPE_OVERRIDE, PARAM_TYPE_SIG_LSB, PARAM_TYPE_SIG_MSB, psuppl_u::part, mod_parm_s::sig, mod_parm_s::suppl, psuppl_u::type, and vsignal_display().

  {

  char type_str[30];  /* String version of module parameter type */

  while( mparm != NULL ) {
    switch( mparm->suppl.part.type ) {
      case PARAM_TYPE_DECLARED       :  strcpy( type_str, "DECLARED" );        break;
      case PARAM_TYPE_OVERRIDE       :  strcpy( type_str, "OVERRIDE" );        break;
      case PARAM_TYPE_SIG_LSB        :  strcpy( type_str, "SIG_LSB"  );        break;
      case PARAM_TYPE_SIG_MSB        :  strcpy( type_str, "SIG_MSB"  );        break;
      case PARAM_TYPE_INST_LSB       :  strcpy( type_str, "INST_LSB" );        break;
      case PARAM_TYPE_INST_MSB       :  strcpy( type_str, "INST_MSB" );        break;
      case PARAM_TYPE_DECLARED_LOCAL :  strcpy( type_str, "DECLARED_LOCAL" );  break;
      default                        :  strcpy( type_str, "UNKNOWN" );         break;
    }
    if( mparm->name == NULL ) {
      printf( "  mparam => type: %s, order: %u, owns_exp: %u",
              type_str, mparm->suppl.part.order, mparm->suppl.part.owns_expr );
    } else {
      printf( "  mparam => name: %s, type: %s, order: %u, owns_exp: %u",
               obf_sig( mparm->name ), type_str, mparm->suppl.part.order, mparm->suppl.part.owns_expr );
    }
    if( mparm->expr != NULL ) {
      printf( ", exp_id: %d\n", mparm->expr->id );
    } else {
      printf( ", no_expr\n" );
    }
    if( mparm->sig != NULL ) {
      printf( "    " );  vsignal_display( mparm->sig );
    }
    printf( "    " );  exp_link_display( mparm->exp_head );
    mparm = mparm->next;
  }

}

mod_parm* mod_parm_find	(	const char *	name,
		mod_parm *	parm
	)

Searches specified module parameter list for matching parameter.

Returns:

Returns pointer to found module parameter or NULL if module parameter is not found.

Searches specified module parameter list for an module parameter that matches the name of the specified module parameter. If a match is found, a pointer to the found module parameter is returned to the calling function; otherwise, a value of NULL is returned if no match was found.

Parameters:

	name	Name of parameter value to find
	parm	Pointer to head of module parameter list to search

References mod_parm_s::name, mod_parm_s::next, PARAM_TYPE_DECLARED, PARAM_TYPE_DECLARED_LOCAL, psuppl_u::part, PROFILE, PROFILE_END, mod_parm_s::suppl, and psuppl_u::type.

Referenced by db_add_declared_param(), fsm_arg_parse_value(), and funit_find_param().

  { PROFILE(MOD_PARM_FIND);

  assert( name != NULL );

  while( (parm != NULL) && ((parm->name == NULL) || (strcmp( parm->name, name ) != 0) || ((parm->suppl.part.type != PARAM_TYPE_DECLARED) && (parm->suppl.part.type != PARAM_TYPE_DECLARED_LOCAL))) ) {
    parm = parm->next;
  }

  PROFILE_END;

  return( parm );
 
}

void param_db_write	(	inst_parm *	iparm,
		FILE *	file
	)

Outputs specified instance parameter to specified output stream.

Prints contents of specified instance parameter to the specified output stream. Parameters get output in the same format as signals (they type specified for parameters is DB_TYPE_SIGNAL). A leading # sign is attached to the parameter name to indicate that the current signal is a parameter and not a signal, and should therefore not be scored as a signal.

Parameters:

	iparm	Pointer to instance parameter to output to file
	file	Pointer to file handle to write parameter contents to

References curr_sig_id, vsignal_s::id, vsignal_s::name, PROFILE, PROFILE_END, inst_parm_s::sig, and vsignal_db_write().

Referenced by funit_db_write().

  { PROFILE(PARAM_DB_WRITE);

  /*
   If the parameter does not have a name, it will not be used in expressions;
   therefore, there is no reason to output this parameter to the CDD file.
  */
  if( iparm->sig->name != NULL ) {

    /* Assign a signal ID and increment it for the next signal -- this is okay to do because parameters only exist during parsing */
    iparm->sig->id = curr_sig_id++;

    /* Write the signal */
    vsignal_db_write( iparm->sig, file );

  }

  PROFILE_END;

}

void param_expr_eval	(	expression *	expr,
		funit_inst *	inst
	)

Evaluates parameter expression for the given instance.

Exceptions:

anonymous

expression_resize param_expr_eval param_expr_eval param_size_function param_find_and_set_expr_value

Recursively evaluates the specified expression tree, calculating the value of leaf nodes first. If a another parameter value is encountered, lookup the value of this parameter in the current instance instance parameter list. If the instance parameter cannot be found, we have encountered a user error; therefore, display an error message to the user indicating such.

Parameters:

	expr	Current expression to evaluate
	inst	Pointer to current instance to evaluate for

References expression_s::elem, EXP_OP_FUNC_CALL, EXP_OP_MBIT_NEG, EXP_OP_MBIT_POS, EXP_OP_MBIT_SEL, EXP_OP_PARAM, EXP_OP_PARAM_MBIT, EXP_OP_PARAM_MBIT_NEG, EXP_OP_PARAM_MBIT_POS, EXP_OP_PARAM_SBIT, EXP_OP_PASSIGN, EXP_OP_SBIT_SEL, EXP_OP_SIG, EXP_OP_STATIC, expression_operate(), expression_resize(), FALSE, funit_inst_s::funit, expression_s::funit, instance_find_by_funit(), expression_s::left, expression_s::op, param_expr_eval(), param_find_and_set_expr_value(), param_size_function(), ssuppl_u::part, PROFILE, PROFILE_END, expression_s::right, expression_s::sig, SSUPPL_TYPE_GENVAR, vsignal_s::suppl, TRUE, ssuppl_u::type, and expression_s::value.

Referenced by enumerate_resolve(), inst_parm_add(), param_expr_eval(), param_resolve_declared(), and param_resolve_override().

  { PROFILE(PARAM_EXPR_EVAL);

  funit_inst* funiti;      /* Pointer to static function instance */
  func_unit*  funit;       /* Pointer to constant function */
  int         ignore = 0;  /* Number of instances to ignore */

  if( expr != NULL ) {

    /* Initialize the current time */
    sim_time time = {0,0,0,FALSE};

    /* For constant functions, resolve parameters and resize the functional unit first */
    if( expr->op == EXP_OP_FUNC_CALL ) {
      funit = expr->elem.funit;
      assert( funit != NULL );
      funiti = instance_find_by_funit( inst, funit, &ignore );
      assert( funiti != NULL );
      param_size_function( funiti, funit );
    }

    /* Evaluate children first */
    param_expr_eval( expr->left,  inst );
    param_expr_eval( expr->right, inst );

    switch( expr->op ) {
      case EXP_OP_STATIC  :
      case EXP_OP_PASSIGN :
        break;
      case EXP_OP_PARAM          :
      case EXP_OP_PARAM_SBIT     :
      case EXP_OP_PARAM_MBIT     :
      case EXP_OP_PARAM_MBIT_POS :
      case EXP_OP_PARAM_MBIT_NEG :
        param_find_and_set_expr_value( expr, inst );
        break;
      case EXP_OP_SIG :
        assert( expr->sig != NULL );
        assert( expr->sig->suppl.part.type == SSUPPL_TYPE_GENVAR );
        break;
      default :
        /*
         Since we are not a parameter identifier, let's allocate some data for us 
         if we don't have some already.
        */
        assert( expr->value != NULL );
        assert( (expr->op != EXP_OP_SBIT_SEL) &&
                (expr->op != EXP_OP_MBIT_SEL) &&
                (expr->op != EXP_OP_MBIT_POS) &&
                (expr->op != EXP_OP_MBIT_NEG) );
        expression_resize( expr, inst->funit, FALSE, TRUE );
        break;
    }

    /* Perform the operation */
    (void)expression_operate( expr, NULL, &time );

  }

  PROFILE_END;
  
}

void param_resolve

(

funit_inst *

inst

)

Resolves all parameters for the specified instance tree.

Exceptions:

anonymous

param_resolve_override param_resolve param_resolve_declared

Called after binding has occurred. Recursively resolves all parameters for the given instance tree.

Parameters:

inst

Pointer to functional unit instance to resolve parameter values for

References funit_inst_s::child_head, funit_inst_s::next, param_resolve(), param_resolve_inst(), PROFILE, and PROFILE_END.

Referenced by funit_size_elements(), param_resolve(), and param_size_function().

  { PROFILE(PARAM_RESOLVE);

  funit_inst* child;  /* Pointer to child instance of this instance */

  /* Resolve this instance */
  param_resolve_inst( inst );

  /* Resolve all child instances */
  child = inst->child_head;
  while( child != NULL ) {
    param_resolve( child );
    child = child->next;
  }

  PROFILE_END;

}

void param_resolve_inst

(

funit_inst *

inst

)

Resolves all parameters for the specified instance.

Called after local binding has occurred. Resolves the parameters for the given functional unit instance.

Parameters:

inst

Pointer to functional unit instance to resolve parameter values for

References funit_inst_s::funit, mod_parm_s::next, func_unit_s::param_head, param_resolve_declared(), param_resolve_override(), PARAM_TYPE_DECLARED, PARAM_TYPE_DECLARED_LOCAL, psuppl_u::part, PROFILE, PROFILE_END, mod_parm_s::suppl, and psuppl_u::type.

Referenced by gen_item_resolve(), instance_resolve_helper(), and param_resolve().

  { PROFILE(PARAM_RESOLVE_INST);

  assert( inst != NULL );

  /* Resolve this instance */
  if( inst->funit != NULL ) {
    mod_parm* mparm = inst->funit->param_head;
    while( mparm != NULL ) {
      if( (mparm->suppl.part.type == PARAM_TYPE_DECLARED) ||
          (mparm->suppl.part.type == PARAM_TYPE_DECLARED_LOCAL) ) {
        param_resolve_declared( mparm, inst );
      } else {
        param_resolve_override( mparm, inst );
      }
      mparm = mparm->next;
    } 
  }

  PROFILE_END;

}

void param_set_sig_size	(	vsignal *	sig,
		inst_parm *	icurr
	)

Sets the specified signal size according to the specified instance parameter.

Sizes the specified signal according to the value of the specified instance parameter value.

Parameters:

	sig	Pointer to signal to search for in instance parameter list
	icurr	Pointer to head of instance parameter list to search

References vsignal_s::dim, psuppl_u::dimension, dim_range_s::lsb, inst_parm_s::mparm, dim_range_s::msb, PARAM_TYPE_SIG_LSB, psuppl_u::part, PROFILE, PROFILE_END, inst_parm_s::sig, mod_parm_s::suppl, psuppl_u::type, vsignal_s::value, and vector_to_int().

Referenced by funit_size_elements().

  { PROFILE(PARAM_SET_SIG_SIZE);

  assert( sig != NULL );
  assert( icurr != NULL );
  assert( icurr->sig != NULL );
  assert( icurr->mparm != NULL );

  /* Set the LSB/MSB to the value of the given instance parameter */
  if( icurr->mparm->suppl.part.type == PARAM_TYPE_SIG_LSB ) {
    sig->dim[icurr->mparm->suppl.part.dimension].lsb = vector_to_int( icurr->sig->value );
  } else {
    sig->dim[icurr->mparm->suppl.part.dimension].msb = vector_to_int( icurr->sig->value );
  }

  PROFILE_END;

}