- Timestamp:
- May 16, 2019, 1:54:43 PM (6 years ago)
- Branches:
- ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum
- Children:
- 1fb7bfd, f3cc5b6
- Parents:
- 54e41b3 (diff), aa00626 (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. - git-author:
- Aaron Moss <a3moss@…> (05/16/19 13:46:32)
- git-committer:
- Aaron Moss <a3moss@…> (05/16/19 13:54:43)
- Location:
- src
- Files:
-
- 9 edited
-
AST/CVQualifiers.hpp (modified) (2 diffs)
-
AST/Decl.cpp (modified) (1 diff)
-
AST/Decl.hpp (modified) (3 diffs)
-
AST/Pass.hpp (modified) (2 diffs)
-
AST/Pass.impl.hpp (modified) (8 diffs)
-
AST/Pass.proto.hpp (modified) (1 diff)
-
AST/Stmt.hpp (modified) (22 diffs)
-
Parser/lex.ll (modified) (2 diffs)
-
Parser/parser.yy (modified) (6 diffs)
Legend:
- Unmodified
- Added
- Removed
-
src/AST/CVQualifiers.hpp
r54e41b3 r24afc53 59 59 // ordering is a subtype relationship over qualifiers, e.g. `int` => `const int` is free 60 60 61 bool operator== ( Qualifiers a, Qualifiers b ) {62 return (a & EquivQualifiers) == (b& EquivQualifiers);61 inline bool operator== ( Qualifiers a, Qualifiers b ) { 62 return (a.val & EquivQualifiers) == (b.val & EquivQualifiers); 63 63 } 64 bool operator!= ( Qualifiers a, Qualifiers b ) {65 return (a & EquivQualifiers) != (b & EquivQualifiers);64 inline bool operator!= ( Qualifiers a, Qualifiers b ) { 65 return !(a == b); 66 66 } 67 bool operator<= ( Qualifiers a, Qualifiers b ) {67 inline bool operator<= ( Qualifiers a, Qualifiers b ) { 68 68 return a.is_const <= b.is_const // non-const converts to const for free 69 69 && a.is_volatile <= b.is_volatile // non-volatile converts to volatile for free … … 71 71 && a.is_atomic == b.is_atomic; // atomicity must be preserved in free conversion 72 72 } 73 bool operator< ( Qualifiers a, Qualifiers b ) { return a != b && a <= b; }74 bool operator>= ( Qualifiers a, Qualifiers b ) { return b <= a; }75 bool operator> ( Qualifiers a, Qualifiers b ) { return b < a; }73 inline bool operator< ( Qualifiers a, Qualifiers b ) { return a != b && a <= b; } 74 inline bool operator>= ( Qualifiers a, Qualifiers b ) { return b <= a; } 75 inline bool operator> ( Qualifiers a, Qualifiers b ) { return b < a; } 76 76 77 77 } -
src/AST/Decl.cpp
r54e41b3 r24afc53 45 45 } 46 46 47 // --- FunctionDecl 48 49 const Type * FunctionDecl::get_type() const override { return type.get(); } 50 void FunctionDecl::set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); } 51 47 52 // --- TypeDecl 48 53 49 54 std::string TypeDecl::typeString() const { 50 55 static const std::string kindNames[] = { "object type", "function type", "tuple type" }; 51 assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, 56 assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, 52 57 "typeString: kindNames is out of sync." ); 53 58 assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." ); -
src/AST/Decl.hpp
r54e41b3 r24afc53 114 114 }; 115 115 116 /// Object declaration `int foo()` 116 117 class FunctionDecl : public DeclWithType { 117 118 public: … … 126 127 stmts( stmts ) {} 127 128 128 const Type * get_type() const override { return type.get(); }129 void set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); }129 const Type * get_type() const override; 130 void set_type(Type * t) override; 130 131 131 132 bool has_body() const { return stmts; } … … 184 185 TypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, Type* b, 185 186 TypeVar::Kind k, bool s, Type* i = nullptr ) 186 : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeVar::Ttype || s ), 187 : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeVar::Ttype || s ), 187 188 init( i ) {} 188 189 -
src/AST/Pass.hpp
r54e41b3 r24afc53 29 29 #include "AST/Init.hpp" 30 30 #include "AST/Stmt.hpp" 31 #include "AST/Type.hpp" 31 32 32 33 #include "AST/Visitor.hpp" … … 189 190 190 191 template< typename node_t > 191 auto call_accept( const node_t * node ) -> decltype( node->accept(*this) ); 192 auto call_accept( const node_t * node ) -> typename std::enable_if< 193 !std::is_base_of<ast::Expr, node_t>::value && 194 !std::is_base_of<ast::Stmt, node_t>::value 195 , decltype( node->accept(*this) ) 196 >::type; 192 197 193 198 template< template <class...> class container_t > -
src/AST/Pass.impl.hpp
r54e41b3 r24afc53 64 64 65 65 std::transform(decls->begin(), decls->end(), it, [](const ast::Decl * decl) -> auto { 66 return new DeclStmt( decl );66 return new DeclStmt( decl->location, decl ); 67 67 }); 68 68 decls->clear(); … … 119 119 template< typename pass_t > 120 120 template< typename node_t > 121 auto Pass< pass_t >::call_accept( const node_t * node ) -> decltype( node->accept(*this) ) { 121 auto Pass< pass_t >::call_accept( const node_t * node ) 122 -> typename std::enable_if< 123 !std::is_base_of<ast::Expr, node_t>::value && 124 !std::is_base_of<ast::Stmt, node_t>::value 125 , decltype( node->accept(*this) ) 126 >::type 127 128 { 122 129 __pedantic_pass_assert( __visit_children() ); 123 130 __pedantic_pass_assert( expr ); … … 296 303 child_t parent_t::*child 297 304 ) { 298 static_assert( std::is_base_of<parent_t, node_t>::value, "Error deduc tiing member object" );305 static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" ); 299 306 300 307 if(__pass::skip(parent->*child)) return; … … 424 431 new ast::ArrayType( 425 432 new ast::BasicType( ast::BasicType::Char, ast::CV::Qualifiers( ast::CV::Const ) ), 426 nullptr, true, false433 nullptr, VariableLen, DynamicDim 427 434 ) 428 435 ); … … 434 441 ValueGuard< bool > oldInFunction( inFunction ); 435 442 inFunction = true; 436 maybe_accept( node, &FunctionDecl::st atements );443 maybe_accept( node, &FunctionDecl::stmts ); 437 444 maybe_accept( node, &FunctionDecl::attributes ); 438 445 ) … … 537 544 538 545 VISIT( 539 maybe_accept( node, &TypeDecl::assertions , *this);546 maybe_accept( node, &TypeDecl::assertions ); 540 547 541 548 { … … 614 621 } 615 622 623 //-------------------------------------------------------------------------- 624 // ExprStmt 625 template< typename pass_t > 626 const ast::Stmt * ast::Pass< pass_t >::visit( const ExprStmt * node ) { 627 VISIT_START( node ); 628 629 VISIT( 630 maybe_accept( node, &ExprStmt::expr ); 631 ) 632 633 VISIT_END( Stmt, node ); 634 } 635 636 //-------------------------------------------------------------------------- 637 // AsmStmt 638 template< typename pass_t > 639 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::AsmStmt * node ) { 640 VISIT_START( node ) 641 642 VISIT( 643 maybe_accept( node, &AsmStmt::instruction ); 644 maybe_accept( node, &AsmStmt::output ); 645 maybe_accept( node, &AsmStmt::input ); 646 maybe_accept( node, &AsmStmt::clobber ); 647 ) 648 649 VISIT_END( Stmt, node ); 650 } 651 652 //-------------------------------------------------------------------------- 653 // DirectiveStmt 654 template< typename pass_t > 655 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DirectiveStmt * node ) { 656 VISIT_START( node ) 657 658 VISIT_END( Stmt, node ); 659 } 660 661 //-------------------------------------------------------------------------- 662 // IfStmt 663 template< typename pass_t > 664 const ast::Stmt * ast::Pass< pass_t >::visit( const ast::IfStmt * node ) { 665 VISIT_START( node ); 666 VISIT({ 667 // if statements introduce a level of scope (for the initialization) 668 guard_indexer guard { *this }; 669 maybe_accept( node, &IfStmt::inits ); 670 maybe_accept( node, &IfStmt::cond ); 671 maybe_accept( node, &IfStmt::thenPart ); 672 maybe_accept( node, &IfStmt::elsePart ); 673 }) 674 VISIT_END( Stmt, node ); 675 } 676 677 //-------------------------------------------------------------------------- 678 // WhileStmt 679 template< typename pass_t > 680 const ast::Stmt * ast::Pass< pass_t >::visit( const WhileStmt * node ) { 681 VISIT_START( node ); 682 683 VISIT({ 684 // while statements introduce a level of scope (for the initialization) 685 guard_indexer guard { *this }; 686 maybe_accept( node, &WhileStmt::inits ); 687 maybe_accept( node, &WhileStmt::cond ); 688 maybe_accept( node, &WhileStmt::body ); 689 }) 690 691 VISIT_END( Stmt, node ); 692 } 616 693 617 694 //-------------------------------------------------------------------------- … … 667 744 ) 668 745 669 VISIT_END( Attribute *, node );746 VISIT_END( Attribute, node ); 670 747 } 671 748 -
src/AST/Pass.proto.hpp
r54e41b3 r24afc53 241 241 INDEXER_FUNC1( addUnion , const UnionDecl * ); 242 242 INDEXER_FUNC1( addTrait , const TraitDecl * ); 243 INDEXER_FUNC2( addWith , const std::list< Expression *> &, const Node * );243 INDEXER_FUNC2( addWith , const std::list< ptr<Expr> > &, const Node * ); 244 244 245 245 // A few extra functions have more complicated behaviour, they are hand written -
src/AST/Stmt.hpp
r54e41b3 r24afc53 62 62 private: 63 63 CompoundStmt* clone() const override { return new CompoundStmt{ *this }; } 64 65 /// Must be copied in ALL derived classes 66 template<typename node_t> 67 friend auto mutate(const node_t * node); 64 68 }; 65 69 … … 73 77 private: 74 78 NullStmt* clone() const override { return new NullStmt{ *this }; } 79 80 /// Must be copied in ALL derived classes 81 template<typename node_t> 82 friend auto mutate(const node_t * node); 75 83 }; 76 84 … … 80 88 ptr<Expr> expr; 81 89 82 ExprStmt( const CodeLocation & loc, const Expr* e ) : Stmt(loc), expr(e) {}90 ExprStmt( const CodeLocation & loc, const Expr * e ) : Stmt(loc), expr(e) {} 83 91 84 92 const Stmt * accept( Visitor& v ) const override { return v.visit( this ); } 85 93 private: 86 94 ExprStmt * clone() const override { return new ExprStmt{ *this }; } 95 96 /// Must be copied in ALL derived classes 97 template<typename node_t> 98 friend auto mutate(const node_t * node); 87 99 }; 88 100 … … 106 118 private: 107 119 AsmStmt* clone() const override { return new AsmStmt{ *this }; } 120 121 /// Must be copied in ALL derived classes 122 template<typename node_t> 123 friend auto mutate(const node_t * node); 108 124 }; 109 125 … … 119 135 private: 120 136 DirectiveStmt* clone() const override { return new DirectiveStmt{ *this }; } 137 138 /// Must be copied in ALL derived classes 139 template<typename node_t> 140 friend auto mutate(const node_t * node); 121 141 }; 122 142 … … 137 157 private: 138 158 IfStmt* clone() const override { return new IfStmt{ *this }; } 159 160 /// Must be copied in ALL derived classes 161 template<typename node_t> 162 friend auto mutate(const node_t * node); 139 163 }; 140 164 … … 151 175 private: 152 176 SwitchStmt* clone() const override { return new SwitchStmt{ *this }; } 177 178 /// Must be copied in ALL derived classes 179 template<typename node_t> 180 friend auto mutate(const node_t * node); 153 181 }; 154 182 … … 167 195 private: 168 196 CaseStmt* clone() const override { return new CaseStmt{ *this }; } 197 198 /// Must be copied in ALL derived classes 199 template<typename node_t> 200 friend auto mutate(const node_t * node); 169 201 }; 170 202 … … 184 216 private: 185 217 WhileStmt* clone() const override { return new WhileStmt{ *this }; } 218 219 /// Must be copied in ALL derived classes 220 template<typename node_t> 221 friend auto mutate(const node_t * node); 186 222 }; 187 223 … … 190 226 std::vector<ptr<Stmt>> inits; 191 227 ptr<Expr> cond; 192 ptr<Expr> inc rement;228 ptr<Expr> inc; 193 229 ptr<Stmt> body; 194 230 195 231 ForStmt( const CodeLocation& loc, std::vector<ptr<Stmt>>&& inits, const Expr* cond, 196 const Expr* inc rement, const Stmt* body, std::vector<Label>&& labels = {} )197 : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc rement(increment),232 const Expr* inc, const Stmt* body, std::vector<Label>&& labels = {} ) 233 : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), 198 234 body(body) {} 199 235 … … 201 237 private: 202 238 ForStmt* clone() const override { return new ForStmt{ *this }; } 239 240 /// Must be copied in ALL derived classes 241 template<typename node_t> 242 friend auto mutate(const node_t * node); 203 243 }; 204 244 … … 225 265 private: 226 266 BranchStmt* clone() const override { return new BranchStmt{ *this }; } 267 268 /// Must be copied in ALL derived classes 269 template<typename node_t> 270 friend auto mutate(const node_t * node); 271 227 272 static const char * kindNames[kindEnd]; 228 273 }; … … 238 283 private: 239 284 ReturnStmt* clone() const override { return new ReturnStmt{ *this }; } 285 286 /// Must be copied in ALL derived classes 287 template<typename node_t> 288 friend auto mutate(const node_t * node); 240 289 }; 241 290 … … 255 304 private: 256 305 ThrowStmt* clone() const override { return new ThrowStmt{ *this }; } 306 307 /// Must be copied in ALL derived classes 308 template<typename node_t> 309 friend auto mutate(const node_t * node); 257 310 }; 258 311 … … 271 324 private: 272 325 TryStmt* clone() const override { return new TryStmt{ *this }; } 326 327 /// Must be copied in ALL derived classes 328 template<typename node_t> 329 friend auto mutate(const node_t * node); 273 330 }; 274 331 … … 289 346 private: 290 347 CatchStmt* clone() const override { return new CatchStmt{ *this }; } 348 349 /// Must be copied in ALL derived classes 350 template<typename node_t> 351 friend auto mutate(const node_t * node); 291 352 }; 292 353 … … 302 363 private: 303 364 FinallyStmt* clone() const override { return new FinallyStmt{ *this }; } 365 366 /// Must be copied in ALL derived classes 367 template<typename node_t> 368 friend auto mutate(const node_t * node); 304 369 }; 305 370 … … 338 403 private: 339 404 WaitForStmt* clone() const override { return new WaitForStmt{ *this }; } 405 406 /// Must be copied in ALL derived classes 407 template<typename node_t> 408 friend auto mutate(const node_t * node); 340 409 }; 341 410 … … 352 421 private: 353 422 WithStmt* clone() const override { return new WithStmt{ *this }; } 423 424 /// Must be copied in ALL derived classes 425 template<typename node_t> 426 friend auto mutate(const node_t * node); 354 427 }; 355 428 … … 364 437 private: 365 438 DeclStmt* clone() const override { return new DeclStmt{ *this }; } 439 440 /// Must be copied in ALL derived classes 441 template<typename node_t> 442 friend auto mutate(const node_t * node); 366 443 }; 367 444 … … 377 454 private: 378 455 ImplicitCtorDtorStmt* clone() const override { return new ImplicitCtorDtorStmt{ *this }; } 456 457 /// Must be copied in ALL derived classes 458 template<typename node_t> 459 friend auto mutate(const node_t * node); 379 460 }; 380 461 … … 390 471 inline void increment( const class ExprStmt * node, Node::ref_type ref ) { node->increment( ref ); } 391 472 inline void decrement( const class ExprStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 392 //inline void increment( const class AsmStmt * node, Node::ref_type ref ) { node->increment( ref ); }393 //inline void decrement( const class AsmStmt * node, Node::ref_type ref ) { node->decrement( ref ); }394 //inline void increment( const class DirectiveStmt * node, Node::ref_type ref ) { node->increment( ref ); }395 //inline void decrement( const class DirectiveStmt * node, Node::ref_type ref ) { node->decrement( ref ); }396 //inline void increment( const class IfStmt * node, Node::ref_type ref ) { node->increment( ref ); }397 //inline void decrement( const class IfStmt * node, Node::ref_type ref ) { node->decrement( ref ); }398 //inline void increment( const class WhileStmt * node, Node::ref_type ref ) { node->increment( ref ); }399 //inline void decrement( const class WhileStmt * node, Node::ref_type ref ) { node->decrement( ref ); }400 //inline void increment( const class ForStmt * node, Node::ref_type ref ) { node->increment( ref ); }401 //inline void decrement( const class ForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }402 //inline void increment( const class SwitchStmt * node, Node::ref_type ref ) { node->increment( ref ); }403 //inline void decrement( const class SwitchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }404 //inline void increment( const class CaseStmt * node, Node::ref_type ref ) { node->increment( ref ); }405 //inline void decrement( const class CaseStmt * node, Node::ref_type ref ) { node->decrement( ref ); }406 //inline void increment( const class BranchStmt * node, Node::ref_type ref ) { node->increment( ref ); }407 //inline void decrement( const class BranchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }408 //inline void increment( const class ReturnStmt * node, Node::ref_type ref ) { node->increment( ref ); }409 //inline void decrement( const class ReturnStmt * node, Node::ref_type ref ) { node->decrement( ref ); }410 //inline void increment( const class ThrowStmt * node, Node::ref_type ref ) { node->increment( ref ); }411 //inline void decrement( const class ThrowStmt * node, Node::ref_type ref ) { node->decrement( ref ); }412 //inline void increment( const class TryStmt * node, Node::ref_type ref ) { node->increment( ref ); }413 //inline void decrement( const class TryStmt * node, Node::ref_type ref ) { node->decrement( ref ); }414 //inline void increment( const class CatchStmt * node, Node::ref_type ref ) { node->increment( ref ); }415 //inline void decrement( const class CatchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }416 //inline void increment( const class FinallyStmt * node, Node::ref_type ref ) { node->increment( ref ); }417 //inline void decrement( const class FinallyStmt * node, Node::ref_type ref ) { node->decrement( ref ); }418 //inline void increment( const class WaitForStmt * node, Node::ref_type ref ) { node->increment( ref ); }419 //inline void decrement( const class WaitForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }420 //inline void increment( const class WithStmt * node, Node::ref_type ref ) { node->increment( ref ); }421 //inline void decrement( const class WithStmt * node, Node::ref_type ref ) { node->decrement( ref ); }422 //inline void increment( const class DeclStmt * node, Node::ref_type ref ) { node->increment( ref ); }423 //inline void decrement( const class DeclStmt * node, Node::ref_type ref ) { node->decrement( ref ); }473 inline void increment( const class AsmStmt * node, Node::ref_type ref ) { node->increment( ref ); } 474 inline void decrement( const class AsmStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 475 inline void increment( const class DirectiveStmt * node, Node::ref_type ref ) { node->increment( ref ); } 476 inline void decrement( const class DirectiveStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 477 inline void increment( const class IfStmt * node, Node::ref_type ref ) { node->increment( ref ); } 478 inline void decrement( const class IfStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 479 inline void increment( const class WhileStmt * node, Node::ref_type ref ) { node->increment( ref ); } 480 inline void decrement( const class WhileStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 481 inline void increment( const class ForStmt * node, Node::ref_type ref ) { node->increment( ref ); } 482 inline void decrement( const class ForStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 483 inline void increment( const class SwitchStmt * node, Node::ref_type ref ) { node->increment( ref ); } 484 inline void decrement( const class SwitchStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 485 inline void increment( const class CaseStmt * node, Node::ref_type ref ) { node->increment( ref ); } 486 inline void decrement( const class CaseStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 487 inline void increment( const class BranchStmt * node, Node::ref_type ref ) { node->increment( ref ); } 488 inline void decrement( const class BranchStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 489 inline void increment( const class ReturnStmt * node, Node::ref_type ref ) { node->increment( ref ); } 490 inline void decrement( const class ReturnStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 491 inline void increment( const class ThrowStmt * node, Node::ref_type ref ) { node->increment( ref ); } 492 inline void decrement( const class ThrowStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 493 inline void increment( const class TryStmt * node, Node::ref_type ref ) { node->increment( ref ); } 494 inline void decrement( const class TryStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 495 inline void increment( const class CatchStmt * node, Node::ref_type ref ) { node->increment( ref ); } 496 inline void decrement( const class CatchStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 497 inline void increment( const class FinallyStmt * node, Node::ref_type ref ) { node->increment( ref ); } 498 inline void decrement( const class FinallyStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 499 inline void increment( const class WaitForStmt * node, Node::ref_type ref ) { node->increment( ref ); } 500 inline void decrement( const class WaitForStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 501 inline void increment( const class WithStmt * node, Node::ref_type ref ) { node->increment( ref ); } 502 inline void decrement( const class WithStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 503 inline void increment( const class DeclStmt * node, Node::ref_type ref ) { node->increment( ref ); } 504 inline void decrement( const class DeclStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 424 505 inline void increment( const class NullStmt * node, Node::ref_type ref ) { node->increment( ref ); } 425 506 inline void decrement( const class NullStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 426 //inline void increment( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->increment( ref ); }427 //inline void decrement( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->decrement( ref ); }507 inline void increment( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->increment( ref ); } 508 inline void decrement( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->decrement( ref ); } 428 509 429 510 } -
src/Parser/lex.ll
r54e41b3 r24afc53 10 10 * Created On : Sat Sep 22 08:58:10 2001 11 11 * Last Modified By : Peter A. Buhr 12 * Last Modified On : Wed Ma r 13 14:54:30201913 * Update Count : 70 712 * Last Modified On : Wed May 15 21:25:27 2019 13 * Update Count : 708 14 14 */ 15 15 … … 265 265 fortran { KEYWORD_RETURN(FORTRAN); } 266 266 ftype { KEYWORD_RETURN(FTYPE); } // CFA 267 generator { KEYWORD_RETURN(GENERATOR); } // CFA 267 268 _Generic { KEYWORD_RETURN(GENERIC); } // C11 268 269 goto { KEYWORD_RETURN(GOTO); } -
src/Parser/parser.yy
r54e41b3 r24afc53 10 10 // Created On : Sat Sep 1 20:22:55 2001 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon Apr 15 15:02:56201913 // Update Count : 429 012 // Last Modified On : Wed May 15 21:25:27 2019 13 // Update Count : 4296 14 14 // 15 15 … … 173 173 DeclarationNode * fieldDecl( DeclarationNode * typeSpec, DeclarationNode * fieldList ) { 174 174 if ( ! fieldList ) { // field declarator ? 175 if ( ! ( typeSpec->type && typeSpec->type->kind == TypeData::Aggregate) ) {175 if ( ! ( typeSpec->type && (typeSpec->type->kind == TypeData::Aggregate || typeSpec->type->kind == TypeData::Enum) ) ) { 176 176 stringstream ss; 177 177 typeSpec->type->print( ss ); … … 275 275 %token ENUM STRUCT UNION 276 276 %token EXCEPTION // CFA 277 %token COROUTINE MONITOR THREAD// CFA277 %token GENERATOR COROUTINE MONITOR THREAD // CFA 278 278 %token OTYPE FTYPE DTYPE TTYPE TRAIT // CFA 279 279 %token SIZEOF OFFSETOF … … 677 677 // empty 678 678 { $$ = nullptr; } 679 | ' ?' // CFA, default parameter679 | '@' // CFA, default parameter 680 680 { SemanticError( yylloc, "Default parameter for argument is currently unimplemented." ); $$ = nullptr; } 681 681 // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); } … … 796 796 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); } 797 797 // keyword cast cannot be grouped because of reduction in aggregate_key 798 | '(' GENERATOR '&' ')' cast_expression // CFA 799 { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); } 798 800 | '(' COROUTINE '&' ')' cast_expression // CFA 799 801 { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); } … … 2061 2063 | EXCEPTION 2062 2064 { yyy = true; $$ = DeclarationNode::Exception; } 2065 | GENERATOR 2066 { yyy = true; $$ = DeclarationNode::Coroutine; } 2063 2067 | COROUTINE 2064 2068 { yyy = true; $$ = DeclarationNode::Coroutine; }
Note: See TracChangeset
for help on using the changeset viewer.
