static void recurse_tree_fix_from_whichcache(struct tree *t)
{
if(t)
{
struct tree *t2 = t;
int i;
int cnt = 1;
struct tree **ar;
while((t2 = t2->next)) { cnt++; }
ar = malloc_2(cnt * sizeof(struct tree *));
t2 = t;
for(i=0;i<cnt;i++)
{
ar[i] = t2;
if(t2->child) { recurse_tree_fix_from_whichcache(t2->child); }
t2 = t2->next;
}
for(i=cnt-1;i>=0;i--)
{
t = ar[i];
if(t->t_which >= 0)
{
GLOBALS->gwt_ghw_c_1 = ghw_splay(t, GLOBALS->gwt_ghw_c_1);
GLOBALS->gwt_corr_ghw_c_1 = ghw_splay(GLOBALS->gwt_ghw_c_1->sym, GLOBALS->gwt_corr_ghw_c_1); /* all facs are in this tree so this is OK */
t->t_which = GLOBALS->gwt_corr_ghw_c_1->val_old;
}
}
free_2(ar);
}
}
/*
* currently only called by parsewavline
*/
void set_current_translate_proc(char *name)
{
int i;
for(i=1;i<GLOBALS->num_proc_filters+1;i++)
{
if(!strcmp(GLOBALS->procsel_filter[i], name)) { GLOBALS->current_translate_proc = i; return; }
}
if(GLOBALS->num_proc_filters < PROC_FILTER_MAX)
{
GLOBALS->num_proc_filters++;
load_proc_filter(GLOBALS->num_proc_filters, name);
if(!GLOBALS->proc_filter[GLOBALS->num_proc_filters])
{
GLOBALS->num_proc_filters--;
GLOBALS->current_translate_proc = 0;
}
else
{
if(GLOBALS->procsel_filter[GLOBALS->num_proc_filters]) free_2(GLOBALS->procsel_filter[GLOBALS->num_proc_filters]);
GLOBALS->procsel_filter[GLOBALS->num_proc_filters] = malloc_2(strlen(name) + 1);
strcpy(GLOBALS->procsel_filter[GLOBALS->num_proc_filters], name);
GLOBALS->current_translate_proc = GLOBALS->num_proc_filters;
}
}
}
static void recurse_tree_build_whichcache(struct tree *t)
{
if(t)
{
struct tree *t2 = t;
int i;
int cnt = 1;
struct tree **ar;
while((t2 = t2->next)) { cnt++; }
ar = malloc_2(cnt * sizeof(struct tree *));
t2 = t;
for(i=0;i<cnt;i++)
{
ar[i] = t2;
if(t2->child) { recurse_tree_build_whichcache(t2->child); }
t2 = t2->next;
}
for(i=cnt-1;i>=0;i--)
{
t = ar[i];
if(t->t_which >= 0)
{
GLOBALS->gwt_ghw_c_1 = ghw_insert(t, GLOBALS->gwt_ghw_c_1, t->t_which, GLOBALS->facs[t->t_which]);
}
}
free_2(ar);
}
}
/*
* for debugging purposes only
*/
void treedebug(struct tree *t, char *s)
{
while(t)
{
char *s2;
s2=(char *)malloc_2(strlen(s)+strlen(t->name)+2);
strcpy(s2,s);
strcat(s2,".");
strcat(s2,t->name);
if(t->child)
{
treedebug(t->child, s2);
}
if(t->t_which>=0) /* for when valid netnames like A.B.C, A.B.C.D exist (not legal excluding texsim) */
/* otherwise this would be an 'else' */
{
printf("%3d) %s\n", t->t_which, s2);
}
free_2(s2);
t=t->next;
}
}
static void enter_callback_e(GtkWidget *widget, GtkWidget *nothing)
{
gchar *entry_text;
int len;
char *vname="<Vector>";
entry_text = gtk_entry_get_text(GTK_ENTRY(entry_a));
DEBUG(printf("Entry contents: %s\n", entry_text));
if(!(len=strlen(entry_text)))
strcpy((entrybox_text_local=(char *)malloc_2(strlen(vname)+1)),vname); /* make consistent with other widgets rather than producing NULL */
else strcpy((entrybox_text_local=(char *)malloc_2(len+1)),entry_text);
gtk_grab_remove(window1);
gtk_widget_destroy(window1);
cleanup_e();
}
static void
read_traces (struct ghw_handler *h)
{
int *list;
int i;
enum ghw_res res;
list = malloc_2((GLOBALS->numfacs + 1) * sizeof (int));
while (1)
{
res = ghw_read_sm_hdr (h, list);
switch (res)
{
case ghw_res_error:
case ghw_res_eof:
free_2(list);
return;
case ghw_res_ok:
case ghw_res_other:
break;
case ghw_res_snapshot:
if (h->snap_time > GLOBALS->max_time)
GLOBALS->max_time = h->snap_time;
/* printf ("Time is "GHWLLD"\n", h->snap_time); */
for (i = 0; i < h->nbr_sigs; i++)
add_history (h, GLOBALS->nxp_ghw_c_1[i], i);
break;
case ghw_res_cycle:
while (1)
{
int sig;
/* printf ("Time is "GHWLLD"\n", h->snap_time); */
if (h->snap_time < LLDescriptor(9223372036854775807))
{
if (h->snap_time > GLOBALS->max_time)
GLOBALS->max_time = h->snap_time;
for (i = 0; (sig = list[i]) != 0; i++)
add_history (h, GLOBALS->nxp_ghw_c_1[sig], sig);
}
res = ghw_read_cycle_next (h);
if (res != 1)
break;
res = ghw_read_cycle_cont (h, list);
if (res < 0)
break;
}
if (res < 0)
break;
res = ghw_read_cycle_end (h);
if (res < 0)
break;
break;
}
}
}
int f_fontname_waves(char *str)
{
DEBUG(printf("f_fontname_signals(\"%s\")\n",str));
if(GLOBALS->fontname_waves) free_2(GLOBALS->fontname_waves);
GLOBALS->fontname_waves=(char *)malloc_2(strlen(str)+1);
strcpy(GLOBALS->fontname_waves,str);
return(0);
}
int f_fontname_logfile(char *str)
{
DEBUG(printf("f_fontname_logfile(\"%s\")\n",str));
if(GLOBALS->fontname_logfile) free_2(GLOBALS->fontname_logfile);
GLOBALS->fontname_logfile=(char *)malloc_2(strlen(str)+1);
strcpy(GLOBALS->fontname_logfile,str);
return(0);
}
static char *build_slisthier(void)
{
struct slist *s;
int len=0;
if(!slistroot)
{
if(slisthier)
{
free_2(slisthier);
}
slisthier_len=0;
slisthier=(char *)malloc_2(1);
*slisthier=0;
return(slisthier);
}
s=slistroot; len=0;
while(s)
{
len+=s->len+(s->next?1:0);
s=s->next;
}
if(slisthier)
{
free_2(slisthier);
}
slisthier=(char *)malloc_2((slisthier_len=len)+1);
s=slistroot; len=0;
while(s)
{
strcpy(slisthier+len,s->str);
len+=s->len;
if(s->next)
{
strcpy(slisthier+len,vcd_hier_delimeter);
len++;
}
s=s->next;
}
return(slisthier);
}
/*
* ae2 callback
*/
static void ae2_callback(uint64_t *tim, unsigned int *facidx, char **value, unsigned int row)
{
struct HistEnt *htemp = histent_calloc();
struct lx2_entry *l2e = &GLOBALS->ae2_lx2_table[*facidx][row];
AE2_FACREF *f = GLOBALS->ae2_fr+(*facidx);
static int busycnt = 0;
busycnt++;
if(busycnt==WAVE_BUSY_ITER)
{
busy_window_refresh();
busycnt = 0;
}
/* fprintf(stderr, "%lld %d %d %s\n", *tim, *facidx, row, *value); */
if(f->length>1)
{
htemp->v.h_vector = (char *)malloc_2(f->length);
memcpy(htemp->v.h_vector, *value, f->length);
}
else
{
switch(**value)
{
case '0': htemp->v.h_val = AN_0; break;
case '1': htemp->v.h_val = AN_1; break;
case 'H':
case 'Z':
case 'z': htemp->v.h_val = AN_Z; break;
default: htemp->v.h_val = AN_X; break;
}
}
if(!GLOBALS->ae2_time_xlate)
{
htemp->time = (*tim);
}
else
{
htemp->time = GLOBALS->ae2_time_xlate[(*tim) - GLOBALS->ae2_start_cyc];
}
if(l2e->histent_head)
{
l2e->histent_curr->next = htemp;
l2e->histent_curr = htemp;
}
else
{
l2e->histent_head = l2e->histent_curr = htemp;
}
l2e->numtrans++;
}
static void
create_facs (struct ghw_handler *h)
{
int i;
struct symchain *sc = GLOBALS->firstnode;
GLOBALS->numfacs = GLOBALS->nbr_sig_ref_ghw_c_1;
GLOBALS->facs=(struct symbol **)malloc_2(GLOBALS->numfacs*sizeof(struct symbol *));
i = 0;
while(sc)
{
GLOBALS->facs[i++] = sc->symbol;
sc = sc->next;
}
for (i = 0; i < h->nbr_sigs; i++)
{
struct Node *n = GLOBALS->nxp_ghw_c_1[i];
if (h->sigs[i].type)
switch (h->sigs[i].type->kind)
{
case ghdl_rtik_type_b2:
if (h->sigs[i].type->en.wkt == ghw_wkt_bit)
{
n->extvals = 0;
break;
}
/* FALLTHROUGH */
case ghdl_rtik_type_e8:
if (GLOBALS->xlat_1164_ghw_c_1 && h->sigs[i].type->en.wkt == ghw_wkt_std_ulogic)
{
n->extvals = 0;
break;
}
/* FALLTHROUGH */
case ghdl_rtik_type_e32:
case ghdl_rtik_type_i32:
case ghdl_rtik_type_i64:
case ghdl_rtik_type_f64:
case ghdl_rtik_type_p32:
case ghdl_rtik_type_p64:
n->extvals = 1;
n->msi = n->lsi = 0;
break;
default:
fprintf (stderr, "ghw:create_facs: unhandled kind %d\n",
h->sigs[i].type->kind);
n->extvals = 0;
}
}
}
static void
set_fac_name (struct ghw_handler *h)
{
if (GLOBALS->fac_name_max_ghw_c_1 == 0)
{
GLOBALS->fac_name_max_ghw_c_1 = 1024;
GLOBALS->fac_name_ghw_c_1 = malloc_2(GLOBALS->fac_name_max_ghw_c_1);
}
GLOBALS->fac_name_len_ghw_c_1 = 3;
memcpy (GLOBALS->fac_name_ghw_c_1, "top", 4);
GLOBALS->last_fac_ghw_c_1 = h->nbr_sigs;
set_fac_name_1 (GLOBALS->treeroot);
}
xl_Tree * xl_insert(char *i, xl_Tree * t, char *trans) {
/* Insert i into the tree t, unless it's already there. */
/* Return a pointer to the resulting tree. */
xl_Tree * n;
int dir;
n = (xl_Tree *) calloc_2(1, sizeof (xl_Tree));
if (n == NULL) {
fprintf(stderr, "xl_insert: ran out of memory, exiting.\n");
exit(255);
}
n->item = strcpy(malloc_2(strlen(i)+1), i);
if(trans) n->trans = strcpy(malloc_2(strlen(trans)+1), trans);
if (t == NULL) {
n->left = n->right = NULL;
return n;
}
t = xl_splay(i,t);
dir = strcasecmp(i,t->item);
if (dir<0) {
n->left = t->left;
n->right = t;
t->left = NULL;
return n;
} else if (dir>0) {
n->right = t->right;
n->left = t;
t->right = NULL;
return n;
} else { /* We get here if it's already in the tree */
/* Don't add it again */
if(n->trans) free_2(n->trans);
free_2(n->item);
free_2(n);
return t;
}
}
/*
* currently only called by parsewavline+tcl
*/
static void set_current_translate_generic(char *name, int typ)
{
int i;
if(typ)
{
for(i=1;i<GLOBALS->num_file_filters+1;i++)
{
if(!strcmp(GLOBALS->filesel_filter[i], name)) { GLOBALS->current_translate_file = i; return; }
}
if(!strcmp(WAVE_TCL_INSTALLED_FILTER, name))
{
GLOBALS->current_translate_file = 0; return;
}
}
if(GLOBALS->num_file_filters < FILE_FILTER_MAX)
{
GLOBALS->num_file_filters++;
if(typ)
{
load_file_filter(GLOBALS->num_file_filters, name);
}
else
{
load_enums_filter(GLOBALS->num_file_filters, name);
}
if(!GLOBALS->xl_file_filter[GLOBALS->num_file_filters])
{
GLOBALS->num_file_filters--;
GLOBALS->current_translate_file = 0;
}
else
{
if(GLOBALS->filesel_filter[GLOBALS->num_file_filters]) free_2(GLOBALS->filesel_filter[GLOBALS->num_file_filters]);
if(!typ)
{
name = WAVE_TCL_INSTALLED_FILTER;
}
GLOBALS->filesel_filter[GLOBALS->num_file_filters] = malloc_2(strlen(name) + 1);
strcpy(GLOBALS->filesel_filter[GLOBALS->num_file_filters], name);
GLOBALS->current_translate_file = GLOBALS->num_file_filters;
}
}
}
static void enter_callback_e(GtkWidget *widget, GtkWidget *nothing)
{
gchar *entry_text;
int len;
entry_text = gtk_entry_get_text(GTK_ENTRY(entry_a));
DEBUG(printf("Entry contents: %s\n", entry_text));
if(!(len=strlen(entry_text))) entrybox_text_local=NULL;
else strcpy((entrybox_text_local=(char *)malloc_2(len+1)),entry_text);
gtk_grab_remove(window1);
gtk_widget_destroy(window1);
cleanup_e();
}
static void add_filter_callback_2(GtkWidget *widget, GtkWidget *nothing)
{
(void)widget;
(void)nothing;
int i;
GtkCList *cl;
if(!GLOBALS->filesel_ok) { return; }
if(*GLOBALS->fileselbox_text)
{
for(i=0;i<GLOBALS->num_file_filters;i++)
{
if(GLOBALS->filesel_filter[i])
{
if(!strcmp(GLOBALS->filesel_filter[i], *GLOBALS->fileselbox_text))
{
status_text("Filter already imported.\n");
if(GLOBALS->is_active_translate_c_5) gdk_window_raise(GLOBALS->window_translate_c_11->window);
return;
}
}
}
}
GLOBALS->num_file_filters++;
load_file_filter(GLOBALS->num_file_filters, *GLOBALS->fileselbox_text);
if(GLOBALS->xl_file_filter[GLOBALS->num_file_filters] && (*GLOBALS->fileselbox_text /* scan-build */))
{
if(GLOBALS->filesel_filter[GLOBALS->num_file_filters]) free_2(GLOBALS->filesel_filter[GLOBALS->num_file_filters]);
GLOBALS->filesel_filter[GLOBALS->num_file_filters] = malloc_2(strlen(*GLOBALS->fileselbox_text) + 1);
strcpy(GLOBALS->filesel_filter[GLOBALS->num_file_filters], *GLOBALS->fileselbox_text);
cl=GTK_CLIST(GLOBALS->clist_translate_c_4);
gtk_clist_freeze(cl);
gtk_clist_append(cl,(gchar **)&(GLOBALS->filesel_filter[GLOBALS->num_file_filters]));
gtk_clist_set_column_width(cl,0,gtk_clist_optimal_column_width(cl,0));
gtk_clist_thaw(cl);
}
else
{
GLOBALS->num_file_filters--;
}
if(GLOBALS->is_active_translate_c_5) gdk_window_raise(GLOBALS->window_translate_c_11->window);
}
static void enter_callback(GtkWidget *widget, GtkWidget *nothing)
{
(void)widget;
(void)nothing;
G_CONST_RETURN gchar *entry_text;
int len;
entry_text = gtk_entry_get_text(GTK_ENTRY(GLOBALS->entry_entry_c_1));
entry_text = entry_text ? entry_text : "";
DEBUG(printf("Entry contents: %s\n", entry_text));
if(!(len=strlen(entry_text))) GLOBALS->entrybox_text=NULL;
else strcpy((GLOBALS->entrybox_text=(char *)malloc_2(len+1)),entry_text);
wave_gtk_grab_remove(GLOBALS->window_entry_c_1);
gtk_widget_destroy(GLOBALS->window_entry_c_1);
GLOBALS->window_entry_c_1 = NULL;
GLOBALS->cleanup_entry_c_1();
}
static void enter_callback(GtkWidget *widget, GtkFileSelection *fw)
{
char *allocbuf;
int alloclen;
allocbuf=gtk_file_selection_get_filename(GTK_FILE_SELECTION(fs));
if((alloclen=strlen(allocbuf)))
{
filesel_ok=1;
if(*fileselbox_text) free_2(*fileselbox_text);
*fileselbox_text=(char *)malloc_2(alloclen+1);
strcpy(*fileselbox_text, allocbuf);
}
DEBUG(printf("Filesel OK %s\n",allocbuf));
gtk_grab_remove(fs);
gtk_widget_destroy(fs);
cleanup();
}
void order_facs_from_treesort(struct tree *t, void *v)
{
struct symbol ***f = (struct symbol ***)v; /* eliminate compiler warning in tree.h as symbol.h refs tree.h */
GLOBALS->facs2_tree_c_1=(struct symbol **)malloc_2(GLOBALS->numfacs*sizeof(struct symbol *));
GLOBALS->facs2_pos_tree_c_1 = GLOBALS->numfacs-1;
order_facs_from_treesort_2(t);
if(GLOBALS->facs2_pos_tree_c_1>=0)
{
fprintf(stderr, "Internal Error: GLOBALS->facs2_pos_tree_c_1 = %d\n",GLOBALS->facs2_pos_tree_c_1);
fprintf(stderr, "[This is usually the result of multiply defined facilities.]\n");
exit(255);
}
free_2(*f);
*f = GLOBALS->facs2_tree_c_1;
GLOBALS->facs2_tree_c_1 = NULL;
}
void append_vcd_slisthier(char *str)
{
struct slist *s;
s=(struct slist *)calloc_2(1,sizeof(struct slist));
s->len=strlen(str);
s->str=(char *)malloc_2(s->len+1);
strcpy(s->str,str);
if(slistcurr)
{
slistcurr->next=s;
slistcurr=s;
}
else
{
slistcurr=slistroot=s;
}
build_slisthier();
DEBUG(fprintf(stderr, "SCOPE: %s\n",slisthier));
}
static void load_proc_filter(int which, char *name)
{
FILE *stream;
char *cmd;
char exec_name[1025];
char abs_path [1025];
char* arg, end;
int result;
exec_name[0] = 0;
abs_path[0] = 0;
/* if name has arguments grab only the first word (the name of the executable)*/
sscanf(name, "%s ", exec_name);
arg = name + strlen(exec_name);
/* remove leading spaces from argument */
while (isspace((int)(unsigned char)arg[0])) {
arg++;
}
/* remove trailing spaces from argument */
if (strlen(arg) > 0) {
end = strlen(arg) - 1;
while (arg[(int)end] == ' ') {
arg[(int)end] = 0;
end--;
}
}
/* turn the exec_name into an absolute path */
#if !defined __MINGW32__ && !defined _MSC_VER
cmd = (char *)malloc_2(strlen(exec_name)+6+1);
sprintf(cmd, "which %s", exec_name);
stream = popen(cmd, "r");
result = fscanf(stream, "%s", abs_path);
if((strlen(abs_path) == 0)||(!result))
{
status_text("Could not find filter process!\n");
return;
}
pclose(stream);
free_2(cmd);
#else
strcpy(abs_path, exec_name);
#endif
/* remove_proc_filter(which, 0); ... should never happen from GUI, but perhaps possible from save files or other weirdness */
if(!GLOBALS->ttrans_filter[which])
{
GLOBALS->proc_filter[which] = pipeio_create(abs_path, arg);
}
}
static void parse_valuechange(void)
{
struct vcdsymbol *v;
char *vector;
int vlen;
switch(yytext[0])
{
case '0':
case '1':
case 'x': case 'X':
case 'z': case 'Z':
case 'h': case 'H':
case 'u': case 'U':
case 'w': case 'W':
case 'l': case 'L':
case '-':
if(yylen>1)
{
v=bsearch_vcd(yytext+1, yylen-1);
if(!v)
{
fprintf(stderr,"Near line %d, Unknown VCD identifier: '%s'\n",vcdlineno,yytext+1);
}
else
{
if(v->vartype!=V_EVENT)
{
char vl[2];
vl[0]=yytext[0]; vl[1]=0;
lxt2_wr_emit_value_bit_string(lt, v->ltsym, 0, vl);
v->value[0]=yytext[0];
DEBUG(fprintf(stderr,"%s = '%c'\n",v->name,v->value[0]));
add_histent(current_time,v->narray[0],v->value[0],1, NULL);
}
else
{
char vl[2];
v->value[0]=(dumping_off)?'x':'1'; /* only '1' is relevant */
if(current_time!=(v->ev->last_event_time+1))
{
/* dump degating event */
DEBUG(fprintf(stderr,"#"TTFormat" %s = '%c' (event)\n",v->ev->last_event_time+1,v->name,'0'));
add_histent(v->ev->last_event_time+1,v->narray[0],'0',1, NULL);
}
DEBUG(fprintf(stderr,"%s = '%c' (event)\n",v->name,v->value[0]));
add_histent(current_time,v->narray[0],v->value[0],1, NULL);
vl[0]='1'; vl[1]=0;
lxt2_wr_emit_value_bit_string(lt, v->ltsym, 0, vl);
vl[0]='0'; vl[1]=0;
lxt2_wr_emit_value_bit_string(lt, v->ltsym, 0, vl);
v->ev->last_event_time=current_time;
}
}
}
else
{
fprintf(stderr,"Near line %d, Malformed VCD identifier\n", vcdlineno);
}
break;
case 'b':
case 'B':
/* extract binary number then.. */
vector=malloc_2(yylen_cache=yylen);
strcpy(vector,yytext+1);
vlen=yylen-1;
get_strtoken();
v=bsearch_vcd(yytext, yylen);
if(!v)
{
fprintf(stderr,"Near line %d, Unknown identifier: '%s'\n",vcdlineno, yytext);
free_2(vector);
}
else
{
if(vlen<v->size) /* fill in left part */
{
char extend;
int i, fill;
extend=(vector[0]=='1')?'0':vector[0];
fill=v->size-vlen;
for(i=0;i<fill;i++)
{
v->value[i]=extend;
}
strcpy(v->value+fill,vector);
}
else if(vlen==v->size) /* straight copy */
{
strcpy(v->value,vector);
}
else /* too big, so copy only right half */
{
int skip;
skip=vlen-v->size;
strcpy(v->value,vector+skip);
}
DEBUG(fprintf(stderr,"%s = '%s'\n",v->name, v->value));
lxt2_wr_emit_value_bit_string(lt, v->ltsym, 0, v->value);
if((v->size==1)||(!atomic_vectors))
{
int i;
for(i=0;i<v->size;i++)
{
add_histent(current_time, v->narray[i],v->value[i],1, NULL);
}
free_2(vector);
}
else
{
if(yylen_cache!=(v->size+1))
{
free_2(vector);
vector=malloc_2(v->size+1);
}
strcpy(vector,v->value);
add_histent(current_time, v->narray[0],0,1,vector);
free_2(vector);
}
}
break;
case 'p':
/* extract port dump value.. */
vector=malloc_2(yylen_cache=yylen);
strcpy(vector,yytext+1);
vlen=yylen-1;
get_strtoken(); /* throw away 0_strength_component */
get_strtoken(); /* throw away 0_strength_component */
get_strtoken(); /* this is the id */
v=bsearch_vcd(yytext, yylen);
if(!v)
{
fprintf(stderr,"Near line %d, Unknown identifier: '%s'\n",vcdlineno, yytext);
free_2(vector);
}
else
{
if(vlen<v->size) /* fill in left part */
{
char extend;
int i, fill;
extend='0';
fill=v->size-vlen;
for(i=0;i<fill;i++)
{
v->value[i]=extend;
}
evcd_strcpy(v->value+fill,vector);
}
else if(vlen==v->size) /* straight copy */
{
evcd_strcpy(v->value,vector);
}
else /* too big, so copy only right half */
{
int skip;
skip=vlen-v->size;
evcd_strcpy(v->value,vector+skip);
}
DEBUG(fprintf(stderr,"%s = '%s'\n",v->name, v->value));
lxt2_wr_emit_value_bit_string(lt, v->ltsym, 0, v->value);
if((v->size==1)||(!atomic_vectors))
{
int i;
for(i=0;i<v->size;i++)
{
add_histent(current_time, v->narray[i],v->value[i],1, NULL);
}
free_2(vector);
}
else
{
if(yylen_cache<v->size)
{
free_2(vector);
vector=malloc_2(v->size+1);
}
strcpy(vector,v->value);
add_histent(current_time, v->narray[0],0,1,vector);
free_2(vector);
}
}
break;
case 'r':
case 'R':
{
double *d;
d=malloc_2(sizeof(double));
*d = 0;
sscanf(yytext+1,"%lg",d);
errno = 0;
get_strtoken();
v=bsearch_vcd(yytext, yylen);
if(!v)
{
fprintf(stderr,"Near line %d, Unknown identifier: '%s'\n",vcdlineno, yytext);
free_2(d);
}
else
{
lxt2_wr_emit_value_double(lt, v->ltsym, 0, *d);
add_histent(current_time, v->narray[0],'g',1,(char *)d);
free_2(d);
}
break;
}
case 's':
case 'S':
{
get_strtoken(); /* simply skip for now */
break;
}
}
}
static int get_vartoken(int match_kw)
{
int ch;
int i, len=0;
if(varsplit)
{
int rc=get_vartoken_patched(match_kw);
if(rc!=V_END) return(rc);
var_prevch=0;
}
if(!var_prevch)
{
for(;;)
{
ch=getch();
if(ch<0) return(V_END);
if((ch==' ')||(ch=='\t')||(ch=='\n')||(ch=='\r')) continue;
break;
}
}
else
{
ch=var_prevch;
var_prevch=0;
}
if(ch=='[') return(V_LB);
if(ch==':') return(V_COLON);
if(ch==']') return(V_RB);
if(ch=='#') /* for MTI System Verilog '$var reg 64 >w #implicit-var###VarElem:ram_di[0.0] [63:0] $end' style declarations */
{ /* debussy simply escapes until the space */
yytext[len++]= '\\';
}
for(yytext[len++]=ch;;yytext[len++]=ch)
{
if(len==T_MAX_STR)
{
yytext=(char *)realloc_2(yytext, (T_MAX_STR=T_MAX_STR*2)+1);
}
ch=getch();
if(ch==' ')
{
if(match_kw) break;
if(getch_peek() == '[')
{
ch = getch();
varsplit=yytext+len; /* keep looping so we get the *last* one */
continue;
}
}
if((ch==' ')||(ch=='\t')||(ch=='\n')||(ch=='\r')||(ch<0)) break;
if((ch=='[')&&(yytext[0]!='\\'))
{
varsplit=yytext+len; /* keep looping so we get the *last* one */
}
else
if(((ch==':')||(ch==']'))&&(!varsplit)&&(yytext[0]!='\\'))
{
var_prevch=ch;
break;
}
}
yytext[len]=0; /* absolute terminator */
if((varsplit)&&(yytext[len-1]==']'))
{
char *vst;
vst=malloc_2(strlen(varsplit)+1);
strcpy(vst, varsplit);
*varsplit=0x00; /* zero out var name at the left bracket */
len=varsplit-yytext;
varsplit=vsplitcurr=vst;
var_prevch=0;
}
else
{
varsplit=NULL;
}
if(match_kw)
for(i=0;i<NUM_VTOKENS;i++)
{
if(!strcmp(yytext,vartypes[i]))
{
return(varenums[i]);
}
}
yylen=len;
return(V_STRING);
}
TimeType vcd_main(char *fname, char *lxname)
{
#ifdef ONLY_NEEDED_FOR_VALGRIND_CLEAN_TEST
struct vcdsymbol *v, *v2;
#endif
vcd_hier_delimeter[0]=hier_delimeter;
errno=0; /* reset in case it's set for some reason */
yytext=(char *)malloc_2(T_MAX_STR+1);
if((strlen(fname)>2)&&(!strcmp(fname+strlen(fname)-3,".gz")))
{
char *str;
int dlen;
dlen=strlen(WAVE_DECOMPRESSOR);
str=(char *)wave_alloca(strlen(fname)+dlen+1);
strcpy(str,WAVE_DECOMPRESSOR);
strcpy(str+dlen,fname);
vcd_handle=popen(str,"r");
vcd_is_compressed=~0;
}
else
{
if(strcmp("-",fname))
{
vcd_handle=fopen(fname,"rb");
}
else
{
vcd_handle=stdin;
}
vcd_is_compressed=0;
}
if(!vcd_handle)
{
fprintf(stderr, "Error opening %s .vcd file '%s'.\n",
vcd_is_compressed?"compressed":"", fname);
exit(1);
}
lt=lxt2_wr_init(lxname);
if(!lt)
{
fprintf(stderr, "Problem opening output file '%s'\n", lxname);
perror("Why");
exit(255);
}
if(opt_partial_mode>=0)
{
lxt2_wr_set_partial_on(lt, opt_partial_mode);
}
if((opt_checkpoint_disable)&&(!opt_break_size))
{
lxt2_wr_set_checkpoint_off(lt);
}
lxt2_wr_set_compression_depth(lt, opt_depth);
lxt2_wr_set_break_size(lt, (off_t)opt_break_size);
lxt2_wr_set_maxgranule(lt, opt_maxgranule);
lxt2_wr_symbol_bracket_stripping(lt, 1); /* this is intentional */
sym=(struct symbol **)calloc_2(SYMPRIME,sizeof(struct symbol *));
printf("\nConverting VCD File '%s' to LXT2 file '%s'...\n\n",(vcd_handle!=stdin)?fname:"from stdin", lxname);
build_slisthier();
vcd_parse();
if(varsplit)
{
free_2(varsplit);
varsplit=NULL;
}
add_tail_histents();
printf("["TTFormat"] start time.\n["TTFormat"] end time.\n\n", start_time, end_time);
lxt2_wr_close(lt);
lt=NULL;
min_time=start_time*time_scale;
max_time=end_time*time_scale;
if((min_time==max_time)||(max_time==0))
{
fprintf(stderr, "VCD times range is equal to zero. Exiting.\n");
exit(1);
}
if(vcd_handle!=stdin)
{
fclose(vcd_handle);
vcd_handle=NULL;
}
free(yytext); yytext=NULL;
if(indexed) { free(indexed); indexed=NULL; }
if(sorted) { free(sorted); sorted=NULL; }
#ifdef ONLY_NEEDED_FOR_VALGRIND_CLEAN_TEST
v=vcdsymroot;
while(v)
{
if(v->name) { free(v->name); v->name=NULL; }
if(v->id) { free(v->id); v->id=NULL; }
if(v->value) { free(v->value); v->value=NULL; }
if(v->narray)
{
int i;
for(i=0;i<v->size;i++)
{
struct HistEnt *h1, *h2;
if((h1 = v->narray[i]->head.next))
{
h1 = v->narray[i]->head.next;
while(h1)
{
h2 = h1->next;
free(h1);
h1 = h2;
}
}
free(v->narray[i]); v->narray[i]=NULL;
}
free(v->narray); v->narray=NULL;
}
v2=v->next;
free(v);
v=v2;
}
vcdsymroot=vcdsymcurr=NULL;
#endif
free(sym); sym=NULL;
if(slisthier) { free(slisthier); slisthier=NULL; }
return(max_time);
}
static void vcd_parse(void)
{
int tok;
for(;;)
{
switch(get_token())
{
case T_COMMENT:
sync_end("COMMENT:");
break;
case T_DATE:
sync_end("DATE:");
break;
case T_VERSION:
sync_end("VERSION:");
break;
case T_TIMEZERO:
{
int vtok=get_token();
if((vtok==T_END)||(vtok==T_EOF)) break;
time_zero=atoi_64(yytext);
lxt2_wr_set_timezero(lt, time_zero);
sync_end(NULL);
}
break;
case T_TIMESCALE:
{
int vtok;
int i;
char prefix=' ';
int timelogadjust = 0;
vtok=get_token();
if((vtok==T_END)||(vtok==T_EOF)) break;
time_scale=atoi_64(yytext);
if(!time_scale) time_scale=1;
else if (time_scale == 10) timelogadjust = +1;
else if (time_scale == 100) timelogadjust = +2;
for(i=0;i<yylen;i++)
{
if((yytext[i]<'0')||(yytext[i]>'9'))
{
prefix=yytext[i];
break;
}
}
if(prefix==' ')
{
vtok=get_token();
if((vtok==T_END)||(vtok==T_EOF)) break;
prefix=yytext[0];
}
switch(prefix)
{
case 's':
case ' ': lxt2_wr_set_timescale(lt, 0+timelogadjust); break;
case 'm': lxt2_wr_set_timescale(lt, -3+timelogadjust); break;
case 'u': lxt2_wr_set_timescale(lt, -6+timelogadjust); break;
case 'n': lxt2_wr_set_timescale(lt, -9+timelogadjust); break;
case 'p': lxt2_wr_set_timescale(lt, -12+timelogadjust); break;
case 'f': lxt2_wr_set_timescale(lt, -15+timelogadjust); break;
default: /* unknown */
lxt2_wr_set_timescale(lt, -9+timelogadjust); break;
}
sync_end(NULL);
}
break;
case T_SCOPE:
T_GET;
T_GET;
if(tok==T_STRING)
{
struct slist *s;
s=(struct slist *)calloc_2(1,sizeof(struct slist));
s->len=yylen;
s->str=(char *)malloc_2(yylen+1);
strcpy(s->str,yytext);
if(slistcurr)
{
slistcurr->next=s;
slistcurr=s;
}
else
{
slistcurr=slistroot=s;
}
build_slisthier();
DEBUG(fprintf(stderr, "SCOPE: %s\n",slisthier));
}
sync_end(NULL);
break;
case T_UPSCOPE:
if(slistroot)
{
struct slist *s;
s=slistroot;
if(!s->next)
{
free_2(s->str);
free_2(s);
slistroot=slistcurr=NULL;
}
else
for(;;)
{
if(!s->next->next)
{
free_2(s->next->str);
free_2(s->next);
s->next=NULL;
slistcurr=s;
break;
}
s=s->next;
}
build_slisthier();
DEBUG(fprintf(stderr, "SCOPE: %s\n",slisthier));
}
sync_end(NULL);
break;
case T_VAR:
{
int vtok;
struct vcdsymbol *v=NULL;
var_prevch=0;
if(varsplit)
{
free_2(varsplit);
varsplit=NULL;
}
vtok=get_vartoken(1);
if(vtok>V_PORT) goto bail;
v=(struct vcdsymbol *)calloc_2(1,sizeof(struct vcdsymbol));
v->vartype=vtok;
v->msi=v->lsi=vcd_explicit_zero_subscripts; /* indicate [un]subscripted status */
if(vtok==V_PORT)
{
vtok=get_vartoken(1);
if(vtok==V_STRING)
{
v->size=atoi_64(yytext);
if(!v->size) v->size=1;
}
else
if(vtok==V_LB)
{
vtok=get_vartoken(1);
if(vtok==V_END) goto err;
if(vtok!=V_STRING) goto err;
v->msi=atoi_64(yytext);
vtok=get_vartoken(0);
if(vtok==V_RB)
{
v->lsi=v->msi;
v->size=1;
}
else
{
if(vtok!=V_COLON) goto err;
vtok=get_vartoken(0);
if(vtok!=V_STRING) goto err;
v->lsi=atoi_64(yytext);
vtok=get_vartoken(0);
if(vtok!=V_RB) goto err;
if(v->msi>v->lsi)
{
v->size=v->msi-v->lsi+1;
}
else
{
v->size=v->lsi-v->msi+1;
}
}
}
else goto err;
vtok=get_strtoken();
if(vtok==V_END) goto err;
v->id=(char *)malloc_2(yylen+1);
strcpy(v->id, yytext);
v->nid=vcdid_hash(yytext,yylen);
if(v->nid < vcd_minid) vcd_minid = v->nid;
if(v->nid > vcd_maxid) vcd_maxid = v->nid;
vtok=get_vartoken(0);
if(vtok!=V_STRING) goto err;
if(slisthier_len)
{
v->name=(char *)malloc_2(slisthier_len+1+yylen+1);
strcpy(v->name,slisthier);
strcpy(v->name+slisthier_len,vcd_hier_delimeter);
strcpy(v->name+slisthier_len+1,yytext);
}
else
{
v->name=(char *)malloc_2(yylen+1);
strcpy(v->name,yytext);
}
}
else /* regular vcd var, not an evcd port var */
{
vtok=get_vartoken(1);
if(vtok==V_END) goto err;
v->size=atoi_64(yytext);
vtok=get_strtoken();
if(vtok==V_END) goto err;
v->id=(char *)malloc_2(yylen+1);
strcpy(v->id, yytext);
v->nid=vcdid_hash(yytext,yylen);
if(v->nid < vcd_minid) vcd_minid = v->nid;
if(v->nid > vcd_maxid) vcd_maxid = v->nid;
vtok=get_vartoken(0);
if(vtok!=V_STRING) goto err;
if(slisthier_len)
{
v->name=(char *)malloc_2(slisthier_len+1+yylen+1);
strcpy(v->name,slisthier);
strcpy(v->name+slisthier_len,vcd_hier_delimeter);
strcpy(v->name+slisthier_len+1,yytext);
}
else
{
v->name=(char *)malloc_2(yylen+1);
strcpy(v->name,yytext);
}
vtok=get_vartoken(1);
if(vtok==V_END) goto dumpv;
if(vtok!=V_LB) goto err;
vtok=get_vartoken(0);
if(vtok!=V_STRING) goto err;
v->msi=atoi_64(yytext);
vtok=get_vartoken(0);
if(vtok==V_RB)
{
v->lsi=v->msi;
goto dumpv;
}
if(vtok!=V_COLON) goto err;
vtok=get_vartoken(0);
if(vtok!=V_STRING) goto err;
v->lsi=atoi_64(yytext);
vtok=get_vartoken(0);
if(vtok!=V_RB) goto err;
}
dumpv:
if(v->size == 0) { v->vartype = V_REAL; } /* MTI fix */
if(v->vartype==V_REAL)
{
v->size=1; /* override any data we parsed in */
v->msi=v->lsi=0;
}
else
if((v->size>1)&&(v->msi<=0)&&(v->lsi<=0))
{
if(v->vartype==V_EVENT)
{
v->size=1;
}
else
{
/* any criteria for the direction here? */
v->msi=v->size-1;
v->lsi=0;
}
}
else
if((v->msi>v->lsi)&&((v->msi-v->lsi+1)!=v->size))
{
if(v->vartype!=V_EVENT) goto err;
v->size=v->msi-v->lsi+1;
}
else
if((v->lsi>=v->msi)&&((v->lsi-v->msi+1)!=v->size))
{
if(v->vartype!=V_EVENT) goto err;
v->size=v->msi-v->lsi+1;
}
/* initial conditions */
v->value=(char *)malloc_2(v->size+1);
v->value[v->size]=0;
v->narray=(struct Node **)calloc_2(v->size,sizeof(struct Node *));
{
int i;
for(i=0;i<v->size;i++)
{
v->value[i]='x';
v->narray[i]=(struct Node *)calloc_2(1,sizeof(struct Node));
v->narray[i]->head.time=-1;
v->narray[i]->head.v.val=1;
}
}
if(v->vartype==V_EVENT)
{
struct queuedevent *q;
v->ev=q=(struct queuedevent *)calloc_2(1,sizeof(struct queuedevent));
q->sym=v;
q->last_event_time=-1;
q->next=queuedevents;
queuedevents=q;
}
if(!vcdsymroot)
{
vcdsymroot=vcdsymcurr=v;
}
else
{
vcdsymcurr->next=v;
vcdsymcurr=v;
}
numsyms++;
#if 0
if((v->vartype==V_INTEGER)||(v->vartype==V_REAL))
{
v->ltsym = lxt2_wr_symbol_add(lt, v->name, 0, v->msi, v->lsi, (v->vartype==V_INTEGER)?LXT2_WR_SYM_F_INTEGER:((v->vartype==V_REAL)?LXT2_WR_SYM_F_DOUBLE:LXT2_WR_SYM_F_BITS));
}
else
{
char buf[65537];
if(v->msi==v->lsi)
{
sprintf(buf, "%s[%d]", v->name, v->msi);
}
else
{
sprintf(buf, "%s[%d:%d]", v->name, v->msi, v->lsi);
}
v->ltsym = lxt2_wr_symbol_add(lt, buf, 0, v->msi, v->lsi, (v->vartype==V_INTEGER)?LXT2_WR_SYM_F_INTEGER:((v->vartype==V_REAL)?LXT2_WR_SYM_F_DOUBLE:LXT2_WR_SYM_F_BITS));
}
#endif
DEBUG(fprintf(stderr,"VAR %s %d %s %s[%d:%d]\n",
vartypes[v->vartype], v->size, v->id, v->name,
v->msi, v->lsi));
goto bail;
err:
if(v)
{
if(v->name) free_2(v->name);
if(v->id) free_2(v->id);
if(v->value) free_2(v->value);
free_2(v);
}
bail:
if(vtok!=V_END) sync_end(NULL);
break;
}
case T_ENDDEFINITIONS:
if(!header_over)
{
header_over=1; /* do symbol table management here */
create_sorted_table();
if((!sorted)&&(!indexed))
{
fprintf(stderr, "No symbols in VCD file..nothing to do!\n");
exit(1);
}
}
break;
case T_STRING:
if(header_over)
{
/* catchall for events when header over */
if(yytext[0]=='#')
{
TimeType t_time;
t_time=atoi_64(yytext+1);
if(start_time<0)
{
start_time=t_time;
}
if(t_time < current_time) /* avoid backtracking time counts which can happen on malformed files */
{
t_time = current_time;
}
current_time=t_time;
if(end_time<t_time) end_time=t_time; /* in case of malformed vcd files */
lxt2_wr_set_time64(lt, current_time);
DEBUG(fprintf(stderr,"#"TTFormat"\n",t_time));
}
else
{
parse_valuechange();
}
}
break;
case T_DUMPALL: /* dump commands modify vals anyway so */
case T_DUMPPORTSALL:
break; /* just loop through.. */
case T_DUMPOFF:
case T_DUMPPORTSOFF:
dumping_off=1;
lxt2_wr_set_dumpoff(lt);
break;
case T_DUMPON:
case T_DUMPPORTSON:
dumping_off=0;
lxt2_wr_set_dumpon(lt);
break;
case T_DUMPVARS:
case T_DUMPPORTS:
if(current_time<0)
{ start_time=current_time=end_time=0; /* lxt2_wr_set_time(lt, current_time); */ }
break;
case T_VCDCLOSE:
sync_end("VCDCLOSE:");
break; /* next token will be '#' time related followed by $end */
case T_END: /* either closure for dump commands or */
break; /* it's spurious */
case T_UNKNOWN_KEY:
sync_end(NULL); /* skip over unknown keywords */
break;
case T_EOF:
return;
default:
DEBUG(fprintf(stderr,"UNKNOWN TOKEN\n"));
}
}
}
static void
add_history (struct ghw_handler *h, struct Node *n, int sig_num)
{
struct HistEnt *he;
struct ghw_sig *sig = &h->sigs[sig_num];
union ghw_type *sig_type = sig->type;
int flags;
int is_vector = 0;
#ifdef WAVE_HAS_H_DOUBLE
int is_double = 0;
#endif
if (sig_type == NULL)
return;
GLOBALS->regions++;
switch (sig_type->kind)
{
case ghdl_rtik_type_b2:
if (sig_type->en.wkt == ghw_wkt_bit)
{
flags = 0;
break;
}
/* FALLTHROUGH */
case ghdl_rtik_type_e8:
if (GLOBALS->xlat_1164_ghw_c_1 && sig_type->en.wkt == ghw_wkt_std_ulogic)
{
flags = 0;
break;
}
/* FALLTHROUGH */
case ghdl_rtik_type_e32:
case ghdl_rtik_type_i32:
case ghdl_rtik_type_i64:
case ghdl_rtik_type_p32:
case ghdl_rtik_type_p64:
flags = HIST_STRING|HIST_REAL;
if (HIST_STRING == 0)
{
if (!GLOBALS->warned_ghw_c_1)
fprintf (stderr, "warning: do not compile with STRICT_VCD\n");
GLOBALS->warned_ghw_c_1 = 1;
return;
}
break;
case ghdl_rtik_type_f64:
flags = HIST_REAL;
break;
default:
fprintf (stderr, "ghw:add_history: unhandled kind %d\n",
sig->type->kind);
return;
}
if(!n->curr)
{
he=histent_calloc();
he->flags = flags;
he->time=-1;
he->v.h_vector=NULL;
n->head.next=he;
n->curr=he;
n->head.time = -2;
}
he=histent_calloc();
he->flags = flags;
he->time=h->snap_time;
switch (sig_type->kind)
{
case ghdl_rtik_type_b2:
if (sig_type->en.wkt == ghw_wkt_bit)
he->v.h_val = sig->val->b2 == 0 ? AN_0 : AN_1;
else
{
he->v.h_vector = (char *)sig->type->en.lits[sig->val->b2];
is_vector = 1;
}
break;
case ghdl_rtik_type_e8:
if (GLOBALS->xlat_1164_ghw_c_1 && sig_type->en.wkt == ghw_wkt_std_ulogic)
{
/* Res: 0->0, 1->X, 2->Z, 3->1 */
static const char map_su2vlg[9] = {
/* U */ AN_U, /* X */ AN_X, /* 0 */ AN_0, /* 1 */ AN_1,
/* Z */ AN_Z, /* W */ AN_W, /* L */ AN_L, /* H */ AN_H,
/* - */ AN_DASH
};
he->v.h_val = map_su2vlg[sig->val->e8];
}
else
{
he->v.h_vector = (char *)sig_type->en.lits[sig->val->e8];
is_vector = 1;
}
break;
case ghdl_rtik_type_f64:
{
#ifdef WAVE_HAS_H_DOUBLE
he->v.h_double = sig->val->f64;
is_double = 1;
#else
double *d = malloc_2(sizeof (double));
*d = sig->val->f64;
he->v.h_vector = (char *)d;
is_vector = 1;
#endif
}
break;
case ghdl_rtik_type_i32:
case ghdl_rtik_type_p32:
sprintf (GLOBALS->asbuf, GHWLD, sig->val->i32);
he->v.h_vector = strdup_2(GLOBALS->asbuf);
is_vector = 1;
break;
case ghdl_rtik_type_i64:
case ghdl_rtik_type_p64:
sprintf (GLOBALS->asbuf, GHWLLD, sig->val->i64);
he->v.h_vector = strdup_2(GLOBALS->asbuf);
is_vector = 1;
break;
default:
abort ();
}
/* deglitch */
if(n->curr->time == he->time)
{
int gl_add = 0;
if(n->curr->time) /* filter out time zero glitches */
{
gl_add = 1;
}
GLOBALS->num_glitches_ghw_c_1 += gl_add;
if(!(n->curr->flags&HIST_GLITCH))
{
if(gl_add)
{
n->curr->flags|=HIST_GLITCH; /* set the glitch flag */
GLOBALS->num_glitch_regions_ghw_c_1++;
}
}
#ifdef WAVE_HAS_H_DOUBLE
if(is_double)
{
n->curr->v.h_double = he->v.h_double;
}
else
#endif
if(is_vector)
{
if(n->curr->v.h_vector &&
sig_type->kind != ghdl_rtik_type_b2 &&
sig_type->kind != ghdl_rtik_type_e8) free_2(n->curr->v.h_vector);
n->curr->v.h_vector = he->v.h_vector;
/* can't free up this "he" because of block allocation so assume it's dead */
}
else
{
n->curr->v.h_val = he->v.h_val;
}
return;
}
else /* look for duplicate dumps of same value at adjacent times */
{
if(!is_vector
#ifdef WAVE_HAS_H_DOUBLE
& !is_double
#endif
)
{
if(n->curr->v.h_val == he->v.h_val)
{
return;
/* can't free up this "he" because of block allocation so assume it's dead */
}
}
}
n->curr->next=he;
n->curr=he;
}
static void treesort_2(struct tree *t, struct tree *p, struct tree ***tm, int *tm_siz)
{
struct tree *it;
struct tree **srt;
int cnt;
int i;
if(t->next)
{
it = t;
cnt = 0;
do {
cnt++;
it=it->next;
} while(it);
if(cnt > *tm_siz)
{
*tm_siz = cnt;
if(*tm) { free_2(*tm); }
*tm = malloc_2((cnt+1) * sizeof(struct tree *));
}
srt = *tm;
for(i=0;i<cnt;i++)
{
srt[i] = t;
t=t->next;
}
srt[i] = NULL;
qsort((void *)srt, cnt, sizeof(struct tree *), tree_qsort_cmp);
if(p)
{
p->child = srt[0];
}
else
{
GLOBALS->treeroot = srt[0];
}
for(i=0;i<cnt;i++)
{
srt[i]->next = srt[i+1];
}
it = srt[0];
for(i=0;i<cnt;i++)
{
if(it->child)
{
treesort_2(it->child, it, tm, tm_siz);
}
it = it->next;
}
}
else if (t->child)
{
treesort_2(t->child, t, tm, tm_siz);
}
}
/*
* mainline
*/
int save_nodes_to_export_generic(FILE *trans_file, Trptr trans_head, const char *fname, int export_typ)
{
Trptr t = trans_head ? trans_head : GLOBALS->traces.first;
int nodecnt = 0;
vcdsav_Tree *vt = NULL;
vcdsav_Tree **hp_clone = GLOBALS->hp_vcd_saver_c_1;
nptr n;
/* ExtNode *e; */
/* int msi, lsi; */
int i;
TimeType prevtime = LLDescriptor(-1);
time_t walltime;
struct strace *st = NULL;
int strace_append = 0;
int max_len = 1;
char *row_data = NULL;
struct lt_trace *lt = NULL;
int lxt = (export_typ == WAVE_EXPORT_LXT);
int is_trans = (export_typ == WAVE_EXPORT_TRANS);
if(export_typ == WAVE_EXPORT_TIM)
{
return(do_timfile_save(fname));
}
errno = 0;
if(lxt)
{
lt = lt_init(fname);
if(!lt)
{
return(VCDSAV_FILE_ERROR);
}
}
else
{
if(export_typ != WAVE_EXPORT_TRANS)
{
GLOBALS->f_vcd_saver_c_1 = fopen(fname, "wb");
}
else
{
if(!trans_head) /* scan-build : is programming error to get here */
{
return(VCDSAV_FILE_ERROR);
}
GLOBALS->f_vcd_saver_c_1 = trans_file;
}
if(!GLOBALS->f_vcd_saver_c_1)
{
return(VCDSAV_FILE_ERROR);
}
}
while(t)
{
if(!t->vector)
{
if(t->n.nd)
{
n = t->n.nd;
if(n->expansion) n = n->expansion->parent;
vt = vcdsav_splay(n, vt);
if(!vt || vt->item != n)
{
unsigned char flags = 0;
if(n->head.next)
if(n->head.next->next)
{
flags = n->head.next->next->flags;
}
vt = vcdsav_insert(n, vt, ++nodecnt, flags, &n->head);
}
}
}
else
{
bvptr b = t->n.vec;
if(b)
{
bptr bt = b->bits;
if(bt)
{
for(i=0;i<bt->nnbits;i++)
{
if(bt->nodes[i])
{
n = bt->nodes[i];
if(n->expansion) n = n->expansion->parent;
vt = vcdsav_splay(n, vt);
if(!vt || vt->item != n)
{
unsigned char flags = 0;
if(n->head.next)
if(n->head.next->next)
{
flags = n->head.next->next->flags;
}
vt = vcdsav_insert(n, vt, ++nodecnt, flags, &n->head);
}
}
}
}
}
}
if(export_typ == WAVE_EXPORT_TRANS)
{
break;
}
if(!strace_append)
{
t=t->t_next;
if(t) continue;
}
else
{
st = st->next;
t = st ? st->trace : NULL;
if(t)
{
continue;
}
else
{
swap_strace_contexts();
}
}
strace_concat:
GLOBALS->strace_ctx = &GLOBALS->strace_windows[GLOBALS->strace_current_window = strace_append];
strace_append++;
if(strace_append == WAVE_NUM_STRACE_WINDOWS) break;
if(!GLOBALS->strace_ctx->shadow_straces)
{
goto strace_concat;
}
swap_strace_contexts();
st = GLOBALS->strace_ctx->straces;
t = st ? st->trace : NULL;
if(!t) {swap_strace_contexts(); goto strace_concat; }
}
if(!nodecnt) return(VCDSAV_EMPTY);
/* header */
if(lxt)
{
int dim;
lt_set_chg_compress(lt);
lt_set_clock_compress(lt);
lt_set_initial_value(lt, 'x');
lt_set_time64(lt, 0);
lt_symbol_bracket_stripping(lt, 1);
switch(GLOBALS->time_dimension)
{
case 'm': dim = -3; break;
case 'u': dim = -6; break;
case 'n': dim = -9; break;
case 'p': dim = -12; break;
case 'f': dim = -15; break;
default: dim = 0; break;
}
lt_set_timescale(lt, dim);
}
else
{
if(export_typ != WAVE_EXPORT_TRANS)
{
time(&walltime);
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$date\n");
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "\t%s",asctime(localtime(&walltime)));
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$end\n");
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$version\n\t"WAVE_VERSION_INFO"\n$end\n");
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$timescale\n\t%d%c%s\n$end\n", (int)GLOBALS->time_scale, GLOBALS->time_dimension, (GLOBALS->time_dimension=='s') ? "" : "s");
if(GLOBALS->global_time_offset) { w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$timezero\n\t"TTFormat"\n$end\n",GLOBALS->global_time_offset); }
}
else
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$comment data_start %p $end\n", (void *)trans_head); /* arbitrary hex identifier */
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$comment name %s $end\n", trans_head->name ? trans_head->name : "UNKNOWN");
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$timescale %d%c%s $end\n", (int)GLOBALS->time_scale, GLOBALS->time_dimension, (GLOBALS->time_dimension=='s') ? "" : "s");
if(GLOBALS->global_time_offset) { w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$timezero "TTFormat" $end\n",GLOBALS->global_time_offset); }
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$comment min_time "TTFormat" $end\n", GLOBALS->min_time / GLOBALS->time_scale);
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$comment max_time "TTFormat" $end\n", GLOBALS->max_time / GLOBALS->time_scale);
}
}
if(export_typ == WAVE_EXPORT_TRANS)
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$comment max_seqn %d $end\n", nodecnt);
if(t && t->transaction_args)
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$comment args \"%s\" $end\n", t->transaction_args);
}
}
/* write out netnames here ... */
hp_clone = GLOBALS->hp_vcd_saver_c_1 = calloc_2(nodecnt, sizeof(vcdsav_Tree *));
recurse_build(vt, &hp_clone);
for(i=0;i<nodecnt;i++)
{
int was_packed = HIER_DEPACK_STATIC;
char *hname = hier_decompress_flagged(GLOBALS->hp_vcd_saver_c_1[i]->item->nname, &was_packed);
char *netname = lxt ? hname : output_hier(is_trans, hname);
if(export_typ == WAVE_EXPORT_TRANS)
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$comment seqn %d %s $end\n", GLOBALS->hp_vcd_saver_c_1[i]->val, hname);
}
if(GLOBALS->hp_vcd_saver_c_1[i]->flags & (HIST_REAL|HIST_STRING))
{
if(lxt)
{
GLOBALS->hp_vcd_saver_c_1[i]->handle.p = lt_symbol_add(lt, netname, 0, 0, 0, GLOBALS->hp_vcd_saver_c_1[i]->flags & HIST_STRING ? LT_SYM_F_STRING : LT_SYM_F_DOUBLE);
}
else
{
const char *typ = (GLOBALS->hp_vcd_saver_c_1[i]->flags & HIST_STRING) ? "string" : "real";
int tlen = (GLOBALS->hp_vcd_saver_c_1[i]->flags & HIST_STRING) ? 0 : 1;
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$var %s %d %s %s $end\n", typ, tlen, vcdid(GLOBALS->hp_vcd_saver_c_1[i]->val, export_typ), netname);
}
}
else
{
int msi = -1, lsi = -1;
if(GLOBALS->hp_vcd_saver_c_1[i]->item->extvals)
{
msi = GLOBALS->hp_vcd_saver_c_1[i]->item->msi;
lsi = GLOBALS->hp_vcd_saver_c_1[i]->item->lsi;
}
if(msi==lsi)
{
if(lxt)
{
int strand_idx = strand_pnt(netname);
if(strand_idx >= 0)
{
msi = lsi = atoi(netname + strand_idx + 1);
}
GLOBALS->hp_vcd_saver_c_1[i]->handle.p = lt_symbol_add(lt, netname, 0, msi, lsi, LT_SYM_F_BITS);
}
else
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$var wire 1 %s %s $end\n", vcdid(GLOBALS->hp_vcd_saver_c_1[i]->val, export_typ), netname);
}
}
else
{
int len = (msi < lsi) ? (lsi - msi + 1) : (msi - lsi + 1);
if(lxt)
{
GLOBALS->hp_vcd_saver_c_1[i]->handle.p = lt_symbol_add(lt, netname, 0, msi, lsi, LT_SYM_F_BITS);
}
else
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$var wire %d %s %s $end\n", len, vcdid(GLOBALS->hp_vcd_saver_c_1[i]->val, export_typ), netname);
}
GLOBALS->hp_vcd_saver_c_1[i]->len = len;
if(len > max_len) max_len = len;
}
}
/* if(was_packed) { free_2(hname); } ...not needed for HIER_DEPACK_STATIC */
}
row_data = malloc_2(max_len + 1);
if(!lxt)
{
output_hier(is_trans, "");
free_hier();
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$enddefinitions $end\n");
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$dumpvars\n");
}
/* value changes */
for(i=(nodecnt/2-1);i>0;i--) /* build nodes into having heap property */
{
heapify(i,nodecnt);
}
for(;;)
{
heapify(0, nodecnt);
if(!GLOBALS->hp_vcd_saver_c_1[0]->hist) break;
if(GLOBALS->hp_vcd_saver_c_1[0]->hist->time > GLOBALS->max_time) break;
if((GLOBALS->hp_vcd_saver_c_1[0]->hist->time != prevtime) && (GLOBALS->hp_vcd_saver_c_1[0]->hist->time >= LLDescriptor(0)))
{
TimeType tnorm = GLOBALS->hp_vcd_saver_c_1[0]->hist->time;
if(GLOBALS->time_scale != 1)
{
tnorm /= GLOBALS->time_scale;
}
if(lxt)
{
lt_set_time64(lt, tnorm);
}
else
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "#"TTFormat"\n", tnorm);
}
prevtime = GLOBALS->hp_vcd_saver_c_1[0]->hist->time;
}
if(GLOBALS->hp_vcd_saver_c_1[0]->hist->time >= LLDescriptor(0))
{
if(GLOBALS->hp_vcd_saver_c_1[0]->flags & (HIST_REAL|HIST_STRING))
{
if(GLOBALS->hp_vcd_saver_c_1[0]->flags & HIST_STRING)
{
char *vec = GLOBALS->hp_vcd_saver_c_1[0]->hist->v.h_vector ? GLOBALS->hp_vcd_saver_c_1[0]->hist->v.h_vector : "UNDEF";
if(lxt)
{
lt_emit_value_string(lt, GLOBALS->hp_vcd_saver_c_1[0]->handle.p, 0, vec);
}
else
{
int vec_slen = strlen(vec);
char *vec_escaped = malloc_2(vec_slen*4 + 1); /* worst case */
int vlen = fstUtilityBinToEsc((unsigned char *)vec_escaped, (unsigned char *)vec, vec_slen);
vec_escaped[vlen] = 0;
if(vlen)
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "s%s %s\n", vec_escaped, vcdid(GLOBALS->hp_vcd_saver_c_1[0]->val, export_typ));
}
else
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "s\\000 %s\n", vcdid(GLOBALS->hp_vcd_saver_c_1[0]->val, export_typ));
}
free_2(vec_escaped);
}
}
else
{
#ifdef WAVE_HAS_H_DOUBLE
double *d = &GLOBALS->hp_vcd_saver_c_1[0]->hist->v.h_double;
#else
double *d = (double *)GLOBALS->hp_vcd_saver_c_1[0]->hist->v.h_vector;
#endif
double value;
if(!d)
{
sscanf("NaN", "%lg", &value);
}
else
{
value = *d;
}
if(lxt)
{
lt_emit_value_double(lt, GLOBALS->hp_vcd_saver_c_1[0]->handle.p, 0, value);
}
else
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "r%.16g %s\n", value, vcdid(GLOBALS->hp_vcd_saver_c_1[0]->val, export_typ));
}
}
}
else
if(GLOBALS->hp_vcd_saver_c_1[0]->len)
{
if(GLOBALS->hp_vcd_saver_c_1[0]->hist->v.h_vector)
{
for(i=0;i<GLOBALS->hp_vcd_saver_c_1[0]->len;i++)
{
row_data[i] = analyzer_demang(lxt, GLOBALS->hp_vcd_saver_c_1[0]->hist->v.h_vector[i]);
}
}
else
{
for(i=0;i<GLOBALS->hp_vcd_saver_c_1[0]->len;i++)
{
row_data[i] = 'x';
}
}
row_data[i] = 0;
if(lxt)
{
lt_emit_value_bit_string(lt, GLOBALS->hp_vcd_saver_c_1[0]->handle.p, 0, row_data);
}
else
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "b%s %s\n", vcd_truncate_bitvec(row_data), vcdid(GLOBALS->hp_vcd_saver_c_1[0]->val, export_typ));
}
}
else
{
if(lxt)
{
row_data[0] = analyzer_demang(lxt, GLOBALS->hp_vcd_saver_c_1[0]->hist->v.h_val);
row_data[1] = 0;
lt_emit_value_bit_string(lt, GLOBALS->hp_vcd_saver_c_1[0]->handle.p, 0, row_data);
}
else
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "%c%s\n", analyzer_demang(lxt, GLOBALS->hp_vcd_saver_c_1[0]->hist->v.h_val), vcdid(GLOBALS->hp_vcd_saver_c_1[0]->val, export_typ));
}
}
}
GLOBALS->hp_vcd_saver_c_1[0]->hist = GLOBALS->hp_vcd_saver_c_1[0]->hist->next;
}
if(prevtime < GLOBALS->max_time)
{
if(lxt)
{
lt_set_time64(lt, GLOBALS->max_time / GLOBALS->time_scale);
}
else
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "#"TTFormat"\n", GLOBALS->max_time / GLOBALS->time_scale);
}
}
for(i=0;i<nodecnt;i++)
{
free_2(GLOBALS->hp_vcd_saver_c_1[i]);
}
free_2(GLOBALS->hp_vcd_saver_c_1); GLOBALS->hp_vcd_saver_c_1 = NULL;
free_2(row_data); row_data = NULL;
if(lxt)
{
lt_close(lt); lt = NULL;
}
else
{
if(export_typ != WAVE_EXPORT_TRANS)
{
fclose(GLOBALS->f_vcd_saver_c_1);
}
else
{
w32redirect_fprintf(is_trans, GLOBALS->f_vcd_saver_c_1, "$comment data_end %p $end\n", (void *)trans_head); /* arbitrary hex identifier */
#if !defined _MSC_VER && !defined __MINGW32__
fflush(GLOBALS->f_vcd_saver_c_1);
#endif
}
GLOBALS->f_vcd_saver_c_1 = NULL;
}
return(VCDSAV_OK);
}
TimeType
ghw_main(char *fname)
{
struct ghw_handler handle;
int i;
int rc;
if(!GLOBALS->hier_was_explicitly_set) /* set default hierarchy split char */
{
GLOBALS->hier_delimeter='.';
}
handle.flag_verbose = 0;
if ((rc=ghw_open (&handle, fname)) < 0)
{
fprintf (stderr, "Error opening ghw file '%s', rc=%d.\n", fname, rc);
return(LLDescriptor(0)); /* look at return code in caller for success status... */
}
GLOBALS->time_scale = 1;
GLOBALS->time_dimension = 'f';
GLOBALS->asbuf = malloc_2(4097);
if (ghw_read_base (&handle) < 0)
{
free_2(GLOBALS->asbuf);
GLOBALS->asbuf = NULL;
fprintf (stderr, "Error in ghw file '%s'.\n", fname);
return(LLDescriptor(0)); /* look at return code in caller for success status... */
}
GLOBALS->min_time = 0;
GLOBALS->max_time = 0;
GLOBALS->nbr_sig_ref_ghw_c_1 = 0;
GLOBALS->nxp_ghw_c_1 =(struct Node **)calloc_2(handle.nbr_sigs, sizeof(struct Node *));
for(i=0;i<handle.nbr_sigs;i++)
{
GLOBALS->nxp_ghw_c_1[i] = (struct Node *)calloc_2(1,sizeof(struct Node));
}
GLOBALS->treeroot = build_hierarchy (&handle, handle.hie);
/* GHW does not contains a 'top' name.
FIXME: should use basename of the file. */
create_facs (&handle);
read_traces (&handle);
add_tail (&handle);
set_fac_name (&handle);
free_2(GLOBALS->nxp_ghw_c_1); GLOBALS->nxp_ghw_c_1 = NULL;
/* fix up names on aliased nodes via cloning... */
for(i=0;i<GLOBALS->numfacs;i++)
{
if(strcmp(GLOBALS->facs[i]->name, GLOBALS->facs[i]->n->nname))
{
struct Node *n = malloc_2(sizeof(struct Node));
memcpy(n, GLOBALS->facs[i]->n, sizeof(struct Node));
GLOBALS->facs[i]->n = n;
n->nname = GLOBALS->facs[i]->name;
}
}
/* treeroot->name = "top"; */
{
const char *base_hier = "top";
struct tree *t = calloc_2(1, sizeof(struct tree) + strlen(base_hier) + 1);
memcpy(t, GLOBALS->treeroot, sizeof(struct tree));
strcpy(t->name, base_hier); /* scan-build false warning here, thinks name[1] is total length */
#ifndef WAVE_TALLOC_POOL_SIZE
free_2(GLOBALS->treeroot); /* if using tree alloc pool, can't deallocate this */
#endif
GLOBALS->treeroot = t;
}
ghw_close (&handle);
rechain_facs(); /* vectorize bitblasted nets */
ghw_sortfacs(); /* sort nets as ghw is unsorted ... also fix hier tree (it should really be built *after* facs are sorted!) */
#if 0
treedebug(GLOBALS->treeroot,"");
facs_debug();
#endif
GLOBALS->is_ghw = 1;
fprintf(stderr, "["TTFormat"] start time.\n["TTFormat"] end time.\n", GLOBALS->min_time*GLOBALS->time_scale, GLOBALS->max_time*GLOBALS->time_scale);
if(GLOBALS->num_glitches_ghw_c_1) fprintf(stderr, "Warning: encountered %d glitch%s across %d glitch region%s.\n",
GLOBALS->num_glitches_ghw_c_1, (GLOBALS->num_glitches_ghw_c_1!=1)?"es":"",
GLOBALS->num_glitch_regions_ghw_c_1, (GLOBALS->num_glitch_regions_ghw_c_1!=1)?"s":"");
return GLOBALS->max_time;
}
static void
pdf_print_cleanup(GtkWidget *widget, gpointer data)
{
FILE *wave;
FILE *wave2;
if(GLOBALS->filesel_ok)
{
DEBUG(printf("PDF Print Fini: %s\n", *GLOBALS->fileselbox_text));
if(!(wave=fopen(*GLOBALS->fileselbox_text,"wb")))
{
fprintf(stderr, "Error opening PDF output file '%s' for writing.\n",*GLOBALS->fileselbox_text);
perror("Why");
errno=0;
}
else
{
int len = strlen(*GLOBALS->fileselbox_text) ;
char *zname = malloc_2(len + 4);
strcpy(zname, *GLOBALS->fileselbox_text);
#ifdef MAC_INTEGRATION
if((len > 4)&&(!strcmp(".pdf", zname+len-4)))
{
zname[len-4] = 0;
len-=4;
}
#endif
strcpy(zname+len, ".ps");
if(!(wave2=fopen(zname,"wb")))
{
fprintf(stderr, "Error opening PS output tempfile '%s' for writing.\n",zname);
perror("Why");
fclose(wave);
unlink(*GLOBALS->fileselbox_text);
errno=0;
}
else
{
char *sysname = malloc_2(7 + 1 + len + 3 + 1 + len + 1);
int rc;
#ifdef MAC_INTEGRATION
sprintf(sysname, "pstopdf" /* 7 */
#else
sprintf(sysname, "ps2pdf" /* 6 */
#endif
" " /* 1 */
"%s" /* len + 3 */
" " /* 1 */
"%s" /* len */
, zname, *GLOBALS->fileselbox_text);
print_ps_image(wave2,px[GLOBALS->page_size_type_renderopt_c_1],py[GLOBALS->page_size_type_renderopt_c_1]);
fclose(wave2);
fclose(wave);
rc = system(sysname);
if(rc)
{
printf("GTKWAVE | ERROR: rc for '%s' = %d\n", sysname, rc);
unlink(*GLOBALS->fileselbox_text);
}
free_2(sysname);
unlink(zname);
}
free_2(zname);
}
}
