Changes in src/Parser/ExpressionNode.cc [e15853c:6e3eaa57]
- File:
-
- 1 edited
-
src/Parser/ExpressionNode.cc (modified) (6 diffs)
Legend:
- Unmodified
- Added
- Removed
-
src/Parser/ExpressionNode.cc
re15853c r6e3eaa57 10 10 // Created On : Sat May 16 13:17:07 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Feb 13 18:07:38 201913 // Update Count : 90212 // Last Modified On : Mon Jun 4 21:24:45 2018 13 // Update Count : 802 14 14 // 15 15 … … 51 51 extern const Type::Qualifiers noQualifiers; // no qualifiers on constants 52 52 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'; } 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'; } 56 57 static inline bool checkF( char c ) { return c == 'f' || c == 'F'; } 57 58 static inline bool checkD( char c ) { return c == 'd' || c == 'D'; } 58 static inline bool checkF80( char c ) { return c == 'w' || c == 'W'; }59 static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }60 static inline bool checkF128( char c ) { return c == 'q' || c == 'Q'; }61 59 static inline bool checkI( char c ) { return c == 'i' || c == 'I'; } 62 60 static inline bool checkB( char c ) { return c == 'b' || c == 'B'; } 63 61 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; } 64 62 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 65 96 Expression * build_constantInteger( string & str ) { 66 97 static const BasicType::Kind kind[2][6] = { 67 // short (h) must be before char (hh) because shorter type has the longer suffix98 // short (h) must be before char (hh) 68 99 { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, }, 69 100 { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, }, 70 101 }; 71 102 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 }; // lnthsInt76 77 103 bool dec = true, Unsigned = false; // decimal, unsigned constant 78 int type = -1;// 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int12879 int l type= -1; // literal length104 int size; // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128 105 int lnth = -1; // literal length 80 106 81 107 unsigned long long int v; // converted integral value … … 101 127 //printf( "%llx %llu\n", v, v ); 102 128 } else if ( checkB( str[1] ) ) { // binary constant ? 103 v = 0; // compute value104 for ( unsigned int i = 2;; ) {129 v = 0; 130 for ( unsigned int i = 2;; i += 1 ) { // compute value 105 131 if ( str[i] == '1' ) v |= 1; 106 i += 1; 107 if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break; 132 if ( i == last ) break; 108 133 v <<= 1; 109 134 } // for 110 //printf( "% #llx %llu\n", v, v );135 //printf( "%llx %llu\n", v, v ); 111 136 } else { // octal constant 112 137 sscanf( (char *)str.c_str(), "%llo", &v ); 113 //printf( "% #llo %llu\n", v, v );138 //printf( "%llo %llu\n", v, v ); 114 139 } // if 115 140 } else { // decimal constant ? … … 118 143 } // if 119 144 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 120 162 // At least one digit in integer constant, so safe to backup while looking for suffix. 121 163 122 string::size_type posn; 123 124 if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true; 125 126 posn = str.rfind( "hh" ); 127 if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; } 128 129 posn = str.rfind( "HH" ); 130 if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; } 131 132 posn = str.find_last_of( "hH" ); 133 if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; } 134 135 posn = str.find_last_of( "zZ" ); 136 if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; } 137 138 if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; } 139 140 posn = str.find_last_of( "lL" ); 141 if ( posn != string::npos ) { 142 type = 3; // default 143 posn += 1; // advance to size 144 if ( str[posn] == '3' ) { // 32 145 type = ltype = 2; str.erase( posn, 2 ); 146 } else if ( str[posn] == '6' ) { // 64 147 type = ltype = 3; str.erase( posn, 2 ); 148 } else if ( str[posn] == '8' ) { // 8 149 type = ltype = 1; str.erase( posn, 1 ); 150 } else if ( str[posn] == '1' ) { 151 if ( str[posn + 1] == '6' ) { // 16 152 type = ltype = 0; str.erase( posn, 2 ); 153 } else { // 128 154 type = ltype = 5; str.erase( posn, 3 ); 164 if ( checkU( str[last] ) ) { // suffix 'u' ? 165 Unsigned = true; 166 if ( checkL( str[last - 1] ) ) { // suffix 'l' ? 167 size = 3; 168 if ( checkL( str[last - 2] ) ) { // suffix "ll" ? 169 size = 4; 155 170 } // if 156 } // if 157 } // if 158 FINI: 159 160 if ( type == -1 ) { // no suffix type, use value 161 if ( v <= INT_MAX ) { // signed int 162 type = 2; 163 } else if ( v <= UINT_MAX && ! dec ) { // unsigned int 164 type = 2; 165 Unsigned = true; // unsigned 166 } else if ( v <= LONG_MAX ) { // signed long int 167 type = 3; 168 } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int 169 type = 3; 170 Unsigned = true; // unsigned long int 171 } else if ( v <= LLONG_MAX ) { // signed long long int 172 type = 4; 173 } else { // unsigned long long int 174 type = 4; 175 Unsigned = true; // unsigned long long int 176 } // if 177 } // if 178 179 assert( 0 <= type && type < 6 ); 171 } else if ( checkH( str[last - 1] ) ) { // suffix 'h' ? 172 size = 0; 173 if ( checkH( str[last - 2] ) ) { // suffix "hh" ? 174 size = 1; 175 } // if 176 str.erase( last - size - 1, size + 1 ); // remove 'h'/"hh" 177 } else { // suffix "ln" ? 178 checkLNInt( str, lnth, size ); 179 } // if 180 } else if ( checkL( str[ last ] ) ) { // suffix 'l' ? 181 size = 3; 182 if ( checkL( str[last - 1] ) ) { // suffix 'll' ? 183 size = 4; 184 if ( checkU( str[last - 2] ) ) { // suffix 'u' ? 185 Unsigned = true; 186 } // if 187 } else if ( checkU( str[last - 1] ) ) { // suffix 'u' ? 188 Unsigned = true; 189 } // if 190 } else if ( checkH( str[ last ] ) ) { // suffix 'h' ? 191 size = 0; 192 if ( checkH( str[last - 1] ) ) { // suffix "hh" ? 193 size = 1; 194 if ( checkU( str[last - 2] ) ) { // suffix 'u' ? 195 Unsigned = true; 196 } // if 197 } else if ( checkU( str[last - 1] ) ) { // suffix 'u' ? 198 Unsigned = true; 199 } // if 200 str.erase( last - size, size + 1 ); // remove 'h'/"hh" 201 } else if ( checkZ( str[last] ) ) { // suffix 'z' ? 202 lnth = 4; 203 str.erase( last, 1 ); // remove 'z' 204 } else { // suffix "ln" ? 205 checkLNInt( str, lnth, size ); 206 } // if 207 208 assert( 0 <= size && size < 6 ); 180 209 // Constant type is correct for overload resolving. 181 ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][ type] ), str, v ) );182 if ( Unsigned && type < 2 ) { // hh or h, less than int ?210 ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) ); 211 if ( Unsigned && size < 2 ) { // hh or h, less than int ? 183 212 // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values. 184 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][ type] ), false );185 } else if ( l type!= -1 ) { // explicit length ?186 if ( l type== 5 ) { // int128 ?187 type = 5;188 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][ type] ), false );213 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false ); 214 } else if ( lnth != -1 ) { // explicit length ? 215 if ( lnth == 5 ) { // int128 ? 216 size = 5; 217 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false ); 189 218 } else { 190 ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][l type], false ), false );219 ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ), false ); 191 220 } // if 192 221 } // if … … 198 227 199 228 200 static inline void checkFnxFloat( string & str, size_t last, bool & explnth, int & type ) { 201 string::size_type posn; 202 // floating-point constant has minimum of 2 characters, 1. or .1, so safe to look ahead 203 if ( str[1] == 'x' ) { // hex ? 204 posn = str.find_last_of( "pP" ); // back for exponent (must have) 205 posn = str.find_first_of( "fF", posn + 1 ); // forward for size (fF allowed in hex constant) 206 } else { 207 posn = str.find_last_of( "fF" ); // back for size (fF not allowed) 208 } // if 229 static inline void checkLNFloat( string & str, int & lnth, int & size ) { 230 string::size_type posn = str.find_first_of( "lL" ), start = posn; 209 231 if ( posn == string::npos ) return; 210 explnth = true; 232 size = 2; // assume largest size 233 lnth = 0; 211 234 posn += 1; // advance to size 212 235 if ( str[posn] == '3' ) { // 32 213 if ( str[last] != 'x' ) type = 6; 214 else type = 7; 236 size = 0; 215 237 } else if ( str[posn] == '6' ) { // 64 216 if ( str[last] != 'x' ) type = 8; 217 else type = 9; 218 } else if ( str[posn] == '8' ) { // 80 219 type = 3; 220 } else if ( str[posn] == '1' ) { // 16/128 221 if ( str[posn + 1] == '6' ) { // 16 222 type = 5; 223 } else { // 128 224 if ( str[last] != 'x' ) type = 10; 225 else type = 11; 226 } // if 238 size = 1; 239 } else if ( str[posn] == '8' || str[posn] == '1' ) { // 80, 128 240 size = 2; 241 if ( str[posn] == '1' ) posn += 1; 227 242 } else { 228 243 assertf( false, "internal error, bad floating point length %s", str.c_str() ); 229 244 } // if 230 } // checkFnxFloat 245 posn += 1; 246 str.erase( start, posn - start + 1 ); // remove length suffix 247 } // checkLNFloat 231 248 232 249 233 250 Expression * build_constantFloat( string & str ) { 234 static const BasicType::Kind kind[2][ 12] = {235 { BasicType::Float, BasicType::Double, BasicType::LongDouble , BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x},236 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex , (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex},251 static const BasicType::Kind kind[2][3] = { 252 { BasicType::Float, BasicType::Double, BasicType::LongDouble }, 253 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, 237 254 }; 238 255 239 // floating-point constant has minimum of 2 characters 1. or .1 256 bool complx = false; // real, complex 257 int size = 1; // 0 => float, 1 => double, 2 => long double 258 int lnth = -1; // literal length 259 // floating-point constant has minimum of 2 characters: 1. or .1 240 260 size_t last = str.length() - 1; 241 261 double v; 242 int type; // 0 => float, 1 => double, 3 => long double, ...243 bool complx = false; // real, complex244 bool explnth = false; // explicit literal length245 262 246 263 sscanf( str.c_str(), "%lg", &v ); … … 252 269 253 270 if ( checkF( str[last] ) ) { // float ? 254 type = 0;271 size = 0; 255 272 } else if ( checkD( str[last] ) ) { // double ? 256 type = 1;273 size = 1; 257 274 } else if ( checkL( str[last] ) ) { // long double ? 258 type = 2; 259 } else if ( checkF80( str[last] ) ) { // __float80 ? 260 type = 3; 261 } else if ( checkF128( str[last] ) ) { // __float128 ? 262 type = 4; 275 size = 2; 263 276 } else { 264 type = 1; // double (default if no suffix) 265 checkFnxFloat( str, last, explnth, type ); 266 } // if 267 277 size = 1; // double (default) 278 checkLNFloat( str, lnth, size ); 279 } // if 268 280 if ( ! complx && checkI( str[last - 1] ) ) { // imaginary ? 269 281 complx = true; 270 282 } // if 271 283 272 assert( 0 <= type && type < 12);273 Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][ type] ), str, v ) );274 if ( explnth) { // explicit length ?275 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][ type] ), false );284 assert( 0 <= size && size < 3 ); 285 Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) ); 286 if ( lnth != -1 ) { // explicit length ? 287 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ), false ); 276 288 } // if 277 289
Note:
See TracChangeset
for help on using the changeset viewer.
