Version bump

Add CONTASSREG error on continuous assignments to regs, bug1369.
Fix __Slow files getting compiled with OPT_FAST, bug1370.
2026-10-03 00:23:35 +02:00 · 2018-12-01 14:52:21 -05:00 · 2018-12-01 10:12:10 -05:00 · 2018-11-29 20:35:21 -05:00 · 2018-11-29 19:50:09 -05:00 · 2018-11-28 19:59:10 -05:00
540 changed files with 20203 additions and 4043 deletions
@@ -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'
@@ -1,6 +1,7 @@
 \#*
 .#*
 *~
+*.tidy
 *.old
 *.gz
 *.gz.uu
@@ -2,6 +2,63 @@ Revision history for Verilator

 The contributors that suggested a given feature are shown in []. Thanks!

+
+* Verilator 4.008 2018-12-01
+
+***   Support "ref" and "const ref" pins and functions, bug1360. [Jake Longo]
+
+***   In --xml-only show the original unmodified names, and add module_files
+      and cells similar to Verilog-Perl, msg2719. [Kanad Kanhere]
+
+****  Add CONTASSREG error on continuous assignments to regs, bug1369. [Peter Gerst]
+
+****  Add PROCASSWIRE error on behavioral assignments to wires, msg2737. [Neil Turton]
+
+****  Add IMPORTSTAR warning on import::* inside $unit scope.
+
+****  Fix --trace-lxt2 compile error on MinGW, msg2711. [HyungKi Jeong]
+
+****  Fix hang on bad pattern keys, bug1364. [Matt Myers]
+
+****  Fix crash due to cygwin bug in getline, bug1349. [Affe Mao]
+
+****  Fix __Slow files getting compiled with OPT_FAST, bug1370. [Thomas Watts]
+
+
+* 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]
+      (Verilator developers need to pull the latest vcddiff.)
+
+***   Support $past. [Dan Gisselquist]
+
+***   Support restrict, bug1350. [Clifford Wolf]
+
+***   Rename include/lxt2 to include/gtkwave.
+
+****  Fix replication of 64-bit signal change detects.
+
+****  Fix Mac OSX 10.13.6 / LLVM 9.1 compile issues, bug1348. [Kevin Kiningham]
+
+****  Fix MinGW compile issues, msg2636. [HyungKi Jeong]
+
+
 * Verilator 4.002 2018-09-16

 **    This is a major release.  Any patches may require major rework to apply.
@@ -1,5 +1,4 @@
-^CVS/
-/CVS/
+\.clang-tidy
 \.git/
 \.svn/
 \.(bak|old)/
@@ -9,13 +8,16 @@
 .*\.log
 \..*\.swp
 .*\.tmp
+.*\.tidy
 .*\.tex
 .*\.key
 .*\.vcd
 .*\.1
 /obj_dir/
 /obj_dbg/
+/obj_nc/
 /obj_opt/
+/obj_vcs/
 /obj_vlt/
 /obj_vltmt/
 /obj_dist/
