static int insert_var(RStr *output, FmtInfo *fi, int pn)
{
switch(fi->cvt_spec)
{
case 'm':
expanding_strcat(output,tf_mipname()); /* calling module */
break;
case 't':
expanding_strcat(output,tf_strgettime()); /* current simulator time */
break;
case '%':
expanding_strcat(output,"%"); /* percent sign */
break;
default:
/* don't need this check if checktf errors */
if(strchr(has_nfld,fi->cvt_spec))
{
char *text;
/* translate x's to h's for hex; NC segfaults if you don't */
if(fi->cvt_spec=='x')
fi->cvt_spec='h';
if(fi->cvt_spec=='X')
fi->cvt_spec='H';
text= format_val(fi,
fi->cvt_spec=='s' ? tf_getcstringp(pn) :
tf_strgetp(pn,fi->cvt_spec));
expanding_strcat(output,text);
free(text);
pn++;
}
}
return pn;
}
static int
mytest(int ud, int reason)
{
PLI_INT32 ht, lt;
PLI_BYTE8 *cp;
PLI_BYTE8 *inst = tf_getinstance();
PLI_BYTE8 *name = tf_spname();
(void)ud; /* Parameter is not used. */
(void)reason; /* Parameter is not used. */
io_printf("Module %s\n", name);
lt = tf_gettime();
io_printf("\ttf_gettime()\t\t\t-> %d\n", (int)lt);
cp = tf_strgettime();
io_printf("\ttf_strgettime()\t\t\t-> %s\n", cp);
lt = tf_getlongtime(&ht);
io_printf("\ttf_getlongtime()\t\t-> %d/%d\n", (int)ht, (int)lt);
lt = tf_igetlongtime(&ht, inst);
io_printf("\ttf_igetlongtime(inst)\t\t-> %d/%d\n", (int)ht, (int)lt);
lt = tf_getlongsimtime(&ht);
io_printf("\ttf_getlongsimtime()\t\t-> %d/%d\n", (int)ht, (int)lt);
lt = tf_gettimeprecision();
io_printf("\ttf_gettimeprecision()\t\t-> %d\n", (int)lt);
lt = tf_igettimeprecision(inst);
io_printf("\ttf_igettimeprecision(inst)\t-> %d\n", (int)lt);
lt = tf_gettimeunit();
io_printf("\ttf_gettimeunit()\t\t-> %d\n", (int)lt);
lt = tf_igettimeunit(inst);
io_printf("\ttf_gettimeunit(inst)\t\t-> %d\n", (int)lt);
lt = tf_igettimeunit(0);
io_printf("\ttf_gettimeunit(0)\t\t-> %d\n", (int)lt);
return 0;
}
/*----------------------------------------------------------------------------
* int
* errorCheck()
* checks to see if we've reached max_errors
*
* Return Value --
* 1 on error kill, 0 otherwise
*
* Design --
* inhibit printing warnings and errors if we've reached max_errors
* either by dying or turning them off
*
* Side effects --
* possible death, modifies finish_pending and finish_type
*----------------------------------------------------------------------------
*/
static int
errorCheck()
{
int l_r=0;
if (ms.global_errors >= ms.max_errors)
{
if(ms.external_finish!=0)
{
if (ms.finish_pending==0)
{
UnitInfo **l_ul=(UnitInfo **)ht_sorted_list(ms.unit_tbl, UnitInfo_cmp);
UnitInfo **l_uit=0;
//printf("Setting finish pending for verilog, and warn_stop as type.\n");
ms.finish_pending = 1;
ms.finish_type = 1;
/* termination pending due to max error */
/* disable further warn/errors till external */
/* verilog shuts down simulator. */
for(l_uit=l_ul; *l_uit; l_uit++)
{
(*l_uit)->enable[MON_WARN]=0;
(*l_uit)->enable[MON_ERR]=0;
}
l_r=1;
free(l_ul);
}
} else
{
printf("\nINFO(%s): MAX ERRORS REACHED - SIMULATION TERMINATED\n",
modulename);
printf("INFO(%s): TIME %s, ABNORMAL END--"
"MONITOR CAUSED END OF SIMULATION\n", modulename, tf_strgettime());
printf("Ending simulation \nSIM_ERR_STATUS:1 \n");
tf_dofinish();
}
}
return l_r;
}
/*----------------------------------------------------------------------------
* int
* warningCheck()
* checks to see if we've reached max_warnings
*
* Return Value --
* 1 on warning kill, 0 otherwise
*
* Design --
* inhibit printing warnings and errors if we've reached max_warnings
* either by dying or turning them off
*
* Side effects --
* possible death, modifies finish_pending and finish_type
*----------------------------------------------------------------------------
*/
static int
warningCheck()
{
int l_r=0;
if (ms.global_warnings >= ms.max_warnings)
{
if(ms.external_finish!=0)
{
if(ms.finish_pending==0)
{
UnitInfo **l_ul=(UnitInfo **)ht_sorted_list(ms.unit_tbl, UnitInfo_cmp);
UnitInfo **l_uit=0;
//printf("Setting finish pending for verilog, and warn_stop as type.\n");
ms.finish_pending = 1;
ms.finish_type = 2;
for(l_uit=l_ul; *l_uit; l_uit++)
{
(*l_uit)->enable[MON_WARN]=0;
(*l_uit)->enable[MON_ERR]=0;
}
l_r=1;
free(l_ul);
}
} else
{
printf("\nINFO(%s): MAX WARNINGS REACHED - SIMULATION TERMINATED\n",
modulename);
printf("INFO(%s): TIME %s, ABNORMAL END--"
"MONITOR CAUSED END OF SIMULATION\n", modulename, tf_strgettime());
printf("Ending simulation \nSIM_ERR_STATUS:2 \n");
tf_dofinish();
}
}
return l_r;
}
/*----------------------------------------------------------------------------
* static void
* print_tagged_line(char *p_prefix, char *p_unit, char *p_output,
* int p_mon_type, int p_add_newline)
* print out the line with timestamp and unit responsible
*
* Return Value --
* none
*
* Design --
* Get timestamp. Go through way too much effort to come up with a module name
* put it together to get a tag, call smart_write_tagged_output
* Side effects --
* possible death since it calls warningCheck() and errorCheck()
* may modify global_errors or global_warnings
*----------------------------------------------------------------------------
*/
static void
print_tagged_line(const char *p_prefix, const char *p_unit, char *p_output,
int p_mon_type, int p_add_newline)
{
char *l_instance=tf_mipname();
char *l_pt1=0;
char *l_modname=0;
char *l_tag_gen[]={"%s%s%s%s", "%s: WARNING: %s[%s%s]: ",
"%s: ERROR: %s[%s%s]: ", "%s: %s[%s%s]: ",
"%s: INFO: %s[%s%s]: ", "%s: DBG: %s[%s%s]: "};
/* If l_instance == NULL, then we may be in a callback */
if (l_instance == NULL)
{
l_instance = "pli callback";
}
/* get the module instance name. */
/* Generally, ch_sys.cheetah_mod.cpu..... */
/* Display as: (<mod>...<end_path_name>) */
if (0==(l_pt1 = strchr(l_instance, '.')))
{
/* No module */
l_modname=strdup(l_instance);
}
else
{
/* we just want the full instance name from the mod level down. */
/* that's what we print out, always! If that's too long and your */
/* printouts end up hard to read, tough! Post process. */
l_modname=strdup(l_pt1+1);
}
if(0!=l_modname)
{
char *l_tagbuffer=0;
/* lacking a predictable snprintf or asprintf, we guess at how large
tagbuffer needs to be */
if(0==(l_tagbuffer=(char*)malloc(strlen(l_tag_gen[p_mon_type])+strlen(p_unit)+
strlen(p_prefix)+strlen(l_modname)+20)))
{
printf("ERROR(%s): Can not generate tag for output\n",modulename);
tf_dofinish();
}
sprintf(l_tagbuffer, l_tag_gen[p_mon_type], tf_strgettime(), p_unit,
p_prefix, l_modname);
if(WARNING_MON_TYPE==p_mon_type)
ms.global_warnings++;
if(ERROR_MON_TYPE==p_mon_type)
{
ms.global_errors++;
/* if we do a dispmon (not writemon!) with an error monitor type.
Force the start of a new line. */
if(p_add_newline && 0==ms.newLine)
{
puts("");
ms.newLine=1;
}
}
smart_write_tagged_output(l_tagbuffer, p_output, p_add_newline);
free(l_modname);
free(l_tagbuffer);
warningCheck();
errorCheck();
}
}
