自学教程：C++ vpi_iterate函数代码示例

int exm_python_vpi_file(char* arg) {  vpiHandle href;  vpiHandle arglist;  s_vpi_value vpi_value;  href = vpi_handle(vpiSysTfCall, 0);  arglist = vpi_iterate(vpiArgument, href);  vpi_value.format = vpiStringVal;  vpi_get_value(vpi_scan(arglist), &vpi_value);  return exm_python_file(vpi_value.value.str);}

/* * Routine to check all the double argument math functions. */static PLI_INT32 va_double_argument_compiletf(ICARUS_VPI_CONST PLI_BYTE8 *ud){    vpiHandle callh, argv, arg;    const t_double_data *data;    const char *name;    va_double_t* fun_data;    assert(ud != 0);    callh = vpi_handle(vpiSysTfCall, 0);    assert(callh != 0);    argv = vpi_iterate(vpiArgument, callh);    data = (const t_double_data *) ud;    name = data->name;    fun_data = malloc(sizeof(va_double_t));    /* Check that there are arguments. */    if (argv == 0) {        va_error_message(callh, "%s requires two arguments./n", name);        free(fun_data);        return 0;    }    /* In Icarus if we have an argv we have at least one argument. */    arg = vpi_scan(argv);    fun_data->arg1 = va_process_argument(callh, name, arg, " (arg1)");    /* Check that there are at least two arguments. */    arg = vpi_scan(argv);    if (arg == 0) {        va_error_message(callh, "%s requires two arguments./n", name);    }    fun_data->arg2 = va_process_argument(callh, name, arg, " (arg2)");    /* These functions only take two arguments. */    arg = vpi_scan(argv);    if (arg != 0) {        va_error_message(callh, "%s takes only two arguments./n", name);        vpi_free_object(argv);    }    /* Get the function that is to be used by the calltf routine. */    fun_data->func = data->func;    vpi_put_userdata(callh, fun_data);    double_funcs_count += 1;    double_funcs = (va_double_t **)realloc(double_funcs,                   double_funcs_count*sizeof(va_double_t **));    double_funcs[double_funcs_count-1] = fun_data;    /* vpi_scan() returning 0 (NULL) has already freed argv. */    return 0;}

