예제 #1
0
/*************************************************
   lxt2_recordsetup
   - specify options
 ************************************************/
int lxt2_recordsetup( int data, int reason )
{
    int i;
    acc_initialize();

    switch( reason ) {
    case reason_checktf:
	if( tf_nump() == 0 ) {
	    tf_error( "not enough arguments to recordsetup" );
	    tf_dofinish();
	}
	goto DONE;
    case reason_calltf:
	if( lxt.inited ) {
	    tf_error( "recording has already started" );
	    tf_dofinish();
	}
	break;
    default:
	goto DONE;
    }
    for( i = 1; i <= tf_nump(); ++i ) {
	lxt2_option( acc_fetch_tfarg_str(i) );
    }
DONE:
    acc_close();
    return 0;
}
예제 #2
0
파일: plimfil2.c 프로젝트: kammoh/cvcx
/*
 * check the fill memory user PLI function
 * notice calling tf_error here will inhibit simulation
 * probably sould also check 2nd index argument 
 */
static void check_plimemfil2(int data, int reason)
{
 if (tf_nump() != 2)
  {
   tf_error("$pli_memfil2 has %d arguments - 2 required", tf_nump());
   return;
  }
 /* this associates nodeinfo struct with argument */
 tf_nodeinfo(1, &ninfo);
 if (ninfo.node_type != TF_MEMORY_NODE)
  {
   tf_error("$pli_memfil2 first argument not read/write memory select");
   return;
  }
}
예제 #3
0
int monitor_checktf(void)
{
  int nump=tf_nump();
  if (nump < 3)
  {
    cDispmon("disp", MON_ERR, "Usage: $dispmon(\"unit\", tag, "
           "\"printf-style-format\", modulename, reg-or-int, "
	   "reg-or-int);\nin instance %s", tf_mipname());
  } else if (tf_typep(1) != tf_string)
  {
    cDispmon("disp", MON_ERR,"dispmon unit name is not a string\n"
	     "in instance %s",tf_mipname());
  } else if (tf_typep(3) != tf_string)
  {
    cDispmon("disp", MON_ERR, "dispmon format field is not a string\n"
	     "in instance %s", tf_mipname());
  } else
  {
    size_t nargs=monitor_nfmtargs(tf_getcstringp(3));
    if(nargs+3!=nump)
    {
      cDispmon("disp",MON_ERR, 
	       "wrong number of parameters for format string \"%s\"\n"
	       "in instance %s", tf_getcstringp(3), tf_mipname());
    }
  }
  return 0;
}
예제 #4
0
/*************************************************
   lxt2_recordclose
   - close lxt file and stop recording
 ************************************************/
int lxt2_recordclose( int data, int reason )
{
    acc_initialize();

    switch( reason ) {
    case reason_checktf:
	if( tf_nump() != 0 ) {
	    tf_error( "too many arguments to recordclose" );
	    tf_dofinish();
	}
	goto DONE;
    case reason_calltf:
	if( !lxt.inited ) {
	    tf_error( "recording has not started" );
	    tf_dofinish();
	    goto DONE;
	}
	break;
    default:
	goto DONE;
    }
    lxt2_close();
DONE:
    acc_close();
    return 0;
}
예제 #5
0
파일: plimfil.c 프로젝트: kammoh/cvcx
/*
 * check the fill memory user PLI function
 * notice calling tf_error here will inhibit simulation
 * probably sould also check 2nd index argument
 */
