Changeset 4e05d27 for src/Parser/ParseNode.cc
- Timestamp:
- Jul 24, 2016, 3:30:09 AM (7 years ago)
- Branches:
- aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
- Children:
- c967ef9, e4957e7
- Parents:
- ef3b335
- File:
-
- 1 edited
-
src/Parser/ParseNode.cc (modified) (3 diffs)
Legend:
- Unmodified
- Added
- Removed
-
src/Parser/ParseNode.cc
ref3b335 r4e05d27 10 10 // Created On : Sat May 16 13:26:29 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Jul 15 18:49:25201613 // Update Count : 6212 // Last Modified On : Sun Jul 24 02:17:01 2016 13 // Update Count : 90 14 14 // 15 15 … … 29 29 // because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their 30 30 // type. 31 32 static Type::Qualifiers emptyQualifiers; // no qualifiers on constants 31 33 32 34 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; } … … 37 39 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; } 38 40 39 BasicType::Kind literalType( ConstantNode::Type type, string &value ) { 40 BasicType::Kind btype; 41 42 // lexing divides constants into 4 kinds 43 switch ( type ) { 44 case ConstantNode::Integer: 45 { 46 static const BasicType::Kind kind[2][3] = { 47 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt }, 48 { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt }, 49 }; 50 bool dec = true, Unsigned = false; // decimal, unsigned constant 51 int size; // 0 => int, 1 => long, 2 => long long 52 unsigned long long v; // converted integral value 53 size_t last = value.length() - 1; // last character of constant 54 55 if ( value[0] == '0' ) { // octal/hex constant ? 56 dec = false; 57 if ( last != 0 && checkX( value[1] ) ) { // hex constant ? 58 sscanf( (char *)value.c_str(), "%llx", &v ); 59 //printf( "%llx %llu\n", v, v ); 60 } else { // octal constant 61 sscanf( (char *)value.c_str(), "%llo", &v ); 62 //printf( "%llo %llu\n", v, v ); 63 } // if 64 } else { // decimal constant ? 65 sscanf( (char *)value.c_str(), "%llu", &v ); 66 //printf( "%llu %llu\n", v, v ); 67 } // if 68 69 if ( v <= INT_MAX ) { // signed int 70 size = 0; 71 } else if ( v <= UINT_MAX && ! dec ) { // unsigned int 72 size = 0; 73 Unsigned = true; // unsigned 74 } else if ( v <= LONG_MAX ) { // signed long int 75 size = 1; 76 } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int 77 size = 1; 78 Unsigned = true; // unsigned long int 79 } else if ( v <= LLONG_MAX ) { // signed long long int 80 size = 2; 81 } else { // unsigned long long int 82 size = 2; 83 Unsigned = true; // unsigned long long int 84 } // if 85 86 if ( checkU( value[last] ) ) { // suffix 'u' ? 87 Unsigned = true; 88 if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'l' ? 89 size = 1; 90 if ( last > 1 && checkL( value[ last - 2 ] ) ) { // suffix 'll' ? 91 size = 2; 92 } // if 93 } // if 94 } else if ( checkL( value[ last ] ) ) { // suffix 'l' ? 95 size = 1; 96 if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'll' ? 97 size = 2; 98 if ( last > 1 && checkU( value[ last - 2 ] ) ) { // suffix 'u' ? 99 Unsigned = true; 100 } // if 101 } else { 102 if ( last > 0 && checkU( value[ last - 1 ] ) ) { // suffix 'u' ? 103 Unsigned = true; 104 } // if 105 } // if 106 } // if 107 btype = kind[Unsigned][size]; // lookup constant type 108 break; 109 } 110 case ConstantNode::Float: 111 { 112 //long double v; 113 static const BasicType::Kind kind[2][3] = { 114 { BasicType::Float, BasicType::Double, BasicType::LongDouble }, 115 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, 116 }; 117 bool complx = false; // real, complex 118 int size = 1; // 0 => float, 1 => double (default), 2 => long double 119 // floating-point constant has minimum of 2 characters: 1. or .1 120 size_t last = value.length() - 1; 121 122 if ( checkI( value[last] ) ) { // imaginary ? 123 complx = true; 124 last -= 1; // backup one character 125 } // if 126 127 //sscanf( (char *)value.c_str(), "%Lf", &v ); 128 //printf( "%s %24.22Lf %Lf\n", value.c_str(), v, v ); 129 130 if ( checkF( value[last] ) ) { // float ? 131 size = 0; 132 } else if ( checkD( value[last] ) ) { // double ? 133 size = 1; 134 } else if ( checkL( value[last] ) ) { // long double ? 41 ConstantNode *makeConstantInteger( std::string & str ) { 42 static const BasicType::Kind kind[2][3] = { 43 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt }, 44 { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt }, 45 }; 46 bool dec = true, Unsigned = false; // decimal, unsigned constant 47 int size; // 0 => int, 1 => long, 2 => long long 48 unsigned long long v; // converted integral value 49 size_t last = str.length() - 1; // last character of constant 50 51 if ( str[0] == '0' ) { // octal/hex constant ? 52 dec = false; 53 if ( last != 0 && checkX( str[1] ) ) { // hex constant ? 54 sscanf( (char *)str.c_str(), "%llx", &v ); 55 //printf( "%llx %llu\n", v, v ); 56 } else { // octal constant 57 sscanf( (char *)str.c_str(), "%llo", &v ); 58 //printf( "%llo %llu\n", v, v ); 59 } // if 60 } else { // decimal constant ? 61 sscanf( (char *)str.c_str(), "%llu", &v ); 62 //printf( "%llu %llu\n", v, v ); 63 } // if 64 65 if ( v <= INT_MAX ) { // signed int 66 size = 0; 67 } else if ( v <= UINT_MAX && ! dec ) { // unsigned int 68 size = 0; 69 Unsigned = true; // unsigned 70 } else if ( v <= LONG_MAX ) { // signed long int 71 size = 1; 72 } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int 73 size = 1; 74 Unsigned = true; // unsigned long int 75 } else if ( v <= LLONG_MAX ) { // signed long long int 76 size = 2; 77 } else { // unsigned long long int 78 size = 2; 79 Unsigned = true; // unsigned long long int 80 } // if 81 82 if ( checkU( str[last] ) ) { // suffix 'u' ? 83 Unsigned = true; 84 if ( last > 0 && checkL( str[last - 1] ) ) { // suffix 'l' ? 85 size = 1; 86 if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ? 135 87 size = 2; 136 88 } // if 137 if ( ! complx && checkI( value[last - 1] ) ) { // imaginary ? 138 complx = true; 89 } // if 90 } else if ( checkL( str[ last ] ) ) { // suffix 'l' ? 91 size = 1; 92 if ( last > 0 && checkL( str[last - 1] ) ) { // suffix 'll' ? 93 size = 2; 94 if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ? 95 Unsigned = true; 139 96 } // if 140 btype = kind[complx][size]; // lookup constant type 141 break; 142 } 143 case ConstantNode::Character: 144 btype = BasicType::Char; // default 145 if ( string( "LUu" ).find( value[0] ) != string::npos ) { 146 // ??? 147 } // if 148 break; 149 case ConstantNode::String: 150 assert( false ); 151 // array of char 152 if ( string( "LUu" ).find( value[0] ) != string::npos ) { 153 if ( value[0] == 'u' && value[1] == '8' ) { 154 // ??? 155 } else { 156 // ??? 97 } else { 98 if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ? 99 Unsigned = true; 157 100 } // if 158 101 } // if 159 break; 160 } // switch 161 return btype; 162 } // literalType 163 164 165 ConstantNode *makeConstant( ConstantNode::Type type, std::string *str ) { 166 ::Type::Qualifiers emptyQualifiers; // no qualifiers on constants 167 return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, literalType( type, *str ) ), *str ), nullptr ) ); 168 } 169 170 ConstantNode *makeConstantStr( ConstantNode::Type type, std::string *str ) { 171 ::Type::Qualifiers emptyQualifiers; // no qualifiers on constants 102 } // if 103 104 return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ), nullptr ) ); 105 } // makeConstantInteger 106 107 ConstantNode *makeConstantFloat( std::string & str ) { 108 static const BasicType::Kind kind[2][3] = { 109 { BasicType::Float, BasicType::Double, BasicType::LongDouble }, 110 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, 111 }; 112 113 bool complx = false; // real, complex 114 int size = 1; // 0 => float, 1 => double (default), 2 => long double 115 // floating-point constant has minimum of 2 characters: 1. or .1 116 size_t last = str.length() - 1; 117 118 if ( checkI( str[last] ) ) { // imaginary ? 119 complx = true; 120 last -= 1; // backup one character 121 } // if 122 123 if ( checkF( str[last] ) ) { // float ? 124 size = 0; 125 } else if ( checkD( str[last] ) ) { // double ? 126 size = 1; 127 } else if ( checkL( str[last] ) ) { // long double ? 128 size = 2; 129 } // if 130 if ( ! complx && checkI( str[last - 1] ) ) { // imaginary ? 131 complx = true; 132 } // if 133 134 return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ), nullptr ) ); 135 } // makeConstantFloat 136 137 ConstantNode *makeConstantChar( std::string & str ) { 138 return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ), nullptr ) ); 139 } // makeConstantChar 140 141 ConstantNode *makeConstantStr( std::string & str ) { 172 142 // string should probably be a primitive type 173 143 ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ), 174 144 new ConstantExpr( 175 145 Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ), 176 toString( str ->size()+1-2 ) ) ), // +1 for '\0' and -2 for '"'146 toString( str.size()+1-2 ) ) ), // +1 for '\0' and -2 for '"' 177 147 false, false ); 178 return new ConstantNode( new ConstantExpr( Constant( at, *str ), nullptr ) );179 } 148 return new ConstantNode( new ConstantExpr( Constant( at, str ), nullptr ) ); 149 } // makeConstantStr 180 150 181 151
Note: See TracChangeset
for help on using the changeset viewer.
