diff --git a/src/V3Ast.h b/src/V3Ast.h
index 8fb52b16c..54ef11526 100644
--- a/src/V3Ast.h
+++ b/src/V3Ast.h
@@ -44,6 +44,8 @@ class VFlagChildDType {};  // Used by parser.y to select constructor that sets c
 
 //######################################################################
 
+//######################################################################
+
 class AstType {
 public:
 #include "V3Ast__gen_types.h"	// From ./astgen
diff --git a/src/V3AstNodes.h b/src/V3AstNodes.h
index 341b023e2..258fc6b3a 100644
--- a/src/V3AstNodes.h
+++ b/src/V3AstNodes.h
@@ -28,9 +28,9 @@
 //######################################################################
 // Standard defines for all AstNode final classes
 
-#define ASTNODE_NODE_FUNCS(name,ucname)	\
+#define ASTNODE_NODE_FUNCS(name) \
     virtual ~Ast ##name() {} \
-    virtual AstType type() const { return AstType::at ##ucname; } \
+    virtual AstType type() const { return AstType::at ## name; } \
     virtual AstNode* clone() { return new Ast ##name (*this); } \
     virtual void accept(AstNVisitor& v, AstNUser* vup=NULL) { v.visit(this,vup); } \
     Ast ##name * cloneTree(bool cloneNext) { return AstNode::cloneTree(cloneNext)->cast ##name(); }
@@ -89,7 +89,7 @@ public:
 	:AstNodeMath(fl)
 	,m_num(V3Number(fl,1,1)) { dtypeSetLogicBool(); }
 
-    ASTNODE_NODE_FUNCS(Const, CONST)
+    ASTNODE_NODE_FUNCS(Const)
     virtual string name()	const { return num().ascii(); }		// * = Value
     virtual const V3Number& num()	const { return m_num; }		// * = Value
     uint32_t toUInt()  const { return num().toUInt(); }
@@ -125,7 +125,7 @@ public:
 	m_littleEndian = range.littleEndian();
 	setOp2p(new AstConst(fl,range.hi())); setOp3p(new AstConst(fl,range.lo()));
     }
-    ASTNODE_NODE_FUNCS(Range, RANGE)
+    ASTNODE_NODE_FUNCS(Range)
     AstNode* msbp() const { return op2p()->castNode(); }	// op2 = Msb expression
     AstNode* lsbp() const { return op3p()->castNode(); }	// op3 = Lsb expression
     AstNode* leftp() const { return littleEndian()?lsbp():msbp(); }  // How to show a declaration
@@ -147,7 +147,7 @@ public:
     AstGatePin(FileLine* fl, AstNode* lhsp, AstRange* rangep) : AstNodeMath(fl) {
 	setOp1p(lhsp); setOp2p(rangep);
     }
-    ASTNODE_NODE_FUNCS(GatePin, GATEPIN)
+    ASTNODE_NODE_FUNCS(GatePin)
     virtual string emitVerilog() { return "%l"; }
     virtual string emitC() { V3ERROR_NA; return ""; }
     virtual bool cleanOut() { return true; }
@@ -170,7 +170,7 @@ public:
 	childDTypep(dtp);  // Only for parser
 	dtypep(NULL);  // V3Width will resolve
     }
-    ASTNODE_NODE_FUNCS(ParamTypeDType, PARAMTYPEDTYPE)
+    ASTNODE_NODE_FUNCS(ParamTypeDType)
     AstNodeDType* getChildDTypep() const { return childDTypep(); }
     AstNodeDType* childDTypep() const { return op1p()->castNodeDType(); } // op1 = Type assigning to
     void	childDTypep(AstNodeDType* nodep) { setOp1p(nodep); }
@@ -203,7 +203,7 @@ public:
 	dtypep(NULL);  // V3Width will resolve
 	m_attrPublic = false;
     }
-    ASTNODE_NODE_FUNCS(Typedef, TYPEDEF)
+    ASTNODE_NODE_FUNCS(Typedef)
     virtual void dump(ostream& str);
     AstNodeDType* getChildDTypep() const { return childDTypep(); }
     AstNodeDType* childDTypep() const { return op1p()->castNodeDType(); } // op1 = Type assigning to
@@ -227,7 +227,7 @@ private:
 public:
     AstTypedefFwd(FileLine* fl, const string& name)
 	: AstNode(fl), m_name(name) {}
-    ASTNODE_NODE_FUNCS(TypedefFwd, TYPEDEFFWD)
+    ASTNODE_NODE_FUNCS(TypedefFwd)
     // METHODS
     virtual string name() const { return m_name; }
 };
@@ -248,7 +248,7 @@ public:
 	dtypep(NULL);  // V3Width will resolve
 	m_uniqueNum = uniqueNumInc();
     }
-    ASTNODE_NODE_FUNCS(DefImplicitDType, DEFIMPLICITDTYPE)
+    ASTNODE_NODE_FUNCS(DefImplicitDType)
     virtual bool same(AstNode* samep) const { return m_uniqueNum==samep->castDefImplicitDType()->m_uniqueNum; }
     virtual V3Hash sameHash() const { return V3Hash(m_uniqueNum); }
     AstNodeDType* getChildDTypep() const { return childDTypep(); }
@@ -290,7 +290,7 @@ public:
 	int width = subDTypep()->width() * rangep->elementsConst();
 	widthForce(width,width);
     }
-    ASTNODE_NODE_FUNCS(PackArrayDType, PACKARRAYDTYPE)
+    ASTNODE_NODE_FUNCS(PackArrayDType)
 };
 
 class AstUnpackArrayDType : public AstNodeArrayDType {
@@ -315,7 +315,7 @@ public:
 	// For backward compatibility AstNodeArrayDType and others inherit width and signing from the subDType/base type
 	widthFromSub(subDTypep());
     }
-    ASTNODE_NODE_FUNCS(UnpackArrayDType, UNPACKARRAYDTYPE)
+    ASTNODE_NODE_FUNCS(UnpackArrayDType)
 };
 
 class AstBasicDType : public AstNodeDType {
@@ -386,7 +386,7 @@ private:
 	dtypep(this);
     }
 public:
-    ASTNODE_NODE_FUNCS(BasicDType, BASICDTYPE)
+    ASTNODE_NODE_FUNCS(BasicDType)
     virtual void dump(ostream& str);
     virtual V3Hash sameHash() const { return V3Hash(V3Hash(m.m_keyword), V3Hash(m.m_nrange.hi())); }
     virtual bool same(AstNode* samep) const {  // width/widthMin/numeric compared elsewhere
@@ -447,7 +447,7 @@ public:
 	dtypep(NULL);  // V3Width will resolve
 	widthFromSub(subDTypep());
     }
-    ASTNODE_NODE_FUNCS(ConstDType, CONSTDTYPE)
+    ASTNODE_NODE_FUNCS(ConstDType)
     virtual const char* broken() const { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
 						     || (!m_refDTypep && childDTypep()))); return NULL; }
     virtual void cloneRelink() { if (m_refDTypep && m_refDTypep->clonep()) {
@@ -488,7 +488,7 @@ public:
     AstIfaceRefDType(FileLine* fl, const string& cellName, const string& ifaceName, const string& modport)
 	: AstNodeDType(fl), m_cellName(cellName), m_ifaceName(ifaceName), m_modportName(modport),
 	  m_ifacep(NULL), m_cellp(NULL), m_modportp(NULL) { }
-    ASTNODE_NODE_FUNCS(IfaceRefDType, IFACEREFDTYPE)
+    ASTNODE_NODE_FUNCS(IfaceRefDType)
     // METHODS
     virtual const char* broken() const;
     virtual void dump(ostream& str=cout);
@@ -529,7 +529,7 @@ public:
 	dtypeFrom(defp->dtypep());
 	widthFromSub(subDTypep());
     }
-    ASTNODE_NODE_FUNCS(RefDType, REFDTYPE)
+    ASTNODE_NODE_FUNCS(RefDType)
     // METHODS
     virtual const char* broken() const { BROKEN_RTN(m_refDTypep && !m_refDTypep->brokeExists()); return NULL; }
     virtual void cloneRelink() { if (m_refDTypep && m_refDTypep->clonep()) {
@@ -574,7 +574,7 @@ class AstStructDType : public AstNodeClassDType {
 public:
     AstStructDType(FileLine* fl, AstNumeric numericUnpack)
 	: AstNodeClassDType(fl,numericUnpack) {}
-    ASTNODE_NODE_FUNCS(StructDType, STRUCTDTYPE)
+    ASTNODE_NODE_FUNCS(StructDType)
     virtual string verilogKwd() const { return "struct"; };
 };
 
@@ -583,7 +583,7 @@ public:
     //UNSUP: bool isTagged;
     AstUnionDType(FileLine* fl, AstNumeric numericUnpack)
 	: AstNodeClassDType(fl,numericUnpack) {}
-    ASTNODE_NODE_FUNCS(UnionDType, UNIONDTYPE)
+    ASTNODE_NODE_FUNCS(UnionDType)
     virtual string verilogKwd() const { return "union"; };
 };
 
@@ -611,7 +611,7 @@ public:
 	dtypep(this);
 	widthFromSub(subDTypep());
     }
-    ASTNODE_NODE_FUNCS(MemberDType, MEMBERDTYPE)
+    ASTNODE_NODE_FUNCS(MemberDType)
     virtual string name()	const { return m_name; }		// * = Var name
     virtual bool hasDType() const { return true; }
     virtual bool maybePointedTo() const { return true; }
@@ -644,7 +644,7 @@ public:
     AstEnumItem(FileLine* fl, const string& name, AstNode* rangep, AstNode* initp)
 	: AstNode(fl), m_name(name)
 	{ addNOp1p(rangep); addNOp2p(initp); }
-    ASTNODE_NODE_FUNCS(EnumItem, ENUMITEM)
+    ASTNODE_NODE_FUNCS(EnumItem)
     virtual string name() const { return m_name; }
     virtual bool maybePointedTo() const { return true; }
     virtual bool hasDType() const { return true; }
@@ -664,7 +664,7 @@ public:
 	: AstNodeMath(fl), m_itemp(itemp), m_packagep(packagep) {
 	dtypeFrom(m_itemp);
     }
-    ASTNODE_NODE_FUNCS(EnumItemRef, ENUMITEMREF)
+    ASTNODE_NODE_FUNCS(EnumItemRef)
     virtual void dump(ostream& str);
     virtual string name() const { return itemp()->name(); }
     virtual const char* broken() const { BROKEN_RTN(!itemp()); return NULL; }
@@ -696,7 +696,7 @@ public:
 	widthFromSub(subDTypep());
 	m_uniqueNum = uniqueNumInc();
     }
-    ASTNODE_NODE_FUNCS(EnumDType, ENUMDTYPE)
+    ASTNODE_NODE_FUNCS(EnumDType)
     virtual const char* broken() const { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
 						     || (!m_refDTypep && childDTypep()))); return NULL; }
     virtual void cloneRelink() { if (m_refDTypep && m_refDTypep->clonep()) {
@@ -729,7 +729,7 @@ class AstParseTypeDType : public AstNodeDType {
 public:
     AstParseTypeDType(FileLine* fl)
 	: AstNodeDType(fl) {}
-    ASTNODE_NODE_FUNCS(ParseTypeDType, PARSETYPEDTYPE)
+    ASTNODE_NODE_FUNCS(ParseTypeDType)
     AstNodeDType* dtypep() const { return NULL; }
     // METHODS
     virtual AstBasicDType* basicp() const { return NULL; }
@@ -763,7 +763,7 @@ public:
 	:AstNodeSel(fl, fromp, new AstConst(fl,bit)), m_start(0), m_length(1) {
 	init(fromp);
     }
-    ASTNODE_NODE_FUNCS(ArraySel, ARRAYSEL)
+    ASTNODE_NODE_FUNCS(ArraySel)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstArraySel(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) {
 	V3ERROR_NA; /* How can from be a const? */ }
@@ -793,7 +793,7 @@ public:
 	:AstNodeSel(fl, fromp, bitp) {
 	dtypeSetUInt32(); // Always used on IData arrays so returns word entities
     }
-    ASTNODE_NODE_FUNCS(WordSel, WORDSEL)
+    ASTNODE_NODE_FUNCS(WordSel)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstWordSel(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& from, const V3Number& bit) { V3ERROR_NA; }
     virtual string emitVerilog() { return "%k(%l%f[%r])"; }
@@ -810,7 +810,7 @@ class AstSelExtract : public AstNodePreSel {
 public:
     AstSelExtract(FileLine* fl, AstNode* fromp, AstNode* msbp, AstNode* lsbp)
 	: AstNodePreSel(fl, fromp, msbp, lsbp) {}
-    ASTNODE_NODE_FUNCS(SelExtract, SELEXTRACT)
+    ASTNODE_NODE_FUNCS(SelExtract)
     AstNode*	msbp() const { return rhsp(); }
     AstNode*	lsbp() const { return thsp(); }
 };
@@ -823,7 +823,7 @@ public:
 	:AstNodePreSel(fl, fromp, bitp, NULL) {
 	if (v3Global.assertDTypesResolved()) { v3fatalSrc("not coded to create after dtypes resolved"); }
     }
-    ASTNODE_NODE_FUNCS(SelBit, SELBIT)
+    ASTNODE_NODE_FUNCS(SelBit)
     AstNode*	bitp() const { return rhsp(); }
 };
 
@@ -833,7 +833,7 @@ class AstSelPlus : public AstNodePreSel {
 public:
     AstSelPlus(FileLine* fl, AstNode* fromp, AstNode* bitp, AstNode* widthp)
 	:AstNodePreSel(fl, fromp, bitp, widthp) {}
-    ASTNODE_NODE_FUNCS(SelPlus, SELPLUS)
+    ASTNODE_NODE_FUNCS(SelPlus)
     AstNode*	bitp() const { return rhsp(); }
     AstNode*	widthp() const { return thsp(); }
 };
@@ -844,7 +844,7 @@ class AstSelMinus : public AstNodePreSel {
 public:
     AstSelMinus(FileLine* fl, AstNode* fromp, AstNode* bitp, AstNode* widthp)
 	:AstNodePreSel(fl, fromp, bitp, widthp) {}
-    ASTNODE_NODE_FUNCS(SelMinus, SELMINUS)
+    ASTNODE_NODE_FUNCS(SelMinus)
     AstNode*	bitp() const { return rhsp(); }
     AstNode*	widthp() const { return thsp(); }
 };
@@ -874,7 +874,7 @@ public:
 	m_declElWidth = 1;
 	dtypeSetLogicSized(bitwidth,bitwidth,AstNumeric::UNSIGNED);
     }
-    ASTNODE_NODE_FUNCS(Sel, SEL)
+    ASTNODE_NODE_FUNCS(Sel)
     virtual void dump(ostream& str);
     virtual void numberOperate(V3Number& out, const V3Number& from, const V3Number& bit, const V3Number& width) {
 	out.opSel(from, bit.toUInt()+width.toUInt()-1, bit.toUInt()); }
@@ -921,7 +921,7 @@ public:
 	dtypep(dtp);
 	m_name = dtp->name();
     }
-    ASTNODE_NODE_FUNCS(MemberSel, MEMBERSEL)
+    ASTNODE_NODE_FUNCS(MemberSel)
     virtual string name() const { return m_name; }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) {
 	V3ERROR_NA; /* How can from be a const? */ }
@@ -951,7 +951,7 @@ public:
 	setOp1p(fromp);
 	addNOp2p(pinsp);
     }
-    ASTNODE_NODE_FUNCS(MethodSel, METHODSEL)
+    ASTNODE_NODE_FUNCS(MethodSel)
     virtual string name() const { return m_name; }		// * = Var name
     virtual void name(const string& name) { m_name = name; }
     AstNode* fromp() const { return op1p()->castNode(); }	// op1 = Extracting what (NULL=TBD during parsing)
@@ -1050,7 +1050,7 @@ public:
 	}
 	dtypeFrom(examplep);
     }
-    ASTNODE_NODE_FUNCS(Var, VAR)
+    ASTNODE_NODE_FUNCS(Var)
     virtual void dump(ostream& str);
     virtual string name() const { return m_name; }		// * = Var name
     virtual bool hasDType() const { return true; }