static void check_plimemfill(int data, int reason)
{
    struct t_tfexprinfo xinfo;

    if (tf_nump() != 2)
    {
        tf_error("$pli_memfill has %d arguments - 2 required", tf_nump());
        return;
    }
    tf_exprinfo(1, &xinfo);
    if (xinfo.expr_type != TF_RWMEMSELECT)
    {
        tf_error("$pli_memfill first argument not read/write memory select");
        return;
    }
}
int util_get_plus_args_num() {

/* Example use

integer         num_vectors;            // number of test vectors
integer         MAX_FAILURES;           // max failed vectors before aborting

initial
  begin
    // get integers from plus argument values
    num_vectors = $util_get_plus_args_num("num_vectors");
    MAX_FAILURES = $util_get_plus_args_num("max_failures");
    $display("%d VECTORS IN TEST FILE.", num_vectors);
    $display("Maximum number of failures is %d", MAX_FAILURES);
  end
*/

   /*  Input: [unsigned int which is a string |
    *                            C string ]
    *  Returns: Arg. value in 32 bit integer.
    *            On error returns VERILOG_C_ERROR
    *  Action:  Gets the parameter, calls  'mc_scan_plusargs'
    *            to get the arg. value.
    *     
    */
					   
				
    int np;
    char *cp;

    np = tf_nump();
    if ( np != 1 ) {
        if (DEBUG_PLUS_ARGS) {
	    io_printf("get_plus_args_num(): Error: Number of args != 1.\n");
        }
	tf_putp(0, VERILOG_ERROR);
	return(VERILOG_ERROR);
    }

    cp = mc_scan_plusargs(tf_getcstringp(1));
    if (cp == NULL ) {
      if (DEBUG_PLUS_ARGS) {
	  io_printf("get_plus_args_num():  Matching number is not found:  %d\n", tf_getcstringp(1));
      }
      tf_putp(0, VERILOG_ERROR);
      return(VERILOG_ERROR);
    }

    if (DEBUG_PLUS_ARGS)
	io_printf("get_plus_args_num():  Got integer value: %d\n", atoi(cp));

    tf_putp(0, atoi(cp) );
    return(VERILOG_OK);
}
예제 #7
0
int parse_ch_dispmon(void)
{
  if (tf_nump() != 1) {
    printf("ERROR(parse_ch_dispmon): Usage: "
	   "$parse_ch_dispmon(\"<unit>=<level>=<0/1>(,<unit>=<level>=<0/1>)*\"\n");
  } else {
    char *l_string=tf_getcstringp(1);
    scan_n_chdispmon(l_string);
  }
    return 0;
}
예제 #8
0
void error_call(int data, int reason)
{
  char *ptr_mipname;
  char *ptr;
  int i;

  int ms, us, ns, ps;

  get_time (&ms, &us, &ns, &ps);

  ptr_mipname =  tf_mipname();

  /* Requires at least two arguments */
  if (tf_nump() < ARG2) {
      tf_error("$error requires at least two arguments, error-disable-tag, and format-string");
      tf_dofinish();
      return;
   }

   /*  First argument to $error() must be a string */
   if (tf_typep(ARG1) != tf_string) {
      tf_error("First argument to $error must be a value");
      tf_dofinish();
   }

   /*  Second argument to $error() must be a string */
   if (tf_typep(ARG2) != tf_string) {
      tf_error("Second argument to $error must be a formating string");
      tf_dofinish();
   }

   for (i = 0; i < diserr_num; i++) {
     ptr = strchr(diserr_arr[i], '.');
     if (ptr == NULL) {
       if (strcmp (tf_getcstringp(ARG1), diserr_arr[i]) == 0) {
	   io_printf ("%05d.%03d.%03d.%03d: ERROR: %s:%s\n",  ms,us,ns,ps, ptr_mipname, format(ptr_mipname));
	 return;
       }
     }
     else {
       sprintf (format_buffer, "%s.%s\0", tf_getcstringp(ARG1), ptr_mipname);
       if (strcmp (format_buffer, diserr_arr[i]) == 0) {
	 io_printf ("%05d.%03d.%03d.%03d: ERROR: %s:%s\n",  ms,us,ns,ps, ptr_mipname, format(ptr_mipname));
	 return;
       }
     }
   }
   io_printf ("%05d.%03d.%03d.%03d: ERROR: %s:%s\n",  ms,us,ns,ps, ptr_mipname, format(ptr_mipname));
   if (!error_disable) tf_dofinish();

   return;
}
예제 #9
0
/*----------------------------------------------------------------------------
* int
* do_ch_dispmon()
* entry point for $ch_dispmon
*
* int
* ch_dispmon()
* Return Value --
* always 0
*
* Design --
* Error check V-side arguments, modify hash table entries
* - Set all tags >= l_tag on/off
* - Set default if "all" is specified so later initialized units may
* use the 'all' setting too.
* 
* Side effects --
* modifies hash table entries and default ms entries ..
*----------------------------------------------------------------------------
*/
int
do_ch_dispmon(void)
{
  if (tf_nump() < 3) {
    printf("ERROR(ch_dispmon): Usage: "
	   "$ch_dispmon(unit, tag, value(1 = on, 0 = off))\n");
  } else {
    char *l_unit_name=tf_getcstringp(1);
    int l_tag= tf_getp(2);
    int l_value=tf_getp(3);
    return(ch_dispmon(l_unit_name, l_tag, l_value));
  }
return 0;
}
예제 #10
0
/*----------------------------------------------------------------------------
* static void
* do_mon(int p_add_newline)
* error check Verilog side arguments, generate then print line
*
* Return Value --
* none
*
* Design --
* 
* Side effects --1H
* possible death, modifies global_errors
*----------------------------------------------------------------------------
*/
static int
do_mon(int p_add_newline)
{
  char *unit_name_arg = tf_getcstringp(1);
  char *l_unit;
  int l_tag = tf_getp(2);
  int l_mon_type;

  if(!unit_name_arg)
  {
    char *mipname = tf_mipname();
    printf("ERROR: failed to read first argument to $dispmon or "
	   "$writemon, in 'do_mon()'. Hierarchy is '%s'\n",
	   mipname ? mipname : "NULL");
    return 0;
  }
  else
  {
    l_unit = strdup(unit_name_arg);
    if(!l_unit)
    {
      printf("ERROR: strdup failed in 'do_mon()'\n");
      return 0;
    }
  }

  if(!ms.unit_tbl)
    init_unit_tbl();

  l_mon_type=mon_type_for(l_unit, l_tag);
  
  if(l_mon_type!=NO_MON_TYPE)
  {
    int l_input_parms = tf_nump();   
    char *l_output=dispmon_parse(tf_getcstringp(3), l_input_parms, 4, 
				 l_unit);
    if (0!=l_output)
    {
      print_tagged_line("", l_unit, l_output, l_mon_type, p_add_newline);
      free(l_output);
    }
  }
  free(l_unit);
  return 0;
}
예제 #11
0
void info_call(int data, int reason)
{
    char *ptr_mipname;
    int i, level;

    int ms, us, ns, ps;
    get_time (&ms, &us, &ns, &ps);
	 
    ptr_mipname =  tf_mipname();

   /* Requires at least two arguments */
  if (tf_nump() < ARG2) {
      tf_error("$info requires at least two arguments, info-level and format-string");
      tf_dofinish();
      return;
   }

   /*  First argument to $info() must be a value */
   if (tf_typep(ARG1) != tf_readonly) {
      tf_error("First argument to $info must be a value");
      tf_dofinish();
   }

   /*  Second argument to $info() must be a string */
   if (tf_typep(ARG2) != tf_string) {
      tf_error("Second argument to $info must be a formating string");
      tf_dofinish();
   }

   level = tf_getp(ARG1);

   if (level == 0) {
     io_printf ("%05d.%03d.%03d.%03d: INFO(%d): %s:%s\n",  ms,us,ns,ps, level, ptr_mipname, format(ptr_mipname));
   }
   else {
     for (i = 0; i < mon_path_num; i++) {
       if ((level <= mon_level[i]) &&
	   (strmatch (mon_inst_path[i], ptr_mipname) == 0)
	   ) {
	 io_printf ("%05d.%03d.%03d.%03d: INFO(%d): %s:%s\n",  ms,us,ns,ps, level, ptr_mipname, format(ptr_mipname));
       }
     }
   }
    return;
}
예제 #12
0
int fseq_checktf()
{
    int err = 0;
    if (tf_nump() != 1) {
        tf_error("$fibonacci requires exactly 1 argument.\n");
        err = 1;
    }
    if (tf_typep(1) == tf_nullparam) {
        tf_error("$fibonacci cannot have a NULL argument.\n");
        err = 1;
    }
    if (tf_sizep(1) > 8) {
        tf_error("$fibonacci input no larger than 8-bits.\n");
        err = 1;
    }
    if (err) {
        tf_message(ERR_ERROR, "", "", "");
    }
    return(0);
}
예제 #13
0
void warn_call(int data, int reason)
{
  char *ptr_mipname;
  int i;

  int ms, us, ns, ps;
  get_time (&ms, &us, &ns, &ps);

  ptr_mipname =  tf_mipname();

  /* Requires at least two arguments */
  if (tf_nump() < ARG2) {
      tf_error("$warn requires at least two arguments, warn-disable-tag, and format-string");
      tf_dofinish();
      return;
   }

   /*  First argument to $warn() must be a string */
   if (tf_typep(ARG1) != tf_string) {
      tf_error("First argument to $warn must be a value");
      tf_dofinish();
   }

   /*  Second argument to $warn() must be a string */
   if (tf_typep(ARG2) != tf_string) {
      tf_error("Second argument to $warn must be a formating string");
      tf_dofinish();
   }

   for (i = 0; i < diswarn_num; i++) {
     if (strcmp (tf_getcstringp(ARG1), diswarn_arr[i]) == 0) return;
   }
   io_printf ("%05d.%03d.%03d.%03d: WARN: %s:%s\n",  ms,us,ns,ps, ptr_mipname, format(ptr_mipname));

   return;
}
예제 #14
0
int util_get_plus_args_str() {

/* Example use:

invocation script (bosox is passed in as first argument)
-----------------
set basename = $1
verilog mymodule.v +tst_file_name${basename}.tst +log_file_name${basename}.log
  +err_file_name${basename}.err +result_file_name${basename}.result

mymodule.v
----------
reg   [32*8:1]  tst_file_name;		// plus argument string value 
reg   [32*8:1]  err_file_name;		// plus argument string value
reg   [32*8:1]  log_file_name;		// plus argument string value
reg   [32*8:1]  result_file_name;	// plus argument string value
integer         plus_arg_ok;            // 0 if ok, 1 if no plus argument value

initial
  begin
    // get strings from plus argument values
    plus_arg_ok = $util_get_plus_args_str("tst_file_name", tst_file_name);
    plus_arg_ok = $util_get_plus_args_str("err_file_name", err_file_name);
    plus_arg_ok = $util_get_plus_args_str("log_file_name", log_file_name);
    plus_arg_ok = $util_get_plus_args_str("result_file_name",result_file_name);

    $display("tst_file_name is %s", tst_file_name);
    $display("err_file_name is %s", err_file_name);
    $display("log_file_name is %s", log_file_name);
    $display("result_file_name is %s", result_file_name);
  end

*/


/* Input is string
	Returning value is string.
*/

    handle		wrk_out;
    char		*strArgIn;
    int			sizeOut,sizeS_in;
    int			numArgs;
    int			cnt,size;
    char		*buffer, *bufferout;
    s_setval_value	value_out;
    s_setval_delay	delay_out;

    delay_out.model = accNoDelay;
    delay_out.time.type = accRealTime;
    delay_out.time.real = 0.0;
    value_out.format = accHexStrVal;

    acc_initialize();

    numArgs = tf_nump();
    if(numArgs !=2) {
	tf_error("$get_plus_arg_string must have two arguments");
	tf_putp(0,VERILOG_ERROR);
	return(VERILOG_ERROR);
    }

/* Fetch the input register and size */

    wrk_out = acc_handle_tfarg(2);
    sizeOut = (acc_fetch_size(wrk_out)/8);

/* Get the string value */
    
    strArgIn = mc_scan_plusargs(tf_getcstringp(1));

    if (strArgIn == NULL) {
	if (DEBUG_PLUS_ARGS)
	    io_printf("get_plus_args_str():  Matching string is not found: %s.\n", tf_getcstringp(1));
	tf_putp(0,VERILOG_ERROR);
	return(VERILOG_ERROR);
    }

    if (strArgIn) {
        if (DEBUG_PLUS_ARGS)
	    io_printf("get_plus_args_str():  Got string value: %s\n",strArgIn);
    }
    else {
	io_printf("get_plus_args_str():  Bad input string value.\n");
	tf_putp(0,VERILOG_ERROR);
	return(VERILOG_ERROR);
    }


/* Build new string */

    sizeS_in = strlen(strArgIn);
    bufferout = (char *) malloc(sizeS_in + 1);
    sprintf(bufferout, "%s",strArgIn);

    if (sizeOut < sizeS_in) {
	tf_error("get_plus_args_str():  Register %s is not large enough.\n",
		 acc_fetch_fullname(wrk_out));
	tf_putp(0,VERILOG_ERROR);
	return(VERILOG_ERROR);
    }

    size = sizeS_in*2;
    buffer = (char *) malloc(size + 1);
    for (cnt =0; cnt < size; cnt +=2){
	if (cnt < size){
	    /* Convert string into HEX code */
	    sprintf(&buffer[cnt],"%x",bufferout[cnt/2]);
	}
    }

/*	 Null out the rest of the register 
	else {
	buffer[cnt] = '\0';
	buffer[cnt +1] = '\0';
}
*/

    /* assign buffer to the verilog register */
	
    value_out.value.str = buffer;
    acc_set_value(wrk_out, &value_out, &delay_out);  
    tf_putp(0,VERILOG_OK);
    acc_close();

    free(buffer);
    free(bufferout);
    return(VERILOG_OK);
}
예제 #15
0
/*************************************************
   lxt2_recordvars
   - add objects to be recorded
 ************************************************/
