Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 0e66857b99034170c3e5555f271044ed10f86624) +++ src/Parser/DeclarationNode.cc (revision ba01b142553f364d8b98d056e7a939ef20820f41) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Nov 1 20:54:26 2018 -// Update Count : 1108 +// Last Modified On : Fri Feb 1 16:49:17 2019 +// Update Count : 1113 // @@ -41,6 +41,8 @@ // These must harmonize with the corresponding DeclarationNode enumerations. -const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "int128", "float80", "float128", "NoBasicTypeNames" }; -const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" }; +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" }; Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 0e66857b99034170c3e5555f271044ed10f86624) +++ src/Parser/ExpressionNode.cc (revision ba01b142553f364d8b98d056e7a939ef20820f41) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jun 4 21:24:45 2018 -// Update Count : 802 +// Last Modified On : Thu Feb 7 22:35:29 2019 +// Update Count : 900 // @@ -51,57 +51,31 @@ extern const Type::Qualifiers noQualifiers; // no qualifiers on constants -static inline bool checkH( char c ) { return c == 'h' || c == 'H'; } -static inline bool checkL( char c ) { return c == 'l' || c == 'L'; } -static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; } -static inline bool checkU( char c ) { return c == 'u' || c == 'U'; } +// static inline bool checkH( char c ) { return c == 'h' || c == 'H'; } +// static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; } +// static inline bool checkU( char c ) { return c == 'u' || c == 'U'; } static inline bool checkF( char c ) { return c == 'f' || c == 'F'; } static inline bool checkD( char c ) { return c == 'd' || c == 'D'; } +static inline bool checkF80( char c ) { return c == 'w' || c == 'W'; } +static inline bool checkL( char c ) { return c == 'l' || c == 'L'; } +static inline bool checkF128( char c ) { return c == 'q' || c == 'Q'; } static inline bool checkI( char c ) { return c == 'i' || c == 'I'; } static inline bool checkB( char c ) { return c == 'b' || c == 'B'; } static inline bool checkX( char c ) { return c == 'x' || c == 'X'; } -static const char * lnthsInt[2][6] = { - { "int8_t", "int16_t", "int32_t", "int64_t", "size_t", }, - { "uint8_t", "uint16_t", "uint32_t", "uint64_t", "size_t", } -}; // lnthsInt - -static inline void checkLNInt( string & str, int & lnth, int & size ) { - string::size_type posn = str.find_first_of( "lL" ), start = posn; - if ( posn == string::npos ) return; - size = 4; // assume largest size - posn += 1; // advance to size - if ( str[posn] == '8' ) { // 8 - lnth = 0; - } else if ( str[posn] == '1' ) { - posn += 1; - if ( str[posn] == '6' ) { // 16 - lnth = 1; - } else { // 128 - posn += 1; - lnth = 5; - } // if - } else { - if ( str[posn] == '3' ) { // 32 - lnth = 2; - } else if ( str[posn] == '6' ) { // 64 - lnth = 3; - } else { - assertf( false, "internal error, bad integral length %s", str.c_str() ); - } // if - posn += 1; - } // if - str.erase( start, posn - start + 1 ); // remove length suffix -} // checkLNInt - Expression * build_constantInteger( string & str ) { static const BasicType::Kind kind[2][6] = { - // short (h) must be before char (hh) + // short (h) must be before char (hh) because shorter type has the longer suffix { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, }, { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, }, }; + static const char * lnthsInt[2][5] = { + { "int16_t", "int8_t", "int32_t", "int64_t", "size_t", }, + { "uint16_t", "uint8_t", "uint32_t", "uint64_t", "size_t", }, + }; // lnthsInt + bool dec = true, Unsigned = false; // decimal, unsigned constant - int size; // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128 - int lnth = -1; // literal length + int type = -1; // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128 + int ltype = -1; // literal length unsigned long long int v; // converted integral value @@ -127,14 +101,15 @@ //printf( "%llx %llu\n", v, v ); } else if ( checkB( str[1] ) ) { // binary constant ? - v = 0; - for ( unsigned int i = 2;; i += 1 ) { // compute value + v = 0; // compute value + for ( unsigned int i = 2;; ) { if ( str[i] == '1' ) v |= 1; - if ( i == last ) break; + i += 1; + if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break; v <<= 1; } // for - //printf( "%llx %llu\n", v, v ); + //printf( "%#llx %llu\n", v, v ); } else { // octal constant sscanf( (char *)str.c_str(), "%llo", &v ); - //printf( "%llo %llu\n", v, v ); + //printf( "%#llo %llu\n", v, v ); } // if } else { // decimal constant ? @@ -143,79 +118,75 @@ } // if - if ( v <= INT_MAX ) { // signed int - size = 2; - } else if ( v <= UINT_MAX && ! dec ) { // unsigned int - size = 2; - Unsigned = true; // unsigned - } else if ( v <= LONG_MAX ) { // signed long int - size = 3; - } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int - size = 3; - Unsigned = true; // unsigned long int - } else if ( v <= LLONG_MAX ) { // signed long long int - size = 4; - } else { // unsigned long long int - size = 4; - Unsigned = true; // unsigned long long int - } // if - // At least one digit in integer constant, so safe to backup while looking for suffix. - if ( checkU( str[last] ) ) { // suffix 'u' ? - Unsigned = true; - if ( checkL( str[last - 1] ) ) { // suffix 'l' ? - size = 3; - if ( checkL( str[last - 2] ) ) { // suffix "ll" ? - size = 4; + string::size_type posn; + + if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true; + + posn = str.rfind( "hh" ); + if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; } + + posn = str.rfind( "HH" ); + if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; } + + posn = str.find_last_of( "hH" ); + if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; } + + posn = str.find_last_of( "zZ" ); + if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; } + + if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; } + + posn = str.find_last_of( "lL" ); + if ( posn != string::npos ) { + type = 3; // default + posn += 1; // advance to size + if ( str[posn] == '3' ) { // 32 + type = ltype = 2; str.erase( posn, 2 ); + } else if ( str[posn] == '6' ) { // 64 + type = ltype = 3; str.erase( posn, 2 ); + } else if ( str[posn] == '8' ) { // 8 + type = ltype = 1; str.erase( posn, 1 ); + } else if ( str[posn] == '1' ) { + if ( str[posn + 1] == '6' ) { // 16 + type = ltype = 0; str.erase( posn, 2 ); + } else { // 128 + type = ltype = 5; str.erase( posn, 3 ); } // if - } else if ( checkH( str[last - 1] ) ) { // suffix 'h' ? - size = 0; - if ( checkH( str[last - 2] ) ) { // suffix "hh" ? - size = 1; - } // if - str.erase( last - size - 1, size + 1 ); // remove 'h'/"hh" - } else { // suffix "ln" ? - checkLNInt( str, lnth, size ); - } // if - } else if ( checkL( str[ last ] ) ) { // suffix 'l' ? - size = 3; - if ( checkL( str[last - 1] ) ) { // suffix 'll' ? - size = 4; - if ( checkU( str[last - 2] ) ) { // suffix 'u' ? - Unsigned = true; - } // if - } else if ( checkU( str[last - 1] ) ) { // suffix 'u' ? - Unsigned = true; - } // if - } else if ( checkH( str[ last ] ) ) { // suffix 'h' ? - size = 0; - if ( checkH( str[last - 1] ) ) { // suffix "hh" ? - size = 1; - if ( checkU( str[last - 2] ) ) { // suffix 'u' ? - Unsigned = true; - } // if - } else if ( checkU( str[last - 1] ) ) { // suffix 'u' ? - Unsigned = true; - } // if - str.erase( last - size, size + 1 ); // remove 'h'/"hh" - } else if ( checkZ( str[last] ) ) { // suffix 'z' ? - lnth = 4; - str.erase( last, 1 ); // remove 'z' - } else { // suffix "ln" ? - checkLNInt( str, lnth, size ); - } // if - - assert( 0 <= size && size < 6 ); + } // if + } // if + FINI: + + if ( type == -1 ) { // no suffix type, use value + if ( v <= INT_MAX ) { // signed int + type = 2; + } else if ( v <= UINT_MAX && ! dec ) { // unsigned int + type = 2; + Unsigned = true; // unsigned + } else if ( v <= LONG_MAX ) { // signed long int + type = 3; + } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int + type = 3; + Unsigned = true; // unsigned long int + } else if ( v <= LLONG_MAX ) { // signed long long int + type = 4; + } else { // unsigned long long int + type = 4; + Unsigned = true; // unsigned long long int + } // if + } // if + + assert( 0 <= type && type < 6 ); // Constant type is correct for overload resolving. - ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) ); - if ( Unsigned && size < 2 ) { // hh or h, less than int ? + ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][type] ), str, v ) ); + if ( Unsigned && type < 2 ) { // hh or h, less than int ? // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values. - ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false ); - } else if ( lnth != -1 ) { // explicit length ? - if ( lnth == 5 ) { // int128 ? - size = 5; - ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false ); + ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false ); + } else if ( ltype != -1 ) { // explicit length ? + if ( ltype == 5 ) { // int128 ? + type = 5; + ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false ); } else { - ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ), false ); + ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false ); } // if } // if @@ -227,37 +198,49 @@ -static inline void checkLNFloat( string & str, int & lnth, int & size ) { - string::size_type posn = str.find_first_of( "lL" ), start = posn; +static inline void checkFnxFloat( string & str, size_t last, bool & explnth, int & type ) { + string::size_type posn; + // floating-point constant has minimum of 2 characters, 1. or .1, so safe to look ahead + if ( str[1] == 'x' ) { // hex ? + posn = str.find_last_of( "pP" ); // back for exponent (must have) + posn = str.find_first_of( "fF", posn + 1 ); // forward for size (fF allowed in hex constant) + } else { + posn = str.find_last_of( "fF" ); // back for size (fF not allowed) + } // if if ( posn == string::npos ) return; - size = 2; // assume largest size - lnth = 0; + explnth = true; posn += 1; // advance to size if ( str[posn] == '3' ) { // 32 - size = 0; + if ( str[last] != 'x' ) type = 6; + else type = 7; } else if ( str[posn] == '6' ) { // 64 - size = 1; - } else if ( str[posn] == '8' || str[posn] == '1' ) { // 80, 128 - size = 2; - if ( str[posn] == '1' ) posn += 1; + if ( str[last] != 'x' ) type = 8; + else type = 9; + } else if ( str[posn] == '8' ) { // 80 + type = 3; + } else if ( str[posn] == '1' ) { // 16/128 + if ( str[posn + 1] == '6' ) { // 16 + type = 5; + } else { // 128 + if ( str[last] != 'x' ) type = 10; + else type = 11; + } // if } else { assertf( false, "internal error, bad floating point length %s", str.c_str() ); } // if - posn += 1; - str.erase( start, posn - start + 1 ); // remove length suffix -} // checkLNFloat +} // checkFnxFloat Expression * build_constantFloat( string & str ) { - static const BasicType::Kind kind[2][3] = { - { BasicType::Float, BasicType::Double, BasicType::LongDouble }, - { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, + static const BasicType::Kind kind[2][12] = { + { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::__float80, BasicType::__float128, BasicType::_Float16, BasicType::_Float32, BasicType::_Float32x, BasicType::_Float64, BasicType::_Float64x, BasicType::_Float128, BasicType::_Float128x }, + { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::_Float16Complex, BasicType::_Float32Complex, BasicType::_Float32xComplex, BasicType::_Float64Complex, BasicType::_Float64xComplex, BasicType::_Float128Complex, BasicType::_Float128xComplex }, }; - bool complx = false; // real, complex - int size = 1; // 0 => float, 1 => double, 2 => long double - int lnth = -1; // literal length - // floating-point constant has minimum of 2 characters: 1. or .1 + // floating-point constant has minimum of 2 characters 1. or .1 size_t last = str.length() - 1; double v; + int type; // 0 => float, 1 => double, 3 => long double, ... + bool complx = false; // real, complex + bool explnth = false; // explicit literal length sscanf( str.c_str(), "%lg", &v ); @@ -269,21 +252,26 @@ if ( checkF( str[last] ) ) { // float ? - size = 0; + type = 0; } else if ( checkD( str[last] ) ) { // double ? - size = 1; + type = 1; } else if ( checkL( str[last] ) ) { // long double ? - size = 2; + type = 2; + } else if ( checkF80( str[last] ) ) { // __float80 ? + type = 3; + } else if ( checkF128( str[last] ) ) { // __float128 ? + type = 4; } else { - size = 1; // double (default) - checkLNFloat( str, lnth, size ); - } // if + type = 1; // double (default if no suffix) + checkFnxFloat( str, last, explnth, type ); + } // if + if ( ! complx && checkI( str[last - 1] ) ) { // imaginary ? complx = true; } // if - assert( 0 <= size && size < 3 ); - Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) ); - if ( lnth != -1 ) { // explicit length ? - ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ), false ); + assert( 0 <= type && type < 12 ); + Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][type] ), str, v ) ); + if ( explnth ) { // explicit length ? + ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][type] ), false ); } // if Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 0e66857b99034170c3e5555f271044ed10f86624) +++ src/Parser/ParseNode.h (revision ba01b142553f364d8b98d056e7a939ef20820f41) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Nov 1 20:54:53 2018 -// Update Count : 854 +// Last Modified On : Fri Feb 1 16:48:10 2019 +// Update Count : 866 // @@ -206,8 +206,10 @@ class DeclarationNode : public ParseNode { public: - // These enumerations must harmonize with their names. - enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, Int128, Float80, Float128, NoBasicType }; + // These enumerations must harmonize with their names in DeclarationNode.cc. + enum BasicType { Void, Bool, Char, Int, Int128, + Float, Double, LongDouble, Float80, Float128, + _Float16, _Float32, _Float32x, _Float64, _Float64x, _Float128, _Float128x, NoBasicType }; static const char * basicTypeNames[]; - enum ComplexType { Complex, Imaginary, NoComplexType }; + enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message static const char * complexTypeNames[]; enum Signedness { Signed, Unsigned, NoSignedness }; Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 0e66857b99034170c3e5555f271044ed10f86624) +++ src/Parser/TypeData.cc (revision ba01b142553f364d8b98d056e7a939ef20820f41) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Nov 2 07:54:26 2018 -// Update Count : 624 +// Last Modified On : Fri Feb 8 09:36:26 2019 +// Update Count : 645 // @@ -629,5 +629,5 @@ } // if - ret = BasicType::Bool; + ret = BasicType::_Bool; break; @@ -666,12 +666,18 @@ case DeclarationNode::Float: + case DeclarationNode::Double: + case DeclarationNode::LongDouble: // not set until below case DeclarationNode::Float80: case DeclarationNode::Float128: - case DeclarationNode::Double: - case DeclarationNode::LongDouble: // not set until below - static BasicType::Kind floattype[3][3] = { - { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, - { BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary }, - { BasicType::Float, BasicType::Double, BasicType::LongDouble }, + case DeclarationNode::_Float16: + case DeclarationNode::_Float32: + case DeclarationNode::_Float32x: + case DeclarationNode::_Float64: + case DeclarationNode::_Float64x: + case DeclarationNode::_Float128: + case DeclarationNode::_Float128x: + static BasicType::Kind floattype[2][12] = { + { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::_Float16Complex, BasicType::_Float32Complex, BasicType::_Float32xComplex, BasicType::_Float64Complex, BasicType::_Float64xComplex, BasicType::_Float128Complex, BasicType::_Float128xComplex, }, + { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::__float80, BasicType::__float128, BasicType::_Float16, BasicType::_Float32, BasicType::_Float32x, BasicType::_Float64, BasicType::_Float64x, BasicType::_Float128, BasicType::_Float128x, }, }; @@ -686,18 +692,16 @@ 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::Float80 || td->basictype == DeclarationNode::Float128) && 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 - if ( td->basictype == DeclarationNode::Float80 || td->basictype == DeclarationNode::Float128 ) { - // if ( td->complextype != DeclarationNode::NoComplexType ) { - // genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype ); - // } - if ( td->basictype == DeclarationNode::Float80 ) ret = BasicType::Float80; - else ret = BasicType::Float128; - break; - } - ret = floattype[ td->complextype ][ td->basictype - DeclarationNode::Float ]; + //printf( "XXXX %d %d %d %d\n", td->complextype, td->basictype, DeclarationNode::Float, ret ); break; Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 0e66857b99034170c3e5555f271044ed10f86624) +++ src/Parser/lex.ll (revision ba01b142553f364d8b98d056e7a939ef20820f41) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Thu Nov 1 20:57:35 2018 - * Update Count : 687 + * Last Modified On : Mon Feb 4 22:49:19 2019 + * Update Count : 701 */ @@ -39,4 +39,5 @@ using namespace std; +#include "config.h" // configure info #include "ParseNode.h" #include "TypedefTable.h" @@ -59,4 +60,10 @@ #define IDENTIFIER_RETURN() RETURN_VAL( typedefTable.isKind( yytext ) ) #define ATTRIBUTE_RETURN() RETURN_VAL( ATTR_IDENTIFIER ) + +#ifdef HAVE_KEYWORDS_FLOATXX // GCC >= 7 => keyword, otherwise typedef +#define FLOATXX(v) KEYWORD_RETURN(v); +#else +#define FLOATXX(v) IDENTIFIER_RETURN(); +#endif // HAVE_KEYWORDS_FLOATXX void rm_underscore() { @@ -112,6 +119,6 @@ // GCC: D (double) and iI (imaginary) suffixes, and DL (long double) exponent "_"?[eE]"_"?[+-]?{decimal_digits} -floating_size 32|64|80|128 -floating_length ([fFdDlL]|[lL]{floating_size}) +floating_size 16|32|32x|64|64x|80|128|128x +floating_length ([fFdDlLwWqQ]|[fF]{floating_size}) floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length}) floating_suffix_opt ("_"?({floating_suffix}|"DL"))? @@ -240,14 +247,15 @@ finally { KEYWORD_RETURN(FINALLY); } // CFA float { KEYWORD_RETURN(FLOAT); } -_Float32 { KEYWORD_RETURN(FLOAT); } // GCC -_Float32x { KEYWORD_RETURN(FLOAT); } // GCC -_Float64 { KEYWORD_RETURN(DOUBLE); } // GCC -_Float64x { KEYWORD_RETURN(DOUBLE); } // GCC __float80 { KEYWORD_RETURN(FLOAT80); } // GCC float80 { KEYWORD_RETURN(FLOAT80); } // GCC -_Float128 { KEYWORD_RETURN(FLOAT128); } // GCC -_Float128x { KEYWORD_RETURN(FLOAT128); } // GCC __float128 { KEYWORD_RETURN(FLOAT128); } // GCC float128 { KEYWORD_RETURN(FLOAT128); } // GCC +_Float16 { FLOATXX(_FLOAT16); } // GCC +_Float32 { FLOATXX(_FLOAT32); } // GCC +_Float32x { FLOATXX(_FLOAT32X); } // GCC +_Float64 { FLOATXX(_FLOAT64); } // GCC +_Float64x { FLOATXX(_FLOAT64X); } // GCC +_Float128 { FLOATXX(_FLOAT128); } // GCC +_Float128x { FLOATXX(_FLOAT128); } // GCC for { KEYWORD_RETURN(FOR); } forall { KEYWORD_RETURN(FORALL); } // CFA Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 0e66857b99034170c3e5555f271044ed10f86624) +++ src/Parser/parser.yy (revision ba01b142553f364d8b98d056e7a939ef20820f41) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Nov 8 18:08:23 2018 -// Update Count : 4052 +// Last Modified On : Fri Feb 1 16:26:47 2019 +// Update Count : 4061 // @@ -264,4 +264,5 @@ %token BOOL COMPLEX IMAGINARY // C99 %token INT128 FLOAT80 FLOAT128 // GCC +%token _FLOAT16 _FLOAT32 _FLOAT32X _FLOAT64 _FLOAT64X _FLOAT128 // GCC %token ZERO_T ONE_T // CFA %token VALIST // GCC @@ -1771,10 +1772,22 @@ | FLOAT { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); } + | DOUBLE + { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); } | FLOAT80 { $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); } | FLOAT128 { $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); } - | DOUBLE - { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); } + | _FLOAT16 + { $$ = DeclarationNode::newBasicType( DeclarationNode::_Float16 ); } + | _FLOAT32 + { $$ = DeclarationNode::newBasicType( DeclarationNode::_Float32 ); } + | _FLOAT32X + { $$ = DeclarationNode::newBasicType( DeclarationNode::_Float32x ); } + | _FLOAT64 + { $$ = DeclarationNode::newBasicType( DeclarationNode::_Float64 ); } + | _FLOAT64X + { $$ = DeclarationNode::newBasicType( DeclarationNode::_Float64x ); } + | _FLOAT128 + { $$ = DeclarationNode::newBasicType( DeclarationNode::_Float128 ); } | COMPLEX // C99 { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }