Version bump

Signed-off-by: Wilson Snyder <[email protected]>

.clang-tidy

@@ -0,0 +1,9 @@
+Checks:          'clang-diagnostic-*,clang-analyzer-*,*,-modernize*,-hicpp*,-android-cloexec-fopen,-cert-dcl50-cpp,-cert-env33-c,-cert-err34-c,-cert-err58-cpp,-clang-analyzer-core.UndefinedBinaryOperatorResult,-clang-analyzer-security*,-cppcoreguidelines-no-malloc,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-union-access,-cppcoreguidelines-pro-type-vararg,-cppcoreguidelines-special-member-functions,-fuchsia-default-arguments,-fuchsia-overloaded-operator,-google-default-arguments,-google-readability-todo,-google-runtime-references,-llvm-header-guard,-llvm-include-order,-misc-string-integer-assignment,-misc-string-literal-with-embedded-nul,-readability-braces-around-statements,-readability-container-size-empty,-readability-delete-null-pointer,-readability-else-after-return,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-static-accessed-through-instance'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
+FormatStyle:     none
+CheckOptions:    
+  - key:             google-readability-braces-around-statements.ShortStatementLines
+    value:           '2'
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'

.gitignore

@@ -1,6 +1,7 @@
 \#*
 .#*
 *~
+*.tidy
 *.old
 *.gz
 *.gz.uu

Changes

@@ -3,6 +3,22 @@ Revision history for Verilator
 The contributors that suggested a given feature are shown in []. Thanks!
 
 
+* Verilator 4.006 2018-10-27
+
+**    Add --pp-comments, msg2700. [Robert Henry]
+
+**    Add --dump-defines.
+
+***   For --trace-fst, save enum decoding information, bug1358. [Sergi Granell]
+      (To visualize enumeration data you must use GTKwave 3.3.95 or newer.)
+
+***   For --trace-fst, instead of *.fst.hier, put data into *.fst. [Tony Bybell]
+
+****  Fix --trace-lxt2 compile error on MinGW, msg2667. [HyungKi Jeong]
+
+****  Fix Windows .exe not found, bug1361. [Patrick Stewart]
+
+
 * Verilator 4.004 2018-10-6
 
 **    Add GTKWave FST native tracing, bug1356. [Sergi Granell]

MANIFEST.SKIP

@@ -1,5 +1,4 @@
-^CVS/
-/CVS/
+\.clang-tidy
 \.git/
 \.svn/
 \.(bak|old)/
@@ -9,6 +8,7 @@
 .*\.log
 \..*\.swp
 .*\.tmp
+.*\.tidy
 .*\.tex
 .*\.key
 .*\.vcd

Makefile.in

@@ -427,14 +427,16 @@ endif
 endif
 
 # Use --xml flag to see the cppcheck code to use for suppression
+CPPCHECK_CPP = $(wildcard \
+	$(srcdir)/include/*.cpp \
+	$(srcdir)/src/*.cpp )
+CPPCHECK_H = $(wildcard \
+	$(srcdir)/include/*.h \
+	$(srcdir)/src/*.h )
 CPPCHECK = src/cppcheck_filtered
 CPPCHECK_FLAGS = --enable=all --inline-suppr \
 	--suppress=unusedScopedObject --suppress=cstyleCast --suppress=useInitializationList
 CPPCHECK_FLAGS += --xml
-CPPCHECK_CPP = $(wildcard \
-	$(srcdir)/include/*.cpp \
-	$(srcdir)/include/gtkwave/*.cpp \
-	$(srcdir)/src/*.cpp)
 CPPCHECK_DEP = $(subst .cpp,.cppcheck,$(CPPCHECK_CPP))
 CPPCHECK_INC = -I$(srcdir)/include -I$(srcdir)/src/obj_dbg -I$(srcdir)/src
 
@@ -442,6 +444,17 @@ cppcheck: $(CPPCHECK_DEP)
 %.cppcheck: %.cpp
 	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $<
 
+CLANGTIDY = clang-tidy
+CLANGTIDY_FLAGS = -config=''
+CLANGTIDY_DEP = $(subst .h,.h.tidy,$(CPPCHECK_H)) \
+	$(subst .cpp,.cpp.tidy,$(CPPCHECK_CPP))
+
+clangtidy: $(CLANGTIDY_DEP)
+%.cpp.tidy: %.cpp
+	$(CLANGTIDY) $(CLANGTIDY_FLAGS) $< -- -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) | 2>&1 tee $@
+%.h.tidy: %.h
+	$(CLANGTIDY) $(CLANGTIDY_FLAGS) $< -- -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) | 2>&1 tee $@
+
 analyzer-src:
 	-rm -rf src/obj_dbg
 	scan-build $(MAKE) -k verilator_coverage_bin_dbg verilator_bin_dbg
@@ -483,8 +496,8 @@ endif
 
 maintainer-clean::
 	@echo "This command is intended for maintainers to use;"
-	@echo "rebuilding the deleted files requires makeinfo."
-	rm -f *.info* *.1 $(INFOS) configure
+	@echo "rebuilding the deleted files requires autoconf."
+	rm -f configure
 
 clean mostlyclean distclean maintainer-clean maintainer-copy::
 	for dir in $(SUBDIRS); do \
@@ -502,6 +515,7 @@ clean mostlyclean distclean maintainer-clean::
 	rm -rf examples/*/obj_dir examples/*/logs
 
 distclean maintainer-clean::
+	rm -f *.info* *.1 $(INFOS)
 	rm -f Makefile config.status config.cache config.log TAGS
 	rm -f verilator_bin* verilator_coverage_bin*
 	rm -f bin/verilator_bin* bin/verilator_coverage_bin*

bin/verilator

@@ -134,13 +134,15 @@ sub verilator_bin {
                     || ($Debug ? "verilator_bin_dbg" : "verilator_bin"));
     if (defined($ENV{VERILATOR_ROOT})) {
         my $dir = $ENV{VERILATOR_ROOT};
-        if (-x "$dir/bin/$basename") {  # From a "make install" into VERILATOR_ROOT
+        if (-x "$dir/bin/$basename"
+            || -x "$dir/bin/$basename.exe") {  # From a "make install" into VERILATOR_ROOT
             $bin = "$dir/bin/$basename";
         } else {
             $bin = "$dir/$basename";  # From pointing to kit directory
         }
     } else {
-        if (-x "$RealBin/$basename") {
+        if (-x "$RealBin/$basename"
+            || -x "$RealBin/$basename.exe") {
             $bin = "$RealBin/$basename";  # From path/to/verilator with verilator_bin installed
         } else {
             $bin = $basename;  # Find in PATH
@@ -287,6 +289,7 @@ detailed descriptions in L</"VERILATION ARGUMENTS"> for more information.
     --debugi-<srcfile> <level>  Enable debugging a source file at a level
     --default-language <lang>   Default language to parse
      +define+<var>=<value>      Set preprocessor define
+    --dump-defines              Show preprocessor defines with -E
     --dump-tree                 Enable dumping .tree files
     --dump-treei <level>        Enable dumping .tree files at a level
     --dump-treei-<srcfile> <level>  Enable dumping .tree file at a source file at a level
@@ -336,6 +339,7 @@ detailed descriptions in L</"VERILATION ARGUMENTS"> for more information.
     --pins-sc-biguint           Specify types for top level ports
     --pins-uint8                Specify types for top level ports
     --pipe-filter <command>     Filter all input through a script
+    --pp-comments               Show preprocessor comments with -E
     --prefix <topname>          Name of top level class
     --prof-cfuncs               Name functions for profiling
     --prof-threads              Enable generating gantt chart data for threads
@@ -501,9 +505,13 @@ output files.
 
 =item -CFLAGS I<flags>
 
-Add specified C compiler flags to the generated makefiles.  When make is
-run on the generated makefile these will be passed to the C++ compiler
-(gcc/g++/msvc++).
+Add specified C compiler flag to the generated makefiles. For multiple
+flags either pass them as a single argument with space separators quoted in
+the shell (C<-CFLAGS "-a -b">), or use multiple -CFLAGS arguments
+(C<-CFLAGS -a -CFLAGS -b>).
+
+When make is run on the generated makefile these will be passed to the C++
+compiler (gcc/g++/msvc++).
 
 =item --cc
 
@@ -712,6 +720,15 @@ Defines the given preprocessor symbol, or multiple symbols if separated by
 plusses.  Similar to -D; +define is fairly standard across Verilog tools
 while -D is an alias for GCC compatibility.
 
+=item --dump-defines
+
+With -E, suppress normal output, and instead print a list of all defines
+existing at the end of pre-processing the input files. Similar to GCC "-dM"
+option. This also gives you a way of finding out what is predefined in
+Verilator using the command:
+
+   touch foo.v ; verilator -E --dump-defines foo.v
+
 =item --dump-tree
 
 Rarely needed.  Enable writing .tree debug files with dumping level 3,
@@ -860,13 +877,17 @@ small modules; they will always be inlined, if allowed.
 
 =item -LDFLAGS I<flags>
 
-Add specified C linker flags to the generated makefiles.  When make is run
-on the generated makefile these will be passed to the C++ linker (ld)
-*after* the primary file being linked.  This flag is called -LDFLAGS as
-that's the traditional name in simulators; it's would have been better
-called LDLIBS as that's the Makefile variable it controls.  (In Make,
-LDFLAGS is before the first object, LDLIBS after.  -L libraries need to be
-in the Make variable LDLIBS, not LDFLAGS.)
+Add specified C linker flags to the generated makefiles.  For multiple
+flags either pass them as a single argument with space separators quoted in
+the shell (C<-LDFLAGS "-a -b">), or use multiple -LDFLAGS arguments
+(C<-LDFLAGS -a -LDFLAGS -b>).
+
+When make is run on the generated makefile these will be passed to the C++
+linker (ld) *after* the primary file being linked.  This flag is called
+-LDFLAGS as that's the traditional name in simulators; it's would have been
+better called LDLIBS as that's the Makefile variable it controls.  (In
+Make, LDFLAGS is before the first object, LDLIBS after.  -L libraries need
+to be in the Make variable LDLIBS, not LDFLAGS.)
 
 =item --l2-name I<value>
 
@@ -1073,6 +1094,10 @@ t/t_pipe_filter test for an example.
 To debug the output of the filter, try using the -E option to see
 preprocessed output.
 
+=item --pp-comments
+
+With -E, show comments in preprocessor output.
+
 =item --prefix I<topname>
 
 Specifies the name of the top level class and makefile.  Defaults to V

bin/verilator_coverage

@@ -93,13 +93,15 @@ sub verilator_coverage_bin {
 		    || "verilator_coverage_bin_dbg");
     if (defined($ENV{VERILATOR_ROOT})) {
 	my $dir = $ENV{VERILATOR_ROOT};
-	if (-x "$dir/bin/$basename") {  # From a "make install" into VERILATOR_ROOT
+        if (-x "$dir/bin/$basename"
+            || -x "$dir/bin/$basename.exe") {  # From a "make install" into VERILATOR_ROOT
 	    $bin = "$dir/bin/$basename";
 	} else {
 	    $bin = "$dir/$basename";  # From pointing to kit directory
 	}
     } else {
-	if (-x "$RealBin/$basename") {
+        if (-x "$RealBin/$basename"
+            || -x "$RealBin/$basename.exe") {
 	    $bin = "$RealBin/$basename";  # From path/to/verilator with verilator_bin installed
 	} else {
 	    $bin = $basename;  # Find in PATH

configure.ac

@@ -6,7 +6,7 @@
 
 #AC_INIT([Verilator],[#.### YYYY-MM-DD])
 #AC_INIT([Verilator],[#.### devel])
-AC_INIT([Verilator],[4.004 2018-10-06],
+AC_INIT([Verilator],[4.006 2018-10-27],
         [https://www.veripool.org/verilator],
         [verilator],[https://www.veripool.org/verilator])
 # When releasing, also update header of Changes file

include/gtkwave/fst_config.h

@@ -7,6 +7,9 @@
 
 /* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix). */
 #define HAVE_ALLOCA_H 1
+#if !defined(__MINGW32__)
+# define HAVE_ALLOCA_H 1
+#endif
 
 /* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
 #define HAVE_FSEEKO 1

include/gtkwave/fstapi.c

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

include/gtkwave/fstapi.h

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

include/gtkwave/lxt2_config.h

@@ -1,12 +0,0 @@
-/* This file specifically for LXT2 usage */
-/* config.h.  Generated from config.h.in by configure.  */
-/* config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* Define to 1 if you have `alloca', as a function or macro. */
-#define HAVE_ALLOCA 1
-
-/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix). */
-#define HAVE_ALLOCA_H 1
-
-/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
-#define HAVE_FSEEKO 1

include/gtkwave/lxt2_write.cpp

@@ -24,7 +24,7 @@
 #pragma alloca
 #endif
 
-#include "lxt2_config.h"
+#include "fst_config.h"
 #include "lxt2_write.h"
 
 

include/verilated.cpp

@@ -24,7 +24,12 @@
 //=========================================================================
 
 #define _VERILATED_CPP_
+
+#include "verilatedos.h"
 #include "verilated_imp.h"
+
+#include "verilated_config.h"
+
 #include <cctype>
 #include <sys/stat.h>  // mkdir
 
@@ -130,13 +135,11 @@ std::string _vl_string_vprintf(const char* formatp, va_list ap) VL_MT_SAFE {
     int len = VL_VSNPRINTF(NULL, 0, formatp, aq);
     va_end(aq);
     if (VL_UNLIKELY(len < 1)) {
-        va_end(ap);
         return "";
     }
 
     char* bufp = new char[len+1];
     VL_VSNPRINTF(bufp, len+1, formatp, ap);
-    va_end(ap);
 
     std::string out = std::string(bufp, len);
     delete[] bufp;
@@ -235,10 +238,10 @@ vluint64_t vl_rand64() VL_MT_SAFE {
 	t_seeded = true;
 	{
 	    VerilatedLockGuard lock(s_mutex);
-            t_state[0] = (((vluint64_t)vl_sys_rand32())<<32
-                          ^ ((vluint64_t)vl_sys_rand32()));
-            t_state[1] = (((vluint64_t)vl_sys_rand32())<<32
-                          ^ ((vluint64_t)vl_sys_rand32()));
+            t_state[0] = ((static_cast<vluint64_t>(vl_sys_rand32()) << 32)
+                          ^ (static_cast<vluint64_t>(vl_sys_rand32())));
+            t_state[1] = ((static_cast<vluint64_t>(vl_sys_rand32()) << 32)
+                          ^ (static_cast<vluint64_t>(vl_sys_rand32())));
             // Fix state as algorithm is slow to randomize if many zeros
             // This causes a loss of ~ 1 bit of seed entropy, no big deal
             if (VL_COUNTONES_I(t_state[0]) < 10) t_state[0] = ~t_state[0];
@@ -1240,19 +1243,19 @@ IData VL_SSCANF_INX(int, const std::string& ld, const char* formatp, ...) VL_MT_
 }
 
 void VL_WRITEMEM_Q(bool hex, int width, int depth, int array_lsb, int,
-                   QData ofilename, const void* memp, IData start,
+                   QData filename, const void* memp, IData start,
                    IData end) VL_MT_SAFE {
-    WData fnw[2];  VL_SET_WQ(fnw, ofilename);
-    return VL_WRITEMEM_W(hex, width,depth,array_lsb,2,fnw,memp,start,end);
+    WData fnw[2];  VL_SET_WQ(fnw, filename);
+    return VL_WRITEMEM_W(hex, width, depth, array_lsb,2, fnw, memp, start, end);
 }
 
 void VL_WRITEMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
-                   WDataInP ofilenamep, const void* memp, IData start,
+                   WDataInP filenamep, const void* memp, IData start,
                    IData end) VL_MT_SAFE {
-    char ofilenamez[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
-    _VL_VINT_TO_STRING(fnwords*VL_WORDSIZE, ofilenamez, ofilenamep);
-    std::string ofilenames(ofilenamez);
-    return VL_WRITEMEM_N(hex, width,depth,array_lsb,ofilenames,memp,start,end);
+    char filenamez[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
+    _VL_VINT_TO_STRING(fnwords*VL_WORDSIZE, filenamez, filenamep);
+    std::string filenames(filenamez);
+    return VL_WRITEMEM_N(hex, width, depth, array_lsb, filenames, memp, start, end);
 }
 
 const char* memhFormat(int nBits) {
@@ -1279,19 +1282,19 @@ void VL_WRITEMEM_N(
     int     depth,  // Number of rows
     int array_lsb,  // Index of first row. Valid row addresses
     //              //  range from array_lsb up to (array_lsb + depth - 1)
-    const std::string& ofilenamep,  // Output file name
+    const std::string& filename,  // Output file name
     const void* memp,  // Array state
     IData   start,  // First array row address to write
     IData     end   // Last address to write
     ) VL_MT_SAFE {
     if (VL_UNLIKELY(!hex)) {
-        VL_FATAL_MT(ofilenamep.c_str(), 0, "",
+        VL_FATAL_MT(filename.c_str(), 0, "",
                     "VL_WRITEMEM_N only supports hex format for now, sorry!");
         return;
     }
-    FILE* fp = fopen(ofilenamep.c_str(), "w");
+    FILE* fp = fopen(filename.c_str(), "w");
     if (VL_UNLIKELY(!fp)) {
-        VL_FATAL_MT(ofilenamep.c_str(), 0, "", "$writemem file not found");
+        VL_FATAL_MT(filename.c_str(), 0, "", "$writemem file not found");
         return;
     }
 
@@ -1300,7 +1303,7 @@ void VL_WRITEMEM_N(
             || (row_addr > array_lsb + depth - 1)) {
             vluint32_t endmax = ~0;
             if (end != endmax) {
-                VL_FATAL_MT(ofilenamep.c_str(), 0, "",
+                VL_FATAL_MT(filename.c_str(), 0, "",
                             "$writemem specified address out-of-bounds");
             }
             // else, it's not an error to overflow due to end == endmax,
@@ -1364,17 +1367,17 @@ void VL_WRITEMEM_N(
 }
 
 void VL_READMEM_Q(bool hex, int width, int depth, int array_lsb, int,
-		  QData ofilename, void* memp, IData start, IData end) VL_MT_SAFE {
-    WData fnw[2];  VL_SET_WQ(fnw, ofilename);
-    return VL_READMEM_W(hex,width,depth,array_lsb,2,fnw,memp,start,end);
+                  QData filename, void* memp, IData start, IData end) VL_MT_SAFE {
+    WData fnw[2];  VL_SET_WQ(fnw, filename);
+    return VL_READMEM_W(hex, width, depth, array_lsb, 2, fnw, memp, start, end);
 }
 
 void VL_READMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
-		  WDataInP ofilenamep, void* memp, IData start, IData end) VL_MT_SAFE {
-    char ofilenamez[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
-    _VL_VINT_TO_STRING(fnwords*VL_WORDSIZE, ofilenamez, ofilenamep);
-    std::string ofilenames(ofilenamez);
-    return VL_READMEM_N(hex,width,depth,array_lsb,ofilenames,memp,start,end);
+                  WDataInP filenamep, void* memp, IData start, IData end) VL_MT_SAFE {
+    char filenamez[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
+    _VL_VINT_TO_STRING(fnwords*VL_WORDSIZE, filenamez, filenamep);
+    std::string filenames(filenamez);
+    return VL_READMEM_N(hex, width, depth, array_lsb, filenames, memp, start, end);
 }
 
 void VL_READMEM_N(
@@ -1383,15 +1386,15 @@ void VL_READMEM_N(
     int     depth,  // Number of rows
     int array_lsb,  // Index of first row. Valid row addresses
     //              //  range from array_lsb up to (array_lsb + depth - 1)
-    const std::string& ofilenamep,  // Input file name
+    const std::string& filename,  // Input file name
     void*    memp,  // Array state
     IData   start,  // First array row address to read
     IData     end   // Last row address to read
     ) VL_MT_SAFE {
-    FILE* fp = fopen(ofilenamep.c_str(), "r");
+    FILE* fp = fopen(filename.c_str(), "r");
     if (VL_UNLIKELY(!fp)) {
         // We don't report the Verilog source filename as it slow to have to pass it down
-        VL_FATAL_MT(ofilenamep.c_str(), 0, "", "$readmem file not found");
+        VL_FATAL_MT(filename.c_str(), 0, "", "$readmem file not found");
         return;
     }
     // Prep for reading
@@ -1438,7 +1441,7 @@ void VL_READMEM_N(
                     //printf(" Value width=%d  @%x = %c\n", width, addr, c);
                     if (VL_UNLIKELY(addr >= static_cast<IData>(depth+array_lsb)
                                     || addr < static_cast<IData>(array_lsb))) {
-                        VL_FATAL_MT(ofilenamep.c_str(), linenum, "",
+                        VL_FATAL_MT(filename.c_str(), linenum, "",
                                     "$readmem file address beyond bounds of array");
                     } else {
                         int entry = addr - array_lsb;
@@ -1468,7 +1471,7 @@ void VL_READMEM_N(
                             datap[0] |= value;
                         }
                         if (VL_UNLIKELY(value>=(1<<shift))) {
-                            VL_FATAL_MT(ofilenamep.c_str(), linenum, "",
+                            VL_FATAL_MT(filename.c_str(), linenum, "",
                                         "$readmemb (binary) file contains hex characters");
                         }
                     }
@@ -1476,7 +1479,7 @@ void VL_READMEM_N(
                 innum = true;
             }
             else {
-                VL_FATAL_MT(ofilenamep.c_str(), linenum, "", "$readmem file syntax error");
+                VL_FATAL_MT(filename.c_str(), linenum, "", "$readmem file syntax error");
             }
         }
         lastc = c;
@@ -1486,7 +1489,8 @@ void VL_READMEM_N(
     // Final checks
     fclose(fp);
     if (VL_UNLIKELY(end != VL_UL(0xffffffff) && addr != (end+1))) {
-        VL_FATAL_MT(ofilenamep.c_str(), linenum, "", "$readmem file ended before specified ending-address");
+        VL_FATAL_MT(filename.c_str(), linenum, "",
+                    "$readmem file ended before specified ending-address");
     }
 }
 
@@ -1494,16 +1498,16 @@ IData VL_SYSTEM_IQ(QData lhs) VL_MT_SAFE {
     WData lhsw[2];  VL_SET_WQ(lhsw, lhs);
     return VL_SYSTEM_IW(2, lhsw);
 }
-IData VL_SYSTEM_IW(int lhswords, WDataInP filenamep) VL_MT_SAFE {
+IData VL_SYSTEM_IW(int lhswords, WDataInP lhsp) VL_MT_SAFE {
     char filenamez[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
-    _VL_VINT_TO_STRING(lhswords*VL_WORDSIZE, filenamez, filenamep);
+    _VL_VINT_TO_STRING(lhswords*VL_WORDSIZE, filenamez, lhsp);
     int code = system(filenamez);  // Yes, system() is threadsafe
     return code >> 8;  // Want exit status
 }
 
 IData VL_TESTPLUSARGS_I(const char* formatp) VL_MT_SAFE {
     const std::string& match = VerilatedImp::argPlusMatch(formatp);
-    if (match == "") return 0;
+    if (match.empty()) return 0;
     else return 1;
 }
 
@@ -1533,7 +1537,7 @@ IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rwp) VL_M
 
     const std::string& match = VerilatedImp::argPlusMatch(prefix.c_str());
     const char* dp = match.c_str() + 1 /*leading + */ + prefix.length();
-    if (match == "") return 0;
+    if (match.empty()) return 0;
 
     VL_ZERO_RESET_W(rbits, rwp);
     switch (tolower(fmt)) {
@@ -1589,7 +1593,7 @@ IData VL_VALUEPLUSARGS_INN(int, const std::string& ld, std::string& rdr) VL_MT_S
     }
     const std::string& match = VerilatedImp::argPlusMatch(prefix.c_str());
     const char* dp = match.c_str() + 1 /*leading + */ + prefix.length();
-    if (match == "") return 0;
+    if (match.empty()) return 0;
     rdr = std::string(dp);
     return 1;
 }
@@ -1597,7 +1601,7 @@ IData VL_VALUEPLUSARGS_INN(int, const std::string& ld, std::string& rdr) VL_MT_S
 const char* vl_mc_scan_plusargs(const char* prefixp) VL_MT_SAFE {
     const std::string& match = VerilatedImp::argPlusMatch(prefixp);
     static VL_THREAD_LOCAL char outstr[VL_VALUE_STRING_MAX_WIDTH];
-    if (match == "") return NULL;
+    if (match.empty()) return NULL;
     strncpy(outstr, match.c_str()+strlen(prefixp)+1, // +1 to skip the "+"
 	    VL_VALUE_STRING_MAX_WIDTH);
     outstr[VL_VALUE_STRING_MAX_WIDTH-1] = '\0';
@@ -1641,10 +1645,10 @@ Verilated::ThreadLocal::ThreadLocal()
 Verilated::ThreadLocal::~ThreadLocal() {
 }
 
-void Verilated::debug(int val) VL_MT_SAFE {
+void Verilated::debug(int level) VL_MT_SAFE {
     VerilatedLockGuard lock(m_mutex);
-    s_s.s_debug = val;
-    if (val) {
+    s_s.s_debug = level;
+    if (level) {
 #ifdef VL_DEBUG
 	VL_DEBUG_IF(VL_DBG_MSGF("- Verilated::debug is on. Message prefix indicates {<thread>,<sequence_number>}.\n"););
 #else
@@ -1721,6 +1725,13 @@ void Verilated::flushCall() VL_MT_SAFE {
     fflush(stdout);
 }
 
+const char* Verilated::productName() VL_PURE {
+    return VERILATOR_PRODUCT;
+}
+const char* Verilated::productVersion() VL_PURE {
+    return VERILATOR_VERSION;
+}
+
 void Verilated::commandArgs(int argc, const char** argv) VL_MT_SAFE {
     VerilatedLockGuard lock(s_args.m_argMutex);
     s_args.argc = argc;
@@ -1731,7 +1742,7 @@ void Verilated::commandArgs(int argc, const char** argv) VL_MT_SAFE {
 const char* Verilated::commandArgsPlusMatch(const char* prefixp) VL_MT_SAFE {
     const std::string& match = VerilatedImp::argPlusMatch(prefixp);
     static VL_THREAD_LOCAL char outstr[VL_VALUE_STRING_MAX_WIDTH];
-    if (match == "") return "";
+    if (match.empty()) return "";
     strncpy(outstr, match.c_str(), VL_VALUE_STRING_MAX_WIDTH);
     outstr[VL_VALUE_STRING_MAX_WIDTH-1] = '\0';
     return outstr;
@@ -1905,7 +1916,8 @@ VerilatedModule::VerilatedModule(const char* namep)
 
 VerilatedModule::~VerilatedModule() {
     // Memory cleanup - not called during normal operation
-    if (m_namep) { free((void*)m_namep); m_namep=NULL; }
+    // NOLINTNEXTLINE(google-readability-casting)
+    if (m_namep) { free((void*)(m_namep)); m_namep=NULL; }
 }
 
 //======================================================================
@@ -2005,7 +2017,7 @@ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap,
     if (!finalize) return;
 
     if (!m_varsp) m_varsp = new VerilatedVarNameMap();
-    VerilatedVar var(namep, datap, vltype, (VerilatedVarFlags)vlflags, dims);
+    VerilatedVar var(namep, datap, vltype, static_cast<VerilatedVarFlags>(vlflags), dims);
 
     va_list ap;
     va_start(ap,dims);

include/verilated.h

@@ -28,23 +28,22 @@
 #ifndef _VERILATED_H_
 #define _VERILATED_H_ 1 ///< Header Guard
 
-#include "verilated_config.h"
 #include "verilatedos.h"
 
 #include <cassert>
+#include <cmath>
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <cmath>
+// <iostream> avoided to reduce compile time
+// <map> avoided and instead in verilated_heavy.h to reduce compile time
+// <string> avoided and instead in verilated_heavy.h to reduce compile time
 #ifdef VL_THREADED
 # include <atomic>
 # include <mutex>
 # include <thread>
 #endif
-// <iostream> avoided to reduce compile time
-// <map> avoided and instead in verilated_heavy.h to reduce compile time
-// <string> avoided and instead in verilated_heavy.h to reduce compile time
 
 //=============================================================================
 // Switches
@@ -448,8 +447,8 @@ public:
     static const char* commandArgsPlusMatch(const char* prefixp) VL_MT_SAFE;
 
     /// Produce name & version for (at least) VPI
-    static const char* productName() VL_PURE { return VERILATOR_PRODUCT; }
-    static const char* productVersion() VL_PURE { return VERILATOR_VERSION; }
+    static const char* productName() VL_PURE;
+    static const char* productVersion() VL_PURE;
 
     /// Convenience OS utilities
     static void mkdir(const char* dirname) VL_MT_UNSAFE;
@@ -584,29 +583,29 @@ extern WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP r
 /// File I/O
 extern IData VL_FGETS_IXI(int obits, void* destp, IData fpi);
 
-extern IData VL_FOPEN_S(const char* filenamep, const char* mode);
-extern IData VL_FOPEN_WI(int fnwords, WDataInP ofilename, IData mode);
-extern IData VL_FOPEN_QI(QData ofilename, IData mode);
-inline IData VL_FOPEN_II(IData ofilename, IData mode) VL_MT_SAFE {
-    return VL_FOPEN_QI(ofilename,mode); }
+extern IData VL_FOPEN_S(const char* filenamep, const char* modep);
+extern IData VL_FOPEN_WI(int fnwords, WDataInP filenamep, IData mode);
+extern IData VL_FOPEN_QI(QData filename, IData mode);
+inline IData VL_FOPEN_II(IData filename, IData mode) VL_MT_SAFE {
+    return VL_FOPEN_QI(filename,mode); }
 
 extern void VL_FCLOSE_I(IData fdi);
 
 extern void VL_READMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
-			 WDataInP ofilename, void* memp, IData start, IData end);
+                         WDataInP filenamep, void* memp, IData start, IData end);
 extern void VL_READMEM_Q(bool hex, int width, int depth, int array_lsb, int fnwords,
-			 QData ofilename,    void* memp, IData start, IData end);
+                         QData filename,     void* memp, IData start, IData end);
 inline void VL_READMEM_I(bool hex, int width, int depth, int array_lsb, int fnwords,
-			 IData ofilename,    void* memp, IData start, IData end) VL_MT_SAFE {
-    VL_READMEM_Q(hex, width,depth,array_lsb,fnwords, ofilename,memp,start,end); }
+                         IData filename,     void* memp, IData start, IData end) VL_MT_SAFE {
+    VL_READMEM_Q(hex, width,depth,array_lsb,fnwords, filename,memp,start,end); }
 
 extern void VL_WRITEMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
-                          WDataInP ofilename, const void* memp, IData start, IData end);
+                          WDataInP filenamep, const void* memp, IData start, IData end);
 extern void VL_WRITEMEM_Q(bool hex, int width, int depth, int array_lsb, int fnwords,
-                          QData ofilename,    const void* memp, IData start, IData end);
+                          QData filename,     const void* memp, IData start, IData end);
 inline void VL_WRITEMEM_I(bool hex, int width, int depth, int array_lsb, int fnwords,
-                          IData ofilename,    const void* memp, IData start, IData end) VL_MT_SAFE {
-    VL_WRITEMEM_Q(hex, width,depth,array_lsb,fnwords, ofilename,memp,start,end); }
+                          IData filename,     const void* memp, IData start, IData end) VL_MT_SAFE {
+    VL_WRITEMEM_Q(hex, width,depth,array_lsb,fnwords, filename,memp,start,end); }
 
 extern void VL_WRITEF(const char* formatp, ...);
 extern void VL_FWRITEF(IData fpi, const char* formatp, ...);
@@ -622,7 +621,7 @@ extern void VL_SFORMAT_X(int obits, IData& destr, const char* formatp, ...);
 extern void VL_SFORMAT_X(int obits, QData& destr, const char* formatp, ...);
 extern void VL_SFORMAT_X(int obits, void* destp, const char* formatp, ...);
 
-extern IData VL_SYSTEM_IW(int lhsnwords, WDataInP lhs);
+extern IData VL_SYSTEM_IW(int lhswords, WDataInP lhsp);
 extern IData VL_SYSTEM_IQ(QData lhs);
 inline IData VL_SYSTEM_II(IData lhs) VL_MT_SAFE { return VL_SYSTEM_IQ(lhs); }
 
@@ -633,24 +632,24 @@ extern const char* vl_mc_scan_plusargs(const char* prefixp);  // PLIish
 // Base macros
 
 /// Return true if data[bit] set; not 0/1 return, but 0/non-zero return.
-#define VL_BITISSET_I(data,bit) (data & (VL_UL(1)<<VL_BITBIT_I(bit)))
-#define VL_BITISSET_Q(data,bit) (data & (VL_ULL(1)<<VL_BITBIT_Q(bit)))
-#define VL_BITISSET_W(data,bit) (data[VL_BITWORD_I(bit)] & (VL_UL(1)<<VL_BITBIT_I(bit)))
+#define VL_BITISSET_I(data,bit) ((data) & (VL_UL(1) << VL_BITBIT_I(bit)))
+#define VL_BITISSET_Q(data,bit) ((data) & (VL_ULL(1) << VL_BITBIT_Q(bit)))
+#define VL_BITISSET_W(data,bit) ((data)[VL_BITWORD_I(bit)] & (VL_UL(1) << VL_BITBIT_I(bit)))
 #define VL_BITISSETLIMIT_W(data,width,bit) \
-    (((bit)<(width)) && data[VL_BITWORD_I(bit)] & (VL_UL(1)<<VL_BITBIT_I(bit)))
+    (((bit)<(width)) && (data)[VL_BITWORD_I(bit)] & (VL_UL(1) << VL_BITBIT_I(bit)))
 
 /// Shift appropriate word by bit. Does not account for wrapping between two words
-#define VL_BITRSHIFT_W(data,bit) (data[VL_BITWORD_I(bit)] >> VL_BITBIT_I(bit))
+#define VL_BITRSHIFT_W(data,bit) ((data)[VL_BITWORD_I(bit)] >> VL_BITBIT_I(bit))
 
 /// Create two 32-bit words from quadword
 /// WData is always at least 2 words; does not clean upper bits
-#define VL_SET_WQ(owp,data)     { owp[0]=static_cast<IData>(data); \
-        owp[1]=static_cast<IData>((data)>>VL_WORDSIZE); }
-#define VL_SET_WI(owp,data)	{ owp[0]=static_cast<IData>(data); owp[1]=0; }
+#define VL_SET_WQ(owp,data) { (owp)[0] = static_cast<IData>(data);  \
+        (owp)[1] = static_cast<IData>((data)>>VL_WORDSIZE); }
+#define VL_SET_WI(owp,data) { (owp)[0] = static_cast<IData>(data); (owp)[1] = 0; }
 #define VL_SET_QW(lwp) \
-    ( (static_cast<QData>(lwp[0])) \
-      | (static_cast<QData>(lwp[1])<<(static_cast<QData>(VL_WORDSIZE)) ))
-#define _VL_SET_QII(ld,rd)      ( (static_cast<QData>(ld)<<VL_ULL(32)) | static_cast<QData>(rd) )
+    ( (static_cast<QData>((lwp)[0]))                                    \
+      | (static_cast<QData>((lwp)[1]) << (static_cast<QData>(VL_WORDSIZE)) ))
+#define _VL_SET_QII(ld,rd) ((static_cast<QData>(ld)<<VL_ULL(32)) | static_cast<QData>(rd))
 
 /// Return FILE* from IData
 extern FILE*  VL_CVT_I_FP(IData lhs);
@@ -699,7 +698,7 @@ extern void _VL_DEBUG_PRINT_W(int lbits, WDataInP iwp);
 // Pli macros
 
 #ifndef VL_TIME_PRECISION
-# define VL_TIME_PRECISION -12	///< Timescale units only for for VPI return - picoseconds
+# define VL_TIME_PRECISION (-12)  ///< Timescale units only for for VPI return - picoseconds
 #endif
 #ifndef VL_TIME_MULTIPLIER
 # define VL_TIME_MULTIPLIER 1
@@ -829,31 +828,32 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) VL_MT_SAF
 #define VL_ASSIGN_ISI(obits,vvar,svar) { (vvar) = VL_CLEAN_II((obits),(obits),(svar).read()); }
 #define VL_ASSIGN_QSQ(obits,vvar,svar) { (vvar) = VL_CLEAN_QQ((obits),(obits),(svar).read()); }
 
-#define VL_ASSIGN_ISW(obits,od,svar) { \
-    od = (svar.read().get_word(0)) & VL_MASK_I(obits); \
-}
-#define VL_ASSIGN_QSW(obits,od,svar) { \
-    od = ((static_cast<QData>(svar.read().get_word(1)))<<VL_WORDSIZE | svar.read().get_word(0)) \
-         & VL_MASK_Q(obits); \
-}
-#define VL_ASSIGN_WSW(obits,owp,svar) { \
-    int words = VL_WORDS_I(obits); \
-    for (int i=0; i < words; ++i) owp[i] = svar.read().get_word(i); \
-    owp[words-1] &= VL_MASK_I(obits); \
-}
+#define VL_ASSIGN_ISW(obits,od,svar) {                          \
+        (od) = ((svar).read().get_word(0)) & VL_MASK_I(obits);  \
+    }
+#define VL_ASSIGN_QSW(obits,od,svar) {                                  \
+        (od) = ((static_cast<QData>((svar).read().get_word(1)))<<VL_WORDSIZE \
+                | (svar).read().get_word(0))                            \
+            & VL_MASK_Q(obits);                                         \
+    }
+#define VL_ASSIGN_WSW(obits,owp,svar) {                                 \
+        int words = VL_WORDS_I(obits);                                  \
+        for (int i=0; i < words; ++i) (owp)[i] = (svar).read().get_word(i); \
+        (owp)[words-1] &= VL_MASK_I(obits);                             \
+    }
 
 #define VL_ASSIGN_ISU(obits,vvar,svar) { (vvar) = VL_CLEAN_II((obits),(obits),(svar).read().to_uint()); }
 #define VL_ASSIGN_QSU(obits,vvar,svar) { (vvar) = VL_CLEAN_QQ((obits),(obits),(svar).read().to_uint64()); }
-#define VL_ASSIGN_WSB(obits,owp,svar) {                       \
-    int words = VL_WORDS_I(obits);                            \
-    sc_biguint<obits> _butemp = (svar).read();                \
-    for (int i=0; i < words; ++i) {                           \
-        int msb = ((i+1)*VL_WORDSIZE) - 1;                    \
-        msb = (msb >= obits) ? (obits-1) : msb;               \
-        owp[i] = _butemp.range(msb,i*VL_WORDSIZE).to_uint();  \
-    }                                                         \
-    owp[words-1] &= VL_MASK_I(obits);                         \
-}
+#define VL_ASSIGN_WSB(obits,owp,svar) {                                 \
+        int words = VL_WORDS_I(obits);                                  \
+        sc_biguint<(obits)> _butemp = (svar).read();                    \
+        for (int i=0; i < words; ++i) {                                 \
+            int msb = ((i+1)*VL_WORDSIZE) - 1;                          \
+            msb = (msb >= (obits)) ? ((obits)-1) : msb;                 \
+            (owp)[i] = _butemp.range(msb,i*VL_WORDSIZE).to_uint();      \
+        }                                                               \
+        (owp)[words-1] &= VL_MASK_I(obits);                             \
+    }
 
 // Copying verilog format from systemc integers and bit vectors.
 // Set a SystemC variable
@@ -861,36 +861,36 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) VL_MT_SAF
 #define VL_ASSIGN_SII(obits,svar,vvar) { (svar).write(vvar); }
 #define VL_ASSIGN_SQQ(obits,svar,vvar) { (svar).write(vvar); }
 
-#define VL_ASSIGN_SWI(obits,svar,rd) { \
-    sc_bv<obits> _bvtemp; \
-    _bvtemp.set_word(0,(rd));			\
-    svar.write(_bvtemp); \
-}
-#define VL_ASSIGN_SWQ(obits,svar,rd) { \
-    sc_bv<obits> _bvtemp; \
-    _bvtemp.set_word(0, static_cast<IData>(rd));	 \
-    _bvtemp.set_word(1, static_cast<IData>((rd)>>VL_WORDSIZE));	\
-    svar.write(_bvtemp); \
-}
-#define VL_ASSIGN_SWW(obits,svar,rwp) { \
-    sc_bv<obits> _bvtemp; \
-    for (int i=0; i < VL_WORDS_I(obits); ++i) _bvtemp.set_word(i,rwp[i]); \
-    svar.write(_bvtemp); \
-}
+#define VL_ASSIGN_SWI(obits,svar,rd) {          \
+        sc_bv<(obits)> _bvtemp;                 \
+        _bvtemp.set_word(0, (rd));              \
+        (svar).write(_bvtemp);                  \
+    }
+#define VL_ASSIGN_SWQ(obits,svar,rd) {                                  \
+        sc_bv<(obits)> _bvtemp;                                         \
+        _bvtemp.set_word(0, static_cast<IData>(rd));                    \
+        _bvtemp.set_word(1, static_cast<IData>((rd)>>VL_WORDSIZE));     \
+        (svar).write(_bvtemp);                                          \
+    }
+#define VL_ASSIGN_SWW(obits,svar,rwp) {                                 \
+        sc_bv<(obits)> _bvtemp;                                         \
+        for (int i=0; i < VL_WORDS_I(obits); ++i) _bvtemp.set_word(i, (rwp)[i]); \
+        (svar).write(_bvtemp);                                          \
+    }
 
 #define VL_ASSIGN_SUI(obits,svar,rd) { (svar).write(rd); }
 #define VL_ASSIGN_SUQ(obits,svar,rd) { (svar).write(rd); }
 #define VL_ASSIGN_SBI(obits,svar,rd) { (svar).write(rd); }
 #define VL_ASSIGN_SBQ(obits,svar,rd) { (svar).write(rd); }