int lxt2_recordvars( int data, int reason )
{
	int update = 0;
	int objects = 0;
	int i;
	acc_initialize();

	switch( reason ) {
	case reason_calltf:
		break;
	case reason_checktf:
		goto DONE;	
	case reason_finish:
		if( lxt.inited ) {
		    lxt2_close();
		}
		goto DONE;	
	case reason_rosynch:
		update = (lxt.updateList != NULL);
		while( lxt.updateList ) {
			info_p info;
			info = lxt.updateList;
			lxt2_dump( info, 0 );
			lxt.updateList = info->updateNext;
			info->updateNext = 0;
		}
		if( update ) {
		    lxt2_timemarkerp1(); 
		}
		while( lxt.eventList ) {
			info_p info;
			info = lxt.eventList;
			lxt2_dump( info, 1 );
			lxt.eventList = info->updateNext;
			info->updateNext = 0;
		}
		lxt2_nexttimemarker(); 
		goto DONE;	
	default:
		goto DONE;	
	}

	ginstance = tf_getinstance();
	/*
	 * parse options first
	 */
	for( i = 1; i <= tf_nump(); ++i ) {
	    handle object;
	    if( tf_typep(i) == tf_nullparam ) {
		continue;
	    }
	    if( tf_typep(i) == tf_string ) {
		char* str = acc_fetch_tfarg_str(i);
		lxt2_option( str );
		continue;
	    } 
	}
	/*
	 * on first call, initialize structure
	 */
	if( !lxt.inited ) {
	    lxt2_init();
	}
	for( i = 1; i <= tf_nump(); ++i ) {
	    handle object;
	    if( tf_typep(i) == tf_nullparam ) {
		continue;
	    }
	    if( tf_typep(i) == tf_string ) {
		continue;
	    } 
	    object = acc_handle_tfarg(i);
	    if( !object ) {
		tf_error( "cannot find object" );
		tf_dofinish();
		goto DONE;
	    }
	    lxt2_add( object, lxt.depth );
	    objects++;
	}
	if( objects == 0 ) {
#if DEBUG
	    io_printf( "lxt2_recordvars: defaultpath=%s\n",
			 acc_fetch_fullname(acc_handle_parent(acc_handle_tfinst())), lxt.depth );
#endif
	    lxt2_add( acc_handle_parent(acc_handle_tfinst()), lxt.depth );
	}
	lxt2_dump( lxt.objectList, 1 );
DONE:
	acc_close();
	return 0;
}	
예제 #16
0
/*
 * format function
 */
char *format(char *mipname)
{
  int num_args, cur_arg, len, i, j;
  char *fmt_str, *ptr, c;

  num_args = tf_nump();
  cur_arg = 3;
  len = sprintf (format_buffer, " ");
  fmt_str = tf_getcstringp(ARG2);

  ptr = format_buffer + len;
  while (1) {
    c = *fmt_str++;
    if (c == 0)      break;
    if (c == '%') {
      c = *fmt_str++;
      switch (c) {
	case 'b':
	  len = sprintf (ptr, "%s", tf_strgetp(cur_arg, 'b'));
	  ptr = ptr + len;
	  cur_arg++;
	  break;

	case 'o':
	  len = sprintf (ptr, "%s", tf_strgetp(cur_arg, 'o'));
	  ptr = ptr + len;
	  cur_arg++;
	  break;

	case 'd':
	  len = sprintf (ptr, "%s", tf_strgetp(cur_arg, 'd'));
	  ptr = ptr + len;
	  cur_arg++;
	  break;

	case 'h':
	  len = sprintf (ptr, "%s", tf_strgetp(cur_arg, 'h'));
	  ptr = ptr + len;
	  cur_arg++;
	  break;

	case 'e':
	  len = sprintf (ptr, "%e", tf_getrealp(cur_arg));
	  ptr = ptr + len;
	  cur_arg++;
	  break;

	case 'f':
	  len = sprintf (ptr, "%e", tf_getrealp(cur_arg));
	  ptr = ptr + len;
	  cur_arg++;
	  break;

	case 't':
	  len = sprintf (ptr, "%d", tf_gettime());
	  ptr = ptr + len;
	  break;

	case 's':
	  len = sprintf (ptr, "%s", tf_strgetp(cur_arg, 'e'));
	  ptr = ptr + len;
	  cur_arg++;
	  break;

	case 'm':
	  len = sprintf (ptr, "%s", mipname);
	  ptr = ptr + len;
	  break;

	case '%':
	  *ptr++ = '%';
	  break;
      }
    }
    else {
      *ptr++ = c;
    }
  }
  *ptr++ = '\0';
  return format_buffer;
}