Changes in / [85d44c6:6d01d89]


Ignore:
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • libcfa/prelude/prelude-gen.cc

    r85d44c6 r6d01d89  
    3434#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
    3535        { "__float80"             , true , true , },
    36         { "__float128"            , true , true , },
     36        { "_Float128"             , true , true , },
    3737#endif
    3838};
     
    153153        cout << "signed int ?==?( one_t, one_t ),                                                       ?!=?( one_t, one_t );" << endl;
    154154        cout << "signed int ?==?( _Bool, _Bool ),                                                       ?!=?( _Bool, _Bool );" << endl;
    155         cout << "signed int !?( _Bool );" << endl;
     155        cout << "signed int     !?( _Bool );" << endl;
    156156
    157157        for (auto op : arithmeticOperators) {
     
    386386        cout << endl;
    387387}
     388
  • src/Concurrency/Waitfor.cc

    r85d44c6 r6d01d89  
    1111// Last Modified By :
    1212// Last Modified On :
    13 // Update Count     : 7
     13// Update Count     : 5
    1414//
    1515
  • src/ControlStruct/ExceptTranslate.cc

    r85d44c6 r6d01d89  
    99// Author           : Andrew Beach
    1010// Created On       : Wed Jun 14 16:49:00 2017
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 18:15:29 2019
    13 // Update Count     : 11
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thr Aug 17 17:19:00 2017
     13// Update Count     : 9
    1414//
    1515
  • src/InitTweak/FixInit.cc

    r85d44c6 r6d01d89  
    1010// Created On       : Wed Jan 13 16:29:30 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 18:15:56 2019
    13 // Update Count     : 76
     12// Last Modified On : Wed Jun 21 17:35:05 2017
     13// Update Count     : 74
    1414//
    1515#include "FixInit.h"
  • src/Parser/DeclarationNode.cc

    r85d44c6 r6d01d89  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  1 16:49:17 2019
    13 // Update Count     : 1113
     12// Last Modified On : Thu Nov  1 20:54:26 2018
     13// Update Count     : 1108
    1414//
    1515
     
    4141
    4242// These must harmonize with the corresponding DeclarationNode enumerations.
    43 const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "int128",
    44                                                                                                    "float", "double", "long double", "float80", "float128",
    45                                                                                                    "_float16", "_float32", "_float32x", "_float64", "_float64x", "_float128", "_float128x", "NoBasicTypeNames" };
    46 const char * DeclarationNode::complexTypeNames[] = { "_Complex", "NoComplexTypeNames", "_Imaginary" }; // Imaginary unsupported => parse, but make invisible and print error message
     43const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "int128", "float80", "float128", "NoBasicTypeNames" };
     44const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
    4745const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
    4846const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };
  • src/Parser/ExpressionNode.cc

    r85d44c6 r6d01d89  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 18:07:38 2019
    13 // Update Count     : 902
     12// Last Modified On : Mon Jun  4 21:24:45 2018
     13// Update Count     : 802
    1414//
    1515
     
    5151extern const Type::Qualifiers noQualifiers;                             // no qualifiers on constants
    5252
    53 // static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
    54 // static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; }
    55 // static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
     53static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
     54static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
     55static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; }
     56static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
    5657static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
    5758static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
    58 static inline bool checkF80( char c ) { return c == 'w' || c == 'W'; }
    59 static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
    60 static inline bool checkF128( char c ) { return c == 'q' || c == 'Q'; }
    6159static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
    6260static inline bool checkB( char c ) { return c == 'b' || c == 'B'; }
    6361static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
    6462
     63static const char * lnthsInt[2][6] = {
     64        { "int8_t", "int16_t", "int32_t", "int64_t", "size_t", },
     65        { "uint8_t", "uint16_t", "uint32_t", "uint64_t", "size_t", }
     66}; // lnthsInt
     67
     68static inline void checkLNInt( string & str, int & lnth, int & size ) {
     69        string::size_type posn = str.find_first_of( "lL" ), start = posn;
     70  if ( posn == string::npos ) return;
     71        size = 4;                                                                                       // assume largest size
     72        posn += 1;                                                                                      // advance to size
     73        if ( str[posn] == '8' ) {                                                       // 8
     74                lnth = 0;
     75        } else if ( str[posn] == '1' ) {
     76                posn += 1;
     77                if ( str[posn] == '6' ) {                                               // 16
     78                        lnth = 1;
     79                } else {                                                                                // 128
     80                        posn += 1;
     81                        lnth = 5;
     82                } // if
     83        } else {
     84                if ( str[posn] == '3' ) {                                               // 32
     85                        lnth = 2;
     86                } else if ( str[posn] == '6' ) {                                // 64
     87                        lnth = 3;
     88                } else {
     89                        assertf( false, "internal error, bad integral length %s", str.c_str() );
     90                } // if
     91                posn += 1;
     92        } // if
     93        str.erase( start, posn - start + 1 );                           // remove length suffix
     94} // checkLNInt
     95
    6596Expression * build_constantInteger( string & str ) {
    6697        static const BasicType::Kind kind[2][6] = {
    67                 // short (h) must be before char (hh) because shorter type has the longer suffix
     98                // short (h) must be before char (hh)
    6899                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, },
    69100                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, },
    70101        };
    71102
    72         static const char * lnthsInt[2][5] = {
    73                 { "int16_t",  "int8_t",  "int32_t",  "int64_t",  "size_t", },
    74                 { "uint16_t", "uint8_t", "uint32_t", "uint64_t", "size_t", },
    75         }; // lnthsInt
    76 
    77103        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
    78         int type = -1;                                                                          // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
    79         int ltype = -1;                                                                         // literal length
     104        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
     105        int lnth = -1;                                                                          // literal length
    80106
    81107        unsigned long long int v;                                                       // converted integral value
     
    101127                        //printf( "%llx %llu\n", v, v );
    102128                } else if ( checkB( str[1] ) ) {                                // binary constant ?
    103                         v = 0;                                                                          // compute value
    104                         for ( unsigned int i = 2;; ) {
     129                        v = 0;
     130                        for ( unsigned int i = 2;; i += 1 ) {           // compute value
    105131                                if ( str[i] == '1' ) v |= 1;
    106                                 i += 1;
    107                           if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
     132                          if ( i == last ) break;
    108133                                v <<= 1;
    109134                        } // for
    110                         //printf( "%#llx %llu\n", v, v );
     135                        //printf( "%llx %llu\n", v, v );
    111136                } else {                                                                                // octal constant
    112137                        sscanf( (char *)str.c_str(), "%llo", &v );
    113                         //printf( "%#llo %llu\n", v, v );
     138                        //printf( "%llo %llu\n", v, v );
    114139                } // if
    115140        } else {                                                                                        // decimal constant ?
     
    118143        } // if
    119144
     145        if ( v <= INT_MAX ) {                                                           // signed int
     146                size = 2;
     147        } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
     148                size = 2;
     149                Unsigned = true;                                                                // unsigned
     150        } else if ( v <= LONG_MAX ) {                                           // signed long int
     151                size = 3;
     152        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
     153                size = 3;
     154                Unsigned = true;                                                                // unsigned long int
     155        } else if ( v <= LLONG_MAX ) {                                          // signed long long int
     156                size = 4;
     157        } else {                                                                                        // unsigned long long int
     158                size = 4;
     159                Unsigned = true;                                                                // unsigned long long int
     160        } // if
     161
    120162        // At least one digit in integer constant, so safe to backup while looking for suffix.
    121163
    122         string::size_type posn;
    123 
    124         if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true;
    125 
    126         posn = str.rfind( "hh" );
    127         if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
    128 
    129         posn = str.rfind( "HH" );
    130         if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
    131 
    132         posn = str.find_last_of( "hH" );
    133         if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
    134 
    135         posn = str.find_last_of( "zZ" );
    136         if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
    137 
    138         if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
    139 
    140         posn = str.find_last_of( "lL" );
    141         if ( posn != string::npos ) {
    142                 type = 3;                                                                               // default
    143                 posn += 1;                                                                              // advance to size
    144                 if ( str[posn] == '3' ) {                                               // 32
    145                         type = ltype = 2; str.erase( posn, 2 );
    146                 } else if ( str[posn] == '6' ) {                                // 64
    147                         type = ltype = 3; str.erase( posn, 2 );
    148                 } else if ( str[posn] == '8' ) {                                // 8
    149                         type = ltype = 1; str.erase( posn, 1 );
    150                 } else if ( str[posn] == '1' ) {
    151                         if ( str[posn + 1] == '6' ) {                           // 16
    152                                 type = ltype = 0; str.erase( posn, 2 );
    153                         } else {                                                                        // 128
    154                                 type = ltype = 5; str.erase( posn, 3 );
     164        if ( checkU( str[last] ) ) {                                            // suffix 'u' ?
     165                Unsigned = true;
     166                if ( checkL( str[last - 1] ) ) {                                // suffix 'l' ?
     167                        size = 3;
     168                        if ( checkL( str[last - 2] ) ) {                        // suffix "ll" ?
     169                                size = 4;
    155170                        } // if
    156                 } // if
    157         } // if
    158   FINI:
    159 
    160         if ( type == -1 ) {                                                                     // no suffix type, use value
    161                 if ( v <= INT_MAX ) {                                                   // signed int
    162                         type = 2;
    163                 } else if ( v <= UINT_MAX && ! dec ) {                  // unsigned int
    164                         type = 2;
    165                         Unsigned = true;                                                        // unsigned
    166                 } else if ( v <= LONG_MAX ) {                                   // signed long int
    167                         type = 3;
    168                 } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
    169                         type = 3;
    170                         Unsigned = true;                                                        // unsigned long int
    171                 } else if ( v <= LLONG_MAX ) {                                  // signed long long int
    172                         type = 4;
    173                 } else {                                                                                // unsigned long long int
    174                         type = 4;
    175                         Unsigned = true;                                                        // unsigned long long int
    176                 } // if
    177         } // if
    178 
    179         assert( 0 <= type && type < 6 );
     171                } else if ( checkH( str[last - 1] ) ) {                 // suffix 'h' ?
     172                        size = 0;
     173                        if ( checkH( str[last - 2] ) ) {                        // suffix "hh" ?
     174                                size = 1;
     175                        } // if
     176                        str.erase( last - size - 1, size + 1 );         // remove 'h'/"hh"
     177                } else {                                                                                // suffix "ln" ?
     178                        checkLNInt( str, lnth, size );
     179                } // if
     180        } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
     181                size = 3;
     182                if ( checkL( str[last - 1] ) ) {                                // suffix 'll' ?
     183                        size = 4;
     184                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
     185                                Unsigned = true;
     186                        } // if
     187                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
     188                        Unsigned = true;
     189                } // if
     190        } else if ( checkH( str[ last ] ) ) {                           // suffix 'h' ?
     191                size = 0;
     192                if ( checkH( str[last - 1] ) ) {                                // suffix "hh" ?
     193                        size = 1;
     194                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
     195                                Unsigned = true;
     196                        } // if
     197                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
     198                        Unsigned = true;
     199                } // if
     200                str.erase( last - size, size + 1 );                             // remove 'h'/"hh"
     201        } else if ( checkZ( str[last] ) ) {                                     // suffix 'z' ?
     202                lnth = 4;
     203                str.erase( last, 1 );                                                   // remove 'z'
     204        } else {                                                                                        // suffix "ln" ?
     205                checkLNInt( str, lnth, size );
     206        } // if
     207
     208        assert( 0 <= size && size < 6 );
    180209        // Constant type is correct for overload resolving.
    181         ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][type] ), str, v ) );
    182         if ( Unsigned && type < 2 ) {                                           // hh or h, less than int ?
     210        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
     211        if ( Unsigned && size < 2 ) {                                           // hh or h, less than int ?
    183212                // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
    184                 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
    185         } else if ( ltype != -1 ) {                                                     // explicit length ?
    186                 if ( ltype == 5 ) {                                                             // int128 ?
    187                         type = 5;
    188                         ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
     213                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
     214        } else if ( lnth != -1 ) {                                                      // explicit length ?
     215                if ( lnth == 5 ) {                                                              // int128 ?
     216                        size = 5;
     217                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
    189218                } else {
    190                         ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false );
     219                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ), false );
    191220                } // if
    192221        } // if
     
    198227
    199228
    200 static inline void checkFnxFloat( string & str, size_t last, bool & explnth, int & type ) {
    201         string::size_type posn;
    202         // floating-point constant has minimum of 2 characters, 1. or .1, so safe to look ahead
    203         if ( str[1] == 'x' ) {                                                          // hex ?
    204                 posn = str.find_last_of( "pP" );                                // back for exponent (must have)
    205                 posn = str.find_first_of( "fF", posn + 1 );             // forward for size (fF allowed in hex constant)
    206         } else {
    207                 posn = str.find_last_of( "fF" );                                // back for size (fF not allowed)
    208         } // if
     229static inline void checkLNFloat( string & str, int & lnth, int & size ) {
     230        string::size_type posn = str.find_first_of( "lL" ), start = posn;
    209231  if ( posn == string::npos ) return;
    210         explnth = true;
     232        size = 2;                                                                                       // assume largest size
     233        lnth = 0;
    211234        posn += 1;                                                                                      // advance to size
    212235        if ( str[posn] == '3' ) {                                                       // 32
    213                 if ( str[last] != 'x' ) type = 6;
    214                 else type = 7;
     236                size = 0;
    215237        } else if ( str[posn] == '6' ) {                                        // 64
    216                 if ( str[last] != 'x' ) type = 8;
    217                 else type = 9;
    218         } else if ( str[posn] == '8' ) {                                        // 80
    219                 type = 3;
    220         } else if ( str[posn] == '1' ) {                                        // 16/128
    221                 if ( str[posn + 1] == '6' ) {                                   // 16
    222                         type = 5;
    223                 } else {                                                                                // 128
    224                         if ( str[last] != 'x' ) type = 10;
    225                         else type = 11;
    226                 } // if
     238                size = 1;
     239        } else if ( str[posn] == '8' || str[posn] == '1' ) { // 80, 128
     240                size = 2;
     241                if ( str[posn] == '1' ) posn += 1;
    227242        } else {
    228243                assertf( false, "internal error, bad floating point length %s", str.c_str() );
    229244        } // if
    230 } // checkFnxFloat
     245        posn += 1;
     246        str.erase( start, posn - start + 1 );                           // remove length suffix
     247} // checkLNFloat
    231248
    232249
    233250Expression * build_constantFloat( string & str ) {
    234         static const BasicType::Kind kind[2][12] = {
    235                 { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x },
    236                 { 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 },
     251        static const BasicType::Kind kind[2][3] = {
     252                { BasicType::Float, BasicType::Double, BasicType::LongDouble },
     253                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
    237254        };
    238255
    239         // floating-point constant has minimum of 2 characters 1. or .1
     256        bool complx = false;                                                            // real, complex
     257        int size = 1;                                                                           // 0 => float, 1 => double, 2 => long double
     258        int lnth = -1;                                                                          // literal length
     259        // floating-point constant has minimum of 2 characters: 1. or .1
    240260        size_t last = str.length() - 1;
    241261        double v;
    242         int type;                                                                                       // 0 => float, 1 => double, 3 => long double, ...
    243         bool complx = false;                                                            // real, complex
    244         bool explnth = false;                                                           // explicit literal length
    245262
    246263        sscanf( str.c_str(), "%lg", &v );
     
    252269
    253270        if ( checkF( str[last] ) ) {                                            // float ?
    254                 type = 0;
     271                size = 0;
    255272        } else if ( checkD( str[last] ) ) {                                     // double ?
    256                 type = 1;
     273                size = 1;
    257274        } else if ( checkL( str[last] ) ) {                                     // long double ?
    258                 type = 2;
    259         } else if ( checkF80( str[last] ) ) {                           // __float80 ?
    260                 type = 3;
    261         } else if ( checkF128( str[last] ) ) {                          // __float128 ?
    262                 type = 4;
     275                size = 2;
    263276        } else {
    264                 type = 1;                                                                               // double (default if no suffix)
    265                 checkFnxFloat( str, last, explnth, type );
    266         } // if
    267 
     277                size = 1;                                                                               // double (default)
     278                checkLNFloat( str, lnth, size );
     279        } // if
    268280        if ( ! complx && checkI( str[last - 1] ) ) {            // imaginary ?
    269281                complx = true;
    270282        } // if
    271283
    272         assert( 0 <= type && type < 12 );
    273         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][type] ), str, v ) );
    274         if ( explnth ) {                                                                        // explicit length ?
    275                 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][type] ), false );
     284        assert( 0 <= size && size < 3 );
     285        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
     286        if ( lnth != -1 ) {                                                                     // explicit length ?
     287                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ), false );
    276288        } // if
    277289
  • src/Parser/ParseNode.h

    r85d44c6 r6d01d89  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 17:36:49 2019
    13 // Update Count     : 867
     12// Last Modified On : Thu Nov  1 20:54:53 2018
     13// Update Count     : 854
    1414//
    1515
     
    206206class DeclarationNode : public ParseNode {
    207207  public:
    208         // These enumerations must harmonize with their names in DeclarationNode.cc.
    209         enum BasicType { Void, Bool, Char, Int, Int128,
    210                                          Float, Double, LongDouble, uuFloat80, uuFloat128,
    211                                          uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, NoBasicType };
     208        // These enumerations must harmonize with their names.
     209        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, Int128, Float80, Float128, NoBasicType };
    212210        static const char * basicTypeNames[];
    213         enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
     211        enum ComplexType { Complex, Imaginary, NoComplexType };
    214212        static const char * complexTypeNames[];
    215213        enum Signedness { Signed, Unsigned, NoSignedness };
  • src/Parser/TypeData.cc

    r85d44c6 r6d01d89  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 18:16:23 2019
    13 // Update Count     : 649
     12// Last Modified On : Fri Nov  2 07:54:26 2018
     13// Update Count     : 624
    1414//
    1515
     
    666666
    667667          case DeclarationNode::Float:
     668          case DeclarationNode::Float80:
     669          case DeclarationNode::Float128:
    668670          case DeclarationNode::Double:
    669671          case DeclarationNode::LongDouble:                                     // not set until below
    670           case DeclarationNode::uuFloat80:
    671           case DeclarationNode::uuFloat128:
    672           case DeclarationNode::uFloat16:
    673           case DeclarationNode::uFloat32:
    674           case DeclarationNode::uFloat32x:
    675           case DeclarationNode::uFloat64:
    676           case DeclarationNode::uFloat64x:
    677           case DeclarationNode::uFloat128:
    678           case DeclarationNode::uFloat128x:
    679                 static BasicType::Kind floattype[2][12] = {
    680                         { 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, },
    681                         { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x, },
     672                static BasicType::Kind floattype[3][3] = {
     673                        { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
     674                        { BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary },
     675                        { BasicType::Float, BasicType::Double, BasicType::LongDouble },
    682676                };
    683677
     
    692686                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
    693687                } // if
    694                 if ( td->complextype == DeclarationNode::Imaginary ) {
    695                         genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
    696                 } // if
    697                 if ( (td->basictype == DeclarationNode::uuFloat80 || td->basictype == DeclarationNode::uuFloat128) && td->complextype == DeclarationNode::Complex ) { // gcc unsupported
    698                         genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
    699                 } // if
    700688                if ( td->length == DeclarationNode::Long ) {
    701689                        const_cast<TypeData *>(td)->basictype = DeclarationNode::LongDouble;
    702690                } // if
    703691
     692                if ( td->basictype == DeclarationNode::Float80 || td->basictype == DeclarationNode::Float128 ) {
     693                        // if ( td->complextype != DeclarationNode::NoComplexType ) {
     694                        //      genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
     695                        // }
     696                        if ( td->basictype == DeclarationNode::Float80 ) ret = BasicType::Float80;
     697                        else ret = BasicType::Float128;
     698                        break;
     699                }
     700
    704701                ret = floattype[ td->complextype ][ td->basictype - DeclarationNode::Float ];
    705                 //printf( "XXXX %d %d %d %d\n", td->complextype, td->basictype, DeclarationNode::Float, ret );
    706702                break;
    707703
  • src/Parser/lex.ll

    r85d44c6 r6d01d89  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Wed Feb 13 17:33:53 2019
    13  * Update Count     : 702
     12 * Last Modified On : Thu Nov  1 20:57:35 2018
     13 * Update Count     : 687
    1414 */
    1515
     
    3939using namespace std;
    4040
    41 #include "config.h"                                                                             // configure info
    4241#include "ParseNode.h"
    4342#include "TypedefTable.h"
     
    6059#define IDENTIFIER_RETURN()     RETURN_VAL( typedefTable.isKind( yytext ) )
    6160#define ATTRIBUTE_RETURN()      RETURN_VAL( ATTR_IDENTIFIER )
    62 
    63 #ifdef HAVE_KEYWORDS_FLOATXX                                                            // GCC >= 7 => keyword, otherwise typedef
    64 #define FLOATXX(v) KEYWORD_RETURN(v);
    65 #else
    66 #define FLOATXX(v) IDENTIFIER_RETURN();
    67 #endif // HAVE_KEYWORDS_FLOATXX
    6861
    6962void rm_underscore() {
     
    119112                                // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
    120113exponent "_"?[eE]"_"?[+-]?{decimal_digits}
    121 floating_size 16|32|32x|64|64x|80|128|128x
    122 floating_length ([fFdDlLwWqQ]|[fF]{floating_size})
     114floating_size 32|64|80|128
     115floating_length ([fFdDlL]|[lL]{floating_size})
    123116floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length})
    124117floating_suffix_opt ("_"?({floating_suffix}|"DL"))?
     
    247240finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
    248241float                   { KEYWORD_RETURN(FLOAT); }
    249 __float80               { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
    250 float80                 { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
    251 __float128              { KEYWORD_RETURN(uuFLOAT128); }                 // GCC
    252 float128                { KEYWORD_RETURN(uuFLOAT128); }                 // GCC
    253 _Float16                { FLOATXX(uFLOAT16); }                                  // GCC
    254 _Float32                { FLOATXX(uFLOAT32); }                                  // GCC
    255 _Float32x               { FLOATXX(uFLOAT32X); }                                 // GCC
    256 _Float64                { FLOATXX(uFLOAT64); }                                  // GCC
    257 _Float64x               { FLOATXX(uFLOAT64X); }                                 // GCC
    258 _Float128               { FLOATXX(uFLOAT128); }                                 // GCC
    259 _Float128x              { FLOATXX(uFLOAT128); }                                 // GCC
     242_Float32                { KEYWORD_RETURN(FLOAT); }                              // GCC
     243_Float32x               { KEYWORD_RETURN(FLOAT); }                              // GCC
     244_Float64                { KEYWORD_RETURN(DOUBLE); }                             // GCC
     245_Float64x               { KEYWORD_RETURN(DOUBLE); }                             // GCC
     246__float80               { KEYWORD_RETURN(FLOAT80); }                    // GCC
     247float80                 { KEYWORD_RETURN(FLOAT80); }                    // GCC
     248_Float128               { KEYWORD_RETURN(FLOAT128); }                   // GCC
     249_Float128x              { KEYWORD_RETURN(FLOAT128); }                   // GCC
     250__float128              { KEYWORD_RETURN(FLOAT128); }                   // GCC
     251float128                { KEYWORD_RETURN(FLOAT128); }                   // GCC
    260252for                             { KEYWORD_RETURN(FOR); }
    261253forall                  { KEYWORD_RETURN(FORALL); }                             // CFA
  • src/Parser/parser.yy

    r85d44c6 r6d01d89  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 14 22:23:13 2019
    13 // Update Count     : 4217
     12// Last Modified On : Thu Feb 14 18:02:44 2019
     13// Update Count     : 4216
    1414//
    1515
     
    267267%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
    268268%token BOOL COMPLEX IMAGINARY                                                   // C99
    269 %token INT128 uuFLOAT80 uuFLOAT128                                              // GCC
    270 %token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC
     269%token INT128 FLOAT80 FLOAT128                                                  // GCC
    271270%token ZERO_T ONE_T                                                                             // CFA
    272271%token VALIST                                                                                   // GCC
     
    17741773        | FLOAT
    17751774                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
     1775        | FLOAT80
     1776                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); }
     1777        | FLOAT128
     1778                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); }
    17761779        | DOUBLE
    17771780                { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    1778         | uuFLOAT80
    1779                 { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat80 ); }
    1780         | uuFLOAT128
    1781                 { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat128 ); }
    1782         | uFLOAT16
    1783                 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat16 ); }
    1784         | uFLOAT32
    1785                 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32 ); }
    1786         | uFLOAT32X
    1787                 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32x ); }
    1788         | uFLOAT64
    1789                 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64 ); }
    1790         | uFLOAT64X
    1791                 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64x ); }
    1792         | uFLOAT128
    1793                 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat128 ); }
    17941781        | COMPLEX                                                                                       // C99
    17951782                { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
  • src/ResolvExpr/CommonType.cc

    r85d44c6 r6d01d89  
    1010// Created On       : Sun May 17 06:59:27 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 22:30:32 2019
    13 // Update Count     : 22
     12// Last Modified On : Mon Sep 25 15:18:17 2017
     13// Update Count     : 9
    1414//
    1515
     
    175175                return result;
    176176        }
    177 #if 0
    178         #define BT BasicType::
     177
    179178        static const BasicType::Kind combinedType[][ BasicType::NUMBER_OF_BASIC_TYPES ] =
    180179        {
    181180/*              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 */
    182                 /* 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 },
    183                 /* 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 },
    184                 /* 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 },
    185                 /* 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 },
    186                 /* 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 },
    187                 /* 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 },
    188                 /* 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 },
    189                 /* 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 },
    190                 /* 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 },
    191                 /* 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 },
    192                 /* 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 },
    193                 /* 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 },
    194 
    195                 /* 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 },
    196                 /* 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 },
    197                 /* 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 },
    198                 /* 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 },
    199                 /* 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 },
    200                 /* 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 },
    201                 /* 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 },
    202                 /* 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 },
    203                 /* 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 },
    204 
    205                 /* 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 },
    206                 /* 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 },
    207                 /* 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 },
    208                 /* 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 },
    209 
    210                 /* _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 },
    211                 /* _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 },
    212                 /* _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 },
    213                 /* _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 },
    214                 /* _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 },
    215                 /* _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 },
    216                 /* _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 },
    217 
    218                 /* _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 },
    219                 /* _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 },
    220                 /* _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 },
    221                 /* _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 },
    222                 /* _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 },
    223                 /* _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 },
    224                 /* _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 },
     181                /* 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 },
     182                /* 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 },
     183                /* 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 },
     184                /* 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 },
     185                /* 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 },
     186                /* 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 },
     187                /* 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 },
     188                /* 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 },
     189                /* 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 },
     190                /* 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 },
     191                /* 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 },
     192                /* 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 },
     193                /* 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 },
     194                /* 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 },
     195                /* 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 },
     196                /* 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, },
     197                /* 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 },
     198                /* 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, },
     199                /* 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, },
     200                /* 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, },
     201                /* 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, },
     202                /* 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, },
     203                /* 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, },
     204                /* 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 },
     205                /* 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 },
    225206        };
    226         #undef BT
    227 #endif
    228 
    229         // GENERATED START, DO NOT EDIT
    230         #define BT BasicType::
    231         static const BasicType::Kind commonTypes[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor
    232                 /*                              B                        C                       SC                       UC                       SI                      SUI
    233                                                 I                       UI                       LI                      LUI                      LLI                     LLUI
    234                                                IB                      UIB                      _FH                      _FH                       _F                      _FC
    235                                                 F                       FC                      _FX                     _FXC                       FD                     _FDC
    236                                                 D                       DC                     F80X                    _FDXC                      F80                      _FB
    237                                             _FLDC                       FB                       LD                      LDC                     _FBX                   _FLDXC
    238                          */
    239                 /*     B*/                BT Bool,                 BT Char,           BT SignedChar,         BT UnsignedChar,       BT ShortSignedInt,     BT ShortUnsignedInt,
    240                                      BT SignedInt,          BT UnsignedInt,        BT LongSignedInt,      BT LongUnsignedInt,    BT LongLongSignedInt,  BT LongLongUnsignedInt,
    241                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    242                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    243                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    244                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    245                          
    246                 /*     C*/                BT Char,                 BT Char,           BT SignedChar,         BT UnsignedChar,       BT ShortSignedInt,     BT ShortUnsignedInt,
    247                                      BT SignedInt,          BT UnsignedInt,        BT LongSignedInt,      BT LongUnsignedInt,    BT LongLongSignedInt,  BT LongLongUnsignedInt,
    248                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    249                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    250                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    251                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    252                          
    253                 /*    SC*/          BT SignedChar,           BT SignedChar,           BT SignedChar,         BT UnsignedChar,       BT ShortSignedInt,     BT ShortUnsignedInt,
    254                                      BT SignedInt,          BT UnsignedInt,        BT LongSignedInt,      BT LongUnsignedInt,    BT LongLongSignedInt,  BT LongLongUnsignedInt,
    255                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    256                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    257                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    258                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    259                          
    260                 /*    UC*/        BT UnsignedChar,         BT UnsignedChar,         BT UnsignedChar,         BT UnsignedChar,       BT ShortSignedInt,     BT ShortUnsignedInt,
    261                                      BT SignedInt,          BT UnsignedInt,        BT LongSignedInt,      BT LongUnsignedInt,    BT LongLongSignedInt,  BT LongLongUnsignedInt,
    262                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    263                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    264                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    265                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    266                          
    267                 /*    SI*/      BT ShortSignedInt,       BT ShortSignedInt,       BT ShortSignedInt,       BT ShortSignedInt,       BT ShortSignedInt,     BT ShortUnsignedInt,
    268                                      BT SignedInt,          BT UnsignedInt,        BT LongSignedInt,      BT LongUnsignedInt,    BT LongLongSignedInt,  BT LongLongUnsignedInt,
    269                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    270                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    271                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    272                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    273                          
    274                 /*   SUI*/    BT ShortUnsignedInt,     BT ShortUnsignedInt,     BT ShortUnsignedInt,     BT ShortUnsignedInt,     BT ShortUnsignedInt,     BT ShortUnsignedInt,
    275                                      BT SignedInt,          BT UnsignedInt,        BT LongSignedInt,      BT LongUnsignedInt,    BT LongLongSignedInt,  BT LongLongUnsignedInt,
    276                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    277                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    278                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    279                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    280                          
    281                 /*     I*/           BT SignedInt,            BT SignedInt,            BT SignedInt,            BT SignedInt,            BT SignedInt,            BT SignedInt,
    282                                      BT SignedInt,          BT UnsignedInt,        BT LongSignedInt,      BT LongUnsignedInt,    BT LongLongSignedInt,  BT LongLongUnsignedInt,
    283                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    284                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    285                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    286                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    287                          
    288                 /*    UI*/         BT UnsignedInt,          BT UnsignedInt,          BT UnsignedInt,          BT UnsignedInt,          BT UnsignedInt,          BT UnsignedInt,
    289                                    BT UnsignedInt,          BT UnsignedInt,        BT LongSignedInt,      BT LongUnsignedInt,    BT LongLongSignedInt,  BT LongLongUnsignedInt,
    290                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    291                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    292                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    293                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    294                          
    295                 /*    LI*/       BT LongSignedInt,        BT LongSignedInt,        BT LongSignedInt,        BT LongSignedInt,        BT LongSignedInt,        BT LongSignedInt,
    296                                  BT LongSignedInt,        BT LongSignedInt,        BT LongSignedInt,      BT LongUnsignedInt,    BT LongLongSignedInt,  BT LongLongUnsignedInt,
    297                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    298                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    299                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    300                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    301                          
    302                 /*   LUI*/     BT LongUnsignedInt,      BT LongUnsignedInt,      BT LongUnsignedInt,      BT LongUnsignedInt,      BT LongUnsignedInt,      BT LongUnsignedInt,
    303                                BT LongUnsignedInt,      BT LongUnsignedInt,      BT LongUnsignedInt,      BT LongUnsignedInt,    BT LongLongSignedInt,  BT LongLongUnsignedInt,
    304                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    305                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    306                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    307                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    308                          
    309                 /*   LLI*/   BT LongLongSignedInt,    BT LongLongSignedInt,    BT LongLongSignedInt,    BT LongLongSignedInt,    BT LongLongSignedInt,    BT LongLongSignedInt,
    310                              BT LongLongSignedInt,    BT LongLongSignedInt,    BT LongLongSignedInt,    BT LongLongSignedInt,    BT LongLongSignedInt,  BT LongLongUnsignedInt,
    311                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    312                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    313                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    314                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    315                          
    316                 /*  LLUI*/ BT LongLongUnsignedInt,  BT LongLongUnsignedInt,  BT LongLongUnsignedInt,  BT LongLongUnsignedInt,  BT LongLongUnsignedInt,  BT LongLongUnsignedInt,
    317                            BT LongLongUnsignedInt,  BT LongLongUnsignedInt,  BT LongLongUnsignedInt,  BT LongLongUnsignedInt,  BT LongLongUnsignedInt,  BT LongLongUnsignedInt,
    318                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    319                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    320                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    321                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    322                          
    323                 /*    IB*/        BT SignedInt128,         BT SignedInt128,         BT SignedInt128,         BT SignedInt128,         BT SignedInt128,         BT SignedInt128,
    324                                   BT SignedInt128,         BT SignedInt128,         BT SignedInt128,         BT SignedInt128,         BT SignedInt128,         BT SignedInt128,
    325                                   BT SignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    326                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    327                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    328                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    329                          
    330                 /*   UIB*/      BT UnsignedInt128,       BT UnsignedInt128,       BT UnsignedInt128,       BT UnsignedInt128,       BT UnsignedInt128,       BT UnsignedInt128,
    331                                 BT UnsignedInt128,       BT UnsignedInt128,       BT UnsignedInt128,       BT UnsignedInt128,       BT UnsignedInt128,       BT UnsignedInt128,
    332                                 BT UnsignedInt128,       BT UnsignedInt128,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    333                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    334                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    335                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    336                          
    337                 /*   _FH*/            BT uFloat16,             BT uFloat16,             BT uFloat16,             BT uFloat16,             BT uFloat16,             BT uFloat16,
    338                                       BT uFloat16,             BT uFloat16,             BT uFloat16,             BT uFloat16,             BT uFloat16,             BT uFloat16,
    339                                       BT uFloat16,             BT uFloat16,             BT uFloat16,      BT uFloat16Complex,             BT uFloat32,      BT uFloat32Complex,
    340                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    341                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    342                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    343                          
    344                 /*   _FH*/     BT uFloat16Complex,      BT uFloat16Complex,      BT uFloat16Complex,      BT uFloat16Complex,      BT uFloat16Complex,      BT uFloat16Complex,
    345                                BT uFloat16Complex,      BT uFloat16Complex,      BT uFloat16Complex,      BT uFloat16Complex,      BT uFloat16Complex,      BT uFloat16Complex,
    346                                BT uFloat16Complex,      BT uFloat16Complex,      BT uFloat16Complex,      BT uFloat16Complex,      BT uFloat32Complex,      BT uFloat32Complex,
    347                                   BT FloatComplex,         BT FloatComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,      BT uFloat64Complex,      BT uFloat64Complex,
    348                                  BT DoubleComplex,        BT DoubleComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat128Complex,
    349                               BT uFloat128Complex,     BT uFloat128Complex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    350                          
    351                 /*    _F*/            BT uFloat32,             BT uFloat32,             BT uFloat32,             BT uFloat32,             BT uFloat32,             BT uFloat32,
    352                                       BT uFloat32,             BT uFloat32,             BT uFloat32,             BT uFloat32,             BT uFloat32,             BT uFloat32,
    353                                       BT uFloat32,             BT uFloat32,             BT uFloat32,      BT uFloat32Complex,             BT uFloat32,      BT uFloat32Complex,
    354                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    355                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    356                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    357                          
    358                 /*   _FC*/     BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,
    359                                BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,
    360                                BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,      BT uFloat32Complex,
    361                                   BT FloatComplex,         BT FloatComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,      BT uFloat64Complex,      BT uFloat64Complex,
    362                                  BT DoubleComplex,        BT DoubleComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat128Complex,
    363                               BT uFloat128Complex,     BT uFloat128Complex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    364                          
    365                 /*     F*/               BT Float,                BT Float,                BT Float,                BT Float,                BT Float,                BT Float,
    366                                          BT Float,                BT Float,                BT Float,                BT Float,                BT Float,                BT Float,
    367                                          BT Float,                BT Float,                BT Float,         BT FloatComplex,                BT Float,         BT FloatComplex,
    368                                          BT Float,         BT FloatComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    369                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    370                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    371                          
    372                 /*    FC*/        BT FloatComplex,         BT FloatComplex,         BT FloatComplex,         BT FloatComplex,         BT FloatComplex,         BT FloatComplex,
    373                                   BT FloatComplex,         BT FloatComplex,         BT FloatComplex,         BT FloatComplex,         BT FloatComplex,         BT FloatComplex,
    374                                   BT FloatComplex,         BT FloatComplex,         BT FloatComplex,         BT FloatComplex,         BT FloatComplex,         BT FloatComplex,
    375                                   BT FloatComplex,         BT FloatComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,      BT uFloat64Complex,      BT uFloat64Complex,
    376                                  BT DoubleComplex,        BT DoubleComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat128Complex,
    377                               BT uFloat128Complex,     BT uFloat128Complex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    378                          
    379                 /*   _FX*/           BT uFloat32x,            BT uFloat32x,            BT uFloat32x,            BT uFloat32x,            BT uFloat32x,            BT uFloat32x,
    380                                      BT uFloat32x,            BT uFloat32x,            BT uFloat32x,            BT uFloat32x,            BT uFloat32x,            BT uFloat32x,
    381                                      BT uFloat32x,            BT uFloat32x,            BT uFloat32x,     BT uFloat32xComplex,            BT uFloat32x,     BT uFloat32xComplex,
    382                                      BT uFloat32x,     BT uFloat32xComplex,            BT uFloat32x,     BT uFloat32xComplex,             BT uFloat64,      BT uFloat64Complex,
    383                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    384                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    385                          
    386                 /*  _FXC*/    BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,
    387                               BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,
    388                               BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,
    389                               BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,     BT uFloat32xComplex,      BT uFloat64Complex,      BT uFloat64Complex,
    390                                  BT DoubleComplex,        BT DoubleComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat128Complex,
    391                               BT uFloat128Complex,     BT uFloat128Complex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    392                          
    393                 /*    FD*/            BT uFloat64,             BT uFloat64,             BT uFloat64,             BT uFloat64,             BT uFloat64,             BT uFloat64,
    394                                       BT uFloat64,             BT uFloat64,             BT uFloat64,             BT uFloat64,             BT uFloat64,             BT uFloat64,
    395                                       BT uFloat64,             BT uFloat64,             BT uFloat64,      BT uFloat64Complex,             BT uFloat64,      BT uFloat64Complex,
    396                                       BT uFloat64,      BT uFloat64Complex,             BT uFloat64,      BT uFloat64Complex,             BT uFloat64,      BT uFloat64Complex,
    397                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    398                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    399                          
    400                 /*  _FDC*/     BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,
    401                                BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,
    402                                BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,
    403                                BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,      BT uFloat64Complex,
    404                                  BT DoubleComplex,        BT DoubleComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat128Complex,
    405                               BT uFloat128Complex,     BT uFloat128Complex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    406                          
    407                 /*     D*/              BT Double,               BT Double,               BT Double,               BT Double,               BT Double,               BT Double,
    408                                         BT Double,               BT Double,               BT Double,               BT Double,               BT Double,               BT Double,
    409                                         BT Double,               BT Double,               BT Double,        BT DoubleComplex,               BT Double,        BT DoubleComplex,
    410                                         BT Double,        BT DoubleComplex,               BT Double,        BT DoubleComplex,               BT Double,        BT DoubleComplex,
    411                                         BT Double,        BT DoubleComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    412                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    413                          
    414                 /*    DC*/       BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,
    415                                  BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,
    416                                  BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,
    417                                  BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,        BT DoubleComplex,
    418                                  BT DoubleComplex,        BT DoubleComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat128Complex,
    419                               BT uFloat128Complex,     BT uFloat128Complex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    420                          
    421                 /*  F80X*/           BT uFloat64x,            BT uFloat64x,            BT uFloat64x,            BT uFloat64x,            BT uFloat64x,            BT uFloat64x,
    422                                      BT uFloat64x,            BT uFloat64x,            BT uFloat64x,            BT uFloat64x,            BT uFloat64x,            BT uFloat64x,
    423                                      BT uFloat64x,            BT uFloat64x,            BT uFloat64x,     BT uFloat64xComplex,            BT uFloat64x,     BT uFloat64xComplex,
    424                                      BT uFloat64x,     BT uFloat64xComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uFloat64x,     BT uFloat64xComplex,
    425                                      BT uFloat64x,     BT uFloat64xComplex,            BT uFloat64x,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    426                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    427                          
    428                 /* _FDXC*/    BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,
    429                               BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,
    430                               BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,
    431                               BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,
    432                               BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat64xComplex,     BT uFloat128Complex,
    433                               BT uFloat128Complex,     BT uFloat128Complex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    434                          
    435                 /*   F80*/           BT uuFloat80,            BT uuFloat80,            BT uuFloat80,            BT uuFloat80,            BT uuFloat80,            BT uuFloat80,
    436                                      BT uuFloat80,            BT uuFloat80,            BT uuFloat80,            BT uuFloat80,            BT uuFloat80,            BT uuFloat80,
    437                                      BT uuFloat80,            BT uuFloat80,            BT uuFloat80,     BT uFloat64xComplex,            BT uuFloat80,     BT uFloat64xComplex,
    438                                      BT uuFloat80,     BT uFloat64xComplex,            BT uuFloat80,     BT uFloat64xComplex,            BT uuFloat80,     BT uFloat64xComplex,
    439                                      BT uuFloat80,     BT uFloat64xComplex,            BT uuFloat80,     BT uFloat64xComplex,            BT uuFloat80,            BT uFloat128,
    440                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    441                          
    442                 /*   _FB*/           BT uFloat128,            BT uFloat128,            BT uFloat128,            BT uFloat128,            BT uFloat128,            BT uFloat128,
    443                                      BT uFloat128,            BT uFloat128,            BT uFloat128,            BT uFloat128,            BT uFloat128,            BT uFloat128,
    444                                      BT uFloat128,            BT uFloat128,            BT uFloat128,     BT uFloat128Complex,            BT uFloat128,     BT uFloat128Complex,
    445                                      BT uFloat128,     BT uFloat128Complex,            BT uFloat128,     BT uFloat128Complex,            BT uFloat128,     BT uFloat128Complex,
    446                                      BT uFloat128,     BT uFloat128Complex,            BT uFloat128,     BT uFloat128Complex,            BT uFloat128,            BT uFloat128,
    447                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    448                          
    449                 /* _FLDC*/    BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,
    450                               BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,
    451                               BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,
    452                               BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,
    453                               BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,     BT uFloat128Complex,
    454                               BT uFloat128Complex,     BT uFloat128Complex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    455                          
    456                 /*    FB*/          BT uuFloat128,           BT uuFloat128,           BT uuFloat128,           BT uuFloat128,           BT uuFloat128,           BT uuFloat128,
    457                                     BT uuFloat128,           BT uuFloat128,           BT uuFloat128,           BT uuFloat128,           BT uuFloat128,           BT uuFloat128,
    458                                     BT uuFloat128,           BT uuFloat128,           BT uuFloat128,     BT uFloat128Complex,           BT uuFloat128,     BT uFloat128Complex,
    459                                     BT uuFloat128,     BT uFloat128Complex,           BT uuFloat128,     BT uFloat128Complex,           BT uuFloat128,     BT uFloat128Complex,
    460                                     BT uuFloat128,     BT uFloat128Complex,           BT uuFloat128,     BT uFloat128Complex,           BT uuFloat128,           BT uuFloat128,
    461                               BT uFloat128Complex,           BT uuFloat128,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    462                          
    463                 /*    LD*/          BT LongDouble,           BT LongDouble,           BT LongDouble,           BT LongDouble,           BT LongDouble,           BT LongDouble,
    464                                     BT LongDouble,           BT LongDouble,           BT LongDouble,           BT LongDouble,           BT LongDouble,           BT LongDouble,
    465                                     BT LongDouble,           BT LongDouble,           BT LongDouble,    BT LongDoubleComplex,           BT LongDouble,    BT LongDoubleComplex,
    466                                     BT LongDouble,    BT LongDoubleComplex,           BT LongDouble,    BT LongDoubleComplex,           BT LongDouble,    BT LongDoubleComplex,
    467                                     BT LongDouble,    BT LongDoubleComplex,           BT LongDouble,    BT LongDoubleComplex,           BT LongDouble,           BT LongDouble,
    468                              BT LongDoubleComplex,           BT LongDouble,           BT LongDouble,    BT LongDoubleComplex,           BT uFloat128x,    BT uFloat128xComplex,
    469                          
    470                 /*   LDC*/   BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,
    471                              BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,
    472                              BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,
    473                              BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,
    474                              BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,
    475                              BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT LongDoubleComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    476                          
    477                 /*  _FBX*/          BT uFloat128x,           BT uFloat128x,           BT uFloat128x,           BT uFloat128x,           BT uFloat128x,           BT uFloat128x,
    478                                     BT uFloat128x,           BT uFloat128x,           BT uFloat128x,           BT uFloat128x,           BT uFloat128x,           BT uFloat128x,
    479                                     BT uFloat128x,           BT uFloat128x,           BT uFloat128x,    BT uFloat128xComplex,           BT uFloat128x,    BT uFloat128xComplex,
    480                                     BT uFloat128x,    BT uFloat128xComplex,           BT uFloat128x,    BT uFloat128xComplex,           BT uFloat128x,    BT uFloat128xComplex,
    481                                     BT uFloat128x,    BT uFloat128xComplex,           BT uFloat128x,    BT uFloat128xComplex,           BT uFloat128x,           BT uFloat128x,
    482                              BT uFloat128xComplex,           BT uFloat128x,           BT uFloat128x,    BT uFloat128xComplex,           BT uFloat128x,    BT uFloat128xComplex,
    483                          
    484                 /*_FLDXC*/   BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    485                              BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    486                              BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    487                              BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    488                              BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    489                              BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,    BT uFloat128xComplex,
    490                          
    491         };
    492         #undef BT
    493         // GENERATED END
    494 
    495207        static_assert(
    496                 sizeof(commonTypes)/sizeof(commonTypes[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
     208                sizeof(combinedType)/sizeof(combinedType[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
    497209                "Each basic type kind should have a corresponding row in the combined type matrix"
    498210        );
     
    506218        void CommonType::postvisit( BasicType *basicType ) {
    507219                if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
    508                         BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ otherBasic->get_kind() ];
     220                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ];
    509221                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= otherBasic->get_qualifiers() ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->get_qualifiers() <= otherBasic->get_qualifiers() ) || widenSecond ) ) {
    510222                                result = new BasicType( basicType->get_qualifiers() | otherBasic->get_qualifiers(), newType );
     
    512224                } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
    513225                        // use signed int in lieu of the enum/zero/one type
    514                         BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ];
     226                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
    515227                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) {
    516228                                result = new BasicType( basicType->get_qualifiers() | type2->get_qualifiers(), newType );
  • src/ResolvExpr/ConversionCost.cc

    r85d44c6 r6d01d89  
    1010// Created On       : Sun May 17 07:06:19 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 23:04:51 2019
    13 // Update Count     : 22
     12// Last Modified On : Mon Sep 25 15:43:34 2017
     13// Update Count     : 10
    1414//
    1515
     
    2828
    2929namespace ResolvExpr {
    30         const Cost Cost::zero =      Cost{  0,  0,  0,  0,  0,  0,  0 };
    31         const Cost Cost::infinity =  Cost{ -1, -1, -1, -1, -1,  1, -1 };
    32         const Cost Cost::unsafe =    Cost{  1,  0,  0,  0,  0,  0,  0 };
    33         const Cost Cost::poly =      Cost{  0,  1,  0,  0,  0,  0,  0 };
    34         const Cost Cost::safe =      Cost{  0,  0,  1,  0,  0,  0,  0 };
    35         const Cost Cost::sign =      Cost{  0,  0,  0,  1,  0,  0,  0 };
    36         const Cost Cost::var =       Cost{  0,  0,  0,  0,  1,  0,  0 };
    37         const Cost Cost::spec =      Cost{  0,  0,  0,  0,  0, -1,  0 };
    38         const Cost Cost::reference = Cost{  0,  0,  0,  0,  0,  0,  1 };
     30        const Cost Cost::zero =      Cost{  0,  0,  0,  0,  0,  0 };
     31        const Cost Cost::infinity =  Cost{ -1, -1, -1, -1,  1, -1 };
     32        const Cost Cost::unsafe =    Cost{  1,  0,  0,  0,  0,  0 };
     33        const Cost Cost::poly =      Cost{  0,  1,  0,  0,  0,  0 };
     34        const Cost Cost::safe =      Cost{  0,  0,  1,  0,  0,  0 };
     35        const Cost Cost::var =       Cost{  0,  0,  0,  1,  0,  0 };
     36        const Cost Cost::spec =      Cost{  0,  0,  0,  0, -1,  0 };
     37        const Cost Cost::reference = Cost{  0,  0,  0,  0,  0,  1 };
    3938
    4039#if 0
     
    179178                : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) {
    180179        }
    181 #if 0
     180
    182181/*
    183182            Old
     
    266265                "Each basic type kind should have a corresponding row in the cost matrix"
    267266        );
    268 #endif
    269 
    270         // GENERATED START, DO NOT EDIT
    271         /* EXTENDED INTEGRAL RANK HIERARCHY (root to leaves)
    272                                  _Bool
    273         char                signed char         unsigned char       
    274                   signed short int         unsigned short int       
    275                   signed int               unsigned int             
    276                   signed long int          unsigned long int       
    277                   signed long long int     unsigned long long int   
    278                   __int128                 unsigned __int128       
    279                   _Float16                 _Float16 _Complex       
    280                   _Float32                 _Float32 _Complex       
    281                   float                    float _Complex           
    282                   _Float32x                _Float32x _Complex       
    283                   _Float64                 _Float64 _Complex       
    284                   double                   double _Complex         
    285                   _Float64x                _Float64x _Complex       
    286                              __float80
    287                   _Float128                _Float128 _Complex       
    288                             __float128
    289                   long double              long double _Complex     
    290                   _Float128x               _Float128x _Complex     
    291         */
    292         // GENERATED END
    293 
    294         // GENERATED START, DO NOT EDIT
    295         static const int costMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
    296                 /*          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 */
    297                 /*     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,
    298                 /*     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,
    299                 /*    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,
    300                 /*    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,
    301                 /*    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,
    302                 /*   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,
    303                 /*     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,
    304                 /*    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,
    305                 /*    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,
    306                 /*   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,
    307                 /*   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,
    308                 /*  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,
    309                 /*    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,
    310                 /*   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,
    311                 /*   _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,
    312                 /*   _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,
    313                 /*    _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,
    314                 /*   _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,
    315                 /*     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,
    316                 /*    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,
    317                 /*   _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,
    318                 /*  _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,
    319                 /*    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,
    320                 /*  _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,
    321                 /*     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,
    322                 /*    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,
    323                 /*  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,
    324                 /* _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,
    325                 /*   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,
    326                 /*   _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,
    327                 /* _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,
    328                 /*    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,
    329                 /*    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,
    330                 /*   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,
    331                 /*  _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,
    332                 /*_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,
    333         }; // costMatrix
    334         // GENERATED END
    335         static_assert(
    336                 sizeof(costMatrix)/sizeof(costMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
    337                 "Missing row in the cost matrix"
    338         );
    339 
    340         // GENERATED START, DO NOT EDIT
    341         static const int signMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion
    342                 /*          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 */
    343                 /*     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,
    344                 /*     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,
    345                 /*    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,
    346                 /*    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,
    347                 /*    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,
    348                 /*   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,
    349                 /*     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,
    350                 /*    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,
    351                 /*    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,
    352                 /*   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,
    353                 /*   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,
    354                 /*  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,
    355                 /*    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,
    356                 /*   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,
    357                 /*   _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,
    358                 /*   _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,
    359                 /*    _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,
    360                 /*   _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,
    361                 /*     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,
    362                 /*    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,
    363                 /*   _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,
    364                 /*  _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,
    365                 /*    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,
    366                 /*  _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,
    367                 /*     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,
    368                 /*    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,
    369                 /*  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,
    370                 /* _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,
    371                 /*   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,
    372                 /*   _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,
    373                 /* _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,
    374                 /*    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,
    375                 /*    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,
    376                 /*   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,
    377                 /*  _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,
    378                 /*_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,
    379         }; // signMatrix
    380         // GENERATED END
    381         static_assert(
    382                 sizeof(signMatrix)/sizeof(signMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
    383                 "Missing row in the sign matrix"
    384         );
     267
    385268
    386269        void ConversionCost::postvisit( VoidType * ) {
     
    396279                                cost = Cost::zero;
    397280                                cost.incSafe( tableResult );
    398                                 cost.incSign( signMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ] );
    399281                        } // if
    400282                } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
     
    418300                                        // types are the same, except otherPointer has more qualifiers
    419301                                        cost = Cost::safe;
    420                                 } // if
     302                                }
    421303                        } else {
    422304                                int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env );
     
    540422                                cost = Cost::zero;
    541423                                cost.incSafe( tableResult + 1 );
    542                                 cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] );
    543                         } // if
     424                        }
    544425                } else if ( dynamic_cast< PointerType* >( dest ) ) {
    545426                        cost = Cost::safe;
    546                 } // if
     427                }
    547428        }
    548429
     
    558439                                cost = Cost::zero;
    559440                                cost.incSafe( tableResult + 1 );
    560                                 cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] );
    561                         } // if
    562                 } // if
     441                        }
     442                }
    563443        }
    564444} // namespace ResolvExpr
  • src/ResolvExpr/Cost.h

    r85d44c6 r6d01d89  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 09:39:50 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb  7 20:54:29 2019
    13 // Update Count     : 8
     11// Last Modified By : Aaron B. Moss
     12// Last Modified On : Fri Oct 05 14:32:00 2018
     13// Update Count     : 7
    1414//
    1515
     
    2121        class Cost {
    2222          private:
    23                 Cost( int unsafeCost, int polyCost, int safeCost, int signCost,
    24                         int varCost, int specCost, int referenceCost );
     23                Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost,
     24                        int referenceCost );
     25
    2526          public:
    2627                Cost & incUnsafe( int inc = 1 );
    2728                Cost & incPoly( int inc = 1 );
    2829                Cost & incSafe( int inc = 1 );
    29                 Cost & incSign( int inc = 1 );
    3030                Cost & incVar( int inc = 1 );
    3131                Cost & decSpec( int inc = 1 );
     
    3535                int get_polyCost() const { return polyCost; }
    3636                int get_safeCost() const { return safeCost; }
    37                 int get_signCost() const { return signCost; }
    3837                int get_varCost() const { return varCost; }
    3938                int get_specCost() const { return specCost; }
     
    4140
    4241                Cost operator+( const Cost &other ) const;
     42                Cost operator-( const Cost &other ) const;
    4343                Cost &operator+=( const Cost &other );
    4444                bool operator<( const Cost &other ) const;
     
    5555                static const Cost poly;
    5656                static const Cost safe;
    57                 static const Cost sign;
    5857                static const Cost var;
    5958                static const Cost spec;
     
    6463                int polyCost;       ///< Count of parameters and return values bound to some poly type
    6564                int safeCost;       ///< Safe (widening) conversions
    66                 int signCost;       ///< Count of safe sign conversions
    6765                int varCost;        ///< Count of polymorphic type variables
    6866                int specCost;       ///< Polymorphic type specializations (type assertions), negative cost
     
    7068        };
    7169
    72         inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int signCost,
    73                         int varCost, int specCost, int referenceCost )
    74                 : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), signCost( signCost ),
    75                   varCost( varCost ), specCost( specCost ), referenceCost( referenceCost ) {}
     70        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost,
     71                        int referenceCost )
     72                : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), varCost( varCost ),
     73                  specCost( specCost ), referenceCost( referenceCost ) {}
    7674
    7775        inline Cost & Cost::incUnsafe( int inc ) {
     
    9088                if ( *this == infinity ) return *this;
    9189                safeCost += inc;
    92                 return *this;
    93         }
    94 
    95         inline Cost & Cost::incSign( int inc ) {
    96                 if ( *this == infinity ) return *this;
    97                 signCost += inc;
    9890                return *this;
    9991        }
     
    119111        inline Cost Cost::operator+( const Cost &other ) const {
    120112                if ( *this == infinity || other == infinity ) return infinity;
    121                 return Cost{
    122                         unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost,
    123                         signCost + other.signCost, varCost + other.varCost, specCost + other.specCost,
     113                return Cost{ 
     114                        unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, 
     115                        varCost + other.varCost, specCost + other.specCost,
    124116                        referenceCost + other.referenceCost };
     117        }
     118
     119        inline Cost Cost::operator-( const Cost &other ) const {
     120                if ( *this == infinity || other == infinity ) return infinity;
     121                return Cost{
     122                        unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost,
     123                        varCost - other.varCost, specCost - other.specCost,
     124                        referenceCost - other.referenceCost };
    125125        }
    126126
     
    134134                polyCost += other.polyCost;
    135135                safeCost += other.safeCost;
    136                 signCost += other.signCost;
    137136                varCost += other.varCost;
    138137                specCost += other.specCost;
     
    157156                } else if ( safeCost < other.safeCost ) {
    158157                        return true;
    159                 } else if ( signCost > other.signCost ) {
    160                         return false;
    161                 } else if ( signCost < other.signCost ) {
    162                         return true;
    163158                } else if ( varCost > other.varCost ) {
    164159                        return false;
     
    185180                c = polyCost - other.polyCost; if ( c ) return c;
    186181                c = safeCost - other.safeCost; if ( c ) return c;
    187                 c = signCost - other.signCost; if ( c ) return c;
    188182                c = varCost - other.varCost; if ( c ) return c;
    189183                c = specCost - other.specCost; if ( c ) return c;
     
    195189                        && polyCost == other.polyCost
    196190                        && safeCost == other.safeCost
    197                         && signCost == other.signCost
    198191                        && varCost == other.varCost
    199192                        && specCost == other.specCost
     
    206199
    207200        inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
    208                 return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", "
    209                           << cost.safeCost << ", " << cost.signCost << ", "
    210                                   << cost.varCost << ", " << cost.specCost << ", "
     201                return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", "
     202                          << cost.safeCost << ", " << cost.varCost << ", " << cost.specCost << ", "
    211203                          << cost.referenceCost << " )";
    212204        }
  • src/ResolvExpr/Resolver.cc

    r85d44c6 r6d01d89  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 12:17:01 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 18:13:43 2019
    13 // Update Count     : 216
     11// Last Modified By : Aaron B. Moss
     12// Last Modified On : Fri Oct 05 09:43:00 2018
     13// Update Count     : 214
    1414//
    1515
  • src/ResolvExpr/typeops.h

    r85d44c6 r6d01d89  
    1010// Created On       : Sun May 17 07:28:22 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  8 09:30:34 2019
    13 // Update Count     : 4
     12// Last Modified On : Sat Jul 22 09:36:18 2017
     13// Update Count     : 3
    1414//
    1515
     
    101101
    102102        // in CommonType.cc
    103         Type * commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
     103        Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
    104104
    105105        // in PolyCost.cc
  • src/SymTab/ManglerCommon.cc

    r85d44c6 r6d01d89  
    1010// Created On       : Sun May 17 21:44:03 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 14 08:12:17 2019
    13 // Update Count     : 25
     12// Last Modified On : Sat Jul 22 09:45:30 2017
     13// Update Count     : 15
    1414//
    1515
     
    2222                namespace Encoding {
    2323                        const std::string manglePrefix = "_X";
    24 #if 0
     24
    2525                        const std::string basicTypes[] = {
    2626                                "b",  // Bool
     
    4343                                "Ce", // LongDoubleComplex
    4444                                // Note: imaginary is not an overloadable type in C++
    45                                 // "If", // FloatImaginary
    46                                 // "Id", // DoubleImaginary
    47                                 // "Ie", // LongDoubleImaginary
     45                                "If", // FloatImaginary
     46                                "Id", // DoubleImaginary
     47                                "Ie", // LongDoubleImaginary
    4848                                "n",  // SignedInt128
    4949                                "o",  // UnsignedInt128
     
    6363                                "Each basic type kind should have a corresponding mangler letter"
    6464                        );
    65 #endif
    66                         // GENERATED START, DO NOT EDIT
    67                         // NOTES ON MANGLING:
    68                         // * Itanium spec says that Float80 encodes to "e" (like LongDouble), but the distinct lengths cause resolution problems.
    69                         // * Float128 is supposed to encode to "g", but I wanted it to mangle equal to LongDouble.
    70                         // * Mangling for non-standard complex types is by best guess
    71                         // * _FloatN is supposed to encode as "DF"N"_"; modified for same reason as above.
    72                         // * unused mangling identifiers:
    73                         //   - "z" ellipsis
    74                         //   - "Dd" IEEE 754r 64-bit decimal floating point (borrowed for _Float32x)
    75                         //   - "De" IEEE 754r 128-bit decimal floating point
    76                         //   - "Df" IEEE 754r 32-bit decimal floating point
    77                         //   - "Dh" IEEE 754r 16-bit decimal floating point (borrowed for _Float16)
    78                         //   - "DF"N"_" ISO/IEC TS 18661 N-bit binary floating point (_FloatN)
    79                         //   - "Di" char32_t
    80                         //   - "Ds" char16_t
    81                         const std::string basicTypes[BasicType::NUMBER_OF_BASIC_TYPES] = {
    82                                 "b",        // _Bool
    83                                 "c",        // char
    84                                 "a",        // signed char
    85                                 "h",        // unsigned char
    86                                 "s",        // signed short int
    87                                 "t",        // unsigned short int
    88                                 "i",        // signed int
    89                                 "j",        // unsigned int
    90                                 "l",        // signed long int
    91                                 "m",        // unsigned long int
    92                                 "x",        // signed long long int
    93                                 "y",        // unsigned long long int
    94                                 "n",        // __int128
    95                                 "o",        // unsigned __int128
    96                                 "DF16_",    // _Float16
    97                                 "CDF16_",   // _Float16 _Complex
    98                                 "DF32_",    // _Float32
    99                                 "CDF32_",   // _Float32 _Complex
    100                                 "f",        // float
    101                                 "Cf",       // float _Complex
    102                                 "DF32x_",   // _Float32x
    103                                 "CDF32x_",  // _Float32x _Complex
    104                                 "DF64_",    // _Float64
    105                                 "CDF64_",   // _Float64 _Complex
    106                                 "d",        // double
    107                                 "Cd",       // double _Complex
    108                                 "DF64x_",   // _Float64x
    109                                 "CDF64x_",  // _Float64x _Complex
    110                                 "Dq",       // __float80
    111                                 "DF128_",   // _Float128
    112                                 "CDF128_",  // _Float128 _Complex
    113                                 "g",        // __float128
    114                                 "e",        // long double
    115                                 "Ce",       // long double _Complex
    116                                 "DF128x_",  // _Float128x
    117                                 "CDF128x_", // _Float128x _Complex
    118                         }; // basicTypes
    119                         // GENERATED END
    12065
    12166                        const std::map<int, std::string> qualifiers = {
  • src/SynTree/BasicType.cc

    r85d44c6 r6d01d89  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 31 21:37:36 2019
    13 // Update Count     : 12
     12// Last Modified On : Mon Sep 25 14:14:03 2017
     13// Update Count     : 11
    1414//
    1515
     
    3030
    3131bool BasicType::isInteger() const {
    32         return kind <= UnsignedInt128;
    33 #if 0
    3432        switch ( kind ) {
    3533          case Bool:
     
    6563        assert( false );
    6664        return false;
    67 #endif
    6865}
    6966
  • src/SynTree/Constant.cc

    r85d44c6 r6d01d89  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 18:11:22 2019
    13 // Update Count     : 32
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Spt 28 14:49:00 2018
     13// Update Count     : 30
    1414//
    1515
  • src/SynTree/Type.cc

    r85d44c6 r6d01d89  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 31 21:54:16 2019
    13 // Update Count     : 43
     12// Last Modified On : Fri Jun 22 10:17:19 2018
     13// Update Count     : 39
    1414//
    1515#include "Type.h"
     
    2525
    2626const char *BasicType::typeNames[] = {
    27 #if 0
    2827        "_Bool",
    2928        "char",
     
    5049        "unsigned __int128",
    5150        "__float80",
    52         "__float128",
    53         "_Float16",
    54         "_Float32",
    55         "_Float32x",
    56         "_Float64",
    57         "_Float64x",
    58         "_Float128",
    59         "_Float128x",
    60         "_Float16 _Complex",
    61         "_Float32 _Complex",
    62         "_Float32x _Complex",
    63         "_Float64 _Complex",
    64         "_Float64x _Complex",
    65         "_Float128 _Complex",
    66         "_Float128x _Complex",
    67 #endif
    68         "_Bool",
    69         "char",
    70         "signed char",
    71         "unsigned char",
    72         "signed short int",
    73         "unsigned short int",
    74         "signed int",
    75         "unsigned int",
    76         "signed long int",
    77         "unsigned long int",
    78         "signed long long int",
    79         "unsigned long long int",
    80         "__int128",
    81         "unsigned __int128",
    82         "_Float16",
    83         "_Float16 _Complex",
    84         "_Float32",
    85         "_Float32 _Complex",
    86         "float",
    87         "float _Complex",
    88         //"float _Imaginary",
    89         "_Float32x",
    90         "_Float32x _Complex",
    91         "_Float64",
    92         "_Float64 _Complex",
    93         "double",
    94         "double _Complex",
    95         //"double _Imaginary",
    96         "_Float64x",
    97         "_Float64x _Complex",
    98         "__float80",
    99         "_Float128",
    100         "_Float128 _Complex",
    101         "__float128",
    102         "long double",
    103         "long double _Complex",
    104         //"long double _Imaginary",
    105         "_Float128x",
    106         "_Float128x _Complex",
     51        "__float128"
    10752};
    10853static_assert(
  • src/SynTree/Type.h

    r85d44c6 r6d01d89  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 18:10:45 2019
    13 // Update Count     : 167
     12// Last Modified On : Mon Sep 25 14:14:01 2017
     13// Update Count     : 154
    1414//
    1515
     
    207207class BasicType : public Type {
    208208  public:
    209 #if 0
    210209        enum Kind {
    211210                Bool,
     
    234233                Float80,
    235234                Float128,
    236                 _Float16,
    237                 _Float32,
    238                 _Float32x,
    239                 _Float64,
    240                 _Float64x,
    241                 _Float128,
    242                 _Float128x,
    243                 _Float16Complex,
    244                 _Float32Complex,
    245                 _Float32xComplex,
    246                 _Float64Complex,
    247                 _Float64xComplex,
    248                 _Float128Complex,
    249                 _Float128xComplex,
    250                 NUMBER_OF_BASIC_TYPES
    251         } kind;
    252 #endif
    253         enum Kind {
    254                 Bool,
    255                 Char,
    256                 SignedChar,
    257                 UnsignedChar,
    258                 ShortSignedInt,
    259                 ShortUnsignedInt,
    260                 SignedInt,
    261                 UnsignedInt,
    262                 LongSignedInt,
    263                 LongUnsignedInt,
    264                 LongLongSignedInt,
    265                 LongLongUnsignedInt,
    266                 SignedInt128,
    267                 UnsignedInt128,
    268                 uFloat16,
    269                 uFloat16Complex,
    270                 uFloat32,
    271                 uFloat32Complex,
    272                 Float,
    273                 FloatComplex,
    274                 // FloatImaginary,
    275                 uFloat32x,
    276                 uFloat32xComplex,
    277                 uFloat64,
    278                 uFloat64Complex,
    279                 Double,
    280                 DoubleComplex,
    281                 // DoubleImaginary,
    282                 uFloat64x,
    283                 uFloat64xComplex,
    284                 uuFloat80,
    285                 uFloat128,
    286                 uFloat128Complex,
    287                 uuFloat128,
    288                 LongDouble,
    289                 LongDoubleComplex,
    290                 // LongDoubleImaginary,
    291                 uFloat128x,
    292                 uFloat128xComplex,
    293235                NUMBER_OF_BASIC_TYPES
    294236        } kind;
  • src/Tuples/TupleExpansion.cc

    r85d44c6 r6d01d89  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 18:14:12 2019
    13 // Update Count     : 21
     12// Last Modified On : Wed Jun 21 17:35:04 2017
     13// Update Count     : 19
    1414//
    1515
  • tests/.expect/castError.txt

    r85d44c6 r6d01d89  
    44... to:
    55  char Alternatives are:
    6 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Cast of:
     6Cost ( 1, 0, 0, 0, 0, 0 ): Cast of:
    77     Variable Expression: f: function
    88       accepting unspecified arguments
     
    1616 Environment:
    1717
    18 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Cast of:
     18Cost ( 1, 0, 0, 0, 0, 0 ): Cast of:
    1919     Variable Expression: f: double
    2020   ... to:
     
    2525 Environment:
    2626
    27 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Cast of:
     27Cost ( 1, 0, 0, 0, 0, 0 ): Cast of:
    2828     Variable Expression: f: signed int
    2929   ... to:
  • tests/.expect/completeTypeError.txt

    r85d44c6 r6d01d89  
    4545
    4646Alternatives with failing assertions are:
    47 Cost ( 0, 1, 0, 0, 1, -5, 0 ): Application of
     47Cost ( 0, 1, 0, 1, -5, 0 ): Application of
    4848     Variable Expression: baz: forall
    4949       T: sized object type
  • tests/literals.cfa

    r85d44c6 r6d01d89  
    1010// Created On       : Sat Sep  9 16:34:38 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb 12 08:07:39 2019
    13 // Update Count     : 224
    14 //
    15 
    16 #include <features.h>                                                                   // __GNUC_PREREQ
     12// Last Modified On : Tue Dec  4 21:44:01 2018
     13// Update Count     : 139
     14//
     15
    1716#ifdef __CFA__
     17#include <stdint.h>
    1818#include <fstream.hfa>
    1919
     
    151151        -0X0123456789.0123456789P-09;  -0X0123456789.0123456789P-09f;  -0X0123456789.0123456789P-09l;  -0X0123456789.0123456789P-09F;  -0X0123456789.0123456789P-09L;
    152152
    153 #if defined(__GNUC__) && __GNUC_PREREQ(7,0)                             // gcc version >= 7
    154 // floating with length, gcc f16/f128x unsupported and no prelude code for any _FloatXXx, so they work by conversion to long double
    155 
    156         /*  0123456789.f16; */   0123456789.f32;   0123456789.f32x;   0123456789.f64;   0123456789.f64x;   0123456789.W;   0123456789.f128;   0123456789.q;  /*  0123456789.f128x; */
    157         /* +0123456789.f16; */  +0123456789.f32;  +0123456789.f32x;  +0123456789.f64;  +0123456789.f64x;  +0123456789.w;  +0123456789.f128;  +0123456789.Q;  /* +0123456789.f128x; */
    158         /* -0123456789.f16; */  -0123456789.f32;  -0123456789.f32x;  -0123456789.f64;  -0123456789.f64x;  -0123456789.W;  -0123456789.f128;  -0123456789.q;  /* -0123456789.f128x; */
    159 
    160         /*  0123456789.e09F16; */    0123456789.e09F32;    0123456789.e09F32x;    0123456789.e09F64;    0123456789.e09F64x;    0123456789.e09W;    0123456789.e09F128;    0123456789.e09q;   /*  .0123456789e09q; */
    161         /* +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; */
    162         /* -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; */
    163 
    164         /*  .0123456789e09F16; */    .0123456789e09F32;    .0123456789e09F32x;    .0123456789e09F64;    .0123456789e09F64x;    .0123456789e09W;    .0123456789e09F128;    .0123456789e09q;   /*  .0123456789e09q; */
    165         /* +.0123456789e+09F16; */  +.0123456789e+09F32;  +.0123456789e+09F32x;  +.0123456789e+09F64;  +.0123456789e+09F64x;  +.0123456789e+09w;  +.0123456789e+09F128;  +.0123456789e+09Q;  /* +.0123456789E+09Q; */
    166         /* -.0123456789e-09F16; */  -.0123456789e-09F32;  -.0123456789e-09F32x;  -.0123456789e-09F64;  -.0123456789e-09F64x;  -.0123456789e-09W;  -.0123456789e-09F128;  -.0123456789e-09q;  /* -.0123456789E-09q; */
    167 
    168         /*  0123456789.0123456789F16; */   0123456789.0123456789F32;   0123456789.0123456789F32x;   0123456789.0123456789F64;   0123456789.0123456789F64x;   0123456789.0123456789W;   0123456789.0123456789F128;   0123456789.0123456789q;  /*  0123456789.0123456789q; */
    169         /* +0123456789.0123456789F16; */  +0123456789.0123456789F32;  +0123456789.0123456789F32x;  +0123456789.0123456789F64;  +0123456789.0123456789F64x;  +0123456789.0123456789w;  +0123456789.0123456789F128;  +0123456789.0123456789Q;  /* +0123456789.0123456789Q; */
    170         /* -0123456789.0123456789F16; */  -0123456789.0123456789F32;  -0123456789.0123456789F32x;  -0123456789.0123456789F64;  -0123456789.0123456789F64x;  -0123456789.0123456789W;  -0123456789.0123456789F128;  -0123456789.0123456789q;  /* -0123456789.0123456789q; */
    171 
    172         /*  0123456789.0123456789E09F16; */    0123456789.0123456789E09F32;    0123456789.0123456789E09F32x;    0123456789.0123456789E09F64;    0123456789.0123456789E09F64x;    0123456789.0123456789E09W;    0123456789.0123456789E09F128;    0123456789.0123456789E09q;   /*  0123456789.0123456789E09q; */
    173         /* +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; */
    174         /* -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; */
    175 
    176         /*  0x123456789.p09f16; */    0x123456789.p09f32;    0x123456789.p09f32x;    0x123456789.p09f64;    0x123456789.p09f64x;    0x123456789.p09W;    0x123456789.p09f128;    0x123456789.p09q;   /*  0x123456789.p09f128x; */
    177         /* +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; */
    178         /* -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; */
    179 
    180         /*  0x123456789.p09F16; */    0x123456789.p09F32;    0x123456789.p09F32x;    0x123456789.p09F64;    0x123456789.p09F64x;    0x123456789.p09W;    0x123456789.p09F128;    0x123456789.p09q;   /*  .0123456789p09q; */
    181         /* +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; */
    182         /* -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; */
    183 
    184         /*  0X.0123456789p09F16; */    0X.0123456789p09F32;    0X.0123456789p09F32x;    0X.0123456789p09F64;    0X.0123456789p09F64x;    0X.0123456789p09W;    0X.0123456789p09F128;    0X.0123456789p09q;   /*  0X.0123456789p09q; */
    185         /* +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; */
    186         /* -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; */
    187 
    188         /*  0x123456789.0123456789P09F16; */    0x123456789.0123456789P09F32;    0x123456789.0123456789P09F32x;    0x123456789.0123456789P09F64;    0x123456789.0123456789P09F64x;    0x123456789.0123456789P09W;    0x123456789.0123456789P09F128;    0x123456789.0123456789P09q;   /*  0x123456789.0123456789P09q; */
    189         /* +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; */
    190         /* -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; */
    191 
    192         /*  0x123456789.0123456789P09F16; */    0x123456789.0123456789P09F32;    0x123456789.0123456789P09F32x;    0x123456789.0123456789P09F64;    0x123456789.0123456789P09F64x;    0x123456789.0123456789P09W;    0x123456789.0123456789P09F128;    0x123456789.0123456789P09q;   /*  0x123456789.0123456789P09q; */
    193         /* +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; */
    194         /* -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; */
    195 #endif // __GNUC_PREREQ(7,0)
    196 
    197153#ifdef __CFA__
    198154// fixed-size length
     
    211167        // octal
    212168         01234567_l8;   01234567_l16;   01234567_l32;   01234567_l64;   01234567_l8u;   01234567_ul16;   01234567_l32u;   01234567_ul64;
    213         +01234567_l8;  +01234567_l16;  +01234567_l32;  +01234567_l64;  +01234567_ul8;  +01234567_ul16;  +01234567_l32u;  +01234567_ul64;
     169        +01234567_l8;  +01234567_l16;  +01234567_l32;  +01234567_l64;  +01234567_l8u;  +01234567_ul16;  +01234567_l32u;  +01234567_ul64;
    214170        -01234567_l8;  -01234567_l16;  -01234567_l32;  -01234567_l64;  -01234567_l8u;  -01234567_ul16;  -01234567_l32u;  -01234567_ul64;
    215171
     
    247203        +0X0123456789ABCDEF_l8;  +0X0123456789ABCDEF_l16;  +0X0123456789ABCDEFl32;  +0X0123456789ABCDEFl64;  +0X0123456789ABCDEF_ul8;  +0X0123456789ABCDEF_l16u;  +0X0123456789ABCDEFul32;  +0X0123456789ABCDEFl64u;
    248204        -0X0123456789ABCDEF_l8;  -0X0123456789ABCDEF_l16;  -0X0123456789ABCDEFl32;  -0X0123456789ABCDEFl64;  -0X0123456789ABCDEF_ul8;  -0X0123456789ABCDEF_l16u;  -0X0123456789ABCDEFul32;  -0X0123456789ABCDEFl64u;
     205
     206        // floating
     207         0123456789.l32;   0123456789.l64;   0123456789.l80;   0123456789.l128;
     208        +0123456789.l32;  +0123456789.l64;  +0123456789.l80;  +0123456789.l128;
     209        -0123456789.l32;  -0123456789.l64;  -0123456789.l80;  -0123456789.l128;
     210
     211         0123456789.e09L32;    0123456789.e09L64;    0123456789.e09L80;    0123456789.e09L128;
     212        +0123456789.e+09L32;  +0123456789.e+09L64;  +0123456789.e+09L80;  +0123456789.e+09L128;
     213        -0123456789.e-09L32;  -0123456789.e-09L64;  -0123456789.e-09L80;  -0123456789.e-09L128;
     214
     215         .0123456789e09L32;    .0123456789e09L64;    .0123456789e09L80;    .0123456789e09L128;
     216        +.0123456789E+09L32;  +.0123456789E+09L64;  +.0123456789E+09L80;  +.0123456789E+09L128;
     217        -.0123456789E-09L32;  -.0123456789E-09L64;  -.0123456789E-09L80;  -.0123456789E-09L128;
     218
     219         0123456789.0123456789L32;       0123456789.0123456789L64;       0123456789.0123456789L80;       0123456789.0123456789L128;
     220        +0123456789.0123456789E09L32;   +0123456789.0123456789E09L64;   +0123456789.0123456789E09L80;   +0123456789.0123456789E09L128;
     221        -0123456789.0123456789E+09L32;  -0123456789.0123456789E+09L64;  -0123456789.0123456789E+09L80;  -0123456789.0123456789E+09L128;
     222         0123456789.0123456789E-09L32;   0123456789.0123456789E-09L64;   0123456789.0123456789E-09L80;   0123456789.0123456789E-09L128;
     223
     224         0x0123456789.p09l32;   0x0123456789.p09l64;   0x0123456789.p09l80;   0x0123456789.p09l128;
     225        +0x0123456789.p09l32;  +0x0123456789.p09l64;  +0x0123456789.p09l80;  +0x0123456789.p09l128;
     226        -0x0123456789.p09l32;  -0x0123456789.p09l64;  -0x0123456789.p09l80;  -0x0123456789.p09l128;
     227
     228         0x0123456789.p+09l32;   0x0123456789.p+09L64;   0x0123456789.p+09L80;   0x0123456789.p+09L128;
     229        +0x0123456789.p-09l32;  +0x0123456789.p-09L64;  +0x0123456789.p-09L80;  +0x0123456789.p-09L128;
     230        -0x.0123456789p09l32;   -0x.0123456789p09L64;   -0x.0123456789p09L80;   -0x.0123456789p09L128;
    249231
    250232// char, short, int suffix overloading
  • tests/numericConstants.cfa

    r85d44c6 r6d01d89  
    1010// Created On       : Wed May 24 22:10:36 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  5 08:58:16 2019
    13 // Update Count     : 5
     12// Last Modified On : Tue Nov  6 17:59:53 2018
     13// Update Count     : 3
    1414//
    1515
     
    6767// Local Variables: //
    6868// tab-width: 4 //
    69 // compile-command: "cfa numericConstants.cfa" //
     69// compile-command: "cfa minmax.cfa" //
    7070// End: //
  • tests/sum.cfa

    r85d44c6 r6d01d89  
    1111// Created On       : Wed May 27 17:56:53 2015
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Sat Feb  9 15:38:48 2019
    14 // Update Count     : 293
     13// Last Modified On : Sun Dec 23 23:00:38 2018
     14// Update Count     : 287
    1515//
    1616
    1717#include <fstream.hfa>
    1818#include <stdlib.hfa>
     19
     20void ?{}( int & c, zero_t ) { c = 0; }                                  // not in prelude
    1921
    2022trait sumable( otype T ) {
     
    4244// Not in prelude.
    4345void ?{}( unsigned char & c, zero_t ) { c = 0; }
    44 void ?{}( int & i, zero_t ) { i = 0; }
    4546void ?{}( float & f, zero_t ) { f = 0.0; }
    4647void ?{}( double & d, zero_t ) { d = 0.0; }
Note: See TracChangeset for help on using the changeset viewer.