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

Update libfst from upstream (gtkwave/libfst#12)

This commit is contained in:
Wilson Snyder 2025-03-30 11:10:38 -04:00
parent 6f87443da5
commit 21229e0350
3 changed files with 243 additions and 314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

347
include/gtkwave/fstapi.c
View File

@ -37,10 +37,9 @@
*
*/
// #ifndef FST_CONFIG_INCLUDE
// # define FST_CONFIG_INCLUDE <config.h>
// #endif
// #include FST_CONFIG_INCLUDE
#ifdef FST_INCLUDE_CONFIG
#include <config.h>
#endif
#include "fstapi.h"
#include "fastlz.h"
@ -60,21 +59,6 @@
#include <windows.h>
#endif
#ifdef HAVE_ALLOCA_H
#include <alloca.h>
#elif defined(__GNUC__)
#ifndef __MINGW32__
#ifndef alloca
#define alloca __builtin_alloca
#endif
#else
#include <malloc.h>
#endif
#elif defined(_MSC_VER)
#include <malloc.h>
#define alloca _alloca
#endif
#ifndef PATH_MAX
#define PATH_MAX (4096)
#endif
@ -1113,10 +1097,9 @@ static void fstDetermineBreakSize(struct fstWriterContext *xc)
/*
* file creation and close
*/
void *fstWriterCreate(const char *nam, int use_compressed_hier)
fstWriterContext *fstWriterCreate(const char *nam, int use_compressed_hier)
{
struct fstWriterContext *xc =
(struct fstWriterContext *)calloc(1, sizeof(struct fstWriterContext));
fstWriterContext *xc = (fstWriterContext *)calloc(1, sizeof(fstWriterContext));
xc->compress_hier = use_compressed_hier;
fstDetermineBreakSize(xc);
@ -1175,10 +1158,8 @@ void *fstWriterCreate(const char *nam, int use_compressed_hier)
/*
* generation and writing out of value change data sections
*/
static void fstWriterEmitSectionHeader(void *ctx)
static void fstWriterEmitSectionHeader(fstWriterContext *xc)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
unsigned long destlen;
unsigned char *dmem;
@ -1235,9 +1216,9 @@ static void fstWriterEmitSectionHeader(void *ctx)
* be synced up with time changes
*/
#ifdef FST_WRITER_PARALLEL
static void fstWriterFlushContextPrivate2(void *ctx)
static void fstWriterFlushContextPrivate2(fstWriterContext *xc)
#else
static void fstWriterFlushContextPrivate(void *ctx)
static void fstWriterFlushContextPrivate(fstWriterContext *xc)
#endif
{
#ifdef FST_DEBUG
@ -1257,7 +1238,6 @@ static void fstWriterFlushContextPrivate(void *ctx)
unsigned char *packmem;
unsigned int packmemlen;
uint32_t *vm4ip;
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
#ifdef FST_WRITER_PARALLEL
struct fstWriterContext *xc2 = xc->xc_parent;
#else
@ -1775,10 +1755,8 @@ static void *fstWriterFlushContextPrivate1(void *ctx)
return (NULL);
}
static void fstWriterFlushContextPrivate(void *ctx)
static void fstWriterFlushContextPrivate(fstWriterContext *xc)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc->parallel_enabled) {
struct fstWriterContext *xc2 =
(struct fstWriterContext *)malloc(sizeof(struct fstWriterContext));
@ -1852,9 +1830,8 @@ static void fstWriterFlushContextPrivate(void *ctx)
/*
* queues up a flush context operation
*/
void fstWriterFlushContext(void *ctx)
void fstWriterFlushContext(fstWriterContext *xc)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
if (xc->tchn_idx > 1) {
xc->flush_context_pending = 1;
@ -1865,10 +1842,8 @@ void fstWriterFlushContext(void *ctx)
/*
* close out FST file
*/
void fstWriterClose(void *ctx)
void fstWriterClose(fstWriterContext *xc)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
#ifdef FST_WRITER_PARALLEL
if (xc) {
pthread_mutex_lock(&xc->mutex);
@ -2234,9 +2209,8 @@ void fstWriterClose(void *ctx)
/*
* functions to set miscellaneous header/block information
*/
void fstWriterSetDate(void *ctx, const char *dat)
void fstWriterSetDate(fstWriterContext *xc, const char *dat)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
char s[FST_HDR_DATE_SIZE];
fst_off_t fpos = ftello(xc->handle);
@ -2251,9 +2225,8 @@ void fstWriterSetDate(void *ctx, const char *dat)
}
}
void fstWriterSetVersion(void *ctx, const char *vers)
void fstWriterSetVersion(fstWriterContext *xc, const char *vers)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc && vers) {
char s[FST_HDR_SIM_VERSION_SIZE];
fst_off_t fpos = ftello(xc->handle);
@ -2268,9 +2241,8 @@ void fstWriterSetVersion(void *ctx, const char *vers)
}
}
void fstWriterSetFileType(void *ctx, enum fstFileType filetype)
void fstWriterSetFileType(fstWriterContext *xc, enum fstFileType filetype)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
if (/*(filetype >= FST_FT_MIN) &&*/ (filetype <= FST_FT_MAX)) {
fst_off_t fpos = ftello(xc->handle);
@ -2285,9 +2257,11 @@ void fstWriterSetFileType(void *ctx, enum fstFileType filetype)
}
}
static void fstWriterSetAttrDoubleArgGeneric(void *ctx, int typ, uint64_t arg1, uint64_t arg2)
static void fstWriterSetAttrDoubleArgGeneric(fstWriterContext *xc,
int typ,
uint64_t arg1,
uint64_t arg2)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
unsigned char buf[11]; /* ceil(64/7) = 10 + null term */
unsigned char *pnt = fstCopyVarint64ToRight(buf, arg1);
@ -2300,9 +2274,8 @@ static void fstWriterSetAttrDoubleArgGeneric(void *ctx, int typ, uint64_t arg1,
}
}
static void fstWriterSetAttrGeneric(void *ctx, const char *comm, int typ, uint64_t arg)
static void fstWriterSetAttrGeneric(fstWriterContext *xc, const char *comm, int typ, uint64_t arg)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc && comm) {
char *s = strdup(comm);
char *sf = s;
@ -2318,14 +2291,12 @@ static void fstWriterSetAttrGeneric(void *ctx, const char *comm, int typ, uint64
}
}
static void fstWriterSetSourceStem_2(void *ctx,
static void fstWriterSetSourceStem_2(fstWriterContext *xc,
const char *path,
unsigned int line,
unsigned int use_realpath,
int typ)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc && path && path[0]) {
uint64_t sidx = 0;
int slen = strlen(path);
@ -2357,7 +2328,7 @@ static void fstWriterSetSourceStem_2(void *ctx,
}
}
void fstWriterSetSourceStem(void *ctx,
void fstWriterSetSourceStem(fstWriterContext *ctx,
const char *path,
unsigned int line,
unsigned int use_realpath)
@ -2365,7 +2336,7 @@ void fstWriterSetSourceStem(void *ctx,
fstWriterSetSourceStem_2(ctx, path, line, use_realpath, FST_MT_SOURCESTEM);
}
void fstWriterSetSourceInstantiationStem(void *ctx,
void fstWriterSetSourceInstantiationStem(fstWriterContext *ctx,
const char *path,
unsigned int line,
unsigned int use_realpath)
@ -2373,24 +2344,23 @@ void fstWriterSetSourceInstantiationStem(void *ctx,
fstWriterSetSourceStem_2(ctx, path, line, use_realpath, FST_MT_SOURCEISTEM);
}
void fstWriterSetComment(void *ctx, const char *comm)
void fstWriterSetComment(fstWriterContext *ctx, const char *comm)
{
fstWriterSetAttrGeneric(ctx, comm, FST_MT_COMMENT, 0);
}
void fstWriterSetValueList(void *ctx, const char *vl)
void fstWriterSetValueList(fstWriterContext *ctx, const char *vl)
{
fstWriterSetAttrGeneric(ctx, vl, FST_MT_VALUELIST, 0);
}
void fstWriterSetEnvVar(void *ctx, const char *envvar)
void fstWriterSetEnvVar(fstWriterContext *ctx, const char *envvar)
{
fstWriterSetAttrGeneric(ctx, envvar, FST_MT_ENVVAR, 0);
}
void fstWriterSetTimescale(void *ctx, int ts)
void fstWriterSetTimescale(fstWriterContext *xc, int ts)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
fst_off_t fpos = ftello(xc->handle);
fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_TIMESCALE, SEEK_SET);
@ -2400,9 +2370,8 @@ void fstWriterSetTimescale(void *ctx, int ts)
}
}
void fstWriterSetTimescaleFromString(void *ctx, const char *s)
void fstWriterSetTimescaleFromString(fstWriterContext *xc, const char *s)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc && s) {
int mat = 0;
int seconds_exp = -9;
@ -2458,13 +2427,12 @@ void fstWriterSetTimescaleFromString(void *ctx, const char *s)
seconds_exp += 2;
}
fstWriterSetTimescale(ctx, seconds_exp);
fstWriterSetTimescale(xc, seconds_exp);
}
}
void fstWriterSetTimezero(void *ctx, int64_t tim)
void fstWriterSetTimezero(fstWriterContext *xc, int64_t tim)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
fst_off_t fpos = ftello(xc->handle);
fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_TIMEZERO, SEEK_SET);
@ -2474,26 +2442,23 @@ void fstWriterSetTimezero(void *ctx, int64_t tim)
}
}
void fstWriterSetPackType(void *ctx, enum fstWriterPackType typ)
void fstWriterSetPackType(fstWriterContext *xc, enum fstWriterPackType typ)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
xc->fastpack = (typ != FST_WR_PT_ZLIB);
xc->fourpack = (typ == FST_WR_PT_LZ4);
}
}
void fstWriterSetRepackOnClose(void *ctx, int enable)
void fstWriterSetRepackOnClose(fstWriterContext *xc, int enable)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
xc->repack_on_close = (enable != 0);
}
}
void fstWriterSetParallelMode(void *ctx, int enable)
void fstWriterSetParallelMode(fstWriterContext *xc, int enable)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
xc->parallel_was_enabled |= xc->parallel_enabled; /* make sticky */
xc->parallel_enabled = (enable != 0);
@ -2508,17 +2473,15 @@ void fstWriterSetParallelMode(void *ctx, int enable)
}
}
void fstWriterSetDumpSizeLimit(void *ctx, uint64_t numbytes)
void fstWriterSetDumpSizeLimit(fstWriterContext *xc, uint64_t numbytes)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
xc->dump_size_limit = numbytes;
}
}
int fstWriterGetDumpSizeLimitReached(void *ctx)
int fstWriterGetDumpSizeLimitReached(fstWriterContext *xc)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
return (xc->size_limit_locked != 0);
}
@ -2526,9 +2489,8 @@ int fstWriterGetDumpSizeLimitReached(void *ctx)
return (0);
}
int fstWriterGetFseekFailed(void *ctx)
int fstWriterGetFseekFailed(fstWriterContext *xc)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
return (xc->fseek_failed != 0);
}
@ -2536,14 +2498,13 @@ int fstWriterGetFseekFailed(void *ctx)
return (0);
}
static int fstWriterGetFlushContextPendingInternal(struct fstWriterContext *xc)
static int fstWriterGetFlushContextPendingInternal(fstWriterContext *xc)
{
return (xc->vchg_siz >= xc->fst_break_size) || (xc->flush_context_pending);
}
int fstWriterGetFlushContextPending(void *ctx)
int fstWriterGetFlushContextPending(fstWriterContext *xc)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
return xc && !xc->is_initial_time && fstWriterGetFlushContextPendingInternal(xc);
}
@ -2552,7 +2513,7 @@ int fstWriterGetFlushContextPending(void *ctx)
* fstWriterCreateVar2() is used to dump VHDL or other languages, but the
* underlying variable needs to map to Verilog/SV via the proper fstVarType vt
*/
fstHandle fstWriterCreateVar2(void *ctx,
fstHandle fstWriterCreateVar2(fstWriterContext *ctx,
enum fstVarType vt,
enum fstVarDir vd,
uint32_t len,
@ -2569,14 +2530,13 @@ fstHandle fstWriterCreateVar2(void *ctx,
return (fstWriterCreateVar(ctx, vt, vd, len, nam, aliasHandle));
}
fstHandle fstWriterCreateVar(void *ctx,
fstHandle fstWriterCreateVar(fstWriterContext *xc,
enum fstVarType vt,
enum fstVarDir vd,
uint32_t len,
const char *nam,
fstHandle aliasHandle)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
unsigned int i;
int nlen, is_real;
@ -2660,13 +2620,11 @@ fstHandle fstWriterCreateVar(void *ctx,
return (0);
}
void fstWriterSetScope(void *ctx,
void fstWriterSetScope(fstWriterContext *xc,
enum fstScopeType scopetype,
const char *scopename,
const char *scopecomp)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
fputc(FST_ST_VCD_SCOPE, xc->hier_handle);
if (/*(scopetype < FST_ST_VCD_MODULE) ||*/ (scopetype > FST_ST_MAX)) {
@ -2692,24 +2650,20 @@ void fstWriterSetScope(void *ctx,
}
}
void fstWriterSetUpscope(void *ctx)
void fstWriterSetUpscope(fstWriterContext *xc)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
fputc(FST_ST_VCD_UPSCOPE, xc->hier_handle);
xc->hier_file_len++;
}
}
void fstWriterSetAttrBegin(void *ctx,
void fstWriterSetAttrBegin(fstWriterContext *xc,
enum fstAttrType attrtype,
int subtype,
const char *attrname,
uint64_t arg)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
fputc(FST_ST_GEN_ATTRBEGIN, xc->hier_handle);
if (/*(attrtype < FST_AT_MISC) ||*/ (attrtype > FST_AT_MAX)) {
@ -2750,17 +2704,15 @@ void fstWriterSetAttrBegin(void *ctx,
}
}
void fstWriterSetAttrEnd(void *ctx)
void fstWriterSetAttrEnd(fstWriterContext *xc)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
fputc(FST_ST_GEN_ATTREND, xc->hier_handle);
xc->hier_file_len++;
}
}
fstEnumHandle fstWriterCreateEnumTable(void *ctx,
fstEnumHandle fstWriterCreateEnumTable(fstWriterContext *xc,
const char *name,
uint32_t elem_count,
unsigned int min_valbits,
@ -2779,9 +2731,7 @@ fstEnumHandle fstWriterCreateEnumTable(void *ctx,
int pos = 0;
char *attr_str = NULL;
if (ctx && name && literal_arr && val_arr && (elem_count != 0)) {
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc && name && literal_arr && val_arr && (elem_count != 0)) {
uint32_t i;
name_len = strlen(name);
@ -2866,9 +2816,8 @@ fstEnumHandle fstWriterCreateEnumTable(void *ctx,
return (handle);
}
void fstWriterEmitEnumTableRef(void *ctx, fstEnumHandle handle)
void fstWriterEmitEnumTableRef(fstWriterContext *xc, fstEnumHandle handle)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc && handle) {
fstWriterSetAttrBegin(xc, FST_AT_MISC, FST_MT_ENUMTABLE, NULL, handle);
}
@ -2877,9 +2826,8 @@ void fstWriterEmitEnumTableRef(void *ctx, fstEnumHandle handle)
/*
* value and time change emission
*/
void fstWriterEmitValueChange(void *ctx, fstHandle handle, const void *val)
void fstWriterEmitValueChange(fstWriterContext *xc, fstHandle handle, const void *val)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
const unsigned char *buf = (const unsigned char *)val;
uint32_t offs;
int len;
@ -2987,7 +2935,10 @@ void fstWriterEmitValueChange(void *ctx, fstHandle handle, const void *val)
}
}
void fstWriterEmitValueChange32(void *ctx, fstHandle handle, uint32_t bits, uint32_t val)
void fstWriterEmitValueChange32(fstWriterContext *ctx,
fstHandle handle,
uint32_t bits,
uint32_t val)
{
char buf[32];
char *s = buf;
@ -2997,7 +2948,11 @@ void fstWriterEmitValueChange32(void *ctx, fstHandle handle, uint32_t bits, uint
}
fstWriterEmitValueChange(ctx, handle, buf);
}
void fstWriterEmitValueChange64(void *ctx, fstHandle handle, uint32_t bits, uint64_t val)
void fstWriterEmitValueChange64(fstWriterContext *ctx,
fstHandle handle,
uint32_t bits,
uint64_t val)
{
char buf[64];
char *s = buf;
@ -3007,11 +2962,14 @@ void fstWriterEmitValueChange64(void *ctx, fstHandle handle, uint32_t bits, uint
}
fstWriterEmitValueChange(ctx, handle, buf);
}
void fstWriterEmitValueChangeVec32(void *ctx, fstHandle handle, uint32_t bits, const uint32_t *val)
void fstWriterEmitValueChangeVec32(fstWriterContext *xc,
fstHandle handle,
uint32_t bits,
const uint32_t *val)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (FST_UNLIKELY(bits <= 32)) {
fstWriterEmitValueChange32(ctx, handle, bits, val[0]);
fstWriterEmitValueChange32(xc, handle, bits, val[0]);
} else if (FST_LIKELY(xc)) {
int bq = bits / 32;
int br = bits & 31;
@ -3047,14 +3005,16 @@ void fstWriterEmitValueChangeVec32(void *ctx, fstHandle handle, uint32_t bits, c
s += 4;
}
}
fstWriterEmitValueChange(ctx, handle, xc->outval_mem);
fstWriterEmitValueChange(xc, handle, xc->outval_mem);
}
}
void fstWriterEmitValueChangeVec64(void *ctx, fstHandle handle, uint32_t bits, const uint64_t *val)
void fstWriterEmitValueChangeVec64(fstWriterContext *xc,
fstHandle handle,
uint32_t bits,
const uint64_t *val)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (FST_UNLIKELY(bits <= 64)) {
fstWriterEmitValueChange64(ctx, handle, bits, val[0]);
fstWriterEmitValueChange64(xc, handle, bits, val[0]);
} else if (FST_LIKELY(xc)) {
int bq = bits / 64;
int br = bits & 63;
@ -3090,16 +3050,15 @@ void fstWriterEmitValueChangeVec64(void *ctx, fstHandle handle, uint32_t bits, c
s += 4;
}
}
fstWriterEmitValueChange(ctx, handle, xc->outval_mem);
fstWriterEmitValueChange(xc, handle, xc->outval_mem);
}
}
void fstWriterEmitVariableLengthValueChange(void *ctx,
void fstWriterEmitVariableLengthValueChange(fstWriterContext *xc,
fstHandle handle,
const void *val,
uint32_t len)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
const unsigned char *buf = (const unsigned char *)val;
if (FST_LIKELY((xc) && (handle <= xc->maxhandle))) {
@ -3143,9 +3102,8 @@ void fstWriterEmitVariableLengthValueChange(void *ctx,
}
}
void fstWriterEmitTimeChange(void *ctx, uint64_t tim)
void fstWriterEmitTimeChange(fstWriterContext *xc, uint64_t tim)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
unsigned int i;
int skip = 0;
if (xc) {
@ -3189,10 +3147,8 @@ void fstWriterEmitTimeChange(void *ctx, uint64_t tim)
}
}
void fstWriterEmitDumpActive(void *ctx, int enable)
void fstWriterEmitDumpActive(fstWriterContext *xc, int enable)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if (xc) {
struct fstBlackoutChain *b =
(struct fstBlackoutChain *)calloc(1, sizeof(struct fstBlackoutChain));
@ -3420,7 +3376,7 @@ static void fstWritex(struct fstReaderContext *xc,
/*
* scope -> flat name handling
*/
static void fstReaderDeallocateScopeData(struct fstReaderContext *xc)
static void fstReaderDeallocateScopeData(fstReaderContext *xc)
{
struct fstCurrHier *chp;
@ -3433,9 +3389,8 @@ static void fstReaderDeallocateScopeData(struct fstReaderContext *xc)
}
}
const char *fstReaderGetCurrentFlatScope(void *ctx)
const char *fstReaderGetCurrentFlatScope(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
return (xc->curr_flat_hier_nam ? xc->curr_flat_hier_nam : "");
} else {
@ -3443,9 +3398,8 @@ const char *fstReaderGetCurrentFlatScope(void *ctx)
}
}
void *fstReaderGetCurrentScopeUserInfo(void *ctx)
void *fstReaderGetCurrentScopeUserInfo(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
return (xc->curr_hier ? xc->curr_hier->user_info : NULL);
} else {
@ -3453,9 +3407,8 @@ void *fstReaderGetCurrentScopeUserInfo(void *ctx)
}
}
const char *fstReaderPopScope(void *ctx)
const char *fstReaderPopScope(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc && xc->curr_hier) {
struct fstCurrHier *ch = xc->curr_hier;
if (xc->curr_hier->prev) {
@ -3471,19 +3424,16 @@ const char *fstReaderPopScope(void *ctx)
return (NULL);
}
void fstReaderResetScope(void *ctx)
void fstReaderResetScope(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
while (fstReaderPopScope(xc))
; /* remove any already-built scoping info */
}
}
const char *fstReaderPushScope(void *ctx, const char *nam, void *user_info)
const char *fstReaderPushScope(fstReaderContext *xc, const char *nam, void *user_info)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
struct fstCurrHier *ch = (struct fstCurrHier *)malloc(sizeof(struct fstCurrHier));
int chl = xc->curr_hier ? xc->curr_hier->len : 0;
@ -3512,10 +3462,8 @@ const char *fstReaderPushScope(void *ctx, const char *nam, void *user_info)
return (NULL);
}
int fstReaderGetCurrentScopeLen(void *ctx)
int fstReaderGetCurrentScopeLen(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc && xc->curr_hier) {
return (xc->curr_hier->len);
}
@ -3523,9 +3471,8 @@ int fstReaderGetCurrentScopeLen(void *ctx)
return (0);
}
int fstReaderGetFseekFailed(void *ctx)
int fstReaderGetFseekFailed(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
return (xc->fseek_failed != 0);
}
@ -3536,10 +3483,8 @@ int fstReaderGetFseekFailed(void *ctx)
/*
* iter mask manipulation util functions
*/
int fstReaderGetFacProcessMask(void *ctx, fstHandle facidx)
int fstReaderGetFacProcessMask(fstReaderContext *xc, fstHandle facidx)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
facidx--;
if (facidx < xc->maxhandle) {
@ -3552,10 +3497,8 @@ int fstReaderGetFacProcessMask(void *ctx, fstHandle facidx)
return (0);
}
void fstReaderSetFacProcessMask(void *ctx, fstHandle facidx)
void fstReaderSetFacProcessMask(fstReaderContext *xc, fstHandle facidx)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
facidx--;
if (facidx < xc->maxhandle) {
@ -3567,10 +3510,8 @@ void fstReaderSetFacProcessMask(void *ctx, fstHandle facidx)
}
}
void fstReaderClrFacProcessMask(void *ctx, fstHandle facidx)
void fstReaderClrFacProcessMask(fstReaderContext *xc, fstHandle facidx)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
facidx--;
if (facidx < xc->maxhandle) {
@ -3582,19 +3523,15 @@ void fstReaderClrFacProcessMask(void *ctx, fstHandle facidx)
}
}
void fstReaderSetFacProcessMaskAll(void *ctx)
void fstReaderSetFacProcessMaskAll(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
memset(xc->process_mask, 0xff, (xc->maxhandle + 7) / 8);
}
}
void fstReaderClrFacProcessMaskAll(void *ctx)
void fstReaderClrFacProcessMaskAll(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
memset(xc->process_mask, 0x00, (xc->maxhandle + 7) / 8);
}
@ -3603,100 +3540,83 @@ void fstReaderClrFacProcessMaskAll(void *ctx)
/*
* various utility read/write functions
*/
signed char fstReaderGetTimescale(void *ctx)
signed char fstReaderGetTimescale(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->timescale : 0);
}
uint64_t fstReaderGetStartTime(void *ctx)
uint64_t fstReaderGetStartTime(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->start_time : 0);
}
uint64_t fstReaderGetEndTime(void *ctx)
uint64_t fstReaderGetEndTime(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->end_time : 0);
}
uint64_t fstReaderGetMemoryUsedByWriter(void *ctx)
uint64_t fstReaderGetMemoryUsedByWriter(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->mem_used_by_writer : 0);
}
uint64_t fstReaderGetScopeCount(void *ctx)
uint64_t fstReaderGetScopeCount(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->scope_count : 0);
}
uint64_t fstReaderGetVarCount(void *ctx)
uint64_t fstReaderGetVarCount(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->var_count : 0);
}
fstHandle fstReaderGetMaxHandle(void *ctx)
fstHandle fstReaderGetMaxHandle(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->maxhandle : 0);
}
uint64_t fstReaderGetAliasCount(void *ctx)
uint64_t fstReaderGetAliasCount(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->num_alias : 0);
}
uint64_t fstReaderGetValueChangeSectionCount(void *ctx)
uint64_t fstReaderGetValueChangeSectionCount(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->vc_section_count : 0);
}
int fstReaderGetDoubleEndianMatchState(void *ctx)
int fstReaderGetDoubleEndianMatchState(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->double_endian_match : 0);
}
const char *fstReaderGetVersionString(void *ctx)
const char *fstReaderGetVersionString(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->version : NULL);
}
const char *fstReaderGetDateString(void *ctx)
const char *fstReaderGetDateString(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->date : NULL);
}
int fstReaderGetFileType(void *ctx)
int fstReaderGetFileType(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? (int)xc->filetype : (int)FST_FT_VERILOG);
}
int64_t fstReaderGetTimezero(void *ctx)
int64_t fstReaderGetTimezero(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->timezero : 0);
}
uint32_t fstReaderGetNumberDumpActivityChanges(void *ctx)
uint32_t fstReaderGetNumberDumpActivityChanges(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
return (xc ? xc->num_blackouts : 0);
}
uint64_t fstReaderGetDumpActivityChangeTime(void *ctx, uint32_t idx)
uint64_t fstReaderGetDumpActivityChangeTime(fstReaderContext *xc, uint32_t idx)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc && (idx < xc->num_blackouts) && (xc->blackout_times)) {
return (xc->blackout_times[idx]);
} else {
@ -3704,10 +3624,8 @@ uint64_t fstReaderGetDumpActivityChangeTime(void *ctx, uint32_t idx)
}
}
unsigned char fstReaderGetDumpActivityChangeValue(void *ctx, uint32_t idx)
unsigned char fstReaderGetDumpActivityChangeValue(fstReaderContext *xc, uint32_t idx)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc && (idx < xc->num_blackouts) && (xc->blackout_activity)) {
return (xc->blackout_activity[idx]);
} else {
@ -3715,10 +3633,8 @@ unsigned char fstReaderGetDumpActivityChangeValue(void *ctx, uint32_t idx)
}
}
void fstReaderSetLimitTimeRange(void *ctx, uint64_t start_time, uint64_t end_time)
void fstReaderSetLimitTimeRange(fstReaderContext *xc, uint64_t start_time, uint64_t end_time)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
xc->limit_range_valid = 1;
xc->limit_range_start = start_time;
@ -3726,27 +3642,22 @@ void fstReaderSetLimitTimeRange(void *ctx, uint64_t start_time, uint64_t end_tim
}
}
void fstReaderSetUnlimitedTimeRange(void *ctx)
void fstReaderSetUnlimitedTimeRange(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
xc->limit_range_valid = 0;
}
}
void fstReaderSetVcdExtensions(void *ctx, int enable)
void fstReaderSetVcdExtensions(fstReaderContext *xc, int enable)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
xc->use_vcd_extensions = (enable != 0);
}
}
void fstReaderIterBlocksSetNativeDoublesOnCallback(void *ctx, int enable)
void fstReaderIterBlocksSetNativeDoublesOnCallback(fstReaderContext *xc, int enable)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
xc->native_doubles_for_cb = (enable != 0);
}
@ -3942,9 +3853,8 @@ static int fstReaderRecreateHierFile(struct fstReaderContext *xc)
return (pass_status);
}
int fstReaderIterateHierRewind(void *ctx)
int fstReaderIterateHierRewind(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
int pass_status = 0;
if (xc) {
@ -3959,13 +3869,13 @@ int fstReaderIterateHierRewind(void *ctx)
return (pass_status);
}
struct fstHier *fstReaderIterateHier(void *ctx)
struct fstHier *fstReaderIterateHier(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
int isfeof;
fstHandle alias;
char *pnt;
int ch;
int unnamed_scope_idx = 0;
if (!xc)
return (NULL);
@ -3997,6 +3907,9 @@ struct fstHier *fstReaderIterateHier(void *ctx)
pnt[cl++] = ch;
}
}; /* scopename */
if (!cl) {
cl = snprintf(pnt, FST_ID_NAM_SIZ, "$unnamed_scope_%d", unnamed_scope_idx++);
}
pnt[cl] = 0;
xc->hier.u.scope.name_length = cl;
@ -4122,9 +4035,8 @@ struct fstHier *fstReaderIterateHier(void *ctx)
return (!isfeof ? &xc->hier : NULL);
}
int fstReaderProcessHier(void *ctx, FILE *fv)
int fstReaderProcessHier(fstReaderContext *xc, FILE *fv)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
char *str;
char *pnt;
int ch, scopetype;
@ -4136,6 +4048,7 @@ int fstReaderProcessHier(void *ctx, FILE *fv)
uint64_t attrarg;
fstHandle maxhandle_scanbuild;
int cl;
int unnamed_scope_idx = 0;
if (!xc)
return (0);
@ -4271,6 +4184,9 @@ int fstReaderProcessHier(void *ctx, FILE *fv)
pnt[cl++] = ch;
}
}; /* scopename */
if (!cl) {
cl = snprintf(pnt, FST_ID_NAM_SIZ, "$unnamed_scope_%d", unnamed_scope_idx++);
}
pnt[cl] = 0;
while (fgetc(xc->fh)) {
}; /* scopecomp */
@ -4802,18 +4718,16 @@ int fstReaderInit(struct fstReaderContext *xc)
return (hdr_seen);
}
void *fstReaderOpenForUtilitiesOnly(void)
fstReaderContext *fstReaderOpenForUtilitiesOnly(void)
{
struct fstReaderContext *xc =
(struct fstReaderContext *)calloc(1, sizeof(struct fstReaderContext));
fstReaderContext *xc = (fstReaderContext *)calloc(1, sizeof(fstReaderContext));
return (xc);
}
void *fstReaderOpen(const char *nam)
fstReaderContext *fstReaderOpen(const char *nam)
{
struct fstReaderContext *xc =
(struct fstReaderContext *)calloc(1, sizeof(struct fstReaderContext));
fstReaderContext *xc = (fstReaderContext *)calloc(1, sizeof(fstReaderContext));
if ((!nam) || (!(xc->f = fopen(nam, "rb")))) {
free(xc);
@ -4851,9 +4765,8 @@ void *fstReaderOpen(const char *nam)
return (xc);
}
static void fstReaderDeallocateRvatData(void *ctx)
static void fstReaderDeallocateRvatData(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
free(xc->rvat_chain_mem);
xc->rvat_chain_mem = NULL;
@ -4870,10 +4783,8 @@ static void fstReaderDeallocateRvatData(void *ctx)
}
}
void fstReaderClose(void *ctx)
void fstReaderClose(fstReaderContext *xc)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if (xc) {
fstReaderDeallocateScopeData(xc);
fstReaderDeallocateRvatData(xc);
@ -4918,7 +4829,7 @@ void fstReaderClose(void *ctx)
*/
/* normal read which re-interleaves the value change data */
int fstReaderIterBlocks(void *ctx,
int fstReaderIterBlocks(fstReaderContext *ctx,
void (*value_change_callback)(void *user_callback_data_pointer,
uint64_t time,
fstHandle facidx,
@ -4929,7 +4840,7 @@ int fstReaderIterBlocks(void *ctx,
return (fstReaderIterBlocks2(ctx, value_change_callback, NULL, user_callback_data_pointer, fv));
}
int fstReaderIterBlocks2(void *ctx,
int fstReaderIterBlocks2(fstReaderContext *ctx,
void (*value_change_callback)(void *user_callback_data_pointer,
uint64_t time,
fstHandle facidx,
@ -6003,7 +5914,7 @@ int fstReaderIterBlocks2(void *ctx,
/* rvat functions */
static char *fstExtractRvatDataFromFrame(struct fstReaderContext *xc, fstHandle facidx, char *buf)
static char *fstExtractRvatDataFromFrame(fstReaderContext *xc, fstHandle facidx, char *buf)
{
if (facidx >= xc->rvat_frame_maxhandle) {
return (NULL);
@ -6038,9 +5949,11 @@ static char *fstExtractRvatDataFromFrame(struct fstReaderContext *xc, fstHandle
return (buf);
}
char *fstReaderGetValueFromHandleAtTime(void *ctx, uint64_t tim, fstHandle facidx, char *buf)
char *fstReaderGetValueFromHandleAtTime(fstReaderContext *xc,
uint64_t tim,
fstHandle facidx,
char *buf)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
fst_off_t blkpos = 0, prev_blkpos;
uint64_t beg_tim, end_tim, beg_tim2, end_tim2;
int sectype;

176
include/gtkwave/fstapi.h
View File

@ -43,8 +43,6 @@ extern "C"
#endif
#include <time.h>
#define FST_RDLOAD "FSTLOAD | "
typedef uint32_t fstHandle;
typedef uint32_t fstEnumHandle;
@ -372,16 +370,19 @@ struct fstETab
/*
* writer functions
*/
void fstWriterClose(void *ctx);
void *fstWriterCreate(const char *nam, int use_compressed_hier);
fstEnumHandle fstWriterCreateEnumTable(void *ctx,
typedef struct fstWriterContext fstWriterContext;
void fstWriterClose(fstWriterContext *ctx);
fstWriterContext *fstWriterCreate(const char *nam, int use_compressed_hier);
fstEnumHandle fstWriterCreateEnumTable(fstWriterContext *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,
fstHandle fstWriterCreateVar(fstWriterContext *ctx,
enum fstVarType vt,
enum fstVarDir vd,
uint32_t len,
@ -390,7 +391,7 @@ fstHandle fstWriterCreateVar(void *ctx,
/* future expansion for VHDL and other languages. The variable type, data type, etc map onto
the current Verilog/SV one. The "type" string is optional for a more verbose or custom
description */
fstHandle fstWriterCreateVar2(void *ctx,
fstHandle fstWriterCreateVar2(fstWriterContext *ctx,
enum fstVarType vt,
enum fstVarDir vd,
uint32_t len,
@ -399,100 +400,113 @@ fstHandle fstWriterCreateVar2(void *ctx,
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 fstWriterEmitValueChange32(void *ctx, fstHandle handle, uint32_t bits, uint32_t val);
void fstWriterEmitValueChange64(void *ctx, fstHandle handle, uint32_t bits, uint64_t val);
void fstWriterEmitValueChangeVec32(void *ctx,
void fstWriterEmitDumpActive(fstWriterContext *ctx, int enable);
void fstWriterEmitEnumTableRef(fstWriterContext *ctx, fstEnumHandle handle);
void fstWriterEmitValueChange(fstWriterContext *ctx, fstHandle handle, const void *val);
void fstWriterEmitValueChange32(fstWriterContext *ctx,
fstHandle handle,
uint32_t bits,
uint32_t val);
void fstWriterEmitValueChange64(fstWriterContext *ctx,
fstHandle handle,
uint32_t bits,
uint64_t val);
void fstWriterEmitValueChangeVec32(fstWriterContext *ctx,
fstHandle handle,
uint32_t bits,
const uint32_t *val);
void fstWriterEmitValueChangeVec64(void *ctx,
void fstWriterEmitValueChangeVec64(fstWriterContext *ctx,
fstHandle handle,
uint32_t bits,
const uint64_t *val);
void fstWriterEmitVariableLengthValueChange(void *ctx,
void fstWriterEmitVariableLengthValueChange(fstWriterContext *ctx,
fstHandle handle,
const void *val,
uint32_t len);
void fstWriterEmitTimeChange(void *ctx, uint64_t tim);
void fstWriterFlushContext(void *ctx);
int fstWriterGetDumpSizeLimitReached(void *ctx);
int fstWriterGetFseekFailed(void *ctx);
int fstWriterGetFlushContextPending(void *ctx);
void fstWriterSetAttrBegin(void *ctx,
void fstWriterEmitTimeChange(fstWriterContext *ctx, uint64_t tim);
void fstWriterFlushContext(fstWriterContext *ctx);
int fstWriterGetDumpSizeLimitReached(fstWriterContext *ctx);
int fstWriterGetFseekFailed(fstWriterContext *ctx);
int fstWriterGetFlushContextPending(fstWriterContext *ctx);
void fstWriterSetAttrBegin(fstWriterContext *ctx,
enum fstAttrType attrtype,
int subtype,
const char *attrname,
uint64_t arg);
void fstWriterSetAttrEnd(void *ctx);
void fstWriterSetComment(void *ctx, const char *comm);
void fstWriterSetDate(void *ctx, const char *dat);
void fstWriterSetDumpSizeLimit(void *ctx, uint64_t numbytes);
void fstWriterSetEnvVar(void *ctx, const char *envvar);
void fstWriterSetFileType(void *ctx, enum fstFileType filetype);
void fstWriterSetPackType(void *ctx, enum fstWriterPackType typ);
void fstWriterSetParallelMode(void *ctx, int enable);
void fstWriterSetRepackOnClose(void *ctx, int enable); /* type = 0 (none), 1 (libz) */
void fstWriterSetScope(void *ctx,
void fstWriterSetAttrEnd(fstWriterContext *ctx);
void fstWriterSetComment(fstWriterContext *ctx, const char *comm);
void fstWriterSetDate(fstWriterContext *ctx, const char *dat);
void fstWriterSetDumpSizeLimit(fstWriterContext *ctx, uint64_t numbytes);
void fstWriterSetEnvVar(fstWriterContext *ctx, const char *envvar);
void fstWriterSetFileType(fstWriterContext *ctx, enum fstFileType filetype);
void fstWriterSetPackType(fstWriterContext *ctx, enum fstWriterPackType typ);
void fstWriterSetParallelMode(fstWriterContext *ctx, int enable);
void fstWriterSetRepackOnClose(fstWriterContext *ctx,
int enable); /* type = 0 (none), 1 (libz) */
void fstWriterSetScope(fstWriterContext *ctx,
enum fstScopeType scopetype,
const char *scopename,
const char *scopecomp);
void fstWriterSetSourceInstantiationStem(void *ctx,
void fstWriterSetSourceInstantiationStem(fstWriterContext *ctx,
const char *path,
unsigned int line,
unsigned int use_realpath);
void fstWriterSetSourceStem(void *ctx,
void fstWriterSetSourceStem(fstWriterContext *ctx,
const char *path,
unsigned int line,
unsigned int use_realpath);
void fstWriterSetTimescale(void *ctx, int ts);
void fstWriterSetTimescaleFromString(void *ctx, const char *s);
void fstWriterSetTimezero(void *ctx, int64_t tim);
void fstWriterSetUpscope(void *ctx);
void fstWriterSetValueList(void *ctx, const char *vl);
void fstWriterSetVersion(void *ctx, const char *vers);
void fstWriterSetTimescale(fstWriterContext *ctx, int ts);
void fstWriterSetTimescaleFromString(fstWriterContext *ctx, const char *s);
void fstWriterSetTimezero(fstWriterContext *ctx, int64_t tim);
void fstWriterSetUpscope(fstWriterContext *ctx);
void fstWriterSetValueList(fstWriterContext *ctx, const char *vl);
void fstWriterSetVersion(fstWriterContext *ctx, const char *vers);
/*
* reader functions
*/
void fstReaderClose(void *ctx);
void fstReaderClrFacProcessMask(void *ctx, fstHandle facidx);
void fstReaderClrFacProcessMaskAll(void *ctx);
uint64_t fstReaderGetAliasCount(void *ctx);
const char *fstReaderGetCurrentFlatScope(void *ctx);
void *fstReaderGetCurrentScopeUserInfo(void *ctx);
int fstReaderGetCurrentScopeLen(void *ctx);
const char *fstReaderGetDateString(void *ctx);
int fstReaderGetDoubleEndianMatchState(void *ctx);
uint64_t fstReaderGetDumpActivityChangeTime(void *ctx, uint32_t idx);
unsigned char fstReaderGetDumpActivityChangeValue(void *ctx, uint32_t idx);
uint64_t fstReaderGetEndTime(void *ctx);
int fstReaderGetFacProcessMask(void *ctx, fstHandle facidx);
int fstReaderGetFileType(void *ctx);
int fstReaderGetFseekFailed(void *ctx);
fstHandle fstReaderGetMaxHandle(void *ctx);
uint64_t fstReaderGetMemoryUsedByWriter(void *ctx);
uint32_t fstReaderGetNumberDumpActivityChanges(void *ctx);
uint64_t fstReaderGetScopeCount(void *ctx);
uint64_t fstReaderGetStartTime(void *ctx);
signed char fstReaderGetTimescale(void *ctx);
int64_t fstReaderGetTimezero(void *ctx);
uint64_t fstReaderGetValueChangeSectionCount(void *ctx);
char *fstReaderGetValueFromHandleAtTime(void *ctx, uint64_t tim, fstHandle facidx, char *buf);
uint64_t fstReaderGetVarCount(void *ctx);
const char *fstReaderGetVersionString(void *ctx);
struct fstHier *fstReaderIterateHier(void *ctx);
int fstReaderIterateHierRewind(void *ctx);
int fstReaderIterBlocks(void *ctx,
typedef struct fstReaderContext fstReaderContext;
void fstReaderClose(fstReaderContext *ctx);
void fstReaderClrFacProcessMask(fstReaderContext *ctx, fstHandle facidx);
void fstReaderClrFacProcessMaskAll(fstReaderContext *ctx);
uint64_t fstReaderGetAliasCount(fstReaderContext *ctx);
const char *fstReaderGetCurrentFlatScope(fstReaderContext *ctx);
void *fstReaderGetCurrentScopeUserInfo(fstReaderContext *ctx);
int fstReaderGetCurrentScopeLen(fstReaderContext *ctx);
const char *fstReaderGetDateString(fstReaderContext *ctx);
int fstReaderGetDoubleEndianMatchState(fstReaderContext *ctx);
uint64_t fstReaderGetDumpActivityChangeTime(fstReaderContext *ctx, uint32_t idx);
unsigned char fstReaderGetDumpActivityChangeValue(fstReaderContext *ctx, uint32_t idx);
uint64_t fstReaderGetEndTime(fstReaderContext *ctx);
int fstReaderGetFacProcessMask(fstReaderContext *ctx, fstHandle facidx);
int fstReaderGetFileType(fstReaderContext *ctx);
int fstReaderGetFseekFailed(fstReaderContext *ctx);
fstHandle fstReaderGetMaxHandle(fstReaderContext *ctx);
uint64_t fstReaderGetMemoryUsedByWriter(fstReaderContext *ctx);
uint32_t fstReaderGetNumberDumpActivityChanges(fstReaderContext *ctx);
uint64_t fstReaderGetScopeCount(fstReaderContext *ctx);
uint64_t fstReaderGetStartTime(fstReaderContext *ctx);
signed char fstReaderGetTimescale(fstReaderContext *ctx);
int64_t fstReaderGetTimezero(fstReaderContext *ctx);
uint64_t fstReaderGetValueChangeSectionCount(fstReaderContext *ctx);
char *fstReaderGetValueFromHandleAtTime(fstReaderContext *ctx,
uint64_t tim,
fstHandle facidx,
char *buf);
uint64_t fstReaderGetVarCount(fstReaderContext *ctx);
const char *fstReaderGetVersionString(fstReaderContext *ctx);
struct fstHier *fstReaderIterateHier(fstReaderContext *ctx);
int fstReaderIterateHierRewind(fstReaderContext *ctx);
int fstReaderIterBlocks(fstReaderContext *ctx,
void (*value_change_callback)(void *user_callback_data_pointer,
uint64_t time,
fstHandle facidx,
const unsigned char *value),
void *user_callback_data_pointer,
FILE *vcdhandle);
int fstReaderIterBlocks2(void *ctx,
int fstReaderIterBlocks2(fstReaderContext *ctx,
void (*value_change_callback)(void *user_callback_data_pointer,
uint64_t time,
fstHandle facidx,
@ -504,18 +518,18 @@ int fstReaderIterBlocks2(void *ctx,
uint32_t len),
void *user_callback_data_pointer,
FILE *vcdhandle);
void fstReaderIterBlocksSetNativeDoublesOnCallback(void *ctx, int enable);
void *fstReaderOpen(const char *nam);
void *fstReaderOpenForUtilitiesOnly(void);
const char *fstReaderPopScope(void *ctx);
int fstReaderProcessHier(void *ctx, FILE *vcdhandle);
const char *fstReaderPushScope(void *ctx, const char *nam, void *user_info);
void fstReaderResetScope(void *ctx);
void fstReaderSetFacProcessMask(void *ctx, fstHandle facidx);
void fstReaderSetFacProcessMaskAll(void *ctx);
void fstReaderSetLimitTimeRange(void *ctx, uint64_t start_time, uint64_t end_time);
void fstReaderSetUnlimitedTimeRange(void *ctx);
void fstReaderSetVcdExtensions(void *ctx, int enable);
void fstReaderIterBlocksSetNativeDoublesOnCallback(fstReaderContext *ctx, int enable);
fstReaderContext *fstReaderOpen(const char *nam);
fstReaderContext *fstReaderOpenForUtilitiesOnly(void);
const char *fstReaderPopScope(fstReaderContext *ctx);
int fstReaderProcessHier(fstReaderContext *ctx, FILE *vcdhandle);
const char *fstReaderPushScope(fstReaderContext *ctx, const char *nam, void *user_info);
void fstReaderResetScope(fstReaderContext *ctx);
void fstReaderSetFacProcessMask(fstReaderContext *ctx, fstHandle facidx);
void fstReaderSetFacProcessMaskAll(fstReaderContext *ctx);
void fstReaderSetLimitTimeRange(fstReaderContext *ctx, uint64_t start_time, uint64_t end_time);
void fstReaderSetUnlimitedTimeRange(fstReaderContext *ctx);
void fstReaderSetVcdExtensions(fstReaderContext *ctx, int enable);
/*
* utility functions

6
include/verilated_fst_c.h
View File

@ -34,6 +34,8 @@ typedef uint32_t vlFstEnumHandle;
class VerilatedFstBuffer;
struct fstWriterContext;
//=============================================================================
// VerilatedFst
// Base class to create a Verilator FST dump
@ -49,7 +51,7 @@ private:
//=========================================================================
// FST-specific internals
void* m_fst = nullptr;
fstWriterContext* m_fst = nullptr;
std::map<uint32_t, vlFstHandle> m_code2symbol;
std::map<int, vlFstEnumHandle> m_local2fstdtype;
vlFstHandle* m_symbolp = nullptr; // same as m_code2symbol, but as an array
@ -161,7 +163,7 @@ class VerilatedFstBuffer VL_NOT_FINAL {
VerilatedFst& m_owner; // Trace file owning this buffer. Required by subclasses.
// The FST file handle
void* const m_fst = m_owner.m_fst;
fstWriterContext* const m_fst = m_owner.m_fst;
// code to fstHande map, as an array
const vlFstHandle* const m_symbolp = m_owner.m_symbolp;
// String buffer long enough to hold maxBits() chars