@@ -1205,7 +1205,7 @@ public:
 	m_path = path;
     }
     virtual string name()	const { return m_name; }		// * = Scope name
-    ASTNODE_NODE_FUNCS(DefParam, DEFPARAM)
+    ASTNODE_NODE_FUNCS(DefParam)
     virtual bool cleanRhs() { return true; }
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(AstNode*) const { return true; }
@@ -1221,7 +1221,7 @@ public:
 	: AstNode(fl) {
 	addNOp1p(exprsp);
     }
-    ASTNODE_NODE_FUNCS(Implicit, IMPLICIT)
+    ASTNODE_NODE_FUNCS(Implicit)
     AstNode* exprsp() const { return op1p()->castNode(); }	// op1 = Assign from
 };
 
@@ -1240,7 +1240,7 @@ public:
 	     AstScope* aboveScopep, AstCell* aboveCellp)
 	:AstNode(fl)
 	,m_name(name) ,m_aboveScopep(aboveScopep) ,m_aboveCellp(aboveCellp), m_modp(modp) {}
-    ASTNODE_NODE_FUNCS(Scope, SCOPE)
+    ASTNODE_NODE_FUNCS(Scope)
     virtual void cloneRelink();
     virtual const char* broken() const;
     virtual bool maybePointedTo() const { return true; }
@@ -1269,7 +1269,7 @@ public:
     AstTopScope(FileLine* fl, AstScope* ascopep)
 	:AstNode(fl)
 	{addNOp2p(ascopep);}
-    ASTNODE_NODE_FUNCS(TopScope, TOPSCOPE)
+    ASTNODE_NODE_FUNCS(TopScope)
     AstNode*	stmtsp() 	const { return op1p()->castNode(); }
     void addStmtsp(AstNode* nodep) { addOp1p(nodep); }
     AstScope* scopep()		const { return op2p()->castScope(); }	// op1 = AstVarScope's
@@ -1293,7 +1293,7 @@ public:
 	m_trace = true;
 	dtypeFrom(varp);
     }
-    ASTNODE_NODE_FUNCS(VarScope, VARSCOPE)
+    ASTNODE_NODE_FUNCS(VarScope)
     virtual void cloneRelink() { if (m_varp && m_varp->clonep()) {
 	m_varp = m_varp->clonep()->castVar();
 	UASSERT(m_scopep->clonep(), "No clone cross link: "<<this);
@@ -1326,7 +1326,7 @@ public:
 	:AstNodeVarRef(fl, varscp->varp()->name(), varscp->varp(), lvalue) {	// because output/wire compression may lead to deletion of AstVar's
 	varScopep(varscp);
     }
-    ASTNODE_NODE_FUNCS(VarRef, VARREF)
+    ASTNODE_NODE_FUNCS(VarRef)
     virtual void dump(ostream& str);
     virtual V3Hash sameHash() const { return V3Hash(V3Hash(varp()->name()),V3Hash(hiername())); }
     virtual bool same(AstNode* samep) const { return same(samep->castVarRef()); }
@@ -1361,7 +1361,7 @@ public:
 	, m_dotted(dotted) {
 	dtypeFrom(varp);
     }
-    ASTNODE_NODE_FUNCS(VarXRef, VARXREF)
+    ASTNODE_NODE_FUNCS(VarXRef)
     virtual void dump(ostream& str);
     string	dotted() const { return m_dotted; }
     void	dotted(const string& dotted) { m_dotted = dotted; }
@@ -1406,7 +1406,7 @@ public:
 	m_modPTypep = NULL;
 	setNOp1p(exprp);
     }
-    ASTNODE_NODE_FUNCS(Pin, PIN)
+    ASTNODE_NODE_FUNCS(Pin)
     virtual void dump(ostream& str);
     virtual const char* broken() const {
 	BROKEN_RTN(m_modVarp && !m_modVarp->brokeExists());
@@ -1441,7 +1441,7 @@ public:
 	,m_name(name) {
 	setNOp1p(exprp);
     }
-    ASTNODE_NODE_FUNCS(Arg, ARG)
+    ASTNODE_NODE_FUNCS(Arg)
     virtual string name()	const { return m_name; }		// * = Pin name, ""=go by number
     virtual void name(const string& name) { m_name = name; }
     virtual V3Hash sameHash() const { return V3Hash(); }
@@ -1455,7 +1455,7 @@ class AstModule : public AstNodeModule {
 public:
     AstModule(FileLine* fl, const string& name)
 	: AstNodeModule (fl,name) {}
-    ASTNODE_NODE_FUNCS(Module, MODULE)
+    ASTNODE_NODE_FUNCS(Module)
     virtual string verilogKwd() const { return "module"; }
 };
 
@@ -1464,7 +1464,7 @@ class AstNotFoundModule : public AstNodeModule {
 public:
     AstNotFoundModule(FileLine* fl, const string& name)
 	: AstNodeModule (fl,name) {}
-    ASTNODE_NODE_FUNCS(NotFoundModule, NOTFOUNDMODULE)
+    ASTNODE_NODE_FUNCS(NotFoundModule)
     virtual string verilogKwd() const { return "/*not-found-*/ module"; }
 };
 
@@ -1473,7 +1473,7 @@ class AstPackage : public AstNodeModule {
 public:
     AstPackage(FileLine* fl, const string& name)
 	: AstNodeModule (fl,name) {}
-    ASTNODE_NODE_FUNCS(Package, PACKAGE)
+    ASTNODE_NODE_FUNCS(Package)
     virtual string verilogKwd() const { return "package"; }
     static string dollarUnitName() { return AstNode::encodeName("$unit"); }
     bool isDollarUnit() const { return name() == dollarUnitName(); }
@@ -1484,7 +1484,7 @@ class AstPrimitive : public AstNodeModule {
 public:
     AstPrimitive(FileLine* fl, const string& name)
 	: AstNodeModule (fl,name) {}
-    ASTNODE_NODE_FUNCS(Primitive, PRIMITIVE)
+    ASTNODE_NODE_FUNCS(Primitive)
     virtual string verilogKwd() const { return "primitive"; }
 };
 
@@ -1496,7 +1496,7 @@ private:
 public:
     AstPackageImport(FileLine* fl, AstPackage* packagep, const string& name)
 	: AstNode (fl), m_name(name), m_packagep(packagep) {}
-    ASTNODE_NODE_FUNCS(PackageImport, PACKAGEIMPORT)
+    ASTNODE_NODE_FUNCS(PackageImport)
     virtual const char* broken() const { BROKEN_RTN(!m_packagep || !m_packagep->brokeExists()); return NULL; }
     virtual void cloneRelink() { if (m_packagep && m_packagep->clonep()) m_packagep = m_packagep->clonep()->castPackage(); }
     virtual void dump(ostream& str);
@@ -1510,7 +1510,7 @@ class AstIface : public AstNodeModule {
 public:
     AstIface(FileLine* fl, const string& name)
 	: AstNodeModule (fl,name) { }
-    ASTNODE_NODE_FUNCS(Iface, IFACE)
+    ASTNODE_NODE_FUNCS(Iface)
 };
 
 class AstModportFTaskRef : public AstNode {
@@ -1524,7 +1524,7 @@ private:
 public:
     AstModportFTaskRef(FileLine* fl, const string& name, bool isExport)
 	: AstNode(fl), m_name(name), m_export(isExport), m_ftaskp(NULL) { }
-    ASTNODE_NODE_FUNCS(ModportFTaskRef, MODPORTFTASKREF)
+    ASTNODE_NODE_FUNCS(ModportFTaskRef)
     virtual const char* broken() const { BROKEN_RTN(m_ftaskp && !m_ftaskp->brokeExists()); return NULL; }
     virtual void dump(ostream& str);
     virtual string name() const { return m_name; }
@@ -1546,7 +1546,7 @@ private:
 public:
     AstModportVarRef(FileLine* fl, const string& name, AstVarType::en type)
 	: AstNode(fl), m_name(name), m_type(type), m_varp(NULL) { }
-    ASTNODE_NODE_FUNCS(ModportVarRef, MODPORTVARREF)
+    ASTNODE_NODE_FUNCS(ModportVarRef)
     virtual const char* broken() const { BROKEN_RTN(m_varp && !m_varp->brokeExists()); return NULL; }
     virtual void dump(ostream& str);
     virtual void cloneRelink() { if (m_varp && m_varp->clonep()) m_varp = m_varp->clonep()->castVar(); }
@@ -1568,7 +1568,7 @@ public:
         addNOp1p(varsp); }
     virtual string name() const { return m_name; }
     virtual bool maybePointedTo() const { return true; }
-    ASTNODE_NODE_FUNCS(Modport, MODPORT)
+    ASTNODE_NODE_FUNCS(Modport)
     AstNode* varsp() const { return op1p(); }	// op1 = List of Vars
 };
 
@@ -1588,7 +1588,7 @@ public:
 	, m_name(instName), m_origName(instName), m_modName(modName)
 	, m_modp(NULL), m_hasIfaceVar(false), m_trace(true) {
 	addNOp1p(pinsp); addNOp2p(paramsp); setNOp3p(rangep); }
-    ASTNODE_NODE_FUNCS(Cell, CELL)
+    ASTNODE_NODE_FUNCS(Cell)
     // No cloneRelink, we presume cloneee's want the same module linkages
     virtual void dump(ostream& str);
     virtual const char* broken() const { BROKEN_RTN(m_modp && !m_modp->brokeExists()); return NULL; }
@@ -1624,7 +1624,7 @@ public:
     AstCellInline(FileLine* fl, const string& name, const string& origModName)
 	: AstNode(fl)
 	, m_name(name), m_origModName(origModName) {}
-    ASTNODE_NODE_FUNCS(CellInline, CELLINLINE)
+    ASTNODE_NODE_FUNCS(CellInline)
     virtual void dump(ostream& str);
     // ACCESSORS
     virtual string name()	const { return m_name; }		// * = Cell name
@@ -1642,7 +1642,7 @@ public:
 	: AstNode(fl)
 	, m_name(name) {
 	addNOp1p(cellp); addNOp2p(exprp); }
-    ASTNODE_NODE_FUNCS(CellRef, CELLREF)
+    ASTNODE_NODE_FUNCS(CellRef)
     // ACCESSORS
     virtual string name()	const { return m_name; }	// * = Array name
     AstNode* cellp()		const { return op1p(); }	// op1 = Cell
@@ -1659,7 +1659,7 @@ public:
 	: AstNode(fl)
 	, m_name(name) {
 	addNOp1p(selectExprp); }
-    ASTNODE_NODE_FUNCS(CellArrayRef, CELLARRAYREF)
+    ASTNODE_NODE_FUNCS(CellArrayRef)
     // ACCESSORS
     virtual string name()	const { return m_name; }	// * = Array name
     AstNode* selp()		const { return op1p(); }	// op1 = Select expression
@@ -1675,7 +1675,7 @@ public:
 	: AstNode(fl)
 	, m_name(name) {
 	addNOp1p(refp); addNOp2p(crp); }
-    ASTNODE_NODE_FUNCS(UnlinkedRef, UNLINKEDREF)
+    ASTNODE_NODE_FUNCS(UnlinkedRef)
     // ACCESSORS
     virtual string name() const { return m_name; }	// * = Var name
     AstNode* refp() const { return op1p(); }		// op1 = VarXRef or AstNodeFTaskRef
@@ -1694,7 +1694,7 @@ public:
 	if (!cellsp->castCell()) cellsp->v3fatalSrc("Only cells allowed to be bound");
 	addNOp1p(cellsp);
     }
-    ASTNODE_NODE_FUNCS(Bind, BIND)
+    ASTNODE_NODE_FUNCS(Bind)
     // ACCESSORS
     virtual string name() const { return m_name; }		// * = Bind Target name
     virtual void name(const string& name) { m_name = name; }
@@ -1710,7 +1710,7 @@ public:
     AstPort(FileLine* fl, int pinnum, const string& name)
 	:AstNode(fl)
 	,m_pinNum(pinnum) ,m_name(name) {}
-    ASTNODE_NODE_FUNCS(Port, PORT)
+    ASTNODE_NODE_FUNCS(Port)
     virtual string name()	const { return m_name; }		// * = Port name
     int pinNum()		const { return m_pinNum; }		// * = Pin number, for order based instantiation
     AstNode* exprp()		const { return op1p()->castNode(); }	// op1 = Expression connected to port
@@ -1727,7 +1727,7 @@ public:
 	: AstNode(fileline) {
 	addNOp1p(stmtsp);
     }
-    ASTNODE_NODE_FUNCS(Generate, GENERATE)
+    ASTNODE_NODE_FUNCS(Generate)
     // op1 = Statements
     AstNode*	stmtsp() 	const { return op1p()->castNode(); }	// op1 = List of statements
     void addStmtp(AstNode* nodep) { addOp1p(nodep); }
@@ -1745,7 +1745,7 @@ private:
 public:
     AstParseRef(FileLine* fl, AstParseRefExp expect, const string& name, AstNode* lhsp, AstNodeFTaskRef* ftaskrefp)
 	:AstNode(fl), m_expect(expect), m_name(name) { setNOp1p(lhsp); setNOp2p(ftaskrefp); }
-    ASTNODE_NODE_FUNCS(ParseRef, PARSEREF)
+    ASTNODE_NODE_FUNCS(ParseRef)
     virtual void dump(ostream& str);
     virtual string name() const { return m_name; }		// * = Var name
     virtual V3Hash sameHash() const { return V3Hash(V3Hash(m_expect),V3Hash(m_name)); }
@@ -1769,7 +1769,7 @@ private:
 public:
     AstPackageRef(FileLine* fl, AstPackage* packagep)
 	: AstNode(fl), m_packagep(packagep) {}
-    ASTNODE_NODE_FUNCS(PackageRef, PACKAGEREF)
+    ASTNODE_NODE_FUNCS(PackageRef)
     // METHODS
     virtual const char* broken() const { BROKEN_RTN(!m_packagep || !m_packagep->brokeExists()); return NULL; }
     virtual void cloneRelink() { if (m_packagep && m_packagep->clonep()) {
@@ -1789,7 +1789,7 @@ class AstDot : public AstNode {
 public:
     AstDot(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
 	:AstNode(fl) { setOp1p(lhsp); setOp2p(rhsp); }
-    ASTNODE_NODE_FUNCS(Dot, DOT)
+    ASTNODE_NODE_FUNCS(Dot)
     static AstNode* newIfPkg(FileLine*fl, AstPackage* packagep, AstNode* rhsp) {  // For parser, make only if non-null package
 	if (!packagep) return rhsp;
 	return new AstDot(fl, new AstPackageRef(fl, packagep), rhsp);
@@ -1808,7 +1808,7 @@ class AstTask : public AstNodeFTask {
 public:
     AstTask(FileLine* fl, const string& name, AstNode* stmtp)
 	:AstNodeFTask(fl, name, stmtp) {}
-    ASTNODE_NODE_FUNCS(Task, TASK)
+    ASTNODE_NODE_FUNCS(Task)
 };
 
 class AstFunc : public AstNodeFTask {
@@ -1818,7 +1818,7 @@ public:
 	:AstNodeFTask(fl, name, stmtp) {
 	addNOp1p(fvarsp);
     }
-    ASTNODE_NODE_FUNCS(Func, FUNC)
+    ASTNODE_NODE_FUNCS(Func)
     virtual bool hasDType() const { return true; }
 };
 
@@ -1829,7 +1829,7 @@ public:
 	:AstNodeFTaskRef(fl, namep, pinsp) {}
     AstTaskRef(FileLine* fl, const string& name, AstNode* pinsp)
 	:AstNodeFTaskRef(fl, name, pinsp) {}
-    ASTNODE_NODE_FUNCS(TaskRef, TASKREF)
+    ASTNODE_NODE_FUNCS(TaskRef)
 };
 
 class AstFuncRef : public AstNodeFTaskRef {
@@ -1839,7 +1839,7 @@ public:
 	:AstNodeFTaskRef(fl, namep, pinsp) {}
     AstFuncRef(FileLine* fl, const string& name, AstNode* pinsp)
 	:AstNodeFTaskRef(fl, name, pinsp) {}
-    ASTNODE_NODE_FUNCS(FuncRef, FUNCREF)
+    ASTNODE_NODE_FUNCS(FuncRef)
     virtual bool hasDType() const { return true; }
 };
 
@@ -1853,7 +1853,7 @@ private:
 public:
     AstDpiExport(FileLine* fl, const string& vname, const string& cname)
 	:AstNode(fl), m_name(vname), m_cname(cname) { }
-    ASTNODE_NODE_FUNCS(DpiExport, DPIEXPORT)
+    ASTNODE_NODE_FUNCS(DpiExport)
     virtual string name() const { return m_name; }
     virtual void name(const string& name) { m_name = name; }
     string cname() const { return m_cname; }
@@ -1892,7 +1892,7 @@ public:
 	: AstNodeSenItem(fl) {
 	m_edgeType = AstEdgeType::ET_NEVER;
     }
-    ASTNODE_NODE_FUNCS(SenItem, SENITEM)
+    ASTNODE_NODE_FUNCS(SenItem)
     virtual void dump(ostream& str);
     virtual V3Hash sameHash() const { return V3Hash(V3Hash(edgeType())); }
     virtual bool same(AstNode* samep) const {
@@ -1919,7 +1919,7 @@ public:
     AstSenGate(FileLine* fl, AstSenItem* sensesp, AstNode* rhsp) : AstNodeSenItem(fl) {
 	dtypeSetLogicBool(); addOp1p(sensesp); setOp2p(rhsp);
     }
-    ASTNODE_NODE_FUNCS(SenGate, SENGATE)
+    ASTNODE_NODE_FUNCS(SenGate)
     virtual string emitVerilog() { return "(%l) %f&& (%r)"; }
     AstSenItem*	sensesp() const { return op1p()->castSenItem(); }
     AstNode*	rhsp() 	const { return op2p()->castNode(); }
@@ -1944,7 +1944,7 @@ public:
 	: AstNode(fl), m_multi(false) {
 	addNOp1p(sensesp);
     }
-    ASTNODE_NODE_FUNCS(SenTree, SENTREE)
+    ASTNODE_NODE_FUNCS(SenTree)
     virtual void dump(ostream& str);
     virtual bool maybePointedTo() const { return true; }
     bool isMulti() const { return m_multi; }
@@ -1965,7 +1965,7 @@ public:
 	: AstNode(fl), m_keyword(keyword) {
 	addNOp1p(sensesp); addNOp2p(bodysp);
     }
-    ASTNODE_NODE_FUNCS(Always, ALWAYS)
+    ASTNODE_NODE_FUNCS(Always)
     //
     virtual void dump(ostream& str);
     AstSenTree*	sensesp() 	const { return op1p()->castSenTree(); }	// op1 = Sensitivity list
@@ -1984,7 +1984,7 @@ public:
 	: AstNodeStmt(fl) {
 	addNOp1p(sensesp); addNOp2p(bodysp);
     }
-    ASTNODE_NODE_FUNCS(AlwaysPublic, ALWAYSPUBLIC)
+    ASTNODE_NODE_FUNCS(AlwaysPublic)
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(AstNode* samep) const { return true; }
     //
@@ -2002,7 +2002,7 @@ public:
 	: AstNode(fl) {
 	addNOp1p(sensesp); addNOp2p(bodysp);
     }
-    ASTNODE_NODE_FUNCS(AlwaysPost, ALWAYSPOST)
+    ASTNODE_NODE_FUNCS(AlwaysPost)
     //
     AstNode*	bodysp() 	const { return op2p()->castNode(); }	// op2 = Statements to evaluate
     void	addBodysp(AstNode* newp)	{ addOp2p(newp); }
@@ -2014,7 +2014,7 @@ public:
 	: AstNodeAssign(fileline, lhsp, rhsp) {
 	dtypeFrom(lhsp);
     }
-    ASTNODE_NODE_FUNCS(Assign, ASSIGN)
+    ASTNODE_NODE_FUNCS(Assign)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstAssign(this->fileline(), lhsp, rhsp); }
 };
 
@@ -2024,7 +2024,7 @@ class AstAssignAlias : public AstNodeAssign {
 public:
     AstAssignAlias(FileLine* fileline, AstVarRef* lhsp, AstVarRef* rhsp)
 	: AstNodeAssign(fileline, lhsp, rhsp) {}
-    ASTNODE_NODE_FUNCS(AssignAlias, ASSIGNALIAS)
+    ASTNODE_NODE_FUNCS(AssignAlias)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { V3ERROR_NA; return NULL; }
 };
 
@@ -2032,7 +2032,7 @@ class AstAssignDly : public AstNodeAssign {
 public:
     AstAssignDly(FileLine* fileline, AstNode* lhsp, AstNode* rhsp)
 	: AstNodeAssign(fileline, lhsp, rhsp) {}
-    ASTNODE_NODE_FUNCS(AssignDly, ASSIGNDLY)
+    ASTNODE_NODE_FUNCS(AssignDly)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstAssignDly(this->fileline(), lhsp, rhsp); }
     virtual bool isGateOptimizable() const { return false; }
     virtual string verilogKwd() const { return "<="; }
@@ -2043,7 +2043,7 @@ class AstAssignW : public AstNodeAssign {
 public:
     AstAssignW(FileLine* fileline, AstNode* lhsp, AstNode* rhsp)
 	: AstNodeAssign(fileline, lhsp, rhsp) { }
-    ASTNODE_NODE_FUNCS(AssignW, ASSIGNW)
+    ASTNODE_NODE_FUNCS(AssignW)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstAssignW(this->fileline(), lhsp, rhsp); }
     AstAlways* convertToAlways() {
 	AstNode* lhs1p = lhsp()->unlinkFrBack();
@@ -2062,7 +2062,7 @@ public:
 	: AstNodeAssign(fileline, lhsp, rhsp) {
 	dtypeFrom(rhsp);
     }
-    ASTNODE_NODE_FUNCS(AssignVarScope, ASSIGNVARSCOPE)
+    ASTNODE_NODE_FUNCS(AssignVarScope)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstAssignVarScope(this->fileline(), lhsp, rhsp); }
 };
 
@@ -2075,7 +2075,7 @@ public:
 	setOp1p(lhsp);
 	m_direction = direction;
     }
-    ASTNODE_NODE_FUNCS(Pull, PULL)
+    ASTNODE_NODE_FUNCS(Pull)
     virtual bool same(AstNode* samep) const {
 	return direction()==samep->castPull()->direction(); }
     void lhsp(AstNode* np) { setOp1p(np); }
@@ -2088,7 +2088,7 @@ class AstAssignPre : public AstNodeAssign {
 public:
     AstAssignPre(FileLine* fileline, AstNode* lhsp, AstNode* rhsp)
 	: AstNodeAssign(fileline, lhsp, rhsp) {}
-    ASTNODE_NODE_FUNCS(AssignPre, ASSIGNPRE)
+    ASTNODE_NODE_FUNCS(AssignPre)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstAssignPre(this->fileline(), lhsp, rhsp); }
 };
 
@@ -2097,7 +2097,7 @@ class AstAssignPost : public AstNodeAssign {
 public:
     AstAssignPost(FileLine* fileline, AstNode* lhsp, AstNode* rhsp)
 	: AstNodeAssign(fileline, lhsp, rhsp) {}
-    ASTNODE_NODE_FUNCS(AssignPost, ASSIGNPOST)
+    ASTNODE_NODE_FUNCS(AssignPost)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstAssignPost(this->fileline(), lhsp, rhsp); }
 };
 
