Changeset cd7ef0b for src/Parser
- Timestamp:
- Aug 10, 2017, 3:39:11 PM (8 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
- Children:
- 38d70ab
- Parents:
- 275f4b4 (diff), e1780a2 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)links above to see all the changes relative to each parent. - Location:
- src/Parser
- Files:
-
- 6 edited
-
ExpressionNode.cc (modified) (13 diffs)
-
InitializerNode.cc (modified) (7 diffs)
-
ParseNode.h (modified) (2 diffs)
-
TypeData.cc (modified) (3 diffs)
-
lex.ll (modified) (3 diffs)
-
parser.yy (modified) (11 diffs)
Legend:
- Unmodified
- Added
- Removed
-
src/Parser/ExpressionNode.cc
r275f4b4 rcd7ef0b 10 10 // Created On : Sat May 16 13:17:07 2015 11 11 // Last Modified By : Andrew Beach 12 // Last Modified On : Tus Jul 25 10:11:00 2017 13 // Update Count : 551 14 // 15 16 #include <cassert> 17 #include <cctype> 18 #include <climits> 19 #include <cstdio> 20 #include <algorithm> 12 // Last Modified On : Wed Aug 2 11:12:00 2017 13 // Update Count : 568 14 // 15 16 #include <climits> // access INT_MAX, UINT_MAX, LONG_MAX, ULONG_MAX, LLONG_MAX 21 17 #include <sstream> 22 18 … … 26 22 #include "SynTree/Expression.h" 27 23 #include "SynTree/Declaration.h" 28 #include "Common/UnimplementedError.h"29 24 #include "parserutility.h" 30 #include "Common/utility.h"31 25 32 26 using namespace std; … … 46 40 // type. 47 41 48 Type::Qualifiers noQualifiers;// no qualifiers on constants42 extern const Type::Qualifiers noQualifiers; // no qualifiers on constants 49 43 50 44 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; } … … 55 49 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; } 56 50 57 Expression * build_constantInteger( const std::string & str ) {51 Expression * build_constantInteger( const std::string & str ) { 58 52 static const BasicType::Kind kind[2][3] = { 59 53 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt }, … … 62 56 bool dec = true, Unsigned = false; // decimal, unsigned constant 63 57 int size; // 0 => int, 1 => long, 2 => long long 64 unsigned long long int v; 58 unsigned long long int v; // converted integral value 65 59 size_t last = str.length() - 1; // last character of constant 66 60 Expression * ret; 61 62 // special constants 63 if ( str == "0" ) { 64 ret = new ConstantExpr( Constant( (Type *)new ZeroType( noQualifiers ), str, (unsigned long long int)0 ) ); 65 goto CLEANUP; 66 } // if 67 if ( str == "1" ) { 68 ret = new ConstantExpr( Constant( (Type *)new OneType( noQualifiers ), str, (unsigned long long int)1 ) ); 69 goto CLEANUP; 70 } // if 71 67 72 if ( str[0] == '0' ) { // octal/hex constant ? 68 73 dec = false; … … 118 123 } // if 119 124 120 Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) ); 125 ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) ); 126 CLEANUP: 121 127 delete &str; // created by lex 122 128 return ret; 123 129 } // build_constantInteger 124 130 125 Expression * build_constantFloat( const std::string & str ) {131 Expression * build_constantFloat( const std::string & str ) { 126 132 static const BasicType::Kind kind[2][3] = { 127 133 { BasicType::Float, BasicType::Double, BasicType::LongDouble }, … … 158 164 } // build_constantFloat 159 165 160 Expression * build_constantChar( const std::string & str ) {166 Expression * build_constantChar( const std::string & str ) { 161 167 Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) ); 162 168 delete &str; // created by lex … … 164 170 } // build_constantChar 165 171 166 ConstantExpr * build_constantStr( const std::string & str ) {172 ConstantExpr * build_constantStr( const std::string & str ) { 167 173 // string should probably be a primitive type 168 ArrayType * at = new ArrayType( noQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),169 new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), 174 ArrayType * at = new ArrayType( noQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), 175 new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"' 170 176 false, false ); 171 // constant 0 is ignored for pure string value 172 ConstantExpr * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) ); 177 ConstantExpr * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) ); // constant 0 is ignored for pure string value 173 178 delete &str; // created by lex 174 179 return ret; 175 180 } // build_constantStr 176 177 Expression *build_constantZeroOne( const std::string & str ) {178 Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( noQualifiers ) : (Type*)new OneType( noQualifiers ), str,179 str == "0" ? (unsigned long long int)0 : (unsigned long long int)1 ) );180 delete &str; // created by lex181 return ret;182 } // build_constantChar183 181 184 182 Expression * build_field_name_FLOATINGconstant( const std::string & str ) { … … 209 207 } // build_field_name_fraction_constants 210 208 211 212 213 209 Expression * build_field_name_REALFRACTIONconstant( const std::string & str ) { 214 210 if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str ); … … 225 221 } // build_field_name_REALDECIMALconstant 226 222 227 NameExpr * build_varref( const string * name ) {228 NameExpr * expr = new NameExpr( *name, nullptr );223 NameExpr * build_varref( const string * name ) { 224 NameExpr * expr = new NameExpr( *name, nullptr ); 229 225 delete name; 230 226 return expr; 231 } 232 233 // Must harmonize with OperKinds. 234 static const char * OperName[] = {227 } // build_varref 228 229 230 static const char * OperName[] = { // must harmonize with OperKinds 235 231 // diadic 236 232 "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?\\?", "?*?", "?/?", "?%?", "||", "&&", … … 240 236 // monadic 241 237 "+?", "-?", "AddressOf", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "&&" 242 }; 243 244 Expression * build_cast( DeclarationNode *decl_node, ExpressionNode *expr_node ) {245 Type * targetType = maybeMoveBuildType( decl_node );238 }; // OperName 239 240 Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) { 241 Type * targetType = maybeMoveBuildType( decl_node ); 246 242 if ( dynamic_cast< VoidType * >( targetType ) ) { 247 243 delete targetType; … … 250 246 return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType ); 251 247 } // if 252 } 253 254 255 Expression *build_virtual_cast( DeclarationNode *decl_node, ExpressionNode *expr_node ) { 256 Type *targetType = maybeMoveBuildType( decl_node ); 257 Expression *castArg = maybeMoveBuild< Expression >( expr_node ); 248 } // build_cast 249 250 Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) { 251 Type * targetType = maybeMoveBuildType( decl_node ); 252 Expression * castArg = maybeMoveBuild< Expression >( expr_node ); 258 253 return new VirtualCastExpr( castArg, targetType ); 259 } 260 261 Expression * build_fieldSel( ExpressionNode *expr_node, Expression *member ) {262 UntypedMemberExpr * ret = new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );263 return ret; 264 } 265 266 Expression * build_pfieldSel( ExpressionNode *expr_node, Expression *member ) {267 UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );254 } // build_virtual_cast 255 256 Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member ) { 257 UntypedMemberExpr * ret = new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) ); 258 return ret; 259 } // build_fieldSel 260 261 Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member ) { 262 UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) ); 268 263 deref->location = expr_node->location; 269 264 deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) ); 270 UntypedMemberExpr * ret = new UntypedMemberExpr( member, deref );271 return ret; 272 } 273 274 Expression * build_addressOf( ExpressionNode *expr_node ) {265 UntypedMemberExpr * ret = new UntypedMemberExpr( member, deref ); 266 return ret; 267 } // build_pfieldSel 268 269 Expression * build_addressOf( ExpressionNode * expr_node ) { 275 270 return new AddressExpr( maybeMoveBuild< Expression >(expr_node) ); 276 } 277 Expression *build_sizeOfexpr( ExpressionNode *expr_node ) { 271 } // build_addressOf 272 273 Expression * build_sizeOfexpr( ExpressionNode * expr_node ) { 278 274 return new SizeofExpr( maybeMoveBuild< Expression >(expr_node) ); 279 } 280 Expression *build_sizeOftype( DeclarationNode *decl_node ) { 275 } // build_sizeOfexpr 276 277 Expression * build_sizeOftype( DeclarationNode * decl_node ) { 281 278 return new SizeofExpr( maybeMoveBuildType( decl_node ) ); 282 } 283 Expression *build_alignOfexpr( ExpressionNode *expr_node ) { 279 } // build_sizeOftype 280 281 Expression * build_alignOfexpr( ExpressionNode * expr_node ) { 284 282 return new AlignofExpr( maybeMoveBuild< Expression >(expr_node) ); 285 } 286 Expression *build_alignOftype( DeclarationNode *decl_node ) { 283 } // build_alignOfexpr 284 285 Expression * build_alignOftype( DeclarationNode * decl_node ) { 287 286 return new AlignofExpr( maybeMoveBuildType( decl_node) ); 288 } 289 Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member ) { 287 } // build_alignOftype 288 289 Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) { 290 290 Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() ); 291 291 delete member; 292 292 return ret; 293 } 294 295 Expression * build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ) {293 } // build_offsetOf 294 295 Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind ) { 296 296 return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind ); 297 } 298 299 Expression * build_unary_val( OperKinds op, ExpressionNode *expr_node ) {297 } // build_and_or 298 299 Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ) { 300 300 std::list< Expression * > args; 301 301 args.push_back( maybeMoveBuild< Expression >(expr_node) ); 302 302 return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); 303 } 304 Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ) { 303 } // build_unary_val 304 305 Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) { 305 306 std::list< Expression * > args; 306 307 args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node) ) ); 307 308 return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); 308 } 309 Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) { 309 } // build_unary_ptr 310 311 Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) { 310 312 std::list< Expression * > args; 311 313 args.push_back( maybeMoveBuild< Expression >(expr_node1) ); 312 314 args.push_back( maybeMoveBuild< Expression >(expr_node2) ); 313 315 return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); 314 } 315 Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) { 316 } // build_binary_val 317 318 Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) { 316 319 std::list< Expression * > args; 317 320 args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node1) ) ); 318 321 args.push_back( maybeMoveBuild< Expression >(expr_node2) ); 319 322 return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); 320 } 321 322 Expression * build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ) {323 } // build_binary_ptr 324 325 Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ) { 323 326 return new ConditionalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), maybeMoveBuild< Expression >(expr_node2), maybeMoveBuild< Expression >(expr_node3) ); 324 } 325 326 Expression * build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {327 } // build_cond 328 329 Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) { 327 330 return new CommaExpr( maybeMoveBuild< Expression >(expr_node1), maybeMoveBuild< Expression >(expr_node2) ); 328 } 329 330 Expression * build_attrexpr( NameExpr *var, ExpressionNode * expr_node ) {331 } // build_comma 332 333 Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node ) { 331 334 return new AttrExpr( var, maybeMoveBuild< Expression >(expr_node) ); 332 } 333 Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node ) { 335 } // build_attrexpr 336 337 Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node ) { 334 338 return new AttrExpr( var, maybeMoveBuildType( decl_node ) ); 335 } 336 337 Expression * build_tuple( ExpressionNode * expr_node ) {339 } // build_attrtype 340 341 Expression * build_tuple( ExpressionNode * expr_node ) { 338 342 std::list< Expression * > exprs; 339 343 buildMoveList( expr_node, exprs ); 340 344 return new UntypedTupleExpr( exprs );; 341 } 342 343 Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ) {345 } // build_tuple 346 347 Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ) { 344 348 std::list< Expression * > args; 345 349 buildMoveList( expr_node, args ); 346 350 return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr ); 347 } 348 349 Expression * build_range( ExpressionNode * low, ExpressionNode *high ) {351 } // build_func 352 353 Expression * build_range( ExpressionNode * low, ExpressionNode * high ) { 350 354 return new RangeExpr( maybeMoveBuild< Expression >( low ), maybeMoveBuild< Expression >( high ) ); 351 } 352 353 Expression * build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ) {355 } // build_range 356 357 Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand ) { 354 358 return new AsmExpr( maybeMoveBuild< Expression >( inout ), constraint, maybeMoveBuild< Expression >(operand) ); 355 } 356 357 Expression * build_valexpr( StatementNode *s ) {359 } // build_asmexpr 360 361 Expression * build_valexpr( StatementNode * s ) { 358 362 return new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(s) ) ); 359 } 360 Expression *build_typevalue( DeclarationNode *decl ) { 363 } // build_valexpr 364 365 Expression * build_typevalue( DeclarationNode * decl ) { 361 366 return new TypeExpr( maybeMoveBuildType( decl ) ); 362 } 363 364 Expression * build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids ) {367 } // build_typevalue 368 369 Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) { 365 370 Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type 366 371 if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type … … 388 393 assert( false ); 389 394 } // if 390 } 395 } // build_compoundLiteral 391 396 392 397 // Local Variables: // -
src/Parser/InitializerNode.cc
r275f4b4 rcd7ef0b 10 10 // Created On : Sat May 16 13:20:24 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Sat Oct 1 23:09:51 201613 // Update Count : 2 112 // Last Modified On : Fri Jul 28 23:27:20 2017 13 // Update Count : 26 14 14 // 15 15 … … 22 22 #include "SynTree/Initializer.h" 23 23 24 InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode *des )25 : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0), maybeConstructed( true ) {24 InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode * des ) 25 : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) { 26 26 if ( aggrp ) 27 27 kids = dynamic_cast< InitializerNode * >( get_next() ); 28 28 29 if ( kids != 0)30 set_last( 0);31 } 29 if ( kids ) 30 set_last( nullptr ); 31 } // InitializerNode::InitializerNode 32 32 33 InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode *des )34 : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0), maybeConstructed( true ) {35 if ( init != 0)33 InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode * des ) 34 : expr( nullptr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) { 35 if ( init ) 36 36 set_last( init ); 37 37 … … 39 39 kids = dynamic_cast< InitializerNode * >( get_next() ); 40 40 41 if ( kids != 0)42 set_next( 0);43 } 41 if ( kids ) 42 set_next( nullptr ); 43 } // InitializerNode::InitializerNode 44 44 45 45 InitializerNode::~InitializerNode() { … … 47 47 delete designator; 48 48 delete kids; 49 } 49 } // InitializerNode::~InitializerNode 50 50 51 51 void InitializerNode::print( std::ostream &os, int indent ) const { 52 52 os << std::string( indent, ' ' ) << "Initializer expression" << std::endl; 53 } 53 } // InitializerNode::print 54 54 55 55 void InitializerNode::printOneLine( std::ostream &os ) const { 56 56 if ( ! aggregate ) { 57 if ( designator != 0) {57 if ( designator ) { 58 58 os << "designated by: ("; 59 59 ExpressionNode *curdes = designator; 60 while ( curdes != 0) {60 while ( curdes != nullptr) { 61 61 curdes->printOneLine(os); 62 62 curdes = (ExpressionNode *)(curdes->get_next()); … … 65 65 os << ")"; 66 66 } // if 67 if ( expr ) expr->printOneLine( os);67 if ( expr ) expr->printOneLine( os ); 68 68 } else { // It's an aggregate 69 69 os << "[--"; 70 if ( next_init() != 0)71 next_init()->printOneLine( os);70 if ( next_init() != nullptr ) 71 next_init()->printOneLine( os ); 72 72 if (aggregate) os << "--]"; 73 73 } // if … … 76 76 if ( (moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) ) { 77 77 moreInit->printOneLine( os ); 78 } 79 } 78 } // if 79 } // InitializerNode::printOneLine 80 80 81 Initializer * InitializerNode::build() const {81 Initializer * InitializerNode::build() const { 82 82 if ( aggregate ) { 83 83 // steal designators from children … … 93 93 return new ListInit( initlist, designlist, maybeConstructed ); 94 94 } else { 95 if ( get_expression() != 0) {95 if ( get_expression() ) { 96 96 return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed ); 97 } 97 } // if 98 98 } // if 99 return 0;100 } 99 return nullptr; 100 } // InitializerNode::build 101 101 102 102 // Local Variables: // -
src/Parser/ParseNode.h
r275f4b4 rcd7ef0b 9 9 // Author : Rodolfo G. Esteves 10 10 // Created On : Sat May 16 13:28:16 2015 11 // Last Modified By : Andrew Beach12 // Last Modified On : T us Jul 25 10:09:00201713 // Update Count : 78 711 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Thu Jul 27 12:08:08 2017 13 // Update Count : 788 14 14 // 15 15 … … 159 159 Expression * build_constantFloat( const std::string &str ); 160 160 Expression * build_constantChar( const std::string &str ); 161 Expression * build_constantZeroOne( const std::string &str );162 161 ConstantExpr * build_constantStr( const std::string &str ); 163 162 Expression * build_field_name_FLOATINGconstant( const std::string & str ); -
src/Parser/TypeData.cc
r275f4b4 rcd7ef0b 10 10 // Created On : Sat May 16 15:12:51 2015 11 11 // Last Modified By : Andrew Beach 12 // Last Modified On : Tus Jul 18 10:10:00 201713 // Update Count : 56 612 // Last Modified On : Wed Aug 9 13:50:00 2017 13 // Update Count : 567 14 14 // 15 15 … … 748 748 } // buildAggInst 749 749 750 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs ) {750 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) { 751 751 assert( td->kind == TypeData::Symbolic ); 752 752 NamedTypeDecl * ret; 753 753 assert( td->base ); 754 754 if ( td->symbolic.isTypedef ) { 755 ret = new TypedefDecl( name, scs, typebuild( td->base ) );755 ret = new TypedefDecl( name, scs, typebuild( td->base ), linkage ); 756 756 } else { 757 757 ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Any ); … … 817 817 return buildEnum( td, attributes ); 818 818 } else if ( td->kind == TypeData::Symbolic ) { 819 return buildSymbolic( td, name, scs );819 return buildSymbolic( td, name, scs, linkage ); 820 820 } else { 821 821 return (new ObjectDecl( name, scs, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName ); -
src/Parser/lex.ll
r275f4b4 rcd7ef0b 10 10 * Created On : Sat Sep 22 08:58:10 2001 11 11 * Last Modified By : Peter A. Buhr 12 * Last Modified On : Mon Jul 24 08:27:23201713 * Update Count : 5 4512 * Last Modified On : Thu Jul 27 21:46:06 2017 13 * Update Count : 550 14 14 */ 15 15 16 16 %option yylineno 17 %option noyywrap 17 18 %option nounput 18 19 … … 288 289 289 290 /* numeric constants */ 290 "0" { NUMERIC_RETURN(ZERO); } // CFA291 "1" { NUMERIC_RETURN(ONE); } // CFA292 291 {decimal_constant} { NUMERIC_RETURN(INTEGERconstant); } 293 292 {octal_constant} { NUMERIC_RETURN(INTEGERconstant); } … … 420 419 421 420 /* unknown characters */ 422 . { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }421 . { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); } 423 422 424 423 %% -
src/Parser/parser.yy
r275f4b4 rcd7ef0b 10 10 // Created On : Sat Sep 1 20:22:55 2001 11 11 // Last Modified By : Andrew Beach 12 // Last Modified On : Tus Jul 25 10:07:00 201713 // Update Count : 24 6412 // Last Modified On : Wed Aug 4 13:33:00 2017 13 // Update Count : 2475 14 14 // 15 15 … … 142 142 // converted into the tuple index (.)(1). e.g., 3.x 143 143 %token<tok> REALDECIMALconstant REALFRACTIONconstant FLOATINGconstant 144 %token<tok> ZERO ONE // CFA145 144 146 145 // multi-character operators … … 159 158 %token ATassign // @= 160 159 161 %type<tok> identifier no_attr_identifier zero_one160 %type<tok> identifier no_attr_identifier 162 161 %type<tok> identifier_or_type_name no_attr_identifier_or_type_name attr_name 163 162 %type<constant> string_literal … … 183 182 %type<en> asm_clobbers_list_opt 184 183 %type<flag> asm_volatile_opt 184 %type<en> handler_predicate_opt 185 185 186 186 // statements … … 360 360 ; 361 361 362 zero_one: // CFA363 ZERO364 | ONE365 ;366 367 362 string_literal: 368 363 string_literal_list { $$ = build_constantStr( *$1 ); } … … 384 379 IDENTIFIER // typedef name cannot be used as a variable name 385 380 { $$ = new ExpressionNode( build_varref( $1 ) ); } 386 | zero_one387 { $$ = new ExpressionNode( build_constantZeroOne( *$1 ) ); }388 381 | tuple 389 382 | '(' comma_expression ')' … … 485 478 $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) ); 486 479 } 487 | zero_one fraction_constants488 {489 $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantZeroOne( *$1 ), $2 ) );490 }491 480 ; 492 481 … … 539 528 | ALIGNOF unary_expression // GCC, variable alignment 540 529 { $$ = new ExpressionNode( build_alignOfexpr( $2 ) ); } 541 | ALIGNOF '(' type_no_function ')' // GCC, type alignment530 | ALIGNOF '(' type_no_function ')' // GCC, type alignment 542 531 { $$ = new ExpressionNode( build_alignOftype( $3 ) ); } 543 532 | OFFSETOF '(' type_no_function ',' no_attr_identifier ')' … … 980 969 981 970 handler_clause: 982 // TEMPORARY, TEST EXCEPTIONS 983 handler_key '(' push push INTEGERconstant pop ')' compound_statement pop 984 { $$ = new StatementNode( build_catch( $1, nullptr, new ExpressionNode( build_constantInteger( *$5 ) ), $8 ) ); } 985 | handler_clause handler_key '(' push push INTEGERconstant pop ')' compound_statement pop 986 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, nullptr, new ExpressionNode( build_constantInteger( *$6 ) ), $9 ) ) ); } 987 988 | handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop 989 { $$ = new StatementNode( build_catch( $1, $5, nullptr, $9 ) ); } 971 handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop 972 { $$ = new StatementNode( build_catch( $1, $5, $7, $9 ) ); } 990 973 | handler_clause handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop 991 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, nullptr, $10 ) ) ); }974 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, $8, $10 ) ) ); } 992 975 ; 993 976 994 977 handler_predicate_opt: 995 978 //empty 979 { $$ = nullptr; } 996 980 | ';' conditional_expression 981 { $$ = $2; } 997 982 ; 998 983 … … 1686 1671 | aggregate_key attribute_list_opt typegen_name // CFA 1687 1672 { $$ = $3->addQualifiers( $2 ); } 1688 1689 // Temp, testing TreeStruct1690 | STRUCT TRY attribute_list_opt no_attr_identifier_or_type_name1691 {1692 typedefTable.makeTypedef( *$4 ); // create typedef1693 if ( forall ) typedefTable.changeKind( *$4, TypedefTable::TG ); // $1694 forall = false; // reset1695 }1696 '{' field_declaration_list '}'1697 {1698 $$ = DeclarationNode::newTreeStruct( DeclarationNode::Struct,1699 $4, nullptr, nullptr, $7, true )->addQualifiers( $3 );1700 }1701 | STRUCT TRY attribute_list_opt no_attr_identifier_or_type_name TYPEDEFname1702 {1703 typedefTable.makeTypedef( *$4 ); // create typedef1704 if ( forall ) typedefTable.changeKind( *$4, TypedefTable::TG ); // $1705 forall = false; // reset1706 }1707 '{' field_declaration_list '}'1708 {1709 $$ = DeclarationNode::newTreeStruct( DeclarationNode::Struct,1710 $4, $5, nullptr, $8, true )->addQualifiers( $3 );1711 }1712 1673 ; 1713 1674 … … 1969 1930 | '=' initializer 1970 1931 { $$ = $2; } 1932 | '=' VOID 1933 { $$ = nullptr; } 1971 1934 | ATassign initializer 1972 1935 { $$ = $2->set_maybeConstructed( false ); }
Note:
See TracChangeset
for help on using the changeset viewer.
