static void
log_init(void)
{
out_init(LOG_PREFIX, LOG_LEVEL_VAR, LOG_FILE_VAR);
LOG(3, NULL);
util_init();
}
int
main(int argc, char *argv[])
{
START(argc, argv, "util_poolset_parse");
out_init(LOG_PREFIX, LOG_LEVEL_VAR, LOG_FILE_VAR,
MAJOR_VERSION, MINOR_VERSION);
if (argc < 2)
FATAL("usage: %s set-file-name ...", argv[0]);
struct pool_set *set;
int fd;
for (int i = 1; i < argc; i++) {
const char *path = argv[i];
fd = OPEN(path, O_RDWR);
int ret = util_poolset_parse(path, fd, &set);
if (ret == 0)
util_poolset_free(set);
CLOSE(fd);
}
out_fini();
DONE(NULL);
}
/*
* vmem_init -- initialization for vmem
*
* Called automatically by the run-time loader or on the first use of vmem.
*/
void
vmem_init(void)
{
static bool initialized = false;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int oerrno;
if (initialized)
return;
if ((errno = pthread_mutex_lock(&lock)))
FATAL("!pthread_mutex_lock");
if (!initialized) {
out_init(VMEM_LOG_PREFIX, VMEM_LOG_LEVEL_VAR,
VMEM_LOG_FILE_VAR, VMEM_MAJOR_VERSION,
VMEM_MINOR_VERSION);
out_set_vsnprintf_func(je_vmem_navsnprintf);
LOG(3, NULL);
util_init();
Header_size = roundup(sizeof (VMEM), Pagesize);
/* Set up jemalloc messages to a custom print function */
je_vmem_malloc_message = print_jemalloc_messages;
initialized = true;
}
oerrno = errno;
if ((errno = pthread_mutex_unlock(&lock)))
ERR("!pthread_mutex_unlock");
errno = oerrno;
}
static void
libpmem_init(void)
{
out_init(PMEM_LOG_PREFIX, PMEM_LOG_LEVEL_VAR, PMEM_LOG_FILE_VAR,
PMEM_MAJOR_VERSION, PMEM_MINOR_VERSION);
LOG(3, NULL);
util_init();
}
/*
* librpmem_init -- load-time initialization for librpmem
*
* Called automatically by the run-time loader.
*/
ATTR_CONSTRUCTOR
void
librpmem_init(void)
{
util_init();
out_init(RPMEM_LOG_PREFIX, RPMEM_LOG_LEVEL_VAR, RPMEM_LOG_FILE_VAR,
RPMEM_MAJOR_VERSION, RPMEM_MINOR_VERSION);
LOG(3, NULL);
}
/*
* libpmemobj_init -- load-time initialization for obj
*
* Called automatically by the run-time loader.
*/
ATTR_CONSTRUCTOR
void
libpmemobj_init(void)
{
out_init(PMEMOBJ_LOG_PREFIX, PMEMOBJ_LOG_LEVEL_VAR,
PMEMOBJ_LOG_FILE_VAR, PMEMOBJ_MAJOR_VERSION,
PMEMOBJ_MINOR_VERSION);
LOG(3, NULL);
util_init();
obj_init();
}
static void
vmem_init(void)
{
out_init(LOG_PREFIX, LOG_LEVEL_VAR, LOG_FILE_VAR);
LOG(3, NULL);
util_init();
Header_size = roundup(sizeof (VMEM), Pagesize);
/* Set up jemalloc to forward messages to a custom print function */
je_vmem_malloc_message = print_jemalloc_messages;
}
void
fileinit(Void)
{
register char *s;
register int i, j;
lastiolabno = 100000;
lastlabno = 0;
lastvarno = 0;
nliterals = 0;
nerr = 0;
infile = stdin;
maxtoklen = 502;
token = (char *)ckalloc(maxtoklen+2);
memset(dflttype, tyreal, 26);
memset(dflttype + 'i' - 'a', tyint, 6);
memset(hextoi_tab, 16, sizeof(hextoi_tab));
for(i = 0, s = "0123456789abcdef"; *s; i++, s++)
hextoi(*s) = i;
for(i = 10, s = "ABCDEF"; *s; i++, s++)
hextoi(*s) = i;
for(j = 0, s = "abcdefghijklmnopqrstuvwxyz"; i = *s++; j++)
Letters[i] = Letters[i+'A'-'a'] = j;
ctls = ALLOCN(maxctl+1, Ctlframe);
extsymtab = ALLOCN(maxext, Extsym);
eqvclass = ALLOCN(maxequiv, Equivblock);
hashtab = ALLOCN(maxhash, Hashentry);
labeltab = ALLOCN(maxstno, Labelblock);
litpool = ALLOCN(maxliterals, Literal);
labarray = (struct Labelblock **)ckalloc(maxlablist*
sizeof(struct Labelblock *));
fmt_init();
mem_init();
np_init();
ctlstack = ctls++;
lastctl = ctls + maxctl;
nextext = extsymtab;
lastext = extsymtab + maxext;
lasthash = hashtab + maxhash;
labtabend = labeltab + maxstno;
highlabtab = labeltab;
main_alias[0] = '\0';
if (forcedouble)
dfltproc[TYREAL] = dfltproc[TYDREAL];
/* Initialize the routines for providing C output */
out_init ();
}
int
main(int argc, char *argv[])
{
START(argc, argv, "util_poolset");
out_init(LOG_PREFIX, LOG_LEVEL_VAR, LOG_FILE_VAR,
MAJOR_VERSION, MINOR_VERSION);
util_init();
if (argc < 5)
UT_FATAL("usage: %s cmd minlen hdrsize [mockopts] setfile ...",
argv[0]);
char *fname;
struct pool_set *set;
int ret;
size_t minsize = strtoul(argv[2], &fname, 0);
for (int arg = 3; arg < argc; arg++) {
arg += mock_options(argv[arg]);
fname = argv[arg];
switch (argv[1][0]) {
case 'c':
ret = util_pool_create(&set, fname, 0, minsize,
SIG, 1, 0, 0, 0);
if (ret == -1)
UT_OUT("!%s: util_pool_create", fname);
else {
util_poolset_chmod(set, S_IWUSR | S_IRUSR);
poolset_info(fname, set, 0);
util_poolset_close(set, 0); /* do not delete */
}
break;
case 'o':
ret = util_pool_open(&set, fname, 0 /* rdonly */,
minsize, SIG, 1, 0, 0, 0);
if (ret == -1)
UT_OUT("!%s: util_pool_open", fname);
else {
poolset_info(fname, set, 1);
util_poolset_close(set, 0); /* do not delete */
}
break;
}
}
out_fini();
DONE(NULL);
}
/* print all event node names */
void
EVTdisplay(wordlist *wl)
{
Evt_Node_Info_t *node;
CKTcircuit *ckt;
int node_index, udn_index;
Evt_Node_Info_t **node_table;
NG_IGNORE(wl);
ckt = g_mif_info.ckt;
if (!ckt) {
fprintf(cp_err, "Error: no circuit loaded.\n");
return;
}
node = ckt->evt->info.node_list;
node_table = ckt->evt->info.node_table;
out_init();
if (!node) {
out_printf("No event node available!\n");
return;
}
out_printf("\nList of event nodes\n");
out_printf(" %-20s: %-5s, %s\n\n", "node name", "type", "number of events");
node_index = 0;
while (node) {
Evt_Node_t *node_data = NULL;
int count = 0;
char *type;
udn_index = node_table[node_index]->udn_index;
if (ckt->evt->data.node)
node_data = ckt->evt->data.node->head[node_index];
while (node_data) {
count++;
node_data = node_data->next;
}
type = g_evt_udn_info[udn_index]->name;
out_printf(" %-20s: %-5s, %5d\n", node->name, type, count);
node = node->next;
node_index++;
}
}
int
main(int argc, char *argv[])
{
START(argc, argv, "traces_custom_function");
if (argc != 2)
FATAL("usage: %s [v|p]", argv[0]);
out_set_print_func(print_custom_function);
out_init(LOG_PREFIX, LOG_LEVEL_VAR, LOG_FILE_VAR,
MAJOR_VERSION, MINOR_VERSION);
switch (argv[1][0]) {
case 'p': {
LOG(0, "Log level NONE");
LOG(1, "Log level ERROR");
LOG(2, "Log level WARNING");
LOG(3, "Log level INFO");
LOG(4, "Log level DEBUG");
}
break;
case 'v':
out_set_vsnprintf_func(vsnprintf_custom_function);
LOG(0, "no format");
LOG(0, "pointer: %p", (void *)0x12345678);
LOG(0, "string: %s", "Hello world!");
LOG(0, "number: %u", 12345678);
errno = EINVAL;
LOG(0, "!error");
break;
default:
FATAL("usage: %s [v|p]", argv[0]);
}
/* Cleanup */
out_fini();
DONE(NULL);
}
int
main(int argc, char *argv[])
{
base64_init();
START(argc, argv, "rpmemd_obc");
out_init("rpmemd_obc",
"RPMEM_LOG_LEVEL",
"RPMEM_LOG_FILE", 0, 0);
rpmemd_log_init("rpmemd", getenv("RPMEMD_LOG_FILE"), 0);
rpmemd_log_level = rpmemd_log_level_from_str(
getenv("RPMEMD_LOG_LEVEL"));
TEST_CASE_PROCESS(argc, argv, test_cases, NTESTS);
rpmemd_log_close();
out_fini();
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "util_is_poolset");
out_init(LOG_PREFIX, LOG_LEVEL_VAR, LOG_FILE_VAR,
MAJOR_VERSION, MINOR_VERSION);
util_init();
if (argc < 2)
UT_FATAL("usage: %s file...",
argv[0]);
for (int i = 1; i < argc; i++) {
char *fname = argv[i];
int is_poolset = util_is_poolset(fname);
UT_OUT("util_is_poolset(%s): %d", fname, is_poolset);
}
out_fini();
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "out_err");
/* Execute test */
out_init(LOG_PREFIX, LOG_LEVEL_VAR, LOG_FILE_VAR,
MAJOR_VERSION, MINOR_VERSION);
errno = 0;
ERR("ERR #%d", 1);
UT_OUT("%s", out_get_errormsg());
errno = 0;
ERR("!ERR #%d", 2);
UT_OUT("%s", out_get_errormsg());
errno = EINVAL;
ERR("!ERR #%d", 3);
UT_OUT("%s", out_get_errormsg());
errno = EBADF;
out_err(__FILE__, 100, __func__,
"ERR1: %s:%d", strerror(errno), 1234);
UT_OUT("%s", out_get_errormsg());
errno = EBADF;
out_err(NULL, 0, NULL,
"ERR2: %s:%d", strerror(errno), 1234);
UT_OUT("%s", out_get_errormsg());
/* Cleanup */
out_fini();
DONE(NULL);
}
void
com_print(wordlist *wl)
{
struct dvec *v, *lv = NULL, *bv, *nv, *vecs = NULL;
int i, j, ll, width = DEF_WIDTH, height = DEF_HEIGHT, npoints, lineno;
struct pnode *pn, *names;
struct plot *p;
bool col = TRUE, nobreak = FALSE, noprintscale, plotnames = FALSE;
bool optgiven = FALSE;
char *s, *buf, *buf2; /*, buf[BSIZE_SP], buf2[BSIZE_SP];*/
char numbuf[BSIZE_SP], numbuf2[BSIZE_SP]; /* Printnum buffers */
int ngood;
if (wl == NULL)
return;
buf = TMALLOC(char, BSIZE_SP);
buf2 = TMALLOC(char, BSIZE_SP);
if (eq(wl->wl_word, "col")) {
col = TRUE;
optgiven = TRUE;
wl = wl->wl_next;
} else if (eq(wl->wl_word, "line")) {
col = FALSE;
optgiven = TRUE;
wl = wl->wl_next;
}
ngood = 0;
names = ft_getpnames(wl, TRUE);
for (pn = names; pn; pn = pn->pn_next) {
if ((v = ft_evaluate(pn)) == NULL)
continue;
if (!vecs)
vecs = lv = v;
else
lv->v_link2 = v;
for (lv = v; lv->v_link2; lv = lv->v_link2)
;
ngood += 1;
}
if (!ngood)
goto done;
/* See whether we really have to print plot names. */
for (v = vecs; v; v = v->v_link2)
if (vecs->v_plot != v->v_plot) {
plotnames = TRUE;
break;
}
if (!optgiven) {
/* Figure out whether col or line should be used... */
col = FALSE;
for (v = vecs; v; v = v->v_link2)
if (v->v_length > 1) {
col = TRUE;
/* Improvement made to print cases @[sin] = (0 12 13 100K) */
if ((v->v_plot->pl_scale && v->v_length != v->v_plot->pl_scale->v_length) && (*(v->v_name) == '@'))
{
col = FALSE;
}
break;
}
/* With this I have found that the vector has less elements than the SCALE vector
* in the linked PLOT. But now I must make sure in case of a print @vin[sin] or
* @vin[pulse]
* for it appear that the v->v_name begins with '@'
* And then be in this case.
*/
}
out_init();
if (!col) {
if (cp_getvar("width", CP_NUM, &i))
width = i;
if (width < 60)
width = 60;
if (width > BSIZE_SP - 2)
buf = TREALLOC(char, buf, width + 1);
for (v = vecs; v; v = v->v_link2) {
char *basename = vec_basename(v);
if (plotnames)
(void) sprintf(buf, "%s.%s", v->v_plot->pl_typename, basename);
else
(void) strcpy(buf, basename);
tfree(basename);
for (s = buf; *s; s++)
;
s--;
while (isspace(*s)) {
*s = '\0';
s--;
}
ll = 10;
/* v->v_rlength = 1 when it comes to make a print @ M1 and does not want to come out on screen
* Multiplier factor [m]=1
* @M1 = 0,00e+00
* In any other case rlength not used for anything and only applies in the copy of the vectors.
*/
if (v->v_rlength == 0) {
if (v->v_length == 1) {
if (isreal(v)) {
printnum(numbuf, *v->v_realdata);
out_printf("%s = %s\n", buf, numbuf);
} else {
printnum(numbuf, realpart(v->v_compdata[0]));
printnum(numbuf2, imagpart(v->v_compdata[0]));
out_printf("%s = %s,%s\n", buf, numbuf, numbuf2);
}
} else {
out_printf("%s = ( ", buf);
for (i = 0; i < v->v_length; i++)
if (isreal(v)) {
printnum(numbuf, v->v_realdata[i]);
(void) strcpy(buf, numbuf);
out_send(buf);
ll += (int) strlen(buf);
ll = (ll + 7) / 8;
ll = ll * 8 + 1;
if (ll > width) {
out_send("\n\t");
ll = 9;
} else {
out_send("\t");
}
} else {
/*DG*/
printnum(numbuf, realpart(v->v_compdata[i]));
printnum(numbuf2, imagpart(v->v_compdata[i]));
(void) sprintf(buf, "%s,%s", numbuf, numbuf2);
out_send(buf);
ll += (int) strlen(buf);
ll = (ll + 7) / 8;
ll = ll * 8 + 1;
if (ll > width) {
out_send("\n\t");
ll = 9;
} else {
out_send("\t");
}
}
out_send(")\n");
} //end if (v->v_length == 1)
} //end if (v->v_rlength == 1)
} // end for loop
} else { /* Print in columns. */
if (cp_getvar("width", CP_NUM, &i))
void EVTprint(
wordlist *wl) /* The command line entered by user */
{
int i;
int nargs;
int num_ports;
wordlist *w;
char *node_name[EPRINT_MAXARGS];
int node_index[EPRINT_MAXARGS];
int udn_index[EPRINT_MAXARGS];
Evt_Node_t *node_data[EPRINT_MAXARGS];
char *node_value[EPRINT_MAXARGS];
CKTcircuit *ckt;
Evt_Node_Info_t **node_table;
Evt_Port_Info_t **port_table;
Mif_Boolean_t more;
Mif_Boolean_t dcop;
double step = 0.0;
double next_step;
double this_step;
char *value;
Evt_Msg_t *msg_data;
Evt_Statistic_t *statistics;
/* Count the number of arguments to the command */
nargs = 0;
w = wl;
while(w) {
nargs++;
w = w->wl_next;
}
if(nargs < 1) {
printf("Usage: eprint <node1> <node2> ...\n");
return;
}
if(nargs > EPRINT_MAXARGS) {
printf("ERROR - eprint currently limited to 32 arguments\n");
return;
}
/* Get needed pointers */
ckt = g_mif_info.ckt;
if (!ckt) {
fprintf(cp_err, "Error: no circuit loaded.\n");
return;
}
node_table = ckt->evt->info.node_table;
/* Get data for each argument */
w = wl;
for(i = 0; i < nargs; i++) {
node_name[i] = w->wl_word;
node_index[i] = get_index(node_name[i]);
if(node_index[i] < 0) {
printf("ERROR - Node %s is not an event node.\n", node_name[i]);
return;
}
udn_index[i] = node_table[node_index[i]]->udn_index;
if (ckt->evt->data.node)
node_data[i] = ckt->evt->data.node->head[node_index[i]];
else {
printf("ERROR - No node data: simulation not yet run?\n");
return;
}
node_value[i] = "";
w = w->wl_next;
}
out_init();
/* Print results data */
out_printf("\n**** Results Data ****\n\n");
/* Print the column identifiers */
out_printf("Time or Step\n");
for(i = 0; i < nargs; i++)
out_printf("%s\n",node_name[i]);
out_printf("\n\n");
/* Scan the node data and determine if the first vector */
/* is for a DCOP analysis or the first step in a swept DC */
/* or transient analysis. Also, determine if there is */
/* more data following it and if so, what the next step */
/* is. */
more = MIF_FALSE;
dcop = MIF_FALSE;
next_step = 1e30;
for(i = 0; i < nargs; i++) {
if(node_data[i]->op)
dcop = MIF_TRUE;
else
step = node_data[i]->step;
(*(g_evt_udn_info[udn_index[i]]->print_val))
(node_data[i]->node_value, "all", &value);
node_value[i] = value;
node_data[i] = node_data[i]->next;
if(node_data[i]) {
more = MIF_TRUE;
if(node_data[i]->step < next_step)
next_step = node_data[i]->step;
}
}
/* Print the data */
print_data(dcop, step, node_value, nargs);
/* While there is more data, get the next values and print */
while(more) {
more = MIF_FALSE;
this_step = next_step;
next_step = 1e30;
for(i = 0; i < nargs; i++) {
if(node_data[i]) {
if(node_data[i]->step == this_step) {
(*(g_evt_udn_info[udn_index[i]]->print_val))
(node_data[i]->node_value, "all", &value);
node_value[i] = value;
node_data[i] = node_data[i]->next;
}
if(node_data[i]) {
more = MIF_TRUE;
if(node_data[i]->step < next_step)
next_step = node_data[i]->step;
}
} /* end if node_data not NULL */
} /* end for number of args */
print_data(MIF_FALSE, this_step, node_value, nargs);
} /* end while there is more data */
out_printf("\n\n");
/* Print messages for all ports */
out_printf("\n**** Messages ****\n\n");
num_ports = ckt->evt->counts.num_ports;
port_table = ckt->evt->info.port_table;
for(i = 0; i < num_ports; i++) {
/* Get pointer to messages for this port */
msg_data = ckt->evt->data.msg->head[i];
/* If no messages on this port, skip */
if(! msg_data)
continue;
/* Print the port description */
out_printf("Node: %s Inst: %s Conn: %s Port: %d\n\n",
port_table[i]->node_name,
port_table[i]->inst_name,
port_table[i]->conn_name,
port_table[i]->port_num);
/* Print the messages on this port */
while(msg_data) {
if(msg_data->op)
printf("DCOP ");
else
printf("%-16.9e", msg_data->step);
printf("%s\n", msg_data->text);
msg_data = msg_data->next;
}
out_printf("\n\n");
} /* end for number of ports */
/* Print statistics */
out_printf("\n**** Statistics ****\n\n");
statistics = ckt->evt->data.statistics;
out_printf("Operating point analog/event alternations: %d\n",
statistics->op_alternations);
out_printf("Operating point load calls: %d\n",
statistics->op_load_calls);
out_printf("Operating point event passes: %d\n",
statistics->op_event_passes);
out_printf("Transient analysis load calls: %d\n",
statistics->tran_load_calls);
out_printf("Transient analysis timestep backups: %d\n",
statistics->tran_time_backups);
out_printf("\n\n");
}
static void
libvmmalloc_init(void)
{
char *env_str;
size_t size;
/*
* Register fork handlers before jemalloc initialization.
* This provides the correct order of fork handlers execution.
* Note that the first malloc() will trigger jemalloc init, so we
* have to register fork handlers before the call to out_init(),
* as it may indirectly call malloc() when opening the log file.
*/
if (pthread_atfork(libvmmalloc_prefork,
libvmmalloc_postfork_parent,
libvmmalloc_postfork_child) != 0) {
perror("Error (libvmmalloc): pthread_atfork");
abort();
}
out_init(VMMALLOC_LOG_PREFIX, VMMALLOC_LOG_LEVEL_VAR,
VMMALLOC_LOG_FILE_VAR, VMMALLOC_MAJOR_VERSION,
VMMALLOC_MINOR_VERSION);
out_set_vsnprintf_func(je_vmem_navsnprintf);
LOG(3, NULL);
util_init();
/* set up jemalloc messages to a custom print function */
je_vmem_malloc_message = print_jemalloc_messages;
Header_size = roundup(sizeof (VMEM), Pagesize);
if ((Dir = getenv(VMMALLOC_POOL_DIR_VAR)) == NULL) {
out_log(NULL, 0, NULL, 0, "Error (libvmmalloc): "
"environment variable %s not specified",
VMMALLOC_POOL_DIR_VAR);
abort();
}
if ((env_str = getenv(VMMALLOC_POOL_SIZE_VAR)) == NULL) {
out_log(NULL, 0, NULL, 0, "Error (libvmmalloc): "
"environment variable %s not specified",
VMMALLOC_POOL_SIZE_VAR);
abort();
} else {
long long int v = atoll(env_str);
if (v < 0) {
out_log(NULL, 0, NULL, 0,
"Error (libvmmalloc): negative %s",
VMMALLOC_POOL_SIZE_VAR);
abort();
}
size = (size_t)v;
}
if (size < VMMALLOC_MIN_POOL) {
out_log(NULL, 0, NULL, 0, "Error (libvmmalloc): "
"%s value is less than minimum (%zu < %zu)",
VMMALLOC_POOL_SIZE_VAR, size,
VMMALLOC_MIN_POOL);
abort();
}
if ((env_str = getenv(VMMALLOC_FORK_VAR)) != NULL) {
Forkopt = atoi(env_str);
if (Forkopt < 0 || Forkopt > 3) {
out_log(NULL, 0, NULL, 0, "Error (libvmmalloc): "
"incorrect %s value (%d)",
VMMALLOC_FORK_VAR, Forkopt);
abort();
}
LOG(4, "Fork action %d", Forkopt);
}
/*
* XXX - vmem_create() could be used here, but then we need to
* link vmem.o, including all the vmem API.
*/
Vmp = libvmmalloc_create(Dir, size);
if (Vmp == NULL) {
out_log(NULL, 0, NULL, 0, "!Error (libvmmalloc): "
"vmem pool creation failed");
abort();
}
LOG(2, "initialization completed");
}
void
EVTprintvcd(wordlist *wl)
{
int i;
int nargs;
wordlist *w;
char *node_name[EPRINT_MAXARGS];
int node_index[EPRINT_MAXARGS];
int udn_index[EPRINT_MAXARGS];
Evt_Node_t *node_data[EPRINT_MAXARGS];
char *node_value[EPRINT_MAXARGS];
char *old_node_value[EPRINT_MAXARGS];
char node_ident[EPRINT_MAXARGS + 1];
CKTcircuit *ckt;
Evt_Node_Info_t **node_table;
Mif_Boolean_t more;
double step = 0.0;
double next_step;
double this_step;
char *value;
/* Count the number of arguments to the command */
nargs = 0;
for (w = wl; w; w = w->wl_next)
nargs++;
if (nargs < 1) {
printf("Usage: eprvcd <node1> <node2> ...\n");
return;
}
if (nargs > EPRINT_MAXARGS) {
fprintf(cp_err, "ERROR - eprvcd currently limited to %d arguments\n", EPRINT_MAXARGS);
return;
}
/* Get needed pointers */
ckt = g_mif_info.ckt;
if (!ckt) {
fprintf(cp_err, "Error: no circuit loaded.\n");
return;
}
if (!ckt->evt->data.node) {
fprintf(cp_err, "ERROR - No node data: simulation not yet run?\n");
return;
}
node_table = ckt->evt->info.node_table;
/* Get data for each argument */
w = wl;
for (i = 0; i < nargs; i++) {
node_name[i] = w->wl_word;
node_index[i] = get_index(node_name[i]);
if (node_index[i] < 0) {
fprintf(cp_err, "ERROR - Node %s is not an event node.\n", node_name[i]);
return;
}
udn_index[i] = node_table[node_index[i]]->udn_index;
node_data[i] = ckt->evt->data.node->head[node_index[i]];
node_value[i] = "";
w = w->wl_next;
}
/* generate the vcd identifier code made of the printable
ASCII character set from ! to ~ (decimal 33 to 126) */
for (i = 0; i < nargs; i++)
node_ident[i] = (char) ('!' + i);
node_ident[i] = '\0';
out_init();
/* get actual time */
time_t ltime;
char datebuff[80];
struct tm *my_time;
time(<ime);
/* Obtain the local time: */
my_time = localtime(<ime);
/* time output format according to vcd spec */
strftime(datebuff, sizeof(datebuff), "%B %d, %Y %H:%M:%S", my_time);
out_printf("$date %s $end\n", datebuff);
out_printf("$version %s %s $end\n", ft_sim->simulator, ft_sim->version);
/* get the sim time resolution based on tstep */
char *unit;
double scale;
double tstep = ckt->CKTstep;
/* if selected time step is down to [ms] then report time at [us] etc., always with one level higher resolution */
if (tstep >= 1e-3) {
unit = "us";
scale = 1e6;
}
else if (tstep >= 1e-6) {
unit = "ns";
scale = 1e9;
}
else if (tstep >= 1e-9) {
unit = "ps";
scale = 1e12;
}
else {
unit = "fs";
scale = 1e15;
}
out_printf("$timescale 1 %s $end\n", unit);
/* Scan the node data. Go for printing using $dumpvars
for the initial values. Also, determine if there is
more data following it and if so, what the next step is. */
more = MIF_FALSE;
next_step = 1e30;
for (i = 0; i < nargs; i++) {
step = node_data[i]->step;
g_evt_udn_info[udn_index[i]]->print_val
(node_data[i]->node_value, "all", &value);
old_node_value[i] = node_value[i] = value;
node_data[i] = node_data[i]->next;
if (node_data[i]) {
more = MIF_TRUE;
if (next_step > node_data[i]->step)
next_step = node_data[i]->step;
}
}
for (i = 0; i < nargs; i++) {
char *buf;
if (get_vcdval(node_value[i], &buf) == 1)
/* real number format */
out_printf("$var real 1 %c %s $end\n", node_ident[i], node_name[i]);
else
/* digital data format */
out_printf("$var wire 1 %c %s $end\n", node_ident[i], node_name[i]);
tfree(buf);
}
out_printf("$enddefinitions $end\n");
out_printf("#%lld\n", (unsigned long long)(step * scale));
/* first set of data for initialization
or if only op has been calculated */
out_printf("$dumpvars\n");
for (i = 0; i < nargs; i++) {
char *buf;
if (get_vcdval(node_value[i], &buf) == 1)
/* real number format */
out_printf("r%s %c\n", buf, node_ident[i]);
else
/* digital data format */
out_printf("%s%c\n", buf, node_ident[i]);
tfree(buf);
}
out_printf("$end\n");
/* While there is more data, get the next values and print */
while (more) {
more = MIF_FALSE;
this_step = next_step;
next_step = 1e30;
for (i = 0; i < nargs; i++)
if (node_data[i]) {
if (node_data[i]->step == this_step) {
g_evt_udn_info[udn_index[i]]->print_val
(node_data[i]->node_value, "all", &value);
node_value[i] = value;
node_data[i] = node_data[i]->next;
}
if (node_data[i]) {
more = MIF_TRUE;
if (next_step > node_data[i]->step)
next_step = node_data[i]->step;
}
}
/* timestamp */
out_printf("#%lld\n", (unsigned long long)(this_step * scale));
/* print only values that have changed */
for (i = 0; i < nargs; i++) {
if (!eq(old_node_value[i], node_value[i])) {
char *buf;
if (get_vcdval(node_value[i], &buf) == 1)
out_printf("r%s %c\n", buf, node_ident[i]);
else
out_printf("%s%c\n", buf, node_ident[i]);
old_node_value[i] = node_value[i];
tfree(buf);
}
}
} /* end while there is more data */
out_printf("\n\n");
}
/* Print the values of currently defined variables. */
void
cp_vprint(void)
{
struct variable *v;
struct variable *uv1;
wordlist *wl;
int i, j;
char *s;
struct xxx *vars;
uv1 = cp_usrvars();
for (v = variables, i = 0; v; v = v->va_next)
i++;
for (v = uv1; v; v = v->va_next)
i++;
if (plot_cur)
for (v = plot_cur->pl_env; v; v = v->va_next)
i++;
if (ft_curckt)
for (v = ft_curckt->ci_vars; v; v = v->va_next)
i++;
vars = TMALLOC(struct xxx, i);
out_init();
for (v = variables, i = 0; v; v = v->va_next, i++) {
vars[i].x_v = v;
vars[i].x_char = ' ';
}
for (v = uv1; v; v = v->va_next, i++) {
vars[i].x_v = v;
vars[i].x_char = '*';
}
if (plot_cur)
for (v = plot_cur->pl_env; v; v = v->va_next, i++) {
vars[i].x_v = v;
vars[i].x_char = '*';
}
if (ft_curckt)
for (v = ft_curckt->ci_vars; v; v = v->va_next, i++) {
vars[i].x_v = v;
vars[i].x_char = '+';
}
qsort(vars, (size_t) i, sizeof(*vars), vcmp);
for (j = 0; j < i; j++) {
if (j && eq(vars[j].x_v->va_name, vars[j-1].x_v->va_name))
continue;
v = vars[j].x_v;
if (v->va_type == CP_BOOL) {
out_printf("%c %s\n", vars[j].x_char, v->va_name);
} else {
out_printf("%c %s\t", vars[j].x_char, v->va_name);
wl = vareval(v->va_name);
s = wl_flatten(wl);
if (v->va_type == CP_LIST)
out_printf("( %s )\n", s);
else
out_printf("%s\n", s);
}
}
free_struct_variable(uv1);
tfree(vars);
}