@@ -2111,7 +2111,7 @@ public:
     AstComment(FileLine* fl, const string& name)
 	: AstNodeStmt(fl)
 	, m_name(name) {}
-    ASTNODE_NODE_FUNCS(Comment, COMMENT)
+    ASTNODE_NODE_FUNCS(Comment)
     virtual string name()	const { return m_name; }		// * = Var name
     virtual V3Hash sameHash() const { return V3Hash(); }  // Ignore name in comments
     virtual bool same(AstNode* samep) const { return true; }  // Ignore name in comments
@@ -2124,7 +2124,7 @@ class AstCond : public AstNodeCond {
 public:
     AstCond(FileLine* fl, AstNode* condp, AstNode* expr1p, AstNode* expr2p)
 	: AstNodeCond(fl, condp, expr1p, expr2p) {}
-    ASTNODE_NODE_FUNCS(Cond, COND)
+    ASTNODE_NODE_FUNCS(Cond)
 };
 
 class AstCondBound : public AstNodeCond {
@@ -2134,7 +2134,7 @@ class AstCondBound : public AstNodeCond {
 public:
     AstCondBound(FileLine* fl, AstNode* condp, AstNode* expr1p, AstNode* expr2p)
 	: AstNodeCond(fl, condp, expr1p, expr2p) {}
-    ASTNODE_NODE_FUNCS(CondBound, CONDBOUND)
+    ASTNODE_NODE_FUNCS(CondBound)
 };
 
 class AstCoverDecl : public AstNodeStmt {
@@ -2155,7 +2155,7 @@ public:
 	m_binNum = 0;
 	m_dataDeclp = NULL;
     }
-    ASTNODE_NODE_FUNCS(CoverDecl, COVERDECL)
+    ASTNODE_NODE_FUNCS(CoverDecl)
     virtual const char* broken() const {
 	BROKEN_RTN(m_dataDeclp && !m_dataDeclp->brokeExists());
 	if (m_dataDeclp && m_dataDeclp->m_dataDeclp) v3fatalSrc("dataDeclp should point to real data, not be a list");  // Avoid O(n^2) accessing
@@ -2196,7 +2196,7 @@ public:
 	: AstNodeStmt(fl) {
 	m_declp = declp;
     }
-    ASTNODE_NODE_FUNCS(CoverInc, COVERINC)
+    ASTNODE_NODE_FUNCS(CoverInc)
     virtual const char* broken() const { BROKEN_RTN(!declp()->brokeExists()); return NULL; }
     virtual void cloneRelink() { if (m_declp->clonep()) m_declp = m_declp->clonep()->castCoverDecl(); }
     virtual void dump(ostream& str);
@@ -2222,7 +2222,7 @@ public:
 	setOp2p(origp);
 	setOp3p(changep);
     }
-    ASTNODE_NODE_FUNCS(CoverToggle, COVERTOGGLE)
+    ASTNODE_NODE_FUNCS(CoverToggle)
     virtual int instrCount()	const { return 3+instrCountBranch()+instrCountLd(); }
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(AstNode*) const { return true; }
@@ -2245,7 +2245,7 @@ public:
     AstGenCase(FileLine* fileline, AstNode* exprp, AstNode* casesp)
 	: AstNodeCase(fileline, exprp, casesp) {
     }
-    ASTNODE_NODE_FUNCS(GenCase, GENCASE)
+    ASTNODE_NODE_FUNCS(GenCase)
 };
 
 class AstCase : public AstNodeCase {
@@ -2267,7 +2267,7 @@ public:
 	m_fullPragma=false; m_parallelPragma=false;
 	m_uniquePragma=false; m_unique0Pragma=false; m_priorityPragma=false;
     }
-    ASTNODE_NODE_FUNCS(Case, CASE)
+    ASTNODE_NODE_FUNCS(Case)
     virtual string  verilogKwd() const { return casez()?"casez":casex()?"casex":"case"; }
     virtual bool same(AstNode* samep) const {
 	return m_casex==samep->castCase()->m_casex; }
@@ -2301,7 +2301,7 @@ public:
 	addNOp1p(condsp); addNOp2p(bodysp);
 	m_ignoreOverlap = false;
     }
-    ASTNODE_NODE_FUNCS(CaseItem, CASEITEM)
+    ASTNODE_NODE_FUNCS(CaseItem)
     virtual int instrCount()	const { return widthInstrs()+instrCountBranch(); }
     AstNode*	condsp()		const { return op1p()->castNode(); }	// op1= list of possible matching expressions
     AstNode*	bodysp()	const { return op2p()->castNode(); }	// op2= what to do
@@ -2322,7 +2322,7 @@ public:
 	: AstNode(fl), m_text(text), m_hidden(hidden) {
 	dtypeSetString();
 	addNOp1p(exprsp); addNOp2p(NULL); }
-    ASTNODE_NODE_FUNCS(SFormatF, SFORMATF)
+    ASTNODE_NODE_FUNCS(SFormatF)
     virtual string name() const { return m_text; }
     virtual int instrCount() const { return instrCountPli(); }
     virtual V3Hash sameHash() const { return V3Hash(text()); }
@@ -2353,7 +2353,7 @@ public:
 	setNOp3p(filep);
 	m_displayType = dispType;
     }
-    ASTNODE_NODE_FUNCS(Display, DISPLAY)
+    ASTNODE_NODE_FUNCS(Display)
     virtual void dump(ostream& str);
     virtual const char* broken() const { BROKEN_RTN(!fmtp()); return NULL; }
     virtual string verilogKwd() const { return (filep() ? (string)"$f"+(string)displayType().ascii()
@@ -2385,7 +2385,7 @@ public:
 	setOp1p(new AstSFormatF(fileline,text,true,exprsp));
 	setOp3p(lhsp);
     }
-    ASTNODE_NODE_FUNCS(SFormat, SFORMAT)
+    ASTNODE_NODE_FUNCS(SFormat)
     virtual const char* broken() const { BROKEN_RTN(!fmtp()); return NULL; }
     virtual string verilogKwd() const { return "$sformat"; }
     virtual string emitVerilog() { V3ERROR_NA; return ""; }
@@ -2410,7 +2410,7 @@ class AstSysIgnore : public AstNodeStmt {
 public:
     AstSysIgnore(FileLine* fileline, AstNode* exprsp)
 	: AstNodeStmt (fileline) { addNOp1p(exprsp); }
-    ASTNODE_NODE_FUNCS(SysIgnore, SYSIGNORE)
+    ASTNODE_NODE_FUNCS(SysIgnore)
     virtual string verilogKwd() const { return "$ignored"; }
     virtual bool isGateOptimizable() const { return false; }  // Though deleted before opt
     virtual bool isPredictOptimizable() const { return false; }  // Though deleted before opt
@@ -2429,7 +2429,7 @@ public:
 	: AstNodeStmt (fileline) {
 	setNOp2p(filep);
     }
-    ASTNODE_NODE_FUNCS(FClose, FCLOSE)
+    ASTNODE_NODE_FUNCS(FClose)
     virtual string verilogKwd() const { return "$fclose"; }
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
@@ -2451,7 +2451,7 @@ public:
 	setOp2p(filenamep);
 	setOp3p(modep);
     }
-    ASTNODE_NODE_FUNCS(FOpen, FOPEN)
+    ASTNODE_NODE_FUNCS(FOpen)
     virtual string verilogKwd() const { return "$fopen"; }
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
@@ -2473,7 +2473,7 @@ public:
 	: AstNodeStmt (fileline) {
 	setNOp2p(filep);
     }
-    ASTNODE_NODE_FUNCS(FFlush, FFLUSH)
+    ASTNODE_NODE_FUNCS(FFlush)
     virtual string verilogKwd() const { return "$fflush"; }
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
@@ -2498,7 +2498,7 @@ public:
 	addNOp1p(exprsp);
 	setNOp2p(filep);
     }
-    ASTNODE_NODE_FUNCS(FScanF, FSCANF)
+    ASTNODE_NODE_FUNCS(FScanF)
     virtual string name()	const { return m_text; }
     virtual string verilogKwd() const { return "$fscanf"; }
     virtual string emitVerilog() { V3ERROR_NA; return ""; }
@@ -2531,7 +2531,7 @@ public:
 	addNOp1p(exprsp);
 	setOp2p(fromp);
     }
-    ASTNODE_NODE_FUNCS(SScanF, SSCANF)
+    ASTNODE_NODE_FUNCS(SScanF)
     virtual string name()	const { return m_text; }
     virtual string verilogKwd() const { return "$sscanf"; }
     virtual string emitVerilog() { V3ERROR_NA; return ""; }
@@ -2561,7 +2561,7 @@ public:
 	: AstNodeStmt (fileline), m_isHex(hex) {
 	setOp1p(filenamep); setOp2p(memp); setNOp3p(lsbp); setNOp4p(msbp);
     }
