From cc402ee0657992555e48a5562c2a176176b3b3b9 Mon Sep 17 00:00:00 2001 From: Krystine Sherwin <93062060+KrystalDelusion@users.noreply.github.com> Date: Mon, 12 May 2025 10:21:06 +1200 Subject: [PATCH] libs/fst: Update upstream libfst is no longer included in gtkwave and instead has its own repo. There has also been some refactoring, so the patches need to update to match, as does sim.cc. --- libs/fst/00_PATCH_i386_endian.patch | 20 +- libs/fst/00_PATCH_win_io.patch | 6 +- libs/fst/00_PATCH_win_zlib.patch | 8 +- libs/fst/00_PATCH_wx_len_overread.patch | 12 +- libs/fst/00_UPDATE.sh | 7 +- libs/fst/fstapi.cc | 10227 +++++++++++----------- libs/fst/fstapi.h | 733 +- passes/sat/sim.cc | 4 +- 8 files changed, 5441 insertions(+), 5576 deletions(-) diff --git a/libs/fst/00_PATCH_i386_endian.patch b/libs/fst/00_PATCH_i386_endian.patch index 3857f1fdf..5c987fbe4 100644 --- a/libs/fst/00_PATCH_i386_endian.patch +++ b/libs/fst/00_PATCH_i386_endian.patch @@ -1,14 +1,14 @@ --- fstapi.cc +++ fstapi.cc @@ -4723,7 +4723,10 @@ if(gzread_pass_status) - hdr_incomplete = (xc->start_time == 0) && (xc->end_time == 0); + hdr_incomplete = (xc->start_time == 0) && (xc->end_time == 0); - fstFread(&dcheck, 8, 1, xc->f); -- xc->double_endian_match = (dcheck == FST_DOUBLE_ENDTEST); -+ /* -+ * Yosys patch: Fix double endian check for i386 targets built in modern gcc -+ */ -+ xc->double_endian_match = (dcheck == (double)FST_DOUBLE_ENDTEST); - if(!xc->double_endian_match) - { - union { + fstFread(&dcheck, 8, 1, xc->f); +- xc->double_endian_match = (dcheck == FST_DOUBLE_ENDTEST); ++ /* ++ * Yosys patch: Fix double endian check for i386 targets built in modern gcc ++ */ ++ xc->double_endian_match = (dcheck == (double)FST_DOUBLE_ENDTEST); + if (!xc->double_endian_match) { + union + { diff --git a/libs/fst/00_PATCH_win_io.patch b/libs/fst/00_PATCH_win_io.patch index a5bc989a8..807b4ab07 100644 --- a/libs/fst/00_PATCH_win_io.patch +++ b/libs/fst/00_PATCH_win_io.patch @@ -23,9 +23,9 @@ @@ -137,7 +137,7 @@ void **JenkinsIns(void *base_i, const unsigned char *mem, uint32_t length, uint3 #include #endif - --#if defined(FST_MACOSX) || defined(__MINGW32__) || defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__) -+#if defined(FST_MACOSX) || defined(__MINGW32__) || defined(_MSC_VER) || defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__) + #if defined(FST_MACOSX) || defined(__MINGW32__) || defined(__OpenBSD__) || defined(__FreeBSD__) || \ +- defined(__NetBSD__) ++ defined(__NetBSD__) || defined(_MSC_VER) #define FST_UNBUFFERED_IO #endif diff --git a/libs/fst/00_PATCH_win_zlib.patch b/libs/fst/00_PATCH_win_zlib.patch index 125e7cf58..762e0f4df 100644 --- a/libs/fst/00_PATCH_win_zlib.patch +++ b/libs/fst/00_PATCH_win_zlib.patch @@ -7,10 +7,10 @@ -#include #include #if defined(_MSC_VER) -+ #include "libs/zlib/zlib.h" - #include "fst_win_unistd.h" ++#include "libs/zlib/zlib.h" + #include "fst_win_unistd.h" #else -+ #include - #include ++#include + #include #endif #include diff --git a/libs/fst/00_PATCH_wx_len_overread.patch b/libs/fst/00_PATCH_wx_len_overread.patch index 7fba1c2d6..43a5fd476 100644 --- a/libs/fst/00_PATCH_wx_len_overread.patch +++ b/libs/fst/00_PATCH_wx_len_overread.patch @@ -1,10 +1,10 @@ --- fstapi.cc +++ fstapi.cc @@ -6072,6 +6072,7 @@ for(;;) - } + } - wx_len = snprintf(wx_buf, 32, "r%.16g", d); -+ if (wx_len > 32 || wx_len < 0) wx_len = 32; - fstWritex(xc, wx_buf, wx_len); - } - } + wx_len = snprintf(wx_buf, 32, "r%.16g", d); ++ if (wx_len > 32 || wx_len < 0) wx_len = 32; + fstWritex(xc, wx_buf, wx_len); + } + } diff --git a/libs/fst/00_UPDATE.sh b/libs/fst/00_UPDATE.sh index 302e187f2..91dcd84ff 100755 --- a/libs/fst/00_UPDATE.sh +++ b/libs/fst/00_UPDATE.sh @@ -2,9 +2,10 @@ mv config.h config.h.bak rm -f *.txt *.cc *.h -git clone --depth 1 https://github.com/gtkwave/gtkwave fst_upstream -rm fst_upstream/lib/libfst/CMakeLists.txt -mv fst_upstream/lib/libfst/*.{h,c,txt} . +git clone --depth 1 https://github.com/gtkwave/libfst fst_upstream +rm fst_upstream/src/meson.build +mv fst_upstream/src/*.{h,c} . +mv fst_upstream/doc/block_format.txt . rm -rf fst_upstream for src in *.c; do diff --git a/libs/fst/fstapi.cc b/libs/fst/fstapi.cc index 2463e6f15..47f07fa82 100644 --- a/libs/fst/fstapi.cc +++ b/libs/fst/fstapi.cc @@ -34,14 +34,12 @@ * FST_DEBUG : not for production use, only enable for development * FST_REMOVE_DUPLICATE_VC : glitch removal (has writer performance impact) * HAVE_LIBPTHREAD -> FST_WRITER_PARALLEL : enables inclusion of parallel writer code - * _WAVE_HAVE_JUDY : use Judy arrays instead of Jenkins (undefine if LGPL is not acceptable) * */ -#ifndef FST_CONFIG_INCLUDE -# define FST_CONFIG_INCLUDE "config.h" +#ifdef FST_INCLUDE_CONFIG +#include "config.h" #endif -#include FST_CONFIG_INCLUDE #include "fstapi.h" #include "fastlz.h" @@ -61,21 +59,6 @@ #include #endif -#ifdef HAVE_ALLOCA_H -#include -#elif defined(__GNUC__) -#ifndef __MINGW32__ -#ifndef alloca -#define alloca __builtin_alloca -#endif -#else -#include -#endif -#elif defined(_MSC_VER) -#include -#define alloca _alloca -#endif - #ifndef PATH_MAX #define PATH_MAX (4096) #endif @@ -86,58 +69,48 @@ typedef int64_t fst_off_t; typedef off_t fst_off_t; #endif -/* note that Judy versus Jenkins requires more experimentation: they are */ -/* functionally equivalent though it appears Jenkins is slightly faster. */ -/* in addition, Jenkins is not bound by the LGPL. */ -#ifdef _WAVE_HAVE_JUDY -#include -#else /* should be more than enough for fstWriterSetSourceStem() */ -#define FST_PATH_HASHMASK ((1UL << 16) - 1) +#define FST_PATH_HASHMASK ((1UL << 16) - 1) typedef const void *Pcvoid_t; typedef void *Pvoid_t; typedef void **PPvoid_t; -#define JudyHSIns(a,b,c,d) JenkinsIns((a),(b),(c),(hashmask)) -#define JudyHSFreeArray(a,b) JenkinsFree((a),(hashmask)) void JenkinsFree(void *base_i, uint32_t hashmask); void **JenkinsIns(void *base_i, const unsigned char *mem, uint32_t length, uint32_t hashmask); -#endif - #ifndef FST_WRITEX_DISABLE -#define FST_WRITEX_MAX (64 * 1024) +#define FST_WRITEX_MAX (64 * 1024) #else -#define fstWritex(a,b,c) fstFwrite((b), (c), 1, fv) +#define fstWritex(a, b, c) fstFwrite((b), (c), 1, fv) #endif - /* these defines have a large impact on writer speed when a model has a */ /* huge number of symbols. as a default, use 128MB and increment when */ /* every 1M signals are defined. */ -#define FST_BREAK_SIZE (1UL << 27) -#define FST_BREAK_ADD_SIZE (1UL << 22) -#define FST_BREAK_SIZE_MAX (1UL << 31) -#define FST_ACTIVATE_HUGE_BREAK (1000000) -#define FST_ACTIVATE_HUGE_INC (1000000) +#define FST_BREAK_SIZE (1UL << 27) +#define FST_BREAK_ADD_SIZE (1UL << 22) +#define FST_BREAK_SIZE_MAX (1UL << 31) +#define FST_ACTIVATE_HUGE_BREAK (1000000) +#define FST_ACTIVATE_HUGE_INC (1000000) -#define FST_WRITER_STR "fstWriter" -#define FST_ID_NAM_SIZ (512) -#define FST_ID_NAM_ATTR_SIZ (65536+4096) -#define FST_DOUBLE_ENDTEST (2.7182818284590452354) -#define FST_HDR_SIM_VERSION_SIZE (128) -#define FST_HDR_DATE_SIZE (119) -#define FST_HDR_FILETYPE_SIZE (1) -#define FST_HDR_TIMEZERO_SIZE (8) -#define FST_GZIO_LEN (32768) -#define FST_HDR_FOURPACK_DUO_SIZE (4*1024*1024) -#define FST_ZWRAPPER_HDR_SIZE (1+8+8) +#define FST_WRITER_STR "fstWriter" +#define FST_ID_NAM_SIZ (512) +#define FST_ID_NAM_ATTR_SIZ (65536 + 4096) +#define FST_DOUBLE_ENDTEST (2.7182818284590452354) +#define FST_HDR_SIM_VERSION_SIZE (128) +#define FST_HDR_DATE_SIZE (119) +#define FST_HDR_FILETYPE_SIZE (1) +#define FST_HDR_TIMEZERO_SIZE (8) +#define FST_GZIO_LEN (32768) +#define FST_HDR_FOURPACK_DUO_SIZE (4 * 1024 * 1024) +#define FST_ZWRAPPER_HDR_SIZE (1 + 8 + 8) #if defined(__APPLE__) && defined(__MACH__) #define FST_MACOSX #include #endif -#if defined(FST_MACOSX) || defined(__MINGW32__) || defined(_MSC_VER) || defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__) +#if defined(FST_MACOSX) || defined(__MINGW32__) || defined(__OpenBSD__) || defined(__FreeBSD__) || \ + defined(__NetBSD__) || defined(_MSC_VER) #define FST_UNBUFFERED_IO #endif @@ -175,138 +148,131 @@ void **JenkinsIns(void *base_i, const unsigned char *mem, uint32_t length, uint3 * this is currently not implemented so that the branchless decode is: * uint32_t shcnt = 2 << (vli & 1); tdelta = vli >> shcnt; */ -#define FST_RCV_X (1 | (0<<1)) -#define FST_RCV_Z (1 | (1<<1)) -#define FST_RCV_H (1 | (2<<1)) -#define FST_RCV_U (1 | (3<<1)) -#define FST_RCV_W (1 | (4<<1)) -#define FST_RCV_L (1 | (5<<1)) -#define FST_RCV_D (1 | (6<<1)) -#define FST_RCV_Q (1 | (7<<1)) +#define FST_RCV_X (1 | (0 << 1)) +#define FST_RCV_Z (1 | (1 << 1)) +#define FST_RCV_H (1 | (2 << 1)) +#define FST_RCV_U (1 | (3 << 1)) +#define FST_RCV_W (1 | (4 << 1)) +#define FST_RCV_L (1 | (5 << 1)) +#define FST_RCV_D (1 | (6 << 1)) +#define FST_RCV_Q (1 | (7 << 1)) #define FST_RCV_STR "xzhuwl-?" /* 01234567 */ - /* * report abort messages */ static void chk_report_abort(const char *s) { -fprintf(stderr,"Triggered %s security check, exiting.\n", s); -abort(); + fprintf(stderr, "Triggered %s security check, exiting.\n", s); + abort(); } - /* * prevent old file overwrite when currently being read */ static FILE *unlink_fopen(const char *nam, const char *mode) { -unlink(nam); -return(fopen(nam, mode)); + unlink(nam); + return (fopen(nam, mode)); } - /* * system-specific temp file handling */ #ifdef __MINGW32__ -static FILE* tmpfile_open(char **nam) +static FILE *tmpfile_open(char **nam) { -char *fname = NULL; -TCHAR szTempFileName[MAX_PATH]; -TCHAR lpTempPathBuffer[MAX_PATH]; -DWORD dwRetVal = 0; -UINT uRetVal = 0; -FILE *fh = NULL; + char *fname = NULL; + TCHAR szTempFileName[MAX_PATH]; + TCHAR lpTempPathBuffer[MAX_PATH]; + DWORD dwRetVal = 0; + UINT uRetVal = 0; + FILE *fh = NULL; -if(nam) /* cppcheck warning fix: nam is always defined, so this is not needed */ - { + if (nam) /* cppcheck warning fix: nam is always defined, so this is not needed */ + { dwRetVal = GetTempPath(MAX_PATH, lpTempPathBuffer); - if((dwRetVal > MAX_PATH) || (dwRetVal == 0)) - { - fprintf(stderr, FST_APIMESS "GetTempPath() failed in " __FILE__ " line %d, exiting.\n", __LINE__); + if ((dwRetVal > MAX_PATH) || (dwRetVal == 0)) { + fprintf(stderr, + FST_APIMESS "GetTempPath() failed in " __FILE__ " line %d, exiting.\n", + __LINE__); + exit(255); + } else { + uRetVal = GetTempFileName(lpTempPathBuffer, TEXT("FSTW"), 0, szTempFileName); + if (uRetVal == 0) { + fprintf(stderr, + FST_APIMESS "GetTempFileName() failed in " __FILE__ " line %d, exiting.\n", + __LINE__); exit(255); - } - else - { - uRetVal = GetTempFileName(lpTempPathBuffer, TEXT("FSTW"), 0, szTempFileName); - if (uRetVal == 0) - { - fprintf(stderr, FST_APIMESS "GetTempFileName() failed in " __FILE__ " line %d, exiting.\n", __LINE__); - exit(255); - } - else - { - fname = strdup(szTempFileName); - } - } - - if(fname) - { - *nam = fname; - fh = unlink_fopen(fname, "w+b"); - } + } else { + fname = strdup(szTempFileName); + } } -return(fh); + if (fname) { + *nam = fname; + fh = unlink_fopen(fname, "w+b"); + } + } + + return (fh); } #else -static FILE* tmpfile_open(char **nam) +static FILE *tmpfile_open(char **nam) { -FILE *f = tmpfile(); /* replace with mkstemp() + fopen(), etc if this is not good enough */ -if(nam) { *nam = NULL; } -return(f); + FILE *f = tmpfile(); /* replace with mkstemp() + fopen(), etc if this is not good enough */ + if (nam) { + *nam = NULL; + } + return (f); } #endif - static void tmpfile_close(FILE **f, char **nam) { -if(f) - { - if(*f) { fclose(*f); *f = NULL; } + if (f) { + if (*f) { + fclose(*f); + *f = NULL; } + } -if(nam) - { - if(*nam) - { - unlink(*nam); - free(*nam); - *nam = NULL; - } + if (nam) { + if (*nam) { + unlink(*nam); + free(*nam); + *nam = NULL; } + } } /*****************************************/ - /* * to remove warn_unused_result compile time messages * (in the future there needs to be results checking) */ static size_t fstFread(void *buf, size_t siz, size_t cnt, FILE *fp) { -return(fread(buf, siz, cnt, fp)); + return (fread(buf, siz, cnt, fp)); } static size_t fstFwrite(const void *buf, size_t siz, size_t cnt, FILE *fp) { -return(fwrite(buf, siz, cnt, fp)); + return (fwrite(buf, siz, cnt, fp)); } static int fstFtruncate(int fd, fst_off_t length) { -return(ftruncate(fd, length)); + return (ftruncate(fd, length)); } - /* * realpath compatibility */ @@ -314,50 +280,57 @@ static char *fstRealpath(const char *path, char *resolved_path) { #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED || defined __CYGWIN__ || defined HAVE_REALPATH #if (defined(__MACH__) && defined(__APPLE__)) -if(!resolved_path) - { - resolved_path = (char *)malloc(PATH_MAX+1); /* fixes bug on Leopard when resolved_path == NULL */ - } + if (!resolved_path) { + resolved_path = + (char *)malloc(PATH_MAX + 1); /* fixes bug on Leopard when resolved_path == NULL */ + } #endif -return(realpath(path, resolved_path)); + return (realpath(path, resolved_path)); #else #ifdef __MINGW32__ -if(!resolved_path) - { - resolved_path = (char *)malloc(PATH_MAX+1); - } -return(_fullpath(resolved_path, path, PATH_MAX)); + if (!resolved_path) { + resolved_path = (char *)malloc(PATH_MAX + 1); + } + return (_fullpath(resolved_path, path, PATH_MAX)); #else -(void)path; -(void)resolved_path; -return(NULL); + (void)path; + (void)resolved_path; + return (NULL); #endif #endif } - /* * mmap compatibility */ #if defined __MINGW32__ || defined _MSC_VER #include -#define fstMmap(__addr,__len,__prot,__flags,__fd,__off) fstMmap2((__len), (__fd), (__off)) -#define fstMunmap(__addr,__len) UnmapViewOfFile((LPCVOID)__addr) +#define fstMmap(__addr, __len, __prot, __flags, __fd, __off) fstMmap2((__len), (__fd), (__off)) +#define fstMunmap(__addr, __len) UnmapViewOfFile((LPCVOID)__addr) static void *fstMmap2(size_t __len, int __fd, fst_off_t __off) { -DWORD64 len64 = __len; /* Must be 64-bit for shift below */ -HANDLE handle = CreateFileMapping((HANDLE)_get_osfhandle(__fd), NULL, - PAGE_READWRITE, (DWORD)(len64 >> 32), - (DWORD)__len, NULL); -if (!handle) { return NULL; } + DWORD64 len64 = __len; /* Must be 64-bit for shift below */ + HANDLE handle = CreateFileMapping((HANDLE)_get_osfhandle(__fd), + NULL, + PAGE_READWRITE, + (DWORD)(len64 >> 32), + (DWORD)__len, + NULL); + if (!handle) { + return NULL; + } -void *ptr = MapViewOfFileEx(handle, FILE_MAP_READ | FILE_MAP_WRITE, - 0, (DWORD)__off, (SIZE_T)__len, (LPVOID)NULL); -CloseHandle(handle); -return ptr; + void *ptr = MapViewOfFileEx(handle, + FILE_MAP_READ | FILE_MAP_WRITE, + 0, + (DWORD)__off, + (SIZE_T)__len, + (LPVOID)NULL); + CloseHandle(handle); + return ptr; } #else #include @@ -366,366 +339,333 @@ return ptr; #else #define FST_CADDR_T_CAST #endif -#define fstMmap(__addr,__len,__prot,__flags,__fd,__off) (void*)mmap(FST_CADDR_T_CAST (__addr),(__len),(__prot),(__flags),(__fd),(__off)) -#define fstMunmap(__addr,__len) { if(__addr) munmap(FST_CADDR_T_CAST (__addr),(__len)); } +#define fstMmap(__addr, __len, __prot, __flags, __fd, __off) \ + (void *)mmap(FST_CADDR_T_CAST(__addr), (__len), (__prot), (__flags), (__fd), (__off)) +#define fstMunmap(__addr, __len) \ + { \ + if (__addr) \ + munmap(FST_CADDR_T_CAST(__addr), (__len)); \ + } #endif - /* * regular and variable-length integer access functions */ static uint32_t fstGetUint32(unsigned char *mem) { -uint32_t u32; -unsigned char *buf = (unsigned char *)(&u32); + uint32_t u32; + unsigned char *buf = (unsigned char *)(&u32); -memcpy(buf, mem, sizeof(uint32_t)); + memcpy(buf, mem, sizeof(uint32_t)); -return(*(uint32_t *)buf); + return (*(uint32_t *)buf); } - static int fstWriterUint64(FILE *handle, uint64_t v) { -unsigned char buf[8]; -int i; + unsigned char buf[8]; + int i; -for(i=7;i>=0;i--) - { + for (i = 7; i >= 0; i--) { buf[i] = v & 0xff; v >>= 8; - } + } -fstFwrite(buf, 8, 1, handle); -return(8); + fstFwrite(buf, 8, 1, handle); + return (8); } - static uint64_t fstReaderUint64(FILE *f) { -uint64_t val = 0; -unsigned char buf[sizeof(uint64_t)]; -unsigned int i; + uint64_t val = 0; + unsigned char buf[sizeof(uint64_t)]; + unsigned int i; -fstFread(buf, sizeof(uint64_t), 1, f); -for(i=0;i>7)) /* determine len to avoid temp buffer copying to cut down on load-hit-store */ - { + while ((nxt = nxt >> + 7)) /* determine len to avoid temp buffer copying to cut down on load-hit-store */ + { cnt++; - } + } -pnt -= cnt; -spnt = pnt; -cnt--; + pnt -= cnt; + spnt = pnt; + cnt--; -for(i=0;i>7; + for (i = 0; i < cnt; i++) /* now generate left to right as normal */ + { + nxt = v >> 7; *(spnt++) = ((unsigned char)v) | 0x80; v = nxt; - } -*spnt = (unsigned char)v; + } + *spnt = (unsigned char)v; -return(pnt); + return (pnt); } - static unsigned char *fstCopyVarint64ToRight(unsigned char *pnt, uint64_t v) { -uint64_t nxt; + uint64_t nxt; -while((nxt = v>>7)) - { + while ((nxt = v >> 7)) { *(pnt++) = ((unsigned char)v) | 0x80; v = nxt; - } -*(pnt++) = (unsigned char)v; + } + *(pnt++) = (unsigned char)v; -return(pnt); + return (pnt); } - static uint64_t fstGetVarint64(unsigned char *mem, int *skiplen) { -unsigned char *mem_orig = mem; -uint64_t rc = 0; -while(*mem & 0x80) - { + unsigned char *mem_orig = mem; + uint64_t rc = 0; + while (*mem & 0x80) { mem++; - } + } -*skiplen = mem - mem_orig + 1; -for(;;) - { + *skiplen = mem - mem_orig + 1; + for (;;) { rc <<= 7; rc |= (uint64_t)(*mem & 0x7f); - if(mem == mem_orig) - { - break; - } - mem--; + if (mem == mem_orig) { + break; } + mem--; + } -return(rc); + return (rc); } - static uint32_t fstReaderVarint32(FILE *f) { -const int chk_len_max = 5; /* TALOS-2023-1783 */ -int chk_len = chk_len_max; -unsigned char buf[chk_len_max]; -unsigned char *mem = buf; -uint32_t rc = 0; -int ch; + const int chk_len_max = 5; /* TALOS-2023-1783 */ + int chk_len = chk_len_max; + unsigned char buf[chk_len_max]; + unsigned char *mem = buf; + uint32_t rc = 0; + int ch; -do - { + do { ch = fgetc(f); *(mem++) = ch; - } while((ch & 0x80) && (--chk_len)); + } while ((ch & 0x80) && (--chk_len)); -if(ch & 0x80) chk_report_abort("TALOS-2023-1783"); -mem--; + if (ch & 0x80) + chk_report_abort("TALOS-2023-1783"); + mem--; -for(;;) - { + for (;;) { rc <<= 7; rc |= (uint32_t)(*mem & 0x7f); - if(mem == buf) - { - break; - } - mem--; + if (mem == buf) { + break; } + mem--; + } -return(rc); + return (rc); } - static uint32_t fstReaderVarint32WithSkip(FILE *f, uint32_t *skiplen) { -const int chk_len_max = 5; /* TALOS-2023-1783 */ -int chk_len = chk_len_max; -unsigned char buf[chk_len_max]; -unsigned char *mem = buf; -uint32_t rc = 0; -int ch; + const int chk_len_max = 5; /* TALOS-2023-1783 */ + int chk_len = chk_len_max; + unsigned char buf[chk_len_max]; + unsigned char *mem = buf; + uint32_t rc = 0; + int ch; -do - { + do { ch = fgetc(f); *(mem++) = ch; - } while((ch & 0x80) && (--chk_len)); + } while ((ch & 0x80) && (--chk_len)); -if(ch & 0x80) chk_report_abort("TALOS-2023-1783"); -*skiplen = mem - buf; -mem--; + if (ch & 0x80) + chk_report_abort("TALOS-2023-1783"); + *skiplen = mem - buf; + mem--; -for(;;) - { + for (;;) { rc <<= 7; rc |= (uint32_t)(*mem & 0x7f); - if(mem == buf) - { - break; - } - mem--; + if (mem == buf) { + break; } + mem--; + } -return(rc); + return (rc); } - static uint64_t fstReaderVarint64(FILE *f) { -const int chk_len_max = 16; /* TALOS-2023-1783 */ -int chk_len = chk_len_max; -unsigned char buf[chk_len_max]; -unsigned char *mem = buf; -uint64_t rc = 0; -int ch; + const int chk_len_max = 16; /* TALOS-2023-1783 */ + int chk_len = chk_len_max; + unsigned char buf[chk_len_max]; + unsigned char *mem = buf; + uint64_t rc = 0; + int ch; -do - { + do { ch = fgetc(f); *(mem++) = ch; - } while((ch & 0x80) && (--chk_len)); + } while ((ch & 0x80) && (--chk_len)); -if(ch & 0x80) chk_report_abort("TALOS-2023-1783"); -mem--; + if (ch & 0x80) + chk_report_abort("TALOS-2023-1783"); + mem--; - -for(;;) - { + for (;;) { rc <<= 7; rc |= (uint64_t)(*mem & 0x7f); - if(mem == buf) - { - break; - } - mem--; + if (mem == buf) { + break; } + mem--; + } -return(rc); + return (rc); } - static int fstWriterVarint(FILE *handle, uint64_t v) { -uint64_t nxt; -unsigned char buf[10]; /* ceil(64/7) = 10 */ -unsigned char *pnt = buf; -int len; + uint64_t nxt; + unsigned char buf[10]; /* ceil(64/7) = 10 */ + unsigned char *pnt = buf; + int len; -while((nxt = v>>7)) - { + while ((nxt = v >> 7)) { *(pnt++) = ((unsigned char)v) | 0x80; v = nxt; - } -*(pnt++) = (unsigned char)v; + } + *(pnt++) = (unsigned char)v; -len = pnt-buf; -fstFwrite(buf, len, 1, handle); -return(len); + len = pnt - buf; + fstFwrite(buf, len, 1, handle); + return (len); } - /* signed integer read/write routines are currently unused */ static int64_t fstGetSVarint64(unsigned char *mem, int *skiplen) { -unsigned char *mem_orig = mem; -int64_t rc = 0; -const int64_t one = 1; -const int siz = sizeof(int64_t) * 8; -int shift = 0; -unsigned char byt; + unsigned char *mem_orig = mem; + int64_t rc = 0; + const int64_t one = 1; + const int siz = sizeof(int64_t) * 8; + int shift = 0; + unsigned char byt; -do { + do { byt = *(mem++); rc |= ((int64_t)(byt & 0x7f)) << shift; shift += 7; - } while(byt & 0x80); + } while (byt & 0x80); -if((shift>= 7; - if (((!v) && (!(byt & 0x40))) || ((v == -1) && (byt & 0x40))) - { - more = 0; - byt &= 0x7f; - } + if (((!v) && (!(byt & 0x40))) || ((v == -1) && (byt & 0x40))) { + more = 0; + byt &= 0x7f; + } *(pnt++) = byt; - } while(more); + } while (more); -len = pnt-buf; -fstFwrite(buf, len, 1, handle); -return(len); + len = pnt - buf; + fstFwrite(buf, len, 1, handle); + return (len); } #endif - /***********************/ /*** ***/ /*** writer function ***/ @@ -737,330 +677,347 @@ return(len); */ struct fstBlackoutChain { -struct fstBlackoutChain *next; -uint64_t tim; -unsigned active : 1; + struct fstBlackoutChain *next; + uint64_t tim; + unsigned active : 1; }; - struct fstWriterContext { -FILE *handle; -FILE *hier_handle; -FILE *geom_handle; -FILE *valpos_handle; -FILE *curval_handle; -FILE *tchn_handle; + FILE *handle; + FILE *hier_handle; + FILE *geom_handle; + FILE *valpos_handle; + FILE *curval_handle; + FILE *tchn_handle; -unsigned char *vchg_mem; + unsigned char *vchg_mem; -fst_off_t hier_file_len; + fst_off_t hier_file_len; -uint32_t *valpos_mem; -unsigned char *curval_mem; + uint32_t *valpos_mem; + unsigned char *curval_mem; -unsigned char *outval_mem; /* for two-state / Verilator-style value changes */ -uint32_t outval_alloc_siz; + unsigned char *outval_mem; /* for two-state / Verilator-style value changes */ + uint32_t outval_alloc_siz; -char *filename; + char *filename; -fstHandle maxhandle; -fstHandle numsigs; -uint32_t maxvalpos; + fstHandle maxhandle; + fstHandle numsigs; + uint32_t maxvalpos; -unsigned vc_emitted : 1; -unsigned is_initial_time : 1; -unsigned fourpack : 1; -unsigned fastpack : 1; + unsigned vc_emitted : 1; + unsigned is_initial_time : 1; + unsigned fourpack : 1; + unsigned fastpack : 1; -int64_t timezero; -fst_off_t section_header_truncpos; -uint32_t tchn_cnt, tchn_idx; -uint64_t curtime; -uint64_t firsttime; -uint32_t vchg_siz; -uint32_t vchg_alloc_siz; + int64_t timezero; + fst_off_t section_header_truncpos; + uint32_t tchn_cnt, tchn_idx; + uint64_t curtime; + uint64_t firsttime; + uint32_t vchg_siz; + uint32_t vchg_alloc_siz; -uint32_t secnum; -fst_off_t section_start; + uint32_t secnum; + fst_off_t section_start; -uint32_t numscopes; -double nan; /* nan value for uninitialized doubles */ + uint32_t numscopes; + double nan; /* nan value for uninitialized doubles */ -struct fstBlackoutChain *blackout_head; -struct fstBlackoutChain *blackout_curr; -uint32_t num_blackouts; + struct fstBlackoutChain *blackout_head; + struct fstBlackoutChain *blackout_curr; + uint32_t num_blackouts; -uint64_t dump_size_limit; + uint64_t dump_size_limit; -unsigned char filetype; /* default is 0, FST_FT_VERILOG */ + unsigned char filetype; /* default is 0, FST_FT_VERILOG */ -unsigned compress_hier : 1; -unsigned repack_on_close : 1; -unsigned skip_writing_section_hdr : 1; -unsigned size_limit_locked : 1; -unsigned section_header_only : 1; -unsigned flush_context_pending : 1; -unsigned parallel_enabled : 1; -unsigned parallel_was_enabled : 1; + unsigned compress_hier : 1; + unsigned repack_on_close : 1; + unsigned skip_writing_section_hdr : 1; + unsigned size_limit_locked : 1; + unsigned section_header_only : 1; + unsigned flush_context_pending : 1; + unsigned parallel_enabled : 1; + unsigned parallel_was_enabled : 1; -/* should really be semaphores, but are bytes to cut down on read-modify-write window size */ -unsigned char already_in_flush; /* in case control-c handlers interrupt */ -unsigned char already_in_close; /* in case control-c handlers interrupt */ + /* should really be semaphores, but are bytes to cut down on read-modify-write window size */ + unsigned char already_in_flush; /* in case control-c handlers interrupt */ + unsigned char already_in_close; /* in case control-c handlers interrupt */ #ifdef FST_WRITER_PARALLEL -pthread_mutex_t mutex; -pthread_t thread; -pthread_attr_t thread_attr; -struct fstWriterContext *xc_parent; + pthread_mutex_t mutex; + pthread_t thread; + pthread_attr_t thread_attr; + struct fstWriterContext *xc_parent; #endif -unsigned in_pthread : 1; + unsigned in_pthread : 1; -size_t fst_orig_break_size; -size_t fst_orig_break_add_size; + size_t fst_orig_break_size; + size_t fst_orig_break_add_size; -size_t fst_break_size; -size_t fst_break_add_size; + size_t fst_break_size; + size_t fst_break_add_size; -size_t fst_huge_break_size; + size_t fst_huge_break_size; -fstHandle next_huge_break; + fstHandle next_huge_break; -Pvoid_t path_array; -uint32_t path_array_count; + Pvoid_t path_array; + uint32_t path_array_count; -unsigned fseek_failed : 1; + unsigned fseek_failed : 1; -char *geom_handle_nam; -char *valpos_handle_nam; -char *curval_handle_nam; -char *tchn_handle_nam; + char *geom_handle_nam; + char *valpos_handle_nam; + char *curval_handle_nam; + char *tchn_handle_nam; -fstEnumHandle max_enumhandle; + fstEnumHandle max_enumhandle; }; - static int fstWriterFseeko(struct fstWriterContext *xc, FILE *stream, fst_off_t offset, int whence) { -int rc = fseeko(stream, offset, whence); + int rc = fseeko(stream, offset, whence); -if(rc<0) - { + if (rc < 0) { xc->fseek_failed = 1; #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "Seek to #%" PRId64 " (whence = %d) failed!\n", offset, whence); perror("Why"); #endif - } + } -return(rc); + return (rc); } - -static uint32_t fstWriterUint32WithVarint32(struct fstWriterContext *xc, uint32_t *u, uint32_t v, const void *dbuf, uint32_t siz) +static uint32_t fstWriterUint32WithVarint32(struct fstWriterContext *xc, + uint32_t *u, + uint32_t v, + const void *dbuf, + uint32_t siz) { -unsigned char *buf = xc->vchg_mem + xc->vchg_siz; -unsigned char *pnt = buf; -uint32_t nxt; -uint32_t len; + unsigned char *buf = xc->vchg_mem + xc->vchg_siz; + unsigned char *pnt = buf; + uint32_t nxt; + uint32_t len; -memcpy(pnt, u, sizeof(uint32_t)); -pnt += 4; + memcpy(pnt, u, sizeof(uint32_t)); + pnt += 4; -while((nxt = v>>7)) - { + while ((nxt = v >> 7)) { *(pnt++) = ((unsigned char)v) | 0x80; v = nxt; - } -*(pnt++) = (unsigned char)v; -memcpy(pnt, dbuf, siz); + } + *(pnt++) = (unsigned char)v; + memcpy(pnt, dbuf, siz); -len = pnt-buf + siz; -return(len); + len = pnt - buf + siz; + return (len); } - -static uint32_t fstWriterUint32WithVarint32AndLength(struct fstWriterContext *xc, uint32_t *u, uint32_t v, const void *dbuf, uint32_t siz) +static uint32_t fstWriterUint32WithVarint32AndLength(struct fstWriterContext *xc, + uint32_t *u, + uint32_t v, + const void *dbuf, + uint32_t siz) { -unsigned char *buf = xc->vchg_mem + xc->vchg_siz; -unsigned char *pnt = buf; -uint32_t nxt; -uint32_t len; + unsigned char *buf = xc->vchg_mem + xc->vchg_siz; + unsigned char *pnt = buf; + uint32_t nxt; + uint32_t len; -memcpy(pnt, u, sizeof(uint32_t)); -pnt += 4; + memcpy(pnt, u, sizeof(uint32_t)); + pnt += 4; -while((nxt = v>>7)) - { + while ((nxt = v >> 7)) { *(pnt++) = ((unsigned char)v) | 0x80; v = nxt; - } -*(pnt++) = (unsigned char)v; + } + *(pnt++) = (unsigned char)v; -v = siz; -while((nxt = v>>7)) - { + v = siz; + while ((nxt = v >> 7)) { *(pnt++) = ((unsigned char)v) | 0x80; v = nxt; - } -*(pnt++) = (unsigned char)v; + } + *(pnt++) = (unsigned char)v; -memcpy(pnt, dbuf, siz); + memcpy(pnt, dbuf, siz); -len = pnt-buf + siz; -return(len); + len = pnt - buf + siz; + return (len); } - /* * header bytes, write here so defines are set up before anything else * that needs to use them */ static void fstWriterEmitHdrBytes(struct fstWriterContext *xc) { -char vbuf[FST_HDR_SIM_VERSION_SIZE]; -char dbuf[FST_HDR_DATE_SIZE]; -double endtest = FST_DOUBLE_ENDTEST; -time_t walltime; + char vbuf[FST_HDR_SIM_VERSION_SIZE]; + char dbuf[FST_HDR_DATE_SIZE]; + double endtest = FST_DOUBLE_ENDTEST; + time_t walltime; -#define FST_HDR_OFFS_TAG (0) -fputc(FST_BL_HDR, xc->handle); /* +0 tag */ +#define FST_HDR_OFFS_TAG (0) + fputc(FST_BL_HDR, xc->handle); /* +0 tag */ -#define FST_HDR_OFFS_SECLEN (FST_HDR_OFFS_TAG + 1) -fstWriterUint64(xc->handle, 329); /* +1 section length */ +#define FST_HDR_OFFS_SECLEN (FST_HDR_OFFS_TAG + 1) + fstWriterUint64(xc->handle, 329); /* +1 section length */ -#define FST_HDR_OFFS_START_TIME (FST_HDR_OFFS_SECLEN + 8) -fstWriterUint64(xc->handle, 0); /* +9 start time */ +#define FST_HDR_OFFS_START_TIME (FST_HDR_OFFS_SECLEN + 8) + fstWriterUint64(xc->handle, 0); /* +9 start time */ -#define FST_HDR_OFFS_END_TIME (FST_HDR_OFFS_START_TIME + 8) -fstWriterUint64(xc->handle, 0); /* +17 end time */ +#define FST_HDR_OFFS_END_TIME (FST_HDR_OFFS_START_TIME + 8) + fstWriterUint64(xc->handle, 0); /* +17 end time */ -#define FST_HDR_OFFS_ENDIAN_TEST (FST_HDR_OFFS_END_TIME + 8) -fstFwrite(&endtest, 8, 1, xc->handle); /* +25 endian test for reals */ +#define FST_HDR_OFFS_ENDIAN_TEST (FST_HDR_OFFS_END_TIME + 8) + fstFwrite(&endtest, 8, 1, xc->handle); /* +25 endian test for reals */ -#define FST_HDR_OFFS_MEM_USED (FST_HDR_OFFS_ENDIAN_TEST + 8) -fstWriterUint64(xc->handle, xc->fst_break_size);/* +33 memory used by writer */ +#define FST_HDR_OFFS_MEM_USED (FST_HDR_OFFS_ENDIAN_TEST + 8) + fstWriterUint64(xc->handle, xc->fst_break_size); /* +33 memory used by writer */ -#define FST_HDR_OFFS_NUM_SCOPES (FST_HDR_OFFS_MEM_USED + 8) -fstWriterUint64(xc->handle, 0); /* +41 scope creation count */ +#define FST_HDR_OFFS_NUM_SCOPES (FST_HDR_OFFS_MEM_USED + 8) + fstWriterUint64(xc->handle, 0); /* +41 scope creation count */ -#define FST_HDR_OFFS_NUM_VARS (FST_HDR_OFFS_NUM_SCOPES + 8) -fstWriterUint64(xc->handle, 0); /* +49 var creation count */ +#define FST_HDR_OFFS_NUM_VARS (FST_HDR_OFFS_NUM_SCOPES + 8) + fstWriterUint64(xc->handle, 0); /* +49 var creation count */ -#define FST_HDR_OFFS_MAXHANDLE (FST_HDR_OFFS_NUM_VARS + 8) -fstWriterUint64(xc->handle, 0); /* +57 max var idcode */ +#define FST_HDR_OFFS_MAXHANDLE (FST_HDR_OFFS_NUM_VARS + 8) + fstWriterUint64(xc->handle, 0); /* +57 max var idcode */ -#define FST_HDR_OFFS_SECTION_CNT (FST_HDR_OFFS_MAXHANDLE + 8) -fstWriterUint64(xc->handle, 0); /* +65 vc section count */ +#define FST_HDR_OFFS_SECTION_CNT (FST_HDR_OFFS_MAXHANDLE + 8) + fstWriterUint64(xc->handle, 0); /* +65 vc section count */ -#define FST_HDR_OFFS_TIMESCALE (FST_HDR_OFFS_SECTION_CNT + 8) -fputc((-9)&255, xc->handle); /* +73 timescale 1ns */ +#define FST_HDR_OFFS_TIMESCALE (FST_HDR_OFFS_SECTION_CNT + 8) + fputc((-9) & 255, xc->handle); /* +73 timescale 1ns */ -#define FST_HDR_OFFS_SIM_VERSION (FST_HDR_OFFS_TIMESCALE + 1) -memset(vbuf, 0, FST_HDR_SIM_VERSION_SIZE); -strcpy(vbuf, FST_WRITER_STR); -fstFwrite(vbuf, FST_HDR_SIM_VERSION_SIZE, 1, xc->handle); /* +74 version */ +#define FST_HDR_OFFS_SIM_VERSION (FST_HDR_OFFS_TIMESCALE + 1) + memset(vbuf, 0, FST_HDR_SIM_VERSION_SIZE); + strcpy(vbuf, FST_WRITER_STR); + fstFwrite(vbuf, FST_HDR_SIM_VERSION_SIZE, 1, xc->handle); /* +74 version */ -#define FST_HDR_OFFS_DATE (FST_HDR_OFFS_SIM_VERSION + FST_HDR_SIM_VERSION_SIZE) -memset(dbuf, 0, FST_HDR_DATE_SIZE); -time(&walltime); -strcpy(dbuf, asctime(localtime(&walltime))); -fstFwrite(dbuf, FST_HDR_DATE_SIZE, 1, xc->handle); /* +202 date */ +#define FST_HDR_OFFS_DATE (FST_HDR_OFFS_SIM_VERSION + FST_HDR_SIM_VERSION_SIZE) + memset(dbuf, 0, FST_HDR_DATE_SIZE); + time(&walltime); + strcpy(dbuf, asctime(localtime(&walltime))); + fstFwrite(dbuf, FST_HDR_DATE_SIZE, 1, xc->handle); /* +202 date */ -/* date size is deliberately overspecified at 119 bytes (originally 128) in order to provide backfill for new args */ + /* date size is deliberately overspecified at 119 bytes (originally 128) in order to provide + * backfill for new args */ -#define FST_HDR_OFFS_FILETYPE (FST_HDR_OFFS_DATE + FST_HDR_DATE_SIZE) -fputc(xc->filetype, xc->handle); /* +321 filetype */ +#define FST_HDR_OFFS_FILETYPE (FST_HDR_OFFS_DATE + FST_HDR_DATE_SIZE) + fputc(xc->filetype, xc->handle); /* +321 filetype */ -#define FST_HDR_OFFS_TIMEZERO (FST_HDR_OFFS_FILETYPE + FST_HDR_FILETYPE_SIZE) -fstWriterUint64(xc->handle, xc->timezero); /* +322 timezero */ +#define FST_HDR_OFFS_TIMEZERO (FST_HDR_OFFS_FILETYPE + FST_HDR_FILETYPE_SIZE) + fstWriterUint64(xc->handle, xc->timezero); /* +322 timezero */ -#define FST_HDR_LENGTH (FST_HDR_OFFS_TIMEZERO + FST_HDR_TIMEZERO_SIZE) - /* +330 next section starts here */ -fflush(xc->handle); +#define FST_HDR_LENGTH (FST_HDR_OFFS_TIMEZERO + FST_HDR_TIMEZERO_SIZE) + /* +330 next section starts here */ + fflush(xc->handle); } - /* * mmap functions */ static void fstWriterMmapSanity(void *pnt, const char *file, int line, const char *usage) { -if(pnt == NULL + if (pnt == NULL #ifdef MAP_FAILED - || pnt == MAP_FAILED + || pnt == MAP_FAILED #endif - ) - { - fprintf(stderr, "fstMmap() assigned to %s failed: errno: %d, file %s, line %d.\n", usage, errno, file, line); + ) { + fprintf(stderr, + "fstMmap() assigned to %s failed: errno: %d, file %s, line %d.\n", + usage, + errno, + file, + line); #if !defined(__MINGW32__) - perror("Why"); + perror("Why"); #else - LPSTR mbuf = NULL; - FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM - | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPSTR)&mbuf, 0, NULL); - fprintf(stderr, "%s", mbuf); - LocalFree(mbuf); + LPSTR mbuf = NULL; + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (LPSTR)&mbuf, + 0, + NULL); + fprintf(stderr, "%s", mbuf); + LocalFree(mbuf); #endif - pnt = NULL; - } + pnt = NULL; + } } - static void fstWriterCreateMmaps(struct fstWriterContext *xc) { -fst_off_t curpos = ftello(xc->handle); + fst_off_t curpos = ftello(xc->handle); -fflush(xc->hier_handle); + fflush(xc->hier_handle); -/* write out intermediate header */ -fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_START_TIME, SEEK_SET); -fstWriterUint64(xc->handle, xc->firsttime); -fstWriterUint64(xc->handle, xc->curtime); -fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_NUM_SCOPES, SEEK_SET); -fstWriterUint64(xc->handle, xc->numscopes); -fstWriterUint64(xc->handle, xc->numsigs); -fstWriterUint64(xc->handle, xc->maxhandle); -fstWriterUint64(xc->handle, xc->secnum); -fstWriterFseeko(xc, xc->handle, curpos, SEEK_SET); -fflush(xc->handle); + /* write out intermediate header */ + fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_START_TIME, SEEK_SET); + fstWriterUint64(xc->handle, xc->firsttime); + fstWriterUint64(xc->handle, xc->curtime); + fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_NUM_SCOPES, SEEK_SET); + fstWriterUint64(xc->handle, xc->numscopes); + fstWriterUint64(xc->handle, xc->numsigs); + fstWriterUint64(xc->handle, xc->maxhandle); + fstWriterUint64(xc->handle, xc->secnum); + fstWriterFseeko(xc, xc->handle, curpos, SEEK_SET); + fflush(xc->handle); -/* do mappings */ -if(!xc->valpos_mem) - { + /* do mappings */ + if (!xc->valpos_mem) { fflush(xc->valpos_handle); - errno = 0; - if(xc->maxhandle) - { - fstWriterMmapSanity(xc->valpos_mem = (uint32_t *)fstMmap(NULL, xc->maxhandle * 4 * sizeof(uint32_t), PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->valpos_handle), 0), __FILE__, __LINE__, "xc->valpos_mem"); - } + errno = 0; + if (xc->maxhandle) { + fstWriterMmapSanity(xc->valpos_mem = + (uint32_t *)fstMmap(NULL, + xc->maxhandle * 4 * sizeof(uint32_t), + PROT_READ | PROT_WRITE, + MAP_SHARED, + fileno(xc->valpos_handle), + 0), + __FILE__, + __LINE__, + "xc->valpos_mem"); } -if(!xc->curval_mem) - { + } + if (!xc->curval_mem) { fflush(xc->curval_handle); - errno = 0; - if(xc->maxvalpos) - { - fstWriterMmapSanity(xc->curval_mem = (unsigned char *)fstMmap(NULL, xc->maxvalpos, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->curval_handle), 0), __FILE__, __LINE__, "xc->curval_handle"); - } + errno = 0; + if (xc->maxvalpos) { + fstWriterMmapSanity(xc->curval_mem = (unsigned char *)fstMmap(NULL, + xc->maxvalpos, + PROT_READ | PROT_WRITE, + MAP_SHARED, + fileno(xc->curval_handle), + 0), + __FILE__, + __LINE__, + "xc->curval_handle"); } + } } - static void fstDestroyMmaps(struct fstWriterContext *xc, int is_closing) { -(void)is_closing; + (void)is_closing; -fstMunmap(xc->valpos_mem, xc->maxhandle * 4 * sizeof(uint32_t)); -xc->valpos_mem = NULL; + fstMunmap(xc->valpos_mem, xc->maxhandle * 4 * sizeof(uint32_t)); + xc->valpos_mem = NULL; -fstMunmap(xc->curval_mem, xc->maxvalpos); -xc->curval_mem = NULL; + fstMunmap(xc->curval_mem, xc->maxvalpos); + xc->curval_mem = NULL; } - /* * set up large and small memory usages * crossover point in model is FST_ACTIVATE_HUGE_BREAK number of signals @@ -1068,105 +1025,89 @@ xc->curval_mem = NULL; static void fstDetermineBreakSize(struct fstWriterContext *xc) { #if defined(__linux__) || defined(FST_MACOSX) -int was_set = 0; + int was_set = 0; #ifdef __linux__ -FILE *f = fopen("/proc/meminfo", "rb"); + FILE *f = fopen("/proc/meminfo", "rb"); -if(f) - { + if (f) { char buf[257]; char *s; - while(!feof(f)) - { - buf[0] = 0; - s = fgets(buf, 256, f); - if(s && *s) - { - if(!strncmp(s, "MemTotal:", 9)) - { - size_t v = atol(s+10); - v *= 1024; /* convert to bytes */ - v /= 8; /* chop down to 1/8 physical memory */ - if(v > FST_BREAK_SIZE) - { - if(v > FST_BREAK_SIZE_MAX) - { - v = FST_BREAK_SIZE_MAX; - } - - xc->fst_huge_break_size = v; - was_set = 1; - break; - } - } + while (!feof(f)) { + buf[0] = 0; + s = fgets(buf, 256, f); + if (s && *s) { + if (!strncmp(s, "MemTotal:", 9)) { + size_t v = atol(s + 10); + v *= 1024; /* convert to bytes */ + v /= 8; /* chop down to 1/8 physical memory */ + if (v > FST_BREAK_SIZE) { + if (v > FST_BREAK_SIZE_MAX) { + v = FST_BREAK_SIZE_MAX; } + + xc->fst_huge_break_size = v; + was_set = 1; + break; + } } + } + } fclose(f); - } + } -if(!was_set) - { + if (!was_set) { xc->fst_huge_break_size = FST_BREAK_SIZE; - } + } #else -int mib[2]; -int64_t v; -size_t length; + int mib[2]; + int64_t v; + size_t length; -mib[0] = CTL_HW; -mib[1] = HW_MEMSIZE; -length = sizeof(int64_t); -if(!sysctl(mib, 2, &v, &length, NULL, 0)) - { + mib[0] = CTL_HW; + mib[1] = HW_MEMSIZE; + length = sizeof(int64_t); + if (!sysctl(mib, 2, &v, &length, NULL, 0)) { v /= 8; - if(v > (int64_t)FST_BREAK_SIZE) - { - if(v > (int64_t)FST_BREAK_SIZE_MAX) - { - v = FST_BREAK_SIZE_MAX; - } + if (v > (int64_t)FST_BREAK_SIZE) { + if (v > (int64_t)FST_BREAK_SIZE_MAX) { + v = FST_BREAK_SIZE_MAX; + } - xc->fst_huge_break_size = v; - was_set = 1; - } + xc->fst_huge_break_size = v; + was_set = 1; } + } -if(!was_set) - { + if (!was_set) { xc->fst_huge_break_size = FST_BREAK_SIZE; - } + } #endif #else -xc->fst_huge_break_size = FST_BREAK_SIZE; + xc->fst_huge_break_size = FST_BREAK_SIZE; #endif -xc->fst_break_size = xc->fst_orig_break_size = FST_BREAK_SIZE; -xc->fst_break_add_size = xc->fst_orig_break_add_size = FST_BREAK_ADD_SIZE; -xc->next_huge_break = FST_ACTIVATE_HUGE_BREAK; + xc->fst_break_size = xc->fst_orig_break_size = FST_BREAK_SIZE; + xc->fst_break_add_size = xc->fst_orig_break_add_size = FST_BREAK_ADD_SIZE; + xc->next_huge_break = FST_ACTIVATE_HUGE_BREAK; } - /* * 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); + xc->compress_hier = use_compressed_hier; + fstDetermineBreakSize(xc); -if((!nam)|| - (!(xc->handle=unlink_fopen(nam, "w+b")))) - { + if ((!nam) || (!(xc->handle = unlink_fopen(nam, "w+b")))) { free(xc); - xc=NULL; - } - else - { + xc = NULL; + } else { int flen = strlen(nam); char *hf = (char *)calloc(1, flen + 6); @@ -1174,671 +1115,651 @@ if((!nam)|| strcpy(hf + flen, ".hier"); xc->hier_handle = unlink_fopen(hf, "w+b"); - xc->geom_handle = tmpfile_open(&xc->geom_handle_nam); /* .geom */ - xc->valpos_handle = tmpfile_open(&xc->valpos_handle_nam); /* .offs */ - xc->curval_handle = tmpfile_open(&xc->curval_handle_nam); /* .bits */ - xc->tchn_handle = tmpfile_open(&xc->tchn_handle_nam); /* .tchn */ + xc->geom_handle = tmpfile_open(&xc->geom_handle_nam); /* .geom */ + xc->valpos_handle = tmpfile_open(&xc->valpos_handle_nam); /* .offs */ + xc->curval_handle = tmpfile_open(&xc->curval_handle_nam); /* .bits */ + xc->tchn_handle = tmpfile_open(&xc->tchn_handle_nam); /* .tchn */ xc->vchg_alloc_siz = xc->fst_break_size + xc->fst_break_add_size; xc->vchg_mem = (unsigned char *)malloc(xc->vchg_alloc_siz); - if(xc->hier_handle && xc->geom_handle && xc->valpos_handle && xc->curval_handle && xc->vchg_mem && xc->tchn_handle) - { - xc->filename = strdup(nam); - xc->is_initial_time = 1; + if (xc->hier_handle && xc->geom_handle && xc->valpos_handle && xc->curval_handle && + xc->vchg_mem && xc->tchn_handle) { + xc->filename = strdup(nam); + xc->is_initial_time = 1; - fstWriterEmitHdrBytes(xc); - xc->nan = strtod("NaN", NULL); + fstWriterEmitHdrBytes(xc); + xc->nan = strtod("NaN", NULL); #ifdef FST_WRITER_PARALLEL - pthread_mutex_init(&xc->mutex, NULL); - pthread_attr_init(&xc->thread_attr); - pthread_attr_setdetachstate(&xc->thread_attr, PTHREAD_CREATE_DETACHED); + pthread_mutex_init(&xc->mutex, NULL); + pthread_attr_init(&xc->thread_attr); + pthread_attr_setdetachstate(&xc->thread_attr, PTHREAD_CREATE_DETACHED); #endif - } - else - { - fclose(xc->handle); - if(xc->hier_handle) { fclose(xc->hier_handle); unlink(hf); } - tmpfile_close(&xc->geom_handle, &xc->geom_handle_nam); - tmpfile_close(&xc->valpos_handle, &xc->valpos_handle_nam); - tmpfile_close(&xc->curval_handle, &xc->curval_handle_nam); - tmpfile_close(&xc->tchn_handle, &xc->tchn_handle_nam); - free(xc->vchg_mem); - free(xc); - xc=NULL; - } - - free(hf); + } else { + fclose(xc->handle); + if (xc->hier_handle) { + fclose(xc->hier_handle); + unlink(hf); + } + tmpfile_close(&xc->geom_handle, &xc->geom_handle_nam); + tmpfile_close(&xc->valpos_handle, &xc->valpos_handle_nam); + tmpfile_close(&xc->curval_handle, &xc->curval_handle_nam); + tmpfile_close(&xc->tchn_handle, &xc->tchn_handle_nam); + free(xc->vchg_mem); + free(xc); + xc = NULL; } -return(xc); -} + free(hf); + } + return (xc); +} /* * 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) - { + if (xc) { unsigned long destlen; unsigned char *dmem; int rc; destlen = xc->maxvalpos; dmem = (unsigned char *)malloc(compressBound(destlen)); - rc = compress2(dmem, &destlen, xc->curval_mem, xc->maxvalpos, 4); /* was 9...which caused performance drag on traces with many signals */ + rc = compress2(dmem, + &destlen, + xc->curval_mem, + xc->maxvalpos, + 4); /* was 9...which caused performance drag on traces with many signals */ - fputc(FST_BL_SKIP, xc->handle); /* temporarily tag the section, use FST_BL_VCDATA on finalize */ + fputc(FST_BL_SKIP, + xc->handle); /* temporarily tag the section, use FST_BL_VCDATA on finalize */ xc->section_start = ftello(xc->handle); #ifdef FST_WRITER_PARALLEL - if(xc->xc_parent) xc->xc_parent->section_start = xc->section_start; + if (xc->xc_parent) + xc->xc_parent->section_start = xc->section_start; #endif - xc->section_header_only = 1; /* indicates truncate might be needed */ - fstWriterUint64(xc->handle, 0); /* placeholder = section length */ - fstWriterUint64(xc->handle, xc->is_initial_time ? xc->firsttime : xc->curtime); /* begin time of section */ - fstWriterUint64(xc->handle, xc->curtime); /* end time of section (placeholder) */ - fstWriterUint64(xc->handle, 0); /* placeholder = amount of buffer memory required in reader for full vc traversal */ - fstWriterVarint(xc->handle, xc->maxvalpos); /* maxvalpos = length of uncompressed data */ + xc->section_header_only = 1; /* indicates truncate might be needed */ + fstWriterUint64(xc->handle, 0); /* placeholder = section length */ + fstWriterUint64(xc->handle, + xc->is_initial_time ? xc->firsttime + : xc->curtime); /* begin time of section */ + fstWriterUint64(xc->handle, xc->curtime); /* end time of section (placeholder) */ + fstWriterUint64( + xc->handle, + 0); /* placeholder = amount of buffer memory required in reader for full vc traversal */ + fstWriterVarint(xc->handle, xc->maxvalpos); /* maxvalpos = length of uncompressed data */ - if((rc == Z_OK) && (destlen < xc->maxvalpos)) - { - fstWriterVarint(xc->handle, destlen); /* length of compressed data */ - } - else - { - fstWriterVarint(xc->handle, xc->maxvalpos); /* length of (unable to be) compressed data */ - } - fstWriterVarint(xc->handle, xc->maxhandle); /* max handle associated with this data (in case of dynamic facility adds) */ + if ((rc == Z_OK) && (destlen < xc->maxvalpos)) { + fstWriterVarint(xc->handle, destlen); /* length of compressed data */ + } else { + fstWriterVarint(xc->handle, + xc->maxvalpos); /* length of (unable to be) compressed data */ + } + fstWriterVarint(xc->handle, xc->maxhandle); /* max handle associated with this data (in case + of dynamic facility adds) */ - if((rc == Z_OK) && (destlen < xc->maxvalpos)) - { - fstFwrite(dmem, destlen, 1, xc->handle); - } - else /* comparison between compressed / decompressed len tells if compressed */ - { - fstFwrite(xc->curval_mem, xc->maxvalpos, 1, xc->handle); - } + if ((rc == Z_OK) && (destlen < xc->maxvalpos)) { + fstFwrite(dmem, destlen, 1, xc->handle); + } else /* comparison between compressed / decompressed len tells if compressed */ + { + fstFwrite(xc->curval_mem, xc->maxvalpos, 1, xc->handle); + } free(dmem); - } + } } - /* * only to be called directly by fst code...otherwise must * 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 -int cnt = 0; + int cnt = 0; #endif -unsigned int i; -unsigned char *vchg_mem; -FILE *f; -fst_off_t fpos, indxpos, endpos; -uint32_t prevpos; -int zerocnt; -unsigned char *scratchpad; -unsigned char *scratchpnt; -unsigned char *tmem; -fst_off_t tlen; -fst_off_t unc_memreq = 0; /* for reader */ -unsigned char *packmem; -unsigned int packmemlen; -uint32_t *vm4ip; -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; + unsigned int i; + unsigned char *vchg_mem; + FILE *f; + fst_off_t fpos, indxpos, endpos; + uint32_t prevpos; + int zerocnt; + unsigned char *scratchpad; + unsigned char *scratchpnt; + unsigned char *tmem; + fst_off_t tlen; + fst_off_t unc_memreq = 0; /* for reader */ + unsigned char *packmem; + unsigned int packmemlen; + uint32_t *vm4ip; #ifdef FST_WRITER_PARALLEL -struct fstWriterContext *xc2 = xc->xc_parent; + struct fstWriterContext *xc2 = xc->xc_parent; #else -struct fstWriterContext *xc2 = xc; + struct fstWriterContext *xc2 = xc; #endif #ifndef FST_DYNAMIC_ALIAS_DISABLE -Pvoid_t PJHSArray = (Pvoid_t) NULL; -#ifndef _WAVE_HAVE_JUDY -uint32_t hashmask = xc->maxhandle; -hashmask |= hashmask >> 1; -hashmask |= hashmask >> 2; -hashmask |= hashmask >> 4; -hashmask |= hashmask >> 8; -hashmask |= hashmask >> 16; -#endif + Pvoid_t PJHSArray = (Pvoid_t)NULL; + uint32_t hashmask = xc->maxhandle; + hashmask |= hashmask >> 1; + hashmask |= hashmask >> 2; + hashmask |= hashmask >> 4; + hashmask |= hashmask >> 8; + hashmask |= hashmask >> 16; #endif -if((xc->vchg_siz <= 1)||(xc->already_in_flush)) return; -xc->already_in_flush = 1; /* should really do this with a semaphore */ + if ((xc->vchg_siz <= 1) || (xc->already_in_flush)) + return; + xc->already_in_flush = 1; /* should really do this with a semaphore */ -xc->section_header_only = 0; -scratchpad = (unsigned char *)malloc(xc->vchg_siz); + xc->section_header_only = 0; + scratchpad = (unsigned char *)malloc(xc->vchg_siz); -vchg_mem = xc->vchg_mem; + vchg_mem = xc->vchg_mem; -f = xc->handle; -fstWriterVarint(f, xc->maxhandle); /* emit current number of handles */ -fputc(xc->fourpack ? '4' : (xc->fastpack ? 'F' : 'Z'), f); -fpos = 1; + f = xc->handle; + fstWriterVarint(f, xc->maxhandle); /* emit current number of handles */ + fputc(xc->fourpack ? '4' : (xc->fastpack ? 'F' : 'Z'), f); + fpos = 1; -packmemlen = 1024; /* maintain a running "longest" allocation to */ -packmem = (unsigned char *)malloc(packmemlen); /* prevent continual malloc...free every loop iter */ + packmemlen = 1024; /* maintain a running "longest" allocation to */ + packmem = + (unsigned char *)malloc(packmemlen); /* prevent continual malloc...free every loop iter */ -for(i=0;imaxhandle;i++) - { - vm4ip = &(xc->valpos_mem[4*i]); + for (i = 0; i < xc->maxhandle; i++) { + vm4ip = &(xc->valpos_mem[4 * i]); - if(vm4ip[2]) - { - uint32_t offs = vm4ip[2]; - uint32_t next_offs; - unsigned int wrlen; + if (vm4ip[2]) { + uint32_t offs = vm4ip[2]; + uint32_t next_offs; + unsigned int wrlen; - vm4ip[2] = fpos; + vm4ip[2] = fpos; - scratchpnt = scratchpad + xc->vchg_siz; /* build this buffer backwards */ - if(vm4ip[1] <= 1) - { - if(vm4ip[1] == 1) - { - wrlen = fstGetVarint32Length(vchg_mem + offs + 4); /* used to advance and determine wrlen */ + scratchpnt = scratchpad + xc->vchg_siz; /* build this buffer backwards */ + if (vm4ip[1] <= 1) { + if (vm4ip[1] == 1) { + wrlen = fstGetVarint32Length(vchg_mem + offs + + 4); /* used to advance and determine wrlen */ #ifndef FST_REMOVE_DUPLICATE_VC - xc->curval_mem[vm4ip[0]] = vchg_mem[offs + 4 + wrlen]; /* checkpoint variable */ + xc->curval_mem[vm4ip[0]] = vchg_mem[offs + 4 + wrlen]; /* checkpoint variable */ #endif - while(offs) - { - unsigned char val; - uint32_t time_delta, rcv; - next_offs = fstGetUint32(vchg_mem + offs); - offs += 4; + while (offs) { + unsigned char val; + uint32_t time_delta, rcv; + next_offs = fstGetUint32(vchg_mem + offs); + offs += 4; - time_delta = fstGetVarint32(vchg_mem + offs, (int *)&wrlen); - val = vchg_mem[offs+wrlen]; - offs = next_offs; + time_delta = fstGetVarint32(vchg_mem + offs, (int *)&wrlen); + val = vchg_mem[offs + wrlen]; + offs = next_offs; - switch(val) - { - case '0': - case '1': rcv = ((val&1)<<1) | (time_delta<<2); - break; /* pack more delta bits in for 0/1 vchs */ + switch (val) { + case '0': + case '1': + rcv = ((val & 1) << 1) | (time_delta << 2); + break; /* pack more delta bits in for 0/1 vchs */ - case 'x': case 'X': rcv = FST_RCV_X | (time_delta<<4); break; - case 'z': case 'Z': rcv = FST_RCV_Z | (time_delta<<4); break; - case 'h': case 'H': rcv = FST_RCV_H | (time_delta<<4); break; - case 'u': case 'U': rcv = FST_RCV_U | (time_delta<<4); break; - case 'w': case 'W': rcv = FST_RCV_W | (time_delta<<4); break; - case 'l': case 'L': rcv = FST_RCV_L | (time_delta<<4); break; - default: rcv = FST_RCV_D | (time_delta<<4); break; - } - - scratchpnt = fstCopyVarint32ToLeft(scratchpnt, rcv); - } - } - else - { - /* variable length */ - /* fstGetUint32 (next_offs) + fstGetVarint32 (time_delta) + fstGetVarint32 (len) + payload */ - unsigned char *pnt; - uint32_t record_len; - uint32_t time_delta; - - while(offs) - { - next_offs = fstGetUint32(vchg_mem + offs); - offs += 4; - pnt = vchg_mem + offs; - offs = next_offs; - time_delta = fstGetVarint32(pnt, (int *)&wrlen); - pnt += wrlen; - record_len = fstGetVarint32(pnt, (int *)&wrlen); - pnt += wrlen; - - scratchpnt -= record_len; - memcpy(scratchpnt, pnt, record_len); - - scratchpnt = fstCopyVarint32ToLeft(scratchpnt, record_len); - scratchpnt = fstCopyVarint32ToLeft(scratchpnt, (time_delta << 1)); /* reserve | 1 case for future expansion */ - } - } - } - else - { - wrlen = fstGetVarint32Length(vchg_mem + offs + 4); /* used to advance and determine wrlen */ -#ifndef FST_REMOVE_DUPLICATE_VC - memcpy(xc->curval_mem + vm4ip[0], vchg_mem + offs + 4 + wrlen, vm4ip[1]); /* checkpoint variable */ -#endif - while(offs) - { - unsigned int idx; - char is_binary = 1; - unsigned char *pnt; - uint32_t time_delta; - - next_offs = fstGetUint32(vchg_mem + offs); - offs += 4; - - time_delta = fstGetVarint32(vchg_mem + offs, (int *)&wrlen); - - pnt = vchg_mem+offs+wrlen; - offs = next_offs; - - for(idx=0;idxvchg_siz - scratchpnt; - unc_memreq += wrlen; - if(wrlen > 32) - { - unsigned long destlen = wrlen; - unsigned char *dmem; - unsigned int rc; + scratchpnt = fstCopyVarint32ToLeft(scratchpnt, rcv); + } + } else { + /* variable length */ + /* fstGetUint32 (next_offs) + fstGetVarint32 (time_delta) + fstGetVarint32 (len) + * + payload */ + unsigned char *pnt; + uint32_t record_len; + uint32_t time_delta; - if(!xc->fastpack) - { - if(wrlen <= packmemlen) - { - dmem = packmem; - } - else - { - free(packmem); - dmem = packmem = (unsigned char *)malloc(compressBound(packmemlen = wrlen)); - } + while (offs) { + next_offs = fstGetUint32(vchg_mem + offs); + offs += 4; + pnt = vchg_mem + offs; + offs = next_offs; + time_delta = fstGetVarint32(pnt, (int *)&wrlen); + pnt += wrlen; + record_len = fstGetVarint32(pnt, (int *)&wrlen); + pnt += wrlen; - rc = compress2(dmem, &destlen, scratchpnt, wrlen, 4); - if(rc == Z_OK) - { -#ifndef FST_DYNAMIC_ALIAS_DISABLE - PPvoid_t pv = JudyHSIns(&PJHSArray, dmem, destlen, NULL); - if(*pv) - { - uint32_t pvi = (intptr_t)(*pv); - vm4ip[2] = -pvi; - } - else - { - *pv = (void *)(intptr_t)(i+1); -#endif - fpos += fstWriterVarint(f, wrlen); - fpos += destlen; - fstFwrite(dmem, destlen, 1, f); -#ifndef FST_DYNAMIC_ALIAS_DISABLE - } -#endif - } - else - { -#ifndef FST_DYNAMIC_ALIAS_DISABLE - PPvoid_t pv = JudyHSIns(&PJHSArray, scratchpnt, wrlen, NULL); - if(*pv) - { - uint32_t pvi = (intptr_t)(*pv); - vm4ip[2] = -pvi; - } - else - { - *pv = (void *)(intptr_t)(i+1); -#endif - fpos += fstWriterVarint(f, 0); - fpos += wrlen; - fstFwrite(scratchpnt, wrlen, 1, f); -#ifndef FST_DYNAMIC_ALIAS_DISABLE - } -#endif - } - } - else - { - /* this is extremely conservative: fastlz needs +5% for worst case, lz4 needs siz+(siz/255)+16 */ - if(((wrlen * 2) + 2) <= packmemlen) - { - dmem = packmem; - } - else - { - free(packmem); - dmem = packmem = (unsigned char *)malloc(packmemlen = (wrlen * 2) + 2); - } + scratchpnt -= record_len; + memcpy(scratchpnt, pnt, record_len); - rc = (xc->fourpack) ? LZ4_compress_default((char *)scratchpnt, (char *)dmem, wrlen, packmemlen) : fastlz_compress(scratchpnt, wrlen, dmem); - if(rc < destlen) - { -#ifndef FST_DYNAMIC_ALIAS_DISABLE - PPvoid_t pv = JudyHSIns(&PJHSArray, dmem, rc, NULL); - if(*pv) - { - uint32_t pvi = (intptr_t)(*pv); - vm4ip[2] = -pvi; - } - else - { - *pv = (void *)(intptr_t)(i+1); -#endif - fpos += fstWriterVarint(f, wrlen); - fpos += rc; - fstFwrite(dmem, rc, 1, f); -#ifndef FST_DYNAMIC_ALIAS_DISABLE - } -#endif - } - else - { -#ifndef FST_DYNAMIC_ALIAS_DISABLE - PPvoid_t pv = JudyHSIns(&PJHSArray, scratchpnt, wrlen, NULL); - if(*pv) - { - uint32_t pvi = (intptr_t)(*pv); - vm4ip[2] = -pvi; - } - else - { - *pv = (void *)(intptr_t)(i+1); -#endif - fpos += fstWriterVarint(f, 0); - fpos += wrlen; - fstFwrite(scratchpnt, wrlen, 1, f); -#ifndef FST_DYNAMIC_ALIAS_DISABLE - } -#endif - } - } - } - else - { -#ifndef FST_DYNAMIC_ALIAS_DISABLE - PPvoid_t pv = JudyHSIns(&PJHSArray, scratchpnt, wrlen, NULL); - if(*pv) - { - uint32_t pvi = (intptr_t)(*pv); - vm4ip[2] = -pvi; - } - else - { - *pv = (void *)(intptr_t)(i+1); -#endif - fpos += fstWriterVarint(f, 0); - fpos += wrlen; - fstFwrite(scratchpnt, wrlen, 1, f); -#ifndef FST_DYNAMIC_ALIAS_DISABLE - } -#endif - } - - /* vm4ip[3] = 0; ...redundant with clearing below */ -#ifdef FST_DEBUG - cnt++; -#endif + scratchpnt = fstCopyVarint32ToLeft(scratchpnt, record_len); + scratchpnt = fstCopyVarint32ToLeft( + scratchpnt, + (time_delta << 1)); /* reserve | 1 case for future expansion */ + } } + } else { + wrlen = fstGetVarint32Length(vchg_mem + offs + + 4); /* used to advance and determine wrlen */ +#ifndef FST_REMOVE_DUPLICATE_VC + memcpy(xc->curval_mem + vm4ip[0], + vchg_mem + offs + 4 + wrlen, + vm4ip[1]); /* checkpoint variable */ +#endif + while (offs) { + unsigned int idx; + char is_binary = 1; + unsigned char *pnt; + uint32_t time_delta; + + next_offs = fstGetUint32(vchg_mem + offs); + offs += 4; + + time_delta = fstGetVarint32(vchg_mem + offs, (int *)&wrlen); + + pnt = vchg_mem + offs + wrlen; + offs = next_offs; + + for (idx = 0; idx < vm4ip[1]; idx++) { + if ((pnt[idx] == '0') || (pnt[idx] == '1')) { + continue; + } else { + is_binary = 0; + break; + } + } + + if (is_binary) { + unsigned char acc = 0; + /* new algorithm */ + idx = ((vm4ip[1] + 7) & ~7); + switch (vm4ip[1] & 7) { + case 0: + do { + acc = (pnt[idx + 7 - 8] & 1) << 0; /* fallthrough */ + case 7: + acc |= (pnt[idx + 6 - 8] & 1) << 1; /* fallthrough */ + case 6: + acc |= (pnt[idx + 5 - 8] & 1) << 2; /* fallthrough */ + case 5: + acc |= (pnt[idx + 4 - 8] & 1) << 3; /* fallthrough */ + case 4: + acc |= (pnt[idx + 3 - 8] & 1) << 4; /* fallthrough */ + case 3: + acc |= (pnt[idx + 2 - 8] & 1) << 5; /* fallthrough */ + case 2: + acc |= (pnt[idx + 1 - 8] & 1) << 6; /* fallthrough */ + case 1: + acc |= (pnt[idx + 0 - 8] & 1) << 7; + *(--scratchpnt) = acc; + idx -= 8; + } while (idx); + } + + scratchpnt = fstCopyVarint32ToLeft(scratchpnt, (time_delta << 1)); + } else { + scratchpnt -= vm4ip[1]; + memcpy(scratchpnt, pnt, vm4ip[1]); + + scratchpnt = fstCopyVarint32ToLeft(scratchpnt, (time_delta << 1) | 1); + } + } + } + + wrlen = scratchpad + xc->vchg_siz - scratchpnt; + unc_memreq += wrlen; + if (wrlen > 32) { + unsigned long destlen = wrlen; + unsigned char *dmem; + unsigned int rc; + + if (!xc->fastpack) { + if (wrlen <= packmemlen) { + dmem = packmem; + } else { + free(packmem); + dmem = packmem = (unsigned char *)malloc(compressBound(packmemlen = wrlen)); + } + + rc = compress2(dmem, &destlen, scratchpnt, wrlen, 4); + if (rc == Z_OK) { +#ifndef FST_DYNAMIC_ALIAS_DISABLE + PPvoid_t pv = JenkinsIns(&PJHSArray, dmem, destlen, hashmask); + if (*pv) { + uint32_t pvi = (intptr_t)(*pv); + vm4ip[2] = -pvi; + } else { + *pv = (void *)(intptr_t)(i + 1); +#endif + fpos += fstWriterVarint(f, wrlen); + fpos += destlen; + fstFwrite(dmem, destlen, 1, f); +#ifndef FST_DYNAMIC_ALIAS_DISABLE + } +#endif + } else { +#ifndef FST_DYNAMIC_ALIAS_DISABLE + PPvoid_t pv = JenkinsIns(&PJHSArray, scratchpnt, wrlen, hashmask); + if (*pv) { + uint32_t pvi = (intptr_t)(*pv); + vm4ip[2] = -pvi; + } else { + *pv = (void *)(intptr_t)(i + 1); +#endif + fpos += fstWriterVarint(f, 0); + fpos += wrlen; + fstFwrite(scratchpnt, wrlen, 1, f); +#ifndef FST_DYNAMIC_ALIAS_DISABLE + } +#endif + } + } else { + /* this is extremely conservative: fastlz needs +5% for worst case, lz4 needs + * siz+(siz/255)+16 */ + if (((wrlen * 2) + 2) <= packmemlen) { + dmem = packmem; + } else { + free(packmem); + dmem = packmem = (unsigned char *)malloc(packmemlen = (wrlen * 2) + 2); + } + + rc = (xc->fourpack) ? LZ4_compress_default((char *)scratchpnt, + (char *)dmem, + wrlen, + packmemlen) + : fastlz_compress(scratchpnt, wrlen, dmem); + if (rc < destlen) { +#ifndef FST_DYNAMIC_ALIAS_DISABLE + PPvoid_t pv = JenkinsIns(&PJHSArray, dmem, rc, hashmask); + if (*pv) { + uint32_t pvi = (intptr_t)(*pv); + vm4ip[2] = -pvi; + } else { + *pv = (void *)(intptr_t)(i + 1); +#endif + fpos += fstWriterVarint(f, wrlen); + fpos += rc; + fstFwrite(dmem, rc, 1, f); +#ifndef FST_DYNAMIC_ALIAS_DISABLE + } +#endif + } else { +#ifndef FST_DYNAMIC_ALIAS_DISABLE + PPvoid_t pv = JenkinsIns(&PJHSArray, scratchpnt, wrlen, hashmask); + if (*pv) { + uint32_t pvi = (intptr_t)(*pv); + vm4ip[2] = -pvi; + } else { + *pv = (void *)(intptr_t)(i + 1); +#endif + fpos += fstWriterVarint(f, 0); + fpos += wrlen; + fstFwrite(scratchpnt, wrlen, 1, f); +#ifndef FST_DYNAMIC_ALIAS_DISABLE + } +#endif + } + } + } else { +#ifndef FST_DYNAMIC_ALIAS_DISABLE + PPvoid_t pv = JenkinsIns(&PJHSArray, scratchpnt, wrlen, hashmask); + if (*pv) { + uint32_t pvi = (intptr_t)(*pv); + vm4ip[2] = -pvi; + } else { + *pv = (void *)(intptr_t)(i + 1); +#endif + fpos += fstWriterVarint(f, 0); + fpos += wrlen; + fstFwrite(scratchpnt, wrlen, 1, f); +#ifndef FST_DYNAMIC_ALIAS_DISABLE + } +#endif + } + + /* vm4ip[3] = 0; ...redundant with clearing below */ +#ifdef FST_DEBUG + cnt++; +#endif } + } #ifndef FST_DYNAMIC_ALIAS_DISABLE -JudyHSFreeArray(&PJHSArray, NULL); + JenkinsFree(&PJHSArray, hashmask); #endif -free(packmem); packmem = NULL; /* packmemlen = 0; */ /* scan-build */ + free(packmem); + packmem = NULL; /* packmemlen = 0; */ /* scan-build */ -prevpos = 0; zerocnt = 0; -free(scratchpad); scratchpad = NULL; + prevpos = 0; + zerocnt = 0; + free(scratchpad); + scratchpad = NULL; -indxpos = ftello(f); -xc->secnum++; + indxpos = ftello(f); + xc->secnum++; #ifndef FST_DYNAMIC_ALIAS2_DISABLE -if(1) - { + if (1) { uint32_t prev_alias = 0; - for(i=0;imaxhandle;i++) - { - vm4ip = &(xc->valpos_mem[4*i]); + for (i = 0; i < xc->maxhandle; i++) { + vm4ip = &(xc->valpos_mem[4 * i]); - if(vm4ip[2]) - { - if(zerocnt) - { - fpos += fstWriterVarint(f, (zerocnt << 1)); - zerocnt = 0; - } - - if(vm4ip[2] & 0x80000000) - { - if(vm4ip[2] != prev_alias) - { - int32_t t_i32 = ((int32_t)(prev_alias = vm4ip[2])); /* vm4ip is generic unsigned data */ - int64_t t_i64 = (int64_t)t_i32; /* convert to signed */ - uint64_t t_u64 = (uint64_t)t_i64; /* sign extend through 64b */ - - fpos += fstWriterSVarint(f, (int64_t)((t_u64 << 1) | 1)); /* all in this block was: fpos += fstWriterSVarint(f, (((int64_t)((int32_t)(prev_alias = vm4ip[2]))) << 1) | 1); */ - } - else - { - fpos += fstWriterSVarint(f, (0 << 1) | 1); - } - } - else - { - fpos += fstWriterSVarint(f, ((vm4ip[2] - prevpos) << 1) | 1); - prevpos = vm4ip[2]; - } - vm4ip[2] = 0; - vm4ip[3] = 0; /* clear out tchn idx */ - } - else - { - zerocnt++; - } + if (vm4ip[2]) { + if (zerocnt) { + fpos += fstWriterVarint(f, (zerocnt << 1)); + zerocnt = 0; } + + if (vm4ip[2] & 0x80000000) { + if (vm4ip[2] != prev_alias) { + int32_t t_i32 = + ((int32_t)(prev_alias = vm4ip[2])); /* vm4ip is generic unsigned data */ + int64_t t_i64 = (int64_t)t_i32; /* convert to signed */ + uint64_t t_u64 = (uint64_t)t_i64; /* sign extend through 64b */ + + fpos += fstWriterSVarint( + f, + (int64_t)((t_u64 << 1) | + 1)); /* all in this block was: fpos += fstWriterSVarint(f, + (((int64_t)((int32_t)(prev_alias = vm4ip[2]))) << 1) | + 1); */ + } else { + fpos += fstWriterSVarint(f, (0 << 1) | 1); + } + } else { + fpos += fstWriterSVarint(f, ((vm4ip[2] - prevpos) << 1) | 1); + prevpos = vm4ip[2]; + } + vm4ip[2] = 0; + vm4ip[3] = 0; /* clear out tchn idx */ + } else { + zerocnt++; + } } - else + } else #endif - { - for(i=0;imaxhandle;i++) - { - vm4ip = &(xc->valpos_mem[4*i]); + { + for (i = 0; i < xc->maxhandle; i++) { + vm4ip = &(xc->valpos_mem[4 * i]); - if(vm4ip[2]) - { - if(zerocnt) - { - fpos += fstWriterVarint(f, (zerocnt << 1)); - zerocnt = 0; - } - - if(vm4ip[2] & 0x80000000) - { - fpos += fstWriterVarint(f, 0); /* signal, note that using a *signed* varint would be more efficient than this byte escape! */ - fpos += fstWriterVarint(f, (-(int32_t)vm4ip[2])); - } - else - { - fpos += fstWriterVarint(f, ((vm4ip[2] - prevpos) << 1) | 1); - prevpos = vm4ip[2]; - } - vm4ip[2] = 0; - vm4ip[3] = 0; /* clear out tchn idx */ - } - else - { - zerocnt++; - } + if (vm4ip[2]) { + if (zerocnt) { + fpos += fstWriterVarint(f, (zerocnt << 1)); + zerocnt = 0; } - } -if(zerocnt) - { + if (vm4ip[2] & 0x80000000) { + fpos += + fstWriterVarint(f, 0); /* signal, note that using a *signed* varint would be + more efficient than this byte escape! */ + fpos += fstWriterVarint(f, (-(int32_t)vm4ip[2])); + } else { + fpos += fstWriterVarint(f, ((vm4ip[2] - prevpos) << 1) | 1); + prevpos = vm4ip[2]; + } + vm4ip[2] = 0; + vm4ip[3] = 0; /* clear out tchn idx */ + } else { + zerocnt++; + } + } + } + + if (zerocnt) { /* fpos += */ fstWriterVarint(f, (zerocnt << 1)); /* scan-build */ - } + } #ifdef FST_DEBUG -fprintf(stderr, FST_APIMESS "value chains: %d\n", cnt); + fprintf(stderr, FST_APIMESS "value chains: %d\n", cnt); #endif -xc->vchg_mem[0] = '!'; -xc->vchg_siz = 1; + xc->vchg_mem[0] = '!'; + xc->vchg_siz = 1; -endpos = ftello(xc->handle); -fstWriterUint64(xc->handle, endpos-indxpos); /* write delta index position at very end of block */ + endpos = ftello(xc->handle); + fstWriterUint64(xc->handle, + endpos - indxpos); /* write delta index position at very end of block */ -/*emit time changes for block */ -fflush(xc->tchn_handle); -tlen = ftello(xc->tchn_handle); -fstWriterFseeko(xc, xc->tchn_handle, 0, SEEK_SET); + /*emit time changes for block */ + fflush(xc->tchn_handle); + tlen = ftello(xc->tchn_handle); + fstWriterFseeko(xc, xc->tchn_handle, 0, SEEK_SET); -errno = 0; -fstWriterMmapSanity(tmem = (unsigned char *)fstMmap(NULL, tlen, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->tchn_handle), 0), __FILE__, __LINE__, "tmem"); -if(tmem) - { + errno = 0; + fstWriterMmapSanity( + tmem = (unsigned char *) + fstMmap(NULL, tlen, PROT_READ | PROT_WRITE, MAP_SHARED, fileno(xc->tchn_handle), 0), + __FILE__, + __LINE__, + "tmem"); + if (tmem) { unsigned long destlen = tlen; unsigned char *dmem = (unsigned char *)malloc(compressBound(destlen)); int rc = compress2(dmem, &destlen, tmem, tlen, 9); - if((rc == Z_OK) && (((fst_off_t)destlen) < tlen)) - { - fstFwrite(dmem, destlen, 1, xc->handle); - } - else /* comparison between compressed / decompressed len tells if compressed */ - { - fstFwrite(tmem, tlen, 1, xc->handle); - destlen = tlen; - } + if ((rc == Z_OK) && (((fst_off_t)destlen) < tlen)) { + fstFwrite(dmem, destlen, 1, xc->handle); + } else /* comparison between compressed / decompressed len tells if compressed */ + { + fstFwrite(tmem, tlen, 1, xc->handle); + destlen = tlen; + } free(dmem); fstMunmap(tmem, tlen); - fstWriterUint64(xc->handle, tlen); /* uncompressed */ - fstWriterUint64(xc->handle, destlen); /* compressed */ - fstWriterUint64(xc->handle, xc->tchn_cnt); /* number of time items */ - } + fstWriterUint64(xc->handle, tlen); /* uncompressed */ + fstWriterUint64(xc->handle, destlen); /* compressed */ + fstWriterUint64(xc->handle, xc->tchn_cnt); /* number of time items */ + } -xc->tchn_cnt = xc->tchn_idx = 0; -fstWriterFseeko(xc, xc->tchn_handle, 0, SEEK_SET); -fstFtruncate(fileno(xc->tchn_handle), 0); + xc->tchn_cnt = xc->tchn_idx = 0; + fstWriterFseeko(xc, xc->tchn_handle, 0, SEEK_SET); + fstFtruncate(fileno(xc->tchn_handle), 0); -/* write block trailer */ -endpos = ftello(xc->handle); -fstWriterFseeko(xc, xc->handle, xc->section_start, SEEK_SET); -fstWriterUint64(xc->handle, endpos - xc->section_start); /* write block length */ -fstWriterFseeko(xc, xc->handle, 8, SEEK_CUR); /* skip begin time */ -fstWriterUint64(xc->handle, xc->curtime); /* write end time for section */ -fstWriterUint64(xc->handle, unc_memreq); /* amount of buffer memory required in reader for full traversal */ -fflush(xc->handle); + /* write block trailer */ + endpos = ftello(xc->handle); + fstWriterFseeko(xc, xc->handle, xc->section_start, SEEK_SET); + fstWriterUint64(xc->handle, endpos - xc->section_start); /* write block length */ + fstWriterFseeko(xc, xc->handle, 8, SEEK_CUR); /* skip begin time */ + fstWriterUint64(xc->handle, xc->curtime); /* write end time for section */ + fstWriterUint64(xc->handle, + unc_memreq); /* amount of buffer memory required in reader for full traversal */ + fflush(xc->handle); -fstWriterFseeko(xc, xc->handle, xc->section_start-1, SEEK_SET); /* write out FST_BL_VCDATA over FST_BL_SKIP */ + fstWriterFseeko(xc, + xc->handle, + xc->section_start - 1, + SEEK_SET); /* write out FST_BL_VCDATA over FST_BL_SKIP */ #ifndef FST_DYNAMIC_ALIAS_DISABLE #ifndef FST_DYNAMIC_ALIAS2_DISABLE -fputc(FST_BL_VCDATA_DYN_ALIAS2, xc->handle); + fputc(FST_BL_VCDATA_DYN_ALIAS2, xc->handle); #else -fputc(FST_BL_VCDATA_DYN_ALIAS, xc->handle); + fputc(FST_BL_VCDATA_DYN_ALIAS, xc->handle); #endif #else -fputc(FST_BL_VCDATA, xc->handle); + fputc(FST_BL_VCDATA, xc->handle); #endif -fflush(xc->handle); + fflush(xc->handle); -fstWriterFseeko(xc, xc->handle, endpos, SEEK_SET); /* seek to end of file */ + fstWriterFseeko(xc, xc->handle, endpos, SEEK_SET); /* seek to end of file */ -xc2->section_header_truncpos = endpos; /* cache in case of need to truncate */ -if(xc->dump_size_limit) - { - if(endpos >= ((fst_off_t)xc->dump_size_limit)) - { - xc2->skip_writing_section_hdr = 1; - xc2->size_limit_locked = 1; - xc2->is_initial_time = 1; /* to trick emit value and emit time change */ + xc2->section_header_truncpos = endpos; /* cache in case of need to truncate */ + if (xc->dump_size_limit) { + if (endpos >= ((fst_off_t)xc->dump_size_limit)) { + xc2->skip_writing_section_hdr = 1; + xc2->size_limit_locked = 1; + xc2->is_initial_time = 1; /* to trick emit value and emit time change */ #ifdef FST_DEBUG - fprintf(stderr, FST_APIMESS "<< dump file size limit reached, stopping dumping >>\n"); + fprintf(stderr, FST_APIMESS "<< dump file size limit reached, stopping dumping >>\n"); #endif - } } + } -if(!xc2->skip_writing_section_hdr) - { - fstWriterEmitSectionHeader(xc); /* emit next section header */ - } -fflush(xc->handle); + if (!xc2->skip_writing_section_hdr) { + fstWriterEmitSectionHeader(xc); /* emit next section header */ + } + fflush(xc->handle); -xc->already_in_flush = 0; + xc->already_in_flush = 0; } - #ifdef FST_WRITER_PARALLEL static void *fstWriterFlushContextPrivate1(void *ctx) { -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; -struct fstWriterContext *xc_parent; + struct fstWriterContext *xc = (struct fstWriterContext *)ctx; + struct fstWriterContext *xc_parent; -pthread_mutex_lock(&(xc->xc_parent->mutex)); -fstWriterFlushContextPrivate2(xc); + pthread_mutex_lock(&(xc->xc_parent->mutex)); + fstWriterFlushContextPrivate2(xc); #ifdef FST_REMOVE_DUPLICATE_VC -free(xc->curval_mem); + free(xc->curval_mem); #endif -free(xc->valpos_mem); -free(xc->vchg_mem); -tmpfile_close(&xc->tchn_handle, &xc->tchn_handle_nam); -xc_parent = xc->xc_parent; -free(xc); + free(xc->valpos_mem); + free(xc->vchg_mem); + tmpfile_close(&xc->tchn_handle, &xc->tchn_handle_nam); + xc_parent = xc->xc_parent; + free(xc); -xc_parent->in_pthread = 0; -pthread_mutex_unlock(&(xc_parent->mutex)); + xc_parent->in_pthread = 0; + pthread_mutex_unlock(&(xc_parent->mutex)); -return(NULL); + 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)); + if (xc->parallel_enabled) { + struct fstWriterContext *xc2 = + (struct fstWriterContext *)malloc(sizeof(struct fstWriterContext)); unsigned int i; pthread_mutex_lock(&xc->mutex); @@ -1847,13 +1768,13 @@ if(xc->parallel_enabled) xc->xc_parent = xc; memcpy(xc2, xc, sizeof(struct fstWriterContext)); - if(sizeof(size_t) < sizeof(uint64_t)) - { - /* TALOS-2023-1777 for 32b overflow */ - uint64_t chk_64 = xc->maxhandle * 4 * sizeof(uint32_t); - size_t chk_32 = xc->maxhandle * 4 * sizeof(uint32_t); - if(chk_64 != chk_32) chk_report_abort("TALOS-2023-1777"); - } + if (sizeof(size_t) < sizeof(uint64_t)) { + /* TALOS-2023-1777 for 32b overflow */ + uint64_t chk_64 = xc->maxhandle * 4 * sizeof(uint32_t); + size_t chk_32 = xc->maxhandle * 4 * sizeof(uint32_t); + if (chk_64 != chk_32) + chk_report_abort("TALOS-2023-1777"); + } xc2->valpos_mem = (uint32_t *)malloc(xc->maxhandle * 4 * sizeof(uint32_t)); memcpy(xc2->valpos_mem, xc->valpos_mem, xc->maxhandle * 4 * sizeof(uint32_t)); @@ -1868,303 +1789,309 @@ if(xc->parallel_enabled) xc->vchg_mem[0] = '!'; xc->vchg_siz = 1; - for(i=0;imaxhandle;i++) - { - uint32_t *vm4ip = &(xc->valpos_mem[4*i]); - vm4ip[2] = 0; /* zero out offset val */ - vm4ip[3] = 0; /* zero out last time change val */ - } + for (i = 0; i < xc->maxhandle; i++) { + uint32_t *vm4ip = &(xc->valpos_mem[4 * i]); + vm4ip[2] = 0; /* zero out offset val */ + vm4ip[3] = 0; /* zero out last time change val */ + } xc->tchn_cnt = xc->tchn_idx = 0; - xc->tchn_handle = tmpfile_open(&xc->tchn_handle_nam); /* child thread will deallocate file/name */ + xc->tchn_handle = + tmpfile_open(&xc->tchn_handle_nam); /* child thread will deallocate file/name */ fstWriterFseeko(xc, xc->tchn_handle, 0, SEEK_SET); fstFtruncate(fileno(xc->tchn_handle), 0); xc->section_header_only = 0; xc->secnum++; - while (xc->in_pthread) - { - pthread_mutex_lock(&xc->mutex); - pthread_mutex_unlock(&xc->mutex); - }; + while (xc->in_pthread) { + pthread_mutex_lock(&xc->mutex); + pthread_mutex_unlock(&xc->mutex); + }; pthread_mutex_lock(&xc->mutex); - xc->in_pthread = 1; + xc->in_pthread = 1; pthread_mutex_unlock(&xc->mutex); pthread_create(&xc->thread, &xc->thread_attr, fstWriterFlushContextPrivate1, xc2); - } - else + } else { + if (xc->parallel_was_enabled) /* conservatively block */ { - if(xc->parallel_was_enabled) /* conservatively block */ - { - pthread_mutex_lock(&xc->mutex); - pthread_mutex_unlock(&xc->mutex); - } + pthread_mutex_lock(&xc->mutex); + pthread_mutex_unlock(&xc->mutex); + } xc->xc_parent = xc; fstWriterFlushContextPrivate2(xc); - } + } } #endif - /* * 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; - } + if (xc) { + if (xc->tchn_idx > 1) { + xc->flush_context_pending = 1; } + } } - /* * close out FST file */ -void fstWriterClose(void *ctx) +void fstWriterClose(fstWriterContext *xc) { -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; - #ifdef FST_WRITER_PARALLEL -if(xc) - { + if (xc) { pthread_mutex_lock(&xc->mutex); pthread_mutex_unlock(&xc->mutex); - } + } #endif -if(xc && !xc->already_in_close && !xc->already_in_flush) - { + if (xc && !xc->already_in_close && !xc->already_in_flush) { unsigned char *tmem = NULL; fst_off_t fixup_offs, tlen, hlen; xc->already_in_close = 1; /* never need to zero this out as it is freed at bottom */ - if(xc->section_header_only && xc->section_header_truncpos && (xc->vchg_siz <= 1) && (!xc->is_initial_time)) + if (xc->section_header_only && xc->section_header_truncpos && (xc->vchg_siz <= 1) && + (!xc->is_initial_time)) { + fstFtruncate(fileno(xc->handle), xc->section_header_truncpos); + fstWriterFseeko(xc, xc->handle, xc->section_header_truncpos, SEEK_SET); + xc->section_header_only = 0; + } else { + xc->skip_writing_section_hdr = 1; + if (!xc->size_limit_locked) { + if (FST_UNLIKELY(xc->is_initial_time)) /* simulation time never advanced so mock up + the changes as time zero ones */ { - fstFtruncate(fileno(xc->handle), xc->section_header_truncpos); - fstWriterFseeko(xc, xc->handle, xc->section_header_truncpos, SEEK_SET); - xc->section_header_only = 0; - } - else - { - xc->skip_writing_section_hdr = 1; - if(!xc->size_limit_locked) - { - if(FST_UNLIKELY(xc->is_initial_time)) /* simulation time never advanced so mock up the changes as time zero ones */ - { - fstHandle dupe_idx; + fstHandle dupe_idx; - fstWriterEmitTimeChange(xc, 0); /* emit some time change just to have one */ - for(dupe_idx = 0; dupe_idx < xc->maxhandle; dupe_idx++) /* now clone the values */ - { - fstWriterEmitValueChange(xc, dupe_idx+1, xc->curval_mem + xc->valpos_mem[4*dupe_idx]); - } - } - fstWriterFlushContextPrivate(xc); + fstWriterEmitTimeChange(xc, 0); /* emit some time change just to have one */ + for (dupe_idx = 0; dupe_idx < xc->maxhandle; + dupe_idx++) /* now clone the values */ + { + fstWriterEmitValueChange(xc, + dupe_idx + 1, + xc->curval_mem + xc->valpos_mem[4 * dupe_idx]); + } + } + fstWriterFlushContextPrivate(xc); #ifdef FST_WRITER_PARALLEL - pthread_mutex_lock(&xc->mutex); - pthread_mutex_unlock(&xc->mutex); + pthread_mutex_lock(&xc->mutex); + pthread_mutex_unlock(&xc->mutex); - while (xc->in_pthread) - { - pthread_mutex_lock(&xc->mutex); - pthread_mutex_unlock(&xc->mutex); - }; + while (xc->in_pthread) { + pthread_mutex_lock(&xc->mutex); + pthread_mutex_unlock(&xc->mutex); + }; #endif - } - } + } + } fstDestroyMmaps(xc, 1); - if(xc->outval_mem) - { - free(xc->outval_mem); xc->outval_mem = NULL; - xc->outval_alloc_siz = 0; - } + if (xc->outval_mem) { + free(xc->outval_mem); + xc->outval_mem = NULL; + xc->outval_alloc_siz = 0; + } /* write out geom section */ fflush(xc->geom_handle); tlen = ftello(xc->geom_handle); - errno = 0; - if(tlen) - { - fstWriterMmapSanity(tmem = (unsigned char *)fstMmap(NULL, tlen, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->geom_handle), 0), __FILE__, __LINE__, "tmem"); - } + errno = 0; + if (tlen) { + fstWriterMmapSanity(tmem = (unsigned char *)fstMmap(NULL, + tlen, + PROT_READ | PROT_WRITE, + MAP_SHARED, + fileno(xc->geom_handle), + 0), + __FILE__, + __LINE__, + "tmem"); + } - if(tmem) - { - unsigned long destlen = tlen; - unsigned char *dmem = (unsigned char *)malloc(compressBound(destlen)); - int rc = compress2(dmem, &destlen, tmem, tlen, 9); + if (tmem) { + unsigned long destlen = tlen; + unsigned char *dmem = (unsigned char *)malloc(compressBound(destlen)); + int rc = compress2(dmem, &destlen, tmem, tlen, 9); - if((rc != Z_OK) || (((fst_off_t)destlen) > tlen)) - { - destlen = tlen; - } + if ((rc != Z_OK) || (((fst_off_t)destlen) > tlen)) { + destlen = tlen; + } - fixup_offs = ftello(xc->handle); - fputc(FST_BL_SKIP, xc->handle); /* temporary tag */ - fstWriterUint64(xc->handle, destlen + 24); /* section length */ - fstWriterUint64(xc->handle, tlen); /* uncompressed */ - /* compressed len is section length - 24 */ - fstWriterUint64(xc->handle, xc->maxhandle); /* maxhandle */ - fstFwrite((((fst_off_t)destlen) != tlen) ? dmem : tmem, destlen, 1, xc->handle); - fflush(xc->handle); + fixup_offs = ftello(xc->handle); + fputc(FST_BL_SKIP, xc->handle); /* temporary tag */ + fstWriterUint64(xc->handle, destlen + 24); /* section length */ + fstWriterUint64(xc->handle, tlen); /* uncompressed */ + /* compressed len is section length - 24 */ + fstWriterUint64(xc->handle, xc->maxhandle); /* maxhandle */ + fstFwrite((((fst_off_t)destlen) != tlen) ? dmem : tmem, destlen, 1, xc->handle); + fflush(xc->handle); - fstWriterFseeko(xc, xc->handle, fixup_offs, SEEK_SET); - fputc(FST_BL_GEOM, xc->handle); /* actual tag */ + fstWriterFseeko(xc, xc->handle, fixup_offs, SEEK_SET); + fputc(FST_BL_GEOM, xc->handle); /* actual tag */ - fstWriterFseeko(xc, xc->handle, 0, SEEK_END); /* move file pointer to end for any section adds */ - fflush(xc->handle); + fstWriterFseeko(xc, + xc->handle, + 0, + SEEK_END); /* move file pointer to end for any section adds */ + fflush(xc->handle); - free(dmem); - fstMunmap(tmem, tlen); - } + free(dmem); + fstMunmap(tmem, tlen); + } - if(xc->num_blackouts) - { - uint64_t cur_bl = 0; - fst_off_t bpos, eos; - uint32_t i; + if (xc->num_blackouts) { + uint64_t cur_bl = 0; + fst_off_t bpos, eos; + uint32_t i; - fixup_offs = ftello(xc->handle); - fputc(FST_BL_SKIP, xc->handle); /* temporary tag */ - bpos = fixup_offs + 1; - fstWriterUint64(xc->handle, 0); /* section length */ - fstWriterVarint(xc->handle, xc->num_blackouts); + fixup_offs = ftello(xc->handle); + fputc(FST_BL_SKIP, xc->handle); /* temporary tag */ + bpos = fixup_offs + 1; + fstWriterUint64(xc->handle, 0); /* section length */ + fstWriterVarint(xc->handle, xc->num_blackouts); - for(i=0;inum_blackouts;i++) - { - fputc(xc->blackout_head->active, xc->handle); - fstWriterVarint(xc->handle, xc->blackout_head->tim - cur_bl); - cur_bl = xc->blackout_head->tim; - xc->blackout_curr = xc->blackout_head->next; - free(xc->blackout_head); - xc->blackout_head = xc->blackout_curr; - } + for (i = 0; i < xc->num_blackouts; i++) { + fputc(xc->blackout_head->active, xc->handle); + fstWriterVarint(xc->handle, xc->blackout_head->tim - cur_bl); + cur_bl = xc->blackout_head->tim; + xc->blackout_curr = xc->blackout_head->next; + free(xc->blackout_head); + xc->blackout_head = xc->blackout_curr; + } - eos = ftello(xc->handle); - fstWriterFseeko(xc, xc->handle, bpos, SEEK_SET); - fstWriterUint64(xc->handle, eos - bpos); - fflush(xc->handle); + eos = ftello(xc->handle); + fstWriterFseeko(xc, xc->handle, bpos, SEEK_SET); + fstWriterUint64(xc->handle, eos - bpos); + fflush(xc->handle); - fstWriterFseeko(xc, xc->handle, fixup_offs, SEEK_SET); - fputc(FST_BL_BLACKOUT, xc->handle); /* actual tag */ + fstWriterFseeko(xc, xc->handle, fixup_offs, SEEK_SET); + fputc(FST_BL_BLACKOUT, xc->handle); /* actual tag */ - fstWriterFseeko(xc, xc->handle, 0, SEEK_END); /* move file pointer to end for any section adds */ - fflush(xc->handle); - } + fstWriterFseeko(xc, + xc->handle, + 0, + SEEK_END); /* move file pointer to end for any section adds */ + fflush(xc->handle); + } - if(xc->compress_hier) - { - fst_off_t hl, eos; - gzFile zhandle; - int zfd; - int fourpack_duo = 0; + if (xc->compress_hier) { + fst_off_t hl, eos; + gzFile zhandle; + int zfd; + int fourpack_duo = 0; #ifndef __MINGW32__ - int fnam_len = strlen(xc->filename) + 5 + 1; - char *fnam = (char *)malloc(fnam_len); + int fnam_len = strlen(xc->filename) + 5 + 1; + char *fnam = (char *)malloc(fnam_len); #endif - fixup_offs = ftello(xc->handle); - fputc(FST_BL_SKIP, xc->handle); /* temporary tag */ - hlen = ftello(xc->handle); - fstWriterUint64(xc->handle, 0); /* section length */ - fstWriterUint64(xc->handle, xc->hier_file_len); /* uncompressed length */ + fixup_offs = ftello(xc->handle); + fputc(FST_BL_SKIP, xc->handle); /* temporary tag */ + hlen = ftello(xc->handle); + fstWriterUint64(xc->handle, 0); /* section length */ + fstWriterUint64(xc->handle, xc->hier_file_len); /* uncompressed length */ - if(!xc->fourpack) - { - unsigned char *mem = (unsigned char *)malloc(FST_GZIO_LEN); - zfd = dup(fileno(xc->handle)); - fflush(xc->handle); - zhandle = gzdopen(zfd, "wb4"); - if(zhandle) - { - fstWriterFseeko(xc, xc->hier_handle, 0, SEEK_SET); - for(hl = 0; hl < xc->hier_file_len; hl += FST_GZIO_LEN) - { - unsigned len = ((xc->hier_file_len - hl) > FST_GZIO_LEN) ? FST_GZIO_LEN : (xc->hier_file_len - hl); - fstFread(mem, len, 1, xc->hier_handle); - gzwrite(zhandle, mem, len); - } - gzclose(zhandle); - } - else - { - close(zfd); - } - free(mem); - } - else - { - int lz4_maxlen; - unsigned char *mem; - unsigned char *hmem = NULL; - int packed_len; + if (!xc->fourpack) { + unsigned char *mem = (unsigned char *)malloc(FST_GZIO_LEN); + zfd = dup(fileno(xc->handle)); + fflush(xc->handle); + zhandle = gzdopen(zfd, "wb4"); + if (zhandle) { + fstWriterFseeko(xc, xc->hier_handle, 0, SEEK_SET); + for (hl = 0; hl < xc->hier_file_len; hl += FST_GZIO_LEN) { + unsigned len = ((xc->hier_file_len - hl) > FST_GZIO_LEN) + ? FST_GZIO_LEN + : (xc->hier_file_len - hl); + fstFread(mem, len, 1, xc->hier_handle); + gzwrite(zhandle, mem, len); + } + gzclose(zhandle); + } else { + close(zfd); + } + free(mem); + } else { + int lz4_maxlen; + unsigned char *mem; + unsigned char *hmem = NULL; + int packed_len; - fflush(xc->handle); - - lz4_maxlen = LZ4_compressBound(xc->hier_file_len); - mem = (unsigned char *)malloc(lz4_maxlen); - errno = 0; - if(xc->hier_file_len) - { - fstWriterMmapSanity(hmem = (unsigned char *)fstMmap(NULL, xc->hier_file_len, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->hier_handle), 0), __FILE__, __LINE__, "hmem"); - } - packed_len = LZ4_compress_default((char *)hmem, (char *)mem, xc->hier_file_len, lz4_maxlen); - fstMunmap(hmem, xc->hier_file_len); - - fourpack_duo = (!xc->repack_on_close) && (xc->hier_file_len > FST_HDR_FOURPACK_DUO_SIZE); /* double pack when hierarchy is large */ - - if(fourpack_duo) /* double packing with LZ4 is faster than gzip */ - { - unsigned char *mem_duo; - int lz4_maxlen_duo; - int packed_len_duo; - - lz4_maxlen_duo = LZ4_compressBound(packed_len); - mem_duo = (unsigned char *)malloc(lz4_maxlen_duo); - packed_len_duo = LZ4_compress_default((char *)mem, (char *)mem_duo, packed_len, lz4_maxlen_duo); - - fstWriterVarint(xc->handle, packed_len); /* 1st round compressed length */ - fstFwrite(mem_duo, packed_len_duo, 1, xc->handle); - free(mem_duo); - } - else - { - fstFwrite(mem, packed_len, 1, xc->handle); - } - - free(mem); - } - - fstWriterFseeko(xc, xc->handle, 0, SEEK_END); - eos = ftello(xc->handle); - fstWriterFseeko(xc, xc->handle, hlen, SEEK_SET); - fstWriterUint64(xc->handle, eos - hlen); fflush(xc->handle); - fstWriterFseeko(xc, xc->handle, fixup_offs, SEEK_SET); - fputc(xc->fourpack ? - ( fourpack_duo ? FST_BL_HIER_LZ4DUO : FST_BL_HIER_LZ4) : - FST_BL_HIER, xc->handle); /* actual tag now also == compression type */ + lz4_maxlen = LZ4_compressBound(xc->hier_file_len); + mem = (unsigned char *)malloc(lz4_maxlen); + errno = 0; + if (xc->hier_file_len) { + fstWriterMmapSanity(hmem = (unsigned char *)fstMmap(NULL, + xc->hier_file_len, + PROT_READ | PROT_WRITE, + MAP_SHARED, + fileno(xc->hier_handle), + 0), + __FILE__, + __LINE__, + "hmem"); + } + packed_len = + LZ4_compress_default((char *)hmem, (char *)mem, xc->hier_file_len, lz4_maxlen); + fstMunmap(hmem, xc->hier_file_len); - fstWriterFseeko(xc, xc->handle, 0, SEEK_END); /* move file pointer to end for any section adds */ - fflush(xc->handle); + fourpack_duo = + (!xc->repack_on_close) && + (xc->hier_file_len > + FST_HDR_FOURPACK_DUO_SIZE); /* double pack when hierarchy is large */ + + if (fourpack_duo) /* double packing with LZ4 is faster than gzip */ + { + unsigned char *mem_duo; + int lz4_maxlen_duo; + int packed_len_duo; + + lz4_maxlen_duo = LZ4_compressBound(packed_len); + mem_duo = (unsigned char *)malloc(lz4_maxlen_duo); + packed_len_duo = LZ4_compress_default((char *)mem, + (char *)mem_duo, + packed_len, + lz4_maxlen_duo); + + fstWriterVarint(xc->handle, packed_len); /* 1st round compressed length */ + fstFwrite(mem_duo, packed_len_duo, 1, xc->handle); + free(mem_duo); + } else { + fstFwrite(mem, packed_len, 1, xc->handle); + } + + free(mem); + } + + fstWriterFseeko(xc, xc->handle, 0, SEEK_END); + eos = ftello(xc->handle); + fstWriterFseeko(xc, xc->handle, hlen, SEEK_SET); + fstWriterUint64(xc->handle, eos - hlen); + fflush(xc->handle); + + fstWriterFseeko(xc, xc->handle, fixup_offs, SEEK_SET); + fputc(xc->fourpack ? (fourpack_duo ? FST_BL_HIER_LZ4DUO : FST_BL_HIER_LZ4) + : FST_BL_HIER, + xc->handle); /* actual tag now also == compression type */ + + fstWriterFseeko(xc, + xc->handle, + 0, + SEEK_END); /* move file pointer to end for any section adds */ + fflush(xc->handle); #ifndef __MINGW32__ - snprintf(fnam, fnam_len, "%s.hier", xc->filename); - unlink(fnam); - free(fnam); + snprintf(fnam, fnam_len, "%s.hier", xc->filename); + unlink(fnam); + free(fnam); #endif - } + } /* finalize out header */ fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_START_TIME, SEEK_SET); @@ -2178,92 +2105,88 @@ if(xc && !xc->already_in_close && !xc->already_in_flush) fflush(xc->handle); tmpfile_close(&xc->tchn_handle, &xc->tchn_handle_nam); - free(xc->vchg_mem); xc->vchg_mem = NULL; + free(xc->vchg_mem); + xc->vchg_mem = NULL; tmpfile_close(&xc->curval_handle, &xc->curval_handle_nam); tmpfile_close(&xc->valpos_handle, &xc->valpos_handle_nam); tmpfile_close(&xc->geom_handle, &xc->geom_handle_nam); - if(xc->hier_handle) { fclose(xc->hier_handle); xc->hier_handle = NULL; } - if(xc->handle) - { - if(xc->repack_on_close) - { - FILE *fp; - fst_off_t offpnt, uclen; - int flen = strlen(xc->filename); - char *hf = (char *)calloc(1, flen + 5); + if (xc->hier_handle) { + fclose(xc->hier_handle); + xc->hier_handle = NULL; + } + if (xc->handle) { + if (xc->repack_on_close) { + FILE *fp; + fst_off_t offpnt, uclen; + int flen = strlen(xc->filename); + char *hf = (char *)calloc(1, flen + 5); - strcpy(hf, xc->filename); - strcpy(hf+flen, ".pak"); - fp = fopen(hf, "wb"); + strcpy(hf, xc->filename); + strcpy(hf + flen, ".pak"); + fp = fopen(hf, "wb"); - if(fp) - { - gzFile dsth; - int zfd; - char gz_membuf[FST_GZIO_LEN]; + if (fp) { + gzFile dsth; + int zfd; + char gz_membuf[FST_GZIO_LEN]; - fstWriterFseeko(xc, xc->handle, 0, SEEK_END); - uclen = ftello(xc->handle); + fstWriterFseeko(xc, xc->handle, 0, SEEK_END); + uclen = ftello(xc->handle); - fputc(FST_BL_ZWRAPPER, fp); - fstWriterUint64(fp, 0); - fstWriterUint64(fp, uclen); - fflush(fp); + fputc(FST_BL_ZWRAPPER, fp); + fstWriterUint64(fp, 0); + fstWriterUint64(fp, uclen); + fflush(fp); - fstWriterFseeko(xc, xc->handle, 0, SEEK_SET); - zfd = dup(fileno(fp)); - dsth = gzdopen(zfd, "wb4"); - if(dsth) - { - for(offpnt = 0; offpnt < uclen; offpnt += FST_GZIO_LEN) - { - size_t this_len = ((uclen - offpnt) > FST_GZIO_LEN) ? FST_GZIO_LEN : (uclen - offpnt); - fstFread(gz_membuf, this_len, 1, xc->handle); - gzwrite(dsth, gz_membuf, this_len); - } - gzclose(dsth); - } - else - { - close(zfd); - } - fstWriterFseeko(xc, fp, 0, SEEK_END); - offpnt = ftello(fp); - fstWriterFseeko(xc, fp, 1, SEEK_SET); - fstWriterUint64(fp, offpnt - 1); - fclose(fp); - fclose(xc->handle); xc->handle = NULL; - - unlink(xc->filename); - rename(hf, xc->filename); - } - else - { - xc->repack_on_close = 0; - fclose(xc->handle); xc->handle = NULL; - } - - free(hf); - } - else - { - fclose(xc->handle); xc->handle = NULL; + fstWriterFseeko(xc, xc->handle, 0, SEEK_SET); + zfd = dup(fileno(fp)); + dsth = gzdopen(zfd, "wb4"); + if (dsth) { + for (offpnt = 0; offpnt < uclen; offpnt += FST_GZIO_LEN) { + size_t this_len = + ((uclen - offpnt) > FST_GZIO_LEN) ? FST_GZIO_LEN : (uclen - offpnt); + fstFread(gz_membuf, this_len, 1, xc->handle); + gzwrite(dsth, gz_membuf, this_len); } + gzclose(dsth); + } else { + close(zfd); + } + fstWriterFseeko(xc, fp, 0, SEEK_END); + offpnt = ftello(fp); + fstWriterFseeko(xc, fp, 1, SEEK_SET); + fstWriterUint64(fp, offpnt - 1); + fclose(fp); + fclose(xc->handle); + xc->handle = NULL; + + unlink(xc->filename); + rename(hf, xc->filename); + } else { + xc->repack_on_close = 0; + fclose(xc->handle); + xc->handle = NULL; } + free(hf); + } else { + fclose(xc->handle); + xc->handle = NULL; + } + } + #ifdef __MINGW32__ { - int flen = strlen(xc->filename); - char *hf = (char *)calloc(1, flen + 6); - strcpy(hf, xc->filename); + int flen = strlen(xc->filename); + char *hf = (char *)calloc(1, flen + 6); + strcpy(hf, xc->filename); - if(xc->compress_hier) - { + if (xc->compress_hier) { strcpy(hf + flen, ".hier"); unlink(hf); /* no longer needed as a section now exists for this */ - } + } - free(hf); + free(hf); } #endif @@ -2272,28 +2195,23 @@ if(xc && !xc->already_in_close && !xc->already_in_flush) pthread_attr_destroy(&xc->thread_attr); #endif - if(xc->path_array) - { -#ifndef _WAVE_HAVE_JUDY - const uint32_t hashmask = FST_PATH_HASHMASK; -#endif - JudyHSFreeArray(&(xc->path_array), NULL); - } - - free(xc->filename); xc->filename = NULL; - free(xc); + if (xc->path_array) { + const uint32_t hashmask = FST_PATH_HASHMASK; + JenkinsFree(&(xc->path_array), hashmask); } -} + free(xc->filename); + xc->filename = NULL; + free(xc); + } +} /* * 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) - { + if (xc) { char s[FST_HDR_DATE_SIZE]; fst_off_t fpos = ftello(xc->handle); int len = strlen(dat); @@ -2304,15 +2222,12 @@ if(xc) fstFwrite(s, FST_HDR_DATE_SIZE, 1, xc->handle); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fpos, SEEK_SET); - } + } } - -void fstWriterSetVersion(void *ctx, const char *vers) +void fstWriterSetVersion(fstWriterContext *xc, const char *vers) { -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; -if(xc && vers) - { + if (xc && vers) { char s[FST_HDR_SIM_VERSION_SIZE]; fst_off_t fpos = ftello(xc->handle); int len = strlen(vers); @@ -2323,972 +2238,935 @@ if(xc && vers) fstFwrite(s, FST_HDR_SIM_VERSION_SIZE, 1, xc->handle); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fpos, SEEK_SET); - } + } } - -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); + if (xc) { + if (/*(filetype >= FST_FT_MIN) &&*/ (filetype <= FST_FT_MAX)) { + fst_off_t fpos = ftello(xc->handle); - xc->filetype = filetype; + xc->filetype = filetype; - fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_FILETYPE, SEEK_SET); - fputc(xc->filetype, xc->handle); - fflush(xc->handle); - fstWriterFseeko(xc, xc->handle, fpos, SEEK_SET); - } + fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_FILETYPE, SEEK_SET); + fputc(xc->filetype, xc->handle); + fflush(xc->handle); + fstWriterFseeko(xc, xc->handle, fpos, SEEK_SET); } + } } - -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) - { + if (xc) { unsigned char buf[11]; /* ceil(64/7) = 10 + null term */ unsigned char *pnt = fstCopyVarint64ToRight(buf, arg1); - if(arg1) - { - *pnt = 0; /* this converts any *nonzero* arg1 when made a varint into a null-term string */ - } + if (arg1) { + *pnt = + 0; /* this converts any *nonzero* arg1 when made a varint into a null-term string */ + } fstWriterSetAttrBegin(xc, FST_AT_MISC, typ, (char *)buf, arg2); - } + } } - -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) - { + if (xc && comm) { char *s = strdup(comm); char *sf = s; - while(*s) - { - if((*s == '\n') || (*s == '\r')) *s = ' '; - s++; - } + while (*s) { + if ((*s == '\n') || (*s == '\r')) + *s = ' '; + s++; + } fstWriterSetAttrBegin(xc, FST_AT_MISC, typ, sf, arg); free(sf); - } + } } - -static void fstWriterSetSourceStem_2(void *ctx, const char *path, unsigned int line, unsigned int use_realpath, int typ) +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]) - { + if (xc && path && path[0]) { uint64_t sidx = 0; int slen = strlen(path); -#ifndef _WAVE_HAVE_JUDY const uint32_t hashmask = FST_PATH_HASHMASK; const unsigned char *path2 = (const unsigned char *)path; - PPvoid_t pv; -#else - char *path2 = (char *)alloca(slen + 1); /* judy lacks const qualifier in its JudyHSIns definition */ - PPvoid_t pv; - strcpy(path2, path); -#endif + PPvoid_t pv; - pv = JudyHSIns(&(xc->path_array), path2, slen, NULL); - if(*pv) - { - sidx = (intptr_t)(*pv); - } - else - { - char *rp = NULL; + pv = JenkinsIns(&(xc->path_array), path2, slen, hashmask); + if (*pv) { + sidx = (intptr_t)(*pv); + } else { + char *rp = NULL; - sidx = ++xc->path_array_count; - *pv = (void *)(intptr_t)(xc->path_array_count); + sidx = ++xc->path_array_count; + *pv = (void *)(intptr_t)(xc->path_array_count); - if(use_realpath) - { - rp = fstRealpath( -#ifndef _WAVE_HAVE_JUDY - (const char *) -#endif - path2, NULL); - } + if (use_realpath) { + rp = fstRealpath((const char *)path2, NULL); + } - fstWriterSetAttrGeneric(xc, rp ? rp : -#ifndef _WAVE_HAVE_JUDY - (const char *) -#endif - path2, FST_MT_PATHNAME, sidx); + fstWriterSetAttrGeneric(xc, rp ? rp : (const char *)path2, FST_MT_PATHNAME, sidx); - if(rp) - { - free(rp); - } - } + if (rp) { + free(rp); + } + } fstWriterSetAttrDoubleArgGeneric(xc, typ, sidx, line); - } + } } - -void fstWriterSetSourceStem(void *ctx, const char *path, unsigned int line, unsigned int use_realpath) +void fstWriterSetSourceStem(fstWriterContext *ctx, + const char *path, + unsigned int line, + unsigned int use_realpath) { -fstWriterSetSourceStem_2(ctx, path, line, use_realpath, FST_MT_SOURCESTEM); + fstWriterSetSourceStem_2(ctx, path, line, use_realpath, FST_MT_SOURCESTEM); } - -void fstWriterSetSourceInstantiationStem(void *ctx, const char *path, unsigned int line, unsigned int use_realpath) +void fstWriterSetSourceInstantiationStem(fstWriterContext *ctx, + const char *path, + unsigned int line, + unsigned int use_realpath) { -fstWriterSetSourceStem_2(ctx, path, line, use_realpath, FST_MT_SOURCEISTEM); + 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); + 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); + 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); + 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) - { + if (xc) { fst_off_t fpos = ftello(xc->handle); fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_TIMESCALE, SEEK_SET); fputc(ts & 255, xc->handle); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fpos, SEEK_SET); - } + } } - -void fstWriterSetTimescaleFromString(void *ctx, const char *s) +void fstWriterSetTimescaleFromString(fstWriterContext *xc, const char *s) { -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; -if(xc && s) - { + if (xc && s) { int mat = 0; int seconds_exp = -9; int tv = atoi(s); const char *pnt = s; - while(*pnt) - { - switch(*pnt) - { - case 'm': seconds_exp = -3; mat = 1; break; - case 'u': seconds_exp = -6; mat = 1; break; - case 'n': seconds_exp = -9; mat = 1; break; - case 'p': seconds_exp = -12; mat = 1; break; - case 'f': seconds_exp = -15; mat = 1; break; - case 'a': seconds_exp = -18; mat = 1; break; - case 'z': seconds_exp = -21; mat = 1; break; - case 's': seconds_exp = 0; mat = 1; break; - default: break; - } + while (*pnt) { + switch (*pnt) { + case 'm': + seconds_exp = -3; + mat = 1; + break; + case 'u': + seconds_exp = -6; + mat = 1; + break; + case 'n': + seconds_exp = -9; + mat = 1; + break; + case 'p': + seconds_exp = -12; + mat = 1; + break; + case 'f': + seconds_exp = -15; + mat = 1; + break; + case 'a': + seconds_exp = -18; + mat = 1; + break; + case 'z': + seconds_exp = -21; + mat = 1; + break; + case 's': + seconds_exp = 0; + mat = 1; + break; + default: + break; + } - if(mat) break; - pnt++; - } - - if(tv == 10) - { - seconds_exp++; - } - else - if(tv == 100) - { - seconds_exp+=2; - } - - fstWriterSetTimescale(ctx, seconds_exp); + if (mat) + break; + pnt++; } + + if (tv == 10) { + seconds_exp++; + } else if (tv == 100) { + seconds_exp += 2; + } + + 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) - { + if (xc) { fst_off_t fpos = ftello(xc->handle); fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_TIMEZERO, SEEK_SET); fstWriterUint64(xc->handle, (xc->timezero = tim)); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fpos, SEEK_SET); - } + } } - -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); - } + 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) - { + 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) - { + if (xc) { xc->parallel_was_enabled |= xc->parallel_enabled; /* make sticky */ xc->parallel_enabled = (enable != 0); #ifndef FST_WRITER_PARALLEL - if(xc->parallel_enabled) - { - fprintf(stderr, FST_APIMESS "fstWriterSetParallelMode(), FST_WRITER_PARALLEL not enabled during compile, exiting.\n"); - exit(255); - } + if (xc->parallel_enabled) { + fprintf(stderr, + FST_APIMESS "fstWriterSetParallelMode(), FST_WRITER_PARALLEL not enabled " + "during compile, exiting.\n"); + exit(255); + } #endif - } + } } - -void fstWriterSetDumpSizeLimit(void *ctx, uint64_t numbytes) +void fstWriterSetDumpSizeLimit(fstWriterContext *xc, uint64_t numbytes) { -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; -if(xc) - { + 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); - } + if (xc) { + return (xc->size_limit_locked != 0); + } -return(0); + return (0); } - -int fstWriterGetFseekFailed(void *ctx) +int fstWriterGetFseekFailed(fstWriterContext *xc) { -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; -if(xc) - { - return(xc->fseek_failed != 0); - } + if (xc) { + return (xc->fseek_failed != 0); + } -return(0); + return (0); } +static int fstWriterGetFlushContextPendingInternal(fstWriterContext *xc) +{ + return (xc->vchg_siz >= xc->fst_break_size) || (xc->flush_context_pending); +} + +int fstWriterGetFlushContextPending(fstWriterContext *xc) +{ + return xc && !xc->is_initial_time && fstWriterGetFlushContextPendingInternal(xc); +} /* * writer attr/scope/var creation: * 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, enum fstVarType vt, enum fstVarDir vd, - uint32_t len, const char *nam, fstHandle aliasHandle, - const char *type, enum fstSupplementalVarType svt, enum fstSupplementalDataType sdt) +fstHandle fstWriterCreateVar2(fstWriterContext *ctx, + enum fstVarType vt, + enum fstVarDir vd, + uint32_t len, + const char *nam, + fstHandle aliasHandle, + const char *type, + enum fstSupplementalVarType svt, + enum fstSupplementalDataType sdt) { -fstWriterSetAttrGeneric(ctx, type ? type : "", FST_MT_SUPVAR, (svt<valpos_mem) - { - fstDestroyMmaps(xc, 0); - } + if (xc && nam) { + if (xc->valpos_mem) { + fstDestroyMmaps(xc, 0); + } fputc(vt, xc->hier_handle); fputc(vd, xc->hier_handle); nlen = strlen(nam); fstFwrite(nam, nlen, 1, xc->hier_handle); fputc(0, xc->hier_handle); - xc->hier_file_len += (nlen+3); + xc->hier_file_len += (nlen + 3); - if((vt == FST_VT_VCD_REAL) || (vt == FST_VT_VCD_REAL_PARAMETER) || (vt == FST_VT_VCD_REALTIME) || (vt == FST_VT_SV_SHORTREAL)) - { - is_real = 1; - len = 8; /* recast number of bytes to that of what a double is */ - } - else - { - is_real = 0; - if(vt == FST_VT_GEN_STRING) - { - len = 0; - } - } + if ((vt == FST_VT_VCD_REAL) || (vt == FST_VT_VCD_REAL_PARAMETER) || + (vt == FST_VT_VCD_REALTIME) || (vt == FST_VT_SV_SHORTREAL)) { + is_real = 1; + len = 8; /* recast number of bytes to that of what a double is */ + } else { + is_real = 0; + if (vt == FST_VT_GEN_STRING) { + len = 0; + } + } xc->hier_file_len += fstWriterVarint(xc->hier_handle, len); - if(aliasHandle > xc->maxhandle) aliasHandle = 0; + if (aliasHandle > xc->maxhandle) + aliasHandle = 0; xc->hier_file_len += fstWriterVarint(xc->hier_handle, aliasHandle); xc->numsigs++; - if(xc->numsigs == xc->next_huge_break) - { - if(xc->fst_break_size < xc->fst_huge_break_size) - { - xc->next_huge_break += FST_ACTIVATE_HUGE_INC; - xc->fst_break_size += xc->fst_orig_break_size; - xc->fst_break_add_size += xc->fst_orig_break_add_size; + if (xc->numsigs == xc->next_huge_break) { + if (xc->fst_break_size < xc->fst_huge_break_size) { + xc->next_huge_break += FST_ACTIVATE_HUGE_INC; + xc->fst_break_size += xc->fst_orig_break_size; + xc->fst_break_add_size += xc->fst_orig_break_add_size; - xc->vchg_alloc_siz = xc->fst_break_size + xc->fst_break_add_size; - if(xc->vchg_mem) - { - xc->vchg_mem = (unsigned char *)realloc(xc->vchg_mem, xc->vchg_alloc_siz); - } - } - } - - if(!aliasHandle) - { - uint32_t zero = 0; - - if(len) - { - fstWriterVarint(xc->geom_handle, !is_real ? len : 0); /* geom section encodes reals as zero byte */ - } - else - { - fstWriterVarint(xc->geom_handle, 0xFFFFFFFF); /* geom section encodes zero len as 32b -1 */ - } - - fstFwrite(&xc->maxvalpos, sizeof(uint32_t), 1, xc->valpos_handle); - fstFwrite(&len, sizeof(uint32_t), 1, xc->valpos_handle); - fstFwrite(&zero, sizeof(uint32_t), 1, xc->valpos_handle); - fstFwrite(&zero, sizeof(uint32_t), 1, xc->valpos_handle); - - if(!is_real) - { - for(i=0;icurval_handle); - } - } - else - { - fstFwrite(&xc->nan, 8, 1, xc->curval_handle); /* initialize doubles to NaN rather than x */ - } - - xc->maxvalpos+=len; - xc->maxhandle++; - return(xc->maxhandle); - } - else - { - return(aliasHandle); + xc->vchg_alloc_siz = xc->fst_break_size + xc->fst_break_add_size; + if (xc->vchg_mem) { + xc->vchg_mem = (unsigned char *)realloc(xc->vchg_mem, xc->vchg_alloc_siz); } + } } -return(0); + if (!aliasHandle) { + uint32_t zero = 0; + + if (len) { + fstWriterVarint(xc->geom_handle, + !is_real ? len : 0); /* geom section encodes reals as zero byte */ + } else { + fstWriterVarint(xc->geom_handle, + 0xFFFFFFFF); /* geom section encodes zero len as 32b -1 */ + } + + fstFwrite(&xc->maxvalpos, sizeof(uint32_t), 1, xc->valpos_handle); + fstFwrite(&len, sizeof(uint32_t), 1, xc->valpos_handle); + fstFwrite(&zero, sizeof(uint32_t), 1, xc->valpos_handle); + fstFwrite(&zero, sizeof(uint32_t), 1, xc->valpos_handle); + + if (!is_real) { + for (i = 0; i < len; i++) { + fputc('x', xc->curval_handle); + } + } else { + fstFwrite(&xc->nan, + 8, + 1, + xc->curval_handle); /* initialize doubles to NaN rather than x */ + } + + xc->maxvalpos += len; + xc->maxhandle++; + return (xc->maxhandle); + } else { + return (aliasHandle); + } + } + + return (0); } - -void fstWriterSetScope(void *ctx, enum fstScopeType scopetype, - const char *scopename, const char *scopecomp) +void fstWriterSetScope(fstWriterContext *xc, + enum fstScopeType scopetype, + const char *scopename, + const char *scopecomp) { -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; - -if(xc) - { + if (xc) { fputc(FST_ST_VCD_SCOPE, xc->hier_handle); - if(/*(scopetype < FST_ST_VCD_MODULE) ||*/ (scopetype > FST_ST_MAX)) { scopetype = FST_ST_VCD_MODULE; } + if (/*(scopetype < FST_ST_VCD_MODULE) ||*/ (scopetype > FST_ST_MAX)) { + scopetype = FST_ST_VCD_MODULE; + } fputc(scopetype, xc->hier_handle); - fprintf(xc->hier_handle, "%s%c%s%c", - scopename ? scopename : "", 0, - scopecomp ? scopecomp : "", 0); + fprintf(xc->hier_handle, + "%s%c%s%c", + scopename ? scopename : "", + 0, + scopecomp ? scopecomp : "", + 0); - if(scopename) - { - xc->hier_file_len += strlen(scopename); - } - if(scopecomp) - { - xc->hier_file_len += strlen(scopecomp); - } + if (scopename) { + xc->hier_file_len += strlen(scopename); + } + if (scopecomp) { + xc->hier_file_len += strlen(scopecomp); + } xc->hier_file_len += 4; /* FST_ST_VCD_SCOPE + scopetype + two string terminating zeros */ xc->numscopes++; - } + } } - -void fstWriterSetUpscope(void *ctx) +void fstWriterSetUpscope(fstWriterContext *xc) { -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; - -if(xc) - { + if (xc) { fputc(FST_ST_VCD_UPSCOPE, xc->hier_handle); xc->hier_file_len++; - } + } } - -void fstWriterSetAttrBegin(void *ctx, enum fstAttrType attrtype, int subtype, - const char *attrname, uint64_t arg) +void fstWriterSetAttrBegin(fstWriterContext *xc, + enum fstAttrType attrtype, + int subtype, + const char *attrname, + uint64_t arg) { -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; - -if(xc) - { + if (xc) { fputc(FST_ST_GEN_ATTRBEGIN, xc->hier_handle); - if(/*(attrtype < FST_AT_MISC) ||*/ (attrtype > FST_AT_MAX)) { attrtype = FST_AT_MISC; subtype = FST_MT_UNKNOWN; } + if (/*(attrtype < FST_AT_MISC) ||*/ (attrtype > FST_AT_MAX)) { + attrtype = FST_AT_MISC; + subtype = FST_MT_UNKNOWN; + } fputc(attrtype, xc->hier_handle); - switch(attrtype) - { - case FST_AT_ARRAY: if((subtype < FST_AR_NONE) || (subtype > FST_AR_MAX)) subtype = FST_AR_NONE; break; - case FST_AT_ENUM: if((subtype < FST_EV_SV_INTEGER) || (subtype > FST_EV_MAX)) subtype = FST_EV_SV_INTEGER; break; - case FST_AT_PACK: if((subtype < FST_PT_NONE) || (subtype > FST_PT_MAX)) subtype = FST_PT_NONE; break; + switch (attrtype) { + case FST_AT_ARRAY: + if ((subtype < FST_AR_NONE) || (subtype > FST_AR_MAX)) + subtype = FST_AR_NONE; + break; + case FST_AT_ENUM: + if ((subtype < FST_EV_SV_INTEGER) || (subtype > FST_EV_MAX)) + subtype = FST_EV_SV_INTEGER; + break; + case FST_AT_PACK: + if ((subtype < FST_PT_NONE) || (subtype > FST_PT_MAX)) + subtype = FST_PT_NONE; + break; - case FST_AT_MISC: - default: break; - } + case FST_AT_MISC: + default: + break; + } fputc(subtype, xc->hier_handle); - fprintf(xc->hier_handle, "%s%c", - attrname ? attrname : "", 0); + fprintf(xc->hier_handle, "%s%c", attrname ? attrname : "", 0); - if(attrname) - { - xc->hier_file_len += strlen(attrname); - } - - xc->hier_file_len += 4; /* FST_ST_GEN_ATTRBEGIN + type + subtype + string terminating zero */ - xc->hier_file_len += fstWriterVarint(xc->hier_handle, arg); + if (attrname) { + xc->hier_file_len += strlen(attrname); } + + xc->hier_file_len += + 4; /* FST_ST_GEN_ATTRBEGIN + type + subtype + string terminating zero */ + xc->hier_file_len += fstWriterVarint(xc->hier_handle, arg); + } } - -void fstWriterSetAttrEnd(void *ctx) +void fstWriterSetAttrEnd(fstWriterContext *xc) { -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; - -if(xc) - { + if (xc) { fputc(FST_ST_GEN_ATTREND, xc->hier_handle); xc->hier_file_len++; - } + } } - -fstEnumHandle fstWriterCreateEnumTable(void *ctx, const char *name, uint32_t elem_count, unsigned int min_valbits, const char **literal_arr, const char **val_arr) +fstEnumHandle fstWriterCreateEnumTable(fstWriterContext *xc, + 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; + 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; + if (xc && name && literal_arr && val_arr && (elem_count != 0)) { + uint32_t i; - uint32_t i; + name_len = strlen(name); + elem_count_len = snprintf(elem_count_buf, 16, "%" PRIu32, elem_count); - name_len = strlen(name); - elem_count_len = snprintf(elem_count_buf, 16, "%" PRIu32, elem_count); + literal_lens = (unsigned int *)calloc(elem_count, sizeof(unsigned int)); + val_lens = (unsigned int *)calloc(elem_count, sizeof(unsigned int)); - 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]); - for(i=0;i 0) { + if (val_lens[i] < min_valbits) { + val_len_tot += + (min_valbits - + val_lens[i]); /* additional converted len is same for '0' character */ + } + } + } - 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; - 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; - 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, 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++] = ' '; - 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 0) { + if (val_lens[i] < min_valbits) { + memset(attr_str + pos, '0', min_valbits - val_lens[i]); + pos += (min_valbits - val_lens[i]); + } + } - for(i=0;i 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++] = ' '; + } - pos += fstUtilityBinToEsc((unsigned char*)attr_str+pos, (unsigned char*)val_arr[i], val_lens[i]); - attr_str[pos++] = ' '; - } - - attr_str[pos-1] = 0; + 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); + 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); + fstWriterSetAttrBegin(xc, + FST_AT_MISC, + FST_MT_ENUMTABLE, + attr_str, + handle = ++xc->max_enumhandle); - free(attr_str); - free(val_lens); - free(literal_lens); - } + free(attr_str); + free(val_lens); + free(literal_lens); + } -return(handle); + 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); - } + if (xc && handle) { + fstWriterSetAttrBegin(xc, FST_AT_MISC, FST_MT_ENUMTABLE, NULL, 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; + const unsigned char *buf = (const unsigned char *)val; + uint32_t offs; + int len; -if(FST_LIKELY((xc) && (handle <= xc->maxhandle))) - { + if (FST_LIKELY((xc) && (handle <= xc->maxhandle))) { uint32_t fpos; uint32_t *vm4ip; - if(FST_UNLIKELY(!xc->valpos_mem)) - { - xc->vc_emitted = 1; - fstWriterCreateMmaps(xc); - } + if (FST_UNLIKELY(!xc->valpos_mem)) { + xc->vc_emitted = 1; + fstWriterCreateMmaps(xc); + } handle--; /* move starting at 1 index to starting at 0 */ - vm4ip = &(xc->valpos_mem[4*handle]); + vm4ip = &(xc->valpos_mem[4 * handle]); - len = vm4ip[1]; - if(FST_LIKELY(len)) /* len of zero = variable length, use fstWriterEmitVariableLengthValueChange */ - { - if(FST_LIKELY(!xc->is_initial_time)) - { - fpos = xc->vchg_siz; - - if(FST_UNLIKELY((fpos + len + 10) > xc->vchg_alloc_siz)) - { - xc->vchg_alloc_siz += (xc->fst_break_add_size + len); /* +len added in the case of extremely long vectors and small break add sizes */ - xc->vchg_mem = (unsigned char *)realloc(xc->vchg_mem, xc->vchg_alloc_siz); - if(FST_UNLIKELY(!xc->vchg_mem)) - { - fprintf(stderr, FST_APIMESS "Could not realloc() in fstWriterEmitValueChange, exiting.\n"); - exit(255); - } - } -#ifdef FST_REMOVE_DUPLICATE_VC - offs = vm4ip[0]; - - if(len != 1) - { - if((vm4ip[3]==xc->tchn_idx)&&(vm4ip[2])) - { - unsigned char *old_value = xc->vchg_mem + vm4ip[2] + 4; /* the +4 skips old vm4ip[2] value */ - while(*(old_value++) & 0x80) { /* skips over varint encoded "xc->tchn_idx - vm4ip[3]" */ } - memcpy(old_value, buf, len); /* overlay new value */ - - memcpy(xc->curval_mem + offs, buf, len); - return; - } - else - { - if(!memcmp(xc->curval_mem + offs, buf, len)) - { - if(!xc->curtime) - { - int i; - for(i=0;icurval_mem + offs, buf, len); - } - else - { - if((vm4ip[3]==xc->tchn_idx)&&(vm4ip[2])) - { - unsigned char *old_value = xc->vchg_mem + vm4ip[2] + 4; /* the +4 skips old vm4ip[2] value */ - while(*(old_value++) & 0x80) { /* skips over varint encoded "xc->tchn_idx - vm4ip[3]" */ } - *old_value = *buf; /* overlay new value */ - - *(xc->curval_mem + offs) = *buf; - return; - } - else - { - if((*(xc->curval_mem + offs)) == (*buf)) - { - if(!xc->curtime) - { - if(*buf != 'x') return; - } - else - { - return; - } - } - } - - *(xc->curval_mem + offs) = *buf; - } -#endif - xc->vchg_siz += fstWriterUint32WithVarint32(xc, &vm4ip[2], xc->tchn_idx - vm4ip[3], buf, len); /* do one fwrite op only */ - vm4ip[3] = xc->tchn_idx; - vm4ip[2] = fpos; - } - else - { - offs = vm4ip[0]; - memcpy(xc->curval_mem + offs, buf, len); - } - } - } -} - -void fstWriterEmitValueChange32(void *ctx, fstHandle handle, - uint32_t bits, uint32_t val) { - char buf[32]; - char *s = buf; - uint32_t i; - for (i = 0; i < bits; ++i) + len = vm4ip[1]; + if (FST_LIKELY(len)) /* len of zero = variable length, use + fstWriterEmitVariableLengthValueChange */ { - *s++ = '0' + ((val >> (bits - i - 1)) & 1); - } - fstWriterEmitValueChange(ctx, handle, buf); -} -void fstWriterEmitValueChange64(void *ctx, fstHandle handle, - uint32_t bits, uint64_t val) { - char buf[64]; - char *s = buf; - uint32_t i; - for (i = 0; i < bits; ++i) - { - *s++ = '0' + ((val >> (bits - i - 1)) & 1); - } - fstWriterEmitValueChange(ctx, handle, buf); -} -void fstWriterEmitValueChangeVec32(void *ctx, 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]); - } - else if(FST_LIKELY(xc)) - { - int bq = bits / 32; - int br = bits & 31; - int i; - int w; - uint32_t v; - unsigned char* s; - if (FST_UNLIKELY(bits > xc->outval_alloc_siz)) - { - xc->outval_alloc_siz = bits*2 + 1; - xc->outval_mem = (unsigned char*)realloc(xc->outval_mem, xc->outval_alloc_siz); - if (FST_UNLIKELY(!xc->outval_mem)) - { - fprintf(stderr, - FST_APIMESS "Could not realloc() in fstWriterEmitValueChangeVec32, exiting.\n"); - exit(255); - } - } - s = xc->outval_mem; - { - w = bq; - v = val[w]; - for (i = 0; i < br; ++i) - { - *s++ = '0' + ((v >> (br - i - 1)) & 1); - } - } - for (w = bq - 1; w >= 0; --w) - { - v = val[w]; - for (i = (32 - 4); i >= 0; i -= 4) { - s[0] = '0' + ((v >> (i + 3)) & 1); - s[1] = '0' + ((v >> (i + 2)) & 1); - s[2] = '0' + ((v >> (i + 1)) & 1); - s[3] = '0' + ((v >> (i + 0)) & 1); - s += 4; - } - } - fstWriterEmitValueChange(ctx, handle, xc->outval_mem); - } -} -void fstWriterEmitValueChangeVec64(void *ctx, 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]); - } - else if(FST_LIKELY(xc)) - { - int bq = bits / 64; - int br = bits & 63; - int i; - int w; - uint32_t v; - unsigned char* s; - if (FST_UNLIKELY(bits > xc->outval_alloc_siz)) - { - xc->outval_alloc_siz = bits*2 + 1; - xc->outval_mem = (unsigned char*)realloc(xc->outval_mem, xc->outval_alloc_siz); - if (FST_UNLIKELY(!xc->outval_mem)) - { - fprintf(stderr, - FST_APIMESS "Could not realloc() in fstWriterEmitValueChangeVec64, exiting.\n"); - exit(255); - } - } - s = xc->outval_mem; - { - w = bq; - v = val[w]; - for (i = 0; i < br; ++i) - { - *s++ = '0' + ((v >> (br - i - 1)) & 1); - } - } - for (w = bq - 1; w >= 0; --w) { - v = val[w]; - for (i = (64 - 4); i >= 0; i -= 4) - { - s[0] = '0' + ((v >> (i + 3)) & 1); - s[1] = '0' + ((v >> (i + 2)) & 1); - s[2] = '0' + ((v >> (i + 1)) & 1); - s[3] = '0' + ((v >> (i + 0)) & 1); - s += 4; - } - } - fstWriterEmitValueChange(ctx, handle, xc->outval_mem); - } -} - - -void fstWriterEmitVariableLengthValueChange(void *ctx, 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))) - { - uint32_t fpos; - uint32_t *vm4ip; - - if(FST_UNLIKELY(!xc->valpos_mem)) - { - xc->vc_emitted = 1; - fstWriterCreateMmaps(xc); - } - - handle--; /* move starting at 1 index to starting at 0 */ - vm4ip = &(xc->valpos_mem[4*handle]); - - /* there is no initial time dump for variable length value changes */ - if(FST_LIKELY(!vm4ip[1])) /* len of zero = variable length */ - { + if (FST_LIKELY(!xc->is_initial_time)) { fpos = xc->vchg_siz; - if(FST_UNLIKELY((fpos + len + 10 + 5) > xc->vchg_alloc_siz)) - { - xc->vchg_alloc_siz += (xc->fst_break_add_size + len + 5); /* +len added in the case of extremely long vectors and small break add sizes */ - xc->vchg_mem = (unsigned char *)realloc(xc->vchg_mem, xc->vchg_alloc_siz); - if(FST_UNLIKELY(!xc->vchg_mem)) - { - fprintf(stderr, FST_APIMESS "Could not realloc() in fstWriterEmitVariableLengthValueChange, exiting.\n"); - exit(255); - } - } + if (FST_UNLIKELY((fpos + len + 10) > xc->vchg_alloc_siz)) { + xc->vchg_alloc_siz += + (xc->fst_break_add_size + len); /* +len added in the case of extremely long + vectors and small break add sizes */ + xc->vchg_mem = (unsigned char *)realloc(xc->vchg_mem, xc->vchg_alloc_siz); + if (FST_UNLIKELY(!xc->vchg_mem)) { + fprintf(stderr, + FST_APIMESS + "Could not realloc() in fstWriterEmitValueChange, exiting.\n"); + exit(255); + } + } +#ifdef FST_REMOVE_DUPLICATE_VC + offs = vm4ip[0]; - xc->vchg_siz += fstWriterUint32WithVarint32AndLength(xc, &vm4ip[2], xc->tchn_idx - vm4ip[3], buf, len); /* do one fwrite op only */ + if (len != 1) { + if ((vm4ip[3] == xc->tchn_idx) && (vm4ip[2])) { + unsigned char *old_value = + xc->vchg_mem + vm4ip[2] + 4; /* the +4 skips old vm4ip[2] value */ + while (*(old_value++) & + 0x80) { /* skips over varint encoded "xc->tchn_idx - vm4ip[3]" */ + } + memcpy(old_value, buf, len); /* overlay new value */ + + memcpy(xc->curval_mem + offs, buf, len); + return; + } else { + if (!memcmp(xc->curval_mem + offs, buf, len)) { + if (!xc->curtime) { + int i; + for (i = 0; i < len; i++) { + if (buf[i] != 'x') + break; + } + + if (i < len) + return; + } else { + return; + } + } + } + + memcpy(xc->curval_mem + offs, buf, len); + } else { + if ((vm4ip[3] == xc->tchn_idx) && (vm4ip[2])) { + unsigned char *old_value = + xc->vchg_mem + vm4ip[2] + 4; /* the +4 skips old vm4ip[2] value */ + while (*(old_value++) & + 0x80) { /* skips over varint encoded "xc->tchn_idx - vm4ip[3]" */ + } + *old_value = *buf; /* overlay new value */ + + *(xc->curval_mem + offs) = *buf; + return; + } else { + if ((*(xc->curval_mem + offs)) == (*buf)) { + if (!xc->curtime) { + if (*buf != 'x') + return; + } else { + return; + } + } + } + + *(xc->curval_mem + offs) = *buf; + } +#endif + xc->vchg_siz += fstWriterUint32WithVarint32(xc, + &vm4ip[2], + xc->tchn_idx - vm4ip[3], + buf, + len); /* do one fwrite op only */ vm4ip[3] = xc->tchn_idx; vm4ip[2] = fpos; - } + } else { + offs = vm4ip[0]; + memcpy(xc->curval_mem + offs, buf, len); + } } + } } - -void fstWriterEmitTimeChange(void *ctx, uint64_t tim) +void fstWriterEmitValueChange32(fstWriterContext *ctx, + fstHandle handle, + uint32_t bits, + uint32_t val) { -struct fstWriterContext *xc = (struct fstWriterContext *)ctx; -unsigned int i; -int skip = 0; -if(xc) + char buf[32]; + char *s = buf; + uint32_t i; + for (i = 0; i < bits; ++i) { + *s++ = '0' + ((val >> (bits - i - 1)) & 1); + } + fstWriterEmitValueChange(ctx, handle, buf); +} + +void fstWriterEmitValueChange64(fstWriterContext *ctx, + fstHandle handle, + uint32_t bits, + uint64_t val) +{ + char buf[64]; + char *s = buf; + uint32_t i; + for (i = 0; i < bits; ++i) { + *s++ = '0' + ((val >> (bits - i - 1)) & 1); + } + fstWriterEmitValueChange(ctx, handle, buf); +} + +void fstWriterEmitValueChangeVec32(fstWriterContext *xc, + fstHandle handle, + uint32_t bits, + const uint32_t *val) +{ + if (FST_UNLIKELY(bits <= 32)) { + fstWriterEmitValueChange32(xc, handle, bits, val[0]); + } else if (FST_LIKELY(xc)) { + int bq = bits / 32; + int br = bits & 31; + int i; + int w; + uint32_t v; + unsigned char *s; + if (FST_UNLIKELY(bits > xc->outval_alloc_siz)) { + xc->outval_alloc_siz = bits * 2 + 1; + xc->outval_mem = (unsigned char *)realloc(xc->outval_mem, xc->outval_alloc_siz); + if (FST_UNLIKELY(!xc->outval_mem)) { + fprintf(stderr, + FST_APIMESS + "Could not realloc() in fstWriterEmitValueChangeVec32, exiting.\n"); + exit(255); + } + } + s = xc->outval_mem; { - if(FST_UNLIKELY(xc->is_initial_time)) - { - if(xc->size_limit_locked) /* this resets xc->is_initial_time to one */ - { - return; - } + w = bq; + v = val[w]; + for (i = 0; i < br; ++i) { + *s++ = '0' + ((v >> (br - i - 1)) & 1); + } + } + for (w = bq - 1; w >= 0; --w) { + v = val[w]; + for (i = (32 - 4); i >= 0; i -= 4) { + s[0] = '0' + ((v >> (i + 3)) & 1); + s[1] = '0' + ((v >> (i + 2)) & 1); + s[2] = '0' + ((v >> (i + 1)) & 1); + s[3] = '0' + ((v >> (i + 0)) & 1); + s += 4; + } + } + fstWriterEmitValueChange(xc, handle, xc->outval_mem); + } +} +void fstWriterEmitValueChangeVec64(fstWriterContext *xc, + fstHandle handle, + uint32_t bits, + const uint64_t *val) +{ + if (FST_UNLIKELY(bits <= 64)) { + fstWriterEmitValueChange64(xc, handle, bits, val[0]); + } else if (FST_LIKELY(xc)) { + int bq = bits / 64; + int br = bits & 63; + int i; + int w; + uint32_t v; + unsigned char *s; + if (FST_UNLIKELY(bits > xc->outval_alloc_siz)) { + xc->outval_alloc_siz = bits * 2 + 1; + xc->outval_mem = (unsigned char *)realloc(xc->outval_mem, xc->outval_alloc_siz); + if (FST_UNLIKELY(!xc->outval_mem)) { + fprintf(stderr, + FST_APIMESS + "Could not realloc() in fstWriterEmitValueChangeVec64, exiting.\n"); + exit(255); + } + } + s = xc->outval_mem; + { + w = bq; + v = val[w]; + for (i = 0; i < br; ++i) { + *s++ = '0' + ((v >> (br - i - 1)) & 1); + } + } + for (w = bq - 1; w >= 0; --w) { + v = val[w]; + for (i = (64 - 4); i >= 0; i -= 4) { + s[0] = '0' + ((v >> (i + 3)) & 1); + s[1] = '0' + ((v >> (i + 2)) & 1); + s[2] = '0' + ((v >> (i + 1)) & 1); + s[3] = '0' + ((v >> (i + 0)) & 1); + s += 4; + } + } + fstWriterEmitValueChange(xc, handle, xc->outval_mem); + } +} - if(!xc->valpos_mem) - { - fstWriterCreateMmaps(xc); - } +void fstWriterEmitVariableLengthValueChange(fstWriterContext *xc, + fstHandle handle, + const void *val, + uint32_t len) +{ + const unsigned char *buf = (const unsigned char *)val; - skip = 1; + if (FST_LIKELY((xc) && (handle <= xc->maxhandle))) { + uint32_t fpos; + uint32_t *vm4ip; - xc->firsttime = (xc->vc_emitted) ? 0: tim; - xc->curtime = 0; - xc->vchg_mem[0] = '!'; - xc->vchg_siz = 1; - fstWriterEmitSectionHeader(xc); - for(i=0;imaxhandle;i++) - { - xc->valpos_mem[4*i+2] = 0; /* zero out offset val */ - xc->valpos_mem[4*i+3] = 0; /* zero out last time change val */ - } - xc->is_initial_time = 0; - } - else - { - if((xc->vchg_siz >= xc->fst_break_size) || (xc->flush_context_pending)) - { - xc->flush_context_pending = 0; - fstWriterFlushContextPrivate(xc); - xc->tchn_cnt++; - fstWriterVarint(xc->tchn_handle, xc->curtime); - } + if (FST_UNLIKELY(!xc->valpos_mem)) { + xc->vc_emitted = 1; + fstWriterCreateMmaps(xc); + } + + handle--; /* move starting at 1 index to starting at 0 */ + vm4ip = &(xc->valpos_mem[4 * handle]); + + /* there is no initial time dump for variable length value changes */ + if (FST_LIKELY(!vm4ip[1])) /* len of zero = variable length */ + { + fpos = xc->vchg_siz; + + if (FST_UNLIKELY((fpos + len + 10 + 5) > xc->vchg_alloc_siz)) { + xc->vchg_alloc_siz += + (xc->fst_break_add_size + len + 5); /* +len added in the case of extremely long + vectors and small break add sizes */ + xc->vchg_mem = (unsigned char *)realloc(xc->vchg_mem, xc->vchg_alloc_siz); + if (FST_UNLIKELY(!xc->vchg_mem)) { + fprintf(stderr, + FST_APIMESS "Could not realloc() in " + "fstWriterEmitVariableLengthValueChange, exiting.\n"); + exit(255); } + } - if(!skip) - { - xc->tchn_idx++; - } + xc->vchg_siz += fstWriterUint32WithVarint32AndLength(xc, + &vm4ip[2], + xc->tchn_idx - vm4ip[3], + buf, + len); /* do one fwrite op only */ + vm4ip[3] = xc->tchn_idx; + vm4ip[2] = fpos; + } + } +} + +void fstWriterEmitTimeChange(fstWriterContext *xc, uint64_t tim) +{ + unsigned int i; + int skip = 0; + if (xc) { + if (FST_UNLIKELY(xc->is_initial_time)) { + if (xc->size_limit_locked) /* this resets xc->is_initial_time to one */ + { + return; + } + + if (!xc->valpos_mem) { + fstWriterCreateMmaps(xc); + } + + skip = 1; + + xc->firsttime = (xc->vc_emitted) ? 0 : tim; + xc->curtime = 0; + xc->vchg_mem[0] = '!'; + xc->vchg_siz = 1; + fstWriterEmitSectionHeader(xc); + for (i = 0; i < xc->maxhandle; i++) { + xc->valpos_mem[4 * i + 2] = 0; /* zero out offset val */ + xc->valpos_mem[4 * i + 3] = 0; /* zero out last time change val */ + } + xc->is_initial_time = 0; + } else { + if (fstWriterGetFlushContextPendingInternal(xc)) { + xc->flush_context_pending = 0; + fstWriterFlushContextPrivate(xc); + xc->tchn_cnt++; + fstWriterVarint(xc->tchn_handle, xc->curtime); + } + } + + if (!skip) { + xc->tchn_idx++; + } fstWriterVarint(xc->tchn_handle, tim - xc->curtime); xc->tchn_cnt++; xc->curtime = 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)); + if (xc) { + struct fstBlackoutChain *b = + (struct fstBlackoutChain *)calloc(1, sizeof(struct fstBlackoutChain)); b->tim = xc->curtime; b->active = (enable != 0); xc->num_blackouts++; - if(xc->blackout_curr) - { - xc->blackout_curr->next = b; - xc->blackout_curr = b; - } - else - { - xc->blackout_head = b; - xc->blackout_curr = b; - } + if (xc->blackout_curr) { + xc->blackout_curr->next = b; + xc->blackout_curr = b; + } else { + xc->blackout_head = b; + xc->blackout_curr = b; } + } } - /***********************/ /*** ***/ /*** reader function ***/ @@ -3299,591 +3177,490 @@ if(xc) * private structs */ static const char *vartypes[] = { - "event", "integer", "parameter", "real", "real_parameter", - "reg", "supply0", "supply1", "time", "tri", - "triand", "trior", "trireg", "tri0", "tri1", - "wand", "wire", "wor", "port", "sparray", "realtime", - "string", - "bit", "logic", "int", "shortint", "longint", "byte", "enum", "shortreal" - }; + "event", "integer", "parameter", "real", "real_parameter", "reg", "supply0", "supply1", + "time", "tri", "triand", "trior", "trireg", "tri0", "tri1", "wand", + "wire", "wor", "port", "sparray", "realtime", "string", "bit", "logic", + "int", "shortint", "longint", "byte", "enum", "shortreal"}; -static const char *modtypes[] = { - "module", "task", "function", "begin", "fork", "generate", "struct", "union", "class", "interface", "package", "program", - "vhdl_architecture", "vhdl_procedure", "vhdl_function", "vhdl_record", "vhdl_process", "vhdl_block", "vhdl_for_generate", "vhdl_if_generate", "vhdl_generate", "vhdl_package" - }; +static const char *modtypes[] = {"module", + "task", + "function", + "begin", + "fork", + "generate", + "struct", + "union", + "class", + "interface", + "package", + "program", + "vhdl_architecture", + "vhdl_procedure", + "vhdl_function", + "vhdl_record", + "vhdl_process", + "vhdl_block", + "vhdl_for_generate", + "vhdl_if_generate", + "vhdl_generate", + "vhdl_package"}; -static const char *attrtypes[] = { - "misc", "array", "enum", "class" - }; +static const char *attrtypes[] = {"misc", "array", "enum", "class"}; -static const char *arraytypes[] = { - "none", "unpacked", "packed", "sparse" - }; +static const char *arraytypes[] = {"none", "unpacked", "packed", "sparse"}; -static const char *enumvaluetypes[] = { - "integer", "bit", "logic", "int", "shortint", "longint", "byte", - "unsigned_integer", "unsigned_bit", "unsigned_logic", "unsigned_int", "unsigned_shortint", "unsigned_longint", "unsigned_byte" - }; - -static const char *packtypes[] = { - "none", "unpacked", "packed", "tagged_packed" - }; +static const char *enumvaluetypes[] = {"integer", + "bit", + "logic", + "int", + "shortint", + "longint", + "byte", + "unsigned_integer", + "unsigned_bit", + "unsigned_logic", + "unsigned_int", + "unsigned_shortint", + "unsigned_longint", + "unsigned_byte"}; +static const char *packtypes[] = {"none", "unpacked", "packed", "tagged_packed"}; struct fstCurrHier { -struct fstCurrHier *prev; -void *user_info; -int len; + struct fstCurrHier *prev; + void *user_info; + int len; }; - struct fstReaderContext { -/* common entries */ + /* common entries */ -FILE *f, *fh; + FILE *f, *fh; -uint64_t start_time, end_time; -uint64_t mem_used_by_writer; -uint64_t scope_count; -uint64_t var_count; -fstHandle maxhandle; -uint64_t num_alias; -uint64_t vc_section_count; + uint64_t start_time, end_time; + uint64_t mem_used_by_writer; + uint64_t scope_count; + uint64_t var_count; + fstHandle maxhandle; + uint64_t num_alias; + uint64_t vc_section_count; -uint32_t *signal_lens; /* maxhandle sized */ -unsigned char *signal_typs; /* maxhandle sized */ -unsigned char *process_mask; /* maxhandle-based, bitwise sized */ -uint32_t longest_signal_value_len; /* longest len value encountered */ -unsigned char *temp_signal_value_buf; /* malloced for len in longest_signal_value_len */ + uint32_t *signal_lens; /* maxhandle sized */ + unsigned char *signal_typs; /* maxhandle sized */ + unsigned char *process_mask; /* maxhandle-based, bitwise sized */ + uint32_t longest_signal_value_len; /* longest len value encountered */ + unsigned char *temp_signal_value_buf; /* malloced for len in longest_signal_value_len */ -signed char timescale; -unsigned char filetype; + signed char timescale; + unsigned char filetype; -unsigned use_vcd_extensions : 1; -unsigned double_endian_match : 1; -unsigned native_doubles_for_cb : 1; -unsigned contains_geom_section : 1; -unsigned contains_hier_section : 1; /* valid for hier_pos */ -unsigned contains_hier_section_lz4duo : 1; /* valid for hier_pos (contains_hier_section_lz4 always also set) */ -unsigned contains_hier_section_lz4 : 1; /* valid for hier_pos */ -unsigned limit_range_valid : 1; /* valid for limit_range_start, limit_range_end */ + unsigned use_vcd_extensions : 1; + unsigned double_endian_match : 1; + unsigned native_doubles_for_cb : 1; + unsigned contains_geom_section : 1; + unsigned contains_hier_section : 1; /* valid for hier_pos */ + unsigned contains_hier_section_lz4duo : 1; /* valid for hier_pos (contains_hier_section_lz4 + always also set) */ + unsigned contains_hier_section_lz4 : 1; /* valid for hier_pos */ + unsigned limit_range_valid : 1; /* valid for limit_range_start, limit_range_end */ -char version[FST_HDR_SIM_VERSION_SIZE + 1]; -char date[FST_HDR_DATE_SIZE + 1]; -int64_t timezero; + char version[FST_HDR_SIM_VERSION_SIZE + 1]; + char date[FST_HDR_DATE_SIZE + 1]; + int64_t timezero; -char *filename, *filename_unpacked; -fst_off_t hier_pos; + char *filename, *filename_unpacked; + fst_off_t hier_pos; -uint32_t num_blackouts; -uint64_t *blackout_times; -unsigned char *blackout_activity; + uint32_t num_blackouts; + uint64_t *blackout_times; + unsigned char *blackout_activity; -uint64_t limit_range_start, limit_range_end; + uint64_t limit_range_start, limit_range_end; -/* entries specific to read value at time functions */ + /* entries specific to read value at time functions */ -unsigned rvat_data_valid : 1; -uint64_t *rvat_time_table; -uint64_t rvat_beg_tim, rvat_end_tim; -unsigned char *rvat_frame_data; -uint64_t rvat_frame_maxhandle; -fst_off_t *rvat_chain_table; -uint32_t *rvat_chain_table_lengths; -uint64_t rvat_vc_maxhandle; -fst_off_t rvat_vc_start; -uint32_t *rvat_sig_offs; -int rvat_packtype; + unsigned rvat_data_valid : 1; + uint64_t *rvat_time_table; + uint64_t rvat_beg_tim, rvat_end_tim; + unsigned char *rvat_frame_data; + uint64_t rvat_frame_maxhandle; + fst_off_t *rvat_chain_table; + uint32_t *rvat_chain_table_lengths; + uint64_t rvat_vc_maxhandle; + fst_off_t rvat_vc_start; + uint32_t *rvat_sig_offs; + int rvat_packtype; -uint32_t rvat_chain_len; -unsigned char *rvat_chain_mem; -fstHandle rvat_chain_facidx; + uint32_t rvat_chain_len; + unsigned char *rvat_chain_mem; + fstHandle rvat_chain_facidx; -uint32_t rvat_chain_pos_tidx; -uint32_t rvat_chain_pos_idx; -uint64_t rvat_chain_pos_time; -unsigned rvat_chain_pos_valid : 1; + uint32_t rvat_chain_pos_tidx; + uint32_t rvat_chain_pos_idx; + uint64_t rvat_chain_pos_time; + unsigned rvat_chain_pos_valid : 1; -/* entries specific to hierarchy traversal */ + /* entries specific to hierarchy traversal */ -struct fstHier hier; -struct fstCurrHier *curr_hier; -fstHandle current_handle; -char *curr_flat_hier_nam; -int flat_hier_alloc_len; -unsigned do_rewind : 1; -char str_scope_nam[FST_ID_NAM_SIZ+1]; -char str_scope_comp[FST_ID_NAM_SIZ+1]; -char *str_scope_attr; + struct fstHier hier; + struct fstCurrHier *curr_hier; + fstHandle current_handle; + char *curr_flat_hier_nam; + int flat_hier_alloc_len; + unsigned do_rewind : 1; + char str_scope_nam[FST_ID_NAM_SIZ + 1]; + char str_scope_comp[FST_ID_NAM_SIZ + 1]; + char *str_scope_attr; -unsigned fseek_failed : 1; + unsigned fseek_failed : 1; -/* self-buffered I/O for writes */ + /* self-buffered I/O for writes */ #ifndef FST_WRITEX_DISABLE -int writex_pos; -int writex_fd; -unsigned char writex_buf[FST_WRITEX_MAX]; + int writex_pos; + int writex_fd; + unsigned char writex_buf[FST_WRITEX_MAX]; #endif -char *f_nam; -char *fh_nam; + char *f_nam; + char *fh_nam; }; - int fstReaderFseeko(struct fstReaderContext *xc, FILE *stream, fst_off_t offset, int whence) { -int rc = fseeko(stream, offset, whence); + int rc = fseeko(stream, offset, whence); -if(rc<0) - { + if (rc < 0) { xc->fseek_failed = 1; #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "Seek to #%" PRId64 " (whence = %d) failed!\n", offset, whence); perror("Why"); #endif - } + } -return(rc); + return (rc); } - #ifndef FST_WRITEX_DISABLE -static void fstWritex(struct fstReaderContext *xc, void *v, uint32_t len) /* TALOS-2023-1793: change len to unsigned */ +static void fstWritex(struct fstReaderContext *xc, + void *v, + uint32_t len) /* TALOS-2023-1793: change len to unsigned */ { -unsigned char *s = (unsigned char *)v; + unsigned char *s = (unsigned char *)v; -if(len) - { - if(len < FST_WRITEX_MAX) - { - if(xc->writex_pos + len >= FST_WRITEX_MAX) - { - fstWritex(xc, NULL, 0); - } - - memcpy(xc->writex_buf + xc->writex_pos, s, len); - xc->writex_pos += len; - } - else - { + if (len) { + if (len < FST_WRITEX_MAX) { + if (xc->writex_pos + len >= FST_WRITEX_MAX) { fstWritex(xc, NULL, 0); - if (write(xc->writex_fd, s, len)) { }; - } + } + + memcpy(xc->writex_buf + xc->writex_pos, s, len); + xc->writex_pos += len; + } else { + fstWritex(xc, NULL, 0); + if (write(xc->writex_fd, s, len)) { + }; } - else - { - if(xc->writex_pos) - { - if(write(xc->writex_fd, xc->writex_buf, xc->writex_pos)) { }; - xc->writex_pos = 0; - } + } else { + if (xc->writex_pos) { + if (write(xc->writex_fd, xc->writex_buf, xc->writex_pos)) { + }; + xc->writex_pos = 0; } + } } #endif - /* * scope -> flat name handling */ -static void fstReaderDeallocateScopeData(struct fstReaderContext *xc) +static void fstReaderDeallocateScopeData(fstReaderContext *xc) { -struct fstCurrHier *chp; + struct fstCurrHier *chp; -free(xc->curr_flat_hier_nam); xc->curr_flat_hier_nam = NULL; -while(xc->curr_hier) - { + free(xc->curr_flat_hier_nam); + xc->curr_flat_hier_nam = NULL; + while (xc->curr_hier) { chp = xc->curr_hier->prev; free(xc->curr_hier); xc->curr_hier = chp; - } + } } - -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 - { - return(NULL); - } + if (xc) { + return (xc->curr_flat_hier_nam ? xc->curr_flat_hier_nam : ""); + } else { + return (NULL); + } } - -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 - { - return(NULL); - } + if (xc) { + return (xc->curr_hier ? xc->curr_hier->user_info : NULL); + } else { + return (NULL); + } } - -const char *fstReaderPopScope(void *ctx) +const char *fstReaderPopScope(fstReaderContext *xc) { -struct fstReaderContext *xc = (struct fstReaderContext *)ctx; -if(xc && xc->curr_hier) - { + if (xc && xc->curr_hier) { struct fstCurrHier *ch = xc->curr_hier; - if(xc->curr_hier->prev) - { - xc->curr_flat_hier_nam[xc->curr_hier->prev->len] = 0; - } - else - { - *xc->curr_flat_hier_nam = 0; - } + if (xc->curr_hier->prev) { + xc->curr_flat_hier_nam[xc->curr_hier->prev->len] = 0; + } else { + *xc->curr_flat_hier_nam = 0; + } xc->curr_hier = xc->curr_hier->prev; free(ch); - return(xc->curr_flat_hier_nam ? xc->curr_flat_hier_nam : ""); - } + return (xc->curr_flat_hier_nam ? xc->curr_flat_hier_nam : ""); + } -return(NULL); + 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 */ - } + 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) - { + if (xc) { struct fstCurrHier *ch = (struct fstCurrHier *)malloc(sizeof(struct fstCurrHier)); int chl = xc->curr_hier ? xc->curr_hier->len : 0; int len = chl + 1 + strlen(nam); - if(len >= xc->flat_hier_alloc_len) - { - xc->curr_flat_hier_nam = xc->curr_flat_hier_nam ? (char *)realloc(xc->curr_flat_hier_nam, len+1) : (char *)malloc(len+1); - } + if (len >= xc->flat_hier_alloc_len) { + xc->curr_flat_hier_nam = xc->curr_flat_hier_nam + ? (char *)realloc(xc->curr_flat_hier_nam, len + 1) + : (char *)malloc(len + 1); + } - if(chl) - { - xc->curr_flat_hier_nam[chl] = '.'; - strcpy(xc->curr_flat_hier_nam + chl + 1, nam); - } - else - { - strcpy(xc->curr_flat_hier_nam, nam); - len--; - } + if (chl) { + xc->curr_flat_hier_nam[chl] = '.'; + strcpy(xc->curr_flat_hier_nam + chl + 1, nam); + } else { + strcpy(xc->curr_flat_hier_nam, nam); + len--; + } ch->len = len; ch->prev = xc->curr_hier; ch->user_info = user_info; xc->curr_hier = ch; - return(xc->curr_flat_hier_nam); - } + return (xc->curr_flat_hier_nam); + } -return(NULL); + 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); + } -if(xc && xc->curr_hier) - { - return(xc->curr_hier->len); - } - -return(0); + return (0); } - -int fstReaderGetFseekFailed(void *ctx) +int fstReaderGetFseekFailed(fstReaderContext *xc) { -struct fstReaderContext *xc = (struct fstReaderContext *)ctx; -if(xc) - { - return(xc->fseek_failed != 0); - } + if (xc) { + return (xc->fseek_failed != 0); + } -return(0); + return (0); } - /* * 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) - { + if (xc) { facidx--; - if(facidxmaxhandle) - { - int process_idx = facidx/8; - int process_bit = facidx&7; + if (facidx < xc->maxhandle) { + int process_idx = facidx / 8; + int process_bit = facidx & 7; - return( (xc->process_mask[process_idx]&(1<process_mask[process_idx] & (1 << process_bit)) != 0); } -return(0); + } + return (0); } - -void fstReaderSetFacProcessMask(void *ctx, fstHandle facidx) +void fstReaderSetFacProcessMask(fstReaderContext *xc, fstHandle facidx) { -struct fstReaderContext *xc = (struct fstReaderContext *)ctx; - -if(xc) - { + if (xc) { facidx--; - if(facidxmaxhandle) - { - int idx = facidx/8; - int bitpos = facidx&7; + if (facidx < xc->maxhandle) { + int idx = facidx / 8; + int bitpos = facidx & 7; - xc->process_mask[idx] |= (1<process_mask[idx] |= (1 << bitpos); } + } } - -void fstReaderClrFacProcessMask(void *ctx, fstHandle facidx) +void fstReaderClrFacProcessMask(fstReaderContext *xc, fstHandle facidx) { -struct fstReaderContext *xc = (struct fstReaderContext *)ctx; - -if(xc) - { + if (xc) { facidx--; - if(facidxmaxhandle) - { - int idx = facidx/8; - int bitpos = facidx&7; + if (facidx < xc->maxhandle) { + int idx = facidx / 8; + int bitpos = facidx & 7; - xc->process_mask[idx] &= (~(1<process_mask[idx] &= (~(1 << bitpos)); } + } } - -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); - } + 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); - } + if (xc) { + memset(xc->process_mask, 0x00, (xc->maxhandle + 7) / 8); + } } - /* * 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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 - { - return(0); - } + if (xc && (idx < xc->num_blackouts) && (xc->blackout_times)) { + return (xc->blackout_times[idx]); + } else { + return (0); + } } - -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 - { - return(0); - } + if (xc && (idx < xc->num_blackouts) && (xc->blackout_activity)) { + return (xc->blackout_activity[idx]); + } else { + return (0); + } } - -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) - { + if (xc) { xc->limit_range_valid = 1; xc->limit_range_start = start_time; xc->limit_range_end = end_time; - } + } } - -void fstReaderSetUnlimitedTimeRange(void *ctx) +void fstReaderSetUnlimitedTimeRange(fstReaderContext *xc) { -struct fstReaderContext *xc = (struct fstReaderContext *)ctx; - -if(xc) - { + 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) - { + 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) - { + if (xc) { xc->native_doubles_for_cb = (enable != 0); - } + } } /* @@ -3891,45 +3668,41 @@ if(xc) */ static void fstVcdID(char *buf, unsigned int value) { -char *pnt = buf; + char *pnt = buf; -/* zero is illegal for a value...it is assumed they start at one */ -while (value) - { + /* zero is illegal for a value...it is assumed they start at one */ + while (value) { value--; *(pnt++) = (char)('!' + value % 94); value = value / 94; - } + } -*pnt = 0; + *pnt = 0; } static int fstVcdIDForFwrite(char *buf, unsigned int value) { -char *pnt = buf; - int len = 0; + char *pnt = buf; + int len = 0; -/* zero is illegal for a value...it is assumed they start at one */ -while (value && len < 14) - { + /* zero is illegal for a value...it is assumed they start at one */ + while (value && len < 14) { value--; - ++len; + ++len; *(pnt++) = (char)('!' + value % 94); value = value / 94; - } + } -return len; + return len; } - static int fstReaderRecreateHierFile(struct fstReaderContext *xc) { -int pass_status = 1; + int pass_status = 1; -if(!xc->fh) - { + if (!xc->fh) { fst_off_t offs_cache = ftello(xc->f); - int fnam_len = strlen(xc->filename) + 6 + 16 + 32 + 1; + int fnam_len = strlen(xc->filename) + 6 + 16 + 32 + 1; char *fnam = (char *)malloc(fnam_len); unsigned char *mem = (unsigned char *)malloc(FST_GZIO_LEN); fst_off_t hl, uclen; @@ -3939,15 +3712,11 @@ if(!xc->fh) int htyp = FST_BL_SKIP; /* can't handle both set at once should never happen in a real file */ - if(!xc->contains_hier_section_lz4 && xc->contains_hier_section) - { - htyp = FST_BL_HIER; - } - else - if(xc->contains_hier_section_lz4 && !xc->contains_hier_section) - { - htyp = xc->contains_hier_section_lz4duo ? FST_BL_HIER_LZ4DUO : FST_BL_HIER_LZ4; - } + if (!xc->contains_hier_section_lz4 && xc->contains_hier_section) { + htyp = FST_BL_HIER; + } else if (xc->contains_hier_section_lz4 && !xc->contains_hier_section) { + htyp = xc->contains_hier_section_lz4duo ? FST_BL_HIER_LZ4DUO : FST_BL_HIER_LZ4; + } snprintf(fnam, fnam_len, "%s.hier_%d_%p", xc->filename, getpid(), (void *)xc); fstReaderFseeko(xc, xc->f, xc->hier_pos, SEEK_SET); @@ -3955,650 +3724,713 @@ if(!xc->fh) #ifndef __MINGW32__ fflush(xc->f); #endif - if(htyp == FST_BL_HIER) - { - fstReaderFseeko(xc, xc->f, xc->hier_pos, SEEK_SET); - uclen = fstReaderUint64(xc->f); + if (htyp == FST_BL_HIER) { + fstReaderFseeko(xc, xc->f, xc->hier_pos, SEEK_SET); + uclen = fstReaderUint64(xc->f); #ifndef __MINGW32__ - fflush(xc->f); + fflush(xc->f); #endif - zfd = dup(fileno(xc->f)); - zhandle = gzdopen(zfd, "rb"); - if(!zhandle) - { - close(zfd); - free(mem); - free(fnam); - return(0); - } - } - else - if((htyp == FST_BL_HIER_LZ4) || (htyp == FST_BL_HIER_LZ4DUO)) - { - fstReaderFseeko(xc, xc->f, xc->hier_pos - 8, SEEK_SET); /* get section len */ - clen = fstReaderUint64(xc->f) - 16; - uclen = fstReaderUint64(xc->f); + zfd = dup(fileno(xc->f)); + zhandle = gzdopen(zfd, "rb"); + if (!zhandle) { + close(zfd); + free(mem); + free(fnam); + return (0); + } + } else if ((htyp == FST_BL_HIER_LZ4) || (htyp == FST_BL_HIER_LZ4DUO)) { + fstReaderFseeko(xc, xc->f, xc->hier_pos - 8, SEEK_SET); /* get section len */ + clen = fstReaderUint64(xc->f) - 16; + uclen = fstReaderUint64(xc->f); #ifndef __MINGW32__ - fflush(xc->f); + fflush(xc->f); #endif - } + } #ifndef __MINGW32__ xc->fh = fopen(fnam, "w+b"); - if(!xc->fh) + if (!xc->fh) #endif - { - xc->fh = tmpfile_open(&xc->fh_nam); - free(fnam); fnam = NULL; - if(!xc->fh) - { - tmpfile_close(&xc->fh, &xc->fh_nam); - free(mem); - return(0); - } - } + { + xc->fh = tmpfile_open(&xc->fh_nam); + free(fnam); + fnam = NULL; + if (!xc->fh) { + tmpfile_close(&xc->fh, &xc->fh_nam); + free(mem); + return (0); + } + } #ifndef __MINGW32__ - if(fnam) unlink(fnam); + if (fnam) + unlink(fnam); #endif - if(htyp == FST_BL_HIER) - { - for(hl = 0; hl < uclen; hl += FST_GZIO_LEN) - { - size_t len = ((uclen - hl) > FST_GZIO_LEN) ? FST_GZIO_LEN : (uclen - hl); - size_t gzreadlen = gzread(zhandle, mem, len); /* rc should equal len... */ - size_t fwlen; + if (htyp == FST_BL_HIER) { + for (hl = 0; hl < uclen; hl += FST_GZIO_LEN) { + size_t len = ((uclen - hl) > FST_GZIO_LEN) ? FST_GZIO_LEN : (uclen - hl); + size_t gzreadlen = gzread(zhandle, mem, len); /* rc should equal len... */ + size_t fwlen; - if(gzreadlen != len) - { - pass_status = 0; - break; - } - - fwlen = fstFwrite(mem, len, 1, xc->fh); - if(fwlen != 1) - { - pass_status = 0; - break; - } - } - gzclose(zhandle); + if (gzreadlen != len) { + pass_status = 0; + break; } - else - if(htyp == FST_BL_HIER_LZ4DUO) - { - unsigned char *lz4_cmem = (unsigned char *)malloc(clen); - unsigned char *lz4_ucmem = (unsigned char *)malloc(uclen); - unsigned char *lz4_ucmem2; - uint64_t uclen2; - int skiplen2 = 0; - fstFread(lz4_cmem, clen, 1, xc->f); - - uclen2 = fstGetVarint64(lz4_cmem, &skiplen2); - lz4_ucmem2 = (unsigned char *)malloc(uclen2); - pass_status = (uclen2 == (uint64_t)LZ4_decompress_safe_partial ((char *)lz4_cmem + skiplen2, (char *)lz4_ucmem2, clen - skiplen2, uclen2, uclen2)); - if(pass_status) - { - pass_status = (uclen == LZ4_decompress_safe_partial ((char *)lz4_ucmem2, (char *)lz4_ucmem, uclen2, uclen, uclen)); - - if(fstFwrite(lz4_ucmem, uclen, 1, xc->fh) != 1) - { - pass_status = 0; - } - } - - free(lz4_ucmem2); - free(lz4_ucmem); - free(lz4_cmem); + fwlen = fstFwrite(mem, len, 1, xc->fh); + if (fwlen != 1) { + pass_status = 0; + break; } - else - if(htyp == FST_BL_HIER_LZ4) - { - unsigned char *lz4_cmem = (unsigned char *)malloc(clen); - unsigned char *lz4_ucmem = (unsigned char *)malloc(uclen); + } + gzclose(zhandle); + } else if (htyp == FST_BL_HIER_LZ4DUO) { + unsigned char *lz4_cmem = (unsigned char *)malloc(clen); + unsigned char *lz4_ucmem = (unsigned char *)malloc(uclen); + unsigned char *lz4_ucmem2; + uint64_t uclen2; + int skiplen2 = 0; - fstFread(lz4_cmem, clen, 1, xc->f); - pass_status = (uclen == LZ4_decompress_safe_partial ((char *)lz4_cmem, (char *)lz4_ucmem, clen, uclen, uclen)); + fstFread(lz4_cmem, clen, 1, xc->f); - if(fstFwrite(lz4_ucmem, uclen, 1, xc->fh) != 1) - { - pass_status = 0; - } + uclen2 = fstGetVarint64(lz4_cmem, &skiplen2); + lz4_ucmem2 = (unsigned char *)malloc(uclen2); + pass_status = + (uclen2 == (uint64_t)LZ4_decompress_safe_partial((char *)lz4_cmem + skiplen2, + (char *)lz4_ucmem2, + clen - skiplen2, + uclen2, + uclen2)); + if (pass_status) { + pass_status = (uclen == LZ4_decompress_safe_partial((char *)lz4_ucmem2, + (char *)lz4_ucmem, + uclen2, + uclen, + uclen)); - free(lz4_ucmem); - free(lz4_cmem); + if (fstFwrite(lz4_ucmem, uclen, 1, xc->fh) != 1) { + pass_status = 0; } - else /* FST_BL_SKIP */ - { + } + + free(lz4_ucmem2); + free(lz4_ucmem); + free(lz4_cmem); + } else if (htyp == FST_BL_HIER_LZ4) { + unsigned char *lz4_cmem = (unsigned char *)malloc(clen); + unsigned char *lz4_ucmem = (unsigned char *)malloc(uclen); + + fstFread(lz4_cmem, clen, 1, xc->f); + pass_status = (uclen == LZ4_decompress_safe_partial((char *)lz4_cmem, + (char *)lz4_ucmem, + clen, + uclen, + uclen)); + + if (fstFwrite(lz4_ucmem, uclen, 1, xc->fh) != 1) { pass_status = 0; - if(xc->fh) - { - fclose(xc->fh); xc->fh = NULL; /* needed in case .hier file is missing and there are no hier sections */ - } - } + } + + free(lz4_ucmem); + free(lz4_cmem); + } else /* FST_BL_SKIP */ + { + pass_status = 0; + if (xc->fh) { + fclose(xc->fh); + xc->fh = + NULL; /* needed in case .hier file is missing and there are no hier sections */ + } + } free(mem); free(fnam); fstReaderFseeko(xc, xc->f, offs_cache, SEEK_SET); - } + } -return(pass_status); + return (pass_status); } - -int fstReaderIterateHierRewind(void *ctx) +int fstReaderIterateHierRewind(fstReaderContext *xc) { -struct fstReaderContext *xc = (struct fstReaderContext *)ctx; -int pass_status = 0; + int pass_status = 0; -if(xc) - { + if (xc) { pass_status = 1; - if(!xc->fh) - { - pass_status = fstReaderRecreateHierFile(xc); - } + if (!xc->fh) { + pass_status = fstReaderRecreateHierFile(xc); + } xc->do_rewind = 1; - } + } -return(pass_status); + 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 isfeof; + fstHandle alias; + char *pnt; + int ch; + int unnamed_scope_idx = 0; -if(!xc) return(NULL); + if (!xc) + return (NULL); -if(!xc->fh) - { - if(!fstReaderRecreateHierFile(xc)) - { - return(NULL); - } + if (!xc->fh) { + if (!fstReaderRecreateHierFile(xc)) { + return (NULL); } + } -if(xc->do_rewind) - { + if (xc->do_rewind) { xc->do_rewind = 0; xc->current_handle = 0; fstReaderFseeko(xc, xc->fh, 0, SEEK_SET); clearerr(xc->fh); - } + } -if(!(isfeof=feof(xc->fh))) - { + if (!(isfeof = feof(xc->fh))) { int tag = fgetc(xc->fh); - int cl; - switch(tag) - { - case FST_ST_VCD_SCOPE: - xc->hier.htyp = FST_HT_SCOPE; - xc->hier.u.scope.typ = fgetc(xc->fh); - xc->hier.u.scope.name = pnt = xc->str_scope_nam; - cl = 0; - while((ch = fgetc(xc->fh))) - { - if(cl < FST_ID_NAM_SIZ) - { - pnt[cl++] = ch; - } - }; /* scopename */ - pnt[cl] = 0; - xc->hier.u.scope.name_length = cl; - - xc->hier.u.scope.component = pnt = xc->str_scope_comp; - cl = 0; - while((ch = fgetc(xc->fh))) - { - if(cl < FST_ID_NAM_SIZ) - { - pnt[cl++] = ch; - } - }; /* scopecomp */ - pnt[cl] = 0; - xc->hier.u.scope.component_length = cl; - break; - - case FST_ST_VCD_UPSCOPE: - xc->hier.htyp = FST_HT_UPSCOPE; - break; - - case FST_ST_GEN_ATTRBEGIN: - xc->hier.htyp = FST_HT_ATTRBEGIN; - xc->hier.u.attr.typ = fgetc(xc->fh); - xc->hier.u.attr.subtype = fgetc(xc->fh); - if(!xc->str_scope_attr) - { - xc->str_scope_attr = (char *)calloc(1, FST_ID_NAM_ATTR_SIZ+1); - } - xc->hier.u.attr.name = pnt = xc->str_scope_attr; - cl = 0; - while((ch = fgetc(xc->fh))) - { - if(cl < FST_ID_NAM_ATTR_SIZ) - { - pnt[cl++] = ch; - } - }; /* attrname */ - pnt[cl] = 0; - xc->hier.u.attr.name_length = cl; - - xc->hier.u.attr.arg = fstReaderVarint64(xc->fh); - - if(xc->hier.u.attr.typ == FST_AT_MISC) - { - if((xc->hier.u.attr.subtype == FST_MT_SOURCESTEM)||(xc->hier.u.attr.subtype == FST_MT_SOURCEISTEM)) - { - int sidx_skiplen_dummy = 0; - xc->hier.u.attr.arg_from_name = fstGetVarint64((unsigned char *)xc->str_scope_attr, &sidx_skiplen_dummy); - } - } - break; - - case FST_ST_GEN_ATTREND: - xc->hier.htyp = FST_HT_ATTREND; - break; - - case FST_VT_VCD_EVENT: - case FST_VT_VCD_INTEGER: - case FST_VT_VCD_PARAMETER: - case FST_VT_VCD_REAL: - case FST_VT_VCD_REAL_PARAMETER: - case FST_VT_VCD_REG: - case FST_VT_VCD_SUPPLY0: - case FST_VT_VCD_SUPPLY1: - case FST_VT_VCD_TIME: - case FST_VT_VCD_TRI: - case FST_VT_VCD_TRIAND: - case FST_VT_VCD_TRIOR: - case FST_VT_VCD_TRIREG: - case FST_VT_VCD_TRI0: - case FST_VT_VCD_TRI1: - case FST_VT_VCD_WAND: - case FST_VT_VCD_WIRE: - case FST_VT_VCD_WOR: - case FST_VT_VCD_PORT: - case FST_VT_VCD_SPARRAY: - case FST_VT_VCD_REALTIME: - case FST_VT_GEN_STRING: - case FST_VT_SV_BIT: - case FST_VT_SV_LOGIC: - case FST_VT_SV_INT: - case FST_VT_SV_SHORTINT: - case FST_VT_SV_LONGINT: - case FST_VT_SV_BYTE: - case FST_VT_SV_ENUM: - case FST_VT_SV_SHORTREAL: - xc->hier.htyp = FST_HT_VAR; - xc->hier.u.var.svt_workspace = FST_SVT_NONE; - xc->hier.u.var.sdt_workspace = FST_SDT_NONE; - xc->hier.u.var.sxt_workspace = 0; - xc->hier.u.var.typ = tag; - xc->hier.u.var.direction = fgetc(xc->fh); - xc->hier.u.var.name = pnt = xc->str_scope_nam; - cl = 0; - while((ch = fgetc(xc->fh))) - { - if(cl < FST_ID_NAM_SIZ) - { - pnt[cl++] = ch; - } - }; /* varname */ - pnt[cl] = 0; - xc->hier.u.var.name_length = cl; - xc->hier.u.var.length = fstReaderVarint32(xc->fh); - if(tag == FST_VT_VCD_PORT) - { - xc->hier.u.var.length -= 2; /* removal of delimiting spaces */ - xc->hier.u.var.length /= 3; /* port -> signal size adjust */ - } - - alias = fstReaderVarint32(xc->fh); - - if(!alias) - { - xc->current_handle++; - xc->hier.u.var.handle = xc->current_handle; - xc->hier.u.var.is_alias = 0; - } - else - { - xc->hier.u.var.handle = alias; - xc->hier.u.var.is_alias = 1; - } - - break; - - default: - isfeof = 1; - break; + int cl; + switch (tag) { + case FST_ST_VCD_SCOPE: + xc->hier.htyp = FST_HT_SCOPE; + xc->hier.u.scope.typ = fgetc(xc->fh); + xc->hier.u.scope.name = pnt = xc->str_scope_nam; + cl = 0; + while ((ch = fgetc(xc->fh))) { + if (cl < FST_ID_NAM_SIZ) { + 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; -return(!isfeof ? &xc->hier : NULL); + xc->hier.u.scope.component = pnt = xc->str_scope_comp; + cl = 0; + while ((ch = fgetc(xc->fh))) { + if (cl < FST_ID_NAM_SIZ) { + pnt[cl++] = ch; + } + }; /* scopecomp */ + pnt[cl] = 0; + xc->hier.u.scope.component_length = cl; + break; + + case FST_ST_VCD_UPSCOPE: + xc->hier.htyp = FST_HT_UPSCOPE; + break; + + case FST_ST_GEN_ATTRBEGIN: + xc->hier.htyp = FST_HT_ATTRBEGIN; + xc->hier.u.attr.typ = fgetc(xc->fh); + xc->hier.u.attr.subtype = fgetc(xc->fh); + if (!xc->str_scope_attr) { + xc->str_scope_attr = (char *)calloc(1, FST_ID_NAM_ATTR_SIZ + 1); + } + xc->hier.u.attr.name = pnt = xc->str_scope_attr; + cl = 0; + while ((ch = fgetc(xc->fh))) { + if (cl < FST_ID_NAM_ATTR_SIZ) { + pnt[cl++] = ch; + } + }; /* attrname */ + pnt[cl] = 0; + xc->hier.u.attr.name_length = cl; + + xc->hier.u.attr.arg = fstReaderVarint64(xc->fh); + + if (xc->hier.u.attr.typ == FST_AT_MISC) { + if ((xc->hier.u.attr.subtype == FST_MT_SOURCESTEM) || + (xc->hier.u.attr.subtype == FST_MT_SOURCEISTEM)) { + int sidx_skiplen_dummy = 0; + xc->hier.u.attr.arg_from_name = + fstGetVarint64((unsigned char *)xc->str_scope_attr, + &sidx_skiplen_dummy); + } + } + break; + + case FST_ST_GEN_ATTREND: + xc->hier.htyp = FST_HT_ATTREND; + break; + + case FST_VT_VCD_EVENT: + case FST_VT_VCD_INTEGER: + case FST_VT_VCD_PARAMETER: + case FST_VT_VCD_REAL: + case FST_VT_VCD_REAL_PARAMETER: + case FST_VT_VCD_REG: + case FST_VT_VCD_SUPPLY0: + case FST_VT_VCD_SUPPLY1: + case FST_VT_VCD_TIME: + case FST_VT_VCD_TRI: + case FST_VT_VCD_TRIAND: + case FST_VT_VCD_TRIOR: + case FST_VT_VCD_TRIREG: + case FST_VT_VCD_TRI0: + case FST_VT_VCD_TRI1: + case FST_VT_VCD_WAND: + case FST_VT_VCD_WIRE: + case FST_VT_VCD_WOR: + case FST_VT_VCD_PORT: + case FST_VT_VCD_SPARRAY: + case FST_VT_VCD_REALTIME: + case FST_VT_GEN_STRING: + case FST_VT_SV_BIT: + case FST_VT_SV_LOGIC: + case FST_VT_SV_INT: + case FST_VT_SV_SHORTINT: + case FST_VT_SV_LONGINT: + case FST_VT_SV_BYTE: + case FST_VT_SV_ENUM: + case FST_VT_SV_SHORTREAL: + xc->hier.htyp = FST_HT_VAR; + xc->hier.u.var.svt_workspace = FST_SVT_NONE; + xc->hier.u.var.sdt_workspace = FST_SDT_NONE; + xc->hier.u.var.sxt_workspace = 0; + xc->hier.u.var.typ = tag; + xc->hier.u.var.direction = fgetc(xc->fh); + xc->hier.u.var.name = pnt = xc->str_scope_nam; + cl = 0; + while ((ch = fgetc(xc->fh))) { + if (cl < FST_ID_NAM_SIZ) { + pnt[cl++] = ch; + } + }; /* varname */ + pnt[cl] = 0; + xc->hier.u.var.name_length = cl; + xc->hier.u.var.length = fstReaderVarint32(xc->fh); + if (tag == FST_VT_VCD_PORT) { + xc->hier.u.var.length -= 2; /* removal of delimiting spaces */ + xc->hier.u.var.length /= 3; /* port -> signal size adjust */ + } + + alias = fstReaderVarint32(xc->fh); + + if (!alias) { + xc->current_handle++; + xc->hier.u.var.handle = xc->current_handle; + xc->hier.u.var.is_alias = 0; + } else { + xc->hier.u.var.handle = alias; + xc->hier.u.var.is_alias = 1; + } + + break; + + default: + isfeof = 1; + break; + } + } + + 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; -int vartype; -uint32_t len, alias; -/* uint32_t maxvalpos=0; */ -unsigned int num_signal_dyn = 65536; -int attrtype, subtype; -uint64_t attrarg; -fstHandle maxhandle_scanbuild; -int cl; + char *str; + char *pnt; + int ch, scopetype; + int vartype; + uint32_t len, alias; + /* uint32_t maxvalpos=0; */ + unsigned int num_signal_dyn = 65536; + int attrtype, subtype; + uint64_t attrarg; + fstHandle maxhandle_scanbuild; + int cl; + int unnamed_scope_idx = 0; -if(!xc) return(0); + if (!xc) + return (0); -xc->longest_signal_value_len = 32; /* arbitrarily set at 32...this is much longer than an expanded double */ + xc->longest_signal_value_len = + 32; /* arbitrarily set at 32...this is much longer than an expanded double */ -if(!xc->fh) - { - if(!fstReaderRecreateHierFile(xc)) - { - return(0); - } + if (!xc->fh) { + if (!fstReaderRecreateHierFile(xc)) { + return (0); } + } -str = (char *)malloc(FST_ID_NAM_ATTR_SIZ+1); + str = (char *)malloc(FST_ID_NAM_ATTR_SIZ + 1); -if(fv) - { + if (fv) { char time_dimension[2] = {0, 0}; int time_scale = 1; fprintf(fv, "$date\n\t%s\n$end\n", xc->date); fprintf(fv, "$version\n\t%s\n$end\n", xc->version); - if(xc->timezero) fprintf(fv, "$timezero\n\t%" PRId64 "\n$end\n", xc->timezero); + if (xc->timezero) + fprintf(fv, "$timezero\n\t%" PRId64 "\n$end\n", xc->timezero); - switch(xc->timescale) - { - case 2: time_scale = 100; time_dimension[0] = 0; break; - case 1: time_scale = 10; /* fallthrough */ - case 0: time_dimension[0] = 0; break; + switch (xc->timescale) { + case 2: + time_scale = 100; + time_dimension[0] = 0; + break; + case 1: + time_scale = 10; /* fallthrough */ + case 0: + time_dimension[0] = 0; + break; - case -1: time_scale = 100; time_dimension[0] = 'm'; break; - case -2: time_scale = 10; /* fallthrough */ - case -3: time_dimension[0] = 'm'; break; + case -1: + time_scale = 100; + time_dimension[0] = 'm'; + break; + case -2: + time_scale = 10; /* fallthrough */ + case -3: + time_dimension[0] = 'm'; + break; - case -4: time_scale = 100; time_dimension[0] = 'u'; break; - case -5: time_scale = 10; /* fallthrough */ - case -6: time_dimension[0] = 'u'; break; + case -4: + time_scale = 100; + time_dimension[0] = 'u'; + break; + case -5: + time_scale = 10; /* fallthrough */ + case -6: + time_dimension[0] = 'u'; + break; - case -10: time_scale = 100; time_dimension[0] = 'p'; break; - case -11: time_scale = 10; /* fallthrough */ - case -12: time_dimension[0] = 'p'; break; + case -10: + time_scale = 100; + time_dimension[0] = 'p'; + break; + case -11: + time_scale = 10; /* fallthrough */ + case -12: + time_dimension[0] = 'p'; + break; - case -13: time_scale = 100; time_dimension[0] = 'f'; break; - case -14: time_scale = 10; /* fallthrough */ - case -15: time_dimension[0] = 'f'; break; + case -13: + time_scale = 100; + time_dimension[0] = 'f'; + break; + case -14: + time_scale = 10; /* fallthrough */ + case -15: + time_dimension[0] = 'f'; + break; - case -16: time_scale = 100; time_dimension[0] = 'a'; break; - case -17: time_scale = 10; /* fallthrough */ - case -18: time_dimension[0] = 'a'; break; + case -16: + time_scale = 100; + time_dimension[0] = 'a'; + break; + case -17: + time_scale = 10; /* fallthrough */ + case -18: + time_dimension[0] = 'a'; + break; - case -19: time_scale = 100; time_dimension[0] = 'z'; break; - case -20: time_scale = 10; /* fallthrough */ - case -21: time_dimension[0] = 'z'; break; + case -19: + time_scale = 100; + time_dimension[0] = 'z'; + break; + case -20: + time_scale = 10; /* fallthrough */ + case -21: + time_dimension[0] = 'z'; + break; - case -7: time_scale = 100; time_dimension[0] = 'n'; break; - case -8: time_scale = 10; /* fallthrough */ - case -9: - default: time_dimension[0] = 'n'; break; - } - - if(fv) fprintf(fv, "$timescale\n\t%d%ss\n$end\n", time_scale, time_dimension); + case -7: + time_scale = 100; + time_dimension[0] = 'n'; + break; + case -8: + time_scale = 10; /* fallthrough */ + case -9: + default: + time_dimension[0] = 'n'; + break; } -xc->maxhandle = 0; -xc->num_alias = 0; + if (fv) + fprintf(fv, "$timescale\n\t%d%ss\n$end\n", time_scale, time_dimension); + } -free(xc->signal_lens); -xc->signal_lens = (uint32_t *)malloc(num_signal_dyn*sizeof(uint32_t)); + xc->maxhandle = 0; + xc->num_alias = 0; -free(xc->signal_typs); -xc->signal_typs = (unsigned char *)malloc(num_signal_dyn*sizeof(unsigned char)); + free(xc->signal_lens); + xc->signal_lens = (uint32_t *)malloc(num_signal_dyn * sizeof(uint32_t)); -fstReaderFseeko(xc, xc->fh, 0, SEEK_SET); -while(!feof(xc->fh)) - { + free(xc->signal_typs); + xc->signal_typs = (unsigned char *)malloc(num_signal_dyn * sizeof(unsigned char)); + + fstReaderFseeko(xc, xc->fh, 0, SEEK_SET); + while (!feof(xc->fh)) { int tag = fgetc(xc->fh); - switch(tag) - { - case FST_ST_VCD_SCOPE: - scopetype = fgetc(xc->fh); - if((scopetype < FST_ST_MIN) || (scopetype > FST_ST_MAX)) scopetype = FST_ST_VCD_MODULE; - pnt = str; - cl = 0; - while((ch = fgetc(xc->fh))) - { - if(cl < FST_ID_NAM_ATTR_SIZ) - { - pnt[cl++] = ch; - } - }; /* scopename */ - pnt[cl] = 0; - while(fgetc(xc->fh)) { }; /* scopecomp */ - - if(fv) fprintf(fv, "$scope %s %s $end\n", modtypes[scopetype], str); - break; - - case FST_ST_VCD_UPSCOPE: - if(fv) fprintf(fv, "$upscope $end\n"); - break; - - case FST_ST_GEN_ATTRBEGIN: - attrtype = fgetc(xc->fh); - subtype = fgetc(xc->fh); - pnt = str; - cl = 0; - while((ch = fgetc(xc->fh))) - { - if(cl < FST_ID_NAM_ATTR_SIZ) - { - pnt[cl++] = ch; - } - }; /* attrname */ - pnt[cl] = 0; - - if(!str[0]) { strcpy(str, "\"\""); } - - attrarg = fstReaderVarint64(xc->fh); - - if(fv && xc->use_vcd_extensions) - { - switch(attrtype) - { - case FST_AT_ARRAY: if((subtype < FST_AR_NONE) || (subtype > FST_AR_MAX)) subtype = FST_AR_NONE; - fprintf(fv, "$attrbegin %s %s %s %" PRId64 " $end\n", attrtypes[attrtype], arraytypes[subtype], str, attrarg); - break; - case FST_AT_ENUM: if((subtype < FST_EV_SV_INTEGER) || (subtype > FST_EV_MAX)) subtype = FST_EV_SV_INTEGER; - fprintf(fv, "$attrbegin %s %s %s %" PRId64 " $end\n", attrtypes[attrtype], enumvaluetypes[subtype], str, attrarg); - break; - case FST_AT_PACK: if((subtype < FST_PT_NONE) || (subtype > FST_PT_MAX)) subtype = FST_PT_NONE; - fprintf(fv, "$attrbegin %s %s %s %" PRId64 " $end\n", attrtypes[attrtype], packtypes[subtype], str, attrarg); - break; - case FST_AT_MISC: - default: attrtype = FST_AT_MISC; - if(subtype == FST_MT_COMMENT) - { - fprintf(fv, "$comment\n\t%s\n$end\n", str); - } - else - { - if((subtype == FST_MT_SOURCESTEM)||(subtype == FST_MT_SOURCEISTEM)) - { - int sidx_skiplen_dummy = 0; - uint64_t sidx = fstGetVarint64((unsigned char *)str, &sidx_skiplen_dummy); - - fprintf(fv, "$attrbegin %s %02x %" PRId64 " %" PRId64 " $end\n", attrtypes[attrtype], subtype, sidx, attrarg); - } - else - { - fprintf(fv, "$attrbegin %s %02x %s %" PRId64 " $end\n", attrtypes[attrtype], subtype, str, attrarg); - } - } - break; - } - } - break; - - case FST_ST_GEN_ATTREND: - if(fv && xc->use_vcd_extensions) fprintf(fv, "$attrend $end\n"); - break; - - case FST_VT_VCD_EVENT: - case FST_VT_VCD_INTEGER: - case FST_VT_VCD_PARAMETER: - case FST_VT_VCD_REAL: - case FST_VT_VCD_REAL_PARAMETER: - case FST_VT_VCD_REG: - case FST_VT_VCD_SUPPLY0: - case FST_VT_VCD_SUPPLY1: - case FST_VT_VCD_TIME: - case FST_VT_VCD_TRI: - case FST_VT_VCD_TRIAND: - case FST_VT_VCD_TRIOR: - case FST_VT_VCD_TRIREG: - case FST_VT_VCD_TRI0: - case FST_VT_VCD_TRI1: - case FST_VT_VCD_WAND: - case FST_VT_VCD_WIRE: - case FST_VT_VCD_WOR: - case FST_VT_VCD_PORT: - case FST_VT_VCD_SPARRAY: - case FST_VT_VCD_REALTIME: - case FST_VT_GEN_STRING: - case FST_VT_SV_BIT: - case FST_VT_SV_LOGIC: - case FST_VT_SV_INT: - case FST_VT_SV_SHORTINT: - case FST_VT_SV_LONGINT: - case FST_VT_SV_BYTE: - case FST_VT_SV_ENUM: - case FST_VT_SV_SHORTREAL: - vartype = tag; - /* vardir = */ fgetc(xc->fh); /* unused in VCD reader, but need to advance read pointer */ - pnt = str; - cl = 0; - while((ch = fgetc(xc->fh))) - { - if(cl < FST_ID_NAM_ATTR_SIZ) - { - pnt[cl++] = ch; - } - }; /* varname */ - pnt[cl] = 0; - len = fstReaderVarint32(xc->fh); - alias = fstReaderVarint32(xc->fh); - - if(!alias) - { - if(xc->maxhandle == num_signal_dyn) - { - num_signal_dyn *= 2; - xc->signal_lens = (uint32_t *)realloc(xc->signal_lens, num_signal_dyn*sizeof(uint32_t)); - xc->signal_typs = (unsigned char *)realloc(xc->signal_typs, num_signal_dyn*sizeof(unsigned char)); - } - xc->signal_lens[xc->maxhandle] = len; - xc->signal_typs[xc->maxhandle] = vartype; - - /* maxvalpos+=len; */ - if(len > xc->longest_signal_value_len) - { - xc->longest_signal_value_len = len; - } - - if((vartype == FST_VT_VCD_REAL) || (vartype == FST_VT_VCD_REAL_PARAMETER) || (vartype == FST_VT_VCD_REALTIME) || (vartype == FST_VT_SV_SHORTREAL)) - { - len = (vartype != FST_VT_SV_SHORTREAL) ? 64 : 32; - xc->signal_typs[xc->maxhandle] = FST_VT_VCD_REAL; - } - if(fv) - { - char vcdid_buf[16]; - uint32_t modlen = (vartype != FST_VT_VCD_PORT) ? len : ((len - 2) / 3); - fstVcdID(vcdid_buf, xc->maxhandle+1); - fprintf(fv, "$var %s %" PRIu32 " %s %s $end\n", vartypes[vartype], modlen, vcdid_buf, str); - } - xc->maxhandle++; - } - else - { - if((vartype == FST_VT_VCD_REAL) || (vartype == FST_VT_VCD_REAL_PARAMETER) || (vartype == FST_VT_VCD_REALTIME) || (vartype == FST_VT_SV_SHORTREAL)) - { - len = (vartype != FST_VT_SV_SHORTREAL) ? 64 : 32; - xc->signal_typs[xc->maxhandle] = FST_VT_VCD_REAL; - } - if(fv) - { - char vcdid_buf[16]; - uint32_t modlen = (vartype != FST_VT_VCD_PORT) ? len : ((len - 2) / 3); - fstVcdID(vcdid_buf, alias); - fprintf(fv, "$var %s %" PRIu32 " %s %s $end\n", vartypes[vartype], modlen, vcdid_buf, str); - } - xc->num_alias++; - } - - break; - - default: - break; + switch (tag) { + case FST_ST_VCD_SCOPE: + scopetype = fgetc(xc->fh); + if ((scopetype < FST_ST_MIN) || (scopetype > FST_ST_MAX)) + scopetype = FST_ST_VCD_MODULE; + pnt = str; + cl = 0; + while ((ch = fgetc(xc->fh))) { + if (cl < FST_ID_NAM_ATTR_SIZ) { + 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 */ + + if (fv) + fprintf(fv, "$scope %s %s $end\n", modtypes[scopetype], str); + break; + + case FST_ST_VCD_UPSCOPE: + if (fv) + fprintf(fv, "$upscope $end\n"); + break; + + case FST_ST_GEN_ATTRBEGIN: + attrtype = fgetc(xc->fh); + subtype = fgetc(xc->fh); + pnt = str; + cl = 0; + while ((ch = fgetc(xc->fh))) { + if (cl < FST_ID_NAM_ATTR_SIZ) { + pnt[cl++] = ch; + } + }; /* attrname */ + pnt[cl] = 0; + + if (!str[0]) { + strcpy(str, "\"\""); + } + + attrarg = fstReaderVarint64(xc->fh); + + if (fv && xc->use_vcd_extensions) { + switch (attrtype) { + case FST_AT_ARRAY: + if ((subtype < FST_AR_NONE) || (subtype > FST_AR_MAX)) + subtype = FST_AR_NONE; + fprintf(fv, + "$attrbegin %s %s %s %" PRId64 " $end\n", + attrtypes[attrtype], + arraytypes[subtype], + str, + attrarg); + break; + case FST_AT_ENUM: + if ((subtype < FST_EV_SV_INTEGER) || (subtype > FST_EV_MAX)) + subtype = FST_EV_SV_INTEGER; + fprintf(fv, + "$attrbegin %s %s %s %" PRId64 " $end\n", + attrtypes[attrtype], + enumvaluetypes[subtype], + str, + attrarg); + break; + case FST_AT_PACK: + if ((subtype < FST_PT_NONE) || (subtype > FST_PT_MAX)) + subtype = FST_PT_NONE; + fprintf(fv, + "$attrbegin %s %s %s %" PRId64 " $end\n", + attrtypes[attrtype], + packtypes[subtype], + str, + attrarg); + break; + case FST_AT_MISC: + default: + attrtype = FST_AT_MISC; + if (subtype == FST_MT_COMMENT) { + fprintf(fv, "$comment\n\t%s\n$end\n", str); + } else { + if ((subtype == FST_MT_SOURCESTEM) || + (subtype == FST_MT_SOURCEISTEM)) { + int sidx_skiplen_dummy = 0; + uint64_t sidx = + fstGetVarint64((unsigned char *)str, &sidx_skiplen_dummy); + + fprintf(fv, + "$attrbegin %s %02x %" PRId64 " %" PRId64 " $end\n", + attrtypes[attrtype], + subtype, + sidx, + attrarg); + } else { + fprintf(fv, + "$attrbegin %s %02x %s %" PRId64 " $end\n", + attrtypes[attrtype], + subtype, + str, + attrarg); + } + } + break; + } + } + break; + + case FST_ST_GEN_ATTREND: + if (fv && xc->use_vcd_extensions) + fprintf(fv, "$attrend $end\n"); + break; + + case FST_VT_VCD_EVENT: + case FST_VT_VCD_INTEGER: + case FST_VT_VCD_PARAMETER: + case FST_VT_VCD_REAL: + case FST_VT_VCD_REAL_PARAMETER: + case FST_VT_VCD_REG: + case FST_VT_VCD_SUPPLY0: + case FST_VT_VCD_SUPPLY1: + case FST_VT_VCD_TIME: + case FST_VT_VCD_TRI: + case FST_VT_VCD_TRIAND: + case FST_VT_VCD_TRIOR: + case FST_VT_VCD_TRIREG: + case FST_VT_VCD_TRI0: + case FST_VT_VCD_TRI1: + case FST_VT_VCD_WAND: + case FST_VT_VCD_WIRE: + case FST_VT_VCD_WOR: + case FST_VT_VCD_PORT: + case FST_VT_VCD_SPARRAY: + case FST_VT_VCD_REALTIME: + case FST_VT_GEN_STRING: + case FST_VT_SV_BIT: + case FST_VT_SV_LOGIC: + case FST_VT_SV_INT: + case FST_VT_SV_SHORTINT: + case FST_VT_SV_LONGINT: + case FST_VT_SV_BYTE: + case FST_VT_SV_ENUM: + case FST_VT_SV_SHORTREAL: + vartype = tag; + /* vardir = */ fgetc( + xc->fh); /* unused in VCD reader, but need to advance read pointer */ + pnt = str; + cl = 0; + while ((ch = fgetc(xc->fh))) { + if (cl < FST_ID_NAM_ATTR_SIZ) { + pnt[cl++] = ch; + } + }; /* varname */ + pnt[cl] = 0; + len = fstReaderVarint32(xc->fh); + alias = fstReaderVarint32(xc->fh); + + if (!alias) { + if (xc->maxhandle == num_signal_dyn) { + num_signal_dyn *= 2; + xc->signal_lens = + (uint32_t *)realloc(xc->signal_lens, num_signal_dyn * sizeof(uint32_t)); + xc->signal_typs = + (unsigned char *)realloc(xc->signal_typs, + num_signal_dyn * sizeof(unsigned char)); + } + xc->signal_lens[xc->maxhandle] = len; + xc->signal_typs[xc->maxhandle] = vartype; + + /* maxvalpos+=len; */ + if (len > xc->longest_signal_value_len) { + xc->longest_signal_value_len = len; + } + + if ((vartype == FST_VT_VCD_REAL) || (vartype == FST_VT_VCD_REAL_PARAMETER) || + (vartype == FST_VT_VCD_REALTIME) || (vartype == FST_VT_SV_SHORTREAL)) { + len = (vartype != FST_VT_SV_SHORTREAL) ? 64 : 32; + xc->signal_typs[xc->maxhandle] = FST_VT_VCD_REAL; + } + if (fv) { + char vcdid_buf[16]; + uint32_t modlen = (vartype != FST_VT_VCD_PORT) ? len : ((len - 2) / 3); + fstVcdID(vcdid_buf, xc->maxhandle + 1); + fprintf(fv, + "$var %s %" PRIu32 " %s %s $end\n", + vartypes[vartype], + modlen, + vcdid_buf, + str); + } + xc->maxhandle++; + } else { + if ((vartype == FST_VT_VCD_REAL) || (vartype == FST_VT_VCD_REAL_PARAMETER) || + (vartype == FST_VT_VCD_REALTIME) || (vartype == FST_VT_SV_SHORTREAL)) { + len = (vartype != FST_VT_SV_SHORTREAL) ? 64 : 32; + xc->signal_typs[xc->maxhandle] = FST_VT_VCD_REAL; + } + if (fv) { + char vcdid_buf[16]; + uint32_t modlen = (vartype != FST_VT_VCD_PORT) ? len : ((len - 2) / 3); + fstVcdID(vcdid_buf, alias); + fprintf(fv, + "$var %s %" PRIu32 " %s %s $end\n", + vartypes[vartype], + modlen, + vcdid_buf, + str); + } + xc->num_alias++; + } + + break; + + default: + break; } -if(fv) fprintf(fv, "$enddefinitions $end\n"); + } + if (fv) + fprintf(fv, "$enddefinitions $end\n"); -maxhandle_scanbuild = xc->maxhandle ? xc->maxhandle : 1; /*scan-build warning suppression, in reality we have at least one signal */ + maxhandle_scanbuild = + xc->maxhandle + ? xc->maxhandle + : 1; /*scan-build warning suppression, in reality we have at least one signal */ -xc->signal_lens = (uint32_t *)realloc(xc->signal_lens, maxhandle_scanbuild*sizeof(uint32_t)); -xc->signal_typs = (unsigned char *)realloc(xc->signal_typs, maxhandle_scanbuild*sizeof(unsigned char)); + xc->signal_lens = (uint32_t *)realloc(xc->signal_lens, maxhandle_scanbuild * sizeof(uint32_t)); + xc->signal_typs = + (unsigned char *)realloc(xc->signal_typs, maxhandle_scanbuild * sizeof(unsigned char)); -free(xc->process_mask); -xc->process_mask = (unsigned char *)calloc(1, (maxhandle_scanbuild+7)/8); + free(xc->process_mask); + xc->process_mask = (unsigned char *)calloc(1, (maxhandle_scanbuild + 7) / 8); -free(xc->temp_signal_value_buf); -xc->temp_signal_value_buf = (unsigned char *)malloc(xc->longest_signal_value_len + 1); + free(xc->temp_signal_value_buf); + xc->temp_signal_value_buf = (unsigned char *)malloc(xc->longest_signal_value_len + 1); -xc->var_count = xc->maxhandle + xc->num_alias; + xc->var_count = xc->maxhandle + xc->num_alias; -free(str); -return(1); + free(str); + return (1); } - /* * reader file open/close functions */ int fstReaderInit(struct fstReaderContext *xc) { -fst_off_t blkpos = 0; -fst_off_t endfile; -uint64_t seclen; -int sectype; -uint64_t vc_section_count_actual = 0; -int hdr_incomplete = 0; -int hdr_seen = 0; -int gzread_pass_status = 1; + fst_off_t blkpos = 0; + fst_off_t endfile; + uint64_t seclen; + int sectype; + uint64_t vc_section_count_actual = 0; + int hdr_incomplete = 0; + int hdr_seen = 0; + int gzread_pass_status = 1; -sectype = fgetc(xc->f); -if(sectype == FST_BL_ZWRAPPER) - { + sectype = fgetc(xc->f); + if (sectype == FST_BL_ZWRAPPER) { FILE *fcomp; fst_off_t offpnt, uclen; char gz_membuf[FST_GZIO_LEN]; @@ -4606,337 +4438,313 @@ if(sectype == FST_BL_ZWRAPPER) int zfd; int flen = strlen(xc->filename); char *hf; - int hf_len; + int hf_len; seclen = fstReaderUint64(xc->f); uclen = fstReaderUint64(xc->f); - if(!seclen) return(0); /* not finished compressing, this is a failed read */ + if (!seclen) + return (0); /* not finished compressing, this is a failed read */ - hf_len = flen + 16 + 32 + 1; + hf_len = flen + 16 + 32 + 1; hf = (char *)calloc(1, hf_len); snprintf(hf, hf_len, "%s.upk_%d_%p", xc->filename, getpid(), (void *)xc); fcomp = fopen(hf, "w+b"); - if(!fcomp) - { - fcomp = tmpfile_open(&xc->f_nam); - free(hf); hf = NULL; - if(!fcomp) { tmpfile_close(&fcomp, &xc->f_nam); return(0); } - } + if (!fcomp) { + fcomp = tmpfile_open(&xc->f_nam); + free(hf); + hf = NULL; + if (!fcomp) { + tmpfile_close(&fcomp, &xc->f_nam); + return (0); + } + } #if defined(FST_UNBUFFERED_IO) - setvbuf(fcomp, (char *)NULL, _IONBF, 0); /* keeps gzip from acting weird in tandem with fopen */ + setvbuf(fcomp, + (char *)NULL, + _IONBF, + 0); /* keeps gzip from acting weird in tandem with fopen */ #endif #ifdef __MINGW32__ xc->filename_unpacked = hf; #else - if(hf) - { - unlink(hf); - free(hf); - } + if (hf) { + unlink(hf); + free(hf); + } #endif fstReaderFseeko(xc, xc->f, FST_ZWRAPPER_HDR_SIZE, SEEK_SET); #if !defined(__MINGW32__) && !defined(_MSC_VER) fflush(xc->f); #else - /* Windows UCRT runtime library reads one byte ahead in the file - even with buffering disabled and does not synchronise the - file position after fseek. */ - _lseek(fileno(xc->f), FST_ZWRAPPER_HDR_SIZE, SEEK_SET); + /* Windows UCRT runtime library reads one byte ahead in the file + even with buffering disabled and does not synchronise the + file position after fseek. */ + _lseek(fileno(xc->f), FST_ZWRAPPER_HDR_SIZE, SEEK_SET); #endif zfd = dup(fileno(xc->f)); zhandle = gzdopen(zfd, "rb"); - if(zhandle) - { - for(offpnt = 0; offpnt < uclen; offpnt += FST_GZIO_LEN) - { - size_t this_len = ((uclen - offpnt) > FST_GZIO_LEN) ? FST_GZIO_LEN : (uclen - offpnt); - size_t gzreadlen = gzread(zhandle, gz_membuf, this_len); - size_t fwlen; + if (zhandle) { + for (offpnt = 0; offpnt < uclen; offpnt += FST_GZIO_LEN) { + size_t this_len = + ((uclen - offpnt) > FST_GZIO_LEN) ? FST_GZIO_LEN : (uclen - offpnt); + size_t gzreadlen = gzread(zhandle, gz_membuf, this_len); + size_t fwlen; - if(gzreadlen != this_len) - { - gzread_pass_status = 0; - break; - } - fwlen = fstFwrite(gz_membuf, this_len, 1, fcomp); - if(fwlen != 1) - { - gzread_pass_status = 0; - break; - } - } - gzclose(zhandle); + if (gzreadlen != this_len) { + gzread_pass_status = 0; + break; } - else - { - close(zfd); + fwlen = fstFwrite(gz_membuf, this_len, 1, fcomp); + if (fwlen != 1) { + gzread_pass_status = 0; + break; } + } + gzclose(zhandle); + } else { + close(zfd); + } fflush(fcomp); fclose(xc->f); xc->f = fcomp; - } + } -if(gzread_pass_status) - { + if (gzread_pass_status) { fstReaderFseeko(xc, xc->f, 0, SEEK_END); endfile = ftello(xc->f); - while(blkpos < endfile) - { - fstReaderFseeko(xc, xc->f, blkpos, SEEK_SET); + while (blkpos < endfile) { + fstReaderFseeko(xc, xc->f, blkpos, SEEK_SET); - sectype = fgetc(xc->f); - seclen = fstReaderUint64(xc->f); + sectype = fgetc(xc->f); + seclen = fstReaderUint64(xc->f); - if(sectype == EOF) + if (sectype == EOF) { + break; + } + + if ((hdr_incomplete) && (!seclen)) { + break; + } + + if (!hdr_seen && (sectype != FST_BL_HDR)) { + break; + } + + blkpos++; + if (sectype == FST_BL_HDR) { + if (!hdr_seen) { + int ch; + double dcheck; + + xc->start_time = fstReaderUint64(xc->f); + xc->end_time = fstReaderUint64(xc->f); + + hdr_incomplete = (xc->start_time == 0) && (xc->end_time == 0); + + fstFread(&dcheck, 8, 1, xc->f); + /* + * Yosys patch: Fix double endian check for i386 targets built in modern gcc + */ + xc->double_endian_match = (dcheck == (double)FST_DOUBLE_ENDTEST); + if (!xc->double_endian_match) { + union { - break; + unsigned char rvs_buf[8]; + double d; + } vu; + + unsigned char *dcheck_alias = (unsigned char *)&dcheck; + int rvs_idx; + + for (rvs_idx = 0; rvs_idx < 8; rvs_idx++) { + vu.rvs_buf[rvs_idx] = dcheck_alias[7 - rvs_idx]; } - - if((hdr_incomplete) && (!seclen)) - { - break; + if (vu.d != FST_DOUBLE_ENDTEST) { + break; /* either corrupt file or wrong architecture (offset +33 also + functions as matchword) */ } + } - if(!hdr_seen && (sectype != FST_BL_HDR)) - { - break; - } + hdr_seen = 1; - blkpos++; - if(sectype == FST_BL_HDR) - { - if(!hdr_seen) - { - int ch; - double dcheck; + xc->mem_used_by_writer = fstReaderUint64(xc->f); + xc->scope_count = fstReaderUint64(xc->f); + xc->var_count = fstReaderUint64(xc->f); + xc->maxhandle = fstReaderUint64(xc->f); + xc->num_alias = xc->var_count - xc->maxhandle; + xc->vc_section_count = fstReaderUint64(xc->f); + ch = fgetc(xc->f); + xc->timescale = (signed char)ch; + fstFread(xc->version, FST_HDR_SIM_VERSION_SIZE, 1, xc->f); + xc->version[FST_HDR_SIM_VERSION_SIZE] = 0; + fstFread(xc->date, FST_HDR_DATE_SIZE, 1, xc->f); + xc->date[FST_HDR_DATE_SIZE] = 0; + ch = fgetc(xc->f); + xc->filetype = (unsigned char)ch; + xc->timezero = fstReaderUint64(xc->f); + } + } else if ((sectype == FST_BL_VCDATA) || (sectype == FST_BL_VCDATA_DYN_ALIAS) || + (sectype == FST_BL_VCDATA_DYN_ALIAS2)) { + if (hdr_incomplete) { + uint64_t bt = fstReaderUint64(xc->f); + xc->end_time = fstReaderUint64(xc->f); - xc->start_time = fstReaderUint64(xc->f); - xc->end_time = fstReaderUint64(xc->f); - - hdr_incomplete = (xc->start_time == 0) && (xc->end_time == 0); - - fstFread(&dcheck, 8, 1, xc->f); - /* - * Yosys patch: Fix double endian check for i386 targets built in modern gcc - */ - xc->double_endian_match = (dcheck == (double)FST_DOUBLE_ENDTEST); - if(!xc->double_endian_match) - { - union { - unsigned char rvs_buf[8]; - double d; - } vu; - - unsigned char *dcheck_alias = (unsigned char *)&dcheck; - int rvs_idx; - - for(rvs_idx=0;rvs_idx<8;rvs_idx++) - { - vu.rvs_buf[rvs_idx] = dcheck_alias[7-rvs_idx]; - } - if(vu.d != FST_DOUBLE_ENDTEST) - { - break; /* either corrupt file or wrong architecture (offset +33 also functions as matchword) */ - } - } - - hdr_seen = 1; - - xc->mem_used_by_writer = fstReaderUint64(xc->f); - xc->scope_count = fstReaderUint64(xc->f); - xc->var_count = fstReaderUint64(xc->f); - xc->maxhandle = fstReaderUint64(xc->f); - xc->num_alias = xc->var_count - xc->maxhandle; - xc->vc_section_count = fstReaderUint64(xc->f); - ch = fgetc(xc->f); - xc->timescale = (signed char)ch; - fstFread(xc->version, FST_HDR_SIM_VERSION_SIZE, 1, xc->f); - xc->version[FST_HDR_SIM_VERSION_SIZE] = 0; - fstFread(xc->date, FST_HDR_DATE_SIZE, 1, xc->f); - xc->date[FST_HDR_DATE_SIZE] = 0; - ch = fgetc(xc->f); - xc->filetype = (unsigned char)ch; - xc->timezero = fstReaderUint64(xc->f); - } - } - else if((sectype == FST_BL_VCDATA) || (sectype == FST_BL_VCDATA_DYN_ALIAS) || (sectype == FST_BL_VCDATA_DYN_ALIAS2)) - { - if(hdr_incomplete) - { - uint64_t bt = fstReaderUint64(xc->f); - xc->end_time = fstReaderUint64(xc->f); - - if(!vc_section_count_actual) { xc->start_time = bt; } - } - - vc_section_count_actual++; - } - else if(sectype == FST_BL_GEOM) - { - if(!hdr_incomplete) - { - uint64_t clen = seclen - 24; - uint64_t uclen = fstReaderUint64(xc->f); - unsigned char *ucdata = (unsigned char *)malloc(uclen); - unsigned char *pnt = ucdata; - unsigned int i; - - xc->contains_geom_section = 1; - xc->maxhandle = fstReaderUint64(xc->f); - xc->longest_signal_value_len = 32; /* arbitrarily set at 32...this is much longer than an expanded double */ - - free(xc->process_mask); - xc->process_mask = (unsigned char *)calloc(1, (xc->maxhandle+7)/8); - - if(clen != uclen) - { - unsigned char *cdata = (unsigned char *)malloc(clen); - unsigned long destlen = uclen; - unsigned long sourcelen = clen; - int rc; - - fstFread(cdata, clen, 1, xc->f); - rc = uncompress(ucdata, &destlen, cdata, sourcelen); - - if(rc != Z_OK) - { - fprintf(stderr, FST_APIMESS "fstReaderInit(), geom uncompress rc = %d, exiting.\n", rc); - exit(255); - } - - free(cdata); - } - else - { - fstFread(ucdata, uclen, 1, xc->f); - } - - free(xc->signal_lens); - xc->signal_lens = (uint32_t *)malloc(sizeof(uint32_t) * xc->maxhandle); - free(xc->signal_typs); - xc->signal_typs = (unsigned char *)malloc(sizeof(unsigned char) * xc->maxhandle); - - for(i=0;imaxhandle;i++) - { - int skiplen; - uint64_t val = fstGetVarint32(pnt, &skiplen); - - pnt += skiplen; - - if(val) - { - xc->signal_lens[i] = (val != 0xFFFFFFFF) ? val : 0; - xc->signal_typs[i] = FST_VT_VCD_WIRE; - if(xc->signal_lens[i] > xc->longest_signal_value_len) - { - xc->longest_signal_value_len = xc->signal_lens[i]; - } - } - else - { - xc->signal_lens[i] = 8; /* backpatch in real */ - xc->signal_typs[i] = FST_VT_VCD_REAL; - /* xc->longest_signal_value_len handled above by overly large init size */ - } - } - - free(xc->temp_signal_value_buf); - xc->temp_signal_value_buf = (unsigned char *)malloc(xc->longest_signal_value_len + 1); - - free(ucdata); - } - } - else if(sectype == FST_BL_HIER) - { - xc->contains_hier_section = 1; - xc->hier_pos = ftello(xc->f); - } - else if(sectype == FST_BL_HIER_LZ4DUO) - { - xc->contains_hier_section_lz4 = 1; - xc->contains_hier_section_lz4duo = 1; - xc->hier_pos = ftello(xc->f); - } - else if(sectype == FST_BL_HIER_LZ4) - { - xc->contains_hier_section_lz4 = 1; - xc->hier_pos = ftello(xc->f); - } - else if(sectype == FST_BL_BLACKOUT) - { - uint32_t i; - uint64_t cur_bl = 0; - uint64_t delta; - - xc->num_blackouts = fstReaderVarint32(xc->f); - free(xc->blackout_times); - xc->blackout_times = (uint64_t *)calloc(xc->num_blackouts, sizeof(uint64_t)); - free(xc->blackout_activity); - xc->blackout_activity = (unsigned char *)calloc(xc->num_blackouts, sizeof(unsigned char)); - - for(i=0;inum_blackouts;i++) - { - xc->blackout_activity[i] = fgetc(xc->f) != 0; - delta = fstReaderVarint64(xc->f); - cur_bl += delta; - xc->blackout_times[i] = cur_bl; - } - } - - blkpos += seclen; - if(!hdr_seen) break; + if (!vc_section_count_actual) { + xc->start_time = bt; + } } - if(hdr_seen) - { - if(xc->vc_section_count != vc_section_count_actual) - { - xc->vc_section_count = vc_section_count_actual; + vc_section_count_actual++; + } else if (sectype == FST_BL_GEOM) { + if (!hdr_incomplete) { + uint64_t clen = seclen - 24; + uint64_t uclen = fstReaderUint64(xc->f); + unsigned char *ucdata = (unsigned char *)malloc(uclen); + unsigned char *pnt = ucdata; + unsigned int i; + + xc->contains_geom_section = 1; + xc->maxhandle = fstReaderUint64(xc->f); + xc->longest_signal_value_len = 32; /* arbitrarily set at 32...this is much + longer than an expanded double */ + + free(xc->process_mask); + xc->process_mask = (unsigned char *)calloc(1, (xc->maxhandle + 7) / 8); + + if (clen != uclen) { + unsigned char *cdata = (unsigned char *)malloc(clen); + unsigned long destlen = uclen; + unsigned long sourcelen = clen; + int rc; + + fstFread(cdata, clen, 1, xc->f); + rc = uncompress(ucdata, &destlen, cdata, sourcelen); + + if (rc != Z_OK) { + fprintf(stderr, + FST_APIMESS + "fstReaderInit(), geom uncompress rc = %d, exiting.\n", + rc); + exit(255); } - if(!xc->contains_geom_section) - { - fstReaderProcessHier(xc, NULL); /* recreate signal_lens/signal_typs info */ + free(cdata); + } else { + fstFread(ucdata, uclen, 1, xc->f); + } + + free(xc->signal_lens); + xc->signal_lens = (uint32_t *)malloc(sizeof(uint32_t) * xc->maxhandle); + free(xc->signal_typs); + xc->signal_typs = + (unsigned char *)malloc(sizeof(unsigned char) * xc->maxhandle); + + for (i = 0; i < xc->maxhandle; i++) { + int skiplen; + uint64_t val = fstGetVarint32(pnt, &skiplen); + + pnt += skiplen; + + if (val) { + xc->signal_lens[i] = (val != 0xFFFFFFFF) ? val : 0; + xc->signal_typs[i] = FST_VT_VCD_WIRE; + if (xc->signal_lens[i] > xc->longest_signal_value_len) { + xc->longest_signal_value_len = xc->signal_lens[i]; + } + } else { + xc->signal_lens[i] = 8; /* backpatch in real */ + xc->signal_typs[i] = FST_VT_VCD_REAL; + /* xc->longest_signal_value_len handled above by overly large init size + */ } + } + + free(xc->temp_signal_value_buf); + xc->temp_signal_value_buf = + (unsigned char *)malloc(xc->longest_signal_value_len + 1); + + free(ucdata); } + } else if (sectype == FST_BL_HIER) { + xc->contains_hier_section = 1; + xc->hier_pos = ftello(xc->f); + } else if (sectype == FST_BL_HIER_LZ4DUO) { + xc->contains_hier_section_lz4 = 1; + xc->contains_hier_section_lz4duo = 1; + xc->hier_pos = ftello(xc->f); + } else if (sectype == FST_BL_HIER_LZ4) { + xc->contains_hier_section_lz4 = 1; + xc->hier_pos = ftello(xc->f); + } else if (sectype == FST_BL_BLACKOUT) { + uint32_t i; + uint64_t cur_bl = 0; + uint64_t delta; + + xc->num_blackouts = fstReaderVarint32(xc->f); + free(xc->blackout_times); + xc->blackout_times = (uint64_t *)calloc(xc->num_blackouts, sizeof(uint64_t)); + free(xc->blackout_activity); + xc->blackout_activity = + (unsigned char *)calloc(xc->num_blackouts, sizeof(unsigned char)); + + for (i = 0; i < xc->num_blackouts; i++) { + xc->blackout_activity[i] = fgetc(xc->f) != 0; + delta = fstReaderVarint64(xc->f); + cur_bl += delta; + xc->blackout_times[i] = cur_bl; + } + } + + blkpos += seclen; + if (!hdr_seen) + break; } -return(hdr_seen); + if (hdr_seen) { + if (xc->vc_section_count != vc_section_count_actual) { + xc->vc_section_count = vc_section_count_actual; + } + + if (!xc->contains_geom_section) { + fstReaderProcessHier(xc, NULL); /* recreate signal_lens/signal_typs info */ + } + } + } + + 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); + 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")))) - { + if ((!nam) || (!(xc->f = fopen(nam, "rb")))) { free(xc); - xc=NULL; - } - else - { + xc = NULL; + } else { int flen = strlen(nam); char *hf = (char *)calloc(1, flen + 6); int rc; #if defined(FST_UNBUFFERED_IO) - setvbuf(xc->f, (char *)NULL, _IONBF, 0); /* keeps gzip from acting weird in tandem with fopen */ + setvbuf(xc->f, + (char *)NULL, + _IONBF, + 0); /* keeps gzip from acting weird in tandem with fopen */ #endif memcpy(hf, nam, flen); @@ -4947,147 +4755,159 @@ if((!nam)||(!(xc->f=fopen(nam, "rb")))) xc->filename = strdup(nam); rc = fstReaderInit(xc); - if((rc) && (xc->vc_section_count) && (xc->maxhandle) && ((xc->fh)||(xc->contains_hier_section||(xc->contains_hier_section_lz4)))) - { - /* more init */ - xc->do_rewind = 1; - } - else - { - fstReaderClose(xc); - xc = NULL; - } + if ((rc) && (xc->vc_section_count) && (xc->maxhandle) && + ((xc->fh) || (xc->contains_hier_section || (xc->contains_hier_section_lz4)))) { + /* more init */ + xc->do_rewind = 1; + } else if (!rc) { + fstReaderClose(xc); + xc = NULL; } + } -return(xc); + 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; - free(xc->rvat_frame_data); xc->rvat_frame_data = NULL; - free(xc->rvat_time_table); xc->rvat_time_table = NULL; - free(xc->rvat_chain_table); xc->rvat_chain_table = NULL; - free(xc->rvat_chain_table_lengths); xc->rvat_chain_table_lengths = NULL; + if (xc) { + free(xc->rvat_chain_mem); + xc->rvat_chain_mem = NULL; + free(xc->rvat_frame_data); + xc->rvat_frame_data = NULL; + free(xc->rvat_time_table); + xc->rvat_time_table = NULL; + free(xc->rvat_chain_table); + xc->rvat_chain_table = NULL; + free(xc->rvat_chain_table_lengths); + xc->rvat_chain_table_lengths = NULL; xc->rvat_data_valid = 0; - } + } } - -void fstReaderClose(void *ctx) +void fstReaderClose(fstReaderContext *xc) { -struct fstReaderContext *xc = (struct fstReaderContext *)ctx; - -if(xc) - { + if (xc) { fstReaderDeallocateScopeData(xc); fstReaderDeallocateRvatData(xc); - free(xc->rvat_sig_offs); xc->rvat_sig_offs = NULL; + free(xc->rvat_sig_offs); + xc->rvat_sig_offs = NULL; - free(xc->process_mask); xc->process_mask = NULL; - free(xc->blackout_times); xc->blackout_times = NULL; - free(xc->blackout_activity); xc->blackout_activity = NULL; - free(xc->temp_signal_value_buf); xc->temp_signal_value_buf = NULL; - free(xc->signal_typs); xc->signal_typs = NULL; - free(xc->signal_lens); xc->signal_lens = NULL; - free(xc->filename); xc->filename = NULL; - free(xc->str_scope_attr); xc->str_scope_attr = NULL; + free(xc->process_mask); + xc->process_mask = NULL; + free(xc->blackout_times); + xc->blackout_times = NULL; + free(xc->blackout_activity); + xc->blackout_activity = NULL; + free(xc->temp_signal_value_buf); + xc->temp_signal_value_buf = NULL; + free(xc->signal_typs); + xc->signal_typs = NULL; + free(xc->signal_lens); + xc->signal_lens = NULL; + free(xc->filename); + xc->filename = NULL; + free(xc->str_scope_attr); + xc->str_scope_attr = NULL; - if(xc->fh) - { - tmpfile_close(&xc->fh, &xc->fh_nam); - } + if (xc->fh) { + tmpfile_close(&xc->fh, &xc->fh_nam); + } - if(xc->f) - { - tmpfile_close(&xc->f, &xc->f_nam); - if(xc->filename_unpacked) - { - unlink(xc->filename_unpacked); - free(xc->filename_unpacked); - } - } + if (xc->f) { + tmpfile_close(&xc->f, &xc->f_nam); + if (xc->filename_unpacked) { + unlink(xc->filename_unpacked); + free(xc->filename_unpacked); + } + } free(xc); - } + } } - /* * read processing */ /* normal read which re-interleaves the value change data */ -int fstReaderIterBlocks(void *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 *fv) +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 *fv) { -return(fstReaderIterBlocks2(ctx, value_change_callback, NULL, user_callback_data_pointer, fv)); + return (fstReaderIterBlocks2(ctx, value_change_callback, NULL, user_callback_data_pointer, fv)); } - -int fstReaderIterBlocks2(void *ctx, - void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value), - void (*value_change_callback_varlen)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value, uint32_t len), - void *user_callback_data_pointer, FILE *fv) +int fstReaderIterBlocks2(fstReaderContext *ctx, + void (*value_change_callback)(void *user_callback_data_pointer, + uint64_t time, + fstHandle facidx, + const unsigned char *value), + void (*value_change_callback_varlen)(void *user_callback_data_pointer, + uint64_t time, + fstHandle facidx, + const unsigned char *value, + uint32_t len), + void *user_callback_data_pointer, + FILE *fv) { -struct fstReaderContext *xc = (struct fstReaderContext *)ctx; + struct fstReaderContext *xc = (struct fstReaderContext *)ctx; -uint64_t previous_time = UINT64_MAX; -uint64_t *time_table = NULL; -uint64_t tsec_nitems; -unsigned int secnum = 0; -int blocks_skipped = 0; -fst_off_t blkpos = 0; -uint64_t seclen, beg_tim; -uint64_t end_tim; -uint64_t frame_uclen, frame_clen, frame_maxhandle, vc_maxhandle; -fst_off_t vc_start; -fst_off_t indx_pntr, indx_pos; -fst_off_t *chain_table = NULL; -uint32_t *chain_table_lengths = NULL; -unsigned char *chain_cmem; -unsigned char *pnt; -long chain_clen; -fstHandle idx, pidx=0, i; -uint64_t pval; -uint64_t vc_maxhandle_largest = 0; -uint64_t tsec_uclen = 0, tsec_clen = 0; -int sectype; -uint64_t mem_required_for_traversal; -unsigned char *mem_for_traversal = NULL; -uint32_t traversal_mem_offs; -uint32_t *scatterptr, *headptr, *length_remaining; -uint32_t cur_blackout = 0; -int packtype; -unsigned char *mc_mem = NULL; -uint32_t mc_mem_len; /* corresponds to largest value encountered in chain_table_lengths[i] */ -int dumpvars_state = 0; + uint64_t previous_time = UINT64_MAX; + uint64_t *time_table = NULL; + uint64_t tsec_nitems; + unsigned int secnum = 0; + int blocks_skipped = 0; + fst_off_t blkpos = 0; + uint64_t seclen, beg_tim; + uint64_t end_tim; + uint64_t frame_uclen, frame_clen, frame_maxhandle, vc_maxhandle; + fst_off_t vc_start; + fst_off_t indx_pntr, indx_pos; + fst_off_t *chain_table = NULL; + uint32_t *chain_table_lengths = NULL; + unsigned char *chain_cmem; + unsigned char *pnt; + long chain_clen; + fstHandle idx, pidx = 0, i; + uint64_t pval; + uint64_t vc_maxhandle_largest = 0; + uint64_t tsec_uclen = 0, tsec_clen = 0; + int sectype; + uint64_t mem_required_for_traversal; + unsigned char *mem_for_traversal = NULL; + uint32_t traversal_mem_offs; + uint32_t *scatterptr, *headptr, *length_remaining; + uint32_t cur_blackout = 0; + int packtype; + unsigned char *mc_mem = NULL; + uint32_t mc_mem_len; /* corresponds to largest value encountered in chain_table_lengths[i] */ + int dumpvars_state = 0; -if(!xc) return(0); + if (!xc) + return (0); -scatterptr = (uint32_t *)calloc(xc->maxhandle, sizeof(uint32_t)); -headptr = (uint32_t *)calloc(xc->maxhandle, sizeof(uint32_t)); -length_remaining = (uint32_t *)calloc(xc->maxhandle, sizeof(uint32_t)); + scatterptr = (uint32_t *)calloc(xc->maxhandle, sizeof(uint32_t)); + headptr = (uint32_t *)calloc(xc->maxhandle, sizeof(uint32_t)); + length_remaining = (uint32_t *)calloc(xc->maxhandle, sizeof(uint32_t)); -if(fv) - { + if (fv) { #ifndef FST_WRITEX_DISABLE fflush(fv); - setvbuf(fv, (char *) NULL, _IONBF, 0); /* even buffered IO is slow so disable it and use our own routines that don't need seeking */ + setvbuf(fv, (char *)NULL, _IONBF, 0); /* even buffered IO is slow so disable it and use our + own routines that don't need seeking */ xc->writex_fd = fileno(fv); #endif - } + } -for(;;) - { + for (;;) { uint32_t *tc_head = NULL; - uint32_t tc_head_items = 0; + uint32_t tc_head_items = 0; traversal_mem_offs = 0; fstReaderFseeko(xc, xc->f, blkpos, SEEK_SET); @@ -5095,372 +4915,364 @@ for(;;) sectype = fgetc(xc->f); seclen = fstReaderUint64(xc->f); - if((sectype == EOF) || (sectype == FST_BL_SKIP)) - { + if ((sectype == EOF) || (sectype == FST_BL_SKIP)) { #ifdef FST_DEBUG - fprintf(stderr, FST_APIMESS "<< EOF >>\n"); + fprintf(stderr, FST_APIMESS "<< EOF >>\n"); #endif - break; - } + break; + } blkpos++; - if((sectype != FST_BL_VCDATA) && (sectype != FST_BL_VCDATA_DYN_ALIAS) && (sectype != FST_BL_VCDATA_DYN_ALIAS2)) - { - blkpos += seclen; - continue; - } + if ((sectype != FST_BL_VCDATA) && (sectype != FST_BL_VCDATA_DYN_ALIAS) && + (sectype != FST_BL_VCDATA_DYN_ALIAS2)) { + blkpos += seclen; + continue; + } - if(!seclen) break; + if (!seclen) + break; beg_tim = fstReaderUint64(xc->f); end_tim = fstReaderUint64(xc->f); - if(xc->limit_range_valid) - { - if(end_tim < xc->limit_range_start) - { - blocks_skipped++; - blkpos += seclen; - continue; - } + if (xc->limit_range_valid) { + if (end_tim < xc->limit_range_start) { + blocks_skipped++; + blkpos += seclen; + continue; + } - if(beg_tim > xc->limit_range_end) /* likely the compare in for(i=0;i xc->limit_range_end) /* likely the compare in for(i=0;if) + 66; /* add in potential fastlz overhead */ + mem_required_for_traversal = + fstReaderUint64(xc->f) + 66; /* add in potential fastlz overhead */ mem_for_traversal = (unsigned char *)malloc(mem_required_for_traversal); #ifdef FST_DEBUG - fprintf(stderr, FST_APIMESS "sec: %u seclen: %d begtim: %d endtim: %d\n", - secnum, (int)seclen, (int)beg_tim, (int)end_tim); - fprintf(stderr, FST_APIMESS "mem_required_for_traversal: %d\n", (int)mem_required_for_traversal-66); + fprintf(stderr, + FST_APIMESS "sec: %u seclen: %d begtim: %d endtim: %d\n", + secnum, + (int)seclen, + (int)beg_tim, + (int)end_tim); + fprintf(stderr, + FST_APIMESS "mem_required_for_traversal: %d\n", + (int)mem_required_for_traversal - 66); #endif /* process time block */ { - unsigned char *ucdata; - unsigned char *cdata; - unsigned long destlen /* = tsec_uclen */; /* scan-build */ - unsigned long sourcelen /*= tsec_clen */; /* scan-build */ - int rc; - unsigned char *tpnt; - uint64_t tpval; - unsigned int ti; + unsigned char *ucdata; + unsigned char *cdata; + unsigned long destlen /* = tsec_uclen */; /* scan-build */ + unsigned long sourcelen /*= tsec_clen */; /* scan-build */ + int rc; + unsigned char *tpnt; + uint64_t tpval; + unsigned int ti; - if(fstReaderFseeko(xc, xc->f, blkpos + seclen - 24, SEEK_SET) != 0) break; - tsec_uclen = fstReaderUint64(xc->f); - tsec_clen = fstReaderUint64(xc->f); - tsec_nitems = fstReaderUint64(xc->f); + if (fstReaderFseeko(xc, xc->f, blkpos + seclen - 24, SEEK_SET) != 0) + break; + tsec_uclen = fstReaderUint64(xc->f); + tsec_clen = fstReaderUint64(xc->f); + tsec_nitems = fstReaderUint64(xc->f); #ifdef FST_DEBUG - fprintf(stderr, FST_APIMESS "time section unc: %d, com: %d (%d items)\n", - (int)tsec_uclen, (int)tsec_clen, (int)tsec_nitems); + fprintf(stderr, + FST_APIMESS "time section unc: %d, com: %d (%d items)\n", + (int)tsec_uclen, + (int)tsec_clen, + (int)tsec_nitems); #endif - if(tsec_clen > seclen) break; /* corrupted tsec_clen: by definition it can't be larger than size of section */ - ucdata = (unsigned char *)malloc(tsec_uclen); - if(!ucdata) break; /* malloc fail as tsec_uclen out of range from corrupted file */ - destlen = tsec_uclen; - sourcelen = tsec_clen; + if (tsec_clen > seclen) + break; /* corrupted tsec_clen: by definition it can't be larger than size of section + */ + ucdata = (unsigned char *)malloc(tsec_uclen); + if (!ucdata) + break; /* malloc fail as tsec_uclen out of range from corrupted file */ + destlen = tsec_uclen; + sourcelen = tsec_clen; - fstReaderFseeko(xc, xc->f, -24 - ((fst_off_t)tsec_clen), SEEK_CUR); + fstReaderFseeko(xc, xc->f, -24 - ((fst_off_t)tsec_clen), SEEK_CUR); - if(tsec_uclen != tsec_clen) - { + if (tsec_uclen != tsec_clen) { cdata = (unsigned char *)malloc(tsec_clen); fstFread(cdata, tsec_clen, 1, xc->f); rc = uncompress(ucdata, &destlen, cdata, sourcelen); - if(rc != Z_OK) - { - fprintf(stderr, FST_APIMESS "fstReaderIterBlocks2(), tsec uncompress rc = %d, exiting.\n", rc); - exit(255); - } + if (rc != Z_OK) { + fprintf(stderr, + FST_APIMESS + "fstReaderIterBlocks2(), tsec uncompress rc = %d, exiting.\n", + rc); + exit(255); + } free(cdata); - } - else - { + } else { fstFread(ucdata, tsec_uclen, 1, xc->f); + } + + free(time_table); + + if (sizeof(size_t) < sizeof(uint64_t)) { + /* TALOS-2023-1792 for 32b overflow */ + uint64_t chk_64 = tsec_nitems * sizeof(uint64_t); + size_t chk_32 = ((size_t)tsec_nitems) * sizeof(uint64_t); + if (chk_64 != chk_32) + chk_report_abort("TALOS-2023-1792"); + } else { + uint64_t chk_64 = tsec_nitems * sizeof(uint64_t); + if ((chk_64 / sizeof(uint64_t)) != tsec_nitems) { + chk_report_abort("TALOS-2023-1792"); } - - free(time_table); - - if(sizeof(size_t) < sizeof(uint64_t)) - { - /* TALOS-2023-1792 for 32b overflow */ - uint64_t chk_64 = tsec_nitems * sizeof(uint64_t); - size_t chk_32 = ((size_t)tsec_nitems) * sizeof(uint64_t); - if(chk_64 != chk_32) chk_report_abort("TALOS-2023-1792"); - } - else - { - uint64_t chk_64 = tsec_nitems * sizeof(uint64_t); - if((chk_64/sizeof(uint64_t)) != tsec_nitems) - { - chk_report_abort("TALOS-2023-1792"); - } - } - time_table = (uint64_t *)calloc(tsec_nitems, sizeof(uint64_t)); - tpnt = ucdata; - tpval = 0; - for(ti=0;tif, blkpos+32, SEEK_SET); + fstReaderFseeko(xc, xc->f, blkpos + 32, SEEK_SET); frame_uclen = fstReaderVarint64(xc->f); frame_clen = fstReaderVarint64(xc->f); frame_maxhandle = fstReaderVarint64(xc->f); - if(secnum == 0) - { - if((beg_tim != time_table[0]) || (blocks_skipped)) - { - unsigned char *mu = (unsigned char *)malloc(frame_uclen); - uint32_t sig_offs = 0; + if (secnum == 0) { + if ((beg_tim != time_table[0]) || (blocks_skipped)) { + unsigned char *mu = (unsigned char *)malloc(frame_uclen); + uint32_t sig_offs = 0; - if(fv) - { - char wx_buf[32]; - int wx_len; + if (fv) { + char wx_buf[32]; + int wx_len; - if(beg_tim) - { - if(dumpvars_state == 1) { wx_len = snprintf(wx_buf, 32, "$end\n"); fstWritex(xc, wx_buf, wx_len); dumpvars_state = 2; } - wx_len = snprintf(wx_buf, 32, "#%" PRIu64 "\n", beg_tim); - fstWritex(xc, wx_buf, wx_len); - if(!dumpvars_state) { wx_len = snprintf(wx_buf, 32, "$dumpvars\n"); fstWritex(xc, wx_buf, wx_len); dumpvars_state = 1; } - } - if((xc->num_blackouts)&&(cur_blackout != xc->num_blackouts)) - { - if(beg_tim == xc->blackout_times[cur_blackout]) - { - wx_len = snprintf(wx_buf, 32, "$dump%s $end\n", (xc->blackout_activity[cur_blackout++]) ? "on" : "off"); - fstWritex(xc, wx_buf, wx_len); - } - } - } - - if(frame_uclen == frame_clen) - { - fstFread(mu, frame_uclen, 1, xc->f); - } - else - { - unsigned char *mc = (unsigned char *)malloc(frame_clen); - int rc; - - unsigned long destlen = frame_uclen; - unsigned long sourcelen = frame_clen; - - fstFread(mc, sourcelen, 1, xc->f); - rc = uncompress(mu, &destlen, mc, sourcelen); - if(rc != Z_OK) - { - fprintf(stderr, FST_APIMESS "fstReaderIterBlocks2(), frame uncompress rc: %d, exiting.\n", rc); - exit(255); - } - free(mc); - } - - - for(idx=0;idxprocess_mask[process_idx]&(1<signal_lens[idx] <= 1) - { - if(xc->signal_lens[idx] == 1) - { - unsigned char val = mu[sig_offs]; - if(value_change_callback) - { - xc->temp_signal_value_buf[0] = val; - xc->temp_signal_value_buf[1] = 0; - value_change_callback(user_callback_data_pointer, beg_tim, idx+1, xc->temp_signal_value_buf); - } - else - { - if(fv) - { - char vcd_id[16]; - - int vcdid_len = fstVcdIDForFwrite(vcd_id+1, idx+1); - vcd_id[0] = val; /* collapse 3 writes into one I/O call */ - vcd_id[vcdid_len + 1] = '\n'; - fstWritex(xc, vcd_id, vcdid_len + 2); - } - } - } - else - { - /* variable-length ("0" length) records have no initial state */ - } - } - else - { - if(xc->signal_typs[idx] != FST_VT_VCD_REAL) - { - if(value_change_callback) - { - if(xc->signal_lens[idx] > xc->longest_signal_value_len) - { - chk_report_abort("TALOS-2023-1797"); - } - memcpy(xc->temp_signal_value_buf, mu+sig_offs, xc->signal_lens[idx]); - xc->temp_signal_value_buf[xc->signal_lens[idx]] = 0; - value_change_callback(user_callback_data_pointer, beg_tim, idx+1, xc->temp_signal_value_buf); - } - else - { - if(fv) - { - char vcd_id[16]; - int vcdid_len = fstVcdIDForFwrite(vcd_id+1, idx+1); - - vcd_id[0] = (xc->signal_typs[idx] != FST_VT_VCD_PORT) ? 'b' : 'p'; - fstWritex(xc, vcd_id, 1); - if((sig_offs + xc->signal_lens[idx]) > frame_uclen) - { - chk_report_abort("TALOS-2023-1793"); - } - fstWritex(xc,mu+sig_offs, xc->signal_lens[idx]); - - vcd_id[0] = ' '; /* collapse 3 writes into one I/O call */ - vcd_id[vcdid_len + 1] = '\n'; - fstWritex(xc, vcd_id, vcdid_len + 2); - } - } - } - else - { - double d; - unsigned char *clone_d; - unsigned char *srcdata = mu+sig_offs; - - if(value_change_callback) - { - if(xc->native_doubles_for_cb) - { - if(xc->double_endian_match) - { - clone_d = srcdata; - } - else - { - int j; - - clone_d = (unsigned char *)&d; - for(j=0;j<8;j++) - { - clone_d[j] = srcdata[7-j]; - } - } - value_change_callback(user_callback_data_pointer, beg_tim, idx+1, clone_d); - } - else - { - clone_d = (unsigned char *)&d; - if(xc->double_endian_match) - { - memcpy(clone_d, srcdata, 8); - } - else - { - int j; - - for(j=0;j<8;j++) - { - clone_d[j] = srcdata[7-j]; - } - } - snprintf((char *)xc->temp_signal_value_buf, xc->longest_signal_value_len + 1, "%.16g", d); - value_change_callback(user_callback_data_pointer, beg_tim, idx+1, xc->temp_signal_value_buf); - } - } - else - { - if(fv) - { - char vcdid_buf[16]; - char wx_buf[64]; - int wx_len; - - clone_d = (unsigned char *)&d; - if(xc->double_endian_match) - { - memcpy(clone_d, srcdata, 8); - } - else - { - int j; - - for(j=0;j<8;j++) - { - clone_d[j] = srcdata[7-j]; - } - } - - fstVcdID(vcdid_buf, idx+1); - wx_len = snprintf(wx_buf, 64, "r%.16g %s\n", d, vcdid_buf); - fstWritex(xc, wx_buf, wx_len); - } - } - } - } - } - - sig_offs += xc->signal_lens[idx]; - } - - free(mu); - fstReaderFseeko(xc, xc->f, -((fst_off_t)frame_clen), SEEK_CUR); + if (beg_tim) { + if (dumpvars_state == 1) { + wx_len = snprintf(wx_buf, 32, "$end\n"); + fstWritex(xc, wx_buf, wx_len); + dumpvars_state = 2; } + wx_len = snprintf(wx_buf, 32, "#%" PRIu64 "\n", beg_tim); + fstWritex(xc, wx_buf, wx_len); + if (!dumpvars_state) { + wx_len = snprintf(wx_buf, 32, "$dumpvars\n"); + fstWritex(xc, wx_buf, wx_len); + dumpvars_state = 1; + } + } + if ((xc->num_blackouts) && (cur_blackout != xc->num_blackouts)) { + if (beg_tim == xc->blackout_times[cur_blackout]) { + wx_len = + snprintf(wx_buf, + 32, + "$dump%s $end\n", + (xc->blackout_activity[cur_blackout++]) ? "on" : "off"); + fstWritex(xc, wx_buf, wx_len); + } + } } + if (frame_uclen == frame_clen) { + fstFread(mu, frame_uclen, 1, xc->f); + } else { + unsigned char *mc = (unsigned char *)malloc(frame_clen); + int rc; + + unsigned long destlen = frame_uclen; + unsigned long sourcelen = frame_clen; + + fstFread(mc, sourcelen, 1, xc->f); + rc = uncompress(mu, &destlen, mc, sourcelen); + if (rc != Z_OK) { + fprintf(stderr, + FST_APIMESS + "fstReaderIterBlocks2(), frame uncompress rc: %d, exiting.\n", + rc); + exit(255); + } + free(mc); + } + + for (idx = 0; idx < frame_maxhandle; idx++) { + int process_idx = idx / 8; + int process_bit = idx & 7; + + if (xc->process_mask[process_idx] & (1 << process_bit)) { + if (xc->signal_lens[idx] <= 1) { + if (xc->signal_lens[idx] == 1) { + unsigned char val = mu[sig_offs]; + if (value_change_callback) { + xc->temp_signal_value_buf[0] = val; + xc->temp_signal_value_buf[1] = 0; + value_change_callback(user_callback_data_pointer, + beg_tim, + idx + 1, + xc->temp_signal_value_buf); + } else { + if (fv) { + char vcd_id[16]; + + int vcdid_len = fstVcdIDForFwrite(vcd_id + 1, idx + 1); + vcd_id[0] = val; /* collapse 3 writes into one I/O call */ + vcd_id[vcdid_len + 1] = '\n'; + fstWritex(xc, vcd_id, vcdid_len + 2); + } + } + } else { + /* variable-length ("0" length) records have no initial state */ + } + } else { + if (xc->signal_typs[idx] != FST_VT_VCD_REAL) { + if (value_change_callback) { + if (xc->signal_lens[idx] > xc->longest_signal_value_len) { + chk_report_abort("TALOS-2023-1797"); + } + memcpy(xc->temp_signal_value_buf, + mu + sig_offs, + xc->signal_lens[idx]); + xc->temp_signal_value_buf[xc->signal_lens[idx]] = 0; + value_change_callback(user_callback_data_pointer, + beg_tim, + idx + 1, + xc->temp_signal_value_buf); + } else { + if (fv) { + char vcd_id[16]; + int vcdid_len = fstVcdIDForFwrite(vcd_id + 1, idx + 1); + + vcd_id[0] = + (xc->signal_typs[idx] != FST_VT_VCD_PORT) ? 'b' : 'p'; + fstWritex(xc, vcd_id, 1); + if ((sig_offs + xc->signal_lens[idx]) > frame_uclen) { + chk_report_abort("TALOS-2023-1793"); + } + fstWritex(xc, mu + sig_offs, xc->signal_lens[idx]); + + vcd_id[0] = ' '; /* collapse 3 writes into one I/O call */ + vcd_id[vcdid_len + 1] = '\n'; + fstWritex(xc, vcd_id, vcdid_len + 2); + } + } + } else { + double d; + unsigned char *clone_d; + unsigned char *srcdata = mu + sig_offs; + + if (value_change_callback) { + if (xc->native_doubles_for_cb) { + if (xc->double_endian_match) { + clone_d = srcdata; + } else { + int j; + + clone_d = (unsigned char *)&d; + for (j = 0; j < 8; j++) { + clone_d[j] = srcdata[7 - j]; + } + } + value_change_callback(user_callback_data_pointer, + beg_tim, + idx + 1, + clone_d); + } else { + clone_d = (unsigned char *)&d; + if (xc->double_endian_match) { + memcpy(clone_d, srcdata, 8); + } else { + int j; + + for (j = 0; j < 8; j++) { + clone_d[j] = srcdata[7 - j]; + } + } + snprintf((char *)xc->temp_signal_value_buf, + xc->longest_signal_value_len + 1, + "%.16g", + d); + value_change_callback(user_callback_data_pointer, + beg_tim, + idx + 1, + xc->temp_signal_value_buf); + } + } else { + if (fv) { + char vcdid_buf[16]; + char wx_buf[64]; + int wx_len; + + clone_d = (unsigned char *)&d; + if (xc->double_endian_match) { + memcpy(clone_d, srcdata, 8); + } else { + int j; + + for (j = 0; j < 8; j++) { + clone_d[j] = srcdata[7 - j]; + } + } + + fstVcdID(vcdid_buf, idx + 1); + wx_len = snprintf(wx_buf, 64, "r%.16g %s\n", d, vcdid_buf); + fstWritex(xc, wx_buf, wx_len); + } + } + } + } + } + + sig_offs += xc->signal_lens[idx]; + } + + free(mu); + fstReaderFseeko(xc, xc->f, -((fst_off_t)frame_clen), SEEK_CUR); + } + } + fstReaderFseeko(xc, xc->f, (fst_off_t)frame_clen, SEEK_CUR); /* skip past compressed data */ vc_maxhandle = fstReaderVarint64(xc->f); - vc_start = ftello(xc->f); /* points to '!' character */ + vc_start = ftello(xc->f); /* points to '!' character */ packtype = fgetc(xc->f); #ifdef FST_DEBUG - fprintf(stderr, FST_APIMESS "frame_uclen: %d, frame_clen: %d, frame_maxhandle: %d\n", - (int)frame_uclen, (int)frame_clen, (int)frame_maxhandle); - fprintf(stderr, FST_APIMESS "vc_maxhandle: %d, packtype: %c\n", (int)vc_maxhandle, packtype); + fprintf(stderr, + FST_APIMESS "frame_uclen: %d, frame_clen: %d, frame_maxhandle: %d\n", + (int)frame_uclen, + (int)frame_clen, + (int)frame_maxhandle); + fprintf(stderr, + FST_APIMESS "vc_maxhandle: %d, packtype: %c\n", + (int)vc_maxhandle, + packtype); #endif - indx_pntr = blkpos + seclen - 24 -tsec_clen -8; + indx_pntr = blkpos + seclen - 24 - tsec_clen - 8; fstReaderFseeko(xc, xc->f, indx_pntr, SEEK_SET); chain_clen = fstReaderUint64(xc->f); indx_pos = indx_pntr - chain_clen; @@ -5468,168 +5280,151 @@ for(;;) fprintf(stderr, FST_APIMESS "indx_pos: %d (%d bytes)\n", (int)indx_pos, (int)chain_clen); #endif chain_cmem = (unsigned char *)malloc(chain_clen); - if(!chain_cmem) goto block_err; + if (!chain_cmem) + goto block_err; fstReaderFseeko(xc, xc->f, indx_pos, SEEK_SET); fstFread(chain_cmem, chain_clen, 1, xc->f); - if(vc_maxhandle > vc_maxhandle_largest) - { - free(chain_table); - free(chain_table_lengths); + if (vc_maxhandle > vc_maxhandle_largest) { + free(chain_table); + free(chain_table_lengths); - vc_maxhandle_largest = vc_maxhandle; + vc_maxhandle_largest = vc_maxhandle; - if(!(vc_maxhandle+1)) - { - chk_report_abort("TALOS-2023-1798"); - } + if (!(vc_maxhandle + 1)) { + chk_report_abort("TALOS-2023-1798"); + } - if(sizeof(size_t) < sizeof(uint64_t)) - { - /* TALOS-2023-1798 for 32b overflow */ - uint64_t chk_64 = (vc_maxhandle+1) * sizeof(fst_off_t); - size_t chk_32 = ((size_t)(vc_maxhandle+1)) * sizeof(fst_off_t); - if(chk_64 != chk_32) chk_report_abort("TALOS-2023-1798"); - } - else - { - uint64_t chk_64 = (vc_maxhandle+1) * sizeof(fst_off_t); - if((chk_64/sizeof(fst_off_t)) != (vc_maxhandle+1)) - { - chk_report_abort("TALOS-2023-1798"); - } - } - chain_table = (fst_off_t *)calloc((vc_maxhandle+1), sizeof(fst_off_t)); - - if(sizeof(size_t) < sizeof(uint64_t)) - { - /* TALOS-2023-1798 for 32b overflow */ - uint64_t chk_64 = (vc_maxhandle+1) * sizeof(uint32_t); - size_t chk_32 = ((size_t)(vc_maxhandle+1)) * sizeof(uint32_t); - if(chk_64 != chk_32) chk_report_abort("TALOS-2023-1798"); - } - else - { - uint64_t chk_64 = (vc_maxhandle+1) * sizeof(uint32_t); - if((chk_64/sizeof(uint32_t)) != (vc_maxhandle+1)) - { - chk_report_abort("TALOS-2023-1798"); - } - } - chain_table_lengths = (uint32_t *)calloc((vc_maxhandle+1), sizeof(uint32_t)); + if (sizeof(size_t) < sizeof(uint64_t)) { + /* TALOS-2023-1798 for 32b overflow */ + uint64_t chk_64 = (vc_maxhandle + 1) * sizeof(fst_off_t); + size_t chk_32 = ((size_t)(vc_maxhandle + 1)) * sizeof(fst_off_t); + if (chk_64 != chk_32) + chk_report_abort("TALOS-2023-1798"); + } else { + uint64_t chk_64 = (vc_maxhandle + 1) * sizeof(fst_off_t); + if ((chk_64 / sizeof(fst_off_t)) != (vc_maxhandle + 1)) { + chk_report_abort("TALOS-2023-1798"); } + } + chain_table = (fst_off_t *)calloc((vc_maxhandle + 1), sizeof(fst_off_t)); - if(!chain_table || !chain_table_lengths) goto block_err; + if (sizeof(size_t) < sizeof(uint64_t)) { + /* TALOS-2023-1798 for 32b overflow */ + uint64_t chk_64 = (vc_maxhandle + 1) * sizeof(uint32_t); + size_t chk_32 = ((size_t)(vc_maxhandle + 1)) * sizeof(uint32_t); + if (chk_64 != chk_32) + chk_report_abort("TALOS-2023-1798"); + } else { + uint64_t chk_64 = (vc_maxhandle + 1) * sizeof(uint32_t); + if ((chk_64 / sizeof(uint32_t)) != (vc_maxhandle + 1)) { + chk_report_abort("TALOS-2023-1798"); + } + } + chain_table_lengths = (uint32_t *)calloc((vc_maxhandle + 1), sizeof(uint32_t)); + } + + if (!chain_table || !chain_table_lengths) + goto block_err; pnt = chain_cmem; idx = 0; pval = 0; - if(sectype == FST_BL_VCDATA_DYN_ALIAS2) - { - uint32_t prev_alias = 0; + if (sectype == FST_BL_VCDATA_DYN_ALIAS2) { + uint32_t prev_alias = 0; - do { - int skiplen; + do { + int skiplen; - if(*pnt & 0x01) - { - int64_t shval = fstGetSVarint64(pnt, &skiplen) >> 1; - if(shval > 0) - { - pval = chain_table[idx] = pval + shval; - if(idx) { chain_table_lengths[pidx] = pval - chain_table[pidx]; } - pidx = idx++; - } - else if(shval < 0) - { - chain_table[idx] = 0; /* need to explicitly zero as calloc above might not run */ - chain_table_lengths[idx] = prev_alias = shval; /* because during this loop iter would give stale data! */ - idx++; - } - else - { - chain_table[idx] = 0; /* need to explicitly zero as calloc above might not run */ - chain_table_lengths[idx] = prev_alias; /* because during this loop iter would give stale data! */ - idx++; - } - } - else - { - uint64_t val = fstGetVarint32(pnt, &skiplen); + if (*pnt & 0x01) { + int64_t shval = fstGetSVarint64(pnt, &skiplen) >> 1; + if (shval > 0) { + pval = chain_table[idx] = pval + shval; + if (idx) { + chain_table_lengths[pidx] = pval - chain_table[pidx]; + } + pidx = idx++; + } else if (shval < 0) { + chain_table[idx] = + 0; /* need to explicitly zero as calloc above might not run */ + chain_table_lengths[idx] = prev_alias = + shval; /* because during this loop iter would give stale data! */ + idx++; + } else { + chain_table[idx] = + 0; /* need to explicitly zero as calloc above might not run */ + chain_table_lengths[idx] = + prev_alias; /* because during this loop iter would give stale data! */ + idx++; + } + } else { + uint64_t val = fstGetVarint32(pnt, &skiplen); - fstHandle loopcnt = val >> 1; - if((idx+loopcnt-1) > vc_maxhandle) /* TALOS-2023-1789 */ - { - chk_report_abort("TALOS-2023-1789"); - } + fstHandle loopcnt = val >> 1; + if ((idx + loopcnt - 1) > vc_maxhandle) /* TALOS-2023-1789 */ + { + chk_report_abort("TALOS-2023-1789"); + } - for(i=0;i> 1); - if(idx) { chain_table_lengths[pidx] = pval - chain_table[pidx]; } - pidx = idx++; - } - else - { - fstHandle loopcnt = val >> 1; + pnt += skiplen; + } while (pnt != (chain_cmem + chain_clen)); + } else { + do { + int skiplen; + uint64_t val = fstGetVarint32(pnt, &skiplen); - if((idx+loopcnt-1) > vc_maxhandle) /* TALOS-2023-1789 */ - { - chk_report_abort("TALOS-2023-1789"); - } + if (!val) { + pnt += skiplen; + val = fstGetVarint32(pnt, &skiplen); + chain_table[idx] = + 0; /* need to explicitly zero as calloc above might not run */ + chain_table_lengths[idx] = + -val; /* because during this loop iter would give stale data! */ + idx++; + } else if (val & 1) { + pval = chain_table[idx] = pval + (val >> 1); + if (idx) { + chain_table_lengths[pidx] = pval - chain_table[pidx]; + } + pidx = idx++; + } else { + fstHandle loopcnt = val >> 1; - for(i=0;i vc_maxhandle) /* TALOS-2023-1789 */ + { + chk_report_abort("TALOS-2023-1789"); + } - pnt += skiplen; - } while (pnt != (chain_cmem + chain_clen)); + for (i = 0; i < loopcnt; i++) { + chain_table[idx++] = 0; + } } + pnt += skiplen; + } while (pnt != (chain_cmem + chain_clen)); + } + chain_table[idx] = indx_pos - vc_start; chain_table_lengths[pidx] = chain_table[idx] - chain_table[pidx]; - for(i=0;i xc->maxhandle) idx = xc->maxhandle; - for(i=0;i xc->maxhandle) + idx = xc->maxhandle; + for (i = 0; i < idx; i++) { + if (chain_table[i]) { + int process_idx = i / 8; + int process_bit = i & 7; - if(xc->process_mask[process_idx]&(1<process_mask[process_idx] & (1 << process_bit)) { + int rc = Z_OK; + uint32_t val; + uint32_t skiplen; + uint32_t tdelta; - fstReaderFseeko(xc, xc->f, vc_start + chain_table[i], SEEK_SET); - val = fstReaderVarint32WithSkip(xc->f, &skiplen); - if(val) - { - unsigned char *mu = mem_for_traversal + traversal_mem_offs; /* uncomp: dst */ - unsigned char *mc; /* comp: src */ - unsigned long destlen = val; - unsigned long sourcelen = chain_table_lengths[i]; + fstReaderFseeko(xc, xc->f, vc_start + chain_table[i], SEEK_SET); + val = fstReaderVarint32WithSkip(xc->f, &skiplen); + if (val) { + unsigned char *mu = + mem_for_traversal + traversal_mem_offs; /* uncomp: dst */ + unsigned char *mc; /* comp: src */ + unsigned long destlen = val; + unsigned long sourcelen = chain_table_lengths[i]; - if(traversal_mem_offs >= mem_required_for_traversal) - { - chk_report_abort("TALOS-2023-1785"); - } - - if(mc_mem_len < chain_table_lengths[i]) - { - free(mc_mem); - mc_mem = (unsigned char *)malloc(mc_mem_len = chain_table_lengths[i]); - } - mc = mc_mem; - - fstFread(mc, chain_table_lengths[i], 1, xc->f); - - switch(packtype) - { - case '4': rc = (destlen == (unsigned long)LZ4_decompress_safe_partial((char *)mc, (char *)mu, sourcelen, destlen, destlen)) ? Z_OK : Z_DATA_ERROR; - break; - case 'F': fastlz_decompress(mc, sourcelen, mu, destlen); /* rc appears unreliable */ - break; - default: rc = uncompress(mu, &destlen, mc, sourcelen); - break; - } - - /* data to process is for(j=0;j= mem_required_for_traversal) - { - chk_report_abort("TALOS-2023-1785"); - } - - fstFread(mu, destlen, 1, xc->f); - /* data to process is for(j=0;jsignal_lens[i] == 1) - { - uint32_t vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[i]); - uint32_t shcnt = 2 << (vli & 1); - tdelta = vli >> shcnt; - } - else - { - uint32_t vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[i]); - tdelta = vli >> 1; - } - - if(tdelta >= tc_head_items) - { - chk_report_abort("TALOS-2023-1791"); - } - - scatterptr[i] = tc_head[tdelta]; - tc_head[tdelta] = i+1; - } + if (traversal_mem_offs >= mem_required_for_traversal) { + chk_report_abort("TALOS-2023-1785"); } + + if (mc_mem_len < chain_table_lengths[i]) { + free(mc_mem); + mc_mem = (unsigned char *)malloc(mc_mem_len = chain_table_lengths[i]); + } + mc = mc_mem; + + fstFread(mc, chain_table_lengths[i], 1, xc->f); + + switch (packtype) { + case '4': + rc = (destlen == + (unsigned long)LZ4_decompress_safe_partial((char *)mc, + (char *)mu, + sourcelen, + destlen, + destlen)) + ? Z_OK + : Z_DATA_ERROR; + break; + case 'F': + fastlz_decompress(mc, + sourcelen, + mu, + destlen); /* rc appears unreliable */ + break; + default: + rc = uncompress(mu, &destlen, mc, sourcelen); + break; + } + + /* data to process is for(j=0;j= mem_required_for_traversal) { + chk_report_abort("TALOS-2023-1785"); + } + + fstFread(mu, destlen, 1, xc->f); + /* data to process is for(j=0;jsignal_lens[i] == 1) { + uint32_t vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[i]); + uint32_t shcnt = 2 << (vli & 1); + tdelta = vli >> shcnt; + } else { + uint32_t vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[i]); + tdelta = vli >> 1; + } + + if (tdelta >= tc_head_items) { + chk_report_abort("TALOS-2023-1791"); + } + + scatterptr[i] = tc_head[tdelta]; + tc_head[tdelta] = i + 1; } + } + } - free(mc_mem); /* there is no usage below for this, no real need to clear out mc_mem or mc_mem_len */ + free(mc_mem); /* there is no usage below for this, no real need to clear out mc_mem or + mc_mem_len */ - for(i=0;ilimit_range_valid) - { - if(time_table[i] > xc->limit_range_end) - { - break; - } - } + if (time_table[i] != previous_time) { + if (xc->limit_range_valid) { + if (time_table[i] > xc->limit_range_end) { + break; + } + } - if(dumpvars_state == 1) { wx_len = snprintf(wx_buf, 32, "$end\n"); fstWritex(xc, wx_buf, wx_len); dumpvars_state = 2; } - wx_len = snprintf(wx_buf, 32, "#%" PRIu64 "\n", time_table[i]); - fstWritex(xc, wx_buf, wx_len); - if(!dumpvars_state) { wx_len = snprintf(wx_buf, 32, "$dumpvars\n"); fstWritex(xc, wx_buf, wx_len); dumpvars_state = 1; } + if (dumpvars_state == 1) { + wx_len = snprintf(wx_buf, 32, "$end\n"); + fstWritex(xc, wx_buf, wx_len); + dumpvars_state = 2; + } + wx_len = snprintf(wx_buf, 32, "#%" PRIu64 "\n", time_table[i]); + fstWritex(xc, wx_buf, wx_len); + if (!dumpvars_state) { + wx_len = snprintf(wx_buf, 32, "$dumpvars\n"); + fstWritex(xc, wx_buf, wx_len); + dumpvars_state = 1; + } - if((xc->num_blackouts)&&(cur_blackout != xc->num_blackouts)) - { - if(time_table[i] == xc->blackout_times[cur_blackout]) - { - wx_len = snprintf(wx_buf, 32, "$dump%s $end\n", (xc->blackout_activity[cur_blackout++]) ? "on" : "off"); - fstWritex(xc, wx_buf, wx_len); - } - } - previous_time = time_table[i]; - } + if ((xc->num_blackouts) && (cur_blackout != xc->num_blackouts)) { + if (time_table[i] == xc->blackout_times[cur_blackout]) { + wx_len = + snprintf(wx_buf, + 32, + "$dump%s $end\n", + (xc->blackout_activity[cur_blackout++]) ? "on" : "off"); + fstWritex(xc, wx_buf, wx_len); + } + } + previous_time = time_table[i]; + } + } + + while (tc_head[i]) { + idx = tc_head[i] - 1; + vli = fstGetVarint32(mem_for_traversal + headptr[idx], &skiplen); + + if (xc->signal_lens[idx] <= 1) { + if (xc->signal_lens[idx] == 1) { + unsigned char val; + if (!(vli & 1)) { + /* tdelta = vli >> 2; */ /* scan-build */ + val = ((vli >> 1) & 1) | '0'; + } else { + /* tdelta = vli >> 4; */ /* scan-build */ + val = FST_RCV_STR[((vli >> 1) & 7)]; } - while(tc_head[i]) - { - idx = tc_head[i] - 1; + if (value_change_callback) { + xc->temp_signal_value_buf[0] = val; + xc->temp_signal_value_buf[1] = 0; + value_change_callback(user_callback_data_pointer, + time_table[i], + idx + 1, + xc->temp_signal_value_buf); + } else { + if (fv) { + char vcd_id[16]; + int vcdid_len = fstVcdIDForFwrite(vcd_id + 1, idx + 1); + + vcd_id[0] = val; + vcd_id[vcdid_len + 1] = '\n'; + fstWritex(xc, vcd_id, vcdid_len + 2); + } + } + headptr[idx] += skiplen; + length_remaining[idx] -= skiplen; + + tc_head[i] = scatterptr[idx]; + scatterptr[idx] = 0; + + if (length_remaining[idx]) { + int shamt; + vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[idx]); + shamt = 2 << (vli & 1); + tdelta = vli >> shamt; + + if ((tdelta + i) >= tc_head_items) { + chk_report_abort("TALOS-2023-1791"); + } + + scatterptr[idx] = tc_head[i + tdelta]; + tc_head[i + tdelta] = idx + 1; + } + } else { + unsigned char *vdata; + uint32_t len; + vli = fstGetVarint32(mem_for_traversal + headptr[idx], &skiplen); + len = fstGetVarint32(mem_for_traversal + headptr[idx] + skiplen, &skiplen2); + /* tdelta = vli >> 1; */ /* scan-build */ + skiplen += skiplen2; + vdata = mem_for_traversal + headptr[idx] + skiplen; - if(xc->signal_lens[idx] <= 1) - { - if(xc->signal_lens[idx] == 1) - { - unsigned char val; - if(!(vli & 1)) - { - /* tdelta = vli >> 2; */ /* scan-build */ - val = ((vli >> 1) & 1) | '0'; - } - else - { - /* tdelta = vli >> 4; */ /* scan-build */ - val = FST_RCV_STR[((vli >> 1) & 7)]; - } + if (!(vli & 1)) { + if (value_change_callback_varlen) { + value_change_callback_varlen(user_callback_data_pointer, + time_table[i], + idx + 1, + vdata, + len); + } else { + if (fv) { + char vcd_id[16]; + int vcdid_len; - if(value_change_callback) - { - xc->temp_signal_value_buf[0] = val; - xc->temp_signal_value_buf[1] = 0; - value_change_callback(user_callback_data_pointer, time_table[i], idx+1, xc->temp_signal_value_buf); - } - else - { - if(fv) - { - char vcd_id[16]; - int vcdid_len = fstVcdIDForFwrite(vcd_id+1, idx+1); + vcd_id[0] = 's'; + fstWritex(xc, vcd_id, 1); - vcd_id[0] = val; - vcd_id[vcdid_len+1] = '\n'; - fstWritex(xc, vcd_id, vcdid_len+2); - } - } - headptr[idx] += skiplen; - length_remaining[idx] -= skiplen; - - tc_head[i] = scatterptr[idx]; - scatterptr[idx] = 0; - - if(length_remaining[idx]) - { - int shamt; - vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[idx]); - shamt = 2 << (vli & 1); - tdelta = vli >> shamt; - - if((tdelta+i) >= tc_head_items) - { - chk_report_abort("TALOS-2023-1791"); - } - - scatterptr[idx] = tc_head[i+tdelta]; - tc_head[i+tdelta] = idx+1; - } + vcdid_len = fstVcdIDForFwrite(vcd_id + 1, idx + 1); + { + if (sizeof(size_t) < sizeof(uint64_t)) { + /* TALOS-2023-1790 for 32b overflow */ + uint64_t chk_64 = len * 4 + 1; + size_t chk_32 = len * 4 + 1; + if (chk_64 != chk_32) + chk_report_abort("TALOS-2023-1790"); } - else - { - unsigned char *vdata; - uint32_t len; - vli = fstGetVarint32(mem_for_traversal + headptr[idx], &skiplen); - len = fstGetVarint32(mem_for_traversal + headptr[idx] + skiplen, &skiplen2); - /* tdelta = vli >> 1; */ /* scan-build */ - skiplen += skiplen2; - vdata = mem_for_traversal + headptr[idx] + skiplen; + unsigned char *vesc = (unsigned char *)malloc(len * 4 + 1); + int vlen = fstUtilityBinToEsc(vesc, vdata, len); + fstWritex(xc, vesc, vlen); + free(vesc); + } - if(!(vli & 1)) - { - if(value_change_callback_varlen) - { - value_change_callback_varlen(user_callback_data_pointer, time_table[i], idx+1, vdata, len); - } - else - { - if(fv) - { - char vcd_id[16]; - int vcdid_len; - - vcd_id[0] = 's'; - fstWritex(xc, vcd_id, 1); - - vcdid_len = fstVcdIDForFwrite(vcd_id+1, idx+1); - { - if(sizeof(size_t) < sizeof(uint64_t)) - { - /* TALOS-2023-1790 for 32b overflow */ - uint64_t chk_64 = len*4 + 1; - size_t chk_32 = len*4 + 1; - if(chk_64 != chk_32) chk_report_abort("TALOS-2023-1790"); - } - - unsigned char *vesc = (unsigned char *)malloc(len*4 + 1); - int vlen = fstUtilityBinToEsc(vesc, vdata, len); - fstWritex(xc, vesc, vlen); - free(vesc); - } - - vcd_id[0] = ' '; - vcd_id[vcdid_len + 1] = '\n'; - fstWritex(xc, vcd_id, vcdid_len+2); - } - } - } - - skiplen += len; - headptr[idx] += skiplen; - length_remaining[idx] -= skiplen; - - tc_head[i] = scatterptr[idx]; - scatterptr[idx] = 0; - - if(length_remaining[idx]) - { - vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[idx]); - tdelta = vli >> 1; - - if((tdelta+i) >= tc_head_items) - { - chk_report_abort("TALOS-2023-1791"); - } - - scatterptr[idx] = tc_head[i+tdelta]; - tc_head[i+tdelta] = idx+1; - } - } - } - else - { - uint32_t len = xc->signal_lens[idx]; - unsigned char *vdata; - - vli = fstGetVarint32(mem_for_traversal + headptr[idx], &skiplen); - /* tdelta = vli >> 1; */ /* scan-build */ - vdata = mem_for_traversal + headptr[idx] + skiplen; - - if(xc->signal_typs[idx] != FST_VT_VCD_REAL) - { - if(len > xc->longest_signal_value_len) - { - chk_report_abort("TALOS-2023-1797"); - } - - if(!(vli & 1)) - { - int byte = 0; - int bit; - unsigned int j; - - for(j=0;j> bit) & 1) | '0'; - xc->temp_signal_value_buf[j] = ch; - } - xc->temp_signal_value_buf[j] = 0; - - if(value_change_callback) - { - value_change_callback(user_callback_data_pointer, time_table[i], idx+1, xc->temp_signal_value_buf); - } - else - { - if(fv) { - unsigned char ch_bp = (xc->signal_typs[idx] != FST_VT_VCD_PORT) ? 'b' : 'p'; - - fstWritex(xc, &ch_bp, 1); - fstWritex(xc, xc->temp_signal_value_buf, len); - } - } - - len = byte+1; - } - else - { - if(value_change_callback) - { - memcpy(xc->temp_signal_value_buf, vdata, len); - xc->temp_signal_value_buf[len] = 0; - value_change_callback(user_callback_data_pointer, time_table[i], idx+1, xc->temp_signal_value_buf); - } - else - { - if(fv) - { - unsigned char ch_bp = (xc->signal_typs[idx] != FST_VT_VCD_PORT) ? 'b' : 'p'; - uint64_t mem_required_for_traversal_chk = vdata - mem_for_traversal + len; - - fstWritex(xc, &ch_bp, 1); - if(mem_required_for_traversal_chk > mem_required_for_traversal) - { - chk_report_abort("TALOS-2023-1793"); - } - fstWritex(xc, vdata, len); - } - } - } - } - else - { - double d; - unsigned char *clone_d /*= (unsigned char *)&d */; /* scan-build */ - unsigned char buf[8]; - unsigned char *srcdata; - - if(!(vli & 1)) /* very rare case, but possible */ - { - int bit; - int j; - - for(j=0;j<8;j++) - { - unsigned char ch; - bit = 7 - (j & 7); - ch = ((vdata[0] >> bit) & 1) | '0'; - buf[j] = ch; - } - - len = 1; - srcdata = buf; - } - else - { - srcdata = vdata; - } - - if(value_change_callback) - { - if(xc->native_doubles_for_cb) - { - if(xc->double_endian_match) - { - clone_d = srcdata; - } - else - { - int j; - - clone_d = (unsigned char *)&d; - for(j=0;j<8;j++) - { - clone_d[j] = srcdata[7-j]; - } - } - value_change_callback(user_callback_data_pointer, time_table[i], idx+1, clone_d); - } - else - { - clone_d = (unsigned char *)&d; - if(xc->double_endian_match) - { - memcpy(clone_d, srcdata, 8); - } - else - { - int j; - - for(j=0;j<8;j++) - { - clone_d[j] = srcdata[7-j]; - } - } - snprintf((char *)xc->temp_signal_value_buf, xc->longest_signal_value_len + 1, "%.16g", d); - value_change_callback(user_callback_data_pointer, time_table[i], idx+1, xc->temp_signal_value_buf); - } - } - else - { - if(fv) - { - char wx_buf[32]; - int wx_len; - - clone_d = (unsigned char *)&d; - if(xc->double_endian_match) - { - memcpy(clone_d, srcdata, 8); - } - else - { - int j; - - for(j=0;j<8;j++) - { - clone_d[j] = srcdata[7-j]; - } - } - - wx_len = snprintf(wx_buf, 32, "r%.16g", d); - if (wx_len > 32 || wx_len < 0) wx_len = 32; - fstWritex(xc, wx_buf, wx_len); - } - } - } - - if(fv) - { - char vcd_id[16]; - int vcdid_len = fstVcdIDForFwrite(vcd_id+1, idx+1); - vcd_id[0] = ' '; - vcd_id[vcdid_len+1] = '\n'; - fstWritex(xc, vcd_id, vcdid_len+2); - } - - skiplen += len; - headptr[idx] += skiplen; - length_remaining[idx] -= skiplen; - - tc_head[i] = scatterptr[idx]; - scatterptr[idx] = 0; - - if(length_remaining[idx]) - { - vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[idx]); - tdelta = vli >> 1; - - if((tdelta+i) >= tc_head_items) - { - chk_report_abort("TALOS-2023-1791"); - } - - scatterptr[idx] = tc_head[i+tdelta]; - tc_head[i+tdelta] = idx+1; - } + vcd_id[0] = ' '; + vcd_id[vcdid_len + 1] = '\n'; + fstWritex(xc, vcd_id, vcdid_len + 2); } + } } - } -block_err: + skiplen += len; + headptr[idx] += skiplen; + length_remaining[idx] -= skiplen; + + tc_head[i] = scatterptr[idx]; + scatterptr[idx] = 0; + + if (length_remaining[idx]) { + vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[idx]); + tdelta = vli >> 1; + + if ((tdelta + i) >= tc_head_items) { + chk_report_abort("TALOS-2023-1791"); + } + + scatterptr[idx] = tc_head[i + tdelta]; + tc_head[i + tdelta] = idx + 1; + } + } + } else { + uint32_t len = xc->signal_lens[idx]; + unsigned char *vdata; + + vli = fstGetVarint32(mem_for_traversal + headptr[idx], &skiplen); + /* tdelta = vli >> 1; */ /* scan-build */ + vdata = mem_for_traversal + headptr[idx] + skiplen; + + if (xc->signal_typs[idx] != FST_VT_VCD_REAL) { + if (len > xc->longest_signal_value_len) { + chk_report_abort("TALOS-2023-1797"); + } + + if (!(vli & 1)) { + int byte = 0; + int bit; + unsigned int j; + + for (j = 0; j < len; j++) { + unsigned char ch; + byte = j / 8; + bit = 7 - (j & 7); + ch = ((vdata[byte] >> bit) & 1) | '0'; + xc->temp_signal_value_buf[j] = ch; + } + xc->temp_signal_value_buf[j] = 0; + + if (value_change_callback) { + value_change_callback(user_callback_data_pointer, + time_table[i], + idx + 1, + xc->temp_signal_value_buf); + } else { + if (fv) { + unsigned char ch_bp = + (xc->signal_typs[idx] != FST_VT_VCD_PORT) ? 'b' : 'p'; + + fstWritex(xc, &ch_bp, 1); + fstWritex(xc, xc->temp_signal_value_buf, len); + } + } + + len = byte + 1; + } else { + if (value_change_callback) { + memcpy(xc->temp_signal_value_buf, vdata, len); + xc->temp_signal_value_buf[len] = 0; + value_change_callback(user_callback_data_pointer, + time_table[i], + idx + 1, + xc->temp_signal_value_buf); + } else { + if (fv) { + unsigned char ch_bp = + (xc->signal_typs[idx] != FST_VT_VCD_PORT) ? 'b' : 'p'; + uint64_t mem_required_for_traversal_chk = + vdata - mem_for_traversal + len; + + fstWritex(xc, &ch_bp, 1); + if (mem_required_for_traversal_chk > + mem_required_for_traversal) { + chk_report_abort("TALOS-2023-1793"); + } + fstWritex(xc, vdata, len); + } + } + } + } else { + double d; + unsigned char *clone_d /*= (unsigned char *)&d */; /* scan-build */ + unsigned char buf[8]; + unsigned char *srcdata; + + if (!(vli & 1)) /* very rare case, but possible */ + { + int bit; + int j; + + for (j = 0; j < 8; j++) { + unsigned char ch; + bit = 7 - (j & 7); + ch = ((vdata[0] >> bit) & 1) | '0'; + buf[j] = ch; + } + + len = 1; + srcdata = buf; + } else { + srcdata = vdata; + } + + if (value_change_callback) { + if (xc->native_doubles_for_cb) { + if (xc->double_endian_match) { + clone_d = srcdata; + } else { + int j; + + clone_d = (unsigned char *)&d; + for (j = 0; j < 8; j++) { + clone_d[j] = srcdata[7 - j]; + } + } + value_change_callback(user_callback_data_pointer, + time_table[i], + idx + 1, + clone_d); + } else { + clone_d = (unsigned char *)&d; + if (xc->double_endian_match) { + memcpy(clone_d, srcdata, 8); + } else { + int j; + + for (j = 0; j < 8; j++) { + clone_d[j] = srcdata[7 - j]; + } + } + snprintf((char *)xc->temp_signal_value_buf, + xc->longest_signal_value_len + 1, + "%.16g", + d); + value_change_callback(user_callback_data_pointer, + time_table[i], + idx + 1, + xc->temp_signal_value_buf); + } + } else { + if (fv) { + char wx_buf[32]; + int wx_len; + + clone_d = (unsigned char *)&d; + if (xc->double_endian_match) { + memcpy(clone_d, srcdata, 8); + } else { + int j; + + for (j = 0; j < 8; j++) { + clone_d[j] = srcdata[7 - j]; + } + } + + wx_len = snprintf(wx_buf, 32, "r%.16g", d); + if (wx_len > 32 || wx_len < 0) wx_len = 32; + fstWritex(xc, wx_buf, wx_len); + } + } + } + + if (fv) { + char vcd_id[16]; + int vcdid_len = fstVcdIDForFwrite(vcd_id + 1, idx + 1); + vcd_id[0] = ' '; + vcd_id[vcdid_len + 1] = '\n'; + fstWritex(xc, vcd_id, vcdid_len + 2); + } + + skiplen += len; + headptr[idx] += skiplen; + length_remaining[idx] -= skiplen; + + tc_head[i] = scatterptr[idx]; + scatterptr[idx] = 0; + + if (length_remaining[idx]) { + vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[idx]); + tdelta = vli >> 1; + + if ((tdelta + i) >= tc_head_items) { + chk_report_abort("TALOS-2023-1791"); + } + + scatterptr[idx] = tc_head[i + tdelta]; + tc_head[i + tdelta] = idx + 1; + } + } + } + } + + block_err: free(tc_head); free(chain_cmem); - free(mem_for_traversal); mem_for_traversal = NULL; + free(mem_for_traversal); + mem_for_traversal = NULL; secnum++; - if(secnum == xc->vc_section_count) break; /* in case file is growing, keep with original block count */ + if (secnum == xc->vc_section_count) + break; /* in case file is growing, keep with original block count */ blkpos += seclen; - } + } -if(mem_for_traversal) free(mem_for_traversal); /* scan-build */ -free(length_remaining); -free(headptr); -free(scatterptr); + if (mem_for_traversal) + free(mem_for_traversal); /* scan-build */ + free(length_remaining); + free(headptr); + free(scatterptr); -if(chain_table) free(chain_table); -if(chain_table_lengths) free(chain_table_lengths); + if (chain_table) + free(chain_table); + if (chain_table_lengths) + free(chain_table_lengths); -free(time_table); + free(time_table); #ifndef FST_WRITEX_DISABLE -if(fv) - { + if (fv) { fstWritex(xc, NULL, 0); - } + } #endif -return(1); + return (1); } - /* 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); - } + if (facidx >= xc->rvat_frame_maxhandle) { + return (NULL); + } -if(xc->signal_lens[facidx] == 1) - { + if (xc->signal_lens[facidx] == 1) { buf[0] = (char)xc->rvat_frame_data[xc->rvat_sig_offs[facidx]]; buf[1] = 0; - } - else - { - if(xc->signal_typs[facidx] != FST_VT_VCD_REAL) - { - memcpy(buf, xc->rvat_frame_data + xc->rvat_sig_offs[facidx], xc->signal_lens[facidx]); - buf[xc->signal_lens[facidx]] = 0; + } else { + if (xc->signal_typs[facidx] != FST_VT_VCD_REAL) { + memcpy(buf, xc->rvat_frame_data + xc->rvat_sig_offs[facidx], xc->signal_lens[facidx]); + buf[xc->signal_lens[facidx]] = 0; + } else { + double d; + unsigned char *clone_d = (unsigned char *)&d; + unsigned char *srcdata = xc->rvat_frame_data + xc->rvat_sig_offs[facidx]; + + if (xc->double_endian_match) { + memcpy(clone_d, srcdata, 8); + } else { + int j; + + for (j = 0; j < 8; j++) { + clone_d[j] = srcdata[7 - j]; } - else - { - double d; - unsigned char *clone_d = (unsigned char *)&d; - unsigned char *srcdata = xc->rvat_frame_data + xc->rvat_sig_offs[facidx]; + } - if(xc->double_endian_match) - { - memcpy(clone_d, srcdata, 8); - } - else - { - int j; - - for(j=0;j<8;j++) - { - clone_d[j] = srcdata[7-j]; - } - } - - snprintf((char *)buf, 32, "%.16g", d); /* this will write 18 bytes */ - } + snprintf((char *)buf, 32, "%.16g", d); /* this will write 18 bytes */ } + } -return(buf); + 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; + fst_off_t blkpos = 0, prev_blkpos; + uint64_t beg_tim, end_tim, beg_tim2, end_tim2; + int sectype; #ifdef FST_DEBUG -unsigned int secnum = 0; + unsigned int secnum = 0; #endif -uint64_t seclen; -uint64_t tsec_uclen = 0, tsec_clen = 0; -uint64_t tsec_nitems; -uint64_t frame_uclen, frame_clen; + uint64_t seclen; + uint64_t tsec_uclen = 0, tsec_clen = 0; + uint64_t tsec_nitems; + uint64_t frame_uclen, frame_clen; #ifdef FST_DEBUG -uint64_t mem_required_for_traversal; + uint64_t mem_required_for_traversal; #endif -fst_off_t indx_pntr, indx_pos; -long chain_clen; -unsigned char *chain_cmem; -unsigned char *pnt; -fstHandle idx, pidx=0, i; -uint64_t pval; + fst_off_t indx_pntr, indx_pos; + long chain_clen; + unsigned char *chain_cmem; + unsigned char *pnt; + fstHandle idx, pidx = 0, i; + uint64_t pval; -if((!xc) || (!facidx) || (facidx > xc->maxhandle) || (!buf) || (!xc->signal_lens[facidx-1])) - { - return(NULL); - } + if ((!xc) || (!facidx) || (facidx > xc->maxhandle) || (!buf) || + (!xc->signal_lens[facidx - 1])) { + return (NULL); + } -if(!xc->rvat_sig_offs) - { + if (!xc->rvat_sig_offs) { uint32_t cur_offs = 0; xc->rvat_sig_offs = (uint32_t *)calloc(xc->maxhandle, sizeof(uint32_t)); - for(i=0;imaxhandle;i++) - { - xc->rvat_sig_offs[i] = cur_offs; - cur_offs += xc->signal_lens[i]; - } + for (i = 0; i < xc->maxhandle; i++) { + xc->rvat_sig_offs[i] = cur_offs; + cur_offs += xc->signal_lens[i]; } + } -if(xc->rvat_data_valid) - { - if((xc->rvat_beg_tim <= tim) && (tim <= xc->rvat_end_tim)) - { - goto process_value; - } + if (xc->rvat_data_valid) { + if ((xc->rvat_beg_tim <= tim) && (tim <= xc->rvat_end_tim)) { + goto process_value; + } fstReaderDeallocateRvatData(xc); - } + } -xc->rvat_chain_pos_valid = 0; + xc->rvat_chain_pos_valid = 0; -for(;;) - { + for (;;) { fstReaderFseeko(xc, xc->f, (prev_blkpos = blkpos), SEEK_SET); sectype = fgetc(xc->f); seclen = fstReaderUint64(xc->f); - if((sectype == EOF) || (sectype == FST_BL_SKIP) || (!seclen)) - { - return(NULL); /* if this loop exits on break, it's successful */ - } + if ((sectype == EOF) || (sectype == FST_BL_SKIP) || (!seclen)) { + return (NULL); /* if this loop exits on break, it's successful */ + } blkpos++; - if((sectype != FST_BL_VCDATA) && (sectype != FST_BL_VCDATA_DYN_ALIAS) && (sectype != FST_BL_VCDATA_DYN_ALIAS2)) - { - blkpos += seclen; - continue; - } + if ((sectype != FST_BL_VCDATA) && (sectype != FST_BL_VCDATA_DYN_ALIAS) && + (sectype != FST_BL_VCDATA_DYN_ALIAS2)) { + blkpos += seclen; + continue; + } beg_tim = fstReaderUint64(xc->f); end_tim = fstReaderUint64(xc->f); - if((beg_tim <= tim) && (tim <= end_tim)) - { - if((tim == end_tim) && (tim != xc->end_time)) - { - fst_off_t cached_pos = ftello(xc->f); - fstReaderFseeko(xc, xc->f, blkpos, SEEK_SET); + if ((beg_tim <= tim) && (tim <= end_tim)) { + if ((tim == end_tim) && (tim != xc->end_time)) { + fst_off_t cached_pos = ftello(xc->f); + fstReaderFseeko(xc, xc->f, blkpos, SEEK_SET); - sectype = fgetc(xc->f); - seclen = fstReaderUint64(xc->f); + sectype = fgetc(xc->f); + seclen = fstReaderUint64(xc->f); - beg_tim2 = fstReaderUint64(xc->f); - end_tim2 = fstReaderUint64(xc->f); + beg_tim2 = fstReaderUint64(xc->f); + end_tim2 = fstReaderUint64(xc->f); - if(((sectype != FST_BL_VCDATA)&&(sectype != FST_BL_VCDATA_DYN_ALIAS)&&(sectype != FST_BL_VCDATA_DYN_ALIAS2)) || (!seclen) || (beg_tim2 != tim)) - { - blkpos = prev_blkpos; - break; - } - beg_tim = beg_tim2; - end_tim = end_tim2; - fstReaderFseeko(xc, xc->f, cached_pos, SEEK_SET); - } - break; + if (((sectype != FST_BL_VCDATA) && (sectype != FST_BL_VCDATA_DYN_ALIAS) && + (sectype != FST_BL_VCDATA_DYN_ALIAS2)) || + (!seclen) || (beg_tim2 != tim)) { + blkpos = prev_blkpos; + break; } + beg_tim = beg_tim2; + end_tim = end_tim2; + fstReaderFseeko(xc, xc->f, cached_pos, SEEK_SET); + } + break; + } blkpos += seclen; #ifdef FST_DEBUG secnum++; #endif - } + } -xc->rvat_beg_tim = beg_tim; -xc->rvat_end_tim = end_tim; + xc->rvat_beg_tim = beg_tim; + xc->rvat_end_tim = end_tim; #ifdef FST_DEBUG -mem_required_for_traversal = + mem_required_for_traversal = #endif fstReaderUint64(xc->f); #ifdef FST_DEBUG -fprintf(stderr, FST_APIMESS "rvat sec: %u seclen: %d begtim: %d endtim: %d\n", - secnum, (int)seclen, (int)beg_tim, (int)end_tim); -fprintf(stderr, FST_APIMESS "mem_required_for_traversal: %d\n", (int)mem_required_for_traversal); + fprintf(stderr, + FST_APIMESS "rvat sec: %u seclen: %d begtim: %d endtim: %d\n", + secnum, + (int)seclen, + (int)beg_tim, + (int)end_tim); + fprintf(stderr, + FST_APIMESS "mem_required_for_traversal: %d\n", + (int)mem_required_for_traversal); #endif -/* process time block */ -{ -unsigned char *ucdata; -unsigned char *cdata; -unsigned long destlen /* = tsec_uclen */; /* scan-build */ -unsigned long sourcelen /* = tsec_clen */; /* scan-build */ -int rc; -unsigned char *tpnt; -uint64_t tpval; -unsigned int ti; + /* process time block */ + { + unsigned char *ucdata; + unsigned char *cdata; + unsigned long destlen /* = tsec_uclen */; /* scan-build */ + unsigned long sourcelen /* = tsec_clen */; /* scan-build */ + int rc; + unsigned char *tpnt; + uint64_t tpval; + unsigned int ti; -fstReaderFseeko(xc, xc->f, blkpos + seclen - 24, SEEK_SET); -tsec_uclen = fstReaderUint64(xc->f); -tsec_clen = fstReaderUint64(xc->f); -tsec_nitems = fstReaderUint64(xc->f); + fstReaderFseeko(xc, xc->f, blkpos + seclen - 24, SEEK_SET); + tsec_uclen = fstReaderUint64(xc->f); + tsec_clen = fstReaderUint64(xc->f); + tsec_nitems = fstReaderUint64(xc->f); #ifdef FST_DEBUG -fprintf(stderr, FST_APIMESS "time section unc: %d, com: %d (%d items)\n", - (int)tsec_uclen, (int)tsec_clen, (int)tsec_nitems); + fprintf(stderr, + FST_APIMESS "time section unc: %d, com: %d (%d items)\n", + (int)tsec_uclen, + (int)tsec_clen, + (int)tsec_nitems); #endif -ucdata = (unsigned char *)malloc(tsec_uclen); -destlen = tsec_uclen; -sourcelen = tsec_clen; + ucdata = (unsigned char *)malloc(tsec_uclen); + destlen = tsec_uclen; + sourcelen = tsec_clen; -fstReaderFseeko(xc, xc->f, -24 - ((fst_off_t)tsec_clen), SEEK_CUR); -if(tsec_uclen != tsec_clen) - { - cdata = (unsigned char *)malloc(tsec_clen); - fstFread(cdata, tsec_clen, 1, xc->f); + fstReaderFseeko(xc, xc->f, -24 - ((fst_off_t)tsec_clen), SEEK_CUR); + if (tsec_uclen != tsec_clen) { + cdata = (unsigned char *)malloc(tsec_clen); + fstFread(cdata, tsec_clen, 1, xc->f); - rc = uncompress(ucdata, &destlen, cdata, sourcelen); + rc = uncompress(ucdata, &destlen, cdata, sourcelen); - if(rc != Z_OK) - { - fprintf(stderr, FST_APIMESS "fstReaderGetValueFromHandleAtTime(), tsec uncompress rc = %d, exiting.\n", rc); + if (rc != Z_OK) { + fprintf(stderr, + FST_APIMESS + "fstReaderGetValueFromHandleAtTime(), tsec uncompress rc = %d, exiting.\n", + rc); exit(255); - } + } - free(cdata); - } - else - { - fstFread(ucdata, tsec_uclen, 1, xc->f); + free(cdata); + } else { + fstFread(ucdata, tsec_uclen, 1, xc->f); } -xc->rvat_time_table = (uint64_t *)calloc(tsec_nitems, sizeof(uint64_t)); -tpnt = ucdata; -tpval = 0; -for(ti=0;tirvat_time_table[ti] = tpval + val; - tpnt += skiplen; + xc->rvat_time_table = (uint64_t *)calloc(tsec_nitems, sizeof(uint64_t)); + tpnt = ucdata; + tpval = 0; + for (ti = 0; ti < tsec_nitems; ti++) { + int skiplen; + uint64_t val = fstGetVarint64(tpnt, &skiplen); + tpval = xc->rvat_time_table[ti] = tpval + val; + tpnt += skiplen; } -free(ucdata); -} + free(ucdata); + } -fstReaderFseeko(xc, xc->f, blkpos+32, SEEK_SET); + fstReaderFseeko(xc, xc->f, blkpos + 32, SEEK_SET); -frame_uclen = fstReaderVarint64(xc->f); -frame_clen = fstReaderVarint64(xc->f); -xc->rvat_frame_maxhandle = fstReaderVarint64(xc->f); -xc->rvat_frame_data = (unsigned char *)malloc(frame_uclen); + frame_uclen = fstReaderVarint64(xc->f); + frame_clen = fstReaderVarint64(xc->f); + xc->rvat_frame_maxhandle = fstReaderVarint64(xc->f); + xc->rvat_frame_data = (unsigned char *)malloc(frame_uclen); -if(frame_uclen == frame_clen) - { + if (frame_uclen == frame_clen) { fstFread(xc->rvat_frame_data, frame_uclen, 1, xc->f); - } - else - { + } else { unsigned char *mc = (unsigned char *)malloc(frame_clen); int rc; @@ -6392,321 +6150,293 @@ if(frame_uclen == frame_clen) fstFread(mc, sourcelen, 1, xc->f); rc = uncompress(xc->rvat_frame_data, &destlen, mc, sourcelen); - if(rc != Z_OK) - { - fprintf(stderr, FST_APIMESS "fstReaderGetValueFromHandleAtTime(), frame decompress rc: %d, exiting.\n", rc); - exit(255); - } - free(mc); + if (rc != Z_OK) { + fprintf(stderr, + FST_APIMESS + "fstReaderGetValueFromHandleAtTime(), frame decompress rc: %d, exiting.\n", + rc); + exit(255); } + free(mc); + } -xc->rvat_vc_maxhandle = fstReaderVarint64(xc->f); -xc->rvat_vc_start = ftello(xc->f); /* points to '!' character */ -xc->rvat_packtype = fgetc(xc->f); + xc->rvat_vc_maxhandle = fstReaderVarint64(xc->f); + xc->rvat_vc_start = ftello(xc->f); /* points to '!' character */ + xc->rvat_packtype = fgetc(xc->f); #ifdef FST_DEBUG -fprintf(stderr, FST_APIMESS "frame_uclen: %d, frame_clen: %d, frame_maxhandle: %d\n", - (int)frame_uclen, (int)frame_clen, (int)xc->rvat_frame_maxhandle); -fprintf(stderr, FST_APIMESS "vc_maxhandle: %d\n", (int)xc->rvat_vc_maxhandle); + fprintf(stderr, + FST_APIMESS "frame_uclen: %d, frame_clen: %d, frame_maxhandle: %d\n", + (int)frame_uclen, + (int)frame_clen, + (int)xc->rvat_frame_maxhandle); + fprintf(stderr, FST_APIMESS "vc_maxhandle: %d\n", (int)xc->rvat_vc_maxhandle); #endif -indx_pntr = blkpos + seclen - 24 -tsec_clen -8; -fstReaderFseeko(xc, xc->f, indx_pntr, SEEK_SET); -chain_clen = fstReaderUint64(xc->f); -indx_pos = indx_pntr - chain_clen; + indx_pntr = blkpos + seclen - 24 - tsec_clen - 8; + fstReaderFseeko(xc, xc->f, indx_pntr, SEEK_SET); + chain_clen = fstReaderUint64(xc->f); + indx_pos = indx_pntr - chain_clen; #ifdef FST_DEBUG -fprintf(stderr, FST_APIMESS "indx_pos: %d (%d bytes)\n", (int)indx_pos, (int)chain_clen); + fprintf(stderr, FST_APIMESS "indx_pos: %d (%d bytes)\n", (int)indx_pos, (int)chain_clen); #endif -chain_cmem = (unsigned char *)malloc(chain_clen); -fstReaderFseeko(xc, xc->f, indx_pos, SEEK_SET); -fstFread(chain_cmem, chain_clen, 1, xc->f); + chain_cmem = (unsigned char *)malloc(chain_clen); + fstReaderFseeko(xc, xc->f, indx_pos, SEEK_SET); + fstFread(chain_cmem, chain_clen, 1, xc->f); -xc->rvat_chain_table = (fst_off_t *)calloc((xc->rvat_vc_maxhandle+1), sizeof(fst_off_t)); -xc->rvat_chain_table_lengths = (uint32_t *)calloc((xc->rvat_vc_maxhandle+1), sizeof(uint32_t)); + xc->rvat_chain_table = (fst_off_t *)calloc((xc->rvat_vc_maxhandle + 1), sizeof(fst_off_t)); + xc->rvat_chain_table_lengths = + (uint32_t *)calloc((xc->rvat_vc_maxhandle + 1), sizeof(uint32_t)); -pnt = chain_cmem; -idx = 0; -pval = 0; + pnt = chain_cmem; + idx = 0; + pval = 0; -if(sectype == FST_BL_VCDATA_DYN_ALIAS2) - { + if (sectype == FST_BL_VCDATA_DYN_ALIAS2) { uint32_t prev_alias = 0; - do { - int skiplen; + do { + int skiplen; - if(*pnt & 0x01) - { - int64_t shval = fstGetSVarint64(pnt, &skiplen) >> 1; - if(shval > 0) - { - pval = xc->rvat_chain_table[idx] = pval + shval; - if(idx) { xc->rvat_chain_table_lengths[pidx] = pval - xc->rvat_chain_table[pidx]; } - pidx = idx++; - } - else if(shval < 0) - { - xc->rvat_chain_table[idx] = 0; /* need to explicitly zero as calloc above might not run */ - xc->rvat_chain_table_lengths[idx] = prev_alias = shval; /* because during this loop iter would give stale data! */ - idx++; - } - else - { - xc->rvat_chain_table[idx] = 0; /* need to explicitly zero as calloc above might not run */ - xc->rvat_chain_table_lengths[idx] = prev_alias; /* because during this loop iter would give stale data! */ - idx++; - } - } - else - { - uint64_t val = fstGetVarint32(pnt, &skiplen); - - fstHandle loopcnt = val >> 1; - for(i=0;irvat_chain_table[idx++] = 0; - } - } - - pnt += skiplen; - } while (pnt != (chain_cmem + chain_clen)); - } - else - { - do - { - int skiplen; - uint64_t val = fstGetVarint32(pnt, &skiplen); - - if(!val) - { - pnt += skiplen; - val = fstGetVarint32(pnt, &skiplen); - xc->rvat_chain_table[idx] = 0; - xc->rvat_chain_table_lengths[idx] = -val; - idx++; - } - else - if(val&1) - { - pval = xc->rvat_chain_table[idx] = pval + (val >> 1); - if(idx) { xc->rvat_chain_table_lengths[pidx] = pval - xc->rvat_chain_table[pidx]; } - pidx = idx++; - } - else - { - fstHandle loopcnt = val >> 1; - for(i=0;irvat_chain_table[idx++] = 0; - } - } - - pnt += skiplen; - } while (pnt != (chain_cmem + chain_clen)); - } - -free(chain_cmem); -xc->rvat_chain_table[idx] = indx_pos - xc->rvat_vc_start; -xc->rvat_chain_table_lengths[pidx] = xc->rvat_chain_table[idx] - xc->rvat_chain_table[pidx]; - -for(i=0;irvat_chain_table_lengths[i]; - if((v32 < 0) && (!xc->rvat_chain_table[i])) - { - v32 = -v32; - v32--; - if(((uint32_t)v32) < i) /* sanity check */ - { - xc->rvat_chain_table[i] = xc->rvat_chain_table[v32]; - xc->rvat_chain_table_lengths[i] = xc->rvat_chain_table_lengths[v32]; - } + if (*pnt & 0x01) { + int64_t shval = fstGetSVarint64(pnt, &skiplen) >> 1; + if (shval > 0) { + pval = xc->rvat_chain_table[idx] = pval + shval; + if (idx) { + xc->rvat_chain_table_lengths[pidx] = pval - xc->rvat_chain_table[pidx]; + } + pidx = idx++; + } else if (shval < 0) { + xc->rvat_chain_table[idx] = + 0; /* need to explicitly zero as calloc above might not run */ + xc->rvat_chain_table_lengths[idx] = prev_alias = + shval; /* because during this loop iter would give stale data! */ + idx++; + } else { + xc->rvat_chain_table[idx] = + 0; /* need to explicitly zero as calloc above might not run */ + xc->rvat_chain_table_lengths[idx] = + prev_alias; /* because during this loop iter would give stale data! */ + idx++; } + } else { + uint64_t val = fstGetVarint32(pnt, &skiplen); + + fstHandle loopcnt = val >> 1; + for (i = 0; i < loopcnt; i++) { + xc->rvat_chain_table[idx++] = 0; + } + } + + pnt += skiplen; + } while (pnt != (chain_cmem + chain_clen)); + } else { + do { + int skiplen; + uint64_t val = fstGetVarint32(pnt, &skiplen); + + if (!val) { + pnt += skiplen; + val = fstGetVarint32(pnt, &skiplen); + xc->rvat_chain_table[idx] = 0; + xc->rvat_chain_table_lengths[idx] = -val; + idx++; + } else if (val & 1) { + pval = xc->rvat_chain_table[idx] = pval + (val >> 1); + if (idx) { + xc->rvat_chain_table_lengths[pidx] = pval - xc->rvat_chain_table[pidx]; + } + pidx = idx++; + } else { + fstHandle loopcnt = val >> 1; + for (i = 0; i < loopcnt; i++) { + xc->rvat_chain_table[idx++] = 0; + } + } + + pnt += skiplen; + } while (pnt != (chain_cmem + chain_clen)); + } + + free(chain_cmem); + xc->rvat_chain_table[idx] = indx_pos - xc->rvat_vc_start; + xc->rvat_chain_table_lengths[pidx] = xc->rvat_chain_table[idx] - xc->rvat_chain_table[pidx]; + + for (i = 0; i < idx; i++) { + int32_t v32 = xc->rvat_chain_table_lengths[i]; + if ((v32 < 0) && (!xc->rvat_chain_table[i])) { + v32 = -v32; + v32--; + if (((uint32_t)v32) < i) /* sanity check */ + { + xc->rvat_chain_table[i] = xc->rvat_chain_table[v32]; + xc->rvat_chain_table_lengths[i] = xc->rvat_chain_table_lengths[v32]; + } } + } #ifdef FST_DEBUG -fprintf(stderr, FST_APIMESS "decompressed chain idx len: %" PRIu32 "\n", idx); + fprintf(stderr, FST_APIMESS "decompressed chain idx len: %" PRIu32 "\n", idx); #endif -xc->rvat_data_valid = 1; + xc->rvat_data_valid = 1; -/* all data at this point is loaded or resident in fst cache, process and return appropriate value */ +/* all data at this point is loaded or resident in fst cache, process and return appropriate value + */ process_value: -if(facidx > xc->rvat_vc_maxhandle) - { - return(NULL); + if (facidx > xc->rvat_vc_maxhandle) { + return (NULL); + } + + facidx--; /* scale down for array which starts at zero */ + + if (((tim == xc->rvat_beg_tim) && (!xc->rvat_chain_table[facidx])) || + (!xc->rvat_chain_table[facidx])) { + return (fstExtractRvatDataFromFrame(xc, facidx, buf)); + } + + if (facidx != xc->rvat_chain_facidx) { + if (xc->rvat_chain_mem) { + free(xc->rvat_chain_mem); + xc->rvat_chain_mem = NULL; + + xc->rvat_chain_pos_valid = 0; } + } -facidx--; /* scale down for array which starts at zero */ - - -if(((tim == xc->rvat_beg_tim)&&(!xc->rvat_chain_table[facidx])) || (!xc->rvat_chain_table[facidx])) - { - return(fstExtractRvatDataFromFrame(xc, facidx, buf)); - } - -if(facidx != xc->rvat_chain_facidx) - { - if(xc->rvat_chain_mem) - { - free(xc->rvat_chain_mem); - xc->rvat_chain_mem = NULL; - - xc->rvat_chain_pos_valid = 0; - } - } - -if(!xc->rvat_chain_mem) - { + if (!xc->rvat_chain_mem) { uint32_t skiplen; fstReaderFseeko(xc, xc->f, xc->rvat_vc_start + xc->rvat_chain_table[facidx], SEEK_SET); xc->rvat_chain_len = fstReaderVarint32WithSkip(xc->f, &skiplen); - if(xc->rvat_chain_len) - { - unsigned char *mu = (unsigned char *)malloc(xc->rvat_chain_len); - unsigned char *mc = (unsigned char *)malloc(xc->rvat_chain_table_lengths[facidx]); - unsigned long destlen = xc->rvat_chain_len; - unsigned long sourcelen = xc->rvat_chain_table_lengths[facidx]; - int rc = Z_OK; + if (xc->rvat_chain_len) { + unsigned char *mu = (unsigned char *)malloc(xc->rvat_chain_len); + unsigned char *mc = (unsigned char *)malloc(xc->rvat_chain_table_lengths[facidx]); + unsigned long destlen = xc->rvat_chain_len; + unsigned long sourcelen = xc->rvat_chain_table_lengths[facidx]; + int rc = Z_OK; - fstFread(mc, xc->rvat_chain_table_lengths[facidx], 1, xc->f); + fstFread(mc, xc->rvat_chain_table_lengths[facidx], 1, xc->f); - switch(xc->rvat_packtype) - { - case '4': rc = (destlen == (unsigned long)LZ4_decompress_safe_partial((char *)mc, (char *)mu, sourcelen, destlen, destlen)) ? Z_OK : Z_DATA_ERROR; - break; - case 'F': fastlz_decompress(mc, sourcelen, mu, destlen); /* rc appears unreliable */ - break; - default: rc = uncompress(mu, &destlen, mc, sourcelen); - break; - } + switch (xc->rvat_packtype) { + case '4': + rc = (destlen == (unsigned long)LZ4_decompress_safe_partial((char *)mc, + (char *)mu, + sourcelen, + destlen, + destlen)) + ? Z_OK + : Z_DATA_ERROR; + break; + case 'F': + fastlz_decompress(mc, sourcelen, mu, destlen); /* rc appears unreliable */ + break; + default: + rc = uncompress(mu, &destlen, mc, sourcelen); + break; + } - free(mc); + free(mc); - if(rc != Z_OK) - { - fprintf(stderr, FST_APIMESS "fstReaderGetValueFromHandleAtTime(), rvat decompress clen: %d (rc=%d), exiting.\n", (int)xc->rvat_chain_len, rc); - exit(255); - } + if (rc != Z_OK) { + fprintf(stderr, + FST_APIMESS "fstReaderGetValueFromHandleAtTime(), rvat decompress clen: %d " + "(rc=%d), exiting.\n", + (int)xc->rvat_chain_len, + rc); + exit(255); + } - /* data to process is for(j=0;jrvat_chain_mem = mu; - } - else - { - int destlen = xc->rvat_chain_table_lengths[facidx] - skiplen; - unsigned char *mu = (unsigned char *)malloc(xc->rvat_chain_len = destlen); - fstFread(mu, destlen, 1, xc->f); - /* data to process is for(j=0;jrvat_chain_mem = mu; - } + /* data to process is for(j=0;jrvat_chain_mem = mu; + } else { + int destlen = xc->rvat_chain_table_lengths[facidx] - skiplen; + unsigned char *mu = (unsigned char *)malloc(xc->rvat_chain_len = destlen); + fstFread(mu, destlen, 1, xc->f); + /* data to process is for(j=0;jrvat_chain_mem = mu; + } xc->rvat_chain_facidx = facidx; + } + + /* process value chain here */ + + { + uint32_t tidx = 0, ptidx = 0; + uint32_t tdelta; + int skiplen; + unsigned int iprev = xc->rvat_chain_len; + uint32_t pvli = 0; + int pskip = 0; + + if ((xc->rvat_chain_pos_valid) && (tim >= xc->rvat_chain_pos_time)) { + i = xc->rvat_chain_pos_idx; + tidx = xc->rvat_chain_pos_tidx; + } else { + i = 0; + tidx = 0; + xc->rvat_chain_pos_time = xc->rvat_beg_tim; } -/* process value chain here */ - -{ -uint32_t tidx = 0, ptidx = 0; -uint32_t tdelta; -int skiplen; -unsigned int iprev = xc->rvat_chain_len; -uint32_t pvli = 0; -int pskip = 0; - -if((xc->rvat_chain_pos_valid)&&(tim >= xc->rvat_chain_pos_time)) - { - i = xc->rvat_chain_pos_idx; - tidx = xc->rvat_chain_pos_tidx; - } - else - { - i = 0; - tidx = 0; - xc->rvat_chain_pos_time = xc->rvat_beg_tim; - } - -if(xc->signal_lens[facidx] == 1) - { - while(irvat_chain_len) - { + if (xc->signal_lens[facidx] == 1) { + while (i < xc->rvat_chain_len) { uint32_t vli = fstGetVarint32(xc->rvat_chain_mem + i, &skiplen); uint32_t shcnt = 2 << (vli & 1); tdelta = vli >> shcnt; - if(xc->rvat_time_table[tidx + tdelta] <= tim) - { - iprev = i; - pvli = vli; - ptidx = tidx; - /* pskip = skiplen; */ /* scan-build */ + if (xc->rvat_time_table[tidx + tdelta] <= tim) { + iprev = i; + pvli = vli; + ptidx = tidx; + /* pskip = skiplen; */ /* scan-build */ - tidx += tdelta; - i+=skiplen; - } - else - { - break; - } + tidx += tdelta; + i += skiplen; + } else { + break; } - if(iprev != xc->rvat_chain_len) - { + } + if (iprev != xc->rvat_chain_len) { xc->rvat_chain_pos_tidx = ptidx; xc->rvat_chain_pos_idx = iprev; xc->rvat_chain_pos_time = tim; xc->rvat_chain_pos_valid = 1; - if(!(pvli & 1)) - { - buf[0] = ((pvli >> 1) & 1) | '0'; - } - else - { - buf[0] = FST_RCV_STR[((pvli >> 1) & 7)]; - } + if (!(pvli & 1)) { + buf[0] = ((pvli >> 1) & 1) | '0'; + } else { + buf[0] = FST_RCV_STR[((pvli >> 1) & 7)]; + } buf[1] = 0; - return(buf); - } - else - { - return(fstExtractRvatDataFromFrame(xc, facidx, buf)); - } - } - else - { - while(irvat_chain_len) - { + return (buf); + } else { + return (fstExtractRvatDataFromFrame(xc, facidx, buf)); + } + } else { + while (i < xc->rvat_chain_len) { uint32_t vli = fstGetVarint32(xc->rvat_chain_mem + i, &skiplen); tdelta = vli >> 1; - if(xc->rvat_time_table[tidx + tdelta] <= tim) - { - iprev = i; - pvli = vli; - ptidx = tidx; - pskip = skiplen; + if (xc->rvat_time_table[tidx + tdelta] <= tim) { + iprev = i; + pvli = vli; + ptidx = tidx; + pskip = skiplen; - tidx += tdelta; - i+=skiplen; + tidx += tdelta; + i += skiplen; - if(!(pvli & 1)) - { - i+=((xc->signal_lens[facidx]+7)/8); - } - else - { - i+=xc->signal_lens[facidx]; - } - } - else - { - break; - } + if (!(pvli & 1)) { + i += ((xc->signal_lens[facidx] + 7) / 8); + } else { + i += xc->signal_lens[facidx]; + } + } else { + break; } + } - if(iprev != xc->rvat_chain_len) - { + if (iprev != xc->rvat_chain_len) { unsigned char *vdata = xc->rvat_chain_mem + iprev + pskip; xc->rvat_chain_pos_tidx = ptidx; @@ -6714,93 +6444,72 @@ if(xc->signal_lens[facidx] == 1) xc->rvat_chain_pos_time = tim; xc->rvat_chain_pos_valid = 1; - if(xc->signal_typs[facidx] != FST_VT_VCD_REAL) - { - if(!(pvli & 1)) - { - int byte = 0; - int bit; - unsigned int j; + if (xc->signal_typs[facidx] != FST_VT_VCD_REAL) { + if (!(pvli & 1)) { + int byte = 0; + int bit; + unsigned int j; - for(j=0;jsignal_lens[facidx];j++) - { - unsigned char ch; - byte = j/8; - bit = 7 - (j & 7); - ch = ((vdata[byte] >> bit) & 1) | '0'; - buf[j] = ch; - } - buf[j] = 0; - - return(buf); - } - else - { - memcpy(buf, vdata, xc->signal_lens[facidx]); - buf[xc->signal_lens[facidx]] = 0; - return(buf); - } + for (j = 0; j < xc->signal_lens[facidx]; j++) { + unsigned char ch; + byte = j / 8; + bit = 7 - (j & 7); + ch = ((vdata[byte] >> bit) & 1) | '0'; + buf[j] = ch; } - else - { - double d; - unsigned char *clone_d = (unsigned char *)&d; - unsigned char bufd[8]; - unsigned char *srcdata; + buf[j] = 0; - if(!(pvli & 1)) /* very rare case, but possible */ - { - int bit; - int j; + return (buf); + } else { + memcpy(buf, vdata, xc->signal_lens[facidx]); + buf[xc->signal_lens[facidx]] = 0; + return (buf); + } + } else { + double d; + unsigned char *clone_d = (unsigned char *)&d; + unsigned char bufd[8]; + unsigned char *srcdata; - for(j=0;j<8;j++) - { - unsigned char ch; - bit = 7 - (j & 7); - ch = ((vdata[0] >> bit) & 1) | '0'; - bufd[j] = ch; - } + if (!(pvli & 1)) /* very rare case, but possible */ + { + int bit; + int j; - srcdata = bufd; - } - else - { - srcdata = vdata; - } - - if(xc->double_endian_match) - { - memcpy(clone_d, srcdata, 8); - } - else - { - int j; - - for(j=0;j<8;j++) - { - clone_d[j] = srcdata[7-j]; - } - } - - snprintf(buf, 32, "r%.16g", d); /* this will write 19 bytes */ - return(buf); + for (j = 0; j < 8; j++) { + unsigned char ch; + bit = 7 - (j & 7); + ch = ((vdata[0] >> bit) & 1) | '0'; + bufd[j] = ch; } + + srcdata = bufd; + } else { + srcdata = vdata; + } + + if (xc->double_endian_match) { + memcpy(clone_d, srcdata, 8); + } else { + int j; + + for (j = 0; j < 8; j++) { + clone_d[j] = srcdata[7 - j]; + } + } + + snprintf(buf, 32, "r%.16g", d); /* this will write 19 bytes */ + return (buf); } - else - { - return(fstExtractRvatDataFromFrame(xc, facidx, buf)); - } + } else { + return (fstExtractRvatDataFromFrame(xc, facidx, buf)); + } } + } + + /* return(NULL); */ } -/* return(NULL); */ -} - - - -/**********************************************************************/ -#ifndef _WAVE_HAVE_JUDY - /***********************/ /*** ***/ /*** jenkins hash ***/ @@ -6833,18 +6542,36 @@ mix() was built out of 36 single-cycle latency instructions in a to choose from. I only looked at a billion or so. -------------------------------------------------------------------- */ -#define mix(a,b,c) \ -{ \ - a -= b; a -= c; a ^= (c>>13); \ - b -= c; b -= a; b ^= (a<<8); \ - c -= a; c -= b; c ^= (b>>13); \ - a -= b; a -= c; a ^= (c>>12); \ - b -= c; b -= a; b ^= (a<<16); \ - c -= a; c -= b; c ^= (b>>5); \ - a -= b; a -= c; a ^= (c>>3); \ - b -= c; b -= a; b ^= (a<<10); \ - c -= a; c -= b; c ^= (b>>15); \ -} +#define mix(a, b, c) \ + { \ + a -= b; \ + a -= c; \ + a ^= (c >> 13); \ + b -= c; \ + b -= a; \ + b ^= (a << 8); \ + c -= a; \ + c -= b; \ + c ^= (b >> 13); \ + a -= b; \ + a -= c; \ + a ^= (c >> 12); \ + b -= c; \ + b -= a; \ + b ^= (a << 16); \ + c -= a; \ + c -= b; \ + c ^= (b >> 5); \ + a -= b; \ + a -= c; \ + a ^= (c >> 3); \ + b -= c; \ + b -= a; \ + b ^= (a << 10); \ + c -= a; \ + c -= b; \ + c ^= (b >> 15); \ + } /* -------------------------------------------------------------------- @@ -6876,44 +6603,55 @@ acceptable. Do NOT use for cryptographic purposes. static uint32_t j_hash(const uint8_t *k, uint32_t length, uint32_t initval) { - uint32_t a,b,c,len; + uint32_t a, b, c, len; - /* Set up the internal state */ - len = length; - a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */ - c = initval; /* the previous hash value */ + /* Set up the internal state */ + len = length; + a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */ + c = initval; /* the previous hash value */ - /*---------------------------------------- handle most of the key */ - while (len >= 12) - { - a += (k[0] +((uint32_t)k[1]<<8) +((uint32_t)k[2]<<16) +((uint32_t)k[3]<<24)); - b += (k[4] +((uint32_t)k[5]<<8) +((uint32_t)k[6]<<16) +((uint32_t)k[7]<<24)); - c += (k[8] +((uint32_t)k[9]<<8) +((uint32_t)k[10]<<16)+((uint32_t)k[11]<<24)); - mix(a,b,c); - k += 12; len -= 12; - } + /*---------------------------------------- handle most of the key */ + while (len >= 12) { + a += (k[0] + ((uint32_t)k[1] << 8) + ((uint32_t)k[2] << 16) + ((uint32_t)k[3] << 24)); + b += (k[4] + ((uint32_t)k[5] << 8) + ((uint32_t)k[6] << 16) + ((uint32_t)k[7] << 24)); + c += (k[8] + ((uint32_t)k[9] << 8) + ((uint32_t)k[10] << 16) + ((uint32_t)k[11] << 24)); + mix(a, b, c); + k += 12; + len -= 12; + } - /*------------------------------------- handle the last 11 bytes */ - c += length; - switch(len) /* all the case statements fall through */ - { - case 11: c+=((uint32_t)k[10]<<24); /* fallthrough */ - case 10: c+=((uint32_t)k[9]<<16); /* fallthrough */ - case 9 : c+=((uint32_t)k[8]<<8); /* fallthrough */ - /* the first byte of c is reserved for the length */ - case 8 : b+=((uint32_t)k[7]<<24); /* fallthrough */ - case 7 : b+=((uint32_t)k[6]<<16); /* fallthrough */ - case 6 : b+=((uint32_t)k[5]<<8); /* fallthrough */ - case 5 : b+=k[4]; /* fallthrough */ - case 4 : a+=((uint32_t)k[3]<<24); /* fallthrough */ - case 3 : a+=((uint32_t)k[2]<<16); /* fallthrough */ - case 2 : a+=((uint32_t)k[1]<<8); /* fallthrough */ - case 1 : a+=k[0]; - /* case 0: nothing left to add */ - } - mix(a,b,c); - /*-------------------------------------------- report the result */ - return(c); + /*------------------------------------- handle the last 11 bytes */ + c += length; + switch (len) /* all the case statements fall through */ + { + case 11: + c += ((uint32_t)k[10] << 24); /* fallthrough */ + case 10: + c += ((uint32_t)k[9] << 16); /* fallthrough */ + case 9: + c += ((uint32_t)k[8] << 8); /* fallthrough */ + /* the first byte of c is reserved for the length */ + case 8: + b += ((uint32_t)k[7] << 24); /* fallthrough */ + case 7: + b += ((uint32_t)k[6] << 16); /* fallthrough */ + case 6: + b += ((uint32_t)k[5] << 8); /* fallthrough */ + case 5: + b += k[4]; /* fallthrough */ + case 4: + a += ((uint32_t)k[3] << 24); /* fallthrough */ + case 3: + a += ((uint32_t)k[2] << 16); /* fallthrough */ + case 2: + a += ((uint32_t)k[1] << 8); /* fallthrough */ + case 1: + a += k[0]; + /* case 0: nothing left to add */ + } + mix(a, b, c); + /*-------------------------------------------- report the result */ + return (c); } /********************************************************************/ @@ -6926,83 +6664,74 @@ static uint32_t j_hash(const uint8_t *k, uint32_t length, uint32_t initval) struct collchain_t { -struct collchain_t *next; -void *payload; -uint32_t fullhash, length; -unsigned char mem[1]; + struct collchain_t *next; + void *payload; + uint32_t fullhash, length; + unsigned char mem[1]; }; - void **JenkinsIns(void *base_i, const unsigned char *mem, uint32_t length, uint32_t hashmask) { -struct collchain_t ***base = (struct collchain_t ***)base_i; -uint32_t hf, h; -struct collchain_t **ar; -struct collchain_t *chain, *pchain; + struct collchain_t ***base = (struct collchain_t ***)base_i; + uint32_t hf, h; + struct collchain_t **ar; + struct collchain_t *chain, *pchain; -if(!*base) - { + if (!*base) { *base = (struct collchain_t **)calloc(1, (hashmask + 1) * sizeof(void *)); - } -ar = *base; + } + ar = *base; -h = (hf = j_hash(mem, length, length)) & hashmask; -pchain = chain = ar[h]; -while(chain) - { - if((chain->fullhash == hf) && (chain->length == length) && !memcmp(chain->mem, mem, length)) - { - if(pchain != chain) /* move hit to front */ - { - pchain->next = chain->next; - chain->next = ar[h]; - ar[h] = chain; - } - return(&(chain->payload)); - } + h = (hf = j_hash(mem, length, length)) & hashmask; + pchain = chain = ar[h]; + while (chain) { + if ((chain->fullhash == hf) && (chain->length == length) && + !memcmp(chain->mem, mem, length)) { + if (pchain != chain) /* move hit to front */ + { + pchain->next = chain->next; + chain->next = ar[h]; + ar[h] = chain; + } + return (&(chain->payload)); + } pchain = chain; chain = chain->next; - } + } -chain = (struct collchain_t *)calloc(1, sizeof(struct collchain_t) + length - 1); -memcpy(chain->mem, mem, length); -chain->fullhash = hf; -chain->length = length; -chain->next = ar[h]; -ar[h] = chain; -return(&(chain->payload)); + chain = (struct collchain_t *)calloc(1, sizeof(struct collchain_t) + length - 1); + memcpy(chain->mem, mem, length); + chain->fullhash = hf; + chain->length = length; + chain->next = ar[h]; + ar[h] = chain; + return (&(chain->payload)); } - void JenkinsFree(void *base_i, uint32_t hashmask) { -struct collchain_t ***base = (struct collchain_t ***)base_i; -uint32_t h; -struct collchain_t **ar; -struct collchain_t *chain, *chain_next; + struct collchain_t ***base = (struct collchain_t ***)base_i; + uint32_t h; + struct collchain_t **ar; + struct collchain_t *chain, *chain_next; -if(base && *base) - { + if (base && *base) { ar = *base; - for(h=0;h<=hashmask;h++) - { - chain = ar[h]; - while(chain) - { - chain_next = chain->next; - free(chain); - chain = chain_next; - } - } + for (h = 0; h <= hashmask; h++) { + chain = ar[h]; + while (chain) { + chain_next = chain->next; + free(chain); + chain = chain_next; + } + } free(*base); *base = NULL; - } + } } -#endif - /**********************************************************************/ /************************/ @@ -7013,212 +6742,266 @@ if(base && *base) int fstUtilityBinToEscConvertedLen(const unsigned char *s, int len) { -const unsigned char *src = s; -int dlen = 0; -int i; + const unsigned char *src = s; + int dlen = 0; + int i; -for(i=0;i ' ') && (src[i] <= '~')) /* no white spaces in output */ { - 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; + dlen++; + } else { + dlen += 4; } + break; } + } -return(dlen); + 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; + const unsigned char *src = s; + unsigned char *dst = d; + unsigned char val; + int i; -for(i=0;i ' ') && (src[i] <= '~')) /* no white spaces in output */ { - case '\a': *(dst++) = '\\'; *(dst++) = 'a'; break; - case '\b': *(dst++) = '\\'; *(dst++) = 'b'; break; - case '\f': *(dst++) = '\\'; *(dst++) = 'f'; break; - case '\n': *(dst++) = '\\'; *(dst++) = 'n'; break; - case '\r': *(dst++) = '\\'; *(dst++) = 'r'; break; - case '\t': *(dst++) = '\\'; *(dst++) = 't'; break; - case '\v': *(dst++) = '\\'; *(dst++) = 'v'; break; - case '\'': *(dst++) = '\\'; *(dst++) = '\''; break; - case '\"': *(dst++) = '\\'; *(dst++) = '\"'; break; - case '\\': *(dst++) = '\\'; *(dst++) = '\\'; break; - case '\?': *(dst++) = '\\'; *(dst++) = '\?'; break; - default: if((src[i] > ' ') && (src[i] <= '~')) /* no white spaces in output */ - { - *(dst++) = src[i]; - } - else - { - val = src[i]; - *(dst++) = '\\'; - *(dst++) = (val/64) + '0'; val = val & 63; - *(dst++) = (val/8) + '0'; val = val & 7; - *(dst++) = (val) + '0'; - } - break; + *(dst++) = src[i]; + } else { + val = src[i]; + *(dst++) = '\\'; + *(dst++) = (val / 64) + '0'; + val = val & 63; + *(dst++) = (val / 8) + '0'; + val = val & 7; + *(dst++) = (val) + '0'; } + break; } + } -return(dst - d); + return (dst - d); } - /* * this overwrites the original string if the destination pointer is NULL */ int fstUtilityEscToBin(unsigned char *d, unsigned char *s, int len) { -unsigned char *src = s; -unsigned char *dst = (!d) ? s : (s = d); -unsigned char val[3]; -int i; + unsigned char *src = s; + unsigned char *dst = (!d) ? s : (s = d); + unsigned char val[3]; + int i; -for(i=0;i='A')&&(val[0]<='F')) ? (val[0] - 'A' + 10) : (val[0] - '0'); - val[1] = ((val[1]>='A')&&(val[1]<='F')) ? (val[1] - 'A' + 10) : (val[1] - '0'); - *(dst++) = val[0] * 16 + val[1]; - break; + case 'x': + val[0] = toupper(src[++i]); + val[1] = toupper(src[++i]); + val[0] = + ((val[0] >= 'A') && (val[0] <= 'F')) ? (val[0] - 'A' + 10) : (val[0] - '0'); + val[1] = + ((val[1] >= 'A') && (val[1] <= 'F')) ? (val[1] - 'A' + 10) : (val[1] - '0'); + *(dst++) = val[0] * 16 + val[1]; + break; - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': val[0] = src[ i] - '0'; - val[1] = src[++i] - '0'; - val[2] = src[++i] - '0'; - *(dst++) = val[0] * 64 + val[1] * 8 + val[2]; - break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + val[0] = src[i] - '0'; + val[1] = src[++i] - '0'; + val[2] = src[++i] - '0'; + *(dst++) = val[0] * 64 + val[1] * 8 + val[2]; + break; - default: *(dst++) = src[i]; break; - } - } + default: + *(dst++) = src[i]; + break; + } } + } -return(dst - s); + return (dst - s); } - struct fstETab *fstUtilityExtractEnumTableFromString(const char *s) { -struct fstETab *et = NULL; -int num_spaces = 0; -int i; -int newlen; + struct fstETab *et = NULL; + int num_spaces = 0; + int i; + int newlen; -if(s) - { - const char *csp = strchr(s, ' '); - int cnt = atoi(csp+1); + if (s) { + const char *csp = strchr(s, ' '); + int cnt = atoi(csp + 1); - for(;;) - { - csp = strchr(csp+1, ' '); - if(csp) { num_spaces++; } else { break; } - } + for (;;) { + csp = strchr(csp + 1, ' '); + if (csp) { + num_spaces++; + } else { + break; + } + } - if(num_spaces == (2*cnt)) - { - char *sp, *sp2; + 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 *)); + 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(et->name, ' '); + *sp = 0; - sp = strchr(sp+1, ' '); + sp = strchr(sp + 1, ' '); - for(i=0;iliteral_arr[i] = sp+1; - sp = sp2; + 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; - } + newlen = fstUtilityEscToBin(NULL, + (unsigned char *)et->literal_arr[i], + strlen(et->literal_arr[i])); + et->literal_arr[i][newlen] = 0; + } - for(i=0;ival_arr[i] = sp+1; - sp = sp2; + 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; - } - } - } + newlen = fstUtilityEscToBin(NULL, + (unsigned char *)et->val_arr[i], + strlen(et->val_arr[i])); + et->val_arr[i][newlen] = 0; + } + } + } -return(et); + return (et); } - void fstUtilityFreeEnumTable(struct fstETab *etab) { -if(etab) - { - free(etab->literal_arr); - free(etab->val_arr); - free(etab->name); - free(etab); - } + if (etab) { + free(etab->literal_arr); + free(etab->val_arr); + free(etab->name); + free(etab); + } } diff --git a/libs/fst/fstapi.h b/libs/fst/fstapi.h index ba58c2017..cace48951 100644 --- a/libs/fst/fstapi.h +++ b/libs/fst/fstapi.h @@ -26,7 +26,8 @@ #define FST_API_H #ifdef __cplusplus -extern "C" { +extern "C" +{ #endif #include @@ -35,430 +36,510 @@ extern "C" { #include #include #if defined(_MSC_VER) - #include "libs/zlib/zlib.h" - #include "fst_win_unistd.h" +#include "libs/zlib/zlib.h" +#include "fst_win_unistd.h" #else - #include - #include +#include +#include #endif #include -#define FST_RDLOAD "FSTLOAD | " - typedef uint32_t fstHandle; typedef uint32_t fstEnumHandle; -enum fstWriterPackType { - FST_WR_PT_ZLIB = 0, - FST_WR_PT_FASTLZ = 1, - FST_WR_PT_LZ4 = 2 +enum fstWriterPackType +{ + FST_WR_PT_ZLIB = 0, + FST_WR_PT_FASTLZ = 1, + FST_WR_PT_LZ4 = 2 }; -enum fstFileType { - FST_FT_MIN = 0, +enum fstFileType +{ + FST_FT_MIN = 0, - FST_FT_VERILOG = 0, - FST_FT_VHDL = 1, - FST_FT_VERILOG_VHDL = 2, + FST_FT_VERILOG = 0, + FST_FT_VHDL = 1, + FST_FT_VERILOG_VHDL = 2, - FST_FT_MAX = 2 + FST_FT_MAX = 2 }; -enum fstBlockType { - FST_BL_HDR = 0, - FST_BL_VCDATA = 1, - FST_BL_BLACKOUT = 2, - FST_BL_GEOM = 3, - FST_BL_HIER = 4, - FST_BL_VCDATA_DYN_ALIAS = 5, - FST_BL_HIER_LZ4 = 6, - FST_BL_HIER_LZ4DUO = 7, - FST_BL_VCDATA_DYN_ALIAS2 = 8, +enum fstBlockType +{ + FST_BL_HDR = 0, + FST_BL_VCDATA = 1, + FST_BL_BLACKOUT = 2, + FST_BL_GEOM = 3, + FST_BL_HIER = 4, + FST_BL_VCDATA_DYN_ALIAS = 5, + FST_BL_HIER_LZ4 = 6, + FST_BL_HIER_LZ4DUO = 7, + FST_BL_VCDATA_DYN_ALIAS2 = 8, - FST_BL_ZWRAPPER = 254, /* indicates that whole trace is gz wrapped */ - FST_BL_SKIP = 255 /* used while block is being written */ + FST_BL_ZWRAPPER = 254, /* indicates that whole trace is gz wrapped */ + FST_BL_SKIP = 255 /* used while block is being written */ }; -enum fstScopeType { - FST_ST_MIN = 0, +enum fstScopeType +{ + FST_ST_MIN = 0, - FST_ST_VCD_MODULE = 0, - FST_ST_VCD_TASK = 1, - FST_ST_VCD_FUNCTION = 2, - FST_ST_VCD_BEGIN = 3, - FST_ST_VCD_FORK = 4, - FST_ST_VCD_GENERATE = 5, - FST_ST_VCD_STRUCT = 6, - FST_ST_VCD_UNION = 7, - FST_ST_VCD_CLASS = 8, - FST_ST_VCD_INTERFACE = 9, - FST_ST_VCD_PACKAGE = 10, - FST_ST_VCD_PROGRAM = 11, + FST_ST_VCD_MODULE = 0, + FST_ST_VCD_TASK = 1, + FST_ST_VCD_FUNCTION = 2, + FST_ST_VCD_BEGIN = 3, + FST_ST_VCD_FORK = 4, + FST_ST_VCD_GENERATE = 5, + FST_ST_VCD_STRUCT = 6, + FST_ST_VCD_UNION = 7, + FST_ST_VCD_CLASS = 8, + FST_ST_VCD_INTERFACE = 9, + FST_ST_VCD_PACKAGE = 10, + FST_ST_VCD_PROGRAM = 11, - FST_ST_VHDL_ARCHITECTURE = 12, - FST_ST_VHDL_PROCEDURE = 13, - FST_ST_VHDL_FUNCTION = 14, - FST_ST_VHDL_RECORD = 15, - FST_ST_VHDL_PROCESS = 16, - FST_ST_VHDL_BLOCK = 17, - FST_ST_VHDL_FOR_GENERATE = 18, - FST_ST_VHDL_IF_GENERATE = 19, - FST_ST_VHDL_GENERATE = 20, - FST_ST_VHDL_PACKAGE = 21, + FST_ST_VHDL_ARCHITECTURE = 12, + FST_ST_VHDL_PROCEDURE = 13, + FST_ST_VHDL_FUNCTION = 14, + FST_ST_VHDL_RECORD = 15, + FST_ST_VHDL_PROCESS = 16, + FST_ST_VHDL_BLOCK = 17, + FST_ST_VHDL_FOR_GENERATE = 18, + FST_ST_VHDL_IF_GENERATE = 19, + FST_ST_VHDL_GENERATE = 20, + FST_ST_VHDL_PACKAGE = 21, - FST_ST_MAX = 21, + FST_ST_MAX = 21, - FST_ST_GEN_ATTRBEGIN = 252, - FST_ST_GEN_ATTREND = 253, + FST_ST_GEN_ATTRBEGIN = 252, + FST_ST_GEN_ATTREND = 253, - FST_ST_VCD_SCOPE = 254, - FST_ST_VCD_UPSCOPE = 255 + FST_ST_VCD_SCOPE = 254, + FST_ST_VCD_UPSCOPE = 255 }; -enum fstVarType { - FST_VT_MIN = 0, /* start of vartypes */ +enum fstVarType +{ + FST_VT_MIN = 0, /* start of vartypes */ - FST_VT_VCD_EVENT = 0, - FST_VT_VCD_INTEGER = 1, - FST_VT_VCD_PARAMETER = 2, - FST_VT_VCD_REAL = 3, - FST_VT_VCD_REAL_PARAMETER = 4, - FST_VT_VCD_REG = 5, - FST_VT_VCD_SUPPLY0 = 6, - FST_VT_VCD_SUPPLY1 = 7, - FST_VT_VCD_TIME = 8, - FST_VT_VCD_TRI = 9, - FST_VT_VCD_TRIAND = 10, - FST_VT_VCD_TRIOR = 11, - FST_VT_VCD_TRIREG = 12, - FST_VT_VCD_TRI0 = 13, - FST_VT_VCD_TRI1 = 14, - FST_VT_VCD_WAND = 15, - FST_VT_VCD_WIRE = 16, - FST_VT_VCD_WOR = 17, - FST_VT_VCD_PORT = 18, - FST_VT_VCD_SPARRAY = 19, /* used to define the rownum (index) port for a sparse array */ - FST_VT_VCD_REALTIME = 20, + FST_VT_VCD_EVENT = 0, + FST_VT_VCD_INTEGER = 1, + FST_VT_VCD_PARAMETER = 2, + FST_VT_VCD_REAL = 3, + FST_VT_VCD_REAL_PARAMETER = 4, + FST_VT_VCD_REG = 5, + FST_VT_VCD_SUPPLY0 = 6, + FST_VT_VCD_SUPPLY1 = 7, + FST_VT_VCD_TIME = 8, + FST_VT_VCD_TRI = 9, + FST_VT_VCD_TRIAND = 10, + FST_VT_VCD_TRIOR = 11, + FST_VT_VCD_TRIREG = 12, + FST_VT_VCD_TRI0 = 13, + FST_VT_VCD_TRI1 = 14, + FST_VT_VCD_WAND = 15, + FST_VT_VCD_WIRE = 16, + FST_VT_VCD_WOR = 17, + FST_VT_VCD_PORT = 18, + FST_VT_VCD_SPARRAY = 19, /* used to define the rownum (index) port for a sparse array */ + FST_VT_VCD_REALTIME = 20, - FST_VT_GEN_STRING = 21, /* generic string type (max len is defined dynamically via fstWriterEmitVariableLengthValueChange) */ + FST_VT_GEN_STRING = 21, /* generic string type (max len is defined dynamically via + fstWriterEmitVariableLengthValueChange) */ - FST_VT_SV_BIT = 22, - FST_VT_SV_LOGIC = 23, - FST_VT_SV_INT = 24, /* declare as size = 32 */ - FST_VT_SV_SHORTINT = 25, /* declare as size = 16 */ - FST_VT_SV_LONGINT = 26, /* declare as size = 64 */ - FST_VT_SV_BYTE = 27, /* declare as size = 8 */ - FST_VT_SV_ENUM = 28, /* declare as appropriate type range */ - FST_VT_SV_SHORTREAL = 29, /* declare and emit same as FST_VT_VCD_REAL (needs to be emitted as double, not a float) */ + FST_VT_SV_BIT = 22, + FST_VT_SV_LOGIC = 23, + FST_VT_SV_INT = 24, /* declare as size = 32 */ + FST_VT_SV_SHORTINT = 25, /* declare as size = 16 */ + FST_VT_SV_LONGINT = 26, /* declare as size = 64 */ + FST_VT_SV_BYTE = 27, /* declare as size = 8 */ + FST_VT_SV_ENUM = 28, /* declare as appropriate type range */ + FST_VT_SV_SHORTREAL = 29, /* declare and emit same as FST_VT_VCD_REAL (needs to be emitted + as double, not a float) */ - FST_VT_MAX = 29 /* end of vartypes */ + FST_VT_MAX = 29 /* end of vartypes */ }; -enum fstVarDir { - FST_VD_MIN = 0, +enum fstVarDir +{ + FST_VD_MIN = 0, - FST_VD_IMPLICIT = 0, - FST_VD_INPUT = 1, - FST_VD_OUTPUT = 2, - FST_VD_INOUT = 3, - FST_VD_BUFFER = 4, - FST_VD_LINKAGE = 5, + FST_VD_IMPLICIT = 0, + FST_VD_INPUT = 1, + FST_VD_OUTPUT = 2, + FST_VD_INOUT = 3, + FST_VD_BUFFER = 4, + FST_VD_LINKAGE = 5, - FST_VD_MAX = 5 + FST_VD_MAX = 5 }; -enum fstHierType { - FST_HT_MIN = 0, +enum fstHierType +{ + FST_HT_MIN = 0, - FST_HT_SCOPE = 0, - FST_HT_UPSCOPE = 1, - FST_HT_VAR = 2, - FST_HT_ATTRBEGIN = 3, - FST_HT_ATTREND = 4, + FST_HT_SCOPE = 0, + FST_HT_UPSCOPE = 1, + FST_HT_VAR = 2, + FST_HT_ATTRBEGIN = 3, + FST_HT_ATTREND = 4, - /* FST_HT_TREEBEGIN and FST_HT_TREEEND are not yet used by FST but are currently used when fstHier bridges other formats */ - FST_HT_TREEBEGIN = 5, - FST_HT_TREEEND = 6, + /* FST_HT_TREEBEGIN and FST_HT_TREEEND are not yet used by FST but are currently used when + fstHier bridges other formats */ + FST_HT_TREEBEGIN = 5, + FST_HT_TREEEND = 6, - FST_HT_MAX = 6 + FST_HT_MAX = 6 }; -enum fstAttrType { - FST_AT_MIN = 0, +enum fstAttrType +{ + FST_AT_MIN = 0, - FST_AT_MISC = 0, /* self-contained: does not need matching FST_HT_ATTREND */ - FST_AT_ARRAY = 1, - FST_AT_ENUM = 2, - FST_AT_PACK = 3, + FST_AT_MISC = 0, /* self-contained: does not need matching FST_HT_ATTREND */ + FST_AT_ARRAY = 1, + FST_AT_ENUM = 2, + FST_AT_PACK = 3, - FST_AT_MAX = 3 + FST_AT_MAX = 3 }; -enum fstMiscType { - FST_MT_MIN = 0, +enum fstMiscType +{ + FST_MT_MIN = 0, - FST_MT_COMMENT = 0, /* use fstWriterSetComment() to emit */ - FST_MT_ENVVAR = 1, /* use fstWriterSetEnvVar() to emit */ - FST_MT_SUPVAR = 2, /* use fstWriterCreateVar2() to emit */ - FST_MT_PATHNAME = 3, /* reserved for fstWriterSetSourceStem() string -> number management */ - 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_ENUMTABLE = 7, /* use fstWriterCreateEnumTable() and fstWriterEmitEnumTableRef() to emit */ - FST_MT_UNKNOWN = 8, + FST_MT_COMMENT = 0, /* use fstWriterSetComment() to emit */ + FST_MT_ENVVAR = 1, /* use fstWriterSetEnvVar() to emit */ + FST_MT_SUPVAR = 2, /* use fstWriterCreateVar2() to emit */ + FST_MT_PATHNAME = 3, /* reserved for fstWriterSetSourceStem() string -> number management */ + 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_ENUMTABLE = + 7, /* use fstWriterCreateEnumTable() and fstWriterEmitEnumTableRef() to emit */ + FST_MT_UNKNOWN = 8, - FST_MT_MAX = 8 + FST_MT_MAX = 8 }; -enum fstArrayType { - FST_AR_MIN = 0, +enum fstArrayType +{ + FST_AR_MIN = 0, - FST_AR_NONE = 0, - FST_AR_UNPACKED = 1, - FST_AR_PACKED = 2, - FST_AR_SPARSE = 3, + FST_AR_NONE = 0, + FST_AR_UNPACKED = 1, + FST_AR_PACKED = 2, + FST_AR_SPARSE = 3, - FST_AR_MAX = 3 + FST_AR_MAX = 3 }; -enum fstEnumValueType { - FST_EV_SV_INTEGER = 0, - FST_EV_SV_BIT = 1, - FST_EV_SV_LOGIC = 2, - FST_EV_SV_INT = 3, - FST_EV_SV_SHORTINT = 4, - FST_EV_SV_LONGINT = 5, - FST_EV_SV_BYTE = 6, - FST_EV_SV_UNSIGNED_INTEGER = 7, - FST_EV_SV_UNSIGNED_BIT = 8, - FST_EV_SV_UNSIGNED_LOGIC = 9, - FST_EV_SV_UNSIGNED_INT = 10, +enum fstEnumValueType +{ + FST_EV_SV_INTEGER = 0, + FST_EV_SV_BIT = 1, + FST_EV_SV_LOGIC = 2, + FST_EV_SV_INT = 3, + FST_EV_SV_SHORTINT = 4, + FST_EV_SV_LONGINT = 5, + FST_EV_SV_BYTE = 6, + FST_EV_SV_UNSIGNED_INTEGER = 7, + FST_EV_SV_UNSIGNED_BIT = 8, + FST_EV_SV_UNSIGNED_LOGIC = 9, + FST_EV_SV_UNSIGNED_INT = 10, FST_EV_SV_UNSIGNED_SHORTINT = 11, - FST_EV_SV_UNSIGNED_LONGINT = 12, - FST_EV_SV_UNSIGNED_BYTE = 13, + FST_EV_SV_UNSIGNED_LONGINT = 12, + FST_EV_SV_UNSIGNED_BYTE = 13, - FST_EV_REG = 14, - FST_EV_TIME = 15, + FST_EV_REG = 14, + FST_EV_TIME = 15, - FST_EV_MAX = 15 + FST_EV_MAX = 15 }; -enum fstPackType { - FST_PT_NONE = 0, - FST_PT_UNPACKED = 1, - FST_PT_PACKED = 2, +enum fstPackType +{ + FST_PT_NONE = 0, + FST_PT_UNPACKED = 1, + FST_PT_PACKED = 2, FST_PT_TAGGED_PACKED = 3, - FST_PT_MAX = 3 + FST_PT_MAX = 3 }; -enum fstSupplementalVarType { - FST_SVT_MIN = 0, +enum fstSupplementalVarType +{ + FST_SVT_MIN = 0, - FST_SVT_NONE = 0, + FST_SVT_NONE = 0, - FST_SVT_VHDL_SIGNAL = 1, - FST_SVT_VHDL_VARIABLE = 2, - FST_SVT_VHDL_CONSTANT = 3, - FST_SVT_VHDL_FILE = 4, - FST_SVT_VHDL_MEMORY = 5, + FST_SVT_VHDL_SIGNAL = 1, + FST_SVT_VHDL_VARIABLE = 2, + FST_SVT_VHDL_CONSTANT = 3, + FST_SVT_VHDL_FILE = 4, + FST_SVT_VHDL_MEMORY = 5, - FST_SVT_MAX = 5 + FST_SVT_MAX = 5 }; -enum fstSupplementalDataType { - FST_SDT_MIN = 0, +enum fstSupplementalDataType +{ + FST_SDT_MIN = 0, - FST_SDT_NONE = 0, + FST_SDT_NONE = 0, - FST_SDT_VHDL_BOOLEAN = 1, - FST_SDT_VHDL_BIT = 2, - FST_SDT_VHDL_BIT_VECTOR = 3, - FST_SDT_VHDL_STD_ULOGIC = 4, + FST_SDT_VHDL_BOOLEAN = 1, + FST_SDT_VHDL_BIT = 2, + FST_SDT_VHDL_BIT_VECTOR = 3, + FST_SDT_VHDL_STD_ULOGIC = 4, FST_SDT_VHDL_STD_ULOGIC_VECTOR = 5, - FST_SDT_VHDL_STD_LOGIC = 6, - FST_SDT_VHDL_STD_LOGIC_VECTOR = 7, - FST_SDT_VHDL_UNSIGNED = 8, - FST_SDT_VHDL_SIGNED = 9, - FST_SDT_VHDL_INTEGER = 10, - FST_SDT_VHDL_REAL = 11, - FST_SDT_VHDL_NATURAL = 12, - FST_SDT_VHDL_POSITIVE = 13, - FST_SDT_VHDL_TIME = 14, - FST_SDT_VHDL_CHARACTER = 15, - FST_SDT_VHDL_STRING = 16, + FST_SDT_VHDL_STD_LOGIC = 6, + FST_SDT_VHDL_STD_LOGIC_VECTOR = 7, + FST_SDT_VHDL_UNSIGNED = 8, + FST_SDT_VHDL_SIGNED = 9, + FST_SDT_VHDL_INTEGER = 10, + FST_SDT_VHDL_REAL = 11, + FST_SDT_VHDL_NATURAL = 12, + FST_SDT_VHDL_POSITIVE = 13, + FST_SDT_VHDL_TIME = 14, + FST_SDT_VHDL_CHARACTER = 15, + FST_SDT_VHDL_STRING = 16, - FST_SDT_MAX = 16, + FST_SDT_MAX = 16, - FST_SDT_SVT_SHIFT_COUNT = 10, /* FST_SVT_* is ORed in by fstWriterCreateVar2() to the left after shifting FST_SDT_SVT_SHIFT_COUNT */ - FST_SDT_ABS_MAX = ((1<<(FST_SDT_SVT_SHIFT_COUNT))-1) + FST_SDT_SVT_SHIFT_COUNT = 10, /* FST_SVT_* is ORed in by fstWriterCreateVar2() to the left + after shifting FST_SDT_SVT_SHIFT_COUNT */ + FST_SDT_ABS_MAX = ((1 << (FST_SDT_SVT_SHIFT_COUNT)) - 1) }; - struct fstHier { -unsigned char htyp; + unsigned char htyp; -union { + union + { /* if htyp == FST_HT_SCOPE */ - struct fstHierScope { - unsigned char typ; /* FST_ST_MIN ... FST_ST_MAX */ - const char *name; - const char *component; - uint32_t name_length; /* strlen(u.scope.name) */ - uint32_t component_length; /* strlen(u.scope.component) */ - } scope; + struct fstHierScope + { + unsigned char typ; /* FST_ST_MIN ... FST_ST_MAX */ + const char *name; + const char *component; + uint32_t name_length; /* strlen(u.scope.name) */ + uint32_t component_length; /* strlen(u.scope.component) */ + } scope; /* if htyp == FST_HT_VAR */ - struct fstHierVar { - unsigned char typ; /* FST_VT_MIN ... FST_VT_MAX */ - unsigned char direction; /* FST_VD_MIN ... FST_VD_MAX */ - unsigned char svt_workspace; /* zeroed out by FST reader, for client code use */ - unsigned char sdt_workspace; /* zeroed out by FST reader, for client code use */ - unsigned int sxt_workspace; /* zeroed out by FST reader, for client code use */ - const char *name; - uint32_t length; - fstHandle handle; - uint32_t name_length; /* strlen(u.var.name) */ - unsigned is_alias : 1; - } var; + struct fstHierVar + { + unsigned char typ; /* FST_VT_MIN ... FST_VT_MAX */ + unsigned char direction; /* FST_VD_MIN ... FST_VD_MAX */ + unsigned char svt_workspace; /* zeroed out by FST reader, for client code use */ + unsigned char sdt_workspace; /* zeroed out by FST reader, for client code use */ + unsigned int sxt_workspace; /* zeroed out by FST reader, for client code use */ + const char *name; + uint32_t length; + fstHandle handle; + uint32_t name_length; /* strlen(u.var.name) */ + unsigned is_alias : 1; + } var; /* if htyp == FST_HT_ATTRBEGIN */ - struct fstHierAttr { - unsigned char typ; /* FST_AT_MIN ... FST_AT_MAX */ - unsigned char subtype; /* from fstMiscType, fstArrayType, fstEnumValueType, fstPackType */ - const char *name; - uint64_t arg; /* number of array elements, struct members, or some other payload (possibly ignored) */ - uint64_t arg_from_name; /* for when name is overloaded as a variable-length integer (FST_AT_MISC + FST_MT_SOURCESTEM) */ - uint32_t name_length; /* strlen(u.attr.name) */ - } attr; - } u; + struct fstHierAttr + { + unsigned char typ; /* FST_AT_MIN ... FST_AT_MAX */ + unsigned char + subtype; /* from fstMiscType, fstArrayType, fstEnumValueType, fstPackType */ + const char *name; + uint64_t arg; /* number of array elements, struct members, or some other payload + (possibly ignored) */ + uint64_t arg_from_name; /* for when name is overloaded as a variable-length integer + (FST_AT_MISC + FST_MT_SOURCESTEM) */ + uint32_t name_length; /* strlen(u.attr.name) */ + } attr; + } u; }; - struct fstETab { -char *name; -uint32_t elem_count; -char **literal_arr; -char **val_arr; + 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); - /* 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, 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 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, fstHandle handle, - uint32_t bits, const uint32_t *val); -void fstWriterEmitValueChangeVec64(void *ctx, fstHandle handle, - uint32_t bits, const uint64_t *val); -void fstWriterEmitVariableLengthValueChange(void *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); -void fstWriterSetAttrBegin(void *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, enum fstScopeType scopetype, - const char *scopename, const char *scopecomp); -void fstWriterSetSourceInstantiationStem(void *ctx, const char *path, unsigned int line, unsigned int use_realpath); -void fstWriterSetSourceStem(void *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); +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(fstWriterContext *ctx, + enum fstVarType vt, + enum fstVarDir vd, + uint32_t len, + const char *nam, + fstHandle aliasHandle); +/* 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(fstWriterContext *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(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(fstWriterContext *ctx, + fstHandle handle, + uint32_t bits, + const uint64_t *val); +void fstWriterEmitVariableLengthValueChange(fstWriterContext *ctx, + fstHandle handle, + const void *val, + uint32_t len); +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(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(fstWriterContext *ctx, + const char *path, + unsigned int line, + unsigned int use_realpath); +void fstWriterSetSourceStem(fstWriterContext *ctx, + const char *path, + unsigned int line, + unsigned int use_realpath); +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, - 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, - void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value), - void (*value_change_callback_varlen)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value, 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); +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(fstReaderContext *ctx, + void (*value_change_callback)(void *user_callback_data_pointer, + uint64_t time, + fstHandle facidx, + const unsigned char *value), + void (*value_change_callback_varlen)(void *user_callback_data_pointer, + uint64_t time, + fstHandle facidx, + const unsigned char *value, + uint32_t len), + void *user_callback_data_pointer, + FILE *vcdhandle); +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 */ -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); +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 */ - +void fstUtilityFreeEnumTable(struct fstETab *etab); /* must use to free fstETab properly */ #ifdef __cplusplus } diff --git a/passes/sat/sim.cc b/passes/sat/sim.cc index bb4eb3d82..b250d23d8 100644 --- a/passes/sat/sim.cc +++ b/passes/sat/sim.cc @@ -2400,7 +2400,7 @@ struct VCDWriter : public OutputWriter struct FSTWriter : public OutputWriter { FSTWriter(SimWorker *worker, std::string filename) : OutputWriter(worker) { - fstfile = (struct fstContext *)fstWriterCreate(filename.c_str(),1); + fstfile = fstWriterCreate(filename.c_str(),1); } virtual ~FSTWriter() @@ -2456,7 +2456,7 @@ struct FSTWriter : public OutputWriter } } - struct fstContext *fstfile = nullptr; + struct fstWriterContext *fstfile = nullptr; std::map mapping; };