Changeset 85d44c6


Ignore:
Timestamp:
Feb 14, 2019, 10:23:51 PM (3 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, persistent-indexer
Children:
fba51ab
Parents:
6d01d89 (diff), e15853c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

fix conflict

Files:
26 edited

Legend:

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

    r6d01d89 r85d44c6  
    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

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

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

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

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

    r6d01d89 r85d44c6  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jun  4 21:24:45 2018
    13 // Update Count     : 802
     12// Last Modified On : Wed Feb 13 18:07:38 2019
     13// Update Count     : 902
    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 checkL( char c ) { return c == 'l' || c == 'L'; }
    55 static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; }
    56 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
     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'; }
    5756static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
    5857static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
     58static inline bool checkF80( char c ) { return c == 'w' || c == 'W'; }
     59static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
     60static inline bool checkF128( char c ) { return c == 'q' || c == 'Q'; }
    5961static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
    6062static inline bool checkB( char c ) { return c == 'b' || c == 'B'; }
    6163static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
    6264
    63 static 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 
    68 static 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 
    9665Expression * build_constantInteger( string & str ) {
    9766        static const BasicType::Kind kind[2][6] = {
    98                 // short (h) must be before char (hh)
     67                // short (h) must be before char (hh) because shorter type has the longer suffix
    9968                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, },
    10069                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, },
    10170        };
    10271
     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
    10377        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
    104         int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
    105         int lnth = -1;                                                                          // literal length
     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
    10680
    10781        unsigned long long int v;                                                       // converted integral value
     
    127101                        //printf( "%llx %llu\n", v, v );
    128102                } else if ( checkB( str[1] ) ) {                                // binary constant ?
    129                         v = 0;
    130                         for ( unsigned int i = 2;; i += 1 ) {           // compute value
     103                        v = 0;                                                                          // compute value
     104                        for ( unsigned int i = 2;; ) {
    131105                                if ( str[i] == '1' ) v |= 1;
    132                           if ( i == last ) break;
     106                                i += 1;
     107                          if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
    133108                                v <<= 1;
    134109                        } // for
    135                         //printf( "%llx %llu\n", v, v );
     110                        //printf( "%#llx %llu\n", v, v );
    136111                } else {                                                                                // octal constant
    137112                        sscanf( (char *)str.c_str(), "%llo", &v );
    138                         //printf( "%llo %llu\n", v, v );
     113                        //printf( "%#llo %llu\n", v, v );
    139114                } // if
    140115        } else {                                                                                        // decimal constant ?
     
    143118        } // if
    144119
    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 
    162120        // At least one digit in integer constant, so safe to backup while looking for suffix.
    163121
    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;
     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 );
    170155                        } // if
    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 );
     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 );
    209180        // Constant type is correct for overload resolving.
    210         ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
    211         if ( Unsigned && size < 2 ) {                                           // hh or h, less than int ?
     181        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][type] ), str, v ) );
     182        if ( Unsigned && type < 2 ) {                                           // hh or h, less than int ?
    212183                // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
    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 );
     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 );
    218189                } else {
    219                         ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ), false );
     190                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false );
    220191                } // if
    221192        } // if
     
    227198
    228199
    229 static inline void checkLNFloat( string & str, int & lnth, int & size ) {
    230         string::size_type posn = str.find_first_of( "lL" ), start = posn;
     200static 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
    231209  if ( posn == string::npos ) return;
    232         size = 2;                                                                                       // assume largest size
    233         lnth = 0;
     210        explnth = true;
    234211        posn += 1;                                                                                      // advance to size
    235212        if ( str[posn] == '3' ) {                                                       // 32
    236                 size = 0;
     213                if ( str[last] != 'x' ) type = 6;
     214                else type = 7;
    237215        } else if ( str[posn] == '6' ) {                                        // 64
    238                 size = 1;
    239         } else if ( str[posn] == '8' || str[posn] == '1' ) { // 80, 128
    240                 size = 2;
    241                 if ( str[posn] == '1' ) posn += 1;
     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
    242227        } else {
    243228                assertf( false, "internal error, bad floating point length %s", str.c_str() );
    244229        } // if
    245         posn += 1;
    246         str.erase( start, posn - start + 1 );                           // remove length suffix
    247 } // checkLNFloat
     230} // checkFnxFloat
    248231
    249232
    250233Expression * build_constantFloat( string & str ) {
    251         static const BasicType::Kind kind[2][3] = {
    252                 { BasicType::Float, BasicType::Double, BasicType::LongDouble },
    253                 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
     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 },
    254237        };
    255238
    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
     239        // floating-point constant has minimum of 2 characters 1. or .1
    260240        size_t last = str.length() - 1;
    261241        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
    262245
    263246        sscanf( str.c_str(), "%lg", &v );
     
    269252
    270253        if ( checkF( str[last] ) ) {                                            // float ?
    271                 size = 0;
     254                type = 0;
    272255        } else if ( checkD( str[last] ) ) {                                     // double ?
    273                 size = 1;
     256                type = 1;
    274257        } else if ( checkL( str[last] ) ) {                                     // long double ?
    275                 size = 2;
     258                type = 2;
     259        } else if ( checkF80( str[last] ) ) {                           // __float80 ?
     260                type = 3;
     261        } else if ( checkF128( str[last] ) ) {                          // __float128 ?
     262                type = 4;
    276263        } else {
    277                 size = 1;                                                                               // double (default)
    278                 checkLNFloat( str, lnth, size );
    279         } // if
     264                type = 1;                                                                               // double (default if no suffix)
     265                checkFnxFloat( str, last, explnth, type );
     266        } // if
     267
    280268        if ( ! complx && checkI( str[last - 1] ) ) {            // imaginary ?
    281269                complx = true;
    282270        } // if
    283271
    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 );
     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 );
    288276        } // if
    289277
  • src/Parser/ParseNode.h

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

    r6d01d89 r85d44c6  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Nov  2 07:54:26 2018
    13 // Update Count     : 624
     12// Last Modified On : Wed Feb 13 18:16:23 2019
     13// Update Count     : 649
    1414//
    1515
     
    666666
    667667          case DeclarationNode::Float:
    668           case DeclarationNode::Float80:
    669           case DeclarationNode::Float128:
    670668          case DeclarationNode::Double:
    671669          case DeclarationNode::LongDouble:                                     // not set until below
    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 },
     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, },
    676682                };
    677683
     
    686692                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
    687693                } // 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
    688700                if ( td->length == DeclarationNode::Long ) {
    689701                        const_cast<TypeData *>(td)->basictype = DeclarationNode::LongDouble;
    690702                } // if
    691703
    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 
    701704                ret = floattype[ td->complextype ][ td->basictype - DeclarationNode::Float ];
     705                //printf( "XXXX %d %d %d %d\n", td->complextype, td->basictype, DeclarationNode::Float, ret );
    702706                break;
    703707
  • src/Parser/lex.ll

    r6d01d89 r85d44c6  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Thu Nov  1 20:57:35 2018
    13  * Update Count     : 687
     12 * Last Modified On : Wed Feb 13 17:33:53 2019
     13 * Update Count     : 702
    1414 */
    1515
     
    3939using namespace std;
    4040
     41#include "config.h"                                                                             // configure info
    4142#include "ParseNode.h"
    4243#include "TypedefTable.h"
     
    5960#define IDENTIFIER_RETURN()     RETURN_VAL( typedefTable.isKind( yytext ) )
    6061#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
    6168
    6269void rm_underscore() {
     
    112119                                // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
    113120exponent "_"?[eE]"_"?[+-]?{decimal_digits}
    114 floating_size 32|64|80|128
    115 floating_length ([fFdDlL]|[lL]{floating_size})
     121floating_size 16|32|32x|64|64x|80|128|128x
     122floating_length ([fFdDlLwWqQ]|[fF]{floating_size})
    116123floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length})
    117124floating_suffix_opt ("_"?({floating_suffix}|"DL"))?
     
    240247finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
    241248float                   { KEYWORD_RETURN(FLOAT); }
    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
    247 float80                 { KEYWORD_RETURN(FLOAT80); }                    // GCC
    248 _Float128               { KEYWORD_RETURN(FLOAT128); }                   // GCC
    249 _Float128x              { KEYWORD_RETURN(FLOAT128); }                   // GCC
    250 __float128              { KEYWORD_RETURN(FLOAT128); }                   // GCC
    251 float128                { KEYWORD_RETURN(FLOAT128); }                   // GCC
     249__float80               { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
     250float80                 { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
     251__float128              { KEYWORD_RETURN(uuFLOAT128); }                 // GCC
     252float128                { 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
    252260for                             { KEYWORD_RETURN(FOR); }
    253261forall                  { KEYWORD_RETURN(FORALL); }                             // CFA
  • src/Parser/parser.yy

    r6d01d89 r85d44c6  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 14 18:02:44 2019
    13 // Update Count     : 4216
     12// Last Modified On : Thu Feb 14 22:23:13 2019
     13// Update Count     : 4217
    1414//
    1515
     
    267267%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
    268268%token BOOL COMPLEX IMAGINARY                                                   // C99
    269 %token INT128 FLOAT80 FLOAT128                                                  // GCC
     269%token INT128 uuFLOAT80 uuFLOAT128                                              // GCC
     270%token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC
    270271%token ZERO_T ONE_T                                                                             // CFA
    271272%token VALIST                                                                                   // GCC
     
    17731774        | FLOAT
    17741775                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    1775         | FLOAT80
    1776                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); }
    1777         | FLOAT128
    1778                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); }
    17791776        | DOUBLE
    17801777                { $$ = 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 ); }
    17811794        | COMPLEX                                                                                       // C99
    17821795                { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
  • src/ResolvExpr/CommonType.cc

    r6d01d89 r85d44c6  
    1010// Created On       : Sun May 17 06:59:27 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 25 15:18:17 2017
    13 // Update Count     : 9
     12// Last Modified On : Wed Feb 13 22:30:32 2019
     13// Update Count     : 22
    1414//
    1515
     
    175175                return result;
    176176        }
    177 
     177#if 0
     178        #define BT BasicType::
    178179        static const BasicType::Kind combinedType[][ BasicType::NUMBER_OF_BASIC_TYPES ] =
    179180        {
    180181/*              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 */
    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 },
     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 },
    206225        };
     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
    207495        static_assert(
    208                 sizeof(combinedType)/sizeof(combinedType[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
     496                sizeof(commonTypes)/sizeof(commonTypes[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
    209497                "Each basic type kind should have a corresponding row in the combined type matrix"
    210498        );
     
    218506        void CommonType::postvisit( BasicType *basicType ) {
    219507                if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
    220                         BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ];
     508                        BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ otherBasic->get_kind() ];
    221509                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= otherBasic->get_qualifiers() ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->get_qualifiers() <= otherBasic->get_qualifiers() ) || widenSecond ) ) {
    222510                                result = new BasicType( basicType->get_qualifiers() | otherBasic->get_qualifiers(), newType );
     
    224512                } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
    225513                        // use signed int in lieu of the enum/zero/one type
    226                         BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
     514                        BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ];
    227515                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) {
    228516                                result = new BasicType( basicType->get_qualifiers() | type2->get_qualifiers(), newType );
  • src/ResolvExpr/ConversionCost.cc

    r6d01d89 r85d44c6  
    1010// Created On       : Sun May 17 07:06:19 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 25 15:43:34 2017
    13 // Update Count     : 10
     12// Last Modified On : Wed Feb 13 23:04:51 2019
     13// Update Count     : 22
    1414//
    1515
     
    2828
    2929namespace ResolvExpr {
    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 };
     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 };
    3839
    3940#if 0
     
    178179                : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) {
    179180        }
    180 
     181#if 0
    181182/*
    182183            Old
     
    265266                "Each basic type kind should have a corresponding row in the cost matrix"
    266267        );
    267 
     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        );
    268385
    269386        void ConversionCost::postvisit( VoidType * ) {
     
    279396                                cost = Cost::zero;
    280397                                cost.incSafe( tableResult );
     398                                cost.incSign( signMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ] );
    281399                        } // if
    282400                } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
     
    300418                                        // types are the same, except otherPointer has more qualifiers
    301419                                        cost = Cost::safe;
    302                                 }
     420                                } // if
    303421                        } else {
    304422                                int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env );
     
    422540                                cost = Cost::zero;
    423541                                cost.incSafe( tableResult + 1 );
    424                         }
     542                                cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] );
     543                        } // if
    425544                } else if ( dynamic_cast< PointerType* >( dest ) ) {
    426545                        cost = Cost::safe;
    427                 }
     546                } // if
    428547        }
    429548
     
    439558                                cost = Cost::zero;
    440559                                cost.incSafe( tableResult + 1 );
    441                         }
    442                 }
     560                                cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] );
     561                        } // if
     562                } // if
    443563        }
    444564} // namespace ResolvExpr
  • src/ResolvExpr/Cost.h

    r6d01d89 r85d44c6  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 09:39:50 2015
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Fri Oct 05 14:32:00 2018
    13 // Update Count     : 7
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Feb  7 20:54:29 2019
     13// Update Count     : 8
    1414//
    1515
     
    2121        class Cost {
    2222          private:
    23                 Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost,
    24                         int referenceCost );
    25 
     23                Cost( int unsafeCost, int polyCost, int safeCost, int signCost,
     24                        int varCost, int specCost, int referenceCost );
    2625          public:
    2726                Cost & incUnsafe( int inc = 1 );
    2827                Cost & incPoly( int inc = 1 );
    2928                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; }
    3738                int get_varCost() const { return varCost; }
    3839                int get_specCost() const { return specCost; }
     
    4041
    4142                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;
    5758                static const Cost var;
    5859                static const Cost spec;
     
    6364                int polyCost;       ///< Count of parameters and return values bound to some poly type
    6465                int safeCost;       ///< Safe (widening) conversions
     66                int signCost;       ///< Count of safe sign conversions
    6567                int varCost;        ///< Count of polymorphic type variables
    6668                int specCost;       ///< Polymorphic type specializations (type assertions), negative cost
     
    6870        };
    6971
    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 ) {}
     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 ) {}
    7476
    7577        inline Cost & Cost::incUnsafe( int inc ) {
     
    8890                if ( *this == infinity ) return *this;
    8991                safeCost += inc;
     92                return *this;
     93        }
     94
     95        inline Cost & Cost::incSign( int inc ) {
     96                if ( *this == infinity ) return *this;
     97                signCost += inc;
    9098                return *this;
    9199        }
     
    111119        inline Cost Cost::operator+( const Cost &other ) const {
    112120                if ( *this == infinity || other == infinity ) return infinity;
    113                 return Cost{ 
    114                         unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, 
    115                         varCost + other.varCost, specCost + other.specCost,
     121                return Cost{
     122                        unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost,
     123                        signCost + other.signCost, varCost + other.varCost, specCost + other.specCost,
    116124                        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;
    136137                varCost += other.varCost;
    137138                specCost += other.specCost;
     
    156157                } else if ( safeCost < other.safeCost ) {
    157158                        return true;
     159                } else if ( signCost > other.signCost ) {
     160                        return false;
     161                } else if ( signCost < other.signCost ) {
     162                        return true;
    158163                } else if ( varCost > other.varCost ) {
    159164                        return false;
     
    180185                c = polyCost - other.polyCost; if ( c ) return c;
    181186                c = safeCost - other.safeCost; if ( c ) return c;
     187                c = signCost - other.signCost; if ( c ) return c;
    182188                c = varCost - other.varCost; if ( c ) return c;
    183189                c = specCost - other.specCost; if ( c ) return c;
     
    189195                        && polyCost == other.polyCost
    190196                        && safeCost == other.safeCost
     197                        && signCost == other.signCost
    191198                        && varCost == other.varCost
    192199                        && specCost == other.specCost
     
    199206
    200207        inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
    201                 return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", "
    202                           << cost.safeCost << ", " << cost.varCost << ", " << cost.specCost << ", "
     208                return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", "
     209                          << cost.safeCost << ", " << cost.signCost << ", "
     210                                  << cost.varCost << ", " << cost.specCost << ", "
    203211                          << cost.referenceCost << " )";
    204212        }
  • src/ResolvExpr/Resolver.cc

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

    r6d01d89 r85d44c6  
    1010// Created On       : Sun May 17 07:28:22 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 22 09:36:18 2017
    13 // Update Count     : 3
     12// Last Modified On : Fri Feb  8 09:30:34 2019
     13// Update Count     : 4
    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

    r6d01d89 r85d44c6  
    1010// Created On       : Sun May 17 21:44:03 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 22 09:45:30 2017
    13 // Update Count     : 15
     12// Last Modified On : Thu Feb 14 08:12:17 2019
     13// Update Count     : 25
    1414//
    1515
     
    2222                namespace Encoding {
    2323                        const std::string manglePrefix = "_X";
    24 
     24#if 0
    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
    65120
    66121                        const std::map<int, std::string> qualifiers = {
  • src/SynTree/BasicType.cc

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

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

    r6d01d89 r85d44c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jun 22 10:17:19 2018
    13 // Update Count     : 39
     12// Last Modified On : Thu Jan 31 21:54:16 2019
     13// Update Count     : 43
    1414//
    1515#include "Type.h"
     
    2525
    2626const char *BasicType::typeNames[] = {
     27#if 0
    2728        "_Bool",
    2829        "char",
     
    4950        "unsigned __int128",
    5051        "__float80",
    51         "__float128"
     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",
    52107};
    53108static_assert(
  • src/SynTree/Type.h

    r6d01d89 r85d44c6  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 25 14:14:01 2017
    13 // Update Count     : 154
     12// Last Modified On : Wed Feb 13 18:10:45 2019
     13// Update Count     : 167
    1414//
    1515
     
    207207class BasicType : public Type {
    208208  public:
     209#if 0
    209210        enum Kind {
    210211                Bool,
     
    233234                Float80,
    234235                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,
    235293                NUMBER_OF_BASIC_TYPES
    236294        } kind;
  • src/Tuples/TupleExpansion.cc

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

    r6d01d89 r85d44c6  
    44... to:
    55  char Alternatives are:
    6 Cost ( 1, 0, 0, 0, 0, 0 ): Cast of:
     6Cost ( 1, 0, 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 ): Cast of:
     18Cost ( 1, 0, 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 ): Cast of:
     27Cost ( 1, 0, 0, 0, 0, 0, 0 ): Cast of:
    2828     Variable Expression: f: signed int
    2929   ... to:
  • tests/.expect/completeTypeError.txt

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

    r6d01d89 r85d44c6  
    1010// Created On       : Sat Sep  9 16:34:38 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Dec  4 21:44:01 2018
    13 // Update Count     : 139
    14 //
    15 
     12// Last Modified On : Tue Feb 12 08:07:39 2019
     13// Update Count     : 224
     14//
     15
     16#include <features.h>                                                                   // __GNUC_PREREQ
    1617#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
    153197#ifdef __CFA__
    154198// fixed-size length
     
    167211        // octal
    168212         01234567_l8;   01234567_l16;   01234567_l32;   01234567_l64;   01234567_l8u;   01234567_ul16;   01234567_l32u;   01234567_ul64;
    169         +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;
    170214        -01234567_l8;  -01234567_l16;  -01234567_l32;  -01234567_l64;  -01234567_l8u;  -01234567_ul16;  -01234567_l32u;  -01234567_ul64;
    171215
     
    203247        +0X0123456789ABCDEF_l8;  +0X0123456789ABCDEF_l16;  +0X0123456789ABCDEFl32;  +0X0123456789ABCDEFl64;  +0X0123456789ABCDEF_ul8;  +0X0123456789ABCDEF_l16u;  +0X0123456789ABCDEFul32;  +0X0123456789ABCDEFl64u;
    204248        -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;
    231249
    232250// char, short, int suffix overloading
  • tests/numericConstants.cfa

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

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