@@ -129,7 +129,7 @@ DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \
 	include/*.[chv]* \
 	include/*.in \
 	include/.*ignore \
-	include/lxt2/*.[chv]* \
+	include/gtkwave/*.[chv]* \
 	include/vltstd/*.[chv]* \
 	.*attributes */.*attributes  */*/.*attributes \
 	src/.*ignore src/*.in src/*.cpp src/*.[chly] \
@@ -162,7 +162,7 @@ INST_PROJ_FILES = \
 	bin/verilator_profcfunc \
 	include/verilated.mk \
 	include/*.[chv]* \
-	include/lxt2/*.[chv]* \
+	include/gtkwave/*.[chv]* \
 	include/vltstd/*.[chv]* \

 INST_PROJ_BIN_FILES = \
@@ -291,7 +291,7 @@ VL_INST_INC_BLDDIR_FILES = \
 # Files under srcdir, instead of build time
 VL_INST_INC_SRCDIR_FILES = \
 	include/*.[chv]* \
-	include/lxt2/*.[chv]* \
+	include/gtkwave/*.[chv]* \
 	include/vltstd/*.[chv]* \

 VL_INST_DATA_SRCDIR_FILES = \
@@ -318,7 +318,7 @@ installman: $(VL_INST_MAN_FILES)
 	done

 installdata:
-	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/include/lxt2
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/include/gtkwave
 	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/include/vltstd
 	for p in $(VL_INST_INC_BLDDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
@@ -348,7 +348,7 @@ uninstall:
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_DATA_SRCDIR_FILES)
 	-rm $(DESTDIR)$(pkgconfigdir)/verilator.pc
 	-rmdir $(DESTDIR)$(pkgdatadir)/bin
-	-rmdir $(DESTDIR)$(pkgdatadir)/include/lxt2
+	-rmdir $(DESTDIR)$(pkgdatadir)/include/gtkwave
 	-rmdir $(DESTDIR)$(pkgdatadir)/include/vltstd
 	-rmdir $(DESTDIR)$(pkgdatadir)/include
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples/hello_world_c
@@ -413,7 +413,7 @@ ifeq ($(CFG_WITH_DEFENV),yes)
 	false
 endif
 	@echo "Install-cadtools-quick (no strip) to $(VERILATOR_CAD_DIR)"
-	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/include/lxt2
+	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/include/gtkwave
 	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/include/vltstd
 	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/bin
 	for p in $(INST_PROJ_FILES) ; do \
@@ -427,11 +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)/src/*.cpp)
 CPPCHECK_DEP = $(subst .cpp,.cppcheck,$(CPPCHECK_CPP))
 CPPCHECK_INC = -I$(srcdir)/include -I$(srcdir)/src/obj_dbg -I$(srcdir)/src

@@ -439,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
@@ -480,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 \
@@ -499,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*
@@ -81,7 +81,7 @@ instead.)
 To use Verilator you will need the C<perl>, C<make> (or C<gmake>), and
 C<g++> (or C<clang>) packages.

-To use Verilator LTX2 tracing you will need the C<gtkwave> and C<libgz> (on
+To use Verilator LXT2 or FST tracing you will need the C<gtkwave> and C<libgz> (on
 Ubuntu C<zlibc> C<zlib1g> C<zlib1g-dev>) packages installed.

 To compile Verilator in addition to the above you need the C<flex>,
@@ -30,7 +30,7 @@ use IO::File;
 use Pod::Usage;

 use strict;
-use vars qw ($Debug @Opt_Verilator_Sw);
+use vars qw($Debug @Opt_Verilator_Sw);

 #######################################################################
 #######################################################################
@@ -57,7 +57,7 @@ foreach my $sw (@ARGV) {
    push @Opt_Verilator_Sw, $sw;
 }

-Getopt::Long::config ("no_auto_abbrev","pass_through");
+Getopt::Long::config("no_auto_abbrev","pass_through");
 if (! GetOptions (
                  # Major operating modes
                  "help"        => \&usage,
@@ -108,7 +108,7 @@ if ($opt_gdb) {
         ." -ex 'bt'");
 } else {
    # Normal, non gdb
-    run (verilator_bin()." ".join(' ',@quoted_sw));
+    run(verilator_bin()." ".join(' ',@quoted_sw));
 }

 #----------------------------------------------------------------------
@@ -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
@@ -224,7 +226,7 @@ Verilator - Convert Verilog code to C++/SystemC
    verilator --version
    verilator --cc [options] [source_files.v]... [opt_c_files.cpp/c/cc/a/o/so]
    verilator --sc [options] [source_files.v]... [opt_c_files.cpp/c/cc/a/o/so]
-    verilator --lint-only    [source_files.v]...
+    verilator --lint-only -Wall [source_files.v]...

 =head1 DESCRIPTION

@@ -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
@@ -356,6 +360,7 @@ detailed descriptions in L</"VERILATION ARGUMENTS"> for more information.
    --threads-max-mtasks <mtasks>  Tune maximum mtask partitioning
    --top-module <topname>      Name of top level input module
    --trace                     Enable waveform creation
+    --trace-fst                 Enable FST waveform creation
    --trace-lxt2                Enable LXT2 waveform creation
    --trace-depth <levels>      Depth of tracing
    --trace-max-array <depth>   Maximum bit width for tracing
@@ -383,6 +388,7 @@ detailed descriptions in L</"VERILATION ARGUMENTS"> for more information.
    --x-assign <mode>           Assign non-initial Xs to this value
    --x-initial <mode>          Assign initial Xs to this value
    --x-initial-edge            Enable initial X->0 and X->1 edge triggers
+    --xml-only                  Create XML parser output
     -y <dir>                   Directory to search for modules

 This is a short summary of the arguments to run-time Verilated arguments.
@@ -500,9 +506,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

@@ -711,6 +721,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,
@@ -859,13 +878,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>

@@ -1072,6 +1095,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
@@ -1242,7 +1269,7 @@ designs with only one top.
 =item --trace

 Adds waveform tracing code to the model using VCD format. This overrides
-C<--trace-lxt2>.
+C<--trace-fst> and C<--trace-lxt2>.

 Verilator will generate additional {prefix}__Trace*.cpp files that will
 need to be compiled.  In addition verilated_vcd_sc.cpp (for SystemC traces)
@@ -1254,9 +1281,15 @@ need to add these to your Makefile manually.
 Having tracing compiled in may result in some small performance losses,
 even when waveforms are not turned on during model execution.

+=item --trace-fst
+
+Enable FST waveform tracing in the model. This overrides C<--trace> and C<--trace-lxt2>.
+
 =item --trace-lxt2

-Enable LXT2 waveform tracing in the model. This overrides C<--trace>.
+Enable LXT2 waveform tracing in the model. This overrides C<--trace> and
+C<--trace-fst>.  This option is deprecated in favor of FST traces and may
+be removed in the near future.

 =item --trace-depth I<levels>

@@ -1381,8 +1414,8 @@ received from third parties.

 Disable all code style related warning messages (note by default they are
 already disabled).  This is equivalent to "-Wno-DECLFILENAME -Wno-DEFPARAM
-Wno-INCABSPATH -Wno-PINCONNECTEMPTY -Wno-PINNOCONNECT -Wno-SYNCASYNCNET
-Wno-UNDRIVEN -Wno-UNUSED -Wno-VARHIDDEN".
+-Wno-IMPORTSTAR -Wno-INCABSPATH -Wno-PINCONNECTEMPTY -Wno-PINNOCONNECT
+-Wno-SYNCASYNCNET -Wno-UNDRIVEN -Wno-UNUSED -Wno-VARHIDDEN".

 =item -Wno-fatal

@@ -1492,6 +1525,14 @@ convergence, and that it may be necessary to use --converge-limit to
 increase the number of convergence iterations. This may be another
 indication of problems with the modelled design that should be addressed.

+=item --xml-only
+
+Create XML output only, do not create any other output.
+
+The XML format is intended to be used to leverage Verilator's parser and
+elaboration to feed to other downstream tools. Be aware that the XML format
+is still evolving; there will be some changes in future versions.
+
 =item -y I<dir>

 Add the directory to the list of directories that should be searched for
@@ -1801,34 +1842,45 @@ For -cc and -sc mode, it also creates:

    {prefix}.cpp                        // Top level C++ file
    {prefix}.h                          // Top level header
+    {prefix}__Slow{__n}.cpp             // Constructors and infrequent routines
+    {prefix}{__n}.cpp                   // Additional top C++ files (--output-split)
    {prefix}{each_verilog_module}.cpp   // Lower level internal C++ files
    {prefix}{each_verilog_module}.h     // Lower level internal header files
+    {prefix}{each_verilog_module}{__n}.cpp   // Additional lower C++ files (--output-split)

-In certain optimization modes, it also creates:
+In certain debug and other modes, it also creates:

+    {prefix}.xml                        // XML tree information (--xml)
+    {prefix}__Dpi.cpp                   // DPI import and export wrappers
    {prefix}__Dpi.h                     // DPI import and export declarations
    {prefix}__Inlines.h                 // Inline support functions
-    {prefix}__Slow.cpp                  // Constructors and infrequent routines
    {prefix}__Syms.cpp                  // Global symbol table C++
    {prefix}__Syms.h                    // Global symbol table header
-    {prefix}__Trace.cpp                 // Wave file generation code (--trace)
+    {prefix}__Trace__Slow{__n}.cpp      // Wave file generation code (--trace)
+    {prefix}__Trace{__n}.cpp            // Wave file generation code (--trace)
    {prefix}__cdc.txt                   // Clock Domain Crossing checks (--cdc)
    {prefix}__stats.txt                 // Statistics (--stats)

 It also creates internal files that can be mostly ignored:

-    {each_verilog_module}.vpp           // Post-processed verilog (--debug)
-    {prefix}.flags_vbin                 // Verilator dependencies
-    {prefix}.flags_vpp                  // Pre-processor dependencies
+    {mod_prefix}_{each_verilog_module}{__n}.vpp  // Post-processed verilog
+    {prefix}__ver.d                     // Make dependencies (-MMD)
    {prefix}__verFiles.dat              // Timestamps for skip-identical
-    {prefix}{misc}.d                    // Make dependencies (-MMD)
    {prefix}{misc}.dot                  // Debugging graph files (--debug)
    {prefix}{misc}.tree                 // Debugging files (--debug)

-After running Make, the C++ compiler should produce the following:
+After running Make, the C++ compiler may produce the following:

+    verilated{misc}.d                   // Intermediate dependencies
+    verilated{misc}.o                   // Intermediate objects
+    {mod_prefix}{misc}.d                // Intermediate dependencies
+    {mod_prefix}{misc}.o                // Intermediate objects
    {prefix}                            // Final executable (w/--exe argument)
    {prefix}__ALL.a                     // Library of all Verilated objects
+    {prefix}__ALLboth.cpp               // Include of classes for single compile
+    {prefix}__ALLcls.cpp                // Include of user classes for single compile
+    {prefix}__ALLsup.cpp                // Include of support files for single compile
+    {prefix}{misc}.d                    // Intermediate dependencies
    {prefix}{misc}.o                    // Intermediate objects


@@ -3403,15 +3455,6 @@ instead intended is to use a casez with C<?>.
 Ignoring this warning will only suppress the lint check, it will simulate
 correctly.

-=item COLONPLUS
-
-Warns that a :+ is seen. Likely the intent was to use +: to select a range
-of bits. If the intent was a range that is explicitly positive, suggest
-adding a space, e.g. use ": +".
-
-Ignoring this warning will only suppress the lint check, it will simulate
-correctly.
-
 =item CDCRSTLOGIC

 With --cdc only, warns that asynchronous flop reset terms come from other
@@ -3436,6 +3479,15 @@ For example "X > 1" will always be true when X is a single bit wide.
 Ignoring this warning will only suppress the lint check, it will simulate
 correctly.

+=item COLONPLUS
+
+Warns that a :+ is seen. Likely the intent was to use +: to select a range
+of bits. If the intent was a range that is explicitly positive, suggest
+adding a space, e.g. use ": +".
+
+Ignoring this warning will only suppress the lint check, it will simulate
+correctly.
+
 =item COMBDLY

 Warns that you have a delayed assignment inside of a combinatorial block.
@@ -3448,6 +3500,18 @@ L<http://www.sunburst-design.com/papers/CummingsSNUG2000SJ_NBA_rev1_2.pdf>
 Ignoring this warning may make Verilator simulations differ from other
 simulators.

+=item CONTASSREG
+
+Error that a continuous assignment is setting a reg. According to IEEE
+Verilog, but not SystemVerilog, a wire must be used as the target of
+continuous assignments.
+
+This error is only reported when "--language 1364-1995", "--language
+1364-2001", or "--language 1364-2005" is used.
+
+Ignoring this error will only suppress the lint check, it will simulate
+correctly.
+
 =item DECLFILENAME

 Warns that a module or other declaration's name doesn't match the filename
@@ -3527,6 +3591,16 @@ Emacs, available from L<http://www.veripool.org/>
 Ignoring this warning will only suppress the lint check, it will simulate
 correctly.

+=item IMPORTSTAR
+
+Warns that an "import I<package>::*" statement is in $unit scope. This
+causes the imported symbols to polute the global namespace, defeating much
+of the purpose of having a package. Generally "import ::*" should only be
+used inside a lower scope such as a package or module.
+
+Disabled by default as this is a code style warning; it will simulate
+correctly.
+
 =item IMPURE

 Warns that a task or function that has been marked with /*verilator
@@ -3641,6 +3715,11 @@ signal.
 Disabled by default as this is a code style warning; it will simulate
 correctly.

+=item PROCASSWIRE
+
+Error that a procedural assignment is setting a wire. According to IEEE, a
+var/reg must be used as the target of procedural assignments.
+
 =item REALCVT

 Warns that a real number is being implicitly rounded to an integer, with
@@ -3717,7 +3796,7 @@ expression as the next statement.  For example:

      task foo; output sig; ... endtask
      always @* begin
-           foo(bus_we_select_from[2]);   // Will get TASKNSVAR error
+           foo(bus_we_select_from[2]);  // Will get TASKNSVAR error
      end

 Change this to:
@@ -3731,6 +3810,17 @@ Change this to:
 Verilator doesn't do this conversion for you, as some more complicated
 cases would result in simulator mismatches.

+=item TICKCOUNT
+
+Warns that the number of ticks to delay a $past variable is greater than
+10.  At present Verilator effectively creates a flop for each delayed
+signals, and as such any large counts may lead to large design size
+increases.
+
+Ignoring this warning will only slow simulations, it will simulate
+correctly.
+
+
 =item UNDRIVEN

 Warns that the specified signal is never sourced.  Verilator is fairly
@@ -3954,17 +4044,30 @@ For example:
 will toggle forever and thus the executable will give the didn't converge
 error to prevent an infinite loop.

-To debug this, run Verilator with --prof-cfuncs.  Run make on the
-generated files with "OPT=-DVL_DEBUG". Then call Verilated::debug(1) in
-your main.cpp.
+To debug this, first is to review any UNOPTFLAT warnings that were ignored,
+though typically these can be ignored (at a performance cost), convergence
+issues can also be flagged with this warning as Verilator didn't know if
+they would eventually converge.
+
+Next, run Verilator with --prof-cfuncs.  Run make on the generated
+files with "OPT=-DVL_DEBUG". Then call Verilated::debug(1) in your
+main.cpp.

 This will cause each change in a variable to print a message.  Near the
-bottom you'll see the code and variable that causes the problem.  For the
-program above:
+bottom you'll see the variables that causes the problem.  For the program
+above:

        CHANGE: filename.v:1: b
        CHANGE: filename.v:2: a

+If many signals are getting printed then most likely each are oscillating
+(or there is a bug). It may also be that e.g. "a" may be oscillating, then
+"a" feeds signal "c" which then is also reported as oscillating.
+
+Finally, rare more difficult cases can be debugged like a "C" program;
+either enter GDB and use its tracing facilities, or edit the generated C++
+code to add appropriate prints to see what is going on.
+
 =back


@@ -4061,12 +4164,12 @@ trace file if you want all data to land in the same output file.
        ...
        Verilated::traceEverOn(true);
        VerilatedVcdC* tfp = new VerilatedVcdC;
-        topp->trace (tfp, 99);
-        tfp->open ("obj_dir/t_trace_ena_cc/simx.vcd");
+        topp->trace(tfp, 99);
+        tfp->open("obj_dir/t_trace_ena_cc/simx.vcd");
        ...
        while (sc_time_stamp() < sim_time && !Verilated::gotFinish()) {
            main_time += #;
-            tfp->dump (main_time);
+            tfp->dump(main_time);
        }
        tfp->close();
    }
@@ -4097,14 +4200,31 @@ trace file if you want all data to land in the same output file.
        ...
        Verilated::traceEverOn(true);
        VerilatedVcdSc* tfp = new VerilatedVcdSc;
-        topp->trace (tfp, 99);
-        tfp->open ("obj_dir/t_trace_ena_cc/simx.vcd");
+        topp->trace(tfp, 99);
+        tfp->open("obj_dir/t_trace_ena_cc/simx.vcd");
        ...
        sc_start(1);
        ...
        tfp->close();
    }

+=item How do I generate FST waveforms (traces) in C++?
+
+FST a format by GTKWave.
+This version provides a basic FST support.
+To dump FST format, add the --trace switch to Verilator and change the include path in the testbench to:
+
+    #include "verilated_fst_c.h"
+    VerilatedFstC* tfp = new VerilatedFstC;
+
+Note that currently supporting both FST and VCD in a single simulation is impossible,
+but such requirement could be rare.
+
+=item How do I generate FST waveforms (traces) in SystemC?
+
+The FST library from GTKWave does not currently support SystemC; use VCD
+format instead.
+
 =item How do I generate LXT2 waveforms (traces) in C++?

 LXT2 a format by GTKWave, which is usually 10x smaller than VCD format.
@@ -4124,10 +4244,10 @@ format instead.

 =item How do I view waveforms (traces)?

-Verilator makes standard VCD (Value Change Dump) and LXT2 files.  VCD files are viewable
+Verilator makes standard VCD (Value Change Dump), LXT2 and FST files.  VCD files are viewable
 with the public domain GTKWave (recommended) or Dinotrace (legacy)
 programs, or any of the many commercial offerings;
-LXT2 is supported by GTKWave only.
+LXT2 and FST are supported by GTKWave only.

 =item How do I reduce the size of large waveform (trace) files?

@@ -31,7 +31,7 @@ use Pod::Usage;
 use Cwd qw(abs_path getcwd);

 use strict;
-use vars qw ($Debug @Opt_Verilator_Sw);
+use vars qw($Debug @Opt_Verilator_Sw);

 #######################################################################
 #######################################################################
@@ -54,7 +54,7 @@ foreach my $sw (@ARGV) {
    push @Opt_Verilator_Sw, $sw;
 }

-Getopt::Long::config ("no_auto_abbrev","pass_through");
+Getopt::Long::config("no_auto_abbrev","pass_through");
 if (! GetOptions (
 	  # Major operating modes
 	  "help"	=> \&usage,
@@ -67,8 +67,8 @@ if (! GetOptions (
 }

 # Normal, non gdb
-run (verilator_coverage_bin()
-     ." ".join(' ',@Opt_Verilator_Sw));
+run(verilator_coverage_bin()
+    ." ".join(' ',@Opt_Verilator_Sw));

 #----------------------------------------------------------------------

@@ -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
@@ -10,7 +10,7 @@ use Getopt::Long;
 use IO::File;
 use Pod::Usage;
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);

 #======================================================================

@@ -37,7 +37,7 @@ my $Opt_B;
 my $Opt_Lineno = 1;
 autoflush STDOUT 1;
 autoflush STDERR 1;
-Getopt::Long::config ("no_auto_abbrev");
+Getopt::Long::config("no_auto_abbrev");
 if (! GetOptions (
 	  "help"	=> \&usage,
 	  "debug"	=> \&debug,
@@ -54,9 +54,9 @@ defined $Opt_B or die "%Error: No new diff filename\n";
 -e $Opt_B or die "%Error: No new diff filename found: $Opt_B\n";

 if (-d $Opt_A && -d $Opt_B) {
-    diff_dir ($Opt_A, $Opt_B);
+    diff_dir($Opt_A, $Opt_B);
 } elsif (-f $Opt_A && -f $Opt_B) {
-    diff_file ($Opt_A, $Opt_B);
+    diff_file($Opt_A, $Opt_B);
 } else {
    die "%Error: Mix of files and dirs\n";
 }
@@ -85,8 +85,8 @@ sub diff_dir {
 	diff_file($a,$b);
 	$any = 1;
    }
-    $any or warn ("%Warning: No .tree files found that have similar base names:\n    "
-                  .join("\n    ", sort keys %files),"\n");
+    $any or warn("%Warning: No .tree files found that have similar base names:\n    "
+                 .join("\n    ", sort keys %files),"\n");
 }

 sub diff_file {
@@ -103,8 +103,8 @@ sub diff_file {
    my $verCvt = (($vera < 0x3900 && $verb >= 0x3900)
 		  || ($vera >= 0x3900 && $verb < 0x3900));

-    filter ($a, $tmp_a, $verCvt);
-    filter ($b, $tmp_b, $verCvt);
+    filter($a, $tmp_a, $verCvt);
+    filter($b, $tmp_b, $verCvt);
    system("diff -u $tmp_a $tmp_b");
    unlink $tmp_a;
    unlink $tmp_b;
@@ -169,7 +169,7 @@ sub filter {

 sub usage {
    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
-    exit (1);
+    exit(1);
 }

 sub debug {
@@ -9,7 +9,7 @@ use warnings;
 use Getopt::Long;
 use IO::File;
 use Pod::Usage;
-use vars qw ($Debug);
+use vars qw($Debug);

 $Debug = 0;
 my $Opt_File;
@@ -44,7 +44,7 @@ exit(0);

 sub usage {
    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
-    exit (1);
+    exit(1);
 }

 sub parameter {
@@ -11,7 +11,7 @@ use IO::File;
 use Pod::Usage;
 eval { use Data::Dumper;  $Data::Dumper::Indent = 1; }; # Debug, ok if missing
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);

 #======================================================================

@@ -23,7 +23,7 @@ $Debug = 0;
 my $Opt_File;
 autoflush STDOUT 1;
 autoflush STDERR 1;
-Getopt::Long::config ("no_auto_abbrev");
+Getopt::Long::config("no_auto_abbrev");
 if (! GetOptions (
 		  "help"	=> \&usage,
 		  "debug"	=> \&debug,
@@ -40,7 +40,7 @@ profcfunc($Opt_File);

 sub usage {
    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
-    exit (1);
+    exit(1);
 }

 sub debug {
@@ -6,7 +6,7 @@

 #AC_INIT([Verilator],[#.### YYYY-MM-DD])
 #AC_INIT([Verilator],[#.### devel])
-AC_INIT([Verilator],[4.002 2018-09-16],
+AC_INIT([Verilator],[4.008 2018-12-01],
        [https://www.veripool.org/verilator],
        [verilator],[https://www.veripool.org/verilator])
 # When releasing, also update header of Changes file
@@ -234,9 +234,9 @@ _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++03)
 AC_SUBST(CFG_CXXFLAGS_STD_NEWEST)
 # And likewise oldest standard (same list above, backwards)
 # This is used for internal testing
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++03)
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++11)
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++14)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=c++03)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=c++11)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=c++14)
 #_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++17)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++03)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++11)
@@ -0,0 +1,547 @@
+/*
+  FastLZ - lightning-fast lossless compression library
+
+  Copyright (C) 2007 Ariya Hidayat ([email protected])
+  Copyright (C) 2006 Ariya Hidayat ([email protected])
+  Copyright (C) 2005 Ariya Hidayat ([email protected])
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#include "fastlz.h"
+
+#if !defined(FASTLZ__COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR)
+
+/*
+ * Always check for bound when decompressing.
+ * Generally it is best to leave it defined.
+ */
+#define FASTLZ_SAFE
+
+
+/*
+ * Give hints to the compiler for branch prediction optimization.
+ */
+#if defined(__GNUC__) && (__GNUC__ > 2)
+#define FASTLZ_EXPECT_CONDITIONAL(c)    (__builtin_expect((c), 1))
+#define FASTLZ_UNEXPECT_CONDITIONAL(c)  (__builtin_expect((c), 0))
+#else
+#define FASTLZ_EXPECT_CONDITIONAL(c)    (c)
+#define FASTLZ_UNEXPECT_CONDITIONAL(c)  (c)
+#endif
+
+/*
+ * Use inlined functions for supported systems.
+ */
+#if defined(__GNUC__) || defined(__DMC__) || defined(__POCC__) || defined(__WATCOMC__) || defined(__SUNPRO_C)
+#define FASTLZ_INLINE inline
+#elif defined(__BORLANDC__) || defined(_MSC_VER) || defined(__LCC__)
+#define FASTLZ_INLINE __inline
+#else
+#define FASTLZ_INLINE
+#endif
+
+/*
+ * Prevent accessing more than 8-bit at once, except on x86 architectures.
+ */
+#if !defined(FASTLZ_STRICT_ALIGN)
+#define FASTLZ_STRICT_ALIGN
+#if defined(__i386__) || defined(__386)  /* GNU C, Sun Studio */
+#undef FASTLZ_STRICT_ALIGN
+#elif defined(__i486__) || defined(__i586__) || defined(__i686__) || defined(__amd64) /* GNU C */
+#undef FASTLZ_STRICT_ALIGN
+#elif defined(_M_IX86) /* Intel, MSVC */
+#undef FASTLZ_STRICT_ALIGN
+#elif defined(__386)
+#undef FASTLZ_STRICT_ALIGN
+#elif defined(_X86_) /* MinGW */
+#undef FASTLZ_STRICT_ALIGN
+#elif defined(__I86__) /* Digital Mars */
+#undef FASTLZ_STRICT_ALIGN
+#endif
+#endif
+
+/* prototypes */
+int fastlz_compress(const void* input, int length, void* output);
+int fastlz_compress_level(int level, const void* input, int length, void* output);
+int fastlz_decompress(const void* input, int length, void* output, int maxout);
+
+#define MAX_COPY       32
+#define MAX_LEN       264  /* 256 + 8 */
+#define MAX_DISTANCE 8192
+
+#if !defined(FASTLZ_STRICT_ALIGN)
+#define FASTLZ_READU16(p) *((const flzuint16*)(p))
+#else
+#define FASTLZ_READU16(p) ((p)[0] | (p)[1]<<8)
+#endif
+
+#define HASH_LOG  13
+#define HASH_SIZE (1<< HASH_LOG)
+#define HASH_MASK  (HASH_SIZE-1)
+#define HASH_FUNCTION(v,p) { v = FASTLZ_READU16(p); v ^= FASTLZ_READU16(p+1)^(v>>(16-HASH_LOG));v &= HASH_MASK; }
+
+#undef FASTLZ_LEVEL
+#define FASTLZ_LEVEL 1
+
+#undef FASTLZ_COMPRESSOR
+#undef FASTLZ_DECOMPRESSOR
+#define FASTLZ_COMPRESSOR fastlz1_compress
+#define FASTLZ_DECOMPRESSOR fastlz1_decompress
+static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output);
+static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout);
+#include "fastlz.c"
+
+#undef FASTLZ_LEVEL
+#define FASTLZ_LEVEL 2
+
+#undef MAX_DISTANCE
+#define MAX_DISTANCE 8191
+#define MAX_FARDISTANCE (65535+MAX_DISTANCE-1)
+
+#undef FASTLZ_COMPRESSOR
+#undef FASTLZ_DECOMPRESSOR
+#define FASTLZ_COMPRESSOR fastlz2_compress
+#define FASTLZ_DECOMPRESSOR fastlz2_decompress
+static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output);
+static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout);
+#include "fastlz.c"
+
+int fastlz_compress(const void* input, int length, void* output)
+{
+  /* for short block, choose fastlz1 */
+  if(length < 65536)
+    return fastlz1_compress(input, length, output);
+
+  /* else... */
+  return fastlz2_compress(input, length, output);
+}
+
+int fastlz_decompress(const void* input, int length, void* output, int maxout)
+{
+  /* magic identifier for compression level */
+  int level = ((*(const flzuint8*)input) >> 5) + 1;
+
+  if(level == 1)
+    return fastlz1_decompress(input, length, output, maxout);
+  if(level == 2)
+    return fastlz2_decompress(input, length, output, maxout);
+
+  /* unknown level, trigger error */
+  return 0;
+}
+
+int fastlz_compress_level(int level, const void* input, int length, void* output)
+{
+  if(level == 1)
+    return fastlz1_compress(input, length, output);
+  if(level == 2)
+    return fastlz2_compress(input, length, output);
+
+  return 0;
+}
+
+#else /* !defined(FASTLZ_COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR) */
+
+static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output)
+{
+  const flzuint8* ip = (const flzuint8*) input;
+  const flzuint8* ip_bound = ip + length - 2;
+  const flzuint8* ip_limit = ip + length - 12;
+  flzuint8* op = (flzuint8*) output;
+
+  const flzuint8* htab[HASH_SIZE];
+  const flzuint8** hslot;
+  flzuint32 hval;
+
+  flzuint32 copy;
+
+  /* sanity check */
+  if(FASTLZ_UNEXPECT_CONDITIONAL(length < 4))
+  {
+    if(length)
+    {
+      /* create literal copy only */
+      *op++ = length-1;
+      ip_bound++;
+      while(ip <= ip_bound)
+        *op++ = *ip++;
+      return length+1;
+    }
+    else
+      return 0;
+  }
+
+  /* initializes hash table */
+  for (hslot = htab; hslot < htab + HASH_SIZE; hslot++)
+    *hslot = ip;
+
+  /* we start with literal copy */
+  copy = 2;
+  *op++ = MAX_COPY-1;
+  *op++ = *ip++;
+  *op++ = *ip++;
+
+  /* main loop */
+  while(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit))
+  {
+    const flzuint8* ref;
+    flzuint32 distance;
+
+    /* minimum match length */
+    flzuint32 len = 3;
+
+    /* comparison starting-point */
+    const flzuint8* anchor = ip;
+
+    /* check for a run */
+#if FASTLZ_LEVEL==2
+    if(ip[0] == ip[-1] && FASTLZ_READU16(ip-1)==FASTLZ_READU16(ip+1))
+    {
+      distance = 1;
+      /* ip += 3; */ /* scan-build, never used */
+      ref = anchor - 1 + 3;
+      goto match;
+    }
+#endif
+
+    /* find potential match */
+    HASH_FUNCTION(hval,ip);
+    hslot = htab + hval;
+    ref = htab[hval];
+
+    /* calculate distance to the match */
+    distance = anchor - ref;
+
+    /* update hash table */
+    *hslot = anchor;
+
+    /* is this a match? check the first 3 bytes */
+    if(distance==0 ||
+#if FASTLZ_LEVEL==1
+    (distance >= MAX_DISTANCE) ||
+#else
+    (distance >= MAX_FARDISTANCE) ||
+#endif
+    *ref++ != *ip++ || *ref++!=*ip++ || *ref++!=*ip++)
+      goto literal;
+
+#if FASTLZ_LEVEL==2
+    /* far, needs at least 5-byte match */
+    if(distance >= MAX_DISTANCE)
+    {
+      if(*ip++ != *ref++ || *ip++!= *ref++)
+        goto literal;
+      len += 2;
+    }
+
+    match:
+#endif
+
+    /* last matched byte */
+    ip = anchor + len;
+
+    /* distance is biased */
+    distance--;
+
+    if(!distance)
+    {
+      /* zero distance means a run */
+      flzuint8 x = ip[-1];
+      while(ip < ip_bound)
+        if(*ref++ != x) break; else ip++;
+    }
+    else
+    for(;;)
+    {
+      /* safe because the outer check against ip limit */
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      while(ip < ip_bound)
+        if(*ref++ != *ip++) break;
+      break;
+    }
+
+    /* if we have copied something, adjust the copy count */
+    if(copy)
+      /* copy is biased, '0' means 1 byte copy */
+      *(op-copy-1) = copy-1;
+    else
+      /* back, to overwrite the copy count */
+      op--;
+
+    /* reset literal counter */
+    copy = 0;
+
+    /* length is biased, '1' means a match of 3 bytes */
+    ip -= 3;
+    len = ip - anchor;
+
+    /* encode the match */
+#if FASTLZ_LEVEL==2
+    if(distance < MAX_DISTANCE)
+    {
+      if(len < 7)
+      {
+        *op++ = (len << 5) + (distance >> 8);
+        *op++ = (distance & 255);
+      }
+      else
+      {
+        *op++ = (7 << 5) + (distance >> 8);
+        for(len-=7; len >= 255; len-= 255)
+          *op++ = 255;
+        *op++ = len;
+        *op++ = (distance & 255);
+      }
+    }
+    else
+    {
+      /* far away, but not yet in the another galaxy... */
+      if(len < 7)
+      {
+        distance -= MAX_DISTANCE;
+        *op++ = (len << 5) + 31;
+        *op++ = 255;
+        *op++ = distance >> 8;
+        *op++ = distance & 255;
+      }
+      else
+      {
+        distance -= MAX_DISTANCE;
+        *op++ = (7 << 5) + 31;
+        for(len-=7; len >= 255; len-= 255)
+          *op++ = 255;
+        *op++ = len;
+        *op++ = 255;
+        *op++ = distance >> 8;
+        *op++ = distance & 255;
+      }
+    }
+#else
+
+    if(FASTLZ_UNEXPECT_CONDITIONAL(len > MAX_LEN-2))
+      while(len > MAX_LEN-2)
+      {
+        *op++ = (7 << 5) + (distance >> 8);
+        *op++ = MAX_LEN - 2 - 7 -2;
+        *op++ = (distance & 255);
+        len -= MAX_LEN-2;
+      }
+
+    if(len < 7)
+    {
+      *op++ = (len << 5) + (distance >> 8);
+      *op++ = (distance & 255);
+    }
+    else
+    {
+      *op++ = (7 << 5) + (distance >> 8);
+      *op++ = len - 7;
+      *op++ = (distance & 255);
+    }
+#endif
+
+    /* update the hash at match boundary */
+    HASH_FUNCTION(hval,ip);
+    htab[hval] = ip++;
+    HASH_FUNCTION(hval,ip);
+    htab[hval] = ip++;
+
+    /* assuming literal copy */
+    *op++ = MAX_COPY-1;
+
+    continue;
+
+    literal:
+      *op++ = *anchor++;
+      ip = anchor;
+      copy++;
+      if(FASTLZ_UNEXPECT_CONDITIONAL(copy == MAX_COPY))
+      {
+        copy = 0;
+        *op++ = MAX_COPY-1;
+      }
+  }
+
+  /* left-over as literal copy */
+  ip_bound++;
+  while(ip <= ip_bound)
+  {
+    *op++ = *ip++;
+    copy++;
+    if(copy == MAX_COPY)
+    {
+      copy = 0;
+      *op++ = MAX_COPY-1;
+    }
+  }
+
+  /* if we have copied something, adjust the copy length */
+  if(copy)
+    *(op-copy-1) = copy-1;
+  else
+    op--;
+
+#if FASTLZ_LEVEL==2
+  /* marker for fastlz2 */
+  *(flzuint8*)output |= (1 << 5);
+#endif
+
+  return op - (flzuint8*)output;
+}
+
+static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout)
+{
+  const flzuint8* ip = (const flzuint8*) input;
+  const flzuint8* ip_limit  = ip + length;
+  flzuint8* op = (flzuint8*) output;
+  flzuint8* op_limit = op + maxout;
+  flzuint32 ctrl = (*ip++) & 31;
+  int loop = 1;
+
+  do
+  {
+    const flzuint8* ref = op;
+    flzuint32 len = ctrl >> 5;
+    flzuint32 ofs = (ctrl & 31) << 8;
+
+    if(ctrl >= 32)
+    {
+#if FASTLZ_LEVEL==2
+      flzuint8 code;
+#endif
+      len--;
+      ref -= ofs;
+      if (len == 7-1)
+#if FASTLZ_LEVEL==1
+        len += *ip++;
+      ref -= *ip++;
+#else
+        do
+        {
+          code = *ip++;
+          len += code;
+        } while (code==255);
+      code = *ip++;
+      ref -= code;
+
+      /* match from 16-bit distance */
+      if(FASTLZ_UNEXPECT_CONDITIONAL(code==255))
+      if(FASTLZ_EXPECT_CONDITIONAL(ofs==(31 << 8)))
+      {
+        ofs = (*ip++) << 8;
+        ofs += *ip++;
+        ref = op - ofs - MAX_DISTANCE;
+      }
+#endif
+
+#ifdef FASTLZ_SAFE
+      if (FASTLZ_UNEXPECT_CONDITIONAL(op + len + 3 > op_limit))
+        return 0;
+
+      if (FASTLZ_UNEXPECT_CONDITIONAL(ref-1 < (flzuint8 *)output))
+        return 0;
+#endif
+
+      if(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit))
+        ctrl = *ip++;
+      else
+        loop = 0;
+
+      if(ref == op)
+      {
+        /* optimize copy for a run */
+        flzuint8 b = ref[-1];
+        *op++ = b;
+        *op++ = b;
+        *op++ = b;
+        for(; len; --len)
+          *op++ = b;
+      }
+      else
+      {
+#if !defined(FASTLZ_STRICT_ALIGN)
+        const flzuint16* p;
+        flzuint16* q;
+#endif
+        /* copy from reference */
+        ref--;
+        *op++ = *ref++;
+        *op++ = *ref++;
+        *op++ = *ref++;
+
+#if !defined(FASTLZ_STRICT_ALIGN)
+        /* copy a byte, so that now it's word aligned */
+        if(len & 1)
+        {
+          *op++ = *ref++;
+          len--;
+        }
+
+        /* copy 16-bit at once */
+        q = (flzuint16*) op;
+        op += len;
+        p = (const flzuint16*) ref;
+        for(len>>=1; len > 4; len-=4)
+        {
+          *q++ = *p++;
+          *q++ = *p++;
+          *q++ = *p++;
+          *q++ = *p++;
+        }
+        for(; len; --len)
+          *q++ = *p++;
+#else
+        for(; len; --len)
+          *op++ = *ref++;
+#endif
+      }
+    }
+    else
+    {
+      ctrl++;
+#ifdef FASTLZ_SAFE
+      if (FASTLZ_UNEXPECT_CONDITIONAL(op + ctrl > op_limit))
+        return 0;
+      if (FASTLZ_UNEXPECT_CONDITIONAL(ip + ctrl > ip_limit))
+        return 0;
+#endif
+
+      *op++ = *ip++;
+      for(--ctrl; ctrl; ctrl--)
+        *op++ = *ip++;
+
+      loop = FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit);
+      if(loop)
+        ctrl = *ip++;
+    }
+  }
+  while(FASTLZ_EXPECT_CONDITIONAL(loop));
+
+  return op - (flzuint8*)output;
+}
+
+#endif /* !defined(FASTLZ_COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR) */
@@ -0,0 +1,107 @@
+/*
+  FastLZ - lightning-fast lossless compression library
+
+  Copyright (C) 2007 Ariya Hidayat ([email protected])
+  Copyright (C) 2006 Ariya Hidayat ([email protected])
+  Copyright (C) 2005 Ariya Hidayat ([email protected])
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef FASTLZ_H
+#define FASTLZ_H
+
+#include <inttypes.h>
+
+#define flzuint8 uint8_t
+#define flzuint16 uint16_t
+#define flzuint32 uint32_t
+
+
+#define FASTLZ_VERSION 0x000100
+
+#define FASTLZ_VERSION_MAJOR     0
+#define FASTLZ_VERSION_MINOR     0
+#define FASTLZ_VERSION_REVISION  0
+
+#define FASTLZ_VERSION_STRING "0.1.0"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/**
+  Compress a block of data in the input buffer and returns the size of
+  compressed block. The size of input buffer is specified by length. The
+  minimum input buffer size is 16.
+
+  The output buffer must be at least 5% larger than the input buffer
+  and can not be smaller than 66 bytes.
+
+  If the input is not compressible, the return value might be larger than
+  length (input buffer size).
+
+  The input buffer and the output buffer can not overlap.
+*/
+
+int fastlz_compress(const void* input, int length, void* output);
+
+/**
+  Decompress a block of compressed data and returns the size of the
+  decompressed block. If error occurs, e.g. the compressed data is
+  corrupted or the output buffer is not large enough, then 0 (zero)
+  will be returned instead.
+
+  The input buffer and the output buffer can not overlap.
+
+  Decompression is memory safe and guaranteed not to write the output buffer
+  more than what is specified in maxout.
+ */
+
+int fastlz_decompress(const void* input, int length, void* output, int maxout);
+
+/**
+  Compress a block of data in the input buffer and returns the size of
+  compressed block. The size of input buffer is specified by length. The
+  minimum input buffer size is 16.
+
+  The output buffer must be at least 5% larger than the input buffer
+  and can not be smaller than 66 bytes.
+
+  If the input is not compressible, the return value might be larger than
+  length (input buffer size).
+
+  The input buffer and the output buffer can not overlap.
+
+  Compression level can be specified in parameter level. At the moment,
+  only level 1 and level 2 are supported.
+  Level 1 is the fastest compression and generally useful for short data.
+  Level 2 is slightly slower but it gives better compression ratio.
+
+  Note that the compressed data, regardless of the level, can always be
+  decompressed using the function fastlz_decompress above.
+*/
+
+int fastlz_compress_level(int level, const void* input, int length, void* output);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* FASTLZ_H */
@@ -1,12 +1,12 @@
-/* This file specifically for LXT2 usage */
+/* This file specifically for FST 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
+#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
@@ -0,0 +1,452 @@
+/*
+ * 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"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef FST_API_H
+#define FST_API_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <zlib.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include <time.h>
+
+#define FST_RDLOAD "FSTLOAD | "
+
+typedef uint32_t fstHandle;
+typedef uint32_t fstEnumHandle;
+
+enum fstWriterPackType {
+    FST_WR_PT_ZLIB             = 0,
+    FST_WR_PT_FASTLZ           = 1,
+    FST_WR_PT_LZ4              = 2
+};
+
+enum fstFileType {
+    FST_FT_MIN                 = 0,
+
+    FST_FT_VERILOG             = 0,
+    FST_FT_VHDL                = 1,
+    FST_FT_VERILOG_VHDL        = 2,
+
+    FST_FT_MAX                 = 2
+};
+
+enum fstBlockType {
+    FST_BL_HDR                 = 0,
+    FST_BL_VCDATA              = 1,
+    FST_BL_BLACKOUT            = 2,
+    FST_BL_GEOM                = 3,
+    FST_BL_HIER                = 4,
+    FST_BL_VCDATA_DYN_ALIAS    = 5,
+    FST_BL_HIER_LZ4            = 6,
+    FST_BL_HIER_LZ4DUO         = 7,
+    FST_BL_VCDATA_DYN_ALIAS2   = 8,
+
+    FST_BL_ZWRAPPER            = 254,   /* indicates that whole trace is gz wrapped */
+    FST_BL_SKIP                = 255    /* used while block is being written */
+};
+
+enum fstScopeType {
+    FST_ST_MIN                 = 0,
+
+    FST_ST_VCD_MODULE          = 0,
+    FST_ST_VCD_TASK            = 1,
+    FST_ST_VCD_FUNCTION        = 2,
+    FST_ST_VCD_BEGIN           = 3,
+    FST_ST_VCD_FORK            = 4,
+    FST_ST_VCD_GENERATE        = 5,
+    FST_ST_VCD_STRUCT          = 6,
+    FST_ST_VCD_UNION           = 7,
+    FST_ST_VCD_CLASS           = 8,
+    FST_ST_VCD_INTERFACE       = 9,
+    FST_ST_VCD_PACKAGE         = 10,
+    FST_ST_VCD_PROGRAM         = 11,
+
+    FST_ST_VHDL_ARCHITECTURE   = 12,
+    FST_ST_VHDL_PROCEDURE      = 13,
+    FST_ST_VHDL_FUNCTION       = 14,
+    FST_ST_VHDL_RECORD         = 15,
+    FST_ST_VHDL_PROCESS        = 16,
+    FST_ST_VHDL_BLOCK          = 17,
+    FST_ST_VHDL_FOR_GENERATE   = 18,
+    FST_ST_VHDL_IF_GENERATE    = 19,
+    FST_ST_VHDL_GENERATE       = 20,
+    FST_ST_VHDL_PACKAGE        = 21,
+
+    FST_ST_MAX                 = 21,
+
+    FST_ST_GEN_ATTRBEGIN       = 252,
+    FST_ST_GEN_ATTREND         = 253,
+
+    FST_ST_VCD_SCOPE           = 254,
+    FST_ST_VCD_UPSCOPE         = 255
+};
+
+enum fstVarType {
+    FST_VT_MIN                 = 0,     /* start of vartypes */
+
+    FST_VT_VCD_EVENT           = 0,
+    FST_VT_VCD_INTEGER         = 1,
+    FST_VT_VCD_PARAMETER       = 2,
+    FST_VT_VCD_REAL            = 3,
+    FST_VT_VCD_REAL_PARAMETER  = 4,
+    FST_VT_VCD_REG             = 5,
+    FST_VT_VCD_SUPPLY0         = 6,
+    FST_VT_VCD_SUPPLY1         = 7,
+    FST_VT_VCD_TIME            = 8,
+    FST_VT_VCD_TRI             = 9,
+    FST_VT_VCD_TRIAND          = 10,
+    FST_VT_VCD_TRIOR           = 11,
+    FST_VT_VCD_TRIREG          = 12,
+    FST_VT_VCD_TRI0            = 13,
+    FST_VT_VCD_TRI1            = 14,
+    FST_VT_VCD_WAND            = 15,
+    FST_VT_VCD_WIRE            = 16,
+    FST_VT_VCD_WOR             = 17,
+    FST_VT_VCD_PORT            = 18,
+    FST_VT_VCD_SPARRAY         = 19,    /* used to define the rownum (index) port for a sparse array */
+    FST_VT_VCD_REALTIME        = 20,
+
+    FST_VT_GEN_STRING          = 21,    /* generic string type   (max len is defined dynamically via fstWriterEmitVariableLengthValueChange) */
+
+    FST_VT_SV_BIT              = 22,
+    FST_VT_SV_LOGIC            = 23,
+    FST_VT_SV_INT              = 24,    /* declare as size = 32 */
+    FST_VT_SV_SHORTINT         = 25,    /* declare as size = 16 */
+    FST_VT_SV_LONGINT          = 26,    /* declare as size = 64 */
+    FST_VT_SV_BYTE             = 27,    /* declare as size = 8  */
+    FST_VT_SV_ENUM             = 28,    /* declare as appropriate type range */
+    FST_VT_SV_SHORTREAL        = 29,    /* declare and emit same as FST_VT_VCD_REAL (needs to be emitted as double, not a float) */
+
+    FST_VT_MAX                 = 29     /* end of vartypes */
+};
+
+enum fstVarDir {
+    FST_VD_MIN         = 0,
+
+    FST_VD_IMPLICIT    = 0,
+    FST_VD_INPUT       = 1,
+    FST_VD_OUTPUT      = 2,
+    FST_VD_INOUT       = 3,
+    FST_VD_BUFFER      = 4,
+    FST_VD_LINKAGE     = 5,
+
+    FST_VD_MAX         = 5
+};
+
+enum fstHierType {
+    FST_HT_MIN         = 0,
+
+    FST_HT_SCOPE       = 0,
+    FST_HT_UPSCOPE     = 1,
+    FST_HT_VAR         = 2,
+    FST_HT_ATTRBEGIN   = 3,
+    FST_HT_ATTREND     = 4,
+
+    /* FST_HT_TREEBEGIN and FST_HT_TREEEND are not yet used by FST but are currently used when fstHier bridges other formats */
+    FST_HT_TREEBEGIN   = 5,
+    FST_HT_TREEEND     = 6,
+
+    FST_HT_MAX         = 6
+};
+
+enum fstAttrType {
+    FST_AT_MIN         = 0,
+
+    FST_AT_MISC        = 0,     /* self-contained: does not need matching FST_HT_ATTREND */
+    FST_AT_ARRAY       = 1,
+    FST_AT_ENUM        = 2,
+    FST_AT_PACK        = 3,
+
+    FST_AT_MAX         = 3
+};
+
+enum fstMiscType {
+    FST_MT_MIN         = 0,
+
+    FST_MT_COMMENT     = 0,     /* use fstWriterSetComment() to emit */
+    FST_MT_ENVVAR      = 1,     /* use fstWriterSetEnvVar() to emit */
+    FST_MT_SUPVAR      = 2,     /* use fstWriterCreateVar2() to emit */
+    FST_MT_PATHNAME    = 3,     /* reserved for fstWriterSetSourceStem() string -> number management */
+    FST_MT_SOURCESTEM  = 4,     /* use fstWriterSetSourceStem() to emit */
+    FST_MT_SOURCEISTEM = 5,     /* use fstWriterSetSourceInstantiationStem() to emit */
+    FST_MT_VALUELIST   = 6,	/* use fstWriterSetValueList() to emit, followed by fstWriterCreateVar*() */
+    FST_MT_ENUMTABLE   = 7,	/* use fstWriterCreateEnumTable() and fstWriterEmitEnumTableRef() to emit */
+    FST_MT_UNKNOWN     = 8,
+
+    FST_MT_MAX         = 8
+};
+
+enum fstArrayType {
+    FST_AR_MIN         = 0,
+
+    FST_AR_NONE        = 0,
+    FST_AR_UNPACKED    = 1,
+    FST_AR_PACKED      = 2,
+    FST_AR_SPARSE      = 3,
+
+    FST_AR_MAX         = 3
+};
+
+enum fstEnumValueType {
+    FST_EV_SV_INTEGER           = 0,
+    FST_EV_SV_BIT               = 1,
+    FST_EV_SV_LOGIC             = 2,
+    FST_EV_SV_INT               = 3,
+    FST_EV_SV_SHORTINT          = 4,
+    FST_EV_SV_LONGINT           = 5,
+    FST_EV_SV_BYTE              = 6,
+    FST_EV_SV_UNSIGNED_INTEGER  = 7,
+    FST_EV_SV_UNSIGNED_BIT      = 8,
+    FST_EV_SV_UNSIGNED_LOGIC    = 9,
+    FST_EV_SV_UNSIGNED_INT      = 10,
+    FST_EV_SV_UNSIGNED_SHORTINT = 11,
+    FST_EV_SV_UNSIGNED_LONGINT  = 12,
+    FST_EV_SV_UNSIGNED_BYTE     = 13,
+
+    FST_EV_REG			= 14,
+    FST_EV_TIME			= 15,
+
+    FST_EV_MAX                  = 15
+};
+
+enum fstPackType {
+    FST_PT_NONE          = 0,
+    FST_PT_UNPACKED      = 1,
+    FST_PT_PACKED        = 2,
+    FST_PT_TAGGED_PACKED = 3,
+
+    FST_PT_MAX           = 3
+};
+
+enum fstSupplementalVarType {
+    FST_SVT_MIN                    = 0,
+
+    FST_SVT_NONE                   = 0,
+
+    FST_SVT_VHDL_SIGNAL            = 1,
+    FST_SVT_VHDL_VARIABLE          = 2,
+    FST_SVT_VHDL_CONSTANT          = 3,
+    FST_SVT_VHDL_FILE              = 4,
+    FST_SVT_VHDL_MEMORY            = 5,
+
+    FST_SVT_MAX                    = 5
+};
+
+enum fstSupplementalDataType {
+    FST_SDT_MIN                    = 0,
+
+    FST_SDT_NONE                   = 0,
+
+    FST_SDT_VHDL_BOOLEAN           = 1,
+    FST_SDT_VHDL_BIT               = 2,
+    FST_SDT_VHDL_BIT_VECTOR        = 3,
+    FST_SDT_VHDL_STD_ULOGIC        = 4,
+    FST_SDT_VHDL_STD_ULOGIC_VECTOR = 5,
+    FST_SDT_VHDL_STD_LOGIC         = 6,
+    FST_SDT_VHDL_STD_LOGIC_VECTOR  = 7,
+    FST_SDT_VHDL_UNSIGNED          = 8,
+    FST_SDT_VHDL_SIGNED            = 9,
+    FST_SDT_VHDL_INTEGER           = 10,
+    FST_SDT_VHDL_REAL              = 11,
+    FST_SDT_VHDL_NATURAL           = 12,
+    FST_SDT_VHDL_POSITIVE          = 13,
+    FST_SDT_VHDL_TIME              = 14,
+    FST_SDT_VHDL_CHARACTER         = 15,
+    FST_SDT_VHDL_STRING            = 16,
+
+    FST_SDT_MAX                    = 16,
+
+    FST_SDT_SVT_SHIFT_COUNT        = 10, /* FST_SVT_* is ORed in by fstWriterCreateVar2() to the left after shifting FST_SDT_SVT_SHIFT_COUNT */
+    FST_SDT_ABS_MAX                = ((1<<(FST_SDT_SVT_SHIFT_COUNT))-1)
+};
+
+
+struct fstHier
+{
+unsigned char htyp;
+
+union {
+        /* if htyp == FST_HT_SCOPE */
+        struct fstHierScope {
+                unsigned char typ; /* FST_ST_MIN ... FST_ST_MAX */
+                const char *name;
+                const char *component;
+                uint32_t name_length;           /* strlen(u.scope.name) */
+                uint32_t component_length;      /* strlen(u.scope.component) */
+                } scope;
+
+        /* if htyp == FST_HT_VAR */
+        struct fstHierVar {
+                unsigned char typ; /* FST_VT_MIN ... FST_VT_MAX */
+                unsigned char direction; /* FST_VD_MIN ... FST_VD_MAX */
+                unsigned char svt_workspace; /* zeroed out by FST reader, for client code use */
+                unsigned char sdt_workspace; /* zeroed out by FST reader, for client code use */
+                unsigned int  sxt_workspace; /* zeroed out by FST reader, for client code use */
+                const char *name;
+                uint32_t length;
+                fstHandle handle;
+                uint32_t name_length; /* strlen(u.var.name) */
+                unsigned is_alias : 1;
+                } var;
+
+        /* if htyp == FST_HT_ATTRBEGIN */
+        struct fstHierAttr {
+                unsigned char typ; /* FST_AT_MIN ... FST_AT_MAX */
+                unsigned char subtype; /* from fstMiscType, fstArrayType, fstEnumValueType, fstPackType */
+                const char *name;
+                uint64_t arg; /* number of array elements, struct members, or some other payload (possibly ignored) */
+                uint64_t arg_from_name; /* for when name is overloaded as a variable-length integer (FST_AT_MISC + FST_MT_SOURCESTEM) */
+                uint32_t name_length; /* strlen(u.attr.name) */
+                } attr;
+        } u;
+};
+
+
+struct 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);
+                /* future expansion for VHDL and other languages.  The variable type, data type, etc map onto
+                   the current Verilog/SV one.  The "type" string is optional for a more verbose or custom description */
+fstHandle       fstWriterCreateVar2(void *ctx, enum fstVarType vt, enum fstVarDir vd,
+                        uint32_t len, const char *nam, fstHandle aliasHandle,
+                        const char *type, enum fstSupplementalVarType svt, enum fstSupplementalDataType sdt);
+void            fstWriterEmitDumpActive(void *ctx, int enable);
+void 		fstWriterEmitEnumTableRef(void *ctx, fstEnumHandle handle);
+void            fstWriterEmitValueChange(void *ctx, fstHandle handle, const void *val);
+void            fstWriterEmitVariableLengthValueChange(void *ctx, fstHandle handle, const void *val, uint32_t len);
+void            fstWriterEmitTimeChange(void *ctx, uint64_t tim);
+void            fstWriterFlushContext(void *ctx);
+int             fstWriterGetDumpSizeLimitReached(void *ctx);
+int             fstWriterGetFseekFailed(void *ctx);
+void            fstWriterSetAttrBegin(void *ctx, enum fstAttrType attrtype, int subtype,
+                        const char *attrname, uint64_t arg);
+void            fstWriterSetAttrEnd(void *ctx);
+void            fstWriterSetComment(void *ctx, const char *comm);
+void            fstWriterSetDate(void *ctx, const char *dat);
+void            fstWriterSetDumpSizeLimit(void *ctx, uint64_t numbytes);
+void            fstWriterSetEnvVar(void *ctx, const char *envvar);
+void            fstWriterSetFileType(void *ctx, enum fstFileType filetype);
+void            fstWriterSetPackType(void *ctx, enum fstWriterPackType typ);
+void            fstWriterSetParallelMode(void *ctx, int enable);
+void            fstWriterSetRepackOnClose(void *ctx, int enable);       /* type = 0 (none), 1 (libz) */
+void            fstWriterSetScope(void *ctx, enum fstScopeType scopetype,
+                        const char *scopename, const char *scopecomp);
+void            fstWriterSetSourceInstantiationStem(void *ctx, const char *path, unsigned int line, unsigned int use_realpath);
+void            fstWriterSetSourceStem(void *ctx, const char *path, unsigned int line, unsigned int use_realpath);
+void            fstWriterSetTimescale(void *ctx, int ts);
+void            fstWriterSetTimescaleFromString(void *ctx, const char *s);
+void            fstWriterSetTimezero(void *ctx, int64_t tim);
+void            fstWriterSetUpscope(void *ctx);
+void		fstWriterSetValueList(void *ctx, const char *vl);
+void            fstWriterSetVersion(void *ctx, const char *vers);
+
+
+/*
+ * reader functions
+ */
+void            fstReaderClose(void *ctx);
+void            fstReaderClrFacProcessMask(void *ctx, fstHandle facidx);
+void            fstReaderClrFacProcessMaskAll(void *ctx);
+uint64_t        fstReaderGetAliasCount(void *ctx);
+const char *    fstReaderGetCurrentFlatScope(void *ctx);
+void *          fstReaderGetCurrentScopeUserInfo(void *ctx);
+int             fstReaderGetCurrentScopeLen(void *ctx);
+const char *    fstReaderGetDateString(void *ctx);
+int             fstReaderGetDoubleEndianMatchState(void *ctx);
+uint64_t        fstReaderGetDumpActivityChangeTime(void *ctx, uint32_t idx);
+unsigned char   fstReaderGetDumpActivityChangeValue(void *ctx, uint32_t idx);
+uint64_t        fstReaderGetEndTime(void *ctx);
+int             fstReaderGetFacProcessMask(void *ctx, fstHandle facidx);
+int             fstReaderGetFileType(void *ctx);
+int             fstReaderGetFseekFailed(void *ctx);
+fstHandle       fstReaderGetMaxHandle(void *ctx);
+uint64_t        fstReaderGetMemoryUsedByWriter(void *ctx);
+uint32_t        fstReaderGetNumberDumpActivityChanges(void *ctx);
+uint64_t        fstReaderGetScopeCount(void *ctx);
+uint64_t        fstReaderGetStartTime(void *ctx);
+signed char     fstReaderGetTimescale(void *ctx);
+int64_t         fstReaderGetTimezero(void *ctx);
+uint64_t        fstReaderGetValueChangeSectionCount(void *ctx);
+char *          fstReaderGetValueFromHandleAtTime(void *ctx, uint64_t tim, fstHandle facidx, char *buf);
+uint64_t        fstReaderGetVarCount(void *ctx);
+const char *    fstReaderGetVersionString(void *ctx);
+struct fstHier *fstReaderIterateHier(void *ctx);
+int             fstReaderIterateHierRewind(void *ctx);
+int             fstReaderIterBlocks(void *ctx,
+                        void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value),
+                        void *user_callback_data_pointer, FILE *vcdhandle);
+int             fstReaderIterBlocks2(void *ctx,
+                        void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value),
+                        void (*value_change_callback_varlen)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value, uint32_t len),
+                        void *user_callback_data_pointer, FILE *vcdhandle);
+void            fstReaderIterBlocksSetNativeDoublesOnCallback(void *ctx, int enable);
+void *          fstReaderOpen(const char *nam);
+void *          fstReaderOpenForUtilitiesOnly(void);
+const char *    fstReaderPopScope(void *ctx);
+int             fstReaderProcessHier(void *ctx, FILE *vcdhandle);
+const char *    fstReaderPushScope(void *ctx, const char *nam, void *user_info);
+void            fstReaderResetScope(void *ctx);
+void            fstReaderSetFacProcessMask(void *ctx, fstHandle facidx);
+void            fstReaderSetFacProcessMaskAll(void *ctx);
+void            fstReaderSetLimitTimeRange(void *ctx, uint64_t start_time, uint64_t end_time);
+void            fstReaderSetUnlimitedTimeRange(void *ctx);
+void            fstReaderSetVcdExtensions(void *ctx, int enable);
+
+
+/*
+ * utility functions
+ */
+int             fstUtilityBinToEscConvertedLen(const unsigned char *s, int len); /* used for mallocs for fstUtilityBinToEsc() */
+int             fstUtilityBinToEsc(unsigned char *d, const unsigned char *s, int len);
+int             fstUtilityEscToBin(unsigned char *d, unsigned char *s, int len);
+struct fstETab *fstUtilityExtractEnumTableFromString(const char *s);
+void 		fstUtilityFreeEnumTable(struct fstETab *etab); /* must use to free fstETab properly */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -24,9 +24,10 @@
 #pragma alloca
 #endif

-#include "lxt2_config.h"
+#include "fst_config.h"
 #include "lxt2_write.h"

