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

Fix compile error under strict C++11 mode (#3463)

Browse Source
This commit is contained in:
Kevin Kiningham 2022-06-11 14:39:05 -07:00 committed by Geza Lore
parent 660d1059b0
commit ea8aaa21e8
1 changed files with 10 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/V3Ast.h
View File

@ -2021,11 +2021,12 @@ private:
return Default; return Default;
} }
template <typename T_Node> constexpr static void checkTypeParameter() { template <typename T_Node> constexpr static bool checkTypeParameter() {
static_assert(!std::is_const<T_Node>::value, static_assert(!std::is_const<T_Node>::value,
"Type parameter 'T_Node' should not be const qualified"); "Type parameter 'T_Node' should not be const qualified");
static_assert(std::is_base_of<AstNode, T_Node>::value, static_assert(std::is_base_of<AstNode, T_Node>::value,
"Type parameter 'T_Node' must be a subtype of AstNode"); "Type parameter 'T_Node' must be a subtype of AstNode");
return true;
} }
public: public:
@ -2035,25 +2036,25 @@ public:
// operation function in 'foreach' should be completely predictable by branch target caches in // operation function in 'foreach' should be completely predictable by branch target caches in
// modern CPUs, while it is basically unpredictable for VNVisitor. // modern CPUs, while it is basically unpredictable for VNVisitor.
template <typename T_Node> void foreach (std::function<void(T_Node*)> f) { template <typename T_Node> void foreach (std::function<void(T_Node*)> f) {
checkTypeParameter<T_Node>(); static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
foreachImpl<T_Node, /* VisitNext: */ false>(this, f); foreachImpl<T_Node, /* VisitNext: */ false>(this, f);
} }
// Same as above, but for 'const' nodes // Same as above, but for 'const' nodes
template <typename T_Node> void foreach (std::function<void(const T_Node*)> f) const { template <typename T_Node> void foreach (std::function<void(const T_Node*)> f) const {
checkTypeParameter<T_Node>(); static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
foreachImpl<const T_Node, /* VisitNext: */ false>(this, f); foreachImpl<const T_Node, /* VisitNext: */ false>(this, f);
} }
// Same as 'foreach' but also follows 'this->nextp()' // Same as 'foreach' but also follows 'this->nextp()'
template <typename T_Node> void foreachAndNext(std::function<void(T_Node*)> f) { template <typename T_Node> void foreachAndNext(std::function<void(T_Node*)> f) {
checkTypeParameter<T_Node>(); static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
foreachImpl<T_Node, /* VisitNext: */ true>(this, f); foreachImpl<T_Node, /* VisitNext: */ true>(this, f);
} }
// Same as 'foreach' but also follows 'this->nextp()' // Same as 'foreach' but also follows 'this->nextp()'
template <typename T_Node> void foreachAndNext(std::function<void(const T_Node*)> f) const { template <typename T_Node> void foreachAndNext(std::function<void(const T_Node*)> f) const {
checkTypeParameter<T_Node>(); static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
foreachImpl<const T_Node, /* VisitNext: */ true>(this, f); foreachImpl<const T_Node, /* VisitNext: */ true>(this, f);
} }
@ -2062,13 +2063,13 @@ public:
// present. Traversal is performed in some arbitrary order and is terminated as soon as the // present. Traversal is performed in some arbitrary order and is terminated as soon as the
// result can be determined. // result can be determined.
template <typename T_Node> bool exists(std::function<bool(T_Node*)> p) { template <typename T_Node> bool exists(std::function<bool(T_Node*)> p) {
checkTypeParameter<T_Node>(); static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
return predicateImpl<T_Node, /* Default: */ false, /* VisitNext: */ false>(this, p); return predicateImpl<T_Node, /* Default: */ false, /* VisitNext: */ false>(this, p);
} }
// Same as above, but for 'const' nodes // Same as above, but for 'const' nodes
template <typename T_Node> void exists(std::function<bool(const T_Node*)> p) const { template <typename T_Node> void exists(std::function<bool(const T_Node*)> p) const {
checkTypeParameter<T_Node>(); static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
return predicateImpl<const T_Node, /* Default: */ false, /* VisitNext: */ false>(this, p); return predicateImpl<const T_Node, /* Default: */ false, /* VisitNext: */ false>(this, p);
} }
@ -2077,13 +2078,13 @@ public:
// present. Traversal is performed in some arbitrary order and is terminated as soon as the // present. Traversal is performed in some arbitrary order and is terminated as soon as the
// result can be determined. // result can be determined.
template <typename T_Node> bool forall(std::function<bool(T_Node*)> p) { template <typename T_Node> bool forall(std::function<bool(T_Node*)> p) {
checkTypeParameter<T_Node>(); static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
return predicateImpl<T_Node, /* Default: */ true, /* VisitNext: */ false>(this, p); return predicateImpl<T_Node, /* Default: */ true, /* VisitNext: */ false>(this, p);
} }
// Same as above, but for 'const' nodes // Same as above, but for 'const' nodes
template <typename T_Node> void forall(std::function<bool(const T_Node*)> p) const { template <typename T_Node> void forall(std::function<bool(const T_Node*)> p) const {
checkTypeParameter<T_Node>(); static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
return predicateImpl<const T_Node, /* Default: */ true, /* VisitNext: */ false>(this, p); return predicateImpl<const T_Node, /* Default: */ true, /* VisitNext: */ false>(this, p);
} }