281 lines
9.1 KiB
C
281 lines
9.1 KiB
C
/*
|
|
* Copyright (C) 2008 Cary R. (cygcary@yahoo.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#ifdef HAVE_MALLOC_H
|
|
# include <malloc.h>
|
|
#endif
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <vpi_user.h>
|
|
#include "sys_priv.h"
|
|
|
|
/* Once we have real string objects replace this with a dynamic string. */
|
|
#define MAX_STRING_RESULT 1024
|
|
|
|
|
|
/*
|
|
* Check that the routines are called with the correct arguments.
|
|
*/
|
|
static PLI_INT32 simparam_compiletf(PLI_BYTE8* name_ext)
|
|
{
|
|
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
|
|
assert(callh != 0);
|
|
vpiHandle argv = vpi_iterate(vpiArgument, callh);
|
|
vpiHandle arg;
|
|
|
|
/* We must have at least one argument. */
|
|
if (argv == 0) {
|
|
vpi_printf("ERROR: %s line %d: ", vpi_get_str(vpiFile, callh),
|
|
(int)vpi_get(vpiLineNo, callh));
|
|
vpi_printf("$simparam%s requires a string argument.\n", name_ext);
|
|
vpi_control(vpiFinish, 1);
|
|
return 0;
|
|
}
|
|
|
|
/* The first argument must be a string. */
|
|
arg = vpi_scan(argv);
|
|
if (! is_string_obj(arg)) {
|
|
vpi_printf("ERROR: %s line %d: ", vpi_get_str(vpiFile, callh),
|
|
(int)vpi_get(vpiLineNo, callh));
|
|
vpi_printf("The first argument to $simparam%s must be a string.\n",
|
|
name_ext);
|
|
vpi_control(vpiFinish, 1);
|
|
}
|
|
|
|
/* The second argument (default value) is optional. */
|
|
arg = vpi_scan(argv);
|
|
if (arg == 0) return 0;
|
|
|
|
/* For the string version the default must also be a string. */
|
|
if (strcmp(name_ext, "$str") == 0) {
|
|
if (! is_string_obj(arg)) {
|
|
vpi_printf("ERROR: %s line %d: ", vpi_get_str(vpiFile, callh),
|
|
(int)vpi_get(vpiLineNo, callh));
|
|
vpi_printf("When provided, the second argument to $simparam%s"
|
|
"must be a string.\n", name_ext);
|
|
vpi_control(vpiFinish, 1);
|
|
}
|
|
/* For the rest the default must be numeric. */
|
|
} else {
|
|
if (! is_numeric_obj(arg)) {
|
|
vpi_printf("ERROR: %s line %d: ", vpi_get_str(vpiFile, callh),
|
|
(int)vpi_get(vpiLineNo, callh));
|
|
vpi_printf("When provided, the second argument to $simparam%s"
|
|
"must be numeric.\n", name_ext);
|
|
vpi_control(vpiFinish, 1);
|
|
}
|
|
}
|
|
|
|
/* We can only have two argument. */
|
|
if (vpi_scan(argv) != 0) {
|
|
char msg [64];
|
|
snprintf(msg, 64, "ERROR: %s line %d:",
|
|
vpi_get_str(vpiFile, callh),
|
|
(int)vpi_get(vpiLineNo, callh));
|
|
|
|
unsigned argc = 1;
|
|
while (vpi_scan(argv)) argc += 1;
|
|
|
|
vpi_printf("%s $simparam%s takes at most two arguments.\n",
|
|
msg, name_ext);
|
|
vpi_printf("%*s Found %u extra argument%s.\n",
|
|
strlen(msg), " ", argc, argc == 1 ? "" : "s");
|
|
vpi_control(vpiFinish, 1);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static PLI_INT32 simparam_calltf(PLI_BYTE8* name_ext)
|
|
{
|
|
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
|
|
vpiHandle argv = vpi_iterate(vpiArgument, callh);
|
|
vpiHandle arg;
|
|
s_vpi_value val;
|
|
char *param;
|
|
unsigned have_def_val = 0;
|
|
double retval, defval = 0.0;
|
|
|
|
/* Get the parameter we are looking for. */
|
|
arg = vpi_scan(argv);
|
|
val.format = vpiStringVal;
|
|
vpi_get_value(arg, &val);
|
|
param = strdup(val.value.str);
|
|
|
|
/* See if there is a default value. */
|
|
arg = vpi_scan(argv);
|
|
if (arg != 0) {
|
|
vpi_free_object(argv);
|
|
have_def_val = 1;
|
|
val.format = vpiRealVal;
|
|
vpi_get_value(arg, &val);
|
|
defval = val.value.real;
|
|
}
|
|
|
|
/* Now check the various things we can return. */
|
|
if (strcmp(param, "gdev") == 0) {
|
|
retval = 0.0; /* Nothing for now. */
|
|
} else if (strcmp(param, "gmin") == 0) {
|
|
retval = 0.0; /* Nothing for now. */
|
|
} else if (strcmp(param, "imax") == 0) {
|
|
retval = 0.0; /* Nothing for now. */
|
|
} else if (strcmp(param, "imelt") == 0) {
|
|
retval = 0.0; /* Nothing for now. */
|
|
} else if (strcmp(param, "iteration") == 0) {
|
|
retval = 0.0; /* Nothing for now. */
|
|
} else if (strcmp(param, "scale") == 0) {
|
|
retval = 0.0; /* Nothing for now. */
|
|
} else if (strcmp(param, "shrink") == 0) {
|
|
retval = 0.0; /* Nothing for now. */
|
|
} else if (strcmp(param, "simulatorSubversion") == 0) {
|
|
retval = 0.0;
|
|
} else if (strcmp(param, "simulatorVersion") == 0) {
|
|
retval = 0.9;
|
|
} else if (strcmp(param, "sourceScaleFactor") == 0) {
|
|
retval = 0.0; /* Nothing for now. */
|
|
} else if (strcmp(param, "tnom") == 0) {
|
|
retval = 0.0; /* Nothing for now. */
|
|
} else if (strcmp(param, "timeUnit") == 0) {
|
|
retval = pow(10, vpi_get(vpiTimeUnit, sys_func_module(callh)));
|
|
} else if (strcmp(param, "timePrecision") == 0) {
|
|
retval = pow(10, vpi_get(vpiTimePrecision, sys_func_module(callh)));
|
|
} else if (strcmp(param, "CPUWordSize") == 0) {
|
|
retval = 8.0*sizeof(long);
|
|
} else {
|
|
if (! have_def_val) {
|
|
vpi_printf("ERROR: %s line %d: ", vpi_get_str(vpiFile, callh),
|
|
(int)vpi_get(vpiLineNo, callh));
|
|
vpi_printf("$simparam%s unknown parameter name \"%s\".\n",
|
|
name_ext, param);
|
|
}
|
|
retval = defval;
|
|
}
|
|
|
|
free(param);
|
|
|
|
/* Return the value to the system. */
|
|
val.format = vpiRealVal;
|
|
val.value.real = retval;
|
|
vpi_put_value(callh, &val, 0, vpiNoDelay);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static PLI_INT32 simparam_str_calltf(PLI_BYTE8* name_ext)
|
|
{
|
|
vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
|
|
vpiHandle argv = vpi_iterate(vpiArgument, callh);
|
|
vpiHandle arg;
|
|
s_vpi_value val;
|
|
char *param;
|
|
char *retval, *defval = NULL;
|
|
|
|
/* Get the parameter we are looking for. */
|
|
arg = vpi_scan(argv);
|
|
val.format = vpiStringVal;
|
|
vpi_get_value(arg, &val);
|
|
param = strdup(val.value.str);
|
|
|
|
/* See if there is a default value. */
|
|
arg = vpi_scan(argv);
|
|
if (arg != 0) {
|
|
vpi_free_object(argv);
|
|
val.format = vpiStringVal;
|
|
vpi_get_value(arg, &val);
|
|
defval = strdup(val.value.str);
|
|
}
|
|
|
|
/* Now check the various things we can return. */
|
|
/* For now we limit the result to 1024 characters. */
|
|
if (strcmp(param, "analysis_name") == 0) {
|
|
retval = strdup("N/A"); /* Nothing for now. */
|
|
} else if (strcmp(param, "analysis_type") == 0) {
|
|
retval = strdup("N/A"); /* Nothing for now. */
|
|
} else if (strcmp(param, "cwd") == 0) {
|
|
char path [MAX_STRING_RESULT];
|
|
char *ptr = getcwd(path, MAX_STRING_RESULT);
|
|
if (ptr == NULL) {
|
|
ptr = strcpy(path, "<error getting the cwd, "
|
|
"is it too long?>");
|
|
}
|
|
retval = strdup(path);
|
|
} else if (strcmp(param, "module") == 0) {
|
|
retval = strdup(vpi_get_str(vpiDefName, sys_func_module(callh)));
|
|
} else if (strcmp(param, "instance") == 0) {
|
|
retval = strdup(vpi_get_str(vpiFullName, sys_func_module(callh)));
|
|
} else if (strcmp(param, "path") == 0) {
|
|
retval = strdup(vpi_get_str(vpiFullName,
|
|
vpi_handle(vpiScope,callh)));
|
|
} else {
|
|
if (defval == 0) {
|
|
vpi_printf("ERROR: %s line %d: ", vpi_get_str(vpiFile, callh),
|
|
(int)vpi_get(vpiLineNo, callh));
|
|
vpi_printf("$simparam%s unknown parameter name \"%s\".\n",
|
|
name_ext, param);
|
|
defval = strdup("<error>");
|
|
}
|
|
retval = defval;
|
|
}
|
|
|
|
free(param);
|
|
|
|
/* Return the value to the system. */
|
|
val.format = vpiStringVal;
|
|
val.value.str = retval;
|
|
vpi_put_value(callh, &val, 0, vpiNoDelay);
|
|
free(retval);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static PLI_INT32 simparam_str_sizetf(PLI_BYTE8* name_ext)
|
|
{
|
|
(void) name_ext; //* Not used! */
|
|
|
|
return MAX_STRING_RESULT; // 128 characters max!
|
|
}
|
|
|
|
/*
|
|
* Register the function with Verilog.
|
|
*/
|
|
void vams_simparam_register(void)
|
|
{
|
|
s_vpi_systf_data tf_data;
|
|
|
|
tf_data.type = vpiSysFunc;
|
|
tf_data.sysfunctype = vpiRealFunc;
|
|
tf_data.calltf = simparam_calltf;
|
|
tf_data.compiletf = simparam_compiletf;
|
|
tf_data.sizetf = 0;
|
|
tf_data.tfname = "$simparam";
|
|
tf_data.user_data = "";
|
|
vpi_register_systf(&tf_data);
|
|
|
|
tf_data.type = vpiSysFunc;
|
|
tf_data.sysfunctype = vpiSizedFunc; /* What should this be? */
|
|
tf_data.calltf = simparam_str_calltf;
|
|
tf_data.compiletf = simparam_compiletf;
|
|
tf_data.sizetf = simparam_str_sizetf; /* Only 128 characters! */
|
|
tf_data.tfname = "$simparam$str";
|
|
tf_data.user_data = "$str";
|
|
vpi_register_systf(&tf_data);
|
|
}
|