Changeset 4e05d27
- Timestamp:
- Jul 24, 2016, 3:30:09 AM (9 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, 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
- Location:
- src/Parser
- Files:
-
- 4 edited
-
ParseNode.cc (modified) (3 diffs)
-
ParseNode.h (modified) (2 diffs)
-
parser.cc (modified) (4 diffs)
-
parser.yy (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 -
src/Parser/ParseNode.h
ref3b335 r4e05d27 10 10 // Created On : Sat May 16 13:28:16 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jul 12 20:50:21201613 // Update Count : 26 112 // Last Modified On : Sun Jul 24 02:17:00 2016 13 // Update Count : 269 14 14 // 15 15 … … 141 141 }; 142 142 143 ConstantNode *makeConstant( ConstantNode::Type, std::string * ); 144 ConstantNode *makeConstantStr( ConstantNode::Type type, std::string *str ); 143 ConstantNode *makeConstantInteger( std::string & ); 144 ConstantNode *makeConstantFloat( std::string & ); 145 ConstantNode *makeConstantChar( std::string & ); 146 ConstantNode *makeConstantStr( std::string & ); 145 147 146 148 class VarRefNode : public ExpressionNode { -
src/Parser/parser.cc
ref3b335 r4e05d27 5235 5235 /* Line 1806 of yacc.c */ 5236 5236 #line 305 "parser.yy" 5237 { (yyval.constant) = makeConstant ( ConstantNode::Integer,(yyvsp[(1) - (1)].tok) ); }5237 { (yyval.constant) = makeConstantInteger( *(yyvsp[(1) - (1)].tok) ); } 5238 5238 break; 5239 5239 … … 5242 5242 /* Line 1806 of yacc.c */ 5243 5243 #line 306 "parser.yy" 5244 { (yyval.constant) = makeConstant ( ConstantNode::Float,(yyvsp[(1) - (1)].tok) ); }5244 { (yyval.constant) = makeConstantFloat( *(yyvsp[(1) - (1)].tok) ); } 5245 5245 break; 5246 5246 … … 5249 5249 /* Line 1806 of yacc.c */ 5250 5250 #line 307 "parser.yy" 5251 { (yyval.constant) = makeConstant ( ConstantNode::Character,(yyvsp[(1) - (1)].tok) ); }5251 { (yyval.constant) = makeConstantChar( *(yyvsp[(1) - (1)].tok) ); } 5252 5252 break; 5253 5253 … … 5256 5256 /* Line 1806 of yacc.c */ 5257 5257 #line 332 "parser.yy" 5258 { (yyval.constant) = makeConstantStr( ConstantNode::String,(yyvsp[(1) - (1)].tok) ); }5258 { (yyval.constant) = makeConstantStr( *(yyvsp[(1) - (1)].tok) ); } 5259 5259 break; 5260 5260 -
src/Parser/parser.yy
ref3b335 r4e05d27 10 10 // Created On : Sat Sep 1 20:22:55 2001 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jul 12 20:52:53201613 // Update Count : 166 112 // Last Modified On : Sat Jul 23 17:01:30 2016 13 // Update Count : 1668 14 14 // 15 15 … … 303 303 constant: 304 304 // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant". 305 INTEGERconstant { $$ = makeConstant ( ConstantNode::Integer,$1 ); }306 | FLOATINGconstant { $$ = makeConstant ( ConstantNode::Float,$1 ); }307 | CHARACTERconstant { $$ = makeConstant ( ConstantNode::Character,$1 ); }305 INTEGERconstant { $$ = makeConstantInteger( *$1 ); } 306 | FLOATINGconstant { $$ = makeConstantFloat( *$1 ); } 307 | CHARACTERconstant { $$ = makeConstantChar( *$1 ); } 308 308 ; 309 309 … … 330 330 331 331 string_literal_list: // juxtaposed strings are concatenated 332 STRINGliteral { $$ = makeConstantStr( ConstantNode::String,$1 ); }332 STRINGliteral { $$ = makeConstantStr( *$1 ); } 333 333 | string_literal_list STRINGliteral { $$ = $1->appendstr( $2 ); } 334 334 ;
Note: See TracChangeset
for help on using the changeset viewer.
