diff --git a/include/verilated.h b/include/verilated.h index 71b2e0c29..fb2ca3671 100644 --- a/include/verilated.h +++ b/include/verilated.h @@ -129,7 +129,7 @@ extern vluint32_t VL_THREAD_ID() VL_MT_SAFE; #define VL_LOCK_SPINS 50000 /// Number of times to spin for a mutex before relaxing /// Mutex, wrapped to allow -fthread_safety checks -class VL_CAPABILITY("mutex") VerilatedMutex { +class VL_CAPABILITY("mutex") VerilatedMutex final { private: std::mutex m_mutex; // Mutex public: @@ -155,7 +155,7 @@ public: }; /// Lock guard for mutex (ala std::unique_lock), wrapped to allow -fthread_safety checks -class VL_SCOPED_CAPABILITY VerilatedLockGuard { +class VL_SCOPED_CAPABILITY VerilatedLockGuard final { VL_UNCOPYABLE(VerilatedLockGuard); private: @@ -174,14 +174,14 @@ public: #else // !VL_THREADED /// Empty non-threaded mutex to avoid #ifdefs in consuming code -class VerilatedMutex { +class VerilatedMutex final { public: void lock() {} void unlock() {} }; /// Empty non-threaded lock guard to avoid #ifdefs in consuming code -class VerilatedLockGuard { +class VerilatedLockGuard final { VL_UNCOPYABLE(VerilatedLockGuard); public: @@ -194,7 +194,7 @@ public: #endif // VL_THREADED /// Remember the calling thread at construction time, and make sure later calls use same thread -class VerilatedAssertOneThread { +class VerilatedAssertOneThread final { // MEMBERS #if defined(VL_THREADED) && defined(VL_DEBUG) vluint32_t m_threadid; /// Thread that is legal @@ -230,7 +230,7 @@ public: class VerilatedScope; -class VerilatedModule { +class VerilatedModule VL_NOT_FINAL { VL_UNCOPYABLE(VerilatedModule); private: @@ -269,7 +269,8 @@ public: #define VL_CELL(instname, type) ///< Declare a cell, ala SP_CELL /// Declare a module, ala SC_MODULE -#define VL_MODULE(modname) class modname : public VerilatedModule +#define VL_MODULE(modname) class modname VL_NOT_FINAL : public VerilatedModule +// Not class final in VL_MODULE, as users might be abstracting our models (--hierarchical) /// Constructor, ala SC_CTOR #define VL_CTOR(modname) modname(const char* __VCname = "") @@ -298,7 +299,7 @@ public: //=========================================================================== /// Verilator symbol table base class -class VerilatedSyms { +class VerilatedSyms VL_NOT_FINAL { public: // But for internal use only #ifdef VL_THREADED VerilatedEvalMsgQueue* __Vm_evalMsgQp; @@ -311,7 +312,7 @@ public: // But for internal use only /// Verilator global class information class /// This class is initialized by main thread only. Reading post-init is thread safe. -class VerilatedScope { +class VerilatedScope final { public: typedef enum : vluint8_t { SCOPE_MODULE, @@ -359,7 +360,7 @@ public: // But internals only - called from VerilatedModule's Type type() const { return m_type; } }; -class VerilatedHierarchy { +class VerilatedHierarchy final { public: static void add(VerilatedScope* fromp, VerilatedScope* top); }; @@ -367,7 +368,7 @@ public: //=========================================================================== /// Verilator global static information class -class Verilated { +class Verilated final { // MEMBERS // Slow path variables static VerilatedMutex m_mutex; ///< Mutex for s_s/s_ns members, when VL_THREADED diff --git a/include/verilated_cov.cpp b/include/verilated_cov.cpp index 6d71400df..9db5eacb7 100644 --- a/include/verilated_cov.cpp +++ b/include/verilated_cov.cpp @@ -29,7 +29,7 @@ // VerilatedCovImpBase /// Implementation base class for constants -struct VerilatedCovImpBase { +struct VerilatedCovImpBase VL_NOT_FINAL { // TYPES enum { MAX_KEYS = 33 }; /// Maximum user arguments + filename+lineno enum { KEY_UNDEF = 0 }; /// Magic key # for unspecified values @@ -39,7 +39,7 @@ struct VerilatedCovImpBase { // VerilatedCovImpItem /// Implementation class for a VerilatedCov item -class VerilatedCovImpItem : VerilatedCovImpBase { +class VerilatedCovImpItem VL_NOT_FINAL : VerilatedCovImpBase { public: // But only local to this file // MEMBERS int m_keys[MAX_KEYS]; ///< Key @@ -63,7 +63,7 @@ public: // But only local to this file /// This isn't in the header file for auto-magic conversion because it /// inlines to too much code and makes compilation too slow. -template class VerilatedCoverItemSpec : public VerilatedCovImpItem { +template class VerilatedCoverItemSpec final : public VerilatedCovImpItem { private: // MEMBERS T* m_countp; ///< Count value @@ -87,7 +87,7 @@ public: /// All value and keys are indexed into a unique number. Thus we can greatly reduce /// the storage requirements for otherwise identical keys. -class VerilatedCovImp : VerilatedCovImpBase { +class VerilatedCovImp final : VerilatedCovImpBase { private: // TYPES typedef std::map ValueIndexMap; diff --git a/include/verilated_cov.h b/include/verilated_cov.h index aef8eda67..331eed6c8 100644 --- a/include/verilated_cov.h +++ b/include/verilated_cov.h @@ -88,7 +88,7 @@ template std::string vlCovCvtToStr(const T& t) VL_PURE { /// Global class with methods affecting all coverage data. /// All public methods in this class are thread safe. -class VerilatedCov { +class VerilatedCov final { VL_UNCOPYABLE(VerilatedCov); public: diff --git a/include/verilated_cov_key.h b/include/verilated_cov_key.h index d4788d435..9a184a518 100644 --- a/include/verilated_cov_key.h +++ b/include/verilated_cov_key.h @@ -102,7 +102,7 @@ VLCOVGEN_ITEM("name=>'weight', short=>'w', group=>0, default=>undef, descr /// Verilator coverage global class. /// This class is thread safe. -class VerilatedCovKey { +class VerilatedCovKey final { public: static std::string shortKey(const std::string& key) VL_PURE { // VLCOVGEN_SHORT_AUTO_EDIT_BEGIN diff --git a/include/verilated_fst_c.h b/include/verilated_fst_c.h index f4aaf08ec..a4c4a779c 100644 --- a/include/verilated_fst_c.h +++ b/include/verilated_fst_c.h @@ -35,7 +35,7 @@ /// Base class to create a Verilator FST dump /// This is an internally used class - see VerilatedFstC for what to call from applications -class VerilatedFst : public VerilatedTrace { +class VerilatedFst final : public VerilatedTrace { private: // Give the superclass access to private bits (to avoid virtual functions) friend class VerilatedTrace; @@ -128,7 +128,7 @@ template <> void VerilatedTrace::set_time_resolution(const std::st /// Also derived for use in SystemC simulations. /// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE -class VerilatedFstC { +class VerilatedFstC final { VerilatedFst m_sptrace; ///< Trace file being created // CONSTRUCTORS diff --git a/include/verilated_heavy.h b/include/verilated_heavy.h index 933a3a6a2..3346cd2be 100644 --- a/include/verilated_heavy.h +++ b/include/verilated_heavy.h @@ -46,7 +46,7 @@ extern std::string VL_TO_STRING_W(int words, WDataInP obj); //=================================================================== // Shuffle RNG -class VlURNG { +class VlURNG final { public: typedef size_t result_type; static constexpr size_t min() { return 0; } @@ -57,7 +57,7 @@ public: //=================================================================== // Readmem/Writemem operation classes -class VlReadMem { +class VlReadMem final { bool m_hex; // Hex format int m_bits; // Bit width of values const std::string& m_filename; // Filename @@ -74,7 +74,7 @@ public: void setData(void* valuep, const std::string& rhs); }; -class VlWriteMem { +class VlWriteMem final { bool m_hex; // Hex format int m_bits; // Bit width of values FILE* m_fp; // File handle for filename @@ -93,7 +93,7 @@ public: // // Bound here is the maximum size() allowed, e.g. 1 + SystemVerilog bound // For dynamic arrays it is always zero -template class VlQueue { +template class VlQueue final { private: // TYPES typedef std::deque Deque; @@ -424,7 +424,7 @@ template std::string VL_TO_STRING(const VlQueue& obj) { // This is only used when we need an upper-level container and so can't // simply use a C style array (which is just a pointer). -template class VlWide { +template class VlWide final { WData m_storage[T_Words]; public: @@ -460,7 +460,7 @@ template std::string VL_TO_STRING(const VlWide& o // There are no multithreaded locks on this; the base variable must // be protected by other means // -template class VlAssocArray { +template class VlAssocArray final { private: // TYPES typedef std::map Map; diff --git a/include/verilated_imp.h b/include/verilated_imp.h index 1b92f4798..ba0993570 100644 --- a/include/verilated_imp.h +++ b/include/verilated_imp.h @@ -46,7 +46,7 @@ class VerilatedScope; #ifdef VL_THREADED /// Message, enqueued on an mtask, and consumed on the main eval thread -class VerilatedMsg { +class VerilatedMsg final { public: // TYPES struct Cmp { @@ -78,7 +78,7 @@ public: /// Each thread has a queue it pushes to /// This assumes no thread starts pushing the next tick until the previous has drained. /// If more aggressiveness is needed, a double-buffered scheme might work well. -class VerilatedEvalMsgQueue { +class VerilatedEvalMsgQueue final { typedef std::multiset VerilatedThreadQueue; std::atomic m_depth; ///< Current depth of queue (see comments below) @@ -130,7 +130,7 @@ public: }; /// Each thread has a local queue to build up messages until the end of the eval() call -class VerilatedThreadMsgQueue { +class VerilatedThreadMsgQueue final { std::queue m_queue; public: @@ -174,7 +174,7 @@ public: #endif // VL_THREADED // FILE* list constructed from a file-descriptor -class VerilatedFpList { +class VerilatedFpList final { FILE* m_fp[31]; std::size_t m_sz = 0; @@ -193,7 +193,7 @@ public: //====================================================================== // VerilatedImp -class VerilatedImpData { +class VerilatedImpData final { // Whole class is internal use only - Global information shared between verilated*.cpp files. protected: friend class Verilated; @@ -264,7 +264,7 @@ protected: } }; -class VerilatedImp { +class VerilatedImp final { // Whole class is internal use only - Global information shared between verilated*.cpp files. protected: friend class Verilated; diff --git a/include/verilated_save.h b/include/verilated_save.h index 5729591d9..ca12c57ca 100644 --- a/include/verilated_save.h +++ b/include/verilated_save.h @@ -28,7 +28,7 @@ // VerilatedSerialize - convert structures to a stream representation // This class is not thread safe, it must be called by a single thread -class VerilatedSerialize { +class VerilatedSerialize VL_NOT_FINAL { protected: // MEMBERS // For speed, keep m_cp as the first member of this structure @@ -87,7 +87,7 @@ private: // VerilatedDeserial - load structures from a stream representation // This class is not thread safe, it must be called by a single thread -class VerilatedDeserialize { +class VerilatedDeserialize VL_NOT_FINAL { protected: // MEMBERS // For speed, keep m_cp as the first member of this structure @@ -154,7 +154,7 @@ private: // VerilatedSave - serialize to a file // This class is not thread safe, it must be called by a single thread -class VerilatedSave : public VerilatedSerialize { +class VerilatedSave final : public VerilatedSerialize { private: int m_fd = -1; ///< File descriptor we're writing to @@ -174,7 +174,7 @@ public: // VerilatedRestore - deserialize from a file // This class is not thread safe, it must be called by a single thread -class VerilatedRestore : public VerilatedDeserialize { +class VerilatedRestore final : public VerilatedDeserialize { private: int m_fd = -1; ///< File descriptor we're writing to diff --git a/include/verilated_sc.h b/include/verilated_sc.h index b250d224b..a807b8302 100644 --- a/include/verilated_sc.h +++ b/include/verilated_sc.h @@ -34,7 +34,7 @@ // This class is thread safe (though most of SystemC is not). #define VL_SC_BV_DATAP(bv) (VlScBvExposer::sp_datap(bv)) -class VlScBvExposer : public sc_bv_base { +class VlScBvExposer final : public sc_bv_base { public: static const vluint32_t* sp_datap(const sc_bv_base& base) VL_MT_SAFE { return static_cast(&base)->sp_datatp(); diff --git a/include/verilated_sym_props.h b/include/verilated_sym_props.h index 9419e3309..2df07855e 100644 --- a/include/verilated_sym_props.h +++ b/include/verilated_sym_props.h @@ -36,7 +36,7 @@ /// Thread safety: Assume is constructed only with model, then any number of readers // See also V3Ast::VNumRange -class VerilatedRange { +class VerilatedRange final { int m_left = 0; int m_right = 0; @@ -68,7 +68,7 @@ public: /// Verilator variable /// Thread safety: Assume is constructed only with model, then any number of readers -class VerilatedVarProps { +class VerilatedVarProps VL_NOT_FINAL { // TYPES enum { MAGIC = 0xddc4f829 }; // MEMBERS @@ -187,7 +187,7 @@ public: //=========================================================================== /// Verilator DPI open array variable -class VerilatedDpiOpenVar { +class VerilatedDpiOpenVar final { // MEMBERS const VerilatedVarProps* m_propsp; // Variable properties void* m_datap; // Location of data (local to thread always, so safe) @@ -225,7 +225,7 @@ public: /// Verilator variable /// Thread safety: Assume is constructed only with model, then any number of readers -class VerilatedVar : public VerilatedVarProps { +class VerilatedVar final : public VerilatedVarProps { // MEMBERS void* m_datap; // Location of data const char* m_namep; // Name - slowpath diff --git a/include/verilated_syms.h b/include/verilated_syms.h index 2a643b341..c8f8514fc 100644 --- a/include/verilated_syms.h +++ b/include/verilated_syms.h @@ -42,7 +42,7 @@ struct VerilatedCStrCmp { }; /// Map of sorted scope names to find associated scope class -class VerilatedScopeNameMap +class VerilatedScopeNameMap final : public std::map { public: VerilatedScopeNameMap() = default; @@ -50,7 +50,7 @@ public: }; /// Map of sorted variable names to find associated variable class -class VerilatedVarNameMap : public std::map { +class VerilatedVarNameMap final : public std::map { public: VerilatedVarNameMap() = default; ~VerilatedVarNameMap() = default; @@ -58,7 +58,7 @@ public: typedef std::vector VerilatedScopeVector; -class VerilatedHierarchyMap : public std::map { +class VerilatedHierarchyMap final : public std::map { public: VerilatedHierarchyMap() = default; ~VerilatedHierarchyMap() = default; diff --git a/include/verilated_threads.h b/include/verilated_threads.h index 1592b2eaf..4b6678c92 100644 --- a/include/verilated_threads.h +++ b/include/verilated_threads.h @@ -52,7 +52,7 @@ typedef void* VlThrSymTab; typedef void (*VlExecFnp)(bool, VlThrSymTab); /// Track dependencies for a single MTask. -class VlMTaskVertex { +class VlMTaskVertex final { // MEMBERS static std::atomic s_yields; // Statistics @@ -124,7 +124,7 @@ public: }; // Profiling support -class VlProfileRec { +class VlProfileRec final { protected: friend class VlThreadPool; enum VlProfileE { TYPE_MTASK_RUN, TYPE_BARRIER }; @@ -168,7 +168,7 @@ public: class VlThreadPool; -class VlWorkerThread { +class VlWorkerThread final { private: // TYPES struct ExecRec { @@ -247,7 +247,7 @@ public: static void startWorker(VlWorkerThread* workerp); }; -class VlThreadPool { +class VlThreadPool final { // TYPES typedef std::vector ProfileTrace; typedef std::set ProfileSet; diff --git a/include/verilated_trace.h b/include/verilated_trace.h index adffb68c3..bb4bc68b9 100644 --- a/include/verilated_trace.h +++ b/include/verilated_trace.h @@ -40,7 +40,7 @@ // Threaded tracing // A simple synchronized first in first out queue -template class VerilatedThreadQueue { // LCOV_EXCL_LINE // lcov bug +template class VerilatedThreadQueue final { // LCOV_EXCL_LINE // lcov bug private: VerilatedMutex m_mutex; // Protects m_queue std::condition_variable_any m_cv; @@ -83,7 +83,7 @@ public: // Commands used by thread tracing. Anonymous enum in class, as we want // it scoped, but we also want the automatic conversion to integer types. -class VerilatedTraceCommand { +class VerilatedTraceCommand final { public: // These must all fit in 4 bit at the moment, as the tracing routines // pack parameters in the top bits. @@ -110,7 +110,7 @@ public: // VerilatedTrace uses F-bounded polymorphism to access duck-typed // implementations in the format specific derived class, which must be passed // as the type parameter T_Derived -template class VerilatedTrace { +template class VerilatedTrace VL_NOT_FINAL { public: //========================================================================= // Generic tracing internals diff --git a/include/verilated_vcd_c.h b/include/verilated_vcd_c.h index 1bc9080a3..8424bd6e6 100644 --- a/include/verilated_vcd_c.h +++ b/include/verilated_vcd_c.h @@ -34,7 +34,7 @@ class VerilatedVcd; // VerilatedFile /// File handling routines, which can be overrode for e.g. socket I/O -class VerilatedVcdFile { +class VerilatedVcdFile final { private: int m_fd = 0; ///< File descriptor we're writing to public: @@ -51,7 +51,7 @@ public: /// Base class to create a Verilator VCD dump /// This is an internally used class - see VerilatedVcdC for what to call from applications -class VerilatedVcd : public VerilatedTrace { +class VerilatedVcd VL_NOT_FINAL : public VerilatedTrace { private: // Give the superclass access to private bits (to avoid virtual functions) friend class VerilatedTrace; @@ -329,7 +329,7 @@ template <> void VerilatedTrace::set_time_resolution(const std::st /// Also derived for use in SystemC simulations. /// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE -class VerilatedVcdC { +class VerilatedVcdC VL_NOT_FINAL { VerilatedVcd m_sptrace; ///< Trace file being created // CONSTRUCTORS diff --git a/include/verilated_vcd_sc.h b/include/verilated_vcd_sc.h index 15d0aae61..2836879c1 100644 --- a/include/verilated_vcd_sc.h +++ b/include/verilated_vcd_sc.h @@ -31,7 +31,7 @@ /// This class is passed to the SystemC simulation kernel, just like a /// documented SystemC trace format. -class VerilatedVcdSc : sc_trace_file, public VerilatedVcdC { +class VerilatedVcdSc final : sc_trace_file, public VerilatedVcdC { // CONSTRUCTORS VL_UNCOPYABLE(VerilatedVcdSc); diff --git a/include/verilated_vpi.cpp b/include/verilated_vpi.cpp index e9a64241a..3f0b34218 100644 --- a/include/verilated_vpi.cpp +++ b/include/verilated_vpi.cpp @@ -55,7 +55,7 @@ constexpr unsigned VL_VPI_LINE_SIZE = 8192; // Implementation // Base VPI handled object -class VerilatedVpio { +class VerilatedVpio VL_NOT_FINAL { // MEM MANGLEMENT static VL_THREAD_LOCAL vluint8_t* t_freeHead; @@ -101,7 +101,7 @@ public: typedef PLI_INT32 (*VerilatedPliCb)(struct t_cb_data*); -class VerilatedVpioCb : public VerilatedVpio { +class VerilatedVpioCb final : public VerilatedVpio { t_cb_data m_cbData; s_vpi_value m_value; QData m_time; @@ -125,7 +125,7 @@ public: QData time() const { return m_time; } }; -class VerilatedVpioConst : public VerilatedVpio { +class VerilatedVpioConst final : public VerilatedVpio { vlsint32_t m_num; public: @@ -139,7 +139,7 @@ public: vlsint32_t num() const { return m_num; } }; -class VerilatedVpioParam : public VerilatedVpio { +class VerilatedVpioParam final : public VerilatedVpio { const VerilatedVar* m_varp; const VerilatedScope* m_scopep; @@ -165,7 +165,7 @@ public: } }; -class VerilatedVpioRange : public VerilatedVpio { +class VerilatedVpioRange final : public VerilatedVpio { const VerilatedRange* m_range; vlsint32_t m_iteration = 0; @@ -191,7 +191,7 @@ public: } }; -class VerilatedVpioScope : public VerilatedVpio { +class VerilatedVpioScope VL_NOT_FINAL : public VerilatedVpio { protected: const VerilatedScope* m_scopep; @@ -208,7 +208,7 @@ public: virtual const char* fullname() const override { return m_scopep->name(); } }; -class VerilatedVpioVar : public VerilatedVpio { +class VerilatedVpioVar VL_NOT_FINAL : public VerilatedVpio { const VerilatedVar* m_varp; const VerilatedScope* m_scopep; vluint8_t* m_prevDatap = nullptr; // Previous value of data, for cbValueChange @@ -266,7 +266,7 @@ public: } }; -class VerilatedVpioMemoryWord : public VerilatedVpioVar { +class VerilatedVpioMemoryWord final : public VerilatedVpioVar { public: VerilatedVpioMemoryWord(const VerilatedVar* varp, const VerilatedScope* scopep, vlsint32_t index, int offset) @@ -290,7 +290,7 @@ public: } }; -class VerilatedVpioVarIter : public VerilatedVpio { +class VerilatedVpioVarIter final : public VerilatedVpio { const VerilatedScope* m_scopep; VerilatedVarNameMap::const_iterator m_it; bool m_started = false; @@ -321,7 +321,7 @@ public: } }; -class VerilatedVpioMemoryWordIter : public VerilatedVpio { +class VerilatedVpioMemoryWordIter final : public VerilatedVpio { const vpiHandle m_handle; const VerilatedVar* m_varp; vlsint32_t m_iteration; @@ -351,7 +351,7 @@ public: } }; -class VerilatedVpioModule : public VerilatedVpioScope { +class VerilatedVpioModule final : public VerilatedVpioScope { const char* m_name; const char* m_fullname; @@ -370,7 +370,7 @@ public: virtual const char* fullname() const override { return m_fullname; } }; -class VerilatedVpioModuleIter : public VerilatedVpio { +class VerilatedVpioModuleIter final : public VerilatedVpio { const std::vector* m_vec; std::vector::const_iterator m_it; @@ -405,7 +405,7 @@ struct VerilatedVpiTimedCbsCmp { class VerilatedVpiError; -class VerilatedVpiImp { +class VerilatedVpiImp final { enum { CB_ENUM_MAX_VALUE = cbAtEndOfSimTime + 1 }; // Maxium callback reason typedef std::list VpioCbList; typedef std::set, VerilatedVpiTimedCbsCmp> VpioTimedCbs; @@ -534,7 +534,7 @@ public: static VerilatedVpiError* error_info() VL_MT_UNSAFE_ONE; // getter for vpi error info }; -class VerilatedVpiError { +class VerilatedVpiError final { //// Container for vpi error info t_vpi_error_info m_errorInfo; diff --git a/include/verilated_vpi.h b/include/verilated_vpi.h index 4ecfc55ca..eebb3736b 100644 --- a/include/verilated_vpi.h +++ b/include/verilated_vpi.h @@ -33,7 +33,7 @@ //====================================================================== -class VerilatedVpi { +class VerilatedVpi final { public: /// Call timed callbacks /// Users should call this from their main loops diff --git a/include/verilatedos.h b/include/verilatedos.h index 7ba4ff55c..abe297843 100644 --- a/include/verilatedos.h +++ b/include/verilatedos.h @@ -374,7 +374,10 @@ typedef unsigned long long vluint64_t; ///< 64-bit unsigned type //========================================================================= // Class definition helpers -// Used to declare a class as uncopyable; put after a private: +/// Used to indicate a base class, e.g. cannot label "class final" +#define VL_NOT_FINAL + +/// Used to declare a class as uncopyable; put after a private: #define VL_UNCOPYABLE(Type) \ Type(const Type& other) = delete; \ Type& operator=(const Type&) = delete diff --git a/src/V3Active.cpp b/src/V3Active.cpp index dae137c95..c2ab0f7cd 100644 --- a/src/V3Active.cpp +++ b/src/V3Active.cpp @@ -43,12 +43,12 @@ //###################################################################### // Collect existing active names -class ActiveBaseVisitor : public AstNVisitor { +class ActiveBaseVisitor VL_NOT_FINAL : public AstNVisitor { protected: VL_DEBUG_FUNC; // Declare debug() }; -class ActiveNamer : public ActiveBaseVisitor { +class ActiveNamer final : public ActiveBaseVisitor { private: // STATE AstScope* m_scopep = nullptr; // Current scope to add statement to @@ -138,7 +138,7 @@ public: //###################################################################### // Active AssignDly replacement functions -class ActiveDlyVisitor : public ActiveBaseVisitor { +class ActiveDlyVisitor final : public ActiveBaseVisitor { public: enum CheckType : uint8_t { CT_SEQ, CT_COMBO, CT_INITIAL, CT_LATCH }; @@ -211,7 +211,7 @@ public: //###################################################################### // Active class functions -class ActiveVisitor : public ActiveBaseVisitor { +class ActiveVisitor final : public ActiveBaseVisitor { private: // NODE STATE // Each call to V3Const::constify diff --git a/src/V3Active.h b/src/V3Active.h index cc0629e0b..79fff9303 100644 --- a/src/V3Active.h +++ b/src/V3Active.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Active { +class V3Active final { public: static void activeAll(AstNetlist* nodep); }; diff --git a/src/V3ActiveTop.cpp b/src/V3ActiveTop.cpp index 72d2f0580..3982acb29 100644 --- a/src/V3ActiveTop.cpp +++ b/src/V3ActiveTop.cpp @@ -35,7 +35,7 @@ //###################################################################### // Active class functions -class ActiveTopVisitor : public AstNVisitor { +class ActiveTopVisitor final : public AstNVisitor { private: // NODE STATE // Entire netlist diff --git a/src/V3ActiveTop.h b/src/V3ActiveTop.h index 27a7b18d1..9bc677ff8 100644 --- a/src/V3ActiveTop.h +++ b/src/V3ActiveTop.h @@ -25,7 +25,7 @@ //============================================================================ -class V3ActiveTop { +class V3ActiveTop final { public: static void activeTopAll(AstNetlist* nodep); }; diff --git a/src/V3Assert.cpp b/src/V3Assert.cpp index 981d705ae..dea371906 100644 --- a/src/V3Assert.cpp +++ b/src/V3Assert.cpp @@ -26,7 +26,7 @@ //###################################################################### // Assert class functions -class AssertVisitor : public AstNVisitor { +class AssertVisitor final : public AstNVisitor { private: // NODE STATE/TYPES // Cleared on netlist diff --git a/src/V3Assert.h b/src/V3Assert.h index d72625aba..934a2032d 100644 --- a/src/V3Assert.h +++ b/src/V3Assert.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Assert { +class V3Assert final { public: static void assertAll(AstNetlist* nodep); }; diff --git a/src/V3AssertPre.cpp b/src/V3AssertPre.cpp index 0c288ea8f..59a89461a 100644 --- a/src/V3AssertPre.cpp +++ b/src/V3AssertPre.cpp @@ -26,7 +26,7 @@ //###################################################################### // Assert class functions -class AssertPreVisitor : public AstNVisitor { +class AssertPreVisitor final : public AstNVisitor { // Removes clocks and other pre-optimizations // Eventually inlines calls to sequences, properties, etc. // We're not parsing the tree, or anything more complicated. diff --git a/src/V3AssertPre.h b/src/V3AssertPre.h index 41eceb57c..862756748 100644 --- a/src/V3AssertPre.h +++ b/src/V3AssertPre.h @@ -25,7 +25,7 @@ //============================================================================ -class V3AssertPre { +class V3AssertPre final { public: static void assertPreAll(AstNetlist* nodep); }; diff --git a/src/V3Ast.h b/src/V3Ast.h index d086a4def..5326f1515 100644 --- a/src/V3Ast.h +++ b/src/V3Ast.h @@ -71,7 +71,7 @@ typedef std::set MTaskIdSet; // Set of mtaskIds for Var sorting //###################################################################### -class AstType { +class AstType final { public: #include "V3Ast__gen_types.h" // From ./astgen // Above include has: @@ -94,7 +94,7 @@ inline std::ostream& operator<<(std::ostream& os, const AstType& rhs) { return o //###################################################################### -class VLifetime { +class VLifetime final { public: enum en : uint8_t { NONE, AUTOMATIC, STATIC }; enum en m_e; @@ -123,7 +123,7 @@ inline std::ostream& operator<<(std::ostream& os, const VLifetime& rhs) { //###################################################################### -class VAccess { +class VAccess final { public: enum en : uint8_t { READ, // Read/Consumed, variable not changed @@ -166,7 +166,7 @@ inline std::ostream& operator<<(std::ostream& os, const VAccess& rhs) { return o //###################################################################### -class VSigning { +class VSigning final { public: enum en : uint8_t { UNSIGNED, @@ -203,7 +203,7 @@ inline std::ostream& operator<<(std::ostream& os, const VSigning& rhs) { //###################################################################### -class AstPragmaType { +class AstPragmaType final { public: enum en : uint8_t { ILLEGAL, @@ -236,7 +236,7 @@ inline bool operator==(AstPragmaType::en lhs, const AstPragmaType& rhs) { return //###################################################################### -class AstCFuncType { +class AstCFuncType final { public: enum en : uint8_t { FT_NORMAL, @@ -269,7 +269,7 @@ inline bool operator==(AstCFuncType::en lhs, const AstCFuncType& rhs) { return l //###################################################################### -class VEdgeType { +class VEdgeType final { public: // REMEMBER to edit the strings below too enum en : uint8_t { @@ -355,7 +355,7 @@ inline bool operator==(VEdgeType::en lhs, const VEdgeType& rhs) { return lhs == //###################################################################### -class AstAttrType { +class AstAttrType final { public: // clang-format off enum en: uint8_t { @@ -436,7 +436,7 @@ inline bool operator==(AstAttrType::en lhs, const AstAttrType& rhs) { return lhs //###################################################################### -class AstBasicDTypeKwd { +class AstBasicDTypeKwd final { public: enum en : uint8_t { UNKNOWN, @@ -572,7 +572,7 @@ inline bool operator==(AstBasicDTypeKwd::en lhs, const AstBasicDTypeKwd& rhs) { //###################################################################### -class VDirection { +class VDirection final { public: enum en : uint8_t { NONE, INPUT, OUTPUT, INOUT, REF, CONSTREF }; enum en m_e; @@ -617,7 +617,7 @@ inline std::ostream& operator<<(std::ostream& os, const VDirection& rhs) { //###################################################################### /// Boolean or unknown -class VBoolOrUnknown { +class VBoolOrUnknown final { public: enum en : uint8_t { BU_FALSE = 0, BU_TRUE = 1, BU_UNKNOWN = 2, _ENUM_END }; enum en m_e; @@ -656,7 +656,7 @@ inline std::ostream& operator<<(std::ostream& os, const VBoolOrUnknown& rhs) { //###################################################################### /// Join type -class VJoinType { +class VJoinType final { public: enum en : uint8_t { JOIN = 0, JOIN_ANY = 1, JOIN_NONE = 2 }; enum en m_e; @@ -689,7 +689,7 @@ inline std::ostream& operator<<(std::ostream& os, const VJoinType& rhs) { //###################################################################### -class AstVarType { +class AstVarType final { public: enum en : uint8_t { UNKNOWN, @@ -757,7 +757,7 @@ inline std::ostream& operator<<(std::ostream& os, const AstVarType& rhs) { //###################################################################### -class VBranchPred { +class VBranchPred final { public: enum en : uint8_t { BP_UNKNOWN = 0, BP_LIKELY, BP_UNLIKELY, _ENUM_END }; enum en m_e; @@ -798,7 +798,7 @@ inline std::ostream& operator<<(std::ostream& os, const VBranchPred& rhs) { //###################################################################### -class VVarAttrClocker { +class VVarAttrClocker final { public: enum en : uint8_t { CLOCKER_UNKNOWN = 0, CLOCKER_YES, CLOCKER_NO, _ENUM_END }; enum en m_e; @@ -841,7 +841,7 @@ inline std::ostream& operator<<(std::ostream& os, const VVarAttrClocker& rhs) { //###################################################################### -class VAlwaysKwd { +class VAlwaysKwd final { public: enum en : uint8_t { ALWAYS, ALWAYS_FF, ALWAYS_LATCH, ALWAYS_COMB }; enum en m_e; @@ -864,7 +864,7 @@ inline bool operator==(VAlwaysKwd::en lhs, const VAlwaysKwd& rhs) { return lhs = //###################################################################### -class VCaseType { +class VCaseType final { public: enum en : uint8_t { CT_CASE, CT_CASEX, CT_CASEZ, CT_CASEINSIDE }; enum en m_e; @@ -883,7 +883,7 @@ inline bool operator==(VCaseType::en lhs, const VCaseType& rhs) { return lhs == //###################################################################### -class AstDisplayType { +class AstDisplayType final { public: enum en : uint8_t { DT_DISPLAY, DT_WRITE, DT_INFO, DT_ERROR, DT_WARNING, DT_FATAL }; enum en m_e; @@ -915,7 +915,7 @@ inline bool operator==(AstDisplayType::en lhs, const AstDisplayType& rhs) { //###################################################################### -class VDumpCtlType { +class VDumpCtlType final { public: enum en : uint8_t { FILE, VARS, ALL, FLUSH, LIMIT, OFF, ON }; enum en m_e; @@ -941,7 +941,7 @@ inline bool operator==(VDumpCtlType::en lhs, const VDumpCtlType& rhs) { return l //###################################################################### -class VParseRefExp { +class VParseRefExp final { public: enum en : uint8_t { PX_NONE, // Used in V3LinkParse only @@ -975,7 +975,7 @@ inline std::ostream& operator<<(std::ostream& os, const VParseRefExp& rhs) { // VNumRange - Structure containing numeric range information // See also AstRange, which is a symbolic version of this -class VNumRange { +class VNumRange final { public: int m_hi = 0; // HI part, HI always >= LO int m_lo = 0; // LO @@ -1048,7 +1048,7 @@ inline std::ostream& operator<<(std::ostream& os, const VNumRange& rhs) { //###################################################################### -class VUseType { +class VUseType final { public: enum en : uint8_t { IMP_INCLUDE, // Implementation (.cpp) needs an include @@ -1081,7 +1081,7 @@ inline std::ostream& operator<<(std::ostream& os, const VUseType& rhs) { //###################################################################### -class VBasicTypeKey { +class VBasicTypeKey final { public: int m_width; // From AstNodeDType: Bit width of operation int m_widthMin; // From AstNodeDType: If unsized, bitwidth of minimum implementation @@ -1123,7 +1123,7 @@ class WidthVP; class V3GraphVertex; class VSymEnt; -class VNUser { +class VNUser final { union { void* up; int ui; @@ -1159,7 +1159,7 @@ public: // user2. When the member goes out of scope it will be automagically // freed up. -class AstUserInUseBase { +class AstUserInUseBase VL_NOT_FINAL { protected: static void allocate(int id, uint32_t& cntGblRef, bool& userBusyRef) { // Perhaps there's still a AstUserInUse in scope for this? @@ -1190,7 +1190,7 @@ protected: // We let AstNode peek into here, because when under low optimization even // an accessor would be way too slow. // clang-format off -class AstUser1InUse : AstUserInUseBase { +class AstUser1InUse final : AstUserInUseBase { protected: friend class AstNode; static uint32_t s_userCntGbl; // Count of which usage of userp() this is @@ -1201,7 +1201,7 @@ public: static void clear() { clearcnt(1, s_userCntGbl/*ref*/, s_userBusy/*ref*/); } static void check() { checkcnt(1, s_userCntGbl/*ref*/, s_userBusy/*ref*/); } }; -class AstUser2InUse : AstUserInUseBase { +class AstUser2InUse final : AstUserInUseBase { protected: friend class AstNode; static uint32_t s_userCntGbl; // Count of which usage of userp() this is @@ -1212,7 +1212,7 @@ public: static void clear() { clearcnt(2, s_userCntGbl/*ref*/, s_userBusy/*ref*/); } static void check() { checkcnt(2, s_userCntGbl/*ref*/, s_userBusy/*ref*/); } }; -class AstUser3InUse : AstUserInUseBase { +class AstUser3InUse final : AstUserInUseBase { protected: friend class AstNode; static uint32_t s_userCntGbl; // Count of which usage of userp() this is @@ -1223,7 +1223,7 @@ public: static void clear() { clearcnt(3, s_userCntGbl/*ref*/, s_userBusy/*ref*/); } static void check() { checkcnt(3, s_userCntGbl/*ref*/, s_userBusy/*ref*/); } }; -class AstUser4InUse : AstUserInUseBase { +class AstUser4InUse final : AstUserInUseBase { protected: friend class AstNode; static uint32_t s_userCntGbl; // Count of which usage of userp() this is @@ -1234,7 +1234,7 @@ public: static void clear() { clearcnt(4, s_userCntGbl/*ref*/, s_userBusy/*ref*/); } static void check() { checkcnt(4, s_userCntGbl/*ref*/, s_userBusy/*ref*/); } }; -class AstUser5InUse : AstUserInUseBase { +class AstUser5InUse final : AstUserInUseBase { protected: friend class AstNode; static uint32_t s_userCntGbl; // Count of which usage of userp() this is @@ -1251,7 +1251,7 @@ public: // AstNVisitor -- Allows new functions to be called on each node // type without changing the base classes. See "Modern C++ Design". -class AstNVisitor { +class AstNVisitor VL_NOT_FINAL { private: // MEMBERS std::vector m_deleteps; // Nodes to delete when doDeletes() called @@ -1298,7 +1298,7 @@ public: // AstNRelinker -- Holds the state of a unlink so a new node can be // added at the same point. -class AstNRelinker { +class AstNRelinker final { protected: friend class AstNode; enum RelinkWhatEn : uint8_t { @@ -1328,7 +1328,7 @@ inline std::ostream& operator<<(std::ostream& os, const AstNRelinker& rhs) { //###################################################################### // V3Hash -- Node hashing for V3Combine -class V3Hash { +class V3Hash final { // A hash of a tree of nodes, consisting of 8 bits with the number of nodes in the hash // and 24 bit value hash of relevant information about the node. // A value of 0 is illegal @@ -1381,7 +1381,7 @@ std::ostream& operator<<(std::ostream& os, const V3Hash& rhs); //###################################################################### // Callback base class to determine if node matches some formula -class VNodeMatcher { +class VNodeMatcher VL_NOT_FINAL { public: virtual bool nodeMatch(const AstNode* nodep) const { return true; } }; @@ -1399,7 +1399,7 @@ public: } \ } while (false) -class AstNode { +class AstNode VL_NOT_FINAL { // v ASTNODE_PREFETCH depends on below ordering of members AstNode* m_nextp; // Next peer in the parent's list AstNode* m_backp; // Node that points to this one (via next/op1/op2/...) @@ -1914,7 +1914,7 @@ inline void AstNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); } } \ Ast##name* clonep() const { return static_cast(AstNode::clonep()); } -class AstNodeMath : public AstNode { +class AstNodeMath VL_NOT_FINAL : public AstNode { // Math -- anything that's part of an expression tree public: AstNodeMath(AstType t, FileLine* fl) @@ -1934,7 +1934,7 @@ public: bool isOpaque() { return VN_IS(this, CvtPackString); } }; -class AstNodeTermop : public AstNodeMath { +class AstNodeTermop VL_NOT_FINAL : public AstNodeMath { // Terminal operator -- a operator with no "inputs" public: AstNodeTermop(AstType t, FileLine* fl) @@ -1947,7 +1947,7 @@ public: virtual void dump(std::ostream& str) const override; }; -class AstNodeUniop : public AstNodeMath { +class AstNodeUniop VL_NOT_FINAL : public AstNodeMath { // Unary math public: AstNodeUniop(AstType t, FileLine* fl, AstNode* lhsp) @@ -1973,7 +1973,7 @@ public: virtual bool same(const AstNode*) const override { return true; } }; -class AstNodeBiop : public AstNodeMath { +class AstNodeBiop VL_NOT_FINAL : public AstNodeMath { // Binary math public: AstNodeBiop(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs) @@ -2005,7 +2005,7 @@ public: virtual bool same(const AstNode*) const override { return true; } }; -class AstNodeTriop : public AstNodeMath { +class AstNodeTriop VL_NOT_FINAL : public AstNodeMath { // Trinary math public: AstNodeTriop(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths) @@ -2038,7 +2038,7 @@ public: virtual bool same(const AstNode*) const override { return true; } }; -class AstNodeQuadop : public AstNodeMath { +class AstNodeQuadop VL_NOT_FINAL : public AstNodeMath { // Quaternary math public: AstNodeQuadop(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths, AstNode* fhs) @@ -2075,7 +2075,7 @@ public: virtual bool same(const AstNode*) const override { return true; } }; -class AstNodeBiCom : public AstNodeBiop { +class AstNodeBiCom VL_NOT_FINAL : public AstNodeBiop { // Binary math with commutative properties public: AstNodeBiCom(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs) @@ -2083,14 +2083,14 @@ public: ASTNODE_BASE_FUNCS(NodeBiCom) }; -class AstNodeBiComAsv : public AstNodeBiCom { +class AstNodeBiComAsv VL_NOT_FINAL : public AstNodeBiCom { // Binary math with commutative & associative properties public: AstNodeBiComAsv(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs) : AstNodeBiCom{t, fl, lhs, rhs} {} ASTNODE_BASE_FUNCS(NodeBiComAsv) }; -class AstNodeCond : public AstNodeTriop { +class AstNodeCond VL_NOT_FINAL : public AstNodeTriop { public: AstNodeCond(AstType t, FileLine* fl, AstNode* condp, AstNode* expr1p, AstNode* expr2p) : AstNodeTriop{t, fl, condp, expr1p, expr2p} { @@ -2121,7 +2121,7 @@ public: virtual AstNode* cloneType(AstNode* condp, AstNode* expr1p, AstNode* expr2p) = 0; }; -class AstNodeBlock : public AstNode { +class AstNodeBlock VL_NOT_FINAL : public AstNode { // A Begin/fork block // Parents: statement // Children: statements @@ -2145,7 +2145,7 @@ public: bool unnamed() const { return m_unnamed; } }; -class AstNodePreSel : public AstNode { +class AstNodePreSel VL_NOT_FINAL : public AstNode { // Something that becomes an AstSel public: AstNodePreSel(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths) @@ -2169,7 +2169,7 @@ public: virtual bool same(const AstNode*) const override { return true; } }; -class AstNodeProcedure : public AstNode { +class AstNodeProcedure VL_NOT_FINAL : public AstNode { // IEEE procedure: initial, final, always public: AstNodeProcedure(AstType t, FileLine* fl, AstNode* bodysp) @@ -2184,7 +2184,7 @@ public: bool isJustOneBodyStmt() const { return bodysp() && !bodysp()->nextp(); } }; -class AstNodeStmt : public AstNode { +class AstNodeStmt VL_NOT_FINAL : public AstNode { // Statement -- anything that's directly under a function bool m_statement; // Really a statement (e.g. not a function with return) public: @@ -2202,7 +2202,7 @@ public: virtual void dump(std::ostream& str = std::cout) const override; }; -class AstNodeAssign : public AstNodeStmt { +class AstNodeAssign VL_NOT_FINAL : public AstNodeStmt { public: AstNodeAssign(AstType t, FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeStmt{t, fl} { @@ -2227,7 +2227,7 @@ public: virtual bool brokeLhsMustBeLvalue() const = 0; }; -class AstNodeFor : public AstNodeStmt { +class AstNodeFor VL_NOT_FINAL : public AstNodeStmt { public: AstNodeFor(AstType t, FileLine* fl, AstNode* initsp, AstNode* condp, AstNode* incsp, AstNode* bodysp) @@ -2248,7 +2248,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstNodeIf : public AstNodeStmt { +class AstNodeIf VL_NOT_FINAL : public AstNodeStmt { private: VBranchPred m_branchPred; // Branch prediction as taken/untaken? public: @@ -2274,7 +2274,7 @@ public: VBranchPred branchPred() const { return m_branchPred; } }; -class AstNodeCase : public AstNodeStmt { +class AstNodeCase VL_NOT_FINAL : public AstNodeStmt { public: AstNodeCase(AstType t, FileLine* fl, AstNode* exprp, AstNode* casesp) : AstNodeStmt{t, fl} { @@ -2292,7 +2292,7 @@ public: void addNotParallelp(AstNode* nodep) { setOp3p(nodep); } }; -class AstNodeVarRef : public AstNodeMath { +class AstNodeVarRef VL_NOT_FINAL : public AstNodeMath { // An AstVarRef or AstVarXRef private: VAccess m_access; // Left hand side assignment @@ -2344,7 +2344,7 @@ public: void iterateChildren(AstNVisitor& v) {} }; -class AstNodeText : public AstNode { +class AstNodeText VL_NOT_FINAL : public AstNode { private: string m_text; @@ -2364,7 +2364,7 @@ public: const string& text() const { return m_text; } }; -class AstNodeDType : public AstNode { +class AstNodeDType VL_NOT_FINAL : public AstNode { // Ideally width() would migrate to BasicDType as that's where it makes sense, // but it's currently so prevalent in the code we leave it here. // Note the below members are included in AstTypeTable::Key lookups @@ -2460,7 +2460,7 @@ private: CTypeRecursed cTypeRecurse(bool compound) const; }; -class AstNodeUOrStructDType : public AstNodeDType { +class AstNodeUOrStructDType VL_NOT_FINAL : public AstNodeDType { // A struct or union; common handling private: // TYPES @@ -2524,7 +2524,7 @@ public: VNumRange declRange() const { return VNumRange(msb(), lsb(), false); } }; -class AstNodeArrayDType : public AstNodeDType { +class AstNodeArrayDType VL_NOT_FINAL : public AstNodeDType { // Array data type, ie "some_dtype var_name [2:0]" // Children: DTYPE (moved to refDTypep() in V3Width) // Children: RANGE (array bounds) @@ -2587,7 +2587,7 @@ public: VNumRange declRange() const; }; -class AstNodeSel : public AstNodeBiop { +class AstNodeSel VL_NOT_FINAL : public AstNodeBiop { // Single bit range extraction, perhaps with non-constant selection or array selection public: AstNodeSel(AstType t, FileLine* fl, AstNode* fromp, AstNode* bitp) @@ -2603,7 +2603,7 @@ public: virtual bool hasDType() const override { return true; } }; -class AstNodeStream : public AstNodeBiop { +class AstNodeStream VL_NOT_FINAL : public AstNodeBiop { // Verilog {rhs{lhs}} - Note rhsp() is the slice size, not the lhsp() public: AstNodeStream(AstType t, FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -2616,7 +2616,7 @@ public: //###################################################################### // Tasks/functions common handling -class AstNodeCCall : public AstNodeStmt { +class AstNodeCCall VL_NOT_FINAL : public AstNodeStmt { // A call of a C++ function, perhaps a AstCFunc or perhaps globally named // Functions are not statements, while tasks are. AstNodeStmt needs isStatement() to deal. AstCFunc* m_funcp; @@ -2664,7 +2664,7 @@ public: void addArgsp(AstNode* nodep) { addOp2p(nodep); } }; -class AstNodeFTask : public AstNode { +class AstNodeFTask VL_NOT_FINAL : public AstNode { private: string m_name; // Name of task string m_cname; // Name of task if DPI import @@ -2769,7 +2769,7 @@ public: VLifetime lifetime() const { return m_lifetime; } }; -class AstNodeFTaskRef : public AstNodeStmt { +class AstNodeFTaskRef VL_NOT_FINAL : public AstNodeStmt { // A reference to a task (or function) // Functions are not statements, while tasks are. AstNodeStmt needs isStatement() to deal. private: @@ -2823,7 +2823,7 @@ public: void scopeNamep(AstNode* nodep) { setNOp4p(nodep); } }; -class AstNodeModule : public AstNode { +class AstNodeModule VL_NOT_FINAL : public AstNode { // A module, package, program or interface declaration; // something that can live directly under the TOP, // excluding $unit package stuff @@ -2902,7 +2902,7 @@ public: VOptionBool unconnectedDrive() const { return m_unconnectedDrive; } }; -class AstNodeRange : public AstNode { +class AstNodeRange VL_NOT_FINAL : public AstNode { // A range, sized or unsized public: AstNodeRange(AstType t, FileLine* fl) diff --git a/src/V3AstNodes.cpp b/src/V3AstNodes.cpp index 9ad9a58c1..3f5dfb2d9 100644 --- a/src/V3AstNodes.cpp +++ b/src/V3AstNodes.cpp @@ -553,7 +553,7 @@ string AstVar::mtasksString() const { return os.str(); } -class AstNodeDType::CTypeRecursed { +class AstNodeDType::CTypeRecursed final { public: string m_type; // The base type, e.g.: "Foo_t"s string m_dims; // Array dimensions, e.g.: "[3][2][1]" diff --git a/src/V3AstNodes.h b/src/V3AstNodes.h index f68c68120..c70763cc9 100644 --- a/src/V3AstNodes.h +++ b/src/V3AstNodes.h @@ -48,7 +48,7 @@ //=== Ast* : Specific types // Netlist interconnect -class AstConst : public AstNodeMath { +class AstConst final : public AstNodeMath { // A constant private: V3Number m_num; // Constant value @@ -175,7 +175,7 @@ public: static AstConst* parseParamLiteral(FileLine* fl, const string& literal); }; -class AstRange : public AstNodeRange { +class AstRange final : public AstNodeRange { // Range specification, for use under variables and cells private: bool m_littleEndian : 1; // Bit vector is little endian @@ -234,7 +234,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstBracketRange : public AstNodeRange { +class AstBracketRange final : public AstNodeRange { // Parser only concept "[lhsp]", a AstUnknownRange, QueueRange or Range, // unknown until lhsp type is determined public: @@ -253,7 +253,7 @@ public: AstNode* elementsp() const { return op1p(); } }; -class AstUnsizedRange : public AstNodeRange { +class AstUnsizedRange final : public AstNodeRange { // Unsized range specification, for open arrays public: explicit AstUnsizedRange(FileLine* fl) @@ -265,7 +265,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstGatePin : public AstNodeMath { +class AstGatePin final : public AstNodeMath { // Possibly expand a gate primitive input pin value to match the range of the gate primitive public: AstGatePin(FileLine* fl, AstNode* lhsp, AstRange* rangep) @@ -284,7 +284,7 @@ public: //###################################################################### // Classes -class AstClassPackage : public AstNodeModule { +class AstClassPackage final : public AstNodeModule { // The static information portion of a class (treated similarly to a package) AstClass* m_classp = nullptr; // Class package this is under (weak pointer, hard link is other way) @@ -298,7 +298,7 @@ public: void classp(AstClass* classp) { m_classp = classp; } }; -class AstClass : public AstNodeModule { +class AstClass final : public AstNodeModule { // TYPES typedef std::map MemberNameMap; // MEMBERS @@ -343,7 +343,7 @@ public: void isVirtual(bool flag) { m_virtual = flag; } }; -class AstClassExtends : public AstNode { +class AstClassExtends final : public AstNode { // Children: List of AstParseRef for packages/classes // during early parse, then moves to dtype public: @@ -364,7 +364,7 @@ public: //###################################################################### //==== Data Types -class AstParamTypeDType : public AstNodeDType { +class AstParamTypeDType final : public AstNodeDType { // Parents: MODULE // A parameter type statement; much like a var or typedef private: @@ -409,7 +409,7 @@ public: bool isGParam() const { return (varType() == AstVarType::GPARAM); } }; -class AstTypedef : public AstNode { +class AstTypedef final : public AstNode { private: string m_name; bool m_attrPublic; @@ -444,7 +444,7 @@ public: virtual string tag() const override { return m_tag; } }; -class AstTypedefFwd : public AstNode { +class AstTypedefFwd final : public AstNode { // Forward declaration of a type; stripped after netlist parsing is complete private: string m_name; @@ -459,7 +459,7 @@ public: virtual bool maybePointedTo() const override { return true; } }; -class AstDefImplicitDType : public AstNodeDType { +class AstDefImplicitDType final : public AstNodeDType { // For parsing enum/struct/unions that are declared with a variable rather than typedef // This allows "var enum {...} a,b" to share the enum definition for both variables // After link, these become typedefs @@ -509,7 +509,7 @@ public: virtual void name(const string& flag) override { m_name = flag; } }; -class AstAssocArrayDType : public AstNodeDType { +class AstAssocArrayDType final : public AstNodeDType { // Associative array data type, ie "[some_dtype]" // Children: DTYPE (moved to refDTypep() in V3Width) // Children: DTYPE (the key, which remains here as a pointer) @@ -580,7 +580,7 @@ public: virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; -class AstBracketArrayDType : public AstNodeDType { +class AstBracketArrayDType final : public AstNodeDType { // Associative/Queue/Normal array data type, ie "[dtype_or_expr]" // only for early parsing then becomes another data type // Children: DTYPE (moved to refDTypep() in V3Width) @@ -610,7 +610,7 @@ public: virtual int widthTotalBytes() const override { V3ERROR_NA_RETURN(0); } }; -class AstDynArrayDType : public AstNodeDType { +class AstDynArrayDType final : public AstNodeDType { // Dynamic array data type, ie "[]" // Children: DTYPE (moved to refDTypep() in V3Width) private: @@ -669,7 +669,7 @@ public: virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; -class AstPackArrayDType : public AstNodeArrayDType { +class AstPackArrayDType final : public AstNodeArrayDType { // Packed array data type, ie "some_dtype [2:0] var_name" // Children: DTYPE (moved to refDTypep() in V3Width) // Children: RANGE (array bounds) @@ -695,7 +695,7 @@ public: virtual string prettyDTypeName() const override; }; -class AstUnpackArrayDType : public AstNodeArrayDType { +class AstUnpackArrayDType final : public AstNodeArrayDType { // Array data type, ie "some_dtype var_name [2:0]" // Children: DTYPE (moved to refDTypep() in V3Width) // Children: RANGE (array bounds) @@ -723,7 +723,7 @@ public: virtual string prettyDTypeName() const override; }; -class AstUnsizedArrayDType : public AstNodeDType { +class AstUnsizedArrayDType final : public AstNodeDType { // Unsized/open-range Array data type, ie "some_dtype var_name []" // Children: DTYPE (moved to refDTypep() in V3Width) private: @@ -775,7 +775,7 @@ public: virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; -class AstBasicDType : public AstNodeDType { +class AstBasicDType final : public AstNodeDType { // Builtin atomic/vectored data type // Children: RANGE (converted to constant in V3Width) private: @@ -932,7 +932,7 @@ public: } }; -class AstConstDType : public AstNodeDType { +class AstConstDType final : public AstNodeDType { // const data type, ie "const some_dtype var_name [2:0]" // ConstDType are removed in V3LinkLValue and become AstVar::isConst. // When more generic types are supported AstConstDType will be propagated further. @@ -984,7 +984,7 @@ public: virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; -class AstClassRefDType : public AstNodeDType { +class AstClassRefDType final : public AstNodeDType { // Reference to a class private: AstClass* m_classp; // data type pointed to, BELOW the AstTypedef @@ -1032,7 +1032,7 @@ public: void classp(AstClass* nodep) { m_classp = nodep; } }; -class AstIfaceRefDType : public AstNodeDType { +class AstIfaceRefDType final : public AstNodeDType { // Reference to an interface, either for a port, or inside parent cell private: FileLine* m_modportFileline; // Where modport token was @@ -1087,7 +1087,7 @@ public: bool isModport() { return !m_modportName.empty(); } }; -class AstQueueDType : public AstNodeDType { +class AstQueueDType final : public AstNodeDType { // Queue array data type, ie "[ $ ]" // Children: DTYPE (moved to refDTypep() in V3Width) private: @@ -1157,7 +1157,7 @@ public: virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; -class AstRefDType : public AstNodeDType { +class AstRefDType final : public AstNodeDType { private: // Pre-Width must reference the Typeref, not what it points to, as some child // types like AstBracketArrayType will disappear and can't lose the handle @@ -1258,7 +1258,7 @@ public: AstPin* paramsp() const { return VN_CAST(op4p(), Pin); } }; -class AstStructDType : public AstNodeUOrStructDType { +class AstStructDType final : public AstNodeUOrStructDType { public: // VSigning below is mispurposed to indicate if packed or not AstStructDType(FileLine* fl, VSigning numericUnpack) @@ -1267,7 +1267,7 @@ public: virtual string verilogKwd() const override { return "struct"; } }; -class AstUnionDType : public AstNodeUOrStructDType { +class AstUnionDType final : public AstNodeUOrStructDType { public: // UNSUP: bool isTagged; // VSigning below is mispurposed to indicate if packed or not @@ -1277,7 +1277,7 @@ public: virtual string verilogKwd() const override { return "union"; } }; -class AstMemberDType : public AstNodeDType { +class AstMemberDType final : public AstNodeDType { // A member of a struct/union // PARENT: AstNodeUOrStructDType private: @@ -1340,7 +1340,7 @@ public: void lsb(int lsb) { m_lsb = lsb; } }; -class AstVoidDType : public AstNodeDType { +class AstVoidDType final : public AstNodeDType { // For e.g. a function returning void public: explicit AstVoidDType(FileLine* fl) @@ -1367,7 +1367,7 @@ public: virtual V3Hash sameHash() const override { return V3Hash(); } }; -class AstEnumItem : public AstNode { +class AstEnumItem final : public AstNode { private: string m_name; @@ -1390,7 +1390,7 @@ public: void valuep(AstNode* nodep) { addOp2p(nodep); } }; -class AstEnumItemRef : public AstNodeMath { +class AstEnumItemRef final : public AstNodeMath { private: AstEnumItem* m_itemp; // [AfterLink] Pointer to item AstNodeModule* m_packagep; // Package hierarchy @@ -1424,7 +1424,7 @@ public: void packagep(AstNodeModule* nodep) { m_packagep = nodep; } }; -class AstEnumDType : public AstNodeDType { +class AstEnumDType final : public AstNodeDType { // Parents: TYPEDEF/MODULE // Children: ENUMVALUEs private: @@ -1483,7 +1483,7 @@ public: virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; -class AstParseTypeDType : public AstNodeDType { +class AstParseTypeDType final : public AstNodeDType { // Parents: VAR // During parsing, this indicates the type of a parameter is a "parameter type" // e.g. the data type is a container of any data type @@ -1506,7 +1506,7 @@ public: //###################################################################### -class AstArraySel : public AstNodeSel { +class AstArraySel final : public AstNodeSel { // Parents: math|stmt // Children: varref|arraysel, math private: @@ -1552,7 +1552,7 @@ public: baseFromp(AstNode* nodep); ///< What is the base variable (or const) this dereferences? }; -class AstAssocSel : public AstNodeSel { +class AstAssocSel final : public AstNodeSel { // Parents: math|stmt // Children: varref|arraysel, math private: @@ -1591,7 +1591,7 @@ public: virtual int instrCount() const override { return widthInstrs(); } }; -class AstWordSel : public AstNodeSel { +class AstWordSel final : public AstNodeSel { // Select a single word from a multi-word wide value public: AstWordSel(FileLine* fl, AstNode* fromp, AstNode* bitp) @@ -1618,7 +1618,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstSelLoopVars : public AstNode { +class AstSelLoopVars final : public AstNode { // Parser only concept "[id, id, id]" for a foreach statement // Unlike normal selects elements is a list public: @@ -1635,7 +1635,7 @@ public: AstNode* elementsp() const { return op2p(); } }; -class AstSelExtract : public AstNodePreSel { +class AstSelExtract final : public AstNodePreSel { // Range extraction, gets replaced with AstSel public: AstSelExtract(FileLine* fl, AstNode* fromp, AstNode* msbp, AstNode* lsbp) @@ -1645,7 +1645,7 @@ public: AstNode* lsbp() const { return thsp(); } }; -class AstSelBit : public AstNodePreSel { +class AstSelBit final : public AstNodePreSel { // Single bit range extraction, perhaps with non-constant selection or array selection // Gets replaced during link with AstArraySel or AstSel public: @@ -1658,7 +1658,7 @@ public: AstNode* bitp() const { return rhsp(); } }; -class AstSelPlus : public AstNodePreSel { +class AstSelPlus final : public AstNodePreSel { // +: range extraction, perhaps with non-constant selection // Gets replaced during link with AstSel public: @@ -1669,7 +1669,7 @@ public: AstNode* widthp() const { return thsp(); } }; -class AstSelMinus : public AstNodePreSel { +class AstSelMinus final : public AstNodePreSel { // -: range extraction, perhaps with non-constant selection // Gets replaced during link with AstSel public: @@ -1680,7 +1680,7 @@ public: AstNode* widthp() const { return thsp(); } }; -class AstSel : public AstNodeTriop { +class AstSel final : public AstNodeTriop { // Multiple bit range extraction // Parents: math|stmt // Children: varref|arraysel, math, constant math @@ -1740,7 +1740,7 @@ public: void declElWidth(int flag) { m_declElWidth = flag; } }; -class AstSliceSel : public AstNodeTriop { +class AstSliceSel final : public AstNodeTriop { // Multiple array element extraction // Parents: math|stmt // Children: varref|arraysel, math, constant math @@ -1778,7 +1778,7 @@ public: void declRange(const VNumRange& flag) { m_declRange = flag; } }; -class AstMethodCall : public AstNodeFTaskRef { +class AstMethodCall final : public AstNodeFTaskRef { // A reference to a member task (or function) // PARENTS: stmt/math // Not all calls are statments vs math. AstNodeStmt needs isStatement() to deal. @@ -1812,7 +1812,7 @@ public: void fromp(AstNode* nodep) { setOp2p(nodep); } }; -class AstCMethodHard : public AstNodeStmt { +class AstCMethodHard final : public AstNodeStmt { // A reference to a "C" hardcoded member task (or function) // PARENTS: stmt/math // Not all calls are statments vs math. AstNodeStmt needs isStatement() to deal. @@ -1857,7 +1857,7 @@ public: void addPinsp(AstNode* nodep) { addOp2p(nodep); } }; -class AstVar : public AstNode { +class AstVar final : public AstNode { // A variable (in/out/wire/reg/param) inside a module private: string m_name; // Name of variable @@ -2190,7 +2190,7 @@ public: string mtasksString() const; }; -class AstDefParam : public AstNode { +class AstDefParam final : public AstNode { // A defparam assignment // Parents: MODULE // Children: math @@ -2212,7 +2212,7 @@ public: string path() const { return m_path; } }; -class AstImplicit : public AstNode { +class AstImplicit final : public AstNode { // Create implicit wires and do nothing else, for gates that are ignored // Parents: MODULE public: @@ -2224,7 +2224,7 @@ public: AstNode* exprsp() const { return op1p(); } // op1 = Assign from }; -class AstScope : public AstNode { +class AstScope final : public AstNode { // A particular usage of a cell // Parents: MODULE // Children: NODEBLOCK @@ -2263,7 +2263,7 @@ public: bool isTop() const { return aboveScopep() == nullptr; } // At top of hierarchy }; -class AstTopScope : public AstNode { +class AstTopScope final : public AstNode { // In the top level netlist, a complete scope tree // There may be two of these, when we support "rare" and "usual" splitting // Parents: topMODULE @@ -2279,7 +2279,7 @@ public: AstScope* scopep() const { return VN_CAST(op2p(), Scope); } // op1 = AstVarScope's }; -class AstVarScope : public AstNode { +class AstVarScope final : public AstNode { // A particular scoped usage of a variable // That is, as a module is used under multiple cells, we get a different // varscope for each var in the module @@ -2327,7 +2327,7 @@ public: void trace(bool flag) { m_trace = flag; } }; -class AstVarRef : public AstNodeVarRef { +class AstVarRef final : public AstNodeVarRef { // A reference to a variable (lvalue or rvalue) public: AstVarRef(FileLine* fl, const string& name, const VAccess& access) @@ -2374,7 +2374,7 @@ public: virtual bool cleanOut() const override { return true; } }; -class AstVarXRef : public AstNodeVarRef { +class AstVarXRef final : public AstNodeVarRef { // A VarRef to something in another module before AstScope. // Includes pin on a cell, as part of a ASSIGN statement to connect I/Os until AstScope private: @@ -2408,7 +2408,7 @@ public: } }; -class AstPin : public AstNode { +class AstPin final : public AstNode { // A pin on a cell private: int m_pinNum; // Pin number @@ -2462,7 +2462,7 @@ public: void svImplicit(bool flag) { m_svImplicit = flag; } }; -class AstArg : public AstNode { +class AstArg final : public AstNode { // An argument to a function/task private: string m_name; // Pin name, or "" for number based interconnect @@ -2482,7 +2482,7 @@ public: bool emptyConnectNoNext() const { return !exprp() && name() == "" && !nextp(); } }; -class AstModule : public AstNodeModule { +class AstModule final : public AstNodeModule { // A module declaration private: bool m_isProgram; // Module represents a program @@ -2494,7 +2494,7 @@ public: virtual string verilogKwd() const override { return m_isProgram ? "program" : "module"; } }; -class AstNotFoundModule : public AstNodeModule { +class AstNotFoundModule final : public AstNodeModule { // A missing module declaration public: AstNotFoundModule(FileLine* fl, const string& name) @@ -2503,7 +2503,7 @@ public: virtual string verilogKwd() const override { return "/*not-found-*/ module"; } }; -class AstPackage : public AstNodeModule { +class AstPackage final : public AstNodeModule { // A package declaration public: AstPackage(FileLine* fl, const string& name) @@ -2514,7 +2514,7 @@ public: bool isDollarUnit() const { return name() == dollarUnitName(); } }; -class AstPrimitive : public AstNodeModule { +class AstPrimitive final : public AstNodeModule { // A primitive declaration public: AstPrimitive(FileLine* fl, const string& name) @@ -2523,7 +2523,7 @@ public: virtual string verilogKwd() const override { return "primitive"; } }; -class AstPackageExportStarStar : public AstNode { +class AstPackageExportStarStar final : public AstNode { // A package export *::* declaration public: // cppcheck-suppress noExplicitConstructor @@ -2532,7 +2532,7 @@ public: ASTNODE_NODE_FUNCS(PackageExportStarStar) }; -class AstPackageExport : public AstNode { +class AstPackageExport final : public AstNode { private: // A package export declaration string m_name; @@ -2556,7 +2556,7 @@ public: void packagep(AstPackage* nodep) { m_packagep = nodep; } }; -class AstPackageImport : public AstNode { +class AstPackageImport final : public AstNode { private: // A package import declaration string m_name; @@ -2580,7 +2580,7 @@ public: void packagep(AstPackage* nodep) { m_packagep = nodep; } }; -class AstIface : public AstNodeModule { +class AstIface final : public AstNodeModule { // A module declaration public: AstIface(FileLine* fl, const string& name) @@ -2588,7 +2588,7 @@ public: ASTNODE_NODE_FUNCS(Iface) }; -class AstMemberSel : public AstNodeMath { +class AstMemberSel final : public AstNodeMath { // Parents: math|stmt // Children: varref|arraysel, math private: @@ -2634,7 +2634,7 @@ public: void varp(AstVar* nodep) { m_varp = nodep; } }; -class AstModportFTaskRef : public AstNode { +class AstModportFTaskRef final : public AstNode { // An import/export referenced under a modport // The storage for the function itself is inside the // interface/instantiator, thus this is a reference @@ -2664,7 +2664,7 @@ public: void ftaskp(AstNodeFTask* ftaskp) { m_ftaskp = ftaskp; } }; -class AstModportVarRef : public AstNode { +class AstModportVarRef final : public AstNode { // A input/output/etc variable referenced under a modport // The storage for the variable itself is inside the interface, thus this is a reference // PARENT: AstModport @@ -2693,7 +2693,7 @@ public: void varp(AstVar* varp) { m_varp = varp; } }; -class AstModport : public AstNode { +class AstModport final : public AstNode { // A modport in an interface private: string m_name; // Name of the modport @@ -2709,7 +2709,7 @@ public: AstNode* varsp() const { return op1p(); } // op1 = List of Vars }; -class AstIntfRef : public AstNode { +class AstIntfRef final : public AstNode { // An interface reference private: string m_name; // Name of the reference @@ -2721,7 +2721,7 @@ public: ASTNODE_NODE_FUNCS(IntfRef) }; -class AstCell : public AstNode { +class AstCell final : public AstNode { // A instantiation cell or interface call (don't know which until link) private: FileLine* m_modNameFileline; // Where module the cell instances token was @@ -2783,7 +2783,7 @@ public: bool recursive() const { return m_recursive; } }; -class AstCellInline : public AstNode { +class AstCellInline final : public AstNode { // A instantiation cell that was removed by inlining // For communication between V3Inline and V3LinkDot, // except for VPI runs where it exists until the end. @@ -2817,7 +2817,7 @@ public: VTimescale timeunit() const { return m_timeunit; } }; -class AstCellRef : public AstNode { +class AstCellRef final : public AstNode { // As-of-yet unlinkable reference into a cell private: string m_name; // Cell name @@ -2835,7 +2835,7 @@ public: AstNode* exprp() const { return op2p(); } // op2 = Expression }; -class AstCellArrayRef : public AstNode { +class AstCellArrayRef final : public AstNode { // As-of-yet unlinkable reference into an array of cells private: string m_name; // Array name @@ -2851,7 +2851,7 @@ public: AstNode* selp() const { return op1p(); } // op1 = Select expression }; -class AstUnlinkedRef : public AstNode { +class AstUnlinkedRef final : public AstNode { // As-of-yet unlinkable Ref private: string m_name; // Var name @@ -2869,7 +2869,7 @@ public: AstNode* cellrefp() const { return op2p(); } // op2 = CellArrayRef or CellRef }; -class AstBind : public AstNode { +class AstBind final : public AstNode { // Parents: MODULE // Children: CELL private: @@ -2888,7 +2888,7 @@ public: AstNode* cellsp() const { return op1p(); } // op1 = cells }; -class AstPort : public AstNode { +class AstPort final : public AstNode { // A port (in/out/inout) on a module private: int m_pinNum; // Pin number @@ -2906,7 +2906,7 @@ public: //###################################################################### -class AstParseRef : public AstNode { +class AstParseRef final : public AstNode { // A reference to a variable, function or task // We don't know which at parse time due to bison constraints // The link stages will replace this with AstVarRef, or AstTaskRef, etc. @@ -2942,7 +2942,7 @@ public: void ftaskrefp(AstNodeFTaskRef* nodep) { setNOp2p(nodep); } // op2 = Function/task reference }; -class AstClassOrPackageRef : public AstNode { +class AstClassOrPackageRef final : public AstNode { private: string m_name; AstNode* m_classOrPackagep; // Package hierarchy @@ -2978,7 +2978,7 @@ public: AstPin* paramsp() const { return VN_CAST(op4p(), Pin); } }; -class AstDot : public AstNode { +class AstDot final : public AstNode { // A dot separating paths in an AstVarXRef, AstFuncRef or AstTaskRef // These are eliminated in the link stage bool m_colon; // Is a "::" instead of a "." (lhs must be package/class) @@ -3001,7 +3001,7 @@ public: bool colon() const { return m_colon; } }; -class AstUnbounded : public AstNodeMath { +class AstUnbounded final : public AstNodeMath { // A $ in the parser, used for unbounded and queues // Due to where is used, treated as Signed32 public: @@ -3017,7 +3017,7 @@ public: //###################################################################### -class AstTask : public AstNodeFTask { +class AstTask final : public AstNodeFTask { // A task inside a module public: AstTask(FileLine* fl, const string& name, AstNode* stmtp) @@ -3025,7 +3025,7 @@ public: ASTNODE_NODE_FUNCS(Task) }; -class AstFunc : public AstNodeFTask { +class AstFunc final : public AstNodeFTask { // A function inside a module public: AstFunc(FileLine* fl, const string& name, AstNode* stmtp, AstNode* fvarsp) @@ -3036,7 +3036,7 @@ public: virtual bool hasDType() const override { return true; } }; -class AstTaskRef : public AstNodeFTaskRef { +class AstTaskRef final : public AstNodeFTaskRef { // A reference to a task public: AstTaskRef(FileLine* fl, AstParseRef* namep, AstNode* pinsp) @@ -3048,7 +3048,7 @@ public: ASTNODE_NODE_FUNCS(TaskRef) }; -class AstFuncRef : public AstNodeFTaskRef { +class AstFuncRef final : public AstNodeFTaskRef { // A reference to a function public: AstFuncRef(FileLine* fl, AstParseRef* namep, AstNode* pinsp) @@ -3059,7 +3059,7 @@ public: virtual bool hasDType() const override { return true; } }; -class AstDpiExport : public AstNode { +class AstDpiExport final : public AstNode { // We could put an AstNodeFTaskRef instead of the verilog function name, // however we're not *calling* it, so that seems somehow wrong. // (Probably AstNodeFTaskRef should be renamed AstNodeFTaskCall and have-a AstNodeFTaskRef) @@ -3078,7 +3078,7 @@ public: void cname(const string& cname) { m_cname = cname; } }; -class AstWithParse : public AstNodeStmt { +class AstWithParse final : public AstNodeStmt { // In early parse, FUNC(index) WITH equation-using-index // Replaced with AstWith // Parents: math|stmt @@ -3098,7 +3098,7 @@ public: AstNode* exprp() const { return op2p(); } }; -class AstLambdaArgRef : public AstNodeMath { +class AstLambdaArgRef final : public AstNodeMath { // Lambda argument usage // These are not AstVarRefs because we need to be able to delete/clone lambdas during // optimizations and AstVar's are painful to remove. @@ -3121,7 +3121,7 @@ public: virtual void name(const string& name) override { m_name = name; } }; -class AstWith : public AstNodeStmt { +class AstWith final : public AstNodeStmt { // Used as argument to method, then to AstCMethodHard // dtypep() contains the with lambda's return dtype // Parents: funcref (similar to AstArg) @@ -3148,7 +3148,7 @@ public: //###################################################################### -class AstSenItem : public AstNode { +class AstSenItem final : public AstNode { // Parents: SENTREE // Children: (optional) VARREF private: @@ -3204,7 +3204,7 @@ public: bool hasVar() const { return !(isCombo() || isInitial() || isSettle() || isNever()); } }; -class AstSenTree : public AstNode { +class AstSenTree final : public AstNode { // A list of senitems // Parents: MODULE | SBLOCK // Children: SENITEM list @@ -3231,21 +3231,21 @@ public: bool hasCombo() const; // Includes a COMBO SenItem }; -class AstFinal : public AstNodeProcedure { +class AstFinal final : public AstNodeProcedure { public: AstFinal(FileLine* fl, AstNode* bodysp) : ASTGEN_SUPER(fl, bodysp) {} ASTNODE_NODE_FUNCS(Final) }; -class AstInitial : public AstNodeProcedure { +class AstInitial final : public AstNodeProcedure { public: AstInitial(FileLine* fl, AstNode* bodysp) : ASTGEN_SUPER(fl, bodysp) {} ASTNODE_NODE_FUNCS(Initial) }; -class AstAlways : public AstNodeProcedure { +class AstAlways final : public AstNodeProcedure { VAlwaysKwd m_keyword; public: @@ -3262,7 +3262,7 @@ public: VAlwaysKwd keyword() const { return m_keyword; } }; -class AstAlwaysPublic : public AstNodeStmt { +class AstAlwaysPublic final : public AstNodeStmt { // "Fake" sensitivity created by /*verilator public_flat_rw @(edgelist)*/ // Body statements are just AstVarRefs to the public signals public: @@ -3282,7 +3282,7 @@ public: bool isJustOneBodyStmt() const { return bodysp() && !bodysp()->nextp(); } }; -class AstAlwaysPost : public AstNode { +class AstAlwaysPost final : public AstNode { // Like always but post assignments for memory assignment IFs public: AstAlwaysPost(FileLine* fl, AstSenTree* sensesp, AstNode* bodysp) @@ -3296,7 +3296,7 @@ public: void addBodysp(AstNode* newp) { addOp2p(newp); } }; -class AstAssign : public AstNodeAssign { +class AstAssign final : public AstNodeAssign { public: AstAssign(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -3309,7 +3309,7 @@ public: virtual bool brokeLhsMustBeLvalue() const override { return true; } }; -class AstAssignAlias : public AstNodeAssign { +class AstAssignAlias final : public AstNodeAssign { // Like AstAssignW, but a true bidirect interconnection alias // If both sides are wires, there's no LHS vs RHS, public: @@ -3322,7 +3322,7 @@ public: virtual bool brokeLhsMustBeLvalue() const override { return false; } }; -class AstAssignDly : public AstNodeAssign { +class AstAssignDly final : public AstNodeAssign { public: AstAssignDly(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} @@ -3335,7 +3335,7 @@ public: virtual bool brokeLhsMustBeLvalue() const override { return true; } }; -class AstAssignW : public AstNodeAssign { +class AstAssignW final : public AstNodeAssign { // Like assign, but wire/assign's in verilog, the only setting of the specified variable public: AstAssignW(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -3355,7 +3355,7 @@ public: } }; -class AstAssignVarScope : public AstNodeAssign { +class AstAssignVarScope final : public AstNodeAssign { // Assign two VarScopes to each other public: AstAssignVarScope(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -3369,7 +3369,7 @@ public: virtual bool brokeLhsMustBeLvalue() const override { return false; } }; -class AstPull : public AstNode { +class AstPull final : public AstNode { private: bool m_direction; @@ -3388,7 +3388,7 @@ public: uint32_t direction() const { return (uint32_t)m_direction; } }; -class AstAssignPre : public AstNodeAssign { +class AstAssignPre final : public AstNodeAssign { // Like Assign, but predelayed assignment requiring special order handling public: AstAssignPre(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -3400,7 +3400,7 @@ public: virtual bool brokeLhsMustBeLvalue() const override { return true; } }; -class AstAssignPost : public AstNodeAssign { +class AstAssignPost final : public AstNodeAssign { // Like Assign, but predelayed assignment requiring special order handling public: AstAssignPost(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -3412,7 +3412,7 @@ public: virtual bool brokeLhsMustBeLvalue() const override { return true; } }; -class AstComment : public AstNodeStmt { +class AstComment final : public AstNodeStmt { // Some comment to put into the output stream // Parents: {statement list} // Children: none @@ -3433,7 +3433,7 @@ public: virtual bool showAt() const { return m_showAt; } }; -class AstCond : public AstNodeCond { +class AstCond final : public AstNodeCond { // Conditional ?: statement // Parents: MATH // Children: MATH @@ -3446,7 +3446,7 @@ public: } }; -class AstCondBound : public AstNodeCond { +class AstCondBound final : public AstNodeCond { // Conditional ?: statement, specially made for safety checking of array bounds // Parents: MATH // Children: MATH @@ -3459,7 +3459,7 @@ public: } }; -class AstCoverDecl : public AstNodeStmt { +class AstCoverDecl final : public AstNodeStmt { // Coverage analysis point declaration // Parents: {statement list} // Children: none @@ -3520,7 +3520,7 @@ public: AstCoverDecl* dataDeclThisp() { return dataDeclNullp() ? dataDeclNullp() : this; } }; -class AstCoverInc : public AstNodeStmt { +class AstCoverInc final : public AstNodeStmt { // Coverage analysis point; increment coverage count // Parents: {statement list} // Children: none @@ -3551,7 +3551,7 @@ public: AstCoverDecl* declp() const { return m_declp; } // Where defined }; -class AstCoverToggle : public AstNodeStmt { +class AstCoverToggle final : public AstNodeStmt { // Toggle analysis of given signal // Parents: MODULE // Children: AstCoverInc, orig var, change det var @@ -3578,7 +3578,7 @@ public: AstNode* changep() const { return op3p(); } }; -class AstDelay : public AstNodeStmt { +class AstDelay final : public AstNodeStmt { // Delay statement public: AstDelay(FileLine* fl, AstNode* lhsp) @@ -3593,7 +3593,7 @@ public: void lhsp(AstNode* nodep) { setOp1p(nodep); } }; -class AstGenCase : public AstNodeCase { +class AstGenCase final : public AstNodeCase { // Generate Case statement // Parents: {statement list} // exprp Children: MATHs @@ -3604,7 +3604,7 @@ public: ASTNODE_NODE_FUNCS(GenCase) }; -class AstCase : public AstNodeCase { +class AstCase final : public AstNodeCase { // Case statement // Parents: {statement list} // exprp Children: MATHs @@ -3644,7 +3644,7 @@ public: void priorityPragma(bool flag) { m_priorityPragma = flag; } }; -class AstCaseItem : public AstNode { +class AstCaseItem final : public AstNode { // Single item of a case statement // Parents: CASE // condsp Children: MATH (Null condition used for default block) @@ -3668,7 +3668,7 @@ public: void ignoreOverlap(bool flag) { m_ignoreOverlap = flag; } }; -class AstSFormatF : public AstNode { +class AstSFormatF final : public AstNode { // Convert format to string, generally under an AstDisplay or AstSFormat // Also used as "real" function for /*verilator sformat*/ functions string m_text; @@ -3726,7 +3726,7 @@ public: VTimescale timeunit() const { return m_timeunit; } }; -class AstDisplay : public AstNodeStmt { +class AstDisplay final : public AstNodeStmt { // Parents: stmtlist // Children: file which must be a varref // Children: SFORMATF to generate print string @@ -3780,7 +3780,7 @@ public: void filep(AstNodeVarRef* nodep) { setNOp3p(nodep); } }; -class AstDumpCtl : public AstNodeStmt { +class AstDumpCtl final : public AstNodeStmt { // $dumpon etc // Parents: expr // Child: expr based on type of control statement @@ -3805,7 +3805,7 @@ public: void exprp(AstNode* nodep) { setOp1p(nodep); } }; -class AstElabDisplay : public AstNode { +class AstElabDisplay final : public AstNode { // Parents: stmtlist // Children: SFORMATF to generate print string private: @@ -3843,7 +3843,7 @@ public: AstSFormatF* fmtp() const { return VN_CAST(op1p(), SFormatF); } }; -class AstSFormat : public AstNodeStmt { +class AstSFormat final : public AstNodeStmt { // Parents: statement container // Children: string to load // Children: SFORMATF to generate print string @@ -3879,7 +3879,7 @@ public: void lhsp(AstNode* nodep) { setOp3p(nodep); } }; -class AstSysFuncAsTask : public AstNodeStmt { +class AstSysFuncAsTask final : public AstNodeStmt { // Call what is normally a system function (with a return) in a non-return context // Parents: stmtlist // Children: a system function @@ -3901,7 +3901,7 @@ public: void lhsp(AstNode* nodep) { addOp1p(nodep); } // op1 = Expressions to eval }; -class AstSysIgnore : public AstNodeStmt { +class AstSysIgnore final : public AstNodeStmt { // Parents: stmtlist // Children: varrefs or exprs public: @@ -3922,7 +3922,7 @@ public: void exprsp(AstNode* nodep) { addOp1p(nodep); } // op1 = Expressions to output }; -class AstFClose : public AstNodeStmt { +class AstFClose final : public AstNodeStmt { // Parents: stmtlist // Children: file which must be a varref public: @@ -3943,7 +3943,7 @@ public: void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); } }; -class AstFOpen : public AstNodeStmt { +class AstFOpen final : public AstNodeStmt { // Although a system function in IEEE, here a statement which sets the file pointer (MCD) public: AstFOpen(FileLine* fl, AstNode* filep, AstNode* filenamep, AstNode* modep) @@ -3967,7 +3967,7 @@ public: AstNode* modep() const { return op3p(); } }; -class AstFOpenMcd : public AstNodeStmt { +class AstFOpenMcd final : public AstNodeStmt { // Although a system function in IEEE, here a statement which sets the file pointer (MCD) public: AstFOpenMcd(FileLine* fl, AstNode* filep, AstNode* filenamep) @@ -3989,7 +3989,7 @@ public: AstNode* filenamep() const { return op2p(); } }; -class AstFFlush : public AstNodeStmt { +class AstFFlush final : public AstNodeStmt { // Parents: stmtlist // Children: file which must be a varref public: @@ -4010,7 +4010,7 @@ public: void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); } }; -class AstFRead : public AstNodeMath { +class AstFRead final : public AstNodeMath { // Parents: expr // Children: varrefs to load // Children: file which must be a varref @@ -4045,7 +4045,7 @@ public: void countp(AstNode* nodep) { setNOp4p(nodep); } }; -class AstFRewind : public AstNodeMath { +class AstFRewind final : public AstNodeMath { // Parents: stmtlist // Children: file which must be a varref public: @@ -4069,7 +4069,7 @@ public: void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); } }; -class AstFTell : public AstNodeMath { +class AstFTell final : public AstNodeMath { // Parents: stmtlist // Children: file which must be a varref public: @@ -4093,7 +4093,7 @@ public: void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); } }; -class AstFSeek : public AstNodeMath { +class AstFSeek final : public AstNodeMath { // Parents: expr // Children: file which must be a varref // Children: offset @@ -4124,7 +4124,7 @@ public: void operation(AstNode* nodep) { setNOp4p(nodep); } }; -class AstFScanF : public AstNodeMath { +class AstFScanF final : public AstNodeMath { // Parents: expr // Children: file which must be a varref // Children: varrefs to load @@ -4160,7 +4160,7 @@ public: void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); } }; -class AstSScanF : public AstNodeMath { +class AstSScanF final : public AstNodeMath { // Parents: expr // Children: file which must be a varref // Children: varrefs to load @@ -4196,7 +4196,7 @@ public: void fromp(AstNode* nodep) { setOp2p(nodep); } }; -class AstNodeReadWriteMem : public AstNodeStmt { +class AstNodeReadWriteMem VL_NOT_FINAL : public AstNodeStmt { private: bool m_isHex; // readmemh, not readmemb public: @@ -4227,7 +4227,7 @@ public: virtual const char* cFuncPrefixp() const = 0; }; -class AstReadMem : public AstNodeReadWriteMem { +class AstReadMem final : public AstNodeReadWriteMem { public: AstReadMem(FileLine* fl, bool hex, AstNode* filenamep, AstNode* memp, AstNode* lsbp, AstNode* msbp) @@ -4237,7 +4237,7 @@ public: virtual const char* cFuncPrefixp() const override { return "VL_READMEM_"; } }; -class AstWriteMem : public AstNodeReadWriteMem { +class AstWriteMem final : public AstNodeReadWriteMem { public: AstWriteMem(FileLine* fl, bool hex, AstNode* filenamep, AstNode* memp, AstNode* lsbp, AstNode* msbp) @@ -4247,7 +4247,7 @@ public: virtual const char* cFuncPrefixp() const override { return "VL_WRITEMEM_"; } }; -class AstSystemT : public AstNodeStmt { +class AstSystemT final : public AstNodeStmt { // $system used as task public: AstSystemT(FileLine* fl, AstNode* lhsp) @@ -4266,7 +4266,7 @@ public: AstNode* lhsp() const { return op1p(); } }; -class AstSystemF : public AstNodeMath { +class AstSystemF final : public AstNodeMath { // $system used as function public: AstSystemF(FileLine* fl, AstNode* lhsp) @@ -4288,7 +4288,7 @@ public: AstNode* lhsp() const { return op1p(); } }; -class AstValuePlusArgs : public AstNodeMath { +class AstValuePlusArgs final : public AstNodeMath { // Parents: expr // Child: variable to set. If nullptr then this is a $test$plusargs instead of $value$plusargs public: @@ -4313,7 +4313,7 @@ public: void outp(AstNode* nodep) { setOp2p(nodep); } }; -class AstTestPlusArgs : public AstNodeMath { +class AstTestPlusArgs final : public AstNodeMath { // Parents: expr // Child: variable to set. If nullptr then this is a $test$plusargs instead of $value$plusargs private: @@ -4339,14 +4339,14 @@ public: void text(const string& text) { m_text = text; } }; -class AstGenFor : public AstNodeFor { +class AstGenFor final : public AstNodeFor { public: AstGenFor(FileLine* fl, AstNode* initsp, AstNode* condp, AstNode* incsp, AstNode* bodysp) : ASTGEN_SUPER(fl, initsp, condp, incsp, bodysp) {} ASTNODE_NODE_FUNCS(GenFor) }; -class AstForeach : public AstNodeStmt { +class AstForeach final : public AstNodeStmt { public: AstForeach(FileLine* fl, AstNode* arrayp, AstNode* bodysp) : ASTGEN_SUPER(fl) { @@ -4362,7 +4362,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstRepeat : public AstNodeStmt { +class AstRepeat final : public AstNodeStmt { public: AstRepeat(FileLine* fl, AstNode* countp, AstNode* bodysp) : ASTGEN_SUPER(fl) { @@ -4380,7 +4380,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstWait : public AstNodeStmt { +class AstWait final : public AstNodeStmt { public: AstWait(FileLine* fl, AstNode* condp, AstNode* bodysp) : ASTGEN_SUPER(fl) { @@ -4391,7 +4391,7 @@ public: AstNode* bodysp() const { return op3p(); } // op3 = body of loop }; -class AstWhile : public AstNodeStmt { +class AstWhile final : public AstNodeStmt { public: AstWhile(FileLine* fl, AstNode* condp, AstNode* bodysp, AstNode* incsp = nullptr) : ASTGEN_SUPER(fl) { @@ -4418,7 +4418,7 @@ public: virtual void addNextStmt(AstNode* newp, AstNode* belowp) override; }; -class AstBreak : public AstNodeStmt { +class AstBreak final : public AstNodeStmt { public: explicit AstBreak(FileLine* fl) : ASTGEN_SUPER(fl) {} @@ -4430,7 +4430,7 @@ public: } }; -class AstContinue : public AstNodeStmt { +class AstContinue final : public AstNodeStmt { public: explicit AstContinue(FileLine* fl) : ASTGEN_SUPER(fl) {} @@ -4442,7 +4442,7 @@ public: } }; -class AstDisable : public AstNodeStmt { +class AstDisable final : public AstNodeStmt { private: string m_name; // Name of block public: @@ -4457,7 +4457,7 @@ public: } }; -class AstDisableFork : public AstNodeStmt { +class AstDisableFork final : public AstNodeStmt { // A "disable fork" statement public: AstDisableFork(FileLine* fl) @@ -4465,7 +4465,7 @@ public: ASTNODE_NODE_FUNCS(DisableFork) }; -class AstWaitFork : public AstNodeStmt { +class AstWaitFork final : public AstNodeStmt { // A "wait fork" statement public: AstWaitFork(FileLine* fl) @@ -4473,7 +4473,7 @@ public: ASTNODE_NODE_FUNCS(WaitFork) }; -class AstReturn : public AstNodeStmt { +class AstReturn final : public AstNodeStmt { public: explicit AstReturn(FileLine* fl, AstNode* lhsp = nullptr) : ASTGEN_SUPER(fl) { @@ -4488,14 +4488,14 @@ public: } }; -class AstGenIf : public AstNodeIf { +class AstGenIf final : public AstNodeIf { public: AstGenIf(FileLine* fl, AstNode* condp, AstNode* ifsp, AstNode* elsesp) : ASTGEN_SUPER(fl, condp, ifsp, elsesp) {} ASTNODE_NODE_FUNCS(GenIf) }; -class AstIf : public AstNodeIf { +class AstIf final : public AstNodeIf { private: bool m_uniquePragma; // unique case bool m_unique0Pragma; // unique0 case @@ -4516,7 +4516,7 @@ public: void priorityPragma(bool flag) { m_priorityPragma = flag; } }; -class AstJumpBlock : public AstNodeStmt { +class AstJumpBlock final : public AstNodeStmt { // Block of code including a JumpGo and JumpLabel // Parents: {statement list} // Children: {statement list, with JumpGo and JumpLabel below} @@ -4547,7 +4547,7 @@ public: void labelp(AstJumpLabel* labelp) { m_labelp = labelp; } }; -class AstJumpLabel : public AstNodeStmt { +class AstJumpLabel final : public AstNodeStmt { // Jump point declaration // Parents: {statement list with JumpBlock above} // Children: none @@ -4576,7 +4576,7 @@ public: AstJumpBlock* blockp() const { return m_blockp; } }; -class AstJumpGo : public AstNodeStmt { +class AstJumpGo final : public AstNodeStmt { // Jump point; branch down to a JumpLabel // No support for backward jumps at present // Parents: {statement list with JumpBlock above} @@ -4608,7 +4608,7 @@ public: AstJumpLabel* labelp() const { return m_labelp; } }; -class AstChangeXor : public AstNodeBiComAsv { +class AstChangeXor final : public AstNodeBiComAsv { // A comparison to determine change detection, common & must be fast. // Returns 32-bit or 64-bit value where 0 indicates no change. // Parents: OR or LOGOR @@ -4636,7 +4636,7 @@ public: virtual int instrCount() const override { return widthInstrs(); } }; -class AstChangeDet : public AstNodeStmt { +class AstChangeDet final : public AstNodeStmt { // A comparison to determine change detection, common & must be fast. private: bool m_clockReq; // Type of detection @@ -4659,7 +4659,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstConsAssoc : public AstNodeMath { +class AstConsAssoc final : public AstNodeMath { // Construct an assoc array and return object, '{} // Parents: math // Children: expression (elements or other queues) @@ -4678,7 +4678,7 @@ public: virtual V3Hash sameHash() const override { return V3Hash(); } virtual bool same(const AstNode* samep) const override { return true; } }; -class AstSetAssoc : public AstNodeMath { +class AstSetAssoc final : public AstNodeMath { // Set an assoc array element and return object, '{} // Parents: math // Children: expression (elements or other queues) @@ -4702,7 +4702,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstConsDynArray : public AstNodeMath { +class AstConsDynArray final : public AstNodeMath { // Construct a queue and return object, '{}. '{lhs}, '{lhs. rhs} // Parents: math // Children: expression (elements or other queues) @@ -4724,7 +4724,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstConsQueue : public AstNodeMath { +class AstConsQueue final : public AstNodeMath { // Construct a queue and return object, '{}. '{lhs}, '{lhs. rhs} // Parents: math // Children: expression (elements or other queues) @@ -4746,7 +4746,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstBegin : public AstNodeBlock { +class AstBegin final : public AstNodeBlock { // A Begin/end named block, only exists shortly after parsing until linking // Parents: statement // Children: statements @@ -4771,7 +4771,7 @@ public: bool implied() const { return m_implied; } }; -class AstFork : public AstNodeBlock { +class AstFork final : public AstNodeBlock { // A fork named block // Parents: statement // Children: statements @@ -4787,7 +4787,7 @@ public: void joinType(const VJoinType& flag) { m_joinType = flag; } }; -class AstInside : public AstNodeMath { +class AstInside final : public AstNodeMath { public: AstInside(FileLine* fl, AstNode* exprp, AstNode* itemsp) : ASTGEN_SUPER(fl) { @@ -4804,7 +4804,7 @@ public: virtual bool cleanOut() const override { return false; } // NA }; -class AstInsideRange : public AstNodeMath { +class AstInsideRange final : public AstNodeMath { public: AstInsideRange(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl) { @@ -4821,7 +4821,7 @@ public: AstNode* newAndFromInside(AstNode* exprp, AstNode* lhsp, AstNode* rhsp); }; -class AstInitItem : public AstNode { +class AstInitItem final : public AstNode { // Container for a item in an init array // This container is present so that the value underneath may get replaced with a new nodep // and the upper AstInitArray's map will remain correct (pointing to this InitItem) @@ -4839,7 +4839,7 @@ public: void valuep(AstNode* nodep) { addOp1p(nodep); } }; -class AstInitArray : public AstNode { +class AstInitArray final : public AstNode { // Set a var to a map of values // The list of initsp() is not relevant // If default is specified, the vector may be sparse, and not provide each value. @@ -4912,7 +4912,7 @@ public: } }; -class AstNew : public AstNodeFTaskRef { +class AstNew final : public AstNodeFTaskRef { // New as constructor // Don't need the class we are extracting from, as the "fromp()"'s datatype can get us to it // Parents: math|stmt @@ -4928,7 +4928,7 @@ public: virtual int instrCount() const override { return widthInstrs(); } }; -class AstNewCopy : public AstNodeMath { +class AstNewCopy final : public AstNodeMath { // New as shallow copy // Parents: math|stmt // Children: varref|arraysel, math @@ -4948,7 +4948,7 @@ public: AstNode* rhsp() const { return op1p(); } }; -class AstNewDynamic : public AstNodeMath { +class AstNewDynamic final : public AstNodeMath { // New for dynamic array // Parents: math|stmt // Children: varref|arraysel, math @@ -4970,7 +4970,7 @@ public: AstNode* rhsp() const { return op2p(); } }; -class AstPragma : public AstNode { +class AstPragma final : public AstNode { private: AstPragmaType m_pragType; // Type of pragma public: @@ -4988,7 +4988,7 @@ public: } }; -class AstPrintTimeScale : public AstNodeStmt { +class AstPrintTimeScale final : public AstNodeStmt { // Parents: stmtlist string m_name; // Parent module name VTimescale m_timeunit; // Parent module time unit @@ -5010,7 +5010,7 @@ public: VTimescale timeunit() const { return m_timeunit; } }; -class AstStop : public AstNodeStmt { +class AstStop final : public AstNodeStmt { public: AstStop(FileLine* fl, bool maybe) : ASTGEN_SUPER(fl) {} @@ -5029,7 +5029,7 @@ public: } }; -class AstFinish : public AstNodeStmt { +class AstFinish final : public AstNodeStmt { public: explicit AstFinish(FileLine* fl) : ASTGEN_SUPER(fl) {} @@ -5048,7 +5048,7 @@ public: } }; -class AstNullCheck : public AstNodeUniop { +class AstNullCheck final : public AstNodeUniop { // Return LHS after checking that LHS is non-null // Children: VarRef or something returning pointer public: @@ -5071,7 +5071,7 @@ public: } }; -class AstTimingControl : public AstNodeStmt { +class AstTimingControl final : public AstNodeStmt { // Parents: stmtlist public: AstTimingControl(FileLine* fl, AstSenTree* sensesp, AstNode* stmtsp) @@ -5091,7 +5091,7 @@ public: AstNode* stmtsp() const { return op2p(); } }; -class AstTimeFormat : public AstNodeStmt { +class AstTimeFormat final : public AstNodeStmt { // Parents: stmtlist public: AstTimeFormat(FileLine* fl, AstNode* unitsp, AstNode* precisionp, AstNode* suffixp, @@ -5116,7 +5116,7 @@ public: AstNode* widthp() const { return op4p(); } }; -class AstTraceDecl : public AstNodeStmt { +class AstTraceDecl final : public AstNodeStmt { // Trace point declaration // Separate from AstTraceInc; as a declaration can't be deleted // Parents: {statement list} @@ -5170,7 +5170,7 @@ public: AstNode* valuep() const { return op1p(); } }; -class AstTraceInc : public AstNodeStmt { +class AstTraceInc final : public AstNodeStmt { // Trace point dump // Parents: {statement list} // Children: op1: things to emit before this node, @@ -5214,7 +5214,7 @@ public: bool full() const { return m_full; } }; -class AstActive : public AstNode { +class AstActive final : public AstNode { // Block of code with sensitivity activation // Parents: MODULE | CFUNC // Children: SENTREE, statements @@ -5257,7 +5257,7 @@ public: bool hasClocked() const { return m_sensesp->hasClocked(); } }; -class AstAttrOf : public AstNode { +class AstAttrOf final : public AstNode { private: // Return a value of a attribute, for example a LSB or array LSB of a signal AstAttrType m_attrType; // What sort of extraction @@ -5277,7 +5277,7 @@ public: virtual void dump(std::ostream& str = std::cout) const override; }; -class AstScopeName : public AstNodeMath { +class AstScopeName final : public AstNodeMath { // For display %m and DPI context imports // Parents: DISPLAY // Children: TEXT @@ -5319,7 +5319,7 @@ public: void dpiExport(bool flag) { m_dpiExport = flag; } }; -class AstUdpTable : public AstNode { +class AstUdpTable final : public AstNode { public: AstUdpTable(FileLine* fl, AstNode* bodysp) : ASTGEN_SUPER(fl) { @@ -5330,7 +5330,7 @@ public: AstUdpTableLine* bodysp() const { return VN_CAST(op1p(), UdpTableLine); } }; -class AstUdpTableLine : public AstNode { +class AstUdpTableLine final : public AstNode { string m_text; public: @@ -5345,7 +5345,7 @@ public: //====================================================================== // non-ary ops -class AstRand : public AstNodeTermop { +class AstRand final : public AstNodeTermop { // Return a random number, based upon width() private: bool m_reset = false; // Random reset, versus always random @@ -5370,7 +5370,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstURandom : public AstNodeTermop { +class AstURandom final : public AstNodeTermop { // $urandom public: explicit AstURandom(FileLine* fl) @@ -5388,7 +5388,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstURandomRange : public AstNodeBiop { +class AstURandomRange final : public AstNodeBiop { // $urandom_range public: explicit AstURandomRange(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -5414,7 +5414,7 @@ public: virtual int instrCount() const override { return instrCountPli(); } }; -class AstTime : public AstNodeTermop { +class AstTime final : public AstNodeTermop { VTimescale m_timeunit; // Parent module time unit public: AstTime(FileLine* fl, const VTimescale& timeunit) @@ -5436,7 +5436,7 @@ public: VTimescale timeunit() const { return m_timeunit; } }; -class AstTimeD : public AstNodeTermop { +class AstTimeD final : public AstNodeTermop { VTimescale m_timeunit; // Parent module time unit public: AstTimeD(FileLine* fl, const VTimescale& timeunit) @@ -5458,7 +5458,7 @@ public: VTimescale timeunit() const { return m_timeunit; } }; -class AstUCFunc : public AstNodeMath { +class AstUCFunc final : public AstNodeMath { // User's $c function // Perhaps this should be an AstNodeListop; but there's only one list math right now public: @@ -5484,7 +5484,7 @@ public: //====================================================================== // Unary ops -class AstNegate : public AstNodeUniop { +class AstNegate final : public AstNodeUniop { public: AstNegate(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) { @@ -5499,7 +5499,7 @@ public: virtual bool cleanLhs() const override { return false; } virtual bool sizeMattersLhs() const override { return true; } }; -class AstNegateD : public AstNodeUniop { +class AstNegateD final : public AstNodeUniop { public: AstNegateD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) { @@ -5516,7 +5516,7 @@ public: virtual int instrCount() const override { return instrCountDouble(); } virtual bool doubleFlavor() const override { return true; } }; -class AstRedAnd : public AstNodeUniop { +class AstRedAnd final : public AstNodeUniop { public: AstRedAnd(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) { @@ -5530,7 +5530,7 @@ public: virtual bool cleanLhs() const override { return true; } virtual bool sizeMattersLhs() const override { return false; } }; -class AstRedOr : public AstNodeUniop { +class AstRedOr final : public AstNodeUniop { public: AstRedOr(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) { @@ -5544,7 +5544,7 @@ public: virtual bool cleanLhs() const override { return true; } virtual bool sizeMattersLhs() const override { return false; } }; -class AstRedXor : public AstNodeUniop { +class AstRedXor final : public AstNodeUniop { public: AstRedXor(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) { @@ -5562,7 +5562,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual int instrCount() const override { return 1 + V3Number::log2b(width()); } }; -class AstRedXnor : public AstNodeUniop { +class AstRedXnor final : public AstNodeUniop { // AstRedXnors are replaced with AstRedXors in V3Const. public: AstRedXnor(FileLine* fl, AstNode* lhsp) @@ -5582,7 +5582,7 @@ public: virtual int instrCount() const override { return 1 + V3Number::log2b(width()); } }; -class AstLenN : public AstNodeUniop { +class AstLenN final : public AstNodeUniop { // Length of a string public: AstLenN(FileLine* fl, AstNode* lhsp) @@ -5597,7 +5597,7 @@ public: virtual bool cleanLhs() const override { return true; } virtual bool sizeMattersLhs() const override { return false; } }; -class AstLogNot : public AstNodeUniop { +class AstLogNot final : public AstNodeUniop { public: AstLogNot(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) { @@ -5612,7 +5612,7 @@ public: virtual bool cleanLhs() const override { return true; } virtual bool sizeMattersLhs() const override { return false; } }; -class AstNot : public AstNodeUniop { +class AstNot final : public AstNodeUniop { public: AstNot(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) { @@ -5627,7 +5627,7 @@ public: virtual bool cleanLhs() const override { return false; } virtual bool sizeMattersLhs() const override { return true; } }; -class AstExtend : public AstNodeUniop { +class AstExtend final : public AstNodeUniop { // Expand a value into a wider entity by 0 extension. Width is implied from nodep->width() public: AstExtend(FileLine* fl, AstNode* lhsp) @@ -5647,7 +5647,7 @@ public: } virtual int instrCount() const override { return 0; } }; -class AstExtendS : public AstNodeUniop { +class AstExtendS final : public AstNodeUniop { // Expand a value into a wider entity by sign extension. Width is implied from nodep->width() public: AstExtendS(FileLine* fl, AstNode* lhsp) @@ -5671,7 +5671,7 @@ public: virtual int instrCount() const override { return 0; } virtual bool signedFlavor() const override { return true; } }; -class AstSigned : public AstNodeUniop { +class AstSigned final : public AstNodeUniop { // $signed(lhs) public: AstSigned(FileLine* fl, AstNode* lhsp) @@ -5691,7 +5691,7 @@ public: virtual bool sizeMattersLhs() const override { return true; } // Eliminated before matters virtual int instrCount() const override { return 0; } }; -class AstUnsigned : public AstNodeUniop { +class AstUnsigned final : public AstNodeUniop { // $unsigned(lhs) public: AstUnsigned(FileLine* fl, AstNode* lhsp) @@ -5711,7 +5711,7 @@ public: virtual bool sizeMattersLhs() const override { return true; } // Eliminated before matters virtual int instrCount() const override { return 0; } }; -class AstRToIS : public AstNodeUniop { +class AstRToIS final : public AstNodeUniop { // $rtoi(lhs) public: AstRToIS(FileLine* fl, AstNode* lhsp) @@ -5727,7 +5727,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } // Eliminated before matters virtual int instrCount() const override { return instrCountDouble(); } }; -class AstRToIRoundS : public AstNodeUniop { +class AstRToIRoundS final : public AstNodeUniop { // Convert real to integer, with arbitrary sized output (not just "integer" format) public: AstRToIRoundS(FileLine* fl, AstNode* lhsp) @@ -5745,7 +5745,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual int instrCount() const override { return instrCountDouble(); } }; -class AstIToRD : public AstNodeUniop { +class AstIToRD final : public AstNodeUniop { // $itor where lhs is unsigned public: AstIToRD(FileLine* fl, AstNode* lhsp) @@ -5761,7 +5761,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual int instrCount() const override { return instrCountDouble(); } }; -class AstISToRD : public AstNodeUniop { +class AstISToRD final : public AstNodeUniop { // $itor where lhs is signed public: AstISToRD(FileLine* fl, AstNode* lhsp) @@ -5778,7 +5778,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual int instrCount() const override { return instrCountDouble(); } }; -class AstRealToBits : public AstNodeUniop { +class AstRealToBits final : public AstNodeUniop { public: AstRealToBits(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) { @@ -5795,7 +5795,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } // Eliminated before matters virtual int instrCount() const override { return instrCountDouble(); } }; -class AstBitsToRealD : public AstNodeUniop { +class AstBitsToRealD final : public AstNodeUniop { public: AstBitsToRealD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) { @@ -5813,7 +5813,7 @@ public: virtual int instrCount() const override { return instrCountDouble(); } }; -class AstCLog2 : public AstNodeUniop { +class AstCLog2 final : public AstNodeUniop { public: AstCLog2(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -5826,7 +5826,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() * 16; } }; -class AstCountBits : public AstNodeQuadop { +class AstCountBits final : public AstNodeQuadop { // Number of bits set in vector public: AstCountBits(FileLine* fl, AstNode* exprp, AstNode* ctrl1p) @@ -5853,7 +5853,7 @@ public: virtual bool sizeMattersFhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() * 16; } }; -class AstCountOnes : public AstNodeUniop { +class AstCountOnes final : public AstNodeUniop { // Number of bits set in vector public: AstCountOnes(FileLine* fl, AstNode* lhsp) @@ -5869,7 +5869,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() * 16; } }; -class AstIsUnknown : public AstNodeUniop { +class AstIsUnknown final : public AstNodeUniop { // True if any unknown bits public: AstIsUnknown(FileLine* fl, AstNode* lhsp) @@ -5886,7 +5886,7 @@ public: virtual bool cleanLhs() const override { return false; } virtual bool sizeMattersLhs() const override { return false; } }; -class AstIsUnbounded : public AstNodeUniop { +class AstIsUnbounded final : public AstNodeUniop { // True if is unmbounded ($) public: AstIsUnbounded(FileLine* fl, AstNode* lhsp) @@ -5904,7 +5904,7 @@ public: virtual bool cleanLhs() const override { return false; } virtual bool sizeMattersLhs() const override { return false; } }; -class AstOneHot : public AstNodeUniop { +class AstOneHot final : public AstNodeUniop { // True if only single bit set in vector public: AstOneHot(FileLine* fl, AstNode* lhsp) @@ -5920,7 +5920,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() * 4; } }; -class AstOneHot0 : public AstNodeUniop { +class AstOneHot0 final : public AstNodeUniop { // True if only single bit, or no bits set in vector public: AstOneHot0(FileLine* fl, AstNode* lhsp) @@ -5937,7 +5937,7 @@ public: virtual int instrCount() const override { return widthInstrs() * 3; } }; -class AstCast : public AstNode { +class AstCast final : public AstNode { // Cast to appropriate data type - note lhsp is value, to match AstTypedef, AstCCast, etc public: AstCast(FileLine* fl, AstNode* lhsp, AstNodeDType* dtp) @@ -5959,7 +5959,7 @@ public: virtual AstNodeDType* subDTypep() const { return dtypep() ? dtypep() : childDTypep(); } }; -class AstCastDynamic : public AstNodeBiop { +class AstCastDynamic final : public AstNodeBiop { // Verilog $cast used as a function // Task usage of $cast is converted during parse to assert($cast(...)) // Parents: MATH @@ -5986,7 +5986,7 @@ public: virtual bool isPure() const override { return true; } }; -class AstCastParse : public AstNode { +class AstCastParse final : public AstNode { // Cast to appropriate type, where we haven't determined yet what the data type is public: AstCastParse(FileLine* fl, AstNode* lhsp, AstNode* dtp) @@ -6004,7 +6004,7 @@ public: AstNode* dtp() const { return op2p(); } }; -class AstCastSize : public AstNode { +class AstCastSize final : public AstNode { // Cast to specific size; signed/twostate inherited from lower element per IEEE public: AstCastSize(FileLine* fl, AstNode* lhsp, AstConst* rhsp) @@ -6022,7 +6022,7 @@ public: AstNode* rhsp() const { return op2p(); } }; -class AstCCast : public AstNodeUniop { +class AstCCast final : public AstNodeUniop { // Cast to C-based data type private: int m_size; @@ -6057,7 +6057,7 @@ public: int size() const { return m_size; } }; -class AstCvtPackString : public AstNodeUniop { +class AstCvtPackString final : public AstNodeUniop { // Convert to Verilator Packed String (aka verilog "string") public: AstCvtPackString(FileLine* fl, AstNode* lhsp) @@ -6075,7 +6075,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstFEof : public AstNodeUniop { +class AstFEof final : public AstNodeUniop { public: AstFEof(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6093,7 +6093,7 @@ public: AstNode* filep() const { return lhsp(); } }; -class AstFError : public AstNodeMath { +class AstFError final : public AstNodeMath { public: AstFError(FileLine* fl, AstNode* filep, AstNode* strp) : ASTGEN_SUPER(fl) { @@ -6118,7 +6118,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstFGetC : public AstNodeUniop { +class AstFGetC final : public AstNodeUniop { public: AstFGetC(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6137,7 +6137,7 @@ public: AstNode* filep() const { return lhsp(); } }; -class AstFUngetC : public AstNodeBiop { +class AstFUngetC final : public AstNodeBiop { public: AstFUngetC(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} @@ -6166,7 +6166,7 @@ public: AstNode* charp() const { return rhsp(); } }; -class AstNodeSystemUniop : public AstNodeUniop { +class AstNodeSystemUniop VL_NOT_FINAL : public AstNodeUniop { public: AstNodeSystemUniop(AstType t, FileLine* fl, AstNode* lhsp) : AstNodeUniop(t, fl, lhsp) { @@ -6180,7 +6180,7 @@ public: virtual bool doubleFlavor() const override { return true; } }; -class AstLogD : public AstNodeSystemUniop { +class AstLogD final : public AstNodeSystemUniop { public: AstLogD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6191,7 +6191,7 @@ public: virtual string emitVerilog() override { return "%f$ln(%l)"; } virtual string emitC() override { return "log(%li)"; } }; -class AstLog10D : public AstNodeSystemUniop { +class AstLog10D final : public AstNodeSystemUniop { public: AstLog10D(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6203,7 +6203,7 @@ public: virtual string emitC() override { return "log10(%li)"; } }; -class AstExpD : public AstNodeSystemUniop { +class AstExpD final : public AstNodeSystemUniop { public: AstExpD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6215,7 +6215,7 @@ public: virtual string emitC() override { return "exp(%li)"; } }; -class AstSqrtD : public AstNodeSystemUniop { +class AstSqrtD final : public AstNodeSystemUniop { public: AstSqrtD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6227,7 +6227,7 @@ public: virtual string emitC() override { return "sqrt(%li)"; } }; -class AstFloorD : public AstNodeSystemUniop { +class AstFloorD final : public AstNodeSystemUniop { public: AstFloorD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6239,7 +6239,7 @@ public: virtual string emitC() override { return "floor(%li)"; } }; -class AstCeilD : public AstNodeSystemUniop { +class AstCeilD final : public AstNodeSystemUniop { public: AstCeilD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6251,7 +6251,7 @@ public: virtual string emitC() override { return "ceil(%li)"; } }; -class AstSinD : public AstNodeSystemUniop { +class AstSinD final : public AstNodeSystemUniop { public: AstSinD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6263,7 +6263,7 @@ public: virtual string emitC() override { return "sin(%li)"; } }; -class AstCosD : public AstNodeSystemUniop { +class AstCosD final : public AstNodeSystemUniop { public: AstCosD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6275,7 +6275,7 @@ public: virtual string emitC() override { return "cos(%li)"; } }; -class AstTanD : public AstNodeSystemUniop { +class AstTanD final : public AstNodeSystemUniop { public: AstTanD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6287,7 +6287,7 @@ public: virtual string emitC() override { return "tan(%li)"; } }; -class AstAsinD : public AstNodeSystemUniop { +class AstAsinD final : public AstNodeSystemUniop { public: AstAsinD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6299,7 +6299,7 @@ public: virtual string emitC() override { return "asin(%li)"; } }; -class AstAcosD : public AstNodeSystemUniop { +class AstAcosD final : public AstNodeSystemUniop { public: AstAcosD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6311,7 +6311,7 @@ public: virtual string emitC() override { return "acos(%li)"; } }; -class AstAtanD : public AstNodeSystemUniop { +class AstAtanD final : public AstNodeSystemUniop { public: AstAtanD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6323,7 +6323,7 @@ public: virtual string emitC() override { return "atan(%li)"; } }; -class AstSinhD : public AstNodeSystemUniop { +class AstSinhD final : public AstNodeSystemUniop { public: AstSinhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6335,7 +6335,7 @@ public: virtual string emitC() override { return "sinh(%li)"; } }; -class AstCoshD : public AstNodeSystemUniop { +class AstCoshD final : public AstNodeSystemUniop { public: AstCoshD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6347,7 +6347,7 @@ public: virtual string emitC() override { return "cosh(%li)"; } }; -class AstTanhD : public AstNodeSystemUniop { +class AstTanhD final : public AstNodeSystemUniop { public: AstTanhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6359,7 +6359,7 @@ public: virtual string emitC() override { return "tanh(%li)"; } }; -class AstAsinhD : public AstNodeSystemUniop { +class AstAsinhD final : public AstNodeSystemUniop { public: AstAsinhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6371,7 +6371,7 @@ public: virtual string emitC() override { return "asinh(%li)"; } }; -class AstAcoshD : public AstNodeSystemUniop { +class AstAcoshD final : public AstNodeSystemUniop { public: AstAcoshD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6383,7 +6383,7 @@ public: virtual string emitC() override { return "acosh(%li)"; } }; -class AstAtanhD : public AstNodeSystemUniop { +class AstAtanhD final : public AstNodeSystemUniop { public: AstAtanhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} @@ -6394,7 +6394,7 @@ public: virtual string emitVerilog() override { return "%f$atanh(%l)"; } virtual string emitC() override { return "atanh(%li)"; } }; -class AstToLowerN : public AstNodeUniop { +class AstToLowerN final : public AstNodeUniop { // string.tolower() public: AstToLowerN(FileLine* fl, AstNode* lhsp) @@ -6411,7 +6411,7 @@ public: virtual bool cleanLhs() const override { return true; } virtual bool sizeMattersLhs() const override { return false; } }; -class AstToUpperN : public AstNodeUniop { +class AstToUpperN final : public AstNodeUniop { // string.toupper() public: AstToUpperN(FileLine* fl, AstNode* lhsp) @@ -6428,7 +6428,7 @@ public: virtual bool cleanLhs() const override { return true; } virtual bool sizeMattersLhs() const override { return false; } }; -class AstTimeImport : public AstNodeUniop { +class AstTimeImport final : public AstNodeUniop { // Take a constant that represents a time and needs conversion based on time units VTimescale m_timeunit; // Parent module time unit public: @@ -6446,7 +6446,7 @@ public: VTimescale timeunit() const { return m_timeunit; } }; -class AstAtoN : public AstNodeUniop { +class AstAtoN final : public AstNodeUniop { // string.atoi(), atobin(), atohex(), atooct(), atoireal() public: enum FmtType { ATOI = 10, ATOHEX = 16, ATOOCT = 8, ATOBIN = 2, ATOREAL = -1 }; @@ -6494,7 +6494,7 @@ public: //====================================================================== // Binary ops -class AstLogOr : public AstNodeBiop { +class AstLogOr final : public AstNodeBiop { public: AstLogOr(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6517,7 +6517,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() + instrCountBranch(); } }; -class AstLogAnd : public AstNodeBiop { +class AstLogAnd final : public AstNodeBiop { public: AstLogAnd(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6540,7 +6540,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() + instrCountBranch(); } }; -class AstLogEq : public AstNodeBiCom { +class AstLogEq final : public AstNodeBiCom { public: AstLogEq(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6563,7 +6563,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() + instrCountBranch(); } }; -class AstLogIf : public AstNodeBiop { +class AstLogIf final : public AstNodeBiop { public: AstLogIf(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6586,7 +6586,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() + instrCountBranch(); } }; -class AstOr : public AstNodeBiComAsv { +class AstOr final : public AstNodeBiComAsv { public: AstOr(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6608,7 +6608,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstAnd : public AstNodeBiComAsv { +class AstAnd final : public AstNodeBiComAsv { public: AstAnd(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6630,7 +6630,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstXor : public AstNodeBiComAsv { +class AstXor final : public AstNodeBiComAsv { public: AstXor(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6652,7 +6652,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstXnor : public AstNodeBiComAsv { +class AstXnor final : public AstNodeBiComAsv { public: AstXnor(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6674,7 +6674,7 @@ public: virtual bool sizeMattersLhs() const override { return true; } virtual bool sizeMattersRhs() const override { return true; } }; -class AstEq : public AstNodeBiCom { +class AstEq final : public AstNodeBiCom { public: AstEq(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6698,7 +6698,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstEqD : public AstNodeBiCom { +class AstEqD final : public AstNodeBiCom { public: AstEqD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6722,7 +6722,7 @@ public: virtual int instrCount() const override { return instrCountDouble(); } virtual bool doubleFlavor() const override { return true; } }; -class AstEqN : public AstNodeBiCom { +class AstEqN final : public AstNodeBiCom { public: AstEqN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6746,7 +6746,7 @@ public: virtual int instrCount() const override { return instrCountString(); } virtual bool stringFlavor() const override { return true; } }; -class AstNeq : public AstNodeBiCom { +class AstNeq final : public AstNodeBiCom { public: AstNeq(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6768,7 +6768,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstNeqD : public AstNodeBiCom { +class AstNeqD final : public AstNodeBiCom { public: AstNeqD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6792,7 +6792,7 @@ public: virtual int instrCount() const override { return instrCountDouble(); } virtual bool doubleFlavor() const override { return true; } }; -class AstNeqN : public AstNodeBiCom { +class AstNeqN final : public AstNodeBiCom { public: AstNeqN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6816,7 +6816,7 @@ public: virtual int instrCount() const override { return instrCountString(); } virtual bool stringFlavor() const override { return true; } }; -class AstLt : public AstNodeBiop { +class AstLt final : public AstNodeBiop { public: AstLt(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6838,7 +6838,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstLtD : public AstNodeBiop { +class AstLtD final : public AstNodeBiop { public: AstLtD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6862,7 +6862,7 @@ public: virtual int instrCount() const override { return instrCountDouble(); } virtual bool doubleFlavor() const override { return true; } }; -class AstLtS : public AstNodeBiop { +class AstLtS final : public AstNodeBiop { public: AstLtS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6885,7 +6885,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual bool signedFlavor() const override { return true; } }; -class AstLtN : public AstNodeBiop { +class AstLtN final : public AstNodeBiop { public: AstLtN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6909,7 +6909,7 @@ public: virtual int instrCount() const override { return instrCountString(); } virtual bool stringFlavor() const override { return true; } }; -class AstGt : public AstNodeBiop { +class AstGt final : public AstNodeBiop { public: AstGt(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6931,7 +6931,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstGtD : public AstNodeBiop { +class AstGtD final : public AstNodeBiop { public: AstGtD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6955,7 +6955,7 @@ public: virtual int instrCount() const override { return instrCountDouble(); } virtual bool doubleFlavor() const override { return true; } }; -class AstGtS : public AstNodeBiop { +class AstGtS final : public AstNodeBiop { public: AstGtS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -6978,7 +6978,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual bool signedFlavor() const override { return true; } }; -class AstGtN : public AstNodeBiop { +class AstGtN final : public AstNodeBiop { public: AstGtN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7002,7 +7002,7 @@ public: virtual int instrCount() const override { return instrCountString(); } virtual bool stringFlavor() const override { return true; } }; -class AstGte : public AstNodeBiop { +class AstGte final : public AstNodeBiop { public: AstGte(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7026,7 +7026,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstGteD : public AstNodeBiop { +class AstGteD final : public AstNodeBiop { public: AstGteD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7050,7 +7050,7 @@ public: virtual int instrCount() const override { return instrCountDouble(); } virtual bool doubleFlavor() const override { return true; } }; -class AstGteS : public AstNodeBiop { +class AstGteS final : public AstNodeBiop { public: AstGteS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7073,7 +7073,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual bool signedFlavor() const override { return true; } }; -class AstGteN : public AstNodeBiop { +class AstGteN final : public AstNodeBiop { public: AstGteN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7097,7 +7097,7 @@ public: virtual int instrCount() const override { return instrCountString(); } virtual bool stringFlavor() const override { return true; } }; -class AstLte : public AstNodeBiop { +class AstLte final : public AstNodeBiop { public: AstLte(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7121,7 +7121,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstLteD : public AstNodeBiop { +class AstLteD final : public AstNodeBiop { public: AstLteD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7145,7 +7145,7 @@ public: virtual int instrCount() const override { return instrCountDouble(); } virtual bool doubleFlavor() const override { return true; } }; -class AstLteS : public AstNodeBiop { +class AstLteS final : public AstNodeBiop { public: AstLteS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7168,7 +7168,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual bool signedFlavor() const override { return true; } }; -class AstLteN : public AstNodeBiop { +class AstLteN final : public AstNodeBiop { public: AstLteN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7192,7 +7192,7 @@ public: virtual int instrCount() const override { return instrCountString(); } virtual bool stringFlavor() const override { return true; } }; -class AstShiftL : public AstNodeBiop { +class AstShiftL final : public AstNodeBiop { public: AstShiftL(FileLine* fl, AstNode* lhsp, AstNode* rhsp, int setwidth = 0) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7214,7 +7214,7 @@ public: virtual bool sizeMattersLhs() const override { return true; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstShiftR : public AstNodeBiop { +class AstShiftR final : public AstNodeBiop { public: AstShiftR(FileLine* fl, AstNode* lhsp, AstNode* rhsp, int setwidth = 0) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7237,7 +7237,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstShiftRS : public AstNodeBiop { +class AstShiftRS final : public AstNodeBiop { // Shift right with sign extension, >>> operator // Output data type's width determines which bit is used for sign extension public: @@ -7263,7 +7263,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual bool signedFlavor() const override { return true; } }; -class AstAdd : public AstNodeBiComAsv { +class AstAdd final : public AstNodeBiComAsv { public: AstAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7285,7 +7285,7 @@ public: virtual bool sizeMattersLhs() const override { return true; } virtual bool sizeMattersRhs() const override { return true; } }; -class AstAddD : public AstNodeBiComAsv { +class AstAddD final : public AstNodeBiComAsv { public: AstAddD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7309,7 +7309,7 @@ public: virtual int instrCount() const override { return instrCountDouble(); } virtual bool doubleFlavor() const override { return true; } }; -class AstSub : public AstNodeBiop { +class AstSub final : public AstNodeBiop { public: AstSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7331,7 +7331,7 @@ public: virtual bool sizeMattersLhs() const override { return true; } virtual bool sizeMattersRhs() const override { return true; } }; -class AstSubD : public AstNodeBiop { +class AstSubD final : public AstNodeBiop { public: AstSubD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7355,7 +7355,7 @@ public: virtual int instrCount() const override { return instrCountDouble(); } virtual bool doubleFlavor() const override { return true; } }; -class AstMul : public AstNodeBiComAsv { +class AstMul final : public AstNodeBiComAsv { public: AstMul(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7378,7 +7378,7 @@ public: virtual bool sizeMattersRhs() const override { return true; } virtual int instrCount() const override { return widthInstrs() * instrCountMul(); } }; -class AstMulD : public AstNodeBiComAsv { +class AstMulD final : public AstNodeBiComAsv { public: AstMulD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7402,7 +7402,7 @@ public: virtual int instrCount() const override { return instrCountDouble(); } virtual bool doubleFlavor() const override { return true; } }; -class AstMulS : public AstNodeBiComAsv { +class AstMulS final : public AstNodeBiComAsv { public: AstMulS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7427,7 +7427,7 @@ public: virtual int instrCount() const override { return widthInstrs() * instrCountMul(); } virtual bool signedFlavor() const override { return true; } }; -class AstDiv : public AstNodeBiop { +class AstDiv final : public AstNodeBiop { public: AstDiv(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7449,7 +7449,7 @@ public: virtual bool sizeMattersRhs() const override { return true; } virtual int instrCount() const override { return widthInstrs() * instrCountDiv(); } }; -class AstDivD : public AstNodeBiop { +class AstDivD final : public AstNodeBiop { public: AstDivD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7473,7 +7473,7 @@ public: virtual int instrCount() const override { return instrCountDoubleDiv(); } virtual bool doubleFlavor() const override { return true; } }; -class AstDivS : public AstNodeBiop { +class AstDivS final : public AstNodeBiop { public: AstDivS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7496,7 +7496,7 @@ public: virtual int instrCount() const override { return widthInstrs() * instrCountDiv(); } virtual bool signedFlavor() const override { return true; } }; -class AstModDiv : public AstNodeBiop { +class AstModDiv final : public AstNodeBiop { public: AstModDiv(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7518,7 +7518,7 @@ public: virtual bool sizeMattersRhs() const override { return true; } virtual int instrCount() const override { return widthInstrs() * instrCountDiv(); } }; -class AstModDivS : public AstNodeBiop { +class AstModDivS final : public AstNodeBiop { public: AstModDivS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7541,7 +7541,7 @@ public: virtual int instrCount() const override { return widthInstrs() * instrCountDiv(); } virtual bool signedFlavor() const override { return true; } }; -class AstPow : public AstNodeBiop { +class AstPow final : public AstNodeBiop { public: AstPow(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7564,7 +7564,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() * instrCountMul() * 10; } }; -class AstPowD : public AstNodeBiop { +class AstPowD final : public AstNodeBiop { public: AstPowD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7587,7 +7587,7 @@ public: virtual int instrCount() const override { return instrCountDoubleDiv() * 5; } virtual bool doubleFlavor() const override { return true; } }; -class AstPowSU : public AstNodeBiop { +class AstPowSU final : public AstNodeBiop { public: AstPowSU(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7613,7 +7613,7 @@ public: virtual int instrCount() const override { return widthInstrs() * instrCountMul() * 10; } virtual bool signedFlavor() const override { return true; } }; -class AstPowSS : public AstNodeBiop { +class AstPowSS final : public AstNodeBiop { public: AstPowSS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7639,7 +7639,7 @@ public: virtual int instrCount() const override { return widthInstrs() * instrCountMul() * 10; } virtual bool signedFlavor() const override { return true; } }; -class AstPowUS : public AstNodeBiop { +class AstPowUS final : public AstNodeBiop { public: AstPowUS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7665,7 +7665,7 @@ public: virtual int instrCount() const override { return widthInstrs() * instrCountMul() * 10; } virtual bool signedFlavor() const override { return true; } }; -class AstPreAdd : public AstNodeTriop { +class AstPreAdd final : public AstNodeTriop { // Pre-increment/add // Parents: MATH // Children: lhsp: AstConst (1) as currently support only ++ not += @@ -7690,7 +7690,7 @@ public: virtual bool sizeMattersRhs() const override { return true; } virtual bool sizeMattersThs() const override { return true; } }; -class AstPreSub : public AstNodeTriop { +class AstPreSub final : public AstNodeTriop { // Pre-decrement/subtract // Parents: MATH // Children: lhsp: AstConst (1) as currently support only -- not -= @@ -7715,7 +7715,7 @@ public: virtual bool sizeMattersRhs() const override { return true; } virtual bool sizeMattersThs() const override { return true; } }; -class AstPostAdd : public AstNodeTriop { +class AstPostAdd final : public AstNodeTriop { // Post-increment/add // Parents: MATH // Children: lhsp: AstConst (1) as currently support only ++ not += @@ -7740,7 +7740,7 @@ public: virtual bool sizeMattersRhs() const override { return true; } virtual bool sizeMattersThs() const override { return true; } }; -class AstPostSub : public AstNodeTriop { +class AstPostSub final : public AstNodeTriop { // Post-decrement/subtract // Parents: MATH // Children: lhsp: AstConst (1) as currently support only -- not -= @@ -7765,7 +7765,7 @@ public: virtual bool sizeMattersRhs() const override { return true; } virtual bool sizeMattersThs() const override { return true; } }; -class AstEqCase : public AstNodeBiCom { +class AstEqCase final : public AstNodeBiCom { public: AstEqCase(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7787,7 +7787,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstNeqCase : public AstNodeBiCom { +class AstNeqCase final : public AstNodeBiCom { public: AstNeqCase(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7809,7 +7809,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstEqWild : public AstNodeBiop { +class AstEqWild final : public AstNodeBiop { // Note wildcard operator rhs differs from lhs public: AstEqWild(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -7834,7 +7834,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstNeqWild : public AstNodeBiop { +class AstNeqWild final : public AstNodeBiop { public: AstNeqWild(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) { @@ -7856,7 +7856,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstConcat : public AstNodeBiop { +class AstConcat final : public AstNodeBiop { // If you're looking for {#{}}, see AstReplicate public: AstConcat(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -7882,7 +7882,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() * 2; } }; -class AstConcatN : public AstNodeBiop { +class AstConcatN final : public AstNodeBiop { // String concatenate public: AstConcatN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -7906,7 +7906,7 @@ public: virtual int instrCount() const override { return instrCountString(); } virtual bool stringFlavor() const override { return true; } }; -class AstReplicate : public AstNodeBiop { +class AstReplicate final : public AstNodeBiop { // Also used as a "Uniop" flavor of Concat, e.g. "{a}" // Verilog {rhs{lhs}} - Note rhsp() is the replicate value, not the lhsp() public: @@ -7936,7 +7936,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() * 2; } }; -class AstReplicateN : public AstNodeBiop { +class AstReplicateN final : public AstNodeBiop { // String replicate public: AstReplicateN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -7962,7 +7962,7 @@ public: virtual int instrCount() const override { return widthInstrs() * 2; } virtual bool stringFlavor() const override { return true; } }; -class AstStreamL : public AstNodeStream { +class AstStreamL final : public AstNodeStream { // Verilog {rhs{lhs}} - Note rhsp() is the slice size, not the lhsp() public: AstStreamL(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -7983,7 +7983,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() * 2; } }; -class AstStreamR : public AstNodeStream { +class AstStreamR final : public AstNodeStream { // Verilog {rhs{lhs}} - Note rhsp() is the slice size, not the lhsp() public: AstStreamR(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -8004,7 +8004,7 @@ public: virtual bool sizeMattersRhs() const override { return false; } virtual int instrCount() const override { return widthInstrs() * 2; } }; -class AstBufIf1 : public AstNodeBiop { +class AstBufIf1 final : public AstNodeBiop { // lhs is enable, rhs is data to drive // Note unlike the Verilog bufif1() UDP, this allows any width; each lhsp // bit enables respective rhsp bit @@ -8029,7 +8029,7 @@ public: virtual bool sizeMattersLhs() const override { return false; } virtual bool sizeMattersRhs() const override { return false; } }; -class AstFGetS : public AstNodeBiop { +class AstFGetS final : public AstNodeBiop { public: AstFGetS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} @@ -8055,7 +8055,7 @@ public: AstNode* filep() const { return rhsp(); } }; -class AstNodeSystemBiop : public AstNodeBiop { +class AstNodeSystemBiop VL_NOT_FINAL : public AstNodeBiop { public: AstNodeSystemBiop(AstType t, FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(t, fl, lhsp, rhsp) { @@ -8070,7 +8070,7 @@ public: virtual bool doubleFlavor() const override { return true; } }; -class AstAtan2D : public AstNodeSystemBiop { +class AstAtan2D final : public AstNodeSystemBiop { public: AstAtan2D(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} @@ -8085,7 +8085,7 @@ public: virtual string emitC() override { return "atan2(%li,%ri)"; } }; -class AstHypotD : public AstNodeSystemBiop { +class AstHypotD final : public AstNodeSystemBiop { public: AstHypotD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} @@ -8100,7 +8100,7 @@ public: virtual string emitC() override { return "hypot(%li,%ri)"; } }; -class AstPutcN : public AstNodeTriop { +class AstPutcN final : public AstNodeTriop { // Verilog string.putc() public: AstPutcN(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* ths) @@ -8126,7 +8126,7 @@ public: virtual bool isHeavy() const override { return true; } }; -class AstGetcN : public AstNodeBiop { +class AstGetcN final : public AstNodeBiop { // Verilog string.getc() public: AstGetcN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) @@ -8152,7 +8152,7 @@ public: virtual bool isHeavy() const override { return true; } }; -class AstGetcRefN : public AstNodeBiop { +class AstGetcRefN final : public AstNodeBiop { // Verilog string[#] on the left-hand-side of assignment // Spec says is of type byte (not string of single character) public: @@ -8178,7 +8178,7 @@ public: virtual bool isHeavy() const override { return true; } }; -class AstSubstrN : public AstNodeTriop { +class AstSubstrN final : public AstNodeTriop { // Verilog string.substr() public: AstSubstrN(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* ths) @@ -8204,7 +8204,7 @@ public: virtual bool isHeavy() const override { return true; } }; -class AstCompareNN : public AstNodeBiop { +class AstCompareNN final : public AstNodeBiop { // Verilog str.compare() and str.icompare() private: bool m_ignoreCase; // True for str.icompare() @@ -8237,7 +8237,7 @@ public: virtual bool isHeavy() const override { return true; } }; -class AstFell : public AstNodeMath { +class AstFell final : public AstNodeMath { // Verilog $fell // Parents: math // Children: expression @@ -8259,7 +8259,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstPast : public AstNodeMath { +class AstPast final : public AstNodeMath { // Verilog $past // Parents: math // Children: expression @@ -8283,7 +8283,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstRose : public AstNodeMath { +class AstRose final : public AstNodeMath { // Verilog $rose // Parents: math // Children: expression @@ -8305,7 +8305,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstSampled : public AstNodeMath { +class AstSampled final : public AstNodeMath { // Verilog $sampled // Parents: math // Children: expression @@ -8325,7 +8325,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstStable : public AstNodeMath { +class AstStable final : public AstNodeMath { // Verilog $stable // Parents: math // Children: expression @@ -8347,7 +8347,7 @@ public: virtual bool same(const AstNode* samep) const override { return true; } }; -class AstPattern : public AstNodeMath { +class AstPattern final : public AstNodeMath { // Verilog '{a,b,c,d...} // Parents: AstNodeAssign, AstPattern, ... // Children: expression, AstPattern, AstPatReplicate @@ -8369,7 +8369,7 @@ public: void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } AstNode* itemsp() const { return op2p(); } // op2 = AstPatReplicate, AstPatMember, etc }; -class AstPatMember : public AstNodeMath { +class AstPatMember final : public AstNodeMath { // Verilog '{a} or '{a{b}} // Parents: AstPattern // Children: expression, AstPattern, replication count @@ -8396,7 +8396,7 @@ public: void isDefault(bool flag) { m_default = flag; } }; -class AstImplication : public AstNodeMath { +class AstImplication final : public AstNodeMath { // Verilog |-> |=> // Parents: math // Children: expression @@ -8425,7 +8425,7 @@ public: //====================================================================== // Assertions -class AstClocking : public AstNode { +class AstClocking final : public AstNode { // Set default clock region // Parents: MODULE // Children: Assertions @@ -8444,7 +8444,7 @@ public: //====================================================================== // PSL -class AstPropClocked : public AstNode { +class AstPropClocked final : public AstNode { // A clocked property // Parents: ASSERT|COVER (property) // Children: SENITEM, Properties @@ -8464,7 +8464,7 @@ public: AstNode* propp() const { return op3p(); } // op3 = property }; -class AstNodeCoverOrAssert : public AstNodeStmt { +class AstNodeCoverOrAssert VL_NOT_FINAL : public AstNodeStmt { // Cover or Assert // Parents: {statement list} // Children: expression, report string @@ -8493,7 +8493,7 @@ public: bool immediate() const { return m_immediate; } }; -class AstAssert : public AstNodeCoverOrAssert { +class AstAssert final : public AstNodeCoverOrAssert { public: ASTNODE_NODE_FUNCS(Assert) AstAssert(FileLine* fl, AstNode* propp, AstNode* passsp, AstNode* failsp, bool immediate, @@ -8504,7 +8504,7 @@ public: AstNode* failsp() const { return op3p(); } // op3 = if assertion fails }; -class AstCover : public AstNodeCoverOrAssert { +class AstCover final : public AstNodeCoverOrAssert { public: ASTNODE_NODE_FUNCS(Cover) AstCover(FileLine* fl, AstNode* propp, AstNode* stmtsp, bool immediate, @@ -8515,7 +8515,7 @@ public: virtual bool immediate() const { return false; } }; -class AstRestrict : public AstNodeCoverOrAssert { +class AstRestrict final : public AstNodeCoverOrAssert { public: ASTNODE_NODE_FUNCS(Restrict) AstRestrict(FileLine* fl, AstNode* propp) @@ -8525,7 +8525,7 @@ public: //====================================================================== // Text based nodes -class AstNodeSimpleText : public AstNodeText { +class AstNodeSimpleText VL_NOT_FINAL : public AstNodeText { private: bool m_tracking; // When emit, it's ok to parse the string to do indentation public: @@ -8537,14 +8537,14 @@ public: bool tracking() const { return m_tracking; } }; -class AstText : public AstNodeSimpleText { +class AstText final : public AstNodeSimpleText { public: AstText(FileLine* fl, const string& textp, bool tracking = false) : ASTGEN_SUPER(fl, textp, tracking) {} ASTNODE_NODE_FUNCS(Text) }; -class AstTextBlock : public AstNodeSimpleText { +class AstTextBlock final : public AstNodeSimpleText { private: bool m_commas; // Comma separate emitted children public: @@ -8562,7 +8562,7 @@ public: } }; -class AstScCtor : public AstNodeText { +class AstScCtor final : public AstNodeText { public: AstScCtor(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} @@ -8571,7 +8571,7 @@ public: virtual bool isOutputter() const override { return true; } }; -class AstScDtor : public AstNodeText { +class AstScDtor final : public AstNodeText { public: AstScDtor(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} @@ -8580,7 +8580,7 @@ public: virtual bool isOutputter() const override { return true; } }; -class AstScHdr : public AstNodeText { +class AstScHdr final : public AstNodeText { public: AstScHdr(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} @@ -8589,7 +8589,7 @@ public: virtual bool isOutputter() const override { return true; } }; -class AstScImp : public AstNodeText { +class AstScImp final : public AstNodeText { public: AstScImp(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} @@ -8598,7 +8598,7 @@ public: virtual bool isOutputter() const override { return true; } }; -class AstScImpHdr : public AstNodeText { +class AstScImpHdr final : public AstNodeText { public: AstScImpHdr(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} @@ -8607,7 +8607,7 @@ public: virtual bool isOutputter() const override { return true; } }; -class AstScInt : public AstNodeText { +class AstScInt final : public AstNodeText { public: AstScInt(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} @@ -8616,7 +8616,7 @@ public: virtual bool isOutputter() const override { return true; } }; -class AstUCStmt : public AstNodeStmt { +class AstUCStmt final : public AstNodeStmt { // User $c statement public: AstUCStmt(FileLine* fl, AstNode* exprsp) @@ -8636,7 +8636,7 @@ public: //====================================================================== // Emitted file nodes -class AstNodeFile : public AstNode { +class AstNodeFile VL_NOT_FINAL : public AstNode { // Emitted Otput file // Parents: NETLIST // Children: AstTextBlock @@ -8659,7 +8659,7 @@ public: //====================================================================== // Emit V nodes -class AstVFile : public AstNodeFile { +class AstVFile final : public AstNodeFile { // Verilog output file // Parents: NETLIST public: @@ -8672,7 +8672,7 @@ public: //====================================================================== // Emit C nodes -class AstCFile : public AstNodeFile { +class AstCFile final : public AstNodeFile { // C++ output file // Parents: NETLIST private: @@ -8695,7 +8695,7 @@ public: void support(bool flag) { m_support = flag; } }; -class AstCFunc : public AstNode { +class AstCFunc final : public AstNode { // C++ function // Parents: MODULE/SCOPE // Children: VAR/statements @@ -8847,7 +8847,7 @@ public: } }; -class AstCCall : public AstNodeCCall { +class AstCCall final : public AstNodeCCall { // C++ function call // Parents: Anything above a statement // Children: Args to the function @@ -8861,7 +8861,7 @@ public: ASTNODE_NODE_FUNCS(CCall) }; -class AstCMethodCall : public AstNodeCCall { +class AstCMethodCall final : public AstNodeCCall { // C++ method call // Parents: Anything above a statement // Children: Args to the function @@ -8882,7 +8882,7 @@ public: void fromp(AstNode* nodep) { setOp1p(nodep); } }; -class AstCNew : public AstNodeCCall { +class AstCNew final : public AstNodeCCall { // C++ new() call // Parents: Anything above an expression // Children: Args to the function @@ -8899,7 +8899,7 @@ public: ASTNODE_NODE_FUNCS(CNew) }; -class AstCReturn : public AstNodeStmt { +class AstCReturn final : public AstNodeStmt { // C++ return from a function // Parents: CFUNC/statement // Children: Math @@ -8916,7 +8916,7 @@ public: AstNode* lhsp() const { return op1p(); } }; -class AstCMath : public AstNodeMath { +class AstCMath final : public AstNodeMath { private: bool m_cleanOut; bool m_pure; // Pure optimizable @@ -8950,7 +8950,7 @@ public: void pure(bool flag) { m_pure = flag; } }; -class AstCReset : public AstNodeStmt { +class AstCReset final : public AstNodeStmt { // Reset variable at startup public: AstCReset(FileLine* fl, AstNode* exprsp) @@ -8965,7 +8965,7 @@ public: AstVarRef* varrefp() const { return VN_CAST(op1p(), VarRef); } // op1 = varref to reset }; -class AstCStmt : public AstNodeStmt { +class AstCStmt final : public AstNodeStmt { // Emit C statement public: AstCStmt(FileLine* fl, AstNode* exprsp) @@ -8985,7 +8985,7 @@ public: AstNode* bodysp() const { return op1p(); } // op1 = expressions to print }; -class AstCUse : public AstNode { +class AstCUse final : public AstNode { // C++ use of a class or #include; indicates need of forward declaration // Parents: NODEMODULE private: @@ -9004,7 +9004,7 @@ public: void useType(VUseType useType) { m_useType = useType; } }; -class AstMTaskBody : public AstNode { +class AstMTaskBody final : public AstNode { // Hold statements for each MTask private: ExecMTask* m_execMTaskp = nullptr; @@ -9024,7 +9024,7 @@ public: virtual void dump(std::ostream& str = std::cout) const override; }; -class AstExecGraph : public AstNode { +class AstExecGraph final : public AstNode { // For parallel execution, this node contains a dependency graph. Each // node in the graph is an ExecMTask, which contains a body for the // mtask, which contains a set of AstActive's, each of which calls a @@ -9048,7 +9048,7 @@ public: void addMTaskBody(AstMTaskBody* bodyp) { addOp1p(bodyp); } }; -class AstSplitPlaceholder : public AstNode { +class AstSplitPlaceholder final : public AstNode { public: // Dummy node used within V3Split; never exists outside of V3Split. explicit AstSplitPlaceholder(FileLine* fl) @@ -9059,7 +9059,7 @@ public: //###################################################################### // Right below top -class AstTypeTable : public AstNode { +class AstTypeTable final : public AstNode { // Container for hash of standard data types // Children: NODEDTYPEs AstVoidDType* m_voidp = nullptr; @@ -9093,7 +9093,7 @@ public: //###################################################################### // Top -class AstNetlist : public AstNode { +class AstNetlist final : public AstNode { // All modules are under this single top node. // Parents: none // Children: MODULEs & CFILEs diff --git a/src/V3Begin.cpp b/src/V3Begin.cpp index 31190eca8..3f92f8081 100644 --- a/src/V3Begin.cpp +++ b/src/V3Begin.cpp @@ -36,7 +36,7 @@ //###################################################################### -class BeginState { +class BeginState final { private: // NODE STATE // Entire netlist: @@ -56,7 +56,7 @@ public: //###################################################################### -class BeginVisitor : public AstNVisitor { +class BeginVisitor final : public AstNVisitor { private: // STATE BeginState* m_statep; // Current global state @@ -247,7 +247,7 @@ public: //###################################################################### -class BeginRelinkVisitor : public AstNVisitor { +class BeginRelinkVisitor final : public AstNVisitor { // Replace tasks with new pointer private: // NODE STATE diff --git a/src/V3Begin.h b/src/V3Begin.h index 9b360c35c..fcd0a33f9 100644 --- a/src/V3Begin.h +++ b/src/V3Begin.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Begin { +class V3Begin final { public: static void debeginAll(AstNetlist* nodep); }; diff --git a/src/V3Branch.cpp b/src/V3Branch.cpp index 325ba2900..34901d20e 100644 --- a/src/V3Branch.cpp +++ b/src/V3Branch.cpp @@ -35,7 +35,7 @@ //###################################################################### // Branch state, as a visitor of each AstNode -class BranchVisitor : public AstNVisitor { +class BranchVisitor final : public AstNVisitor { private: // NODE STATE // Entire netlist: diff --git a/src/V3Branch.h b/src/V3Branch.h index 9a82514a7..d8ebed0f5 100644 --- a/src/V3Branch.h +++ b/src/V3Branch.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Branch { +class V3Branch final { public: // CONSTRUCTORS static void branchAll(AstNetlist* nodep); diff --git a/src/V3Broken.cpp b/src/V3Broken.cpp index d76a9241c..fe3c481c9 100644 --- a/src/V3Broken.cpp +++ b/src/V3Broken.cpp @@ -36,7 +36,7 @@ //###################################################################### -class BrokenTable : public AstNVisitor { +class BrokenTable final : public AstNVisitor { // Table of brokenExists node pointers private: // MEMBERS @@ -211,7 +211,7 @@ bool AstNode::brokeExistsBelow() const { //###################################################################### -class BrokenMarkVisitor : public AstNVisitor { +class BrokenMarkVisitor final : public AstNVisitor { // Mark every node in the tree private: // NODE STATE @@ -237,7 +237,7 @@ public: //###################################################################### // Broken state, as a visitor of each AstNode -class BrokenCheckVisitor : public AstNVisitor { +class BrokenCheckVisitor final : public AstNVisitor { bool m_inScope = false; // Under AstScope private: diff --git a/src/V3Broken.h b/src/V3Broken.h index 104765f03..ee7d718f6 100644 --- a/src/V3Broken.h +++ b/src/V3Broken.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Broken { +class V3Broken final { public: static void brokenAll(AstNetlist* nodep); static void addNewed(AstNode* nodep); diff --git a/src/V3CCtors.cpp b/src/V3CCtors.cpp index eb3a88d5d..1dc6b9b04 100644 --- a/src/V3CCtors.cpp +++ b/src/V3CCtors.cpp @@ -34,7 +34,7 @@ #include #include -class V3CCtorsVisitor { +class V3CCtorsVisitor final { private: string m_basename; string m_argsp; diff --git a/src/V3CCtors.h b/src/V3CCtors.h index 1592d19c9..533a0e819 100644 --- a/src/V3CCtors.h +++ b/src/V3CCtors.h @@ -25,7 +25,7 @@ //============================================================================ -class V3CCtors { +class V3CCtors final { public: static void cctorsAll(); diff --git a/src/V3CUse.cpp b/src/V3CUse.cpp index 86f97dd74..3bf389464 100644 --- a/src/V3CUse.cpp +++ b/src/V3CUse.cpp @@ -36,7 +36,7 @@ //###################################################################### -class CUseState { +class CUseState final { private: // MEMBERS AstNodeModule* m_modInsertp; // Current module to insert AstCUse under @@ -75,7 +75,7 @@ public: // Visit within a module all nodes and data types they reference, finding // any classes so we can make sure they are defined when Verilated code // compiles -class CUseDTypeVisitor : public AstNVisitor { +class CUseDTypeVisitor final : public AstNVisitor { // MEMBERS CUseState& m_stater; // State for inserter bool m_impOnly = false; // In details needed only for implementation @@ -113,7 +113,7 @@ public: VL_UNCOPYABLE(CUseDTypeVisitor); }; -class CUseVisitor : public AstNVisitor { +class CUseVisitor final : public AstNVisitor { // MEMBERS CUseState m_state; // Inserter state diff --git a/src/V3CUse.h b/src/V3CUse.h index ffae09a46..d3d0a44af 100644 --- a/src/V3CUse.h +++ b/src/V3CUse.h @@ -25,7 +25,7 @@ //============================================================================ -class V3CUse { +class V3CUse final { public: static void cUseAll(); }; diff --git a/src/V3Case.cpp b/src/V3Case.cpp index 31c0bfeec..3b36aa6ba 100644 --- a/src/V3Case.cpp +++ b/src/V3Case.cpp @@ -50,7 +50,7 @@ //###################################################################### -class CaseLintVisitor : public AstNVisitor { +class CaseLintVisitor final : public AstNVisitor { private: AstNodeCase* m_caseExprp = nullptr; // Under a CASE value node, if so the relevant case statement @@ -117,7 +117,7 @@ public: //###################################################################### // Case state, as a visitor of each AstNode -class CaseVisitor : public AstNVisitor { +class CaseVisitor final : public AstNVisitor { private: // NODE STATE // Cleared each Case diff --git a/src/V3Case.h b/src/V3Case.h index 1e4d916b6..35d4abbf7 100644 --- a/src/V3Case.h +++ b/src/V3Case.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Case { +class V3Case final { public: static void caseAll(AstNetlist* nodep); static void caseLint(AstNodeCase* nodep); diff --git a/src/V3Cast.cpp b/src/V3Cast.cpp index e2fe21ccb..355516acb 100644 --- a/src/V3Cast.cpp +++ b/src/V3Cast.cpp @@ -49,7 +49,7 @@ //###################################################################### // Cast state, as a visitor of each AstNode -class CastVisitor : public AstNVisitor { +class CastVisitor final : public AstNVisitor { private: // NODE STATE // Entire netlist: diff --git a/src/V3Cast.h b/src/V3Cast.h index d18fc641b..ab9ad4dc0 100644 --- a/src/V3Cast.h +++ b/src/V3Cast.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Cast { +class V3Cast final { public: static void castAll(AstNetlist* nodep); }; diff --git a/src/V3Cdc.cpp b/src/V3Cdc.cpp index 65e69ed04..dfb70a833 100644 --- a/src/V3Cdc.cpp +++ b/src/V3Cdc.cpp @@ -41,7 +41,7 @@ constexpr int CDC_WEIGHT_ASYNC = 0x1000; // Weight for edges that feed async lo //###################################################################### -class CdcBaseVisitor : public AstNVisitor { +class CdcBaseVisitor VL_NOT_FINAL : public AstNVisitor { public: VL_DEBUG_FUNC; // Declare debug() }; @@ -49,7 +49,7 @@ public: //###################################################################### // Graph support classes -class CdcEitherVertex : public V3GraphVertex { +class CdcEitherVertex VL_NOT_FINAL : public V3GraphVertex { AstScope* m_scopep; AstNode* m_nodep; AstSenTree* m_srcDomainp = nullptr; @@ -83,7 +83,7 @@ public: void asyncPath(bool flag) { m_asyncPath = flag; } }; -class CdcVarVertex : public CdcEitherVertex { +class CdcVarVertex final : public CdcEitherVertex { AstVarScope* m_varScp; int m_cntAsyncRst = 0; bool m_fromFlop = false; @@ -105,7 +105,7 @@ public: void fromFlop(bool flag) { m_fromFlop = flag; } }; -class CdcLogicVertex : public CdcEitherVertex { +class CdcLogicVertex final : public CdcEitherVertex { bool m_hazard : 1; bool m_isFlop : 1; @@ -135,7 +135,7 @@ public: //###################################################################### -class CdcDumpVisitor : public CdcBaseVisitor { +class CdcDumpVisitor final : public CdcBaseVisitor { private: // NODE STATE // Entire netlist: @@ -175,7 +175,7 @@ public: //###################################################################### -class CdcWidthVisitor : public CdcBaseVisitor { +class CdcWidthVisitor final : public CdcBaseVisitor { private: int m_maxLineno = 0; size_t m_maxFilenameLen = 0; @@ -209,7 +209,7 @@ public: //###################################################################### // Cdc class functions -class CdcVisitor : public CdcBaseVisitor { +class CdcVisitor final : public CdcBaseVisitor { private: // NODE STATE // Entire netlist: diff --git a/src/V3Cdc.h b/src/V3Cdc.h index cd6b33f30..9d59849f1 100644 --- a/src/V3Cdc.h +++ b/src/V3Cdc.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Cdc { +class V3Cdc final { public: static void cdcAll(AstNetlist* nodep); }; diff --git a/src/V3Changed.cpp b/src/V3Changed.cpp index 7cf53bdfa..dbe1905b7 100644 --- a/src/V3Changed.cpp +++ b/src/V3Changed.cpp @@ -38,7 +38,7 @@ //###################################################################### -class ChangedState { +class ChangedState final { public: // STATE AstNodeModule* m_topModp = nullptr; // Top module @@ -94,7 +94,7 @@ public: //###################################################################### // Utility visitor to find elements to be compared -class ChangedInsertVisitor : public AstNVisitor { +class ChangedInsertVisitor final : public AstNVisitor { private: // STATE ChangedState* m_statep; // Shared state across visitors @@ -214,7 +214,7 @@ public: //###################################################################### // Changed state, as a visitor of each AstNode -class ChangedVisitor : public AstNVisitor { +class ChangedVisitor final : public AstNVisitor { private: // NODE STATE // Entire netlist: diff --git a/src/V3Changed.h b/src/V3Changed.h index 311a0c371..79c56cb27 100644 --- a/src/V3Changed.h +++ b/src/V3Changed.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Changed { +class V3Changed final { public: static void changedAll(AstNetlist* nodep); }; diff --git a/src/V3Class.cpp b/src/V3Class.cpp index ebde82354..69c25783c 100644 --- a/src/V3Class.cpp +++ b/src/V3Class.cpp @@ -29,7 +29,7 @@ //###################################################################### -class ClassVisitor : public AstNVisitor { +class ClassVisitor final : public AstNVisitor { private: // MEMBERS AstUser1InUse m_inuser1; diff --git a/src/V3Class.h b/src/V3Class.h index f93be9a71..a436bd9ed 100644 --- a/src/V3Class.h +++ b/src/V3Class.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Class { +class V3Class final { public: static void classAll(AstNetlist* nodep); }; diff --git a/src/V3Clean.cpp b/src/V3Clean.cpp index e1ebe1fa0..458e366fe 100644 --- a/src/V3Clean.cpp +++ b/src/V3Clean.cpp @@ -35,7 +35,7 @@ //###################################################################### // Clean state, as a visitor of each AstNode -class CleanVisitor : public AstNVisitor { +class CleanVisitor final : public AstNVisitor { private: // NODE STATE // Entire netlist: diff --git a/src/V3Clean.h b/src/V3Clean.h index 76b212a80..76223d2ee 100644 --- a/src/V3Clean.h +++ b/src/V3Clean.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Clean { +class V3Clean final { public: static void cleanAll(AstNetlist* nodep); }; diff --git a/src/V3Clock.cpp b/src/V3Clock.cpp index 77a7d6ff7..ecb1f939b 100644 --- a/src/V3Clock.cpp +++ b/src/V3Clock.cpp @@ -40,7 +40,7 @@ //###################################################################### // Clock state, as a visitor of each AstNode -class ClockVisitor : public AstNVisitor { +class ClockVisitor final : public AstNVisitor { private: // NODE STATE // Cleared each Module: diff --git a/src/V3Clock.h b/src/V3Clock.h index c2301a8e3..de0ae9f2f 100644 --- a/src/V3Clock.h +++ b/src/V3Clock.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Clock { +class V3Clock final { public: static void clockAll(AstNetlist* nodep); }; diff --git a/src/V3Combine.cpp b/src/V3Combine.cpp index 70fcd589d..795f1a8b1 100644 --- a/src/V3Combine.cpp +++ b/src/V3Combine.cpp @@ -51,7 +51,7 @@ constexpr int COMBINE_MIN_STATEMENTS = 50; // Min # of statements to be worth m //###################################################################### -class CombBaseVisitor : public AstNVisitor { +class CombBaseVisitor VL_NOT_FINAL : public AstNVisitor { protected: // STATE @@ -63,7 +63,7 @@ protected: //###################################################################### // Combine replacement function -class CombCallVisitor : CombBaseVisitor { +class CombCallVisitor final : CombBaseVisitor { // Find all CCALLS of each CFUNC, so that we can later rename them private: // NODE STATE @@ -139,7 +139,7 @@ public: //###################################################################### // Combine marking function -class CombMarkVisitor : CombBaseVisitor { +class CombMarkVisitor final : CombBaseVisitor { // Mark all nodes under specified one. private: // OUTPUT: @@ -159,7 +159,7 @@ public: //###################################################################### // Combine state, as a visitor of each AstNode -class CombineVisitor : CombBaseVisitor { +class CombineVisitor final : CombBaseVisitor { private: // NODE STATE // Entire netlist: diff --git a/src/V3Combine.h b/src/V3Combine.h index 39a223fe8..aee53c2ae 100644 --- a/src/V3Combine.h +++ b/src/V3Combine.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Combine { +class V3Combine final { public: static void combineAll(AstNetlist* nodep); }; diff --git a/src/V3Config.cpp b/src/V3Config.cpp index e37421159..3498e66fb 100644 --- a/src/V3Config.cpp +++ b/src/V3Config.cpp @@ -82,7 +82,7 @@ public: }; // Only public_flat_rw has the sensitity tree -class V3ConfigVarAttr { +class V3ConfigVarAttr final { public: AstAttrType m_type; // Type of attribute AstSenTree* m_sentreep; // Sensitivity tree for public_flat_rw @@ -92,7 +92,7 @@ public: }; // Overload vector with the required update function and to apply all entries -class V3ConfigVar : public std::vector { +class V3ConfigVar final : public std::vector { public: // Update from other by copying all attributes void update(const V3ConfigVar& node) { @@ -116,7 +116,7 @@ typedef V3ConfigWildcardResolver V3ConfigVarResolver; //###################################################################### // Function or task: Have variables and properties -class V3ConfigFTask { +class V3ConfigFTask final { V3ConfigVarResolver m_vars; // Variables in function/task bool m_isolate = false; // Isolate function return bool m_noinline = false; // Don't inline function/task @@ -153,7 +153,7 @@ typedef V3ConfigWildcardResolver V3ConfigFTaskResolver; //###################################################################### // Modules have tasks, variables, named blocks and properties -class V3ConfigModule { +class V3ConfigModule final { typedef std::unordered_set StringSet; typedef std::set PragmaSet; @@ -224,7 +224,7 @@ typedef V3ConfigWildcardResolver V3ConfigModuleResolver; // - Line attributes: Attributes attached to lines // lint/coverage/tracing on/off -class V3ConfigIgnoresLine { +class V3ConfigIgnoresLine final { public: int m_lineno; // Line number to make change at V3ErrorCode m_code; // Error code @@ -253,7 +253,7 @@ std::ostream& operator<<(std::ostream& os, const V3ConfigIgnoresLine& rhs) { typedef std::bitset V3ConfigLineAttribute; // File entity -class V3ConfigFile { +class V3ConfigFile final { typedef std::map LineAttrMap; // Map line->bitset of attributes typedef std::multiset IgnLines; // list of {line,code,on} typedef std::pair WaiverSetting; // Waive code if string matches @@ -347,7 +347,7 @@ typedef V3ConfigWildcardResolver V3ConfigFileResolver; //###################################################################### // Resolve modules and files in the design -class V3ConfigResolver { +class V3ConfigResolver final { V3ConfigModuleResolver m_modules; // Access to module names (with wildcards) V3ConfigFileResolver m_files; // Access to file names (with wildcards) diff --git a/src/V3Config.h b/src/V3Config.h index cc3a3a42f..dcf01427f 100644 --- a/src/V3Config.h +++ b/src/V3Config.h @@ -26,7 +26,7 @@ //###################################################################### -class V3Config { +class V3Config final { public: static void addCaseFull(const string& file, int lineno); static void addCaseParallel(const string& file, int lineno); diff --git a/src/V3Const.cpp b/src/V3Const.cpp index b34485311..6ec823740 100644 --- a/src/V3Const.cpp +++ b/src/V3Const.cpp @@ -36,7 +36,7 @@ //###################################################################### // Utilities -class ConstVarMarkVisitor : public AstNVisitor { +class ConstVarMarkVisitor final : public AstNVisitor { // NODE STATE // AstVar::user4p -> bool, Var marked, 0=not set yet private: @@ -55,7 +55,7 @@ public: virtual ~ConstVarMarkVisitor() override = default; }; -class ConstVarFindVisitor : public AstNVisitor { +class ConstVarFindVisitor final : public AstNVisitor { // NODE STATE // AstVar::user4p -> bool, input from ConstVarMarkVisitor // MEMBERS @@ -79,7 +79,7 @@ public: //###################################################################### // Const state, as a visitor of each AstNode -class ConstVisitor : public AstNVisitor { +class ConstVisitor final : public AstNVisitor { private: // NODE STATE // ** only when m_warn/m_doExpensive is set. If state is needed other times, diff --git a/src/V3Const.h b/src/V3Const.h index a7a45aca6..f5b8732f3 100644 --- a/src/V3Const.h +++ b/src/V3Const.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Const { +class V3Const final { public: static AstNode* constifyParamsEdit(AstNode* nodep); static AstNode* constifyGenerateParamsEdit(AstNode* nodep); diff --git a/src/V3Coverage.cpp b/src/V3Coverage.cpp index 4019953e8..3a4c2f3d9 100644 --- a/src/V3Coverage.cpp +++ b/src/V3Coverage.cpp @@ -37,7 +37,7 @@ //###################################################################### // Coverage state, as a visitor of each AstNode -class CoverageVisitor : public AstNVisitor { +class CoverageVisitor final : public AstNVisitor { private: // TYPES typedef std::unordered_map VarNameMap; diff --git a/src/V3Coverage.h b/src/V3Coverage.h index b24b25ee8..37ebbacd5 100644 --- a/src/V3Coverage.h +++ b/src/V3Coverage.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Coverage { +class V3Coverage final { public: // CONSTRUCTORS static void coverage(AstNetlist* rootp); diff --git a/src/V3CoverageJoin.cpp b/src/V3CoverageJoin.cpp index 94da008d7..aebcc1f7f 100644 --- a/src/V3CoverageJoin.cpp +++ b/src/V3CoverageJoin.cpp @@ -30,7 +30,7 @@ //###################################################################### // CoverageJoin state, as a visitor of each AstNode -class CoverageJoinVisitor : public AstNVisitor { +class CoverageJoinVisitor final : public AstNVisitor { private: // NODE STATE // V3Hashed diff --git a/src/V3CoverageJoin.h b/src/V3CoverageJoin.h index 1983db564..cdf2447e5 100644 --- a/src/V3CoverageJoin.h +++ b/src/V3CoverageJoin.h @@ -25,7 +25,7 @@ //============================================================================ -class V3CoverageJoin { +class V3CoverageJoin final { public: // CONSTRUCTORS static void coverageJoin(AstNetlist* rootp); diff --git a/src/V3Dead.cpp b/src/V3Dead.cpp index 718131703..648d4d641 100644 --- a/src/V3Dead.cpp +++ b/src/V3Dead.cpp @@ -46,7 +46,7 @@ //###################################################################### -class DeadModVisitor : public AstNVisitor { +class DeadModVisitor final : public AstNVisitor { // In a module that is dead, cleanup the in-use counts of the modules private: // NODE STATE @@ -69,7 +69,7 @@ public: //###################################################################### // Dead state, as a visitor of each AstNode -class DeadVisitor : public AstNVisitor { +class DeadVisitor final : public AstNVisitor { private: // NODE STATE // Entire Netlist: diff --git a/src/V3Dead.h b/src/V3Dead.h index 6ef94b8d6..45da1943c 100644 --- a/src/V3Dead.h +++ b/src/V3Dead.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Dead { +class V3Dead final { public: // Modules, no vars/dtypes static void deadifyModules(AstNetlist* nodep); diff --git a/src/V3Delayed.cpp b/src/V3Delayed.cpp index e37f1d7f1..c03478ad1 100644 --- a/src/V3Delayed.cpp +++ b/src/V3Delayed.cpp @@ -63,7 +63,7 @@ //###################################################################### // Delayed state, as a visitor of each AstNode -class DelayedVisitor : public AstNVisitor { +class DelayedVisitor final : public AstNVisitor { private: // NODE STATE // Cleared each module: diff --git a/src/V3Delayed.h b/src/V3Delayed.h index cdacae1ff..eaa1e2650 100644 --- a/src/V3Delayed.h +++ b/src/V3Delayed.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Delayed { +class V3Delayed final { public: static void delayedAll(AstNetlist* nodep); }; diff --git a/src/V3Depth.cpp b/src/V3Depth.cpp index 158bf4f85..6cc0bc5d7 100644 --- a/src/V3Depth.cpp +++ b/src/V3Depth.cpp @@ -34,7 +34,7 @@ //###################################################################### -class DepthVisitor : public AstNVisitor { +class DepthVisitor final : public AstNVisitor { private: // NODE STATE diff --git a/src/V3Depth.h b/src/V3Depth.h index 6527afab8..9e1e4834f 100644 --- a/src/V3Depth.h +++ b/src/V3Depth.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Depth { +class V3Depth final { public: static void depthAll(AstNetlist* nodep); }; diff --git a/src/V3DepthBlock.cpp b/src/V3DepthBlock.cpp index a95592ab8..19a3a0604 100644 --- a/src/V3DepthBlock.cpp +++ b/src/V3DepthBlock.cpp @@ -32,7 +32,7 @@ //###################################################################### -class DepthBlockVisitor : public AstNVisitor { +class DepthBlockVisitor final : public AstNVisitor { private: // NODE STATE diff --git a/src/V3DepthBlock.h b/src/V3DepthBlock.h index 2ba04b280..7233cd320 100644 --- a/src/V3DepthBlock.h +++ b/src/V3DepthBlock.h @@ -25,7 +25,7 @@ //============================================================================ -class V3DepthBlock { +class V3DepthBlock final { public: static void depthBlockAll(AstNetlist* nodep); }; diff --git a/src/V3Descope.cpp b/src/V3Descope.cpp index fb864118d..b59e900ca 100644 --- a/src/V3Descope.cpp +++ b/src/V3Descope.cpp @@ -34,7 +34,7 @@ //###################################################################### -class DescopeVisitor : public AstNVisitor { +class DescopeVisitor final : public AstNVisitor { private: // NODE STATE // Cleared entire netlist diff --git a/src/V3Descope.h b/src/V3Descope.h index f808a5a8d..04093afd6 100644 --- a/src/V3Descope.h +++ b/src/V3Descope.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Descope { +class V3Descope final { public: static void descopeAll(AstNetlist* nodep); }; diff --git a/src/V3EmitC.cpp b/src/V3EmitC.cpp index 4dabe5e7c..0345ceb44 100644 --- a/src/V3EmitC.cpp +++ b/src/V3EmitC.cpp @@ -39,7 +39,7 @@ constexpr int EMITC_NUM_CONSTW //###################################################################### // Emit statements and math operators -class EmitCStmts : public EmitCBaseVisitor { +class EmitCStmts VL_NOT_FINAL : public EmitCBaseVisitor { private: typedef std::vector VarVec; typedef std::map VarSortMap; // Map size class to VarVec @@ -1264,7 +1264,7 @@ public: //###################################################################### // Establish mtask variable sort order in mtasks mode -class EmitVarTspSorter : public V3TSP::TspStateBase { +class EmitVarTspSorter final : public V3TSP::TspStateBase { private: // MEMBERS const MTaskIdSet& m_mtaskIds; // Mtask we're ordering @@ -1306,7 +1306,7 @@ unsigned EmitVarTspSorter::m_serialNext = 0; //###################################################################### // Internal EmitC implementation -class EmitCImp : EmitCStmts { +class EmitCImp final : EmitCStmts { // MEMBERS AstNodeModule* m_modp = nullptr; std::vector m_blkChangeDetVec; // All encountered changes in block @@ -3401,7 +3401,7 @@ void EmitCImp::mainImp(AstNodeModule* modp, bool slow) { //###################################################################### // Tracing routines -class EmitCTrace : EmitCStmts { +class EmitCTrace final : EmitCStmts { // NODE STATE/TYPES // Cleared on netlist // AstNode::user1() -> int. Enum number diff --git a/src/V3EmitC.h b/src/V3EmitC.h index 0bd5ec642..e89b8f89a 100644 --- a/src/V3EmitC.h +++ b/src/V3EmitC.h @@ -25,7 +25,7 @@ //============================================================================ -class V3EmitC { +class V3EmitC final { public: static void emitc(); static void emitcInlines(); diff --git a/src/V3EmitCBase.h b/src/V3EmitCBase.h index 87bdb58bc..731b8356e 100644 --- a/src/V3EmitCBase.h +++ b/src/V3EmitCBase.h @@ -30,7 +30,7 @@ //###################################################################### // Base Visitor class -- holds output file pointer -class EmitCBaseVisitor : public AstNVisitor { +class EmitCBaseVisitor VL_NOT_FINAL : public AstNVisitor { public: // STATE V3OutCFile* m_ofp = nullptr; @@ -113,7 +113,7 @@ public: //###################################################################### // Count operations under the given node, as a visitor of each AstNode -class EmitCBaseCounterVisitor : public AstNVisitor { +class EmitCBaseCounterVisitor final : public AstNVisitor { private: // MEMBERS int m_count = 0; // Number of statements diff --git a/src/V3EmitCInlines.cpp b/src/V3EmitCInlines.cpp index eb91000d0..df7d20c88 100644 --- a/src/V3EmitCInlines.cpp +++ b/src/V3EmitCInlines.cpp @@ -26,7 +26,7 @@ //###################################################################### -class EmitCInlines : EmitCBaseVisitor { +class EmitCInlines final : EmitCBaseVisitor { // STATE // METHODS diff --git a/src/V3EmitCMain.cpp b/src/V3EmitCMain.cpp index 3d066bc1b..f23cc7668 100644 --- a/src/V3EmitCMain.cpp +++ b/src/V3EmitCMain.cpp @@ -26,7 +26,7 @@ //###################################################################### -class EmitCMain : EmitCBaseVisitor { +class EmitCMain final : EmitCBaseVisitor { // METHODS // VISITORS diff --git a/src/V3EmitCMain.h b/src/V3EmitCMain.h index 04df088a2..c17449f50 100644 --- a/src/V3EmitCMain.h +++ b/src/V3EmitCMain.h @@ -22,7 +22,7 @@ //============================================================================ -class V3EmitCMain { +class V3EmitCMain final { public: static void emit(); }; diff --git a/src/V3EmitCMake.cpp b/src/V3EmitCMake.cpp index ce830611e..4844f5ad6 100644 --- a/src/V3EmitCMake.cpp +++ b/src/V3EmitCMake.cpp @@ -28,7 +28,7 @@ //###################################################################### // Emit statements -class CMakeEmitter { +class CMakeEmitter final { // METHODS VL_DEBUG_FUNC; // Declare debug() diff --git a/src/V3EmitCMake.h b/src/V3EmitCMake.h index 9cfe9275a..144a22925 100644 --- a/src/V3EmitCMake.h +++ b/src/V3EmitCMake.h @@ -22,7 +22,7 @@ //============================================================================ -class V3EmitCMake { +class V3EmitCMake final { public: static void emit(); }; diff --git a/src/V3EmitCSyms.cpp b/src/V3EmitCSyms.cpp index eb88e4cdb..fe2ef52f8 100644 --- a/src/V3EmitCSyms.cpp +++ b/src/V3EmitCSyms.cpp @@ -29,7 +29,7 @@ //###################################################################### // Symbol table emitting -class EmitCSyms : EmitCBaseVisitor { +class EmitCSyms final : EmitCBaseVisitor { // NODE STATE // Cleared on Netlist // AstNodeModule::user1() -> bool. Set true __Vconfigure called diff --git a/src/V3EmitMk.cpp b/src/V3EmitMk.cpp index 1c9f11cba..cf50f1ea2 100644 --- a/src/V3EmitMk.cpp +++ b/src/V3EmitMk.cpp @@ -26,7 +26,7 @@ //###################################################################### // Emit statements and math operators -class EmitMk { +class EmitMk final { public: // METHODS VL_DEBUG_FUNC; // Declare debug() @@ -289,7 +289,7 @@ public: }; //###################################################################### -class EmitMkHierVerilation { +class EmitMkHierVerilation final { const V3HierBlockPlan* const m_planp; const string m_makefile; // path of this makefile void emitCommonOpts(V3OutMkFile& of) const { diff --git a/src/V3EmitMk.h b/src/V3EmitMk.h index 4e30f598c..bb329c3bd 100644 --- a/src/V3EmitMk.h +++ b/src/V3EmitMk.h @@ -24,7 +24,7 @@ class V3HierBlockPlan; //============================================================================ -class V3EmitMk { +class V3EmitMk final { public: static void emitmk(); static void emitHierVerilation(const V3HierBlockPlan* planp); diff --git a/src/V3EmitV.cpp b/src/V3EmitV.cpp index fb3974f7f..53565a87e 100644 --- a/src/V3EmitV.cpp +++ b/src/V3EmitV.cpp @@ -28,7 +28,7 @@ //###################################################################### // Emit statements and math operators -class EmitVBaseVisitor : public EmitCBaseVisitor { +class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor { // MEMBERS bool m_suppressSemi = false; bool m_suppressUnknown = false; @@ -673,7 +673,7 @@ public: //###################################################################### // Emit to an output file -class EmitVFileVisitor : public EmitVBaseVisitor { +class EmitVFileVisitor final : public EmitVBaseVisitor { // MEMBERS V3OutFile* m_ofp; // METHODS @@ -699,7 +699,7 @@ public: //###################################################################### // Emit to a stream (perhaps stringstream) -class EmitVStreamVisitor : public EmitVBaseVisitor { +class EmitVStreamVisitor final : public EmitVBaseVisitor { // MEMBERS std::ostream& m_os; // METHODS @@ -721,7 +721,7 @@ public: //###################################################################### // Emit to a stream (perhaps stringstream) -class EmitVPrefixedFormatter : public V3OutFormatter { +class EmitVPrefixedFormatter final : public V3OutFormatter { std::ostream& m_os; string m_prefix; // What to print at beginning of each line int m_flWidth; // Padding of fileline @@ -763,7 +763,7 @@ public: } }; -class EmitVPrefixedVisitor : public EmitVBaseVisitor { +class EmitVPrefixedVisitor final : public EmitVBaseVisitor { // MEMBERS EmitVPrefixedFormatter m_formatter; // Special verilog formatter (Way down the // inheritance is another unused V3OutFormatter) diff --git a/src/V3EmitV.h b/src/V3EmitV.h index 4a4900895..98f8b3cbb 100644 --- a/src/V3EmitV.h +++ b/src/V3EmitV.h @@ -25,7 +25,7 @@ //============================================================================ -class V3EmitV { +class V3EmitV final { public: static void verilogForTree(AstNode* nodep, std::ostream& os = std::cout); static void verilogPrefixedTree(AstNode* nodep, std::ostream& os, const string& prefix, diff --git a/src/V3EmitXml.cpp b/src/V3EmitXml.cpp index e607a8db8..b39a30f43 100644 --- a/src/V3EmitXml.cpp +++ b/src/V3EmitXml.cpp @@ -28,7 +28,7 @@ //###################################################################### // Emit statements and math operators -class EmitXmlFileVisitor : public AstNVisitor { +class EmitXmlFileVisitor final : public AstNVisitor { // NODE STATE // Entire netlist: // AstNode::user1 -> uint64_t, number to connect crossrefs @@ -256,7 +256,7 @@ public: //###################################################################### // List of module files xml visitor -class ModuleFilesXmlVisitor : public AstNVisitor { +class ModuleFilesXmlVisitor final : public AstNVisitor { private: // MEMBERS std::ostream& m_os; @@ -304,7 +304,7 @@ public: //###################################################################### // Hierarchy of Cells visitor -class HierCellsXmlVisitor : public AstNVisitor { +class HierCellsXmlVisitor final : public AstNVisitor { private: // MEMBERS std::ostream& m_os; diff --git a/src/V3EmitXml.h b/src/V3EmitXml.h index 14d1a3e9e..18555891f 100644 --- a/src/V3EmitXml.h +++ b/src/V3EmitXml.h @@ -25,7 +25,7 @@ //============================================================================ -class V3EmitXml { +class V3EmitXml final { public: static void emitxml(); }; diff --git a/src/V3Error.h b/src/V3Error.h index a895a9cdb..fcf166a75 100644 --- a/src/V3Error.h +++ b/src/V3Error.h @@ -33,7 +33,7 @@ //###################################################################### -class V3ErrorCode { +class V3ErrorCode final { public: // clang-format off enum en: uint8_t { @@ -217,7 +217,7 @@ inline std::ostream& operator<<(std::ostream& os, const V3ErrorCode& rhs) { //###################################################################### -class V3Error { +class V3Error final { // Base class for any object that wants debugging and error reporting typedef std::set MessagesSet; diff --git a/src/V3Expand.cpp b/src/V3Expand.cpp index 3bb2d2451..f594434b2 100644 --- a/src/V3Expand.cpp +++ b/src/V3Expand.cpp @@ -37,7 +37,7 @@ //###################################################################### // Expand state, as a visitor of each AstNode -class ExpandVisitor : public AstNVisitor { +class ExpandVisitor final : public AstNVisitor { private: // NODE STATE // AstNode::user1() -> bool. Processed diff --git a/src/V3Expand.h b/src/V3Expand.h index f0eb83608..7080ecbcd 100644 --- a/src/V3Expand.h +++ b/src/V3Expand.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Expand { +class V3Expand final { public: static void expandAll(AstNetlist* nodep); }; diff --git a/src/V3File.cpp b/src/V3File.cpp index 0d1fc5986..66f82abbb 100644 --- a/src/V3File.cpp +++ b/src/V3File.cpp @@ -62,9 +62,9 @@ constexpr int INFILTER_CACHE_MAX = (64 * 1024); // Maximum bytes to cache if sa //###################################################################### // V3File Internal state -class V3FileDependImp { +class V3FileDependImp final { // TYPES - class DependFile { + class DependFile final { // A single file bool m_target; // True if write, else read bool m_exists = true; @@ -327,7 +327,7 @@ void V3File::createMakeDir() { //###################################################################### // VInFilterImp -class VInFilterImp { +class VInFilterImp final { typedef std::map FileContentsMap; typedef VInFilter::StrList StrList; @@ -949,7 +949,7 @@ void V3OutCFile::putsGuard() { //###################################################################### // VIdProtect -class VIdProtectImp { +class VIdProtectImp final { // MEMBERS typedef std::map IdMap; IdMap m_nameMap; // Map of old name into new name diff --git a/src/V3File.h b/src/V3File.h index 5b841fe59..c4a176150 100644 --- a/src/V3File.h +++ b/src/V3File.h @@ -31,7 +31,7 @@ //============================================================================ // V3File: Create streams, recording dependency information -class V3File { +class V3File final { public: static std::ifstream* new_ifstream(const string& filename) { addSrcDepend(filename); @@ -76,7 +76,7 @@ public: class VInFilterImp; -class VInFilter { +class VInFilter final { public: // TYPES typedef std::list StrList; @@ -99,7 +99,7 @@ public: //============================================================================ // V3OutFormatter: A class for automatic indentation of C++ or Verilog code. -class V3OutFormatter { +class V3OutFormatter VL_NOT_FINAL { // TYPES static constexpr int MAXSPACE = 80; // After this indent, stop indenting more public: @@ -176,7 +176,7 @@ public: //============================================================================ // V3OutFile: A class for printing to a file, with automatic indentation of C++ code. -class V3OutFile : public V3OutFormatter { +class V3OutFile VL_NOT_FINAL : public V3OutFormatter { // MEMBERS FILE* m_fp; @@ -190,7 +190,7 @@ private: virtual void putcOutput(char chr) override { fputc(chr, m_fp); } }; -class V3OutCFile : public V3OutFile { +class V3OutCFile VL_NOT_FINAL : public V3OutFile { int m_guard = false; // Created header guard int m_private; // 1 = Most recently emitted private:, 2 = public: public: @@ -218,7 +218,7 @@ public: } }; -class V3OutScFile : public V3OutCFile { +class V3OutScFile final : public V3OutCFile { public: explicit V3OutScFile(const string& filename) : V3OutCFile{filename} {} @@ -231,7 +231,7 @@ public: } }; -class V3OutVFile : public V3OutFile { +class V3OutVFile final : public V3OutFile { public: explicit V3OutVFile(const string& filename) : V3OutFile{filename, V3OutFormatter::LA_VERILOG} {} @@ -239,7 +239,7 @@ public: virtual void putsHeader() { puts("// Verilated -*- Verilog -*-\n"); } }; -class V3OutXmlFile : public V3OutFile { +class V3OutXmlFile final : public V3OutFile { public: explicit V3OutXmlFile(const string& filename) : V3OutFile{filename, V3OutFormatter::LA_XML} { @@ -249,7 +249,7 @@ public: virtual void putsHeader() { puts("\n"); } }; -class V3OutMkFile : public V3OutFile { +class V3OutMkFile final : public V3OutFile { public: explicit V3OutMkFile(const string& filename) : V3OutFile{filename, V3OutFormatter::LA_MK} {} @@ -265,7 +265,7 @@ public: class VIdProtectImp; -class VIdProtect { +class VIdProtect final { public: // METHODS // Rename to a new encoded string (unless earlier passthru'ed) diff --git a/src/V3FileLine.h b/src/V3FileLine.h index 64adea8d4..0e992d311 100644 --- a/src/V3FileLine.h +++ b/src/V3FileLine.h @@ -37,7 +37,7 @@ class FileLine; //! This singleton class contains tables of data that are unchanging in each //! source file (each with its own unique filename number). -class FileLineSingleton { +class FileLineSingleton final { // TYPES typedef std::map FileNameNumMap; // MEMBERS @@ -64,7 +64,7 @@ protected: }; //! All source lines from a file/stream, to enable errors to show sources -class VFileContent { +class VFileContent final { // MEMBERS int m_id; // Content ID number std::deque m_lines; // Source text lines @@ -87,7 +87,7 @@ std::ostream& operator<<(std::ostream& os, VFileContent* contentp); //! This class is instantiated for every source code line (potentially //! millions). To save space, per-file information (e.g. filename, source //! language is held in tables in the FileLineSingleton class. -class FileLine { +class FileLine final { // CONSTANTS static constexpr unsigned SHOW_SOURCE_MAX_LENGTH = 400; // Don't show source lines > this long diff --git a/src/V3Gate.cpp b/src/V3Gate.cpp index 25b45e040..72aca1174 100644 --- a/src/V3Gate.cpp +++ b/src/V3Gate.cpp @@ -43,7 +43,7 @@ constexpr int GATE_DEDUP_MAX_DEPTH = 20; //###################################################################### -class GateBaseVisitor : public AstNVisitor { +class GateBaseVisitor VL_NOT_FINAL : public AstNVisitor { public: VL_DEBUG_FUNC; // Declare debug() }; @@ -52,7 +52,7 @@ public: class GateLogicVertex; class GateVarVertex; -class GateGraphBaseVisitor { +class GateGraphBaseVisitor VL_NOT_FINAL { public: V3Graph* m_graphp; // Graph this class is visiting explicit GateGraphBaseVisitor(V3Graph* graphp) @@ -66,7 +66,7 @@ public: //###################################################################### // Support classes -class GateEitherVertex : public V3GraphVertex { +class GateEitherVertex VL_NOT_FINAL : public V3GraphVertex { AstScope* m_scopep; // Scope vertex refers to bool m_reducible = true; // True if this node should be able to be eliminated bool m_dedupable = true; // True if this node should be able to be deduped @@ -123,7 +123,7 @@ public: } }; -class GateVarVertex : public GateEitherVertex { +class GateVarVertex final : public GateEitherVertex { AstVarScope* m_varScp; bool m_isTop = false; bool m_isClock = false; @@ -163,7 +163,7 @@ public: } }; -class GateLogicVertex : public GateEitherVertex { +class GateLogicVertex final : public GateEitherVertex { AstNode* m_nodep; AstActive* m_activep; // Under what active; nullptr is ok (under cfunc or such) bool m_slow; // In slow block @@ -192,7 +192,7 @@ public: //###################################################################### // Is this a simple math expression with a single input and single output? -class GateOkVisitor : public GateBaseVisitor { +class GateOkVisitor final : public GateBaseVisitor { private: // RETURN STATE bool m_isSimple = true; // Set false when we know it isn't simple @@ -301,7 +301,7 @@ public: //###################################################################### // Gate class functions -class GateVisitor : public GateBaseVisitor { +class GateVisitor final : public GateBaseVisitor { private: // NODE STATE // Entire netlist: @@ -826,7 +826,7 @@ void GateVisitor::warnSignals() { class GateDedupeVarVisitor; -class GateElimVisitor : public GateBaseVisitor { +class GateElimVisitor final : public GateBaseVisitor { private: // NODE STATE // STATE @@ -903,7 +903,7 @@ void GateVisitor::optimizeElimVar(AstVarScope* varscp, AstNode* substp, AstNode* //###################################################################### // Auxiliary hash class for GateDedupeVarVisitor -class GateDedupeHash : public V3HashedUserSame { +class GateDedupeHash final : public V3HashedUserSame { public: // TYPES typedef std::set NodeSet; @@ -1021,7 +1021,7 @@ public: //###################################################################### // Have we seen the rhs of this assign before? -class GateDedupeVarVisitor : public GateBaseVisitor { +class GateDedupeVarVisitor final : public GateBaseVisitor { // Given a node, it is visited to try to find the AstNodeAssign under // it that can used for dedupe. // Right now, only the following node trees are supported for dedupe. @@ -1121,7 +1121,7 @@ void GateElimVisitor::hashReplace(AstNode* oldp, AstNode* newp) { //###################################################################### // Recurse through the graph, looking for duplicate expressions on the rhs of an assign -class GateDedupeGraphVisitor : public GateGraphBaseVisitor { +class GateDedupeGraphVisitor final : public GateGraphBaseVisitor { private: // NODE STATE // AstVarScope::user2p -> bool: already visited @@ -1248,7 +1248,7 @@ void GateVisitor::dedupe() { //###################################################################### // Recurse through the graph, try to merge assigns -class GateMergeAssignsGraphVisitor : public GateGraphBaseVisitor { +class GateMergeAssignsGraphVisitor final : public GateGraphBaseVisitor { private: // NODE STATE AstNodeAssign* m_assignp = nullptr; @@ -1378,7 +1378,7 @@ void GateVisitor::mergeAssigns() { //###################################################################### // Find a var's offset in a concatenation -class GateConcatVisitor : public GateBaseVisitor { +class GateConcatVisitor final : public GateBaseVisitor { private: // STATE AstVarScope* m_vscp = nullptr; // Varscope we're trying to find @@ -1429,7 +1429,7 @@ public: //###################################################################### // Recurse through the graph, looking for clock vectors to bypass -class GateClkDecompState { +class GateClkDecompState final { public: int m_offset; AstVarScope* m_last_vsp; @@ -1439,7 +1439,7 @@ public: virtual ~GateClkDecompState() = default; }; -class GateClkDecompGraphVisitor : public GateGraphBaseVisitor { +class GateClkDecompGraphVisitor final : public GateGraphBaseVisitor { private: // NODE STATE // AstVarScope::user2p -> bool: already visited @@ -1571,7 +1571,7 @@ void GateVisitor::decomposeClkVectors() { //###################################################################### // Convert VARSCOPE(ASSIGN(default, VARREF)) to just VARSCOPE(default) -class GateDeassignVisitor : public GateBaseVisitor { +class GateDeassignVisitor final : public GateBaseVisitor { private: // VISITORS virtual void visit(AstVarScope* nodep) override { diff --git a/src/V3Gate.h b/src/V3Gate.h index 4248ce6f8..18ab97f16 100644 --- a/src/V3Gate.h +++ b/src/V3Gate.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Gate { +class V3Gate final { public: static void gateAll(AstNetlist* nodep); }; diff --git a/src/V3GenClk.cpp b/src/V3GenClk.cpp index 60ebff081..b8acc7430 100644 --- a/src/V3GenClk.cpp +++ b/src/V3GenClk.cpp @@ -29,7 +29,7 @@ //###################################################################### // GenClk state, as a visitor of each AstNode -class GenClkBaseVisitor : public AstNVisitor { +class GenClkBaseVisitor VL_NOT_FINAL : public AstNVisitor { protected: VL_DEBUG_FUNC; // Declare debug() }; @@ -37,7 +37,7 @@ protected: //###################################################################### // GenClk Read -class GenClkRenameVisitor : public GenClkBaseVisitor { +class GenClkRenameVisitor final : public GenClkBaseVisitor { private: // NODE STATE // Cleared on top scope @@ -127,7 +127,7 @@ public: //###################################################################### // GenClk Read -class GenClkReadVisitor : public GenClkBaseVisitor { +class GenClkReadVisitor final : public GenClkBaseVisitor { private: // NODE STATE // Cleared on top scope diff --git a/src/V3GenClk.h b/src/V3GenClk.h index 38d4c7ec6..850f0cec0 100644 --- a/src/V3GenClk.h +++ b/src/V3GenClk.h @@ -25,7 +25,7 @@ //============================================================================ -class V3GenClk { +class V3GenClk final { public: static void genClkAll(AstNetlist* nodep); }; diff --git a/src/V3Global.h b/src/V3Global.h index 41afa569d..3075092c4 100644 --- a/src/V3Global.h +++ b/src/V3Global.h @@ -61,7 +61,7 @@ public: //###################################################################### -class VWidthMinUsage { +class VWidthMinUsage final { public: enum en : uint8_t { LINT_WIDTH, MATCHES_WIDTH, VERILOG_WIDTH }; enum en m_e; @@ -87,7 +87,7 @@ inline bool operator==(VWidthMinUsage::en lhs, const VWidthMinUsage& rhs) { //###################################################################### // V3Global - The top level class for the entire program -class V3Global { +class V3Global final { // Globals AstNetlist* m_rootp; // Root of entire netlist V3HierBlockPlan* m_hierPlanp; // Hierarchical verilation plan, nullptr unless hier_block diff --git a/src/V3Graph.h b/src/V3Graph.h index d4dbab874..4ac788646 100644 --- a/src/V3Graph.h +++ b/src/V3Graph.h @@ -45,7 +45,7 @@ typedef bool (*V3EdgeFuncP)(const V3GraphEdge* edgep); // it's useful to have algorithms that can walk in either direction, hence // some methods take GraphWay to programmatically select the direction. -class GraphWay { +class GraphWay final { public: enum en : uint8_t { FORWARD = 0, @@ -77,7 +77,7 @@ inline bool operator==(GraphWay::en lhs, const GraphWay& rhs) { return lhs == rh //============================================================================ -class V3Graph { +class V3Graph VL_NOT_FINAL { private: // MEMBERS V3List m_vertices; // All vertices @@ -185,7 +185,7 @@ public: //============================================================================ -class V3GraphVertex { +class V3GraphVertex VL_NOT_FINAL { // Vertices may be a 'gate'/wire statement OR a variable protected: friend class V3Graph; @@ -273,7 +273,7 @@ std::ostream& operator<<(std::ostream& os, V3GraphVertex* vertexp); //============================================================================ -class V3GraphEdge { +class V3GraphEdge VL_NOT_FINAL { // Wires/variables aren't edges. Edges have only a single to/from vertex public: // ENUMS diff --git a/src/V3GraphAcyc.cpp b/src/V3GraphAcyc.cpp index dce97d011..5b38813c1 100644 --- a/src/V3GraphAcyc.cpp +++ b/src/V3GraphAcyc.cpp @@ -29,7 +29,7 @@ // Algorithms - acyclic // Break the minimal number of backward edges to make the graph acyclic -class GraphAcycVertex : public V3GraphVertex { +class GraphAcycVertex final : public V3GraphVertex { // user() is used for various sub-algorithm pieces V3GraphVertex* m_origVertexp; // Pointer to first vertex this represents protected: @@ -53,7 +53,7 @@ public: //-------------------------------------------------------------------- -class GraphAcycEdge : public V3GraphEdge { +class GraphAcycEdge final : public V3GraphEdge { // userp() is always used to point to the head original graph edge private: typedef std::list OrigEdgeList; // List of orig edges, see also GraphAcyc's decl @@ -87,7 +87,7 @@ struct GraphAcycEdgeCmp { //-------------------------------------------------------------------- // CLASSES -class GraphAcyc { +class GraphAcyc final { private: typedef std::list OrigEdgeList; // List of orig edges, see also GraphAcycEdge's decl diff --git a/src/V3GraphAlg.cpp b/src/V3GraphAlg.cpp index 218d050a3..929dbdcd9 100644 --- a/src/V3GraphAlg.cpp +++ b/src/V3GraphAlg.cpp @@ -69,7 +69,7 @@ void V3Graph::deleteCutableOnlyEdges() { //###################################################################### // Algorithms - weakly connected components -class GraphRemoveRedundant : GraphAlg<> { +class GraphRemoveRedundant final : GraphAlg<> { bool m_sumWeights; ///< Sum, rather then maximize weights private: void main() { @@ -137,7 +137,7 @@ void V3Graph::removeRedundantEdgesSum(V3EdgeFuncP edgeFuncp) { //###################################################################### // Algorithms - remove transitive -class GraphAlgRemoveTransitiveEdges : GraphAlg<> { +class GraphAlgRemoveTransitiveEdges final : GraphAlg<> { public: explicit GraphAlgRemoveTransitiveEdges(V3Graph* graphp) : GraphAlg<>(graphp, nullptr) {} @@ -168,7 +168,7 @@ void V3Graph::removeTransitiveEdges() { GraphAlgRemoveTransitiveEdges(this).go() //###################################################################### // Algorithms - weakly connected components -class GraphAlgWeakly : GraphAlg<> { +class GraphAlgWeakly final : GraphAlg<> { private: void main() { // Initialize state @@ -209,7 +209,7 @@ void V3Graph::weaklyConnected(V3EdgeFuncP edgeFuncp) { GraphAlgWeakly(this, edge //###################################################################### // Algorithms - strongly connected components -class GraphAlgStrongly : GraphAlg<> { +class GraphAlgStrongly final : GraphAlg<> { private: uint32_t m_currentDfs; // DFS count std::vector m_callTrace; // List of everything we hit processing so far @@ -297,7 +297,7 @@ void V3Graph::stronglyConnected(V3EdgeFuncP edgeFuncp) { GraphAlgStrongly(this, //###################################################################### // Algorithms - ranking -class GraphAlgRank : GraphAlg<> { +class GraphAlgRank final : GraphAlg<> { private: void main() { // Rank each vertex, ignoring cutable edges @@ -350,7 +350,7 @@ void V3Graph::rank(V3EdgeFuncP edgeFuncp) { GraphAlgRank(this, edgeFuncp); } //###################################################################### // Algorithms - ranking -class GraphAlgRLoops : GraphAlg<> { +class GraphAlgRLoops final : GraphAlg<> { private: std::vector m_callTrace; // List of everything we hit processing so far bool m_done; // Exit algorithm @@ -404,7 +404,7 @@ void V3Graph::reportLoops(V3EdgeFuncP edgeFuncp, V3GraphVertex* vertexp) { //###################################################################### // Algorithms - subtrees -class GraphAlgSubtrees : GraphAlg<> { +class GraphAlgSubtrees final : GraphAlg<> { private: V3Graph* m_loopGraphp; diff --git a/src/V3GraphAlg.h b/src/V3GraphAlg.h index 408e99c46..b25b785f8 100644 --- a/src/V3GraphAlg.h +++ b/src/V3GraphAlg.h @@ -28,7 +28,7 @@ // For internal use, most graph algorithms use this as a base class template // Or sometimes const V3Graph -class GraphAlg { +class GraphAlg VL_NOT_FINAL { protected: T_Graph* m_graphp; // Graph we're operating upon V3EdgeFuncP m_edgeFuncp; // Function that says we follow this edge diff --git a/src/V3GraphDfa.cpp b/src/V3GraphDfa.cpp index c114f8632..7669fa619 100644 --- a/src/V3GraphDfa.cpp +++ b/src/V3GraphDfa.cpp @@ -51,7 +51,7 @@ DfaVertex* DfaGraph::findStart() { // Algorithms - convert NFA to a DFA // Uses the Subset Construction Algorithm -class GraphNfaToDfa : GraphAlg<> { +class GraphNfaToDfa final : GraphAlg<> { // We have two types of nodes in one graph, NFA and DFA nodes. // Edges from NFA to NFA come from the user, and indicate input or epsilon transitions // Edges from DFA to NFA indicate the NFA from which that DFA was formed. @@ -379,7 +379,7 @@ void DfaGraph::nfaToDfa() { GraphNfaToDfa(this, &V3GraphEdge::followAlwaysTrue); // // Scan the DFA, cleaning up trailing states. -class DfaGraphReduce : GraphAlg<> { +class DfaGraphReduce final : GraphAlg<> { private: // METHODS #ifdef VL_CPPCHECK @@ -527,7 +527,7 @@ void DfaGraph::dfaReduce() { DfaGraphReduce(this, &V3GraphEdge::followAlwaysTrue // The user's old accept is now the new accept. This is important as // we want the virtual type of it to be intact. -class DfaGraphComplement : GraphAlg<> { +class DfaGraphComplement final : GraphAlg<> { private: // MEMBERS DfaVertex* m_tempNewerReject; diff --git a/src/V3GraphDfa.h b/src/V3GraphDfa.h index 027724506..3c726995d 100644 --- a/src/V3GraphDfa.h +++ b/src/V3GraphDfa.h @@ -58,7 +58,7 @@ class DfaEdge; /// | ^\----[epsilon]<-------/ | /// \->[epsilon]-----------------------------------------/ -class DfaGraph : public V3Graph { +class DfaGraph final : public V3Graph { public: // CONSTRUCTORS DfaGraph() = default; @@ -77,7 +77,7 @@ public: //============================================================================= // Vertex -class DfaVertex : public V3GraphVertex { +class DfaVertex VL_NOT_FINAL : public V3GraphVertex { // Each DFA state is captured in this vertex. // Start and accepting are members, rather than the more intuitive // subclasses, as subclassing them would make it harder to inherit from here. @@ -113,7 +113,7 @@ typedef VNUser DfaInput; //============================================================================ // Edge types -class DfaEdge : public V3GraphEdge { +class DfaEdge final : public V3GraphEdge { DfaInput m_input; bool m_complement; // Invert value when doing compare public: diff --git a/src/V3GraphPathChecker.h b/src/V3GraphPathChecker.h index b32e360c1..104aa719d 100644 --- a/src/V3GraphPathChecker.h +++ b/src/V3GraphPathChecker.h @@ -29,7 +29,7 @@ /// /// The graph (or at least, the subset the algorithm sees through /// edgeFuncp) must not change during the lifetime of the checker. -class GraphPathChecker : GraphAlg { +class GraphPathChecker final : GraphAlg { // Count "generations" which increases on operations that scan through // the graph. Each node is marked with the last generation that scanned // it, to enable asserting there are no cycles, and to avoid recursing diff --git a/src/V3GraphStream.h b/src/V3GraphStream.h index d8a44a472..cc53b9e9d 100644 --- a/src/V3GraphStream.h +++ b/src/V3GraphStream.h @@ -40,7 +40,7 @@ template class GraphStream { private: // TYPES - class VxHolder { + class VxHolder final { public: // MEMBERS const V3GraphVertex* m_vxp; // [mtask] Vertex @@ -62,7 +62,7 @@ private: } }; - class VxHolderCmp { + class VxHolderCmp final { public: // MEMBERS T_Compare m_lessThan; // Sorting functor diff --git a/src/V3GraphTest.cpp b/src/V3GraphTest.cpp index ba12e0284..67340c5ec 100644 --- a/src/V3GraphTest.cpp +++ b/src/V3GraphTest.cpp @@ -25,7 +25,7 @@ //###################################################################### // Test class -class V3GraphTest { +class V3GraphTest VL_NOT_FINAL { protected: // MEMBERS DfaGraph m_graph; @@ -50,7 +50,7 @@ public: //###################################################################### // Vertices and nodes -class V3GraphTestVertex : public V3GraphVertex { +class V3GraphTestVertex VL_NOT_FINAL : public V3GraphVertex { string m_name; public: @@ -62,7 +62,7 @@ public: virtual string name() const override { return m_name; } }; -class V3GraphTestVarVertex : public V3GraphTestVertex { +class V3GraphTestVarVertex final : public V3GraphTestVertex { public: V3GraphTestVarVertex(V3Graph* graphp, const string& name) : V3GraphTestVertex{graphp, name} {} @@ -75,7 +75,7 @@ public: //###################################################################### // Test vertices and nodes -class V3GraphTestStrong : public V3GraphTest { +class V3GraphTestStrong final : public V3GraphTest { public: virtual string name() override { return "strong"; } virtual void runTest() override { @@ -113,7 +113,7 @@ public: } }; -class V3GraphTestAcyc : public V3GraphTest { +class V3GraphTestAcyc final : public V3GraphTest { public: virtual string name() override { return "acyc"; } virtual void runTest() override { @@ -141,7 +141,7 @@ public: } }; -class V3GraphTestVars : public V3GraphTest { +class V3GraphTestVars final : public V3GraphTest { public: virtual string name() override { return "vars"; } virtual void runTest() override { @@ -260,7 +260,7 @@ public: //====================================================================== -class DfaTestVertex : public DfaVertex { +class DfaTestVertex final : public DfaVertex { string m_name; public: @@ -272,7 +272,7 @@ public: virtual string name() const override { return m_name; } }; -class V3GraphTestDfa : public V3GraphTest { +class V3GraphTestDfa final : public V3GraphTest { public: virtual string name() override { return "dfa"; } @@ -321,7 +321,7 @@ public: //====================================================================== -class V3GraphTestImport : public V3GraphTest { +class V3GraphTestImport final : public V3GraphTest { #ifdef GRAPH_IMPORT void dotImport(); diff --git a/src/V3Hashed.cpp b/src/V3Hashed.cpp index a9600f699..459bed724 100644 --- a/src/V3Hashed.cpp +++ b/src/V3Hashed.cpp @@ -37,7 +37,7 @@ //###################################################################### // Hashed state, as a visitor of each AstNode -class HashedVisitor : public AstNVisitor { +class HashedVisitor final : public AstNVisitor { private: // NODE STATE // Entire netlist: diff --git a/src/V3Hashed.h b/src/V3Hashed.h index 0f8afbac1..e8d7b6fdc 100644 --- a/src/V3Hashed.h +++ b/src/V3Hashed.h @@ -24,7 +24,7 @@ //============================================================================ -class VHashedBase { +class VHashedBase VL_NOT_FINAL { public: // CONSTRUCTORS VHashedBase() = default; @@ -43,7 +43,7 @@ struct V3HashedUserSame { virtual ~V3HashedUserSame() = default; }; -class V3Hashed : public VHashedBase { +class V3Hashed final : public VHashedBase { // NODE STATE // AstNode::user4() -> V3Hash. Hash value of this node (hash of 0 is illegal) AstUser4InUse m_inuser4; diff --git a/src/V3HierBlock.cpp b/src/V3HierBlock.cpp index 198877007..be21161e2 100644 --- a/src/V3HierBlock.cpp +++ b/src/V3HierBlock.cpp @@ -234,7 +234,7 @@ string V3HierBlock::commandArgsFileName(bool forCMake) const { //###################################################################### // Collect how hierarchical blocks are used -class HierBlockUsageCollectVisitor : public AstNVisitor { +class HierBlockUsageCollectVisitor final : public AstNVisitor { // NODE STATE // AstNode::user1() -> bool. Processed AstUser1InUse m_inuser1; diff --git a/src/V3HierBlock.h b/src/V3HierBlock.h index 81e0603ae..e5409d1fd 100644 --- a/src/V3HierBlock.h +++ b/src/V3HierBlock.h @@ -37,7 +37,7 @@ class AstVar; //###################################################################### -class V3HierBlock { +class V3HierBlock final { public: typedef std::vector GParams; typedef std::set HierBlockSet; @@ -95,7 +95,7 @@ public: //###################################################################### // Holds relashonship between AstNodeModule and V3HierBlock -class V3HierBlockPlan { +class V3HierBlockPlan final { typedef std::map HierMap; HierMap m_blocks; diff --git a/src/V3Inline.cpp b/src/V3Inline.cpp index f66f2a0f8..681d123ef 100644 --- a/src/V3Inline.cpp +++ b/src/V3Inline.cpp @@ -44,7 +44,7 @@ static const int INLINE_MODS_SMALLER = 100; // If a mod is < this # nodes, can //###################################################################### // Inline state, as a visitor of each AstNode -class InlineMarkVisitor : public AstNVisitor { +class InlineMarkVisitor final : public AstNVisitor { private: // NODE STATE // Output @@ -233,7 +233,7 @@ public: // Using clonep(), find cell cross references. // clone() must not be called inside this visitor -class InlineCollectVisitor : public AstNVisitor { +class InlineCollectVisitor final : public AstNVisitor { private: // NODE STATE // Output: @@ -260,7 +260,7 @@ public: //###################################################################### // After cell is cloned, relink the new module's contents -class InlineRelinkVisitor : public AstNVisitor { +class InlineRelinkVisitor final : public AstNVisitor { private: typedef std::unordered_set StringSet; @@ -480,7 +480,7 @@ public: //###################################################################### // Inline state, as a visitor of each AstNode -class InlineVisitor : public AstNVisitor { +class InlineVisitor final : public AstNVisitor { private: // NODE STATE // Cleared entire netlist @@ -621,7 +621,7 @@ public: //###################################################################### // Track interface references under the Cell they reference -class InlineIntfRefVisitor : public AstNVisitor { +class InlineIntfRefVisitor final : public AstNVisitor { private: // NODE STATE // AstVar::user1p() // AstCell which this Var points to diff --git a/src/V3Inline.h b/src/V3Inline.h index a45cfbe1a..dd5b591f7 100644 --- a/src/V3Inline.h +++ b/src/V3Inline.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Inline { +class V3Inline final { public: static void inlineAll(AstNetlist* nodep); }; diff --git a/src/V3Inst.cpp b/src/V3Inst.cpp index 022388977..4ef17a730 100644 --- a/src/V3Inst.cpp +++ b/src/V3Inst.cpp @@ -34,7 +34,7 @@ //###################################################################### // Inst state, as a visitor of each AstNode -class InstVisitor : public AstNVisitor { +class InstVisitor final : public AstNVisitor { private: // NODE STATE // Cleared each Cell: @@ -137,7 +137,7 @@ public: //###################################################################### -class InstDeModVarVisitor : public AstNVisitor { +class InstDeModVarVisitor final : public AstNVisitor { // Expand all module variables, and save names for later reference private: // STATE @@ -189,7 +189,7 @@ public: //###################################################################### -class InstDeVisitor : public AstNVisitor { +class InstDeVisitor final : public AstNVisitor { // Find all cells with arrays, and convert to non-arrayed private: // STATE @@ -472,7 +472,7 @@ public: //###################################################################### // Inst static function -class InstStatic { +class InstStatic final { private: VL_DEBUG_FUNC; // Declare debug() InstStatic() = default; // Static class diff --git a/src/V3Inst.h b/src/V3Inst.h index 7fa389256..5b68d0a31 100644 --- a/src/V3Inst.h +++ b/src/V3Inst.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Inst { +class V3Inst final { public: static void instAll(AstNetlist* nodep); static void dearrayAll(AstNetlist* nodep); diff --git a/src/V3InstrCount.cpp b/src/V3InstrCount.cpp index 894aceba4..5da14c211 100644 --- a/src/V3InstrCount.cpp +++ b/src/V3InstrCount.cpp @@ -29,7 +29,7 @@ /// we'll count instructions from either the 'if' or the 'else' branch, /// whichever is larger. We know we won't run both. -class InstrCountVisitor : public AstNVisitor { +class InstrCountVisitor final : public AstNVisitor { private: // NODE STATE // AstNode::user4() -> int. Path cost + 1, 0 means don't dump @@ -46,7 +46,7 @@ private: // TYPES // Little class to cleanly call startVisitBase/endVisitBase - class VisitBase { + class VisitBase final { private: // MEMBERS uint32_t m_savedCount; @@ -258,7 +258,7 @@ private: }; // Iterate the graph printing the critical path marked by previous visitation -class InstrCountDumpVisitor : public AstNVisitor { +class InstrCountDumpVisitor final : public AstNVisitor { private: // NODE STATE // AstNode::user4() -> int. Path cost, 0 means don't dump diff --git a/src/V3InstrCount.h b/src/V3InstrCount.h index 697a69cb6..8e3d109f1 100644 --- a/src/V3InstrCount.h +++ b/src/V3InstrCount.h @@ -23,7 +23,7 @@ class AstNode; -class V3InstrCount { +class V3InstrCount final { public: // Return the estimate count of instructions we'd incur while running // code in and under nodep. diff --git a/src/V3LangCode.h b/src/V3LangCode.h index e9eb7ae4e..cdb68b03e 100644 --- a/src/V3LangCode.h +++ b/src/V3LangCode.h @@ -28,7 +28,7 @@ //! Class for the different languages supported. //! A separate file, since used both in V3Options (globally) and FileLine 9per //! file). -class V3LangCode { +class V3LangCode final { public: enum en : uint8_t { L_ERROR, // Must be first. diff --git a/src/V3LanguageWords.h b/src/V3LanguageWords.h index 3764f2dce..37cc5bee9 100644 --- a/src/V3LanguageWords.h +++ b/src/V3LanguageWords.h @@ -24,7 +24,7 @@ //============================================================================ -class V3LanguageWords { +class V3LanguageWords final { // List of common reserved keywords private: typedef std::map KeywordMap; diff --git a/src/V3Life.cpp b/src/V3Life.cpp index 7663ca404..fc4708235 100644 --- a/src/V3Life.cpp +++ b/src/V3Life.cpp @@ -38,7 +38,7 @@ //###################################################################### // Structure for global state -class LifeState { +class LifeState final { // NODE STATE // See below AstUser1InUse m_inuser1; @@ -66,7 +66,7 @@ public: //###################################################################### // Structure for each variable encountered -class LifeVarEntry { +class LifeVarEntry final { // Last assignment to this varscope, nullptr if no longer relevant AstNodeAssign* m_assignp = nullptr; AstConst* m_constp = nullptr; // Known constant value @@ -116,7 +116,7 @@ public: //###################################################################### // Structure for all variables under a given meta-basic block -class LifeBlock { +class LifeBlock final { // NODE STATE // Cleared each AstIf: // AstVarScope::user1() -> int. Used in combining to detect duplicates @@ -268,7 +268,7 @@ public: //###################################################################### // Life state, as a visitor of each AstNode -class LifeVisitor : public AstNVisitor { +class LifeVisitor final : public AstNVisitor { private: // STATE LifeState* m_statep; // Current state @@ -450,7 +450,7 @@ public: //###################################################################### -class LifeTopVisitor : public AstNVisitor { +class LifeTopVisitor final : public AstNVisitor { // Visit all top nodes searching for functions that are entry points we want to start // finding code within. private: diff --git a/src/V3Life.h b/src/V3Life.h index 44a44f020..7e8141329 100644 --- a/src/V3Life.h +++ b/src/V3Life.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Life { +class V3Life final { public: static void lifeAll(AstNetlist* nodep); }; diff --git a/src/V3LifePost.cpp b/src/V3LifePost.cpp index a633af7ce..b3bc39795 100644 --- a/src/V3LifePost.cpp +++ b/src/V3LifePost.cpp @@ -40,7 +40,7 @@ //###################################################################### // LifePost class functions -class LifePostElimVisitor : public AstNVisitor { +class LifePostElimVisitor final : public AstNVisitor { private: bool m_tracingCall = false; // Iterating into a CCall to a CFunc @@ -128,7 +128,7 @@ struct LifePostLocation { //###################################################################### // LifePost delay elimination -class LifePostDlyVisitor : public AstNVisitor { +class LifePostDlyVisitor final : public AstNVisitor { private: // NODE STATE // Cleared on entire tree diff --git a/src/V3LifePost.h b/src/V3LifePost.h index 1aa9fae02..426270a70 100644 --- a/src/V3LifePost.h +++ b/src/V3LifePost.h @@ -25,7 +25,7 @@ //============================================================================ -class V3LifePost { +class V3LifePost final { public: static void lifepostAll(AstNetlist* nodep); }; diff --git a/src/V3LinkCells.cpp b/src/V3LinkCells.cpp index a5f8e78c7..b4dec71fa 100644 --- a/src/V3LinkCells.cpp +++ b/src/V3LinkCells.cpp @@ -41,14 +41,14 @@ //###################################################################### // Graph subclasses -class LinkCellsGraph : public V3Graph { +class LinkCellsGraph final : public V3Graph { public: LinkCellsGraph() = default; virtual ~LinkCellsGraph() override = default; virtual void loopsMessageCb(V3GraphVertex* vertexp) override; }; -class LinkCellsVertex : public V3GraphVertex { +class LinkCellsVertex final : public V3GraphVertex { AstNodeModule* m_modp; public: @@ -65,7 +65,7 @@ public: } }; -class LibraryVertex : public V3GraphVertex { +class LibraryVertex final : public V3GraphVertex { public: explicit LibraryVertex(V3Graph* graphp) : V3GraphVertex{graphp} {} @@ -91,7 +91,7 @@ void LinkCellsGraph::loopsMessageCb(V3GraphVertex* vertexp) { //###################################################################### // Link state, as a visitor of each AstNode -class LinkCellsVisitor : public AstNVisitor { +class LinkCellsVisitor final : public AstNVisitor { private: // NODE STATE // Entire netlist: diff --git a/src/V3LinkCells.h b/src/V3LinkCells.h index b79b94a01..c1cd4b817 100644 --- a/src/V3LinkCells.h +++ b/src/V3LinkCells.h @@ -28,7 +28,7 @@ class V3ParseSym; //============================================================================ -class V3LinkCells { +class V3LinkCells final { public: static void link(AstNetlist* nodep, VInFilter* filterp, V3ParseSym* parseSymp); }; diff --git a/src/V3LinkDot.cpp b/src/V3LinkDot.cpp index df155c683..d84b344db 100644 --- a/src/V3LinkDot.cpp +++ b/src/V3LinkDot.cpp @@ -78,25 +78,25 @@ //###################################################################### // Matcher classes (for suggestion matching) -class LinkNodeMatcherClass : public VNodeMatcher { +class LinkNodeMatcherClass final : public VNodeMatcher { public: virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Class); } }; -class LinkNodeMatcherFTask : public VNodeMatcher { +class LinkNodeMatcherFTask final : public VNodeMatcher { public: virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, NodeFTask); } }; -class LinkNodeMatcherModport : public VNodeMatcher { +class LinkNodeMatcherModport final : public VNodeMatcher { public: virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Modport); } }; -class LinkNodeMatcherVar : public VNodeMatcher { +class LinkNodeMatcherVar final : public VNodeMatcher { public: virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Var) || VN_IS(nodep, LambdaArgRef); } }; -class LinkNodeMatcherVarIO : public VNodeMatcher { +class LinkNodeMatcherVarIO final : public VNodeMatcher { public: virtual bool nodeMatch(const AstNode* nodep) const override { const AstVar* varp = VN_CAST_CONST(nodep, Var); @@ -104,7 +104,7 @@ public: return varp->isIO(); } }; -class LinkNodeMatcherVarParam : public VNodeMatcher { +class LinkNodeMatcherVarParam final : public VNodeMatcher { public: virtual bool nodeMatch(const AstNode* nodep) const override { const AstVar* varp = VN_CAST_CONST(nodep, Var); @@ -116,7 +116,7 @@ public: //###################################################################### // LinkDot state, as a visitor of each AstNode -class LinkDotState { +class LinkDotState final { private: // NODE STATE // Cleared on Netlist @@ -705,7 +705,7 @@ LinkDotState* LinkDotState::s_errorThisp = nullptr; //====================================================================== -class LinkDotFindVisitor : public AstNVisitor { +class LinkDotFindVisitor final : public AstNVisitor { // STATE LinkDotState* m_statep; // State to pass between visitors, including symbol table AstNodeModule* m_packagep = nullptr; // Current package @@ -1319,7 +1319,7 @@ public: //====================================================================== -class LinkDotParamVisitor : public AstNVisitor { +class LinkDotParamVisitor final : public AstNVisitor { private: // NODE STATE // Cleared on global @@ -1484,7 +1484,7 @@ public: //====================================================================== -class LinkDotScopeVisitor : public AstNVisitor { +class LinkDotScopeVisitor final : public AstNVisitor { // STATE LinkDotState* m_statep; // State to pass between visitors, including symbol table @@ -1643,7 +1643,7 @@ public: //====================================================================== // Iterate an interface to resolve modports -class LinkDotIfaceVisitor : public AstNVisitor { +class LinkDotIfaceVisitor final : public AstNVisitor { // STATE LinkDotState* m_statep; // State to pass between visitors, including symbol table VSymEnt* m_curSymp; // Symbol Entry for current table, where to lookup/insert @@ -1736,7 +1736,7 @@ void LinkDotState::computeIfaceModSyms() { //====================================================================== -class LinkDotResolveVisitor : public AstNVisitor { +class LinkDotResolveVisitor final : public AstNVisitor { private: // NODE STATE // Cleared on global diff --git a/src/V3LinkDot.h b/src/V3LinkDot.h index e0d829a01..026ba0e2b 100644 --- a/src/V3LinkDot.h +++ b/src/V3LinkDot.h @@ -27,7 +27,7 @@ enum VLinkDotStep : uint8_t { LDS_PRIMARY, LDS_PARAMED, LDS_ARRAYED, LDS_SCOPED }; -class V3LinkDot { +class V3LinkDot final { private: static int debug(); static void linkDotGuts(AstNetlist* rootp, VLinkDotStep step); diff --git a/src/V3LinkInc.cpp b/src/V3LinkInc.cpp index db1f00fa1..89ea48649 100644 --- a/src/V3LinkInc.cpp +++ b/src/V3LinkInc.cpp @@ -47,7 +47,7 @@ //###################################################################### -class LinkIncVisitor : public AstNVisitor { +class LinkIncVisitor final : public AstNVisitor { private: // TYPES enum InsertMode : uint8_t { diff --git a/src/V3LinkInc.h b/src/V3LinkInc.h index a1679e6d3..ebb9194e7 100644 --- a/src/V3LinkInc.h +++ b/src/V3LinkInc.h @@ -25,7 +25,7 @@ //============================================================================ -class V3LinkInc { +class V3LinkInc final { public: static void linkIncrements(AstNetlist* nodep); diff --git a/src/V3LinkJump.cpp b/src/V3LinkJump.cpp index a83387885..e4bbc3c0e 100644 --- a/src/V3LinkJump.cpp +++ b/src/V3LinkJump.cpp @@ -41,7 +41,7 @@ //###################################################################### -class LinkJumpVisitor : public AstNVisitor { +class LinkJumpVisitor final : public AstNVisitor { private: // TYPES typedef std::vector BlockStack; diff --git a/src/V3LinkJump.h b/src/V3LinkJump.h index fba121e9c..af1e88ba0 100644 --- a/src/V3LinkJump.h +++ b/src/V3LinkJump.h @@ -25,7 +25,7 @@ //============================================================================ -class V3LinkJump { +class V3LinkJump final { public: static void linkJump(AstNetlist* nodep); }; diff --git a/src/V3LinkLValue.cpp b/src/V3LinkLValue.cpp index 999950d8e..b1e365f10 100644 --- a/src/V3LinkLValue.cpp +++ b/src/V3LinkLValue.cpp @@ -30,7 +30,7 @@ //###################################################################### // Link state, as a visitor of each AstNode -class LinkLValueVisitor : public AstNVisitor { +class LinkLValueVisitor final : public AstNVisitor { private: // NODE STATE diff --git a/src/V3LinkLValue.h b/src/V3LinkLValue.h index 101e06514..1a534d649 100644 --- a/src/V3LinkLValue.h +++ b/src/V3LinkLValue.h @@ -25,7 +25,7 @@ //============================================================================ -class V3LinkLValue { +class V3LinkLValue final { public: static void linkLValue(AstNetlist* nodep); static void linkLValueSet(AstNode* nodep); diff --git a/src/V3LinkLevel.h b/src/V3LinkLevel.h index 4143efa4e..ca9a51a26 100644 --- a/src/V3LinkLevel.h +++ b/src/V3LinkLevel.h @@ -25,7 +25,7 @@ //============================================================================ -class V3LinkLevel { +class V3LinkLevel final { private: typedef std::vector ModVec; diff --git a/src/V3LinkParse.cpp b/src/V3LinkParse.cpp index 19c065d24..2dce23b64 100644 --- a/src/V3LinkParse.cpp +++ b/src/V3LinkParse.cpp @@ -34,7 +34,7 @@ //###################################################################### // Link state, as a visitor of each AstNode -class LinkParseVisitor : public AstNVisitor { +class LinkParseVisitor final : public AstNVisitor { private: // NODE STATE // Cleared on netlist diff --git a/src/V3LinkParse.h b/src/V3LinkParse.h index 10425842c..bd600daab 100644 --- a/src/V3LinkParse.h +++ b/src/V3LinkParse.h @@ -25,7 +25,7 @@ //============================================================================ -class V3LinkParse { +class V3LinkParse final { public: static void linkParse(AstNetlist* rootp); }; diff --git a/src/V3LinkResolve.cpp b/src/V3LinkResolve.cpp index eccb7318a..8734e2532 100644 --- a/src/V3LinkResolve.cpp +++ b/src/V3LinkResolve.cpp @@ -38,7 +38,7 @@ //###################################################################### // Link state, as a visitor of each AstNode -class LinkResolveVisitor : public AstNVisitor { +class LinkResolveVisitor final : public AstNVisitor { private: // NODE STATE // Entire netlist: @@ -525,7 +525,7 @@ public: // Recurses cells backwards, so we can pick up those things that propagate // from child cells up to the top module. -class LinkBotupVisitor : public AstNVisitor { +class LinkBotupVisitor final : public AstNVisitor { private: // STATE AstNodeModule* m_modp = nullptr; // Current module diff --git a/src/V3LinkResolve.h b/src/V3LinkResolve.h index f33ff91d7..a998c0500 100644 --- a/src/V3LinkResolve.h +++ b/src/V3LinkResolve.h @@ -25,7 +25,7 @@ //============================================================================ -class V3LinkResolve { +class V3LinkResolve final { public: static void linkResolve(AstNetlist* rootp); }; diff --git a/src/V3Localize.cpp b/src/V3Localize.cpp index 6ac5830f1..565bddae5 100644 --- a/src/V3Localize.cpp +++ b/src/V3Localize.cpp @@ -35,7 +35,7 @@ //###################################################################### // Localize base class -class LocalizeBaseVisitor : public AstNVisitor { +class LocalizeBaseVisitor VL_NOT_FINAL : public AstNVisitor { protected: // NODE STATE // Cleared on entire tree @@ -66,7 +66,7 @@ protected: //###################################################################### // Localize class functions -class LocalizeDehierVisitor : public LocalizeBaseVisitor { +class LocalizeDehierVisitor final : public LocalizeBaseVisitor { private: // NODE STATE/TYPES // See above @@ -91,7 +91,7 @@ public: //###################################################################### // Localize class functions -class LocalizeVisitor : public LocalizeBaseVisitor { +class LocalizeVisitor final : public LocalizeBaseVisitor { private: // NODE STATE/TYPES // See above diff --git a/src/V3Localize.h b/src/V3Localize.h index 8fdf5fe5c..3db73dec4 100644 --- a/src/V3Localize.h +++ b/src/V3Localize.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Localize { +class V3Localize final { public: static void localizeAll(AstNetlist* nodep); }; diff --git a/src/V3MergeCond.cpp b/src/V3MergeCond.cpp index 967c715d3..73742a3be 100644 --- a/src/V3MergeCond.cpp +++ b/src/V3MergeCond.cpp @@ -52,7 +52,7 @@ //###################################################################### -class CheckMergeableVisitor : public AstNVisitor { +class CheckMergeableVisitor final : public AstNVisitor { private: // STATE bool m_mergeable @@ -98,7 +98,7 @@ public: } }; -class MarkVarsVisitor : public AstNVisitor { +class MarkVarsVisitor final : public AstNVisitor { private: // METHODS VL_DEBUG_FUNC; // Declare debug() @@ -115,7 +115,7 @@ public: void mark(AstNode* node) { iterate(node); } }; -class MergeCondVisitor : public AstNVisitor { +class MergeCondVisitor final : public AstNVisitor { private: // NODE STATE // AstVar::user1 -> Flag set for variables referenced by m_mgCondp diff --git a/src/V3MergeCond.h b/src/V3MergeCond.h index 52232bd0b..3366963e7 100644 --- a/src/V3MergeCond.h +++ b/src/V3MergeCond.h @@ -25,7 +25,7 @@ //============================================================================ -class V3MergeCond { +class V3MergeCond final { public: static void mergeAll(AstNetlist* nodep); }; diff --git a/src/V3Name.cpp b/src/V3Name.cpp index 1ac76a283..9c3c745dc 100644 --- a/src/V3Name.cpp +++ b/src/V3Name.cpp @@ -30,7 +30,7 @@ //###################################################################### // Name state, as a visitor of each AstNode -class NameVisitor : public AstNVisitor { +class NameVisitor final : public AstNVisitor { private: // NODE STATE // Cleared on Netlist diff --git a/src/V3Name.h b/src/V3Name.h index e998b5eb7..526858787 100644 --- a/src/V3Name.h +++ b/src/V3Name.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Name { +class V3Name final { public: static void nameAll(AstNetlist* nodep); }; diff --git a/src/V3Number.h b/src/V3Number.h index e19f4a767..4433bae29 100644 --- a/src/V3Number.h +++ b/src/V3Number.h @@ -37,7 +37,7 @@ inline bool v3EpsilonEqual(double a, double b) { class AstNode; -class V3Number { +class V3Number final { // Large 4-state number handling int m_width; // Width as specified/calculated. bool m_sized : 1; // True if the user specified the width, else we track it. diff --git a/src/V3Options.cpp b/src/V3Options.cpp index b388d8394..d0bae2ff4 100644 --- a/src/V3Options.cpp +++ b/src/V3Options.cpp @@ -50,7 +50,7 @@ //###################################################################### // V3 Internal state -class V3OptionsImp { +class V3OptionsImp final { public: // TYPES typedef std::map> DirMap; // Directory listing diff --git a/src/V3Options.h b/src/V3Options.h index da8bc0eb2..1c5b05ad5 100644 --- a/src/V3Options.h +++ b/src/V3Options.h @@ -33,7 +33,7 @@ class FileLine; //###################################################################### -class VOptionBool { +class VOptionBool final { // Class to track options that are either not specified (and default // true/false), versus user setting the option to true or false public: @@ -69,7 +69,7 @@ inline std::ostream& operator<<(std::ostream& os, const VOptionBool& rhs) { //###################################################################### -class VTimescale { +class VTimescale final { public: enum en : uint8_t { // clang-format off @@ -167,7 +167,7 @@ inline std::ostream& operator<<(std::ostream& os, const VTimescale& rhs) { //###################################################################### -class TraceFormat { +class TraceFormat final { public: enum en : uint8_t { VCD = 0, FST } m_e; // cppcheck-suppress noExplicitConstructor @@ -198,7 +198,7 @@ typedef std::set V3StringSet; //###################################################################### // Information given by --hierarchical-block option -class V3HierarchicalBlockOption { +class V3HierarchicalBlockOption final { public: // key:parameter name, value:value (as string) typedef std::map ParamStrMap; @@ -223,7 +223,7 @@ typedef std::map V3HierBlockOptSet; //###################################################################### // V3Options - Command line options -class V3Options { +class V3Options final { public: private: // TYPES diff --git a/src/V3Order.cpp b/src/V3Order.cpp index 7653e7054..6d734e123 100644 --- a/src/V3Order.cpp +++ b/src/V3Order.cpp @@ -126,7 +126,7 @@ void OrderGraph::loopsVertexCb(V3GraphVertex* vertexp) { //###################################################################### -class OrderMoveDomScope { +class OrderMoveDomScope final { // Information stored for each unique loop, domain & scope trifecta public: V3ListEnt m_readyDomScopeE; // List of next ready dom scope @@ -186,7 +186,7 @@ inline std::ostream& operator<<(std::ostream& lhs, const OrderMoveDomScope& rhs) // Types of vertex we can create enum WhichVertex : uint8_t { WV_STD, WV_PRE, WV_PORD, WV_POST, WV_SETL, WV_MAX }; -class OrderUser { +class OrderUser final { // Stored in AstVarScope::user1p, a list of all the various vertices // that can exist for one given variable private: @@ -252,7 +252,7 @@ struct OrderVarFanoutCmp { // In addition it also check whether clock and data signals are mixed, and // produce a CLKDATA warning if so. // -class OrderClkMarkVisitor : public AstNVisitor { +class OrderClkMarkVisitor final : public AstNVisitor { private: bool m_hasClk = false; // flag indicating whether there is clock signal on rhs bool m_inClocked = false; // Currently inside a sequential block @@ -372,7 +372,7 @@ public: //###################################################################### // The class checks if the assignment generates a clock. -class OrderClkAssVisitor : public AstNVisitor { +class OrderClkAssVisitor final : public AstNVisitor { private: bool m_clkAss = false; // There is signals marked as clocker in the assignment // METHODS @@ -429,7 +429,7 @@ template class ProcessMoveBuildGraph { typedef std::unordered_map Logic2Move; public: - class MoveVertexMaker { + class MoveVertexMaker VL_NOT_FINAL { public: // Clients of ProcessMoveBuildGraph must supply MoveVertexMaker // which creates new T_MoveVertex's. Each new vertex wraps lvertexp @@ -551,7 +551,7 @@ private: //###################################################################### // OrderMoveVertexMaker and related -class OrderMoveVertexMaker : public ProcessMoveBuildGraph::MoveVertexMaker { +class OrderMoveVertexMaker final : public ProcessMoveBuildGraph::MoveVertexMaker { // MEMBERS V3Graph* m_pomGraphp; V3List* m_pomWaitingp; @@ -579,7 +579,8 @@ private: VL_UNCOPYABLE(OrderMoveVertexMaker); }; -class OrderMTaskMoveVertexMaker : public ProcessMoveBuildGraph::MoveVertexMaker { +class OrderMTaskMoveVertexMaker final + : public ProcessMoveBuildGraph::MoveVertexMaker { V3Graph* m_pomGraphp; public: @@ -602,7 +603,7 @@ private: VL_UNCOPYABLE(OrderMTaskMoveVertexMaker); }; -class OrderVerticesByDomainThenScope { +class OrderVerticesByDomainThenScope final { PartPtrIdMap m_ids; public: @@ -619,7 +620,7 @@ public: } }; -class MTaskVxIdLessThan { +class MTaskVxIdLessThan final { public: MTaskVxIdLessThan() = default; virtual ~MTaskVxIdLessThan() = default; @@ -636,7 +637,7 @@ public: //###################################################################### // Order class functions -class OrderVisitor : public AstNVisitor { +class OrderVisitor final : public AstNVisitor { private: // NODE STATE // Forming graph: diff --git a/src/V3Order.h b/src/V3Order.h index 92be224f0..35c04cc57 100644 --- a/src/V3Order.h +++ b/src/V3Order.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Order { +class V3Order final { public: static void orderAll(AstNetlist* nodep); }; diff --git a/src/V3OrderGraph.h b/src/V3OrderGraph.h index 9ff15d083..579ea70bb 100644 --- a/src/V3OrderGraph.h +++ b/src/V3OrderGraph.h @@ -110,7 +110,7 @@ inline bool operator==(OrderVEdgeType::en lhs, const OrderVEdgeType& rhs) { //###################################################################### // Graph types -class OrderGraph : public V3Graph { +class OrderGraph final : public V3Graph { public: OrderGraph() = default; virtual ~OrderGraph() override = default; @@ -121,7 +121,7 @@ public: //###################################################################### // Vertex types -class OrderEitherVertex : public V3GraphVertex { +class OrderEitherVertex VL_NOT_FINAL : public V3GraphVertex { AstScope* m_scopep; // Scope the vertex is in AstSenTree* m_domainp; // Clock domain (nullptr = to be computed as we iterate) bool m_isFromInput = false; // From input, or derived therefrom (conservatively false) @@ -151,7 +151,7 @@ public: bool isFromInput() const { return m_isFromInput; } }; -class OrderInputsVertex : public OrderEitherVertex { +class OrderInputsVertex final : public OrderEitherVertex { OrderInputsVertex(V3Graph* graphp, const OrderInputsVertex& old) : OrderEitherVertex{graphp, old} {} @@ -171,7 +171,7 @@ public: virtual bool domainMatters() override { return false; } }; -class OrderLogicVertex : public OrderEitherVertex { +class OrderLogicVertex final : public OrderEitherVertex { AstNode* m_nodep; protected: @@ -197,7 +197,7 @@ public: virtual string dotColor() const override { return "yellow"; } }; -class OrderVarVertex : public OrderEitherVertex { +class OrderVarVertex VL_NOT_FINAL : public OrderEitherVertex { AstVarScope* m_varScp; bool m_isClock = false; // Used as clock bool m_isDelayed = false; // Set in a delayed assignment @@ -224,7 +224,7 @@ public: bool isDelayed() const { return m_isDelayed; } }; -class OrderVarStdVertex : public OrderVarVertex { +class OrderVarStdVertex final : public OrderVarVertex { OrderVarStdVertex(V3Graph* graphp, const OrderVarStdVertex& old) : OrderVarVertex{graphp, old} {} @@ -242,7 +242,7 @@ public: virtual string dotColor() const override { return "skyblue"; } virtual bool domainMatters() override { return true; } }; -class OrderVarPreVertex : public OrderVarVertex { +class OrderVarPreVertex final : public OrderVarVertex { OrderVarPreVertex(V3Graph* graphp, const OrderVarPreVertex& old) : OrderVarVertex{graphp, old} {} @@ -260,7 +260,7 @@ public: virtual string dotColor() const override { return "lightblue"; } virtual bool domainMatters() override { return false; } }; -class OrderVarPostVertex : public OrderVarVertex { +class OrderVarPostVertex final : public OrderVarVertex { OrderVarPostVertex(V3Graph* graphp, const OrderVarPostVertex& old) : OrderVarVertex{graphp, old} {} @@ -278,7 +278,7 @@ public: virtual string dotColor() const override { return "CadetBlue"; } virtual bool domainMatters() override { return false; } }; -class OrderVarPordVertex : public OrderVarVertex { +class OrderVarPordVertex final : public OrderVarVertex { OrderVarPordVertex(V3Graph* graphp, const OrderVarPordVertex& old) : OrderVarVertex{graphp, old} {} @@ -296,7 +296,7 @@ public: virtual string dotColor() const override { return "NavyBlue"; } virtual bool domainMatters() override { return false; } }; -class OrderVarSettleVertex : public OrderVarVertex { +class OrderVarSettleVertex final : public OrderVarVertex { OrderVarSettleVertex(V3Graph* graphp, const OrderVarSettleVertex& old) : OrderVarVertex{graphp, old} {} @@ -318,7 +318,7 @@ public: //###################################################################### //--- Following only under the move graph, not the main graph -class OrderMoveVertex : public V3GraphVertex { +class OrderMoveVertex final : public V3GraphVertex { typedef enum : uint8_t { POM_WAIT, POM_READY, POM_MOVED } OrderMState; OrderLogicVertex* m_logicp; @@ -387,7 +387,7 @@ public: }; // Similar to OrderMoveVertex, but modified for threaded code generation. -class MTaskMoveVertex : public V3GraphVertex { +class MTaskMoveVertex final : public V3GraphVertex { // This could be more compact, since we know m_varp and m_logicp // cannot both be set. Each MTaskMoveVertex represents a logic node // or a var node, it can't be both. @@ -445,7 +445,7 @@ public: //###################################################################### // Edge types -class OrderEdge : public V3GraphEdge { +class OrderEdge VL_NOT_FINAL : public V3GraphEdge { protected: OrderEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top, const OrderEdge& old) : V3GraphEdge{graphp, fromp, top, old} {} @@ -470,7 +470,7 @@ public: } }; -class OrderComboCutEdge : public OrderEdge { +class OrderComboCutEdge final : public OrderEdge { // Edge created from output of combo logic // Breakable if the output var is also a input, // in which case we'll need a change detect loop around this var. @@ -491,7 +491,7 @@ public: virtual bool followComboConnected() const override { return true; } }; -class OrderPostCutEdge : public OrderEdge { +class OrderPostCutEdge final : public OrderEdge { // Edge created from output of post assignment // Breakable if the output var feeds back to input combo logic or another clock pin // in which case we'll need a change detect loop around this var. @@ -512,7 +512,7 @@ public: virtual bool followComboConnected() const override { return false; } }; -class OrderPreCutEdge : public OrderEdge { +class OrderPreCutEdge final : public OrderEdge { // Edge created from var_PREVAR->consuming logic vertex // Always breakable, just results in performance loss // in which case we can't optimize away the pre/post delayed assignments diff --git a/src/V3Os.h b/src/V3Os.h index 21fa583b9..a1eef9b86 100644 --- a/src/V3Os.h +++ b/src/V3Os.h @@ -28,7 +28,7 @@ //============================================================================ // V3Os: OS static class -class V3Os { +class V3Os final { public: // METHODS (environment) static string getenvStr(const string& envvar, const string& defaultValue); diff --git a/src/V3Param.cpp b/src/V3Param.cpp index a73845d39..6c491ae5e 100644 --- a/src/V3Param.cpp +++ b/src/V3Param.cpp @@ -65,7 +65,7 @@ //###################################################################### // Hierarchical block and parameter db (modules without parameter is also handled) -class ParameterizedHierBlocks { +class ParameterizedHierBlocks final { typedef std::multimap HierBlockOptsByOrigName; typedef HierBlockOptsByOrigName::const_iterator HierMapIt; typedef std::map HierBlockModMap; @@ -197,7 +197,7 @@ public: //###################################################################### // Param state, as a visitor of each AstNode -class ParamVisitor : public AstNVisitor { +class ParamVisitor final : public AstNVisitor { private: // NODE STATE // AstNodeModule::user5() // bool True if processed diff --git a/src/V3Param.h b/src/V3Param.h index a2354de03..750e4177c 100644 --- a/src/V3Param.h +++ b/src/V3Param.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Param { +class V3Param final { public: static void param(AstNetlist* rootp); }; diff --git a/src/V3Parse.h b/src/V3Parse.h index 47bb0206e..198af1757 100644 --- a/src/V3Parse.h +++ b/src/V3Parse.h @@ -30,7 +30,7 @@ class V3ParseSym; //============================================================================ -class V3Parse { +class V3Parse final { private: V3ParseImp* m_impp; diff --git a/src/V3ParseImp.h b/src/V3ParseImp.h index c460ee22a..ee58a7eeb 100644 --- a/src/V3ParseImp.h +++ b/src/V3ParseImp.h @@ -156,7 +156,7 @@ std::ostream& operator<<(std::ostream& os, const V3ParseBisonYYSType& rhs); //###################################################################### -class V3ParseImp { +class V3ParseImp final { // MEMBERS AstNetlist* m_rootp; // Root of the design VInFilter* m_filterp; // Reading filter diff --git a/src/V3ParseLex.cpp b/src/V3ParseLex.cpp index 709f2fe96..04bfa9b90 100644 --- a/src/V3ParseLex.cpp +++ b/src/V3ParseLex.cpp @@ -32,7 +32,7 @@ // Lex-derived class /// Override the base lexer class so we can add some access functions -class V3Lexer : public V3LexerBase { +class V3Lexer final : public V3LexerBase { public: // CONSTRUCTORS V3Lexer() diff --git a/src/V3ParseSym.h b/src/V3ParseSym.h index 60a829ace..42045f273 100644 --- a/src/V3ParseSym.h +++ b/src/V3ParseSym.h @@ -30,7 +30,7 @@ //###################################################################### // Symbol table for parsing -class V3ParseSym { +class V3ParseSym final { // TYPES typedef std::vector SymStack; diff --git a/src/V3Partition.cpp b/src/V3Partition.cpp index b927ad644..78ee3e236 100644 --- a/src/V3Partition.cpp +++ b/src/V3Partition.cpp @@ -243,7 +243,7 @@ private: VL_UNCOPYABLE(PartPropagateCp); }; -class PartPropagateCpSelfTest { +class PartPropagateCpSelfTest final { private: // MEMBERS V3Graph m_graph; // A graph @@ -350,7 +350,7 @@ public: //###################################################################### // LogicMTask -class LogicMTask : public AbstractLogicMTask { +class LogicMTask final : public AbstractLogicMTask { public: // TYPES typedef std::list VxList; @@ -366,7 +366,7 @@ public: // - PartPropagateCp can thus be declared before LogicMTask // - PartPropagateCp could be reused with graphs of other node types // in the future, using another Accessor adaptor. - class CpCostAccessor { + class CpCostAccessor final { public: CpCostAccessor() = default; ~CpCostAccessor() = default; @@ -690,7 +690,7 @@ private: // Sort AbstractMTask objects into deterministic order by calling id() // which is a unique and stable serial number. -class MTaskIdLessThan { +class MTaskIdLessThan final { public: MTaskIdLessThan() = default; virtual ~MTaskIdLessThan() = default; @@ -700,7 +700,7 @@ public: }; // Information associated with scoreboarding an MTask -class MergeCandidate { +class MergeCandidate VL_NOT_FINAL { private: bool m_removedFromSb = false; // Not on scoreboard, generally ignore vluint64_t m_id; // Serial number for ordering @@ -720,7 +720,7 @@ public: // A pair of associated LogicMTask's that are merge candidates for sibling // contraction -class SiblingMC : public MergeCandidate { +class SiblingMC final : public MergeCandidate { private: LogicMTask* m_ap; LogicMTask* m_bp; @@ -755,7 +755,7 @@ public: }; // GraphEdge for the MTask graph -class MTaskEdge : public V3GraphEdge, public MergeCandidate { +class MTaskEdge final : public V3GraphEdge, public MergeCandidate { public: // CONSTRUCTORS MTaskEdge(V3Graph* graphp, LogicMTask* fromp, LogicMTask* top, int weight) @@ -801,7 +801,7 @@ private: //###################################################################### // Vertex utility classes -class OrderByPtrId { +class OrderByPtrId final { PartPtrIdMap m_ids; public: @@ -815,7 +815,7 @@ public: //###################################################################### // PartParallelismEst - Estimate parallelism of graph -class PartParallelismEst { +class PartParallelismEst final { // MEMBERS const V3Graph* m_graphp; // Mtask-containing graph @@ -1028,7 +1028,7 @@ static void partMergeEdgesFrom(V3Graph* mtasksp, LogicMTask* recipientp, LogicMT // PartContraction // Perform edge or sibling contraction on the partition graph -class PartContraction { +class PartContraction final { private: // TYPES @@ -1633,7 +1633,7 @@ const GraphWay* PartContraction::s_shortestWaywardCpInclusiveWay = nullptr; // Scan node, indicate whether it contains a call to a DPI imported // routine. -class DpiImportCallVisitor : public AstNVisitor { +class DpiImportCallVisitor final : public AstNVisitor { private: bool m_hasDpiHazard = false; // Found a DPI import call. bool m_tracingCall = false; // Iterating into a CCall to a CFunc @@ -1753,7 +1753,7 @@ private: // clock signal. This leads to unordered reader/writer pairs in // parallel mode. // -class PartFixDataHazards { +class PartFixDataHazards final { private: // TYPES typedef std::set LogicMTaskSet; @@ -2015,7 +2015,7 @@ private: // depending on which thread is looking. Be a little bit pessimistic when // thread A checks the end time of an mtask running on thread B. This extra // "padding" avoids tight "layovers" at cross-thread dependencies. -class PartPackMTasks { +class PartPackMTasks final { private: // TYPES struct MTaskState { diff --git a/src/V3Partition.h b/src/V3Partition.h index 46cc267b2..0a91c6010 100644 --- a/src/V3Partition.h +++ b/src/V3Partition.h @@ -34,7 +34,7 @@ typedef std::unordered_map Vx2MTaskMap; /// of which contains of set of the logic nodes from the fine-grained /// graph. -class V3Partition { +class V3Partition final { // MEMBERS V3Graph* m_fineDepsGraphp; // Fine-grained dependency graph public: @@ -73,7 +73,7 @@ private: //************************************************************************* // Map a pointer into a id, for e.g. nodep to mtask mappings -class PartPtrIdMap { +class PartPtrIdMap final { private: // TYPES typedef std::unordered_map PtrMap; diff --git a/src/V3PartitionGraph.h b/src/V3PartitionGraph.h index 789125bba..74276c92d 100644 --- a/src/V3PartitionGraph.h +++ b/src/V3PartitionGraph.h @@ -28,7 +28,7 @@ //************************************************************************* // MTasks and graph structures -class AbstractMTask : public V3GraphVertex { +class AbstractMTask VL_NOT_FINAL : public V3GraphVertex { public: AbstractMTask(V3Graph* graphp) : V3GraphVertex{graphp} {} @@ -37,7 +37,7 @@ public: virtual uint32_t cost() const = 0; }; -class AbstractLogicMTask : public AbstractMTask { +class AbstractLogicMTask VL_NOT_FINAL : public AbstractMTask { public: // TYPES typedef std::list VxList; @@ -52,7 +52,7 @@ public: virtual uint32_t cost() const override = 0; }; -class ExecMTask : public AbstractMTask { +class ExecMTask final : public AbstractMTask { private: AstMTaskBody* m_bodyp; // Task body uint32_t m_id; // Unique id of this mtask. diff --git a/src/V3PreLex.h b/src/V3PreLex.h index 34f978de0..ee801421f 100644 --- a/src/V3PreLex.h +++ b/src/V3PreLex.h @@ -126,7 +126,7 @@ void yy_delete_buffer(YY_BUFFER_STATE b); //====================================================================== // Entry for each file processed; a stack of entries included -class VPreStream { +class VPreStream final { public: FileLine* m_curFilelinep; // Current processing point (see also m_tokFilelinep) V3PreLex* m_lexp; // Lexer, for resource tracking @@ -149,7 +149,7 @@ private: //====================================================================== // Class entry for each per-lexer state -class V3PreLex { +class V3PreLex final { public: // Used only by V3PreLex.cpp and V3PreProc.cpp V3PreProcImp* m_preimpp; // Preprocessor lexor belongs to std::stack m_streampStack; // Stack of processing files diff --git a/src/V3PreProc.cpp b/src/V3PreProc.cpp index 344b939c2..122385e8f 100644 --- a/src/V3PreProc.cpp +++ b/src/V3PreProc.cpp @@ -43,7 +43,7 @@ //************************************************************************* -class VDefine { +class VDefine final { // Define class. One for each define. // string m_name; // Name of the define (list is keyed by this) FileLine* m_fileline; // Where it was declared @@ -64,7 +64,7 @@ public: //************************************************************************* -class VDefineRef { +class VDefineRef final { // One for each pending define substitution string m_name; // Define last name being defined string m_params; // Define parameter list for next expansion @@ -89,7 +89,7 @@ public: //************************************************************************* /// Data for parsing on/off -class VPreIfEntry { +class VPreIfEntry final { // One for each pending ifdef/ifndef bool m_on; // Current parse for this ifdef level is "on" bool m_everOn; // Some if term in elsif tree has been on @@ -105,7 +105,7 @@ public: //************************************************************************* // Data for a preprocessor instantiation. -class V3PreProcImp : public V3PreProc { +class V3PreProcImp final : public V3PreProc { public: // TYPES typedef std::map DefinesMap; diff --git a/src/V3PreProc.h b/src/V3PreProc.h index aae1dff36..39c7dbb48 100644 --- a/src/V3PreProc.h +++ b/src/V3PreProc.h @@ -33,7 +33,7 @@ class VInFilter; class VSpellCheck; -class V3PreProc { +class V3PreProc VL_NOT_FINAL { // This defines a preprocessor. Functions are virtual so implementation can be hidden. // After creating, call open(), then getline() in a loop. The class will to the rest... diff --git a/src/V3PreShell.cpp b/src/V3PreShell.cpp index bdef192cd..e2f1042dd 100644 --- a/src/V3PreShell.cpp +++ b/src/V3PreShell.cpp @@ -29,7 +29,7 @@ //###################################################################### -class V3PreShellImp { +class V3PreShellImp final { protected: friend class V3PreShell; diff --git a/src/V3PreShell.h b/src/V3PreShell.h index ec8a7678a..3428a8a88 100644 --- a/src/V3PreShell.h +++ b/src/V3PreShell.h @@ -29,7 +29,7 @@ class VSpellCheck; //============================================================================ -class V3PreShell { +class V3PreShell final { // Static class for calling preprocessor public: static void boot(char** env); diff --git a/src/V3Premit.cpp b/src/V3Premit.cpp index bdbff1af1..5865a902f 100644 --- a/src/V3Premit.cpp +++ b/src/V3Premit.cpp @@ -36,7 +36,7 @@ //###################################################################### // Structure for global state -class PremitAssignVisitor : public AstNVisitor { +class PremitAssignVisitor final : public AstNVisitor { private: // NODE STATE // AstVar::user4() // bool; occurs on LHS of current assignment @@ -82,7 +82,7 @@ public: //###################################################################### // Premit state, as a visitor of each AstNode -class PremitVisitor : public AstNVisitor { +class PremitVisitor final : public AstNVisitor { private: // NODE STATE // AstNodeMath::user() -> bool. True if iterated already diff --git a/src/V3Premit.h b/src/V3Premit.h index b7a5e302d..8d798665c 100644 --- a/src/V3Premit.h +++ b/src/V3Premit.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Premit { +class V3Premit final { public: static void premitAll(AstNetlist* nodep); }; diff --git a/src/V3ProtectLib.cpp b/src/V3ProtectLib.cpp index 88bf6ba8f..599699b5a 100644 --- a/src/V3ProtectLib.cpp +++ b/src/V3ProtectLib.cpp @@ -28,7 +28,7 @@ //###################################################################### // ProtectLib top-level visitor -class ProtectVisitor : public AstNVisitor { +class ProtectVisitor final : public AstNVisitor { private: AstVFile* m_vfilep = nullptr; // DPI-enabled Verilog wrapper AstCFile* m_cfilep = nullptr; // C implementation of DPI functions diff --git a/src/V3ProtectLib.h b/src/V3ProtectLib.h index 879305054..8bb167db3 100644 --- a/src/V3ProtectLib.h +++ b/src/V3ProtectLib.h @@ -25,7 +25,7 @@ //============================================================================ -class V3ProtectLib { +class V3ProtectLib final { public: static void protect(); }; diff --git a/src/V3Reloop.cpp b/src/V3Reloop.cpp index 50c3e9e30..71379aa05 100644 --- a/src/V3Reloop.cpp +++ b/src/V3Reloop.cpp @@ -43,7 +43,7 @@ constexpr unsigned RELOOP_MIN_ITERS = 40; // Need at least this many loops to d //###################################################################### -class ReloopVisitor : public AstNVisitor { +class ReloopVisitor final : public AstNVisitor { private: // TYPES typedef std::vector AssVec; diff --git a/src/V3Reloop.h b/src/V3Reloop.h index 674ef408f..fb0a748dc 100644 --- a/src/V3Reloop.h +++ b/src/V3Reloop.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Reloop { +class V3Reloop final { public: static void reloopAll(AstNetlist* nodep); }; diff --git a/src/V3Scope.cpp b/src/V3Scope.cpp index a26971951..a1374541e 100644 --- a/src/V3Scope.cpp +++ b/src/V3Scope.cpp @@ -36,7 +36,7 @@ //###################################################################### // Scope class functions -class ScopeVisitor : public AstNVisitor { +class ScopeVisitor final : public AstNVisitor { private: // NODE STATE // AstVar::user1p -> AstVarScope replacement for this variable @@ -319,7 +319,7 @@ public: //###################################################################### // Scope cleanup -- remove unused activates -class ScopeCleanupVisitor : public AstNVisitor { +class ScopeCleanupVisitor final : public AstNVisitor { private: // STATE AstScope* m_scopep = nullptr; // Current scope we are building diff --git a/src/V3Scope.h b/src/V3Scope.h index 46a9691a4..ffce787f9 100644 --- a/src/V3Scope.h +++ b/src/V3Scope.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Scope { +class V3Scope final { public: static void scopeAll(AstNetlist* nodep); }; diff --git a/src/V3Scoreboard.cpp b/src/V3Scoreboard.cpp index cf25c090e..42df6dbd8 100644 --- a/src/V3Scoreboard.cpp +++ b/src/V3Scoreboard.cpp @@ -19,7 +19,7 @@ #include "V3Scoreboard.h" -class ScoreboardTestElem { +class ScoreboardTestElem final { public: // MEMBERS uint32_t m_score; diff --git a/src/V3Scoreboard.h b/src/V3Scoreboard.h index 2aa8207c3..d0a1ec3e7 100644 --- a/src/V3Scoreboard.h +++ b/src/V3Scoreboard.h @@ -41,7 +41,7 @@ /// break ties in the sort when values collide. template > -class SortByValueMap { +class SortByValueMap final { // TYPES private: typedef std::unordered_map Key2Val; @@ -56,7 +56,7 @@ public: // CONSTRUCTORS SortByValueMap() = default; - class const_iterator { + class const_iterator VL_NOT_FINAL { // TYPES public: typedef const_iterator value_type; @@ -193,7 +193,7 @@ public: } }; - class iterator : public const_iterator { + class iterator final : public const_iterator { public: // TYPES typedef iterator value_type; @@ -350,11 +350,11 @@ private: /// the full set size. template > -class V3Scoreboard { +class V3Scoreboard final { private: // TYPES typedef std::unordered_set NeedRescoreSet; - class CmpElems { + class CmpElems final { public: bool operator()(const T_Elem* const& ap, const T_Elem* const& bp) const { T_ElemCompare cmp; diff --git a/src/V3SenTree.h b/src/V3SenTree.h index b1fa10947..b64937081 100644 --- a/src/V3SenTree.h +++ b/src/V3SenTree.h @@ -31,7 +31,7 @@ // Collect SenTrees under the entire scope // And provide functions to find/add a new one -class SenTreeSet { +class SenTreeSet final { // Hash table of sensitive blocks. private: // TYPES @@ -71,7 +71,7 @@ private: VL_UNCOPYABLE(SenTreeSet); }; -class SenTreeFinder { +class SenTreeFinder final { private: // STATE AstTopScope* m_topScopep = nullptr; // Top scope to add global SenTrees to diff --git a/src/V3Simulate.h b/src/V3Simulate.h index cec2c81ee..6a251e905 100644 --- a/src/V3Simulate.h +++ b/src/V3Simulate.h @@ -48,7 +48,7 @@ //###################################################################### // Simulate class functions -class SimStackNode { +class SimStackNode final { public: // MEMBERS AstFuncRef* m_funcp; @@ -63,7 +63,7 @@ public: typedef std::deque ConstDeque; typedef std::map ConstPile; -class SimulateVisitor : public AstNVisitor { +class SimulateVisitor VL_NOT_FINAL : public AstNVisitor { // Simulate a node tree, returning value of variables // Two major operating modes: // Test the tree to see if it is conformant diff --git a/src/V3Slice.cpp b/src/V3Slice.cpp index 76a31cde6..3c66b1648 100644 --- a/src/V3Slice.cpp +++ b/src/V3Slice.cpp @@ -44,7 +44,7 @@ //************************************************************************* -class SliceVisitor : public AstNVisitor { +class SliceVisitor final : public AstNVisitor { // NODE STATE // Cleared on netlist // AstNodeAssign::user1() -> bool. True if find is complete diff --git a/src/V3Slice.h b/src/V3Slice.h index 1ac23ac24..ad711d0f2 100644 --- a/src/V3Slice.h +++ b/src/V3Slice.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Slice { +class V3Slice final { public: static void sliceAll(AstNetlist* nodep); }; diff --git a/src/V3Split.cpp b/src/V3Split.cpp index 83fc53856..9b7e0cd85 100644 --- a/src/V3Split.cpp +++ b/src/V3Split.cpp @@ -95,7 +95,7 @@ //###################################################################### // Support classes -class SplitNodeVertex : public V3GraphVertex { +class SplitNodeVertex VL_NOT_FINAL : public V3GraphVertex { AstNode* m_nodep; protected: @@ -115,7 +115,7 @@ public: virtual AstNode* nodep() const { return m_nodep; } }; -class SplitPliVertex : public SplitNodeVertex { +class SplitPliVertex final : public SplitNodeVertex { public: explicit SplitPliVertex(V3Graph* graphp, AstNode* nodep) : SplitNodeVertex{graphp, nodep} {} @@ -124,7 +124,7 @@ public: virtual string dotColor() const override { return "green"; } }; -class SplitLogicVertex : public SplitNodeVertex { +class SplitLogicVertex final : public SplitNodeVertex { public: SplitLogicVertex(V3Graph* graphp, AstNode* nodep) : SplitNodeVertex{graphp, nodep} {} @@ -132,7 +132,7 @@ public: virtual string dotColor() const override { return "yellow"; } }; -class SplitVarStdVertex : public SplitNodeVertex { +class SplitVarStdVertex final : public SplitNodeVertex { public: SplitVarStdVertex(V3Graph* graphp, AstNode* nodep) : SplitNodeVertex{graphp, nodep} {} @@ -140,7 +140,7 @@ public: virtual string dotColor() const override { return "skyblue"; } }; -class SplitVarPostVertex : public SplitNodeVertex { +class SplitVarPostVertex final : public SplitNodeVertex { public: SplitVarPostVertex(V3Graph* graphp, AstNode* nodep) : SplitNodeVertex{graphp, nodep} {} @@ -152,7 +152,7 @@ public: //###################################################################### // Edge types -class SplitEdge : public V3GraphEdge { +class SplitEdge VL_NOT_FINAL : public V3GraphEdge { uint32_t m_ignoreInStep = 0; // Step number that if set to, causes this edge to be ignored static uint32_t s_stepNum; // Global step number protected: @@ -185,7 +185,7 @@ public: }; uint32_t SplitEdge::s_stepNum = 0; -class SplitPostEdge : public SplitEdge { +class SplitPostEdge final : public SplitEdge { public: SplitPostEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) : SplitEdge{graphp, fromp, top, WEIGHT_NORMAL} {} @@ -194,7 +194,7 @@ public: virtual string dotColor() const override { return "khaki"; } }; -class SplitLVEdge : public SplitEdge { +class SplitLVEdge final : public SplitEdge { public: SplitLVEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) : SplitEdge{graphp, fromp, top, WEIGHT_NORMAL} {} @@ -203,7 +203,7 @@ public: virtual string dotColor() const override { return "yellowGreen"; } }; -class SplitRVEdge : public SplitEdge { +class SplitRVEdge final : public SplitEdge { public: SplitRVEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) : SplitEdge{graphp, fromp, top, WEIGHT_NORMAL} {} @@ -235,7 +235,7 @@ public: //###################################################################### // Split class functions -class SplitReorderBaseVisitor : public AstNVisitor { +class SplitReorderBaseVisitor VL_NOT_FINAL : public AstNVisitor { private: // NODE STATE // AstVarScope::user1p -> Var SplitNodeVertex* for usage var, 0=not set yet @@ -439,7 +439,7 @@ private: VL_UNCOPYABLE(SplitReorderBaseVisitor); }; -class ReorderVisitor : public SplitReorderBaseVisitor { +class ReorderVisitor final : public SplitReorderBaseVisitor { // CONSTRUCTORS public: explicit ReorderVisitor(AstNetlist* nodep) { iterate(nodep); } @@ -622,7 +622,7 @@ private: typedef std::unordered_set ColorSet; typedef std::vector AlwaysVec; -class IfColorVisitor : public AstNVisitor { +class IfColorVisitor final : public AstNVisitor { // MEMBERS ColorSet m_colors; // All colors in the original always block @@ -680,7 +680,7 @@ private: VL_UNCOPYABLE(IfColorVisitor); }; -class EmitSplitVisitor : public AstNVisitor { +class EmitSplitVisitor final : public AstNVisitor { // MEMBERS AstAlways* m_origAlwaysp; // Block that *this will split const IfColorVisitor* m_ifColorp; // Digest of results of prior coloring @@ -793,7 +793,7 @@ private: VL_UNCOPYABLE(EmitSplitVisitor); }; -class RemovePlaceholdersVisitor : public AstNVisitor { +class RemovePlaceholdersVisitor final : public AstNVisitor { typedef std::unordered_set NodeSet; NodeSet m_removeSet; // placeholders to be removed public: @@ -812,7 +812,7 @@ private: VL_UNCOPYABLE(RemovePlaceholdersVisitor); }; -class SplitVisitor : public SplitReorderBaseVisitor { +class SplitVisitor final : public SplitReorderBaseVisitor { private: // Keys are original always blocks pending delete, // values are newly split always blocks pending insertion diff --git a/src/V3Split.h b/src/V3Split.h index a60268cee..bcabc01e3 100644 --- a/src/V3Split.h +++ b/src/V3Split.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Split { +class V3Split final { public: static void splitReorderAll(AstNetlist* nodep); static void splitAlwaysAll(AstNetlist* nodep); diff --git a/src/V3SplitAs.cpp b/src/V3SplitAs.cpp index 8b69134e6..e40a87f42 100644 --- a/src/V3SplitAs.cpp +++ b/src/V3SplitAs.cpp @@ -33,7 +33,7 @@ //###################################################################### -class SplitAsBaseVisitor : public AstNVisitor { +class SplitAsBaseVisitor VL_NOT_FINAL : public AstNVisitor { public: // METHODS VL_DEBUG_FUNC; // Declare debug() @@ -42,7 +42,7 @@ public: //###################################################################### // Find all split variables in a block -class SplitAsFindVisitor : public SplitAsBaseVisitor { +class SplitAsFindVisitor final : public SplitAsBaseVisitor { private: // STATE AstVarScope* m_splitVscp = nullptr; // Variable we want to split @@ -66,7 +66,7 @@ public: //###################################################################### // Remove nodes not containing proper references -class SplitAsCleanVisitor : public SplitAsBaseVisitor { +class SplitAsCleanVisitor final : public SplitAsBaseVisitor { private: // STATE AstVarScope* m_splitVscp; // Variable we want to split @@ -124,7 +124,7 @@ public: //###################################################################### // SplitAs class functions -class SplitAsVisitor : public SplitAsBaseVisitor { +class SplitAsVisitor final : public SplitAsBaseVisitor { private: // NODE STATE // AstAlways::user() -> bool. True if already processed diff --git a/src/V3SplitAs.h b/src/V3SplitAs.h index e42d03678..82f9d4915 100644 --- a/src/V3SplitAs.h +++ b/src/V3SplitAs.h @@ -25,7 +25,7 @@ //============================================================================ -class V3SplitAs { +class V3SplitAs final { public: static void splitAsAll(AstNetlist* nodep); }; diff --git a/src/V3SplitVar.cpp b/src/V3SplitVar.cpp index 9abdbe246..fd191ec24 100644 --- a/src/V3SplitVar.cpp +++ b/src/V3SplitVar.cpp @@ -232,7 +232,7 @@ struct AstNodeComparator { } }; -class UnpackRef { +class UnpackRef final { // m_nodep is called in this context (AstNodeStmt, AstCell, AstNodeFTask, or AstAlways) AstNode* m_contextp; AstNode* m_nodep; // ArraySel, SliceSel, ArrayVarRef (entire value) @@ -283,7 +283,7 @@ public: } }; -class UnpackRefMap { +class UnpackRefMap final { public: typedef std::map, AstNodeComparator> MapType; typedef MapType::iterator MapIt; @@ -384,7 +384,7 @@ public: typedef std::map SplitVarRefsMap; -class SplitUnpackedVarVisitor : public AstNVisitor, public SplitVarImpl { +class SplitUnpackedVarVisitor final : public AstNVisitor, public SplitVarImpl { typedef std::set VarSet; VarSet m_foundTargetVar; UnpackRefMap m_refs; @@ -802,7 +802,7 @@ public: // Split packed variables // Split variable -class SplitNewVar { +class SplitNewVar final { int m_lsb; // LSB in the original bitvector int m_bitwidth; AstVar* m_varp; // The LSB of this variable is always 0, not m_lsb @@ -828,7 +828,7 @@ public: }; // One Entry instance for an AstVarRef instance -class PackedVarRefEntry { +class PackedVarRefEntry final { AstNode* m_nodep; // Either AstSel or AstVarRef is expected. int m_lsb; int m_bitwidth; @@ -859,7 +859,7 @@ public: }; // How a variable is used -class PackedVarRef { +class PackedVarRef final { struct SortByFirst { bool operator()(const std::pair& a, const std::pair& b) const { if (a.first == b.first) return a.second < b.second; @@ -956,7 +956,7 @@ public: } }; -class SplitPackedVarVisitor : public AstNVisitor, public SplitVarImpl { +class SplitPackedVarVisitor final : public AstNVisitor, public SplitVarImpl { typedef std::map PackedVarRefMap; AstNetlist* m_netp; AstNodeModule* m_modp; // Current module (just for log) diff --git a/src/V3SplitVar.h b/src/V3SplitVar.h index f9c1c64ab..41195bc57 100644 --- a/src/V3SplitVar.h +++ b/src/V3SplitVar.h @@ -22,7 +22,7 @@ class AstNetlist; class AstVar; -class V3SplitVar { +class V3SplitVar final { public: // Split variables marked with split_var metacomment. static void splitVariable(AstNetlist* nodep); diff --git a/src/V3Stats.cpp b/src/V3Stats.cpp index a73df13e4..612ea0244 100644 --- a/src/V3Stats.cpp +++ b/src/V3Stats.cpp @@ -30,7 +30,7 @@ //###################################################################### // Stats class functions -class StatsVisitor : public AstNVisitor { +class StatsVisitor final : public AstNVisitor { private: // NODE STATE/TYPES diff --git a/src/V3Stats.h b/src/V3Stats.h index 084eb312c..7f9012238 100644 --- a/src/V3Stats.h +++ b/src/V3Stats.h @@ -26,7 +26,7 @@ class AstNetlist; //============================================================================ -class VDouble0 { +class VDouble0 final { // Double counter, initializes to zero for easy use double m_d = 0.0; ///< Count of occurrences/ value public: @@ -65,7 +65,7 @@ public: //============================================================================ -class V3Statistic { +class V3Statistic final { // A statistical entry we want published into the database string m_name; ///< Nameiption of this statistic double m_count; ///< Count of occurrences/ value @@ -99,7 +99,7 @@ public: //============================================================================ -class V3Stats { +class V3Stats final { public: static void addStat(const V3Statistic&); static void addStat(const string& stage, const string& name, double count) { diff --git a/src/V3StatsReport.cpp b/src/V3StatsReport.cpp index e93491eec..24c84932e 100644 --- a/src/V3StatsReport.cpp +++ b/src/V3StatsReport.cpp @@ -30,7 +30,7 @@ //###################################################################### // Stats dumping -class StatsReport { +class StatsReport final { // TYPES typedef std::vector StatColl; diff --git a/src/V3String.h b/src/V3String.h index 1a700d264..af5437092 100644 --- a/src/V3String.h +++ b/src/V3String.h @@ -66,7 +66,7 @@ inline string ucfirst(const string& text) { //###################################################################### // VString - String manipulation -class VString { +class VString final { static bool wildmatchi(const char* s, const char* p); public: @@ -104,7 +104,7 @@ public: //###################################################################### // VHashSha256 - Compute Sha256 hashes -class VHashSha256 { +class VHashSha256 final { // As blocks must be processed in 64 byte chunks, this does not at present // support calling input() on multiple non-64B chunks and getting the correct // hash. To do that first combine the string before calling here. @@ -157,7 +157,7 @@ private: // VName - string which contains a possibly hashed string // TODO use this wherever there is currently a "string m_name" -class VName { +class VName final { string m_name; string m_hashed; static std::map s_dehashMap; // hashed -> original decoder @@ -187,7 +187,7 @@ public: //###################################################################### // VSpellCheck - Find near-match spelling suggestions given list of possibilities -class VSpellCheck { +class VSpellCheck final { // CONSTANTS static constexpr unsigned NUM_CANDIDATE_LIMIT = 10000; // Avoid searching huge netlists static constexpr unsigned LENGTH_LIMIT = 100; // Maximum string length to search diff --git a/src/V3Subst.cpp b/src/V3Subst.cpp index 8590a57cf..8a0bb483c 100644 --- a/src/V3Subst.cpp +++ b/src/V3Subst.cpp @@ -36,7 +36,7 @@ //###################################################################### // Common debugging baseclass -class SubstBaseVisitor : public AstNVisitor { +class SubstBaseVisitor VL_NOT_FINAL : public AstNVisitor { public: VL_DEBUG_FUNC; // Declare debug() }; @@ -44,7 +44,7 @@ public: //###################################################################### // Class for each word of a multi-word variable -class SubstVarWord { +class SubstVarWord final { protected: // MEMBERS AstNodeAssign* m_assignp; // Last assignment to each word of this var @@ -64,7 +64,7 @@ protected: //###################################################################### // Class for every variable we may process -class SubstVarEntry { +class SubstVarEntry final { // MEMBERS AstVar* m_varp; // Variable this tracks bool m_wordAssign = false; // True if any word assignments @@ -174,7 +174,7 @@ public: // See if any variables have changed value since we determined subst value, // as a visitor of each AstNode -class SubstUseVisitor : public SubstBaseVisitor { +class SubstUseVisitor final : public SubstBaseVisitor { private: // NODE STATE // See SubstVisitor @@ -221,7 +221,7 @@ public: //###################################################################### // Subst state, as a visitor of each AstNode -class SubstVisitor : public SubstBaseVisitor { +class SubstVisitor final : public SubstBaseVisitor { private: // NODE STATE // Passed to SubstUseVisitor diff --git a/src/V3Subst.h b/src/V3Subst.h index fbc3e5708..9906f3487 100644 --- a/src/V3Subst.h +++ b/src/V3Subst.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Subst { +class V3Subst final { public: static void substituteAll(AstNetlist* nodep); }; diff --git a/src/V3SymTable.h b/src/V3SymTable.h index e77b982d7..68a2296f0 100644 --- a/src/V3SymTable.h +++ b/src/V3SymTable.h @@ -38,7 +38,7 @@ class VSymEnt; typedef std::set VSymConstMap; -class VSymEnt { +class VSymEnt final { // Symbol table that can have a "superior" table for resolving upper references // MEMBERS typedef std::multimap IdNameMap; @@ -277,7 +277,7 @@ public: //###################################################################### // Symbol tables -class VSymGraph { +class VSymGraph final { // Collection of symbol tables // TYPES typedef std::vector SymStack; diff --git a/src/V3TSP.cpp b/src/V3TSP.cpp index 07a6d9e84..140815c74 100644 --- a/src/V3TSP.cpp +++ b/src/V3TSP.cpp @@ -119,7 +119,7 @@ public: return vertices; } - class EdgeCmp { + class EdgeCmp final { // Provides a deterministic compare for outgoing V3GraphEdge's // to be used in Prim's algorithm below. Also used in the // perfectMatching() routine. @@ -494,7 +494,7 @@ void V3TSP::tspSort(const V3TSP::StateVec& states, V3TSP::StateVec* resultp) { //###################################################################### // Self Tests -class TspTestState : public V3TSP::TspStateBase { +class TspTestState final : public V3TSP::TspStateBase { public: TspTestState(unsigned xpos, unsigned ypos) : m_xpos{xpos} diff --git a/src/V3TSP.h b/src/V3TSP.h index cc9e79fed..b3cc20808 100644 --- a/src/V3TSP.h +++ b/src/V3TSP.h @@ -27,7 +27,7 @@ namespace V3TSP { // Perform a "Traveling Salesman Problem" optimizing sort // on any type you like -- so long as inherits from TspStateBase. -class TspStateBase { +class TspStateBase VL_NOT_FINAL { public: // This is the cost function that the TSP sort will minimize. // All costs in V3TSP are int, chosen to match the type of diff --git a/src/V3Table.cpp b/src/V3Table.cpp index 6918493e1..271c8c649 100644 --- a/src/V3Table.cpp +++ b/src/V3Table.cpp @@ -48,7 +48,7 @@ static const int TABLE_MIN_NODE_COUNT = 32; // If < 32 instructions, not worth class TableVisitor; -class TableSimulateVisitor : public SimulateVisitor { +class TableSimulateVisitor final : public SimulateVisitor { // MEMBERS TableVisitor* m_cbthis; ///< Class for callback @@ -65,7 +65,7 @@ public: //###################################################################### // Table class functions -class TableVisitor : public AstNVisitor { +class TableVisitor final : public AstNVisitor { private: // NODE STATE // Cleared on each always/assignw diff --git a/src/V3Table.h b/src/V3Table.h index c54220b8d..3ad3de773 100644 --- a/src/V3Table.h +++ b/src/V3Table.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Table { +class V3Table final { public: static void tableAll(AstNetlist* nodep); }; diff --git a/src/V3Task.cpp b/src/V3Task.cpp index 8cb19bedb..90f776cf3 100644 --- a/src/V3Task.cpp +++ b/src/V3Task.cpp @@ -39,7 +39,7 @@ //###################################################################### // Graph subclasses -class TaskBaseVertex : public V3GraphVertex { +class TaskBaseVertex VL_NOT_FINAL : public V3GraphVertex { AstNode* m_impurep = nullptr; // Node causing impure function w/ outside references bool m_noInline = false; // Marked with pragma public: @@ -53,7 +53,7 @@ public: void noInline(bool flag) { m_noInline = flag; } }; -class TaskFTaskVertex : public TaskBaseVertex { +class TaskFTaskVertex final : public TaskBaseVertex { // Every task gets a vertex, and we link tasks together based on funcrefs. AstNodeFTask* m_nodep; AstCFunc* m_cFuncp = nullptr; @@ -71,7 +71,7 @@ public: void cFuncp(AstCFunc* nodep) { m_cFuncp = nodep; } }; -class TaskCodeVertex : public TaskBaseVertex { +class TaskCodeVertex final : public TaskBaseVertex { // Top vertex for all calls not under another task public: explicit TaskCodeVertex(V3Graph* graphp) @@ -81,7 +81,7 @@ public: virtual string dotColor() const override { return "green"; } }; -class TaskEdge : public V3GraphEdge { +class TaskEdge final : public V3GraphEdge { public: TaskEdge(V3Graph* graphp, TaskBaseVertex* fromp, TaskBaseVertex* top) : V3GraphEdge{graphp, fromp, top, 1, false} {} @@ -91,7 +91,7 @@ public: //###################################################################### -class TaskStateVisitor : public AstNVisitor { +class TaskStateVisitor final : public AstNVisitor { private: // NODE STATE // Output: @@ -287,7 +287,7 @@ public: //###################################################################### -class TaskRelinkVisitor : public AstNVisitor { +class TaskRelinkVisitor final : public AstNVisitor { // Replace varrefs with new var pointer private: // NODE STATE @@ -323,7 +323,7 @@ public: //###################################################################### // Task state, as a visitor of each AstNode -class TaskVisitor : public AstNVisitor { +class TaskVisitor final : public AstNVisitor { private: // NODE STATE // Each module: diff --git a/src/V3Task.h b/src/V3Task.h index a1722a16c..9c162dccc 100644 --- a/src/V3Task.h +++ b/src/V3Task.h @@ -32,7 +32,7 @@ typedef std::vector V3TaskConnects; // [ [port, pin-connects-to] //============================================================================ -class V3Task { +class V3Task final { public: static void taskAll(AstNetlist* nodep); /// Return vector of [port, pin-connects-to] (SLOW) diff --git a/src/V3Trace.cpp b/src/V3Trace.cpp index a1598bb70..9a704175b 100644 --- a/src/V3Trace.cpp +++ b/src/V3Trace.cpp @@ -51,7 +51,7 @@ //###################################################################### // Graph vertexes -class TraceActivityVertex : public V3GraphVertex { +class TraceActivityVertex final : public V3GraphVertex { AstNode* const m_insertp; vlsint32_t m_activityCode; bool m_slow; // If always slow, we can use the same code @@ -95,7 +95,7 @@ public: } }; -class TraceCFuncVertex : public V3GraphVertex { +class TraceCFuncVertex final : public V3GraphVertex { AstCFunc* m_nodep; public: @@ -110,7 +110,7 @@ public: virtual FileLine* fileline() const override { return nodep()->fileline(); } }; -class TraceTraceVertex : public V3GraphVertex { +class TraceTraceVertex final : public V3GraphVertex { AstTraceDecl* const m_nodep; // TRACEINC this represents // nullptr, or other vertex with the real code() that duplicates this one TraceTraceVertex* m_duplicatep = nullptr; @@ -132,7 +132,7 @@ public: } }; -class TraceVarVertex : public V3GraphVertex { +class TraceVarVertex final : public V3GraphVertex { AstVarScope* m_nodep; public: @@ -150,7 +150,7 @@ public: //###################################################################### // Trace state, as a visitor of each AstNode -class TraceVisitor : public EmitCBaseVisitor { +class TraceVisitor final : public EmitCBaseVisitor { private: // NODE STATE // V3Hashed diff --git a/src/V3Trace.h b/src/V3Trace.h index 07d7fd679..c45922fe6 100644 --- a/src/V3Trace.h +++ b/src/V3Trace.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Trace { +class V3Trace final { public: static void traceAll(AstNetlist* nodep); }; diff --git a/src/V3TraceDecl.cpp b/src/V3TraceDecl.cpp index f8669c6bd..ba248b720 100644 --- a/src/V3TraceDecl.cpp +++ b/src/V3TraceDecl.cpp @@ -31,7 +31,7 @@ //###################################################################### // TraceDecl state, as a visitor of each AstNode -class TraceDeclVisitor : public EmitCBaseVisitor { +class TraceDeclVisitor final : public EmitCBaseVisitor { private: // NODE STATE diff --git a/src/V3TraceDecl.h b/src/V3TraceDecl.h index 1327b45df..024d284a7 100644 --- a/src/V3TraceDecl.h +++ b/src/V3TraceDecl.h @@ -25,7 +25,7 @@ //============================================================================ -class V3TraceDecl { +class V3TraceDecl final { public: static void traceDeclAll(AstNetlist* nodep); }; diff --git a/src/V3Tristate.cpp b/src/V3Tristate.cpp index 086ecbb30..8988b6258 100644 --- a/src/V3Tristate.cpp +++ b/src/V3Tristate.cpp @@ -69,7 +69,7 @@ //###################################################################### -class TristateBaseVisitor : public AstNVisitor { +class TristateBaseVisitor VL_NOT_FINAL : public AstNVisitor { public: // METHODS VL_DEBUG_FUNC; // Declare debug() @@ -78,7 +78,7 @@ public: //###################################################################### // Graph support classes -class TristateVertex : public V3GraphVertex { +class TristateVertex final : public V3GraphVertex { AstNode* m_nodep; bool m_isTristate = false; // Logic indicates a tristate bool m_feedsTri = false; // Propagates to a tristate node (on RHS) @@ -110,7 +110,7 @@ public: //###################################################################### -class TristateGraph { +class TristateGraph final { // NODE STATE // AstVar::user5p -> TristateVertex* for variable being built // AstUser5InUse m_inuser5; // In visitor below @@ -271,7 +271,7 @@ public: // Given a node, flip any VarRef from LValue to RValue (i.e. make it an input) // See also V3LinkLValue::linkLValueSet -class TristatePinVisitor : public TristateBaseVisitor { +class TristatePinVisitor final : public TristateBaseVisitor { TristateGraph& m_tgraph; bool m_lvalue; // Flip to be an LVALUE // VISITORS @@ -312,7 +312,7 @@ public: //###################################################################### -class TristateVisitor : public TristateBaseVisitor { +class TristateVisitor final : public TristateBaseVisitor { // NODE STATE // *::user1p -> pointer to output enable __en expressions // *::user2 -> int - already visited, see U2_ enum diff --git a/src/V3Tristate.h b/src/V3Tristate.h index 509a6bd94..5ea6c7d17 100644 --- a/src/V3Tristate.h +++ b/src/V3Tristate.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Tristate { +class V3Tristate final { public: static void tristateAll(AstNetlist* nodep); }; diff --git a/src/V3Undriven.cpp b/src/V3Undriven.cpp index 1ff124aee..36077d610 100644 --- a/src/V3Undriven.cpp +++ b/src/V3Undriven.cpp @@ -37,7 +37,7 @@ //###################################################################### // Class for every variable we may process -class UndrivenVarEntry { +class UndrivenVarEntry final { // MEMBERS AstVar* m_varp; // Variable this tracks std::vector m_wholeFlags; // Used/Driven on whole vector @@ -226,7 +226,7 @@ public: //###################################################################### // Undriven state, as a visitor of each AstNode -class UndrivenVisitor : public AstNVisitor { +class UndrivenVisitor final : public AstNVisitor { private: // NODE STATE // Netlist: diff --git a/src/V3Undriven.h b/src/V3Undriven.h index 4475ab053..2a4e5d18c 100644 --- a/src/V3Undriven.h +++ b/src/V3Undriven.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Undriven { +class V3Undriven final { public: static void undrivenAll(AstNetlist* nodep); }; diff --git a/src/V3Unknown.cpp b/src/V3Unknown.cpp index 21e61b019..dbfa9a101 100644 --- a/src/V3Unknown.cpp +++ b/src/V3Unknown.cpp @@ -41,7 +41,7 @@ //###################################################################### -class UnknownVisitor : public AstNVisitor { +class UnknownVisitor final : public AstNVisitor { private: // NODE STATE // Cleared on Netlist diff --git a/src/V3Unknown.h b/src/V3Unknown.h index db784a95a..2139cf771 100644 --- a/src/V3Unknown.h +++ b/src/V3Unknown.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Unknown { +class V3Unknown final { public: static void unknownAll(AstNetlist* nodep); }; diff --git a/src/V3Unroll.cpp b/src/V3Unroll.cpp index 7a0165c15..85b7d4484 100644 --- a/src/V3Unroll.cpp +++ b/src/V3Unroll.cpp @@ -39,7 +39,7 @@ //###################################################################### // Unroll state, as a visitor of each AstNode -class UnrollVisitor : public AstNVisitor { +class UnrollVisitor final : public AstNVisitor { private: // STATE AstVar* m_forVarp; // Iterator variable diff --git a/src/V3Unroll.h b/src/V3Unroll.h index 39e588c41..61b662f1b 100644 --- a/src/V3Unroll.h +++ b/src/V3Unroll.h @@ -28,7 +28,7 @@ class UnrollVisitor; -class UnrollStateful { +class UnrollStateful final { // MEMBERS UnrollVisitor* m_unrollerp; VL_UNCOPYABLE(UnrollStateful); @@ -44,7 +44,7 @@ public: //============================================================================ -class V3Unroll { +class V3Unroll final { public: static void unrollAll(AstNetlist* nodep); }; diff --git a/src/V3Waiver.h b/src/V3Waiver.h index 67d4d65a0..7c93aa52c 100644 --- a/src/V3Waiver.h +++ b/src/V3Waiver.h @@ -22,7 +22,7 @@ #include #include -class V3Waiver { +class V3Waiver final { // TYPES typedef std::vector WaiverList; static WaiverList s_waiverList; diff --git a/src/V3Width.cpp b/src/V3Width.cpp index 17979e595..ed88444a9 100644 --- a/src/V3Width.cpp +++ b/src/V3Width.cpp @@ -103,7 +103,7 @@ std::ostream& operator<<(std::ostream& str, const Determ& rhs) { //###################################################################### // Width state, as a visitor of each AstNode -class WidthVP { +class WidthVP final { // Parameters to pass down hierarchy with visit functions. AstNodeDType* m_dtypep; // Parent's data type to resolve to Stage m_stage; // If true, report errors @@ -164,7 +164,7 @@ std::ostream& operator<<(std::ostream& str, const WidthVP* vup) { //###################################################################### -class WidthClearVisitor { +class WidthClearVisitor final { // Rather than a AstNVisitor, can just quickly touch every node void clearWidthRecurse(AstNode* nodep) { for (; nodep; nodep = nodep->nextp()) { @@ -188,7 +188,7 @@ public: //###################################################################### -class WidthVisitor : public AstNVisitor { +class WidthVisitor final : public AstNVisitor { private: // TYPES typedef std::map, AstVar*> TableMap; diff --git a/src/V3Width.h b/src/V3Width.h index 5ba10dc80..03e1fb037 100644 --- a/src/V3Width.h +++ b/src/V3Width.h @@ -25,7 +25,7 @@ //============================================================================ -class V3Width { +class V3Width final { public: static int debug(); static void width(AstNetlist* nodep); diff --git a/src/V3WidthCommit.h b/src/V3WidthCommit.h index 047dec26e..2176bc8cd 100644 --- a/src/V3WidthCommit.h +++ b/src/V3WidthCommit.h @@ -34,7 +34,7 @@ /// Remove all $signed, $unsigned, we're done with them. /// This step is only called on real V3Width, not intermediate e.g. widthParams -class WidthRemoveVisitor : public AstNVisitor { +class WidthRemoveVisitor final : public AstNVisitor { private: // METHODS void replaceWithSignedVersion(AstNode* nodep, AstNode* newp) { @@ -64,7 +64,7 @@ public: // Now that all widthing is complete, // Copy all width() to widthMin(). V3Const expects this -class WidthCommitVisitor : public AstNVisitor { +class WidthCommitVisitor final : public AstNVisitor { // NODE STATE // AstVar::user1p -> bool, processed AstUser1InUse m_inuser1; diff --git a/src/V3WidthSel.cpp b/src/V3WidthSel.cpp index 71d805d20..37f5959ff 100644 --- a/src/V3WidthSel.cpp +++ b/src/V3WidthSel.cpp @@ -36,7 +36,7 @@ //###################################################################### // Width state, as a visitor of each AstNode -class WidthSelVisitor : public AstNVisitor { +class WidthSelVisitor final : public AstNVisitor { private: // IMPORTANT //**** This is not a normal visitor, in that all iteration is instead diff --git a/src/VlcBucket.h b/src/VlcBucket.h index 97df0c4b1..be7245e27 100644 --- a/src/VlcBucket.h +++ b/src/VlcBucket.h @@ -25,7 +25,7 @@ // This is a bitmap array - we store a single bit to indicate a test // has hit that point with sufficient coverage. -class VlcBuckets { +class VlcBuckets final { private: // MEMBERS vluint64_t* m_datap = nullptr; ///< Pointer to first bucket (dynamically allocated) diff --git a/src/VlcOptions.h b/src/VlcOptions.h index 0efd39e0f..53940bbb9 100644 --- a/src/VlcOptions.h +++ b/src/VlcOptions.h @@ -31,7 +31,7 @@ typedef std::set VlStringSet; -class VlcOptions { +class VlcOptions final { // MEMBERS (general options) // clang-format off string m_annotateOut; // main switch: --annotate I diff --git a/src/VlcPoint.h b/src/VlcPoint.h index e87c0de0f..36eea2feb 100644 --- a/src/VlcPoint.h +++ b/src/VlcPoint.h @@ -29,7 +29,7 @@ //******************************************************************** // VlcPoint - A coverage point (across all tests) -class VlcPoint { +class VlcPoint final { private: // MEMBERS string m_name; //< Name of the point @@ -90,7 +90,7 @@ public: //******************************************************************** // VlcPoints - Container of all points -class VlcPoints { +class VlcPoints final { private: // MEMBERS typedef std::map NameMap; // Sorted by name (ordered) diff --git a/src/VlcSource.h b/src/VlcSource.h index adebdde3a..7874b9de0 100644 --- a/src/VlcSource.h +++ b/src/VlcSource.h @@ -26,7 +26,7 @@ //******************************************************************** // VlcColumnCount - count at specific source file, line and column -class VlcSourceCount { +class VlcSourceCount final { private: // MEMBERS int m_lineno; ///< Line number @@ -57,7 +57,7 @@ public: //******************************************************************** // VlcSource - source file to annotate -class VlcSource { +class VlcSource final { public: // TYPES typedef std::map ColumnMap; // Map of {column} @@ -98,7 +98,7 @@ public: //******************************************************************** // VlcSources - Container of all source files -class VlcSources { +class VlcSources final { public: // TYPES typedef std::map NameMap; diff --git a/src/VlcTest.h b/src/VlcTest.h index 8db9a2059..5cc1c3ae2 100644 --- a/src/VlcTest.h +++ b/src/VlcTest.h @@ -29,7 +29,7 @@ //******************************************************************** // VlcTest - a single testrun i.e. a file containing coverage data -class VlcTest { +class VlcTest final { private: // MEMBERS string m_name; //< Name of the test @@ -84,7 +84,7 @@ public: //******************************************************************** // VlcTests - Container of all tests -class VlcTests { +class VlcTests final { public: // TYPES typedef std::vector ByName; diff --git a/src/VlcTop.h b/src/VlcTop.h index b00edd110..4284c69ed 100644 --- a/src/VlcTop.h +++ b/src/VlcTop.h @@ -28,7 +28,7 @@ //###################################################################### // VlcTop - Top level options container -class VlcTop { +class VlcTop final { public: // PUBLIC MEMBERS VlcOptions opt; //< Runtime options diff --git a/src/astgen b/src/astgen index f7ff60fcf..60f20a283 100644 --- a/src/astgen +++ b/src/astgen @@ -378,9 +378,9 @@ sub write_header { $line =~ s/^\s*#(define|undef)\s+ASTGEN_.*$//; # Track current node type and base class - if ($line =~ /^\s*class\s*Ast(\S+)\s*:\s*(public)?\s*(AstNode\S*)/) { + if ($line =~ /^\s*class\s*Ast(\S+)\s*(final|VL_NOT_FINAL)?\s*:\s*(public)?\s*(AstNode\S*)/) { $type = $1; - $base = $3; + $base = $4; } # Substitute macros diff --git a/test_regress/t/t_dist_portability.pl b/test_regress/t/t_dist_portability.pl index 5b6a8e037..78c4d6279 100755 --- a/test_regress/t/t_dist_portability.pl +++ b/test_regress/t/t_dist_portability.pl @@ -22,6 +22,7 @@ if (!-r "$root/.git") { printfll(); cstr(); vsnprintf(); + final(); } ok(1); @@ -30,7 +31,7 @@ sub uint { ### Must trim output before and after our file list #my $files = "*/*.c* */*.h test_regress/t/*.c* test_regress/t/*.h"; # src isn't clean, and probably doesn't need to be (yet?) - my $files = "include/*.c* include/*.h test_c/*.c* test_regress/t/*.c* test_regress/t/*.h"; + my $files = "include/*.c* include/*.h examples/*/*.c* test_regress/t/*.c* test_regress/t/*.h"; my $cmd = "cd $root && fgrep -n int $files | sort"; print "C $cmd\n"; my $grep = `$cmd`; @@ -52,7 +53,7 @@ sub uint { } sub printfll { - my $files = "src/*.c* src/*.h include/*.c* include/*.h test_c/*.c* test_regress/t/*.c* test_regress/t/*.h"; + my $files = "src/*.c* src/*.h include/*.c* include/*.h examples/*/*.c* test_regress/t/*.c* test_regress/t/*.h"; my $cmd = "cd $root && fgrep -n ll $files | sort"; print "C $cmd\n"; my $grep = `$cmd`; @@ -73,7 +74,7 @@ sub printfll { } sub cstr { - my $files = "src/*.c* src/*.h include/*.c* include/*.h test_c/*.c* test_regress/t/*.c* test_regress/t/*.h"; + my $files = "src/*.c* src/*.h include/*.c* include/*.h examples/*/*.c* test_regress/t/*.c* test_regress/t/*.h"; my $cmd = "cd $root && grep -n -P 'c_str|begin|end' $files | sort"; print "C $cmd\n"; my $grep = `$cmd`; @@ -92,7 +93,7 @@ sub cstr { sub vsnprintf { # Note do not do test_regress, as VPI files need to compile without verilatedos.h - my $files = "src/*.c* src/*.h include/*.c* include/*.h test_c/*.c*"; + my $files = "src/*.c* src/*.h include/*.c* include/*.h examples/*/*.c*"; my $cmd = "cd $root && grep -n -P '(snprintf|vsnprintf)' $files | sort"; print "C $cmd\n"; my $grep = `$cmd`; @@ -109,4 +110,25 @@ sub vsnprintf { } } +sub final { + # Note do not do test_regress, as VPI files need to compile without verilatedos.h + my $files = "src/*.c* src/*.h include/*.c* include/*.h"; + my $cmd = "cd $root && grep -n -P '(class)' $files | sort"; + print "C $cmd\n"; + my $grep = `$cmd`; + my %names; + foreach my $line (split /\n/, $grep) { + if ($line =~ /:\s*class /) { + next if $line =~ /final|VL_NOT_FINAL/; + next if $line =~ /{}/; # e.g. 'class Foo {};' + next if $line =~ /;/; # e.g. 'class Foo;' + print "$line\n"; + $names{$1} = 1; + } + } + if (keys %names) { + error("Files with classes without final/VL_NOT_FINAL: ",join(' ',sort keys %names)); + } +} + 1;