Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 9398177386476da6b03c6876423397970cb283d0) +++ src/Parser/DeclarationNode.cc (revision e048ece8ba334125dcccebb214f58a23f0e29d8a) @@ -45,23 +45,4 @@ 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,7 +465,7 @@ 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 ); Index: src/Parser/DeclarationNode.h =================================================================== --- src/Parser/DeclarationNode.h (revision 9398177386476da6b03c6876423397970cb283d0) +++ src/Parser/DeclarationNode.h (revision e048ece8ba334125dcccebb214f58a23f0e29d8a) @@ -22,22 +22,4 @@ struct DeclarationNode final : public ParseList { - // 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 ); Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 9398177386476da6b03c6876423397970cb283d0) +++ src/Parser/ExpressionNode.cc (revision e048ece8ba334125dcccebb214f58a23f0e29d8a) @@ -319,6 +319,6 @@ 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 ) Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 9398177386476da6b03c6876423397970cb283d0) +++ src/Parser/TypeData.cc (revision e048ece8ba334125dcccebb214f58a23f0e29d8a) @@ -33,4 +33,24 @@ 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,5 +259,5 @@ break; case Builtin: - assert( builtintype == DeclarationNode::Zero || builtintype == DeclarationNode::One ); + assert( builtintype == Zero || builtintype == One ); newtype->builtintype = builtintype; break; @@ -261,8 +281,8 @@ 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,5 +449,5 @@ break; case Builtin: - os << DeclarationNode::builtinTypeNames[builtintype]; + os << builtinTypeNames[builtintype]; break; case GlobalScope: @@ -495,5 +515,5 @@ } -TypeData * build_basic_type( DeclarationNode::BasicType basic ) { +TypeData * build_basic_type( TypeData::BasicType basic ) { TypeData * type = new TypeData( TypeData::Basic ); type->basictype = basic; @@ -501,5 +521,5 @@ } -TypeData * build_complex_type( DeclarationNode::ComplexType complex ) { +TypeData * build_complex_type( TypeData::ComplexType complex ) { TypeData * type = new TypeData( TypeData::Basic ); type->complextype = complex; @@ -507,5 +527,5 @@ } -TypeData * build_signedness( DeclarationNode::Signedness signedness ) { +TypeData * build_signedness( TypeData::Signedness signedness ) { TypeData * type = new TypeData( TypeData::Basic ); type->signedness = signedness; @@ -513,5 +533,5 @@ } -TypeData * build_builtin_type( DeclarationNode::BuiltinType bit ) { +TypeData * build_builtin_type( TypeData::BuiltinType bit ) { TypeData * type = new TypeData( TypeData::Builtin ); type->builtintype = bit; @@ -519,5 +539,5 @@ } -TypeData * build_length( DeclarationNode::Length length ) { +TypeData * build_length( TypeData::Length length ) { TypeData * type = new TypeData( TypeData::Basic ); type->length = length; @@ -622,33 +642,33 @@ 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,7 +1111,7 @@ 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,6 +1169,6 @@ -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,20 +1177,20 @@ 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,5 +1198,5 @@ 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,6 +1204,6 @@ 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,5 +1211,5 @@ 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,29 +1218,29 @@ Integral: ; - if ( td->signedness == DeclarationNode::NoSignedness ) { - const_cast(td)->signedness = DeclarationNode::Signed; + if ( td->signedness == TypeData::NoSignedness ) { + const_cast(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,35 +1249,35 @@ 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(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(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(td)->basictype = DeclarationNode::Double; + if ( td->complextype == TypeData::Complex || td->complextype == TypeData::Imaginary ) { + const_cast(td)->basictype = TypeData::Double; goto FloatingPoint; } // if - const_cast(td)->basictype = DeclarationNode::Int; + const_cast(td)->basictype = TypeData::Int; goto Integral; default: @@ -1803,5 +1823,5 @@ 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 Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision 9398177386476da6b03c6876423397970cb283d0) +++ src/Parser/TypeData.h (revision e048ece8ba334125dcccebb214f58a23f0e29d8a) @@ -24,4 +24,22 @@ 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,9 +104,9 @@ 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,9 +136,9 @@ 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(); Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 9398177386476da6b03c6876423397970cb283d0) +++ src/Parser/parser.yy (revision e048ece8ba334125dcccebb214f58a23f0e29d8a) @@ -2302,35 +2302,35 @@ 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,19 +2340,19 @@ { 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,7 +2416,7 @@ { $$ = 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,5 +2856,5 @@ 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; }