/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1988 Wayne A. Christopher, U. C. Berkeley CAD Group
Modified: 2000 AlansFixes
**********/
/**************************************************************************
* 10.Mar.2017 - RM - Added a dirty fix to handle orphan FOSSEE test bench
* processes. The following static functions were added in the process:
* o nghdl_orphan_tb()
* o nghdl_tb_SIGUSR1()
**************************************************************************
*/
/*
* This module replaces the old "writedata" routines in nutmeg.
* Unlike the writedata routines, the OUT routines are only called by
* the simulator routines, and only call routines in nutmeg. The rest
* of nutmeg doesn't deal with OUT at all.
*/
#include "ngspice/ngspice.h"
#include "ngspice/cpdefs.h"
#include "ngspice/ftedefs.h"
#include "ngspice/dvec.h"
#include "ngspice/plot.h"
#include "ngspice/sim.h"
#include "ngspice/inpdefs.h" /* for INPtables */
#include "ngspice/ifsim.h"
#include "ngspice/jobdefs.h"
#include "ngspice/iferrmsg.h"
#include "circuits.h"
#include "outitf.h"
#include "variable.h"
#include <fcntl.h>
#include "ngspice/cktdefs.h"
#include "ngspice/inpdefs.h"
#include "breakp2.h"
#include "runcoms.h"
#include "plotting/graf.h"
#include "../misc/misc_time.h"
/* 10.Mar.2917 - RM - Added the following #include */
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
extern char *spice_analysis_get_name(int index);
extern char *spice_analysis_get_description(int index);
static int beginPlot(JOB *analysisPtr, CKTcircuit *circuitPtr, char *cktName, char *analName,
char *refName, int refType, int numNames, char **dataNames, int dataType,
bool windowed, runDesc **runp);
static int addDataDesc(runDesc *run, char *name, int type, int ind);
static int addSpecialDesc(runDesc *run, char *name, char *devname, char *param, int depind);
static void fileInit(runDesc *run);
static void fileInit_pass2(runDesc *run);
static void fileStartPoint(FILE *fp, bool bin, int num);
static void fileAddRealValue(FILE *fp, bool bin, double value);
static void fileAddComplexValue(FILE *fp, bool bin, IFcomplex value);
static void fileEndPoint(FILE *fp, bool bin);
static void fileEnd(runDesc *run);
static void plotInit(runDesc *run);
static void plotAddRealValue(dataDesc *desc, double value);
static void plotAddComplexValue(dataDesc *desc, IFcomplex value);
static void plotEnd(runDesc *run);
static bool parseSpecial(char *name, char *dev, char *param, char *ind);
static bool name_eq(char *n1, char *n2);
static bool getSpecial(dataDesc *desc, runDesc *run, IFvalue *val);
static void freeRun(runDesc *run);
/*Output data to spice module*/
#ifdef TCL_MODULE
#include "ngspice/tclspice.h"
#elif defined SHARED_MODULE
extern int sh_ExecutePerLoop(void);
extern void sh_vecinit(runDesc *run);
#endif
/*Suppressing progress info in -o option */
#ifndef HAS_WINGUI
extern bool orflag;
#endif
#define DOUBLE_PRECISION 15
static clock_t lastclock, currclock;
static double *rowbuf;
static size_t column, rowbuflen;
static bool shouldstop = FALSE; /* Tell simulator to stop next time it asks. */
/* 10.Mar.2017 - RM - Added nghdl_tb_SIGUSR1().*/
static void nghdl_tb_SIGUSR1(char* pid_file)
{
int ret;
char line[80];
char* nptr;
FILE* fp = fopen(pid_file, "r");
if (fp)
{
if (fscanf(fp, "%s", line) != EOF)
{
fclose(fp);
pid_t pid = (pid_t) strtol(line, &nptr, 10);
// PID is converted to a decimal value.
if ((errno != ERANGE) && (errno!= EINVAL))
{
if (pid)
{
// Check if a process with this pid really exists.
ret = kill(pid, 0);
if (ret == 0)
{
kill(pid, SIGUSR1);
}
}
}
}
}
}
/* 10.Mar.2017 - RM - Added nghdl_orphan_tb().*/
static void nghdl_orphan_tb(void)
{
struct dirent* dirp;
DIR* dirfd;
char* dir = "/tmp";
char filename_tmp[1024];
char pid_file_prefix[256];
sprintf(pid_file_prefix, "NGHDL_%d", getpid());
if ((dirfd = opendir(dir)) == NULL)
{
fprintf(stderr, "nghdl_orphan_tb(): Cannot open /tmp\n");
return;
}
/* Loop through /tmp directories looking for "NGHDL_<my pid>*" files.*/
while ((dirp = readdir(dirfd)) != NULL)
{
struct stat stbuf;
sprintf(filename_tmp, "/tmp/%s", dirp->d_name);
if (strstr(filename_tmp, pid_file_prefix))
{
if (stat(filename_tmp, &stbuf) == -1)
{
fprintf(stderr,
"nghdl_orphan_tb: stat() failed; ERRNO=%d on file:%s\n",
errno, filename_tmp);
continue;
}
if ((stbuf.st_mode & S_IFMT) == S_IFDIR)
{
continue;
}
else
{
nghdl_tb_SIGUSR1(filename_tmp);
}
}
}
}
/* End 10.Mar.2017 - RM */
/* The two "begin plot" routines share all their internals... */
int
OUTpBeginPlot(CKTcircuit *circuitPtr, JOB *analysisPtr,
IFuid analName,
IFuid refName, int refType,
int numNames, IFuid *dataNames, int dataType, runDesc **plotPtr)
{
char *name;
if (ft_curckt->ci_ckt == circuitPtr)
name = ft_curckt->ci_name;
else
name = "circuit name";
return (beginPlot(analysisPtr, circuitPtr, name,
analName, refName, refType, numNames,
dataNames, dataType, FALSE,
plotPtr));
}
int
OUTwBeginPlot(CKTcircuit *circuitPtr, JOB *analysisPtr,
IFuid analName,
IFuid refName, int refType,
int numNames, IFuid *dataNames, int dataType, runDesc **plotPtr)
{
return (beginPlot(analysisPtr, circuitPtr, "circuit name",
analName, refName, refType, numNames,
dataNames, dataType, TRUE,
plotPtr));
}
static int
beginPlot(JOB *analysisPtr, CKTcircuit *circuitPtr, char *cktName, char *analName, char *refName, int refType, int numNames, char **dataNames, int dataType, bool windowed, runDesc **runp)
{
runDesc *run;
struct save_info *saves;
bool *savesused = NULL;
int numsaves;
int i, j, depind = 0;
char namebuf[BSIZE_SP], parambuf[BSIZE_SP], depbuf[BSIZE_SP];
char *ch, tmpname[BSIZE_SP];
bool saveall = TRUE;
bool savealli = FALSE;
char *an_name;
/*to resume a run saj
*All it does is reassign the file pointer and return (requires *runp to be NULL if this is not needed)
*/
if (dataType == 666 && numNames == 666) {
run = *runp;
run->writeOut = ft_getOutReq(&run->fp, &run->runPlot, &run->binary,
run->type, run->name);
} else {
/*end saj*/
/* Check to see if we want to print informational data. */
if (cp_getvar("printinfo", CP_BOOL, NULL))
fprintf(cp_err, "(debug printing enabled)\n");
*runp = run = alloc(struct runDesc);
/* First fill in some general information. */
run->analysis = analysisPtr;
run->circuit = circuitPtr;
run->name = copy(cktName);
run->type = copy(analName);
run->windowed = windowed;
run->numData = 0;
an_name = spice_analysis_get_name(analysisPtr->JOBtype);
ft_curckt->ci_last_an = an_name;
/* Now let's see which of these things we need. First toss in the
* reference vector. Then toss in anything that getSaves() tells
* us to save that we can find in the name list. Finally unpack
* the remaining saves into parameters.
*/
numsaves = ft_getSaves(&saves);
if (numsaves) {
savesused = TMALLOC(bool, numsaves);
saveall = FALSE;
for (i = 0; i < numsaves; i++) {
if (saves[i].analysis && !cieq(saves[i].analysis, an_name)) {
/* ignore this one this time around */
savesused[i] = TRUE;
continue;
}
/* Check for ".save all" and new synonym ".save allv" */
if (cieq(saves[i].name, "all") || cieq(saves[i].name, "allv")) {
saveall = TRUE;
savesused[i] = TRUE;
saves[i].used = 1;
continue;
}
/* And now for the new ".save alli" option */
if (cieq(saves[i].name, "alli")) {
savealli = TRUE;
savesused[i] = TRUE;
saves[i].used = 1;
continue;
}
}
}
/* Pass 0. */
if (refName) {
addDataDesc(run, refName, refType, -1);
for (i = 0; i < numsaves; i++)
if (!savesused[i] && name_eq(saves[i].name, refName)) {
savesused[i] = TRUE;
saves[i].used = 1;
}
} else {
run->refIndex = -1;
}
/* Pass 1. */
if (numsaves && !saveall) {
for (i = 0; i < numsaves; i++)
if (!savesused[i])
for (j = 0; j < numNames; j++)
if (name_eq(saves[i].name, dataNames[j])) {
addDataDesc(run, dataNames[j], dataType, j);
savesused[i] = TRUE;
saves[i].used = 1;
break;
}
} else {
for (i = 0; i < numNames; i++)
if (!refName || !name_eq(dataNames[i], refName))
/* Save the node as long as it's an internal device node */
if (!strstr(dataNames[i], "#internal") &&
!strstr(dataNames[i], "#source") &&
!strstr(dataNames[i], "#drain") &&
!strstr(dataNames[i], "#collector") &&
!strstr(dataNames[i], "#emitter") &&
!strstr(dataNames[i], "#base"))
{
addDataDesc(run, dataNames[i], dataType, i);
}
}
/* Pass 1 and a bit.
This is a new pass which searches for all the internal device
nodes, and saves the terminal currents instead */
if (savealli) {
depind = 0;
for (i = 0; i < numNames; i++) {
if (strstr(dataNames[i], "#internal") ||
strstr(dataNames[i], "#source") ||
strstr(dataNames[i], "#drain") ||
strstr(dataNames[i], "#collector") ||
strstr(dataNames[i], "#emitter") ||
strstr(dataNames[i], "#base"))
{
tmpname[0] = '@';
tmpname[1] = '\0';
strncat(tmpname, dataNames[i], BSIZE_SP-1);
ch = strchr(tmpname, '#');
if (strstr(ch, "#collector")) {
strcpy(ch, "[ic]");
} else if (strstr(ch, "#base")) {
strcpy(ch, "[ib]");
} else if (strstr(ch, "#emitter")) {
strcpy(ch, "[ie]");
if (parseSpecial(tmpname, namebuf, parambuf, depbuf))
addSpecialDesc(run, tmpname, namebuf, parambuf, depind);
strcpy(ch, "[is]");
} else if (strstr(ch, "#drain")) {
strcpy(ch, "[id]");
if (parseSpecial(tmpname, namebuf, parambuf, depbuf))
addSpecialDesc(run, tmpname, namebuf, parambuf, depind);
strcpy(ch, "[ig]");
} else if (strstr(ch, "#source")) {
strcpy(ch, "[is]");
if (parseSpecial(tmpname, namebuf, parambuf, depbuf))
addSpecialDesc(run, tmpname, namebuf, parambuf, depind);
strcpy(ch, "[ib]");
} else if (strstr(ch, "#internal") && (tmpname[1] == 'd')) {
strcpy(ch, "[id]");
} else {
fprintf(cp_err,
"Debug: could output current for %s\n", tmpname);
continue;
}
if (parseSpecial(tmpname, namebuf, parambuf, depbuf)) {
if (*depbuf) {
fprintf(stderr,
"Warning : unexpected dependent variable on %s\n", tmpname);
} else {
addSpecialDesc(run, tmpname, namebuf, parambuf, depind);
}
}
}
}
}
/* Pass 2. */
for (i = 0; i < numsaves; i++) {
if (savesused[i])
continue;
if (!parseSpecial(saves[i].name, namebuf, parambuf, depbuf)) {
if (saves[i].analysis)
fprintf(cp_err, "Warning: can't parse '%s': ignored\n",
saves[i].name);
continue;
}
/* Now, if there's a dep variable, do we already have it? */
if (*depbuf) {
for (j = 0; j < run->numData; j++)
if (name_eq(depbuf, run->data[j].name))
break;
if (j == run->numData) {
/* Better add it. */
for (j = 0; j < numNames; j++)
if (name_eq(depbuf, dataNames[j]))
break;
if (j == numNames) {
fprintf(cp_err,
"Warning: can't find '%s': value '%s' ignored\n",
depbuf, saves[i].name);
continue;
}
addDataDesc(run, dataNames[j], dataType, j);
savesused[i] = TRUE;
saves[i].used = 1;
depind = j;
} else {
depind = run->data[j].outIndex;
}
}
addSpecialDesc(run, saves[i].name, namebuf, parambuf, depind);
}
if (numsaves) {
for (i = 0; i < numsaves; i++) {
tfree(saves[i].analysis);
tfree(saves[i].name);
}
tfree(saves);
tfree(savesused);
}
if (numNames &&
((run->numData == 1 && run->refIndex != -1) ||
(run->numData == 0 && run->refIndex == -1)))
{
fprintf(cp_err, "Error: no data saved for %s; analysis not run\n",
spice_analysis_get_description(analysisPtr->JOBtype));
return E_NOTFOUND;
}
/* Now that we have our own data structures built up, let's see what
* nutmeg wants us to do.
*/
run->writeOut = ft_getOutReq(&run->fp, &run->runPlot, &run->binary,
run->type, run->name);
if (run->writeOut) {
fileInit(run);
} else {
plotInit(run);
if (refName)
run->runPlot->pl_ndims = 1;
}
}
/*Start BLT, initilises the blt vectors saj*/
#ifdef TCL_MODULE
blt_init(run);
#elif defined SHARED_MODULE
sh_vecinit(run);
#endif
return (OK);
}
static int
addDataDesc(runDesc *run, char *name, int type, int ind)
{
dataDesc *data;
if (!run->numData)
run->data = TMALLOC(dataDesc, 1);
else
run->data = TREALLOC(dataDesc, run->data, run->numData + 1);
data = &run->data[run->numData];
/* so freeRun will get nice NULL pointers for the fields we don't set */
bzero(data, sizeof(dataDesc));
data->name = copy(name);
data->type = type;
data->gtype = GRID_LIN;
data->regular = TRUE;
data->outIndex = ind;
/* It's the reference vector. */
if (ind == -1)
run->refIndex = run->numData;
run->numData++;
return (OK);
}
static int
addSpecialDesc(runDesc *run, char *name, char *devname, char *param, int depind)
{
dataDesc *data;
char *unique; /* unique char * from back-end */
if (!run->numData)
run->data = TMALLOC(dataDesc, 1);
else
run->data = TREALLOC(dataDesc, run->data, run->numData + 1);
data = &run->data[run->numData];
/* so freeRun will get nice NULL pointers for the fields we don't set */
bzero(data, sizeof(dataDesc));
data->name = copy(name);
unique = copy(devname);
/* MW. My "special" routine here */
INPinsertNofree(&unique, ft_curckt->ci_symtab);
data->specName = unique;
data->specParamName = copy(param);
data->specIndex = depind;
data->specType = -1;
data->specFast = NULL;
data->regular = FALSE;
run->numData++;
return (OK);
}
int
OUTpData(runDesc *plotPtr, IFvalue *refValue, IFvalue *valuePtr)
{
runDesc *run = plotPtr; // FIXME
int i;
run->pointCount++;
#ifdef TCL_MODULE
steps_completed = run->pointCount;
#endif
if (run->writeOut) {
if (run->pointCount == 1)
fileInit_pass2(run);
fileStartPoint(run->fp, run->binary, run->pointCount);
if (run->refIndex != -1) {
if (run->isComplex) {
fileAddComplexValue(run->fp, run->binary, refValue->cValue);
/* While we're looking at the reference value, print it to the screen
every quarter of a second, to give some feedback without using
too much CPU time */
#ifndef HAS_WINGUI
if (!orflag) {
currclock = clock();
if ((currclock-lastclock) > (0.25*CLOCKS_PER_SEC)) {
fprintf(stderr, " Reference value : % 12.5e\r",
refValue->cValue.real);
lastclock = currclock;
}
}
#endif
} else {
/* And the same for a non-complex value */
fileAddRealValue(run->fp, run->binary, refValue->rValue);
#ifndef HAS_WINGUI
if (!orflag) {
currclock = clock();
if ((currclock-lastclock) > (0.25*CLOCKS_PER_SEC)) {
fprintf(stderr, " Reference value : % 12.5e\r",
refValue->rValue);
lastclock = currclock;
}
}
#endif
}
}
for (i = 0; i < run->numData; i++) {
/* we've already printed reference vec first */
if (run->data[i].outIndex == -1)
continue;
#ifdef TCL_MODULE
blt_add(i, refValue ? refValue->rValue : NAN);
#endif
if (run->data[i].regular) {
if (run->data[i].type == IF_REAL)
fileAddRealValue(run->fp, run->binary,
valuePtr->v.vec.rVec [run->data[i].outIndex]);
else if (run->data[i].type == IF_COMPLEX)
fileAddComplexValue(run->fp, run->binary,
valuePtr->v.vec.cVec [run->data[i].outIndex]);
else
fprintf(stderr, "OUTpData: unsupported data type\n");
} else {
IFvalue val;
/* should pre-check instance */
if (!getSpecial(&run->data[i], run, &val)) {
/* If this is the first data point, print a warning for any unrecognized
variables, since this has not already been checked */
if (run->pointCount == 1)
fprintf(stderr, "Warning: unrecognized variable - %s\n",
run->data[i].name);
if (run->isComplex) {
val.cValue.real = 0;
val.cValue.imag = 0;
fileAddComplexValue(run->fp, run->binary, val.cValue);
} else {
val.rValue = 0;
fileAddRealValue(run->fp, run->binary, val.rValue);
}
continue;
}
if (run->data[i].type == IF_REAL)
fileAddRealValue(run->fp, run->binary, val.rValue);
else if (run->data[i].type == IF_COMPLEX)
fileAddComplexValue(run->fp, run->binary, val.cValue);
else
fprintf(stderr, "OUTpData: unsupported data type\n");
}
#ifdef TCL_MODULE
blt_add(i, valuePtr->v.vec.rVec [run->data[i].outIndex]);
#endif
}
fileEndPoint(run->fp, run->binary);
/* Check that the write to disk completed successfully, otherwise abort */
if (ferror(run->fp)) {
fprintf(stderr, "Warning: rawfile write error !!\n");
shouldstop = TRUE;
}
} else {
/* This is interactive mode. Update the screen with the reference
variable just the same */
#ifndef HAS_WINGUI
if (!orflag) {
currclock = clock();
if ((currclock-lastclock) > (0.25*CLOCKS_PER_SEC)) {
if (run->isComplex) {
fprintf(stderr, " Reference value : % 12.5e\r",
refValue ? refValue->cValue.real : NAN);
} else {
fprintf(stderr, " Reference value : % 12.5e\r",
refValue ? refValue->rValue : NAN);
}
lastclock = currclock;
}
}
#endif
for (i = 0; i < run->numData; i++) {
#ifdef TCL_MODULE
/*Locks the blt vector to stop access*/
blt_lockvec(i);
#endif
if (run->data[i].outIndex == -1) {
if (run->data[i].type == IF_REAL)
plotAddRealValue(&run->data[i], refValue->rValue);
else if (run->data[i].type == IF_COMPLEX)
plotAddComplexValue(&run->data[i], refValue->cValue);
} else if (run->data[i].regular) {
if (run->data[i].type == IF_REAL)
plotAddRealValue(&run->data[i],
valuePtr->v.vec.rVec[run->data[i].outIndex]);
else if (run->data[i].type == IF_COMPLEX)
plotAddComplexValue(&run->data[i],
valuePtr->v.vec.cVec[run->data[i].outIndex]);
} else {
IFvalue val;
/* should pre-check instance */
if (!getSpecial(&run->data[i], run, &val))
continue;
if (run->data[i].type == IF_REAL)
plotAddRealValue(&run->data[i], val.rValue);
else if (run->data[i].type == IF_COMPLEX)
plotAddComplexValue(&run->data[i], val.cValue);
else
fprintf(stderr, "OUTpData: unsupported data type\n");
}
#ifdef TCL_MODULE
/*relinks and unlocks vector*/
blt_relink(i, (run->data[i]).vec);
#endif
}
gr_iplot(run->runPlot);
}
if (ft_bpcheck(run->runPlot, run->pointCount) == FALSE)
shouldstop = TRUE;
#ifdef TCL_MODULE
Tcl_ExecutePerLoop();
#elif defined SHARED_MODULE
sh_ExecutePerLoop();
#endif
return (OK);
}
/* ARGSUSED */ /* until some code gets written */
int
OUTwReference(void *plotPtr, IFvalue *valuePtr, void **refPtr)
{
NG_IGNORE(refPtr);
NG_IGNORE(valuePtr);
NG_IGNORE(plotPtr);
return (OK);
}
/* ARGSUSED */ /* until some code gets written */
int
OUTwData(runDesc *plotPtr, int dataIndex, IFvalue *valuePtr, void *refPtr)
{
NG_IGNORE(refPtr);
NG_IGNORE(valuePtr);
NG_IGNORE(dataIndex);
NG_IGNORE(plotPtr);
return (OK);
}
/* ARGSUSED */ /* until some code gets written */
int
OUTwEnd(runDesc *plotPtr)
{
NG_IGNORE(plotPtr);
return (OK);
}
int
OUTendPlot(runDesc *plotPtr)
{
runDesc *run = plotPtr; // FIXME
if (run->writeOut) {
fileEnd(run);
} else {
gr_end_iplot();
plotEnd(run);
}
freeRun(run);
return (OK);
}
/* ARGSUSED */ /* until some code gets written */
int
OUTbeginDomain(runDesc *plotPtr, IFuid refName, int refType, IFvalue *outerRefValue)
{
NG_IGNORE(outerRefValue);
NG_IGNORE(refType);
NG_IGNORE(refName);
NG_IGNORE(plotPtr);
return (OK);
}
/* ARGSUSED */ /* until some code gets written */
int
OUTendDomain(runDesc *plotPtr)
{
NG_IGNORE(plotPtr);
return (OK);
}
/* ARGSUSED */ /* until some code gets written */
int
OUTattributes(runDesc *plotPtr, IFuid varName, int param, IFvalue *value)
{
runDesc *run = plotPtr; // FIXME
GRIDTYPE type;
struct dvec *d;
NG_IGNORE(value);
if (param == OUT_SCALE_LIN)
type = GRID_LIN;
else if (param == OUT_SCALE_LOG)
type = GRID_XLOG;
else
return E_UNSUPP;
if (run->writeOut) {
if (varName) {
int i;
for (i = 0; i < run->numData; i++)
if (!strcmp(varName, run->data[i].name))
run->data[i].gtype = type;
} else {
run->data[run->refIndex].gtype = type;
}
} else {
if (varName) {
for (d = run->runPlot->pl_dvecs; d; d = d->v_next)
if (!strcmp(varName, d->v_name))
d->v_gridtype = type;
} else if (param == PLOT_COMB) {
for (d = run->runPlot->pl_dvecs; d; d = d->v_next)
d->v_plottype = PLOT_COMB;
} else {
run->runPlot->pl_scale->v_gridtype = type;
}
}
return (OK);
}
/* The file writing routines. */
static void
fileInit(runDesc *run)
{
char buf[513];
int i;
size_t n;
lastclock = clock();
/* This is a hack. */
run->isComplex = FALSE;
for (i = 0; i < run->numData; i++)
if (run->data[i].type == IF_COMPLEX)
run->isComplex = TRUE;
n = 0;
sprintf(buf, "Title: %s\n", run->name);
n += strlen(buf);
fputs(buf, run->fp);
sprintf(buf, "Date: %s\n", datestring());
n += strlen(buf);
fputs(buf, run->fp);
sprintf(buf, "Plotname: %s\n", run->type);
n += strlen(buf);
fputs(buf, run->fp);
sprintf(buf, "Flags: %s\n", run->isComplex ? "complex" : "real");
n += strlen(buf);
fputs(buf, run->fp);
sprintf(buf, "No. Variables: %d\n", run->numData);
n += strlen(buf);
fputs(buf, run->fp);
sprintf(buf, "No. Points: ");
n += strlen(buf);
fputs(buf, run->fp);
fflush(run->fp); /* Gotta do this for LATTICE. */
if (run->fp == stdout || (run->pointPos = ftell(run->fp)) <= 0)
run->pointPos = (long) n;
fprintf(run->fp, "0 \n"); /* Save 8 spaces here. */
/*fprintf(run->fp, "Command: version %s\n", ft_sim->version);*/
fprintf(run->fp, "Variables:\n");
printf("No. of Data Columns : %d \n", run->numData);
}
static void
fileInit_pass2(runDesc *run)
{
int i, type;
for (i = 0; i < run->numData; i++) {
char *name = run->data[i].name;
if (substring("#branch", name))
type = SV_CURRENT;
else if (cieq(name, "time"))
type = SV_TIME;
else if (cieq(name, "frequency"))
type = SV_FREQUENCY;
else if (cieq(name, "temp-sweep"))
type = SV_TEMP;
else if (cieq(name, "res-sweep"))
type = SV_RES;
else if ((*name == '@') && (substring("[g", name)))
type = SV_ADMITTANCE;
else if ((*name == '@') && (substring("[c", name)))
type = SV_CAPACITANCE;
else if ((*name == '@') && (substring("[i", name)))
type = SV_CURRENT;
else if ((*name == '@') && (substring("[q", name)))
type = SV_CHARGE;
else
type = SV_VOLTAGE;
if (type == SV_CURRENT) {
char *branch = strstr(name, "#branch");
if (branch)
*branch = '\0';
fprintf(run->fp, "\t%d\ti(%s)\t%s", i, name, ft_typenames(type));
if (branch)
*branch = '#';
} else if (type == SV_VOLTAGE) {
fprintf(run->fp, "\t%d\tv(%s)\t%s", i, name, ft_typenames(type));
} else {
fprintf(run->fp, "\t%d\t%s\t%s", i, name, ft_typenames(type));
}
if (run->data[i].gtype == GRID_XLOG)
fprintf(run->fp, "\tgrid=3");
fprintf(run->fp, "\n");
}
fprintf(run->fp, "%s:\n", run->binary ? "Binary" : "Values");
fflush(run->fp);
/* Allocate Row buffer */
if (run->binary) {
rowbuflen = (size_t) (run->numData);
if (run->isComplex)
rowbuflen *= 2;
rowbuf = TMALLOC(double, rowbuflen);
} else {
// fIXME rowbuflen = 0;
rowbuf = NULL;
}
}
static void
fileStartPoint(FILE *fp, bool bin, int num)
{
if (!bin)
fprintf(fp, "%d\t", num - 1);
/* reset buffer pointer to zero */
column = 0;
}
static void
fileAddRealValue(FILE *fp, bool bin, double value)
{
if (bin)
rowbuf[column++] = value;
else
fprintf(fp, "\t%.*e\n", DOUBLE_PRECISION, value);
}
static void
fileAddComplexValue(FILE *fp, bool bin, IFcomplex value)
{
if (bin) {
rowbuf[column++] = value.real;
rowbuf[column++] = value.imag;
} else {
fprintf(fp, "\t%.*e,%.*e\n", DOUBLE_PRECISION, value.real,
DOUBLE_PRECISION, value.imag);
}
}
/* ARGSUSED */ /* until some code gets written */
static void
fileEndPoint(FILE *fp, bool bin)
{
/* write row buffer to file */
/* otherwise the data has already been written */
if (bin)
fwrite(rowbuf, sizeof(double), rowbuflen, fp);
}
/* Here's the hack... Run back and fill in the number of points. */
static void
fileEnd(runDesc *run)
{
/* 10.Mar.2017 - RM - Check if any orphan test benches are running. If any are
* found, force them to exit.
*/
nghdl_orphan_tb();
/* End 10.Mar.2017 */
if (run->fp != stdout) {
long place = ftell(run->fp);
fseek(run->fp, run->pointPos, SEEK_SET);
fprintf(run->fp, "%d", run->pointCount);
fprintf(stdout, "\nNo. of Data Rows : %d\n", run->pointCount);
fseek(run->fp, place, SEEK_SET);
} else {
/* Yet another hack-around */
fprintf(stderr, "@@@ %ld %d\n", run->pointPos, run->pointCount);
}
fflush(run->fp);
if (run->binary) {
/* deallocate row buffer */
tfree(rowbuf);
}
}
/* The plot maintenance routines. */
static void
plotInit(runDesc *run)
{
struct plot *pl = plot_alloc(run->type);
char buf[100];
struct dvec *v;
dataDesc *dd;
int i;
pl->pl_title = copy(run->name);
pl->pl_name = copy(run->type);
pl->pl_date = copy(datestring());
pl->pl_ndims = 0;
plot_new(pl);
plot_setcur(pl->pl_typename);
run->runPlot = pl;
/* This is a hack. */
/* if any of them complex, make them all complex */
run->isComplex = FALSE;
for (i = 0; i < run->numData; i++)
if (run->data[i].type == IF_COMPLEX)
run->isComplex = TRUE;
for (i = 0; i < run->numData; i++) {
dd = &run->data[i];
v = alloc(struct dvec);
if (isdigit(*dd->name)) {
(void) sprintf(buf, "V(%s)", dd->name);
v->v_name = copy(buf);
} else {
v->v_name = copy(dd->name);
}
if (substring("#branch", v->v_name))
v->v_type = SV_CURRENT;
else if (cieq(v->v_name, "time"))
v->v_type = SV_TIME;
else if (cieq(v->v_name, "frequency"))
v->v_type = SV_FREQUENCY;
else if (cieq(v->v_name, "onoise_spectrum"))
v->v_type = SV_OUTPUT_N_DENS;
else if (cieq(v->v_name, "onoise_integrated"))
v->v_type = SV_OUTPUT_NOISE;
else if (cieq(v->v_name, "inoise_spectrum"))
v->v_type = SV_INPUT_N_DENS;
else if (cieq(v->v_name, "inoise_integrated"))
v->v_type = SV_INPUT_NOISE;
else if (cieq(v->v_name, "temp-sweep"))
v->v_type = SV_TEMP;
else if (cieq(v->v_name, "res-sweep"))
v->v_type = SV_RES;
else if ((*(v->v_name) == '@') && (substring("[g", v->v_name)))
v->v_type = SV_ADMITTANCE;
else if ((*(v->v_name) == '@') && (substring("[c", v->v_name)))
v->v_type = SV_CAPACITANCE;
else if ((*(v->v_name) == '@') && (substring("[i", v->v_name)))
v->v_type = SV_CURRENT;
else if ((*(v->v_name) == '@') && (substring("[q", v->v_name)))
v->v_type = SV_CHARGE;
else
v->v_type = SV_VOLTAGE;
v->v_length = 0;
v->v_scale = NULL;
if (!run->isComplex) {
v->v_flags = VF_REAL;
v->v_realdata = NULL;
} else {
v->v_flags = VF_COMPLEX;
v->v_compdata = NULL;
}
v->v_flags |= VF_PERMANENT;
vec_new(v);
dd->vec = v;
}
}
static void
plotAddRealValue(dataDesc *desc, double value)
{
struct dvec *v = desc->vec;
if (isreal(v)) {
v->v_realdata = TREALLOC(double, v->v_realdata, v->v_length + 1);
v->v_realdata[v->v_length] = value;
} else {
/* a real parading as a VF_COMPLEX */
v->v_compdata = TREALLOC(ngcomplex_t, v->v_compdata, v->v_length + 1);
v->v_compdata[v->v_length].cx_real = value;
v->v_compdata[v->v_length].cx_imag = 0.0;
}
v->v_length++;
v->v_dims[0] = v->v_length; /* va, must be updated */
}
static void
plotAddComplexValue(dataDesc *desc, IFcomplex value)
{
struct dvec *v = desc->vec;
v->v_compdata = TREALLOC(ngcomplex_t, v->v_compdata, v->v_length + 1);
v->v_compdata[v->v_length].cx_real = value.real;
v->v_compdata[v->v_length].cx_imag = value.imag;
v->v_length++;
v->v_dims[0] = v->v_length; /* va, must be updated */
}
/* ARGSUSED */ /* until some code gets written */
static void
plotEnd(runDesc *run)
{
/* 10.Mar.2017 - RM */
nghdl_orphan_tb();
/* End 10.Mar.2017 */
fprintf(stderr, "\n");
fprintf(stdout, "\nNo. of Data Rows : %d\n", run->pointCount);
}
/* ParseSpecial takes something of the form "@name[param,index]" and rips
* out name, param, andstrchr.
*/
static bool
parseSpecial(char *name, char *dev, char *param, char *ind)
{
char *s;
*dev = *param = *ind = '\0';
if (*name != '@')
return FALSE;
name++;
s = dev;
while (*name && (*name != '['))
*s++ = *name++;
*s = '\0';
if (!*name)
return TRUE;
name++;
s = param;
while (*name && (*name != ',') && (*name != ']'))
*s++ = *name++;
*s = '\0';
if (*name == ']')
return (!name[1] ? TRUE : FALSE);
else if (!*name)
return FALSE;
name++;
s = ind;
while (*name && (*name != ']'))
*s++ = *name++;
*s = '\0';
if (*name && !name[1])
return TRUE;
else
return FALSE;
}
/* This routine must match two names with or without a V() around them. */
static bool
name_eq(char *n1, char *n2)
{
char buf1[BSIZE_SP], buf2[BSIZE_SP], *s;
if ((s = strchr(n1, '(')) != NULL) {
strcpy(buf1, s);
if ((s = strchr(buf1, ')')) == NULL)
return FALSE;
*s = '\0';
n1 = buf1;
}
if ((s = strchr(n2, '(')) != NULL) {
strcpy(buf2, s);
if ((s = strchr(buf2, ')')) == NULL)
return FALSE;
*s = '\0';
n2 = buf2;
}
return (strcmp(n1, n2) ? FALSE : TRUE);
}
static bool
getSpecial(dataDesc *desc, runDesc *run, IFvalue *val)
{
IFvalue selector;
struct variable *vv;
selector.iValue = desc->specIndex;
if (INPaName(desc->specParamName, val, run->circuit, &desc->specType,
desc->specName, &desc->specFast, ft_sim, &desc->type,
&selector) == OK) {
desc->type &= (IF_REAL | IF_COMPLEX); /* mask out other bits */
return TRUE;
}
if ((vv = if_getstat(run->circuit, &desc->name[1])) != NULL) {
/* skip @ sign */
desc->type = IF_REAL;
if (vv->va_type == CP_REAL)
val->rValue = vv->va_real;
else if (vv->va_type == CP_NUM)
val->rValue = vv->va_num;
else if (vv->va_type == CP_BOOL)
val->rValue = (vv->va_bool ? 1.0 : 0.0);
else
return FALSE; /* not a real */
tfree(vv);
return TRUE;
}
return FALSE;
}
static void
freeRun(runDesc *run)
{
int i;
for (i = 0; i < run->numData; i++) {
tfree(run->data[i].name);
tfree(run->data[i].specParamName);
}
tfree(run->data);
tfree(run->type);
tfree(run->name);
tfree(run);
}
int
OUTstopnow(void)
{
if (ft_intrpt || shouldstop) {
ft_intrpt = shouldstop = FALSE;
return (1);
}
return (0);
}
/* Print out error messages. */
static struct mesg {
char *string;
long flag;
} msgs[] = {
{ "Warning", ERR_WARNING } ,
{ "Fatal error", ERR_FATAL } ,
{ "Panic", ERR_PANIC } ,
{ "Note", ERR_INFO } ,
{ NULL, 0 }
};
void
OUTerror(int flags, char *format, IFuid *names)
{
struct mesg *m;
char buf[BSIZE_SP], *s, *bptr;
int nindex = 0;
if ((flags == ERR_INFO) && cp_getvar("printinfo", CP_BOOL, NULL))
return;
for (m = msgs; m->flag; m++)
if (flags & m->flag)
fprintf(cp_err, "%s: ", m->string);
for (s = format, bptr = buf; *s; s++) {
if (*s == '%' && (s == format || s[-1] != '%') && s[1] == 's') {
if (names[nindex])
strcpy(bptr, names[nindex]);
else
strcpy(bptr, "(null)");
bptr += strlen(bptr);
s++;
nindex++;
} else {
*bptr++ = *s;
}
}
*bptr = '\0';
fprintf(cp_err, "%s\n", buf);
fflush(cp_err);
}