-    ASTNODE_NODE_FUNCS(ReadMem, READMEM)
+    ASTNODE_NODE_FUNCS(ReadMem)
     virtual string verilogKwd() const { return (isHex()?"$readmemh":"$readmemb"); }
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
@@ -2584,7 +2584,7 @@ public:
 	: AstNodeStmt (fileline) {
 	setOp1p(lhsp);
     }
-    ASTNODE_NODE_FUNCS(SystemT, SYSTEMT)
+    ASTNODE_NODE_FUNCS(SystemT)
     virtual string verilogKwd() const { return "$system"; }
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
@@ -2603,7 +2603,7 @@ public:
 	: AstNodeMath (fileline) {
 	setOp1p(lhsp);
     }
-    ASTNODE_NODE_FUNCS(SystemF, SYSTEMF)
+    ASTNODE_NODE_FUNCS(SystemF)
     virtual string verilogKwd() const { return "$system"; }
     virtual string emitVerilog() { return verilogKwd(); }
     virtual string emitC() { return "VL_SYSTEM_%nq(%lw, %P)"; }
@@ -2628,7 +2628,7 @@ public:
 	: AstNodeMath (fileline), m_text(text) {
 	setOp1p(exprsp);
     }
-    ASTNODE_NODE_FUNCS(ValuePlusArgs, VALUEPLUSARGS)
+    ASTNODE_NODE_FUNCS(ValuePlusArgs)
     virtual string name()	const { return m_text; }
     virtual string verilogKwd() const { return "$value$plusargs"; }
     virtual string emitVerilog() { return verilogKwd(); }
@@ -2653,7 +2653,7 @@ private:
 public:
     AstTestPlusArgs(FileLine* fileline, const string& text)
 	: AstNodeMath (fileline), m_text(text) { }
-    ASTNODE_NODE_FUNCS(TestPlusArgs, TESTPLUSARGS)
+    ASTNODE_NODE_FUNCS(TestPlusArgs)
     virtual string name()	const { return m_text; }
     virtual string verilogKwd() const { return "$test$plusargs"; }
     virtual string emitVerilog() { return verilogKwd(); }
@@ -2674,7 +2674,7 @@ public:
 	   AstNode* incsp, AstNode* bodysp)
 	: AstNodeFor(fileline, initsp, condp, incsp, bodysp) {
     }
-    ASTNODE_NODE_FUNCS(GenFor, GENFOR)
+    ASTNODE_NODE_FUNCS(GenFor)
 };
 
 class AstForeach : public AstNodeStmt {
@@ -2684,7 +2684,7 @@ public:
 	: AstNodeStmt(fileline) {
 	setOp1p(arrayp); addNOp2p(varsp); addNOp4p(bodysp);
     }
-    ASTNODE_NODE_FUNCS(Foreach, FOREACH)
+    ASTNODE_NODE_FUNCS(Foreach)
     AstNode* arrayp() const { return op1p()->castNode(); }	// op1= array
     AstNode* varsp() const { return op2p()->castNode(); }	// op2= variable index list
     AstNode* bodysp() const { return op4p()->castNode(); }	// op4= body of loop
@@ -2700,7 +2700,7 @@ public:
 	: AstNodeStmt(fileline) {
 	setOp2p(countp); addNOp3p(bodysp);
     }
-    ASTNODE_NODE_FUNCS(Repeat, REPEAT)
+    ASTNODE_NODE_FUNCS(Repeat)
     AstNode*	countp()	const { return op2p()->castNode(); }	// op2= condition to continue
     AstNode*	bodysp()	const { return op3p()->castNode(); }	// op3= body of loop
     virtual bool isGateOptimizable() const { return false; }  // Not releavant - converted to FOR
@@ -2715,7 +2715,7 @@ public:
 	: AstNodeStmt(fileline) {
 	setOp2p(condp); addNOp3p(bodysp); addNOp4p(incsp);
     }
-    ASTNODE_NODE_FUNCS(While, WHILE)
+    ASTNODE_NODE_FUNCS(While)
     AstNode*	precondsp()	const { return op1p()->castNode(); }	// op1= prepare statements for condition (exec every loop)
     AstNode*	condp()		const { return op2p()->castNode(); }	// op2= condition to continue
     AstNode*	bodysp()	const { return op3p()->castNode(); }	// op3= body of loop
@@ -2735,7 +2735,7 @@ class AstBreak : public AstNodeStmt {
 public:
     explicit AstBreak(FileLine* fileline)
 	: AstNodeStmt (fileline) {}
-    ASTNODE_NODE_FUNCS(Break, BREAK)
+    ASTNODE_NODE_FUNCS(Break)
     virtual string verilogKwd() const { return "break"; };
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool isBrancher() const { return true; }	// SPECIAL: We don't process code after breaks
@@ -2745,7 +2745,7 @@ class AstContinue : public AstNodeStmt {
 public:
     explicit AstContinue(FileLine* fileline)
 	: AstNodeStmt (fileline) {}
-    ASTNODE_NODE_FUNCS(Continue, CONTINUE)
+    ASTNODE_NODE_FUNCS(Continue)
     virtual string verilogKwd() const { return "continue"; };
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool isBrancher() const { return true; }	// SPECIAL: We don't process code after breaks
@@ -2757,7 +2757,7 @@ private:
 public:
     AstDisable(FileLine* fileline, const string& name)
 	: AstNodeStmt(fileline), m_name(name) {}
-    ASTNODE_NODE_FUNCS(Disable, DISABLE)
+    ASTNODE_NODE_FUNCS(Disable)
     virtual string name()	const { return m_name; }		// * = Block name
     void name(const string& flag) { m_name=flag; }
     virtual bool isBrancher() const { return true; }	// SPECIAL: We don't process code after breaks
@@ -2769,7 +2769,7 @@ public:
 	: AstNodeStmt (fileline) {
 	setNOp1p(lhsp);
     }
-    ASTNODE_NODE_FUNCS(Return, RETURN)
+    ASTNODE_NODE_FUNCS(Return)
     virtual string verilogKwd() const { return "return"; };
     virtual V3Hash sameHash() const { return V3Hash(); }
     AstNode*	lhsp() const { return op1p(); }
@@ -2781,7 +2781,7 @@ public:
     AstGenIf(FileLine* fileline, AstNode* condp, AstNode* ifsp, AstNode* elsesp)
 	: AstNodeIf(fileline, condp, ifsp, elsesp) {
     }
-    ASTNODE_NODE_FUNCS(GenIf, GENIF)
+    ASTNODE_NODE_FUNCS(GenIf)
 };
 
 class AstIf : public AstNodeIf {
@@ -2794,7 +2794,7 @@ public:
 	: AstNodeIf(fileline, condp, ifsp, elsesp) {
 	m_uniquePragma=false; m_unique0Pragma=false; m_priorityPragma=false;
     }
-    ASTNODE_NODE_FUNCS(If, IF)
+    ASTNODE_NODE_FUNCS(If)
     bool	uniquePragma() const { return m_uniquePragma; }
     void	uniquePragma(bool flag) { m_uniquePragma=flag; }
     bool	unique0Pragma()	const { return m_unique0Pragma; }
@@ -2816,7 +2816,7 @@ public:
 	addNOp1p(stmtsp);
     }
     virtual int instrCount()	const { return 0; }
-    ASTNODE_NODE_FUNCS(JumpLabel, JUMPLABEL)
+    ASTNODE_NODE_FUNCS(JumpLabel)
     virtual bool maybePointedTo() const { return true; }
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(AstNode* samep) const { return true; }
@@ -2837,7 +2837,7 @@ public:
 	: AstNodeStmt(fl) {
 	m_labelp = labelp;
     }
-    ASTNODE_NODE_FUNCS(JumpGo, JUMPGO)
+    ASTNODE_NODE_FUNCS(JumpGo)
     virtual const char* broken() const { BROKEN_RTN(!labelp()->brokeExistsAbove()); return NULL; }
     virtual void cloneRelink() { if (m_labelp->clonep()) m_labelp = m_labelp->clonep()->castJumpLabel(); }
     virtual void dump(ostream& str);
@@ -2859,7 +2859,7 @@ public:
 	: AstNodeStmt(fileline) {
 	addNOp2p(stablesp); addNOp3p(bodysp);
     }
-    ASTNODE_NODE_FUNCS(UntilStable, UNTILSTABLE)
+    ASTNODE_NODE_FUNCS(UntilStable)
     AstVarRef* stablesp()	const { return op2p()->castVarRef(); } // op2= list of variables that must become stable
     AstNode*	bodysp()	const { return op3p()->castNode(); }	// op3= body of loop
     void	addStablesp(AstVarRef* newp)	{ addOp2p(newp); }
@@ -2881,7 +2881,7 @@ public:
 	: AstNodeBiComAsv(fl, lhsp, rhsp) {
 	dtypeSetUInt32(); // Always used on, and returns word entities
     }
-    ASTNODE_NODE_FUNCS(ChangeXor, CHANGEXOR)
+    ASTNODE_NODE_FUNCS(ChangeXor)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstChangeXor(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opChangeXor(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f^ %r)"; }
@@ -2903,7 +2903,7 @@ public:
 	: AstNodeStmt(fl) {
 	setNOp1p(lhsp); setNOp2p(rhsp); m_clockReq=clockReq;
     }
-    ASTNODE_NODE_FUNCS(ChangeDet, CHANGEDET)
+    ASTNODE_NODE_FUNCS(ChangeDet)
     AstNode*	lhsp() 	const { return op1p(); }
     AstNode*	rhsp() 	const { return op2p(); }
     bool	isClockReq() const { return m_clockReq; }
@@ -2931,7 +2931,7 @@ public:
 	m_unnamed = (name=="");
 	m_generate = generate;
     }
-    ASTNODE_NODE_FUNCS(Begin, BEGIN)
+    ASTNODE_NODE_FUNCS(Begin)
     virtual void dump(ostream& str);
     virtual string name()	const { return m_name; }		// * = Block name
     virtual void name(const string& name) { m_name = name; }
@@ -2952,7 +2952,7 @@ public:
 	: AstNode(fl) {
 	addNOp1p(bodysp);
     }
-    ASTNODE_NODE_FUNCS(Initial, INITIAL)
+    ASTNODE_NODE_FUNCS(Initial)
     AstNode*	bodysp() 	const { return op1p()->castNode(); }	// op1 = Expressions to evaluate
     // Special accessors
     bool isJustOneBodyStmt() const { return bodysp() && !bodysp()->nextp(); }
@@ -2964,7 +2964,7 @@ public:
 	: AstNode(fl) {
 	addNOp1p(bodysp);
     }
-    ASTNODE_NODE_FUNCS(Final, FINAL)
+    ASTNODE_NODE_FUNCS(Final)
     AstNode*	bodysp() 	const { return op1p()->castNode(); }	// op1 = Expressions to evaluate
 };
 
@@ -2975,7 +2975,7 @@ public:
 	addOp1p(exprp); addOp2p(itemsp);
 	dtypeSetLogicBool();
     }
-    ASTNODE_NODE_FUNCS(Inside, INSIDE)
+    ASTNODE_NODE_FUNCS(Inside)
     AstNode* exprp() const { return op1p()->castNode(); }	// op1 = LHS expression to compare with
     AstNode* itemsp() const { return op2p()->castNode(); }	// op2 = RHS, possibly a list of expr or AstInsideRange
     virtual string emitVerilog() { return "%l inside { %r }"; }
@@ -2989,7 +2989,7 @@ public:
 	: AstNodeMath(fl) {
 	addOp1p(lhsp); addOp2p(rhsp);
     }
-    ASTNODE_NODE_FUNCS(InsideRange, INSIDERANGE)
+    ASTNODE_NODE_FUNCS(InsideRange)
     AstNode* lhsp() const { return op1p()->castNode(); }	// op1 = LHS
     AstNode* rhsp() const { return op2p()->castNode(); }	// op2 = RHS
     virtual string emitVerilog() { return "[%l:%r]"; }
@@ -3011,7 +3011,7 @@ public:
 	dtypep(newDTypep);
 	addNOp1p(defaultp);
     }
-    ASTNODE_NODE_FUNCS(InitArray, INITARRAY)
+    ASTNODE_NODE_FUNCS(InitArray)
     AstNode* defaultp() const { return op1p()->castNode(); }	// op1 = Default if sparse
     void defaultp(AstNode* newp) { setOp1p(newp); }
     AstNode* initsp() const { return op2p()->castNode(); }	// op2 = Initial value expressions
@@ -3044,7 +3044,7 @@ public:
 	: AstNode(fl) {
 	m_pragType = pragType;
     }
-    ASTNODE_NODE_FUNCS(Pragma, PRAGMA)
+    ASTNODE_NODE_FUNCS(Pragma)
     AstPragmaType	pragType() 	const { return m_pragType; }	// *=type of the pragma
     virtual V3Hash sameHash() const { return V3Hash(pragType()); }
     virtual bool isPredictOptimizable() const { return false; }
@@ -3056,7 +3056,7 @@ class AstStop : public AstNodeStmt {
 public:
     explicit AstStop(FileLine* fl)
 	: AstNodeStmt(fl) {}
-    ASTNODE_NODE_FUNCS(Stop, STOP)
+    ASTNODE_NODE_FUNCS(Stop)
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
     virtual bool isPure() const { return false; }	// SPECIAL: $display has 'visual' ordering
@@ -3072,7 +3072,7 @@ class AstFinish : public AstNodeStmt {
 public:
     explicit AstFinish(FileLine* fl)
 	: AstNodeStmt(fl) {}
-    ASTNODE_NODE_FUNCS(Finish, FINISH)
+    ASTNODE_NODE_FUNCS(Finish)
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
     virtual bool isPure() const { return false; }	// SPECIAL: $display has 'visual' ordering
@@ -3106,7 +3106,7 @@ public:
 		     * valuep->dtypep()->widthWords());
     }
     virtual int instrCount()	const { return 100; }  // Large...
-    ASTNODE_NODE_FUNCS(TraceDecl, TRACEDECL)
+    ASTNODE_NODE_FUNCS(TraceDecl)
     virtual string name()	const { return m_showname; }
     virtual bool maybePointedTo() const { return true; }
     virtual bool hasDType() const { return true; }
@@ -3133,7 +3133,7 @@ public:
 	m_declp = declp;
 	addNOp2p(valuep);
     }
-    ASTNODE_NODE_FUNCS(TraceInc, TRACEINC)
+    ASTNODE_NODE_FUNCS(TraceInc)
     virtual const char* broken() const { BROKEN_RTN(!declp()->brokeExists()); return NULL; }
     virtual void cloneRelink() { if (m_declp->clonep()) m_declp = m_declp->clonep()->castTraceDecl(); }
     virtual void dump(ostream& str);
@@ -3168,7 +3168,7 @@ public:
 	UASSERT(sensesp, "Sensesp required arg");
 	m_sensesp = sensesp;
     }
-    ASTNODE_NODE_FUNCS(Active, ACTIVE)
+    ASTNODE_NODE_FUNCS(Active)
     virtual void dump(ostream& str=cout);
     virtual string name()	const { return m_name; }
     virtual const char* broken() const { BROKEN_RTN(m_sensesp && !m_sensesp->brokeExists()); return NULL; }
@@ -3203,7 +3203,7 @@ public:
 	setNOp1p(fromp);
 	setNOp2p(dimp);
 	m_attrType = attrtype; }
-    ASTNODE_NODE_FUNCS(AttrOf, ATTROF)
+    ASTNODE_NODE_FUNCS(AttrOf)
     AstNode*	fromp() const { return op1p(); }
     AstNode*	dimp() const { return op2p(); }
     AstAttrType	attrType() const { return m_attrType; }
@@ -3221,7 +3221,7 @@ private:
 public:
     explicit AstScopeName(FileLine* fl) : AstNodeMath(fl), m_dpiExport(false) {
 	dtypeSetUInt64(); }
-    ASTNODE_NODE_FUNCS(ScopeName, SCOPENAME)
+    ASTNODE_NODE_FUNCS(ScopeName)
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(AstNode* samep) const { return m_dpiExport==samep->castScopeName()->m_dpiExport; }
     virtual string emitVerilog() { return ""; }
