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

Update fstapi files to the latest from GTKWave

This commit is contained in:
Cary R 2018-10-12 21:29:29 -07:00
parent 3581da23e3
commit 95444b474d
2 changed files with 249 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

229
vpi/fstapi.c
View File

@ -283,7 +283,7 @@ static char *fstRealpath(const char *path, char *resolved_path)
#if (defined(__MACH__) && defined(__APPLE__))
if(!resolved_path)
{
resolved_path = (unsigned char *)malloc(PATH_MAX+1); /* fixes bug on Leopard when resolved_path == NULL */
resolved_path = (char *)malloc(PATH_MAX+1); /* fixes bug on Leopard when resolved_path == NULL */
}
#endif
@ -293,7 +293,7 @@ return(realpath(path, resolved_path));
#ifdef __MINGW32__
if(!resolved_path)
{
resolved_path = (unsigned char *)malloc(PATH_MAX+1);
resolved_path = (char *)malloc(PATH_MAX+1);
}
return(_fullpath(resolved_path, path, PATH_MAX));
#else
@ -793,6 +793,8 @@ char *geom_handle_nam;
char *valpos_handle_nam;
char *curval_handle_nam;
char *tchn_handle_nam;
fstEnumHandle max_enumhandle;
};
@ -2160,7 +2162,7 @@ if(xc && !xc->already_in_close && !xc->already_in_flush)
#ifdef __MINGW32__
{
int flen = strlen(xc->filename);
char *hf = calloc(1, flen + 6);
char *hf = (char *)calloc(1, flen + 6);
strcpy(hf, xc->filename);
if(xc->compress_hier)
@ -2303,7 +2305,7 @@ if(xc && path && path[0])
const unsigned char *path2 = (const unsigned char *)path;
PPvoid_t pv;
#else
char *path2 = alloca(slen + 1); /* judy lacks const qualifier in its JudyHSIns definition */
char *path2 = (char *)alloca(slen + 1); /* judy lacks const qualifier in its JudyHSIns definition */
PPvoid_t pv;
strcpy(path2, path);
#endif
@ -2724,6 +2726,111 @@ if(xc)
}
fstEnumHandle fstWriterCreateEnumTable(void *ctx, const char *name, uint32_t elem_count, unsigned int min_valbits, const char **literal_arr, const char **val_arr)
{
fstEnumHandle handle = 0;
unsigned int *literal_lens = NULL;
unsigned int *val_lens = NULL;
int lit_len_tot = 0;
int val_len_tot = 0;
int name_len;
char elem_count_buf[16];
int elem_count_len;
int total_len;
int pos = 0;
char *attr_str = NULL;
if(ctx && name && literal_arr && val_arr && (elem_count != 0))
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
uint32_t i;
name_len = strlen(name);
elem_count_len = sprintf(elem_count_buf, "%" PRIu32, elem_count);
literal_lens = (unsigned int *)calloc(elem_count, sizeof(unsigned int));
val_lens = (unsigned int *)calloc(elem_count, sizeof(unsigned int));
for(i=0;i<elem_count;i++)
{
literal_lens[i] = strlen(literal_arr[i]);
lit_len_tot += fstUtilityBinToEscConvertedLen((unsigned char*)literal_arr[i], literal_lens[i]);
val_lens[i] = strlen(val_arr[i]);
val_len_tot += fstUtilityBinToEscConvertedLen((unsigned char*)val_arr[i], val_lens[i]);
if(min_valbits > 0)
{
if(val_lens[i] < min_valbits)
{
val_len_tot += (min_valbits - val_lens[i]); /* additional converted len is same for '0' character */
}
}
}
total_len = name_len + 1 + elem_count_len + 1 + lit_len_tot + elem_count + val_len_tot + elem_count;
attr_str = (char*)malloc(total_len);
pos = 0;
memcpy(attr_str+pos, name, name_len);
pos += name_len;
attr_str[pos++] = ' ';
memcpy(attr_str+pos, elem_count_buf, elem_count_len);
pos += elem_count_len;
attr_str[pos++] = ' ';
for(i=0;i<elem_count;i++)
{
pos += fstUtilityBinToEsc((unsigned char*)attr_str+pos, (unsigned char*)literal_arr[i], literal_lens[i]);
attr_str[pos++] = ' ';
}
for(i=0;i<elem_count;i++)
{
if(min_valbits > 0)
{
if(val_lens[i] < min_valbits)
{
memset(attr_str+pos, '0', min_valbits - val_lens[i]);
pos += (min_valbits - val_lens[i]);
}
}
pos += fstUtilityBinToEsc((unsigned char*)attr_str+pos, (unsigned char*)val_arr[i], val_lens[i]);
attr_str[pos++] = ' ';
}
attr_str[pos-1] = 0;
#ifdef FST_DEBUG
fprintf(stderr, FST_APIMESS"fstWriterCreateEnumTable() total_len: %d, pos: %d\n", total_len, pos);
fprintf(stderr, FST_APIMESS"*%s*\n", attr_str);
#endif
fstWriterSetAttrBegin(xc, FST_AT_MISC, FST_MT_ENUMTABLE, attr_str, handle = ++xc->max_enumhandle);
free(attr_str);
free(val_lens);
free(literal_lens);
}
return(handle);
}
void fstWriterEmitEnumTableRef(void *ctx, fstEnumHandle handle)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if(xc && handle)
{
fstWriterSetAttrBegin(xc, FST_AT_MISC, FST_MT_ENUMTABLE, NULL, handle);
}
}
/*
* value and time change emission
*/
@ -6501,9 +6608,46 @@ if(base && *base)
/*** ***/
/************************/
int fstUtilityBinToEsc(unsigned char *d, unsigned char *s, int len)
int fstUtilityBinToEscConvertedLen(const unsigned char *s, int len)
{
unsigned char *src = s;
const unsigned char *src = s;
int dlen = 0;
int i;
for(i=0;i<len;i++)
{
switch(src[i])
{
case '\a': /* fallthrough */
case '\b': /* fallthrough */
case '\f': /* fallthrough */
case '\n': /* fallthrough */
case '\r': /* fallthrough */
case '\t': /* fallthrough */
case '\v': /* fallthrough */
case '\'': /* fallthrough */
case '\"': /* fallthrough */
case '\\': /* fallthrough */
case '\?': dlen += 2; break;
default: if((src[i] > ' ') && (src[i] <= '~')) /* no white spaces in output */
{
dlen++;
}
else
{
dlen += 4;
}
break;
}
}
return(dlen);
}
int fstUtilityBinToEsc(unsigned char *d, const unsigned char *s, int len)
{
const unsigned char *src = s;
unsigned char *dst = d;
unsigned char val;
int i;
@ -6602,3 +6746,76 @@ for(i=0;i<len;i++)
return(dst - s);
}
struct fstETab *fstUtilityExtractEnumTableFromString(const char *s)
{
struct fstETab *et = NULL;
int num_spaces = 0;
int i;
int newlen;
if(s)
{
const char *csp = strchr(s, ' ');
int cnt = atoi(csp+1);
for(;;)
{
csp = strchr(csp+1, ' ');
if(csp) { num_spaces++; } else { break; }
}
if(num_spaces == (2*cnt))
{
char *sp, *sp2;
et = (struct fstETab*)calloc(1, sizeof(struct fstETab));
et->elem_count = cnt;
et->name = strdup(s);
et->literal_arr = (char**)calloc(cnt, sizeof(char *));
et->val_arr = (char**)calloc(cnt, sizeof(char *));
sp = strchr(et->name, ' ');
*sp = 0;
sp = strchr(sp+1, ' ');
for(i=0;i<cnt;i++)
{
sp2 = strchr(sp+1, ' ');
*(char*)sp2 = 0;
et->literal_arr[i] = sp+1;
sp = sp2;
newlen = fstUtilityEscToBin(NULL, (unsigned char*)et->literal_arr[i], strlen(et->literal_arr[i]));
et->literal_arr[i][newlen] = 0;
}
for(i=0;i<cnt;i++)
{
sp2 = strchr(sp+1, ' ');
if(sp2) { *sp2 = 0; }
et->val_arr[i] = sp+1;
sp = sp2;
newlen = fstUtilityEscToBin(NULL, (unsigned char*)et->val_arr[i], strlen(et->val_arr[i]));
et->val_arr[i][newlen] = 0;
}
}
}
return(et);
}
void fstUtilityFreeEnumTable(struct fstETab *etab)
{
if(etab)
{
free(etab->literal_arr);
free(etab->val_arr);
free(etab->name);
free(etab);
}
}

