Changeset 1cb758f2 for src/SynTree

Timestamp:

Aug 27, 2017, 11:26:26 AM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

111a8af8, 26238c1, 7ee1e2f6

Parents:

0c6596f (diff), eca3d10 (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.

Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Location:

src/SynTree

Files:

• Mutator.cc (modified) (61 diffs)
• Mutator.h (modified) (1 diff)
• Statement.cc (modified) (1 diff)
• Statement.h (modified) (2 diffs)
• SynTree.h (modified) (1 diff)
• Visitor.cc (modified) (1 diff)
• Visitor.h (modified) (1 diff)

src/SynTree/Mutator.cc

@@ -32 +32 @@
 Mutator::~Mutator() {}
 
-DeclarationWithType *Mutator::mutate( ObjectDecl *objectDecl ) {
+DeclarationWithType * Mutator::mutate( ObjectDecl *objectDecl ) {
         objectDecl->set_type( maybeMutate( objectDecl->get_type(), *this ) );
         objectDecl->set_init( maybeMutate( objectDecl->get_init(), *this ) );
@@ -39 +39 @@
 }
 
-DeclarationWithType *Mutator::mutate( FunctionDecl *functionDecl ) {
+DeclarationWithType * Mutator::mutate( FunctionDecl *functionDecl ) {
         functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
         functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
@@ -45 +45 @@
 }
 
-Declaration *Mutator::handleAggregateDecl( AggregateDecl *aggregateDecl ) {
+Declaration * Mutator::handleAggregateDecl( AggregateDecl *aggregateDecl ) {
         mutateAll( aggregateDecl->get_parameters(), *this );
         mutateAll( aggregateDecl->get_members(), *this );
@@ -51 +51 @@
 }
 
-Declaration *Mutator::mutate( StructDecl *aggregateDecl ) {
+Declaration * Mutator::mutate( StructDecl *aggregateDecl ) {
         handleAggregateDecl( aggregateDecl );
         return aggregateDecl;
 }
 
-Declaration *Mutator::mutate( UnionDecl *aggregateDecl ) {
+Declaration * Mutator::mutate( UnionDecl *aggregateDecl ) {
         handleAggregateDecl( aggregateDecl );
         return aggregateDecl;
 }
 
-Declaration *Mutator::mutate( EnumDecl *aggregateDecl ) {
+Declaration * Mutator::mutate( EnumDecl *aggregateDecl ) {
         handleAggregateDecl( aggregateDecl );
         return aggregateDecl;
 }
 
-Declaration *Mutator::mutate( TraitDecl *aggregateDecl ) {
+Declaration * Mutator::mutate( TraitDecl *aggregateDecl ) {
         handleAggregateDecl( aggregateDecl );
         return aggregateDecl;
 }
 
-Declaration *Mutator::handleNamedTypeDecl( NamedTypeDecl *typeDecl ) {
+Declaration * Mutator::handleNamedTypeDecl( NamedTypeDecl *typeDecl ) {
         mutateAll( typeDecl->get_parameters(), *this );
         mutateAll( typeDecl->get_assertions(), *this );
@@ -78 +78 @@
 }
 
-TypeDecl *Mutator::mutate( TypeDecl *typeDecl ) {
+TypeDecl * Mutator::mutate( TypeDecl *typeDecl ) {
         handleNamedTypeDecl( typeDecl );
         typeDecl->set_init( maybeMutate( typeDecl->get_init(), *this ) );
@@ -84 +84 @@
 }
 
-Declaration *Mutator::mutate( TypedefDecl *typeDecl ) {
+Declaration * Mutator::mutate( TypedefDecl *typeDecl ) {
         handleNamedTypeDecl( typeDecl );
         return typeDecl;
 }
 
-AsmDecl *Mutator::mutate( AsmDecl *asmDecl ) {
+AsmDecl * Mutator::mutate( AsmDecl *asmDecl ) {
         asmDecl->set_stmt( maybeMutate( asmDecl->get_stmt(), *this ) );
         return asmDecl;
@@ -95 +95 @@
 
 
-CompoundStmt *Mutator::mutate( CompoundStmt *compoundStmt ) {
+CompoundStmt * Mutator::mutate( CompoundStmt *compoundStmt ) {
         mutateAll( compoundStmt->get_kids(), *this );
         return compoundStmt;
 }
 
-Statement *Mutator::mutate( ExprStmt *exprStmt ) {
+Statement * Mutator::mutate( ExprStmt *exprStmt ) {
         exprStmt->set_expr( maybeMutate( exprStmt->get_expr(), *this ) );
         return exprStmt;
 }
 
-Statement *Mutator::mutate( AsmStmt *asmStmt ) {
+Statement * Mutator::mutate( AsmStmt *asmStmt ) {
         asmStmt->set_instruction( maybeMutate( asmStmt->get_instruction(), *this ) );
         mutateAll( asmStmt->get_output(), *this );
@@ -113 +113 @@
 }
 
-Statement *Mutator::mutate( IfStmt *ifStmt ) {
+Statement * Mutator::mutate( IfStmt *ifStmt ) {
         mutateAll( ifStmt->get_initialization(), *this );
         ifStmt->set_condition( maybeMutate( ifStmt->get_condition(), *this ) );
@@ -121 +121 @@
 }
 
-Statement *Mutator::mutate( WhileStmt *whileStmt ) {
+Statement * Mutator::mutate( WhileStmt *whileStmt ) {
         whileStmt->set_condition( maybeMutate( whileStmt->get_condition(), *this ) );
         whileStmt->set_body( maybeMutate( whileStmt->get_body(), *this ) );
@@ -127 +127 @@
 }
 
-Statement *Mutator::mutate( ForStmt *forStmt ) {
+Statement * Mutator::mutate( ForStmt *forStmt ) {
         mutateAll( forStmt->get_initialization(), *this );
         forStmt->set_condition( maybeMutate( forStmt->get_condition(), *this ) );
@@ -135 +135 @@
 }
 
-Statement *Mutator::mutate( SwitchStmt *switchStmt ) {
+Statement * Mutator::mutate( SwitchStmt *switchStmt ) {
         switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
         mutateAll( switchStmt->get_statements(), *this );
@@ -141 +141 @@
 }
 
-Statement *Mutator::mutate( CaseStmt *caseStmt ) {
+Statement * Mutator::mutate( CaseStmt *caseStmt ) {
         caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) );
         mutateAll (caseStmt->get_statements(), *this );
@@ -148 +148 @@
 }
 
-Statement *Mutator::mutate( BranchStmt *branchStmt ) {
+Statement * Mutator::mutate( BranchStmt *branchStmt ) {
         return branchStmt;
 }
 
-Statement *Mutator::mutate( ReturnStmt *returnStmt ) {
+Statement * Mutator::mutate( ReturnStmt *returnStmt ) {
         returnStmt->set_expr( maybeMutate( returnStmt->get_expr(), *this ) );
         return returnStmt;
 }
 
-Statement *Mutator::mutate( ThrowStmt *throwStmt ) {
+Statement * Mutator::mutate( ThrowStmt *throwStmt ) {
         throwStmt->set_expr( maybeMutate( throwStmt->get_expr(), *this ) );
         throwStmt->set_target( maybeMutate( throwStmt->get_target(), *this ) );
@@ -163 +163 @@
 }
 
-Statement *Mutator::mutate( TryStmt *tryStmt ) {
+Statement * Mutator::mutate( TryStmt *tryStmt ) {
         tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
         mutateAll( tryStmt->get_catchers(), *this );
@@ -170 +170 @@
 }
 
-Statement *Mutator::mutate( CatchStmt *catchStmt ) {
+Statement * Mutator::mutate( CatchStmt *catchStmt ) {
         catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
         catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) );
@@ -177 +177 @@
 }
 
-Statement *Mutator::mutate( FinallyStmt *finalStmt ) {
+Statement * Mutator::mutate( FinallyStmt *finalStmt ) {
         finalStmt->set_block( maybeMutate( finalStmt->get_block(), *this ) );
         return finalStmt;
 }
 
-NullStmt *Mutator::mutate( NullStmt *nullStmt ) {
+Statement * Mutator::mutate( WaitForStmt *waitforStmt ) {
+        for( auto & clause : waitforStmt->clauses ) {
+                clause.target.function = maybeMutate( clause.target.function, *this );
+                mutateAll( clause.target.arguments, *this );
+
+                clause.statement = maybeMutate( clause.statement, *this );
+                clause.condition = maybeMutate( clause.condition, *this );
+        }
+
+        waitforStmt->timeout.time      = maybeMutate( waitforStmt->timeout.time, *this );
+        waitforStmt->timeout.statement = maybeMutate( waitforStmt->timeout.statement, *this );
+        waitforStmt->timeout.condition = maybeMutate( waitforStmt->timeout.condition, *this );
+        waitforStmt->orelse.statement  = maybeMutate( waitforStmt->orelse.statement, *this );
+        waitforStmt->orelse.condition  = maybeMutate( waitforStmt->orelse.condition, *this );
+
+        return waitforStmt;
+}
+
+NullStmt * Mutator::mutate( NullStmt *nullStmt ) {
         return nullStmt;
 }
 
-Statement *Mutator::mutate( DeclStmt *declStmt ) {
+Statement * Mutator::mutate( DeclStmt *declStmt ) {
         declStmt->set_decl( maybeMutate( declStmt->get_decl(), *this ) );
         return declStmt;
 }
 
-Statement *Mutator::mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
+Statement * Mutator::mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
         impCtorDtorStmt->set_callStmt( maybeMutate( impCtorDtorStmt->get_callStmt(), *this ) );
         return impCtorDtorStmt;
@@ -197 +215 @@
 
 
-Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
+Expression * Mutator::mutate( ApplicationExpr *applicationExpr ) {
         applicationExpr->set_env( maybeMutate( applicationExpr->get_env(), *this ) );
         applicationExpr->set_result( maybeMutate( applicationExpr->get_result(), *this ) );
@@ -205 +223 @@
 }
 
-Expression *Mutator::mutate( UntypedExpr *untypedExpr ) {
+Expression * Mutator::mutate( UntypedExpr *untypedExpr ) {
         untypedExpr->set_env( maybeMutate( untypedExpr->get_env(), *this ) );
         untypedExpr->set_result( maybeMutate( untypedExpr->get_result(), *this ) );
@@ -212 +230 @@
 }
 
-Expression *Mutator::mutate( NameExpr *nameExpr ) {
+Expression * Mutator::mutate( NameExpr *nameExpr ) {
         nameExpr->set_env( maybeMutate( nameExpr->get_env(), *this ) );
         nameExpr->set_result( maybeMutate( nameExpr->get_result(), *this ) );
@@ -218 +236 @@
 }
 
-Expression *Mutator::mutate( AddressExpr *addressExpr ) {
+Expression * Mutator::mutate( AddressExpr *addressExpr ) {
         addressExpr->set_env( maybeMutate( addressExpr->get_env(), *this ) );
         addressExpr->set_result( maybeMutate( addressExpr->get_result(), *this ) );
@@ -225 +243 @@
 }
 
-Expression *Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
+Expression * Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
         labelAddressExpr->set_env( maybeMutate( labelAddressExpr->get_env(), *this ) );
         labelAddressExpr->set_result( maybeMutate( labelAddressExpr->get_result(), *this ) );
@@ -232 +250 @@
 }
 
-Expression *Mutator::mutate( CastExpr *castExpr ) {
+Expression * Mutator::mutate( CastExpr *castExpr ) {
         castExpr->set_env( maybeMutate( castExpr->get_env(), *this ) );
         castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
@@ -239 +257 @@
 }
 
-Expression *Mutator::mutate( VirtualCastExpr *castExpr ) {
+Expression * Mutator::mutate( VirtualCastExpr *castExpr ) {
         castExpr->set_env( maybeMutate( castExpr->get_env(), *this ) );
         castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
@@ -246 +264 @@
 }
 
-Expression *Mutator::mutate( UntypedMemberExpr *memberExpr ) {
+Expression * Mutator::mutate( UntypedMemberExpr *memberExpr ) {
         memberExpr->set_env( maybeMutate( memberExpr->get_env(), *this ) );
         memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
@@ -254 +272 @@
 }
 
-Expression *Mutator::mutate( MemberExpr *memberExpr ) {
+Expression * Mutator::mutate( MemberExpr *memberExpr ) {
         memberExpr->set_env( maybeMutate( memberExpr->get_env(), *this ) );
         memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
@@ -261 +279 @@
 }
 
-Expression *Mutator::mutate( VariableExpr *variableExpr ) {
+Expression * Mutator::mutate( VariableExpr *variableExpr ) {
         variableExpr->set_env( maybeMutate( variableExpr->get_env(), *this ) );
         variableExpr->set_result( maybeMutate( variableExpr->get_result(), *this ) );
@@ -267 +285 @@
 }
 
-Expression *Mutator::mutate( ConstantExpr *constantExpr ) {
+Expression * Mutator::mutate( ConstantExpr *constantExpr ) {
         constantExpr->set_env( maybeMutate( constantExpr->get_env(), *this ) );
         constantExpr->set_result( maybeMutate( constantExpr->get_result(), *this ) );
@@ -274 +292 @@
 }
 
-Expression *Mutator::mutate( SizeofExpr *sizeofExpr ) {
+Expression * Mutator::mutate( SizeofExpr *sizeofExpr ) {
         sizeofExpr->set_env( maybeMutate( sizeofExpr->get_env(), *this ) );
         sizeofExpr->set_result( maybeMutate( sizeofExpr->get_result(), *this ) );
@@ -285 +303 @@
 }
 
-Expression *Mutator::mutate( AlignofExpr *alignofExpr ) {
+Expression * Mutator::mutate( AlignofExpr *alignofExpr ) {
         alignofExpr->set_env( maybeMutate( alignofExpr->get_env(), *this ) );
         alignofExpr->set_result( maybeMutate( alignofExpr->get_result(), *this ) );
@@ -296 +314 @@
 }
 
-Expression *Mutator::mutate( UntypedOffsetofExpr *offsetofExpr ) {
+Expression * Mutator::mutate( UntypedOffsetofExpr *offsetofExpr ) {
         offsetofExpr->set_env( maybeMutate( offsetofExpr->get_env(), *this ) );
         offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
@@ -303 +321 @@
 }
 
-Expression *Mutator::mutate( OffsetofExpr *offsetofExpr ) {
+Expression * Mutator::mutate( OffsetofExpr *offsetofExpr ) {
         offsetofExpr->set_env( maybeMutate( offsetofExpr->get_env(), *this ) );
         offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
@@ -311 +329 @@
 }
 
-Expression *Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
+Expression * Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
         offsetPackExpr->set_env( maybeMutate( offsetPackExpr->get_env(), *this ) );
         offsetPackExpr->set_result( maybeMutate( offsetPackExpr->get_result(), *this ) );
@@ -318 +336 @@
 }
 
-Expression *Mutator::mutate( AttrExpr *attrExpr ) {
+Expression * Mutator::mutate( AttrExpr *attrExpr ) {
         attrExpr->set_env( maybeMutate( attrExpr->get_env(), *this ) );
         attrExpr->set_result( maybeMutate( attrExpr->get_result(), *this ) );
@@ -329 +347 @@
 }
 
-Expression *Mutator::mutate( LogicalExpr *logicalExpr ) {
+Expression * Mutator::mutate( LogicalExpr *logicalExpr ) {
         logicalExpr->set_env( maybeMutate( logicalExpr->get_env(), *this ) );
         logicalExpr->set_result( maybeMutate( logicalExpr->get_result(), *this ) );
@@ -337 +355 @@
 }
 
-Expression *Mutator::mutate( ConditionalExpr *conditionalExpr ) {
+Expression * Mutator::mutate( ConditionalExpr *conditionalExpr ) {
         conditionalExpr->set_env( maybeMutate( conditionalExpr->get_env(), *this ) );
         conditionalExpr->set_result( maybeMutate( conditionalExpr->get_result(), *this ) );
@@ -346 +364 @@
 }
 
-Expression *Mutator::mutate( CommaExpr *commaExpr ) {
+Expression * Mutator::mutate( CommaExpr *commaExpr ) {
         commaExpr->set_env( maybeMutate( commaExpr->get_env(), *this ) );
         commaExpr->set_result( maybeMutate( commaExpr->get_result(), *this ) );
@@ -354 +372 @@
 }
 
-Expression *Mutator::mutate( TypeExpr *typeExpr ) {
+Expression * Mutator::mutate( TypeExpr *typeExpr ) {
         typeExpr->set_env( maybeMutate( typeExpr->get_env(), *this ) );
         typeExpr->set_result( maybeMutate( typeExpr->get_result(), *this ) );
@@ -361 +379 @@
 }
 
-Expression *Mutator::mutate( AsmExpr *asmExpr ) {
+Expression * Mutator::mutate( AsmExpr *asmExpr ) {
         asmExpr->set_env( maybeMutate( asmExpr->get_env(), *this ) );
         asmExpr->set_inout( maybeMutate( asmExpr->get_inout(), *this ) );
@@ -386 +404 @@
 }
 
-Expression *Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
+Expression * Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
         compLitExpr->set_env( maybeMutate( compLitExpr->get_env(), *this ) );
         compLitExpr->set_result( maybeMutate( compLitExpr->get_result(), *this ) );
@@ -393 +411 @@
 }
 
-Expression *Mutator::mutate( RangeExpr *rangeExpr ) {
+Expression * Mutator::mutate( RangeExpr *rangeExpr ) {
         rangeExpr->set_env( maybeMutate( rangeExpr->get_env(), *this ) );
         rangeExpr->set_low( maybeMutate( rangeExpr->get_low(), *this ) );
@@ -400 +418 @@
 }
 
-Expression *Mutator::mutate( UntypedTupleExpr *tupleExpr ) {
+Expression * Mutator::mutate( UntypedTupleExpr *tupleExpr ) {
         tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
@@ -407 +425 @@
 }
 
-Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
+Expression * Mutator::mutate( TupleExpr *tupleExpr ) {
         tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
@@ -414 +432 @@
 }
 
-Expression *Mutator::mutate( TupleIndexExpr *tupleExpr ) {
+Expression * Mutator::mutate( TupleIndexExpr *tupleExpr ) {
         tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
@@ -421 +439 @@
 }
 
-Expression *Mutator::mutate( TupleAssignExpr *assignExpr ) {
+Expression * Mutator::mutate( TupleAssignExpr *assignExpr ) {
         assignExpr->set_env( maybeMutate( assignExpr->get_env(), *this ) );
         assignExpr->set_result( maybeMutate( assignExpr->get_result(), *this ) );
@@ -428 +446 @@
 }
 
-Expression *Mutator::mutate( StmtExpr *stmtExpr ) {
+Expression * Mutator::mutate( StmtExpr *stmtExpr ) {
         stmtExpr->set_env( maybeMutate( stmtExpr->get_env(), *this ) );
         stmtExpr->set_result( maybeMutate( stmtExpr->get_result(), *this ) );
@@ -437 +455 @@
 }
 
-Expression *Mutator::mutate( UniqueExpr *uniqueExpr ) {
+Expression * Mutator::mutate( UniqueExpr *uniqueExpr ) {
         uniqueExpr->set_env( maybeMutate( uniqueExpr->get_env(), *this ) );
         uniqueExpr->set_result( maybeMutate( uniqueExpr->get_result(), *this ) );
@@ -444 +462 @@
 }
 
-Expression *Mutator::mutate( UntypedInitExpr * initExpr ) {
+Expression * Mutator::mutate( UntypedInitExpr * initExpr ) {
         initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
         initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
@@ -452 +470 @@
 }
 
-Expression *Mutator::mutate( InitExpr * initExpr ) {
+Expression * Mutator::mutate( InitExpr * initExpr ) {
         initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
         initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
@@ -461 +479 @@
 
 
-Type *Mutator::mutate( VoidType *voidType ) {
+Type * Mutator::mutate( VoidType *voidType ) {
         mutateAll( voidType->get_forall(), *this );
         return voidType;
 }
 
-Type *Mutator::mutate( BasicType *basicType ) {
+Type * Mutator::mutate( BasicType *basicType ) {
         mutateAll( basicType->get_forall(), *this );
         return basicType;
 }
 
-Type *Mutator::mutate( PointerType *pointerType ) {
+Type * Mutator::mutate( PointerType *pointerType ) {
         mutateAll( pointerType->get_forall(), *this );
         pointerType->set_base( maybeMutate( pointerType->get_base(), *this ) );
@@ -477 +495 @@
 }
 
-Type *Mutator::mutate( ArrayType *arrayType ) {
+Type * Mutator::mutate( ArrayType *arrayType ) {
         mutateAll( arrayType->get_forall(), *this );
         arrayType->set_dimension( maybeMutate( arrayType->get_dimension(), *this ) );
@@ -484 +502 @@
 }
 
-Type *Mutator::mutate( ReferenceType *refType ) {
+Type * Mutator::mutate( ReferenceType * refType ) {
         mutateAll( refType->get_forall(), *this );
         refType->set_base( maybeMutate( refType->get_base(), *this ) );
@@ -490 +508 @@
 }
 
-Type *Mutator::mutate( FunctionType *functionType ) {
+Type * Mutator::mutate( FunctionType * functionType ) {
         mutateAll( functionType->get_forall(), *this );
         mutateAll( functionType->get_returnVals(), *this );
@@ -497 +515 @@
 }
 
-Type *Mutator::handleReferenceToType( ReferenceToType *aggregateUseType ) {
+Type * Mutator::handleReferenceToType( ReferenceToType *aggregateUseType ) {
         mutateAll( aggregateUseType->get_forall(), *this );
         mutateAll( aggregateUseType->get_parameters(), *this );
@@ -503 +521 @@
 }
 
-Type *Mutator::mutate( StructInstType *aggregateUseType ) {
+Type * Mutator::mutate( StructInstType *aggregateUseType ) {
         handleReferenceToType( aggregateUseType );
         return aggregateUseType;
 }
 
-Type *Mutator::mutate( UnionInstType *aggregateUseType ) {
+Type * Mutator::mutate( UnionInstType *aggregateUseType ) {
         handleReferenceToType( aggregateUseType );
         return aggregateUseType;
 }
 
-Type *Mutator::mutate( EnumInstType *aggregateUseType ) {
+Type * Mutator::mutate( EnumInstType *aggregateUseType ) {
         handleReferenceToType( aggregateUseType );
         return aggregateUseType;
 }
 
-Type *Mutator::mutate( TraitInstType *aggregateUseType ) {
+Type * Mutator::mutate( TraitInstType *aggregateUseType ) {
         handleReferenceToType( aggregateUseType );
         mutateAll( aggregateUseType->get_members(), *this );
@@ -524 +542 @@
 }
 
-Type *Mutator::mutate( TypeInstType *aggregateUseType ) {
+Type * Mutator::mutate( TypeInstType *aggregateUseType ) {
         handleReferenceToType( aggregateUseType );
         return aggregateUseType;
 }
 
-Type *Mutator::mutate( TupleType *tupleType ) {
+Type * Mutator::mutate( TupleType *tupleType ) {
         mutateAll( tupleType->get_forall(), *this );
         mutateAll( tupleType->get_types(), *this );
@@ -536 +554 @@
 }
 
-Type *Mutator::mutate( TypeofType *typeofType ) {
+Type * Mutator::mutate( TypeofType *typeofType ) {
         assert( typeofType->get_expr() );
         typeofType->set_expr( typeofType->get_expr()->acceptMutator( *this ) );
@@ -542 +560 @@
 }
 
-Type *Mutator::mutate( AttrType *attrType ) {
+Type * Mutator::mutate( AttrType *attrType ) {
         if ( attrType->get_isType() ) {
                 assert( attrType->get_type() );
@@ -553 +571 @@
 }
 
-Type *Mutator::mutate( VarArgsType *varArgsType ) {
+Type * Mutator::mutate( VarArgsType *varArgsType ) {
         mutateAll( varArgsType->get_forall(), *this );
         return varArgsType;
 }
 
-Type *Mutator::mutate( ZeroType *zeroType ) {
+Type * Mutator::mutate( ZeroType *zeroType ) {
         mutateAll( zeroType->get_forall(), *this );
         return zeroType;
 }
 
-Type *Mutator::mutate( OneType *oneType ) {
+Type * Mutator::mutate( OneType *oneType ) {
         mutateAll( oneType->get_forall(), *this );
         return oneType;
@@ -569 +587 @@
 
 
-Designation *Mutator::mutate( Designation * designation ) {
+Designation * Mutator::mutate( Designation * designation ) {
         mutateAll( designation->get_designators(), *this );
         return designation;
 }
 
-Initializer *Mutator::mutate( SingleInit *singleInit ) {
+Initializer * Mutator::mutate( SingleInit *singleInit ) {
         singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
         return singleInit;
 }
 
-Initializer *Mutator::mutate( ListInit *listInit ) {
+Initializer * Mutator::mutate( ListInit *listInit ) {
         mutateAll( listInit->get_designations(), *this );
         mutateAll( listInit->get_initializers(), *this );
@@ -585 +603 @@
 }
 
-Initializer *Mutator::mutate( ConstructorInit *ctorInit ) {
+Initializer * Mutator::mutate( ConstructorInit *ctorInit ) {
         ctorInit->set_ctor( maybeMutate( ctorInit->get_ctor(), *this ) );
         ctorInit->set_dtor( maybeMutate( ctorInit->get_dtor(), *this ) );
@@ -593 +611 @@
 
 
-Subrange *Mutator::mutate( Subrange *subrange ) {
+Subrange * Mutator::mutate( Subrange *subrange ) {
         return subrange;
 }
 
 
-Constant *Mutator::mutate( Constant *constant ) {
+Constant * Mutator::mutate( Constant *constant ) {
         return constant;
 }

src/SynTree/Mutator.h

@@ -49 +49 @@
         virtual Statement* mutate( CatchStmt *catchStmt );
         virtual Statement* mutate( FinallyStmt *catchStmt );
+        virtual Statement* mutate( WaitForStmt *waitforStmt );
         virtual NullStmt* mutate( NullStmt *nullStmt );
         virtual Statement* mutate( DeclStmt *declStmt );

src/SynTree/Statement.cc

@@ -419 +419 @@
 }
 
+WaitForStmt::WaitForStmt( std::list<Label> labels ) : Statement( labels ) {
+        timeout.time      = nullptr;
+        timeout.statement = nullptr;
+        timeout.condition = nullptr;
+        orelse .statement = nullptr;
+        orelse .condition = nullptr;
+}
+
+WaitForStmt::WaitForStmt( const WaitForStmt & other ) : Statement( other ) {
+        clauses.reserve( other.clauses.size() );
+        for( auto & ocl : other.clauses ) {
+                clauses.emplace_back();
+                clauses.back().target.function = ocl.target.function->clone();
+                cloneAll( ocl.target.arguments, clauses.back().target.arguments );
+                clauses.back().statement = ocl.statement->clone();
+                clauses.back().condition = ocl.condition->clone();
+        }
+
+        timeout.time      = other.timeout.time     ->clone();
+        timeout.statement = other.timeout.statement->clone();
+        timeout.condition = other.timeout.condition->clone();
+        orelse .statement = other.orelse .statement->clone();
+        orelse .condition = other.orelse .condition->clone();
+}
+
+WaitForStmt::~WaitForStmt() {
+        for( auto & clause : clauses ) {
+                delete clause.target.function;
+                deleteAll( clause.target.arguments );
+                delete clause.statement;
+                delete clause.condition;
+        }
+
+        delete timeout.time;
+        delete timeout.statement;
+        delete timeout.condition;
+
+        delete orelse.statement;
+        delete orelse.condition;
+}
+
+void WaitForStmt::print( std::ostream &os, int indent ) const {
+        os << "Waitfor Statement" << endl;
+        os << string( indent + 2, ' ' ) << "with block:" << endl;
+        os << string( indent + 4, ' ' );
+        // block->print( os, indent + 4 );
+}
+
 NullStmt::NullStmt( std::list<Label> labels ) : CompoundStmt( labels ) {}
 NullStmt::NullStmt() : CompoundStmt( std::list<Label>() ) {}

src/SynTree/Statement.h

@@ -19 +19 @@
 #include <list>                    // for list
 #include <memory>                  // for allocator
+#include <vector>                        // for vector
 
 #include "BaseSyntaxNode.h"        // for BaseSyntaxNode
@@ -392 +393 @@
 };
 
+class WaitForStmt : public Statement {
+  public:
+
+        struct Target {
+                Expression * function;
+                std::list<Expression * > arguments;
+        };
+
+        struct Clause {
+                Target       target;
+                Statement  * statement;
+                Expression * condition;
+        };
+
+        WaitForStmt( std::list<Label> labels = noLabels );
+        WaitForStmt( const WaitForStmt & );
+        virtual ~WaitForStmt();
+
+        std::vector<Clause> clauses;
+
+        struct {
+                Expression * time;
+                Statement  * statement;
+                Expression * condition;
+        } timeout;
+
+        struct {
+                Statement  * statement;
+                Expression * condition;
+        } orelse;
+
+        virtual WaitForStmt *clone() const { return new WaitForStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+
+};
+
 
 // represents a declaration that occurs as part of a compound statement

src/SynTree/SynTree.h

@@ -54 +54 @@
 class CatchStmt;
 class FinallyStmt;
+class WaitForStmt;
 class NullStmt;
 class DeclStmt;

src/SynTree/Visitor.cc

@@ -155 +155 @@
 }
 
+void Visitor::visit( WaitForStmt *waitforStmt ) {
+        for( auto & clause : waitforStmt->clauses ) {
+                maybeAccept( clause.target.function, *this );
+                acceptAll( clause.target.arguments, *this );
+
+                maybeAccept( clause.statement, *this );
+                maybeAccept( clause.condition, *this );
+        }
+
+        maybeAccept( waitforStmt->timeout.time, *this );
+        maybeAccept( waitforStmt->timeout.statement, *this );
+        maybeAccept( waitforStmt->timeout.condition, *this );
+        maybeAccept( waitforStmt->orelse.statement, *this );
+        maybeAccept( waitforStmt->orelse.condition, *this );
+}
+
 void Visitor::visit( __attribute__((unused)) NullStmt *nullStmt ) {
 }

src/SynTree/Visitor.h

@@ -51 +51 @@
         virtual void visit( CatchStmt *catchStmt );
         virtual void visit( FinallyStmt *finallyStmt );
+        virtual void visit( WaitForStmt *waitforStmt );
         virtual void visit( NullStmt *nullStmt );
         virtual void visit( DeclStmt *declStmt );