Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/ExpressionNode.cc

    rf56c32e re15853c  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 28 21:36:38 2019
    13 // Update Count     : 933
     12// Last Modified On : Wed Feb 13 18:07:38 2019
     13// Update Count     : 902
    1414//
    1515
     
    5757static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
    5858static inline bool checkF80( char c ) { return c == 'w' || c == 'W'; }
     59static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
    5960static inline bool checkF128( char c ) { return c == 'q' || c == 'Q'; }
    60 static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
    6161static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
    6262static inline bool checkB( char c ) { return c == 'b' || c == 'B'; }
    6363static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
    64 static inline bool checkN( char c ) { return c == 'n' || c == 'N'; }
    65 
    66 void lnthSuffix( string & str, int & type, int & ltype ) {
    67         string::size_type posn = str.find_last_of( "lL" );
    68         if ( posn != string::npos ) {
    69                 type = 3;                                                                               // default
    70                 posn += 1;                                                                              // advance to size
    71                 if ( str[posn] == '3' ) {                                               // 32
    72                         type = ltype = 2; str.erase( posn, 2 );
    73                 } else if ( str[posn] == '6' ) {                                // 64
    74                         type = ltype = 3; str.erase( posn, 2 );
    75                 } else if ( str[posn] == '8' ) {                                // 8
    76                         type = ltype = 1; str.erase( posn, 1 );
    77                 } else if ( str[posn] == '1' ) {
    78                         if ( str[posn + 1] == '6' ) {                           // 16
    79                                 type = ltype = 0; str.erase( posn, 2 );
    80                         } else {                                                                        // 128
    81                                 type = ltype = 5; str.erase( posn, 3 );
    82                         } // if
    83                 } // if
    84         } // if
    85 } // lnthSuffix
    8664
    8765Expression * build_constantInteger( string & str ) {
     
    10482        size_t last = str.length() - 1;                                         // last subscript of constant
    10583        Expression * ret;
    106         string fred( str );
    10784
    10885        // special constants
     
    11693        } // if
    11794
    118         // Cannot be just "0"/"1"; sscanf stops at the suffix, if any; value goes over the wall so always generate
     95        // Cannot be "0"
    11996
    12097        if ( str[0] == '0' ) {                                                          // radix character ?
     
    138115        } else {                                                                                        // decimal constant ?
    139116                sscanf( (char *)str.c_str(), "%llu", &v );
    140                 //printf( "%llu\n", v );
    141         } // if
     117                //printf( "%llu %llu\n", v, v );
     118        } // if
     119
     120        // At least one digit in integer constant, so safe to backup while looking for suffix.
    142121
    143122        string::size_type posn;
    144123
    145         if ( isdigit( str[last] ) ) {                                           // no suffix ?
    146                 lnthSuffix( str, type, ltype );                                 // could have length suffix
    147                 if ( type == -1 ) {
    148                         // no suffix type, use value to determine type
    149                         if ( v <= INT_MAX ) {                                           // signed int
    150                                 type = 2;
    151                         } else if ( v <= UINT_MAX && ! dec ) {          // unsigned int
    152                                 type = 2;
    153                                 Unsigned = true;                                                // unsigned
    154                         } else if ( v <= LONG_MAX ) {                           // signed long int
    155                                 type = 3;
    156                         } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
    157                                 type = 3;
    158                                 Unsigned = true;                                                // unsigned long int
    159                         } else if ( v <= LLONG_MAX ) {                          // signed long long int
    160                                 type = 4;
    161                         } else {                                                                        // unsigned long long int
    162                                 type = 4;
    163                                 Unsigned = true;                                                // unsigned long long int
     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 );
    164155                        } // if
    165156                } // if
    166         } else {
    167                 // At least one digit in integer constant, so safe to backup while looking for suffix.
    168 
    169                 if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true;
    170 
    171                 posn = str.rfind( "hh" );
    172                 if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
    173 
    174                 posn = str.rfind( "HH" );
    175                 if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
    176 
    177                 posn = str.find_last_of( "hH" );
    178                 if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
    179 
    180                 posn = str.find_last_of( "nN" );
    181                 if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; }
    182 
    183                 posn = str.find_last_of( "zZ" );
    184                 if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
    185 
    186                 if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
    187 
    188                 lnthSuffix( str, type, ltype );                                 // must be after check for "ll"
    189                 if ( type == -1 ) { type = 3; goto FINI; }
    190           FINI: ;
    191         } // if
    192 
    193         //if ( !( 0 <= type && type < 6 ) ) { printf( "%s %lu %d %s\n", fred.c_str(), fred.length(), type, str.c_str() ); }
     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
    194179        assert( 0 <= type && type < 6 );
    195 
    196180        // Constant type is correct for overload resolving.
    197181        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][type] ), str, v ) );
     
    207191                } // if
    208192        } // if
    209 
    210   CLEANUP: ;
     193  CLEANUP:
     194
    211195        delete &str;                                                                            // created by lex
    212196        return ret;
Note: See TracChangeset for help on using the changeset viewer.