-#define VL_ASSIGN_SBW(obits,svar,rwp) {             \
-    sc_biguint<obits> _butemp;                      \
-    for (int i=0; i < VL_WORDS_I(obits); ++i) {     \
-        int msb = ((i+1)*VL_WORDSIZE) - 1;          \
-        msb = (msb >= obits) ? (obits-1) : msb;     \
-        _butemp.range(msb,i*VL_WORDSIZE) = rwp[i];  \
-    }                                               \
-    svar.write(_butemp);                            \
-}
+#define VL_ASSIGN_SBW(obits,svar,rwp) {                         \
+        sc_biguint<(obits)> _butemp;                            \
+        for (int i=0; i < VL_WORDS_I(obits); ++i) {             \
+            int msb = ((i+1)*VL_WORDSIZE) - 1;                  \
+            msb = (msb >= (obits)) ? ((obits)-1) : msb;         \
+            _butemp.range(msb, i*VL_WORDSIZE) = (rwp)[i];       \
+        }                                                       \
+        (svar).write(_butemp);                                  \
+    }
 
 //===================================================================
 // Extending sizes
@@ -958,8 +958,8 @@ static inline WDataOutP VL_EXTENDS_WW(int obits, int lbits, WDataOutP owp, WData
 // REDUCTION OPERATORS
 
 // EMIT_RULE: VL_REDAND:  oclean=clean; lclean==clean; obits=1;
-#define VL_REDAND_II(obits,lbits,lhs) (lhs == VL_MASK_I(lbits))
-#define VL_REDAND_IQ(obits,lbits,lhs) (lhs == VL_MASK_Q(lbits))
+#define VL_REDAND_II(obits,lbits,lhs) ((lhs) == VL_MASK_I(lbits))
+#define VL_REDAND_IQ(obits,lbits,lhs) ((lhs) == VL_MASK_Q(lbits))
 static inline IData VL_REDAND_IW(int, int lbits, WDataInP lwp) VL_MT_SAFE {
     int words = VL_WORDS_I(lbits);
     IData combine=lwp[0];
@@ -969,8 +969,8 @@ static inline IData VL_REDAND_IW(int, int lbits, WDataInP lwp) VL_MT_SAFE {
 }
 
 // EMIT_RULE: VL_REDOR:  oclean=clean; lclean==clean; obits=1;
-#define VL_REDOR_I(lhs) (lhs!=0)
-#define VL_REDOR_Q(lhs) (lhs!=0)
+#define VL_REDOR_I(lhs) ((lhs)!=0)
+#define VL_REDOR_Q(lhs) ((lhs)!=0)
 static inline IData VL_REDOR_W(int words, WDataInP lwp) VL_MT_SAFE {
     IData equal=0;
     for (int i=0; i < words; ++i) equal |= lwp[i];

include/verilated_cov.cpp

@@ -24,9 +24,9 @@
 #include "verilated_cov.h"
 #include "verilated_cov_key.h"
 
-#include <map>
 #include <deque>
 #include <fstream>
+#include <map>
 
 //=============================================================================
 // VerilatedCovImpBase
@@ -77,7 +77,7 @@ public:
     virtual void zero() const { *m_countp = 0; }
     // CONSTRUCTORS
     // cppcheck-suppress noExplicitConstructor
-    VerilatedCoverItemSpec(T* countp) : m_countp(countp) { zero(); }
+    VerilatedCoverItemSpec(T* countp) : m_countp(countp) { *m_countp = 0; }
     virtual ~VerilatedCoverItemSpec() {}
 };
 
@@ -167,8 +167,8 @@ private:
 	// (foo.a.x, foo.b.y) => foo.*
 	// (foo.a.x, foo.b)   => foo.*
 	if (old == add) return add;
-	if (old == "") return add;
-	if (add == "") return old;
+        if (old.empty()) return add;
+        if (add.empty()) return old;
 
 	const char* a = old.c_str();
 	const char* b = add.c_str();
@@ -296,7 +296,7 @@ public:
 	}
 	// Ignore empty keys
 	for (int i=0; i<MAX_KEYS; ++i) {
-	    if (keys[i]!="") {
+            if (!keys[i].empty()) {
 		for (int j=i+1; j<MAX_KEYS; ++j) {
 		    if (keys[i] == keys[j]) {  // Duplicate key.  Keep the last one
 			keys[i] = "";
@@ -309,7 +309,7 @@ public:
 	int addKeynum=0;
 	for (int i=0; i<MAX_KEYS; ++i) {
 	    const std::string key = keys[i];
-	    if (keys[i]!="") {
+            if (!keys[i].empty()) {
 		const std::string val = valps[i];
 		//cout<<"   "<<__FUNCTION__<<"  "<<key<<" = "<<val<<endl;
 		m_insertp->m_keys[addKeynum] = valueIndex(key);
@@ -391,7 +391,7 @@ public:
 	for (EventMap::const_iterator it=eventCounts.begin(); it!=eventCounts.end(); ++it) {
 	    os<<"C '"<<std::dec;
 	    os<<it->first;
-	    if (it->second.first != "") os<<keyValueFormatter(VL_CIK_HIER,it->second.first);
+            if (!it->second.first.empty()) os<<keyValueFormatter(VL_CIK_HIER,it->second.first);
 	    os<<"' "<<it->second.second;
 	    os<<std::endl;
 	}
@@ -424,9 +424,9 @@ void VerilatedCov::_insertf(const char* filename, int lineno) VL_MT_SAFE {
 }
 
 #define K(n) const char* key ## n
-#define A(n) const char* key ## n, const char* val ## n		// Argument list
-#define C(n) key ## n, val ## n	// Calling argument list
-#define N(n) "",""	// Null argument list
+#define A(n) const char* key ## n, const char* valp ## n  // Argument list
+#define C(n) key ## n, valp ## n  // Calling argument list
+#define N(n) "",""  // Null argument list
 void VerilatedCov::_insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
                             A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19),
                             A(20),A(21),A(22),A(23),A(24),A(25),A(26),A(27),A(28),A(29)) VL_MT_SAFE {
@@ -437,9 +437,9 @@ void VerilatedCov::_insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
 	   key20,key21,key22,key23,key24,key25,key26,key27,key28,key29};
     const char* valps[VerilatedCovImpBase::MAX_KEYS]
 	= {NULL,NULL,NULL,	// filename,lineno,page
-	   val0,val1,val2,val3,val4,val5,val6,val7,val8,val9,
-	   val10,val11,val12,val13,val14,val15,val16,val17,val18,val19,
-	   val20,val21,val22,val23,val24,val25,val26,val27,val28,val29};
+           valp0,valp1,valp2,valp3,valp4,valp5,valp6,valp7,valp8,valp9,
+           valp10,valp11,valp12,valp13,valp14,valp15,valp16,valp17,valp18,valp19,
+           valp20,valp21,valp22,valp23,valp24,valp25,valp26,valp27,valp28,valp29};
     VerilatedCovImp::imp().insertp(keyps, valps);
 }
 

include/verilated_dpi.cpp

@@ -24,6 +24,7 @@
 //=========================================================================
 
 #define _VERILATED_DPI_CPP_
+
 #include "verilatedos.h"
 #include "verilated_dpi.h"
 #include "verilated_imp.h"
@@ -720,14 +721,16 @@ void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1, int
 
 svScope svGetScope() {
     if (VL_UNLIKELY(!Verilated::dpiInContext())) { _VL_SVDPI_CONTEXT_WARN(); return NULL; }
-    return (svScope)Verilated::dpiScope();
+    // NOLINTNEXTLINE(google-readability-casting)
+    return (svScope)(Verilated::dpiScope());
 }
 
 svScope svSetScope(const svScope scope) {
     const VerilatedScope* prevScopep = Verilated::dpiScope();
     const VerilatedScope* vscopep = reinterpret_cast<const VerilatedScope*>(scope);
     Verilated::dpiScope(vscopep);
-    return (svScope)prevScopep;
+    // NOLINTNEXTLINE(google-readability-casting)
+    return (svScope)(prevScopep);
 }
 
 const char* svGetNameFromScope(const svScope scope) {
@@ -736,7 +739,8 @@ const char* svGetNameFromScope(const svScope scope) {
 }
 
 svScope svGetScopeFromName(const char* scopeName) {
-    return (svScope)VerilatedImp::scopeFind(scopeName);
+    // NOLINTNEXTLINE(google-readability-casting)
+    return (svScope)(VerilatedImp::scopeFind(scopeName));
 }
 
 int svPutUserData(const svScope scope, void* userKey, void* userData) {

include/verilated_dpi.h

@@ -28,8 +28,10 @@
 #ifndef _VERILATED_DPI_H_
 #define _VERILATED_DPI_H_ 1 ///< Header Guard
 
-#include "verilated.h"   // Also presumably included by caller
+#include "verilatedos.h"
+#include "verilated.h"  // Also presumably included by caller
 #include "verilated_sym_props.h"
+
 #include "svdpi.h"
 
 //===================================================================

include/verilated_fst_c.cpp

@@ -23,18 +23,19 @@
 #include "verilatedos.h"
 #include "verilated.h"
 #include "verilated_fst_c.h"
+
 // Include the GTKWave implementation directly
-#include "gtkwave/fstapi.c"
 #include "gtkwave/fastlz.c"
+#include "gtkwave/fstapi.c"
 #include "gtkwave/lz4.c"
 
-#include <sys/stat.h>
-#include <fcntl.h>
+#include <algorithm>
 #include <cerrno>
 #include <ctime>
-#include <algorithm>
-#include <sstream>
+#include <fcntl.h>
 #include <iterator>
+#include <sstream>
+#include <sys/stat.h>
 
 #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
 # include <io.h>
@@ -70,7 +71,7 @@ VerilatedFst::VerilatedFst(void* fst)
 
 void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
     m_assertOne.check();
-    m_fst = fstWriterCreate(filename, 0);
+    m_fst = fstWriterCreate(filename, 1);
     m_curScope.clear();
 
     for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
@@ -94,11 +95,19 @@ void VerilatedFst::module(const std::string& name) {
 //=============================================================================
 // Decl
 
-void VerilatedFst::declSymbol(vluint32_t code, const char* name, fstVarDir vardir,
-                              fstVarType vartype,
+void VerilatedFst::declDTypeEnum(int dtypenum, const char* name, vluint32_t elements,
+                                 unsigned int minValbits,
+                                 const char** itemNamesp, const char** itemValuesp) {
+    fstEnumHandle enumNum = fstWriterCreateEnumTable(m_fst, name, elements,
+                                                     minValbits, itemNamesp, itemValuesp);
+    m_local2fstdtype[dtypenum] = enumNum;
+}
+
+void VerilatedFst::declSymbol(vluint32_t code, const char* name,
+                              int dtypenum, fstVarDir vardir, fstVarType vartype,
                               int arraynum, vluint32_t len) {
     std::pair<Code2SymbolType::iterator, bool> p
-        = m_code2symbol.insert(std::make_pair(code, (fstHandle)(0)));
+        = m_code2symbol.insert(std::make_pair(code, static_cast<fstHandle>(NULL)));
     std::istringstream nameiss(name);
     std::istream_iterator<std::string> beg(nameiss), end;
     std::list<std::string> tokens(beg, end);  // Split name
@@ -135,6 +144,10 @@ void VerilatedFst::declSymbol(vluint32_t code, const char* name, fstVarDir vardi
         name_ss << "(" << arraynum << ")";
     std::string name_str = name_ss.str();
 
+    if (dtypenum > 0) {
+        fstEnumHandle enumNum = m_local2fstdtype[dtypenum];
+        fstWriterEmitEnumTableRef(m_fst, enumNum);
+    }
     if (p.second) {  // New
         p.first->second = fstWriterCreateVar(m_fst, vartype, vardir, len, name_str.c_str(), 0);
         assert(p.first->second);

include/verilated_fst_c.h

@@ -25,12 +25,13 @@
 
 #include "verilatedos.h"
 #include "verilated.h"
+
 #include "gtkwave/fstapi.h"
 
-#include <string>
-#include <vector>
 #include <list>
 #include <map>
+#include <string>
+#include <vector>
 
 class VerilatedFst;
 class VerilatedFstCallInfo;
@@ -43,6 +44,7 @@ typedef void (*VerilatedFstCallback_t)(VerilatedFst* vcdp, void* userthis, vluin
 
 class VerilatedFst {
     typedef std::map<vluint32_t, fstHandle> Code2SymbolType;
+    typedef std::map<int, fstEnumHandle> Local2FstDtype;
     typedef std::vector<VerilatedFstCallInfo*> CallbackVec;
 private:
     void* m_fst;
@@ -52,11 +54,12 @@ private:
     std::string m_module;
     CallbackVec m_callbacks;  ///< Routines to perform dumping
     Code2SymbolType m_code2symbol;
+    Local2FstDtype m_local2fstdtype;
     std::list<std::string> m_curScope;
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedFst);
     void declSymbol(vluint32_t code, const char* name,
-                    fstVarDir vardir, fstVarType vartype,
+                    int dtypenum, fstVarDir vardir, fstVarType vartype,
                     int arraynum, vluint32_t len);
     // helpers
     std::vector<char> m_valueStrBuffer;
@@ -74,10 +77,10 @@ public:
         fstWriterClose(m_fst);
         m_fst = NULL;
     }
-    // void set_time_unit(const char* unit); ///< Set time units (s/ms, defaults to ns)
+    // void set_time_unit(const char* unitp);  ///< Set time units (s/ms, defaults to ns)
     // void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
 
-    // void set_time_resolution(const char* unit); ///< Set time resolution (s/ms, defaults to ns)
+    // void set_time_resolution(const char* unitp);  ///< Set time resolution (s/ms, defaults to ns)
     // void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
 
     // double timescaleToDouble(const char* unitp);
@@ -90,36 +93,46 @@ public:
     /// Inside dumping routines, called each cycle to make the dump
     void dump(vluint64_t timeui);
     /// Inside dumping routines, declare callbacks for tracings
-    void addCallback(VerilatedFstCallback_t init, VerilatedFstCallback_t full,
-                     VerilatedFstCallback_t change,
+    void addCallback(VerilatedFstCallback_t initcb, VerilatedFstCallback_t fullcb,
+                     VerilatedFstCallback_t changecb,
                      void* userthis) VL_MT_UNSAFE_ONE;
 
     /// Inside dumping routines, declare a module
     void module(const std::string& name);
+    /// Inside dumping routines, declare a data type
+    void declDTypeEnum(int dtypenum, const char* name, vluint32_t elements,
+                       unsigned int minValbits,
+                       const char** itemNamesp, const char** itemValuesp);
     /// Inside dumping routines, declare a signal
-    void declBit(vluint32_t code, const char* name, fstVarDir vardir, fstVarType vartype,
+    void declBit(vluint32_t code, const char* name,
+                 int dtypenum, fstVarDir vardir, fstVarType vartype,
                  int arraynum) {
-        declSymbol(code, name, vardir, vartype, arraynum, 1);
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 1);
     }
-    void declBus(vluint32_t code, const char* name, fstVarDir vardir, fstVarType vartype,
+    void declBus(vluint32_t code, const char* name,
+                 int dtypenum, fstVarDir vardir, fstVarType vartype,
                  int arraynum, int msb, int lsb) {
-        declSymbol(code, name, vardir, vartype, arraynum, msb - lsb + 1);
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
     }
-    void declDouble(vluint32_t code, const char* name, fstVarDir vardir, fstVarType vartype,
+    void declDouble(vluint32_t code, const char* name,
+                    int dtypenum, fstVarDir vardir, fstVarType vartype,
                     int arraynum) {
-        declSymbol(code, name, vardir, vartype, arraynum, 2);
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 2);
     }
-    void declFloat(vluint32_t code, const char* name, fstVarDir vardir, fstVarType vartype,
+    void declFloat(vluint32_t code, const char* name,
+                   int dtypenum, fstVarDir vardir, fstVarType vartype,
                    int arraynum) {
-        declSymbol(code, name, vardir, vartype, arraynum, 1);
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 1);
     }
-    void declQuad(vluint32_t code, const char* name, fstVarDir vardir, fstVarType vartype,
+    void declQuad(vluint32_t code, const char* name,
+                  int dtypenum, fstVarDir vardir, fstVarType vartype,
                   int arraynum, int msb, int lsb) {
-        declSymbol(code, name, vardir, vartype, arraynum, msb - lsb + 1);
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
     }
-    void declArray(vluint32_t code, const char* name, fstVarDir vardir, fstVarType vartype,
+    void declArray(vluint32_t code, const char* name,
+                   int dtypenum, fstVarDir vardir, fstVarType vartype,
                    int arraynum, int msb, int lsb) {
-        declSymbol(code, name, vardir, vartype, arraynum, msb - lsb + 1);
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
     }
 
     /// Inside dumping routines, dump one signal if it has changed

include/verilated_heavy.h

@@ -65,15 +65,15 @@ inline IData VL_LEN_IN(const std::string& ld) { return ld.length(); }
 
 extern IData VL_FOPEN_NI(const std::string& filename, IData mode) VL_MT_SAFE;
 extern void VL_READMEM_N(bool hex, int width, int depth, int array_lsb,
-                         const std::string& ofilename,
+                         const std::string& filename,
                          void* memp, IData start, IData end) VL_MT_SAFE;
 extern void VL_WRITEMEM_N(bool hex, int width, int depth, int array_lsb,
-                          const std::string& ofilename,
+                          const std::string& filename,
                           const void* memp, IData start, IData end) VL_MT_SAFE;
 extern IData VL_SSCANF_INX(int lbits, const std::string& ld, const char* formatp, ...) VL_MT_SAFE;
 extern void VL_SFORMAT_X(int obits_ignored, std::string& output, const char* formatp, ...) VL_MT_SAFE;
 extern std::string VL_SFORMATF_NX(const char* formatp, ...) VL_MT_SAFE;
-extern IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rdp) VL_MT_SAFE;
+extern IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rwp) VL_MT_SAFE;
 inline IData VL_VALUEPLUSARGS_INI(int rbits, const std::string& ld, IData& rdr) VL_MT_SAFE {
     WData rwp[2];  // WData must always be at least 2
     IData got = VL_VALUEPLUSARGS_INW(rbits,ld,rwp);

include/verilated_imp.h

@@ -33,11 +33,9 @@
 #include "verilated_heavy.h"
 #include "verilated_syms.h"
 
-#include <map>
+#include <deque>
 #include <set>
 #include <vector>
-#include <deque>
-#include <string>
 #ifdef VL_THREADED
 # include <functional>
 # include <queue>

include/verilated_lxt2_c.cpp

@@ -23,15 +23,16 @@
 #include "verilatedos.h"
 #include "verilated.h"
 #include "verilated_lxt2_c.h"
+
 // Include the GTKWave implementation directly
 #include "gtkwave/lxt2_write.cpp"
 
-#include <sys/stat.h>
-#include <fcntl.h>
+#include <algorithm>
 #include <cerrno>
 #include <ctime>
-#include <algorithm>
+#include <fcntl.h>
 #include <sstream>
+#include <sys/stat.h>
 
 #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
 # include <io.h>

include/verilated_lxt2_c.h

@@ -25,11 +25,12 @@
 
 #include "verilatedos.h"
 #include "verilated.h"
+
 #include "gtkwave/lxt2_write.h"
 
+#include <map>
 #include <string>
 #include <vector>
-#include <map>
 
 class VerilatedLxt2;
 class VerilatedLxt2CallInfo;
@@ -69,10 +70,10 @@ public:
         lxt2_wr_close(m_lxt2);
         m_lxt2 = NULL;
     }
-    // void set_time_unit(const char* unit); ///< Set time units (s/ms, defaults to ns)
+    // void set_time_unit(const char* unitp);  ///< Set time units (s/ms, defaults to ns)
     // void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
 
-    // void set_time_resolution(const char* unit); ///< Set time resolution (s/ms, defaults to ns)
+    // void set_time_resolution(const char* unitp);  ///< Set time resolution (s/ms, defaults to ns)
     // void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
 
     // double timescaleToDouble(const char* unitp);
@@ -85,8 +86,8 @@ public:
     /// Inside dumping routines, called each cycle to make the dump
     void dump(vluint64_t timeui);
     /// Inside dumping routines, declare callbacks for tracings
-    void addCallback(VerilatedLxt2Callback_t init, VerilatedLxt2Callback_t full,
-                     VerilatedLxt2Callback_t change,
+    void addCallback(VerilatedLxt2Callback_t initcb, VerilatedLxt2Callback_t fullcb,
+                     VerilatedLxt2Callback_t changecb,
                      void* userthis) VL_MT_UNSAFE_ONE;
 
     /// Inside dumping routines, declare a module

include/verilated_save.cpp

@@ -23,8 +23,8 @@
 #include "verilated.h"
 #include "verilated_save.h"
 
-#include <fcntl.h>
 #include <cerrno>
+#include <fcntl.h>
 
 #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
 # include <io.h>
@@ -38,6 +38,9 @@
 #ifndef O_NONBLOCK
 # define O_NONBLOCK 0
 #endif
+#ifndef O_CLOEXEC
+# define O_CLOEXEC 0
+#endif
 
 // CONSTANTS
 static const char* const VLTSAVE_HEADER_STR = "verilatorsave01\n";	///< Value of first bytes of each file
@@ -50,7 +53,7 @@ static const char* const VLTSAVE_TRAILER_STR = "vltsaved";	///< Value of last by
 
 bool VerilatedDeserialize::readDiffers(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
     bufferCheck();
-    const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
+    const vluint8_t* __restrict dp = static_cast<const vluint8_t* __restrict>(datap);
     vluint8_t miss = 0;
     while (size--) {
 	miss |= (*dp++ ^ *m_cp++);
@@ -119,7 +122,7 @@ void VerilatedSave::open(const char* filenamep) VL_MT_UNSAFE_ONE {
 	assert(0);	// Not supported yet.
     } else {
 	// cppcheck-suppress duplicateExpression
-        m_fd = ::open(filenamep, O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK
+        m_fd = ::open(filenamep, O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK|O_CLOEXEC
                       , 0666);
 	if (m_fd<0) {
 	    // User code can check isOpen()
@@ -142,7 +145,7 @@ void VerilatedRestore::open(const char* filenamep) VL_MT_UNSAFE_ONE {
 	assert(0);	// Not supported yet.
     } else {
 	// cppcheck-suppress duplicateExpression
-        m_fd = ::open(filenamep, O_CREAT|O_RDONLY|O_LARGEFILE
+        m_fd = ::open(filenamep, O_CREAT|O_RDONLY|O_LARGEFILE|O_CLOEXEC
                       , 0666);
 	if (m_fd<0) {
 	    // User code can check isOpen()

include/verilated_sc.h

@@ -28,6 +28,7 @@
 #define _VERILATED_SC_H_ 1 ///< Header Guard
 
 #include "verilatedos.h"
+
 #include "systemc.h"
 
 //=============================================================================

include/verilated_sym_props.h

@@ -32,6 +32,8 @@
 #ifndef _VERILATED_SYM_PROPS_H_
 #define _VERILATED_SYM_PROPS_H_ 1 ///< Header Guard
 
+#include "verilatedos.h"
+
 //===========================================================================
 /// Verilator range
 /// Thread safety: Assume is constructed only with model, then any number of readers

include/verilated_syms.h

@@ -31,9 +31,10 @@
 #ifndef _VERILATED_SYMS_H_
 #define _VERILATED_SYMS_H_ 1 ///< Header Guard
 
+#include "verilatedos.h"
+#include "verilated_heavy.h"
 #include "verilated_sym_props.h"
 
-#include "verilated_heavy.h"
 #include <map>
 
 //======================================================================

include/verilated_threads.cpp

@@ -21,6 +21,7 @@
 
 #include "verilatedos.h"
 #include "verilated_threads.h"
+
 #include <cstdio>
 
 std::atomic<vluint64_t> VlNotification::s_yields;

include/verilated_threads.h

@@ -23,18 +23,15 @@
 #define _VERILATED_THREADS_H_
 
 #include "verilatedos.h"
+#include "verilated.h"  // for VerilatedMutex and clang annotations
 
-#include <atomic>
-#include <thread>
-#include <vector>
-#include <set>
 #include <sched.h>  // For sched_getcpu()
+#include <set>
+#include <vector>
 #if defined(__APPLE__)
 # include <cpuid.h>  // For __cpuid_count()
 #endif
 
-#include "verilated.h"  // for VerilatedMutex and clang annotations
-
 // VlMTaskVertex and VlThreadpool will work with multiple symbol table types.
 // Since the type is opaque to VlMTaskVertex and VlThreadPool, represent it
 // as a void* here.

include/verilated_unordered_set_map.h

@@ -39,7 +39,6 @@
 #ifndef _V3_UNORDERED_SET_MAP_H_
 #define _V3_UNORDERED_SET_MAP_H_
 
-#include "verilated_config.h"
 #include "verilatedos.h"
 
 #include <list>

include/verilated_vcd_c.cpp

@@ -24,11 +24,11 @@
 #include "verilated.h"
 #include "verilated_vcd_c.h"
 
-#include <sys/stat.h>
-#include <fcntl.h>
+#include <algorithm>
 #include <cerrno>
 #include <ctime>
-#include <algorithm>
+#include <fcntl.h>
+#include <sys/stat.h>
 
 #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
 # include <io.h>
@@ -44,6 +44,9 @@
 #ifndef O_NONBLOCK
 # define O_NONBLOCK 0
 #endif
+#ifndef O_CLOEXEC
+# define O_CLOEXEC 0
+#endif
 
 //=============================================================================
 // VerilatedVcdImp
@@ -109,7 +112,7 @@ protected:
 // VerilatedVcdFile
 
 bool VerilatedVcdFile::open(const std::string& name) VL_MT_UNSAFE {
-    m_fd = ::open(name.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK, 0666);
+    m_fd = ::open(name.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK|O_CLOEXEC, 0666);
     return (m_fd>=0);
 }
 
@@ -182,7 +185,7 @@ void VerilatedVcd::openNext(bool incFilename) {
     if (incFilename) {
         // Find _0000.{ext} in filename
         std::string name = m_filename;
-        size_t pos=name.rfind(".");
+        size_t pos = name.rfind('.');
         if (pos>8 && 0==strncmp("_cat",name.c_str()+pos-8,4)
             && isdigit(name.c_str()[pos-4])
             && isdigit(name.c_str()[pos-3])
@@ -237,7 +240,7 @@ void VerilatedVcd::makeNameMap() {
     bool nullScope = false;
     for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
         const std::string& hiername = it->first;
-        if (hiername.size() >= 1 && hiername[0] == '\t') nullScope=true;
+        if (!hiername.empty() && hiername[0] == '\t') nullScope=true;
     }
     if (nullScope) {
         NameMap* newmapp = new NameMap;
@@ -546,13 +549,15 @@ void VerilatedVcd::declare(vluint32_t code, const char* name, const char* wirep,
     // Tab sorts before spaces, so signals nicely will print before scopes
     // Note the hiername may be nothing, if so we'll add "\t{name}"
     std::string nameasstr = name;
-    if (m_modName!="") { nameasstr = m_modName+m_scopeEscape+nameasstr; }  // Optional ->module prefix
+    if (!m_modName.empty()) {
+        nameasstr = m_modName+m_scopeEscape+nameasstr;  // Optional ->module prefix
+    }
     std::string hiername;
     std::string basename;
     for (const char* cp=nameasstr.c_str(); *cp; cp++) {
         if (isScopeEscape(*cp)) {
             // Ahh, we've just read a scope, not a basename
-            if (hiername!="") hiername += " ";
+            if (!hiername.empty()) hiername += " ";
             hiername += basename;
             basename = "";
         } else {

include/verilated_vcd_c.h

@@ -26,9 +26,9 @@
 #include "verilatedos.h"
 #include "verilated.h"
 
+#include <map>
 #include <string>
 #include <vector>
-#include <map>
 
 class VerilatedVcd;
 class VerilatedVcdCallInfo;
@@ -121,7 +121,7 @@ private:
     void openNext();
     void makeNameMap();
     void deleteNameMap();
-    void printIndent(int levelchange);
+    void printIndent(int level_change);
     void printStr(const char* str);
     void printQuad(vluint64_t n);
     void printTime(vluint64_t timeui);
@@ -172,10 +172,10 @@ public:
     /// Flush any remaining data from all files
     static void flush_all() VL_MT_UNSAFE_ONE;
 
-    void set_time_unit(const char* unit);  ///< Set time units (s/ms, defaults to ns)
+    void set_time_unit(const char* unitp);  ///< Set time units (s/ms, defaults to ns)
     void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
 
-    void set_time_resolution(const char* unit);  ///< Set time resolution (s/ms, defaults to ns)
+    void set_time_resolution(const char* unitp);  ///< Set time resolution (s/ms, defaults to ns)
     void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
 
     double timescaleToDouble(const char* unitp);
@@ -187,8 +187,8 @@ public:
     void dumpSeconds(double secs) { dump(static_cast<vluint64_t>(secs * m_timeRes)); }
 
     /// Inside dumping routines, declare callbacks for tracings
-    void addCallback(VerilatedVcdCallback_t init, VerilatedVcdCallback_t full,
-                     VerilatedVcdCallback_t change,
+    void addCallback(VerilatedVcdCallback_t initcb, VerilatedVcdCallback_t fullcb,
+                     VerilatedVcdCallback_t changecb,
                      void* userthis) VL_MT_UNSAFE_ONE;
 
     /// Inside dumping routines, declare a module

include/verilated_vcd_sc.h

@@ -25,6 +25,7 @@
 #ifndef _VERILATED_VCD_SC_H_
 #define _VERILATED_VCD_SC_H_ 1
 
+#include "verilatedos.h"
 #include "verilated_sc.h"
 #include "verilated_vcd_c.h"
 

include/verilated_vpi.cpp

@@ -33,8 +33,8 @@
 #include "verilated_vpi.h"
 
 #include <list>
-#include <set>
 #include <map>
+#include <set>
 
 //======================================================================
 // Internal constants
@@ -79,11 +79,10 @@ public:
             vluint8_t* newp = t_freeHead;
             t_freeHead = *((vluint8_t**)newp);
             return newp+8;
-        } else {
-            // +8: 8 bytes for next
-            vluint8_t* newp = reinterpret_cast<vluint8_t*>(::operator new(chunk+8));
-            return newp+8;
         }
+        // +8: 8 bytes for next
+        vluint8_t* newp = reinterpret_cast<vluint8_t*>(::operator new(chunk+8));
+        return newp+8;
     }
     inline static void operator delete(void* obj, size_t size) VL_MT_SAFE {
         vluint8_t* oldp = ((vluint8_t*)obj)-8;
@@ -156,9 +155,8 @@ public:
             VerilatedVpioRange* nextp = new VerilatedVpioRange(*this);
             nextp->iterationInc();
             return ((nextp)->castVpiHandle());
-        } else {
-            return 0;  // End of list - only one deep
         }
+        return 0;  // End of list - only one deep
     }
 };
 
@@ -275,9 +273,8 @@ public:
             if (m_it == varsp->end()) return 0;
             return ((new VerilatedVpioVar(&(m_it->second), m_scopep))
                     ->castVpiHandle());
-        } else {
-            return 0;  // End of list - only one deep
         }
+        return 0;  // End of list - only one deep
     }
 };
 
@@ -388,9 +385,8 @@ public:
         VpioTimedCbs::const_iterator it=s_s.m_timedCbs.begin();
         if (VL_LIKELY(it!=s_s.m_timedCbs.end())) {
             return it->first;
-        } else {
-            return ~VL_ULL(0);  // maxquad
         }
+        return ~VL_ULL(0);  // maxquad
     }
     static void callCbs(vluint32_t reason) {
         VpioCbList& cbObjList = s_s.m_cbObjLists[reason];
@@ -1037,17 +1033,15 @@ vpiHandle vpi_handle_by_index(vpiHandle object, PLI_INT32 indx) {
 	    return (new VerilatedVpioMemoryWord(varop->varp(), varop->scopep(), indx,
                                               indx - varop->varp()->unpacked().right()))
 		->castVpiHandle();
-	} else {
-            if (VL_UNLIKELY(indx < varop->varp()->unpacked().left()
-                            || indx > varop->varp()->unpacked().right())) return 0;
-	    return (new VerilatedVpioMemoryWord(varop->varp(), varop->scopep(), indx,
-                                              indx - varop->varp()->unpacked().left()))
-		->castVpiHandle();
 	}
-    } else {
-	_VL_VPI_INTERNAL(__FILE__, __LINE__, "%s : can't resolve handle", VL_FUNC);
-        return 0;
+        if (VL_UNLIKELY(indx < varop->varp()->unpacked().left()
+                        || indx > varop->varp()->unpacked().right())) return 0;
+        return (new VerilatedVpioMemoryWord(varop->varp(), varop->scopep(), indx,
+                                            indx - varop->varp()->unpacked().left()))
+            ->castVpiHandle();
     }
+    _VL_VPI_INTERNAL(__FILE__, __LINE__, "%s : can't resolve handle", VL_FUNC);
+    return 0;
 }
 
 // for traversing relationships

include/verilated_vpi.h

@@ -26,6 +26,7 @@
 #ifndef _VERILATED_VPI_H_
 #define _VERILATED_VPI_H_ 1 ///< Header Guard
 
+#include "verilatedos.h"
 #include "verilated.h"
 #include "verilated_syms.h"
 

include/verilatedos.h

@@ -40,7 +40,7 @@
 # ifdef _WIN32
 #  define VL_ATTR_PRINTF(fmtArgNum)  // GCC with MS runtime will fool the print arg checker
 # else
-#  define VL_ATTR_PRINTF(fmtArgNum) __attribute__ ((format (printf, fmtArgNum, fmtArgNum+1)))
+#  define VL_ATTR_PRINTF(fmtArgNum) __attribute__ ((format (printf, (fmtArgNum), (fmtArgNum)+1)))
 # endif
 # define VL_ATTR_PURE __attribute__ ((pure))
 # define VL_ATTR_UNUSED __attribute__ ((unused))
@@ -202,11 +202,11 @@
 //=========================================================================
 // Basic integer types
 
-#ifdef VL_UINTS_DEFINED
-#elif defined(__CYGWIN__)
+#if defined(__CYGWIN__)
 
 # include <stdint.h>
 # include <sys/types.h>  // __WORDSIZE
+# include <unistd.h>  // ssize_t
 typedef unsigned char           uint8_t;	///< 8-bit unsigned type (backward compatibility)
 typedef unsigned short int      uint16_t;	///< 16-bit unsigned type (backward compatibility)
 typedef unsigned char           vluint8_t;	///< 8-bit unsigned type
@@ -249,10 +249,10 @@ typedef signed   __int32        ssize_t;        ///< signed size_t; returned fro
 
 #else // Linux or compliant Unix flavors, -m64
 
-# include <stdint.h>	// Linux and most flavors
-# include <unistd.h>	// Linux ssize_t
 # include <inttypes.h>	// Solaris
+# include <stdint.h>  // Linux and most flavors
 # include <sys/types.h>  // __WORDSIZE
+# include <unistd.h>  // ssize_t
 typedef uint8_t			vluint8_t;	///< 32-bit unsigned type
 typedef uint16_t		vluint16_t;	///< 32-bit unsigned type
 typedef int			vlsint32_t;	///< 32-bit signed type

nodist/git_untabify

@@ -11,6 +11,7 @@ use strict;
 use vars qw ($Debug);
 
 our $VERSION = '0.001';
+our $Opt_Widen = 1;
 
 #======================================================================
 # main
@@ -22,7 +23,9 @@ if (! GetOptions (
           "debug"       => sub { $Debug = 1; },
           "help"        => sub { print "Version $VERSION\n";
                                  pod2usage(-verbose=>2, -exitval => 2, output=>\*STDOUT, -noperldoc=>1); },
+          "narrow!"     => sub { $Opt_Widen = 0; },
           "version"     => sub { print "Version $VERSION\n"; exit(0); },
+          "widen!"      => sub { $Opt_Widen = 1; },  # Default, undocumented
           "<>"          => sub { die "%Error: Unknown parameter: $_[0]\n"; },
     )) {
     die "%Error: Bad usage, try 'git_untabify --help'\n";
@@ -35,9 +38,12 @@ read_patch();
 sub read_patch {
     my $filename = undef;
     my $lineno = 0;
+    my $hunk = 0;
     my $editlines = {};
     while (defined(my $line = <STDIN>)) {
+        chomp $line;
         if ($line =~ m!^\+\+\+ b/(.*)!) {
+            find_edits($editlines);
             edit_file($filename, $editlines);
             $filename = $1;
             $lineno = 0;
@@ -46,32 +52,78 @@ sub read_patch {
         }
         elsif ($line  =~ m!^@@ -?[0-9]+,?[0-9]* \+?([0-9]+)!) {
             $lineno = $1 - 1;
+            ++$hunk;
             print "  LINE $1  $line" if $Debug;
         }
         elsif ($line  =~ m!^ !) {
             ++$lineno;
+            $editlines->{$lineno} = {line => $line,
+                                     hunk => $hunk,
+                                     user_edit => 0, };
         }
         elsif ($line  =~ m!^\+!) {
             ++$lineno;
-            if ($line  =~ m!\t!) {
-                print "  $lineno: $line" if $Debug;
-                $editlines->{$lineno} = 1;
+            print "  $lineno: $line" if $Debug;
+            $editlines->{$lineno} = {line => $line,
+                                     hunk => $hunk,
+                                     user_edit => 1, };
+        }
+    }
+    find_edits($editlines);
+    edit_file($filename, $editlines);
+}
+
+sub find_edits {
+    my $editlines = shift;
+    # Expand edit regions so if have edited line, non-edited line, edited
+    # line, we will tab expand the middle ones.
+    my %hunk_firstlines;
+    foreach my $lineno (sort {$a <=> $b} keys %$editlines) {
+        my $hunk = $editlines->{$lineno}{hunk};
+        $hunk_firstlines{$hunk} ||= $lineno if $editlines->{$lineno}{user_edit};
+    }
+    my %hunk_lastlines;
+    foreach my $lineno (sort {$b <=> $a} keys %$editlines) {
+        my $hunk = $editlines->{$lineno}{hunk};
+        $hunk_lastlines{$hunk} ||= $lineno if $editlines->{$lineno}{user_edit};
+    }
+    # Expand to always untabify at least 3 lines (so that future diff will
+    # have non-tabs within a edit hunk distance
+    foreach my $hunk (keys %hunk_firstlines) {
+        if ($hunk_firstlines{$hunk} == $hunk_lastlines{$hunk}) {
+            --$hunk_firstlines{$hunk};
+            ++$hunk_lastlines{$hunk};
+        }
+        elsif ($hunk_firstlines{$hunk}+1 == $hunk_lastlines{$hunk}) {
+            ++$hunk_lastlines{$hunk};
+        }
+    }
+
+    foreach my $lineno (sort {$a <=> $b} keys %$editlines) {
+        if ($editlines->{$lineno}{line} =~ /\t/) {
+            my $hunk = $editlines->{$lineno}{hunk};
+            if ($hunk_firstlines{$hunk} <= $lineno && $hunk_lastlines{$hunk} >= $lineno) {
+                $editlines->{$lineno}{editit} = 1;
             }
         }
     }
-    edit_file($filename, $editlines);
 }
 
 sub edit_file {
     my $filename = shift;
     my $editlines = shift;
 
-    return if (scalar keys(%$editlines) < 1);
+    my @editits;
+    foreach my $lineno (sort {$a <=> $b} keys %$editlines) {
+        push @editits, $lineno if $editlines->{$lineno}{editit};
+    }
+    
+    return if $#editits < 0;
     if (ignore($filename)) {
         print "%Warning: Ignoring $filename\n";
         return;
     }
-    print "Edit $filename ",join(",",sort(keys %$editlines)),"\n";
+    print "Edit $filename ",join(",",@editits),"\n";
 
     my $lineno = 0;
     my @out;
@@ -79,7 +131,7 @@ sub edit_file {
         my $fh = IO::File->new("<$filename") or die "%Error: $! $filename\n";
         while (defined(my $line = $fh->getline)) {
             ++$lineno;
-            if ($editlines->{$lineno}) {
+            if ($editlines->{$lineno}{editit}) {
                 print $line;
                 push @out, untabify($line);
             } else {
@@ -104,6 +156,7 @@ sub ignore {
     my $filename = shift;
     return 1 if ($filename =~ /(Makefile|\.mk)/);
     return 1 if ($filename =~ /\.(y|l|out|vcd)$/);
+    return 1 if ($filename =~ /gtkwave/);
     #
     return 0 if ($filename =~ /\.(sv|v|vh|svh|h|vc|cpp|pl)$/);
     return 0;
@@ -151,6 +204,13 @@ untabify the related patch lines.
 
 Displays this message and program version and exits.
 
+=item --narrow
+
+Only edit lines which the user edited.
+
+If not provided, also edit other lines within at least a 3 line area around
+the edit, and between any edits within the same hunk.
+
 =item --version
 
 Displays program version and exits.

src/V3Active.cpp

@@ -32,12 +32,6 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <map>
-#include <algorithm>
-#include <vector>
 
 #include "V3Global.h"
 #include "V3Active.h"
@@ -45,6 +39,7 @@
 #include "V3EmitCBase.h"
 #include "V3Const.h"
 #include "V3SenTree.h"  // for SenTreeSet
+
 #include VL_INCLUDE_UNORDERED_MAP
 
 //***** See below for main transformation engine

src/V3Active.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3ACTIVE_H_
 #define _V3ACTIVE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3ActiveTop.cpp

@@ -29,11 +29,6 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
-#include <vector>
 
 #include "V3Global.h"
 #include "V3ActiveTop.h"

src/V3ActiveTop.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3ACTIVETOP_H_
 #define _V3ACTIVETOP_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Assert.cpp

@@ -20,11 +20,6 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <map>
-#include <iomanip>
 
 #include "V3Global.h"
 #include "V3Assert.h"
@@ -32,6 +27,9 @@
 #include "V3GraphDfa.h"
 #include "V3Stats.h"
 
+#include <cstdarg>
+#include <iomanip>
+
 //######################################################################
 // Assert class functions
 
@@ -77,13 +75,14 @@ private:
     AstNode* newIfAssertOn(AstNode* nodep) {
 	// Add a internal if to check assertions are on.
 	// Don't make this a AND term, as it's unlikely to need to test this.
+        FileLine* fl = nodep->fileline();
 	AstNode* newp
-            = new AstIf(nodep->fileline(),
+            = new AstIf(fl,
                         // If assertions are off, have constant propagation rip them out later
                         // This allows syntax errors and such to be detected normally.
                         (v3Global.opt.assertOn()
-                         ? (AstNode*)(new AstCMath(nodep->fileline(), "Verilated::assertOn()", 1))
-                         : (AstNode*)(new AstConst(nodep->fileline(), AstConst::LogicFalse()))),
+                         ? static_cast<AstNode*>(new AstCMath(fl, "Verilated::assertOn()", 1))
+                         : static_cast<AstNode*>(new AstConst(fl, AstConst::LogicFalse()))),
                         nodep, NULL);
 	newp->user1(true); // Don't assert/cover this if
 	return newp;

src/V3Assert.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3ASSERT_H_
 #define _V3ASSERT_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3AssertPre.cpp

@@ -23,15 +23,12 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <map>
-#include <iomanip>
 
 #include "V3Global.h"
 #include "V3AssertPre.h"
-#include "V3Ast.h"
+
+#include <cstdarg>
+#include <iomanip>
 
 //######################################################################
 // Assert class functions

src/V3AssertPre.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3ASSERTPRE_H_
 #define _V3ASSERTPRE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Ast.cpp

@@ -18,11 +18,8 @@
 //
 //*************************************************************************
 
-#include <cstdio>
-#include <cstdarg>
-#include <fstream>
-#include <iomanip>
-#include <memory>
+#include "config_build.h"
+#include "verilatedos.h"
 
 #include "V3Ast.h"
 #include "V3File.h"
@@ -30,6 +27,10 @@
 #include "V3Broken.h"
 #include "V3String.h"
 
+#include <cstdarg>
+#include <iomanip>
+#include <memory>
+
 //======================================================================
 // Statics
 
@@ -158,7 +159,7 @@ string AstNode::vcdName(const string& namein) {
     while ((pos=pretty.find("__DOT__")) != string::npos) {
 	pretty.replace(pos, 7, " ");
     }
-    while ((pos=pretty.find(".")) != string::npos) {
+    while ((pos = pretty.find('.')) != string::npos) {
 	pretty.replace(pos, 1, " ");
     }
     // Now convert escaped special characters, etc
@@ -230,7 +231,7 @@ inline void AstNode::debugTreeChange(const char* prefix, int lineno, bool next)
     // Only for use for those really nasty bugs relating to internals
     // Note this may be null.
     //if (debug()) cout<<"-treeChange: V3Ast.cpp:"<<lineno<<" Tree Change for "
-    //                 <<prefix<<": "<<(void*)this<<" <e"<<AstNode::s_editCntGbl<<">"<<endl;
+    //                 <<prefix<<": "<<cvtToHex(this)<<" <e"<<AstNode::s_editCntGbl<<">"<<endl;
     //if (debug()) {
     //	cout<<"-treeChange: V3Ast.cpp:"<<lineno<<" Tree Change for "<<prefix<<endl;
     //	// Commenting out the section below may crash, as the tree state
@@ -418,8 +419,8 @@ void AstNode::replaceWith(AstNode* newp) {
 }
 
 void AstNRelinker::dump(std::ostream& str) const {
-    str<<" BK="<<(uint32_t*)m_backp;
-    str<<" ITER="<<(uint32_t*)m_iterpp;
+    str<<" BK="<<reinterpret_cast<uint32_t*>(m_backp);
+    str<<" ITER="<<reinterpret_cast<uint32_t*>(m_iterpp);
     str<<" CHG="<<(m_chg==RELINK_NEXT?"[NEXT] ":"");
     str<<(m_chg==RELINK_OP1?"[OP1] ":"");
     str<<(m_chg==RELINK_OP2?"[OP2] ":"");
@@ -669,13 +670,13 @@ void AstNode::deleteNode() {
     UASSERT(!m_backp, "Delete called on node with backlink still set");
     editCountInc();
     // Change links of old node so we coredump if used
-    this->m_nextp = (AstNode*)1;
-    this->m_backp = (AstNode*)1;
-    this->m_headtailp = (AstNode*)1;
-    this->m_op1p = (AstNode*)1;
-    this->m_op2p = (AstNode*)1;
-    this->m_op3p = (AstNode*)1;
-    this->m_op4p = (AstNode*)1;
+    this->m_nextp = reinterpret_cast<AstNode*>(0x1);
+    this->m_backp = reinterpret_cast<AstNode*>(0x1);
+    this->m_headtailp = reinterpret_cast<AstNode*>(0x1);
+    this->m_op1p = reinterpret_cast<AstNode*>(0x1);
+    this->m_op2p = reinterpret_cast<AstNode*>(0x1);
+    this->m_op3p = reinterpret_cast<AstNode*>(0x1);
+    this->m_op4p = reinterpret_cast<AstNode*>(0x1);
     if (
 #if !defined(VL_DEBUG) || defined(VL_LEAK_CHECKS)
         1
@@ -787,8 +788,8 @@ void AstNode::iterateAndNext(AstNVisitor& v) {
 	niterp->accept(v);
 	// accept may do a replaceNode and change niterp on us...
         // niterp maybe NULL, so need cast if printing
-        //if (niterp != nodep) UINFO(1,"iterateAndNext edited "<<(void*)nodep
-        //                             <<" now into "<<(void*)niterp<<endl);
+        //if (niterp != nodep) UINFO(1,"iterateAndNext edited "<<cvtToHex(nodep)
+        //                             <<" now into "<<cvtToHex(niterp)<<endl);
 	if (!niterp) return;  // Perhaps node deleted inside accept
 	niterp->m_iterpp = NULL;
 	if (VL_UNLIKELY(niterp!=nodep)) { // Edited node inside accept
@@ -997,23 +998,23 @@ void AstNode::checkIter() const {
 }
 
 void AstNode::dumpPtrs(std::ostream& os) const {
-    os<<"This="<<typeName()<<" "<<(void*)this;
-    os<<" back="<<(void*)backp();
-    if (nextp()) os<<" next="<<(void*)nextp();
+    os<<"This="<<typeName()<<" "<<cvtToHex(this);
+    os<<" back="<<cvtToHex(backp());
+    if (nextp()) os<<" next="<<cvtToHex(nextp());
     if (m_headtailp==this) os<<" headtail=this";
-    else os<<" headtail="<<(void*)m_headtailp;
-    if (op1p()) os<<" op1p="<<(void*)op1p();
-    if (op2p()) os<<" op2p="<<(void*)op2p();
-    if (op3p()) os<<" op3p="<<(void*)op3p();
-    if (op4p()) os<<" op4p="<<(void*)op4p();
-    if (user1p()) os<<" user1p="<<(void*)user1p();
-    if (user2p()) os<<" user2p="<<(void*)user2p();
-    if (user3p()) os<<" user3p="<<(void*)user3p();
-    if (user4p()) os<<" user4p="<<(void*)user4p();
-    if (user5p()) os<<" user5p="<<(void*)user5p();
+    else os<<" headtail="<<cvtToHex(m_headtailp);
+    if (op1p()) os<<" op1p="<<cvtToHex(op1p());
+    if (op2p()) os<<" op2p="<<cvtToHex(op2p());
+    if (op3p()) os<<" op3p="<<cvtToHex(op3p());
+    if (op4p()) os<<" op4p="<<cvtToHex(op4p());
+    if (user1p()) os<<" user1p="<<cvtToHex(user1p());
+    if (user2p()) os<<" user2p="<<cvtToHex(user2p());
+    if (user3p()) os<<" user3p="<<cvtToHex(user3p());
+    if (user4p()) os<<" user4p="<<cvtToHex(user4p());
+    if (user5p()) os<<" user5p="<<cvtToHex(user5p());
     if (m_iterpp) {
-	os<<" iterpp="<<(void*)m_iterpp;
-	os<<"*="<<(void*)*m_iterpp;
+        os<<" iterpp="<<cvtToHex(m_iterpp);
+        os<<"*="<<cvtToHex(*m_iterpp);
     }
     os<<endl;
 }
@@ -1076,7 +1077,9 @@ void AstNode::v3errorEnd(std::ostringstream& str) const {
 	nsstr<<str.str();
 	if (debug()) {
 	    nsstr<<endl;
-	    nsstr<<"-node: "; ((AstNode*)this)->dump(nsstr); nsstr<<endl;
+            nsstr<<"-node: ";
+            const_cast<AstNode*>(this)->dump(nsstr);
+            nsstr<<endl;
 	}
 	m_fileline->v3errorEnd(nsstr);
     }

src/V3Ast.h

@@ -20,15 +20,16 @@
 
 #ifndef _V3AST_H_
 #define _V3AST_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3FileLine.h"
 #include "V3Number.h"
 #include "V3Global.h"
-#include <vector>
+
 #include <cmath>
-#include <map>
 #include VL_INCLUDE_UNORDERED_SET
 
 #include "V3Ast__gen_classes.h"	// From ./astgen
@@ -1026,7 +1027,7 @@ std::ostream& operator<<(std::ostream& os, const V3Hash& rhs);
 // Prefetch a node.
 // The if() makes it faster, even though prefetch won't fault on null pointers
 #define ASTNODE_PREFETCH(nodep) \
-    { if (nodep) { VL_PREFETCH_RD(&(nodep->m_nextp)); VL_PREFETCH_RD(&(nodep->m_iterpp)); }}
+    { if (nodep) { VL_PREFETCH_RD(&((nodep)->m_nextp)); VL_PREFETCH_RD(&((nodep)->m_iterpp)); }}
 
 class AstNode {
     // v ASTNODE_PREFETCH depends on below ordering of members
@@ -1170,8 +1171,8 @@ public:
     static string dedotName(const string& namein);	// Name with dots removed
     static string prettyName(const string& namein);	// Name for printing out to the user
     static string encodeName(const string& namein);	// Encode user name into internal C representation
-    static string encodeNumber(vlsint64_t numin);	// Encode number into internal C representation
-    static string vcdName(const string& namein); // Name for printing out to vcd files
+    static string encodeNumber(vlsint64_t num);  // Encode number into internal C representation
+    static string vcdName(const string& namein);  // Name for printing out to vcd files
     string	prettyName() const { return prettyName(name()); }
     string 	prettyTypeName() const;			// "VARREF" for error messages
     virtual string prettyOperatorName() const { return "operator "+prettyTypeName(); }
@@ -1346,13 +1347,13 @@ public:
     void	checkTree();  // User Interface version
     void	checkIter() const;
     void	clearIter() { m_iterpp=NULL; }
-    void        dumpPtrs(std::ostream& str=std::cout) const;
-    void        dumpTree(std::ostream& str=std::cout, const string& indent="    ", int maxDepth=0);
-    void	dumpTree(const string& indent, int maxDepth=0) { dumpTree(cout,indent,maxDepth); }
-    void	dumpTreeGdb(); // For GDB only
-    void        dumpTreeAndNext(std::ostream& str=std::cout, const string& indent="    ", int maxDepth=0);
-    void	dumpTreeFile(const string& filename, bool append=false, bool doDump=true);
-    static void	dumpTreeFileGdb(const char* filenamep=NULL);
+    void dumpPtrs(std::ostream& os=std::cout) const;
+    void dumpTree(std::ostream& os=std::cout, const string& indent="    ", int maxDepth=0);
+    void dumpTree(const string& indent, int maxDepth=0) { dumpTree(cout,indent,maxDepth); }
+    void dumpTreeGdb();  // For GDB only
+    void dumpTreeAndNext(std::ostream& os=std::cout, const string& indent="    ", int maxDepth=0);
+    void dumpTreeFile(const string& filename, bool append=false, bool doDump=true);
+    static void dumpTreeFileGdb(const char* filenamep=NULL);
 
     // METHODS - queries
     virtual bool isPure() const { return true; }	// Else a $display, etc, that must be ordered with other displays
@@ -1797,7 +1798,7 @@ public:
     bool widthSized() const { return !m_widthMin || m_widthMin==m_width; }
     bool generic() const { return m_generic; }
     void generic(bool flag) { m_generic = flag; }
-    AstNodeDType* dtypeDimensionp(int depth);
+    AstNodeDType* dtypeDimensionp(int dimension);
     std::pair<uint32_t,uint32_t> dimensions(bool includeBasic);
     uint32_t	arrayUnpackedElements();	// 1, or total multiplication of all dimensions
     static int uniqueNumInc() { return ++s_uniqueNum; }
@@ -1809,6 +1810,7 @@ private:
     // TYPES
     typedef std::map<string,AstMemberDType*> MemberNameMap;
     // MEMBERS
+    string m_name;  // Name from upper typedef, if any
     bool		m_packed;
     bool		m_isFourstate;
     MemberNameMap	m_members;
@@ -1837,6 +1839,8 @@ public:
     virtual bool similarDType(AstNodeDType* samep) const {
 	return this==samep;  // We don't compare members, require exact equivalence
     }
+    virtual string name() const { return m_name; }
+    void name(const string& flag) { m_name = flag; }
     AstMemberDType* membersp() const { return VN_CAST(op1p(), MemberDType); }  // op1 = AstMember list
     void addMembersp(AstNode* nodep) { addNOp1p(nodep); }
     bool packed() const { return m_packed; }

src/V3AstNodes.cpp

@@ -20,13 +20,6 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <fstream>
-#include <iomanip>
-#include <vector>
-#include <algorithm>
-#include VL_INCLUDE_UNORDERED_SET
 
 #include "V3Ast.h"
 #include "V3File.h"
@@ -34,6 +27,10 @@
 #include "V3Graph.h"
 #include "V3PartitionGraph.h"  // Just for mtask dumping
 
+#include <cstdarg>
+#include <iomanip>
+#include <vector>
+
 //======================================================================
 // Special methods
 
@@ -580,13 +577,15 @@ const char* AstScope::broken() const {
 void AstScope::cloneRelink() {
     if (m_aboveScopep && m_aboveScopep->clonep()) m_aboveScopep->clonep();
     if (m_aboveCellp && m_aboveCellp->clonep()) m_aboveCellp->clonep();
-    if (m_modp && ((AstNode*)m_modp)->clonep()) ((AstNode*)m_modp)->clonep();
+    if (m_modp && static_cast<AstNode*>(m_modp)->clonep()) {
+        static_cast<AstNode*>(m_modp)->clonep();
+    }
 }
 
 string AstScope::nameDotless() const {
     string out = shortName();
     string::size_type pos;
-    while ((pos=out.find(".")) != string::npos) {
+    while ((pos = out.find('.')) != string::npos) {
 	out.replace(pos, 1, "__");
     }
     return out;
@@ -613,7 +612,7 @@ string AstScopeName::scopeNameFormatter(AstText* scopeTextp) const {
     if (out.substr(0,7) == "__DOT__") out.replace(0,7,"");
     if (out.substr(0,1) == ".") out.replace(0,1,"");
     string::size_type pos;
-    while ((pos=out.find(".")) != string::npos) {
+    while ((pos = out.find('.')) != string::npos) {
 	out.replace(pos, 1, "__");
     }
     while ((pos=out.find("__DOT__")) != string::npos) {
@@ -654,7 +653,7 @@ bool AstSenTree::hasCombo() const {
 void AstTypeTable::clearCache() {
     // When we mass-change widthMin in V3WidthCommit, we need to correct the table.
     // Just clear out the maps; the search functions will be used to rebuild the map
-    for (int i=0; i<(int)(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
+    for (int i=0; i < static_cast<int>(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
 	m_basicps[i] = NULL;
     }
     for (int isbit=0; isbit<_IDX0_MAX; ++isbit) {
@@ -704,7 +703,7 @@ AstBasicDType* AstTypeTable::findLogicBitDType(FileLine* fl, AstBasicDTypeKwd kw
     else if (kwd == AstBasicDTypeKwd::BIT) idx = IDX0_BIT;
     else fl->v3fatalSrc("Bad kwd for findLogicBitDType");
     std::pair<int,int> widths = make_pair(width,widthMin);
-    LogicMap& mapr = m_logicMap[idx][(int)numeric];
+    LogicMap& mapr = m_logicMap[idx][static_cast<int>(numeric)];
     LogicMap::const_iterator it = mapr.find(widths);
     if (it != mapr.end()) return it->second;
     //
@@ -807,24 +806,25 @@ void AstWhile::addNextStmt(AstNode* newp, AstNode* belowp) {
 // Per-type Debugging
 
 void AstNode::dump(std::ostream& str) {
-    str<<typeName()<<" "<<(void*)this
-	//<<" "<<(void*)this->m_backp
+    str<<typeName()<<" "<<cvtToHex(this)
+        //<<" "<<cvtToHex(this)->m_backp
        <<" <e"<<std::dec<<editCount()
        <<((editCount()>=editCountLast())?"#>":">")
        <<" {"<<fileline()->filenameLetters()<<std::dec<<fileline()->lineno()<<"}";
-    if (user1p()) str<<" u1="<<(void*)user1p();
-    if (user2p()) str<<" u2="<<(void*)user2p();
-    if (user3p()) str<<" u3="<<(void*)user3p();
-    if (user4p()) str<<" u4="<<(void*)user4p();
-    if (user5p()) str<<" u5="<<(void*)user5p();
+    if (user1p()) str<<" u1="<<cvtToHex(user1p());
+    if (user2p()) str<<" u2="<<cvtToHex(user2p());
+    if (user3p()) str<<" u3="<<cvtToHex(user3p());
+    if (user4p()) str<<" u4="<<cvtToHex(user4p());
+    if (user5p()) str<<" u5="<<cvtToHex(user5p());
     if (hasDType()) {
+        // Final @ so less likely to by accident read it as a nodep
 	if (dtypep()==this) str<<" @dt="<<"this@";
-	else str<<" @dt="<<(void*)dtypep()<<"@";  // Final @ so less likely to by accident think it's nodep
+        else str<<" @dt="<<cvtToHex(dtypep())<<"@";
 	if (AstNodeDType* dtp = dtypep()) {
 	    dtp->dumpSmall(str);
 	}
     } else { // V3Broken will throw an error
-	if (dtypep()) str<<" %Error-dtype-exp=null,got="<<(void*)dtypep();
+        if (dtypep()) str<<" %Error-dtype-exp=null,got="<<cvtToHex(dtypep());
     }
     if (name()!="") {
         if (VN_IS(this, Const)) str<<"  "<<name();  // Already quoted
@@ -930,7 +930,7 @@ void AstNodeDType::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (generic()) str<<" [GENERIC]";
     if (AstNodeDType* dtp = virtRefDTypep()) {
-	str<<" refdt="<<(void*)(dtp);
+        str<<" refdt="<<cvtToHex(dtp);
 	dtp->dumpSmall(str);
     }
 }
@@ -993,7 +993,7 @@ void AstMTaskBody::dump(std::ostream& str) {
 }
 void AstTypeTable::dump(std::ostream& str) {
     this->AstNode::dump(str);
-    for (int i=0; i<(int)(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
+    for (int i=0; i < static_cast<int>(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
 	if (AstBasicDType* subnodep=m_basicps[i]) {
 	    str<<endl;  // Newline from caller, so newline first
             str<<"\t\t"<<std::setw(8)<<AstBasicDTypeKwd(i).ascii();
@@ -1040,7 +1040,7 @@ void AstVarScope::dump(std::ostream& str) {
 }
 void AstVarXRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
-    if (packagep()) { str<<" pkg="<<(void*)packagep(); }
+    if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
     if (lvalue()) str<<" [LV] => ";
     else          str<<" [RV] <- ";
     str<<".="<<dotted()<<" ";
@@ -1051,7 +1051,7 @@ void AstVarXRef::dump(std::ostream& str) {
 }
 void AstVarRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
-    if (packagep()) { str<<" pkg="<<(void*)packagep(); }
+    if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
     if (lvalue()) str<<" [LV] => ";
     else          str<<" [RV] <- ";
     if (varScopep()) { varScopep()->dump(str); }
@@ -1096,7 +1096,7 @@ void AstParseRef::dump(std::ostream& str) {
 }
 void AstPackageRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
-    if (packagep()) { str<<" pkg="<<(void*)packagep(); }
+    if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
     str<<" -> ";
     if (packagep()) { packagep()->dump(str); }
     else { str<<"UNLINKED"; }
@@ -1112,7 +1112,7 @@ void AstActive::dump(std::ostream& str) {
 }
 void AstNodeFTaskRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
-    if (packagep()) { str<<" pkg="<<(void*)packagep(); }
+    if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
     str<<" -> ";
     if (dotted()!="") { str<<".="<<dotted()<<" "; }
     if (taskp()) { taskp()->dump(str); }
@@ -1159,7 +1159,7 @@ void AstNodeText::dump(std::ostream& str) {
     this->AstNode::dump(str);
     string out = text();
     string::size_type pos;
-    if ((pos = out.find("\n")) != string::npos) {
+    if ((pos = out.find('\n')) != string::npos) {
 	out.erase(pos,out.length()-pos);
 	out += "...";
     }

src/V3AstNodes.h

@@ -779,6 +779,7 @@ class AstEnumDType : public AstNodeDType {
     // Parents: TYPEDEF/MODULE
     // Children: ENUMVALUEs
 private:
+    string m_name;  // Name from upper typedef, if any
     AstNodeDType*	m_refDTypep;	// Elements are of this type after V3Width
     int		m_uniqueNum;
 public:
@@ -809,6 +810,8 @@ public:
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
     virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; }
     virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); }
+    virtual string name() const { return m_name; }
+    void name(const string& flag) { m_name = flag; }
     AstEnumItem* itemsp() const { return VN_CAST(op2p(), EnumItem); }  // op2 = AstEnumItem's
     void addValuesp(AstNode* nodep) { addOp2p(nodep); }
     // METHODS
@@ -1402,7 +1405,7 @@ public:
     virtual string name()	const { return m_name; }		// * = Scope name
     virtual void name(const string& name) { m_name = name; }
     string nameDotless() const;
-    string nameVlSym() const { return (((string)"vlSymsp->") + nameDotless()); }
+    string nameVlSym() const { return ((string("vlSymsp->")) + nameDotless()); }
     AstNodeModule* modp()		const { return m_modp; }
     void addVarp(AstNode* nodep) { addOp1p(nodep); }
     AstNode* varsp()		const { return op1p(); }	// op1 = AstVarScope's
@@ -2582,8 +2585,8 @@ public:
     ASTNODE_NODE_FUNCS(Display)
     virtual void dump(std::ostream& str);
     virtual const char* broken() const { BROKEN_RTN(!fmtp()); return NULL; }
-    virtual string verilogKwd() const { return (filep() ? (string)"$f"+(string)displayType().ascii()
-						: (string)"$"+(string)displayType().ascii()); }
+    virtual string verilogKwd() const { return (filep() ? string("$f")+string(displayType().ascii())
+                                                : string("$")+string(displayType().ascii())); }
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
     virtual bool isPure() const { return false; }	// SPECIAL: $display has 'visual' ordering
@@ -3498,8 +3501,8 @@ class AstScopeName : public AstNodeMath {
     // Children: TEXT
 private:
     bool	m_dpiExport;	// Is for dpiExport
-    string scopeNameFormatter(AstText* textp) const;
-    string scopePrettyNameFormatter(AstText* textp) const;
+    string scopeNameFormatter(AstText* scopeTextp) const;
+    string scopePrettyNameFormatter(AstText* scopeTextp) const;
 public:
     explicit AstScopeName(FileLine* fl) : AstNodeMath(fl), m_dpiExport(false) {
 	dtypeSetUInt64(); }

src/V3Begin.cpp

@@ -31,17 +31,16 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
-#include <vector>
 
 #include "V3Global.h"
 #include "V3Begin.h"
 #include "V3Inst.h"
 #include "V3Ast.h"
 
+#include <algorithm>
+#include <cstdarg>
+#include <vector>
+
 //######################################################################
 
 class BeginState {
@@ -197,7 +196,7 @@ private:
 	    // To keep correct visual order, must add before other Text's
 	    AstNode* afterp = nodep->scopeAttrp();
 	    if (afterp) afterp->unlinkFrBackWithNext();
-	    nodep->scopeAttrp(new AstText(nodep->fileline(), (string)"__DOT__"+m_namedScope));
+            nodep->scopeAttrp(new AstText(nodep->fileline(), string("__DOT__")+m_namedScope));
 	    if (afterp) nodep->scopeAttrp(afterp);
 	}
         iterateChildren(nodep);

src/V3Begin.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3BEGIN_H_
 #define _V3BEGIN_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Branch.cpp

@@ -29,15 +29,14 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <map>
 
 #include "V3Global.h"
 #include "V3Branch.h"
 #include "V3Ast.h"
 
+#include <cstdarg>
+#include <map>
+
 //######################################################################
 // Branch state, as a visitor of each AstNode
 
@@ -135,7 +134,7 @@ public:
 //######################################################################
 // Branch class functions
 
-void V3Branch::branchAll(AstNetlist* rootp) {
+void V3Branch::branchAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    BranchVisitor visitor (rootp);
+    BranchVisitor visitor (nodep);
 }

src/V3Branch.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3BRANCH_H_
 #define _V3BRANCH_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 
@@ -30,7 +32,7 @@
 class V3Branch {
 public:
     // CONSTRUCTORS
-    static void branchAll(AstNetlist* rootp);
+    static void branchAll(AstNetlist* nodep);
 };
 
 #endif // Guard

src/V3Broken.cpp

@@ -27,11 +27,6 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
-#include VL_INCLUDE_UNORDERED_MAP
 
 #include "V3Global.h"
 #include "V3Broken.h"
@@ -40,6 +35,10 @@
 // This visitor does not edit nodes, and is called at error-exit, so should use constant iterators
 #include "V3AstConstOnly.h"
 
+#include <algorithm>
+#include <cstdarg>
+#include VL_INCLUDE_UNORDERED_MAP
+
 //######################################################################
 
 class BrokenTable : public AstNVisitor {
@@ -59,10 +58,11 @@ public:
     // METHODS
     static void deleted(const AstNode* nodep) {
 	// Called by operator delete on any node - only if VL_LEAK_CHECKS
-	if (debug()>=9) cout<<"-nodeDel:  "<<(void*)(nodep)<<endl;
+        if (debug()>=9) cout<<"-nodeDel:  "<<cvtToHex(nodep)<<endl;
 	NodeMap::iterator iter = s_nodes.find(nodep);
 	if (iter==s_nodes.end() || !(iter->second & FLAG_ALLOCATED)) {
-	    ((AstNode*)(nodep))->v3fatalSrc("Deleting AstNode object that was never tracked or already deleted");
+            reinterpret_cast<const AstNode*>(nodep)
+                ->v3fatalSrc("Deleting AstNode object that was never tracked or already deleted");
 	}
 	if (iter!=s_nodes.end()) s_nodes.erase(iter);
     }
@@ -72,7 +72,7 @@ public:
 #endif
     static void addNewed(const AstNode* nodep) {
 	// Called by operator new on any node - only if VL_LEAK_CHECKS
-	if (debug()>=9) cout<<"-nodeNew:  "<<(void*)(nodep)<<endl;
+        if (debug()>=9) cout<<"-nodeNew:  "<<cvtToHex(nodep)<<endl;
 	NodeMap::iterator iter = s_nodes.find(nodep);
 	if (iter!=s_nodes.end() || (iter->second & FLAG_ALLOCATED)) {
 	    nodep->v3fatalSrc("Newing AstNode object that is already allocated");
@@ -156,7 +156,9 @@ public:
 		    // may be varp() and other cross links that are bad.
 		    if (v3Global.opt.debugCheck()) {
                         std::cerr<<"%Error: LeakedNode"<<(it->first->backp()?"Back: ":": ");
-                        ((AstNode*)(it->first))->AstNode::dump(std::cerr);
+                        AstNode* rawp = const_cast<AstNode*>
+                            (static_cast<const AstNode*>(it->first));
+                        rawp->AstNode::dump(std::cerr);
                         std::cerr<<endl;
 			V3Error::incErrors();
 		    }
@@ -225,9 +227,12 @@ private:
 	}
 	if (nodep->dtypep()) {
             if (!nodep->dtypep()->brokeExists()) {
-                nodep->v3fatalSrc("Broken link in node->dtypep() to "<<(void*)nodep->dtypep()); }
-            else if (!VN_IS(nodep->dtypep(), NodeDType)) {
-                nodep->v3fatalSrc("Non-dtype link in node->dtypep() to "<<(void*)nodep->dtypep()); }
+                nodep->v3fatalSrc("Broken link in node->dtypep() to "
+                                  <<cvtToHex(nodep->dtypep()));
+            } else if (!VN_IS(nodep->dtypep(), NodeDType)) {
+                nodep->v3fatalSrc("Non-dtype link in node->dtypep() to "
+                                  <<cvtToHex(nodep->dtypep()));
+            }
 	}
 	if (v3Global.assertDTypesResolved()) {
 	    if (nodep->hasDType()) {

src/V3Broken.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3BROKEN_H_
 #define _V3BROKEN_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3CCtors.cpp

@@ -27,20 +27,20 @@
 //
 //	This transformation honors outputSplitCFuncs.
 //*************************************************************************
+
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <cmath>
-#include <map>
-#include <vector>
-#include <algorithm>
 
 #include "V3Global.h"
 #include "V3EmitCBase.h"
 #include "V3CCtors.h"
 
+#include <algorithm>
+#include <cmath>
+#include <cstdarg>
+#include <map>
+#include <vector>
+
 class V3CCtorsVisitor {
 private:
     string 		m_basename;

src/V3CCtors.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3CCTORS_H_
 #define _V3CCTORS_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Case.cpp

@@ -39,16 +39,15 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
 
 #include "V3Global.h"
 #include "V3Case.h"
 #include "V3Ast.h"
 #include "V3Stats.h"
 
+#include <algorithm>
+#include <cstdarg>
+
 #define CASE_OVERLAP_WIDTH 12		// Maximum width we can check for overlaps in
 #define CASE_BARF	   999999	// Magic width when non-constant
 #define CASE_ENCODER_GROUP_DEPTH 8	// Levels of priority to be ORed together in top IF tree

src/V3Case.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3CASE_H_
 #define _V3CASE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Cast.cpp

@@ -43,15 +43,14 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
 
 #include "V3Global.h"
 #include "V3Cast.h"
 #include "V3Ast.h"
 
+#include <algorithm>
+#include <cstdarg>
+
 //######################################################################
 // Cast state, as a visitor of each AstNode
 

src/V3Cast.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3CAST_H_
 #define _V3CAST_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Cdc.cpp

@@ -27,15 +27,6 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
-#include <iomanip>
-#include <vector>
-#include <deque>
-#include <list>
-#include <memory>
 
 #include "V3Global.h"
 #include "V3Cdc.h"
@@ -45,6 +36,14 @@
 #include "V3EmitV.h"
 #include "V3File.h"
 
+#include <algorithm>
+#include <cstdarg>
+#include <deque>
+#include <iomanip>
+#include <list>
+#include <memory>
+#include <vector>
+
 #define CDC_WEIGHT_ASYNC	0x1000	// Weight for edges that feed async logic
 
 //######################################################################
@@ -98,7 +97,7 @@ public:
     virtual ~CdcVarVertex() {}
     // ACCESSORS
     AstVarScope* varScp() const { return m_varScp; }
-    virtual string name() const { return (cvtToStr((void*)m_varScp)+" "+varScp()->name()); }
+    virtual string name() const { return (cvtToHex(m_varScp)+" "+varScp()->name()); }
     virtual string dotColor() const { return fromFlop() ? "green" : cntAsyncRst() ? "red" : "blue"; }
     int cntAsyncRst() const { return m_cntAsyncRst; }
     void cntAsyncRst(int flag) { m_cntAsyncRst=flag; }
@@ -116,7 +115,7 @@ public:
 	{ srcDomainp(sensenodep); dstDomainp(sensenodep); }
     virtual ~CdcLogicVertex() {}
     // ACCESSORS
-    virtual string name() const { return (cvtToStr((void*)nodep())+"@"+scopep()->prettyName()); }
+    virtual string name() const { return (cvtToHex(nodep())+"@"+scopep()->prettyName()); }
     virtual string dotColor() const { return hazard() ? "black" : "yellow"; }
     bool hazard() const { return m_hazard; }
     void setHazard(AstNode* nodep) { m_hazard = true; nodep->user3(true); }
@@ -194,7 +193,7 @@ public:
 	width += 1;  // The :
 	width += cvtToStr(m_maxLineno).length();
 	width += 1;  // Final :
-	return (int)width;
+        return static_cast<int>(width);
     }
 };
 
@@ -249,7 +248,7 @@ private:
     }
 
     CdcVarVertex* makeVarVertex(AstVarScope* varscp) {
-	CdcVarVertex* vertexp = (CdcVarVertex*)(varscp->user1p());
+        CdcVarVertex* vertexp = reinterpret_cast<CdcVarVertex*>(varscp->user1p());
 	if (!vertexp) {
 	    UINFO(6,"New vertex "<<varscp<<endl);
 	    vertexp = new CdcVarVertex(&m_graph, m_scopep, varscp);
@@ -377,7 +376,7 @@ private:
 	    if (vvertexp->varScp()->varp()->isPrimaryIn()) {
 		// Show the source "input" statement if it exists
 		for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
-		    CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
+                    CdcEitherVertex* eFromVertexp = static_cast<CdcEitherVertex*>(edgep->fromp());
 		    eFromVertexp->asyncPath(true);
 		}
 		return NULL;
@@ -385,7 +384,7 @@ private:
 	    // Also ok if from flop, but partially trace the flop so more obvious to users
 	    if (vvertexp->fromFlop()) {
 		for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
-		    CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
+                    CdcEitherVertex* eFromVertexp = static_cast<CdcEitherVertex*>(edgep->fromp());
 		    eFromVertexp->asyncPath(true);
 		}
 		return NULL;
@@ -393,7 +392,7 @@ private:
 	}
 
 	for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
-	    CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
+            CdcEitherVertex* eFromVertexp = static_cast<CdcEitherVertex*>(edgep->fromp());
 	    CdcEitherVertex* submarkp = traceAsyncRecurse(eFromVertexp, mark);
 	    if (submarkp && !mark_outp) mark_outp = submarkp;
 	}
@@ -408,7 +407,7 @@ private:
 	*m_ofp<<"\n";
 	CdcEitherVertex* targetp = vertexp;  // One example destination flop (of possibly many)
 	for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
-	    CdcEitherVertex* eToVertexp = (CdcEitherVertex*)edgep->top();
+            CdcEitherVertex* eToVertexp = static_cast<CdcEitherVertex*>(edgep->top());
 	    if (!eToVertexp) targetp = eToVertexp;
 	    if (CdcLogicVertex* vvertexp = dynamic_cast<CdcLogicVertex*>(eToVertexp)) {
 		if (vvertexp->isFlop()  // IE the target flop that is upsetting us
@@ -435,7 +434,7 @@ private:
 	string cont = prefix+sep;
 	string nextsep = "   ";
 	for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
-	    CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
+            CdcEitherVertex* eFromVertexp = static_cast<CdcEitherVertex*>(edgep->fromp());
 	    if (dumpAsyncRecurse(eFromVertexp, cont, nextsep, level+1)) {
 		nextsep = " | ";
 	    }
@@ -554,13 +553,13 @@ private:
 	// Now combine domains of sources/dests
 	if (traceDests) {
 	    for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
-		CdcEitherVertex* eToVertexp = (CdcEitherVertex*)edgep->top();
+                CdcEitherVertex* eToVertexp = static_cast<CdcEitherVertex*>(edgep->top());
 		edgeDomainRecurse(eToVertexp, traceDests, level+1);
 		if (eToVertexp->dstDomainp()) senouts.insert(eToVertexp->dstDomainp());
 	    }
 	} else {
 	    for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
-		CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
+                CdcEitherVertex* eFromVertexp = static_cast<CdcEitherVertex*>(edgep->fromp());
 		edgeDomainRecurse(eFromVertexp, traceDests, level+1);
 		if (eFromVertexp->srcDomainp()) senouts.insert(eFromVertexp->srcDomainp());
 	    }

src/V3Cdc.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3CDC_H_
 #define _V3CDC_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Changed.cpp

@@ -32,17 +32,16 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
-#include <set>
 
 #include "V3Global.h"
 #include "V3Ast.h"
 #include "V3Changed.h"
 #include "V3EmitCBase.h"
 
+#include <algorithm>
+#include <cstdarg>
+#include <set>
+
 //######################################################################
 
 class ChangedState {

src/V3Changed.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3CHANGED_H_
 #define _V3CHANGED_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Clean.cpp

@@ -29,15 +29,14 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
 
 #include "V3Global.h"
 #include "V3Clean.h"
 #include "V3Ast.h"
 
+#include <algorithm>
+#include <cstdarg>
+
 //######################################################################
 // Clean state, as a visitor of each AstNode
 
@@ -99,7 +98,7 @@ private:
 	nodep->user1(clean);
     }
     CleanState getCleanState(AstNode* nodep) {
-	return ((CleanState)nodep->user1());
+        return static_cast<CleanState>(nodep->user1());
     }
     bool isClean(AstNode* nodep) {
 	CleanState clstate = getCleanState(nodep);

src/V3Clean.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3CLEAN_H_
 #define _V3CLEAN_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3ClkGater.cpp

@@ -33,12 +33,6 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <map>
-#include <algorithm>
-#include <vector>
 
 #include "V3Global.h"
 #include "V3Ast.h"
@@ -46,6 +40,11 @@
 #include "V3Graph.h"
 #include "V3ClkGater.h"
 
+#include <algorithm>
+#include <cstdarg>
+#include <map>
+#include <vector>
+
 //######################################################################
 // Base for debug
 
@@ -101,7 +100,8 @@ public:
 	: GaterVertex(graphp), m_nodep(nodep) { }
     virtual ~GaterIfVertex() {}
     virtual int typeNum() const { return __LINE__; }  // C++ typeof() equivelent
-    virtual string name() const { return cvtToStr((void*)m_nodep)+" {"+cvtToStr(m_nodep->fileline()->lineno())+"}"; }
+    virtual string name() const {
+        return cvtToHex(m_nodep)+" {"+cvtToStr(m_nodep->fileline()->lineno())+"}"; }
 };
 
 class GaterVarVertex : public GaterVertex {
@@ -376,7 +376,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	    m_pliVertexp = new GaterPliVertex(&m_graph);
 	}
 	if (m_stmtVscp) {  // Already saw a variable, be sure to mark it!
-	    GaterVarVertex* varVtxp = (GaterVarVertex*)(m_stmtVscp->user1p());
+            GaterVarVertex* varVtxp = reinterpret_cast<GaterVarVertex*>(m_stmtVscp->user1p());
 	    new GaterEdge(&m_graph, m_pliVertexp, varVtxp, VU_PLI);
 	}
 	m_stmtInPli = true;  // Mark all followon variables too
@@ -583,9 +583,9 @@ class GaterVisitor : public GaterBaseVisitor {
     }
     void nafgMarkRecurse(V3GraphVertex* vertexp, uint32_t generation) {
 	// Backwards mark user() on the path we recurse
-	//UINFO(9," nafgMark: v "<<(void*)(vertexp)<<" "<<vertexp->name()<<endl);
+        //UINFO(9," nafgMark: v "<<cvtToHex(vertexp)<<" "<<vertexp->name()<<endl);
 	for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
-	    //UINFO(9," nafgMark: "<<(void*)(edgep)<<" "<<edgep->name()<<endl);
+            //UINFO(9," nafgMark: "<<cvtToHex(edgep)<<" "<<edgep->name()<<endl);
 	    edgep->user(generation);
 	    nafgMarkRecurse(edgep->fromp(), generation);
 	}
@@ -594,18 +594,18 @@ class GaterVisitor : public GaterBaseVisitor {
 	// Forewards follow user() marked previously and build tree
 	AstNode* nodep = NULL;
 	// OR across all edges found at this level
-	//UINFO(9," nafgEnter: v "<<(void*)(vertexp)<<" "<<vertexp->name()<<endl);
+        //UINFO(9," nafgEnter: v "<<cvtToHex(vertexp)<<" "<<vertexp->name()<<endl);
 	for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
 	    if (edgep->user() == generation) {
 		GaterEdge* cedgep = static_cast<GaterEdge*>(edgep);
 		AstNode* eqnp = NULL;
-		//UINFO(9," nafgFollow: "<<(void*)(edgep)<<" "<<edgep->name()<<endl);
+                //UINFO(9," nafgFollow: "<<cvtToHex(edgep)<<" "<<edgep->name()<<endl);
 		if (dynamic_cast<GaterHeadVertex*>(edgep->fromp())) {
 		    // Just OR in all lower terms
 		    eqnp = nafgCreateRecurse(edgep->top(), generation);
 		} else if (GaterIfVertex* cVxp = dynamic_cast<GaterIfVertex*>(edgep->fromp())) {
 		    // Edges from IFs represent a real IF branch in the equation tree
-		    //UINFO(9,"  ifver "<<(void*)(edgep)<<" cc"<<edgep->dotColor()<<endl);
+                    //UINFO(9,"  ifver "<<cvtToHex(edgep)<<" cc"<<edgep->dotColor()<<endl);
 		    eqnp = cVxp->nodep()->condp()->cloneTree(true);
 		    if (!eqnp) cVxp->nodep()->v3fatalSrc("null condition");
 		    if (cedgep->ifelseFalse()) {
@@ -622,7 +622,7 @@ class GaterVisitor : public GaterBaseVisitor {
 		//if (debug()>=9) nodep->dumpTree(cout,"      followExpr: ");
 	    }
 	}
-	//UINFO(9," nafgExit:  "<<(void*)(vertexp)<<" "<<vertexp->name()<<endl);
+        //UINFO(9," nafgExit:  "<<cvtToHex(vertexp)<<" "<<vertexp->name()<<endl);
 	return nodep;
     }
 
@@ -689,9 +689,9 @@ class GaterVisitor : public GaterBaseVisitor {
 	nodep->addNextHere(alwp);
 
 	// Blow moved statements from old body
-	GaterBodyVisitor(nodep,exprp,true);
+        { GaterBodyVisitor vis(nodep,exprp,true); }
 	// Blow old statements from new body
-	GaterBodyVisitor(alwp,exprp,false);
+        { GaterBodyVisitor vis(alwp,exprp,false); }
 
 	++m_statGaters;
 	if (debug()>=9) alwp->dumpTree(cout,"  new: ");
@@ -764,7 +764,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	    }
 	    m_stmtVscp = vscp;
 	    // Find, or make new Vertex
-	    GaterVarVertex* vertexp = (GaterVarVertex*)(vscp->user1p());
+            GaterVarVertex* vertexp = reinterpret_cast<GaterVarVertex*>(vscp->user1p());
 	    if (!vertexp) {
 		vertexp = new GaterVarVertex(&m_graph, vscp);
 		vscp->user1p(vertexp);

src/V3ClkGater.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3CLKGATER_H_
 #define _V3CLKGATER_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Clock.cpp

@@ -33,16 +33,15 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
 
 #include "V3Global.h"
 #include "V3Clock.h"
 #include "V3Ast.h"
 #include "V3EmitCBase.h"
 
+#include <algorithm>
+#include <cstdarg>
+
 //######################################################################
 // Clock state, as a visitor of each AstNode
 
@@ -72,10 +71,10 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     AstVarScope* getCreateLastClk(AstVarScope* vscp) {
-	if (vscp->user1p()) return ((AstVarScope*)vscp->user1p());
+        if (vscp->user1p()) return static_cast<AstVarScope*>(vscp->user1p());
 	AstVar* varp = vscp->varp();
 	if (!varp->width1()) varp->v3error("Unsupported: Clock edge on non-single bit signal: "<<varp->prettyName());
-	string newvarname = ((string)"__Vclklast__"+vscp->scopep()->nameDotless()+"__"+varp->name());
+        string newvarname = (string("__Vclklast__")+vscp->scopep()->nameDotless()+"__"+varp->name());
         AstVar* newvarp = new AstVar(vscp->fileline(), AstVarType::MODULETEMP, newvarname, VFlagLogicPacked(), 1);
         newvarp->noReset(true);  // Reset by below assign
 	m_modp->addStmtp(newvarp);

src/V3Clock.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3CLOCK_H_
 #define _V3CLOCK_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Combine.cpp

@@ -36,12 +36,6 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
-#include <vector>
-#include <map>
 
 #include "V3Global.h"
 #include "V3Combine.h"
@@ -49,6 +43,11 @@
 #include "V3Stats.h"
 #include "V3Ast.h"
 
+#include <algorithm>
+#include <cstdarg>
+#include <map>
+#include <vector>
+
 //######################################################################
 
 #define COMBINE_MIN_STATEMENTS 50	// Min # of statements to be worth making a function
@@ -70,7 +69,7 @@ protected:
     // Also repair it for DPI functions; when make __common need to insure proper
     // flags get inherited from the old to new AstCFunc, and that AstText doesn't
     // get split between functions causing the text to have a danginling reference.
-    bool statementCombine() { return false && duplicateFunctionCombine(); }
+    bool statementCombine() { return false; }  // duplicateFunctionCombine();
 };
 
 //######################################################################

src/V3Combine.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3COMBINE_H_
 #define _V3COMBINE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Config.cpp

@@ -20,14 +20,15 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <string>
-#include <map>
-#include <set>
 
 #include "V3Global.h"
 #include "V3String.h"
 #include "V3Config.h"
 
+#include <map>
+#include <set>
+#include <string>
+
 //######################################################################
 
 class V3ConfigLine {

src/V3Config.h

@@ -20,9 +20,10 @@
 
 #ifndef _V3CONFIG_H_
 #define _V3CONFIG_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
-#include <string>
+
 #include "V3Error.h"
 #include "V3FileLine.h"
 

src/V3Const.cpp

@@ -26,11 +26,6 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <map>
-#include <algorithm>
 
 #include "V3Global.h"
 #include "V3String.h"
@@ -39,6 +34,10 @@
 #include "V3Width.h"
 #include "V3Simulate.h"
 
+#include <algorithm>
+#include <cstdarg>
+#include <map>
+
 //######################################################################
 // Utilities
 
@@ -243,13 +242,15 @@ private:
     bool operandHugeShiftL(const AstNodeBiop* nodep) {
         return (VN_IS(nodep->rhsp(), Const)
                 && !VN_CAST_CONST(nodep->rhsp(), Const)->num().isFourState()
-                && VN_CAST_CONST(nodep->rhsp(), Const)->toUInt() >= (uint32_t)(nodep->width())
+                && (VN_CAST_CONST(nodep->rhsp(), Const)->toUInt()
+                    >= static_cast<uint32_t>(nodep->width()))
 		&& isTPure(nodep->lhsp()));
     }
     bool operandHugeShiftR(const AstNodeBiop* nodep) {
         return (VN_IS(nodep->rhsp(), Const)
                 && !VN_CAST_CONST(nodep->rhsp(), Const)->num().isFourState()
-                && VN_CAST_CONST(nodep->rhsp(), Const)->toUInt() >= (uint32_t)(nodep->lhsp()->width())
+                && (VN_CAST_CONST(nodep->rhsp(), Const)->toUInt()
+                    >= static_cast<uint32_t>(nodep->lhsp()->width()))
 		&& isTPure(nodep->lhsp()));
     }
     bool operandIsTwo(const AstNode* nodep) {
@@ -295,14 +296,14 @@ private:
         return (VN_IS(nodep->rhsp(), Const)
                 && VN_IS(nodep->fromp(), NodeVarRef)
                 && !VN_CAST_CONST(nodep->fromp(), NodeVarRef)->lvalue()
-                && ((int)(VN_CAST_CONST(nodep->rhsp(), Const)->toUInt())
+                && (static_cast<int>(VN_CAST_CONST(nodep->rhsp(), Const)->toUInt())
                     >= VN_CAST(nodep->fromp(), NodeVarRef)->varp()->widthWords()));
     }
     bool operandSelFull(const AstSel* nodep) {
         return (VN_IS(nodep->lsbp(), Const)
                 && VN_IS(nodep->widthp(), Const)
 		&& nodep->lsbConst()==0
-		&& (int)nodep->widthConst()==nodep->fromp()->width());
+                && static_cast<int>(nodep->widthConst()) == nodep->fromp()->width());
     }
     bool operandSelExtend(AstSel* nodep) {
 	// A pattern created by []'s after offsets have been removed
@@ -314,7 +315,7 @@ private:
               && VN_IS(nodep->lsbp(), Const)
               && VN_IS(nodep->widthp(), Const)
 	      && nodep->lsbConst()==0
-	      && (int)nodep->widthConst()==extendp->lhsp()->width()
+              && static_cast<int>(nodep->widthConst()) == extendp->lhsp()->width()
 		)) return false;
 	replaceWChild(nodep, extendp->lhsp()); VL_DANGLING(nodep);
 	return true;
@@ -513,8 +514,7 @@ private:
         const AstConst* rwidth = VN_CAST_CONST(rhsp->widthp(), Const);
 	if (!lstart || !rstart || !lwidth || !rwidth) return false;  // too complicated
 	int rend = (rstart->toSInt() + rwidth->toSInt());
-	if (rend == lstart->toSInt()) return true;
-	return false;
+        return (rend == lstart->toSInt());
     }
     bool ifMergeAdjacent(AstNode* lhsp, AstNode* rhsp) {
 	// called by concatmergeable to determine if {lhsp, rhsp} make sense
@@ -1075,8 +1075,8 @@ private:
 		if (!m_modp) nodep->v3fatalSrc("Not under module");
 		// We could create just one temp variable, but we'll get better optimization
 		// if we make one per term.
-		string name1 = ((string)"__Vconcswap"+cvtToStr(m_modp->varNumGetInc()));
-		string name2 = ((string)"__Vconcswap"+cvtToStr(m_modp->varNumGetInc()));
+                string name1 = (string("__Vconcswap")+cvtToStr(m_modp->varNumGetInc()));
+                string name2 = (string("__Vconcswap")+cvtToStr(m_modp->varNumGetInc()));
 		AstVar* temp1p = new AstVar(sel1p->fileline(), AstVarType::BLOCKTEMP, name1,
 					    VFlagLogicPacked(), msb1-lsb1+1);
 		AstVar* temp2p = new AstVar(sel2p->fileline(), AstVarType::BLOCKTEMP, name2,
@@ -1185,7 +1185,8 @@ private:
         if (!VN_IS(VN_CAST_CONST(nodep, And)->rhsp(), ShiftR)) return false;
         const AstShiftR* shiftp = VN_CAST(VN_CAST_CONST(nodep, And)->rhsp(), ShiftR);
         if (!VN_IS(shiftp->rhsp(), Const)) return false;
-        if ((uint32_t)(nodep->width()) <= VN_CAST_CONST(shiftp->rhsp(), Const)->toUInt()) return false;
+        if (static_cast<uint32_t>(nodep->width())
+            <= VN_CAST_CONST(shiftp->rhsp(), Const)->toUInt()) return false;
 	return true;
     }
     void replaceBoolShift(AstNode* nodep) {
@@ -1367,7 +1368,7 @@ private:
         AstConcat* conp = VN_CAST(nodep->fromp(), Concat);
 	AstNode* conLhsp = conp->lhsp();
 	AstNode* conRhsp = conp->rhsp();
-	if ((int)nodep->lsbConst() >= conRhsp->width()) {
+        if (static_cast<int>(nodep->lsbConst()) >= conRhsp->width()) {
 	    conLhsp->unlinkFrBack();
 	    AstSel* newp = new AstSel(nodep->fileline(),
 				      conLhsp,
@@ -1375,7 +1376,7 @@ private:
 				      nodep->widthConst());
 	    nodep->replaceWith(newp);
 	}
-	else if ((int)nodep->msbConst() < conRhsp->width()) {
+        else if (static_cast<int>(nodep->msbConst()) < conRhsp->width()) {
 	    conRhsp->unlinkFrBack();
 	    AstSel* newp = new AstSel(nodep->fileline(),
 				      conRhsp,
@@ -1544,7 +1545,7 @@ private:
 		    || nodep->varp()->isParam())) {
 		if (operandConst(valuep)) {
                     const V3Number& num = VN_CAST(valuep, Const)->num();
-		    //UINFO(2,"constVisit "<<(void*)valuep<<" "<<num<<endl);
+                    //UINFO(2,"constVisit "<<cvtToHex(valuep)<<" "<<num<<endl);
 		    replaceNum(nodep, num); VL_DANGLING(nodep);
 		    did=true;
 		}
@@ -1566,7 +1567,7 @@ private:
 		    }
                     if (VN_IS(itemp, Const)) {
                         const V3Number& num = VN_CAST(itemp, Const)->num();
-			//UINFO(2,"constVisit "<<(void*)valuep<<" "<<num<<endl);
+                        //UINFO(2,"constVisit "<<cvtToHex(valuep)<<" "<<num<<endl);
 			replaceNum(nodep, num); VL_DANGLING(nodep);
 			did=true;
 		    }
@@ -1977,8 +1978,8 @@ private:
 	}
 	if (m_doNConst && anyconst) {
 	    //UINFO(9,"  Display in  "<<nodep->text()<<endl);
-	    string newFormat = "";
-	    string fmt = "";
+            string newFormat;
+            string fmt;
 	    bool inPct = false;
 	    AstNode* argp = nodep->exprsp();
 	    string text = nodep->text();
@@ -2021,7 +2022,7 @@ private:
 	    }
 	}
 	if (!nodep->exprsp()
-	    && nodep->name().find("%") == string::npos
+            && nodep->name().find('%') == string::npos
 	    && !nodep->hidden()) {
 	    // Just a simple constant string - the formatting is pointless
 	    replaceConstString(nodep, nodep->name()); VL_DANGLING(nodep);

src/V3Const.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3CONST_H_
 #define _V3CONST_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Coverage.cpp

@@ -30,15 +30,14 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <map>
 
 #include "V3Global.h"
 #include "V3Coverage.h"
 #include "V3Ast.h"
 
+#include <cstdarg>
+#include <map>
+
 //######################################################################
 // Coverage state, as a visitor of each AstNode
 
@@ -162,7 +161,7 @@ private:
 		//	We'll do this, and make the if(...) coverinc later.
 
 		// Add signal to hold the old value
-		string newvarname = (string)"__Vtogcov__"+nodep->shortName();
+                string newvarname = string("__Vtogcov__")+nodep->shortName();
                 AstVar* chgVarp = new AstVar(nodep->fileline(), AstVarType::MODULETEMP, newvarname, nodep);
 		chgVarp->fileline()->modifyWarnOff(V3ErrorCode::UNUSED, true);
 		m_modp->addStmtp(chgVarp);
@@ -181,9 +180,7 @@ private:
 	}
     }
 
-    void toggleVarBottom(AstNodeDType* dtypep, int depth, // per-iteration
-		     const ToggleEnt& above,
-		     AstVar* varp, AstVar* chgVarp) { // Constant
+    void toggleVarBottom(const ToggleEnt& above, const AstVar* varp) {
 	AstCoverToggle* newp
             = new AstCoverToggle(varp->fileline(),
                                  newCoverInc(varp->fileline(), "", "v_toggle",
@@ -203,15 +200,11 @@ private:
 		    ToggleEnt newent (above.m_comment+string("[")+cvtToStr(index_docs)+"]",
 				      new AstSel(varp->fileline(), above.m_varRefp->cloneTree(true), index_code, 1),
 				      new AstSel(varp->fileline(), above.m_chgRefp->cloneTree(true), index_code, 1));
-		    toggleVarBottom(dtypep, depth+1,
-				    newent,
-				    varp, chgVarp);
+                    toggleVarBottom(newent, varp);
 		    newent.cleanup();
 		}
 	    } else {
-		toggleVarBottom(dtypep, depth+1,
-				above,
-				varp, chgVarp);
+                toggleVarBottom(above, varp);
 	    }
 	}
         else if (AstUnpackArrayDType* adtypep = VN_CAST(dtypep, UnpackArrayDType)) {

src/V3Coverage.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3COVERAGE_H_
 #define _V3COVERAGE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3CoverageJoin.cpp

@@ -24,16 +24,15 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <vector>
 
 #include "V3Global.h"
 #include "V3CoverageJoin.h"
 #include "V3Hashed.h"
 #include "V3Stats.h"
 
+#include <cstdarg>
+#include <vector>
+
 //######################################################################
 // CoverageJoin state, as a visitor of each AstNode
 

src/V3CoverageJoin.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3COVERAGEJOIN_H_
 #define _V3COVERAGEJOIN_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Dead.cpp

@@ -40,16 +40,15 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <vector>
-#include <map>
 
 #include "V3Global.h"
 #include "V3Dead.h"
 #include "V3Ast.h"
 
+#include <cstdarg>
+#include <map>
+#include <vector>
+
 //######################################################################
 
 class DeadModVisitor : public AstNVisitor {

src/V3Dead.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3DEAD_H_
 #define _V3DEAD_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Delayed.cpp

@@ -53,18 +53,17 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
-#include <map>
-#include <deque>
 
 #include "V3Global.h"
 #include "V3Delayed.h"
 #include "V3Ast.h"
 #include "V3Stats.h"
 
+#include <algorithm>
+#include <cstdarg>
+#include <deque>
+#include <map>
+
 //######################################################################
 // Delayed state, as a visitor of each AstNode
 

src/V3Delayed.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3DELAYED_H_
 #define _V3DELAYED_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Depth.cpp

@@ -29,15 +29,14 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
 
 #include "V3Global.h"
 #include "V3Depth.h"
 #include "V3Ast.h"
 
+#include <algorithm>
+#include <cstdarg>
+
 //######################################################################
 
 class DepthVisitor : public AstNVisitor {
@@ -58,7 +57,7 @@ private:
 	UINFO(6,"  Deep  "<<nodep<<endl);
 	//if (debug()>=9) nodep->dumpTree(cout,"deep:");
 
-	string newvarname = ((string)"__Vdeeptemp"+cvtToStr(m_modp->varNumGetInc()));
+        string newvarname = (string("__Vdeeptemp")+cvtToStr(m_modp->varNumGetInc()));
         AstVar* varp = new AstVar(nodep->fileline(), AstVarType::STMTTEMP, newvarname,
                                   // Width, not widthMin, as we may be in middle of BITSEL expression which
                                   // though it's one bit wide, needs the mask in the upper bits.

src/V3Depth.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3DEPTH_H_
 #define _V3DEPTH_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3DepthBlock.cpp

@@ -26,16 +26,15 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
 
 #include "V3Global.h"
 #include "V3DepthBlock.h"
 #include "V3Ast.h"
 #include "V3EmitCBase.h"
 
+#include <algorithm>
+#include <cstdarg>
+
 //######################################################################
 
 class DepthBlockVisitor : public AstNVisitor {

src/V3DepthBlock.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3DEPTHBLOCK_H_
 #define _V3DEPTHBLOCK_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3Descope.cpp

@@ -28,16 +28,15 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <map>
 
 #include "V3Global.h"
 #include "V3Descope.h"
 #include "V3Ast.h"
 #include "V3EmitCBase.h"
 
+#include <cstdarg>
+#include <map>
+
 //######################################################################
 
 class DescopeVisitor : public AstNVisitor {
@@ -126,7 +125,7 @@ private:
             // Reference to scope of cell directly under this module, can just "cell->"
             string name = scopep->name();
             string::size_type pos;
-            if ((pos = name.rfind(".")) != string::npos) {
+            if ((pos = name.rfind('.')) != string::npos) {
                 name.erase(0,pos+1);
             }
             m_needThis = true;

src/V3Descope.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3DESCOPE_H_
 #define _V3DESCOPE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3EmitC.cpp

@@ -20,14 +20,6 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <cmath>
-#include <map>
-#include <vector>
-#include <algorithm>
-#include VL_INCLUDE_UNORDERED_SET
 
 #include "V3Global.h"
 #include "V3String.h"
@@ -37,6 +29,13 @@
 #include "V3PartitionGraph.h"
 #include "V3TSP.h"
 
+#include <algorithm>
+#include <cmath>
+#include <cstdarg>
+#include <map>
+#include <vector>
+#include VL_INCLUDE_UNORDERED_SET
+
 #define VL_VALUE_STRING_MAX_WIDTH 8192	// We use a static char array in VL_VALUE_STRING
 
 #define EMITC_NUM_CONSTW	8	// Number of VL_CONST_W_*X's in verilated.h (IE VL_CONST_W_8X is last)
@@ -233,7 +232,7 @@ public:
 	nodep->v3fatalSrc("Case statements should have been reduced out");
     }
     virtual void visit(AstComment* nodep) {
-	putsDecoration((string)"// "+nodep->name()+" at "+nodep->fileline()->ascii()+"\n");
+        putsDecoration(string("// ")+nodep->name()+" at "+nodep->fileline()->ascii()+"\n");
         iterateChildren(nodep);
     }
     virtual void visit(AstCoverDecl* nodep) {
@@ -586,8 +585,8 @@ public:
     }
     virtual void visit(AstReplicate* nodep) {
 	if (nodep->lhsp()->widthMin() == 1 && !nodep->isWide()) {
-            if (((int)VN_CAST(nodep->rhsp(), Const)->toUInt()
-		     * nodep->lhsp()->widthMin()) != nodep->widthMin())
+            if ((static_cast<int>(VN_CAST(nodep->rhsp(), Const)->toUInt())
+                 * nodep->lhsp()->widthMin()) != nodep->widthMin())
 		nodep->v3fatalSrc("Replicate non-constant or width miscomputed");
 	    puts("VL_REPLICATE_");
 	    emitIQW(nodep);
@@ -688,7 +687,9 @@ public:
 		}
 		for (int word=VL_WORDS_I(upWidth)-1; word>=0; word--) {
 		    // Only 32 bits - llx + long long here just to appease CPP format warning
-		    ofp()->printf(",0x%08" VL_PRI64 "x", (vluint64_t)(nodep->num().dataWord(word+chunks*EMITC_NUM_CONSTW)));
+                    ofp()->printf(",0x%08" VL_PRI64 "x",
+                                  static_cast<vluint64_t>(nodep->num().dataWord
+                                                          (word+chunks*EMITC_NUM_CONSTW)));
 		}
 		puts(")");
 	    }
@@ -709,7 +710,9 @@ public:
 		}
 		for (int word=EMITC_NUM_CONSTW-1; word>=0; word--) {
 		    // Only 32 bits - llx + long long here just to appease CPP format warning
-		    ofp()->printf(",0x%08" VL_PRI64 "x", (vluint64_t)(nodep->num().dataWord(word+chunks*EMITC_NUM_CONSTW)));
+                    ofp()->printf(",0x%08" VL_PRI64 "x",
+                                  static_cast<vluint64_t>(nodep->num().dataWord
+                                                          (word+chunks*EMITC_NUM_CONSTW)));
 		}
 		puts(")");
 	    }
@@ -731,7 +734,7 @@ public:
 	    uint32_t num = nodep->toUInt();
 	    // Only 32 bits - llx + long long here just to appease CPP format warning
 	    if (num<10) puts(cvtToStr(num));
-	    else ofp()->printf("0x%" VL_PRI64 "x", (vluint64_t)num);
+            else ofp()->printf("0x%" VL_PRI64 "x", static_cast<vluint64_t>(num));
 	    // If signed, we'll do our own functions
 	    // But must be here, or <= comparisons etc may end up signed
 	    puts("U");
@@ -776,7 +779,7 @@ public:
     virtual void visit(AstCFile*) {}		// Handled outside the Visit class
     // Default
     virtual void visit(AstNode* nodep) {
-	puts((string)"\n???? // "+nodep->prettyTypeName()+"\n");
+        puts(string("\n???? // ")+nodep->prettyTypeName()+"\n");
         iterateChildren(nodep);
 	nodep->v3fatalSrc("Unknown node type reached emitter: "<<nodep->prettyTypeName());
     }
@@ -1165,7 +1168,7 @@ class EmitCImp : EmitCStmts {
 
     // METHODS
     // Low level
-    void emitVarReset(AstVar* modp);
+    void emitVarReset(AstVar* varp);
     void emitCellCtors(AstNodeModule* modp);
     void emitSensitives();
     // Medium level
@@ -1337,7 +1340,7 @@ void EmitCStmts::emitOpName(AstNode* nodep, const string& format,
     //	,	Commas suppressed if the previous field is suppressed
     string nextComma;
     bool needComma = false;
-#define COMMA { if (nextComma!="") { puts(nextComma); nextComma=""; } }
+#define COMMA { if (!nextComma.empty()) { puts(nextComma); nextComma=""; } }
 
     putbs("");
     for (string::const_iterator pos = format.begin(); pos != format.end(); ++pos) {
@@ -1559,11 +1562,11 @@ void EmitCStmts::displayNode(AstNode* nodep, AstScopeName* scopenamep,
     // Convert Verilog display to C printf formats
     // 		"%0t" becomes "%d"
     emitDispState.clear();
-    string vfmt = "";
+    string vfmt;
     string::const_iterator pos = vformat.begin();
     bool inPct = false;
     for (; pos != vformat.end(); ++pos) {
-	//UINFO(1,"Parse '"<<*pos<<"'  IP"<<inPct<<" List "<<(void*)(elistp)<<endl);
+        //UINFO(1,"Parse '"<<*pos<<"'  IP"<<inPct<<" List "<<cvtToHex(elistp)<<endl);
 	if (!inPct && pos[0]=='%') {
 	    inPct = true;
 	    vfmt = "";
@@ -1676,7 +1679,8 @@ void EmitCImp::emitVarReset(AstVar* varp) {
 	}
 	bool zeroit = (varp->attrFileDescr() // Zero it out, so we don't core dump if never call $fopen
 		       || (varp->basicp() && varp->basicp()->isZeroInit())
-		       || (varp->name().size()>=1 && varp->name()[0]=='_' && v3Global.opt.underlineZero())
+                       || (v3Global.opt.underlineZero()
+                           && !varp->name().empty() && varp->name()[0]=='_')
 		       || (v3Global.opt.xInitial() == "fast" || v3Global.opt.xInitial() == "0"));
 	if (varp->isWide()) {
 	    // DOCUMENT: We randomize everything.  If the user wants a _var to be zero,
@@ -1866,6 +1870,7 @@ void EmitCImp::emitSavableImp(AstNodeModule* modp) {
 	    string funcname = de ? "__Vdeserialize" : "__Vserialize";
 	    string writeread = de ? "read" : "write";
 	    string op = de ? ">>" : "<<";
+            // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
 	    puts("void "+modClassName(modp)+"::"+funcname+"("+classname+"& os) {\n");
 	    // Place a computed checksum to insure proper structure save/restore formatting
 	    // OK if this hash includes some things we won't dump, since just looking for loading the wrong model
@@ -1877,7 +1882,7 @@ void EmitCImp::emitSavableImp(AstNodeModule* modp) {
 		}
 	    }
 	    ofp()->printf(   "vluint64_t __Vcheckval = VL_ULL(0x%" VL_PRI64 "x);\n",
-                             (vluint64_t)hash.digestUInt64());
+                             static_cast<vluint64_t>(hash.digestUInt64()));
 	    if (de) {
 		puts("os.readAssert(__Vcheckval);\n");
 	    } else {
@@ -2242,7 +2247,7 @@ void EmitCStmts::emitVarSort(const VarSortMap& vmap, VarVec* sortedp) {
 void EmitCStmts::emitSortedVarList(const VarVec& anons,
                                    const VarVec& nonanons,
                                    const string& prefixIfImp) {
-    string curVarCmt = "";
+    string curVarCmt;
     // Output anons
     {
         int anonMembers = anons.size();
@@ -2715,8 +2720,15 @@ void EmitCImp::main(AstNodeModule* modp, bool slow, bool fast) {
 // Tracing routines
 
 class EmitCTrace : EmitCStmts {
+    // NODE STATE/TYPES
+    // Cleared on netlist
+    //  AstNode::user1()        -> int.  Enum number
+    AstUser1InUse m_inuser1;
+
+    // MEMBERS
     AstCFunc*	m_funcp;	// Function we're in now
     bool	m_slow;		// Making slow file
+    int         m_enumNum;      // Enumeration number (whole netlist)
 
     // METHODS
     void newOutCFile(int filenum) {
@@ -2819,17 +2831,17 @@ class EmitCTrace : EmitCStmts {
 	return varp->isSc() && varp->isScUint();
     }
 
-    void emitTraceInitOne(AstTraceDecl* nodep) {
+    void emitTraceInitOne(AstTraceDecl* nodep, int enumNum) {
 	if (nodep->dtypep()->basicp()->isDouble()) {
 	    puts("vcdp->declDouble");
 	} else if (nodep->isWide()) {
 	    puts("vcdp->declArray");
 	} else if (nodep->isQuad()) {
-	    puts("vcdp->declQuad ");
+            puts("vcdp->declQuad");
 	} else if (nodep->bitRange().ranged()) {
-	    puts("vcdp->declBus  ");
+            puts("vcdp->declBus");
 	} else {
-	    puts("vcdp->declBit  ");
+            puts("vcdp->declBit");
 	}
 
 	puts("(c+"+cvtToStr(nodep->code()));
@@ -2838,6 +2850,7 @@ class EmitCTrace : EmitCStmts {
 	putsQuoted(nodep->showname());
         // Direction
         if (v3Global.opt.traceFormat() == TraceFormat::FST) {
+            puts(","+cvtToStr(enumNum));
             // fstVarDir
             if (nodep->declInout()) puts(",FST_VD_INOUT");
             else if (nodep->declInput()) puts(",FST_VD_INPUT");
@@ -2900,6 +2913,49 @@ class EmitCTrace : EmitCStmts {
 	puts(");");
     }
 
+    int emitTraceDeclDType(AstNodeDType* nodep) {
+        // Return enum number or -1 for none
+        if (v3Global.opt.traceFormat() == TraceFormat::FST) {
+            // Skip over refs-to-refs, but stop before final ref so can get data type name
+            // Alternatively back in V3Width we could have push enum names from upper typedefs
+            if (AstEnumDType* enump = VN_CAST(nodep->skipRefToEnump(), EnumDType)) {
+                int enumNum = enump->user1();
+                if (!enumNum) {
+                    enumNum = ++m_enumNum;
+                    enump->user1(enumNum);
+                    int nvals = 0;
+                    puts("{\n");
+                    puts("const char* __VenumItemNames[]\n");
+                    puts("= {");
+                    for (AstEnumItem* itemp = enump->itemsp(); itemp;
+                         itemp=VN_CAST(itemp->nextp(), EnumItem)) {
+                        if (++nvals > 1) puts(", ");
+                        putbs("\""+itemp->prettyName()+"\"");
+                    }
+                    puts("};\n");
+                    nvals = 0;
+                    puts("const char* __VenumItemValues[]\n");
+                    puts("= {");
+                    for (AstEnumItem* itemp = enump->itemsp(); itemp;
+                         itemp=VN_CAST(itemp->nextp(), EnumItem)) {
+                        AstConst* constp = VN_CAST(itemp->valuep(), Const);
+                        if (++nvals > 1) puts(", ");
+                        putbs("\""+constp->num().displayed(nodep->fileline(), "%0b")+"\"");
+                    }
+                    puts("};\n");
+                    puts("vcdp->declDTypeEnum("+cvtToStr(enumNum)
+                         +", \""+enump->prettyName()+"\", "
+                         +cvtToStr(nvals)
+                         +", "+cvtToStr(enump->widthMin())
+                         +", __VenumItemNames, __VenumItemValues);\n");
+                    puts("}\n");
+                }
+                return enumNum;
+            }
+        }
+        return -1;
+    }
+
     void emitTraceChangeOne(AstTraceInc* nodep, int arrayindex) {
         iterateAndNextNull(nodep->precondsp());
 	string full = ((m_funcp->funcType() == AstCFuncType::TRACE_FULL
@@ -2912,15 +2968,15 @@ class EmitCTrace : EmitCStmts {
 	    puts("vcdp->"+full+"Array");
             emitWidth = true;
 	} else if (nodep->isQuad()) {
-	    puts("vcdp->"+full+"Quad ");
+            puts("vcdp->"+full+"Quad");
             emitWidth = true;
         } else if (nodep->declp()->bitRange().ranged()
                    // 1 element smaller to use Bit dump
                    && nodep->declp()->bitRange().elements() != 1) {
-	    puts("vcdp->"+full+"Bus  ");
+            puts("vcdp->"+full+"Bus");
             emitWidth = true;
 	} else {
-	    puts("vcdp->"+full+"Bit  ");
+            puts("vcdp->"+full+"Bit");
 	}
 	puts("(c+"+cvtToStr(nodep->declp()->code()
 			    + ((arrayindex<0) ? 0 : (arrayindex*nodep->declp()->widthWords()))));
@@ -3013,12 +3069,13 @@ class EmitCTrace : EmitCStmts {
 	m_funcp = NULL;
     }
     virtual void visit(AstTraceDecl* nodep) {
+        int enumNum = emitTraceDeclDType(nodep->dtypep());
 	if (nodep->arrayRange().ranged()) {
 	    puts("{int i; for (i=0; i<"+cvtToStr(nodep->arrayRange().elements())+"; i++) {\n");
-	    emitTraceInitOne(nodep);
+            emitTraceInitOne(nodep, enumNum);
 	    puts("}}\n");
 	} else {
-	    emitTraceInitOne(nodep);
+            emitTraceInitOne(nodep, enumNum);
 	    puts("\n");
 	}
     }
@@ -3041,6 +3098,7 @@ public:
     explicit EmitCTrace(bool slow) {
 	m_funcp = NULL;
 	m_slow = slow;
+        m_enumNum = 0;
     }
     virtual ~EmitCTrace() {}
     void main() {

src/V3EmitC.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3EMITC_H_
 #define _V3EMITC_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3EmitCBase.h

@@ -23,15 +23,14 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <cmath>
 
 #include "V3Global.h"
 #include "V3File.h"
 #include "V3Ast.h"
 
+#include <cstdarg>
+#include <cmath>
+
 //######################################################################
 // Base Visitor class -- holds output file pointer
 
@@ -59,7 +58,7 @@ public:
     static string topClassName() {		// Return name of top wrapper module
 	return v3Global.opt.prefix();
     }
-    AstCFile* newCFile(const string& filename, bool slow, bool source) {
+    static AstCFile* newCFile(const string& filename, bool slow, bool source) {
 	AstCFile* cfilep = new AstCFile(v3Global.rootp()->fileline(), filename);
 	cfilep->slow(slow);
 	cfilep->source(source);

src/V3EmitCInlines.cpp

@@ -20,18 +20,17 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <cmath>
-#include <map>
-#include <vector>
 
 #include "V3Global.h"
 #include "V3EmitC.h"
 #include "V3EmitCBase.h"
 #include "V3Stats.h"
 
+#include <cmath>
+#include <cstdarg>
+#include <map>
+#include <vector>
+
 //######################################################################
 
 class EmitCInlines : EmitCBaseVisitor {

src/V3EmitCSyms.cpp

@@ -20,20 +20,19 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <cmath>
-#include <map>
-#include <set>
-#include <vector>
-#include <algorithm>
 
 #include "V3Global.h"
 #include "V3EmitC.h"
 #include "V3EmitCBase.h"
 #include "V3LanguageWords.h"
 
+#include <algorithm>
+#include <cmath>
+#include <cstdarg>
+#include <map>
+#include <set>
+#include <vector>
+
 //######################################################################
 // Symbol table emitting
 
@@ -144,7 +143,7 @@ class EmitCSyms : EmitCBaseVisitor {
 			}
 			if (out.substr(0,10) == "TOP__DOT__") out.replace(0,10,"");
 			if (out.substr(0,4) == "TOP.") out.replace(0,4,"");
-			while ((pos=out.find(".")) != string::npos) {
+                        while ((pos = out.find('.')) != string::npos) {
 			    out.replace(pos, 1, "__");
 			}
 			while ((pos=out.find("__DOT__")) != string::npos) {
@@ -299,7 +298,7 @@ void EmitCSyms::emitSymHdr() {
     }
 
     puts("\n// SYMS CLASS\n");
-    puts((string)"class "+symClassName()+" : public VerilatedSyms {\n");
+    puts(string("class ")+symClassName()+" : public VerilatedSyms {\n");
     ofp()->putsPrivate(false);  // public:
 
     puts("\n// LOCAL STATE\n");
@@ -340,7 +339,7 @@ void EmitCSyms::emitSymHdr() {
 
     puts("\n// CREATORS\n");
     puts(symClassName()+"("+topClassName()+"* topp, const char* namep);\n");
-    puts((string)"~"+symClassName()+"() {}\n");
+    puts(string("~")+symClassName()+"() {}\n");
 
     puts("\n// METHODS\n");
     puts("inline const char* name() { return __Vm_namep; }\n");
@@ -409,7 +408,7 @@ void EmitCSyms::emitSymImp() {
 	if (!modp->isTop()) {
 	    string arrow = scopep->name();
 	    string::size_type pos;
-	    while ((pos=arrow.find(".")) != string::npos) {
+            while ((pos = arrow.find('.')) != string::npos) {
 		arrow.replace(pos, 1, "->");
 	    }
 	    if (arrow.substr(0,5) == "TOP->") arrow.replace(0,5,"TOPp->");
@@ -526,6 +525,7 @@ void EmitCSyms::emitSymImp() {
 	    string classname = de ? "VerilatedDeserialize" : "VerilatedSerialize";
 	    string funcname = de ? "__Vdeserialize" : "__Vserialize";
 	    string op = de ? ">>" : "<<";
+            // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
 	    puts("void "+symClassName()+"::"+funcname+"("+classname+"& os) {\n");
 	    puts(   "// LOCAL STATE\n");
 	    // __Vm_namep presumably already correct

src/V3EmitMk.cpp

@@ -20,19 +20,18 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <cmath>
-#include <map>
-#include <vector>
-#include <algorithm>
 
 #include "V3Global.h"
 #include "V3Os.h"
 #include "V3EmitMk.h"
 #include "V3EmitCBase.h"
 
+#include <algorithm>
+#include <cmath>
+#include <cstdarg>
+#include <map>
+#include <vector>
+
 //######################################################################
 // Emit statements and math operators
 
@@ -208,6 +207,7 @@ public:
 	    for (V3StringSet::const_iterator it = cppFiles.begin(); it != cppFiles.end(); ++it) {
 		string cppfile = *it;
 		string basename = V3Os::filenameNonExt(cppfile);
+                // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
 		of.puts(basename+".o: "+cppfile+"\n");
 		of.puts("\t$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<\n");
 	    }

src/V3EmitMk.h

@@ -20,8 +20,10 @@
 
 #ifndef _V3EMITMK_H_
 #define _V3EMITMK_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 

src/V3EmitV.cpp

@@ -20,18 +20,17 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <cmath>
-#include <map>
-#include <vector>
-#include <algorithm>
 
 #include "V3Global.h"
 #include "V3EmitV.h"
 #include "V3EmitCBase.h"
 
+#include <algorithm>
+#include <cmath>
+#include <cstdarg>
+#include <map>
+#include <vector>
+
 //######################################################################
 // Emit statements and math operators
 
@@ -194,7 +193,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	putqs(nodep,"end\n");
     }
     virtual void visit(AstComment* nodep) {
-	puts((string)"// "+nodep->name()+"\n");
+        puts(string("// ")+nodep->name()+"\n");
         iterateChildren(nodep);
     }
     virtual void visit(AstContinue* nodep) {
@@ -257,10 +256,10 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	puts(");\n");
     }
     virtual void visit(AstJumpGo* nodep) {
-	putbs("disable "+cvtToStr((void*)(nodep->labelp()))+";\n");
+        putbs("disable "+cvtToHex(nodep->labelp())+";\n");
     }
     virtual void visit(AstJumpLabel* nodep) {
-	putbs("begin : "+cvtToStr((void*)(nodep))+"\n");
+        putbs("begin : "+cvtToHex(nodep)+"\n");
         if (nodep->stmtsp()) iterateAndNextNull(nodep->stmtsp());
 	puts("end\n");
     }
@@ -551,9 +550,9 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
     }
     // Terminals
     virtual void visit(AstVarRef* nodep) {
-	if (nodep->varScopep())
+        if (nodep->varScopep()) {
 	    putfs(nodep,nodep->varScopep()->prettyName());
-	else {
+        } else {
 	    putfs(nodep,nodep->hiername());
 	    puts(nodep->varp()->prettyName());
 	}
@@ -595,7 +594,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
     virtual void visit(AstCell*) {}		// Handled outside the Visit class
     // Default
     virtual void visit(AstNode* nodep) {
-	puts((string)"\n???? // "+nodep->prettyTypeName()+"\n");
+        puts(string("\n???? // ")+nodep->prettyTypeName()+"\n");
         iterateChildren(nodep);
 	// Not v3fatalSrc so we keep processing
 	nodep->v3error("Internal: Unknown node type reached emitter: "<<nodep->prettyTypeName());