Changeset e048ece

Timestamp:

Mar 11, 2024, 1:00:41 PM (9 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

6c8b76b

Parents:

9398177

Message:

Moved the DeclarationNode? enums over to TypeData? where they are actually used.

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (2 diffs)
• DeclarationNode.h (modified) (1 diff)
• ExpressionNode.cc (modified) (1 diff)
• TypeData.cc (modified) (19 diffs)
• TypeData.h (modified) (3 diffs)
• parser.yy (modified) (4 diffs)

src/Parser/DeclarationNode.cc

@@ -45 +45 @@
 
 using namespace std;
-
-// These must harmonize with the corresponding DeclarationNode enumerations.
-const char * DeclarationNode::basicTypeNames[] = {
-        "void", "_Bool", "char", "int", "int128",
-        "float", "double", "long double", "float80", "float128",
-        "_float16", "_float32", "_float32x", "_float64", "_float64x", "_float128", "_float128x", "NoBasicTypeNames"
-};
-const char * DeclarationNode::complexTypeNames[] = {
-        "_Complex", "NoComplexTypeNames", "_Imaginary"
-}; // Imaginary unsupported => parse, but make invisible and print error message
-const char * DeclarationNode::signednessNames[] = {
-        "signed", "unsigned", "NoSignednessNames"
-};
-const char * DeclarationNode::lengthNames[] = {
-        "short", "long", "long long", "NoLengthNames"
-};
-const char * DeclarationNode::builtinTypeNames[] = {
-        "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames"
-};
 
 UniqueName DeclarationNode::anonymous( "__anonymous" );
@@ -484 +465 @@
 
         checkQualifiers( type, q->type );
-        BuiltinType const builtin = type->builtintype;
-        if ( (builtin == Zero || builtin == One) && q->type->qualifiers.any() && error.length() == 0 ) {
-                SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, builtinTypeNames[builtin] );
+        TypeData::BuiltinType const builtin = type->builtintype;
+        if ( (builtin == TypeData::Zero || builtin == TypeData::One) && q->type->qualifiers.any() && error.length() == 0 ) {
+                SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, TypeData::builtinTypeNames[builtin] );
         } // if
         type = ::addQualifiers( q->type, type );

src/Parser/DeclarationNode.h

