Changeset f6582252


Ignore:
Timestamp:
Jul 11, 2020, 6:37:01 PM (15 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast, new-ast-unique-expr
Children:
9f350c4
Parents:
7d9bbef
Message:

add support for int128 constants

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/ExpressionNode.cc

    r7d9bbef rf6582252  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec 18 21:14:58 2019
    13 // Update Count     : 981
     12// Last Modified On : Sat Jul 11 16:44:49 2020
     13// Update Count     : 1034
    1414//
    1515
     
    8585        } // if
    8686        // remove "lL" for these cases because it may not imply long
    87         str.erase( posn );                                                                      // remove length
     87        str.erase( posn );                                                                      // remove length suffix and "uU"
    8888} // lnthSuffix
    8989
     
    108108} // valueToType
    109109
     110static void scanbin( string & str, unsigned long long int & v ) {
     111        v = 0;
     112        size_t last = str.length() - 1;                                         // last subscript of constant
     113        for ( unsigned int i = 2;; ) {                                          // ignore prefix
     114                if ( str[i] == '1' ) v |= 1;
     115                i += 1;
     116          if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
     117                v <<= 1;
     118        } // for
     119} // scanbin
     120
    110121Expression * build_constantInteger( string & str ) {
    111122        static const BasicType::Kind kind[2][6] = {
    112123                // short (h) must be before char (hh) because shorter type has the longer suffix
    113                 { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, },
    114                 { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, },
     124                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, /* BasicType::SignedInt128 */ BasicType::LongLongSignedInt, },
     125                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, /* BasicType::UnsignedInt128 */ BasicType::LongLongUnsignedInt, },
    115126        };
    116127
     
    120131        }; // lnthsInt
    121132
    122         unsigned long long int v;                                                       // converted integral value
    123         size_t last = str.length() - 1;                                         // last subscript of constant
    124         Expression * ret;
    125         //string fred( str );
     133        string str2( "0x0" );
     134        unsigned long long int v, v2 = 0;                                       // converted integral value
     135        Expression * ret, * ret2;
    126136
    127137        int type = -1;                                                                          // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
     
    139149        } // if
    140150
     151        string::size_type posn;
     152
     153        // 'u' can appear before or after length suffix
     154        if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true;
     155
     156        if ( isdigit( str[str.length() - 1] ) ) {                       // no suffix ?
     157                lnthSuffix( str, type, ltype );                                 // could have length suffix
     158                if ( type == 5 && Unsigned ) str.erase( str.length() - 1 ); // L128 and terminating "uU" ?
     159        } else {
     160                // At least one digit in integer constant, so safe to backup while looking for suffix.
     161
     162                posn = str.find_last_of( "pP" );                                // pointer value
     163                if ( posn != string::npos ) { ltype = 5; str.erase( posn, 1 ); goto FINI; }
     164
     165                posn = str.find_last_of( "zZ" );                                // size_t
     166                if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
     167
     168                posn = str.rfind( "hh" );                                               // char
     169                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
     170
     171                posn = str.rfind( "HH" );                                               // char
     172                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
     173
     174                posn = str.find_last_of( "hH" );                                // short
     175                if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
     176
     177                posn = str.find_last_of( "nN" );                                // int (natural number)
     178                if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; }
     179
     180                if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
     181
     182                lnthSuffix( str, type, ltype );                                 // must be after check for "ll"
     183          FINI: ;
     184        } // if
     185
    141186        // Cannot be just "0"/"1"; sscanf stops at the suffix, if any; value goes over the wall => always generate
    142 
     187       
    143188        if ( str[0] == '0' ) {                                                          // radix character ?
    144189                dec = false;
    145190                if ( checkX( str[1] ) ) {                                               // hex constant ?
    146                         sscanf( (char *)str.c_str(), "%llx", &v );
     191                        if ( type < 5 ) {                                                       // not L128 ?
     192                                sscanf( (char *)str.c_str(), "%llx", &v );
     193                        } else {                                                                        // hex int128 constant
     194                                unsigned int len = str.length();
     195                                if ( len > (2 + 16 + 16) ) SemanticError( yylloc, "128-bit hexadecimal constant to large " + str );
     196                          if ( len <= (2 + 16) ) goto FHEX1;            // hex digits < 2^64
     197                                str2 = "0x" + str.substr( len - 16 );
     198                                sscanf( (char *)str2.c_str(), "%llx", &v2 );
     199                                str = str.substr( 0, len - 16 );
     200                          FHEX1: ;
     201                                sscanf( (char *)str.c_str(), "%llx", &v );
     202                        } // if
    147203                        //printf( "%llx %llu\n", v, v );
    148204                } else if ( checkB( str[1] ) ) {                                // binary constant ?
    149                         v = 0;                                                                          // compute value
    150                         for ( unsigned int i = 2;; ) {                          // ignore prefix
    151                                 if ( str[i] == '1' ) v |= 1;
    152                                 i += 1;
    153                           if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
    154                                 v <<= 1;
    155                         } // for
     205                        unsigned int len = str.length();
     206                        if ( type == 5 && len > 2 + 64 ) {
     207                                if ( len > 2 + 64 + 64 ) SemanticError( yylloc, "128-bit binary constant to large " + str );
     208                                str2 = "0b" + str.substr( len - 64 );
     209                                str = str.substr( 0, len - 64 );
     210                                scanbin( str2, v2 );
     211                        } // if
     212                        scanbin( str, v );
    156213                        //printf( "%#llx %llu\n", v, v );
    157214                } else {                                                                                // octal constant
    158                         sscanf( (char *)str.c_str(), "%llo", &v );
     215                        if ( type < 5 ) {                                                       // not L128 ?
     216                                sscanf( (char *)str.c_str(), "%llo", &v );
     217                        } else {                                                                        // octal int128 constant
     218                                unsigned int len = str.length();
     219                                char buf[32];
     220                                __int128 val = v;
     221                               
     222                                if ( len > 1 + 43 || (len == 1 + 43 && str[0] > '3') ) SemanticError( yylloc, "128-bit octal constant to large " + str );
     223                                if ( len <= 1 + 21 ) {                                  // value < 21 octal digitis
     224                                        sscanf( (char *)str.c_str(), "%llo", &v ); // leave value in octal
     225                                } else {
     226                                        sscanf( &str[len - 21], "%llo", &v );
     227                                        val = v;                                                        // store bits
     228                                        str[len - 21] ='\0';                            // shorten string
     229                                        sscanf( &str[len == 43 ? 1 : 0], "%llo", &v );
     230                                        val |= (__int128)v << 63;                       // store bits
     231                                        if ( len == 1 + 43 ) {                          // most significant 2 bits ?
     232                                                str[2] = '\0';                                  // shorten string
     233                                                sscanf( &str[1], "%llo", &v );  // process most significant 2 bits
     234                                                val |= (__int128)v << 126;              // store bits
     235                                        } // if
     236                                        v = val >> 64; v2 = (uint64_t)val;      // replace octal constant with 2 hex constants
     237                                        sprintf( buf, "%#llx", v2 );
     238                                        str2 = buf;
     239                                        sprintf( buf, "%#llx", v );
     240                                        str = buf;
     241                                } // if
     242                        } // if
    159243                        //printf( "%#llo %llu\n", v, v );
    160244                } // if
    161245        } else {                                                                                        // decimal constant ?
    162                 sscanf( (char *)str.c_str(), "%llu", &v );
     246                if ( type < 5 ) {                                                               // not L128 ?
     247                        sscanf( (char *)str.c_str(), "%llu", &v );
     248                } else {                                                                                // decimal int128 constant
     249                        #define P10_UINT64 10'000'000'000'000'000'000ULL // 19 zeroes
     250                        unsigned int len = str.length();
     251                        char buf[32];
     252                        __int128 val = v;
     253
     254                        if ( str.length() == 39 && str > (Unsigned ? "340282366920938463463374607431768211455" : "170141183460469231731687303715884105727") )
     255                                SemanticError( yylloc, "128-bit decimal constant to large " + str );
     256                        if ( len <= 19 ) {                                                      // value < 19 decimal digitis
     257                                sscanf( (char *)str.c_str(), "%llu", &v ); // leave value in decimal
     258                        } else {
     259                                sscanf( &str[len - 19], "%llu", &v );
     260                                val = v;                                                                // store bits
     261                                str[len - 19] ='\0';                                    // shorten string
     262                                sscanf( &str[len == 39 ? 1 : 0], "%llu", &v );
     263                                val += (__int128)v * (__int128)P10_UINT64; // store bits
     264                                if ( len == 39 ) {                                              // most significant 2 bits ?
     265                                        str[1] = '\0';                                          // shorten string
     266                                        sscanf( &str[0], "%llu", &v );          // process most significant 2 bits
     267                                        val += (__int128)v * (__int128)P10_UINT64 * (__int128)P10_UINT64; // store bits
     268                                } // if
     269                                v = val >> 64; v2 = (uint64_t)val;              // replace decimal constant with 2 hex constants
     270                                sprintf( buf, "%#llx", v2 );
     271                                str2 = buf;
     272                                sprintf( buf, "%#llx", v );
     273                                str = buf;
     274                        } // if
     275                } // if
    163276                //printf( "%llu\n", v );
    164277        } // if
    165278
    166         string::size_type posn;
    167 
    168         if ( isdigit( str[last] ) ) {                                           // no suffix ?
    169                 lnthSuffix( str, type, ltype );                                 // could have length suffix
    170                 if ( type == -1 ) {                                                             // no suffix
    171                         valueToType( v, dec, type, Unsigned );
    172                 } // if
    173         } else {
    174                 // At least one digit in integer constant, so safe to backup while looking for suffix.
    175 
    176                 posn = str.find_last_of( "pP" );
    177                 if ( posn != string::npos ) { valueToType( v, dec, type, Unsigned ); ltype = 5; str.erase( posn, 1 ); goto FINI; }
    178 
    179                 posn = str.find_last_of( "zZ" );
    180                 if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
    181 
    182                 // 'u' can appear before or after length suffix
    183                 if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true;
    184 
    185                 posn = str.rfind( "hh" );
    186                 if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
    187 
    188                 posn = str.rfind( "HH" );
    189                 if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
    190 
    191                 posn = str.find_last_of( "hH" );
    192                 if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
    193 
    194                 posn = str.find_last_of( "nN" );
    195                 if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; }
    196 
    197                 if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
    198 
    199                 lnthSuffix( str, type, ltype );                                 // must be after check for "ll"
    200                 if ( type == -1 ) {                                                             // only 'u' suffix ?
    201                         valueToType( v, dec, type, Unsigned );
    202                 } // if
    203           FINI: ;
    204         } // if
     279        if ( type == -1 ) {                                                                     // no suffix => determine type from value size
     280                valueToType( v, dec, type, Unsigned );
     281        } // if
     282        /* printf( "%s %llo %s %llo\n", str.c_str(), v, str2.c_str(), v2 ); */
    205283
    206284        //if ( !( 0 <= type && type <= 6 ) ) { printf( "%s %lu %d %s\n", fred.c_str(), fred.length(), type, str.c_str() ); }
     
    214292        } else if ( ltype != -1 ) {                                                     // explicit length ?
    215293                if ( ltype == 6 ) {                                                             // int128, (int128)constant
    216                         ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
     294//                      ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
     295                        ret2 = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::LongLongSignedInt ), str2, v2 ) );
     296                        ret = build_compoundLiteral( DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ),
     297                                                                                 new InitializerNode( (InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true ) );
    217298                } else {                                                                                // explicit length, (length_type)constant
    218299                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false );
Note: See TracChangeset for help on using the changeset viewer.