Index: libcfa/prelude/prelude-gen.cc =================================================================== --- libcfa/prelude/prelude-gen.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ libcfa/prelude/prelude-gen.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -34,5 +34,5 @@ #if defined(__i386__) || defined(__ia64__) || defined(__x86_64__) { "__float80" , true , true , }, - { "_Float128" , true , true , }, + { "__float128" , true , true , }, #endif }; @@ -153,5 +153,5 @@ cout << "signed int ?==?( one_t, one_t ), ?!=?( one_t, one_t );" << endl; cout << "signed int ?==?( _Bool, _Bool ), ?!=?( _Bool, _Bool );" << endl; - cout << "signed int !?( _Bool );" << endl; + cout << "signed int !?( _Bool );" << endl; for (auto op : arithmeticOperators) { @@ -386,3 +386,2 @@ cout << endl; } - Index: src/Concurrency/Waitfor.cc =================================================================== --- src/Concurrency/Waitfor.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/Concurrency/Waitfor.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -11,5 +11,5 @@ // Last Modified By : // Last Modified On : -// Update Count : 5 +// Update Count : 7 // Index: src/ControlStruct/ExceptTranslate.cc =================================================================== --- src/ControlStruct/ExceptTranslate.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/ControlStruct/ExceptTranslate.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -9,7 +9,7 @@ // Author : Andrew Beach // Created On : Wed Jun 14 16:49:00 2017 -// Last Modified By : Andrew Beach -// Last Modified On : Thr Aug 17 17:19:00 2017 -// Update Count : 9 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Feb 13 18:15:29 2019 +// Update Count : 11 // Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/InitTweak/FixInit.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,6 +10,6 @@ // Created On : Wed Jan 13 16:29:30 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jun 21 17:35:05 2017 -// Update Count : 74 +// Last Modified On : Wed Feb 13 18:15:56 2019 +// Update Count : 76 // #include "FixInit.h" Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/Parser/DeclarationNode.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -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 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/Parser/ExpressionNode.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -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 : Wed Feb 13 18:07:38 2019 +// Update Count : 902 // @@ -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::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x }, + { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex }, }; - 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 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/Parser/ParseNode.h (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -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 : Wed Feb 13 17:36:49 2019 +// Update Count : 867 // @@ -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, uuFloat80, uuFloat128, + uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, 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 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/Parser/TypeData.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -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 : Wed Feb 13 18:16:23 2019 +// Update Count : 649 // @@ -666,12 +666,18 @@ case DeclarationNode::Float: - 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::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: + static BasicType::Kind floattype[2][12] = { + { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex, }, + { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x, }, }; @@ -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::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 - 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 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/Parser/lex.ll (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -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 : Wed Feb 13 17:33:53 2019 + * Update Count : 702 */ @@ -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 +__float80 { KEYWORD_RETURN(uuFLOAT80); } // GCC +float80 { KEYWORD_RETURN(uuFLOAT80); } // GCC +__float128 { KEYWORD_RETURN(uuFLOAT128); } // GCC +float128 { KEYWORD_RETURN(uuFLOAT128); } // GCC +_Float16 { FLOATXX(uFLOAT16); } // GCC +_Float32 { FLOATXX(uFLOAT32); } // GCC +_Float32x { FLOATXX(uFLOAT32X); } // GCC +_Float64 { FLOATXX(uFLOAT64); } // GCC +_Float64x { FLOATXX(uFLOAT64X); } // GCC +_Float128 { FLOATXX(uFLOAT128); } // GCC +_Float128x { FLOATXX(uFLOAT128); } // GCC for { KEYWORD_RETURN(FOR); } forall { KEYWORD_RETURN(FORALL); } // CFA Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/Parser/parser.yy (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 14 18:02:44 2019 -// Update Count : 4216 +// Last Modified On : Thu Feb 14 22:23:13 2019 +// Update Count : 4217 // @@ -267,5 +267,6 @@ %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED %token BOOL COMPLEX IMAGINARY // C99 -%token INT128 FLOAT80 FLOAT128 // GCC +%token INT128 uuFLOAT80 uuFLOAT128 // GCC +%token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC %token ZERO_T ONE_T // CFA %token VALIST // GCC @@ -1773,10 +1774,22 @@ | FLOAT { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); } - | FLOAT80 - { $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); } - | FLOAT128 - { $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); } | DOUBLE { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); } + | uuFLOAT80 + { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat80 ); } + | uuFLOAT128 + { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat128 ); } + | uFLOAT16 + { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat16 ); } + | uFLOAT32 + { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32 ); } + | uFLOAT32X + { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32x ); } + | uFLOAT64 + { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64 ); } + | uFLOAT64X + { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64x ); } + | uFLOAT128 + { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat128 ); } | COMPLEX // C99 { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); } Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/ResolvExpr/CommonType.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,6 +10,6 @@ // Created On : Sun May 17 06:59:27 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 25 15:18:17 2017 -// Update Count : 9 +// Last Modified On : Wed Feb 13 22:30:32 2019 +// Update Count : 22 // @@ -175,36 +175,324 @@ return result; } - +#if 0 + #define BT BasicType:: static const BasicType::Kind combinedType[][ BasicType::NUMBER_OF_BASIC_TYPES ] = { /* Bool Char SignedChar UnsignedChar ShortSignedInt ShortUnsignedInt SignedInt UnsignedInt LongSignedInt LongUnsignedInt LongLongSignedInt LongLongUnsignedInt Float Double LongDouble FloatComplex DoubleComplex LongDoubleComplex FloatImaginary DoubleImaginary LongDoubleImaginary SignedInt128 UnsignedInt128 Float80 Float128 */ - /* Bool */ { BasicType::Bool, BasicType::Char, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* Char */ { BasicType::Char, BasicType::Char, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* SignedChar */ { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* UnsignedChar */ { BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* ShortSignedInt */ { BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* ShortUnsignedInt */ { BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* SignedInt */ { BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* UnsignedInt */ { BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* LongSignedInt */ { BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* LongUnsignedInt */ { BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* LongLongSignedInt */ { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* LongLongUnsignedInt */ { BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, - /* Float */ { BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::Float, BasicType::Float, BasicType::Float80, BasicType::Float128 }, - /* Double */ { BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::LongDouble, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::Double, BasicType::Double, BasicType::Float80, BasicType::Float128 }, - /* LongDouble */ { BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDouble, BasicType::LongDouble, BasicType::BasicType::LongDouble, BasicType::Float128 }, - /* FloatComplex */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, }, - /* DoubleComplex */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex }, - /* LongDoubleComplex */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, }, - /* FloatImaginary */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::FloatImaginary, BasicType::FloatImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, }, - /* DoubleImaginary */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::DoubleImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, }, - /* LongDoubleImaginary */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, }, - /* SignedInt128 */ { BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128, }, - /* UnsignedInt128 */ { BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128, }, - /* Float80 */ { BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::LongDouble, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float128 }, - /* Float128 */ { BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128 }, + /* Bool */ { BT Bool, BT Char, BT SignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* Char */ { BT Char, BT Char, BT UnsignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* SignedChar */ { BT SignedChar, BT UnsignedChar, BT SignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* UnsignedChar */ { BT UnsignedChar, BT UnsignedChar, BT UnsignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* ShortSignedInt */ { BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* ShortUnsignedInt */ { BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* SignedInt */ { BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* UnsignedInt */ { BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* LongSignedInt */ { BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* LongUnsignedInt */ { BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* LongLongSignedInt */ { BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* LongLongUnsignedInt */ { BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + + /* Float */ { BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT Float, BT Float, BT Float80, BT Float128, BT Float, BT Float, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT FloatComplex, BT FloatComplex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* Double */ { BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, BT LongDouble, BT DoubleComplex, BT DoubleComplex, BT LongDoubleComplex, BT DoubleComplex, BT DoubleComplex, BT LongDoubleComplex, BT Double, BT Double, BT Float80, BT Float128, BT Double, BT Double, BT Double, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* LongDouble */ { BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDouble, BT LongDouble, BT BT LongDouble, BT Float128, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT _Float128x, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT _Float128xComplex }, + /* FloatComplex */ { BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT FloatComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT FloatComplex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex, BT FloatComplex, BT FloatComplex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* DoubleComplex */ { BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT LongDoubleComplex, BT DoubleComplex, BT DoubleComplex, BT LongDoubleComplex, BT DoubleComplex, BT DoubleComplex, BT LongDoubleComplex, BT DoubleComplex, BT DoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* LongDoubleComplex */ { BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT _Float128xComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT _Float128xComplex }, + /* FloatImaginary */ { BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatImaginary, BT DoubleImaginary, BT LongDoubleImaginary, BT FloatImaginary, BT FloatImaginary, BT LongDoubleImaginary, BT LongDoubleImaginary, BT FloatComplex, BT FloatComplex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex, BT FloatComplex, BT FloatComplex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* DoubleImaginary */ { BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT LongDoubleComplex, BT DoubleComplex, BT DoubleComplex, BT LongDoubleComplex, BT DoubleImaginary, BT DoubleImaginary, BT LongDoubleImaginary, BT DoubleImaginary, BT DoubleImaginary, BT LongDoubleImaginary, BT LongDoubleImaginary, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* LongDoubleImaginary */ { BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleImaginary, BT LongDoubleImaginary, BT LongDoubleImaginary, BT LongDoubleImaginary, BT LongDoubleImaginary, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT _Float128xComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT _Float128xComplex }, + + /* SignedInt128 */ { BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT SignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* UnsignedInt128 */ { BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT UnsignedInt128, BT UnsignedInt128, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* Float80 */ { BT Float80, BT Float80, BT Float80, BT Float80, BT Float80, BT Float80, BT Float80, BT Float80, BT Float80, BT Float80, BT Float80, BT Float80, BT Float80, BT Float80, BT LongDouble, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT Float80, BT Float80, BT Float80, BT Float128, BT Float80, BT Float80, BT Float80, BT Float80, BT Float80, BT _Float128, BT _Float128x, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* Float128 */ { BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT Float128, BT _Float128x, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128xComplex }, + + /* _Float16 */ { BT _Float16, BT _Float16, BT _Float16, BT _Float16, BT _Float16, BT _Float16, BT _Float16, BT _Float16, BT _Float16, BT _Float16, BT _Float16, BT _Float16, BT Float, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT _Float16, BT _Float16, BT Float80, BT Float128, BT _Float16, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float32 */ { BT _Float32, BT _Float32, BT _Float32, BT _Float32, BT _Float32, BT _Float32, BT _Float32, BT _Float32, BT _Float32, BT _Float32, BT _Float32, BT _Float32, BT _Float32, BT Double, BT LongDouble, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT _Float32, BT _Float32, BT Float80, BT Float128, BT _Float32, BT _Float32, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float32Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float32x */ { BT _Float32x, BT _Float32x, BT _Float32x, BT _Float32x, BT _Float32x, BT _Float32x, BT _Float32x, BT _Float32x, BT _Float32x, BT _Float32x, BT _Float32x, BT _Float32x, BT _Float32x, BT Double, BT LongDouble, BT _Float32xComplex, BT DoubleComplex, BT LongDoubleComplex, BT _Float32xComplex, BT DoubleComplex, BT LongDoubleComplex, BT _Float32x, BT _Float32x, BT Float80, BT Float128, BT _Float32x, BT _Float32x, BT _Float32x, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float64 */ { BT _Float64, BT _Float64, BT _Float64, BT _Float64, BT _Float64, BT _Float64, BT _Float64, BT _Float64, BT _Float64, BT _Float64, BT _Float64, BT _Float64, BT _Float64, BT Double, BT LongDouble, BT _Float64Complex, BT DoubleComplex, BT LongDoubleComplex, BT _Float64Complex, BT DoubleComplex, BT LongDoubleComplex, BT _Float64, BT _Float64, BT Float80, BT Float128, BT _Float64, BT _Float64, BT _Float64, BT _Float64, BT _Float64x, BT _Float128, BT _Float128x, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float64x */ { BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT LongDouble, BT _Float64xComplex, BT _Float64xComplex, BT LongDoubleComplex, BT _Float64xComplex, BT _Float64xComplex, BT LongDoubleComplex, BT _Float64x, BT _Float64x, BT Float80, BT Float128, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float64x, BT _Float128, BT _Float128x, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float128 */ { BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT LongDouble, BT _Float128Complex, BT _Float128Complex, BT LongDoubleComplex, BT _Float128Complex, BT _Float128Complex, BT LongDoubleComplex, BT _Float128, BT _Float128, BT _Float128, BT Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128, BT _Float128x, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float128x */ { BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128x, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex }, + + /* _Float16Complex */ { BT _Float16Complex, BT _Float16Complex, BT _Float16Complex, BT _Float16Complex, BT _Float16Complex, BT _Float16Complex, BT _Float16Complex, BT _Float16Complex, BT _Float16Complex, BT _Float16Complex, BT _Float16Complex, BT _Float16Complex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT _Float16Complex, BT _Float16Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex, BT _Float16Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float32Complex */ { BT _Float32Complex, BT _Float32Complex, BT _Float32Complex, BT _Float32Complex, BT _Float32Complex, BT _Float32Complex, BT _Float32Complex, BT _Float32Complex, BT _Float32Complex, BT _Float32Complex, BT _Float32Complex, BT _Float32Complex, BT _Float32Complex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT FloatComplex, BT DoubleComplex, BT LongDoubleComplex, BT _Float32Complex, BT _Float32Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float32Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex, BT _Float32Complex, BT _Float32Complex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float32xComplex */ { BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT DoubleComplex, BT LongDoubleComplex, BT _Float32xComplex, BT DoubleComplex, BT LongDoubleComplex, BT _Float32xComplex, BT DoubleComplex, BT LongDoubleComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float64xComplex, BT _Float128Complex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float32xComplex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float64Complex */ { BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT DoubleComplex, BT LongDoubleComplex, BT _Float64Complex, BT DoubleComplex, BT LongDoubleComplex, BT _Float64Complex, BT DoubleComplex, BT LongDoubleComplex, BT _Float64Complex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64Complex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float64xComplex */ { BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT LongDoubleComplex, BT _Float64xComplex, BT _Float64xComplex, BT LongDoubleComplex, BT _Float64xComplex, BT _Float64xComplex, BT LongDoubleComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float128Complex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float64xComplex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float128Complex */ { BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT LongDoubleComplex, BT _Float128Complex, BT _Float128Complex, BT LongDoubleComplex, BT _Float128Complex, BT _Float128Complex, BT LongDoubleComplex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128xComplex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128Complex, BT _Float128xComplex }, + /* _Float128xComplex */ { BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex, BT _Float128xComplex }, }; + #undef BT +#endif + + // GENERATED START, DO NOT EDIT + #define BT BasicType:: + static const BasicType::Kind commonTypes[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor + /* B C SC UC SI SUI + I UI LI LUI LLI LLUI + IB UIB _FH _FH _F _FC + F FC _FX _FXC FD _FDC + D DC F80X _FDXC F80 _FB + _FLDC FB LD LDC _FBX _FLDXC + */ + /* B*/ BT Bool, BT Char, BT SignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, + BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* C*/ BT Char, BT Char, BT SignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, + BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* SC*/ BT SignedChar, BT SignedChar, BT SignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, + BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* UC*/ BT UnsignedChar, BT UnsignedChar, BT UnsignedChar, BT UnsignedChar, BT ShortSignedInt, BT ShortUnsignedInt, + BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* SI*/ BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortSignedInt, BT ShortUnsignedInt, + BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* SUI*/ BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, BT ShortUnsignedInt, + BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* I*/ BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, BT SignedInt, + BT SignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* UI*/ BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, BT UnsignedInt, + BT UnsignedInt, BT UnsignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* LI*/ BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, + BT LongSignedInt, BT LongSignedInt, BT LongSignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* LUI*/ BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, + BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongUnsignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* LLI*/ BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, + BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongSignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* LLUI*/ BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, + BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* IB*/ BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, + BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, BT SignedInt128, + BT SignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* UIB*/ BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, + BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, BT UnsignedInt128, + BT UnsignedInt128, BT UnsignedInt128, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* _FH*/ BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, + BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16, + BT uFloat16, BT uFloat16, BT uFloat16, BT uFloat16Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* _FH*/ BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, + BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, + BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat16Complex, BT uFloat32Complex, BT uFloat32Complex, + BT FloatComplex, BT FloatComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat64Complex, BT uFloat64Complex, + BT DoubleComplex, BT DoubleComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT LongDoubleComplex, BT LongDoubleComplex, BT uFloat128xComplex, BT uFloat128xComplex, + + /* _F*/ BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, + BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32, + BT uFloat32, BT uFloat32, BT uFloat32, BT uFloat32Complex, BT uFloat32, BT uFloat32Complex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* _FC*/ BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, + BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, + BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, BT uFloat32Complex, + BT FloatComplex, BT FloatComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat64Complex, BT uFloat64Complex, + BT DoubleComplex, BT DoubleComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT LongDoubleComplex, BT LongDoubleComplex, BT uFloat128xComplex, BT uFloat128xComplex, + + /* F*/ BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, + BT Float, BT Float, BT Float, BT Float, BT Float, BT Float, + BT Float, BT Float, BT Float, BT FloatComplex, BT Float, BT FloatComplex, + BT Float, BT FloatComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* FC*/ BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, + BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, + BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, BT FloatComplex, + BT FloatComplex, BT FloatComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat64Complex, BT uFloat64Complex, + BT DoubleComplex, BT DoubleComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT LongDoubleComplex, BT LongDoubleComplex, BT uFloat128xComplex, BT uFloat128xComplex, + + /* _FX*/ BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, + BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32x, + BT uFloat32x, BT uFloat32x, BT uFloat32x, BT uFloat32xComplex, BT uFloat32x, BT uFloat32xComplex, + BT uFloat32x, BT uFloat32xComplex, BT uFloat32x, BT uFloat32xComplex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* _FXC*/ BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, + BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, + BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, + BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat32xComplex, BT uFloat64Complex, BT uFloat64Complex, + BT DoubleComplex, BT DoubleComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT LongDoubleComplex, BT LongDoubleComplex, BT uFloat128xComplex, BT uFloat128xComplex, + + /* FD*/ BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, + BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64, + BT uFloat64, BT uFloat64, BT uFloat64, BT uFloat64Complex, BT uFloat64, BT uFloat64Complex, + BT uFloat64, BT uFloat64Complex, BT uFloat64, BT uFloat64Complex, BT uFloat64, BT uFloat64Complex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* _FDC*/ BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, + BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, + BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, + BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, BT uFloat64Complex, + BT DoubleComplex, BT DoubleComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT LongDoubleComplex, BT LongDoubleComplex, BT uFloat128xComplex, BT uFloat128xComplex, + + /* D*/ BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, + BT Double, BT Double, BT Double, BT Double, BT Double, BT Double, + BT Double, BT Double, BT Double, BT DoubleComplex, BT Double, BT DoubleComplex, + BT Double, BT DoubleComplex, BT Double, BT DoubleComplex, BT Double, BT DoubleComplex, + BT Double, BT DoubleComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* DC*/ BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, + BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, + BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, + BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, BT DoubleComplex, + BT DoubleComplex, BT DoubleComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT LongDoubleComplex, BT LongDoubleComplex, BT uFloat128xComplex, BT uFloat128xComplex, + + /* F80X*/ BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, + BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64x, + BT uFloat64x, BT uFloat64x, BT uFloat64x, BT uFloat64xComplex, BT uFloat64x, BT uFloat64xComplex, + BT uFloat64x, BT uFloat64xComplex, BT uFloat64x, BT uFloat64xComplex, BT uFloat64x, BT uFloat64xComplex, + BT uFloat64x, BT uFloat64xComplex, BT uFloat64x, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* _FDXC*/ BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, + BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, + BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, + BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, + BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat64xComplex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT LongDoubleComplex, BT LongDoubleComplex, BT uFloat128xComplex, BT uFloat128xComplex, + + /* F80*/ BT uuFloat80, BT uuFloat80, BT uuFloat80, BT uuFloat80, BT uuFloat80, BT uuFloat80, + BT uuFloat80, BT uuFloat80, BT uuFloat80, BT uuFloat80, BT uuFloat80, BT uuFloat80, + BT uuFloat80, BT uuFloat80, BT uuFloat80, BT uFloat64xComplex, BT uuFloat80, BT uFloat64xComplex, + BT uuFloat80, BT uFloat64xComplex, BT uuFloat80, BT uFloat64xComplex, BT uuFloat80, BT uFloat64xComplex, + BT uuFloat80, BT uFloat64xComplex, BT uuFloat80, BT uFloat64xComplex, BT uuFloat80, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* _FB*/ BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, + BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128, + BT uFloat128, BT uFloat128, BT uFloat128, BT uFloat128Complex, BT uFloat128, BT uFloat128Complex, + BT uFloat128, BT uFloat128Complex, BT uFloat128, BT uFloat128Complex, BT uFloat128, BT uFloat128Complex, + BT uFloat128, BT uFloat128Complex, BT uFloat128, BT uFloat128Complex, BT uFloat128, BT uFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* _FLDC*/ BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, BT uFloat128Complex, + BT uFloat128Complex, BT uFloat128Complex, BT LongDoubleComplex, BT LongDoubleComplex, BT uFloat128xComplex, BT uFloat128xComplex, + + /* FB*/ BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, + BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uuFloat128, + BT uuFloat128, BT uuFloat128, BT uuFloat128, BT uFloat128Complex, BT uuFloat128, BT uFloat128Complex, + BT uuFloat128, BT uFloat128Complex, BT uuFloat128, BT uFloat128Complex, BT uuFloat128, BT uFloat128Complex, + BT uuFloat128, BT uFloat128Complex, BT uuFloat128, BT uFloat128Complex, BT uuFloat128, BT uuFloat128, + BT uFloat128Complex, BT uuFloat128, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* LD*/ BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, + BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, BT LongDouble, + BT LongDouble, BT LongDouble, BT LongDouble, BT LongDoubleComplex, BT LongDouble, BT LongDoubleComplex, + BT LongDouble, BT LongDoubleComplex, BT LongDouble, BT LongDoubleComplex, BT LongDouble, BT LongDoubleComplex, + BT LongDouble, BT LongDoubleComplex, BT LongDouble, BT LongDoubleComplex, BT LongDouble, BT LongDouble, + BT LongDoubleComplex, BT LongDouble, BT LongDouble, BT LongDoubleComplex, BT uFloat128x, BT uFloat128xComplex, + + /* LDC*/ BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, + BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, + BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, + BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, + BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, + BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT LongDoubleComplex, BT uFloat128xComplex, BT uFloat128xComplex, + + /* _FBX*/ BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, + BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128x, + BT uFloat128x, BT uFloat128x, BT uFloat128x, BT uFloat128xComplex, BT uFloat128x, BT uFloat128xComplex, + BT uFloat128x, BT uFloat128xComplex, BT uFloat128x, BT uFloat128xComplex, BT uFloat128x, BT uFloat128xComplex, + BT uFloat128x, BT uFloat128xComplex, BT uFloat128x, BT uFloat128xComplex, BT uFloat128x, BT uFloat128x, + BT uFloat128xComplex, BT uFloat128x, BT uFloat128x, BT uFloat128xComplex, BT uFloat128x, BT uFloat128xComplex, + + /*_FLDXC*/ BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, + BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, + BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, + BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, + BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, + BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, BT uFloat128xComplex, + + }; + #undef BT + // GENERATED END + static_assert( - sizeof(combinedType)/sizeof(combinedType[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES, + sizeof(commonTypes)/sizeof(commonTypes[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES, "Each basic type kind should have a corresponding row in the combined type matrix" ); @@ -218,5 +506,5 @@ void CommonType::postvisit( BasicType *basicType ) { if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) { - BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ]; + BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ otherBasic->get_kind() ]; if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= otherBasic->get_qualifiers() ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->get_qualifiers() <= otherBasic->get_qualifiers() ) || widenSecond ) ) { result = new BasicType( basicType->get_qualifiers() | otherBasic->get_qualifiers(), newType ); @@ -224,5 +512,5 @@ } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) { // use signed int in lieu of the enum/zero/one type - BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ]; + BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ]; if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) { result = new BasicType( basicType->get_qualifiers() | type2->get_qualifiers(), newType ); Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/ResolvExpr/ConversionCost.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,6 +10,6 @@ // Created On : Sun May 17 07:06:19 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 25 15:43:34 2017 -// Update Count : 10 +// Last Modified On : Wed Feb 13 23:04:51 2019 +// Update Count : 22 // @@ -28,12 +28,13 @@ namespace ResolvExpr { - const Cost Cost::zero = Cost{ 0, 0, 0, 0, 0, 0 }; - const Cost Cost::infinity = Cost{ -1, -1, -1, -1, 1, -1 }; - const Cost Cost::unsafe = Cost{ 1, 0, 0, 0, 0, 0 }; - const Cost Cost::poly = Cost{ 0, 1, 0, 0, 0, 0 }; - const Cost Cost::safe = Cost{ 0, 0, 1, 0, 0, 0 }; - const Cost Cost::var = Cost{ 0, 0, 0, 1, 0, 0 }; - const Cost Cost::spec = Cost{ 0, 0, 0, 0, -1, 0 }; - const Cost Cost::reference = Cost{ 0, 0, 0, 0, 0, 1 }; + const Cost Cost::zero = Cost{ 0, 0, 0, 0, 0, 0, 0 }; + const Cost Cost::infinity = Cost{ -1, -1, -1, -1, -1, 1, -1 }; + const Cost Cost::unsafe = Cost{ 1, 0, 0, 0, 0, 0, 0 }; + const Cost Cost::poly = Cost{ 0, 1, 0, 0, 0, 0, 0 }; + const Cost Cost::safe = Cost{ 0, 0, 1, 0, 0, 0, 0 }; + const Cost Cost::sign = Cost{ 0, 0, 0, 1, 0, 0, 0 }; + const Cost Cost::var = Cost{ 0, 0, 0, 0, 1, 0, 0 }; + const Cost Cost::spec = Cost{ 0, 0, 0, 0, 0, -1, 0 }; + const Cost Cost::reference = Cost{ 0, 0, 0, 0, 0, 0, 1 }; #if 0 @@ -178,5 +179,5 @@ : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) { } - +#if 0 /* Old @@ -265,5 +266,121 @@ "Each basic type kind should have a corresponding row in the cost matrix" ); - +#endif + + // GENERATED START, DO NOT EDIT + /* EXTENDED INTEGRAL RANK HIERARCHY (root to leaves) + _Bool + char signed char unsigned char + signed short int unsigned short int + signed int unsigned int + signed long int unsigned long int + signed long long int unsigned long long int + __int128 unsigned __int128 + _Float16 _Float16 _Complex + _Float32 _Float32 _Complex + float float _Complex + _Float32x _Float32x _Complex + _Float64 _Float64 _Complex + double double _Complex + _Float64x _Float64x _Complex + __float80 + _Float128 _Float128 _Complex + __float128 + long double long double _Complex + _Float128x _Float128x _Complex + */ + // GENERATED END + + // GENERATED START, DO NOT EDIT + static const int costMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node + /* B C SC UC SI SUI I UI LI LUI LLI LLUI IB UIB _FH _FH _F _FC F FC _FX _FXC FD _FDC D DC F80X _FDXC F80 _FB _FLDC FB LD LDC _FBX _FLDXC */ + /* B*/ 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 17, 16, 18, 17, + /* C*/ -1, 0, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, + /* SC*/ -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, + /* UC*/ -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, + /* SI*/ -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 14, 16, 15, + /* SUI*/ -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 14, 16, 15, + /* I*/ -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 13, 15, 14, + /* UI*/ -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 13, 15, 14, + /* LI*/ -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 12, 14, 13, + /* LUI*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 12, 14, 13, + /* LLI*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 12, 11, 13, 12, + /* LLUI*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 12, 11, 13, 12, + /* IB*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 11, 10, 12, 11, + /* UIB*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 11, 10, 12, 11, + /* _FH*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10, 9, 11, 10, + /* _FH*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, 5, -1, 6, -1, -1, 7, -1, -1, 8, -1, 9, + /* _F*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 9, 8, 10, 9, + /* _FC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, 5, -1, -1, 6, -1, -1, 7, -1, 8, + /* F*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8, 7, 9, 8, + /* FC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, -1, 5, -1, -1, 6, -1, 7, + /* _FX*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 6, 8, 7, + /* _FXC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, -1, 4, -1, -1, 5, -1, 6, + /* FD*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 6, 5, 7, 6, + /* _FDC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, -1, 3, -1, -1, 4, -1, 5, + /* D*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 5, 4, 6, 5, + /* DC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, -1, 2, -1, -1, 3, -1, 4, + /* F80X*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 4, 3, 5, 4, + /* _FDXC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, -1, 2, -1, 3, + /* F80*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 0, 1, 2, 2, 3, 3, 4, 4, + /* _FB*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, + /* _FLDC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, 2, + /* FB*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 0, 1, 2, 2, 3, + /* LD*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, + /* LDC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, + /* _FBX*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, + /*_FLDXC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, + }; // costMatrix + // GENERATED END + static_assert( + sizeof(costMatrix)/sizeof(costMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES, + "Missing row in the cost matrix" + ); + + // GENERATED START, DO NOT EDIT + static const int signMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion + /* B C SC UC SI SUI I UI LI LUI LLI LLUI IB UIB _FH _FH _F _FC F FC _FX _FXC FD _FDC D DC F80X _FDXC F80 _FB _FLDC FB LD LDC _FBX _FLDXC */ + /* B*/ 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* C*/ -1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* SC*/ -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* UC*/ -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* SI*/ -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* SUI*/ -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* I*/ -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* UI*/ -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* LI*/ -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* LUI*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* LLI*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* LLUI*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* IB*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* UIB*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* _FH*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* _FH*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, + /* _F*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* _FC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, + /* F*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* FC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, + /* _FX*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* _FXC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, + /* FD*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* _FDC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, + /* D*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* DC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, + /* F80X*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* _FDXC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, + /* F80*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* _FB*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, + /* _FLDC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 0, -1, 0, + /* FB*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, + /* LD*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, + /* LDC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, + /* _FBX*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, + /*_FLDXC*/ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, + }; // signMatrix + // GENERATED END + static_assert( + sizeof(signMatrix)/sizeof(signMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES, + "Missing row in the sign matrix" + ); void ConversionCost::postvisit( VoidType * ) { @@ -279,4 +396,5 @@ cost = Cost::zero; cost.incSafe( tableResult ); + cost.incSign( signMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ] ); } // if } else if ( dynamic_cast< EnumInstType *>( dest ) ) { @@ -300,5 +418,5 @@ // types are the same, except otherPointer has more qualifiers cost = Cost::safe; - } + } // if } else { int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env ); @@ -422,8 +540,9 @@ cost = Cost::zero; cost.incSafe( tableResult + 1 ); - } + cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] ); + } // if } else if ( dynamic_cast< PointerType* >( dest ) ) { cost = Cost::safe; - } + } // if } @@ -439,6 +558,7 @@ cost = Cost::zero; cost.incSafe( tableResult + 1 ); - } - } + cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] ); + } // if + } // if } } // namespace ResolvExpr Index: src/ResolvExpr/Cost.h =================================================================== --- src/ResolvExpr/Cost.h (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/ResolvExpr/Cost.h (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 09:39:50 2015 -// Last Modified By : Aaron B. Moss -// Last Modified On : Fri Oct 05 14:32:00 2018 -// Update Count : 7 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Feb 7 20:54:29 2019 +// Update Count : 8 // @@ -21,11 +21,11 @@ class Cost { private: - Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost, - int referenceCost ); - + Cost( int unsafeCost, int polyCost, int safeCost, int signCost, + int varCost, int specCost, int referenceCost ); public: Cost & incUnsafe( int inc = 1 ); Cost & incPoly( int inc = 1 ); Cost & incSafe( int inc = 1 ); + Cost & incSign( int inc = 1 ); Cost & incVar( int inc = 1 ); Cost & decSpec( int inc = 1 ); @@ -35,4 +35,5 @@ int get_polyCost() const { return polyCost; } int get_safeCost() const { return safeCost; } + int get_signCost() const { return signCost; } int get_varCost() const { return varCost; } int get_specCost() const { return specCost; } @@ -40,5 +41,4 @@ Cost operator+( const Cost &other ) const; - Cost operator-( const Cost &other ) const; Cost &operator+=( const Cost &other ); bool operator<( const Cost &other ) const; @@ -55,4 +55,5 @@ static const Cost poly; static const Cost safe; + static const Cost sign; static const Cost var; static const Cost spec; @@ -63,4 +64,5 @@ int polyCost; ///< Count of parameters and return values bound to some poly type int safeCost; ///< Safe (widening) conversions + int signCost; ///< Count of safe sign conversions int varCost; ///< Count of polymorphic type variables int specCost; ///< Polymorphic type specializations (type assertions), negative cost @@ -68,8 +70,8 @@ }; - inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost, - int referenceCost ) - : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), varCost( varCost ), - specCost( specCost ), referenceCost( referenceCost ) {} + inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int signCost, + int varCost, int specCost, int referenceCost ) + : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), signCost( signCost ), + varCost( varCost ), specCost( specCost ), referenceCost( referenceCost ) {} inline Cost & Cost::incUnsafe( int inc ) { @@ -88,4 +90,10 @@ if ( *this == infinity ) return *this; safeCost += inc; + return *this; + } + + inline Cost & Cost::incSign( int inc ) { + if ( *this == infinity ) return *this; + signCost += inc; return *this; } @@ -111,16 +119,8 @@ inline Cost Cost::operator+( const Cost &other ) const { if ( *this == infinity || other == infinity ) return infinity; - return Cost{ - unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, - varCost + other.varCost, specCost + other.specCost, + return Cost{ + unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, + signCost + other.signCost, varCost + other.varCost, specCost + other.specCost, referenceCost + other.referenceCost }; - } - - inline Cost Cost::operator-( const Cost &other ) const { - if ( *this == infinity || other == infinity ) return infinity; - return Cost{ - unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost, - varCost - other.varCost, specCost - other.specCost, - referenceCost - other.referenceCost }; } @@ -134,4 +134,5 @@ polyCost += other.polyCost; safeCost += other.safeCost; + signCost += other.signCost; varCost += other.varCost; specCost += other.specCost; @@ -156,4 +157,8 @@ } else if ( safeCost < other.safeCost ) { return true; + } else if ( signCost > other.signCost ) { + return false; + } else if ( signCost < other.signCost ) { + return true; } else if ( varCost > other.varCost ) { return false; @@ -180,4 +185,5 @@ c = polyCost - other.polyCost; if ( c ) return c; c = safeCost - other.safeCost; if ( c ) return c; + c = signCost - other.signCost; if ( c ) return c; c = varCost - other.varCost; if ( c ) return c; c = specCost - other.specCost; if ( c ) return c; @@ -189,4 +195,5 @@ && polyCost == other.polyCost && safeCost == other.safeCost + && signCost == other.signCost && varCost == other.varCost && specCost == other.specCost @@ -199,6 +206,7 @@ inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) { - return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " - << cost.safeCost << ", " << cost.varCost << ", " << cost.specCost << ", " + return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " + << cost.safeCost << ", " << cost.signCost << ", " + << cost.varCost << ", " << cost.specCost << ", " << cost.referenceCost << " )"; } Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/ResolvExpr/Resolver.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 12:17:01 2015 -// Last Modified By : Aaron B. Moss -// Last Modified On : Fri Oct 05 09:43:00 2018 -// Update Count : 214 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Feb 13 18:13:43 2019 +// Update Count : 216 // Index: src/ResolvExpr/typeops.h =================================================================== --- src/ResolvExpr/typeops.h (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/ResolvExpr/typeops.h (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,6 +10,6 @@ // Created On : Sun May 17 07:28:22 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:36:18 2017 -// Update Count : 3 +// Last Modified On : Fri Feb 8 09:30:34 2019 +// Update Count : 4 // @@ -101,5 +101,5 @@ // in CommonType.cc - Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ); + Type * commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ); // in PolyCost.cc Index: src/SymTab/ManglerCommon.cc =================================================================== --- src/SymTab/ManglerCommon.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/SymTab/ManglerCommon.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,6 +10,6 @@ // Created On : Sun May 17 21:44:03 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:45:30 2017 -// Update Count : 15 +// Last Modified On : Thu Feb 14 08:12:17 2019 +// Update Count : 25 // @@ -22,5 +22,5 @@ namespace Encoding { const std::string manglePrefix = "_X"; - +#if 0 const std::string basicTypes[] = { "b", // Bool @@ -43,7 +43,7 @@ "Ce", // LongDoubleComplex // Note: imaginary is not an overloadable type in C++ - "If", // FloatImaginary - "Id", // DoubleImaginary - "Ie", // LongDoubleImaginary + // "If", // FloatImaginary + // "Id", // DoubleImaginary + // "Ie", // LongDoubleImaginary "n", // SignedInt128 "o", // UnsignedInt128 @@ -63,4 +63,59 @@ "Each basic type kind should have a corresponding mangler letter" ); +#endif + // GENERATED START, DO NOT EDIT + // NOTES ON MANGLING: + // * Itanium spec says that Float80 encodes to "e" (like LongDouble), but the distinct lengths cause resolution problems. + // * Float128 is supposed to encode to "g", but I wanted it to mangle equal to LongDouble. + // * Mangling for non-standard complex types is by best guess + // * _FloatN is supposed to encode as "DF"N"_"; modified for same reason as above. + // * unused mangling identifiers: + // - "z" ellipsis + // - "Dd" IEEE 754r 64-bit decimal floating point (borrowed for _Float32x) + // - "De" IEEE 754r 128-bit decimal floating point + // - "Df" IEEE 754r 32-bit decimal floating point + // - "Dh" IEEE 754r 16-bit decimal floating point (borrowed for _Float16) + // - "DF"N"_" ISO/IEC TS 18661 N-bit binary floating point (_FloatN) + // - "Di" char32_t + // - "Ds" char16_t + const std::string basicTypes[BasicType::NUMBER_OF_BASIC_TYPES] = { + "b", // _Bool + "c", // char + "a", // signed char + "h", // unsigned char + "s", // signed short int + "t", // unsigned short int + "i", // signed int + "j", // unsigned int + "l", // signed long int + "m", // unsigned long int + "x", // signed long long int + "y", // unsigned long long int + "n", // __int128 + "o", // unsigned __int128 + "DF16_", // _Float16 + "CDF16_", // _Float16 _Complex + "DF32_", // _Float32 + "CDF32_", // _Float32 _Complex + "f", // float + "Cf", // float _Complex + "DF32x_", // _Float32x + "CDF32x_", // _Float32x _Complex + "DF64_", // _Float64 + "CDF64_", // _Float64 _Complex + "d", // double + "Cd", // double _Complex + "DF64x_", // _Float64x + "CDF64x_", // _Float64x _Complex + "Dq", // __float80 + "DF128_", // _Float128 + "CDF128_", // _Float128 _Complex + "g", // __float128 + "e", // long double + "Ce", // long double _Complex + "DF128x_", // _Float128x + "CDF128x_", // _Float128x _Complex + }; // basicTypes + // GENERATED END const std::map qualifiers = { Index: src/SynTree/BasicType.cc =================================================================== --- src/SynTree/BasicType.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/SynTree/BasicType.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 25 14:14:03 2017 -// Update Count : 11 +// Last Modified On : Thu Jan 31 21:37:36 2019 +// Update Count : 12 // @@ -30,4 +30,6 @@ bool BasicType::isInteger() const { + return kind <= UnsignedInt128; +#if 0 switch ( kind ) { case Bool: @@ -63,4 +65,5 @@ assert( false ); return false; +#endif } Index: src/SynTree/Constant.cc =================================================================== --- src/SynTree/Constant.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/SynTree/Constant.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Fri Spt 28 14:49:00 2018 -// Update Count : 30 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Feb 13 18:11:22 2019 +// Update Count : 32 // Index: src/SynTree/Type.cc =================================================================== --- src/SynTree/Type.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/SynTree/Type.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jun 22 10:17:19 2018 -// Update Count : 39 +// Last Modified On : Thu Jan 31 21:54:16 2019 +// Update Count : 43 // #include "Type.h" @@ -25,4 +25,5 @@ const char *BasicType::typeNames[] = { +#if 0 "_Bool", "char", @@ -49,5 +50,59 @@ "unsigned __int128", "__float80", - "__float128" + "__float128", + "_Float16", + "_Float32", + "_Float32x", + "_Float64", + "_Float64x", + "_Float128", + "_Float128x", + "_Float16 _Complex", + "_Float32 _Complex", + "_Float32x _Complex", + "_Float64 _Complex", + "_Float64x _Complex", + "_Float128 _Complex", + "_Float128x _Complex", +#endif + "_Bool", + "char", + "signed char", + "unsigned char", + "signed short int", + "unsigned short int", + "signed int", + "unsigned int", + "signed long int", + "unsigned long int", + "signed long long int", + "unsigned long long int", + "__int128", + "unsigned __int128", + "_Float16", + "_Float16 _Complex", + "_Float32", + "_Float32 _Complex", + "float", + "float _Complex", + //"float _Imaginary", + "_Float32x", + "_Float32x _Complex", + "_Float64", + "_Float64 _Complex", + "double", + "double _Complex", + //"double _Imaginary", + "_Float64x", + "_Float64x _Complex", + "__float80", + "_Float128", + "_Float128 _Complex", + "__float128", + "long double", + "long double _Complex", + //"long double _Imaginary", + "_Float128x", + "_Float128x _Complex", }; static_assert( Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/SynTree/Type.h (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 25 14:14:01 2017 -// Update Count : 154 +// Last Modified On : Wed Feb 13 18:10:45 2019 +// Update Count : 167 // @@ -207,4 +207,5 @@ class BasicType : public Type { public: +#if 0 enum Kind { Bool, @@ -233,4 +234,61 @@ Float80, Float128, + _Float16, + _Float32, + _Float32x, + _Float64, + _Float64x, + _Float128, + _Float128x, + _Float16Complex, + _Float32Complex, + _Float32xComplex, + _Float64Complex, + _Float64xComplex, + _Float128Complex, + _Float128xComplex, + NUMBER_OF_BASIC_TYPES + } kind; +#endif + enum Kind { + Bool, + Char, + SignedChar, + UnsignedChar, + ShortSignedInt, + ShortUnsignedInt, + SignedInt, + UnsignedInt, + LongSignedInt, + LongUnsignedInt, + LongLongSignedInt, + LongLongUnsignedInt, + SignedInt128, + UnsignedInt128, + uFloat16, + uFloat16Complex, + uFloat32, + uFloat32Complex, + Float, + FloatComplex, + // FloatImaginary, + uFloat32x, + uFloat32xComplex, + uFloat64, + uFloat64Complex, + Double, + DoubleComplex, + // DoubleImaginary, + uFloat64x, + uFloat64xComplex, + uuFloat80, + uFloat128, + uFloat128Complex, + uuFloat128, + LongDouble, + LongDoubleComplex, + // LongDoubleImaginary, + uFloat128x, + uFloat128xComplex, NUMBER_OF_BASIC_TYPES } kind; Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ src/Tuples/TupleExpansion.cc (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jun 21 17:35:04 2017 -// Update Count : 19 +// Last Modified On : Wed Feb 13 18:14:12 2019 +// Update Count : 21 // Index: tests/.expect/castError.txt =================================================================== --- tests/.expect/castError.txt (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ tests/.expect/castError.txt (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -4,5 +4,5 @@ ... to: char Alternatives are: -Cost ( 1, 0, 0, 0, 0, 0 ): Cast of: +Cost ( 1, 0, 0, 0, 0, 0, 0 ): Cast of: Variable Expression: f: function accepting unspecified arguments @@ -16,5 +16,5 @@ Environment: -Cost ( 1, 0, 0, 0, 0, 0 ): Cast of: +Cost ( 1, 0, 0, 0, 0, 0, 0 ): Cast of: Variable Expression: f: double ... to: @@ -25,5 +25,5 @@ Environment: -Cost ( 1, 0, 0, 0, 0, 0 ): Cast of: +Cost ( 1, 0, 0, 0, 0, 0, 0 ): Cast of: Variable Expression: f: signed int ... to: Index: tests/.expect/completeTypeError.txt =================================================================== --- tests/.expect/completeTypeError.txt (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ tests/.expect/completeTypeError.txt (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -45,5 +45,5 @@ Alternatives with failing assertions are: -Cost ( 0, 1, 0, 1, -5, 0 ): Application of +Cost ( 0, 1, 0, 0, 1, -5, 0 ): Application of Variable Expression: baz: forall T: sized object type Index: tests/literals.cfa =================================================================== --- tests/literals.cfa (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ tests/literals.cfa (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,10 +10,10 @@ // Created On : Sat Sep 9 16:34:38 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Dec 4 21:44:01 2018 -// Update Count : 139 -// - +// Last Modified On : Tue Feb 12 08:07:39 2019 +// Update Count : 224 +// + +#include // __GNUC_PREREQ #ifdef __CFA__ -#include #include @@ -151,4 +151,48 @@ -0X0123456789.0123456789P-09; -0X0123456789.0123456789P-09f; -0X0123456789.0123456789P-09l; -0X0123456789.0123456789P-09F; -0X0123456789.0123456789P-09L; +#if defined(__GNUC__) && __GNUC_PREREQ(7,0) // gcc version >= 7 +// floating with length, gcc f16/f128x unsupported and no prelude code for any _FloatXXx, so they work by conversion to long double + + /* 0123456789.f16; */ 0123456789.f32; 0123456789.f32x; 0123456789.f64; 0123456789.f64x; 0123456789.W; 0123456789.f128; 0123456789.q; /* 0123456789.f128x; */ + /* +0123456789.f16; */ +0123456789.f32; +0123456789.f32x; +0123456789.f64; +0123456789.f64x; +0123456789.w; +0123456789.f128; +0123456789.Q; /* +0123456789.f128x; */ + /* -0123456789.f16; */ -0123456789.f32; -0123456789.f32x; -0123456789.f64; -0123456789.f64x; -0123456789.W; -0123456789.f128; -0123456789.q; /* -0123456789.f128x; */ + + /* 0123456789.e09F16; */ 0123456789.e09F32; 0123456789.e09F32x; 0123456789.e09F64; 0123456789.e09F64x; 0123456789.e09W; 0123456789.e09F128; 0123456789.e09q; /* .0123456789e09q; */ + /* +0123456789.e+09F16; */ +0123456789.e+09F32; +0123456789.e+09F32x; +0123456789.e+09F64; +0123456789.e+09F64x; +0123456789.e+09w; +0123456789.e+09F128; +0123456789.e+09Q; /* +.0123456789E+09Q; */ + /* -0123456789.e-09F16; */ -0123456789.e-09F32; -0123456789.e-09F32x; -0123456789.e-09F64; -0123456789.e-09F64x; -0123456789.e-09W; -0123456789.e-09F128; -0123456789.e-09q; /* -.0123456789E-09q; */ + + /* .0123456789e09F16; */ .0123456789e09F32; .0123456789e09F32x; .0123456789e09F64; .0123456789e09F64x; .0123456789e09W; .0123456789e09F128; .0123456789e09q; /* .0123456789e09q; */ + /* +.0123456789e+09F16; */ +.0123456789e+09F32; +.0123456789e+09F32x; +.0123456789e+09F64; +.0123456789e+09F64x; +.0123456789e+09w; +.0123456789e+09F128; +.0123456789e+09Q; /* +.0123456789E+09Q; */ + /* -.0123456789e-09F16; */ -.0123456789e-09F32; -.0123456789e-09F32x; -.0123456789e-09F64; -.0123456789e-09F64x; -.0123456789e-09W; -.0123456789e-09F128; -.0123456789e-09q; /* -.0123456789E-09q; */ + + /* 0123456789.0123456789F16; */ 0123456789.0123456789F32; 0123456789.0123456789F32x; 0123456789.0123456789F64; 0123456789.0123456789F64x; 0123456789.0123456789W; 0123456789.0123456789F128; 0123456789.0123456789q; /* 0123456789.0123456789q; */ + /* +0123456789.0123456789F16; */ +0123456789.0123456789F32; +0123456789.0123456789F32x; +0123456789.0123456789F64; +0123456789.0123456789F64x; +0123456789.0123456789w; +0123456789.0123456789F128; +0123456789.0123456789Q; /* +0123456789.0123456789Q; */ + /* -0123456789.0123456789F16; */ -0123456789.0123456789F32; -0123456789.0123456789F32x; -0123456789.0123456789F64; -0123456789.0123456789F64x; -0123456789.0123456789W; -0123456789.0123456789F128; -0123456789.0123456789q; /* -0123456789.0123456789q; */ + + /* 0123456789.0123456789E09F16; */ 0123456789.0123456789E09F32; 0123456789.0123456789E09F32x; 0123456789.0123456789E09F64; 0123456789.0123456789E09F64x; 0123456789.0123456789E09W; 0123456789.0123456789E09F128; 0123456789.0123456789E09q; /* 0123456789.0123456789E09q; */ + /* +0123456789.0123456789E+09F16; */ +0123456789.0123456789E+09F32; +0123456789.0123456789E+09F32x; +0123456789.0123456789E+09F64; +0123456789.0123456789E+09F64x; +0123456789.0123456789E+09w; +0123456789.0123456789E+09F128; +0123456789.0123456789E+09Q; /* +0123456789.0123456789E+09Q; */ + /* -0123456789.0123456789E-09F16; */ -0123456789.0123456789E-09F32; -0123456789.0123456789E-09F32x; -0123456789.0123456789E-09F64; -0123456789.0123456789E-09F64x; -0123456789.0123456789E-09W; -0123456789.0123456789E-09F128; -0123456789.0123456789E-09q; /* -0123456789.0123456789E-09q; */ + + /* 0x123456789.p09f16; */ 0x123456789.p09f32; 0x123456789.p09f32x; 0x123456789.p09f64; 0x123456789.p09f64x; 0x123456789.p09W; 0x123456789.p09f128; 0x123456789.p09q; /* 0x123456789.p09f128x; */ + /* +0x123456789.P+09f16; */ +0x123456789.P+09f32; +0x123456789.P+09f32x; +0x123456789.P+09f64; +0x123456789.P+09f64x; +0x123456789.P+09w; +0x123456789.P+09f128; +0x123456789.P+09Q; /* +0x123456789.P+09f128x; */ + /* -0x123456789.P-09f16; */ -0x123456789.P-09f32; -0x123456789.P-09f32x; -0x123456789.P-09f64; -0x123456789.P-09f64x; -0x123456789.P-09W; -0x123456789.P-09f128; -0x123456789.P-09q; /* -0x123456789.P-09f128x; */ + + /* 0x123456789.p09F16; */ 0x123456789.p09F32; 0x123456789.p09F32x; 0x123456789.p09F64; 0x123456789.p09F64x; 0x123456789.p09W; 0x123456789.p09F128; 0x123456789.p09q; /* .0123456789p09q; */ + /* +0x123456789.p+09F16; */ +0x123456789.p+09F32; +0x123456789.p+09F32x; +0x123456789.p+09F64; +0x123456789.p+09F64x; +0x123456789.p+09w; +0x123456789.p+09F128; +0x123456789.p+09Q; /* +.0123456789p+09Q; */ + /* -0x123456789.p-09F16; */ -0x123456789.p-09F32; -0x123456789.p-09F32x; -0x123456789.p-09F64; -0x123456789.p-09F64x; -0x123456789.p-09W; -0x123456789.p-09F128; -0x123456789.p-09q; /* -.0123456789P-09q; */ + + /* 0X.0123456789p09F16; */ 0X.0123456789p09F32; 0X.0123456789p09F32x; 0X.0123456789p09F64; 0X.0123456789p09F64x; 0X.0123456789p09W; 0X.0123456789p09F128; 0X.0123456789p09q; /* 0X.0123456789p09q; */ + /* +0X.0123456789p+09F16; */ +0X.0123456789p+09F32; +0X.0123456789p+09F32x; +0X.0123456789p+09F64; +0X.0123456789p+09F64x; +0X.0123456789p+09w; +0X.0123456789p+09F128; +0X.0123456789p+09Q; /* +0X.0123456789p+09Q; */ + /* -0X.0123456789p-09F16; */ -0X.0123456789p-09F32; -0X.0123456789p-09F32x; -0X.0123456789p-09F64; -0X.0123456789p-09F64x; -0X.0123456789p-09W; -0X.0123456789p-09F128; -0X.0123456789p-09q; /* -0X.0123456789P-09q; */ + + /* 0x123456789.0123456789P09F16; */ 0x123456789.0123456789P09F32; 0x123456789.0123456789P09F32x; 0x123456789.0123456789P09F64; 0x123456789.0123456789P09F64x; 0x123456789.0123456789P09W; 0x123456789.0123456789P09F128; 0x123456789.0123456789P09q; /* 0x123456789.0123456789P09q; */ + /* +0x123456789.0123456789P+09F16; */ +0x123456789.0123456789P+09F32; +0x123456789.0123456789P+09F32x; +0x123456789.0123456789P+09F64; +0x123456789.0123456789P+09F64x; +0x123456789.0123456789P+09w; +0x123456789.0123456789P+09F128; +0x123456789.0123456789P+09Q; /* +0x123456789.0123456789P+09Q; */ + /* -0x123456789.0123456789p-09F16; */ -0x123456789.0123456789p-09F32; -0x123456789.0123456789p-09F32x; -0x123456789.0123456789p-09F64; -0x123456789.0123456789p-09F64x; -0x123456789.0123456789p-09W; -0x123456789.0123456789p-09F128; -0x123456789.0123456789p-09q; /* -0x123456789.0123456789p-09q; */ + + /* 0x123456789.0123456789P09F16; */ 0x123456789.0123456789P09F32; 0x123456789.0123456789P09F32x; 0x123456789.0123456789P09F64; 0x123456789.0123456789P09F64x; 0x123456789.0123456789P09W; 0x123456789.0123456789P09F128; 0x123456789.0123456789P09q; /* 0x123456789.0123456789P09q; */ + /* +0x123456789.0123456789p+09F16; */ +0x123456789.0123456789p+09F32; +0x123456789.0123456789p+09F32x; +0x123456789.0123456789p+09F64; +0x123456789.0123456789p+09F64x; +0x123456789.0123456789p+09w; +0x123456789.0123456789p+09F128; +0x123456789.0123456789p+09Q; /* +0x123456789.0123456789p+09Q; */ + /* -0x123456789.0123456789P-09F16; */ -0x123456789.0123456789P-09F32; -0x123456789.0123456789P-09F32x; -0x123456789.0123456789P-09F64; -0x123456789.0123456789P-09F64x; -0x123456789.0123456789P-09W; -0x123456789.0123456789P-09F128; -0x123456789.0123456789P-09q; /* -0x123456789.0123456789P-09q; */ +#endif // __GNUC_PREREQ(7,0) + #ifdef __CFA__ // fixed-size length @@ -167,5 +211,5 @@ // octal 01234567_l8; 01234567_l16; 01234567_l32; 01234567_l64; 01234567_l8u; 01234567_ul16; 01234567_l32u; 01234567_ul64; - +01234567_l8; +01234567_l16; +01234567_l32; +01234567_l64; +01234567_l8u; +01234567_ul16; +01234567_l32u; +01234567_ul64; + +01234567_l8; +01234567_l16; +01234567_l32; +01234567_l64; +01234567_ul8; +01234567_ul16; +01234567_l32u; +01234567_ul64; -01234567_l8; -01234567_l16; -01234567_l32; -01234567_l64; -01234567_l8u; -01234567_ul16; -01234567_l32u; -01234567_ul64; @@ -203,30 +247,4 @@ +0X0123456789ABCDEF_l8; +0X0123456789ABCDEF_l16; +0X0123456789ABCDEFl32; +0X0123456789ABCDEFl64; +0X0123456789ABCDEF_ul8; +0X0123456789ABCDEF_l16u; +0X0123456789ABCDEFul32; +0X0123456789ABCDEFl64u; -0X0123456789ABCDEF_l8; -0X0123456789ABCDEF_l16; -0X0123456789ABCDEFl32; -0X0123456789ABCDEFl64; -0X0123456789ABCDEF_ul8; -0X0123456789ABCDEF_l16u; -0X0123456789ABCDEFul32; -0X0123456789ABCDEFl64u; - - // floating - 0123456789.l32; 0123456789.l64; 0123456789.l80; 0123456789.l128; - +0123456789.l32; +0123456789.l64; +0123456789.l80; +0123456789.l128; - -0123456789.l32; -0123456789.l64; -0123456789.l80; -0123456789.l128; - - 0123456789.e09L32; 0123456789.e09L64; 0123456789.e09L80; 0123456789.e09L128; - +0123456789.e+09L32; +0123456789.e+09L64; +0123456789.e+09L80; +0123456789.e+09L128; - -0123456789.e-09L32; -0123456789.e-09L64; -0123456789.e-09L80; -0123456789.e-09L128; - - .0123456789e09L32; .0123456789e09L64; .0123456789e09L80; .0123456789e09L128; - +.0123456789E+09L32; +.0123456789E+09L64; +.0123456789E+09L80; +.0123456789E+09L128; - -.0123456789E-09L32; -.0123456789E-09L64; -.0123456789E-09L80; -.0123456789E-09L128; - - 0123456789.0123456789L32; 0123456789.0123456789L64; 0123456789.0123456789L80; 0123456789.0123456789L128; - +0123456789.0123456789E09L32; +0123456789.0123456789E09L64; +0123456789.0123456789E09L80; +0123456789.0123456789E09L128; - -0123456789.0123456789E+09L32; -0123456789.0123456789E+09L64; -0123456789.0123456789E+09L80; -0123456789.0123456789E+09L128; - 0123456789.0123456789E-09L32; 0123456789.0123456789E-09L64; 0123456789.0123456789E-09L80; 0123456789.0123456789E-09L128; - - 0x0123456789.p09l32; 0x0123456789.p09l64; 0x0123456789.p09l80; 0x0123456789.p09l128; - +0x0123456789.p09l32; +0x0123456789.p09l64; +0x0123456789.p09l80; +0x0123456789.p09l128; - -0x0123456789.p09l32; -0x0123456789.p09l64; -0x0123456789.p09l80; -0x0123456789.p09l128; - - 0x0123456789.p+09l32; 0x0123456789.p+09L64; 0x0123456789.p+09L80; 0x0123456789.p+09L128; - +0x0123456789.p-09l32; +0x0123456789.p-09L64; +0x0123456789.p-09L80; +0x0123456789.p-09L128; - -0x.0123456789p09l32; -0x.0123456789p09L64; -0x.0123456789p09L80; -0x.0123456789p09L128; // char, short, int suffix overloading Index: tests/numericConstants.cfa =================================================================== --- tests/numericConstants.cfa (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ tests/numericConstants.cfa (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -10,6 +10,6 @@ // Created On : Wed May 24 22:10:36 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Nov 6 17:59:53 2018 -// Update Count : 3 +// Last Modified On : Tue Feb 5 08:58:16 2019 +// Update Count : 5 // @@ -67,4 +67,4 @@ // Local Variables: // // tab-width: 4 // -// compile-command: "cfa minmax.cfa" // +// compile-command: "cfa numericConstants.cfa" // // End: // Index: tests/sum.cfa =================================================================== --- tests/sum.cfa (revision 6d01d8968e5ddcca442bac031525f960a2f4f81f) +++ tests/sum.cfa (revision 85d44c64a0451298e3994ef0dae6f162d5f44c8d) @@ -11,12 +11,10 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Dec 23 23:00:38 2018 -// Update Count : 287 +// Last Modified On : Sat Feb 9 15:38:48 2019 +// Update Count : 293 // #include #include - -void ?{}( int & c, zero_t ) { c = 0; } // not in prelude trait sumable( otype T ) { @@ -44,4 +42,5 @@ // Not in prelude. void ?{}( unsigned char & c, zero_t ) { c = 0; } +void ?{}( int & i, zero_t ) { i = 0; } void ?{}( float & f, zero_t ) { f = 0.0; } void ?{}( double & d, zero_t ) { d = 0.0; }