+
 static char *lxt2_wr_vcd_truncate_bitvec(char *s)
 {
 char l, r;
@@ -96,7 +97,7 @@ if (lo<hi)

 static void wave_msort(struct lxt2_wr_symbol **a, int num)
 {
-struct lxt2_wr_symbol **b = (lxt2_wr_symbol**)malloc(((num/2)+1) * sizeof(struct lxt2_wr_symbol *));
+struct lxt2_wr_symbol **b = (struct lxt2_wr_symbol**)malloc(((num/2)+1) * sizeof(struct lxt2_wr_symbol *));

 wave_mergesort(a, b, 0, num-1);

@@ -582,7 +583,7 @@ unsigned int i;
 if((lt)&&(lt->numfacs))
 	{
 	struct lxt2_wr_symbol *s = lt->symchain;
-	struct lxt2_wr_symbol **aliascache = (lxt2_wr_symbol**)calloc(lt->numalias ? lt->numalias : 1, sizeof(struct lxt2_wr_symbol *));
+	struct lxt2_wr_symbol **aliascache = (struct lxt2_wr_symbol**)calloc(lt->numalias ? lt->numalias : 1, sizeof(struct lxt2_wr_symbol *));
 	unsigned int aliases_encountered, facs_encountered;

 	lt->sorted_facs = (struct lxt2_wr_symbol **)calloc(lt->numfacs, sizeof(struct lxt2_wr_symbol *));
@@ -2100,7 +2101,7 @@ if((lt)&&(lt->blackout))
                {
                if((!(s->flags&LXT2_WR_SYM_F_ALIAS))&&(s->rows<2))
                        {
-			char tmp[16]; // To get rid of the warning
+			char tmp[16]; /* To get rid of the warning */
 			if(!(s->flags&(LXT2_WR_SYM_F_DOUBLE|LXT2_WR_SYM_F_STRING)))
 				{
 	                        strcpy(tmp, "x");
@@ -0,0 +1,360 @@
+/*
+   LZ4 - Fast LZ compression algorithm
+   Header File
+   Copyright (C) 2011-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - LZ4 source repository : https://github.com/Cyan4973/lz4
+   - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+#pragma once
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*
+ * lz4.h provides block compression functions, and gives full buffer control to programmer.
+ * If you need to generate inter-operable compressed data (respecting LZ4 frame specification),
+ * and can let the library handle its own memory, please use lz4frame.h instead.
+*/
+
+/**************************************
+*  Version
+**************************************/
+#define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
+#define LZ4_VERSION_MINOR    7    /* for new (non-breaking) interface capabilities */
+#define LZ4_VERSION_RELEASE  1    /* for tweaks, bug-fixes, or development */
+#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
+int LZ4_versionNumber (void);
+
+/**************************************
+*  Tuning parameter
+**************************************/
+/*
+ * LZ4_MEMORY_USAGE :
+ * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+ * Increasing memory usage improves compression ratio
+ * Reduced memory usage can improve speed, due to cache effect
+ * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
+ */
+#define LZ4_MEMORY_USAGE 14
+
+
+/**************************************
+*  Simple Functions
+**************************************/
+
+int LZ4_compress_default(const char* source, char* dest, int sourceSize, int maxDestSize);
+int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize);
+
+/*
+LZ4_compress_default() :
+    Compresses 'sourceSize' bytes from buffer 'source'
+    into already allocated 'dest' buffer of size 'maxDestSize'.
+    Compression is guaranteed to succeed if 'maxDestSize' >= LZ4_compressBound(sourceSize).
+    It also runs faster, so it's a recommended setting.
+    If the function cannot compress 'source' into a more limited 'dest' budget,
+    compression stops *immediately*, and the function result is zero.
+    As a consequence, 'dest' content is not valid.
+    This function never writes outside 'dest' buffer, nor read outside 'source' buffer.
+        sourceSize  : Max supported value is LZ4_MAX_INPUT_VALUE
+        maxDestSize : full or partial size of buffer 'dest' (which must be already allocated)
+        return : the number of bytes written into buffer 'dest' (necessarily <= maxOutputSize)
+              or 0 if compression fails
+
+LZ4_decompress_safe() :
+    compressedSize : is the precise full size of the compressed block.
+    maxDecompressedSize : is the size of destination buffer, which must be already allocated.
+    return : the number of bytes decompressed into destination buffer (necessarily <= maxDecompressedSize)
+             If destination buffer is not large enough, decoding will stop and output an error code (<0).
+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
+             This function is protected against buffer overflow exploits, including malicious data packets.
+             It never writes outside output buffer, nor reads outside input buffer.
+*/
+
+
+/**************************************
+*  Advanced Functions
+**************************************/
+#define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
+#define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
+
+/*
+LZ4_compressBound() :
+    Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
+    This function is primarily useful for memory allocation purposes (destination buffer size).
+    Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
+    Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
+        inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
+        return : maximum output size in a "worst case" scenario
+              or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
+*/
+int LZ4_compressBound(int inputSize);
+
+/*
+LZ4_compress_fast() :
+    Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
+    The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
+    It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
+    An acceleration value of "1" is the same as regular LZ4_compress_default()
+    Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
+*/
+int LZ4_compress_fast (const char* source, char* dest, int sourceSize, int maxDestSize, int acceleration);
+
+
+/*
+LZ4_compress_fast_extState() :
+    Same compression function, just using an externally allocated memory space to store compression state.
+    Use LZ4_sizeofState() to know how much memory must be allocated,
+    and allocate it on 8-bytes boundaries (using malloc() typically).
+    Then, provide it as 'void* state' to compression function.
+*/
+int LZ4_sizeofState(void);
+int LZ4_compress_fast_extState (void* state, const char* source, char* dest, int inputSize, int maxDestSize, int acceleration);
+
+
+/*
+LZ4_compress_destSize() :
+    Reverse the logic, by compressing as much data as possible from 'source' buffer
+    into already allocated buffer 'dest' of size 'targetDestSize'.
+    This function either compresses the entire 'source' content into 'dest' if it's large enough,
+    or fill 'dest' buffer completely with as much data as possible from 'source'.
+        *sourceSizePtr : will be modified to indicate how many bytes where read from 'source' to fill 'dest'.
+                         New value is necessarily <= old value.
+        return : Nb bytes written into 'dest' (necessarily <= targetDestSize)
+              or 0 if compression fails
+*/
+int LZ4_compress_destSize (const char* source, char* dest, int* sourceSizePtr, int targetDestSize);
+
+
+/*
+LZ4_decompress_fast() :
+    originalSize : is the original and therefore uncompressed size
+    return : the number of bytes read from the source buffer (in other words, the compressed size)
+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
+             Destination buffer must be already allocated. Its size must be a minimum of 'originalSize' bytes.
+    note : This function fully respect memory boundaries for properly formed compressed data.
+           It is a bit faster than LZ4_decompress_safe().
+           However, it does not provide any protection against intentionally modified data stream (malicious input).
+           Use this function in trusted environment only (data to decode comes from a trusted source).
+*/
+int LZ4_decompress_fast (const char* source, char* dest, int originalSize);
+
+/*
+LZ4_decompress_safe_partial() :
+    This function decompress a compressed block of size 'compressedSize' at position 'source'
+    into destination buffer 'dest' of size 'maxDecompressedSize'.
+    The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached,
+    reducing decompression time.
+    return : the number of bytes decoded in the destination buffer (necessarily <= maxDecompressedSize)
+       Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller.
+             Always control how many bytes were decoded.
+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
+             This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
+*/
+int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize);
+
+
+/***********************************************
+*  Streaming Compression Functions
+***********************************************/
+#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
+#define LZ4_STREAMSIZE     (LZ4_STREAMSIZE_U64 * sizeof(long long))
+/*
+ * LZ4_stream_t
+ * information structure to track an LZ4 stream.
+ * important : init this structure content before first use !
+ * note : only allocated directly the structure if you are statically linking LZ4
+ *        If you are using liblz4 as a DLL, please use below construction methods instead.
+ */
+typedef struct { long long table[LZ4_STREAMSIZE_U64]; } LZ4_stream_t;
+
+/*
+ * LZ4_resetStream
+ * Use this function to init an allocated LZ4_stream_t structure
+ */
+void LZ4_resetStream (LZ4_stream_t* streamPtr);
+
+/*
+ * LZ4_createStream will allocate and initialize an LZ4_stream_t structure
+ * LZ4_freeStream releases its memory.
+ * In the context of a DLL (liblz4), please use these methods rather than the static struct.
+ * They are more future proof, in case of a change of LZ4_stream_t size.
+ */
+LZ4_stream_t* LZ4_createStream(void);
+int           LZ4_freeStream (LZ4_stream_t* streamPtr);
+
+/*
+ * LZ4_loadDict
+ * Use this function to load a static dictionary into LZ4_stream.
+ * Any previous data will be forgotten, only 'dictionary' will remain in memory.
+ * Loading a size of 0 is allowed.
+ * Return : dictionary size, in bytes (necessarily <= 64 KB)
+ */
+int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
+
+/*
+ * LZ4_compress_fast_continue
+ * Compress buffer content 'src', using data from previously compressed blocks as dictionary to improve compression ratio.
+ * Important : Previous data blocks are assumed to still be present and unmodified !
+ * 'dst' buffer must be already allocated.
+ * If maxDstSize >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
+ * If not, and if compressed data cannot fit into 'dst' buffer size, compression stops, and function returns a zero.
+ */
+int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int maxDstSize, int acceleration);
+
+/*
+ * LZ4_saveDict
+ * If previously compressed data block is not guaranteed to remain available at its memory location
+ * save it into a safer place (char* safeBuffer)
+ * Note : you don't need to call LZ4_loadDict() afterwards,
+ *        dictionary is immediately usable, you can therefore call LZ4_compress_fast_continue()
+ * Return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error
+ */
+int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int dictSize);
+
+
+/************************************************
+*  Streaming Decompression Functions
+************************************************/
+
+#define LZ4_STREAMDECODESIZE_U64  4
+#define LZ4_STREAMDECODESIZE     (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
+typedef struct { unsigned long long table[LZ4_STREAMDECODESIZE_U64]; } LZ4_streamDecode_t;
+/*
+ * LZ4_streamDecode_t
+ * information structure to track an LZ4 stream.
+ * init this structure content using LZ4_setStreamDecode or memset() before first use !
+ *
+ * In the context of a DLL (liblz4) please prefer usage of construction methods below.
+ * They are more future proof, in case of a change of LZ4_streamDecode_t size in the future.
+ * LZ4_createStreamDecode will allocate and initialize an LZ4_streamDecode_t structure
+ * LZ4_freeStreamDecode releases its memory.
+ */
+LZ4_streamDecode_t* LZ4_createStreamDecode(void);
+int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
+
+/*
+ * LZ4_setStreamDecode
+ * Use this function to instruct where to find the dictionary.
+ * Setting a size of 0 is allowed (same effect as reset).
+ * Return : 1 if OK, 0 if error
+ */
+int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
+
+/*
+*_continue() :
+    These decoding functions allow decompression of multiple blocks in "streaming" mode.
+    Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB)
+    In the case of a ring buffers, decoding buffer must be either :
+    - Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
+      In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
+    - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
+      maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block.
+      In which case, encoding and decoding buffers do not need to be synchronized,
+      and encoding ring buffer can have any size, including small ones ( < 64 KB).
+    - _At least_ 64 KB + 8 bytes + maxBlockSize.
+      In which case, encoding and decoding buffers do not need to be synchronized,
+      and encoding ring buffer can have any size, including larger than decoding buffer.
+    Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
+    and indicate where it is saved using LZ4_setStreamDecode()
+*/
+int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxDecompressedSize);
+int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize);
+
+
+/*
+Advanced decoding functions :
+*_usingDict() :
+    These decoding functions work the same as
+    a combination of LZ4_setStreamDecode() followed by LZ4_decompress_x_continue()
+    They are stand-alone. They don't need nor update an LZ4_streamDecode_t structure.
+*/
+int LZ4_decompress_safe_usingDict (const char* source, char* dest, int compressedSize, int maxDecompressedSize, const char* dictStart, int dictSize);
+int LZ4_decompress_fast_usingDict (const char* source, char* dest, int originalSize, const char* dictStart, int dictSize);
+
+
+
+/**************************************
+*  Obsolete Functions
+**************************************/
+/* Deprecate Warnings */
+/* Should these warnings messages be a problem,
+   it is generally possible to disable them,
+   with -Wno-deprecated-declarations for gcc
+   or _CRT_SECURE_NO_WARNINGS in Visual for example.
+   You can also define LZ4_DEPRECATE_WARNING_DEFBLOCK. */
+#ifndef LZ4_DEPRECATE_WARNING_DEFBLOCK
+#  define LZ4_DEPRECATE_WARNING_DEFBLOCK
+#  define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#  if (LZ4_GCC_VERSION >= 405) || defined(__clang__)
+#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
+#  elif (LZ4_GCC_VERSION >= 301)
+#    define LZ4_DEPRECATED(message) __attribute__((deprecated))
+#  elif defined(_MSC_VER)
+#    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
+#  else
+#    pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
+#    define LZ4_DEPRECATED(message)
+#  endif
+#endif /* LZ4_DEPRECATE_WARNING_DEFBLOCK */
+
+/* Obsolete compression functions */
+/* These functions are planned to start generate warnings by r131 approximately */
+int LZ4_compress               (const char* source, char* dest, int sourceSize);
+int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
+int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
+int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
+int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
+int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
+
+/* Obsolete decompression functions */
+/* These function names are completely deprecated and must no longer be used.
+   They are only provided here for compatibility with older programs.
+    - LZ4_uncompress is the same as LZ4_decompress_fast
+    - LZ4_uncompress_unknownOutputSize is the same as LZ4_decompress_safe
+   These function prototypes are now disabled; uncomment them only if you really need them.
+   It is highly recommended to stop using these prototypes and migrate to maintained ones */
+/* int LZ4_uncompress (const char* source, char* dest, int outputSize); */
+/* int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize); */
+
+/* Obsolete streaming functions; use new streaming interface whenever possible */
+LZ4_DEPRECATED("use LZ4_createStream() instead") void* LZ4_create (char* inputBuffer);
+LZ4_DEPRECATED("use LZ4_createStream() instead") int   LZ4_sizeofStreamState(void);
+LZ4_DEPRECATED("use LZ4_resetStream() instead")  int   LZ4_resetStreamState(void* state, char* inputBuffer);
+LZ4_DEPRECATED("use LZ4_saveDict() instead")     char* LZ4_slideInputBuffer (void* state);
+
+/* Obsolete streaming decoding functions */
+LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
+LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
+
+
+#if defined (__cplusplus)
+}
+#endif
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 1999 Tony Bybell.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef WAVE_ALLOCA_H
+#define WAVE_ALLOCA_H
+#include <stdlib.h>
+#ifdef HAVE_ALLOCA_H
+#include <alloca.h>
+#elif defined(__GNUC__)
+#ifndef __MINGW32__
+#ifndef alloca
+#define alloca __builtin_alloca
+#endif
+#else
+#include <malloc.h>
+#endif
+#elif defined(_MSC_VER)
+#include <malloc.h>
+#define alloca _alloca
+#endif
+#define wave_alloca alloca
+#endif
+
@@ -1,29 +0,0 @@
-/*
- * Copyright (c) Tony Bybell 1999.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- */
-
-#ifndef WAVE_ALLOCA_H
-#define WAVE_ALLOCA_H
-#include <stdlib.h>
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#elif defined(__GNUC__)
-#ifndef __MINGW32__
-#ifndef alloca
-#define alloca __builtin_alloca
-#endif
-#else
-#include <malloc.h>
-#endif
-#elif defined(_MSC_VER)
-#include <malloc.h>
-#define alloca _alloca
-#endif
-#define wave_alloca alloca
-#endif
-
@@ -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

@@ -32,7 +37,7 @@
 # include <direct.h>  // mkdir
 #endif

-#define VL_VALUE_STRING_MAX_WIDTH 8192	///< Max static char array for VL_VALUE_STRING
+#define VL_VALUE_STRING_MAX_WIDTH 8192  ///< Max static char array for VL_VALUE_STRING

 //===========================================================================
 // Global variables
@@ -53,7 +58,7 @@ VerilatedImp VerilatedImp::s_s;
 //===========================================================================
 // User definable functions

-#ifndef VL_USER_FINISH		// Define this to override this function
+#ifndef VL_USER_FINISH  ///< Define this to override this function
 void vl_finish(const char* filename, int linenum, const char* hier) VL_MT_UNSAFE {
    if (0 && hier) {}
    VL_PRINTF("- %s:%d: Verilog $finish\n", filename, linenum);  // Not VL_PRINTF_MT, already on main thread
@@ -66,7 +71,7 @@ void vl_finish(const char* filename, int linenum, const char* hier) VL_MT_UNSAFE
 }
 #endif

-#ifndef VL_USER_STOP		// Define this to override this function
+#ifndef VL_USER_STOP  ///< Define this to override this function
 void vl_stop(const char* filename, int linenum, const char* hier) VL_MT_UNSAFE {
    Verilated::gotFinish(true);
    Verilated::flushCall();
@@ -74,7 +79,7 @@ void vl_stop(const char* filename, int linenum, const char* hier) VL_MT_UNSAFE {
 }
 #endif

-#ifndef VL_USER_FATAL	// Define this to override this function
+#ifndef VL_USER_FATAL  ///< Define this to override this function
 void vl_fatal(const char* filename, int linenum, const char* hier, const char* msg) VL_MT_UNSAFE {
    if (0 && hier) {}
    Verilated::gotFinish(true);
@@ -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;
@@ -155,7 +158,7 @@ vluint64_t _vl_dbg_sequence_number() VL_MT_SAFE {
 vluint32_t VL_THREAD_ID() VL_MT_SAFE {
 #ifdef VL_THREADED
    // Alternative is to use std::this_thread::get_id, but that returns a hard-to-read number and is very slow
-    static std::atomic<vluint32_t> s_nextId (0);
+    static std::atomic<vluint32_t> s_nextId(0);
    static VL_THREAD_LOCAL vluint32_t t_myId = ++s_nextId;
    return t_myId;
 #else
@@ -199,7 +202,7 @@ Verilated::Serialized::Serialized() {
    s_calcUnusedSigs = false;
    s_gotFinish = false;
    s_assertOn = true;
-    s_fatalOnVpiError = true; // retains old default behaviour
+    s_fatalOnVpiError = true;  // retains old default behaviour
 }

 Verilated::NonSerialized::NonSerialized() {
@@ -234,12 +237,11 @@ vluint64_t vl_rand64() VL_MT_SAFE {
    if (VL_UNLIKELY(!t_seeded)) {
 	t_seeded = true;
 	{
-            long seedval;
 	    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];
@@ -275,8 +277,8 @@ WDataOutP VL_RANDOM_W(int obits, WDataOutP outwp) VL_MT_SAFE {
 IData VL_RAND_RESET_I(int obits) VL_MT_SAFE {
    if (Verilated::randReset()==0) return 0;
    IData data = ~0;
-    if (Verilated::randReset()!=1) {	// if 2, randomize
-	data = VL_RANDOM_I(obits);
+    if (Verilated::randReset()!=1) {  // if 2, randomize
+        data = VL_RANDOM_I(obits);
    }
    if (obits<32) data &= VL_MASK_I(obits);
    return data;
@@ -284,8 +286,8 @@ IData VL_RAND_RESET_I(int obits) VL_MT_SAFE {
 QData VL_RAND_RESET_Q(int obits) VL_MT_SAFE {
    if (Verilated::randReset()==0) return 0;
    QData data = VL_ULL(~0);
-    if (Verilated::randReset()!=1) {	// if 2, randomize
-	data = VL_RANDOM_Q(obits);
+    if (Verilated::randReset()!=1) {  // if 2, randomize
+        data = VL_RANDOM_Q(obits);
    }
    if (obits<64) data &= VL_MASK_Q(obits);
    return data;
@@ -326,10 +328,10 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
    int words = VL_WORDS_I(lbits);
    for (int i=0; i<words; ++i) owp[i]=0;
    // Find MSB and check for zero.
-    int umsbp1 = VL_MOSTSETBITP1_W(words,lwp); // dividend
-    int vmsbp1 = VL_MOSTSETBITP1_W(words,rwp); // divisor
+    int umsbp1 = VL_MOSTSETBITP1_W(words,lwp);  // dividend
+    int vmsbp1 = VL_MOSTSETBITP1_W(words,rwp);  // divisor
    if (VL_UNLIKELY(vmsbp1==0)  // rwp==0 so division by zero.  Return 0.
-	|| VL_UNLIKELY(umsbp1==0)) {	// 0/x so short circuit and return 0
+        || VL_UNLIKELY(umsbp1==0)) {  // 0/x so short circuit and return 0
 	return owp;
    }

@@ -351,8 +353,8 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
    }

    // +1 word as we may shift during normalization
-    vluint32_t un[VL_MULS_MAX_WORDS+1]; // Fixed size, as MSVC++ doesn't allow [words] here
-    vluint32_t vn[VL_MULS_MAX_WORDS+1]; // v normalized
+    vluint32_t un[VL_MULS_MAX_WORDS+1];  // Fixed size, as MSVC++ doesn't allow [words] here
+    vluint32_t vn[VL_MULS_MAX_WORDS+1];  // v normalized

    // Zero for ease of debugging and to save having to zero for shifts
    // Note +1 as loop will use extra word
@@ -399,8 +401,8 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
 	    k = (p >> VL_ULL(32)) - (t >> VL_ULL(32));
 	}
 	t = un[j+vw] - k;
-	un[j+vw] = t;
-	owp[j] = qhat; // Save quotient digit
+        un[j+vw] = t;
+        owp[j] = qhat;  // Save quotient digit

 	if (t < 0) {
 	    // Over subtracted; correct by adding back
@@ -415,14 +417,14 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
 	}
    }

-    if (is_modulus) { // modulus
-	// Need to reverse normalization on copy to output
-	for (int i=0; i<vw; ++i) {
-	    owp[i] = (un[i] >> s) | (shift_mask & (un[i+1] << (32-s)));
-	}
-	for (int i=vw; i<words; ++i) owp[i] = 0;
-	return owp;
-    } else { // division
+    if (is_modulus) {  // modulus
+        // Need to reverse normalization on copy to output
+        for (int i=0; i<vw; ++i) {
+            owp[i] = (un[i] >> s) | (shift_mask & (un[i+1] << (32-s)));
+        }
+        for (int i=vw; i<words; ++i) owp[i] = 0;
+        return owp;
+    } else {  // division
 	return owp;
    }
 }
@@ -432,9 +434,9 @@ WDataOutP VL_POW_WWW(int obits, int, int rbits, WDataOutP owp, WDataInP lwp, WDa
    owp[0] = 1;
    for (int i=1; i < VL_WORDS_I(obits); i++) owp[i] = 0;
    // cppcheck-suppress variableScope
-    WData powstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
-    WData lastpowstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
-    WData lastoutstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    WData powstore[VL_MULS_MAX_WORDS];  // Fixed size, as MSVC++ doesn't allow [words] here
+    WData lastpowstore[VL_MULS_MAX_WORDS];  // Fixed size, as MSVC++ doesn't allow [words] here
+    WData lastoutstore[VL_MULS_MAX_WORDS];  // Fixed size, as MSVC++ doesn't allow [words] here
    // cppcheck-suppress variableScope
    VL_ASSIGN_W(obits, powstore, lwp);
    for (int bit=0; bit<rbits; bit++) {
@@ -471,17 +473,17 @@ WDataOutP VL_POWSS_WWW(int obits, int, int rbits, WDataOutP owp, WDataInP lwp, W
    if (rsign && VL_SIGN_W(rbits, rwp)) {
 	int words = VL_WORDS_I(obits);
 	VL_ZERO_W(obits, owp);
-	IData lor = 0; // 0=all zeros, ~0=all ones, else mix
-	for (int i=1; i < (words-1); ++i) {
-	    lor |= lwp[i];
-	}
-	lor |= ( (lwp[words-1] == VL_MASK_I(rbits)) ? ~VL_UL(0) : 0);
-	if (lor==0 && lwp[0]==0) { return owp; } // "X" so return 0
-	else if (lor==0 && lwp[0]==1) { owp[0] = 1; return owp; } // 1
-	else if (lsign && lor == ~VL_UL(0) && lwp[0]==~VL_UL(0)) {  // -1
-	    if (rwp[0] & 1) { return VL_ALLONES_W(obits, owp); } // -1^odd=-1
-	    else { owp[0] = 1; return owp; } // -1^even=1
-	}
+        IData lor = 0;  // 0=all zeros, ~0=all ones, else mix
+        for (int i=1; i < (words-1); ++i) {
+            lor |= lwp[i];
+        }
+        lor |= ( (lwp[words-1] == VL_MASK_I(rbits)) ? ~VL_UL(0) : 0);
+        if (lor==0 && lwp[0]==0) { return owp; }  // "X" so return 0
+        else if (lor==0 && lwp[0]==1) { owp[0] = 1; return owp; }  // 1
+        else if (lsign && lor == ~VL_UL(0) && lwp[0]==~VL_UL(0)) {  // -1
+            if (rwp[0] & 1) { return VL_ALLONES_W(obits, owp); }  // -1^odd=-1
+            else { owp[0] = 1; return owp; }  // -1^even=1
+        }
 	return 0;
    }
    return VL_POW_WWW(obits, rbits, rbits, owp, lwp, rwp);
@@ -495,12 +497,12 @@ WDataOutP VL_POWSS_WWQ(int obits, int lbits, int rbits,
 QData VL_POWSS_QQW(int obits, int, int rbits, QData lhs, WDataInP rwp, bool lsign, bool rsign) VL_MT_SAFE {
    // Skip check for rhs == 0, as short-circuit doesn't save time
    if (rsign && VL_SIGN_W(rbits, rwp)) {
-	if (lhs==0) return 0;	// "X"
-	else if (lhs==1) return 1;
-	else if (lsign && lhs==VL_MASK_I(obits)) {  // -1
-	    if (rwp[0] & 1) return VL_MASK_I(obits);  // -1^odd=-1
-	    else return 1; // -1^even=1
-	}
+        if (lhs==0) return 0;  // "X"
+        else if (lhs==1) return 1;
+        else if (lsign && lhs==VL_MASK_I(obits)) {  // -1
+            if (rwp[0] & 1) return VL_MASK_I(obits);  // -1^odd=-1
+            else return 1;  // -1^even=1
+        }
 	return 0;
    }
    return VL_POW_QQW(obits, rbits, rbits, lhs, rwp);
@@ -539,7 +541,7 @@ std::string VL_DECIMAL_NW(int width, WDataInP lwp) VL_MT_SAFE {
    }
    std::string output;
    int lsb = (maxdecwidth-1) & ~3;
-    for (; lsb>0; lsb-=4) { // Skip leading zeros
+    for (; lsb>0; lsb-=4) {  // Skip leading zeros
        if (VL_BITRSHIFT_W(bcd, lsb) & 0xf) break;
    }
    for (; lsb>=0; lsb-=4) {
@@ -570,17 +572,17 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
 	    pctp = pos;
 	    inPct = true;
 	    widthSet = false;
-	    width = 0;
-	} else if (!inPct) {   // Normal text
-	    // Fast-forward to next escape and add to output
-	    const char *ep = pos;
-	    while (ep[0] && ep[0]!='%') ep++;
-	    if (ep != pos) {
-		output.append(pos, ep-pos);
-		pos += ep-pos-1;
-	    }
-	} else { // Format character
-	    inPct = false;
+            width = 0;
+        } else if (!inPct) {  // Normal text
+            // Fast-forward to next escape and add to output
+            const char *ep = pos;
+            while (ep[0] && ep[0]!='%') ep++;
+            if (ep != pos) {
+                output.append(pos, ep-pos);
+                pos += ep-pos-1;
+            }
+        } else {  // Format character
+            inPct = false;
 	    char fmt = pos[0];
 	    switch (fmt) {
 	    case '0': case '1': case '2': case '3': case '4':
@@ -595,17 +597,17 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
 	    case '%':
 		output += '%';
 		break;
-	    case 'N': { // "C" string with name of module, add . if needed
-		const char* cstrp = va_arg(ap, const char*);
-		if (VL_LIKELY(*cstrp)) { output += cstrp; output += '.'; }
-		break;
-	    }
-	    case 'S': { // "C" string
-		const char* cstrp = va_arg(ap, const char*);
-		output += cstrp;
-		break;
-	    }
-	    case '@': { // Verilog/C++ string
+            case 'N': {  // "C" string with name of module, add . if needed
+                const char* cstrp = va_arg(ap, const char*);
+                if (VL_LIKELY(*cstrp)) { output += cstrp; output += '.'; }
+                break;
+            }
+            case 'S': {  // "C" string
+                const char* cstrp = va_arg(ap, const char*);
+                output += cstrp;
+                break;
+            }
+            case '@': {  // Verilog/C++ string
 		va_arg(ap, int);  // # bits is ignored
 		const std::string* cstrp = va_arg(ap, const std::string*);
 		output += *cstrp;
@@ -647,12 +649,12 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
 		}
 		case 's':
 		    for (; lsb>=0; --lsb) {
-			lsb = (lsb / 8) * 8; // Next digit
-			IData charval = VL_BITRSHIFT_W(lwp, lsb) & 0xff;
-			output += (charval==0)?' ':charval;
-		    }
-		    break;
-		case 'd': { // Signed decimal
+                        lsb = (lsb / 8) * 8;  // Next digit
+                        IData charval = VL_BITRSHIFT_W(lwp, lsb) & 0xff;
+                        output += (charval==0)?' ':charval;
+                    }
+                    break;
+                case 'd': {  // Signed decimal
                    int digits;
                    std::string append;
                    if (lbits <= VL_QUADSIZE) {
@@ -671,16 +673,16 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
                    }
 		    int needmore = width-digits;
 		    if (needmore>0) {
-			if (pctp && pctp[0] && pctp[1]=='0') { //%0
-			    output.append(needmore,'0'); // Pre-pad zero
-			} else {
-			    output.append(needmore,' '); // Pre-pad spaces
-			}
-		    }
-		    output += append;
-		    break;
-		}
-		case '#': { // Unsigned decimal
+                        if (pctp && pctp[0] && pctp[1]=='0') {  // %0
+                            output.append(needmore, '0');  // Pre-pad zero
+                        } else {
+                            output.append(needmore, ' ');  // Pre-pad spaces
+                        }
+                    }
+                    output += append;
+                    break;
+                }
+                case '#': {  // Unsigned decimal
                    int digits;
                    std::string append;
                    if (lbits <= VL_QUADSIZE) {
@@ -692,16 +694,16 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
                    }
 		    int needmore = width-digits;
 		    if (needmore>0) {
-			if (pctp && pctp[0] && pctp[1]=='0') { //%0
-			    output.append(needmore,'0'); // Pre-pad zero
-			} else {
-			    output.append(needmore,' '); // Pre-pad spaces
-			}
-		    }
-		    output += append;
-		    break;
-		}
-		case 't': { // Time
+                        if (pctp && pctp[0] && pctp[1]=='0') {  // %0
+                            output.append(needmore, '0');  // Pre-pad zero
+                        } else {
+                            output.append(needmore, ' ');  // Pre-pad spaces
+                        }
+                    }
+                    output += append;
+                    break;
+                }
+                case 't': {  // Time
 		    int digits;
 		    if (VL_TIME_MULTIPLIER==1) {
 			digits=sprintf(tmp,"%" VL_PRI64 "u",ld);
@@ -712,9 +714,9 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
 		    } else {
 			VL_FATAL_MT(__FILE__,__LINE__,"","Unsupported VL_TIME_MULTIPLIER");
 		    }
-		    int needmore = width-digits;
-		    if (needmore>0) output.append(needmore,' '); // Pre-pad spaces
-		    output += tmp;
+                    int needmore = width-digits;
+                    if (needmore>0) output.append(needmore, ' ');  // Pre-pad spaces
+                    output += tmp;
 		    break;
 		}
 		case 'b':
@@ -723,9 +725,9 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
 		    }
 		    break;
 		case 'o':
-		    for (; lsb>=0; --lsb) {
-			lsb = (lsb / 3) * 3; // Next digit
-			// Octal numbers may span more than one wide word,
+                    for (; lsb>=0; --lsb) {
+                        lsb = (lsb / 3) * 3;  // Next digit
+                        // Octal numbers may span more than one wide word,
 			// so we need to grab each bit separately and check for overrun
 			// Octal is rare, so we'll do it a slow simple way
 			output += ('0'
@@ -750,19 +752,19 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
                        output += static_cast<char>((lwp[i] >> 8) & 0xff);
                        output += static_cast<char>((lwp[i] >> 16) & 0xff);
                        output += static_cast<char>((lwp[i] >> 24) & 0xff);
-                        output += "\0\0\0\0"; // No tristate
-		    }
-		    break;
-		case 'v': // Strength; assume always strong
-		    for (lsb=lbits-1; lsb>=0; --lsb) {
+                        output += "\0\0\0\0";  // No tristate
+                    }
+                    break;
+                case 'v':  // Strength; assume always strong
+                    for (lsb=lbits-1; lsb>=0; --lsb) {
                        if (VL_BITRSHIFT_W(lwp, lsb) & 1) output += "St1 ";
                        else output += "St0 ";
-		    }
-		    break;
-		case 'x':
-		    for (; lsb>=0; --lsb) {
-			lsb = (lsb / 4) * 4; // Next digit
-			IData charval = VL_BITRSHIFT_W(lwp, lsb) & 0xf;
+                    }
+                    break;
+                case 'x':
+                    for (; lsb>=0; --lsb) {
+                        lsb = (lsb / 4) * 4;  // Next digit
+                        IData charval = VL_BITRSHIFT_W(lwp, lsb) & 0xf;
 			output += "0123456789abcdef"[charval];
 		    }
 		    break;
@@ -770,10 +772,10 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
 		    std::string msg = std::string("Unknown _vl_vsformat code: ")+pos[0];
 		    VL_FATAL_MT(__FILE__,__LINE__,"",msg.c_str());
 		    break;
-		} // switch
-	    }
-	    } // switch
-	}
+                }  // switch
+            }
+            }  // switch
+        }
    }
 }

@@ -793,9 +795,9 @@ static inline int  _vl_vsss_peek(FILE* fp, int& floc, WDataInP fromp, const std:
 	ungetc(data,fp);
 	return data;
    } else {
-	if (floc < 0) return EOF;
-	floc = floc & ~7;	// Align to closest character
-	if (fromp == NULL) {
+        if (floc < 0) return EOF;
+        floc = floc & ~7;  // Align to closest character
+        if (fromp == NULL) {
 	    return fstr[fstr.length()-1 - (floc>>3)];
 	} else {
            return VL_BITRSHIFT_W(fromp, floc) & 0xff;
@@ -816,9 +818,9 @@ static inline void _vl_vsss_read(FILE* fp, int& floc, WDataInP fromp, const std:
    while (1) {
 	int c = _vl_vsss_peek(fp, floc, fromp, fstr);
 	if (c==EOF || isspace(c)) break;
-	if (acceptp!=NULL // String - allow anything
-	    && NULL==strchr(acceptp, c)) break;
-	if (acceptp!=NULL) c = tolower(c); // Non-strings we'll simplify
+        if (acceptp  // String - allow anything
+            && NULL==strchr(acceptp, c)) break;
+        if (acceptp) c = tolower(c);  // Non-strings we'll simplify
 	*cp++ = c;
 	_vl_vsss_advance(fp, floc);
    }
@@ -835,9 +837,9 @@ static inline void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2,
    // Read in base "2^^baseLog2" digits from strp[posstart..posend-1] into owp of size obits.
    int lsb = 0;
    for (int i=0, pos=static_cast<int>(posend)-1; i<obits && pos>=static_cast<int>(posstart); --pos) {
-	switch (tolower (strp[pos])) {
-	case 'x': case 'z': case '?': //FALLTHRU
-	case '0': lsb += baseLog2; break;
+        switch (tolower (strp[pos])) {
+        case 'x': case 'z': case '?':  // FALLTHRU
+        case '0': lsb += baseLog2; break;
 	case '1': _vl_vsss_setbit(owp,obits,lsb, baseLog2,  1); lsb+=baseLog2; break;
 	case '2': _vl_vsss_setbit(owp,obits,lsb, baseLog2,  2); lsb+=baseLog2; break;
 	case '3': _vl_vsss_setbit(owp,obits,lsb, baseLog2,  3); lsb+=baseLog2; break;
@@ -874,15 +876,15 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 	//VL_DBG_MSGF("_vlscan fmt='"<<pos[0]<<"' floc="<<floc<<" file='"<<_vl_vsss_peek(fp,floc,fromp,fstr)<<"'"<<endl);
 	if (!inPct && pos[0]=='%') {
 	    inPct = true;
-	} else if (!inPct && isspace(pos[0])) {   // Format spaces
-	    while (isspace(pos[1])) pos++;
-	    _vl_vsss_skipspace(fp,floc,fromp,fstr);
-	} else if (!inPct) {   // Expected Format
-	    _vl_vsss_skipspace(fp,floc,fromp,fstr);
-	    int c = _vl_vsss_peek(fp,floc,fromp,fstr);
-	    if (c != pos[0]) goto done;
-	    else _vl_vsss_advance(fp,floc);
-	} else { // Format character
+        } else if (!inPct && isspace(pos[0])) {  // Format spaces
+            while (isspace(pos[1])) pos++;
+            _vl_vsss_skipspace(fp,floc,fromp,fstr);
+        } else if (!inPct) {  // Expected Format
+            _vl_vsss_skipspace(fp,floc,fromp,fstr);
+            int c = _vl_vsss_peek(fp,floc,fromp,fstr);
+            if (c != pos[0]) goto done;
+            else _vl_vsss_advance(fp,floc);
+        } else {  // Format character
 	    // Skip loading spaces
 	    inPct = false;
 	    char fmt = pos[0];
@@ -921,9 +923,9 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 			_vl_vsss_setbit(owp,obits,lsb, 8, tmp[lpos]); lsb+=8;
 		    }
 		    break;
-		}
-		case 'd': { // Signed decimal
-		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+                }
+                case 'd': {  // Signed decimal
+                    _vl_vsss_skipspace(fp,floc,fromp,fstr);
 		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "0123456789+-xXzZ?_");
 		    if (!tmp[0]) goto done;
 		    vlsint64_t ld;
@@ -932,9 +934,9 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		    break;
 		}
 		case 'f':
-		case 'e':
-		case 'g': { // Real number
-		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+                case 'e':
+                case 'g': {  // Real number
+                    _vl_vsss_skipspace(fp,floc,fromp,fstr);
 		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "+-.0123456789eE");
 		    if (!tmp[0]) goto done;
 		    // cppcheck-suppress unusedStructMember  // It's used
@@ -943,9 +945,9 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		    VL_SET_WQ(owp,u.ld);
 		    break;
 		}
-		case 't': // FALLTHRU  // Time
-		case '#': { // Unsigned decimal
-		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+                case 't':  // FALLTHRU  // Time
+                case '#': {  // Unsigned decimal
+                    _vl_vsss_skipspace(fp,floc,fromp,fstr);
 		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "0123456789+-xXzZ?_");
 		    if (!tmp[0]) goto done;
 		    QData ld;
@@ -977,8 +979,8 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		default:
 		    std::string msg = std::string("Unknown _vl_vsscanf code: ")+pos[0];
 		    VL_FATAL_MT(__FILE__,__LINE__,"",msg.c_str());
-		    break;
-		} // switch
+                    break;
+                }  // switch

 		got++;
 		// Reload data if non-wide (if wide, we put it in the right place directly)
@@ -992,8 +994,8 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		    QData* p = va_arg(ap,QData*); *p = VL_SET_QW(owp);
 		}
 	    }
-	    } // switch
-	}
+            }  // switch
+        }
    }
  done:
    return got;
@@ -1012,14 +1014,14 @@ void _VL_VINT_TO_STRING(int obits, char* destoutp, WDataInP sourcep) VL_MT_SAFE
    bool start=true;
    char* destp = destoutp;
    for (; lsb>=0; --lsb) {
-	lsb = (lsb / 8) * 8; // Next digit
-	IData charval = VL_BITRSHIFT_W(sourcep, lsb) & 0xff;
-	if (!start || charval) {
-	    *destp++ = (charval==0)?' ':charval;
-	    start = false;	// Drop leading 0s
-	}
+        lsb = (lsb / 8) * 8;  // Next digit
+        IData charval = VL_BITRSHIFT_W(sourcep, lsb) & 0xff;
+        if (!start || charval) {
+            *destp++ = (charval==0)?' ':charval;
+            start = false;  // Drop leading 0s
+        }
    }
-    *destp = '\0'; // Terminate
+    *destp = '\0';  // Terminate
    // Drop trailing spaces
    if (!start) while (isspace(*(destp-1)) && destp>destoutp) *--destp = '\0';
 }
@@ -1241,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) {
@@ -1275,24 +1277,24 @@ const char* memhFormat(int nBits) {
 }

 void VL_WRITEMEM_N(
-    bool      hex,  // Hex format, else binary
-    int     width,  // Width of each array row
-    int     depth,  // Number of rows
+    bool hex,  // Hex format, else binary
+    int width,  // Width of each array row
+    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
+    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;
    }

@@ -1301,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,
@@ -1365,34 +1367,34 @@ 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(
-    bool      hex,  // Hex format, else binary
-    int     width,  // Width of each array row
-    int     depth,  // Number of rows
+    bool hex,  // Hex format, else binary
+    int width,  // Width of each array row
+    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
-    void*    memp,  // Array state
-    IData   start,  // First array row address to read
-    IData     end   // Last row address to read
+    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
@@ -1439,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;
@@ -1469,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");
                        }
                    }
@@ -1477,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;
@@ -1487,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");
    }
 }

@@ -1495,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;
 }

@@ -1516,9 +1519,9 @@ IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rwp) VL_M
    for (const char* posp = ld.c_str(); !done && *posp; ++posp) {
 	if (!inPct && posp[0]=='%') {
 	    inPct = true;
-	} else if (!inPct) {   // Normal text
-	    prefix += *posp;
-	} else { // Format character
+        } else if (!inPct) {  // Normal text
+            prefix += *posp;
+        } else {  // Format character
 	    switch (tolower(*posp)) {
 	    case '%':
 		prefix += *posp;
@@ -1534,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)) {
@@ -1549,18 +1552,18 @@ IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rwp) VL_M
    case 'o':
 	_vl_vsss_based(rwp,rbits, 3, dp, 0, strlen(dp));
 	break;
-    case 'h': //FALLTHRU
+    case 'h':  // FALLTHRU
    case 'x':
-	_vl_vsss_based(rwp,rbits, 4, dp, 0, strlen(dp));
-	break;
-    case 's': // string/no conversion
-	for (int i=0, lsb=0, posp=static_cast<int>(strlen(dp))-1; i<rbits && posp>=0; --posp) {
-	    _vl_vsss_setbit(rwp,rbits,lsb, 8, dp[posp]); lsb+=8;
-	}
-	break;
-    case 'e': //FALLTHRU - Unsupported
-    case 'f': //FALLTHRU - Unsupported
-    case 'g': //FALLTHRU - Unsupported
+        _vl_vsss_based(rwp,rbits, 4, dp, 0, strlen(dp));
+        break;
+    case 's':  // string/no conversion
+        for (int i=0, lsb=0, posp=static_cast<int>(strlen(dp))-1; i<rbits && posp>=0; --posp) {
+            _vl_vsss_setbit(rwp,rbits,lsb, 8, dp[posp]); lsb+=8;
+        }
+        break;
+    case 'e':  // FALLTHRU - Unsupported
+    case 'f':  // FALLTHRU - Unsupported
+    case 'g':  // FALLTHRU - Unsupported
    default:  // Other simulators simply return 0 in these cases and don't error out
 	return 0;
    }
@@ -1574,9 +1577,9 @@ IData VL_VALUEPLUSARGS_INN(int, const std::string& ld, std::string& rdr) VL_MT_S
    for (const char* posp = ld.c_str(); !done && *posp; ++posp) {
 	if (!inPct && posp[0]=='%') {
 	    inPct = true;
-	} else if (!inPct) {   // Normal text
-	    prefix += *posp;
-	} else { // Format character
+        } else if (!inPct) {  // Normal text
+            prefix += *posp;
+        } else {  // Format character
 	    switch (tolower(*posp)) {
 	    case '%':
 		prefix += *posp;
@@ -1590,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;
 }
@@ -1598,9 +1601,9 @@ 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;
-    strncpy(outstr, match.c_str()+strlen(prefixp)+1, // +1 to skip the "+"
-	    VL_VALUE_STRING_MAX_WIDTH);
+    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';
    return outstr;
 }
@@ -1617,13 +1620,13 @@ std::string VL_CVT_PACK_STR_NW(int lwords, WDataInP lwp) VL_MT_SAFE {
    char* destp = destout;
    int len = 0;
    for (; lsb>=0; --lsb) {
-	lsb = (lsb / 8) * 8; // Next digit
-	IData charval = VL_BITRSHIFT_W(lwp, lsb) & 0xff;
-	if (!start || charval) {
-	    *destp++ = (charval==0)?' ':charval;
-	    len++;
-	    start = false;	// Drop leading 0s
-	}
+        lsb = (lsb / 8) * 8;  // Next digit
+        IData charval = VL_BITRSHIFT_W(lwp, lsb) & 0xff;
+        if (!start || charval) {
+            *destp++ = (charval==0)?' ':charval;
+            len++;
+            start = false;  // Drop leading 0s
+        }
    }
    return std::string(destout, len);
 }
@@ -1642,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
@@ -1722,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;
@@ -1732,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;
@@ -1906,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; }
 }

 //======================================================================
@@ -1990,9 +2001,9 @@ void VerilatedScope::exportInsert(int finalize, const char* namep, void* cb) VL_
    } else {
 	if (VL_UNLIKELY(funcnum >= m_funcnumMax)) {
 	    VL_FATAL_MT(__FILE__,__LINE__,"","Internal: Bad funcnum vs. pre-finalize maximum");
-	}
-	if (VL_UNLIKELY(!m_callbacksp)) { // First allocation
-	    m_callbacksp = new void* [m_funcnumMax];
+        }
+        if (VL_UNLIKELY(!m_callbacksp)) {  // First allocation
+            m_callbacksp = new void* [m_funcnumMax];
 	    memset(m_callbacksp, 0, m_funcnumMax*sizeof(void*));
 	}
 	m_callbacksp[funcnum] = cb;
@@ -2006,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);
@@ -26,31 +26,30 @@


 #ifndef _VERILATED_H_
-#define _VERILATED_H_ 1 ///< Header Guard
+#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

-#if VM_TRACE		// Verilator tracing requested
-# define WAVES 1	// Set backward compatibility flag
+#if VM_TRACE  // Verilator tracing requested
+# define WAVES 1  // Set backward compatibility flag
 #endif

 //=========================================================================
@@ -81,6 +80,8 @@ class VerilatedVcd;
 class VerilatedVcdC;
 class VerilatedLxt2;
 class VerilatedLxt2C;
+class VerilatedFst;
+class VerilatedFstC;

 enum VerilatedVarType {
    VLVT_UNKNOWN=0,
@@ -94,15 +95,16 @@ enum VerilatedVarType {
 };

 enum VerilatedVarFlags {
-    VLVD_IN=1,		// == vpiInput
-    VLVD_OUT=2,		// == vpiOutput
-    VLVD_INOUT=3,	// == vpiInOut
-    VLVD_NODIR=5,	// == vpiNoDirection
-    VLVF_MASK_DIR=7,	// Bit mask for above directions
+    VLVD_0 = 0,         // None
+    VLVD_IN = 1,	// == vpiInput
+    VLVD_OUT = 2,	// == vpiOutput
+    VLVD_INOUT = 3,	// == vpiInOut
+    VLVD_NODIR = 5,	// == vpiNoDirection
+    VLVF_MASK_DIR = 7,	// Bit mask for above directions
    // Flags
-    VLVF_PUB_RD=(1<<8),	// Public readable
-    VLVF_PUB_RW=(1<<9),  // Public writable
-    VLVF_DPI_CLAY=(1<<10)  // DPI compatible C standard layout
+    VLVF_PUB_RD = (1<<8),  // Public readable
+    VLVF_PUB_RW = (1<<9),  // Public writable
+    VLVF_DPI_CLAY = (1<<10)  // DPI compatible C standard layout
 };

 //=========================================================================
@@ -156,7 +158,7 @@ class VL_SCOPED_CAPABILITY VerilatedLockGuard {
    }
 };

-#else // !VL_THREADED
+#else  // !VL_THREADED

 /// Empty non-threaded mutex to avoid #ifdefs in consuming code
 class VerilatedMutex {
@@ -173,7 +175,7 @@ public:
    ~VerilatedLockGuard() {}
 };

-#endif // VL_THREADED
+#endif  // VL_THREADED

 /// Remember the calling thread at construction time, and make sure later calls use same thread
 class VerilatedAssertOneThread {
@@ -194,7 +196,7 @@ public:
        }
    }
    static void fatal_different() VL_MT_SAFE;
-#else // !VL_THREADED || !VL_DEBUG
+#else  // !VL_THREADED || !VL_DEBUG
 public:
    void check() {}
 #endif
@@ -206,11 +208,11 @@ public:
 class VerilatedModule {
    VL_UNCOPYABLE(VerilatedModule);
 private:
-    const char*		m_namep;	///< Module name
+    const char* m_namep;  ///< Module name
 public:
-    explicit VerilatedModule(const char* namep);	///< Create module with given hierarchy name
+    explicit VerilatedModule(const char* namep);  ///< Create module with given hierarchy name
    ~VerilatedModule();
-    const char* name() const { return m_namep; }	///< Return name of module
+    const char* name() const { return m_namep; }  ///< Return name of module
 };

 //=========================================================================
@@ -334,9 +336,9 @@ class Verilated {

    static VerilatedVoidCb  s_flushCb;		///< Flush callback function

-    static struct Serialized {   // All these members serialized/deserialized
-	// Fast path
-	int		s_debug;		///< See accessors... only when VL_DEBUG set
+    static struct Serialized {  // All these members serialized/deserialized
+        // Fast path
+        int             s_debug;                ///< See accessors... only when VL_DEBUG set
 	bool		s_calcUnusedSigs;	///< Waves file on, need all signals calculated
 	bool		s_gotFinish;		///< A $finish statement executed
 	bool		s_assertOn;		///< Assertions are enabled
@@ -445,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;
@@ -468,7 +470,7 @@ public:
 public:
    // METHODS - INTERNAL USE ONLY (but public due to what uses it)
    // Internal: Create a new module name by concatenating two strings
-    static const char* catName(const char* n1, const char* n2); // Returns static data
+    static const char* catName(const char* n1, const char* n2);  // Returns static data

    // Internal: Throw signal assertion
    static void overWidthError(const char* signame) VL_MT_SAFE;
@@ -489,7 +491,7 @@ public:
    static int exportFuncNum(const char* namep) VL_MT_SAFE;

    static size_t serializedSize() VL_PURE { return sizeof(s_s); }
-    static void* serializedPtr() VL_MT_UNSAFE { return &s_s; } // Unsafe, for Serialize only
+    static void* serializedPtr() VL_MT_UNSAFE { return &s_s; }  // Unsafe, for Serialize only
 #ifdef VL_THREADED
    /// Set the mtaskId, called when an mtask starts
    static void mtaskId(vluint32_t id) VL_MT_SAFE { t_s.t_mtaskId = id; }
@@ -560,15 +562,15 @@ extern void VL_PRINTF_MT(const char* formatp, ...) VL_ATTR_PRINTF(1) VL_MT_SAFE;
 /// Print a debug message from internals with standard prefix, with printf style format
 extern void VL_DBG_MSGF(const char* formatp, ...) VL_ATTR_PRINTF(1) VL_MT_SAFE;

-extern IData  VL_RANDOM_I(int obits);	///< Randomize a signal
-extern QData  VL_RANDOM_Q(int obits);	///< Randomize a signal
-extern WDataOutP VL_RANDOM_W(int obits, WDataOutP outwp);	///< Randomize a signal
+extern IData  VL_RANDOM_I(int obits);  ///< Randomize a signal
+extern QData  VL_RANDOM_Q(int obits);  ///< Randomize a signal
+extern WDataOutP VL_RANDOM_W(int obits, WDataOutP outwp);  ///< Randomize a signal

 /// Init time only, so slow is fine
-extern IData  VL_RAND_RESET_I(int obits);	///< Random reset a signal
-extern QData  VL_RAND_RESET_Q(int obits);	///< Random reset a signal
-extern WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp);	///< Random reset a signal
-extern WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp);	///< Zero reset a signal (slow - else use VL_ZERO_W)
+extern IData  VL_RAND_RESET_I(int obits);  ///< Random reset a signal
+extern QData  VL_RAND_RESET_Q(int obits);  ///< Random reset a signal
+extern WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp);  ///< Random reset a signal
+extern WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp);  ///< Zero reset a signal (slow - else use VL_ZERO_W)

 #if VL_THREADED
 /// Return high-precision counter for profiling, or 0x0 if not available
@@ -581,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, ...);
@@ -619,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); }

@@ -630,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);
@@ -696,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
@@ -826,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
@@ -858,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
@@ -955,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];
@@ -966,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];
@@ -1188,7 +1191,7 @@ static inline int _VL_CMP_W(int words, WDataInP lwp, WDataInP rwp) VL_MT_SAFE {
 	if (lwp[i] > rwp[i]) return 1;
 	if (lwp[i] < rwp[i]) return -1;
    }
-    return(0); // ==
+    return(0);  // ==
 }

 #define VL_LTS_IWW(obits,lbits,rbbits,lwp,rwp)		(_VL_CMPS_W(lbits,lwp,rwp)<0)
