Mario1159/verilator
1
0
Fork 0
forked from github/verilator
Code Pull Requests Releases 1 Activity

Make enum constructors and operators constexpr

Browse Source
This commit is contained in:
Geza Lore 2022-09-23 10:57:01 +01:00
parent 63c694f65f
commit 050060b139
8 changed files with 184 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

263
src/V3Ast.h
View File

@ -95,18 +95,18 @@ public:
// cppcheck-suppress uninitVar // responsibility of each subclass
VNType() = default;
// cppcheck-suppress noExplicitConstructor
VNType(en _e)
constexpr VNType(en _e)
: m_e{_e} {}
explicit VNType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
};
inline bool operator==(const VNType& lhs, const VNType& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VNType& lhs, VNType::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VNType::en lhs, const VNType& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VNType& lhs, const VNType& rhs) { return lhs.m_e == rhs.m_e; }
constexpr bool operator==(const VNType& lhs, VNType::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VNType::en lhs, const VNType& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const VNType& rhs) { return os << rhs.ascii(); }
//######################################################################
// ######################################################################
class VLifetime final {
public:
@ -119,23 +119,25 @@ public:
VLifetime()
: m_e{NONE} {}
// cppcheck-suppress noExplicitConstructor
VLifetime(en _e)
constexpr VLifetime(en _e)
: m_e{_e} {}
explicit VLifetime(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
bool isNone() const { return m_e == NONE; }
bool isAutomatic() const { return m_e == AUTOMATIC; }
bool isStatic() const { return m_e == STATIC; }
};
inline bool operator==(const VLifetime& lhs, const VLifetime& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VLifetime& lhs, VLifetime::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VLifetime::en lhs, const VLifetime& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VLifetime& lhs, const VLifetime& rhs) {
return lhs.m_e == rhs.m_e;
}
constexpr bool operator==(const VLifetime& lhs, VLifetime::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VLifetime::en lhs, const VLifetime& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const VLifetime& rhs) {
return os << rhs.ascii();
}
//######################################################################
// ######################################################################
class VAccess final {
public:
@ -160,11 +162,11 @@ public:
VAccess()
: m_e{READ} {}
// cppcheck-suppress noExplicitConstructor
VAccess(en _e)
constexpr VAccess(en _e)
: m_e{_e} {}
explicit VAccess(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
VAccess invert() const {
return (m_e == READWRITE) ? VAccess{m_e} : (m_e == WRITE ? VAccess{READ} : VAccess{WRITE});
}
@ -174,12 +176,12 @@ public:
bool isWriteOrRW() const { return m_e == WRITE || m_e == READWRITE; }
bool isRW() const { return m_e == READWRITE; }
};
inline bool operator==(const VAccess& lhs, const VAccess& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VAccess& lhs, VAccess::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VAccess::en lhs, const VAccess& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VAccess& lhs, const VAccess& rhs) { return lhs.m_e == rhs.m_e; }
constexpr bool operator==(const VAccess& lhs, VAccess::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VAccess::en lhs, const VAccess& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const VAccess& rhs) { return os << rhs.ascii(); }
//######################################################################
// ######################################################################
class VSigning final {
public:
@ -197,26 +199,26 @@ public:
VSigning()
: m_e{UNSIGNED} {}
// cppcheck-suppress noExplicitConstructor
VSigning(en _e)
constexpr VSigning(en _e)
: m_e{_e} {}
static VSigning fromBool(bool isSigned) { // Factory method
return isSigned ? VSigning{SIGNED} : VSigning{UNSIGNED};
}
explicit VSigning(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
bool isSigned() const { return m_e == SIGNED; }
bool isNosign() const { return m_e == NOSIGN; }
// No isUnsigned() as it's ambiguous if NOSIGN should be included or not.
};
inline bool operator==(const VSigning& lhs, const VSigning& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VSigning& lhs, VSigning::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VSigning::en lhs, const VSigning& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VSigning& lhs, const VSigning& rhs) { return lhs.m_e == rhs.m_e; }
constexpr bool operator==(const VSigning& lhs, VSigning::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VSigning::en lhs, const VSigning& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const VSigning& rhs) {
return os << rhs.ascii();
}
//######################################################################
// ######################################################################
class VPragmaType final {
public:
@ -237,19 +239,19 @@ public:
VPragmaType()
: m_e{ILLEGAL} {}
// cppcheck-suppress noExplicitConstructor
VPragmaType(en _e)
constexpr VPragmaType(en _e)
: m_e{_e} {}
explicit VPragmaType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
};
inline bool operator==(const VPragmaType& lhs, const VPragmaType& rhs) {
constexpr bool operator==(const VPragmaType& lhs, const VPragmaType& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const VPragmaType& lhs, VPragmaType::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VPragmaType::en lhs, const VPragmaType& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VPragmaType& lhs, VPragmaType::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VPragmaType::en lhs, const VPragmaType& rhs) { return lhs == rhs.m_e; }
//######################################################################
// ######################################################################
class VEdgeType final {
public:
@ -325,17 +327,19 @@ public:
VEdgeType()
: m_e{ET_ILLEGAL} {}
// cppcheck-suppress noExplicitConstructor
VEdgeType(en _e)
constexpr VEdgeType(en _e)
: m_e{_e} {}
explicit VEdgeType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
};
inline bool operator==(const VEdgeType& lhs, const VEdgeType& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VEdgeType& lhs, VEdgeType::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VEdgeType::en lhs, const VEdgeType& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VEdgeType& lhs, const VEdgeType& rhs) {
return lhs.m_e == rhs.m_e;
}
constexpr bool operator==(const VEdgeType& lhs, VEdgeType::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VEdgeType::en lhs, const VEdgeType& rhs) { return lhs == rhs.m_e; }
//######################################################################
// ######################################################################
class VAttrType final {
public:
@ -406,17 +410,19 @@ public:
VAttrType()
: m_e{ILLEGAL} {}
// cppcheck-suppress noExplicitConstructor
VAttrType(en _e)
constexpr VAttrType(en _e)
: m_e{_e} {}
explicit VAttrType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
};
inline bool operator==(const VAttrType& lhs, const VAttrType& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VAttrType& lhs, VAttrType::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VAttrType::en lhs, const VAttrType& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VAttrType& lhs, const VAttrType& rhs) {
return lhs.m_e == rhs.m_e;
}
constexpr bool operator==(const VAttrType& lhs, VAttrType::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VAttrType::en lhs, const VAttrType& rhs) { return lhs == rhs.m_e; }
//######################################################################
// ######################################################################
class VBasicDTypeKwd final {
public:
@ -473,11 +479,11 @@ public:
VBasicDTypeKwd()
: m_e{UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor
VBasicDTypeKwd(en _e)
constexpr VBasicDTypeKwd(en _e)
: m_e{_e} {}
explicit VBasicDTypeKwd(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
int width() const {
switch (m_e) {
case BIT: return 1; // scalar, can't bit extract unless ranged
@ -558,13 +564,13 @@ public:
}
}
};
inline bool operator==(const VBasicDTypeKwd& lhs, const VBasicDTypeKwd& rhs) {
constexpr bool operator==(const VBasicDTypeKwd& lhs, const VBasicDTypeKwd& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const VBasicDTypeKwd& lhs, VBasicDTypeKwd::en rhs) {
constexpr bool operator==(const VBasicDTypeKwd& lhs, VBasicDTypeKwd::en rhs) {
return lhs.m_e == rhs;
}
inline bool operator==(VBasicDTypeKwd::en lhs, const VBasicDTypeKwd& rhs) {
constexpr bool operator==(VBasicDTypeKwd::en lhs, const VBasicDTypeKwd& rhs) {
return lhs == rhs.m_e;
}
@ -577,11 +583,11 @@ public:
VDirection()
: m_e{NONE} {}
// cppcheck-suppress noExplicitConstructor
VDirection(en _e)
constexpr VDirection(en _e)
: m_e{_e} {}
explicit VDirection(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
const char* ascii() const {
static const char* const names[] = {"NONE", "INPUT", "OUTPUT", "INOUT", "REF", "CONSTREF"};
return names[m_e];
@ -605,14 +611,16 @@ public:
bool isWritable() const { return m_e == OUTPUT || m_e == INOUT || m_e == REF; }
bool isRefOrConstRef() const { return m_e == REF || m_e == CONSTREF; }
};
inline bool operator==(const VDirection& lhs, const VDirection& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VDirection& lhs, VDirection::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VDirection::en lhs, const VDirection& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VDirection& lhs, const VDirection& rhs) {
return lhs.m_e == rhs.m_e;
}
constexpr bool operator==(const VDirection& lhs, VDirection::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VDirection::en lhs, const VDirection& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const VDirection& rhs) {
return os << rhs.ascii();
}
//######################################################################
// ######################################################################
/// Boolean or unknown
class VBoolOrUnknown final {
@ -623,7 +631,7 @@ public:
VBoolOrUnknown()
: m_e{BU_UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor
VBoolOrUnknown(en _e)
constexpr VBoolOrUnknown(en _e)
: m_e{_e} {}
explicit VBoolOrUnknown(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
@ -638,13 +646,13 @@ public:
bool unknown() const { return m_e == BU_UNKNOWN; }
void setTrueOrFalse(bool flag) { m_e = flag ? BU_TRUE : BU_FALSE; }
};
inline bool operator==(const VBoolOrUnknown& lhs, const VBoolOrUnknown& rhs) {
constexpr bool operator==(const VBoolOrUnknown& lhs, const VBoolOrUnknown& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const VBoolOrUnknown& lhs, VBoolOrUnknown::en rhs) {
constexpr bool operator==(const VBoolOrUnknown& lhs, VBoolOrUnknown::en rhs) {
return lhs.m_e == rhs;
}
inline bool operator==(VBoolOrUnknown::en lhs, const VBoolOrUnknown& rhs) {
constexpr bool operator==(VBoolOrUnknown::en lhs, const VBoolOrUnknown& rhs) {
return lhs == rhs.m_e;
}
inline std::ostream& operator<<(std::ostream& os, const VBoolOrUnknown& rhs) {
@ -662,7 +670,7 @@ public:
VJoinType()
: m_e{JOIN} {}
// cppcheck-suppress noExplicitConstructor
VJoinType(en _e)
constexpr VJoinType(en _e)
: m_e{_e} {}
explicit VJoinType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
@ -678,14 +686,16 @@ public:
bool joinAny() const { return m_e == JOIN_ANY; }
bool joinNone() const { return m_e == JOIN_NONE; }
};
inline bool operator==(const VJoinType& lhs, const VJoinType& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VJoinType& lhs, VJoinType::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VJoinType::en lhs, const VJoinType& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VJoinType& lhs, const VJoinType& rhs) {
return lhs.m_e == rhs.m_e;
}
constexpr bool operator==(const VJoinType& lhs, VJoinType::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VJoinType::en lhs, const VJoinType& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const VJoinType& rhs) {
return os << rhs.ascii();
}
//######################################################################
// ######################################################################
class VVarType final {
public:
@ -715,11 +725,11 @@ public:
VVarType()
: m_e{UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor
VVarType(en _e)
constexpr VVarType(en _e)
: m_e{_e} {}
explicit VVarType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
const char* ascii() const {
static const char* const names[] = {
"?", "GPARAM", "LPARAM", "GENVAR", "VAR", "SUPPLY0", "SUPPLY1",
@ -750,14 +760,14 @@ public:
return (m_e == BLOCKTEMP || m_e == MODULETEMP || m_e == STMTTEMP || m_e == XTEMP);
}
};
inline bool operator==(const VVarType& lhs, const VVarType& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VVarType& lhs, VVarType::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VVarType::en lhs, const VVarType& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VVarType& lhs, const VVarType& rhs) { return lhs.m_e == rhs.m_e; }
constexpr bool operator==(const VVarType& lhs, VVarType::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VVarType::en lhs, const VVarType& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const VVarType& rhs) {
return os << rhs.ascii();
}
//######################################################################
// ######################################################################
class VBranchPred final {
public:
@ -767,11 +777,11 @@ public:
VBranchPred()
: m_e{BP_UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor
VBranchPred(en _e)
constexpr VBranchPred(en _e)
: m_e{_e} {}
explicit VBranchPred(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
bool unknown() const { return m_e == BP_UNKNOWN; }
bool likely() const { return m_e == BP_LIKELY; }
bool unlikely() const { return m_e == BP_UNLIKELY; }
@ -789,16 +799,16 @@ public:
return names[m_e];
}
};
inline bool operator==(const VBranchPred& lhs, const VBranchPred& rhs) {
constexpr bool operator==(const VBranchPred& lhs, const VBranchPred& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const VBranchPred& lhs, VBranchPred::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VBranchPred::en lhs, const VBranchPred& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VBranchPred& lhs, VBranchPred::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VBranchPred::en lhs, const VBranchPred& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const VBranchPred& rhs) {
return os << rhs.ascii();
}
//######################################################################
// ######################################################################
class VVarAttrClocker final {
public:
@ -808,11 +818,11 @@ public:
VVarAttrClocker()
: m_e{CLOCKER_UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor
VVarAttrClocker(en _e)
constexpr VVarAttrClocker(en _e)
: m_e{_e} {}
explicit VVarAttrClocker(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
bool unknown() const { return m_e == CLOCKER_UNKNOWN; }
VVarAttrClocker invert() const {
if (m_e == CLOCKER_YES) {
@ -828,13 +838,13 @@ public:
return names[m_e];
}
};
inline bool operator==(const VVarAttrClocker& lhs, const VVarAttrClocker& rhs) {
constexpr bool operator==(const VVarAttrClocker& lhs, const VVarAttrClocker& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const VVarAttrClocker& lhs, VVarAttrClocker::en rhs) {
constexpr bool operator==(const VVarAttrClocker& lhs, VVarAttrClocker::en rhs) {
return lhs.m_e == rhs;
}
inline bool operator==(VVarAttrClocker::en lhs, const VVarAttrClocker& rhs) {
constexpr bool operator==(VVarAttrClocker::en lhs, const VVarAttrClocker& rhs) {
return lhs == rhs.m_e;
}
inline std::ostream& operator<<(std::ostream& os, const VVarAttrClocker& rhs) {
@ -850,21 +860,23 @@ public:
VAlwaysKwd()
: m_e{ALWAYS} {}
// cppcheck-suppress noExplicitConstructor
VAlwaysKwd(en _e)
constexpr VAlwaysKwd(en _e)
: m_e{_e} {}
explicit VAlwaysKwd(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
const char* ascii() const {
static const char* const names[] = {"always", "always_ff", "always_latch", "always_comb"};
return names[m_e];
}
};
inline bool operator==(const VAlwaysKwd& lhs, const VAlwaysKwd& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VAlwaysKwd& lhs, VAlwaysKwd::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VAlwaysKwd::en lhs, const VAlwaysKwd& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VAlwaysKwd& lhs, const VAlwaysKwd& rhs) {
return lhs.m_e == rhs.m_e;
}
constexpr bool operator==(const VAlwaysKwd& lhs, VAlwaysKwd::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VAlwaysKwd::en lhs, const VAlwaysKwd& rhs) { return lhs == rhs.m_e; }
//######################################################################
// ######################################################################
class VCaseType final {
public:
@ -873,17 +885,19 @@ public:
VCaseType()
: m_e{CT_CASE} {}
// cppcheck-suppress noExplicitConstructor
VCaseType(en _e)
constexpr VCaseType(en _e)
: m_e{_e} {}
explicit VCaseType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
};
inline bool operator==(const VCaseType& lhs, const VCaseType& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VCaseType& lhs, VCaseType::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VCaseType::en lhs, const VCaseType& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VCaseType& lhs, const VCaseType& rhs) {
return lhs.m_e == rhs.m_e;
}
constexpr bool operator==(const VCaseType& lhs, VCaseType::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VCaseType::en lhs, const VCaseType& rhs) { return lhs == rhs.m_e; }
//######################################################################
// ######################################################################
class VDisplayType final {
public:
@ -901,11 +915,11 @@ public:
VDisplayType()
: m_e{DT_DISPLAY} {}
// cppcheck-suppress noExplicitConstructor
VDisplayType(en _e)
constexpr VDisplayType(en _e)
: m_e{_e} {}
explicit VDisplayType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
bool addNewline() const { return m_e != DT_WRITE; }
bool needScopeTracking() const { return m_e != DT_DISPLAY && m_e != DT_WRITE; }
const char* ascii() const {
@ -914,13 +928,13 @@ public:
return names[m_e];
}
};
inline bool operator==(const VDisplayType& lhs, const VDisplayType& rhs) {
constexpr bool operator==(const VDisplayType& lhs, const VDisplayType& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const VDisplayType& lhs, VDisplayType::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VDisplayType::en lhs, const VDisplayType& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VDisplayType& lhs, VDisplayType::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VDisplayType::en lhs, const VDisplayType& rhs) { return lhs == rhs.m_e; }
//######################################################################
// ######################################################################
class VDumpCtlType final {
public:
@ -929,24 +943,24 @@ public:
VDumpCtlType()
: m_e{ON} {}
// cppcheck-suppress noExplicitConstructor
VDumpCtlType(en _e)
constexpr VDumpCtlType(en _e)
: m_e{_e} {}
explicit VDumpCtlType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
const char* ascii() const {
static const char* const names[] = {"$dumpfile", "$dumpvars", "$dumpall", "$dumpflush",
"$dumplimit", "$dumpoff", "$dumpon"};
return names[m_e];
}
};
inline bool operator==(const VDumpCtlType& lhs, const VDumpCtlType& rhs) {
constexpr bool operator==(const VDumpCtlType& lhs, const VDumpCtlType& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const VDumpCtlType& lhs, VDumpCtlType::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VDumpCtlType::en lhs, const VDumpCtlType& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VDumpCtlType& lhs, VDumpCtlType::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VDumpCtlType::en lhs, const VDumpCtlType& rhs) { return lhs == rhs.m_e; }
//######################################################################
// ######################################################################
class VParseRefExp final {
public:
@ -959,26 +973,26 @@ public:
VParseRefExp()
: m_e{PX_NONE} {}
// cppcheck-suppress noExplicitConstructor
VParseRefExp(en _e)
constexpr VParseRefExp(en _e)
: m_e{_e} {}
explicit VParseRefExp(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
const char* ascii() const {
static const char* const names[] = {"", "$root", "TEXT", "PREDOT"};
return names[m_e];
}
};
inline bool operator==(const VParseRefExp& lhs, const VParseRefExp& rhs) {
constexpr bool operator==(const VParseRefExp& lhs, const VParseRefExp& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const VParseRefExp& lhs, VParseRefExp::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VParseRefExp::en lhs, const VParseRefExp& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VParseRefExp& lhs, VParseRefExp::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VParseRefExp::en lhs, const VParseRefExp& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const VParseRefExp& rhs) {
return os << rhs.ascii();
}
//######################################################################
// ######################################################################
class VStrength final {
public:
@ -986,28 +1000,29 @@ public:
enum en m_e;
// cppcheck-suppress noExplicitConstructor
VStrength(en strengthLevel)
constexpr VStrength(en strengthLevel)
: m_e(strengthLevel) {}
explicit VStrength(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
const char* ascii() const {
static const char* const names[]
= {"highz", "small", "medium", "weak", "large", "pull", "strong", "supply"};
return names[m_e];
}
};
inline bool operator==(const VStrength& lhs, const VStrength& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VStrength& lhs, VStrength::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VStrength::en lhs, const VStrength& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VStrength& lhs, const VStrength& rhs) {
return lhs.m_e == rhs.m_e;
}
constexpr bool operator==(const VStrength& lhs, VStrength::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VStrength::en lhs, const VStrength& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const VStrength& rhs) {
return os << rhs.ascii();
}
//######################################################################
// VNumRange - Structure containing numeric range information
// See also AstRange, which is a symbolic version of this
// ######################################################################
// VNumRange - Structure containing numeric range information
// See also AstRange, which is a symbolic version of this
class VNumRange final {
public:
@ -1083,26 +1098,26 @@ public:
VUseType()
: m_e{IMP_FWD_CLASS} {}
// cppcheck-suppress noExplicitConstructor
VUseType(en _e)
constexpr VUseType(en _e)
: m_e{_e} {}
explicit VUseType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
bool isInclude() const { return m_e == IMP_INCLUDE || m_e == INT_INCLUDE; }
bool isFwdClass() const { return m_e == IMP_FWD_CLASS || m_e == INT_FWD_CLASS; }
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
const char* ascii() const {
static const char* const names[] = {"IMP_INC", "INT_INC", "IMP_FWD", "INT_FWD"};
return names[m_e];
}
};
inline bool operator==(const VUseType& lhs, const VUseType& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VUseType& lhs, VUseType::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VUseType::en lhs, const VUseType& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VUseType& lhs, const VUseType& rhs) { return lhs.m_e == rhs.m_e; }
constexpr bool operator==(const VUseType& lhs, VUseType::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VUseType::en lhs, const VUseType& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const VUseType& rhs) {
return os << rhs.ascii();
}
//######################################################################
// ######################################################################
class VBasicTypeKey final {
public:

2
src/V3CCtors.cpp
View File

@ -46,7 +46,7 @@ private:
public:
// cppcheck-suppress noExplicitConstructor
VCtorType(en _e)
constexpr VCtorType(en _e)
: m_e{_e} {}
bool isClass() const { return m_e == CLASS; }
bool isCoverage() const { return m_e == COVERAGE; }

12
src/V3Error.h
View File

@ -146,12 +146,12 @@ public:
V3ErrorCode()
: m_e{EC_MIN} {}
// cppcheck-suppress noExplicitConstructor
V3ErrorCode(en _e)
constexpr V3ErrorCode(en _e)
: m_e{_e} {}
explicit V3ErrorCode(const char* msgp); // Matching code or ERROR
explicit V3ErrorCode(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
const char* ascii() const {
// clang-format off
static const char* const names[] = {
@ -221,16 +221,16 @@ public:
|| m_e == VARHIDDEN);
}
};
inline bool operator==(const V3ErrorCode& lhs, const V3ErrorCode& rhs) {
constexpr bool operator==(const V3ErrorCode& lhs, const V3ErrorCode& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const V3ErrorCode& lhs, V3ErrorCode::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(V3ErrorCode::en lhs, const V3ErrorCode& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const V3ErrorCode& lhs, V3ErrorCode::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(V3ErrorCode::en lhs, const V3ErrorCode& rhs) { return lhs == rhs.m_e; }
inline std::ostream& operator<<(std::ostream& os, const V3ErrorCode& rhs) {
return os << rhs.ascii();
}
//######################################################################
// ######################################################################
class V3Error final {
// Base class for any object that wants debugging and error reporting

10
src/V3Global.h
View File

@ -70,19 +70,19 @@ public:
VWidthMinUsage()
: m_e{LINT_WIDTH} {}
// cppcheck-suppress noExplicitConstructor
VWidthMinUsage(en _e)
constexpr VWidthMinUsage(en _e)
: m_e{_e} {}
explicit VWidthMinUsage(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
};
inline bool operator==(const VWidthMinUsage& lhs, const VWidthMinUsage& rhs) {
constexpr bool operator==(const VWidthMinUsage& lhs, const VWidthMinUsage& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const VWidthMinUsage& lhs, VWidthMinUsage::en rhs) {
constexpr bool operator==(const VWidthMinUsage& lhs, VWidthMinUsage::en rhs) {
return lhs.m_e == rhs;
}
inline bool operator==(VWidthMinUsage::en lhs, const VWidthMinUsage& rhs) {
constexpr bool operator==(VWidthMinUsage::en lhs, const VWidthMinUsage& rhs) {
return lhs == rhs.m_e;
}

8
src/V3Graph.h
View File

@ -61,7 +61,7 @@ public:
: m_e{_e} {}
explicit constexpr GraphWay(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
const char* ascii() const {
static const char* const names[] = {"FORWARD", "REVERSE"};
return names[m_e];
@ -71,9 +71,9 @@ public:
constexpr bool forward() const { return m_e == FORWARD; }
constexpr bool reverse() const { return m_e != FORWARD; }
};
inline bool operator==(const GraphWay& lhs, const GraphWay& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const GraphWay& lhs, GraphWay::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(GraphWay::en lhs, const GraphWay& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const GraphWay& lhs, const GraphWay& rhs) { return lhs.m_e == rhs.m_e; }
constexpr bool operator==(const GraphWay& lhs, GraphWay::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(GraphWay::en lhs, const GraphWay& rhs) { return lhs == rhs.m_e; }
//============================================================================

4
src/V3LangCode.h
View File

@ -58,12 +58,12 @@ public:
V3LangCode()
: m_e{L_ERROR} {}
// cppcheck-suppress noExplicitConstructor
V3LangCode(en _e)
constexpr V3LangCode(en _e)
: m_e{_e} {}
explicit V3LangCode(const char* textp);
explicit V3LangCode(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
};
//######################################################################

40
src/V3Options.h
View File

@ -42,24 +42,24 @@ public:
VOptionBool()
: m_e{OPT_DEFAULT_FALSE} {}
// cppcheck-suppress noExplicitConstructor
VOptionBool(en _e)
constexpr VOptionBool(en _e)
: m_e{_e} {}
explicit VOptionBool(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
bool isDefault() const { return m_e == OPT_DEFAULT_FALSE || m_e == OPT_DEFAULT_TRUE; }
bool isTrue() const { return m_e == OPT_TRUE || m_e == OPT_DEFAULT_TRUE; }
bool isSetTrue() const { return m_e == OPT_TRUE; }
bool isSetFalse() const { return m_e == OPT_FALSE; }
void setTrueOrFalse(bool flag) { m_e = flag ? OPT_TRUE : OPT_FALSE; }
};
inline bool operator==(const VOptionBool& lhs, const VOptionBool& rhs) {
constexpr bool operator==(const VOptionBool& lhs, const VOptionBool& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const VOptionBool& lhs, VOptionBool::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VOptionBool::en lhs, const VOptionBool& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VOptionBool& lhs, VOptionBool::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VOptionBool::en lhs, const VOptionBool& rhs) { return lhs == rhs.m_e; }
//######################################################################
// ######################################################################
class VTimescale final {
public:
@ -81,7 +81,7 @@ public:
VTimescale()
: m_e{NONE} {}
// cppcheck-suppress noExplicitConstructor
VTimescale(en _e)
constexpr VTimescale(en _e)
: m_e{_e} {}
explicit VTimescale(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
@ -116,26 +116,30 @@ public:
return values[m_e];
}
};
inline bool operator==(const VTimescale& lhs, const VTimescale& rhs) { return lhs.m_e == rhs.m_e; }
inline bool operator==(const VTimescale& lhs, VTimescale::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(VTimescale::en lhs, const VTimescale& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const VTimescale& lhs, const VTimescale& rhs) {
return lhs.m_e == rhs.m_e;
}
constexpr bool operator==(const VTimescale& lhs, VTimescale::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(VTimescale::en lhs, const VTimescale& rhs) { return lhs == rhs.m_e; }
// Comparisons are based on time, not enum values, so seconds > milliseconds
inline bool operator<(const VTimescale& lhs, const VTimescale& rhs) { return lhs.m_e > rhs.m_e; }
constexpr bool operator<(const VTimescale& lhs, const VTimescale& rhs) {
return lhs.m_e > rhs.m_e;
}
inline std::ostream& operator<<(std::ostream& os, const VTimescale& rhs) {
return os << rhs.ascii();
}
//######################################################################
// ######################################################################
class TraceFormat final {
public:
enum en : uint8_t { VCD = 0, FST } m_e;
// cppcheck-suppress noExplicitConstructor
TraceFormat(en _e = VCD)
constexpr TraceFormat(en _e = VCD)
: m_e{_e} {}
explicit TraceFormat(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
bool fst() const { return m_e == FST; }
bool vcd() const { return m_e == VCD; }
string classBase() const {
@ -147,16 +151,16 @@ public:
return names[m_e];
}
};
inline bool operator==(const TraceFormat& lhs, const TraceFormat& rhs) {
constexpr bool operator==(const TraceFormat& lhs, const TraceFormat& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const TraceFormat& lhs, TraceFormat::en rhs) { return lhs.m_e == rhs; }
inline bool operator==(TraceFormat::en lhs, const TraceFormat& rhs) { return lhs == rhs.m_e; }
constexpr bool operator==(const TraceFormat& lhs, TraceFormat::en rhs) { return lhs.m_e == rhs; }
constexpr bool operator==(TraceFormat::en lhs, const TraceFormat& rhs) { return lhs == rhs.m_e; }
using V3StringList = std::vector<std::string>;
using V3StringSet = std::set<std::string>;
//######################################################################
// ######################################################################
// Information given by --hierarchical-block option
class V3HierarchicalBlockOption final {

10
src/V3OrderGraph.h
View File

@ -90,19 +90,19 @@ struct OrderVEdgeType {
OrderVEdgeType()
: m_e{VERTEX_UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor
OrderVEdgeType(en _e)
constexpr OrderVEdgeType(en _e)
: m_e{_e} {}
explicit OrderVEdgeType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; }
constexpr operator en() const { return m_e; }
};
inline bool operator==(const OrderVEdgeType& lhs, const OrderVEdgeType& rhs) {
constexpr bool operator==(const OrderVEdgeType& lhs, const OrderVEdgeType& rhs) {
return lhs.m_e == rhs.m_e;
}
inline bool operator==(const OrderVEdgeType& lhs, OrderVEdgeType::en rhs) {
constexpr bool operator==(const OrderVEdgeType& lhs, OrderVEdgeType::en rhs) {
return lhs.m_e == rhs;
}
inline bool operator==(OrderVEdgeType::en lhs, const OrderVEdgeType& rhs) {
constexpr bool operator==(OrderVEdgeType::en lhs, const OrderVEdgeType& rhs) {
return lhs == rhs.m_e;
}