@@ -3245,7 +3245,7 @@ public:
 	: AstNode(fl) {
 	addNOp1p(bodysp);
     }
-    ASTNODE_NODE_FUNCS(UdpTable, UDPTABLE)
+    ASTNODE_NODE_FUNCS(UdpTable)
     AstUdpTableLine*	bodysp() 	const { return op1p()->castUdpTableLine(); }	// op1 = List of UdpTableLines
 };
 
@@ -3254,7 +3254,7 @@ class AstUdpTableLine : public AstNode {
 public:
     AstUdpTableLine(FileLine* fl, const string& text)
 	: AstNode(fl), m_text(text) {}
-    ASTNODE_NODE_FUNCS(UdpTableLine, UDPTABLELINE)
+    ASTNODE_NODE_FUNCS(UdpTableLine)
     virtual string name()	const { return m_text; }
     string text() const { return m_text; }
 };
@@ -3270,7 +3270,7 @@ public:
     AstRand(FileLine* fl, AstNodeDType* dtp, bool reset) : AstNodeTermop(fl) {
 	dtypep(dtp); m_reset=reset; }
     explicit AstRand(FileLine* fl) : AstNodeTermop(fl), m_reset(false) { }
-    ASTNODE_NODE_FUNCS(Rand, RAND)
+    ASTNODE_NODE_FUNCS(Rand)
     virtual string emitVerilog() { return "%f$random"; }
     virtual string emitC() {
 	return (m_reset ?
@@ -3288,7 +3288,7 @@ class AstTime : public AstNodeTermop {
 public:
     explicit AstTime(FileLine* fl) : AstNodeTermop(fl) {
 	dtypeSetUInt64(); }
-    ASTNODE_NODE_FUNCS(Time, TIME)
+    ASTNODE_NODE_FUNCS(Time)
     virtual string emitVerilog() { return "%f$time"; }
     virtual string emitC() { return "VL_TIME_%nq()"; }
     virtual bool cleanOut() { return true; }
@@ -3303,7 +3303,7 @@ class AstTimeD : public AstNodeTermop {
 public:
     explicit AstTimeD(FileLine* fl) : AstNodeTermop(fl) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(TimeD, TIMED)
+    ASTNODE_NODE_FUNCS(TimeD)
     virtual string emitVerilog() { return "%f$realtime"; }
     virtual string emitC() { return "VL_TIME_D()"; }
     virtual bool cleanOut() { return true; }
@@ -3322,7 +3322,7 @@ public:
 	: AstNodeMath(fl) {
 	addNOp1p(exprsp);
     }
-    ASTNODE_NODE_FUNCS(UCFunc, UCFUNC)
+    ASTNODE_NODE_FUNCS(UCFunc)
     virtual bool cleanOut() { return false; }
     virtual string emitVerilog() { V3ERROR_NA; return ""; }  // Implemented specially
     virtual string emitC() { V3ERROR_NA; return ""; }
@@ -3344,7 +3344,7 @@ class AstNegate : public AstNodeUniop {
 public:
     AstNegate(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(Negate, NEGATE)
+    ASTNODE_NODE_FUNCS(Negate)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opNegate(lhs); }
     virtual string emitVerilog() { return "%f(- %l)"; }
     virtual string emitC() { return "VL_NEGATE_%lq(%lW, %P, %li)"; }
@@ -3355,7 +3355,7 @@ class AstNegateD : public AstNodeUniop {
 public:
     AstNegateD(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(NegateD, NEGATED)
+    ASTNODE_NODE_FUNCS(NegateD)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opNegateD(lhs); }
     virtual string emitVerilog() { return "%f(- %l)"; }
     virtual string emitC() { V3ERROR_NA; return ""; }
@@ -3369,7 +3369,7 @@ class AstRedAnd : public AstNodeUniop {
 public:
     AstRedAnd(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(RedAnd, REDAND)
+    ASTNODE_NODE_FUNCS(RedAnd)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRedAnd(lhs); }
     virtual string emitVerilog() { return "%f(& %l)"; }
     virtual string emitC() { return "VL_REDAND_%nq%lq(%nw,%lw, %P, %li)"; }
@@ -3380,7 +3380,7 @@ class AstRedOr : public AstNodeUniop {
 public:
     AstRedOr(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(RedOr, REDOR)
+    ASTNODE_NODE_FUNCS(RedOr)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRedOr(lhs); }
     virtual string emitVerilog() { return "%f(| %l)"; }
     virtual string emitC() { return "VL_REDOR_%lq(%lW, %P, %li)"; }
@@ -3391,7 +3391,7 @@ class AstRedXor : public AstNodeUniop {
 public:
     AstRedXor(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(RedXor, REDXOR)
+    ASTNODE_NODE_FUNCS(RedXor)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRedXor(lhs); }
     virtual string emitVerilog() { return "%f(^ %l)"; }
     virtual string emitC() { return "VL_REDXOR_%lq(%lW, %P, %li)"; }
@@ -3406,7 +3406,7 @@ class AstRedXnor : public AstNodeUniop {
 public:
     AstRedXnor(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(RedXnor, REDXNOR)
+    ASTNODE_NODE_FUNCS(RedXnor)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRedXnor(lhs); }
     virtual string emitVerilog() { return "%f(~^ %l)"; }
     virtual string emitC() { v3fatalSrc("REDXNOR should have became REDXOR"); return ""; }
@@ -3419,7 +3419,7 @@ class AstLogNot : public AstNodeUniop {
 public:
     AstLogNot(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(LogNot, LOGNOT)
+    ASTNODE_NODE_FUNCS(LogNot)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opLogNot(lhs); }
     virtual string emitVerilog() { return "%f(! %l)"; }
     virtual string emitC() { return "VL_LOGNOT_%nq%lq(%nw,%lw, %P, %li)"; }
@@ -3431,7 +3431,7 @@ class AstNot : public AstNodeUniop {
 public:
     AstNot(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(Not, NOT)
+    ASTNODE_NODE_FUNCS(Not)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opNot(lhs); }
     virtual string emitVerilog() { return "%f(~ %l)"; }
     virtual string emitC() { return "VL_NOT_%lq(%lW, %P, %li)"; }
@@ -3445,7 +3445,7 @@ public:
     AstExtend(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {}
     AstExtend(FileLine* fl, AstNode* lhsp, int width) : AstNodeUniop(fl, lhsp) {
 	dtypeSetLogicSized(width,width,AstNumeric::UNSIGNED); }
-    ASTNODE_NODE_FUNCS(Extend, EXTEND)
+    ASTNODE_NODE_FUNCS(Extend)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opAssign(lhs); }
     virtual string emitVerilog() { return "%l"; }
     virtual string emitC() { return "VL_EXTEND_%nq%lq(%nw,%lw, %P, %li)"; }
@@ -3460,7 +3460,7 @@ public:
     AstExtendS(FileLine* fl, AstNode* lhsp, int width) : AstNodeUniop(fl, lhsp) {
 	// Important that widthMin be correct, as opExtend requires it after V3Expand
 	dtypeSetLogicSized(width,width,AstNumeric::UNSIGNED); }
-    ASTNODE_NODE_FUNCS(ExtendS, EXTENDS)
+    ASTNODE_NODE_FUNCS(ExtendS)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) {
 	out.opExtendS(lhs, lhsp()->widthMinV());
     }
@@ -3477,7 +3477,7 @@ public:
     AstSigned(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	if (v3Global.assertDTypesResolved()) { v3fatalSrc("not coded to create after dtypes resolved"); }
     }
-    ASTNODE_NODE_FUNCS(Signed, SIGNED)
+    ASTNODE_NODE_FUNCS(Signed)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opAssign(lhs); out.isSigned(false); }
     virtual string emitVerilog() { return "%f$signed(%l)"; }
     virtual string emitC() { V3ERROR_NA; return ""; }
@@ -3491,7 +3491,7 @@ public:
     AstUnsigned(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	if (v3Global.assertDTypesResolved()) { v3fatalSrc("not coded to create after dtypes resolved"); }
     }
-    ASTNODE_NODE_FUNCS(Unsigned, UNSIGNED)
+    ASTNODE_NODE_FUNCS(Unsigned)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opAssign(lhs); out.isSigned(false); }
     virtual string emitVerilog() { return "%f$unsigned(%l)"; }
     virtual string emitC() { V3ERROR_NA; return ""; }
@@ -3504,7 +3504,7 @@ class AstRToIS : public AstNodeUniop {
 public:
     AstRToIS(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetSigned32(); }
-    ASTNODE_NODE_FUNCS(RToIS, RTOIS)
+    ASTNODE_NODE_FUNCS(RToIS)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRToIS(lhs); }
     virtual string emitVerilog() { return "%f$rtoi(%l)"; }
     virtual string emitC() { return "VL_RTOI_I_D(%li)"; }
@@ -3516,7 +3516,7 @@ class AstRToIRoundS : public AstNodeUniop {
 public:
     AstRToIRoundS(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetSigned32(); }
-    ASTNODE_NODE_FUNCS(RToIRoundS, RTOIROUNDS)
+    ASTNODE_NODE_FUNCS(RToIRoundS)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRToIRoundS(lhs); }
     virtual string emitVerilog() { return "%f$rtoi_rounded(%l)"; }
     virtual string emitC() { return "VL_RTOIROUND_I_D(%li)"; }
@@ -3528,7 +3528,7 @@ class AstIToRD : public AstNodeUniop {
 public:
     AstIToRD(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(IToRD, ITORD)
+    ASTNODE_NODE_FUNCS(IToRD)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opIToRD(lhs); }
     virtual string emitVerilog() { return "%f$itor(%l)"; }
     virtual string emitC() { return "VL_ITOR_D_I(%li)"; }
@@ -3540,7 +3540,7 @@ class AstRealToBits : public AstNodeUniop {
 public:
     AstRealToBits(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetUInt64(); }
-    ASTNODE_NODE_FUNCS(RealToBits, REALTOBITS)
+    ASTNODE_NODE_FUNCS(RealToBits)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRealToBits(lhs); }
     virtual string emitVerilog() { return "%f$realtobits(%l)"; }
     virtual string emitC() { return "VL_CVT_Q_D(%li)"; }
@@ -3552,7 +3552,7 @@ class AstBitsToRealD : public AstNodeUniop {
 public:
     AstBitsToRealD(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(BitsToRealD, BITSTOREALD)
+    ASTNODE_NODE_FUNCS(BitsToRealD)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opBitsToRealD(lhs); }
     virtual string emitVerilog() { return "%f$bitstoreal(%l)"; }
     virtual string emitC() { return "VL_CVT_D_Q(%li)"; }
@@ -3564,7 +3564,7 @@ public:
 class AstCLog2 : public AstNodeUniop {
 public:
     AstCLog2(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {}
-    ASTNODE_NODE_FUNCS(CLog2, CLOG2)
+    ASTNODE_NODE_FUNCS(CLog2)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opCLog2(lhs); }
     virtual string emitVerilog() { return "%f$clog2(%l)"; }
     virtual string emitC() { return "VL_CLOG2_%lq(%lW, %P, %li)"; }
@@ -3576,7 +3576,7 @@ class AstCountOnes : public AstNodeUniop {
     // Number of bits set in vector
 public:
     AstCountOnes(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {}
-    ASTNODE_NODE_FUNCS(CountOnes, COUNTONES)
+    ASTNODE_NODE_FUNCS(CountOnes)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opCountOnes(lhs); }
     virtual string emitVerilog() { return "%f$countones(%l)"; }
     virtual string emitC() { return "VL_COUNTONES_%lq(%lW, %P, %li)"; }
@@ -3589,7 +3589,7 @@ class AstIsUnknown : public AstNodeUniop {
 public:
     AstIsUnknown(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(IsUnknown, ISUNKNOWN)
+    ASTNODE_NODE_FUNCS(IsUnknown)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opIsUnknown(lhs); }
     virtual string emitVerilog() { return "%f$isunknown(%l)"; }
     virtual string emitC() { V3ERROR_NA; return ""; }
@@ -3601,7 +3601,7 @@ class AstOneHot : public AstNodeUniop {
 public:
     AstOneHot(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(OneHot, ONEHOT)
+    ASTNODE_NODE_FUNCS(OneHot)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opOneHot(lhs); }
     virtual string emitVerilog() { return "%f$onehot(%l)"; }
     virtual string emitC() { return "VL_ONEHOT_%lq(%lW, %P, %li)"; }
@@ -3614,7 +3614,7 @@ class AstOneHot0 : public AstNodeUniop {
 public:
     AstOneHot0(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(OneHot0, ONEHOT0)
+    ASTNODE_NODE_FUNCS(OneHot0)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opOneHot0(lhs); }
     virtual string emitVerilog() { return "%f$onehot0(%l)"; }
     virtual string emitC() { return "VL_ONEHOT0_%lq(%lW, %P, %li)"; }
@@ -3630,7 +3630,7 @@ public:
 	setOp1p(lhsp); setOp2p(dtp);
 	dtypeFrom(dtp);
     }
-    ASTNODE_NODE_FUNCS(Cast, CAST)
+    ASTNODE_NODE_FUNCS(Cast)
     virtual bool hasDType() const { return true; }
     virtual string emitVerilog() { return "((%d)'(%l))"; }
     virtual string emitC() { V3ERROR_NA; return ""; }
@@ -3647,7 +3647,7 @@ public:
     AstCastParse(FileLine* fl, AstNode* lhsp, AstNode* dtp) : AstNode(fl) {
 	setOp1p(lhsp); setOp2p(dtp);
     }
-    ASTNODE_NODE_FUNCS(CastParse, CASTPARSE)
+    ASTNODE_NODE_FUNCS(CastParse)
     virtual string emitVerilog() { return "((%d)'(%l))"; }
     virtual string emitC() { V3ERROR_NA; return ""; }
     virtual bool cleanOut() { V3ERROR_NA; return true;} virtual bool cleanLhs() {return true;}
@@ -3662,7 +3662,7 @@ public:
     AstCastSize(FileLine* fl, AstNode* lhsp, AstConst* rhsp) : AstNode(fl) {
 	setOp1p(lhsp); setOp2p(rhsp);
     }
-    ASTNODE_NODE_FUNCS(CastSize, CASTSIZE)
+    ASTNODE_NODE_FUNCS(CastSize)
     // No hasDType because widthing removes this node before the hasDType check
     virtual string emitVerilog() { return "((%r)'(%l))"; }
     virtual string emitC() { V3ERROR_NA; return ""; }
@@ -3688,7 +3688,7 @@ public:
 	dtypeFrom(typeFromp);
 	m_size=width();
     }
-    ASTNODE_NODE_FUNCS(CCast, CCAST)
+    ASTNODE_NODE_FUNCS(CCast)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opAssign(lhs); }
     virtual string emitVerilog() { return "%f$_CAST(%l)"; }
     virtual string emitC() { return "VL_CAST_%nq%lq(%nw,%lw, %P, %li)"; }
@@ -3706,7 +3706,7 @@ class AstCvtPackString : public AstNodeUniop {
 public:
     AstCvtPackString(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetString(); }  // Really, width should be dtypep -> STRING
-    ASTNODE_NODE_FUNCS(CvtPackString, CVTPACKSTRING)
+    ASTNODE_NODE_FUNCS(CvtPackString)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { V3ERROR_NA; }
     virtual string emitVerilog() { return "%f$_CAST(%l)"; }
     virtual string emitC() { return "VL_CVT_PACK_STR_N%lq(%lW, %li)"; }
@@ -3719,7 +3719,7 @@ public:
 class AstFEof : public AstNodeUniop {
 public:
     AstFEof(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {}
-    ASTNODE_NODE_FUNCS(FEof, FEOF)
+    ASTNODE_NODE_FUNCS(FEof)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { V3ERROR_NA; }
     virtual string emitVerilog() { return "%f$feof(%l)"; }
     virtual string emitC() { return "(%li ? feof(VL_CVT_I_FP(%li)) : true)"; }
@@ -3733,7 +3733,7 @@ public:
 class AstFGetC : public AstNodeUniop {
 public:
     AstFGetC(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {}
-    ASTNODE_NODE_FUNCS(FGetC, FGETC)
+    ASTNODE_NODE_FUNCS(FGetC)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) { V3ERROR_NA; }
     virtual string emitVerilog() { return "%f$fgetc(%l)"; }
     // Non-existent filehandle returns EOF
@@ -3749,7 +3749,7 @@ class AstCeilD : public AstNodeUniop {
 public:
     AstCeilD(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(CeilD, CEILD)
+    ASTNODE_NODE_FUNCS(CeilD)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) {
 	out.setDouble(ceil(lhs.toDouble())); }
     virtual string emitVerilog() { return "%f$ceil(%l)"; }
@@ -3764,7 +3764,7 @@ class AstExpD : public AstNodeUniop {
 public:
     AstExpD(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(ExpD, EXPD)
+    ASTNODE_NODE_FUNCS(ExpD)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) {
 	out.setDouble(exp(lhs.toDouble())); }
     virtual string emitVerilog() { return "%f$exp(%l)"; }
@@ -3779,7 +3779,7 @@ class AstFloorD : public AstNodeUniop {
 public:
     AstFloorD(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(FloorD, FLOORD)
+    ASTNODE_NODE_FUNCS(FloorD)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) {
 	out.setDouble(floor(lhs.toDouble())); }
     virtual string emitVerilog() { return "%f$floor(%l)"; }
@@ -3794,7 +3794,7 @@ class AstLogD : public AstNodeUniop {
 public:
     AstLogD(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(LogD, LOGD)
+    ASTNODE_NODE_FUNCS(LogD)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) {
 	out.setDouble(log(lhs.toDouble())); }
     virtual string emitVerilog() { return "%f$ln(%l)"; }
@@ -3809,7 +3809,7 @@ class AstLog10D : public AstNodeUniop {
 public:
     AstLog10D(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(Log10D, LOG10D)
+    ASTNODE_NODE_FUNCS(Log10D)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) {
 	out.setDouble(log10(lhs.toDouble())); }
     virtual string emitVerilog() { return "%f$log10(%l)"; }
@@ -3824,7 +3824,7 @@ class AstSqrtD : public AstNodeUniop {
 public:
     AstSqrtD(FileLine* fl, AstNode* lhsp) : AstNodeUniop(fl, lhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(SqrtD, SQRTD)
+    ASTNODE_NODE_FUNCS(SqrtD)
     virtual void numberOperate(V3Number& out, const V3Number& lhs) {
 	out.setDouble(sqrt(lhs.toDouble())); }
     virtual string emitVerilog() { return "%f$sqrt(%l)"; }
@@ -3842,7 +3842,7 @@ class AstLogOr : public AstNodeBiop {
 public:
     AstLogOr(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(LogOr, LOGOR)
+    ASTNODE_NODE_FUNCS(LogOr)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLogOr(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLogOr(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f|| %r)"; }
@@ -3857,7 +3857,7 @@ class AstLogAnd : public AstNodeBiop {
 public:
     AstLogAnd(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(LogAnd, LOGAND)
+    ASTNODE_NODE_FUNCS(LogAnd)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLogAnd(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLogAnd(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f&& %r)"; }
@@ -3872,7 +3872,7 @@ class AstLogIf : public AstNodeBiop {
 public:
     AstLogIf(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(LogIf, LOGIF)
+    ASTNODE_NODE_FUNCS(LogIf)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLogIf(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLogIf(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f-> %r)"; }
@@ -3887,7 +3887,7 @@ class AstLogIff : public AstNodeBiCom {
 public:
     AstLogIff(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiCom(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(LogIff, LOGIFF)
+    ASTNODE_NODE_FUNCS(LogIff)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLogIff(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLogIff(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f<-> %r)"; }
@@ -3902,7 +3902,7 @@ class AstOr : public AstNodeBiComAsv {
 public:
     AstOr(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(Or, OR)
+    ASTNODE_NODE_FUNCS(Or)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstOr(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opOr(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f| %r)"; }
@@ -3916,7 +3916,7 @@ class AstAnd : public AstNodeBiComAsv {
 public:
     AstAnd(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(And, AND)
+    ASTNODE_NODE_FUNCS(And)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstAnd(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opAnd(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f& %r)"; }
@@ -3930,7 +3930,7 @@ class AstXor : public AstNodeBiComAsv {
 public:
     AstXor(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(Xor, XOR)
+    ASTNODE_NODE_FUNCS(Xor)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstXor(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opXor(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f^ %r)"; }
@@ -3944,7 +3944,7 @@ class AstXnor : public AstNodeBiComAsv {
 public:
     AstXnor(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(Xnor, XNOR)
+    ASTNODE_NODE_FUNCS(Xnor)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstXnor(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opXnor(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f^ ~ %r)"; }
@@ -3958,7 +3958,7 @@ class AstEq : public AstNodeBiCom {
 public:
     AstEq(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiCom(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(Eq, EQ)
+    ASTNODE_NODE_FUNCS(Eq)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstEq(this->fileline(), lhsp, rhsp); }
     static AstNodeBiop* newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp);  // Return AstEq/AstEqD
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opEq(lhs,rhs); }
@@ -3973,7 +3973,7 @@ class AstEqD : public AstNodeBiCom {
 public:
     AstEqD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiCom(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(EqD, EQD)
+    ASTNODE_NODE_FUNCS(EqD)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstEqD(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opEqD(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f== %r)"; }
@@ -3989,7 +3989,7 @@ class AstEqN : public AstNodeBiCom {
 public:
     AstEqN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiCom(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(EqN, EQN)
+    ASTNODE_NODE_FUNCS(EqN)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstEqN(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opEqN(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f== %r)"; }
@@ -4005,7 +4005,7 @@ class AstNeq : public AstNodeBiCom {
 public:
     AstNeq(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiCom(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(Neq, NEQ)
+    ASTNODE_NODE_FUNCS(Neq)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstNeq(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opNeq(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f!= %r)"; }
@@ -4019,7 +4019,7 @@ class AstNeqD : public AstNodeBiCom {
 public:
     AstNeqD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiCom(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(NeqD, NEQD)
+    ASTNODE_NODE_FUNCS(NeqD)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstNeqD(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opNeqD(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f!= %r)"; }
@@ -4035,7 +4035,7 @@ class AstNeqN : public AstNodeBiCom {
 public:
     AstNeqN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiCom(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(NeqN, NEQN)
+    ASTNODE_NODE_FUNCS(NeqN)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstNeqN(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opNeqN(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f!= %r)"; }
@@ -4051,7 +4051,7 @@ class AstLt : public AstNodeBiop {
 public:
     AstLt(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(Lt, LT)
+    ASTNODE_NODE_FUNCS(Lt)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLt(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLt(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f< %r)"; }
@@ -4065,7 +4065,7 @@ class AstLtD : public AstNodeBiop {
 public:
     AstLtD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(LtD, LTD)
+    ASTNODE_NODE_FUNCS(LtD)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLtD(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLtD(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f< %r)"; }
@@ -4081,7 +4081,7 @@ class AstLtS : public AstNodeBiop {
 public:
     AstLtS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(LtS, LTS)
+    ASTNODE_NODE_FUNCS(LtS)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLtS(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLtS(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f< %r)"; }
@@ -4096,7 +4096,7 @@ class AstLtN : public AstNodeBiop {
 public:
     AstLtN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(LtN, LTN)
+    ASTNODE_NODE_FUNCS(LtN)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLtN(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLtN(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f< %r)"; }
@@ -4112,7 +4112,7 @@ class AstGt : public AstNodeBiop {
 public:
     AstGt(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(Gt, GT)
+    ASTNODE_NODE_FUNCS(Gt)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstGt(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opGt(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f> %r)"; }
@@ -4126,7 +4126,7 @@ class AstGtD : public AstNodeBiop {
 public:
     AstGtD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(GtD, GTD)
+    ASTNODE_NODE_FUNCS(GtD)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstGtD(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opGtD(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f> %r)"; }
@@ -4142,7 +4142,7 @@ class AstGtS : public AstNodeBiop {
 public:
     AstGtS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(GtS, GTS)
+    ASTNODE_NODE_FUNCS(GtS)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstGtS(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opGtS(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f> %r)"; }
@@ -4157,7 +4157,7 @@ class AstGtN : public AstNodeBiop {
 public:
     AstGtN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(GtN, GTN)
+    ASTNODE_NODE_FUNCS(GtN)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstGtN(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opGtN(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f> %r)"; }
@@ -4173,7 +4173,7 @@ class AstGte : public AstNodeBiop {
 public:
     AstGte(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(Gte, GTE)
+    ASTNODE_NODE_FUNCS(Gte)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstGte(this->fileline(), lhsp, rhsp); }
     static AstNodeBiop* newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp);  // Return AstGte/AstGteS/AstGteD
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opGte(lhs,rhs); }
@@ -4188,7 +4188,7 @@ class AstGteD : public AstNodeBiop {
 public:
     AstGteD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(GteD, GTED)
+    ASTNODE_NODE_FUNCS(GteD)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstGteD(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opGteD(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f>= %r)"; }
@@ -4204,7 +4204,7 @@ class AstGteS : public AstNodeBiop {
 public:
     AstGteS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(GteS, GTES)
+    ASTNODE_NODE_FUNCS(GteS)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstGteS(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opGteS(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f>= %r)"; }
@@ -4219,7 +4219,7 @@ class AstGteN : public AstNodeBiop {
 public:
     AstGteN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(GteN, GTEN)
+    ASTNODE_NODE_FUNCS(GteN)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstGteN(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opGteN(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f>= %r)"; }
@@ -4235,7 +4235,7 @@ class AstLte : public AstNodeBiop {
 public:
     AstLte(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(Lte, LTE)
+    ASTNODE_NODE_FUNCS(Lte)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLte(this->fileline(), lhsp, rhsp); }
     static AstNodeBiop* newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp);  // Return AstLte/AstLteS/AstLteD
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLte(lhs,rhs); }
@@ -4250,7 +4250,7 @@ class AstLteD : public AstNodeBiop {
 public:
     AstLteD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(LteD, LTED)
+    ASTNODE_NODE_FUNCS(LteD)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLteD(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLteD(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f<= %r)"; }
@@ -4266,7 +4266,7 @@ class AstLteS : public AstNodeBiop {
 public:
     AstLteS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(LteS, LTES)
+    ASTNODE_NODE_FUNCS(LteS)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLteS(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLteS(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f<= %r)"; }
@@ -4281,7 +4281,7 @@ class AstLteN : public AstNodeBiop {
 public:
     AstLteN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(LteN, LTEN)
+    ASTNODE_NODE_FUNCS(LteN)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstLteN(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opLteN(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f<= %r)"; }
@@ -4299,7 +4299,7 @@ public:
 	: AstNodeBiop(fl, lhsp, rhsp) {
 	if (setwidth) { dtypeSetLogicSized(setwidth,setwidth,AstNumeric::UNSIGNED); }
     }
-    ASTNODE_NODE_FUNCS(ShiftL, SHIFTL)
+    ASTNODE_NODE_FUNCS(ShiftL)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstShiftL(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opShiftL(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f<< %r)"; }
@@ -4315,7 +4315,7 @@ public:
 	: AstNodeBiop(fl, lhsp, rhsp) {
 	if (setwidth) { dtypeSetLogicSized(setwidth,setwidth,AstNumeric::UNSIGNED); }
     }
-    ASTNODE_NODE_FUNCS(ShiftR, SHIFTR)
+    ASTNODE_NODE_FUNCS(ShiftR)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstShiftR(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opShiftR(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f>> %r)"; }
@@ -4334,7 +4334,7 @@ public:
 	// Important that widthMin be correct, as opExtend requires it after V3Expand
 	if (setwidth) { dtypeSetLogicSized(setwidth,setwidth,AstNumeric::SIGNED); }
     }
-    ASTNODE_NODE_FUNCS(ShiftRS, SHIFTRS)
+    ASTNODE_NODE_FUNCS(ShiftRS)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstShiftRS(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) {
 	out.opShiftRS(lhs,rhs,lhsp()->widthMinV()); }
@@ -4350,7 +4350,7 @@ class AstAdd : public AstNodeBiComAsv {
 public:
     AstAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(Add, ADD)
+    ASTNODE_NODE_FUNCS(Add)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstAdd(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opAdd(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f+ %r)"; }
@@ -4364,7 +4364,7 @@ class AstAddD : public AstNodeBiComAsv {
 public:
     AstAddD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(AddD, ADDD)
+    ASTNODE_NODE_FUNCS(AddD)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstAddD(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opAddD(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f+ %r)"; }
@@ -4380,7 +4380,7 @@ class AstSub : public AstNodeBiop {
 public:
     AstSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(Sub, SUB)
+    ASTNODE_NODE_FUNCS(Sub)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstSub(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opSub(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f- %r)"; }
@@ -4394,7 +4394,7 @@ class AstSubD : public AstNodeBiop {
 public:
     AstSubD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(SubD, SUBD)
+    ASTNODE_NODE_FUNCS(SubD)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstSubD(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opSubD(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f- %r)"; }
@@ -4410,7 +4410,7 @@ class AstMul : public AstNodeBiComAsv {
 public:
     AstMul(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(Mul, MUL)
+    ASTNODE_NODE_FUNCS(Mul)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstMul(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opMul(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f* %r)"; }
@@ -4425,7 +4425,7 @@ class AstMulD : public AstNodeBiComAsv {
 public:
     AstMulD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(MulD, MULD)
+    ASTNODE_NODE_FUNCS(MulD)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstMulD(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opMulD(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f* %r)"; }
@@ -4441,7 +4441,7 @@ class AstMulS : public AstNodeBiComAsv {
 public:
     AstMulS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiComAsv(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(MulS, MULS)
+    ASTNODE_NODE_FUNCS(MulS)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstMulS(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opMulS(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f* %r)"; }
@@ -4457,7 +4457,7 @@ class AstDiv : public AstNodeBiop {
 public:
     AstDiv(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(Div, DIV)
+    ASTNODE_NODE_FUNCS(Div)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstDiv(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opDiv(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f/ %r)"; }
@@ -4471,7 +4471,7 @@ class AstDivD : public AstNodeBiop {
 public:
     AstDivD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(DivD, DIVD)
+    ASTNODE_NODE_FUNCS(DivD)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstDivD(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opDivD(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f/ %r)"; }
@@ -4487,7 +4487,7 @@ class AstDivS : public AstNodeBiop {
 public:
     AstDivS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(DivS, DIVS)
+    ASTNODE_NODE_FUNCS(DivS)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstDivS(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opDivS(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f/ %r)"; }
@@ -4502,7 +4502,7 @@ class AstModDiv : public AstNodeBiop {
 public:
     AstModDiv(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(ModDiv, MODDIV)
+    ASTNODE_NODE_FUNCS(ModDiv)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstModDiv(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opModDiv(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f%% %r)"; }
@@ -4516,7 +4516,7 @@ class AstModDivS : public AstNodeBiop {
 public:
     AstModDivS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(ModDivS, MODDIVS)
+    ASTNODE_NODE_FUNCS(ModDivS)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstModDivS(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opModDivS(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f%% %r)"; }
@@ -4531,7 +4531,7 @@ class AstPow : public AstNodeBiop {
 public:
     AstPow(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(Pow, POW)
+    ASTNODE_NODE_FUNCS(Pow)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstPow(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opPow(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f** %r)"; }
@@ -4545,7 +4545,7 @@ class AstPowD : public AstNodeBiop {
 public:
     AstPowD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetDouble(); }
-    ASTNODE_NODE_FUNCS(PowD, POWD)
+    ASTNODE_NODE_FUNCS(PowD)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstPowD(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opPowD(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f** %r)"; }
@@ -4560,7 +4560,7 @@ class AstPowSU : public AstNodeBiop {
 public:
     AstPowSU(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(PowSU, POWSU)
+    ASTNODE_NODE_FUNCS(PowSU)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstPowSU(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opPowSU(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f** %r)"; }
@@ -4575,7 +4575,7 @@ class AstPowSS : public AstNodeBiop {
 public:
     AstPowSS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(PowSS, POWSS)
+    ASTNODE_NODE_FUNCS(PowSS)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstPowSS(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opPowSS(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f** %r)"; }
@@ -4590,7 +4590,7 @@ class AstPowUS : public AstNodeBiop {
 public:
     AstPowUS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(PowUS, POWUS)
+    ASTNODE_NODE_FUNCS(PowUS)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstPowUS(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opPowUS(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f** %r)"; }
@@ -4605,7 +4605,7 @@ class AstEqCase : public AstNodeBiCom {
 public:
     AstEqCase(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiCom(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(EqCase, EQCASE)
+    ASTNODE_NODE_FUNCS(EqCase)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstEqCase(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opCaseEq(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f=== %r)"; }
@@ -4619,7 +4619,7 @@ class AstNeqCase : public AstNodeBiCom {
 public:
     AstNeqCase(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiCom(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(NeqCase, NEQCASE)
+    ASTNODE_NODE_FUNCS(NeqCase)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstNeqCase(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opCaseNeq(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f!== %r)"; }
@@ -4634,7 +4634,7 @@ class AstEqWild : public AstNodeBiop {
 public:
     AstEqWild(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(EqWild, EQWILD)
+    ASTNODE_NODE_FUNCS(EqWild)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstEqWild(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opWildEq(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f==? %r)"; }
@@ -4648,7 +4648,7 @@ class AstNeqWild : public AstNodeBiop {
 public:
     AstNeqWild(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetLogicBool(); }
-    ASTNODE_NODE_FUNCS(NeqWild, NEQWILD)
+    ASTNODE_NODE_FUNCS(NeqWild)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstNeqWild(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opWildNeq(lhs,rhs); }
     virtual string emitVerilog() { return "%k(%l %f!=? %r)"; }
@@ -4668,7 +4668,7 @@ public:
 			       AstNumeric::UNSIGNED);
 	}
     }
-    ASTNODE_NODE_FUNCS(Concat, CONCAT)
+    ASTNODE_NODE_FUNCS(Concat)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstConcat(this->fileline(), lhsp, rhsp); }
     virtual string emitVerilog() { return "%f{%l, %k%r}"; }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opConcat(lhs,rhs); }
@@ -4684,7 +4684,7 @@ public:
     AstConcatN(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeSetString();
     }
-    ASTNODE_NODE_FUNCS(ConcatN, CONCATN)
+    ASTNODE_NODE_FUNCS(ConcatN)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstConcatN(this->fileline(), lhsp, rhsp); }
     virtual string emitVerilog() { return "%f{%l, %k%r}"; }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opConcatN(lhs,rhs); }
@@ -4711,7 +4711,7 @@ public:
         : AstNodeBiop(fl, lhsp, rhsp) { init(); }
     AstReplicate(FileLine* fl, AstNode* lhsp, uint32_t repCount)
 	: AstNodeBiop(fl, lhsp, new AstConst(fl, repCount)) { init(); }
-    ASTNODE_NODE_FUNCS(Replicate, REPLICATE)
+    ASTNODE_NODE_FUNCS(Replicate)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstReplicate(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opRepl(lhs,rhs); }
     virtual string emitVerilog() { return "%f{%r{%k%l}}"; }
@@ -4730,7 +4730,7 @@ public:
         : AstNodeBiop(fl, lhsp, rhsp) { init(); }
     AstReplicateN(FileLine* fl, AstNode* lhsp, uint32_t repCount)
 	: AstNodeBiop(fl, lhsp, new AstConst(fl, repCount)) { init(); }
-    ASTNODE_NODE_FUNCS(ReplicateN, REPLICATEN)
+    ASTNODE_NODE_FUNCS(ReplicateN)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstReplicateN(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opReplN(lhs,rhs); }
     virtual string emitVerilog() { return "%f{%r{%k%l}}"; }
@@ -4745,7 +4745,7 @@ class AstStreamL : public AstNodeStream {
     // Verilog {rhs{lhs}} - Note rhsp() is the slice size, not the lhsp()
 public:
     AstStreamL(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeStream(fl, lhsp, rhsp) {}
-    ASTNODE_NODE_FUNCS(StreamL, STREAML)
+    ASTNODE_NODE_FUNCS(StreamL)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstStreamL(this->fileline(), lhsp, rhsp); }
     virtual string emitVerilog() { return "%f{ << %r %k{%l} }"; }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opStreamL(lhs,rhs); }
@@ -4759,7 +4759,7 @@ class AstStreamR : public AstNodeStream {
     // Verilog {rhs{lhs}} - Note rhsp() is the slice size, not the lhsp()
 public:
     AstStreamR(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeStream(fl, lhsp, rhsp) {}
-    ASTNODE_NODE_FUNCS(StreamR, STREAMR)
+    ASTNODE_NODE_FUNCS(StreamR)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstStreamR(this->fileline(), lhsp, rhsp); }
     virtual string emitVerilog() { return "%f{ >> %r %k{%l} }"; }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opAssign(lhs); }
@@ -4775,7 +4775,7 @@ class AstBufIf1 : public AstNodeBiop {
 public:
     AstBufIf1(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
 	dtypeFrom(lhsp); }
-    ASTNODE_NODE_FUNCS(BufIf1, BUFIF1)
+    ASTNODE_NODE_FUNCS(BufIf1)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstBufIf1(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { out.opBufIf1(lhs,rhs); }
     virtual string emitVerilog() { return "bufif(%r,%l)"; }
@@ -4788,7 +4788,7 @@ public:
 class AstFGetS : public AstNodeBiop {
 public:
     AstFGetS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {}
-    ASTNODE_NODE_FUNCS(FGetS, FGETS)
+    ASTNODE_NODE_FUNCS(FGetS)
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { return new AstFGetS(this->fileline(), lhsp, rhsp); }
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { V3ERROR_NA; }
     virtual string emitVerilog() { return "%f$fgets(%l,%r)"; }
@@ -4809,7 +4809,7 @@ public:
     AstPattern(FileLine* fl, AstNode* itemsp) : AstNodeMath(fl) {
 	addNOp2p(itemsp);
     }
-    ASTNODE_NODE_FUNCS(Pattern, PATTERN)
+    ASTNODE_NODE_FUNCS(Pattern)
     virtual string emitVerilog() { V3ERROR_NA; return ""; }  // Implemented specially
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { V3ERROR_NA; }
     virtual string emitC() { V3ERROR_NA; return "";}
@@ -4831,7 +4831,7 @@ private:
 public:
     AstPatMember(FileLine* fl, AstNode* lhsp, AstNode* keyp, AstNode* repp) : AstNodeMath(fl) {
 	addOp1p(lhsp), setNOp2p(keyp), setNOp3p(repp); m_default = false; }
-    ASTNODE_NODE_FUNCS(PatMember, PATMEMBER)
+    ASTNODE_NODE_FUNCS(PatMember)
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { V3ERROR_NA; }
     virtual string emitVerilog() { return lhssp()?"%f{%r{%k%l}}":"%l"; }
     virtual string emitC() { V3ERROR_NA; return "";}
@@ -4859,7 +4859,7 @@ public:
 	addNOp2p(passsp);
 	addNOp3p(failsp);
     }
-    ASTNODE_NODE_FUNCS(VAssert, VASSERT)
+    ASTNODE_NODE_FUNCS(VAssert)
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(AstNode* samep) const { return true; }
     AstNode*	propp()		const { return op1p(); }	// op1 = property
@@ -4880,7 +4880,7 @@ public:
 	addOp1p(sensesp);
 	addNOp2p(bodysp);
     }
-    ASTNODE_NODE_FUNCS(Clocking, CLOCKING)
+    ASTNODE_NODE_FUNCS(Clocking)
     AstNodeSenItem* sensesp() 	const { return op1p()->castNodeSenItem(); }	// op1 = Sensitivity list
     AstNode*	bodysp() 	const { return op2p(); }	// op2 = Body
 };
@@ -4899,7 +4899,7 @@ public:
 	addNOp2p(disablep);
 	addOp3p(propp);
     }
-    ASTNODE_NODE_FUNCS(PslClocked, PSLCLOCKED)
+    ASTNODE_NODE_FUNCS(PslClocked)
     virtual bool hasDType() const { return true; }  // Used under PslCover, which expects a bool child
     AstNodeSenItem* sensesp() 	const { return op1p()->castNodeSenItem(); }	// op1 = Sensitivity list
     AstNode*	disablep()	const { return op2p(); }	// op2 = disable
@@ -4919,7 +4919,7 @@ public:
 	addOp1p(propp);
 	addNOp4p(stmtsp);
     }
-    ASTNODE_NODE_FUNCS(PslCover, PSLCOVER)
+    ASTNODE_NODE_FUNCS(PslCover)
     virtual string name()	const { return m_name; }		// * = Var name
     virtual V3Hash sameHash() const { return V3Hash(name()); }
     virtual bool same(AstNode* samep) const { return samep->name() == name(); }
@@ -4941,7 +4941,7 @@ private:
 public:
     AstText(FileLine* fl, const string& textp, bool tracking=false)
 	: AstNodeText(fl, textp), m_tracking(tracking) {}
-    ASTNODE_NODE_FUNCS(Text, TEXT)
+    ASTNODE_NODE_FUNCS(Text)
     void tracking(bool flag) { m_tracking = flag; }
     bool tracking() const { return m_tracking; }
 };
@@ -4950,7 +4950,7 @@ class AstScCtor : public AstNodeText {
 public:
     AstScCtor(FileLine* fl, const string& textp)
 	: AstNodeText(fl, textp) {}
-    ASTNODE_NODE_FUNCS(ScCtor, SCCTOR)
+    ASTNODE_NODE_FUNCS(ScCtor)
     virtual bool isPure() const { return false; }	// SPECIAL: User may order w/other sigs
     virtual bool isOutputter() const { return true; }
 };
@@ -4959,7 +4959,7 @@ class AstScDtor : public AstNodeText {
 public:
     AstScDtor(FileLine* fl, const string& textp)
 	: AstNodeText(fl, textp) {}
-    ASTNODE_NODE_FUNCS(ScDtor, SCDTOR)
+    ASTNODE_NODE_FUNCS(ScDtor)
     virtual bool isPure() const { return false; }	// SPECIAL: User may order w/other sigs
     virtual bool isOutputter() const { return true; }
 };
@@ -4968,7 +4968,7 @@ class AstScHdr : public AstNodeText {
 public:
     AstScHdr(FileLine* fl, const string& textp)
 	: AstNodeText(fl, textp) {}
-    ASTNODE_NODE_FUNCS(ScHdr, SCHDR)
+    ASTNODE_NODE_FUNCS(ScHdr)
     virtual bool isPure() const { return false; }	// SPECIAL: User may order w/other sigs
     virtual bool isOutputter() const { return true; }
 };
@@ -4977,7 +4977,7 @@ class AstScImp : public AstNodeText {
 public:
     AstScImp(FileLine* fl, const string& textp)
 	: AstNodeText(fl, textp) {}
-    ASTNODE_NODE_FUNCS(ScImp, SCIMP)
+    ASTNODE_NODE_FUNCS(ScImp)
     virtual bool isPure() const { return false; }	// SPECIAL: User may order w/other sigs
     virtual bool isOutputter() const { return true; }
 };
@@ -4986,7 +4986,7 @@ class AstScImpHdr : public AstNodeText {
 public:
     AstScImpHdr(FileLine* fl, const string& textp)
 	: AstNodeText(fl, textp) {}
-    ASTNODE_NODE_FUNCS(ScImpHdr, SCIMPHDR)
+    ASTNODE_NODE_FUNCS(ScImpHdr)
     virtual bool isPure() const { return false; }	// SPECIAL: User may order w/other sigs
     virtual bool isOutputter() const { return true; }
 };
@@ -4995,7 +4995,7 @@ class AstScInt : public AstNodeText {
 public:
     AstScInt(FileLine* fl, const string& textp)
 	: AstNodeText(fl, textp) {}
-    ASTNODE_NODE_FUNCS(ScInt, SCINT)
+    ASTNODE_NODE_FUNCS(ScInt)
     virtual bool isPure() const { return false; }	// SPECIAL: User may order w/other sigs
     virtual bool isOutputter() const { return true; }
 };
@@ -5007,7 +5007,7 @@ public:
 	: AstNodeStmt(fl) {
 	addNOp1p(exprsp);
     }
-    ASTNODE_NODE_FUNCS(UCStmt, UCSTMT)
+    ASTNODE_NODE_FUNCS(UCStmt)
     AstNode*	bodysp()	const { return op1p()->castNode(); }	// op1= expressions to print
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
@@ -5037,7 +5037,7 @@ public:
 	m_source = false;
 	m_support = false;
     }
-    ASTNODE_NODE_FUNCS(CFile, CFILE)
+    ASTNODE_NODE_FUNCS(CFile)
     virtual string name()	const { return m_name; }
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(AstNode* samep) const { return true; }
@@ -5097,7 +5097,7 @@ public:
 	m_dpiExportWrapper = false;
 	m_dpiImport = false;
     }
-    ASTNODE_NODE_FUNCS(CFunc, CFUNC)
+    ASTNODE_NODE_FUNCS(CFunc)
     virtual string name()	const { return m_name; }
     virtual const char* broken() const { BROKEN_RTN((m_scopep && !m_scopep->brokeExists())); return NULL; }
     virtual bool maybePointedTo() const { return true; }
@@ -5185,7 +5185,7 @@ public:
 	m_argTypes = oldp->argTypes();
 	if (oldp->argsp()) addNOp1p(oldp->argsp()->unlinkFrBackWithNext());
     }
-    ASTNODE_NODE_FUNCS(CCall, CCALL)
+    ASTNODE_NODE_FUNCS(CCall)
     virtual void dump(ostream& str=cout);
     virtual void cloneRelink() { if (m_funcp && m_funcp->clonep()) {
 	m_funcp = m_funcp->clonep()->castCFunc();
@@ -5220,7 +5220,7 @@ public:
 	: AstNodeStmt(fl) {
 	setOp1p(lhsp);
     }
-    ASTNODE_NODE_FUNCS(CReturn, CRETURN)
+    ASTNODE_NODE_FUNCS(CReturn)
     virtual int instrCount()	const { return widthInstrs(); }
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(AstNode*) const { return true; }
@@ -5243,7 +5243,7 @@ public:
 	addNOp1p(new AstText(fl, textStmt, true));
 	if (setwidth) { dtypeSetLogicSized(setwidth,setwidth,AstNumeric::UNSIGNED); }
     }
-    ASTNODE_NODE_FUNCS(CMath, CMATH)
+    ASTNODE_NODE_FUNCS(CMath)
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
     virtual bool cleanOut() { return m_cleanOut; }
@@ -5263,7 +5263,7 @@ public:
 	: AstNodeStmt(fl) {
 	addNOp1p(exprsp);
     }
-    ASTNODE_NODE_FUNCS(CReset, CRESET)
+    ASTNODE_NODE_FUNCS(CReset)
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
     virtual V3Hash sameHash() const { return V3Hash(); }
@@ -5282,7 +5282,7 @@ public:
 	: AstNodeStmt(fl) {
 	addNOp1p(new AstText(fl, textStmt, true));
     }
-    ASTNODE_NODE_FUNCS(CStmt, CSTMT)
+    ASTNODE_NODE_FUNCS(CStmt)
     virtual bool isGateOptimizable() const { return false; }
     virtual bool isPredictOptimizable() const { return false; }
     virtual V3Hash sameHash() const { return V3Hash(); }
@@ -5309,7 +5309,7 @@ public:
     explicit AstTypeTable(FileLine* fl) : AstNode(fl) {
 	for (int i=0; i<AstBasicDTypeKwd::_ENUM_MAX; ++i) m_basicps[i] = NULL;
     }
-    ASTNODE_NODE_FUNCS(TypeTable, TYPETABLE)
+    ASTNODE_NODE_FUNCS(TypeTable)
     AstNodeDType*     typesp() 	const { return op1p()->castNodeDType();}	// op1 = List of dtypes
     void addTypesp(AstNodeDType* nodep) { addOp1p(nodep); }
     AstBasicDType* findBasicDType(FileLine* fl, AstBasicDTypeKwd kwd);
@@ -5338,7 +5338,7 @@ public:
 	m_typeTablep = NULL;
 	m_dollarUnitPkgp = NULL;
     }
-    ASTNODE_NODE_FUNCS(Netlist, NETLIST)
+    ASTNODE_NODE_FUNCS(Netlist)
     virtual const char* broken() const { BROKEN_RTN(m_dollarUnitPkgp && !m_dollarUnitPkgp->brokeExists()); return NULL; }
     AstNodeModule*	modulesp() 	const { return op1p()->castNodeModule();}	// op1 = List of modules
     AstNodeModule*  topModulep() const { return op1p()->castNodeModule(); }	// * = Top module in hierarchy (first one added, for now)
diff --git a/src/V3EmitC.cpp b/src/V3EmitC.cpp
index bf85f4e94..f6020396f 100644
--- a/src/V3EmitC.cpp
+++ b/src/V3EmitC.cpp
@@ -1501,7 +1501,7 @@ void EmitCImp::emitCtorImp(AstNodeModule* modp) {
     }
     putsDecoration("// Reset structure values\n");
     puts("_ctor_var_reset();\n");
-    emitTextSection(AstType::atSCCTOR);
+    emitTextSection(AstType::atScCtor);
     if (optSystemPerl()) puts("SP_AUTO_CTOR;\n");
     puts("}\n");
 }
@@ -1545,7 +1545,7 @@ void EmitCImp::emitCoverageImp(AstNodeModule* modp) {
 void EmitCImp::emitDestructorImp(AstNodeModule* modp) {
     puts("\n");
     puts(modClassName(modp)+"::~"+modClassName(modp)+"() {\n");
-    emitTextSection(AstType::atSCDTOR);
+    emitTextSection(AstType::atScDtor);
     if (modp->isTop()) puts("delete __VlSymsp; __VlSymsp=NULL;\n");
     puts("}\n");
     splitSizeInc(10);
@@ -1864,7 +1864,7 @@ void EmitCImp::emitInt(AstNodeModule* modp) {
     }
 
     puts("\n//----------\n\n");
-    emitTextSection(AstType::atSCHDR);
+    emitTextSection(AstType::atScHdr);
 
     if (optSystemC() && modp->isTop()) {
 	puts("SC_MODULE("+modClassName(modp)+") {\n");
@@ -1981,7 +1981,7 @@ void EmitCImp::emitInt(AstNodeModule* modp) {
 
     puts("\n// USER METHODS\n");
     if (optSystemPerl()) puts("/*AUTOMETHODS*/\n");
-    emitTextSection(AstType::atSCINT);
+    emitTextSection(AstType::atScInt);
 
     puts("\n// API METHODS\n");
     if (modp->isTop()) {
@@ -2059,7 +2059,7 @@ void EmitCImp::emitImp(AstNodeModule* modp) {
 	puts("SP_MODULE_CONTINUED("+modClassName(modp)+");\n");
     }
 
-    emitTextSection(AstType::atSCIMPHDR);
+    emitTextSection(AstType::atScImpHdr);
 
     if (m_slow && splitFilenum()==0) {
 	puts("\n//--------------------\n");
@@ -2068,7 +2068,7 @@ void EmitCImp::emitImp(AstNodeModule* modp) {
     }
 
     if (m_fast && splitFilenum()==0) {
-	emitTextSection(AstType::atSCIMP);
+	emitTextSection(AstType::atScImp);
 	emitStaticDecl(modp);
     }
 
diff --git a/src/V3Slice.cpp b/src/V3Slice.cpp
index 2be2706f1..314f79fa4 100644
--- a/src/V3Slice.cpp
+++ b/src/V3Slice.cpp
@@ -147,16 +147,16 @@ class SliceCloneVisitor : public AstNVisitor {
 	    if (!lhsp) lhsp = clonep;
 	    else {
 		switch (nodep->type()) {
-		case AstType::atREDOR:
+		case AstType::atRedOr:
 		    lhsp = new AstOr(nodep->fileline(), lhsp, clonep);
 		    break;
-		case AstType::atREDAND:
+		case AstType::atRedAnd:
 		    lhsp = new AstAnd(nodep->fileline(), lhsp, clonep);
 		    break;
-		case AstType::atREDXOR:
+		case AstType::atRedXor:
 		    lhsp = new AstXor(nodep->fileline(), lhsp, clonep);
 		    break;
-		case AstType::atREDXNOR:
+		case AstType::atRedXnor:
 		    lhsp = new AstXnor(nodep->fileline(), lhsp, clonep);
 		    break;
 		default:
@@ -492,12 +492,12 @@ class SliceVisitor : public AstNVisitor {
 		    if (!logp) logp = clonep;
 		    else {
 			switch (nodep->type()) {
-			case AstType::atEQ:  // FALLTHRU
-			case AstType::atEQCASE:
+			case AstType::atEq:  // FALLTHRU
+			case AstType::atEqCase:
 			    logp = new AstLogAnd(nodep->fileline(), logp, clonep);
 			    break;
-			case AstType::atNEQ:  // FALLTHRU
-			case AstType::atNEQCASE:
+			case AstType::atNeq:  // FALLTHRU
+			case AstType::atNeqCase:
 			    logp = new AstLogOr(nodep->fileline(), logp, clonep);
 			    break;
 			default:
diff --git a/src/V3Width.cpp b/src/V3Width.cpp
index 7d9e3ecaf..7b74d7a18 100644
--- a/src/V3Width.cpp
+++ b/src/V3Width.cpp
@@ -3162,13 +3162,13 @@ private:
 	if (!nodep->dtypep()) nodep->dtypeFrom(nodep->lhsp());
 	// To simplify callers, some node types don't need to change
 	switch (nodep->type()) {
-	case AstType::atEQ:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
-	case AstType::atNEQ:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
-	case AstType::atEQCASE:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
-	case AstType::atNEQCASE: nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
-	case AstType::atADD:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
-	case AstType::atSUB:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
-	case AstType::atSHIFTL:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
+	case AstType::atEq:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
+	case AstType::atNeq:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
+	case AstType::atEqCase:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
+	case AstType::atNeqCase: nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
+	case AstType::atAdd:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
+	case AstType::atSub:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
+	case AstType::atShiftL:	nodep->dtypeChgSigned(signedFlavorNeeded); return NULL;
 	default: break;
 	}
 	FileLine* fl = nodep->fileline();
@@ -3176,22 +3176,22 @@ private:
 	AstNode* rhsp = nodep->rhsp()->unlinkFrBack();
 	AstNodeBiop* newp = NULL;
 	switch (nodep->type()) {
-	case AstType::atGT:	newp = new AstGtS	(fl,lhsp,rhsp); break;
-	case AstType::atGTS:	newp = new AstGt	(fl,lhsp,rhsp); break;
-	case AstType::atGTE:	newp = new AstGteS	(fl,lhsp,rhsp); break;
-	case AstType::atGTES:	newp = new AstGte	(fl,lhsp,rhsp); break;
-	case AstType::atLT:	newp = new AstLtS	(fl,lhsp,rhsp); break;
-	case AstType::atLTS:	newp = new AstLt	(fl,lhsp,rhsp); break;
-	case AstType::atLTE:	newp = new AstLteS	(fl,lhsp,rhsp); break;
-	case AstType::atLTES:	newp = new AstLte	(fl,lhsp,rhsp); break;
-	case AstType::atDIV:	newp = new AstDivS	(fl,lhsp,rhsp); break;
-	case AstType::atDIVS:	newp = new AstDiv	(fl,lhsp,rhsp); break;
-	case AstType::atMODDIV:	newp = new AstModDivS	(fl,lhsp,rhsp); break;
-	case AstType::atMODDIVS: newp = new AstModDiv 	(fl,lhsp,rhsp); break;
-	case AstType::atMUL:	newp = new AstMulS	(fl,lhsp,rhsp); break;
-	case AstType::atMULS:	newp = new AstMul	(fl,lhsp,rhsp); break;
-	case AstType::atSHIFTR:	newp = new AstShiftRS	(fl,lhsp,rhsp); break;
-	case AstType::atSHIFTRS: newp = new AstShiftR	(fl,lhsp,rhsp); break;
+	case AstType::atGt:	newp = new AstGtS	(fl,lhsp,rhsp); break;
+	case AstType::atGtS:	newp = new AstGt	(fl,lhsp,rhsp); break;
+	case AstType::atGte:	newp = new AstGteS	(fl,lhsp,rhsp); break;
+	case AstType::atGteS:	newp = new AstGte	(fl,lhsp,rhsp); break;
+	case AstType::atLt:	newp = new AstLtS	(fl,lhsp,rhsp); break;
+	case AstType::atLtS:	newp = new AstLt	(fl,lhsp,rhsp); break;
+	case AstType::atLte:	newp = new AstLteS	(fl,lhsp,rhsp); break;
+	case AstType::atLteS:	newp = new AstLte	(fl,lhsp,rhsp); break;
+	case AstType::atDiv:	newp = new AstDivS	(fl,lhsp,rhsp); break;
+	case AstType::atDivS:	newp = new AstDiv	(fl,lhsp,rhsp); break;
+	case AstType::atModDiv:	newp = new AstModDivS	(fl,lhsp,rhsp); break;
+	case AstType::atModDivS: newp = new AstModDiv 	(fl,lhsp,rhsp); break;
+	case AstType::atMul:	newp = new AstMulS	(fl,lhsp,rhsp); break;
+	case AstType::atMulS:	newp = new AstMul	(fl,lhsp,rhsp); break;
+	case AstType::atShiftR:	newp = new AstShiftRS	(fl,lhsp,rhsp); break;
+	case AstType::atShiftRS: newp = new AstShiftR	(fl,lhsp,rhsp); break;
 	default:
 	    nodep->v3fatalSrc("Node needs sign change, but bad case: "<<nodep<<endl);
 	    break;
@@ -3214,17 +3214,17 @@ private:
 	AstNodeBiop* newp = NULL;
 	// No width change on output;...		// All below have bool or double outputs
 	switch (nodep->type()) {
-	case AstType::atADD:  				newp = new AstAddD	(fl,lhsp,rhsp); break;
-	case AstType::atSUB:  				newp = new AstSubD	(fl,lhsp,rhsp); break;
-	case AstType::atPOW:				newp = new AstPowD	(fl,lhsp,rhsp); break;
-	case AstType::atEQ:	case AstType::atEQCASE:	newp = new AstEqD	(fl,lhsp,rhsp); break;
-	case AstType::atNEQ:	case AstType::atNEQCASE: newp = new AstNeqD	(fl,lhsp,rhsp); break;
-	case AstType::atGT:	case AstType::atGTS:	newp = new AstGtD	(fl,lhsp,rhsp); break;
-	case AstType::atGTE:	case AstType::atGTES:	newp = new AstGteD	(fl,lhsp,rhsp); break;
-	case AstType::atLT:	case AstType::atLTS:	newp = new AstLtD	(fl,lhsp,rhsp); break;
-	case AstType::atLTE:	case AstType::atLTES:	newp = new AstLteD	(fl,lhsp,rhsp); break;
-	case AstType::atDIV:	case AstType::atDIVS:	newp = new AstDivD	(fl,lhsp,rhsp); break;
-	case AstType::atMUL:	case AstType::atMULS:	newp = new AstMulD	(fl,lhsp,rhsp); break;
+	case AstType::atAdd:  				newp = new AstAddD	(fl,lhsp,rhsp); break;
+	case AstType::atSub:  				newp = new AstSubD	(fl,lhsp,rhsp); break;
+	case AstType::atPow:				newp = new AstPowD	(fl,lhsp,rhsp); break;
+	case AstType::atEq:	case AstType::atEqCase:	newp = new AstEqD	(fl,lhsp,rhsp); break;
+	case AstType::atNeq:	case AstType::atNeqCase: newp = new AstNeqD	(fl,lhsp,rhsp); break;
+	case AstType::atGt:	case AstType::atGtS:	newp = new AstGtD	(fl,lhsp,rhsp); break;
+	case AstType::atGte:	case AstType::atGteS:	newp = new AstGteD	(fl,lhsp,rhsp); break;
+	case AstType::atLt:	case AstType::atLtS:	newp = new AstLtD	(fl,lhsp,rhsp); break;
+	case AstType::atLte:	case AstType::atLteS:	newp = new AstLteD	(fl,lhsp,rhsp); break;
+	case AstType::atDiv:	case AstType::atDivS:	newp = new AstDivD	(fl,lhsp,rhsp); break;
+	case AstType::atMul:	case AstType::atMulS:	newp = new AstMulD	(fl,lhsp,rhsp); break;
 	default:
 	    nodep->v3fatalSrc("Node needs conversion to double, but bad case: "<<nodep<<endl);
 	    break;
@@ -3247,12 +3247,12 @@ private:
 	AstNodeBiop* newp = NULL;
 	// No width change on output;...		// All below have bool or double outputs
 	switch (nodep->type()) {
-	case AstType::atEQ:	case AstType::atEQCASE:	newp = new AstEqN	(fl,lhsp,rhsp); break;
-	case AstType::atNEQ:	case AstType::atNEQCASE: newp = new AstNeqN	(fl,lhsp,rhsp); break;
-	case AstType::atGT:	case AstType::atGTS:	newp = new AstGtN	(fl,lhsp,rhsp); break;
-	case AstType::atGTE:	case AstType::atGTES:	newp = new AstGteN	(fl,lhsp,rhsp); break;
-	case AstType::atLT:	case AstType::atLTS:	newp = new AstLtN	(fl,lhsp,rhsp); break;
-	case AstType::atLTE:	case AstType::atLTES:	newp = new AstLteN	(fl,lhsp,rhsp); break;
+	case AstType::atEq:	case AstType::atEqCase:	newp = new AstEqN	(fl,lhsp,rhsp); break;
+	case AstType::atNeq:	case AstType::atNeqCase: newp = new AstNeqN	(fl,lhsp,rhsp); break;
+	case AstType::atGt:	case AstType::atGtS:	newp = new AstGtN	(fl,lhsp,rhsp); break;
+	case AstType::atGte:	case AstType::atGteS:	newp = new AstGteN	(fl,lhsp,rhsp); break;
+	case AstType::atLt:	case AstType::atLtS:	newp = new AstLtN	(fl,lhsp,rhsp); break;
+	case AstType::atLte:	case AstType::atLteS:	newp = new AstLteN	(fl,lhsp,rhsp); break;
 	default:
 	    nodep->v3fatalSrc("Node needs conversion to string, but bad case: "<<nodep<<endl);
 	    break;
@@ -3273,7 +3273,7 @@ private:
 	AstNode* lhsp = nodep->lhsp()->unlinkFrBack();
 	AstNodeUniop* newp = NULL;
 	switch (nodep->type()) {
-	case AstType::atNEGATE:			newp = new AstNegateD	(fl,lhsp); break;
+	case AstType::atNegate:			newp = new AstNegateD	(fl,lhsp); break;
 	default:
 	    nodep->v3fatalSrc("Node needs conversion to double, but bad case: "<<nodep<<endl);
 	    break;
diff --git a/src/astgen b/src/astgen
index 8aba5b352..8c0463f62 100755
--- a/src/astgen
+++ b/src/astgen
@@ -253,8 +253,7 @@ sub write_impl {
 	    printf $fh "inline Ast%-16s AstNode::cast${type}() { return (dynamic_cast<Ast${type}*>(this)); }\n"
 		,$type."*";
 	} else {
-	    my $ucType = uc $type;
-	    printf $fh "inline Ast%-16s AstNode::cast${type}() { return (this && this->type() == AstType::at${ucType}) ? static_cast<Ast${type}*>(this) : NULL; }\n"
+	    printf $fh "inline Ast%-16s AstNode::cast${type}() { return (this && this->type() == AstType::at${type}) ? static_cast<Ast${type}*>(this) : NULL; }\n"
 		,$type."*";
 	}
     }
@@ -268,7 +267,7 @@ sub write_types {
     # Add "at" prefix to avoid conflicting with FOPEN and other macros in include files
     foreach my $type (sort (keys %Classes)) {
 	next if $type =~ /^Node/;
-	print $fh "\tat",uc $type,",\n";
+	print $fh "\tat",$type,",\n";
     }
     printf $fh "\t_ENUM_END\n";
     printf $fh "    };\n";