@@ -22 +22 @@
 
 struct DeclarationNode final : public ParseList<DeclarationNode> {
-        // These enumerations must harmonize with their names in DeclarationNode.cc.
-        enum BasicType {
-                Void, Bool, Char, Int, Int128,
-                Float, Double, LongDouble, uuFloat80, uuFloat128,
-                uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x,
-                NoBasicType
-        };
-        static const char * basicTypeNames[];
-        enum ComplexType { Complex, NoComplexType, Imaginary };
-        // Imaginary unsupported => parse, but make invisible and print error message
-        static const char * complexTypeNames[];
-        enum Signedness { Signed, Unsigned, NoSignedness };
-        static const char * signednessNames[];
-        enum Length { Short, Long, LongLong, NoLength };
-        static const char * lengthNames[];
-        enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
-        static const char * builtinTypeNames[];
-
         static DeclarationNode * newFromTypeData( TypeData * );
         static DeclarationNode * newStorageClass( ast::Storage::Classes );

src/Parser/ExpressionNode.cc

@@ -319 +319 @@
                                 DeclarationNode::newFromTypeData(
                                         addType(
-                                                build_basic_type( DeclarationNode::Int128 ),
-                                                build_signedness( DeclarationNode::Unsigned ) ) ),
+                                                build_basic_type( TypeData::Int128 ),
+                                                build_signedness( TypeData::Unsigned ) ) ),
                                 new InitializerNode(
                                         (new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true )

src/Parser/TypeData.cc

@@ -33 +33 @@
 using namespace std;
 
+// These must harmonize with the corresponding enumerations in the header.
+const char * TypeData::basicTypeNames[] = {
+        "void", "_Bool", "char", "int", "int128",
+        "float", "double", "long double", "float80", "float128",
+        "_float16", "_float32", "_float32x", "_float64", "_float64x", "_float128", "_float128x",
+        "NoBasicTypeNames"
+};
+const char * TypeData::complexTypeNames[] = {
+        "_Complex", "NoComplexTypeNames", "_Imaginary"
+}; // Imaginary unsupported => parse, but make invisible and print error message
+const char * TypeData::signednessNames[] = {
+        "signed", "unsigned", "NoSignednessNames"
+};
+const char * TypeData::lengthNames[] = {
+        "short", "long", "long long", "NoLengthNames"
+};
+const char * TypeData::builtinTypeNames[] = {
+        "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames"
+};
+
 TypeData::TypeData( Kind k ) : location( yylloc ), kind( k ), base( nullptr ), forall( nullptr ) /*, PTR1( (void*)(0xdeadbeefdeadbeef)), PTR2( (void*)(0xdeadbeefdeadbeef) ) */ {
         switch ( kind ) {
@@ -239 +259 @@
                 break;
         case Builtin:
-                assert( builtintype == DeclarationNode::Zero || builtintype == DeclarationNode::One );
+                assert( builtintype == Zero || builtintype == One );
                 newtype->builtintype = builtintype;
                 break;
@@ -261 +281 @@
         switch ( kind ) {
         case Basic:
-                if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " ";
-                if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " ";
-                if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeNames[ complextype ] << " ";
-                if ( basictype != DeclarationNode::NoBasicType ) os << DeclarationNode::basicTypeNames[ basictype ] << " ";
+                if ( signedness != NoSignedness ) os << signednessNames[ signedness ] << " ";
+                if ( length != NoLength ) os << lengthNames[ length ] << " ";
+                if ( complextype != NoComplexType ) os << complexTypeNames[ complextype ] << " ";
+                if ( basictype != NoBasicType ) os << basicTypeNames[ basictype ] << " ";
                 break;
         case Pointer:
@@ -429 +449 @@
                 break;
         case Builtin:
-                os << DeclarationNode::builtinTypeNames[builtintype];
+                os << builtinTypeNames[builtintype];
                 break;
         case GlobalScope:
@@ -495 +515 @@
 }
 
-TypeData * build_basic_type( DeclarationNode::BasicType basic ) {
+TypeData * build_basic_type( TypeData::BasicType basic ) {
         TypeData * type = new TypeData( TypeData::Basic );
         type->basictype = basic;
@@ -501 +521 @@
 }
 
-TypeData * build_complex_type( DeclarationNode::ComplexType complex ) {
+TypeData * build_complex_type( TypeData::ComplexType complex ) {
         TypeData * type = new TypeData( TypeData::Basic );
         type->complextype = complex;
@@ -507 +527 @@
 }
 
-TypeData * build_signedness( DeclarationNode::Signedness signedness ) {
+TypeData * build_signedness( TypeData::Signedness signedness ) {
         TypeData * type = new TypeData( TypeData::Basic );
         type->signedness = signedness;
@@ -513 +533 @@
 }
 
-TypeData * build_builtin_type( DeclarationNode::BuiltinType bit ) {
+TypeData * build_builtin_type( TypeData::BuiltinType bit ) {
         TypeData * type = new TypeData( TypeData::Builtin );
         type->builtintype = bit;
@@ -519 +539 @@
 }
 
-TypeData * build_length( DeclarationNode::Length length ) {
+TypeData * build_length( TypeData::Length length ) {
         TypeData * type = new TypeData( TypeData::Basic );
         type->length = length;
@@ -622 +642 @@
                         assert( src->kind == TypeData::Basic );
 
-                        if ( dst->basictype == DeclarationNode::NoBasicType ) {
+                        if ( dst->basictype == TypeData::NoBasicType ) {
                                 dst->basictype = src->basictype;
-                        } else if ( src->basictype != DeclarationNode::NoBasicType ) {
+                        } else if ( src->basictype != TypeData::NoBasicType ) {
                                 SemanticError( yylloc, "multiple declaration types \"%s\" and \"%s\".",
-                                        DeclarationNode::basicTypeNames[ dst->basictype ],
-                                        DeclarationNode::basicTypeNames[ src->basictype ] );
+                                        TypeData::basicTypeNames[ dst->basictype ],
+                                        TypeData::basicTypeNames[ src->basictype ] );
                         }
-                        if ( dst->complextype == DeclarationNode::NoComplexType ) {
+                        if ( dst->complextype == TypeData::NoComplexType ) {
                                 dst->complextype = src->complextype;
-                        } else if ( src->complextype != DeclarationNode::NoComplexType ) {
+                        } else if ( src->complextype != TypeData::NoComplexType ) {
                                 SemanticError( yylloc, "multiple declaration types \"%s\" and \"%s\".",
-                                        DeclarationNode::complexTypeNames[ src->complextype ],
-                                        DeclarationNode::complexTypeNames[ src->complextype ] );
+                                        TypeData::complexTypeNames[ src->complextype ],
+                                        TypeData::complexTypeNames[ src->complextype ] );
                         }
-                        if ( dst->signedness == DeclarationNode::NoSignedness ) {
+                        if ( dst->signedness == TypeData::NoSignedness ) {
                                 dst->signedness = src->signedness;
-                        } else if ( src->signedness != DeclarationNode::NoSignedness ) {
+                        } else if ( src->signedness != TypeData::NoSignedness ) {
                                 SemanticError( yylloc, "conflicting type specifier \"%s\" and \"%s\".",
-                                        DeclarationNode::signednessNames[ dst->signedness ],
-                                        DeclarationNode::signednessNames[ src->signedness ] );
+                                        TypeData::signednessNames[ dst->signedness ],
+                                        TypeData::signednessNames[ src->signedness ] );
                         }
-                        if ( dst->length == DeclarationNode::NoLength ) {
+                        if ( dst->length == TypeData::NoLength ) {
                                 dst->length = src->length;
-                        } else if ( dst->length == DeclarationNode::Long && src->length == DeclarationNode::Long ) {
-                                dst->length = DeclarationNode::LongLong;
-                        } else if ( src->length != DeclarationNode::NoLength ) {
+                        } else if ( dst->length == TypeData::Long && src->length == TypeData::Long ) {
+                                dst->length = TypeData::LongLong;
+                        } else if ( src->length != TypeData::NoLength ) {
                                 SemanticError( yylloc, "conflicting type specifier \"%s\" and \"%s\".",
-                                        DeclarationNode::lengthNames[ dst->length ],
-                                        DeclarationNode::lengthNames[ src->length ] );
+                                        TypeData::lengthNames[ dst->length ],
+                                        TypeData::lengthNames[ src->length ] );
                         }
                 } // if
@@ -1091 +1111 @@
         case TypeData::Builtin:
                 switch ( td->builtintype ) {
-                case DeclarationNode::Zero:
+                case TypeData::Zero:
                         return new ast::ZeroType();
-                case DeclarationNode::One:
+                case TypeData::One:
                         return new ast::OneType();
                 default:
@@ -1149 +1169 @@
 
 
-static string genTSError( string msg, DeclarationNode::BasicType basictype ) {
-        SemanticError( yylloc, "invalid type specifier \"%s\" for type \"%s\".", msg.c_str(), DeclarationNode::basicTypeNames[basictype] );
+static string genTSError( string msg, TypeData::BasicType basictype ) {
+        SemanticError( yylloc, "invalid type specifier \"%s\" for type \"%s\".", msg.c_str(), TypeData::basicTypeNames[basictype] );
 } // genTSError
 
@@ -1157 +1177 @@
 
         switch ( td->basictype ) {
-        case DeclarationNode::Void:
-                if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
-                } // if
-                if ( td->length != DeclarationNode::NoLength ) {
-                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
+        case TypeData::Void:
+                if ( td->signedness != TypeData::NoSignedness ) {
+                        genTSError( TypeData::signednessNames[ td->signedness ], td->basictype );
+                } // if
+                if ( td->length != TypeData::NoLength ) {
+                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
                 } // if
                 return new ast::VoidType( buildQualifiers( td ) );
                 break;
 
-        case DeclarationNode::Bool:
-                if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
-                } // if
-                if ( td->length != DeclarationNode::NoLength ) {
-                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
+        case TypeData::Bool:
+                if ( td->signedness != TypeData::NoSignedness ) {
+                        genTSError( TypeData::signednessNames[ td->signedness ], td->basictype );
+                } // if
+                if ( td->length != TypeData::NoLength ) {
+                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
                 } // if
 
@@ -1178 +1198 @@
                 break;
 
-        case DeclarationNode::Char:
+        case TypeData::Char:
                 // C11 Standard 6.2.5.15: The three types char, signed char, and unsigned char are collectively called the
                 // character types. The implementation shall define char to have the same range, representation, and behavior as
@@ -1184 +1204 @@
                 static ast::BasicType::Kind chartype[] = { ast::BasicType::SignedChar, ast::BasicType::UnsignedChar, ast::BasicType::Char };
 
-                if ( td->length != DeclarationNode::NoLength ) {
-                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
+                if ( td->length != TypeData::NoLength ) {
+                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
                 } // if
 
@@ -1191 +1211 @@
                 break;
 
-        case DeclarationNode::Int:
+        case TypeData::Int:
                 static ast::BasicType::Kind inttype[2][4] = {
                         { ast::BasicType::ShortSignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, ast::BasicType::SignedInt },
@@ -1198 +1218 @@
 
         Integral: ;
-                if ( td->signedness == DeclarationNode::NoSignedness ) {
-                        const_cast<TypeData *>(td)->signedness = DeclarationNode::Signed;
+                if ( td->signedness == TypeData::NoSignedness ) {
+                        const_cast<TypeData *>(td)->signedness = TypeData::Signed;
                 } // if
                 ret = inttype[ td->signedness ][ td->length ];
                 break;
 
-        case DeclarationNode::Int128:
-                ret = td->signedness == DeclarationNode::Unsigned ? ast::BasicType::UnsignedInt128 : ast::BasicType::SignedInt128;
-                if ( td->length != DeclarationNode::NoLength ) {
-                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
-                } // if
-                break;
-
-        case DeclarationNode::Float:
-        case DeclarationNode::Double:
-        case DeclarationNode::LongDouble:                                       // not set until below
-        case DeclarationNode::uuFloat80:
-        case DeclarationNode::uuFloat128:
-        case DeclarationNode::uFloat16:
-        case DeclarationNode::uFloat32:
-        case DeclarationNode::uFloat32x:
-        case DeclarationNode::uFloat64:
-        case DeclarationNode::uFloat64x:
-        case DeclarationNode::uFloat128:
-        case DeclarationNode::uFloat128x:
+        case TypeData::Int128:
+                ret = td->signedness == TypeData::Unsigned ? ast::BasicType::UnsignedInt128 : ast::BasicType::SignedInt128;
+                if ( td->length != TypeData::NoLength ) {
+                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
+                } // if
+                break;
+
+        case TypeData::Float:
+        case TypeData::Double:
+        case TypeData::LongDouble:                                      // not set until below
+        case TypeData::uuFloat80:
+        case TypeData::uuFloat128:
+        case TypeData::uFloat16:
+        case TypeData::uFloat32:
+        case TypeData::uFloat32x:
+        case TypeData::uFloat64:
+        case TypeData::uFloat64x:
+        case TypeData::uFloat128:
+        case TypeData::uFloat128x:
                 static ast::BasicType::Kind floattype[2][12] = {
                         { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, (ast::BasicType::Kind)-1, (ast::BasicType::Kind)-1, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex, },
@@ -1229 +1249 @@
 
         FloatingPoint: ;
-                if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
-                } // if
-                if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
-                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
-                } // if
-                if ( td->basictype != DeclarationNode::Double && td->length == DeclarationNode::Long ) {
-                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
-                } // if
-                if ( td->complextype == DeclarationNode::Imaginary ) {
-                        genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
-                } // if
-                if ( (td->basictype == DeclarationNode::uuFloat80 || td->basictype == DeclarationNode::uuFloat128) && td->complextype == DeclarationNode::Complex ) { // gcc unsupported
-                        genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
-                } // if
-                if ( td->length == DeclarationNode::Long ) {
-                        const_cast<TypeData *>(td)->basictype = DeclarationNode::LongDouble;
-                } // if
-
-                ret = floattype[ td->complextype ][ td->basictype - DeclarationNode::Float ];
-                //printf( "XXXX %d %d %d %d\n", td->complextype, td->basictype, DeclarationNode::Float, ret );
-                break;
-
-        case DeclarationNode::NoBasicType:
+                if ( td->signedness != TypeData::NoSignedness ) {
+                        genTSError( TypeData::signednessNames[ td->signedness ], td->basictype );
+                } // if
+                if ( td->length == TypeData::Short || td->length == TypeData::LongLong ) {
+                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
+                } // if
+                if ( td->basictype != TypeData::Double && td->length == TypeData::Long ) {
+                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
+                } // if
+                if ( td->complextype == TypeData::Imaginary ) {
+                        genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype );
+                } // if
+                if ( (td->basictype == TypeData::uuFloat80 || td->basictype == TypeData::uuFloat128) && td->complextype == TypeData::Complex ) { // gcc unsupported
+                        genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype );
+                } // if
+                if ( td->length == TypeData::Long ) {
+                        const_cast<TypeData *>(td)->basictype = TypeData::LongDouble;
+                } // if
+
+                ret = floattype[ td->complextype ][ td->basictype - TypeData::Float ];
+                //printf( "XXXX %d %d %d %d\n", td->complextype, td->basictype, TypeData::Float, ret );
+                break;
+
+        case TypeData::NoBasicType:
                 // No basic type in declaration => default double for Complex/Imaginary and int type for integral types
-                if ( td->complextype == DeclarationNode::Complex || td->complextype == DeclarationNode::Imaginary ) {
-                        const_cast<TypeData *>(td)->basictype = DeclarationNode::Double;
+                if ( td->complextype == TypeData::Complex || td->complextype == TypeData::Imaginary ) {
+                        const_cast<TypeData *>(td)->basictype = TypeData::Double;
                         goto FloatingPoint;
                 } // if
 
-                const_cast<TypeData *>(td)->basictype = DeclarationNode::Int;
+                const_cast<TypeData *>(td)->basictype = TypeData::Int;
                 goto Integral;
         default:
@@ -1803 +1823 @@
                 if ( ! param->type ) {                                                  // generate type int for empty parameter type
                         param->type = new TypeData( TypeData::Basic );
-                        param->type->basictype = DeclarationNode::Int;
+                        param->type->basictype = TypeData::Int;
                 } // if
         } // for

src/Parser/TypeData.h

@@ -24 +24 @@
 
 struct TypeData {
+        // Type flags used in this type, and there names (harmonize with implementation).
+        enum BasicType {
+                Void, Bool, Char, Int, Int128,
+                Float, Double, LongDouble, uuFloat80, uuFloat128,
+                uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x,
+                NoBasicType
+        };
+        static const char * basicTypeNames[];
+        enum ComplexType { Complex, NoComplexType, Imaginary };
+        // Imaginary unsupported => parse, but make invisible and print error message
+        static const char * complexTypeNames[];
+        enum Signedness { Signed, Unsigned, NoSignedness };
+        static const char * signednessNames[];
+        enum Length { Short, Long, LongLong, NoLength };
+        static const char * lengthNames[];
+        enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
+        static const char * builtinTypeNames[];
+
         enum Kind { Basic, Pointer, Reference, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
                                 SymbolicInst, Tuple, Basetypeof, Typeof, Vtable, Builtin, GlobalScope, Qualified, Unknown };
@@ -86 +104 @@
         Kind kind;
         TypeData * base;
-        DeclarationNode::BasicType basictype = DeclarationNode::NoBasicType;
-        DeclarationNode::ComplexType complextype = DeclarationNode::NoComplexType;
-        DeclarationNode::Signedness signedness = DeclarationNode::NoSignedness;
-        DeclarationNode::Length length = DeclarationNode::NoLength;
-        DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType;
+        BasicType basictype = NoBasicType;
+        ComplexType complextype = NoComplexType;
+        Signedness signedness = NoSignedness;
+        Length length = NoLength;
+        BuiltinType builtintype = NoBuiltinType;
 
         ast::CV::Qualifiers qualifiers;
@@ -118 +136 @@
 
 TypeData * build_type_qualifier( ast::CV::Qualifiers );
-TypeData * build_basic_type( DeclarationNode::BasicType );
-TypeData * build_complex_type( DeclarationNode::ComplexType );
-TypeData * build_signedness( DeclarationNode::Signedness );
-TypeData * build_builtin_type( DeclarationNode::BuiltinType );
-TypeData * build_length( DeclarationNode::Length );
+TypeData * build_basic_type( TypeData::BasicType );
+TypeData * build_complex_type( TypeData::ComplexType );
+TypeData * build_signedness( TypeData::Signedness );
+TypeData * build_builtin_type( TypeData::BuiltinType );
+TypeData * build_length( TypeData::Length );
 TypeData * build_forall( DeclarationNode * );
 TypeData * build_global_scope();

src/Parser/parser.yy

@@ -2302 +2302 @@
 basic_type_name_type:
         VOID
-                { $$ = build_basic_type( DeclarationNode::Void ); }
+                { $$ = build_basic_type( TypeData::Void ); }
         | BOOL                                                                                          // C99
-                { $$ = build_basic_type( DeclarationNode::Bool ); }
+                { $$ = build_basic_type( TypeData::Bool ); }
         | CHAR
-                { $$ = build_basic_type( DeclarationNode::Char ); }
+                { $$ = build_basic_type( TypeData::Char ); }
         | INT
-                { $$ = build_basic_type( DeclarationNode::Int ); }
+                { $$ = build_basic_type( TypeData::Int ); }
         | INT128
-                { $$ = build_basic_type( DeclarationNode::Int128 ); }
+                { $$ = build_basic_type( TypeData::Int128 ); }
         | UINT128
-                { $$ = addType( build_basic_type( DeclarationNode::Int128 ), build_signedness( DeclarationNode::Unsigned ) ); }
+                { $$ = addType( build_basic_type( TypeData::Int128 ), build_signedness( TypeData::Unsigned ) ); }
         | FLOAT
-                { $$ = build_basic_type( DeclarationNode::Float ); }
+                { $$ = build_basic_type( TypeData::Float ); }
         | DOUBLE
-                { $$ = build_basic_type( DeclarationNode::Double ); }
+                { $$ = build_basic_type( TypeData::Double ); }
         | uuFLOAT80
-                { $$ = build_basic_type( DeclarationNode::uuFloat80 ); }
+                { $$ = build_basic_type( TypeData::uuFloat80 ); }
         | uuFLOAT128
-                { $$ = build_basic_type( DeclarationNode::uuFloat128 ); }
+                { $$ = build_basic_type( TypeData::uuFloat128 ); }
         | uFLOAT16
-                { $$ = build_basic_type( DeclarationNode::uFloat16 ); }
+                { $$ = build_basic_type( TypeData::uFloat16 ); }
         | uFLOAT32
-                { $$ = build_basic_type( DeclarationNode::uFloat32 ); }
+                { $$ = build_basic_type( TypeData::uFloat32 ); }
         | uFLOAT32X
-                { $$ = build_basic_type( DeclarationNode::uFloat32x ); }
+                { $$ = build_basic_type( TypeData::uFloat32x ); }
         | uFLOAT64
-                { $$ = build_basic_type( DeclarationNode::uFloat64 ); }
+                { $$ = build_basic_type( TypeData::uFloat64 ); }
         | uFLOAT64X
-                { $$ = build_basic_type( DeclarationNode::uFloat64x ); }
+                { $$ = build_basic_type( TypeData::uFloat64x ); }
         | uFLOAT128
-                { $$ = build_basic_type( DeclarationNode::uFloat128 ); }
+                { $$ = build_basic_type( TypeData::uFloat128 ); }
         | DECIMAL32
                 { SemanticError( yylloc, "_Decimal32 is currently unimplemented." ); $$ = nullptr; }
@@ -2340 +2340 @@
                 { SemanticError( yylloc, "_Decimal128 is currently unimplemented." ); $$ = nullptr; }
         | COMPLEX                                                                                       // C99
-                { $$ = build_complex_type( DeclarationNode::Complex ); }
+                { $$ = build_complex_type( TypeData::Complex ); }
         | IMAGINARY                                                                                     // C99
-                { $$ = build_complex_type( DeclarationNode::Imaginary ); }
+                { $$ = build_complex_type( TypeData::Imaginary ); }
         | SIGNED
-                { $$ = build_signedness( DeclarationNode::Signed ); }
+                { $$ = build_signedness( TypeData::Signed ); }
         | UNSIGNED
-                { $$ = build_signedness( DeclarationNode::Unsigned ); }
+                { $$ = build_signedness( TypeData::Unsigned ); }
         | SHORT
-                { $$ = build_length( DeclarationNode::Short ); }
+                { $$ = build_length( TypeData::Short ); }
         | LONG
-                { $$ = build_length( DeclarationNode::Long ); }
+                { $$ = build_length( TypeData::Long ); }
         | VA_LIST                                                                                       // GCC, __builtin_va_list
-                { $$ = build_builtin_type( DeclarationNode::Valist ); }
+                { $$ = build_builtin_type( TypeData::Valist ); }
         | AUTO_TYPE
-                { $$ = build_builtin_type( DeclarationNode::AutoType ); }
+                { $$ = build_builtin_type( TypeData::AutoType ); }
         | vtable
         ;
@@ -2416 +2416 @@
                 { $$ = DeclarationNode::newTypeof( $3, true ); }
         | ZERO_T                                                                                        // CFA
-                { $$ = DeclarationNode::newFromTypeData( build_builtin_type( DeclarationNode::Zero ) ); }
+                { $$ = DeclarationNode::newFromTypeData( build_builtin_type( TypeData::Zero ) ); }
         | ONE_T                                                                                         // CFA
-                { $$ = DeclarationNode::newFromTypeData( build_builtin_type( DeclarationNode::One ) ); }
+                { $$ = DeclarationNode::newFromTypeData( build_builtin_type( TypeData::One ) ); }
         ;
 
@@ -2856 +2856 @@
 cfa_parameter_list_ellipsis_opt:                                                // CFA, abstract + real
         // empty
-                { $$ = DeclarationNode::newFromTypeData( build_basic_type( DeclarationNode::Void ) ); }
+                { $$ = DeclarationNode::newFromTypeData( build_basic_type( TypeData::Void ) ); }
         | ELLIPSIS
                 { $$ = nullptr; }