luke
/
iverilog
mirror of https://github.com/steveicarus/iverilog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
iverilog/ivtest/src/vcd.c

1986 lines
41 KiB
C
Raw Blame History

/*
* Copyright (c) Tony Bybell 1999-2000.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*/
/*
* vcd.c 23jan99ajb
* evcd parts 29jun99ajb
* profiler optimizations 15jul99ajb
* more profiler optimizations 25jan00ajb
* finsim parameter fix 26jan00ajb
* vector rechaining code 03apr00ajb
* multiple var section code 06apr00ajb
* stripped from gtkwave 09apr00ajb
*/
#include "vcd.h"
#undef VCD_BSEARCH_IS_PERFECT /* bsearch is imperfect under linux, but OK under AIX */
/******************************************************************/
static void add_histent(struct globals *obj, TimeType time, struct Node *n, char ch, int regadd, char *vector);
static void add_tail_histents(struct globals *obj);
static void vcd_build_symbols(struct globals *obj);
static void vcd_cleanup(struct globals *obj);
static void evcd_strcpy(char *dst, char *src);
/******************************************************************/
enum Tokens { T_VAR, T_END, T_SCOPE, T_UPSCOPE,
T_COMMENT, T_DATE, T_DUMPALL, T_DUMPOFF, T_DUMPON,
T_DUMPVARS, T_ENDDEFINITIONS,
T_DUMPPORTS, T_DUMPPORTSOFF, T_DUMPPORTSON, T_DUMPPORTSALL,
T_TIMESCALE, T_VERSION, T_VCDCLOSE,
T_EOF, T_STRING, T_UNKNOWN_KEY };
char *tokens[]={ "var", "end", "scope", "upscope",
"comment", "date", "dumpall", "dumpoff", "dumpon",
"dumpvars", "enddefinitions",
"dumpports", "dumpportsoff", "dumpportson", "dumpportsall",
"timescale", "version", "vcdclose",
"", "", "" };
#define NUM_TOKENS 18
#define T_GET(x) tok=get_token(x);if((tok==T_END)||(tok==T_EOF))break;
/******************************************************************/
enum VarTypes { V_EVENT, V_PARAMETER,
V_INTEGER, V_REAL, V_REG, V_SUPPLY0,
V_SUPPLY1, V_TIME, V_TRI, V_TRIAND, V_TRIOR,
V_TRIREG, V_TRI0, V_TRI1, V_WAND, V_WIRE, V_WOR, V_PORT,
V_END, V_LB, V_COLON, V_RB, V_STRING };
char *vartypes[]={ "event", "parameter",
"integer", "real", "reg", "supply0",
"supply1", "time", "tri", "triand", "trior",
"trireg", "tri0", "tri1", "wand", "wire", "wor", "port",
"$end", "", "", "", ""};
#define NUM_VTOKENS 19
/******************************************************************/
/*
* histent structs are NEVER freed so this is OK..
*/
#define VCD_HISTENT_GRANULARITY 100
static struct HistEnt *histent_calloc(struct globals *obj)
{
if(obj->he_curr==obj->he_fini)
{
obj->he_curr=(struct HistEnt *)calloc_2(VCD_HISTENT_GRANULARITY, sizeof(struct HistEnt));
obj->he_fini=obj->he_curr+VCD_HISTENT_GRANULARITY;
}
return(obj->he_curr++);
}
/******************************************************************/
static struct queuedevent *queuedevents=NULL;
/******************************************************************/
/*
* bsearch compare
*/
static int vcdsymbsearchcompare(const void *s1, const void *s2)
{
char *v1;
struct vcdsymbol *v2;
v1=(char *)s1;
v2=*((struct vcdsymbol **)s2);
return(strcmp(v1, v2->id));
}
/*
* actual bsearch
*/
static struct vcdsymbol *bsearch_vcd(struct globals *obj, char *key)
{
struct vcdsymbol **v;
struct vcdsymbol *t;
v=(struct vcdsymbol **)bsearch(key, obj->sorted, obj->numsyms,
sizeof(struct vcdsymbol *), vcdsymbsearchcompare);
if(v)
{
#ifndef VCD_BSEARCH_IS_PERFECT
for(;;)
{
t=*v;
if((v==obj->sorted)||(strcmp((*(--v))->id, key)))
{
return(t);
}
}
#else
return(*v);
#endif
}
else
{
return(NULL);
}
}
/*
* sort on vcdsymbol pointers
*/
static int vcdsymcompare(const void *s1, const void *s2)
{
struct vcdsymbol *v1, *v2;
v1=*((struct vcdsymbol **)s1);
v2=*((struct vcdsymbol **)s2);
return(strcmp(v1->id, v2->id));
}
/*
* create sorted (by id) table
*/
static void create_sorted_table(struct globals *obj)
{
struct vcdsymbol *v;
struct vcdsymbol **pnt;
if(obj->sorted)
{
free_2(obj->sorted); /* this means we saw a 2nd enddefinition chunk! */
}
if(obj->numsyms)
{
pnt=obj->sorted=(struct vcdsymbol **)calloc_2(obj->numsyms, sizeof(struct vcdsymbol *));
v=obj->vcdsymroot;
while(v)
{
*(pnt++)=v;
v=v->next;
}
qsort(obj->sorted, obj->numsyms, sizeof(struct vcdsymbol *), vcdsymcompare);
}
}
/******************************************************************/
/*
* single char get inlined/optimized
*/
static void getch_alloc(struct globals *obj)
{
obj->vend=obj->vst=obj->vcdbuf=(char *)calloc_2(1,VCD_BSIZ);
}
static void getch_free(struct globals *obj)
{
free_2(obj->vcdbuf);
obj->vcdbuf=obj->vst=obj->vend=NULL;
}
static int getch_fetch(struct globals *obj)
{
size_t rd;
if(feof(obj->vcd_handle)||errno) return(-1);
obj->vcdbyteno+=(obj->vend-obj->vcdbuf);
rd=fread(obj->vcdbuf, sizeof(char), VCD_BSIZ, obj->vcd_handle);
obj->vend=(obj->vst=obj->vcdbuf)+rd;
if(!rd) return(-1);
return((int)(*(obj->vst++)));
}
#define getch(x) ((x->vst!=x->vend)?((int)(*(x->vst++))):(getch_fetch(x)))
static int getch_patched(struct globals *obj)
{
char ch;
ch=*obj->vsplitcurr;
if(!ch)
{
return(-1);
}
else
{
obj->vsplitcurr++;
return((int)ch);
}
}
/*
* simple tokenizer
*/
static int get_token(struct globals *obj)
{
int ch;
int i, len=0;
int is_string=0;
for(;;)
{
ch=getch(obj);
if(ch<0) return(T_EOF);
if(ch<=' ') continue; /* val<=' ' is a quick whitespace check */
break; /* (take advantage of fact that vcd is text) */
}
if(ch=='$')
{
obj->yytext[len++]=ch;
for(;;)
{
ch=getch(obj);
if(ch<0) return(T_EOF);
if(ch<=' ') continue;
break;
}
}
else
{
is_string=1;
}
for(obj->yytext[len++]=ch;;obj->yytext[len++]=ch)
{
if(len==obj->T_MAX_STR)
{
obj->yytext=(char *)realloc_2(obj->yytext, (obj->T_MAX_STR=obj->T_MAX_STR*2)+1);
}
ch=getch(obj);
if(ch<=' ') break;
}
obj->yytext[len]=0; /* terminator */
if(is_string)
{
obj->yylen=len;
return(T_STRING);
}
for(i=0;i<NUM_TOKENS;i++)
{
if(!strcmp(obj->yytext+1,tokens[i]))
{
return(i);
}
}
return(T_UNKNOWN_KEY);
}
static int get_vartoken_patched(struct globals *obj)
{
int ch;
int i, len=0;
if(!obj->var_prevch)
{
for(;;)
{
ch=getch_patched(obj);
if(ch<0) { free_2(obj->varsplit); obj->varsplit=NULL; return(V_END); }
if((ch==' ')||(ch=='\t')||(ch=='\n')||(ch=='\r')) continue;
break;
}
}
else
{
ch=obj->var_prevch;
obj->var_prevch=0;
}
if(ch=='[') return(V_LB);
if(ch==':') return(V_COLON);
if(ch==']') return(V_RB);
for(obj->yytext[len++]=ch;;obj->yytext[len++]=ch)
{
if(len==obj->T_MAX_STR)
{
obj->yytext=(char *)realloc_2(obj->yytext, (obj->T_MAX_STR=obj->T_MAX_STR*2)+1);
}
ch=getch_patched(obj);
if(ch<0) break;
if((ch==':')||(ch==']'))
{
obj->var_prevch=ch;
break;
}
}
obj->yytext[len]=0; /* terminator */
for(i=0;i<NUM_VTOKENS;i++)
{
if(!strcmp(obj->yytext,vartypes[i]))
{
if(ch<0) { free_2(obj->varsplit); obj->varsplit=NULL; }
return(i);
}
}
obj->yylen=len;
if(ch<0) { free_2(obj->varsplit); obj->varsplit=NULL; }
return(V_STRING);
}
static int get_vartoken(struct globals *obj)
{
int ch;
int i, len=0;
if(obj->varsplit)
{
int rc=get_vartoken_patched(obj);
if(rc!=V_END) return(rc);
obj->var_prevch=0;
}
if(!obj->var_prevch)
{
for(;;)
{
ch=getch(obj);
if(ch<0) return(V_END);
if((ch==' ')||(ch=='\t')||(ch=='\n')||(ch=='\r')) continue;
break;
}
}
else
{
ch=obj->var_prevch;
obj->var_prevch=0;
}
if(ch=='[') return(V_LB);
if(ch==':') return(V_COLON);
if(ch==']') return(V_RB);
for(obj->yytext[len++]=ch;;obj->yytext[len++]=ch)
{
if(len==obj->T_MAX_STR)
{
obj->yytext=(char *)realloc_2(obj->yytext, (obj->T_MAX_STR=obj->T_MAX_STR*2)+1);
}
ch=getch(obj);
if((ch==' ')||(ch=='\t')||(ch=='\n')||(ch=='\r')||(ch<0)) break;
if((ch=='[')&&(obj->yytext[0]!='\\'))
{
obj->varsplit=obj->yytext+len; /* keep looping so we get the *last* one */
}
else
if(((ch==':')||(ch==']'))&&(!obj->varsplit)&&(obj->yytext[0]!='\\'))
{
obj->var_prevch=ch;
break;
}
}
obj->yytext[len]=0; /* absolute terminator */
if((obj->varsplit)&&(obj->yytext[len-1]==']'))
{
char *vst;
vst=malloc_2(strlen(obj->varsplit)+1);
strcpy(vst, obj->varsplit);
*obj->varsplit=0x00; /* zero out var name at the left bracket */
len=obj->varsplit-obj->yytext;
obj->varsplit=obj->vsplitcurr=vst;
obj->var_prevch=0;
}
else
{
obj->varsplit=NULL;
}
for(i=0;i<NUM_VTOKENS;i++)
{
if(!strcmp(obj->yytext,vartypes[i]))
{
return(i);
}
}
obj->yylen=len;
return(V_STRING);
}
static int get_strtoken(struct globals *obj)
{
int ch;
int len=0;
if(!obj->var_prevch)
{
for(;;)
{
ch=getch(obj);
if(ch<0) return(V_END);
if((ch==' ')||(ch=='\t')||(ch=='\n')||(ch=='\r')) continue;
break;
}
}
else
{
ch=obj->var_prevch;
obj->var_prevch=0;
}
for(obj->yytext[len++]=ch;;obj->yytext[len++]=ch)
{
if(len==obj->T_MAX_STR)
{
obj->yytext=(char *)realloc_2(obj->yytext, (obj->T_MAX_STR=obj->T_MAX_STR*2)+1);
}
ch=getch(obj);
if((ch==' ')||(ch=='\t')||(ch=='\n')||(ch=='\r')||(ch<0)) break;
}
obj->yytext[len]=0; /* terminator */
obj->yylen=len;
return(V_STRING);
}
static void sync_end(struct globals *obj, char *hdr)
{
int tok;
if(hdr) DEBUG(fprintf(stderr,"%s",hdr));
for(;;)
{
tok=get_token(obj);
if((tok==T_END)||(tok==T_EOF)) break;
if(hdr)DEBUG(fprintf(stderr," %s",yytext));
}
if(hdr) DEBUG(fprintf(stderr,"\n"));
}
static char *build_slisthier(struct globals *obj)
{
struct slist *s;
int len=0;
if(!obj->slistroot)
{
if(obj->slisthier)
{
free_2(obj->slisthier);
}
obj->slisthier_len=0;
obj->slisthier=(char *)malloc_2(1);
*obj->slisthier=0;
return(obj->slisthier);
}
s=obj->slistroot; len=0;
while(s)
{
len+=s->len+(s->next?1:0);
s=s->next;
}
obj->slisthier=(char *)malloc_2((obj->slisthier_len=len)+1);
s=obj->slistroot; len=0;
while(s)
{
strcpy(obj->slisthier+len,s->str);
len+=s->len;
if(s->next)
{
strcpy(obj->slisthier+len,obj->vcd_hier_delimeter);
len++;
}
s=s->next;
}
return(obj->slisthier);
}
void append_vcd_slisthier(struct globals *obj, 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(obj->slistcurr)
{
obj->slistcurr->next=s;
obj->slistcurr=s;
}
else
{
obj->slistcurr=obj->slistroot=s;
}
build_slisthier(obj);
DEBUG(fprintf(stderr, "SCOPE: %s\n",obj->slisthier));
}
static void parse_valuechange(struct globals *obj)
{
struct vcdsymbol *v;
char *vector;
int vlen;
switch(obj->yytext[0])
{
case '0':
case '1':
case 'x':
case 'X':
case 'z':
case 'Z':
if(obj->yylen>1)
{
v=bsearch_vcd(obj, obj->yytext+1);
if(!v)
{
fprintf(stderr,"Near byte %d, Unknown VCD identifier: '%s'\n",obj->vcdbyteno+(obj->vst-obj->vcdbuf),obj->yytext+1);
}
else
{
if(v->vartype!=V_EVENT)
{
v->value[0]=obj->yytext[0];
DEBUG(fprintf(stderr,"%s = '%c'\n",v->name,v->value[0]));
add_histent(obj, obj->current_time,v->narray[0],v->value[0],1, NULL);
}
else
{
v->value[0]=(obj->dumping_off)?'x':'1'; /* only '1' is relevant */
if(obj->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(obj, 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(obj, obj->current_time,v->narray[0],v->value[0],1, NULL);
v->ev->last_event_time=obj->current_time;
}
}
}
else
{
fprintf(stderr,"Near byte %d, Malformed VCD identifier\n", obj->vcdbyteno+(obj->vst-obj->vcdbuf));
}
break;
case 'b':
case 'B':
{
/* extract binary number then.. */
vector=malloc_2(obj->yylen_cache=obj->yylen);
strcpy(vector,obj->yytext+1);
vlen=obj->yylen-1;
get_strtoken(obj);
v=bsearch_vcd(obj, obj->yytext);
if(!v)
{
fprintf(stderr,"Near byte %d, Unknown identifier: '%s'\n",obj->vcdbyteno+(obj->vst-obj->vcdbuf), obj->yytext);
free_2(vector);
}
else
{
if((obj->convert_to_reals)&&(v->vartype==V_REAL))
{
double *d;
char *pnt;
char ch;
TimeType k=0;
pnt=vector;
while((ch=*(pnt++))) { k=(k<<1)|((ch=='1')?1:0); }
free_2(vector);
d=malloc_2(sizeof(double));
*d=(double)k;
if(!v)
{
fprintf(stderr,"Near byte %d, Unknown identifier: '%s'\n",obj->vcdbyteno+(obj->vst-obj->vcdbuf), obj->yytext);
free_2(d);
}
else
{
add_histent(obj, obj->current_time, v->narray[0],'g',1,(char *)d);
}
break;
}
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));
if((v->size==1)||(!obj->atomic_vectors))
{
int i;
for(i=0;i<v->size;i++)
{
add_histent(obj, obj->current_time, v->narray[i],v->value[i],1, NULL);
}
free_2(vector);
}
else
{
if(obj->yylen_cache!=(v->size+1))
{
free_2(vector);
vector=malloc_2(v->size+1);
}
strcpy(vector,v->value);
add_histent(obj, obj->current_time, v->narray[0],0,1,vector);
}
}
break;
}
case 'p':
/* extract port dump value.. */
vector=malloc_2(obj->yylen_cache=obj->yylen);
strcpy(vector,obj->yytext+1);
vlen=obj->yylen-1;
get_strtoken(obj); /* throw away 0_strength_component */
get_strtoken(obj); /* throw away 0_strength_component */
get_strtoken(obj); /* this is the id */
v=bsearch_vcd(obj, obj->yytext);
if(!v)
{
fprintf(stderr,"Near byte %d, Unknown identifier: '%s'\n",obj->vcdbyteno+(obj->vst-obj->vcdbuf), obj->yytext);
free_2(vector);
}
else
{
if((obj->convert_to_reals)&&(v->vartype==V_REAL)) /* should never happen, but just in case.. */
{
double *d;
char *pnt;
char ch;
TimeType k=0;
pnt=vector;
while((ch=*(pnt++))) { k=(k<<1)|((ch=='1')?1:0); }
free_2(vector);
d=malloc_2(sizeof(double));
*d=(double)k;
if(!v)
{
fprintf(stderr,"Near byte %d, Unknown identifier: '%s'\n",obj->vcdbyteno+(obj->vst-obj->vcdbuf), obj->yytext);
free_2(d);
}
else
{
add_histent(obj, obj->current_time, v->narray[0],'g',1,(char *)d);
}
break;
}
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));
if((v->size==1)||(!obj->atomic_vectors))
{
int i;
for(i=0;i<v->size;i++)
{
add_histent(obj, obj->current_time, v->narray[i],v->value[i],1, NULL);
}
free_2(vector);
}
else
{
if(obj->yylen_cache<v->size)
{
free_2(vector);
vector=malloc_2(v->size+1);
}
strcpy(vector,v->value);
add_histent(obj, obj->current_time, v->narray[0],0,1,vector);
}
}
break;
case 'r':
case 'R':
{
double *d;
d=malloc_2(sizeof(double));
sscanf(obj->yytext+1,"%lg",d);
get_strtoken(obj);
v=bsearch_vcd(obj, obj->yytext);
if(!v)
{
fprintf(stderr,"Near byte %d, Unknown identifier: '%s'\n",obj->vcdbyteno+(obj->vst-obj->vcdbuf), obj->yytext);
free_2(d);
}
else
{
add_histent(obj, obj->current_time, v->narray[0],'g',1,(char *)d);
}
break;
}
#ifndef STRICT_VCD_ONLY
case 's':
case 'S':
{
char *d;
d=(char *)malloc_2(obj->yylen);
strcpy(d, obj->yytext+1);
get_strtoken(obj);
v=bsearch_vcd(obj, obj->yytext);
if(!v)
{
fprintf(stderr,"Near byte %d, Unknown identifier: '%s'\n",obj->vcdbyteno+(obj->vst-obj->vcdbuf), obj->yytext);
free_2(d);
}
else
{
add_histent(obj, obj->current_time, v->narray[0],'s',1,(char *)d);
}
break;
}
#endif
}
}
static void evcd_strcpy(char *dst, char *src)
{
static char *evcd="DUNZduLHXTlh01?FAaBbCcf";
static char *vcd="01xz0101xz0101xzxxxxxxx";
char ch;
int i;
while((ch=*src))
{
for(i=0;i<23;i++)
{
if(evcd[i]==ch)
{
*dst=vcd[i];
break;
}
}
if(i==23) *dst='x';
src++;
dst++;
}
*dst=0; /* null terminate destination */
}
static void vcd_parse(struct globals *obj)
{
int tok;
for(;;)
{
switch(tok=get_token(obj))
{
case T_COMMENT:
sync_end(obj, "COMMENT:");
break;
case T_DATE:
sync_end(obj, "DATE:");
break;
case T_VERSION:
sync_end(obj, "VERSION:");
break;
case T_TIMESCALE:
{
int vtok;
int i;
char prefix=' ';
vtok=get_token(obj);
if((vtok==T_END)||(vtok==T_EOF)) break;
obj->time_scale=atoi_64(obj->yytext);
if(!obj->time_scale) obj->time_scale=1;
for(i=0;i<obj->yylen;i++)
{
if((obj->yytext[i]<'0')||(obj->yytext[i]>'9'))
{
prefix=obj->yytext[i];
break;
}
}
if(prefix==' ')
{
vtok=get_token(obj);
if((vtok==T_END)||(vtok==T_EOF)) break;
prefix=obj->yytext[0];
}
switch(prefix)
{
case ' ':
case 'm':
case 'u':
case 'n':
case 'p':
case 'f':
obj->time_dimension=prefix;
break;
case 's':
obj->time_dimension=' ';
break;
default: /* unknown */
obj->time_dimension='n';
break;
}
DEBUG(fprintf(stderr,"TIMESCALE: "TTFormat" %cs\n",obj->time_scale, obj->time_dimension));
sync_end(obj, NULL);
}
break;
case T_SCOPE:
T_GET(obj);
T_GET(obj);
if(tok==T_STRING)
{
struct slist *s;
s=(struct slist *)calloc_2(1,sizeof(struct slist));
s->len=obj->yylen;
s->str=(char *)malloc_2(obj->yylen+1);
strcpy(s->str,obj->yytext);
if(obj->slistcurr)
{
obj->slistcurr->next=s;
obj->slistcurr=s;
}
else
{
obj->slistcurr=obj->slistroot=s;
}
build_slisthier(obj);
DEBUG(fprintf(stderr, "SCOPE: %s\n",obj->slisthier));
}
sync_end(obj, NULL);
break;
case T_UPSCOPE:
if(obj->slistroot)
{
struct slist *s;
s=obj->slistroot;
if(!s->next)
{
free_2(s->str);
free_2(s);
obj->slistroot=obj->slistcurr=NULL;
}
else
for(;;)
{
if(!s->next->next)
{
free_2(s->next->str);
free_2(s->next);
s->next=NULL;
obj->slistcurr=s;
break;
}
s=s->next;
}
build_slisthier(obj);
DEBUG(fprintf(stderr, "SCOPE: %s\n",obj->slisthier));
}
sync_end(obj, NULL);
break;
case T_VAR:
if((obj->header_over)&&(0))
{
fprintf(stderr,"$VAR encountered after $ENDDEFINITIONS near byte %d. VCD is malformed, exiting.\n",obj->vcdbyteno+(obj->vst-obj->vcdbuf));
exit(VCD_FAIL);
}
else
{
int vtok;
struct vcdsymbol *v=NULL;
obj->var_prevch=0;
obj->varsplit=NULL;
vtok=get_vartoken(obj);
if(vtok>V_PORT) goto bail;
v=(struct vcdsymbol *)calloc_2(1,sizeof(struct vcdsymbol));
v->vartype=vtok;
v->msi=v->lsi=obj->vcd_explicit_zero_subscripts; /* indicate [un]subscripted status */
if(vtok==V_PORT)
{
vtok=get_vartoken(obj);
if(vtok==V_STRING)
{
v->size=atoi_64(obj->yytext);
if(!v->size) v->size=1;
}
else
if(vtok==V_LB)
{
vtok=get_vartoken(obj);
if(vtok==V_END) goto err;
if(vtok!=V_STRING) goto err;
v->msi=atoi_64(obj->yytext);
vtok=get_vartoken(obj);
if(vtok==V_RB)
{
v->lsi=v->msi;
v->size=1;
}
else
{
if(vtok!=V_COLON) goto err;
vtok=get_vartoken(obj);
if(vtok!=V_STRING) goto err;
v->lsi=atoi_64(obj->yytext);
vtok=get_vartoken(obj);
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(obj);
if(vtok==V_END) goto err;
v->id=(char *)malloc_2(obj->yylen+1);
strcpy(v->id, obj->yytext);
vtok=get_vartoken(obj);
if(vtok!=V_STRING) goto err;
if(obj->slisthier_len)
{
v->name=(char *)malloc_2(obj->slisthier_len+1+obj->yylen+1);
strcpy(v->name,obj->slisthier);
strcpy(v->name+obj->slisthier_len,obj->vcd_hier_delimeter);
strcpy(v->name+obj->slisthier_len+1,obj->yytext);
}
else
{
v->name=(char *)malloc_2(obj->yylen+1);
strcpy(v->name,obj->yytext);
}
if(obj->pv)
{
if(!strcmp(obj->pv->name,v->name))
{
obj->pv->chain=v;
v->root=obj->rootv;
if(obj->pv==obj->rootv) obj->pv->root=obj->rootv;
}
else
{
obj->rootv=v;
}
}
else
{
obj->rootv=v;
}
obj->pv=v;
}
else /* regular vcd var, not an evcd port var */
{
vtok=get_vartoken(obj);
if(vtok==V_END) goto err;
v->size=atoi_64(obj->yytext);
if(!v->size) v->size=1;
vtok=get_strtoken(obj);
if(vtok==V_END) goto err;
v->id=(char *)malloc_2(obj->yylen+1);
strcpy(v->id, obj->yytext);
vtok=get_vartoken(obj);
if(vtok!=V_STRING) goto err;
if(obj->slisthier_len)
{
v->name=(char *)malloc_2(obj->slisthier_len+1+obj->yylen+1);
strcpy(v->name,obj->slisthier);
strcpy(v->name+obj->slisthier_len,obj->vcd_hier_delimeter);
strcpy(v->name+obj->slisthier_len+1,obj->yytext);
}
else
{
v->name=(char *)malloc_2(obj->yylen+1);
strcpy(v->name,obj->yytext);
}
if(obj->pv)
{
if(!strcmp(obj->pv->name,v->name))
{
obj->pv->chain=v;
v->root=obj->rootv;
if(obj->pv==obj->rootv) obj->pv->root=obj->rootv;
}
else
{
obj->rootv=v;
}
}
else
{
obj->rootv=v;
}
obj->pv=v;
vtok=get_vartoken(obj);
if(vtok==V_END) goto dumpv;
if(vtok!=V_LB) goto err;
vtok=get_vartoken(obj);
if(vtok!=V_STRING) goto err;
v->msi=atoi_64(obj->yytext);
vtok=get_vartoken(obj);
if(vtok==V_RB)
{
v->lsi=v->msi;
goto dumpv;
}
if(vtok!=V_COLON) goto err;
vtok=get_vartoken(obj);
if(vtok!=V_STRING) goto err;
v->lsi=atoi_64(obj->yytext);
vtok=get_vartoken(obj);
if(vtok!=V_RB) goto err;
}
dumpv:
if((v->vartype==V_REAL)||((obj->convert_to_reals)&&((v->vartype==V_INTEGER)||(v->vartype==V_PARAMETER))))
{
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)&&(v->vartype!=V_PARAMETER)) 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)&&(v->vartype!=V_PARAMETER)) 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;
if(obj->atomic_vectors)
{
for(i=0;i<v->size;i++)
{
v->value[i]='x';
}
v->narray[0]=(struct Node *)calloc_2(1,sizeof(struct Node));
v->narray[0]->head.time=-1;
v->narray[0]->head.v.val=1;
}
else
{
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(!obj->vcdsymroot)
{
obj->vcdsymroot=obj->vcdsymcurr=v;
}
else
{
obj->vcdsymcurr->next=v;
obj->vcdsymcurr=v;
}
obj->numsyms++;
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(obj, NULL);
break;
}
case T_ENDDEFINITIONS:
obj->header_over=1; /* do symbol table management here */
create_sorted_table(obj);
if(!obj->sorted)
{
fprintf(stderr, "No symbols in VCD file..nothing to do!\n");
exit(VCD_FAIL);
}
break;
case T_STRING:
if(obj->header_over)
{
/* catchall for events when header over */
if(obj->yytext[0]=='#')
{
TimeType time;
time=atoi_64(obj->yytext+1);
if(obj->start_time<0)
{
obj->start_time=time;
}
obj->current_time=time;
if(obj->end_time<time) obj->end_time=time; /* in case of malformed vcd files */
DEBUG(fprintf(stderr,"#"TTFormat"\n",time));
}
else
{
parse_valuechange(obj);
}
}
break;
case T_DUMPALL: /* dump commands modify vals anyway so */
case T_DUMPPORTSALL:
break; /* just loop through.. */
case T_DUMPOFF:
case T_DUMPPORTSOFF:
obj->dumping_off=1;
break;
case T_DUMPON:
case T_DUMPPORTSON:
obj->dumping_off=0;
break;
case T_DUMPVARS:
case T_DUMPPORTS:
break;
case T_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(obj, NULL); /* skip over unknown keywords */
break;
case T_EOF:
return;
default:
DEBUG(fprintf(stderr,"UNKNOWN TOKEN\n"));
}
}
}
/*******************************************************************************/
void add_histent(struct globals *obj, TimeType time, struct Node *n, char ch, int regadd, char *vector)
{
struct HistEnt *he;
char heval;
if(!vector)
{
if(!n->curr)
{
he=histent_calloc(obj);
he->time=-1;
he->v.val=1;
n->curr=he;
n->head.next=he;
add_histent(obj, time,n,ch,regadd, vector);
}
else
{
if(regadd) { time*=(obj->time_scale); }
if(ch=='0') heval=0; else
if(ch=='1') heval=3; else
if((ch=='x')||(ch=='X')) heval=1; else
heval=2;
if((n->curr->v.val!=heval)||(time==obj->start_time)) /* same region == go skip */
{
if((n->curr->time==time)&&(obj->count_glitches))
{
DEBUG(printf("Warning: Glitch at time ["TTFormat"] Signal [%p], Value [%c->%c].\n",
time, n, "0XZ1"[n->curr->v.val], ch));
n->curr->v.val=heval; /* we have a glitch! */
obj->num_glitches++;
if(!(n->curr->flags&HIST_GLITCH))
{
n->curr->flags|=HIST_GLITCH; /* set the glitch flag */
obj->num_glitch_regions++;
}
}
else
{
he=histent_calloc(obj);
he->time=time;
he->v.val=heval;
n->curr->next=he;
n->curr=he;
obj->regions+=regadd;
}
}
}
}
else
{
switch(ch)
{
case 's': /* string */
{
if(!n->curr)
{
he=histent_calloc(obj);
he->flags=(HIST_STRING|HIST_REAL);
he->time=-1;
he->v.vector=NULL;
n->curr=he;
n->head.next=he;
add_histent(obj, time,n,ch,regadd, vector);
}
else
{
if(regadd) { time*=(obj->time_scale); }
if((n->curr->time==time)&&(obj->count_glitches))
{
DEBUG(printf("Warning: String Glitch at time ["TTFormat"] Signal [%p].\n",
time, n));
if(n->curr->v.vector) free_2(n->curr->v.vector);
n->curr->v.vector=vector; /* we have a glitch! */
obj->num_glitches++;
if(!(n->curr->flags&HIST_GLITCH))
{
n->curr->flags|=HIST_GLITCH; /* set the glitch flag */
obj->num_glitch_regions++;
}
}
else
{
he=histent_calloc(obj);
he->flags=(HIST_STRING|HIST_REAL);
he->time=time;
he->v.vector=vector;
n->curr->next=he;
n->curr=he;
obj->regions+=regadd;
}
}
break;
}
case 'g': /* real number */
{
if(!n->curr)
{
he=histent_calloc(obj);
he->flags=HIST_REAL;
he->time=-1;
he->v.vector=NULL;
n->curr=he;
n->head.next=he;
add_histent(obj, time,n,ch,regadd, vector);
}
else
{
if(regadd) { time*=(obj->time_scale); }
if(
(n->curr->v.vector&&vector&&(*(double *)n->curr->v.vector!=*(double *)vector))
||(time==obj->start_time)
||(!n->curr->v.vector)
) /* same region == go skip */
{
if((n->curr->time==time)&&(obj->count_glitches))
{
DEBUG(printf("Warning: Real number Glitch at time ["TTFormat"] Signal [%p].\n",
time, n));
if(n->curr->v.vector) free_2(n->curr->v.vector);
n->curr->v.vector=vector; /* we have a glitch! */
obj->num_glitches++;
if(!(n->curr->flags&HIST_GLITCH))
{
n->curr->flags|=HIST_GLITCH; /* set the glitch flag */
obj->num_glitch_regions++;
}
}
else
{
he=histent_calloc(obj);
he->flags=HIST_REAL;
he->time=time;
he->v.vector=vector;
n->curr->next=he;
n->curr=he;
obj->regions+=regadd;
}
}
else
{
free_2(vector);
}
}
break;
}
default:
{
if(!n->curr)
{
he=histent_calloc(obj);
he->time=-1;
he->v.vector=NULL;
n->curr=he;
n->head.next=he;
add_histent(obj, time,n,ch,regadd, vector);
}
else
{
if(regadd) { time*=(obj->time_scale); }
if(
(n->curr->v.vector&&vector&&(strcmp(n->curr->v.vector,vector)))
||(time==obj->start_time)
||(!n->curr->v.vector)
) /* same region == go skip */
{
if((n->curr->time==time)&&(obj->count_glitches))
{
DEBUG(printf("Warning: Glitch at time ["TTFormat"] Signal [%p], Value [%c->%c].\n",
time, n, "0XZ1"[n->curr->v.val], ch));
if(n->curr->v.vector) free_2(n->curr->v.vector);
n->curr->v.vector=vector; /* we have a glitch! */
obj->num_glitches++;
if(!(n->curr->flags&HIST_GLITCH))
{
n->curr->flags|=HIST_GLITCH; /* set the glitch flag */
obj->num_glitch_regions++;
}
}
else
{
he=histent_calloc(obj);
he->time=time;
he->v.vector=vector;
n->curr->next=he;
n->curr=he;
obj->regions+=regadd;
}
}
else
{
free_2(vector);
}
}
break;
}
}
}
}
static void add_tail_histents(struct globals *obj)
{
int i,j;
/* dump out any pending events 1st */
struct queuedevent *q;
q=queuedevents;
while(q)
{
struct vcdsymbol *v;
v=q->sym;
if(obj->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(obj, v->ev->last_event_time+1,v->narray[0],'0',1, NULL);
}
q=q->next;
}
/* then do 'x' trailers */
for(i=0;i<obj->numsyms;i++)
{
struct vcdsymbol *v;
v=obj->sorted[i];
if(v->vartype==V_REAL)
{
double *d;
d=malloc_2(sizeof(double));
*d=1.0;
add_histent(obj, MAX_HISTENT_TIME-1, v->narray[0], 'g', 0, (char *)d);
}
else
if((v->size==1)||(!obj->atomic_vectors))
for(j=0;j<v->size;j++)
{
add_histent(obj, MAX_HISTENT_TIME-1, v->narray[j], 'x', 0, NULL);
}
else
{
add_histent(obj, MAX_HISTENT_TIME-1, v->narray[0], 'x', 0, (char *)calloc_2(1,sizeof(char)));
}
}
for(i=0;i<obj->numsyms;i++)
{
struct vcdsymbol *v;
v=obj->sorted[i];
if(v->vartype==V_REAL)
{
double *d;
d=malloc_2(sizeof(double));
*d=0.0;
add_histent(obj, MAX_HISTENT_TIME, v->narray[0], 'g', 0, (char *)d);
}
else
if((v->size==1)||(!obj->atomic_vectors))
for(j=0;j<v->size;j++)
{
add_histent(obj, MAX_HISTENT_TIME, v->narray[j], 'z', 0, NULL);
}
else
{
add_histent(obj, MAX_HISTENT_TIME, v->narray[0], 'z', 0, (char *)calloc_2(1,sizeof(char)));
}
}
}
/*******************************************************************************/
static void vcd_build_symbols(struct globals *obj)
{
int i,j;
int max_slen=-1;
struct sym_chain *sym_chain=NULL, *sym_curr=NULL;
for(i=0;i<obj->numsyms;i++)
{
struct vcdsymbol *v, *vprime;
int msi;
int delta;
{
char *str;
int slen;
int substnode;
v=obj->sorted[i];
msi=v->msi;
delta=((v->lsi-v->msi)<0)?-1:1;
substnode=0;
slen=strlen(v->name);
str=(slen>max_slen)?(wave_alloca((max_slen=slen)+32)):(str); /* more than enough */
strcpy(str,v->name);
if(v->msi>=0)
{
strcpy(str+slen,obj->vcd_hier_delimeter);
slen++;
}
if((vprime=bsearch_vcd(obj, v->id))!=v) /* hash mish means dup net */
{
if(v->size!=vprime->size)
{
fprintf(stderr,"ERROR: Duplicate IDs with differing width: %s %s\n", v->name, vprime->name);
}
else
{
substnode=1;
}
}
if(((v->size==1)||(!obj->atomic_vectors))&&(v->vartype!=V_REAL))
{
struct symbol *s;
for(j=0;j<v->size;j++)
{
if(v->msi>=0)
{
if(!obj->vcd_explicit_zero_subscripts)
sprintf(str+slen,"%d",msi);
else
sprintf(str+slen-1,"[%d]",msi);
}
if(!symfind(obj, str))
{
s=symadd(obj, str,hash(str));
s->n=v->narray[j];
if(substnode)
{
struct Node *n, *n2;
n=s->n;
n2=vprime->narray[j];
/* nname stays same */
n->head=n2->head;
n->curr=n2->curr;
/* harray calculated later */
n->numhist=n2->numhist;
}
s->n->nname=s->name;
s->h=s->n->curr;
if(!obj->firstnode)
{
obj->firstnode=obj->curnode=s;
}
else
{
obj->curnode->nextinaet=s;
obj->curnode=s;
}
obj->numfacs++;
DEBUG(fprintf(stderr,"Added: %s\n",str));
}
else
{
fprintf(stderr,"Warning: %s is a duplicate net name.\n",str);
}
msi+=delta;
}
if((j==1)&&(v->root))
{
s->vec_root=(struct symbol *)v->root; /* these will get patched over */
s->vec_chain=(struct symbol *)v->chain; /* these will get patched over */
v->sym_chain=s;
if(!sym_chain)
{
sym_curr=(struct sym_chain *)calloc_2(1,sizeof(struct sym_chain));
sym_chain=sym_curr;
}
else
{
sym_curr->next=(struct sym_chain *)calloc_2(1,sizeof(struct sym_chain));
sym_curr=sym_curr->next;
}
sym_curr->val=s;
}
}
else /* atomic vector */
{
if(v->vartype!=V_REAL)
{
sprintf(str+slen-1,"[%d:%d]",v->msi,v->lsi);
}
else
{
*(str+slen-1)=0;
}
if(!symfind(obj, str))
{
struct symbol *s;
s=symadd(obj, str,hash(str));
s->n=v->narray[0];
if(substnode)
{
struct Node *n, *n2;
n=s->n;
n2=vprime->narray[0];
/* nname stays same */
n->head=n2->head;
n->curr=n2->curr;
/* harray calculated later */
n->numhist=n2->numhist;
n->ext=n2->ext;
}
else
{
struct ExtNode *en;
en=(struct ExtNode *)malloc_2(sizeof(struct ExtNode));
en->msi=v->msi;
en->lsi=v->lsi;
s->n->ext=en;
}
s->n->nname=s->name;
s->h=s->n->curr;
if(!obj->firstnode)
{
obj->firstnode=obj->curnode=s;
}
else
{
obj->curnode->nextinaet=s;
obj->curnode=s;
}
obj->numfacs++;
DEBUG(fprintf(stderr,"Added: %s\n",str));
}
else
{
fprintf(stderr,"Warning: %s is a duplicate net name.\n",str);
}
}
}
}
if(sym_chain)
{
sym_curr=sym_chain;
while(sym_curr)
{
sym_curr->val->vec_root= ((struct vcdsymbol *)sym_curr->val->vec_root)->sym_chain;
if ((struct vcdsymbol *)sym_curr->val->vec_chain)
sym_curr->val->vec_chain=((struct vcdsymbol *)sym_curr->val->vec_chain)->sym_chain;
DEBUG(printf("Link: ('%s') '%s' -> '%s'\n",sym_curr->val->vec_root->name, sym_curr->val->name, sym_curr->val->vec_chain?sym_curr->val->vec_chain->name:"(END)"));
sym_chain=sym_curr;
sym_curr=sym_curr->next;
free_2(sym_chain);
}
}
}
/*******************************************************************************/
void vcd_sortfacs(struct globals *obj)
{
int i;
obj->facs=(struct symbol **)malloc_2(obj->numfacs*sizeof(struct symbol *));
obj->curnode=obj->firstnode;
for(i=0;i<obj->numfacs;i++)
{
char *subst, ch;
int len;
obj->facs[i]=obj->curnode;
if((len=strlen(subst=obj->curnode->name))>obj->longestname) obj->longestname=len;
obj->curnode=obj->curnode->nextinaet;
while((ch=(*subst)))
{
if(ch==obj->hier_delimeter) { *subst=0x01; } /* forces sort at hier boundaries */
subst++;
}
}
quicksort(obj->facs,0,obj->numfacs-1);
for(i=0;i<obj->numfacs;i++)
{
char *subst, ch;
subst=obj->facs[i]->name;
while((ch=(*subst)))
{
if(ch==0x01) { *subst=obj->hier_delimeter; } /* restore back to normal */
subst++;
}
#ifdef DEBUG_FACILITIES
printf("%-4d %s\n",i,obj->facs[i]->name);
#endif
}
obj->facs_are_sorted=1;
}
/*******************************************************************************/
static void vcd_cleanup(struct globals *obj)
{
int i;
struct slist *s, *s2;
if(obj->sorted)
{
for(i=0;i<obj->numsyms;i++)
{
struct vcdsymbol *v;
v=obj->sorted[i];
if(v)
{
if(v->name) free_2(v->name);
if(v->id) free_2(v->id);
if(v->value) free_2(v->value);
if(v->ev) free_2(v->ev);
if(v->narray) free_2(v->narray);
free_2(v);
}
}
free_2(obj->sorted); obj->sorted=NULL;
}
if(obj->slisthier) { free_2(obj->slisthier); obj->slisthier=NULL; }
s=obj->slistroot;
while(s)
{
s2=s->next;
if(s->str)free_2(s->str);
free_2(s);
s=s2;
}
obj->slistroot=obj->slistcurr=NULL; obj->slisthier_len=0;
queuedevents=NULL; /* deallocated in the symbol stuff */
if(obj->vcd_is_compressed)
{
pclose(obj->vcd_handle);
}
else
{
fclose(obj->vcd_handle);
}
if(obj->yytext)
{
free_2(obj->yytext);
obj->yytext=NULL;
}
}
/*******************************************************************************/
TimeType vcd_main(struct globals *obj, char *fname)
{
int flen;
obj->pv=obj->rootv=NULL;
obj->vcd_hier_delimeter[0]=obj->hier_delimeter;
errno=0; /* reset in case it's set for some reason */
printf("Processing '%s'\n",fname);
obj->yytext=(char *)malloc_2(obj->T_MAX_STR+1);
flen=strlen(fname);
if (((flen>2)&&(!strcmp(fname+flen-3,".gz")))||
((flen>3)&&(!strcmp(fname+flen-4,".zip"))))
{
char *str;
int dlen;
dlen=strlen(WAVE_DECOMPRESSOR);
str=wave_alloca(strlen(fname)+dlen+1);
strcpy(str,WAVE_DECOMPRESSOR);
strcpy(str+dlen,fname);
obj->vcd_handle=popen(str,"r");
obj->vcd_is_compressed=~0;
}
else
{
if(strcmp("-vcd",fname))
{
obj->vcd_handle=fopen(fname,"rb");
}
else
{
obj->vcd_handle=stdin;
}
obj->vcd_is_compressed=0;
}
if(!obj->vcd_handle)
{
fprintf(stderr, "Error opening %s .vcd file '%s'.\n",
obj->vcd_is_compressed?"compressed":"", fname);
exit(VCD_FAIL);
}
getch_alloc(obj); /* alloc membuff for vcd getch buffer */
build_slisthier(obj);
vcd_parse(obj);
add_tail_histents(obj);
vcd_build_symbols(obj);
vcd_sortfacs(obj);
vcd_cleanup(obj);
printf("Found %d symbols.\n", obj->numfacs);
printf("["TTFormat"] start time.\n["TTFormat"] end time.\n", obj->start_time, obj->end_time);
if(obj->num_glitches) printf("Warning: encountered %d glitch%s across %d glitch region%s.\n",
obj->num_glitches, (obj->num_glitches!=1)?"es":"",
obj->num_glitch_regions, (obj->num_glitch_regions!=1)?"s":"");
getch_free(obj); /* free membuff for vcd getch buffer */
obj->min_time=obj->start_time*obj->time_scale;
obj->max_time=obj->end_time*obj->time_scale;
if(obj->min_time==obj->max_time)
{
fprintf(stderr, "VCD times range is equal to zero. Exiting.\n");
exit(VCD_FAIL);
}
return(obj->max_time);
}
/*******************************************************************************/
Reference in New Issue View Git Blame Copy Permalink