@@ -1199,8 +1202,8 @@ static inline int _VL_CMP_W(int words, WDataInP lwp, WDataInP rwp) VL_MT_SAFE {
 static inline IData VL_GTS_III(int, int lbits, int, IData lhs, IData rhs) VL_PURE {
    // For lbits==32, this becomes just a single instruction, otherwise ~5.
    // GCC 3.3.4 sign extension bugs on AMD64 architecture force us to use quad logic
-    vlsint64_t lhs_signed = VL_EXTENDS_QQ(64, lbits, lhs); //Q for gcc
-    vlsint64_t rhs_signed = VL_EXTENDS_QQ(64, lbits, rhs); //Q for gcc
+    vlsint64_t lhs_signed = VL_EXTENDS_QQ(64, lbits, lhs);  // Q for gcc
+    vlsint64_t rhs_signed = VL_EXTENDS_QQ(64, lbits, rhs);  // Q for gcc
    return lhs_signed > rhs_signed;
 }
 static inline IData VL_GTS_IQQ(int, int lbits, int, QData lhs, QData rhs) VL_PURE {
@@ -1210,8 +1213,8 @@ static inline IData VL_GTS_IQQ(int, int lbits, int, QData lhs, QData rhs) VL_PUR
 }

 static inline IData VL_GTES_III(int, int lbits, int, IData lhs, IData rhs) VL_PURE {
-    vlsint64_t lhs_signed = VL_EXTENDS_QQ(64, lbits, lhs); //Q for gcc
-    vlsint64_t rhs_signed = VL_EXTENDS_QQ(64, lbits, rhs); //Q for gcc
+    vlsint64_t lhs_signed = VL_EXTENDS_QQ(64, lbits, lhs);  // Q for gcc
+    vlsint64_t rhs_signed = VL_EXTENDS_QQ(64, lbits, rhs);  // Q for gcc
    return lhs_signed >= rhs_signed;
 }
 static inline IData VL_GTES_IQQ(int, int lbits, int, QData lhs, QData rhs) VL_PURE {
@@ -1221,8 +1224,8 @@ static inline IData VL_GTES_IQQ(int, int lbits, int, QData lhs, QData rhs) VL_PU
 }

 static inline IData VL_LTS_III(int, int lbits, int, IData lhs, IData rhs) VL_PURE {
-    vlsint64_t lhs_signed = VL_EXTENDS_QQ(64, lbits, lhs); //Q for gcc
-    vlsint64_t rhs_signed = VL_EXTENDS_QQ(64, lbits, rhs); //Q for gcc
+    vlsint64_t lhs_signed = VL_EXTENDS_QQ(64, lbits, lhs);  // Q for gcc
+    vlsint64_t rhs_signed = VL_EXTENDS_QQ(64, lbits, rhs);  // Q for gcc
    return lhs_signed < rhs_signed;
 }
 static inline IData VL_LTS_IQQ(int, int lbits, int, QData lhs, QData rhs) VL_PURE {
@@ -1232,8 +1235,8 @@ static inline IData VL_LTS_IQQ(int, int lbits, int, QData lhs, QData rhs) VL_PUR
 }

 static inline IData VL_LTES_III(int, int lbits, int, IData lhs, IData rhs) VL_PURE {
-    vlsint64_t lhs_signed = VL_EXTENDS_QQ(64, lbits, lhs); //Q for gcc
-    vlsint64_t rhs_signed = VL_EXTENDS_QQ(64, lbits, rhs); //Q for gcc
+    vlsint64_t lhs_signed = VL_EXTENDS_QQ(64, lbits, lhs);  // Q for gcc
+    vlsint64_t rhs_signed = VL_EXTENDS_QQ(64, lbits, rhs);  // Q for gcc
    return lhs_signed <= rhs_signed;
 }
 static inline IData VL_LTES_IQQ(int, int lbits, int, QData lhs, QData rhs) VL_PURE {
@@ -1248,13 +1251,13 @@ static inline int _VL_CMPS_W(int lbits, WDataInP lwp, WDataInP rwp) VL_MT_SAFE {
    // We need to flip sense if negative comparison
    IData lsign = VL_SIGN_I(lbits,lwp[i]);
    IData rsign = VL_SIGN_I(lbits,rwp[i]);
-    if (!lsign && rsign) return  1; // + > -
-    if (lsign && !rsign) return -1; // - < +
+    if (!lsign && rsign) return  1;  // + > -
+    if (lsign && !rsign) return -1;  // - < +
    for (; i>=0; --i) {
-	if (lwp[i] > rwp[i]) return 1;
-	if (lwp[i] < rwp[i]) return -1;
+        if (lwp[i] > rwp[i]) return 1;
+        if (lwp[i] < rwp[i]) return -1;
    }
-    return(0); // ==
+    return(0);  // ==
 }

 //=========================================================================
@@ -1338,26 +1341,26 @@ static inline QData VL_MULS_QQQ(int,int lbits,int, QData lhs,QData rhs) VL_PURE
 static inline WDataOutP VL_MULS_WWW(int,int lbits,int, WDataOutP owp,WDataInP lwp,WDataInP rwp) VL_MT_SAFE {
    int words = VL_WORDS_I(lbits);
    // cppcheck-suppress variableScope
-    WData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    WData lwstore[VL_MULS_MAX_WORDS];  // Fixed size, as MSVC++ doesn't allow [words] here
    // cppcheck-suppress variableScope
    WData rwstore[VL_MULS_MAX_WORDS];
    WDataInP lwusp = lwp;
    WDataInP rwusp = rwp;
    IData lneg = VL_SIGN_I(lbits,lwp[words-1]);
-    if (lneg) { // Negate lhs
-	lwusp = lwstore;
-	VL_NEGATE_W(words, lwstore, lwp);
-	lwstore[words-1] &= VL_MASK_I(lbits);  // Clean it
+    if (lneg) {  // Negate lhs
+        lwusp = lwstore;
+        VL_NEGATE_W(words, lwstore, lwp);
+        lwstore[words-1] &= VL_MASK_I(lbits);  // Clean it
    }
    IData rneg = VL_SIGN_I(lbits,rwp[words-1]);
-    if (rneg) { // Negate rhs
-	rwusp = rwstore;
-	VL_NEGATE_W(words, rwstore, rwp);
-	rwstore[words-1] &= VL_MASK_I(lbits);  // Clean it
+    if (rneg) {  // Negate rhs
+        rwusp = rwstore;
+        VL_NEGATE_W(words, rwstore, rwp);
+        rwstore[words-1] &= VL_MASK_I(lbits);  // Clean it
    }
    VL_MUL_W(words,owp,lwusp,rwusp);
    owp[words-1] &= VL_MASK_I(lbits);  // Clean.  Note it's ok for the multiply to overflow into the sign bit
-    if ((lneg ^ rneg) & 1) {      // Negate output  (not using NEGATE, as owp==lwp)
+    if ((lneg ^ rneg) & 1) {  // Negate output (not using NEGATE, as owp==lwp)
 	QData carry = 0;
 	for (int i=0; i<words; ++i) {
 	    carry = carry + static_cast<QData>(static_cast<IData>(~owp[i]));
@@ -1401,7 +1404,7 @@ static inline WDataOutP VL_DIVS_WWW(int lbits, WDataOutP owp,WDataInP lwp,WDataI
    IData lsign = VL_SIGN_I(lbits,lwp[words-1]);
    IData rsign = VL_SIGN_I(lbits,rwp[words-1]);
    // cppcheck-suppress variableScope
-    WData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    WData lwstore[VL_MULS_MAX_WORDS];  // Fixed size, as MSVC++ doesn't allow [words] here
    // cppcheck-suppress variableScope
    WData rwstore[VL_MULS_MAX_WORDS];
    WDataInP ltup = lwp;
@@ -1422,7 +1425,7 @@ static inline WDataOutP VL_MODDIVS_WWW(int lbits, WDataOutP owp,WDataInP lwp,WDa
    IData lsign = VL_SIGN_I(lbits,lwp[words-1]);
    IData rsign = VL_SIGN_I(lbits,rwp[words-1]);
    // cppcheck-suppress variableScope
-    WData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    WData lwstore[VL_MULS_MAX_WORDS];  // Fixed size, as MSVC++ doesn't allow [words] here
    // cppcheck-suppress variableScope
    WData rwstore[VL_MULS_MAX_WORDS];
    WDataInP ltup = lwp;
@@ -1485,12 +1488,12 @@ static inline IData VL_POWSS_III(int obits, int, int rbits,
                                 IData lhs, IData rhs, bool lsign, bool rsign) VL_MT_SAFE {
    if (VL_UNLIKELY(rhs==0)) return 1;
    if (rsign && VL_SIGN_I(rbits, rhs)) {
-	if (lhs==0) return 0;	// "X"
-	else if (lhs==1) return 1;
-	else if (lsign && lhs==VL_MASK_I(obits)) {  // -1
-	    if (rhs & 1) return VL_MASK_I(obits);  // -1^odd=-1
-	    else return 1; // -1^even=1
-	}
+        if (lhs==0) return 0;  // "X"
+        else if (lhs==1) return 1;
+        else if (lsign && lhs==VL_MASK_I(obits)) {  // -1
+            if (rhs & 1) return VL_MASK_I(obits);  // -1^odd=-1
+            else return 1;  // -1^even=1
+        }
 	return 0;
    }
    return VL_POW_III(obits, rbits, rbits, lhs, rhs);
@@ -1499,12 +1502,12 @@ static inline QData VL_POWSS_QQQ(int obits, int, int rbits,
                                 QData lhs, QData rhs, bool lsign, bool rsign) VL_MT_SAFE {
    if (VL_UNLIKELY(rhs==0)) return 1;
    if (rsign && VL_SIGN_I(rbits, rhs)) {
-	if (lhs==0) return 0;	// "X"
-	else if (lhs==1) return 1;
-	else if (lsign && lhs==VL_MASK_I(obits)) {  // -1
-	    if (rhs & 1) return VL_MASK_I(obits);  // -1^odd=-1
-	    else return 1; // -1^even=1
-	}
+        if (lhs==0) return 0;  // "X"
+        else if (lhs==1) return 1;
+        else if (lsign && lhs==VL_MASK_I(obits)) {  // -1
+            if (rhs & 1) return VL_MASK_I(obits);  // -1^odd=-1
+            else return 1;  // -1^even=1
+        }
 	return 0;
    }
    return VL_POW_QQQ(obits, rbits, rbits, lhs, rhs);
@@ -1546,9 +1549,9 @@ static inline void _VL_INSERT_WI(int, WDataOutP owp, IData ld, int hbit, int lbi
    }
    else {
 	int hword = VL_BITWORD_I(hbit);
-	int lword = VL_BITWORD_I(lbit);
-	if (hword==lword) {	// know < 32 bits because above checks it
-	    IData insmask = (VL_MASK_I(hoffset-loffset+1))<<loffset;
+        int lword = VL_BITWORD_I(lbit);
+        if (hword==lword) {  // know < 32 bits because above checks it
+            IData insmask = (VL_MASK_I(hoffset-loffset+1))<<loffset;
 	    owp[lword] = (owp[lword] & ~insmask) | ((ld<<loffset) & insmask);
 	} else {
 	    IData hinsmask = (VL_MASK_I(hoffset-0+1))<<0;
@@ -1577,9 +1580,9 @@ static inline void _VL_INSERT_WW(int, WDataOutP owp, WDataInP lwp, int hbit, int
 	// Non-32bit, but nicely aligned, so stuff all but the last word
 	for (int i=0; i<(words-1); ++i) {
 	    owp[lword+i] = lwp[i];
-	}
-	IData hinsmask = (VL_MASK_I(hoffset-0+1)); // Know it's not a full word as above fast case handled it
-	owp[lword+words-1] = (owp[words+lword-1] & ~hinsmask) | (lwp[words-1] & hinsmask);
+        }
+        IData hinsmask = (VL_MASK_I(hoffset-0+1));  // Know it's not a full word as above fast case handled it
+        owp[lword+words-1] = (owp[words+lword-1] & ~hinsmask) | (lwp[words-1] & hinsmask);
    }
    else {
 	IData hinsmask = (VL_MASK_I(hoffset-0+1))<<0;
@@ -1685,20 +1688,24 @@ static inline IData VL_STREAML_FAST_III(int, int lbits, int, IData ld, IData rd_
    //   ret = 10324---
    IData ret = ld;
    if (rd_log2) {
-	vluint32_t lbitsFloor = lbits & ~VL_MASK_I(rd_log2); // max multiple of rd <= lbits
-	vluint32_t lbitsRem = lbits - lbitsFloor; // number of bits in most-sig slice (MSS)
-	IData msbMask = VL_MASK_I(lbitsRem) << lbitsFloor; // mask to sel only bits in MSS
-	ret = (ret & ~msbMask) | ((ret & msbMask) << ((VL_UL(1) << rd_log2) - lbitsRem));
+        vluint32_t lbitsFloor = lbits & ~VL_MASK_I(rd_log2);  // max multiple of rd <= lbits
+        vluint32_t lbitsRem = lbits - lbitsFloor;  // number of bits in most-sig slice (MSS)
+        IData msbMask = VL_MASK_I(lbitsRem) << lbitsFloor;  // mask to sel only bits in MSS
+        ret = (ret & ~msbMask) | ((ret & msbMask) << ((VL_UL(1) << rd_log2) - lbitsRem));
    }
    switch (rd_log2) {
-	case 0:
-	    ret = ((ret >> 1) & VL_UL(0x55555555)) | ((ret & VL_UL(0x55555555)) << 1);    // FALLTHRU
-	case 1:
-	    ret = ((ret >> 2) & VL_UL(0x33333333)) | ((ret & VL_UL(0x33333333)) << 2);    // FALLTHRU
-	case 2:
-	    ret = ((ret >> 4) & VL_UL(0x0f0f0f0f)) | ((ret & VL_UL(0x0f0f0f0f)) << 4);    // FALLTHRU
-	case 3:
-	    ret = ((ret >> 8) & VL_UL(0x00ff00ff)) | ((ret & VL_UL(0x00ff00ff)) << 8);    // FALLTHRU
+        case 0:
+            ret = ((ret >> 1) & VL_UL(0x55555555))
+                | ((ret & VL_UL(0x55555555)) << 1);  // FALLTHRU
+        case 1:
+            ret = ((ret >> 2) & VL_UL(0x33333333))
+                | ((ret & VL_UL(0x33333333)) << 2);  // FALLTHRU
+        case 2:
+            ret = ((ret >> 4) & VL_UL(0x0f0f0f0f))
+                | ((ret & VL_UL(0x0f0f0f0f)) << 4);  // FALLTHRU
+        case 3:
+            ret = ((ret >> 8) & VL_UL(0x00ff00ff))
+                | ((ret & VL_UL(0x00ff00ff)) << 8);  // FALLTHRU
 	case 4:
 	    ret = ((ret >> 16) | (ret << 16));
    }
@@ -1892,17 +1899,17 @@ static inline WDataOutP VL_SHIFTL_WWI(int obits,int,int,WDataOutP owp,WDataInP l
 static inline WDataOutP VL_SHIFTL_WWW(int obits, int lbits, int rbits,
                                      WDataOutP owp, WDataInP lwp, WDataInP rwp) VL_MT_SAFE {
    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
-	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
-	    return VL_ZERO_W(obits, owp);
-	}
+        if (VL_UNLIKELY(rwp[i])) {  // Huge shift 1>>32 or more
+            return VL_ZERO_W(obits, owp);
+        }
    }
    return VL_SHIFTL_WWI(obits,lbits,32,owp,lwp,rwp[0]);
 }
 static inline IData VL_SHIFTL_IIW(int obits,int,int rbits,IData lhs, WDataInP rwp) VL_MT_SAFE {
    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
-	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
-	    return 0;
-	}
+        if (VL_UNLIKELY(rwp[i])) {  // Huge shift 1>>32 or more
+            return 0;
+        }
    }
    return VL_CLEAN_II(obits,obits,lhs<<rwp[0]);
 }
@@ -1939,17 +1946,17 @@ static inline WDataOutP VL_SHIFTR_WWI(int obits, int, int,
 static inline WDataOutP VL_SHIFTR_WWW(int obits, int lbits, int rbits,
                                      WDataOutP owp, WDataInP lwp, WDataInP rwp) VL_MT_SAFE {
    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
-	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
-	    return VL_ZERO_W(obits, owp);
-	}
+        if (VL_UNLIKELY(rwp[i])) {  // Huge shift 1>>32 or more
+            return VL_ZERO_W(obits, owp);
+        }
    }
    return VL_SHIFTR_WWI(obits,lbits,32,owp,lwp,rwp[0]);
 }
 static inline IData VL_SHIFTR_IIW(int obits,int,int rbits,IData lhs, WDataInP rwp) VL_MT_SAFE {
    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
-	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
-	    return 0;
-	}
+        if (VL_UNLIKELY(rwp[i])) {  // Huge shift 1>>32 or more
+            return 0;
+        }
    }
    return VL_CLEAN_II(obits,obits,lhs>>rwp[0]);
 }
@@ -1960,8 +1967,8 @@ static inline IData VL_SHIFTRS_III(int obits, int lbits, int, IData lhs, IData r
    // IEEE says signed if output signed, but bit position from lbits;
    // must use lbits for sign; lbits might != obits,
    // an EXTEND(SHIFTRS(...)) can became a SHIFTRS(...) within same 32/64 bit word length
-    IData sign    = -(lhs >> (lbits-1)); // ffff_ffff if negative
-    IData signext = ~(VL_MASK_I(lbits) >> rhs);   // One with bits where we've shifted "past"
+    IData sign    = -(lhs >> (lbits-1));  // ffff_ffff if negative
+    IData signext = ~(VL_MASK_I(lbits) >> rhs);  // One with bits where we've shifted "past"
    return (lhs >> rhs) | (sign & VL_CLEAN_II(obits,obits,signext));
 }
 static inline QData VL_SHIFTRS_QQI(int obits, int lbits, int, QData lhs, IData rhs) VL_PURE {
@@ -2009,9 +2016,9 @@ static inline WDataOutP VL_SHIFTRS_WWI(int obits, int lbits, int,
 static inline WDataOutP VL_SHIFTRS_WWW(int obits, int lbits, int rbits,
                                       WDataOutP owp, WDataInP lwp, WDataInP rwp) VL_MT_SAFE {
    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
-	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
-	    int lmsw = VL_WORDS_I(obits)-1;
-	    IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]);
+        if (VL_UNLIKELY(rwp[i])) {  // Huge shift 1>>32 or more
+            int lmsw = VL_WORDS_I(obits)-1;
+            IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]);
 	    for (int j=0; j <= lmsw; ++j) owp[j] = sign;
 	    owp[lmsw] &= VL_MASK_I(lbits);
 	    return owp;
@@ -2022,20 +2029,20 @@ static inline WDataOutP VL_SHIFTRS_WWW(int obits, int lbits, int rbits,
 static inline IData VL_SHIFTRS_IIW(int obits, int lbits, int rbits,
                                   IData lhs, WDataInP rwp) VL_MT_SAFE {
    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
-	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
-	    IData sign    = -(lhs >> (lbits-1)); // ffff_ffff if negative
-	    return VL_CLEAN_II(obits,obits,sign);
-	}
+        if (VL_UNLIKELY(rwp[i])) {  // Huge shift 1>>32 or more
+            IData sign = -(lhs >> (lbits-1));  // ffff_ffff if negative
+            return VL_CLEAN_II(obits,obits,sign);
+        }
    }
    return VL_SHIFTRS_III(obits,lbits,32,lhs,rwp[0]);
 }
 static inline QData VL_SHIFTRS_QQW(int obits, int lbits, int rbits,
                                   QData lhs, WDataInP rwp) VL_MT_SAFE {
    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
-	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
-	    QData sign    = -(lhs >> (lbits-1)); // ffff_ffff if negative
-	    return VL_CLEAN_QQ(obits,obits,sign);
-	}
+        if (VL_UNLIKELY(rwp[i])) {  // Huge shift 1>>32 or more
+            QData sign = -(lhs >> (lbits-1));  // ffff_ffff if negative
+            return VL_CLEAN_QQ(obits,obits,sign);
+        }
    }
    return VL_SHIFTRS_QQI(obits,lbits,32,lhs,rwp[0]);
 }
@@ -2060,8 +2067,8 @@ static inline QData VL_SHIFTRS_QQQ(int obits,int lbits,int rbits,QData lhs, QDat
 static inline IData VL_BITSEL_IWII(int, int lbits, int, int, WDataInP lwp, IData rd) VL_MT_SAFE {
    int word = VL_BITWORD_I(rd);
    if (VL_UNLIKELY(rd > static_cast<IData>(lbits))) {
-	return ~0; // Spec says you can go outside the range of a array.  Don't coredump if so.
-	// We return all 1's as that's more likely to find bugs (?) than 0's.
+        return ~0;  // Spec says you can go outside the range of a array.  Don't coredump if so.
+        // We return all 1's as that's more likely to find bugs (?) than 0's.
    } else {
 	return (lwp[word]>>VL_BITBIT_I(rd));
    }
@@ -2077,7 +2084,7 @@ static inline IData VL_SEL_IWII(int, int lbits, int, int,
                                WDataInP lwp, IData lsb, IData width) VL_MT_SAFE {
    int msb = lsb+width-1;
    if (VL_UNLIKELY(msb>lbits)) {
-	return ~0; // Spec says you can go outside the range of a array.  Don't coredump if so.
+        return ~0;  // Spec says you can go outside the range of a array.  Don't coredump if so.
    } else if (VL_BITWORD_I(msb)==VL_BITWORD_I(static_cast<int>(lsb))) {
        return VL_BITRSHIFT_W(lwp, lsb);
    } else {
@@ -2092,7 +2099,7 @@ static inline QData VL_SEL_QWII(int, int lbits, int, int,
                                WDataInP lwp, IData lsb, IData width) VL_MT_SAFE {
    int msb = lsb+width-1;
    if (VL_UNLIKELY(msb>lbits)) {
-	return ~0; // Spec says you can go outside the range of a array.  Don't coredump if so.
+        return ~0;  // Spec says you can go outside the range of a array.  Don't coredump if so.
    } else if (VL_BITWORD_I(msb)==VL_BITWORD_I(static_cast<int>(lsb))) {
        return VL_BITRSHIFT_W(lwp, lsb);
    } else if (VL_BITWORD_I(msb)==1+VL_BITWORD_I(static_cast<int>(lsb))) {
@@ -2114,9 +2121,9 @@ static inline WDataOutP VL_SEL_WWII(int obits, int lbits, int, int,
                                    WDataOutP owp, WDataInP lwp, IData lsb, IData width) VL_MT_SAFE {
    int msb = lsb+width-1;
    int word_shift = VL_BITWORD_I(lsb);
-    if (VL_UNLIKELY(msb>lbits)) { // Outside bounds,
-	for (int i=0; i<VL_WORDS_I(obits)-1; ++i) owp[i] = ~0;
-	owp[VL_WORDS_I(obits)-1] = VL_MASK_I(obits);
+    if (VL_UNLIKELY(msb>lbits)) {  // Outside bounds,
+        for (int i=0; i<VL_WORDS_I(obits)-1; ++i) owp[i] = ~0;
+        owp[VL_WORDS_I(obits)-1] = VL_MASK_I(obits);
    } else if (VL_BITBIT_I(lsb)==0) {
 	// Just a word extract
 	for (int i=0; i<VL_WORDS_I(obits); ++i) owp[i] = lwp[i+word_shift];
@@ -2284,4 +2291,4 @@ static inline void VL_CONSTLO_W_8X(int lsb, WDataOutP obase,

 //======================================================================

-#endif /*_VERILATED_H_*/
+#endif  // Guard
@@ -167,17 +167,19 @@ $(VM_PREFIX)__ALL.a: $(VK_OBJS)
 ### Compile rules

 ifneq ($(VM_DEFAULT_RULES),0)
-$(VM_PREFIX)__ALLsup.o: $(VM_PREFIX)__ALLsup.cpp
-	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_SLOW) -c -o $@ $<
-
 $(VM_PREFIX)__ALLcls.o: $(VM_PREFIX)__ALLcls.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<

-$(VM_PREFIX)%__Slow.o: $(VM_PREFIX)%__Slow.cpp
+$(VM_PREFIX)__ALLsup.o: $(VM_PREFIX)__ALLsup.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_SLOW) -c -o $@ $<

-$(VM_PREFIX)%.o: $(VM_PREFIX)%.cpp
+# VM_GLOBAL_FAST files including verilated.o use this rule
+%.o: %.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<
+
+%__Slow.o: %__Slow.cpp
+	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_SLOW) -c -o $@ $<
+
 endif

 #Default rule embedded in make:
@@ -189,7 +191,10 @@ endif

 debug-make::
 	@echo
+	@echo CXXFLAGS: $(CXXFLAGS)
 	@echo CPPFLAGS: $(CPPFLAGS)
+	@echo OPT_FAST: $(OPT_FAST)
+	@echo OPT_SLOW: $(OPT_SLOW)
 	@echo VM_PREFIX:  $(VM_PREFIX)
 	@echo VM_PARALLEL_BUILDS:  $(VM_PARALLEL_BUILDS)
 	@echo VM_CLASSES_FAST: $(VM_CLASSES_FAST)
@@ -29,4 +29,4 @@
 // Hide file descriptor difference - deprecated - for older versions
 `define verilator_file_descriptor integer

-`endif // guard
+`endif  // guard
@@ -24,9 +24,9 @@
 #include "verilated_cov.h"
 #include "verilated_cov_key.h"

-#include <map>
 #include <deque>
 #include <fstream>
+#include <map>

 //=============================================================================
 // VerilatedCovImpBase
@@ -34,8 +34,8 @@

 struct VerilatedCovImpBase {
    // TYPES
-    enum { MAX_KEYS = 33 };		/// Maximum user arguments + filename+lineno
-    enum { KEY_UNDEF = 0 };		/// Magic key # for unspecified values
+    enum { MAX_KEYS = 33 };  /// Maximum user arguments + filename+lineno
+    enum { KEY_UNDEF = 0 };  /// Magic key # for unspecified values
 };

 //=============================================================================
@@ -45,8 +45,8 @@ struct VerilatedCovImpBase {
 class VerilatedCovImpItem : VerilatedCovImpBase {
 public:  // But only local to this file
    // MEMBERS
-    int	m_keys[MAX_KEYS];		///< Key
-    int	m_vals[MAX_KEYS];		///< Value for specified key
+    int m_keys[MAX_KEYS];  ///< Key
+    int m_vals[MAX_KEYS];  ///< Value for specified key
    // CONSTRUCTORS
    // Derived classes should call zero() in their constructor
    VerilatedCovImpItem() {
@@ -69,7 +69,7 @@ public:  // But only local to this file
 template <class T> class VerilatedCoverItemSpec : public VerilatedCovImpItem {
 private:
    // MEMBERS
-    T*	m_countp;	///< Count value
+    T*  m_countp;  ///< Count value
 public:
    // METHODS
    // cppcheck-suppress truncLongCastReturn
@@ -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,22 +424,22 @@ 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 {
    const char* keyps[VerilatedCovImpBase::MAX_KEYS]
-	= {NULL,NULL,NULL,	// filename,lineno,page
-	   key0,key1,key2,key3,key4,key5,key6,key7,key8,key9,
-	   key10,key11,key12,key13,key14,key15,key16,key17,key18,key19,
-	   key20,key21,key22,key23,key24,key25,key26,key27,key28,key29};
+        = {NULL,NULL,NULL,  // filename,lineno,page
+           key0,key1,key2,key3,key4,key5,key6,key7,key8,key9,
+           key10,key11,key12,key13,key14,key15,key16,key17,key18,key19,
+           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};
+        = {NULL,NULL,NULL,  // filename,lineno,page
+           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);
 }

@@ -106,8 +106,8 @@ public:
    // much slower (nearly 2x) than having smaller versions also.  However
    // there's not much more gain in having a version for each number of args.
 #define K(n) const char* key ## n
-#define A(n) const char* key ## n, const char* valp ## n	// Argument list
-#define D(n) const char* key ## n = NULL, const char* valp ## n = NULL	// Argument list
+#define A(n) const char* key ## n, const char* valp ## n  // Argument list
+#define D(n) const char* key ## n = NULL, const char* valp ## n = NULL  // Argument list
    static void _insertp(D(0),D(1),D(2),D(3),D(4),D(5),D(6),D(7),D(8),D(9));
    static void _insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)
                         ,A(10),D(11),D(12),D(13),D(14),D(15),D(16),D(17),D(18),D(19));
@@ -129,4 +129,4 @@ public:
    static void zero() VL_MT_SAFE;
 };

-#endif // guard
+#endif  // Guard
@@ -140,4 +140,4 @@ public:
    }
 };

-#endif // guard
+#endif  // guard
@@ -24,6 +24,7 @@
 //=========================================================================

 #define _VERILATED_DPI_CPP_
+
 #include "verilatedos.h"
 #include "verilated_dpi.h"
 #include "verilated_imp.h"
@@ -146,7 +147,7 @@ void svPutPartselBit(svBitVecVal* dp, const svBitVecVal s, int lbit, int width)
    else {
        int hword = VL_BITWORD_I(hbit);
        int lword = VL_BITWORD_I(lbit);
-        if (hword==lword) {     // know < 32 bits because above checks it
+        if (hword==lword) {  // know < 32 bits because above checks it
            IData insmask = (VL_MASK_I(hoffset-loffset+1))<<loffset;
            dp[lword] = (dp[lword] & ~insmask) | ((s<<loffset) & insmask);
        } else {
@@ -171,7 +172,7 @@ void svPutPartselLogic(svLogicVecVal* dp, const svLogicVecVal s, int lbit, int w
    else {
        int hword = VL_BITWORD_I(hbit);
        int lword = VL_BITWORD_I(lbit);
-        if (hword==lword) {     // know < 32 bits because above checks it
+        if (hword==lword) {  // know < 32 bits because above checks it
            IData insmask = (VL_MASK_I(hoffset-loffset+1))<<loffset;
            dp[lword].aval = (dp[lword].aval & ~insmask) | ((s.aval<<loffset) & insmask);
            dp[lword].bval = (dp[lword].bval & ~insmask) | ((s.bval<<loffset) & insmask);
@@ -473,7 +474,7 @@ void* svGetArrElemPtr(const svOpenArrayHandle h, int indx1, ...) {
            datap = _vl_svGetArrElemPtr(h, 2, indx1, indx2, 0); break; }
    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
            datap = _vl_svGetArrElemPtr(h, 3, indx1, indx2, indx3); break; }
-    default: datap = _vl_svGetArrElemPtr(h, -1, 0, 0, 0); break; // Will error
+    default: datap = _vl_svGetArrElemPtr(h, -1, 0, 0, 0); break;  // Will error
    }
    va_end(ap);
    return datap;
@@ -499,7 +500,7 @@ void svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s,
            _vl_svPutBitArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
            _vl_svPutBitArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
-    default: _vl_svPutBitArrElemVecVal(d, s, -1, 0, 0, 0); break; // Will error
+    default: _vl_svPutBitArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
    }
    va_end(ap);
 }
@@ -526,7 +527,7 @@ void svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
            _vl_svPutLogicArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
            _vl_svPutLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
-    default: _vl_svPutLogicArrElemVecVal(d, s, -1, 0, 0, 0); break; // Will error
+    default: _vl_svPutLogicArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
    }
    va_end(ap);
 }
@@ -557,7 +558,7 @@ void svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
            _vl_svGetBitArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
            _vl_svGetBitArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
-    default: _vl_svGetBitArrElemVecVal(d, s, -1, 0, 0, 0); break; // Will error
+    default: _vl_svGetBitArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
    }
    va_end(ap);
 }
@@ -584,7 +585,7 @@ void svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s,
            _vl_svGetLogicArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
            _vl_svGetLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
-    default: _vl_svGetLogicArrElemVecVal(d, s, -1, 0, 0, 0); break; // Will error
+    default: _vl_svGetLogicArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
    }
    va_end(ap);
 }
@@ -614,7 +615,7 @@ svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...) {
            out = _vl_svGetBitArrElem(s, 3, indx1, indx2, indx3, 0); break; }
    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
            out = _vl_svGetBitArrElem(s, 4, indx1, indx2, indx3, indx4); break; }
-    default: out = _vl_svGetBitArrElem(s, -1, 0, 0, 0, 0); break; // Will error
+    default: out = _vl_svGetBitArrElem(s, -1, 0, 0, 0, 0); break;  // Will error
    }
    va_end(ap);
    return out;
@@ -642,7 +643,7 @@ svLogic svGetLogicArrElem(const svOpenArrayHandle s, int indx1, ...) {
            out = _vl_svGetBitArrElem(s, 3, indx1, indx2, indx3, 0); break; }
    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
            out = _vl_svGetBitArrElem(s, 4, indx1, indx2, indx3, indx4); break; }
-    default: out = _vl_svGetBitArrElem(s, -1, 0, 0, 0, 0); break; // Will error
+    default: out = _vl_svGetBitArrElem(s, -1, 0, 0, 0, 0); break;  // Will error
    }
    va_end(ap);
    return out;
@@ -672,7 +673,7 @@ void svPutBitArrElem(const svOpenArrayHandle d, svBit value, int indx1, ...) {
            _vl_svPutBitArrElem(d, value, 3, indx1, indx2, indx3, 0); break; }
    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
            _vl_svPutBitArrElem(d, value, 4, indx1, indx2, indx3, indx4); break; }
-    default: _vl_svPutBitArrElem(d, value, -1, 0, 0, 0, 0); break; // Will error
+    default: _vl_svPutBitArrElem(d, value, -1, 0, 0, 0, 0); break;  // Will error
    }
    va_end(ap);
 }
@@ -698,7 +699,7 @@ void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1, ...)
            _vl_svPutBitArrElem(d, value, 3, indx1, indx2, indx3, 0); break; }
    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
            _vl_svPutBitArrElem(d, value, 4, indx1, indx2, indx3, indx4); break; }
-    default: _vl_svPutBitArrElem(d, value, -1, 0, 0, 0, 0); break; // Will error
+    default: _vl_svPutBitArrElem(d, value, -1, 0, 0, 0, 0); break;  // Will error
    }
    va_end(ap);
 }
@@ -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) {
@@ -759,7 +763,7 @@ int svGetCallerInfo(const char** fileNamepp, int *lineNumberp) {
 // Disables

 int svIsDisabledState() {
-    return 0; // Disables not implemented
+    return 0;  // Disables not implemented
 }

 void svAckDisabledState() {
@@ -26,10 +26,12 @@


 #ifndef _VERILATED_DPI_H_
-#define _VERILATED_DPI_H_ 1 ///< Header Guard
+#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"

 //===================================================================
@@ -78,4 +80,4 @@ static inline void VL_SET_SVLV_Q(int, svLogicVecVal* owp, QData ld) VL_MT_SAFE {

 //======================================================================

-#endif // _VERILATED_DPI_H_
+#endif  // Guard
@@ -0,0 +1,239 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2001-2018 by Wilson Snyder.  This program is free software;
+// you can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
+//
+// This is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+//
+//=============================================================================
+///
+/// \file
+/// \brief C++ Tracing in FST Format
+///
+//=============================================================================
+// SPDIFF_OFF
+
+#include "verilatedos.h"
+#include "verilated.h"
+#include "verilated_fst_c.h"
+
+// Include the GTKWave implementation directly
+#include "gtkwave/fastlz.c"
+#include "gtkwave/fstapi.c"
+#include "gtkwave/lz4.c"
+
+#include <algorithm>
+#include <cerrno>
+#include <ctime>
+#include <fcntl.h>
+#include <iterator>
+#include <sstream>
+#include <sys/stat.h>
+
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
+# include <io.h>
+#else
+# include <unistd.h>
+#endif
+
+//=============================================================================
+
+class VerilatedFstCallInfo {
+protected:
+    friend class VerilatedFst;
+    VerilatedFstCallback_t m_initcb;  ///< Initialization Callback function
+    VerilatedFstCallback_t m_fullcb;  ///< Full Dumping Callback function
+    VerilatedFstCallback_t m_changecb;  ///< Incremental Dumping Callback function
+    void* m_userthis;  ///< Fake "this" for caller
+    vluint32_t m_code;  ///< Starting code number
+    // CONSTRUCTORS
+    VerilatedFstCallInfo(VerilatedFstCallback_t icb, VerilatedFstCallback_t fcb,
+                         VerilatedFstCallback_t changecb,
+                         void* ut, vluint32_t code)
+        : m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {};
+    ~VerilatedFstCallInfo() {}
+};
+
+//=============================================================================
+// VerilatedFst
+
+VerilatedFst::VerilatedFst(void* fst)
+    : m_fst(fst),
+      m_fullDump(true),
+      m_scopeEscape('.') {}
+
+void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
+    m_assertOne.check();
+    m_fst = fstWriterCreate(filename, 1);
+    m_curScope.clear();
+
+    for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
+        VerilatedFstCallInfo* cip = m_callbacks[ent];
+        cip->m_code = 1;
+        (cip->m_initcb)(this, cip->m_userthis, cip->m_code);
+    }
+
+    // Clear the scope stack
+    std::list<std::string>::iterator it = m_curScope.begin();
+    while (it != m_curScope.end()) {
+        fstWriterSetUpscope(m_fst);
+        it = m_curScope.erase(it);
+    }
+}
+
+void VerilatedFst::module(const std::string& name) {
+    m_module = name;
+}
+
+//=============================================================================
+// Decl
+
+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, 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
+    std::string symbol_name(tokens.back());
+    tokens.pop_back();  // Remove symbol name from hierarchy
+    tokens.insert(tokens.begin(), m_module);  // Add current module to the hierarchy
+
+    // Find point where current and new scope diverge
+    std::list<std::string>::iterator cur_it = m_curScope.begin();
+    std::list<std::string>::iterator new_it = tokens.begin();
+    while (cur_it != m_curScope.end() && new_it != tokens.end()) {
+        if (*cur_it != *new_it)
+            break;
+        ++cur_it;
+        ++new_it;
+    }
+
+    // Go back to the common point
+    while (cur_it != m_curScope.end()) {
+        fstWriterSetUpscope(m_fst);
+        cur_it = m_curScope.erase(cur_it);
+    }
+
+    // Follow the hierarchy of the new variable from the common scope point
+    while (new_it != tokens.end()) {
+        fstWriterSetScope(m_fst, FST_ST_VCD_SCOPE, new_it->c_str(), NULL);
+        m_curScope.push_back(*new_it);
+        new_it = tokens.erase(new_it);
+    }
+
+    std::stringstream name_ss;
+    name_ss << symbol_name;
+    if (arraynum >= 0)
+        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);
+    } else {  // Alias
+        fstWriterCreateVar(m_fst, vartype, vardir, len, name_str.c_str(), p.first->second);
+    }
+}
+
+//=============================================================================
+// Callbacks
+
+void VerilatedFst::addCallback(
+    VerilatedFstCallback_t initcb, VerilatedFstCallback_t fullcb,
+    VerilatedFstCallback_t changecb, void* userthis) VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
+    if (VL_UNLIKELY(isOpen())) {
+        std::string msg = std::string("Internal: ")+__FILE__+"::"+__FUNCTION__+" called with already open file";
+        VL_FATAL_MT(__FILE__,__LINE__,"",msg.c_str());
+    }
+    VerilatedFstCallInfo* vci = new VerilatedFstCallInfo(initcb, fullcb, changecb, userthis, 1);
+    m_callbacks.push_back(vci);
+}
+
+//=============================================================================
+// Dumping
+
+void VerilatedFst::dump(vluint64_t timeui) {
+    if (!isOpen()) return;
+    if (VL_UNLIKELY(m_fullDump)) {
+        m_fullDump = false;  // No need for more full dumps
+        for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
+            VerilatedFstCallInfo* cip = m_callbacks[ent];
+            (cip->m_fullcb)(this, cip->m_userthis, cip->m_code);
+        }
+        return;
+    }
+    fstWriterEmitTimeChange(m_fst, timeui);
+    for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
+        VerilatedFstCallInfo* cip = m_callbacks[ent];
+        (cip->m_changecb)(this, cip->m_userthis, cip->m_code);
+    }
+}
+
+//=============================================================================
+// Helpers
+
+char* VerilatedFst::word2Str(vluint32_t newval, int bits) {
+    m_valueStrBuffer.resize(bits+1);
+    char* s = m_valueStrBuffer.data();
+    for (int i = 0; i < bits; ++i) {
+        *s = '0' + ((newval>>(bits-i-1))&1);
+        ++s;
+    }
+    *s = '\0';
+    return m_valueStrBuffer.data();
+}
+
+char* VerilatedFst::quad2Str(vluint64_t newval, int bits) {
+    m_valueStrBuffer.resize(bits+1);
+    char* s = m_valueStrBuffer.data();
+    for (int i = 0; i < bits; ++i) {
+        *s = '0' + ((newval>>(bits-i-1))&1);
+        ++s;
+    }
+    *s = '\0';
+    return m_valueStrBuffer.data();
+}
+
+char* VerilatedFst::array2Str(const vluint32_t* newval, int bits) {
+    int bq = bits/32, br = bits%32;
+    m_valueStrBuffer.resize(bits+1);
+    char* s = m_valueStrBuffer.data();
+    for (int w = bq-1; w >= 0; --w) {
+        for (int i = 0; i < 32; ++i) {
+            *s = '0' + ((newval[w]>>(32-i-1))&1);
+            ++s;
+        }
+    }
+    for (int i = 0; i < br; ++i) {
+        *s = '0' + ((newval[bq]>>(br-i-1))&1);
+        ++s;
+    }
+    *s = '\0';
+    return m_valueStrBuffer.data();
+}
+
+//********************************************************************
+// Local Variables:
+// End:
@@ -0,0 +1,230 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2001-2018 by Wilson Snyder.  This program is free software;
+// you can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
+//
+// This is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+//
+//=============================================================================
+///
+/// \file
+/// \brief C++ Tracing in FST Format
+///
+//=============================================================================
+// SPDIFF_OFF
+
+#ifndef _VERILATED_FST_C_H_
+#define _VERILATED_FST_C_H_ 1
+
+#include "verilatedos.h"
+#include "verilated.h"
+
+#include "gtkwave/fstapi.h"
+
+#include <list>
+#include <map>
+#include <string>
+#include <vector>
+
+class VerilatedFst;
+class VerilatedFstCallInfo;
+typedef void (*VerilatedFstCallback_t)(VerilatedFst* vcdp, void* userthis, vluint32_t code);
+
+//=============================================================================
+// VerilatedFst
+/// Base class to create a Verilator FST dump
+/// This is an internally used class - see VerilatedFstC for what to call from applications
+
+class VerilatedFst {
+    typedef std::map<vluint32_t, fstHandle> Code2SymbolType;
+    typedef std::map<int, fstEnumHandle> Local2FstDtype;
+    typedef std::vector<VerilatedFstCallInfo*> CallbackVec;
+private:
+    void* m_fst;
+    VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread
+    bool m_fullDump;
+    char m_scopeEscape;
+    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,
+                    int dtypenum, fstVarDir vardir, fstVarType vartype,
+                    int arraynum, vluint32_t len);
+    // helpers
+    std::vector<char> m_valueStrBuffer;
+    char* word2Str(vluint32_t newval, int bits);
+    char* quad2Str(vluint64_t newval, int bits);
+    char* array2Str(const vluint32_t *newval, int bits);
+public:
+    explicit VerilatedFst(void* fst=NULL);
+    ~VerilatedFst() { if (m_fst == NULL) { fstWriterClose(m_fst); } }
+    bool isOpen() const { return m_fst != NULL; }
+    void open(const char* filename) VL_MT_UNSAFE;
+    void flush() VL_MT_UNSAFE { fstWriterFlushContext(m_fst); }
+    void close() VL_MT_UNSAFE {
+        m_assertOne.check();
+        fstWriterClose(m_fst);
+        m_fst = NULL;
+    }
+    // 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* 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);
+    // std::string doubleToTimescale(double value);
+
+    /// Change character that splits scopes.  Note whitespace are ALWAYS escapes.
+    void scopeEscape(char flag) { m_scopeEscape = flag; }
+    /// Is this an escape?
+    bool isScopeEscape(char c) { return isspace(c) || c==m_scopeEscape; }
+    /// 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 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,
+                 int dtypenum, fstVarDir vardir, fstVarType vartype,
+                 int arraynum) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 1);
+    }
+    void declBus(vluint32_t code, const char* name,
+                 int dtypenum, fstVarDir vardir, fstVarType vartype,
+                 int arraynum, int msb, int lsb) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
+    }
+    void declDouble(vluint32_t code, const char* name,
+                    int dtypenum, fstVarDir vardir, fstVarType vartype,
+                    int arraynum) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 2);
+    }
+    void declFloat(vluint32_t code, const char* name,
+                   int dtypenum, fstVarDir vardir, fstVarType vartype,
+                   int arraynum) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 1);
+    }
+    void declQuad(vluint32_t code, const char* name,
+                  int dtypenum, fstVarDir vardir, fstVarType vartype,
+                  int arraynum, int msb, int lsb) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
+    }
+    void declArray(vluint32_t code, const char* name,
+                   int dtypenum, fstVarDir vardir, fstVarType vartype,
+                   int arraynum, int msb, int lsb) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
+    }
+
+    /// Inside dumping routines, dump one signal if it has changed
+    void chgBit(vluint32_t code, const vluint32_t newval) {
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], newval ? "1" : "0");
+    }
+    void chgBus(vluint32_t code, const vluint32_t newval, int bits) {
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], word2Str(newval, bits));
+    }
+    void chgDouble(vluint32_t code, const double newval) {
+        double val = newval;
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], &val);
+    }
+    void chgFloat(vluint32_t code, const float newval) {
+        double val = (double)newval;
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], &val);
+    }
+    void chgQuad(vluint32_t code, const vluint64_t newval, int bits) {
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], quad2Str(newval, bits));
+    }
+    void chgArray(vluint32_t code, const vluint32_t* newval, int bits) {
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], array2Str(newval, bits));
+    }
+
+    void fullBit(vluint32_t code, const vluint32_t newval) { chgBit(code, newval); }
+    void fullBus(vluint32_t code, const vluint32_t newval, int bits) { chgBus(code, newval, bits); }
+    void fullDouble(vluint32_t code, const double newval) { chgDouble(code, newval); }
+    void fullFloat(vluint32_t code, const float newval) { chgFloat(code, newval); }
+    void fullQuad(vluint32_t code, const vluint64_t newval, int bits) { chgQuad(code, newval, bits); }
+    void fullArray(vluint32_t code, const vluint32_t* newval, int bits) { chgArray(code, newval, bits); }
+
+    void declTriBit   (vluint32_t code, const char* name, int arraynum);
+    void declTriBus   (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriQuad  (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriArray (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void fullTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri);
+    void fullTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits);
+    void fullTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits);
+    void fullTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits);
+    void fullBitX(vluint32_t code);
+    void fullBusX(vluint32_t code, int bits);
+    void fullQuadX(vluint32_t code, int bits);
+    void fullArrayX(vluint32_t code, int bits);
+    void chgTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri);
+    void chgTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits);
+    void chgTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits);
+    void chgTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits);
+};
+
+//=============================================================================
+// VerilatedFstC
+/// Create a FST dump file in C standalone (no SystemC) simulations.
+/// Also derived for use in SystemC simulations.
+/// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE
+
+class VerilatedFstC {
+    VerilatedFst m_sptrace;  ///< Trace file being created
+
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedFstC);
+public:
+    explicit VerilatedFstC(void* filep=NULL) : m_sptrace(filep) {}
+    ~VerilatedFstC() {}
+public:
+    // ACCESSORS
+    /// Is file open?
+    bool isOpen() const { return m_sptrace.isOpen(); }
+    // METHODS
+    /// Open a new FST file
+    void open(const char* filename) VL_MT_UNSAFE_ONE { m_sptrace.open(filename); }
+    /// Close dump
+    void close() VL_MT_UNSAFE_ONE { m_sptrace.close(); }
+    /// Flush dump
+    void flush() VL_MT_UNSAFE_ONE { m_sptrace.flush(); }
+    /// Write one cycle of dump data
+    void dump(vluint64_t timeui) { m_sptrace.dump(timeui); }
+    /// Write one cycle of dump data - backward compatible and to reduce
+    /// conversion warnings.  It's better to use a vluint64_t time instead.
+    void dump(double timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump(vluint32_t timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump(int timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    /// Set time units (s/ms, defaults to ns)
+    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    void set_time_unit(const char* unit) { /* TODO */ }
+    void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
+    /// Set time resolution (s/ms, defaults to ns)
+    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    void set_time_resolution(const char* unit) { /* TODO */ }
+    void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
+
+    /// Internal class access
+    inline VerilatedFst* spTrace() { return &m_sptrace; };
+};
+
+#endif  // guard
@@ -27,7 +27,7 @@


 #ifndef _VERILATED_HEAVY_H_
-#define _VERILATED_HEAVY_H_ 1 ///< Header Guard
+#define _VERILATED_HEAVY_H_ 1  ///< Header Guard

 #include "verilated.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);
@@ -88,4 +88,4 @@ inline IData VL_VALUEPLUSARGS_INQ(int rbits, const std::string& ld, QData& rdr)
 }
 extern IData VL_VALUEPLUSARGS_INN(int, const std::string& ld, std::string& rdr) VL_MT_SAFE;

-#endif // Guard
+#endif  // Guard
@@ -22,7 +22,7 @@


 #ifndef _VERILATED_IMP_H_
-#define _VERILATED_IMP_H_ 1 ///< Header Guard
+#define _VERILATED_IMP_H_ 1  ///< Header Guard

 #if !defined(_VERILATED_CPP_) && !defined(_VERILATED_DPI_CPP_)
 # error "verilated_imp.h only to be included by verilated*.cpp internals"
@@ -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>
@@ -59,8 +57,8 @@ public:
    };
 private:
    // MEMBERS
-    vluint32_t          m_mtaskId;      ///< MTask that did enqueue
-    std::function<void()> m_cb; 	///< Lambda to execute when message received
+    vluint32_t m_mtaskId;  ///< MTask that did enqueue
+    std::function<void()> m_cb;  ///< Lambda to execute when message received
 public:
    // CONSTRUCTORS
    VerilatedMsg(const std::function<void()>& cb)
@@ -105,9 +103,9 @@ public:
 	while (m_depth) {
 	    // Wait for a message to be added to the queue
 	    // We don't use unique_lock as want to unlock with the message copy still in scope
-	    m_mutex.lock();
-	    assert(!m_queue.empty()); // Otherwise m_depth is wrong
-	    // Unfortunately to release the lock we need to copy the message
+            m_mutex.lock();
+            assert(!m_queue.empty());  // Otherwise m_depth is wrong
+            // Unfortunately to release the lock we need to copy the message
 	    // (Or have the message be a pointer, but then new/delete cost on each message)
 	    // We assume messages are small, so copy
 	    auto it = m_queue.begin();
@@ -162,7 +160,7 @@ public:
 	}
    }
 };
-#endif // VL_THREADED
+#endif  // VL_THREADED

 //======================================================================
 // VerilatedImp
@@ -176,7 +174,7 @@ class VerilatedImp {
    typedef std::map<const char*, int, VerilatedCStrCmp>  ExportNameMap;

    // MEMBERS
-    static VerilatedImp	s_s;		///< Static Singleton; One and only static this
+    static VerilatedImp s_s;  ///< Static Singleton; One and only static this

    // Nothing here is save-restored; users expected to re-register appropriately

@@ -199,7 +197,7 @@ class VerilatedImp {
    std::vector<FILE*>  m_fdps VL_GUARDED_BY(m_fdMutex);  ///< File descriptors
    std::deque<IData>   m_fdFree VL_GUARDED_BY(m_fdMutex);  ///< List of free descriptors (SLOW - FOPEN/CLOSE only)

-public: // But only for verilated*.cpp
+public:  // But only for verilated*.cpp
    // CONSTRUCTORS
    VerilatedImp()
 	: m_argVecLoaded(false), m_exportNext(0) {
@@ -284,7 +282,7 @@ private:
 	}
    }

-public: // But only for verilated*.cpp
+public:  // But only for verilated*.cpp
    // METHODS - scope name
    static void scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE {
 	// Slow ok - called once/scope at construction
@@ -321,7 +319,7 @@ public: // But only for verilated*.cpp
        return &s_s.m_nameMap;
    }

-public: // But only for verilated*.cpp
+public:  // But only for verilated*.cpp
    // METHODS - export names

    // Each function prototype is converted to a function number which we
@@ -369,7 +367,7 @@ public: // But only for verilated*.cpp
    // We don't free up m_exportMap until the end, because we can't be sure
    // what other models are using the assigned funcnum's.

-public: // But only for verilated*.cpp
+public:  // But only for verilated*.cpp
    // METHODS - file IO
    static IData fdNew(FILE* fp) VL_MT_SAFE {
 	if (VL_UNLIKELY(!fp)) return 0;
@@ -23,15 +23,16 @@
 #include "verilatedos.h"
 #include "verilated.h"
 #include "verilated_lxt2_c.h"
-// Include the GTKWave implementation directly
-#include "lxt2/lxt2_write.cpp"

-#include <sys/stat.h>
-#include <fcntl.h>
+// Include the GTKWave implementation directly
+#include "gtkwave/lxt2_write.cpp"
+
+#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>
@@ -50,9 +51,9 @@ protected:
    void* m_userthis;  ///< Fake "this" for caller
    vluint32_t m_code;  ///< Starting code number
    // CONSTRUCTORS
-    VerilatedLxt2CallInfo (VerilatedLxt2Callback_t icb, VerilatedLxt2Callback_t fcb,
-                           VerilatedLxt2Callback_t changecb,
-                           void* ut, vluint32_t code)
+    VerilatedLxt2CallInfo(VerilatedLxt2Callback_t icb, VerilatedLxt2Callback_t fcb,
+                          VerilatedLxt2Callback_t changecb,
+                          void* ut, vluint32_t code)
        : m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {};
    ~VerilatedLxt2CallInfo() {}
 };
@@ -25,11 +25,12 @@

 #include "verilatedos.h"
 #include "verilated.h"
-#include "lxt2/lxt2_write.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,30 +86,30 @@ 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
    void module(const std::string& name);
    /// Inside dumping routines, declare a signal
    void declBit(vluint32_t code, const char* name, int arraynum) {
-        this->declSymbol(code, name, arraynum, 0, 0, LXT2_WR_SYM_F_BITS);
+        declSymbol(code, name, arraynum, 0, 0, LXT2_WR_SYM_F_BITS);
    }
    void declBus(vluint32_t code, const char* name, int arraynum, int msb, int lsb) {
-        this->declSymbol(code, name, arraynum, msb, lsb, LXT2_WR_SYM_F_BITS);
+        declSymbol(code, name, arraynum, msb, lsb, LXT2_WR_SYM_F_BITS);
    }
    void declDouble(vluint32_t code, const char* name, int arraynum) {
-        this->declSymbol(code, name, arraynum, 63, 0, LXT2_WR_SYM_F_DOUBLE);
+        declSymbol(code, name, arraynum, 63, 0, LXT2_WR_SYM_F_DOUBLE);
    }
    void declFloat(vluint32_t code, const char* name, int arraynum) {
-        this->declSymbol(code, name, arraynum, 63, 0, LXT2_WR_SYM_F_DOUBLE);
+        declSymbol(code, name, arraynum, 63, 0, LXT2_WR_SYM_F_DOUBLE);
    }
    void declQuad(vluint32_t code, const char* name, int arraynum, int msb, int lsb) {
-        this->declSymbol(code, name, arraynum, msb, lsb, LXT2_WR_SYM_F_BITS);
+        declSymbol(code, name, arraynum, msb, lsb, LXT2_WR_SYM_F_BITS);
    }
    void declArray(vluint32_t code, const char* name, int arraynum, int msb, int lsb) {
-        this->declSymbol(code, name, arraynum, msb, lsb, LXT2_WR_SYM_F_BITS);
+        declSymbol(code, name, arraynum, msb, lsb, LXT2_WR_SYM_F_BITS);
    }

    /// Inside dumping routines, dump one signal if it has changed
@@ -138,10 +139,10 @@ public:
    void fullQuad(vluint32_t code, const vluint64_t newval, int bits) { chgQuad(code, newval, bits); }
    void fullArray(vluint32_t code, const vluint32_t* newval, int bits) { chgArray(code, newval, bits); }

-    void declTriBit   (vluint32_t code, const char* name, int arraynum);
-    void declTriBus   (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
-    void declTriQuad  (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
-    void declTriArray (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriBit(vluint32_t code, const char* name, int arraynum);
+    void declTriBus(vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriQuad(vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriArray(vluint32_t code, const char* name, int arraynum, int msb, int lsb);
    void fullTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri);
    void fullTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits);
    void fullTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits);
@@ -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>
@@ -32,16 +32,19 @@
 # include <unistd.h>
 #endif

-#ifndef O_LARGEFILE // For example on WIN32
+#ifndef O_LARGEFILE  // For example on WIN32
 # define O_LARGEFILE 0
 #endif
 #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
-static const char* const VLTSAVE_TRAILER_STR = "vltsaved";	///< Value of last bytes of each file
+static const char* const VLTSAVE_HEADER_STR = "verilatorsave01\n";  ///< Value of first bytes of each file
+static const char* const VLTSAVE_TRAILER_STR = "vltsaved";  ///< Value of last 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++);
@@ -116,10 +119,10 @@ void VerilatedSave::open(const char* filenamep) VL_MT_UNSAFE_ONE {
    VL_DEBUG_IF(VL_DBG_MSGF("- save: opening save file %s\n",filenamep););

    if (filenamep[0]=='|') {
-	assert(0);	// Not supported yet.
+        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()
@@ -139,10 +142,10 @@ void VerilatedRestore::open(const char* filenamep) VL_MT_UNSAFE_ONE {
    VL_DEBUG_IF(VL_DBG_MSGF("- restore: opening restore file %s\n",filenamep););

    if (filenamep[0]=='|') {
-	assert(0);	// Not supported yet.
+        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()
@@ -197,7 +200,7 @@ void VerilatedSave::flush() VL_MT_UNSAFE_ONE {
 	    }
 	}
    }
-    m_cp = m_bufp; // Reset buffer
+    m_cp = m_bufp;  // Reset buffer
 }

 void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
@@ -207,7 +210,7 @@ void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
    vluint8_t* rp = m_bufp;
    for (vluint8_t* sp=m_cp; sp < m_endp;) *rp++ = *sp++;  // Overlaps
    m_endp = m_bufp + (m_endp - m_cp);
-    m_cp = m_bufp; // Reset buffer
+    m_cp = m_bufp;  // Reset buffer
    // Read into buffer starting at m_endp
    while (1) {
 	ssize_t remaining = (m_bufp+bufferSize() - m_endp);
@@ -223,9 +226,10 @@ void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
 		VL_FATAL_MT("",0,"",msg.c_str());
 		close();
 		break;
-	    }
-	} else { // got==0, EOF
-	    // Fill buffer from here to end with NULLs so reader's don't need to check eof each character.
+            }
+        } else {  // got==0, EOF
+            // Fill buffer from here to end with NULLs so reader's don't
+            // need to check eof each character.
 	    while (m_endp < m_bufp+bufferSize()) *m_endp++ = '\0';
 	    break;
 	}
@@ -248,4 +248,4 @@ inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, std::string& r
    return os.read((void*)rhs.data(), len);
 }

-#endif // guard
+#endif  // Guard
@@ -25,9 +25,10 @@


 #ifndef _VERILATED_SC_H_
-#define _VERILATED_SC_H_ 1 ///< Header Guard
+#define _VERILATED_SC_H_ 1  ///< Header Guard

 #include "verilatedos.h"
+
 #include "systemc.h"

 //=============================================================================
@@ -49,4 +50,4 @@ public:

 //=========================================================================

-#endif // guard
+#endif  // Guard
@@ -30,7 +30,9 @@


 #ifndef _VERILATED_SYM_PROPS_H_
-#define _VERILATED_SYM_PROPS_H_ 1 ///< Header Guard
+#define _VERILATED_SYM_PROPS_H_ 1  ///< Header Guard
+
+#include "verilatedos.h"

 //===========================================================================
 /// Verilator range
@@ -221,4 +223,4 @@ public:
    const char* name() const { return m_namep; }
 };

-#endif // Guard
+#endif  // Guard
@@ -29,11 +29,12 @@


 #ifndef _VERILATED_SYMS_H_
-#define _VERILATED_SYMS_H_ 1 ///< Header Guard
+#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>

 //======================================================================
@@ -62,4 +63,4 @@ public:
    ~VerilatedVarNameMap() {}
 };

-#endif // Guard
+#endif  // Guard
@@ -21,6 +21,7 @@

 #include "verilatedos.h"
 #include "verilated_threads.h"
+
 #include <cstdio>

 std::atomic<vluint64_t> VlNotification::s_yields;
@@ -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.
@@ -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>
@@ -123,9 +122,9 @@ public:
    class iterator {
    protected:
        // MEMBERS
-        size_t m_bucketIdx; //  Bucket this iterator points into.
-        typename Bucket::iterator m_bit; //  Bucket-local iterator.
-        const vl_unordered_set* m_setp;  //  The containing set.
+        size_t m_bucketIdx;  //  Bucket this iterator points into
+        typename Bucket::iterator m_bit;  // Bucket-local iterator
+        const vl_unordered_set* m_setp;  // The containing set

    public:
        // CONSTRUCTORS
@@ -470,7 +469,7 @@ private:

    // MEMBERS
    typedef vl_unordered_set<KeyValPair, KeyHash, KeyEqual> MapSet;
-    MapSet m_set;   //  Wrap this vl_unordered_set which holds all state.
+    MapSet m_set;  // Wrap this vl_unordered_set which holds all state.

 public:
    // CONSTRUCTORS
@@ -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])
@@ -227,7 +230,7 @@ void VerilatedVcd::makeNameMap() {
    for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
        VerilatedVcdCallInfo* cip = m_callbacks[ent];
        cip->m_code = m_nextCode;
-        (cip->m_initcb) (this, cip->m_userthis, cip->m_code);
+        (cip->m_initcb)(this, cip->m_userthis, cip->m_code);
    }

    // Though not speced, it's illegal to generate a vcd with signals
@@ -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 {
@@ -26,9 +26,9 @@
 #include "verilatedos.h"
 #include "verilated.h"

+#include <map>
 #include <string>
 #include <vector>
-#include <map>

 class VerilatedVcd;
 class VerilatedVcdCallInfo;
@@ -40,7 +40,7 @@ class VerilatedVcdCallInfo;

 class VerilatedVcdFile {
 private:
-    int                 m_fd;           ///< File descriptor we're writing to
+    int m_fd;  ///< File descriptor we're writing to
 public:
    // METHODS
    VerilatedVcdFile() : m_fd(0) {}
@@ -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
@@ -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"

@@ -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];
@@ -925,7 +921,7 @@ void VerilatedVpiError::selfTest() VL_MT_UNSAFE_ONE {

 vpiHandle vpi_register_cb(p_cb_data cb_data_p) {
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    // cppcheck-suppress nullPointer
    if (VL_UNLIKELY(!cb_data_p)) {
        _VL_VPI_WARNING(__FILE__, __LINE__, "%s : callback data pointer is null", VL_FUNC);
@@ -967,7 +963,7 @@ PLI_INT32 vpi_remove_cb(vpiHandle object) {
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_remove_cb %p\n",object););
    VerilatedVpiImp::assertOneCheck();
    VerilatedVpioCb* vop = VerilatedVpioCb::castp(object);
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    if (VL_UNLIKELY(!vop)) return 0;
    if (vop->cb_datap()->reason == cbAfterDelay) {
 	VerilatedVpiImp::cbTimedRemove(vop);
@@ -991,7 +987,7 @@ void vpi_get_systf_info(vpiHandle object, p_vpi_systf_data systf_data_p) {

 vpiHandle vpi_handle_by_name(PLI_BYTE8* namep, vpiHandle scope) {
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    if (VL_UNLIKELY(!namep)) return NULL;
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_handle_by_name %s %p\n",namep,scope););
    VerilatedVpioScope* voScopep = VerilatedVpioScope::castp(scope);
@@ -1028,7 +1024,7 @@ vpiHandle vpi_handle_by_index(vpiHandle object, PLI_INT32 indx) {
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_handle_by_index %p %d\n",object, indx););
    VerilatedVpiImp::assertOneCheck();
    VerilatedVpioVar* varop = VerilatedVpioVar::castp(object);
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    if (VL_LIKELY(varop)) {
 	if (varop->varp()->dims()<2) return 0;
        if (VL_LIKELY(varop->varp()->unpacked().left() >= varop->varp()->unpacked().right())) {
@@ -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
@@ -1055,7 +1049,7 @@ vpiHandle vpi_handle_by_index(vpiHandle object, PLI_INT32 indx) {
 vpiHandle vpi_handle(PLI_INT32 type, vpiHandle object) {
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_handle %d %p\n",type,object););
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    switch (type) {
    case vpiLeftRange: {
 	VerilatedVpioVar* vop = VerilatedVpioVar::castp(object);
@@ -1098,7 +1092,7 @@ vpiHandle vpi_handle_multi(PLI_INT32 type, vpiHandle refHandle1, vpiHandle refHa
 vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) {
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_iterate %d %p\n",type,object););
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    switch (type) {
    case vpiMemoryWord: {
 	VerilatedVpioVar* vop = VerilatedVpioVar::castp(object);
@@ -1136,7 +1130,7 @@ vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) {
 vpiHandle vpi_scan(vpiHandle object) {
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_scan %p\n",object););
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    VerilatedVpio* vop = VerilatedVpio::castp(object);
    if (VL_UNLIKELY(!vop)) return NULL;
    return vop->dovpi_scan();
@@ -1148,7 +1142,7 @@ PLI_INT32 vpi_get(PLI_INT32 property, vpiHandle object) {
    // Leave this in the header file - in many cases the compiler can constant propagate "object"
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_get %d %p\n",property,object););
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    switch (property) {
    case vpiTimePrecision: {
 	return VL_TIME_PRECISION;
@@ -1191,7 +1185,7 @@ PLI_BYTE8 *vpi_get_str(PLI_INT32 property, vpiHandle object) {
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_get_str %d %p\n",property,object););
    VerilatedVpiImp::assertOneCheck();
    VerilatedVpio* vop = VerilatedVpio::castp(object);
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    if (VL_UNLIKELY(!vop)) return NULL;
    switch (property) {
    case vpiName: {
@@ -1230,7 +1224,7 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
    static VL_THREAD_LOCAL int outStrSz = sizeof(outStr)-1;
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_get_value %p\n",object););
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    if (VL_UNLIKELY(!value_p)) return;
    if (VerilatedVpioVar* vop = VerilatedVpioVar::castp(object)) {
 	// We used to presume vpiValue.format = vpiIntVal or if single bit vpiScalarVal
@@ -1301,10 +1295,10 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
 		for (i=0; i<bits; ++i) {
 		    char val = (datap[i>>3]>>(i&7))&1;
 		    outStr[bits-i-1] = val?'1':'0';
-		}
-		outStr[i]=0; // NULL terminate
-		return;
-	    }
+                }
+                outStr[i] = '\0';
+                return;
+            }
 	    default:
 		_VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s",
                              VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format),
@@ -1351,10 +1345,10 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
 			}
 		    }
 		    outStr[chars-i-1] = '0' + (val&7);
-		}
-		outStr[i]=0; // NULL terminate
-		return;
-	    }
+                }
+                outStr[i] = '\0';
+                return;
+            }
 	    default:
                strcpy(outStr, "0");
 		_VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s",
@@ -1410,10 +1404,10 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
 			}
 		    }
 		    outStr[chars-i-1] = "0123456789abcdef"[static_cast<int>(val)];
-		}
-		outStr[i]=0; // NULL terminate
-		return;
-	    }
+                }
+                outStr[i] = '\0';
+                return;
+            }
 	    default:
 		_VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s",
 			      VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname());
@@ -1442,10 +1436,10 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
 		    char val = datap[bytes-i-1];
                     // other simulators replace [leading?] zero chars with spaces, replicate here.
 		    outStr[i] = val?val:' ';
-		}
-		outStr[i]=0; // NULL terminate
-		return;
-	    }
+                }
+                outStr[i] = '\0';
+                return;
+            }
 	    default:
 		_VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s",
 			      VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname());
@@ -1462,9 +1456,9 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
 	    case VLVT_UINT32:
 		value_p->value.integer = *(reinterpret_cast<IData*>(vop->varDatap()));
 		return;
-	    case VLVT_WDATA: // FALLTHRU
-	    case VLVT_UINT64: // FALLTHRU
-	    default:
+            case VLVT_WDATA:  // FALLTHRU
+            case VLVT_UINT64:  // FALLTHRU
+            default:
 		value_p->value.integer = 0;
                _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s",
 			      VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname());
@@ -1494,7 +1488,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
 			p_vpi_time time_p, PLI_INT32 flags) {
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_put_value %p %p\n",object, value_p););
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    if (VL_UNLIKELY(!value_p)) {
      _VL_VPI_WARNING(__FILE__, __LINE__, "Ignoring vpi_put_value with NULL value pointer");
      return 0;
@@ -1584,8 +1578,8 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
 		int len	 = strlen(value_p->value.str);
 		CData* datap = (reinterpret_cast<CData*>(vop->varDatap()));
                div_t idx;
-                datap[0] = 0; // reset zero'th byte
-		for (int i=0; i<chars; ++i) {
+                datap[0] = 0;  // reset zero'th byte
+                for (int i=0; i<chars; ++i) {
                    union {
 			char  byte[2];
                        short half;
@@ -1611,11 +1605,12 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
                    // signifcant byte of the aligned value is the most significant
                    // byte of the destination.
                    val.half <<= idx.rem;
-                    datap[idx.quot] |= val.byte[0]; // or in value
+                    datap[idx.quot] |= val.byte[0];  // or in value
                    if ((idx.quot+1) < bytes) {
-		        datap[idx.quot+1] = val.byte[1]; // this also resets all bits to 0 prior to or'ing above
-		    }
-		}
+                        datap[idx.quot+1] = val.byte[1];  // this also resets
+			// all bits to 0 prior to or'ing above
+                    }
+                }
                // mask off non existant bits in the most significant byte
                if (idx.quot == (bytes-1)) {
                    datap[idx.quot] &= vop->mask_byte(idx.quot);
@@ -1698,9 +1693,10 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
 		    if (i&1) {
 		        datap[i>>1] |= hex<<4;
 		    } else {
-		        datap[i>>1]  = hex; // this also resets all bits to 0 prior to or'ing above of the msb
-		    }
-		}
+                        datap[i>>1]  = hex;  // this also resets all
+			// bits to 0 prior to or'ing above of the msb
+                    }
+                }
                // apply bit mask to most significant byte
                datap[(chars-1)>>1] &= vop->mask_byte((chars-1)>>1);
 		return object;
@@ -1742,9 +1738,9 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
 	    case VLVT_UINT32:
 		*(reinterpret_cast<IData*>(vop->varDatap())) = vop->mask() & value_p->value.integer;
 		return object;
-	    case VLVT_WDATA: // FALLTHRU
-	    case VLVT_UINT64: // FALLTHRU
-	    default:
+            case VLVT_WDATA:  // FALLTHRU
+            case VLVT_UINT64:  // FALLTHRU
+            default:
                _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s",
 			      VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname());
 		return 0;
@@ -1795,13 +1791,13 @@ void vpi_get_time(vpiHandle object, p_vpi_time time_p) {

 PLI_UINT32 vpi_mcd_open(PLI_BYTE8 *filenamep) {
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    return VL_FOPEN_S(filenamep,"wb");
 }

 PLI_UINT32 vpi_mcd_close(PLI_UINT32 mcd) {
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    VL_FCLOSE_I(mcd); return 0;
 }

@@ -1811,7 +1807,7 @@ PLI_BYTE8 *vpi_mcd_name(PLI_UINT32 mcd) {

 PLI_INT32 vpi_mcd_printf(PLI_UINT32 mcd, PLI_BYTE8 *formatp, ...) {
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    va_list ap;
    va_start(ap,formatp);
    int chars = vpi_mcd_vprintf(mcd, formatp, ap);
@@ -1821,7 +1817,7 @@ PLI_INT32 vpi_mcd_printf(PLI_UINT32 mcd, PLI_BYTE8 *formatp, ...) {

 PLI_INT32 vpi_printf(PLI_BYTE8 *formatp, ...) {
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    va_list ap;
    va_start(ap,formatp);
    int chars = vpi_vprintf(formatp, ap);
@@ -1831,14 +1827,14 @@ PLI_INT32 vpi_printf(PLI_BYTE8 *formatp, ...) {

 PLI_INT32 vpi_vprintf(PLI_BYTE8* formatp, va_list ap) {
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    return VL_VPRINTF(formatp, ap);
 }

 PLI_INT32 vpi_mcd_vprintf(PLI_UINT32 mcd, PLI_BYTE8 *format, va_list ap) {
    VerilatedVpiImp::assertOneCheck();
    FILE* fp = VL_CVT_I_FP(mcd);
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    // cppcheck-suppress nullPointer
    if (VL_UNLIKELY(!fp)) return 0;
    int chars = vfprintf(fp, format, ap);
@@ -1847,7 +1843,7 @@ PLI_INT32 vpi_mcd_vprintf(PLI_UINT32 mcd, PLI_BYTE8 *format, va_list ap) {

 PLI_INT32 vpi_flush(void) {
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    Verilated::flushCall();
    return 0;
 }
@@ -1855,7 +1851,7 @@ PLI_INT32 vpi_flush(void) {
 PLI_INT32 vpi_mcd_flush(PLI_UINT32 mcd) {
    VerilatedVpiImp::assertOneCheck();
    FILE* fp = VL_CVT_I_FP(mcd);
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    if (VL_UNLIKELY(!fp)) return 1;
    fflush(fp);
    return 0;
@@ -1874,13 +1870,13 @@ PLI_INT32 vpi_chk_error(p_vpi_error_info error_info_p) {
    if (error_info_p && _error_info_p) {
      *error_info_p = *_error_info_p;
    }
-    if (!_error_info_p) return 0; // no error occured
+    if (!_error_info_p) return 0;  // no error occured
    return _error_info_p->level;  // return error severity level
 };

 PLI_INT32 vpi_free_object(vpiHandle object) {
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    return vpi_release_handle(object);  // Deprecated
 }

@@ -1888,7 +1884,7 @@ PLI_INT32 vpi_release_handle(vpiHandle object) {
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_release_handle %p\n",object););
    VerilatedVpiImp::assertOneCheck();
    VerilatedVpio* vop = VerilatedVpio::castp(object);
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    if (VL_UNLIKELY(!vop)) return 0;
    vpi_remove_cb(object);  // May not be a callback, but that's ok
    delete vop;
@@ -1897,7 +1893,7 @@ PLI_INT32 vpi_release_handle(vpiHandle object) {

 PLI_INT32 vpi_get_vlog_info(p_vpi_vlog_info vlog_info_p) VL_MT_SAFE {
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    vlog_info_p->argc = Verilated::getCommandArgs()->argc;
    vlog_info_p->argv = (PLI_BYTE8**)Verilated::getCommandArgs()->argv;
    vlog_info_p->product = (PLI_BYTE8*)Verilated::productName();
@@ -1923,7 +1919,7 @@ PLI_INT32 vpi_put_userdata(vpiHandle obj, void *userdata) {
 PLI_INT32 vpi_control(PLI_INT32 operation, ...) {
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_control %d\n",operation););
    VerilatedVpiImp::assertOneCheck();
-    _VL_VPI_ERROR_RESET(); // reset vpi error status
+    _VL_VPI_ERROR_RESET();
    switch (operation) {
    case vpiFinish: {
 	VL_FINISH_MT(__FILE__,__LINE__,"*VPI*");
@@ -24,8 +24,9 @@
 //=========================================================================

 #ifndef _VERILATED_VPI_H_
-#define _VERILATED_VPI_H_ 1 ///< Header Guard
+#define _VERILATED_VPI_H_ 1  ///< Header Guard

+#include "verilatedos.h"
 #include "verilated.h"
 #include "verilated_syms.h"

@@ -48,5 +49,4 @@ public:
    static void selfTest() VL_MT_UNSAFE_ONE;
 };

-
-#endif // Guard
+#endif  // Guard
@@ -28,7 +28,7 @@


 #ifndef _VERILATEDOS_H_
-#define _VERILATEDOS_H_ 1 ///< Header Guard
+#define _VERILATEDOS_H_ 1  ///< Header Guard

 //=========================================================================
 // Compiler pragma abstraction
@@ -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))
@@ -188,33 +188,33 @@

 #ifndef VL_WARNINGS
 # ifdef _MSC_VER
-#  pragma warning(disable:4099)	// C4099: type name first seen using 'class' now seen using 'struct' (V3AstNode)
-#  pragma warning(disable:4100)	// C4100: unreferenced formal parameter (L4)
-#  pragma warning(disable:4127)	// C4127: conditional expression is constant (L4)
-#  pragma warning(disable:4146)	// C4146: unary minus operator applied to unsigned type, result still unsigned
-#  pragma warning(disable:4189)	// C4189: local variable is initialized but not referenced (L4)
-#  pragma warning(disable:4244)	// C4244: conversion from 'uint64_t' to 'uint_32_t', possible loss of data
-#  pragma warning(disable:4245)	// C4245: conversion from 'int' to 'unsigned', signed/unsigned mismatch
-#  pragma warning(disable:4996)	// C4996: sscanf/fopen/etc may be unsafe
+#  pragma warning(disable:4099)  // C4099: type name first seen using 'class' now seen using 'struct' (V3AstNode)
+#  pragma warning(disable:4100)  // C4100: unreferenced formal parameter (L4)
+#  pragma warning(disable:4127)  // C4127: conditional expression is constant (L4)
+#  pragma warning(disable:4146)  // C4146: unary minus operator applied to unsigned type, result still unsigned
+#  pragma warning(disable:4189)  // C4189: local variable is initialized but not referenced (L4)
+#  pragma warning(disable:4244)  // C4244: conversion from 'uint64_t' to 'uint_32_t', possible loss of data
+#  pragma warning(disable:4245)  // C4245: conversion from 'int' to 'unsigned', signed/unsigned mismatch
+#  pragma warning(disable:4996)  // C4996: sscanf/fopen/etc may be unsafe
 # endif
 #endif

 //=========================================================================
 // 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
 typedef unsigned short int      vluint16_t;	///< 16-bit unsigned type
-# if defined(__uint32_t_defined) || defined(___int32_t_defined)    // Newer Cygwin uint32_t in stdint.h as an unsigned int
-typedef int32_t			vlsint32_t;	///< 32-bit signed type
-typedef uint32_t		vluint32_t;	///< 32-bit unsigned type
-# else				 		// Older Cygwin has long==uint32_t
+# if defined(__uint32_t_defined) || defined(___int32_t_defined)  // Newer Cygwin uint32_t in stdint.h as an unsigned int
+typedef int32_t                 vlsint32_t;     ///< 32-bit signed type
+typedef uint32_t                vluint32_t;     ///< 32-bit unsigned type
+# else  // Older Cygwin has long==uint32_t
 typedef unsigned long		uint32_t;	///< 32-bit unsigned type (backward compatibility)
 typedef long			vlsint32_t;	///< 32-bit signed type
 typedef unsigned long		vluint32_t;	///< 32-bit unsigned type
@@ -247,12 +247,12 @@ typedef signed   __int32        ssize_t;        ///< signed size_t; returned fro
 #  endif
 # endif

-#else // Linux or compliant Unix flavors, -m64
+#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 <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
@@ -272,7 +272,7 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type

 #ifdef _WIN32
 # define VL_PRI64 "I64"
-#else // Linux or compliant Unix flavors
+#else  // Linux or compliant Unix flavors
 # if defined(__WORDSIZE) && (__WORDSIZE == 64)
 #  define VL_PRI64 "l"
 # else
@@ -297,7 +297,7 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type

 #ifdef _WIN32
 # define VL_DEV_NULL "nul"
-#else // Linux or compliant Unix flavors
+#else  // Linux or compliant Unix flavors
 # define VL_DEV_NULL "/dev/null"
 #endif

@@ -341,9 +341,9 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 /// Mask for quads with 1's where relevant bits are (0=all bits)
 #define VL_MASK_Q(nbits)  (((nbits) & VL_SIZEBITS_Q) \
 			 ? ((VL_ULL(1) << ((nbits) & VL_SIZEBITS_Q) )-VL_ULL(1)) : VL_ULL(~0))
-#define VL_BITWORD_I(bit)	((bit)/VL_WORDSIZE)	///< Word number for a wide quantity
-#define VL_BITBIT_I(bit)	((bit)&VL_SIZEBITS_I)	///< Bit number for a bit in a long
-#define VL_BITBIT_Q(bit)	((bit)&VL_SIZEBITS_Q)	///< Bit number for a bit in a quad
+#define VL_BITWORD_I(bit) ((bit)/VL_WORDSIZE)  ///< Word number for a wide quantity
+#define VL_BITBIT_I(bit) ((bit)&VL_SIZEBITS_I)  ///< Bit number for a bit in a long
+#define VL_BITBIT_Q(bit) ((bit)&VL_SIZEBITS_Q)  ///< Bit number for a bit in a quad

 //=========================================================================
 // Floating point
@@ -8,7 +8,7 @@ use IO::File;
 use Pod::Usage;
 use Data::Dumper; $Data::Dumper::Indent=1;
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);

 #======================================================================

@@ -32,14 +32,14 @@ if (! GetOptions (
    usage();
 }

-dotread ($opt_filename);
+dotread($opt_filename);
 cwrite("graph_export.cpp");

 #----------------------------------------------------------------------

 sub usage {
    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
-    exit (1);
+    exit(1);
 }

 sub debug {
@@ -8,7 +8,7 @@ use IO::File;
 use Pod::Usage;
 use Data::Dumper; $Data::Dumper::Indent=1;
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);

 #======================================================================

@@ -35,7 +35,7 @@ if (! GetOptions (
    usage();
 }

-dotread ($opt_filename);
+dotread($opt_filename);
 circle($opt_circle) if $opt_circle;
 simplify();
 dotwrite();
@@ -44,7 +44,7 @@ dotwrite();

 sub usage {
    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
-    exit (1);
+    exit(1);
 }

 sub debug {
@@ -47,12 +47,12 @@ sub prep {
    my @lines;

    while (defined(my $line = $fh->getline)) {
-	# Productions
-	#$line =~ s/[ \t]{[^}]*?}/\t{}/g;
-	$line =~ s/StashPrefix;//g;
-	$line =~ s/VALTEXT;//g;
-	$line =~ s/CALLBACK\([^)]*\);//g;
-	push @lines, $line;
+        # Productions
+        #$line =~ s/[ \t]{[^}]*?}/\t{}/g;
+        $line =~ s/StashPrefix;//g;
+        $line =~ s/VALTEXT;//g;
+        $line =~ s/CALLBACK\([^)]*\);//g;
+        push @lines, $line;
    }

    #@lines = sort @lines;
@@ -8,21 +8,24 @@ use IO::File;
 use IO::Dir;
 use Pod::Usage;
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);

 our $VERSION = '0.001';
+our $Opt_Widen = 1;

 #======================================================================
 # main

 autoflush STDOUT 1;
 autoflush STDERR 1;
-Getopt::Long::config ("no_auto_abbrev");
+Getopt::Long::config("no_auto_abbrev");
 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,90 @@ 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 include }'s that finish basic block
+    foreach my $hunk (keys %hunk_lastlines) {
+        while (my $lineno = $hunk_lastlines{$hunk}) {
+            ++$lineno;
+            if (($editlines->{$lineno}{line} || "")
+                =~ /^[+ ]\s+}[ \t};]*$/) {
+                $hunk_lastlines{$hunk} = $lineno;
+            } else {
+                last;
+            }
+        }
+    }
+    # 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 +143,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 +168,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 +216,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.
@@ -7,7 +7,7 @@ use Cwd;
 use IO::File;
 use Pod::Usage;
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);

 #======================================================================
 # main
@@ -17,7 +17,7 @@ our $Opt_Jobs = calc_jobs();

 autoflush STDOUT 1;
 autoflush STDERR 1;
-Getopt::Long::config ("no_auto_abbrev");
+Getopt::Long::config("no_auto_abbrev");
 if (! GetOptions (
 	  "debug"	=> sub { $Debug = 1; },
 	  "<>"		=> sub { die "%Error: Unknown parameter: $_[0]\n"; },
@@ -8,7 +8,7 @@ use IO::File;
 use Pod::Usage;
 use Data::Dumper; $Data::Dumper::Indent=1;
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);

 #======================================================================

@@ -31,7 +31,7 @@ if (! GetOptions (
    usage();
 }

-vread ($opt_filename);
+vread($opt_filename);
 #print Dumper($Tree);
 vwrite();

@@ -41,7 +41,7 @@ print '(query-replace-regexp "(\\([0-9a-z_]+\\))" "\\1" nil nil nil)',"\n";

 sub usage {
    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
-    exit (1);
+    exit(1);
 }

 sub debug {
@@ -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
@@ -20,8 +20,10 @@

 #ifndef _V3ACTIVE_H_
 #define _V3ACTIVE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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"
@@ -20,8 +20,10 @@

 #ifndef _V3ACTIVETOP_H_
 #define _V3ACTIVETOP_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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

@@ -45,6 +43,7 @@ private:
    // STATE
    AstNodeModule*	m_modp;		// Last module
    AstBegin*	m_beginp;	// Last begin
+    unsigned    m_modPastNum;   // Module past numbering
    V3Double0	m_statAsCover;	// Statistic tracking
    V3Double0	m_statAsPsl;	// Statistic tracking
    V3Double0	m_statAsFull;	// Statistic tracking
@@ -76,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;
@@ -144,6 +144,10 @@ private:
            // than the sim-killing else clause:
            ifp->branchPred(AstBranchPred::BP_LIKELY);
            bodysp = newIfAssertOn(ifp);
+        } else if (VN_IS(nodep, PslRestrict)) {
+            // IEEE says simulator ignores these
+            pushDeletep(nodep->unlinkFrBack()); VL_DANGLING(nodep);
+            return;
 	} else {
 	    nodep->v3fatalSrc("Unknown node type");
 	}
@@ -185,6 +189,7 @@ private:
 	pushDeletep(nodep); VL_DANGLING(nodep);
    }

+    // VISITORS
    virtual void visit(AstIf* nodep) {
 	if (nodep->user1SetOnce()) return;
 	if (nodep->uniquePragma() || nodep->unique0Pragma()) {
@@ -244,7 +249,7 @@ private:
 	}
    }

-    // VISITORS  //========== Case assertions
+    //========== Case assertions
    virtual void visit(AstCase* nodep) {
        iterateChildren(nodep);
 	if (!nodep->user1SetOnce()) {
@@ -302,7 +307,38 @@ private:
 	}
    }

-    // VISITORS  //========== Statements
+    //========== Past
+    virtual void visit(AstPast* nodep) {
+        iterateChildren(nodep);
+        uint32_t ticks = 1;
+        if (nodep->ticksp()) {
+            if (!VN_IS(nodep->ticksp(), Const)) nodep->v3fatalSrc("Expected constant ticks, checked in V3Width");
+            ticks = VN_CAST(nodep->ticksp(), Const)->toUInt();
+        }
+        if (ticks<1) nodep->v3fatalSrc("0 tick should have been checked in V3Width");
+        AstNode* inp = nodep->exprp()->unlinkFrBack();
+        AstVar* invarp = NULL;
+        AstSenTree* sentreep = nodep->sentreep(); sentreep->unlinkFrBack();
+        AstAlways* alwaysp = new AstAlways(nodep->fileline(), VAlwaysKwd::ALWAYS,
+                                           sentreep, NULL);
+        m_modp->addStmtp(alwaysp);
+        for (uint32_t i=0; i<ticks; ++i) {
+            AstVar* outvarp = new AstVar(nodep->fileline(), AstVarType::MODULETEMP,
+                                         "_Vpast_"+cvtToStr(m_modPastNum++)+"_"+cvtToStr(i),
+                                         inp->dtypep());
+            m_modp->addStmtp(outvarp);
+            AstNode* assp = new AstAssignDly(nodep->fileline(),
+                                             new AstVarRef(nodep->fileline(), outvarp, true),
+                                             inp);
+            alwaysp->addStmtp(assp);
+            //if (debug()>-9) assp->dumpTree(cout, "-ass: ");
+            invarp = outvarp;
+            inp = new AstVarRef(nodep->fileline(), invarp, false);
+        }
+        nodep->replaceWith(inp);
+    }
+
+    //========== Statements
    virtual void visit(AstDisplay* nodep) {
        iterateChildren(nodep);
 	// Replace the special types with standard text
@@ -330,6 +366,7 @@ private:

    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
+        m_modPastNum = 0;
 	//
        iterateChildren(nodep);
 	// Reset defaults
@@ -354,6 +391,7 @@ public:
    explicit AssertVisitor(AstNetlist* nodep) {
 	m_beginp = NULL;
 	m_modp = NULL;
+        m_modPastNum = 0;
 	// Process
        iterate(nodep);
    }
@@ -20,8 +20,10 @@

 #ifndef _V3ASSERT_H_
 #define _V3ASSERT_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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
@@ -44,9 +41,11 @@ private:
    // NODE STATE/TYPES
    // STATE
    // Reset each module:
-    AstNodeSenItem*	m_seniDefaultp;	// Default sensitivity (from AstDefClock)
+    AstNodeSenItem* m_seniDefaultp;  // Default sensitivity (from AstDefClock)
    // Reset each assertion:
-    AstNodeSenItem*	m_senip;	// Last sensitivity
+    AstNodeSenItem* m_senip;  // Last sensitivity
+    // Reset each always:
+    AstNodeSenItem* m_seniAlwaysp;  // Last sensitivity in always

    // METHODS
    VL_DEBUG_FUNC;  // Declare debug()
@@ -55,7 +54,9 @@ private:
 	// Create sentree based on clocked or default clock
 	// Return NULL for always
 	AstSenTree* newp = NULL;
-	AstNodeSenItem* senip = m_senip ? m_senip : m_seniDefaultp;
+        AstNodeSenItem* senip = m_senip;
+        if (!senip) senip = m_seniDefaultp;
+        if (!senip) senip = m_seniAlwaysp;
 	if (!senip) {
 	    nodep->v3error("Unsupported: Unclocked assertion");
 	    newp = new AstSenTree(nodep->fileline(), NULL);
@@ -68,7 +69,8 @@ private:
 	m_senip = NULL;
    }

-    // VISITORS  //========== Statements
+    // VISITORS
+    //========== Statements
    virtual void visit(AstClocking* nodep) {
 	UINFO(8,"   CLOCKING"<<nodep<<endl);
 	// Store the new default clock, reset on new module
@@ -81,16 +83,31 @@ private:
 	}
 	pushDeletep(nodep); VL_DANGLING(nodep);
    }
+    virtual void visit(AstAlways* nodep) {
+        iterateAndNextNull(nodep->sensesp());
+        if (nodep->sensesp()) {
+            m_seniAlwaysp = nodep->sensesp()->sensesp();
+        }
+        iterateAndNextNull(nodep->bodysp());
+        m_seniAlwaysp = NULL;
+    }

    virtual void visit(AstNodePslCoverOrAssert* nodep) {
 	if (nodep->sentreep()) return;  // Already processed
 	clearAssertInfo();
+        // Find PslClocking's burried under nodep->exprsp
        iterateChildren(nodep);
 	nodep->sentreep(newSenTree(nodep));
 	clearAssertInfo();
    }
-    virtual void visit(AstPslClocked* nodep) {
+    virtual void visit(AstPast* nodep) {
+        if (nodep->sentreep()) return;  // Already processed
        iterateChildren(nodep);
+        nodep->sentreep(newSenTree(nodep));
+    }
+    virtual void visit(AstPslClocked* nodep) {
+        // No need to iterate the body, once replace will get iterated
+        iterateAndNextNull(nodep->sensesp());
 	if (m_senip) {
 	    nodep->v3error("Unsupported: Only one PSL clock allowed per assertion");
 	}
@@ -120,6 +137,7 @@ public:
    // CONSTRUCTORS
    explicit AssertPreVisitor(AstNetlist* nodep) {
 	m_seniDefaultp = NULL;
+        m_seniAlwaysp = NULL;
 	clearAssertInfo();
 	// Process
        iterate(nodep);
@@ -20,8 +20,10 @@

 #ifndef _V3ASSERTPRE_H_
 #define _V3ASSERTPRE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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);
    }
@@ -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
@@ -463,18 +464,61 @@ public:

 //######################################################################

+class VDirection {
+public:
+    enum en {
+        NONE,
+        INPUT,
+        OUTPUT,
+        INOUT,
+        REF,
+        CONSTREF
+    };
+    enum en m_e;
+    inline VDirection() : m_e(NONE) {}
+    // cppcheck-suppress noExplicitConstructor
+    inline VDirection(en _e) : m_e(_e) {}
+    explicit inline VDirection(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
+    const char* ascii() const {
+        static const char* const names[] = {
+            "NONE", "INPUT", "OUTPUT", "INOUT", "REF", "CONSTREF"};
+        return names[m_e]; }
+    string verilogKwd() const {
+        static const char* const names[] = {
+            "", "input", "output", "inout", "ref", "const ref"};
+        return names[m_e]; }
+    string xmlKwd() const {  // For historical reasons no "put" suffix
+        static const char* const names[] = {
+            "", "in", "out", "inout", "ref", "const ref"};
+        return names[m_e]; }
+    string prettyName() const { return verilogKwd(); }
+    bool isAny() const { return m_e != NONE; }
+    // Looks like inout - "ish" because not identical to being an INOUT
+    bool isInoutish() const { return m_e == INOUT; }
+    bool isNonOutput() const { return m_e == INPUT || m_e == INOUT
+            || m_e == REF || m_e == CONSTREF; }
+    bool isReadOnly() const { return m_e == INPUT || m_e == CONSTREF; }
+    bool isWritable() const { return m_e == OUTPUT || m_e == INOUT
+            || m_e == REF; }
+    bool isRefOrConstRef() const { return m_e == REF || m_e == CONSTREF; }
+  };
+  inline bool operator== (VDirection lhs, VDirection rhs) { return (lhs.m_e == rhs.m_e); }
+  inline bool operator== (VDirection lhs, VDirection::en rhs) { return (lhs.m_e == rhs); }
+  inline bool operator== (VDirection::en lhs, VDirection rhs) { return (lhs == rhs.m_e); }
+  inline std::ostream& operator<<(std::ostream& os, const VDirection& rhs) { return os<<rhs.ascii(); }
+
+//######################################################################
+
 class AstVarType {
 public:
    enum en {
-	UNKNOWN,
-	GPARAM,
-	LPARAM,
-	GENVAR,
-	VAR,		// Reg, integer, logic, etc
-	INPUT,
-	OUTPUT,
-	INOUT,
-	SUPPLY0,
+        UNKNOWN,
+        GPARAM,
+        LPARAM,
+        GENVAR,
+        VAR,  // Reg, integer, logic, etc
+        SUPPLY0,
 	SUPPLY1,
 	WIRE,
 	WREAL,
@@ -496,20 +540,35 @@ public:
    explicit inline AstVarType(int _e) : m_e(static_cast<en>(_e)) {}
    operator en() const { return m_e; }
    const char* ascii() const {
-	static const char* const names[] = {
-	    "?","GPARAM","LPARAM","GENVAR",
-	    "VAR","INPUT","OUTPUT","INOUT",
-	    "SUPPLY0","SUPPLY1","WIRE","WREAL","IMPLICITWIRE",
-	    "TRIWIRE","TRI0","TRI1",
-	    "PORT",
-	    "BLOCKTEMP","MODULETEMP","STMTTEMP","XTEMP",
-	    "IFACEREF"};
-	return names[m_e]; }
-    bool isSignal() const  { return (m_e==WIRE || m_e==WREAL || m_e==IMPLICITWIRE
-				     || m_e==TRIWIRE
-				     || m_e==TRI0 || m_e==TRI1
-				     || m_e==SUPPLY0 || m_e==SUPPLY1
-				     || m_e==VAR); }
+        static const char* const names[] = {
+            "?", "GPARAM", "LPARAM", "GENVAR", "VAR",
+            "SUPPLY0", "SUPPLY1", "WIRE", "WREAL", "IMPLICITWIRE",
+            "TRIWIRE", "TRI0", "TRI1",
+            "PORT",
+            "BLOCKTEMP", "MODULETEMP", "STMTTEMP", "XTEMP",
+            "IFACEREF"};
+        return names[m_e]; }
+    bool isSignal() const {
+        return (m_e==WIRE || m_e==WREAL || m_e==IMPLICITWIRE
+                || m_e==TRIWIRE
+                || m_e==TRI0 || m_e==TRI1 || m_e==PORT
+                || m_e==SUPPLY0 || m_e==SUPPLY1
+                || m_e==VAR);
+    }
+    bool isContAssignable() const {  // In Verilog, always ok in SystemVerilog
+        return (m_e==SUPPLY0 || m_e==SUPPLY1
+                || m_e==WIRE || m_e==WREAL || m_e==IMPLICITWIRE
+                || m_e==TRIWIRE || m_e==TRI0 || m_e==TRI1 || m_e==PORT
+                || m_e==BLOCKTEMP || m_e==MODULETEMP || m_e==STMTTEMP
+                || m_e==XTEMP || m_e==IFACEREF);
+    }
+    bool isProcAssignable() const {
+        return (m_e==GPARAM || m_e==LPARAM || m_e==GENVAR
+                || m_e==VAR
+                || m_e==TRIWIRE || m_e==TRI0 || m_e==TRI1 || m_e==PORT
+                || m_e==BLOCKTEMP || m_e==MODULETEMP || m_e==STMTTEMP
+                || m_e==XTEMP || m_e==IFACEREF);
+    }
  };
  inline bool operator== (AstVarType lhs, AstVarType rhs) { return (lhs.m_e == rhs.m_e); }
  inline bool operator== (AstVarType lhs, AstVarType::en rhs) { return (lhs.m_e == rhs); }
@@ -1026,7 +1085,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 +1229,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 +1405,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 +1856,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 +1868,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 +1897,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; }
@@ -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

@@ -181,89 +178,98 @@ void AstVar::combineType(AstVarType type) {
    // These flags get combined with the existing settings of the flags.
    // We don't test varType for certain types, instead set flags since
    // when we combine wires cross-hierarchy we need a union of all characteristics.
-    if (type == AstVarType::SUPPLY0) type = AstVarType::WIRE;
-    if (type == AstVarType::SUPPLY1) type = AstVarType::WIRE;
-    m_varType=type; 	// For debugging prints only
+    m_varType = type;
    // These flags get combined with the existing settings of the flags.
-    if (type==AstVarType::INPUT || type==AstVarType::INOUT)
-	m_input = true;
-    if (type==AstVarType::OUTPUT || type==AstVarType::INOUT) {
-	m_output = true;
-	m_declOutput = true;
+    if (type==AstVarType::TRIWIRE || type==AstVarType::TRI0 || type==AstVarType::TRI1) {
+        m_tristate = true;
+    }
+    if (type==AstVarType::TRI0) {
+        m_isPulldown = true;
+    }
+    if (type==AstVarType::TRI1) {
+        m_isPullup = true;
    }
-    if (type==AstVarType::INOUT || type==AstVarType::TRIWIRE
-	|| type==AstVarType::TRI0 || type==AstVarType::TRI1)
-	m_tristate = true;
-    if (type==AstVarType::TRI0)
-	m_isPulldown = true;
-    if (type==AstVarType::TRI1)
-	m_isPullup = true;
 }

 string AstVar::verilogKwd() const {
-    if (isInout()) {
-	return "inout";
-    } else if (isInput()) {
-	return "input";
-    } else if (isOutput()) {
-	return "output";
+    if (isIO()) {
+        return direction().verilogKwd();
    } else if (isTristate()) {
-	return "tri";
+        return "tri";
    } else if (varType()==AstVarType::WIRE) {
-	return "wire";
+        return "wire";
    } else if (varType()==AstVarType::WREAL) {
-	return "wreal";
+        return "wreal";
    } else {
-	return dtypep()->name();
+        return dtypep()->name();
    }
 }

 string AstVar::vlArgType(bool named, bool forReturn, bool forFunc) const {
    if (forReturn) named=false;
    if (forReturn) v3fatalSrc("verilator internal data is never passed as return, but as first argument");
-    string arg;
-    if (isWide() && isInOnly()) arg += "const ";
+    string otype;
    AstBasicDType* bdtypep = basicp();
    bool strtype = bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::STRING;
    if (bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::CHARPTR) {
-	arg += "const char*";
+        otype += "const char*";
    } else if (bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::SCOPEPTR) {
-	arg += "const VerilatedScope*";
+        otype += "const VerilatedScope*";
    } else if (bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::DOUBLE) {
-	arg += "double";
+        if (forFunc && isReadOnly()) otype += "const ";
+        otype += "double";
    } else if (bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::FLOAT) {
-	arg += "float";
+        if (forFunc && isReadOnly()) otype += "const ";
+        otype += "float";
    } else if (strtype) {
-	if (isInOnly()) arg += "const ";
-	arg += "std::string";
+        if (forFunc && isReadOnly()) otype += "const ";
+        otype += "std::string";
    } else if (widthMin() <= 8) {
-	arg += "CData";
+        if (forFunc && isReadOnly()) otype += "const ";
+        otype += "CData";
    } else if (widthMin() <= 16) {
-	arg += "SData";
+        if (forFunc && isReadOnly()) otype += "const ";
+        otype += "SData";
    } else if (widthMin() <= VL_WORDSIZE) {
-	arg += "IData";
+        if (forFunc && isReadOnly()) otype += "const ";
+        otype += "IData";
    } else if (isQuad()) {
-	arg += "QData";
+        if (forFunc && isReadOnly()) otype += "const ";
+        otype += "QData";
    } else if (isWide()) {
-	arg += "WData";  // []'s added later
+        if (forFunc && isReadOnly()) otype += "const ";
+        otype += "WData";  // []'s added later
    }
-    if (isDpiOpenArray() || (isWide() && !strtype)) {
-        arg += " (& "+name()+")";
+
+    bool mayparen = false;  // Need paren, to handle building "(& name)[2]"
+    string oname;
+    if (isDpiOpenArray()
+        || (isWide() && !strtype)
+        || (forFunc && (isWritable()
+                        || direction()==VDirection::REF
+                        || direction()==VDirection::CONSTREF
+                        || (strtype && isNonOutput())))) {
+        oname += "&";
+        mayparen = true;
+    }
+    if (named) oname += " "+name();
+
+    string oarray;
+    if (isDpiOpenArray() || direction().isRefOrConstRef()) {
        for (AstNodeDType* dtp=dtypep(); dtp; ) {
            dtp = dtp->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
            if (AstUnpackArrayDType* adtypep = VN_CAST(dtp, UnpackArrayDType)) {
-                arg += "["+cvtToStr(adtypep->declRange().elements())+"]";
+                if (mayparen) { oname = " ("+oname+")"; mayparen = false; }
+                oarray += "["+cvtToStr(adtypep->declRange().elements())+"]";
                dtp = adtypep->subDTypep();
            } else break;
        }
-        if (isWide() && !strtype) {
-            arg += "["+cvtToStr(widthWords())+"]";
-        }
-    } else {
-        if (forFunc && (isOutput() || (strtype && isInput()))) arg += "&";
-	if (named) arg += " "+name();
    }
-    return arg;
+    if (isWide() && !strtype) {
+        if (mayparen) { oname = " ("+oname+")"; mayparen = false; }
+        oarray += "["+cvtToStr(widthWords())+"]";
+    }
+    return otype+oname+oarray;
 }

 string AstVar::vlEnumType() const {
@@ -293,12 +299,12 @@ string AstVar::vlEnumType() const {

 string AstVar::vlEnumDir() const {
    string out;
-    if (isInout()) {
+    if (isInoutish()) {
        out = "VLVD_INOUT";
-    } else if (isInOnly()) {
-        out = "VLVD_IN";
-    } else if (isOutOnly()) {
+    } else if (isWritable()) {
        out = "VLVD_OUT";
+    } else if (isNonOutput()) {
+        out = "VLVD_IN";
    } else {
        out = "VLVD_NODIR";
    }
@@ -339,7 +345,7 @@ string AstVar::vlPropInit() const {
 string AstVar::cPubArgType(bool named, bool forReturn) const {
    if (forReturn) named=false;
    string arg;
-    if (isWide() && isInOnly()) arg += "const ";
+    if (isWide() && isReadOnly()) arg += "const ";
    if (widthMin() == 1) {
 	arg += "bool";
    } else if (widthMin() <= VL_WORDSIZE) {
@@ -354,8 +360,9 @@ string AstVar::cPubArgType(bool named, bool forReturn) const {
 	arg += " (& "+name();
 	arg += ")["+cvtToStr(widthWords())+"]";
    } else {
-	if (isOutput() && !forReturn) arg += "&";
-	if (named) arg += " "+name();
+        if (!forReturn && (isWritable()
+                           || direction().isRefOrConstRef())) arg += "&";
+        if (named) arg += " "+name();
    }
    return arg;
 }
@@ -370,11 +377,11 @@ string AstVar::dpiArgType(bool named, bool forReturn) const {
    } else if (basicp()->keyword().isDpiBitVal()) {
 	if (widthMin() == 1) {
 	    arg = "unsigned char";
-	    if (!forReturn && isOutput()) arg += "*";
-	} else {
-	    if (forReturn) {
-		arg = "svBitVecVal";
-	    } else if (isInOnly()) {
+            if (!forReturn && isWritable()) arg += "*";
+        } else {
+            if (forReturn) {
+                arg = "svBitVecVal";
+            } else if (isReadOnly()) {
 		arg = "const svBitVecVal*";
 	    } else {
 		arg = "svBitVecVal*";
@@ -383,11 +390,11 @@ string AstVar::dpiArgType(bool named, bool forReturn) const {
    } else if (basicp()->keyword().isDpiLogicVal()) {
        if (widthMin() == 1) {
            arg = "unsigned char";
-            if (!forReturn && isOutput()) arg += "*";
+            if (!forReturn && isWritable()) arg += "*";
        } else {
            if (forReturn) {
                arg = "svLogicVecVal";
-            } else if (isInOnly()) {
+            } else if (isReadOnly()) {
                arg = "const svLogicVecVal*";
            } else {
                arg = "svLogicVecVal*";
@@ -397,8 +404,8 @@ string AstVar::dpiArgType(bool named, bool forReturn) const {
 	arg = basicp()->keyword().dpiType();
 	if (basicp()->keyword().isDpiUnsignable() && !basicp()->isSigned()) {
 	    arg = "unsigned "+arg;
-	}
-	if (!forReturn && isOutput()) arg += "*";
+        }
+        if (!forReturn && isWritable()) arg += "*";
    }
    if (named) arg += " "+name();
    return arg;
@@ -580,13 +587,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 +622,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 +663,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 +713,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 +816,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
@@ -898,7 +908,7 @@ void AstModportFTaskRef::dump(std::ostream& str) {
 }
 void AstModportVarRef::dump(std::ostream& str) {
    this->AstNode::dump(str);
-    str<<" "<<varType();
+    if (direction().isAny()) str<<" "<<direction();
    if (varp()) { str<<" -> "; varp()->dump(str); }
    else { str<<" -> UNLINKED"; }
 }
@@ -930,7 +940,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 +1003,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 +1050,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 +1061,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); }
@@ -1061,12 +1071,8 @@ void AstVarRef::dump(std::ostream& str) {
 void AstVar::dump(std::ostream& str) {
    this->AstNode::dump(str);
    if (isSc()) str<<" [SC]";
-    if (isPrimaryIO()) str<<(isInout()?" [PIO]":(isInput()?" [PI]":" [PO]"));
-    else {
-	if (isInout()) str<<" [IO]";
-	else if (isInput()) str<<" [I]";
-	else if (isOutput()) str<<" [O]";
-    }
+    if (isPrimaryIO()) str<<(isInoutish()?" [PIO]":(isWritable()?" [PO]":" [PI]"));
+    if (isIO()) str<<" "<<direction().ascii();
    if (isConst()) str<<" [CONST]";
    if (isPullup()) str<<" [PULLUP]";
    if (isPulldown()) str<<" [PULLDOWN]";
@@ -1096,7 +1102,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 +1118,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 +1165,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 += "...";
    }
@@ -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
@@ -1093,10 +1096,10 @@ private:
    string	m_origName;	// Original name before dot addition
    string      m_tag;          // Holds the string of the verilator tag -- used in XML output.
    AstVarType	m_varType;	// Type of variable
-    bool	m_input:1;	// Input or inout
-    bool	m_output:1;	// Output or inout
+    VDirection  m_direction;    // Direction input/output etc
+    VDirection  m_declDirection;    // Declared direction input/output etc
+    AstBasicDTypeKwd m_declKwd;  // Keyword at declaration time
    bool	m_tristate:1;	// Inout or triwire or trireg
-    bool	m_declOutput:1; // Inout or output before tristate resolution
    bool	m_primaryIO:1;	// In/out to top level (or directly assigned from same)
    bool	m_sc:1;		// SystemC variable
    bool	m_scClocked:1;	// SystemC sc_clk<> needed
@@ -1127,10 +1130,9 @@ private:
    AstVarAttrClocker m_attrClocker;
    MTaskIdSet  m_mtaskIds;  // MTaskID's that read or write this var

-    void	init() {
-	m_input=false; m_output=false; m_tristate=false; m_declOutput=false;
-	m_primaryIO=false;
-	m_sc=false; m_scClocked=false; m_scSensitive=false;
+    void init() {
+        m_tristate=false; m_primaryIO=false;
+        m_sc=false; m_scClocked=false; m_scSensitive=false;
 	m_usedClock=false; m_usedParam=false; m_usedLoopIdx=false;
 	m_sigPublic=false; m_sigModPublic=false; m_sigUserRdPublic=false; m_sigUserRWPublic=false;
 	m_funcLocal=false; m_funcReturn=false;
@@ -1148,6 +1150,8 @@ public:
 	combineType(type);
 	childDTypep(dtp);  // Only for parser
 	dtypep(NULL);  // V3Width will resolve
+        if (dtp->basicp()) m_declKwd = dtp->basicp()->keyword();
+        else m_declKwd = AstBasicDTypeKwd::LOGIC;
    }
    AstVar(FileLine* fl, AstVarType type, const string& name, AstNodeDType* dtp)
 	:AstNode(fl)
@@ -1156,6 +1160,8 @@ public:
 	combineType(type);
 	UASSERT(dtp,"AstVar created with no dtype");
 	dtypep(dtp);
+        if (dtp->basicp()) m_declKwd = dtp->basicp()->keyword();
+        else m_declKwd = AstBasicDTypeKwd::LOGIC;
    }
    AstVar(FileLine* fl, AstVarType type, const string& name, VFlagLogicPacked, int wantwidth)
 	:AstNode(fl)
@@ -1163,6 +1169,7 @@ public:
 	init();
 	combineType(type);
 	dtypeSetLogicSized(wantwidth,wantwidth,AstNumeric::UNSIGNED);
+        m_declKwd = AstBasicDTypeKwd::LOGIC;
    }
    AstVar(FileLine* fl, AstVarType type, const string& name, VFlagBitPacked, int wantwidth)
 	:AstNode(fl)
@@ -1170,6 +1177,7 @@ public:
 	init();
 	combineType(type);
 	dtypeSetLogicSized(wantwidth,wantwidth,AstNumeric::UNSIGNED);
+        m_declKwd = AstBasicDTypeKwd::BIT;
    }
    AstVar(FileLine* fl, AstVarType type, const string& name, AstVar* examplep)
 	:AstNode(fl)
@@ -1180,6 +1188,7 @@ public:
 	    childDTypep(examplep->childDTypep()->cloneTree(true));
 	}
 	dtypeFrom(examplep);
+        m_declKwd = examplep->declKwd();
    }
    ASTNODE_NODE_FUNCS(Var)
    virtual void dump(std::ostream& str);
@@ -1189,9 +1198,17 @@ public:
    string origName() const { return m_origName; }		// * = Original name
    void origName(const string& name) { m_origName = name; }
    AstVarType varType() const { return m_varType; }  // * = Type of variable
+    void direction(const VDirection& flag) {
+        m_direction = flag;
+        if (m_direction == VDirection::INOUT) m_tristate = true; }
+    VDirection direction() const { return m_direction; }
+    bool isIO() const { return m_direction != VDirection::NONE; }
+    void declDirection(const VDirection& flag) { m_declDirection = flag; }
+    VDirection declDirection() const { return m_declDirection; }
    void varType(AstVarType type) { m_varType = type; }
-    void varType2Out() { m_tristate=0; m_input=0; m_output=1; }
-    void varType2In() {  m_tristate=0; m_input=1; m_output=0; }
+    void varType2Out() { m_tristate=0; m_direction=VDirection::OUTPUT; }
+    void varType2In() {  m_tristate=0; m_direction=VDirection::INPUT; }
+    AstBasicDTypeKwd declKwd() const { return m_declKwd; }
    string	scType() const;	  // Return SysC type: bool, uint32_t, uint64_t, sc_bv
    string	cPubArgType(bool named, bool forReturn) const;  // Return C /*public*/ type for argument: bool, uint32_t, uint64_t, etc.
    string	dpiArgType(bool named, bool forReturn) const;  // Return DPI-C type for argument
@@ -1245,18 +1262,13 @@ public:
    virtual void name(const string& name) { m_name = name; }
    virtual void tag(const string& text) { m_tag = text;}
    virtual string tag() const { return m_tag; }
-    virtual string directionName() const { return (isInout() ? "inout" : isInput() ? "input"
-						   : isOutput() ? "output" : varType().ascii()); }
-    bool	isInput() const { return m_input; }
-    bool	isOutput() const { return m_output; }
-    bool	isInOnly() const { return m_input && !m_output; }
-    bool	isOutOnly() const { return m_output && !m_input; }
-    bool	isInout() const { return m_input && m_output; }
-    bool	isTristate() const  { return m_tristate; }
-    bool	isDeclOutput() const  { return m_declOutput; }
-    bool	isPrimaryIO() const { return m_primaryIO; }
-    bool	isPrimaryIn() const { return isPrimaryIO() && isInput(); }
-    bool	isIO() const  { return (m_input||m_output); }
+    bool isInoutish() const { return m_direction.isInoutish(); }
+    bool isNonOutput() const { return m_direction.isNonOutput(); }
+    bool isReadOnly() const { return m_direction.isReadOnly(); }
+    bool isWritable() const { return m_direction.isWritable(); }
+    bool isTristate() const { return m_tristate; }
+    bool isPrimaryIO() const { return m_primaryIO; }
+    bool isPrimaryInish() const { return isPrimaryIO() && isNonOutput(); }
    bool	isIfaceRef() const { return (varType()==AstVarType::IFACEREF); }
    bool	isIfaceParent() const { return m_isIfaceParent; }
    bool	isSignal() const  { return varType().isSignal(); }
@@ -1312,8 +1324,9 @@ public:
 	// Ok to gate optimize; must return false if propagateAttrFrom would do anything
 	return (!attrClockEn() && !isUsedClock());
    }
-    void	combineType(AstVar* typevarp) {
-	// This is same as typevarp (for combining input & reg decls)
+    void combineType(AstVar* typevarp) {
+        // This is same as typevarp (for combining input & reg decls)
+        // "this" is the input var. typevarp is the reg var.
 	propagateAttrFrom(typevarp);
 	combineType(typevarp->varType());
 	if (typevarp->isSigPublic()) sigPublic(true);
@@ -1323,9 +1336,11 @@ public:
 	if (typevarp->attrScClocked()) attrScClocked(true);
    }
    void	inlineAttrReset(const string& name) {
-	m_input=m_output=false; m_name = name;
-	if (varType()==AstVarType::INOUT) m_varType = AstVarType::TRIWIRE;
-	if (varType()==AstVarType::INPUT || varType()==AstVarType::OUTPUT) m_varType = AstVarType::WIRE;
+        if (direction()==VDirection::INOUT && varType()==AstVarType::WIRE) {
+            m_varType = AstVarType::TRIWIRE;
+        }
+        m_direction = VDirection::NONE;
+        m_name = name;
    }
    static AstVar* scVarRecurse(AstNode* nodep);
    void addProducingMTaskId(int id) { m_mtaskIds.insert(id); }
@@ -1391,7 +1406,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
@@ -1563,10 +1578,13 @@ public:
 	return NULL; }
    virtual string name()	const { return m_name; }		// * = Pin name, ""=go by number
    virtual void name(const string& name) { m_name = name; }
-    virtual string prettyOperatorName() const { return modVarp()
-	    ? (modVarp()->directionName()+" port connection '"+modVarp()->prettyName()+"'")
-	    : "port connection"; }
-    bool	dotStar()	const { return name() == ".*"; }	// Special fake name for .* connections until linked
+    virtual string prettyOperatorName() const {
+        return modVarp() ? ((modVarp()->direction().isAny()
+                             ? modVarp()->direction().prettyName()+" "
+                             : "")
+                            +"port connection '"+modVarp()->prettyName()+"'")
+            : "port connection"; }
+    bool dotStar() const { return name() == ".*"; }  // Fake name for .* connections until linked
    int		pinNum()	const { return m_pinNum; }
    void	exprp(AstNode* nodep) { addOp1p(nodep); }
    AstNode*	exprp()		const { return op1p(); }	// op1 = Expression connected to pin, NULL if unconnected
@@ -1716,19 +1734,18 @@ class AstModportVarRef : public AstNode {
    // PARENT: AstModport
 private:
    string	m_name;		// Name of the variable referenced
-    AstVarType	m_type;		// Type of the variable (in/out)
-    AstVar*	m_varp;		// Link to the actual Var
+    VDirection  m_direction;    // Direction of the variable (in/out)
+    AstVar*     m_varp;         // Link to the actual Var
 public:
-    AstModportVarRef(FileLine* fl, const string& name, AstVarType::en type)
-	: AstNode(fl), m_name(name), m_type(type), m_varp(NULL) { }
+    AstModportVarRef(FileLine* fl, const string& name, VDirection::en direction)
+        : AstNode(fl), m_name(name), m_direction(direction), m_varp(NULL) { }
    ASTNODE_NODE_FUNCS(ModportVarRef)
    virtual const char* broken() const { BROKEN_RTN(m_varp && !m_varp->brokeExists()); return NULL; }
    virtual void dump(std::ostream& str);
    virtual void cloneRelink() { if (m_varp && m_varp->clonep()) m_varp = m_varp->clonep(); }
    virtual string name() const { return m_name; }
-    AstVarType	varType() const { return m_type; }		// * = Type of variable
-    bool isInput() const { return (varType()==AstVarType::INPUT || varType()==AstVarType::INOUT); }
-    bool isOutput() const { return (varType()==AstVarType::OUTPUT || varType()==AstVarType::INOUT); }
+    void direction(const VDirection& flag) { m_direction = flag; }
+    VDirection direction() const { return m_direction; }
    AstVar* varp() const { return m_varp; }		// [After Link] Pointer to variable
    void varp(AstVar* varp) { m_varp=varp; }
 };
@@ -2155,7 +2172,7 @@ public:
    //
    virtual void dump(std::ostream& str);
    AstSenTree* sensesp() const { return VN_CAST(op1p(), SenTree); }  // op1 = Sensitivity list
-    AstNode*	bodysp() 	const { return op2p(); }	// op2 = Statements to evaluate
+    AstNode* bodysp() const { return op2p(); }  // op2 = Statements to evaluate
    void addStmtp(AstNode* nodep) { addOp2p(nodep); }
    VAlwaysKwd keyword() const { return m_keyword; }
    // Special accessors
@@ -2571,8 +2588,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
@@ -3351,8 +3368,13 @@ private:
    VNumRange	m_bitRange;	// Property of var the trace details
    VNumRange	m_arrayRange;	// Property of var the trace details
    uint32_t	m_codeInc;	// Code increment
+    AstVarType  m_varType;      // Type of variable (for localparam vs. param)
+    AstBasicDTypeKwd m_declKwd;  // Keyword at declaration time
+    VDirection  m_declDirection;  // Declared direction input/output etc
 public:
-    AstTraceDecl(FileLine* fl, const string& showname, AstNode* valuep,
+    AstTraceDecl(FileLine* fl, const string& showname,
+                 AstVar* varp,  // For input/output state etc
+                 AstNode* valuep,
 		 const VNumRange& bitRange, const VNumRange& arrayRange)
 	: AstNodeStmt(fl)
 	, m_showname(showname), m_bitRange(bitRange), m_arrayRange(arrayRange) {
@@ -3360,20 +3382,26 @@ public:
 	m_code = 0;
 	m_codeInc = ((arrayRange.ranged() ? arrayRange.elements() : 1)
 		     * valuep->dtypep()->widthWords());
+        m_varType = varp->varType();
+        m_declKwd = varp->declKwd();
+        m_declDirection = varp->declDirection();
    }
-    virtual int instrCount()	const { return 100; }  // Large...
+    virtual int instrCount() const { return 100; }  // Large...
    ASTNODE_NODE_FUNCS(TraceDecl)
-    virtual string name()	const { return m_showname; }
+    virtual string name() const { return m_showname; }
    virtual bool maybePointedTo() const { return true; }
    virtual bool hasDType() const { return true; }
    virtual bool same(const AstNode* samep) const { return false; }
    string showname()	const { return m_showname; }		// * = Var name
    // Details on what we're tracing
-    uint32_t	code() const { return m_code; }
-    void	code(uint32_t code) { m_code=code; }
-    uint32_t	codeInc() const { return m_codeInc; }
+    uint32_t code() const { return m_code; }
+    void code(uint32_t code) { m_code=code; }
+    uint32_t codeInc() const { return m_codeInc; }
    const VNumRange& bitRange() const { return m_bitRange; }
    const VNumRange& arrayRange() const { return m_arrayRange; }
+    AstVarType varType() const { return m_varType; }
+    AstBasicDTypeKwd declKwd() const { return m_declKwd; }
+    VDirection declDirection() const { return m_declDirection; }
 };

 class AstTraceInc : public AstNodeStmt {
@@ -3472,8 +3500,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(); }
@@ -5193,6 +5221,30 @@ public:
    virtual string emitC() { return "hypot(%li,%ri)"; }
 };

+class AstPast : public AstNodeMath {
+    // Verilog $past
+    // Parents: math
+    // Children: expression
+public:
+    AstPast(FileLine* fl, AstNode* exprp, AstNode* ticksp) : AstNodeMath(fl) {
+        addOp1p(exprp);
+        addNOp2p(ticksp);
+    }
+    ASTNODE_NODE_FUNCS(Past)
+    virtual string emitVerilog() { V3ERROR_NA; return ""; }
+    virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { V3ERROR_NA; }
+    virtual string emitC() { V3ERROR_NA; return "";}
+    virtual string emitSimpleOperator() { V3ERROR_NA; return "";}
+    virtual bool cleanOut() { V3ERROR_NA; return "";}
+    virtual int instrCount() const { return widthInstrs(); }
+    AstNode* exprp() const { return op1p(); }  // op1 = expression
+    AstNode* ticksp() const { return op2p(); }  // op2 = ticks or NULL means 1
+    AstSenTree* sentreep() const { return VN_CAST(op4p(), SenTree); }  // op4 = clock domain
+    void sentreep(AstSenTree* sentreep) { addOp4p(sentreep); }  // op4 = clock domain
+    virtual V3Hash sameHash() const { return V3Hash(); }
+    virtual bool same(const AstNode* samep) const { return true; }
+};
+
 class AstPattern : public AstNodeMath {
    // Verilog '{a,b,c,d...}
    // Parents: AstNodeAssign, AstPattern, ...
@@ -5322,6 +5374,13 @@ public:
    AstNode* stmtsp() const { return op4p(); }  // op4 = statements
 };

+class AstPslAssert : public AstNodePslCoverOrAssert {
+public:
+    ASTNODE_NODE_FUNCS(PslAssert)
+    AstPslAssert(FileLine* fl, AstNode* propp, AstNode* stmtsp, const string& name="")
+        : AstNodePslCoverOrAssert(fl, propp, stmtsp, name) {}
+};
+
 class AstPslCover : public AstNodePslCoverOrAssert {
 public:
    ASTNODE_NODE_FUNCS(PslCover)
@@ -5331,11 +5390,11 @@ public:
    void coverincp(AstCoverInc* nodep) { addOp3p(nodep); }  // op3 = coverage node
 };

-class AstPslAssert : public AstNodePslCoverOrAssert {
+class AstPslRestrict : public AstNodePslCoverOrAssert {
 public:
-    ASTNODE_NODE_FUNCS(PslAssert)
-    AstPslAssert(FileLine* fl, AstNode* propp, AstNode* stmtsp, const string& name="")
-        : AstNodePslCoverOrAssert(fl, propp, stmtsp, name) {}
+    ASTNODE_NODE_FUNCS(PslRestrict)
+    AstPslRestrict(FileLine* fl, AstNode* propp)
+        : AstNodePslCoverOrAssert(fl, propp, NULL, "") {}
 };

 //======================================================================
@@ -5793,15 +5852,15 @@ class AstNetlist : public AstNode {
    // Parents:   none
    // Children:  MODULEs & CFILEs
 private:
-    AstTypeTable* m_typeTablep;	// Reference to top type table, for faster lookup
-    AstPackage*	  m_dollarUnitPkgp;
-    AstCFunc*     m_evalp;      // The '_eval' function
+    AstTypeTable* m_typeTablep;  // Reference to top type table, for faster lookup
+    AstPackage*   m_dollarUnitPkgp;  // $unit
+    AstCFunc*     m_evalp;       // The '_eval' function
    AstExecGraph* m_execGraphp;  // Execution MTask graph for threads>1 mode
 public:
    AstNetlist()
-	: AstNode(new FileLine("AstRoot",0))
-	, m_typeTablep(NULL)
-	, m_dollarUnitPkgp(NULL)
+        : AstNode(new FileLine("AstRoot", 0))
+        , m_typeTablep(NULL)
+        , m_dollarUnitPkgp(NULL)
        , m_evalp(NULL)
        , m_execGraphp(NULL) { }
    ASTNODE_NODE_FUNCS(Netlist)
@@ -5817,7 +5876,7 @@ public:
    void addModulep(AstNodeModule* modulep) { addOp1p(modulep); }
    AstCFile* filesp() const { return VN_CAST(op2p(), CFile);}  // op2 = List of files
    void addFilesp(AstCFile* filep) { addOp2p(filep); }
-    AstNode*	miscsp() 	const { return op3p();}	// op3 = List of dtypes etc
+    AstNode* miscsp() const { return op3p(); }  // op3 = List of dtypes etc
    void addMiscsp(AstNode* nodep) { addOp3p(nodep); }
    AstTypeTable* typeTablep() { return m_typeTablep; }
    void addTypeTablep(AstTypeTable* nodep) { m_typeTablep = nodep; addMiscsp(nodep); }
@@ -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);
@@ -20,8 +20,10 @@

 #ifndef _V3BEGIN_H_
 #define _V3BEGIN_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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);
 }
@@ -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
@@ -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()) {
@@ -20,8 +20,10 @@

 #ifndef _V3BROKEN_H_
 #define _V3BROKEN_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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;
@@ -114,7 +114,7 @@ void V3CCtors::evalAsserts() {
    modp->addStmtp(funcp);
    for (AstNode* np = modp->stmtsp(); np; np = np->nextp()) {
        if (AstVar* varp = VN_CAST(np, Var)) {
-	    if (varp->isPrimaryIn() && !varp->isSc()) {
+            if (varp->isPrimaryInish() && !varp->isSc()) {
                if (AstBasicDType* basicp = VN_CAST(varp->dtypeSkipRefp(), BasicDType)) {
 		    int storedWidth = basicp->widthAlignBytes() * 8;
 		    int lastWordWidth = varp->width() % storedWidth;
@@ -20,8 +20,10 @@

 #ifndef _V3CCTORS_H_
 #define _V3CCTORS_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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
@@ -20,8 +20,10 @@

 #ifndef _V3CASE_H_
 #define _V3CASE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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

@@ -20,8 +20,10 @@

 #ifndef _V3CAST_H_
 #define _V3CAST_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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);
@@ -259,13 +258,13 @@ private:
 		// Create IO vertex - note it's relative to the pointed to var, not where we are now
 		// This allows reporting to easily print the input statement
 		CdcLogicVertex* ioVertexp = new CdcLogicVertex(&m_graph, varscp->scopep(), varscp->varp(), NULL);
-		if (varscp->varp()->isInput()) {
-		    new V3GraphEdge(&m_graph, ioVertexp, vertexp, 1);
-		} else {
-		    new V3GraphEdge(&m_graph, vertexp, ioVertexp, 1);
-		}
-	    }
-	}
+                if (varscp->varp()->isWritable()) {
+                    new V3GraphEdge(&m_graph, vertexp, ioVertexp, 1);
+                } else {
+                    new V3GraphEdge(&m_graph, ioVertexp, vertexp, 1);
+                }
+            }
+        }
 	if (m_inSenItem) {
 	    varscp->user2(true);  // It's like a clock...
 	    // TODO: In the future we could mark it here and do normal clock tree glitch checks also
@@ -373,11 +372,11 @@ private:
 	}
 	else if (CdcVarVertex* vvertexp = dynamic_cast<CdcVarVertex*>(vertexp)) {
 	    if (mark) vvertexp->asyncPath(true);
-	    // If primary I/O, it's ok here back
-	    if (vvertexp->varScp()->varp()->isPrimaryIn()) {
-		// Show the source "input" statement if it exists
+            // If primary I/O, it's ok here back
+            if (vvertexp->varScp()->varp()->isPrimaryInish()) {
+                // 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 = " | ";
 	    }
@@ -502,8 +501,8 @@ private:
 	    if (CdcVarVertex* vvertexp = dynamic_cast<CdcVarVertex*>(itp)) {
 		AstVar* varp = vvertexp->varScp()->varp();
 		if (1) {  // varp->isPrimaryIO()
-		    const char* whatp = "wire";
-		    if (varp->isPrimaryIO()) whatp = (varp->isInout()?"inout":varp->isInput()?"input":"output");
+                    string what = "wire";
+                    if (varp->isPrimaryIO()) what = varp->direction().prettyName();

                    std::ostringstream os;
                    os.setf(std::ios::left);
@@ -511,7 +510,7 @@ private:
 		    // so we assume the modulename matches the filebasename
 		    string fname = vvertexp->varScp()->fileline()->filebasename() + ":";
                    os<<"  "<<std::setw(20)<<fname;
-                    os<<"  "<<std::setw(8)<<whatp;
+                    os<<"  "<<std::setw(8)<<what;
                    os<<"  "<<std::setw(40)<<vvertexp->varScp()->prettyName();
 		    os<<"  SRC=";
 		    if (vvertexp->srcDomainp()) V3EmitV::verilogForTree(vvertexp->srcDomainp(), os);
@@ -546,21 +545,23 @@ private:
 	else if (CdcVarVertex* vvertexp = dynamic_cast<CdcVarVertex*>(vertexp)) {
 	    // If primary I/O, give it domain of the input
 	    AstVar* varp = vvertexp->varScp()->varp();
-	    if (varp->isPrimaryIO() && varp->isInput() && !traceDests) {
-		senouts.insert(new AstSenTree(varp->fileline(), new AstSenItem(varp->fileline(), AstSenItem::Combo())));
-	    }
-	}
+            if (varp->isPrimaryIO() && varp->isNonOutput() && !traceDests) {
+                senouts.insert(
+                    new AstSenTree(varp->fileline(),
+                                   new AstSenItem(varp->fileline(), AstSenItem::Combo())));
+            }
+        }

 	// 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());
 	    }
@@ -20,8 +20,10 @@

 #ifndef _V3CDC_H_
 #define _V3CDC_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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 {
@@ -20,8 +20,10 @@

 #ifndef _V3CHANGED_H_
 #define _V3CHANGED_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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);
@@ -20,8 +20,10 @@

 #ifndef _V3CLEAN_H_
 #define _V3CLEAN_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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);
@@ -20,8 +20,10 @@

 #ifndef _V3CLKGATER_H_
 #define _V3CLKGATER_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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);
@@ -20,8 +20,10 @@

 #ifndef _V3CLOCK_H_
 #define _V3CLOCK_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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();
 };

 //######################################################################
@@ -20,8 +20,10 @@

 #ifndef _V3COMBINE_H_
 #define _V3COMBINE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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 {
@@ -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"

@@ -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,
@@ -1537,14 +1538,15 @@ private:
 		&& ((!m_params // Can reduce constant wires into equations
 		     && m_doNConst
 		     && v3Global.opt.oConst()
-		     && !(nodep->varp()->isFuncLocal() // Default value, not a "known" constant for this usage
-			  && nodep->varp()->isInput())
-		     && !nodep->varp()->noSubst()
+                     // Default value, not a "known" constant for this usage
+                     && !(nodep->varp()->isFuncLocal()
+                          && nodep->varp()->isNonOutput())
+                     && !nodep->varp()->noSubst()
 		     && !nodep->varp()->isSigPublic())
 		    || 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 +1568,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 +1979,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 +2023,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);
@@ -20,8 +20,10 @@

 #ifndef _V3CONST_H_
 #define _V3CONST_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

@@ -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)) {
@@ -20,8 +20,10 @@

 #ifndef _V3COVERAGE_H_
 #define _V3COVERAGE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Wilson Snyder	2685037ca2	Version bump	2018-12-01 14:52:21 -05:00
Wilson Snyder	940dc98c66	Add CONTASSREG error on continuous assignments to regs, bug1369.	2018-12-01 10:12:10 -05:00
Wilson Snyder	49353784fd	Fix __Slow files getting compiled with OPT_FAST, bug1370.	2018-11-29 20:35:21 -05:00
Wilson Snyder	2e5919549c	Tests: Separate make_main flag from verilator_make_gcc flag.	2018-11-29 19:50:09 -05:00
Wilson Snyder	8170391573	Internals: Fix spacing of comments. No functional change.	2018-11-28 19:59:10 -05:00
Wilson Snyder	61e4b0a472	Add IMPORTSTAR warning on import::* inside scope.	2018-11-28 18:25:34 -05:00
Wilson Snyder	15af706286	Fix crash due to cygwin bug in getline, bug1349.	2018-11-26 19:09:08 -05:00
Wilson Snyder	2a43410fa6	Tests: Fix buggy size test.	2018-11-26 18:22:20 -05:00
Wilson Snyder	5cc11839b5	Add PROCASSWIRE error on behavioral assignments to wires, msg2737.	2018-11-26 17:58:18 -05:00
Wilson Snyder	d1bfeae026	Tests: Ignore obj_vcs	2018-11-25 21:08:16 -05:00
Wilson Snyder	e0b2c46664	Internals: Function return values act as vars, not wires.	2018-11-25 19:50:53 -05:00
Wilson Snyder	ea61559ab5	Internals: Cleaner name for var. No functional change.	2018-11-25 19:10:18 -05:00
Wilson Snyder	6a5a2a56d7	Internals: Favor AstNetlist for global thread errors, and allow 0 line number error suppression.	2018-11-16 20:49:17 -05:00
Wilson Snyder	5cbf80918f	Tests: Favor golden files over long regexps. No functional change.	2018-11-03 14:59:04 -04:00
Wilson Snyder	196e3a9712	Tests: Reduce timeout when single-threaded testing.	2018-11-03 09:07:28 -04:00
Wilson Snyder	3798b80091	Tests: Fix test instability.	2018-11-03 09:07:11 -04:00
Wilson Snyder	689e4cf1d3	Tests: Have files_identical fail on error	2018-11-01 21:58:39 -04:00
Wilson Snyder	64f11251b6	Fix verilator_coverage not sorting output	2018-11-01 21:39:37 -04:00
Wilson Snyder	6cd2bd2972	Tests: Add golden_filename.	2018-11-01 21:04:19 -04:00
Wilson Snyder	d396c55e34	In --xml-only show module_files and cells ala Verilog-Perl vhier, msg2716.	2018-11-01 19:53:26 -04:00
Wilson Snyder	45c9939a5e	Fix hang on bad pattern keys, bug1364.	2018-11-01 19:03:52 -04:00
Wilson Snyder	ad2929dff0	Support "ref" and "const ref" pins and functions, bug1360.	2018-10-30 20:50:09 -04:00
Wilson Snyder	d3e1dfd3f5	Tests: Add VERILATOR_MAKE override variable.	2018-10-30 20:28:39 -04:00
Wilson Snyder	14b48140bd	In --xml-only show the original unmodified names, msg2716.	2018-10-30 18:17:37 -04:00
Wilson Snyder	7be1678fb0	Fix --trace-lxt2 compile error on MinGW, msg2711.	2018-10-30 07:35:30 -04:00
Wilson Snyder	d464ce1477	Fix unneeded emit comment. No functional change.	2018-10-29 20:48:50 -04:00
Wilson Snyder	0a04f79576	Commentary	2018-10-28 08:16:19 -04:00
Wilson Snyder	b8098098d8	Internals: Refactor input/output to new class in prep for ref support.	2018-10-27 17:29:00 -04:00
Wilson Snyder	dc26815b1c	Tests: Report wide line numbers.	2018-10-27 17:21:07 -04:00
Wilson Snyder	f2028b60af	Internals: Expand git_untabify lines touched.	2018-10-27 16:48:42 -04:00
Wilson Snyder	06c7d8ce3b	Internals: Fix whitespace issues. No functional change, use -b to diff	2018-10-27 10:03:28 -04:00
Wilson Snyder	160505c5a4	devel release	2018-10-27 08:48:12 -04:00
Wilson Snyder	3df9b4230b	Version bump	2018-10-27 08:27:10 -04:00
Wilson Snyder	13163aef24	make distclean should remove .1 files as not in distribution	2018-10-27 08:26:25 -04:00
Wilson Snyder	5c2b5bd782	Internals: Expand git_untabify lines touched	2018-10-26 19:49:36 -04:00
Wilson Snyder	da1ebcb4e4	Add --pp-comments, msg2700.	2018-10-25 21:17:25 -04:00
Wilson Snyder	8dbfc940ba	Internals: Refactor comment parsing. No functional change intended.	2018-10-25 20:46:23 -04:00
Wilson Snyder	e0654dc218	Add --dump-defines.	2018-10-25 19:47:07 -04:00
Patrick Stewart	74a92e739f	Internals: Fix missing static. No functional change. Signed-off-by: Wilson Snyder <[email protected]>	2018-10-24 19:40:07 -04:00
Wilson Snyder	304a24d03a	Internals: Fix many clang-tidy issues. No functional change intended.	2018-10-14 18:39:33 -04:00
Wilson Snyder	5ae1ce90ad	Internals: Refactor into cvtToHex function. No functional change.	2018-10-14 16:25:36 -04:00
Wilson Snyder	d87b9d25ca	Internals: Cleanup and standardize include order. No functional change intended.	2018-10-14 13:59:40 -04:00
Wilson Snyder	9bc8d77f39	Includes: Move version to implementation only.	2018-10-14 11:21:09 -04:00
Wilson Snyder	b7e4083e70	Internals: Cleanup temp string inserts for clang-tidy. No functional change.	2018-10-14 11:10:11 -04:00
Wilson Snyder	595419b370	Internals: Sort includes for clang-tidy. No functional change intended.	2018-10-14 07:04:18 -04:00
Wilson Snyder	442e4f35f0	Internals: Cleanup empty string constructors for clang-tidy. No functional change.	2018-10-13 23:06:36 -04:00
Wilson Snyder	e8b8b33ff6	Internals: Cleanup find with chars for clang-tidy. No functional change.	2018-10-13 22:28:59 -04:00
Wilson Snyder	e4d638c73d	Internals: Cleanup string casts. No functional change.	2018-10-13 22:02:39 -04:00
Wilson Snyder	bccb9f794c	Fix Windows .exe not found, bug1361.	2018-10-12 19:13:50 -04:00
Wilson Snyder	fe0dae74c1	include: Upstream update for GTKWave	2018-10-12 06:55:12 -04:00
Wilson Snyder	b59c23d346	Move some unsupported syntax to parser for cleaner errors.	2018-10-11 21:57:07 -04:00
Wilson Snyder	6047049fc7	Fix --trace-lxt2 compile error on MinGW, msg2684.	2018-10-11 21:03:49 -04:00
Wilson Snyder	08e650a2b4	Commentary	2018-10-11 21:00:29 -04:00
Wilson Snyder	11d4d6562f	Commentary	2018-10-10 17:10:59 -04:00
Wilson Snyder	5c9da65606	Fix --trace-lxt2 compile error on MinGW, msg2667.	2018-10-10 06:54:51 -04:00
Wilson Snyder	97d89cce35	Move some unsupported syntax to parser for cleaner errors.	2018-10-08 22:18:09 -04:00
Wilson Snyder	cc45a3dd72	For --trace-fst, save enum decoding information, bug1358.	2018-10-08 07:21:22 -04:00
Wilson Snyder	870918a788	Tests: Dump and test FST trace attributes.	2018-10-07 22:04:49 -04:00
Wilson Snyder	41be66af95	Indent output C code '= {' blocks.	2018-10-07 21:23:45 -04:00
Wilson Snyder	9ad252be34	For --trace-fst, instead of .fst.hier, put data into .fst.	2018-10-07 20:47:26 -04:00
Wilson Snyder	1f344ac99e	Fix whitespace on trace function calls. Output changed, but no functional change.	2018-10-07 18:17:45 -04:00
Wilson Snyder	8b738c0022	Compute struct/union/enum names from surrounding typedefs.	2018-10-07 18:07:42 -04:00
Wilson Snyder	57fbf38fb2	Internals: Don't detabify gtkwave files.	2018-10-07 18:00:04 -04:00
Wilson Snyder	4cd01bc99a	Deprecate --trace-lxt2.	2018-10-06 14:13:38 -04:00
Wilson Snyder	fc0cf00b1d	devel release	2018-10-06 10:12:31 -04:00
Wilson Snyder	4333c201f1	Version bump	2018-10-06 09:51:57 -04:00
Wilson Snyder	1f5913a83c	Internals: V3Simulate refactoring prep for future work. No functional change.	2018-10-05 20:26:54 -04:00
Wilson Snyder	159c653b4b	Internals: V3Simulate refactoring prep for future work. No functional change.	2018-10-05 20:06:08 -04:00
Wilson Snyder	47a2e2aeb9	Commentary	2018-10-05 18:47:46 -04:00
Wilson Snyder	98b0d19363	Tests: Add enum to trace test.	2018-10-05 18:38:52 -04:00
Wilson Snyder	24a0873f6d	Commentary	2018-10-05 06:47:18 -04:00
Wilson Snyder	c5fee7c456	Fix flex warning	2018-10-04 20:51:20 -04:00
Wilson Snyder	d11592cadd	Support signal types in FST dumps, bug1358.	2018-10-04 20:24:41 -04:00
Wilson Snyder	8ef9ac7dba	Support in/out directions in FST dumps, bug1358.	2018-10-03 19:51:05 -04:00
Sergi Granell	a5aa0e2b0a	Add GTKWave FST native tracing, bug1356. Signed-off-by: Wilson Snyder <[email protected]>	2018-10-02 18:42:53 -04:00
Wilson Snyder	f8ae08c0c2	Internals: Fix whitespace.	2018-10-02 06:31:11 -04:00
Wilson Snyder	72f5d39ace	Rename include/lxt2 to include/gtkwave.	2018-10-01 18:29:04 -04:00
Sergi Granell	5c9801d42c	Commentary Signed-off-by: Wilson Snyder <[email protected]>	2018-09-30 17:34:47 -04:00
Wilson Snyder	c9ee425ed5	Fix replication of 64-bit signal change detects.	2018-09-28 08:36:37 -04:00
Wilson Snyder	1871e2b541	Commentary	2018-09-27 19:58:17 -04:00
Wilson Snyder	3e39c55a97	Tests: Check mod-prefix subnames.	2018-09-27 19:58:13 -04:00
Wilson Snyder	e4d6fa0e3b	include: Update license from GTKWave upstream.	2018-09-27 19:55:00 -04:00
Wilson Snyder	9f8dbc91f2	Support restrict, bug1350.	2018-09-23 15:20:12 -04:00
Wilson Snyder	0e37747d2c	Support $past.	2018-09-23 15:20:01 -04:00
Wilson Snyder	a8519a7a53	Fix MinGW compile issues, msg2636.	2018-09-20 18:09:19 -04:00
Kevin Kiningham	d4159811d2	configure: Fix test for c++03 etc.	2018-09-17 21:47:35 -04:00
Kevin Kiningham	b2ca4995ab	Fix Mac OSX 10.13.6 / LLVM 9.1 compile issues, bug1348.	2018-09-17 18:35:23 -04:00
Wilson Snyder	7876fe94ad	Fix Mac OSX 10.13.6 / LLVM 9.1 compile issues, bug1348.	2018-09-17 06:39:43 -04:00
Wilson Snyder	cc9f7d1ac3	devel release	2018-09-17 06:24:18 -04:00