32
vpi/fstapi.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2009-2017 Tony Bybell.
* Copyright (c) 2009-2018 Tony Bybell.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
@ -39,6 +39,7 @@ extern "C" {
#define FST_RDLOAD "FSTLOAD | "
typedef uint32_t fstHandle;
typedef uint32_t fstEnumHandle;
enum fstWriterPackType {
FST_WR_PT_ZLIB = 0,
@ -196,9 +197,10 @@ enum fstMiscType {
FST_MT_SOURCESTEM = 4, /* use fstWriterSetSourceStem() to emit */
FST_MT_SOURCEISTEM = 5, /* use fstWriterSetSourceInstantiationStem() to emit */
FST_MT_VALUELIST = 6, /* use fstWriterSetValueList() to emit, followed by fstWriterCreateVar*() */
FST_MT_UNKNOWN = 7,
FST_MT_ENUMTABLE = 7, /* use fstWriterCreateEnumTable() and fstWriterEmitEnumTableRef() to emit */
FST_MT_UNKNOWN = 8,
FST_MT_MAX = 7
FST_MT_MAX = 8
};
enum fstArrayType {
@ -228,7 +230,10 @@ enum fstEnumValueType {
FST_EV_SV_UNSIGNED_LONGINT = 12,
FST_EV_SV_UNSIGNED_BYTE = 13,
FST_EV_MAX = 13
FST_EV_REG = 14,
FST_EV_TIME = 15,
FST_EV_MAX = 15
};
enum fstPackType {
@ -324,11 +329,21 @@ union {
};
struct fstETab
{
char *name;
uint32_t elem_count;
char **literal_arr;
char **val_arr;
};
/*
* writer functions
*/
void fstWriterClose(void *ctx);
void * fstWriterCreate(const char *nam, int use_compressed_hier);
fstEnumHandle fstWriterCreateEnumTable(void *ctx, const char *name, uint32_t elem_count, unsigned int min_valbits, const char **literal_arr, const char **val_arr);
/* used for Verilog/SV */
fstHandle fstWriterCreateVar(void *ctx, enum fstVarType vt, enum fstVarDir vd,
uint32_t len, const char *nam, fstHandle aliasHandle);
@ -337,9 +352,10 @@ fstHandle fstWriterCreateVar(void *ctx, enum fstVarType vt, enum fstVarDir
fstHandle fstWriterCreateVar2(void *ctx, enum fstVarType vt, enum fstVarDir vd,
uint32_t len, const char *nam, fstHandle aliasHandle,
const char *type, enum fstSupplementalVarType svt, enum fstSupplementalDataType sdt);
void fstWriterEmitDumpActive(void *ctx, int enable);
void fstWriterEmitEnumTableRef(void *ctx, fstEnumHandle handle);
void fstWriterEmitValueChange(void *ctx, fstHandle handle, const void *val);
void fstWriterEmitVariableLengthValueChange(void *ctx, fstHandle handle, const void *val, uint32_t len);
void fstWriterEmitDumpActive(void *ctx, int enable);
void fstWriterEmitTimeChange(void *ctx, uint64_t tim);
void fstWriterFlushContext(void *ctx);
int fstWriterGetDumpSizeLimitReached(void *ctx);
@ -422,8 +438,12 @@ void fstReaderSetVcdExtensions(void *ctx, int enable);
/*
* utility functions
*/
int fstUtilityBinToEsc(unsigned char *d, unsigned char *s, int len);
int fstUtilityBinToEscConvertedLen(const unsigned char *s, int len); /* used for mallocs for fstUtilityBinToEsc() */
int fstUtilityBinToEsc(unsigned char *d, const unsigned char *s, int len);
int fstUtilityEscToBin(unsigned char *d, unsigned char *s, int len);
struct fstETab *fstUtilityExtractEnumTableFromString(const char *s);
void fstUtilityFreeEnumTable(struct fstETab *etab); /* must use to free fstETab properly */
#ifdef __cplusplus
}