static void
add_tail (struct ghw_handler *h)
{
int i;
TimeType j;
for (j = 1; j>=0 ; j--) /* add two endcaps */
for (i = 0; i < h->nbr_sigs; i++)
{
struct ghw_sig *sig = &h->sigs[i];
struct Node *n = GLOBALS->nxp_ghw_c_1[i];
struct HistEnt *he;
if (sig->type == NULL || n == NULL || !n->curr)
continue;
/* Copy the last one. */
he = histent_calloc();
*he = *n->curr;
he->time = MAX_HISTENT_TIME - j;
he->next = NULL;
/* Append. */
n->curr->next=he;
n->curr=he;
}
}
/*
* 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
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;
}
void ae2_import_masked(void)
{
int txidx, i, cnt=0;
for(txidx=0;txidx<GLOBALS->numfacs;txidx++)
{
if(aet2_rd_get_fac_process_mask(txidx))
{
cnt++;
}
}
if(!cnt) return;
if(cnt>100)
{
fprintf(stderr, AET2_RDLOAD"Extracting %d traces\n", cnt);
}
set_window_busy(NULL);
ae2_iterator(GLOBALS->ae2_start_limit_cyc, GLOBALS->ae2_end_limit_cyc);
set_window_idle(NULL);
for(txidx=0;txidx<GLOBALS->numfacs;txidx++)
{
if(aet2_rd_get_fac_process_mask(txidx))
{
struct HistEnt *htemp, *histent_tail;
AE2_FACREF *f = GLOBALS->ae2_fr+txidx;
int r, nr = ae2_read_symbol_rows_2(GLOBALS->ae2, f->s);
int len = f->length;
if(nr<1) nr=1;
for(r = 0; r < nr; r++)
{
nptr np = GLOBALS->ae2_lx2_table[txidx][r].np;
histent_tail = htemp = histent_calloc();
if(len>1)
{
htemp->v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) htemp->v.h_vector[i] = AN_Z;
}
else
{
htemp->v.h_val = AN_Z; /* z */
}
htemp->time = MAX_HISTENT_TIME;
htemp = histent_calloc();
if(len>1)
{
htemp->v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) htemp->v.h_vector[i] = AN_X;
}
else
{
htemp->v.h_val = AN_X; /* x */
}
htemp->time = MAX_HISTENT_TIME-1;
htemp->next = histent_tail;
if(GLOBALS->ae2_lx2_table[txidx][r].histent_curr)
{
GLOBALS->ae2_lx2_table[txidx][r].histent_curr->next = htemp;
htemp = GLOBALS->ae2_lx2_table[txidx][r].histent_head;
}
{
struct HistEnt *htemp2 = histent_calloc();
htemp2->time = -1;
if(len>1)
{
htemp2->v.h_vector = htemp->v.h_vector;
}
else
{
htemp2->v.h_val = htemp->v.h_val;
}
htemp2->next = htemp;
htemp = htemp2;
GLOBALS->ae2_lx2_table[txidx][r].numtrans++;
}
if(len>1)
{
np->head.v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) np->head.v.h_vector[i] = AN_X;
}
else
{
np->head.v.h_val = AN_X; /* x */
}
np->head.time = -2;
np->head.next = htemp;
np->numhist=GLOBALS->ae2_lx2_table[txidx][r].numtrans +2 /*endcap*/ +1 /*frontcap*/;
np->curr = histent_tail;
np->mv.mvlfac = NULL; /* it's imported and cached so we can forget it's an mvlfac now */
}
free_2(GLOBALS->ae2_lx2_table[txidx]);
GLOBALS->ae2_lx2_table[txidx] = NULL;
aet2_rd_clr_fac_process_mask(txidx);
}
}
}
/*
* actually import an ae2 trace but don't do it if it's already been imported
*/
void import_ae2_trace(nptr np)
{
struct HistEnt *htemp, *histent_tail;
int len, i;
AE2_FACREF *f;
int txidx;
int r, nr;
if(!(f=(AE2_FACREF *)(np->mv.mvlfac))) return; /* already imported */
txidx = f - GLOBALS->ae2_fr;
nr = ae2_read_symbol_rows_2(GLOBALS->ae2, f->s);
/* new stuff */
len = f->length;
if((1)||(f->row <= 1)) /* sorry, arrays not supported yet in the viewer */
{
int flagged = HIER_DEPACK_STATIC;
char *str = hier_decompress_flagged(np->nname, &flagged);
fprintf(stderr, "Import: %s\n", str);
if(nr<1) nr=1;
if(!GLOBALS->ae2_lx2_table[txidx])
{
GLOBALS->ae2_lx2_table[txidx] = calloc_2(nr, sizeof(struct lx2_entry));
for(r=0;r<nr;r++)
{
GLOBALS->ae2_lx2_table[txidx][r].np = &np[r];
}
}
aet2_rd_set_fac_process_mask(txidx);
ae2_iterator(GLOBALS->ae2_start_limit_cyc, GLOBALS->ae2_end_limit_cyc);
aet2_rd_clr_fac_process_mask(txidx);
}
else
{
int flagged = HIER_DEPACK_STATIC;
char *str = hier_decompress_flagged(np->nname, &flagged);
fprintf(stderr, AET2_RDLOAD"Skipping array: %s (%d rows)\n", str, f->row);
if(nr<1) nr=1;
if(!GLOBALS->ae2_lx2_table[txidx])
{
GLOBALS->ae2_lx2_table[txidx] = calloc_2(nr, sizeof(struct lx2_entry));
for(r=0;r<nr;r++)
{
GLOBALS->ae2_lx2_table[txidx][r].np = &np[r];
}
}
}
for(r = 0; r < nr; r++)
{
histent_tail = htemp = histent_calloc();
if(len>1)
{
htemp->v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) htemp->v.h_vector[i] = AN_Z;
}
else
{
htemp->v.h_val = AN_Z; /* z */
}
htemp->time = MAX_HISTENT_TIME;
htemp = histent_calloc();
if(len>1)
{
htemp->v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) htemp->v.h_vector[i] = AN_X;
}
else
{
htemp->v.h_val = AN_X; /* x */
}
htemp->time = MAX_HISTENT_TIME-1;
htemp->next = histent_tail;
if(GLOBALS->ae2_lx2_table[txidx][r].histent_curr)
{
GLOBALS->ae2_lx2_table[txidx][r].histent_curr->next = htemp;
htemp = GLOBALS->ae2_lx2_table[txidx][r].histent_head;
}
if(len>1)
{
np[r].head.v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) np[r].head.v.h_vector[i] = AN_X;
}
else
{
np[r].head.v.h_val = AN_X; /* x */
}
{
struct HistEnt *htemp2 = histent_calloc();
htemp2->time = -1;
if(len>1)
{
htemp2->v.h_vector = htemp->v.h_vector;
}
else
{
htemp2->v.h_val = htemp->v.h_val;
}
htemp2->next = htemp;
htemp = htemp2;
GLOBALS->ae2_lx2_table[txidx][r].numtrans++;
}
np[r].head.time = -2;
np[r].head.next = htemp;
np[r].numhist=GLOBALS->ae2_lx2_table[txidx][r].numtrans +2 /*endcap*/ +1 /*frontcap*/;
np[r].curr = histent_tail;
np[r].mv.mvlfac = NULL; /* it's imported and cached so we can forget it's an mvlfac now */
}
}
void vzt_import_masked(void)
{
int txidx, i, cnt;
cnt = 0;
for(txidx=0;txidx<GLOBALS->numfacs;txidx++)
{
if(vzt_rd_get_fac_process_mask(GLOBALS->vzt_vzt_c_1, txidx))
{
cnt++;
}
}
if(!cnt) return;
if(cnt>100)
{
fprintf(stderr, VZT_RDLOAD"Extracting %d traces\n", cnt);
}
set_window_busy(NULL);
vzt_rd_iter_blocks(GLOBALS->vzt_vzt_c_1, vzt_callback, NULL);
set_window_idle(NULL);
for(txidx=0;txidx<GLOBALS->numfacs;txidx++)
{
if(vzt_rd_get_fac_process_mask(GLOBALS->vzt_vzt_c_1, txidx))
{
struct HistEnt *htemp, *histent_tail;
struct fac *f = GLOBALS->mvlfacs_vzt_c_3+txidx;
int len = f->len;
nptr np = GLOBALS->vzt_table_vzt_c_1[txidx].np;
histent_tail = htemp = histent_calloc();
if(len>1)
{
htemp->v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) htemp->v.h_vector[i] = AN_Z;
}
else
{
htemp->v.h_val = AN_Z; /* z */
}
htemp->time = MAX_HISTENT_TIME;
htemp = histent_calloc();
if(len>1)
{
htemp->v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) htemp->v.h_vector[i] = AN_X;
}
else
{
htemp->v.h_val = AN_X; /* x */
}
htemp->time = MAX_HISTENT_TIME-1;
htemp->next = histent_tail;
if(GLOBALS->vzt_table_vzt_c_1[txidx].histent_curr)
{
GLOBALS->vzt_table_vzt_c_1[txidx].histent_curr->next = htemp;
htemp = GLOBALS->vzt_table_vzt_c_1[txidx].histent_head;
}
if(!(f->flags&(VZT_RD_SYM_F_DOUBLE|VZT_RD_SYM_F_STRING)))
{
if(len>1)
{
np->head.v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) np->head.v.h_vector[i] = AN_X;
}
else
{
np->head.v.h_val = AN_X; /* x */
}
}
else
{
np->head.flags = HIST_REAL;
if(f->flags&VZT_RD_SYM_F_STRING) np->head.flags |= HIST_STRING;
}
{
struct HistEnt *htemp2 = histent_calloc();
htemp2->time = -1;
if(len>1)
{
htemp2->v.h_vector = htemp->v.h_vector;
}
else
{
htemp2->v.h_val = htemp->v.h_val;
}
htemp2->next = htemp;
htemp = htemp2;
GLOBALS->vzt_table_vzt_c_1[txidx].numtrans++;
}
np->head.time = -2;
np->head.next = htemp;
np->numhist=GLOBALS->vzt_table_vzt_c_1[txidx].numtrans +2 /*endcap*/ +1 /*frontcap*/;
memset(GLOBALS->vzt_table_vzt_c_1+txidx, 0, sizeof(struct lx2_entry)); /* zero it out */
np->curr = histent_tail;
np->mv.mvlfac = NULL; /* it's imported and cached so we can forget it's an mvlfac now */
vzt_rd_clr_fac_process_mask(GLOBALS->vzt_vzt_c_1, txidx);
}
}
}
/*
* actually import a vzt trace but don't do it if it's already been imported
*/
void import_vzt_trace(nptr np)
{
struct HistEnt *htemp, *histent_tail;
int len, i;
struct fac *f;
int txidx;
nptr nold = np;
if(!(f=np->mv.mvlfac)) return; /* already imported */
txidx = f - GLOBALS->mvlfacs_vzt_c_3;
if(np->mv.mvlfac->flags&VZT_RD_SYM_F_ALIAS)
{
txidx = vzt_rd_get_alias_root(GLOBALS->vzt_vzt_c_1, txidx);
np = GLOBALS->mvlfacs_vzt_c_3[txidx].working_node;
if(!(f=np->mv.mvlfac))
{
vzt_resolver(nold, np);
return; /* already imported */
}
}
fprintf(stderr, "Import: %s\n", np->nname);
/* new stuff */
len = np->mv.mvlfac->len;
if(f->node_alias <= 1) /* sorry, arrays not supported, but vzt doesn't support them yet either */
{
vzt_rd_set_fac_process_mask(GLOBALS->vzt_vzt_c_1, txidx);
vzt_rd_iter_blocks(GLOBALS->vzt_vzt_c_1, vzt_callback, NULL);
vzt_rd_clr_fac_process_mask(GLOBALS->vzt_vzt_c_1, txidx);
}
histent_tail = htemp = histent_calloc();
if(len>1)
{
htemp->v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) htemp->v.h_vector[i] = AN_Z;
}
else
{
htemp->v.h_val = AN_Z; /* z */
}
htemp->time = MAX_HISTENT_TIME;
htemp = histent_calloc();
if(len>1)
{
htemp->v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) htemp->v.h_vector[i] = AN_X;
}
else
{
htemp->v.h_val = AN_X; /* x */
}
htemp->time = MAX_HISTENT_TIME-1;
htemp->next = histent_tail;
if(GLOBALS->vzt_table_vzt_c_1[txidx].histent_curr)
{
GLOBALS->vzt_table_vzt_c_1[txidx].histent_curr->next = htemp;
htemp = GLOBALS->vzt_table_vzt_c_1[txidx].histent_head;
}
if(!(f->flags&(VZT_RD_SYM_F_DOUBLE|VZT_RD_SYM_F_STRING)))
{
if(len>1)
{
np->head.v.h_vector = (char *)malloc_2(len);
for(i=0;i<len;i++) np->head.v.h_vector[i] = AN_X;
}
else
{
np->head.v.h_val = AN_X; /* x */
}
}
else
{
np->head.flags = HIST_REAL;
if(f->flags&VZT_RD_SYM_F_STRING) np->head.flags |= HIST_STRING;
}
{
struct HistEnt *htemp2 = histent_calloc();
htemp2->time = -1;
if(len>1)
{
htemp2->v.h_vector = htemp->v.h_vector;
}
else
{
htemp2->v.h_val = htemp->v.h_val;
}
htemp2->next = htemp;
htemp = htemp2;
GLOBALS->vzt_table_vzt_c_1[txidx].numtrans++;
}
np->head.time = -2;
np->head.next = htemp;
np->numhist=GLOBALS->vzt_table_vzt_c_1[txidx].numtrans +2 /*endcap*/ +1 /*frontcap*/;
memset(GLOBALS->vzt_table_vzt_c_1+txidx, 0, sizeof(struct lx2_entry)); /* zero it out */
np->curr = histent_tail;
np->mv.mvlfac = NULL; /* it's imported and cached so we can forget it's an mvlfac now */
if(nold!=np)
{
vzt_resolver(nold, np);
}
}
/*
* vzt callback (only does bits for now)
*/
static void vzt_callback(struct vzt_rd_trace **lt, lxtint64_t *tim, lxtint32_t *facidx, char **value)
{
struct HistEnt *htemp = histent_calloc();
struct lx2_entry *l2e = GLOBALS->vzt_table_vzt_c_1+(*facidx);
struct fac *f = GLOBALS->mvlfacs_vzt_c_3+(*facidx);
GLOBALS->busycnt_vzt_c_2++;
if(GLOBALS->busycnt_vzt_c_2==WAVE_BUSY_ITER)
{
busy_window_refresh();
GLOBALS->busycnt_vzt_c_2 = 0;
}
/* fprintf(stderr, "%lld %d %s\n", *tim, *facidx, *value); */
if(!(f->flags&(VZT_RD_SYM_F_DOUBLE|VZT_RD_SYM_F_STRING)))
{
if(f->len>1)
{
htemp->v.h_vector = (char *)malloc_2(f->len);
memcpy(htemp->v.h_vector, *value, f->len);
}
else
{
switch(**value)
{
case '0': htemp->v.h_val = AN_0; break;
case '1': htemp->v.h_val = AN_1; break;
case 'Z':
case 'z': htemp->v.h_val = AN_Z; break;
default: htemp->v.h_val = AN_X; break;
}
}
}
else if(f->flags&VZT_RD_SYM_F_DOUBLE)
{
#ifdef WAVE_HAS_H_DOUBLE
sscanf(*value, "%lg", &htemp->v.h_double);
#else
double *d = malloc_2(sizeof(double));
sscanf(*value, "%lg", d);
htemp->v.h_vector = (char *)d;
#endif
htemp->flags = HIST_REAL;
}
else /* string */
{
char *s = malloc_2(strlen(*value)+1);
strcpy(s, *value);
htemp->v.h_vector = s;
htemp->flags = HIST_REAL|HIST_STRING;
}
htemp->time = (*tim) * (GLOBALS->time_scale);
if(l2e->histent_head)
{
l2e->histent_curr->next = htemp;
l2e->histent_curr = htemp;
}
else
{
l2e->histent_head = l2e->histent_curr = htemp;
}
l2e->numtrans++;
}
/*
* actually import a extload trace but don't do it if it's already been imported
*/
void import_extload_trace(nptr np)
{
struct HistEnt *htemp, *histent_tail;
int len, i;
struct fac *f;
int txidx, txidx_in_trace;
nptr nold = np;
if(!(f=np->mv.mvlfac)) return; /* already imported */
txidx = f - GLOBALS->mvlfacs_vzt_c_3;
txidx_in_trace = GLOBALS->extload_idcodes[txidx];
if(GLOBALS->extload_inv_idcodes[txidx_in_trace] < 0)
{
txidx = (-GLOBALS->extload_inv_idcodes[txidx_in_trace]) - 1;
np = GLOBALS->mvlfacs_vzt_c_3[txidx].working_node;
if(!(f=np->mv.mvlfac))
{
ext_resolver(nold, np);
return; /* already imported */
}
}
GLOBALS->extload_inv_idcodes[txidx_in_trace] = - (txidx + 1);
#ifndef WAVE_FSDB_READER_IS_PRESENT
fprintf(stderr, EXTLOAD"Import: %s\n", np->nname);
#endif
/* new stuff */
len = np->mv.mvlfac->len;
#ifdef WAVE_FSDB_READER_IS_PRESENT
{
void *hdl;
/* fsdbReaderAddToSignalList(GLOBALS->extload_ffr_ctx, txidx_in_trace); */
/* fsdbReaderLoadSignals(GLOBALS->extload_ffr_ctx); */
hdl = fsdbReaderCreateVCTraverseHandle(GLOBALS->extload_ffr_ctx, txidx_in_trace);
if(fsdbReaderHasIncoreVC(GLOBALS->extload_ffr_ctx, hdl))
{
TimeType mxt = (TimeType)fsdbReaderGetMinXTag(GLOBALS->extload_ffr_ctx, hdl);
fsdbReaderGotoXTag(GLOBALS->extload_ffr_ctx, hdl, mxt);
for(;;)
{
void *val_ptr;
char *b;
if(!fsdbReaderGetVC(GLOBALS->extload_ffr_ctx, hdl, &val_ptr))
{
break;
}
b = fsdbReaderTranslateVC(hdl, val_ptr);
extload_callback(&mxt, &txidx, &b);
if(!fsdbReaderGotoNextVC(GLOBALS->extload_ffr_ctx, hdl))
{
break;
}
mxt = (TimeType)fsdbReaderGetXTag(GLOBALS->extload_ffr_ctx, hdl);
}
}
fsdbReaderFree(GLOBALS->extload_ffr_ctx, hdl);
/* fsdbReaderUnloadSignals(GLOBALS->extload_ffr_ctx); */
}
#else
if(last_modification_check()) /* place array height check here in an "&&" branch, sorry, arrays not supported */
{
char sbuff[65537];
TimeType tim;
sprintf(sbuff, "%s -vc -vidcode %d %s 2>&1", EXTLOAD_PATH, txidx_in_trace, GLOBALS->loaded_file_name);
GLOBALS->extload = popen(sbuff, "r");
for(;;)
{
char *rc = fgets(sbuff, 65536, GLOBALS->extload);
if(!rc)
{
break;
}
if(isdigit(rc[0]))
{
rc = strchr(rc, '(');
if(rc)
{
unsigned int lo = 0, hi = 0;
sscanf(rc+1, "%u %u", &hi, &lo);
tim = (TimeType)((((UTimeType)hi)<<32) + ((UTimeType)lo));
rc = strchr(rc+1, ')');
if(rc)
{
rc = strchr(rc+1, ':');
if(rc)
{
char *rtn, *pnt;
rc += 2;
rtn = rc;
while(*rtn)
{
if(isspace(*rtn)) {
*rtn = 0;
break;
}
rtn++;
}
pnt = rc;
while(*pnt)
{
switch(*pnt)
{
case 'Z':
case '3':
*pnt = 'z';
break;
case 'X':
case '2':
*pnt = 'x';
break;
default:
break;
}
pnt++;
}
extload_callback(&tim, &txidx, &rc);
}
}
}
}
}
pclose(GLOBALS->extload);
}
#endif
histent_tail = htemp = histent_calloc();
if(len>1)
{
htemp->v.h_vector = (char *)malloc_2(len);
for(i=0; i<len; i++) htemp->v.h_vector[i] = AN_Z;
}
else
{
htemp->v.h_val = AN_Z; /* z */
}
htemp->time = MAX_HISTENT_TIME;
htemp = histent_calloc();
if(len>1)
{
htemp->v.h_vector = (char *)malloc_2(len);
for(i=0; i<len; i++) htemp->v.h_vector[i] = AN_X;
}
else
{
htemp->v.h_val = AN_X; /* x */
}
htemp->time = MAX_HISTENT_TIME-1;
htemp->next = histent_tail;
if(GLOBALS->vzt_table_vzt_c_1[txidx].histent_curr)
{
GLOBALS->vzt_table_vzt_c_1[txidx].histent_curr->next = htemp;
htemp = GLOBALS->vzt_table_vzt_c_1[txidx].histent_head;
}
if(!(f->flags&(VZT_RD_SYM_F_DOUBLE|VZT_RD_SYM_F_STRING)))
{
if(len>1)
{
np->head.v.h_vector = (char *)malloc_2(len);
for(i=0; i<len; i++) np->head.v.h_vector[i] = AN_X;
}
else
{
np->head.v.h_val = AN_X; /* x */
}
}
else
{
np->head.flags = HIST_REAL;
if(f->flags&VZT_RD_SYM_F_STRING) np->head.flags |= HIST_STRING;
}
{
struct HistEnt *htemp2 = histent_calloc();
htemp2->time = -1;
if(len>1)
{
htemp2->v.h_vector = htemp->v.h_vector;
}
else
{
htemp2->v.h_val = htemp->v.h_val;
}
htemp2->next = htemp;
htemp = htemp2;
GLOBALS->vzt_table_vzt_c_1[txidx].numtrans++;
}
np->head.time = -2;
np->head.next = htemp;
np->numhist=GLOBALS->vzt_table_vzt_c_1[txidx].numtrans +2 /*endcap*/ +1 /*frontcap*/;
memset(GLOBALS->vzt_table_vzt_c_1+txidx, 0, sizeof(struct lx2_entry)); /* zero it out */
np->curr = histent_tail;
np->mv.mvlfac = NULL; /* it's imported and cached so we can forget it's an mvlfac now */
if(nold!=np)
{
ext_resolver(nold, np);
}
}