static PLI_INT32 sys_fopenrwa_calltf(PLI_BYTE8*name){      vpiHandle callh = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv = vpi_iterate(vpiArgument, callh);      vpiHandle file = vpi_scan(argv);      s_vpi_value val;      char *mode;      unsigned idx, len;      vpi_free_object(argv);	/* Get the mode. */      mode = name + strlen(name) - 1;	/* Get the filename. */      val.format = vpiStringVal;      vpi_get_value(file, &val);	/* Verify that we have a string and that it is not NULL. */      if (val.format != vpiStringVal || !*(val.value.str)) {	    vpi_printf("WARNING: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("%s's file name argument is not a valid string./n",	                name);	    return 0;      }	/*	 * Verify that the file name is composed of only printable	 * characters.	 */      len = strlen(val.value.str);      for (idx = 0; idx < len; idx++) {	    if (! isprint(val.value.str[idx])) {		  char msg [64];		  snprintf(msg, 64, "WARNING: %s:%d:",		           vpi_get_str(vpiFile, callh),		           (int)vpi_get(vpiLineNo, callh));		  vpi_printf("%s %s's file name argument contains non-"		             "printable characters./n", msg, name);		  vpi_printf("%*s /"%s/"/n", (int) strlen(msg), " ", val.value.str);		  return 0;	    }      }	/* Open the file and return the result. */      val.format = vpiIntVal;      val.value.integer = vpi_fopen(val.value.str, mode);      vpi_put_value(callh, &val, 0, vpiNoDelay);      return 0;}

static PLI_INT32 sys_mti_random_calltf(ICARUS_VPI_CONST PLI_BYTE8*name){      vpiHandle callh, argv, seed = 0;      s_vpi_value val;      int i_seed = COOKIE;      struct context_s *context;      (void)name; /* Parameter is not used. */	/* Get the argument list and look for a seed. If it is there,	   get the value and reseed the random number generator. */      callh = vpi_handle(vpiSysTfCall, 0);      argv = vpi_iterate(vpiArgument, callh);      val.format = vpiIntVal;      if (argv) {	    seed = vpi_scan(argv);	    vpi_free_object(argv);	    vpi_get_value(seed, &val);	    i_seed = val.value.integer;	      /* Since there is a seed use the current	         context or create a new one */	    context = (struct context_s *)vpi_get_userdata(callh);	    if (!context) {		  context = (struct context_s *)calloc(1, sizeof(*context));		  context->mti = NP1;		    /* squirrel away context */		  vpi_put_userdata(callh, (void *)context);	    }	      /* If the argument is not the Icarus cookie, then		 reseed context */	    if (i_seed != COOKIE) sgenrand(context, i_seed);      } else {	    /* use global context */          context = &global_context;      }        /* Calculate and return the result */      val.value.integer = genrand(context);      vpi_put_value(callh, &val, 0, vpiNoDelay);        /* mark seed with cookie */      if (seed && i_seed != COOKIE) {	    val.value.integer = COOKIE;	    vpi_put_value(seed, &val, 0, vpiNoDelay);      }      return 0;}

static PLI_INT32 sys_dumplimit_calltf(ICARUS_VPI_CONST PLI_BYTE8 *name){      vpiHandle callh = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv = vpi_iterate(vpiArgument, callh);      s_vpi_value val;      /* Get the value and set the dump limit. */      val.format = vpiIntVal;      vpi_get_value(vpi_scan(argv), &val);      dump_limit = val.value.integer;      vpi_free_object(argv);      return 0;}

static PLI_INT32 poke_calltf(char*xx){      s_vpi_value value;      s_vpi_time poke_time;      s_cb_data cb_data;      vpiHandle sys = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv = vpi_iterate(vpiArgument, sys);      vpiHandle dst, val, del, tmp;      struct poke_details*poke;      (void)xx;  /* Parameter is not used. */      assert(argv);      dst = vpi_scan(argv);      assert(dst);      val = vpi_scan(argv);      assert(val);      del = vpi_scan(argv);      assert(del);      tmp = vpi_scan(argv);      assert(tmp == 0);      poke = calloc(1, sizeof (struct poke_details));      assert(poke);      poke->dst = dst;      value.format = vpiIntVal;      vpi_get_value(val, &value);      poke->val = value.value.integer;      value.format = vpiIntVal;      vpi_get_value(del, &value);      poke_time.low = value.value.integer;      poke_time.high = 0;      poke_time.type = vpiSimTime;      cb_data.reason = cbAtStartOfSimTime;      cb_data.cb_rtn = delayed_poke;      cb_data.user_data = (char*)poke;      cb_data.time = &poke_time;      vpi_register_cb(&cb_data);      return 0;}

static int sys_fgets_calltf(char *name){      unsigned int mcd;      FILE*fd;      s_vpi_value value, rval;      char*txt;      unsigned txt_len;      vpiHandle sys  = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv = vpi_iterate(vpiArgument, sys);      vpiHandle str  = vpi_scan(argv);      vpiHandle mch  = vpi_scan(argv);      value.format = vpiIntVal;      vpi_get_value(mch, &value);      mcd = value.value.integer;      fd = vpi_get_file(mcd);      if (!fd || IS_MCD(mcd)) {	    rval.format = vpiIntVal;	    rval.value.integer = 0;	    vpi_put_value(sys, &rval, 0, vpiNoDelay);	    return 0;      }      txt_len = vpi_get(vpiSize, str) / 8;      txt = malloc(txt_len + 1);      if (fgets(txt, txt_len, fd) == 0) {	    rval.format = vpiIntVal;	    rval.value.integer = 0;	    vpi_put_value(sys, &rval, 0, vpiNoDelay);	    free(txt);	    return 0;      }      rval.format = vpiIntVal;      rval.value.integer = strlen(txt);      vpi_put_value(sys, &rval, 0, vpiNoDelay);      value.format = vpiStringVal;      value.value.str = txt;      vpi_put_value(str, &value, 0, vpiNoDelay);      free(txt);      return 0;}

static PLI_INT32 calltf(PLI_BYTE8 *data){    vpiHandle callh = vpi_handle(vpiSysTfCall, 0);    vpiHandle argv = vpi_iterate(vpiArgument, callh);    vpiHandle mod = vpi_scan(argv);    (void)data;  /* Parameter is not used. */    vpi_free_object(argv);    vpi_printf("Module instance %s is%s a cell./n",               vpi_get_str(vpiFullName, mod),               vpi_get(vpiCellInstance, mod) ? "" : " not");    return 0;}

static int sys_dist_uniform_calltf(char*name){      s_vpi_value val;      vpiHandle call_handle;      vpiHandle argv;      vpiHandle seed = 0, start, end;      long i_seed, i_start, i_end;      call_handle = vpi_handle(vpiSysTfCall, 0);      assert(call_handle);      argv = vpi_iterate(vpiArgument, call_handle);      if (argv == 0) {	    vpi_printf("ERROR: %s requires parameters "		       "(seed, start, end)/n", name);	    return 0;      }      seed = vpi_scan(argv);      assert(seed);      start = vpi_scan(argv);      assert(start);      end = vpi_scan(argv);      assert(end);      vpi_free_object(argv);      val.format = vpiIntVal;      vpi_get_value(seed, &val);      i_seed = val.value.integer;      vpi_get_value(start, &val);      i_start = val.value.integer;      vpi_get_value(end, &val);      i_end = val.value.integer;      val.format = vpiIntVal;      val.value.integer = rtl_dist_uniform(&i_seed, i_start, i_end);      vpi_put_value(call_handle, &val, 0, vpiNoDelay);      val.format = vpiIntVal;      val.value.integer = i_seed;      vpi_put_value(seed, &val, 0, vpiNoDelay);      return 0;}

VpiIterator::VpiIterator(GpiImplInterface *impl, GpiObjHdl *hdl) : GpiIterator(impl, hdl),                                                                   m_iterator(NULL){    vpiHandle iterator;    vpiHandle vpi_hdl = m_parent->get_handle<vpiHandle>();    int type = vpi_get(vpiType, vpi_hdl);    if (NULL == (selected = iterate_over.get_options(type))) {        LOG_WARN("VPI: Implementation does not know how to iterate over %s(%d)",                  vpi_get_str(vpiType, vpi_hdl), type);        return;    }    for (one2many = selected->begin();         one2many != selected->end();         one2many++) {        /* GPI_GENARRAY are pseudo-regions and all that should be searched for are the sub-regions */        if (m_parent->get_type() == GPI_GENARRAY && *one2many != vpiInternalScope) {            LOG_DEBUG("vpi_iterator vpiOneToManyT=%d skipped for GPI_GENARRAY type", *one2many);            continue;        }        iterator = vpi_iterate(*one2many, vpi_hdl);        if (iterator) {            break;        }        LOG_DEBUG("vpi_iterate type=%d returned NULL", *one2many);    }    if (NULL == iterator) {        LOG_DEBUG("vpi_iterate return NULL for all relationships on %s (%d) type:%s",                  vpi_get_str(vpiName, vpi_hdl),                  type,                  vpi_get_str(vpiType, vpi_hdl));        selected = NULL;        return;    }    LOG_DEBUG("Created iterator working from type %d %s",              *one2many,              vpi_get_str(vpiFullName, vpi_hdl));    m_iterator = iterator;}

char *tf_istrgetp(PLI_INT32 n, PLI_INT32 fmt, void *obj){      vpiHandle sys_h, sys_i, arg_h = 0;      s_vpi_value value;      char *rtn = 0;      assert(n > 0);      /* get task/func handle */      sys_h = (vpiHandle)obj;      sys_i = vpi_iterate(vpiArgument, sys_h);      /* find nth arg */      while (n > 0) {	    if (!(arg_h = vpi_scan(sys_i))) { goto out; }	    n--;      }      if (vpi_get(vpiType, arg_h) == vpiConstant &&	  vpi_get(vpiConstType, arg_h) == vpiStringConst)      {	    value.format = vpiStringVal;	    vpi_get_value(arg_h, &value);	    rtn = value.value.str;      } else {	    value.format = -1;	    switch (tolower(fmt)) {		  case 'b': value.format = vpiBinStrVal; break;		  case 'o': value.format = vpiOctStrVal; break;		  case 'd': value.format = vpiDecStrVal; break;		  case 'h': value.format = vpiHexStrVal; break;	    }	    if (value.format > 0) {		  vpi_get_value(arg_h, &value);		  rtn = value.value.str;	    }      }      vpi_free_object(sys_i);out:      if (pli_trace) {	    fprintf(pli_trace, "tf_istrgetp(n=%d, fmt=%c, obj=%p) --> /"%s/"/n",		  n, fmt, obj, rtn);      }      return rtn;}

/* * process one instance and recursively process all under instances * processing is top down depth first */static void process_inst(vpiHandle up_ihref) { int isiz; vpiHandle iter, ihref; iproc_rtn(up_ihref); if ((iter = vpi_iterate(vpiModule, up_ihref)) == NULL) return; isiz = vpi_get(vpiSize, iter); vpi_printf("  There are %d instances in %s./n", isiz,  vpi_get_str(vpiFullName, up_ihref));  for (;;)  {   if ((ihref = vpi_scan(iter)) == NULL) break;   process_inst(ihref);  }}

static vpiHandle find_scope(vpiHandle scope, const char*name){      vpiHandle idx = vpi_iterate(vpiModule, scope);      assert(idx);      vpiHandle cur;      while ( (cur = vpi_scan(idx)) ) {	    if ( strcmp(name, vpi_get_str(vpiName,cur)) == 0) {		  vpi_free_object(idx);		  return cur;	    }      }      return 0;}

/* * acc_next_topmod implemented using VPI interface */handle acc_next_topmod(handle prev_topmod){      static vpiHandle last = NULL;      static vpiHandle mod_i = NULL;      if (!prev_topmod) {	    /* start over */	    mod_i = vpi_iterate(vpiModule, NULL);      } else {	    /* subsequent time through */	    assert(prev_topmod == last);      }      last = vpi_scan(mod_i);      return last;}

/* * Check that the function is called with the correct argument. */static PLI_INT32 sys_clog2_compiletf(PLI_BYTE8 *name){      vpiHandle callh = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv, arg;      assert(callh != 0);      argv = vpi_iterate(vpiArgument, callh);      (void) name;  /* Not used! */	/* We must have an argument. */      if (argv == 0) {	    vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("$clog2 requires one numeric argument./n");	    vpi_control(vpiFinish, 1);	    return 0;      }	/* The argument must be numeric. */      arg = vpi_scan(argv);      if (! is_numeric_obj(arg)) {	    vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("The first argument to $clog2 must be numeric./n");	    vpi_control(vpiFinish, 1);      }	/* We can have a maximum of one argument. */      if (vpi_scan(argv) != 0) {	    char msg [64];	    unsigned argc;	    snprintf(msg, 64, "ERROR: %s:%d:",	             vpi_get_str(vpiFile, callh),	             (int)vpi_get(vpiLineNo, callh));	    argc = 1;	    while (vpi_scan(argv)) argc += 1;            vpi_printf("%s $clog2 takes at most one argument./n", msg);            vpi_printf("%*s Found %u extra argument%s./n",	               (int) strlen(msg), " ", argc, argc == 1 ? "" : "s");            vpi_control(vpiFinish, 1);      }      return 0;}

/* * Implement $fflush system function */static PLI_INT32 sys_fflush_calltf(PLI_BYTE8*name){      vpiHandle callh = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv = vpi_iterate(vpiArgument, callh);      vpiHandle arg;      s_vpi_value val;      PLI_UINT32 fd_mcd;      FILE *fp;      errno = 0;	/* If we have no argument then flush all the streams. */      if (argv == 0) {	    fflush(NULL);	    return 0;      }	/* Get the file/MC descriptor and verify that it is valid. */      arg = vpi_scan(argv);      vpi_free_object(argv);      val.format = vpiIntVal;      vpi_get_value(arg, &val);      fd_mcd = val.value.integer;	/* If the MCD is zero we have nothing to do so just return. */      if (fd_mcd == 0) return 0;      if ((! IS_MCD(fd_mcd) && vpi_get_file(fd_mcd) == NULL) ||          ( IS_MCD(fd_mcd) && vpi_mcd_printf(fd_mcd, "%s", "") == EOF) ||          (! fd_mcd)) {	    vpi_printf("WARNING: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("invalid file descriptor/MCD (0x%x) given to %s./n",	               (unsigned int)fd_mcd, name);	    errno = EBADF;	    return 0;      }      if (IS_MCD(fd_mcd)) {	    vpi_mcd_flush(fd_mcd);      } else {	      /* If we have a valid file descriptor flush the file. */	    fp = vpi_get_file(fd_mcd);	    if (fp) fflush(fp);      }      return 0;}

static PLI_INT32 to_vec_compiletf(ICARUS_VPI_CONST PLI_BYTE8*user_data){      (void) user_data; /* Parameter is not used. */      vpiHandle systf_handle, arg_iterator, arg_handle;      PLI_INT32 arg_type[2];      /* obtain a handle to the system task instance */      systf_handle = vpi_handle(vpiSysTfCall, NULL);      if (systf_handle == NULL) {          vpi_printf("ERROR: $ivl_darray_method$to_vec failed to obtain systf handle/n");          vpi_control(vpiFinish,0); /* abort simulation */          return 0;      }      /* obtain handles to system task arguments */      arg_iterator = vpi_iterate(vpiArgument, systf_handle);      if (arg_iterator == NULL) {          vpi_printf("ERROR: $ivl_darray_method$to_vec requires 2 arguments/n");          vpi_control(vpiFinish, 0);          return 0;      }      /* check the type of object in system task arguments */      arg_handle = vpi_scan(arg_iterator);      for(int i = 0; i < 2; ++i) {          arg_type[i] = vpi_get(vpiType, arg_handle);          arg_handle = vpi_scan(arg_iterator);      }      if (arg_handle != NULL) {       /* are there more arguments? */          vpi_printf("ERROR: $ivl_darray_method$to_vec can only have 2 arguments/n");          vpi_free_object(arg_iterator);          vpi_control(vpiFinish, 0);          return 0;      }      if ((arg_type[0] != vpiRegArray) ||          (arg_type[1] != vpiNet && arg_type[1] != vpiReg && arg_type[1] != vpiBitVar)) {          vpi_printf("ERROR: $ivl_darray_method$to_vec value arguments must be a dynamic array and a net or reg/n");          vpi_free_object(arg_iterator);          vpi_control(vpiFinish, 0);          return 0;      }      return 0;}

static PLI_INT32 regfileTestCompileTf(){  vpiHandle sys = vpi_handle(vpiSysTfCall, 0);  vpiHandle argv = vpi_iterate(vpiArgument, sys);  vpiHandle arg = NULL;  init();  /* Check for arguments number */  for (int i=0; i < ARGS_NR; i++) {    arg = vpi_scan(argv);    assert(arg);    args[i].handle = arg;    char* name = vpi_get_str(vpiName, arg);    if (!(args[i].name = copy_string(args[i].name, name))) bomb();  }  return 0;}

static PLI_INT32 sys_fgets_compiletf(PLI_BYTE8*name){      vpiHandle callh = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv = vpi_iterate(vpiArgument, callh);      vpiHandle arg;	/*	 * Check that there are two arguments and that the first is a	 * register and that the second is numeric.	 */      if (argv == 0) {	    vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("%s requires two arguments./n", name);	    vpi_control(vpiFinish, 1);	    return 0;      }      if (vpi_get(vpiType, vpi_scan(argv)) != vpiReg) {	    vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("%s's first argument must be a reg./n", name);	    vpi_control(vpiFinish, 1);      }      arg = vpi_scan(argv);      if (! arg) {	    vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("%s requires a second (numeric) argument./n", name);	    vpi_control(vpiFinish, 1);	    return 0;      }      if (! is_numeric_obj(arg)) {	    vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("%s's second argument must be numeric./n", name);	    vpi_control(vpiFinish, 1);      }	/* Make sure there are no extra arguments. */      check_for_extra_args(argv, callh, name, "two arguments", 0);      return 0;}

static PLI_INT32 sys_dumplimit_calltf(ICARUS_VPI_CONST PLI_BYTE8 *name){      vpiHandle callh = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv = vpi_iterate(vpiArgument, callh);      s_vpi_value val;      (void)name; /* Parameter is not used. */      /* Get the value and set the dump limit. */      val.format = vpiIntVal;      vpi_get_value(vpi_scan(argv), &val);      dump_limit = val.value.integer;      fstWriterSetDumpSizeLimit(dump_file, dump_limit);      vpi_free_object(argv);      return 0;}

static PLI_INT32 sys_deposit_compiletf(ICARUS_VPI_CONST PLI_BYTE8 *name){      vpiHandle callh = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv = vpi_iterate(vpiArgument, callh);      vpiHandle target, value;      /* Check that there are arguments. */      if (argv == 0) {	    vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("%s requires two arguments./n", name);	    vpi_control(vpiFinish, 1);	    return 0;      }      /* Check that there are at least two arguments. */      target = vpi_scan(argv);  /* This should never be zero. */      value = vpi_scan(argv);      if (value == 0) {	    vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("%s requires two arguments./n", name);	    vpi_control(vpiFinish, 1);	    return 0;      }      assert(target);      /* Check the targets type. It must be a net or a register. */      switch (vpi_get(vpiType, target)) {            case vpiNet:            case vpiReg:                  break;            default:		  vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),		             (int)vpi_get(vpiLineNo, callh));		  vpi_printf("invalid target type (%s) for %s./n",		             vpi_get_str(vpiType, target), name);		  vpi_control(vpiFinish, 1);      }      /* Check that there is at most two arguments. */      check_for_extra_args(argv, callh, name, "two arguments", 0);      return 0;}

/* * routine to get and zero all delays in design  */int process_all_insts(struct t_cb_data *cbp){ int isiz; vpiHandle topiter, topiref; /* build the iterator for each module */ topiter = vpi_iterate(vpiModule, NULL); isiz = vpi_get(vpiSize, topiter); vpi_printf("  There are %d top level modules./n", isiz); for (;;)  {   if ((topiref = vpi_scan(topiter)) == NULL) break;   process_inst(topiref);  } vpi_printf("  >>> All instances processed - continuing with simulation./n"); return(0);}

static PLI_INT32 listparams_calltf(PLI_BYTE8*name)#endif{      vpiHandle sys  = vpi_handle(vpiSysTfCall,0);      vpiHandle scope= vpi_handle(vpiScope, sys);      vpiHandle argv = vpi_iterate(vpiArgument, sys);      vpiHandle item;      while ( (item = vpi_scan(argv)) ) {	    s_vpi_value value;	    value.format = vpiStringVal;	    vpi_get_value(item, &value);	    param_by_name(scope, value.value.str);      }      return 0;}

static int sys_fputc_calltf(char *name){      unsigned int mcd;      int type;      unsigned char x;      s_vpi_value value, xvalue;      vpiHandle sys = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv = vpi_iterate(vpiArgument, sys);      vpiHandle item = vpi_scan(argv);      FILE *fp;      if (item == 0) {	    vpi_printf("%s: mcd parameter missing./n", name);	    return 0;      }      type = vpi_get(vpiType, item);      switch (type) {	    case vpiReg:	    case vpiRealVal:	    case vpiIntegerVar:	      break;	    default:	      vpi_printf("ERROR: %s mcd parameter must be of integral", name);	      vpi_printf(", got vpiType=%d/n", type);	      vpi_free_object(argv);	      return 0;      }      value.format = vpiIntVal;      vpi_get_value(item, &value);      mcd = value.value.integer;      if (IS_MCD(mcd)) return EOF;      item = vpi_scan(argv);      xvalue.format = vpiIntVal;      vpi_get_value(item, &xvalue);      x = xvalue.value.integer;      fp = vpi_get_file(mcd);      if (!fp) return EOF;      return fputc(x, fp);}

static PLI_INT32 sys_ungetc_calltf(PLI_BYTE8*name){      vpiHandle callh = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv = vpi_iterate(vpiArgument, callh);      vpiHandle arg;      s_vpi_value val;      PLI_UINT32 fd_mcd;      FILE *fp;      int chr;      errno = 0;	/* Get the character. */      arg = vpi_scan(argv);      val.format = vpiIntVal;      vpi_get_value(arg, &val);      chr = val.value.integer;	/* Get the file/MC descriptor. */      arg = vpi_scan(argv);      vpi_free_object(argv);      val.format = vpiIntVal;      vpi_get_value(arg, &val);      fd_mcd = val.value.integer;	/* Return EOF if this is not a valid fd. */      fp = vpi_get_file(fd_mcd);      if (!fp) {	    vpi_printf("WARNING: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("invalid file descriptor (0x%x) given to %s./n",	               (unsigned int)fd_mcd, name);	    errno = EBADF;	    val.format = vpiIntVal;	    val.value.integer = EOF;	    vpi_put_value(callh, &val, 0, vpiNoDelay);	    return 0;      }	/* ungetc the character and return the result. */      val.format = vpiIntVal;      val.value.integer = ungetc(chr, fp);      if (val.value.integer != EOF) val.value.integer = 0;      vpi_put_value(callh, &val, 0, vpiNoDelay);      return 0;}

static PLI_INT32 sys_sdf_annotate_calltf(PLI_BYTE8*name){      s_vpi_value value;      vpiHandle sys = vpi_handle(vpiSysTfCall,0);      vpiHandle argv = vpi_iterate(vpiArgument, sys);	/* The first argument is the path to the SDF file. */      vpiHandle path = vpi_scan(argv);      assert(path);      value.format = vpiStringVal;      vpi_get_value(path, &value);      if ((value.format != vpiStringVal) || !value.value.str) {	    vpi_printf("ERROR: %s: File name argument (type=%d)"		       " does not have a string value./n",		       name, vpi_get(vpiType, path));	    vpi_control(vpiFinish, 1);	    return 0;      }      char*path_str = strdup(value.value.str);      FILE*sdf_fd = fopen(path_str, "r");      if (sdf_fd == 0) {	    vpi_printf("ERROR: %s: Unable to open SDF file `%s'."		       " Skipping annotation./n", name, path_str);	    return 0;      }	/* The optional second argument is the scope to annotate. */      sdf_scope = vpi_scan(argv);      if (sdf_scope)	    vpi_free_object(argv);      if (sdf_scope == 0) {	    sdf_scope = vpi_handle(vpiScope,sys);      }      sdf_cur_cell = 0;      sdf_process_file(sdf_fd, path_str);      fclose(sdf_fd);      free(path_str);      return 0;}

static PLI_INT32 sys_sdf_annotate_compiletf(ICARUS_VPI_CONST PLI_BYTE8*name){      vpiHandle callh = vpi_handle(vpiSysTfCall,0);      vpiHandle argv = vpi_iterate(vpiArgument, callh);      vpiHandle module;      check_command_line_args();	/* Check that we have a file name argument. */      if (argv == 0) {	    vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("%s requires a file name argument./n", name);	    vpi_control(vpiFinish, 1);	    return 0;      }      if (! is_string_obj(vpi_scan(argv))) {	    vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("%s's file name must be a string./n", name);	    vpi_control(vpiFinish, 1);      }	/* The module argument is optional. */      module = vpi_scan(argv);      if (module == 0) return 0;      if (vpi_get(vpiType, module) != vpiModule) {	    vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("%s's second argument must be a module instance./n",	               name);	    vpi_control(vpiFinish, 1);      }	/* Warn the user that we only use the first two arguments. */      if (vpi_scan(argv) != 0) {	    vpi_printf("WARNING: %s:%d: ", vpi_get_str(vpiFile, callh),	               (int)vpi_get(vpiLineNo, callh));	    vpi_printf("%s currently only uses the first two argument./n",	               name);	    vpi_free_object(argv);      }      return 0;}

static vpiHandle find_scope(vpiHandle scope, const char*name){      vpiHandle idx = vpi_iterate(vpiModule, scope);	/* If this scope has no modules then it can't have the one we	 * are looking for so just return 0. */      if (idx == 0) return 0;      vpiHandle cur;      while ( (cur = vpi_scan(idx)) ) {	    if ( strcmp(name, vpi_get_str(vpiName,cur)) == 0) {		  vpi_free_object(idx);		  return cur;	    }      }      return 0;}

/* * Compare the +arguments passed to the simulator with the argument * passed to the $test$plusargs. If there is a simulator argument that * is like this argument, then return true. Otherwise return false. */static PLI_INT32 sys_test_plusargs_calltf(ICARUS_VPI_CONST PLI_BYTE8*name){      s_vpi_value val;      s_vpi_vlog_info info;      int idx;      int flag = 0;      size_t slen, len;      (void)name; /* Parameter is not used. */      vpiHandle callh = vpi_handle(vpiSysTfCall, 0);      vpiHandle argv = vpi_iterate(vpiArgument, callh);      val.format = vpiStringVal;      vpi_get_value(vpi_scan(argv), &val);      slen = strlen(val.value.str);      vpi_get_vlog_info(&info);	/* Look for a +arg that matches the prefix supplied. */      for (idx = 0 ;  idx < info.argc ;  idx += 1) {	      /* Skip arguments that are not +args. */	    if (info.argv[idx][0] != '+')		  continue;	    len = strlen(info.argv[idx]+1);	    if (len < slen)		  continue;	    if (strncmp(val.value.str, info.argv[idx]+1, slen) != 0)		  continue;	    flag = 1;	    break;      }      val.format = vpiIntVal;      val.value.integer = flag;      vpi_put_value(callh, &val, 0, vpiNoDelay);      vpi_free_object(argv);      return 0;}