Changeset a08ba92 for translator/ControlStruct

translator/ControlStruct/CaseRangeMutator.cc

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// CaseRangeMutator.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
+//
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 13:00:28 2015
+// Update Count     : 3
+//
 #include <list>
 #include <cassert>
 …
 namespace ControlStruct {
+    Statement *CaseRangeMutator::mutate(ChooseStmt *chooseStmt) {
+        /* There shouldn't be any `choose' statements by now, throw an exception or something. */
+        throw( 0 ) ; /* FIXME */
+    }
+    Statement *CaseRangeMutator::mutate(SwitchStmt *switchStmt) {
+        std::list< Statement * > &cases = switchStmt->get_branches();
+        // a `for' would be more natural... all this contortions are because `replace' invalidates the iterator
+        std::list< Statement * >::iterator i = cases.begin();
+        while (  i != cases.end() ) {
+            (*i)->acceptMutator( *this );
+            if ( ! newCaseLabels.empty() ) {
+                std::list< Statement * > newCases;
+                // transform( newCaseLabels.begin(), newCaseLabels.end(), bnd1st( ptr_fun( ctor< CaseStmt, Label, Expression * > ) ) );
+                for ( std::list< Expression * >::iterator j = newCaseLabels.begin();
+                      j != newCaseLabels.end(); j++ ) {
+                    std::list<Label> emptyLabels;
+                    std::list< Statement *> emptyStmts;
+                    newCases.push_back( new CaseStmt( emptyLabels, *j, emptyStmts ) );
+                }
+                if ( CaseStmt *currentCase = dynamic_cast< CaseStmt * > ( *i ) )
+                    if ( ! currentCase->get_statements().empty() ) {
+                        CaseStmt *lastCase = dynamic_cast< CaseStmt * > ( newCases.back() );
+                        if ( lastCase == 0 ) { throw ( 0 ); /* FIXME */ } // something is very wrong, as I just made these, and they were all cases
+                        // transfer the statement block (if any) to the new list:
+                        lastCase->set_statements( currentCase->get_statements() );
+                    }
+                std::list< Statement * >::iterator j = i; advance( j, 1 );
+                replace ( cases, i, newCases );
+                i = j;
+                newCaseLabels.clear();
+            } else
+                i++;
+        } // while
+        return switchStmt;
+    }
+    Statement *CaseRangeMutator::mutate(FallthruStmt *fallthruStmt) {
+        //delete fallthruStmt;
+        return new NullStmt();
+    }
+    Statement *CaseRangeMutator::mutate(CaseStmt *caseStmt) {
+        UntypedExpr *cond;
+        if ( (cond = dynamic_cast< UntypedExpr * >( caseStmt->get_condition() )) != 0 ) {
+            NameExpr *nmfunc;
+            if ( (nmfunc = dynamic_cast< NameExpr *>( cond->get_function() )) != 0 ) {
+                if ( nmfunc->get_name() == std::string("Range") ) {
+                    assert( cond->get_args().size() == 2 );
+                    std::list<Expression *>::iterator i = cond->get_args().begin();
+                    Expression *lo = *i, *hi = *(++i); // "unnecessary" temporaries
+                    fillRange( lo, hi);
+                }
+            }
+        } else if ( TupleExpr *tcond = dynamic_cast< TupleExpr * >( caseStmt->get_condition() ) ) {
+            // case list
+            assert( ! tcond->get_exprs().empty() );
+            for ( std::list< Expression * >::iterator i = tcond->get_exprs().begin(); i != tcond->get_exprs().end(); i++ )
+                newCaseLabels.push_back( *i ); // do I need to clone them?
+        } // if
+        std::list< Statement * > &stmts = caseStmt->get_statements();
+        mutateAll ( stmts, *this );
+        return caseStmt;
+    }
+    void CaseRangeMutator::fillRange(Expression *lo, Expression *hi) {
+        // generate the actual range (and check for consistency)
+        Constant *c_lo, *c_hi;
+        ConstantExpr *ce_lo, *ce_hi;
+        ce_lo = dynamic_cast< ConstantExpr * >( lo );
+        ce_hi = dynamic_cast< ConstantExpr * >( hi );
+        if ( ce_lo && ce_hi ) {
+            c_lo = ce_lo->get_constant(); c_hi = ce_hi->get_constant();
+        } /* else {
+             if ( ! ce_lo ) ;
+             if ( ! ce_hi ) ;
+             } */
+        BasicType *ty_lo = dynamic_cast< BasicType * >( c_lo->get_type() ),
+            *ty_hi = dynamic_cast< BasicType * >( c_hi->get_type() );
+        if ( ! ty_lo || ! ty_hi )
+            return; // one of them is not a constant
+        switch ( ty_lo->get_kind() ) {
+          case BasicType::Char:
+          case BasicType::UnsignedChar:
+            switch ( ty_hi->get_kind() ){
+        Statement *CaseRangeMutator::mutate( ChooseStmt *chooseStmt ) {
+                // There shouldn't be any `choose' statements by now, throw an exception or something.
+                throw( 0 ) ; /* FIXME */
+        }
+        Statement *CaseRangeMutator::mutate( SwitchStmt *switchStmt ) {
+                std::list< Statement * > &cases = switchStmt->get_branches();
+                // a `for' would be more natural... all this contortions are because `replace' invalidates the iterator
+                std::list< Statement * >::iterator i = cases.begin();
+                while ( i != cases.end() ) {
+                        (*i )->acceptMutator( *this );
+                        if ( ! newCaseLabels.empty() ) {
+                                std::list< Statement * > newCases;
+                                // transform( newCaseLabels.begin(), newCaseLabels.end(), bnd1st( ptr_fun( ctor< CaseStmt, Label, Expression * > ) ) );
+                                for ( std::list< Expression * >::iterator j = newCaseLabels.begin();
+                                          j != newCaseLabels.end(); j++ ) {
+                                        std::list<Label> emptyLabels;
+                                        std::list< Statement *> emptyStmts;
+                                        newCases.push_back( new CaseStmt( emptyLabels, *j, emptyStmts ) );
+                                } // for
+                                if ( CaseStmt *currentCase = dynamic_cast< CaseStmt * > ( *i ) )
+                                        if ( ! currentCase->get_statements().empty() ) {
+                                                CaseStmt *lastCase = dynamic_cast< CaseStmt * > ( newCases.back() );
+                                                if ( lastCase == 0 ) { throw ( 0 ); /* FIXME */ } // something is very wrong, as I just made these, and they were all cases
+                                                // transfer the statement block ( if any ) to the new list:
+                                                lastCase->set_statements( currentCase->get_statements() );
+                                        } // if
+                                std::list< Statement * >::iterator j = i; advance( j, 1 );
+                                replace ( cases, i, newCases );
+                                i = j;
+                                newCaseLabels.clear();
+                        } else
+                                i++;
+                } // while
+                return switchStmt;
+        }
+        Statement *CaseRangeMutator::mutate( FallthruStmt *fallthruStmt ) {
+                //delete fallthruStmt;
+                return new NullStmt();
+        }
+        Statement *CaseRangeMutator::mutate( CaseStmt *caseStmt ) {
+                UntypedExpr *cond;
+                if ( ( cond = dynamic_cast< UntypedExpr * >( caseStmt->get_condition() )) != 0 ) {
+                        NameExpr *nmfunc;
+                        if ( ( nmfunc = dynamic_cast< NameExpr *>( cond->get_function() )) != 0 ) {
+                                if ( nmfunc->get_name() == std::string("Range") ) {
+                                        assert( cond->get_args().size() == 2 );
+                                        std::list<Expression *>::iterator i = cond->get_args().begin();
+                                        Expression *lo = *i, *hi = *(++i ); // "unnecessary" temporaries
+                                        fillRange( lo, hi );
+                                } // if
+                        } // if
+                } else if ( TupleExpr *tcond = dynamic_cast< TupleExpr * >( caseStmt->get_condition() ) ) {
+                        // case list
+                        assert( ! tcond->get_exprs().empty() );
+                        for ( std::list< Expression * >::iterator i = tcond->get_exprs().begin(); i != tcond->get_exprs().end(); i++ )
+                                newCaseLabels.push_back( *i ); // do I need to clone them?
+                } // if
+                std::list< Statement * > &stmts = caseStmt->get_statements();
+                mutateAll ( stmts, *this );
+                return caseStmt;
+        }
+        void CaseRangeMutator::fillRange( Expression *lo, Expression *hi ) {
+                // generate the actual range ( and check for consistency )
+                Constant *c_lo, *c_hi;
+                ConstantExpr *ce_lo, *ce_hi;
+                ce_lo = dynamic_cast< ConstantExpr * >( lo );
+                ce_hi = dynamic_cast< ConstantExpr * >( hi );
+                if ( ce_lo && ce_hi ) {
+                        c_lo = ce_lo->get_constant(); c_hi = ce_hi->get_constant();
+                } /* else {
+                         if ( ! ce_lo ) ;
+                         if ( ! ce_hi ) ;
+                         } */
+                BasicType *ty_lo = dynamic_cast< BasicType * >( c_lo->get_type() ),
+                        *ty_hi = dynamic_cast< BasicType * >( c_hi->get_type() );
+                if ( ! ty_lo || ! ty_hi )
+                        return; // one of them is not a constant
+                switch ( ty_lo->get_kind() ) {
                   case BasicType::Char:
                   case BasicType::UnsignedChar:
+                    // first case, they are both printable ASCII characters represented as 'x'
+                    if ( c_lo->get_value().size() == 3 && c_hi->get_value().size() == 3 ) {
+                        char ch_lo = (c_lo->get_value())[1], ch_hi = (c_hi->get_value())[1];
+                        if ( ch_lo > ch_hi ) { char t=ch_lo; ch_lo=ch_hi; ch_hi=t; }
+                        for ( char c = ch_lo; c <=  ch_hi; c++ ){
+                            Type::Qualifiers q;
+                            Constant cnst( new BasicType(q, BasicType::Char),
+                                           std::string("'") + c + std::string("'") );
+                            newCaseLabels.push_back( new ConstantExpr( cnst ) );
+                        switch ( ty_hi->get_kind() ) {
+                          case BasicType::Char:
+                          case BasicType::UnsignedChar:
+                                // first case, they are both printable ASCII characters represented as 'x'
+                                if ( c_lo->get_value().size() == 3 && c_hi->get_value().size() == 3 ) {
+                                        char ch_lo = ( c_lo->get_value())[1], ch_hi = ( c_hi->get_value())[1];
+                                        if ( ch_lo > ch_hi ) { char t=ch_lo; ch_lo=ch_hi; ch_hi=t; }
+                                        for ( char c = ch_lo; c <=  ch_hi; c++ ) {
+                                                Type::Qualifiers q;
+                                                Constant cnst( new BasicType( q, BasicType::Char ),
+                                                                           std::string("'") + c + std::string("'") );
+                                                newCaseLabels.push_back( new ConstantExpr( cnst ) );
+                                        } // for
+                                        return;
+                                } // if
+                                break;
+                          default:
+                                // error: incompatible constants
+                                break;
+                        } // switch
+                        break;
+                  case BasicType::ShortSignedInt:
+                  case BasicType::ShortUnsignedInt:
+                  case BasicType::SignedInt:
+                  case BasicType::UnsignedInt:
+                  case BasicType::LongSignedInt:
+                  case BasicType::LongUnsignedInt:
+                  case BasicType::LongLongSignedInt:
+                  case BasicType::LongLongUnsignedInt:
+                        switch ( ty_hi->get_kind() ) {
+                          case BasicType::ShortSignedInt:
+                          case BasicType::ShortUnsignedInt:
+                          case BasicType::SignedInt:
+                          case BasicType::UnsignedInt:
+                          case BasicType::LongSignedInt:
+                          case BasicType::LongUnsignedInt:
+                          case BasicType::LongLongSignedInt:
+                          case BasicType::LongLongUnsignedInt: {
+                                  int i_lo = atoi( c_lo->get_value().c_str()),
+                                          i_hi = atoi( c_hi->get_value().c_str());
+                                  if ( i_lo > i_hi ) { int t=i_lo; i_lo=i_hi; i_hi=t; }
+                                  for ( int c = i_lo; c <=  i_hi; c++ ) {
+                                          Type::Qualifiers q;
+                                          Constant cnst( new BasicType( q, ty_hi->get_kind()), // figure can't hurt (used to think in positives)
+                                                                         toString< int >( c ) );
+                                          newCaseLabels.push_back( new ConstantExpr( cnst ) );
+                                  }
+                                  return;
+                          }
+                          default:
+                                // error: incompatible constants
+                                break;
+                        }
+                        break;
+                  default:
+                        break;
+                } // switch
+                /* End: */{
+                        // invalid range, signal a warning (it still generates the two case labels)
+                        newCaseLabels.push_back( lo );
+                        newCaseLabels.push_back( hi );
                         return;
+                    }
-                    break;
-                  default:
-                    // error: incompatible constants
-                    break;
+                }
+            break;
+          case BasicType::ShortSignedInt:
+          case BasicType::ShortUnsignedInt:
+          case BasicType::SignedInt:
+          case BasicType::UnsignedInt:
+          case BasicType::LongSignedInt:
+          case BasicType::LongUnsignedInt:
+          case BasicType::LongLongSignedInt:
+          case BasicType::LongLongUnsignedInt:
+            switch ( ty_hi->get_kind() ) {
+              case BasicType::ShortSignedInt:
+              case BasicType::ShortUnsignedInt:
+              case BasicType::SignedInt:
+              case BasicType::UnsignedInt:
+              case BasicType::LongSignedInt:
+              case BasicType::LongUnsignedInt:
+              case BasicType::LongLongSignedInt:
+              case BasicType::LongLongUnsignedInt: {
+                  int i_lo = atoi(c_lo->get_value().c_str()),
+                      i_hi = atoi(c_hi->get_value().c_str());
+                  if ( i_lo > i_hi ) { int t=i_lo; i_lo=i_hi; i_hi=t; }
+                  for ( int c = i_lo; c <=  i_hi; c++ ){
+                      Type::Qualifiers q;
+                      Constant cnst( new BasicType(q, ty_hi->get_kind()), // figure can't hurt (used to think in positives)
+                                     toString< int >( c ) );
+                      newCaseLabels.push_back( new ConstantExpr( cnst ) );
+                  }
+                  return;
+              }
+              default:
+                // error: incompatible constants
+                break;
+            }
+            break;
+          default:
+            break;
+        } // switch
+        /* End: */{
+            // invalid range, signal a warning (it still generates the two case labels)
+            newCaseLabels.push_back( lo );
+            newCaseLabels.push_back( hi );
+            return;
+        }
+    }
+        }
 } // namespace ControlStruct
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/CaseRangeMutator.h

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// CaseRangeMutator.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:22:51 2015
+// Update Count     : 3
 //
 #ifndef CASERNG_MUTATOR_H
 #define CASERNG_MUTATOR_H
 …
 namespace ControlStruct {
     class CaseRangeMutator : public Mutator {
       public:
         CaseRangeMutator() {}
+        class CaseRangeMutator : public Mutator {
+          public:
+                CaseRangeMutator() {}
         virtual Statement *mutate( ChooseStmt * );
         virtual Statement *mutate( SwitchStmt * );
         virtual Statement *mutate( FallthruStmt * );
         virtual Statement *mutate( CaseStmt * );
       private:
         void fillRange( Expression *lo, Expression *hi );
+                virtual Statement *mutate( ChooseStmt * );
+                virtual Statement *mutate( SwitchStmt * );
+                virtual Statement *mutate( FallthruStmt * );
+                virtual Statement *mutate( CaseStmt * );
+          private:
+                void fillRange( Expression *lo, Expression *hi );
+        Expression *currentCondition;
+        std::list< Expression * > newCaseLabels;
+    };
+                Expression *currentCondition;
+                std::list< Expression * > newCaseLabels;
+        };
 } // namespace ControlStruct
 #endif // CASERNG_MUTATOR_H
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/ChooseMutator.cc

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// ChooseMutator.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:31:39 2015
+// Update Count     : 2
 //
 #include <list>
 …
 namespace ControlStruct {
     Statement *ChooseMutator::mutate( ChooseStmt *chooseStmt) {
         bool enclosingChoose = insideChoose;
         insideChoose = true;
         mutateAll( chooseStmt->get_branches(), *this );
         insideChoose = enclosingChoose;
         return new SwitchStmt( chooseStmt->get_labels(),  chooseStmt->get_condition(), chooseStmt->get_branches() );
+    }
+        Statement *ChooseMutator::mutate( ChooseStmt *chooseStmt ) {
+                bool enclosingChoose = insideChoose;
+                insideChoose = true;
+                mutateAll( chooseStmt->get_branches(), *this );
+                insideChoose = enclosingChoose;
+                return new SwitchStmt( chooseStmt->get_labels(),  chooseStmt->get_condition(), chooseStmt->get_branches() );
+        }
     Statement *ChooseMutator::mutate( SwitchStmt *switchStmt ) {
         bool enclosingChoose = insideChoose;
         insideChoose = false;
         mutateAll( switchStmt->get_branches(), *this );
         insideChoose = enclosingChoose;
         return switchStmt;
+    }
+        Statement *ChooseMutator::mutate( SwitchStmt *switchStmt ) {
+                bool enclosingChoose = insideChoose;
+                insideChoose = false;
+                mutateAll( switchStmt->get_branches(), *this );
+                insideChoose = enclosingChoose;
+                return switchStmt;
+        }
     Statement *ChooseMutator::mutate( FallthruStmt *fallthruStmt ) {
         delete fallthruStmt;
         return new NullStmt();
+    }
+        Statement *ChooseMutator::mutate( FallthruStmt *fallthruStmt ) {
+                delete fallthruStmt;
+                return new NullStmt();
+        }
     Statement* ChooseMutator::mutate(CaseStmt *caseStmt) {
         std::list< Statement * > &stmts = caseStmt->get_statements();
+        Statement* ChooseMutator::mutate( CaseStmt *caseStmt ) {
+                std::list< Statement * > &stmts = caseStmt->get_statements();
         if ( insideChoose ) {
             BranchStmt *posBrk;
             if ( (( posBrk = dynamic_cast< BranchStmt * > ( stmts.back() ) ) &&
                   ( posBrk->get_type() == BranchStmt::Break ))  // last statement in the list is a (superfluous) 'break'
                  || dynamic_cast< FallthruStmt * > ( stmts.back() ) )
+                ;
             else {
                 stmts.push_back( new BranchStmt( std::list< Label >(), "", BranchStmt::Break ) );
             } // if
         } // if
+                if ( insideChoose ) {
+                        BranchStmt *posBrk;
+                        if ( (( posBrk = dynamic_cast< BranchStmt * > ( stmts.back() ) ) &&
+                                  ( posBrk->get_type() == BranchStmt::Break ))  // last statement in the list is a (superfluous) 'break'
+                                 || dynamic_cast< FallthruStmt * > ( stmts.back() ) )
+                                ;
+                        else {
+                                stmts.push_back( new BranchStmt( std::list< Label >(), "", BranchStmt::Break ) );
+                        } // if
+                } // if
         mutateAll ( stmts, *this );
         return caseStmt;
+    }
+                mutateAll ( stmts, *this );
+                return caseStmt;
+        }
 } // namespace ControlStruct
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/ChooseMutator.h

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// ChooseMutator.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:33:11 2015
+// Update Count     : 3
 //
 #ifndef CHOOSE_MUTATOR_H
 #define CHOOSE_MUTATOR_H
 …
 namespace ControlStruct {
+        class ChooseMutator : public Mutator {
+          public:
+                ChooseMutator() : insideChoose( false ) {}
+    class ChooseMutator : public Mutator {
+      public:
+        ChooseMutator() : insideChoose( false ) {}
+        virtual Statement *mutate( ChooseStmt * );
+        virtual Statement *mutate( SwitchStmt * );
+        virtual Statement *mutate( FallthruStmt * );
+        virtual Statement *mutate( CaseStmt * );
+      private:
+        bool insideChoose;
+    };
+                virtual Statement *mutate( ChooseStmt * );
+                virtual Statement *mutate( SwitchStmt * );
+                virtual Statement *mutate( FallthruStmt * );
+                virtual Statement *mutate( CaseStmt * );
+          private:
+                bool insideChoose;
+        };
 } // namespace ControlStruct
 #endif // CHOOSE_MUTATOR_H
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/ForExprMutator.cc

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// ForExprMutator.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:31:47 2015
+// Update Count     : 2
 //
 #include "SynTree/Mutator.h"
 #include "SynTree/Statement.h"
 …
 namespace ControlStruct {
     Statement *ForExprMutator::mutate( ForStmt *forStmt ) {
         // recurse down all nest for loops to hoist any initializer declarations to make them C89 (rather than C99)
         forStmt->set_body( forStmt->get_body()->acceptMutator( *this ) );
         if ( DeclStmt *decl = dynamic_cast< DeclStmt * > ( forStmt->get_initialization() ) ) {
             // create compound statement, move initializer declaration outside, leave _for_ as-is
             CompoundStmt *block = new CompoundStmt( std::list< Label >() );
             std::list<Statement *> &stmts = block->get_kids();
+        Statement *ForExprMutator::mutate( ForStmt *forStmt ) {
+                // recurse down all nest for loops to hoist any initializer declarations to make them C89 (rather than C99)
+                forStmt->set_body( forStmt->get_body()->acceptMutator( *this ) );
+                if ( DeclStmt *decl = dynamic_cast< DeclStmt * > ( forStmt->get_initialization() ) ) {
+                        // create compound statement, move initializer declaration outside, leave _for_ as-is
+                        CompoundStmt *block = new CompoundStmt( std::list< Label >() );
+                        std::list<Statement *> &stmts = block->get_kids();
             stmts.push_back( decl );
             forStmt->set_initialization( 0 );
             stmts.push_back( forStmt );
+                        stmts.push_back( decl );
+                        forStmt->set_initialization( 0 );
+                        stmts.push_back( forStmt );
             return block;
         } // if
+                        return block;
+                } // if
         return forStmt;
+    }
+                return forStmt;
+        }
 } // namespace ControlStruct
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/ForExprMutator.h

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// ForExprMutator.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:25:19 2015
+// Update Count     : 2
 //
 #ifndef FOR_MUTATOR_H
 #define FOR_MUTATOR_H
 #include "SynTree/Mutator.h"
 #include "utility.h"
 namespace ControlStruct {
     class ForExprMutator : public Mutator {
       public:
         virtual Statement *mutate( ForStmt * );
     };
+        class ForExprMutator : public Mutator {
+          public:
+                virtual Statement *mutate( ForStmt * );
+        };
 } // namespace ControlStruct
 #endif // CHOOSE_MUTATOR_H
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/LabelFixer.cc

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// LabelFixer.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:25:59 2015
+// Update Count     : 1
 //
 #include <list>
 #include <cassert>
 …
 namespace ControlStruct {
+    LabelFixer::Entry::Entry( Statement *to, Statement *from ) : definition ( to ) {
+        if ( from != 0 )
+            usage.push_back( from );
+    }
+    bool LabelFixer::Entry::insideLoop() {
+        return ( dynamic_cast< ForStmt * > ( definition ) ||
+                 dynamic_cast< WhileStmt * > ( definition )  );
+    }
+    LabelFixer::LabelFixer( LabelGenerator *gen ) : generator ( gen ) {
+        if ( generator == 0 )
+            generator = LabelGenerator::getGenerator();
+    }
+    void LabelFixer::visit( FunctionDecl *functionDecl ) {
+        if ( functionDecl->get_statements() != 0 )
+            functionDecl->get_statements()->accept( *this );
+        MLEMutator mlemut( resolveJumps(), generator );
+        functionDecl->acceptMutator( mlemut );
+    }
+    void LabelFixer::visit( Statement *stmt ) {
+        std::list< Label > &labels = stmt->get_labels();
+        if ( ! labels.empty() ) {
+            Label current = setLabelsDef( labels, stmt );
+            labels.clear();
+            labels.push_front( current );
+        } // if
+    }
+    void LabelFixer::visit( BranchStmt *branchStmt ) {
+        visit ( ( Statement * )branchStmt );  // the labels this statement might have
+        Label target;
+        if ( (target = branchStmt->get_target()) != "" ) {
+            setLabelsUsg( target, branchStmt );
+        } //else       /* computed goto or normal exit-loop statements */
+    }
+    Label LabelFixer::setLabelsDef( std::list< Label > &llabel, Statement *definition ) {
+        assert( definition != 0 );
+        Entry *entry = new Entry( definition );
+        bool used = false;
+        for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ )
+            if ( labelTable.find( *i ) == labelTable.end() )
+                { used = true; labelTable[ *i ] = entry; } // undefined and unused
+            else
+                if ( labelTable[ *i ]->defined() )
+                    throw SemanticError( "Duplicate definition of label: " + *i );
+                else
+                    labelTable[ *i ]->set_definition( definition );
+        if (! used ) delete entry;
+        return labelTable[ llabel.front() ]->get_label();  // this *must* exist
+    }
+    Label LabelFixer::setLabelsUsg( Label orgValue, Statement *use ) {
+        assert( use != 0 );
+        if ( labelTable.find( orgValue ) != labelTable.end() )
+            labelTable[ orgValue ]->add_use( use );         // the label has been defined or used before
+        else
+            labelTable[ orgValue ] = new Entry( 0, use );
+        return labelTable[ orgValue ]->get_label();
+    }
+    std::map<Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticError ) {
+        std::map< Statement *, Entry * > def_us;
+        for ( std::map< Label, Entry *>::iterator i = labelTable.begin(); i != labelTable.end(); i++ ) {
+            Entry *e = i->second;
+            if ( def_us.find ( e->get_definition() ) == def_us.end() )
+                def_us[ e->get_definition() ] = e;
+            else
+                if ( e->used() )
+                    def_us[ e->get_definition() ]->add_uses( e->get_uses() );
+        LabelFixer::Entry::Entry( Statement *to, Statement *from ) : definition ( to ) {
+                if ( from != 0 )
+                        usage.push_back( from );
+        }
+        // get rid of labelTable
+        for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); i++ ) {
+            Statement *to = (*i).first;
+            std::list< Statement *> &from = (*i).second->get_uses();
+            Label finalLabel = generator->newLabel();
+            (*i).second->set_label( finalLabel );
+        bool LabelFixer::Entry::insideLoop() {
+                return ( dynamic_cast< ForStmt * > ( definition ) ||
+                                 dynamic_cast< WhileStmt * > ( definition )  );
+        }
+            if ( to == 0 ) {
+                BranchStmt *first_use = dynamic_cast<BranchStmt *>(from.back());
+                Label undef("");
+                if ( first_use != 0 )
+                    undef = first_use->get_target();
+                throw SemanticError ( "'" + undef + "' label not defined");
+            }
+        LabelFixer::LabelFixer( LabelGenerator *gen ) : generator ( gen ) {
+                if ( generator == 0 )
+                        generator = LabelGenerator::getGenerator();
+        }
+            to->get_labels().clear();
+            to->get_labels().push_back( finalLabel );
+        void LabelFixer::visit( FunctionDecl *functionDecl ) {
+                if ( functionDecl->get_statements() != 0 )
+                        functionDecl->get_statements()->accept( *this );
+            for ( std::list< Statement *>::iterator j = from.begin(); j != from.end(); j++ ) {
+                BranchStmt *jumpTo = dynamic_cast< BranchStmt * > ( *j );
+                assert( jumpTo != 0 );
+                jumpTo->set_target( finalLabel );
+            } // for
+        } // for
+                MLEMutator mlemut( resolveJumps(), generator );
+                functionDecl->acceptMutator( mlemut );
+        }
+        // reverse table
+        std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
+        for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); i++ )
+            (*ret)[ (*i).second->get_label() ] = (*i).first;
+        void LabelFixer::visit( Statement *stmt ) {
+                std::list< Label > &labels = stmt->get_labels();
+        return ret;
+    }
+                if ( ! labels.empty() ) {
+                        Label current = setLabelsDef( labels, stmt );
+                        labels.clear();
+                        labels.push_front( current );
+                } // if
+        }
+        void LabelFixer::visit( BranchStmt *branchStmt ) {
+                visit ( ( Statement * )branchStmt );  // the labels this statement might have
+                Label target;
+                if ( (target = branchStmt->get_target()) != "" ) {
+                        setLabelsUsg( target, branchStmt );
+                } //else       /* computed goto or normal exit-loop statements */
+        }
+        Label LabelFixer::setLabelsDef( std::list< Label > &llabel, Statement *definition ) {
+                assert( definition != 0 );
+                Entry *entry = new Entry( definition );
+                bool used = false;
+                for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ )
+                        if ( labelTable.find( *i ) == labelTable.end() )
+                                { used = true; labelTable[ *i ] = entry; } // undefined and unused
+                        else
+                                if ( labelTable[ *i ]->defined() )
+                                        throw SemanticError( "Duplicate definition of label: " + *i );
+                                else
+                                        labelTable[ *i ]->set_definition( definition );
+                if ( ! used ) delete entry;
+                return labelTable[ llabel.front() ]->get_label();  // this *must* exist
+        }
+        Label LabelFixer::setLabelsUsg( Label orgValue, Statement *use ) {
+                assert( use != 0 );
+                if ( labelTable.find( orgValue ) != labelTable.end() )
+                        labelTable[ orgValue ]->add_use( use );         // the label has been defined or used before
+                else
+                        labelTable[ orgValue ] = new Entry( 0, use );
+                return labelTable[ orgValue ]->get_label();
+        }
+        std::map<Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticError ) {
+                std::map< Statement *, Entry * > def_us;
+                for ( std::map< Label, Entry *>::iterator i = labelTable.begin(); i != labelTable.end(); i++ ) {
+                        Entry *e = i->second;
+                        if ( def_us.find ( e->get_definition() ) == def_us.end() )
+                                def_us[ e->get_definition() ] = e;
+                        else
+                                if ( e->used() )
+                                        def_us[ e->get_definition() ]->add_uses( e->get_uses() );
+                }
+                // get rid of labelTable
+                for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); i++ ) {
+                        Statement *to = (*i).first;
+                        std::list< Statement *> &from = (*i).second->get_uses();
+                        Label finalLabel = generator->newLabel();
+                        (*i).second->set_label( finalLabel );
+                        if ( to == 0 ) {
+                                BranchStmt *first_use = dynamic_cast<BranchStmt *>(from.back());
+                                Label undef("");
+                                if ( first_use != 0 )
+                                        undef = first_use->get_target();
+                                throw SemanticError ( "'" + undef + "' label not defined");
+                        }
+                        to->get_labels().clear();
+                        to->get_labels().push_back( finalLabel );
+                        for ( std::list< Statement *>::iterator j = from.begin(); j != from.end(); j++ ) {
+                                BranchStmt *jumpTo = dynamic_cast< BranchStmt * > ( *j );
+                                assert( jumpTo != 0 );
+                                jumpTo->set_target( finalLabel );
+                        } // for
+                } // for
+                // reverse table
+                std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
+                for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); i++ )
+                        (*ret)[ (*i).second->get_label() ] = (*i).first;
+                return ret;
+        }
 }  // namespace ControlStruct
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/LabelFixer.h

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// LabelFixer.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:31:55 2015
+// Update Count     : 3
 //
 #ifndef LABEL_FIXER_H
 #define LABEL_FIXER_H
 #include "utility.h"
 #include "SynTree/SynTree.h"
 #include "SynTree/Visitor.h"
 #include "LabelGenerator.h"
 …
 namespace ControlStruct {
     class LabelFixer : public Visitor {
         typedef Visitor Parent;
       public:
         LabelFixer( LabelGenerator *gen = 0 );
+        class LabelFixer : public Visitor {
+                typedef Visitor Parent;
+          public:
+                LabelFixer( LabelGenerator *gen = 0 );
         std::map < Label, Statement * > *resolveJumps() throw ( SemanticError );
+                std::map < Label, Statement * > *resolveJumps() throw ( SemanticError );
         // Declarations
         virtual void visit( FunctionDecl *functionDecl );
+                // Declarations
+                virtual void visit( FunctionDecl *functionDecl );
         // Statements
         void visit( Statement *stmt );
+                // Statements
+                void visit( Statement *stmt );
         virtual void visit( CompoundStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( NullStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( ExprStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( IfStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( WhileStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( ForStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( SwitchStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( ChooseStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( FallthruStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( CaseStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( ReturnStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( TryStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( CatchStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( DeclStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
         virtual void visit( BranchStmt *branchStmt );
+                virtual void visit( CompoundStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( NullStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( ExprStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( IfStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( WhileStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( ForStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( SwitchStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( ChooseStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( FallthruStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( CaseStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( ReturnStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( TryStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( CatchStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( DeclStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( BranchStmt *branchStmt );
         Label setLabelsDef( std::list< Label > &, Statement *definition );
         Label setLabelsUsg( Label, Statement *usage = 0 );
+                Label setLabelsDef( std::list< Label > &, Statement *definition );
+                Label setLabelsUsg( Label, Statement *usage = 0 );
       private:
         class Entry {
           public:
             Entry( Statement *to = 0, Statement *from = 0 );
             bool used() { return ( usage.empty() ); }
             bool defined() { return ( definition != 0 ); }
             bool insideLoop();
+          private:
+                class Entry {
+                  public:
+                        Entry( Statement *to = 0, Statement *from = 0 );
+                        bool used() { return ( usage.empty() ); }
+                        bool defined() { return ( definition != 0 ); }
+                        bool insideLoop();
             Label get_label() const { return label; }
             Statement *get_definition() const { return definition; }
             std::list< Statement *> &get_uses() { return usage; }
+                        Label get_label() const { return label; }
+                        Statement *get_definition() const { return definition; }
+                        std::list< Statement *> &get_uses() { return usage; }
             void add_use ( Statement *use ) { usage.push_back( use ); }
             void add_uses ( std::list<Statement *> uses ) { usage.insert( usage.end(), uses.begin(), uses.end() ); }
             void set_definition( Statement *def ) { definition = def; }
+                        void add_use ( Statement *use ) { usage.push_back( use ); }
+                        void add_uses ( std::list<Statement *> uses ) { usage.insert( usage.end(), uses.begin(), uses.end() ); }
+                        void set_definition( Statement *def ) { definition = def; }
+            void set_label( Label lab ) { label = lab; }
+            Label gset_label() const { return label; }
+          private:
+            Label label;
+            Statement *definition;
+            std::list<Statement *> usage;
+                        void set_label( Label lab ) { label = lab; }
+                        Label gset_label() const { return label; }
+                  private:
+                        Label label;
+                        Statement *definition;
+                        std::list<Statement *> usage;
+                };
+                std::map < Label, Entry *> labelTable;
+                LabelGenerator *generator;
         };
-        std::map < Label, Entry *> labelTable;
-        LabelGenerator *generator;
-    };
 } // namespace ControlStruct
 #endif // LABEL_FIXER_H
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/LabelGenerator.cc

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// LabelGenerator.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:32:04 2015
+// Update Count     : 2
 //
 #include <iostream>
 #include <strstream>
 …
 namespace ControlStruct {
     LabelGenerator *LabelGenerator::labelGenerator = 0;
+        LabelGenerator *LabelGenerator::labelGenerator = 0;
     LabelGenerator *LabelGenerator::getGenerator() {
         if ( LabelGenerator::labelGenerator == 0 )
             LabelGenerator::labelGenerator = new LabelGenerator();
+        LabelGenerator *LabelGenerator::getGenerator() {
+                if ( LabelGenerator::labelGenerator == 0 )
+                        LabelGenerator::labelGenerator = new LabelGenerator();
         return labelGenerator;
+    }
+                return labelGenerator;
+        }
     Label LabelGenerator::newLabel() {
         std::ostrstream os;
         os << "__L" << current++ << "__";// << std::ends;
         os.freeze( false );
         std::string ret = std::string (os.str(), os.pcount());
         return Label( ret );
+    }
+        Label LabelGenerator::newLabel() {
+                std::ostrstream os;
+                os << "__L" << current++ << "__";// << std::ends;
+                os.freeze( false );
+                std::string ret = std::string (os.str(), os.pcount());
+                return Label( ret );
+        }
 } // namespace ControlStruct
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/LabelGenerator.h

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// LabelGenerator.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:33:20 2015
+// Update Count     : 3
 //
 #ifndef LABEL_GENERATOR_H
 #define LABEL_GENERATOR_H
 …
 namespace ControlStruct {
     class LabelGenerator {
       public:
         static LabelGenerator *getGenerator();
         Label newLabel();
         void reset() { current = 0; }
         void rewind() { current--; }
       protected:
         LabelGenerator(): current(0) {}
       private:
         int current;
         static LabelGenerator *labelGenerator;
     };
+        class LabelGenerator {
+          public:
+                static LabelGenerator *getGenerator();
+                Label newLabel();
+                void reset() { current = 0; }
+                void rewind() { current--; }
+          protected:
+                LabelGenerator(): current(0) {}
+          private:
+                int current;
+                static LabelGenerator *labelGenerator;
+        };
 } // namespace ControlStruct
 #endif // LABEL_GENERATOR_H
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/LabelTypeChecker.cc

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// LabelTypeChecker.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:32:15 2015
+// Update Count     : 2
 //
 #include <list>
 #include <cassert>
 …
 #include "LabelTypeChecker.h"
+namespace ControlStruct {
+        void LabelTypeChecker::visit(UntypedExpr *untypedExpr) {
+                assert( untypedExpr != 0 );
+                NameExpr *fname;
+                if ( ((fname = dynamic_cast<NameExpr *>(untypedExpr->get_function())) != 0)
+                         && fname->get_name() == std::string("LabAddress") )
+                        std::cerr << "Taking the label of an address." << std::endl;
+                else {
+                        acceptAll( untypedExpr->get_results(), *this );
+                        acceptAll( untypedExpr->get_args(), *this );
+                } // if
+                return;
+        }
+namespace ControlStruct {
+    void LabelTypeChecker::visit(UntypedExpr *untypedExpr){
+        assert( untypedExpr != 0 );
+        NameExpr *fname;
+        if ( ((fname = dynamic_cast<NameExpr *>(untypedExpr->get_function())) != 0)
+            && fname->get_name() == std::string("LabAddress") )
+            std::cerr << "Taking the label of an address." << std::endl;
+        else {
+            acceptAll( untypedExpr->get_results(), *this );
+            acceptAll( untypedExpr->get_args(), *this );
+        } // if
+        return;
+    }
+        void LabelTypeChecker::visit(CompoundStmt *compoundStmt) {
+                index.enterScope();
+                acceptAll( compoundStmt->get_kids(), *this );
+                index.leaveScope();
+        }
+    void LabelTypeChecker::visit(CompoundStmt *compoundStmt) {
+        index.enterScope();
+        acceptAll( compoundStmt->get_kids(), *this );
+        index.leaveScope();
+    }
+        void LabelTypeChecker::visit(DeclStmt *declStmt) {
+                declStmt->accept( index );
+    void LabelTypeChecker::visit(DeclStmt *declStmt){
+        declStmt->accept( index );
+                //ObjectDecl *odecl = 0;
+                // if ( ( odecl = dynamic_cast<ObjectDecl *>(declStmt->get_decl()) ) != 0 ) {
+                return;
+        }
         //ObjectDecl *odecl = 0;
         // if ( ( odecl = dynamic_cast<ObjectDecl *>(declStmt->get_decl()) ) != 0 ){
         return;
+    }
+        void LabelTypeChecker::visit(BranchStmt *branchStmt) {
+                if ( branchStmt->get_type() != BranchStmt::Goto ) return;
+                Expression *target;
+                if ( (target = branchStmt->get_computedTarget()) == 0 ) return;
+    void LabelTypeChecker::visit(BranchStmt *branchStmt) {
+        if ( branchStmt->get_type() != BranchStmt::Goto ) return;
+        Expression *target;
+        if ( (target = branchStmt->get_computedTarget()) == 0 ) return;
+                NameExpr *name;
+                if ( ((name = dynamic_cast<NameExpr *>(target)) == 0) )
+                        return; // Not a name expression
+                std::list< DeclarationWithType * > interps;
+                index.lookupId(name->get_name(), interps);
+                if ( interps.size() != 1)
+                        // in case of multiple declarations
+                        throw SemanticError("Illegal label expression: " + name->get_name() );
+        NameExpr *name;
+        if ( ((name = dynamic_cast<NameExpr *>(target)) == 0) )
+            return; // Not a name expression
+        std::list< DeclarationWithType * > interps;
+        index.lookupId(name->get_name(), interps);
+        if ( interps.size() != 1)
+            // in case of multiple declarations
+            throw SemanticError("Illegal label expression: " + name->get_name() );
+                PointerType *ptr;
+                if ( (ptr = dynamic_cast<PointerType *>(interps.front()->get_type())) != 0 )
+                        if ( dynamic_cast<VoidType *>(ptr->get_base()) != 0 )
+                                return;
+                        else
+                                throw SemanticError("Wrong type of parameter for computed goto");
+                else
+                        throw SemanticError("Wrong type of parameter for computed goto");
-        PointerType *ptr;
-        if ( (ptr = dynamic_cast<PointerType *>(interps.front()->get_type())) != 0 )
-            if ( dynamic_cast<VoidType *>(ptr->get_base()) != 0 )
                 return;
+            else
+                throw SemanticError("Wrong type of parameter for computed goto");
+        else
+            throw SemanticError("Wrong type of parameter for computed goto");
+        }
+} // namespace ControlStruct
-        return;
+    }
-} // namespace ControlStruct
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/LabelTypeChecker.h

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// LabelTypeChecker.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:33:47 2015
+// Update Count     : 3
 //
 #ifndef LABEL_TYPE_H
 #define LABEL_TYPE_H
 …
 namespace ControlStruct {
     class LabelTypeChecker : public Visitor {
       public:
         //LabelTypeChecker() {
+        class LabelTypeChecker : public Visitor {
+          public:
+                //LabelTypeChecker() {
         virtual void visit( CompoundStmt *compoundStmt );
         virtual void visit( DeclStmt *declStmt );
         virtual void visit( BranchStmt *branchStmt );
         virtual void visit( UntypedExpr *untypedExpr );
       private:
         SymTab::Indexer index;
     };
+                virtual void visit( CompoundStmt *compoundStmt );
+                virtual void visit( DeclStmt *declStmt );
+                virtual void visit( BranchStmt *branchStmt );
+                virtual void visit( UntypedExpr *untypedExpr );
+          private:
+                SymTab::Indexer index;
+        };
 } // namespace ControlStruct
 #endif // LABEL_TYPE_H
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //

translator/ControlStruct/MLEMutator.cc

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// MLEMutator.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
+//
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:32:26 2015
+// Update Count     : 2
+//
 #include <cassert>
 #include <algorithm>
 …
 #include "SynTree/Statement.h"
 namespace ControlStruct {
     MLEMutator::~MLEMutator() {
         delete targetTable;
         targetTable = 0;
+    }
     CompoundStmt* MLEMutator::mutate( CompoundStmt *cmpndStmt ) {
         bool labeledBlock = false;
         if ( !((cmpndStmt->get_labels()).empty()) ) {
             labeledBlock = true;
             enclosingBlocks.push_back( Entry( cmpndStmt ) );
+        }
         std::list< Statement * > &kids = cmpndStmt->get_kids();
         for ( std::list< Statement * >::iterator k = kids.begin(); k != kids.end(); k++ ) {
             *k = (*k)->acceptMutator(*this);
             if ( ! get_breakLabel().empty() ) {
                 std::list< Statement * >::iterator next = k; next++;
                 if ( next == kids.end() ) {
                     std::list<Label> ls; ls.push_back( get_breakLabel() );
                     kids.push_back( new NullStmt( ls ) );
                 } else
                     (*next)->get_labels().push_back( get_breakLabel() );
                 set_breakLabel("");
             } // if
         } // for
         if ( labeledBlock ) {
             assert( ! enclosingBlocks.empty() );
             if ( ! enclosingBlocks.back().get_breakExit().empty() )
                 set_breakLabel( enclosingBlocks.back().get_breakExit() );
             enclosingBlocks.pop_back();
         } // if
         //mutateAll( cmpndStmt->get_kids(), *this );
         return cmpndStmt;
+    }
     Statement *MLEMutator::mutate( WhileStmt *whileStmt ) {
         enclosingLoops.push_back( Entry( whileStmt ) );
         whileStmt->set_body ( whileStmt->get_body()->acceptMutator( *this ) );
         Entry &e = enclosingLoops.back();
         assert ( e == whileStmt );
         whileStmt->set_body( mutateLoop( whileStmt->get_body(), e ) );
         enclosingLoops.pop_back();
         return whileStmt;
+    }
     Statement *MLEMutator::mutate( ForStmt *forStmt ) {
         enclosingLoops.push_back( Entry( forStmt ) );
         maybeMutate( forStmt->get_body(), *this );
         Entry &e = enclosingLoops.back();
         assert ( e == forStmt );
         forStmt->set_body( mutateLoop( forStmt->get_body(), e ) );
         enclosingLoops.pop_back();
         return forStmt;
+    }
     Statement *MLEMutator::mutate( BranchStmt *branchStmt ) throw ( SemanticError ) {
         if ( branchStmt->get_type() == BranchStmt::Goto )
             return branchStmt;
         // test if continue target is a loop
         if ( branchStmt->get_type() == BranchStmt::Continue && enclosingLoops.empty() )
             throw SemanticError( "'continue' outside a loop" );
         if ( branchStmt->get_type() == BranchStmt::Break && (enclosingLoops.empty() && enclosingSwitches.empty() && enclosingBlocks.empty() ) )
             throw SemanticError( "'break' outside a loop or switch" );
         if ( branchStmt->get_target() == "" ) return branchStmt;
         if ( targetTable->find( branchStmt->get_target() ) == targetTable->end() )
             throw SemanticError("The label defined in the exit loop statement does not exist." );  // shouldn't happen (since that's already checked)
         std::list< Entry >::iterator check;
         if ( ( check = std::find( enclosingLoops.begin(), enclosingLoops.end(), (*targetTable)[branchStmt->get_target()] ) ) == enclosingLoops.end() )
             // not in loop, checking if in block
             if ( (check = std::find( enclosingBlocks.begin(), enclosingBlocks.end(), (*targetTable)[branchStmt->get_target()] )) == enclosingBlocks.end() )
                 // neither in loop nor in block, checking if in switch/choose
                 if ( (check = std::find( enclosingSwitches.begin(), enclosingSwitches.end(), (*targetTable)[branchStmt->get_target()] )) == enclosingSwitches.end() )
                     throw SemanticError("The target specified in the exit loop statement does not correspond to an enclosing loop.");
         if ( enclosingLoops.back() == (*check) )
             return branchStmt;                          // exit the innermost loop (labels unnecessary)
         Label newLabel;
         switch ( branchStmt->get_type() ) {
           case BranchStmt::Break:
             if ( check->get_breakExit() != "" )
                 newLabel = check->get_breakExit();
             else {
                 newLabel = generator->newLabel();
                 check->set_breakExit( newLabel );
             } // if
             break;
           case BranchStmt::Continue:
             if ( check->get_contExit() != "" )
                 newLabel = check->get_contExit();
             else {
                 newLabel = generator->newLabel();
                 check->set_contExit( newLabel );
             } // if
             break;
           default:
             return 0;                                   // shouldn't be here
         } // switch
         return new BranchStmt( std::list<Label>(), newLabel, BranchStmt::Goto );
+    }
     Statement *MLEMutator::mutate( SwitchStmt *switchStmt ) {
         Label brkLabel = generator->newLabel();
         enclosingSwitches.push_back( Entry(switchStmt, "", brkLabel) );
         mutateAll( switchStmt->get_branches(), *this ); {
             // check if this is necessary (if there is a break to this point, otherwise do not generate
             std::list<Label> temp; temp.push_back( brkLabel );
             switchStmt->get_branches().push_back( new BranchStmt( temp, Label(""), BranchStmt::Break ) );
+        }
         assert ( enclosingSwitches.back() == switchStmt );
         enclosingSwitches.pop_back();
         return switchStmt;
+    }
     Statement *MLEMutator::mutate( ChooseStmt *switchStmt ) {
         Label brkLabel = generator->newLabel();
         enclosingSwitches.push_back( Entry(switchStmt,"", brkLabel) );
         mutateAll( switchStmt->get_branches(), *this ); {
             // check if this is necessary (if there is a break to this point, otherwise do not generate
             std::list<Label> temp; temp.push_back( brkLabel );
             switchStmt->get_branches().push_back( new BranchStmt( temp, Label(""), BranchStmt::Break ) );
+        }
         assert ( enclosingSwitches.back() == switchStmt );
         enclosingSwitches.pop_back();
         return switchStmt;
+    }
     Statement *MLEMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
         CompoundStmt *newBody;
         if ( ! (newBody = dynamic_cast<CompoundStmt *>( bodyLoop )) ) {
             newBody = new CompoundStmt( std::list< Label >() );
             newBody->get_kids().push_back( bodyLoop );
         } // if
         Label endLabel = e.get_contExit();
         if ( e.get_breakExit() != "" ) {
             if ( endLabel == "" ) endLabel = generator->newLabel();
             // check for whether this label is used or not, so as to not generate extraneous gotos
             if (e.breakExitUsed)
                 newBody->get_kids().push_back( new BranchStmt( std::list< Label >(), endLabel, BranchStmt::Goto ) );
             // xxx
             //std::list< Label > ls; ls.push_back( e.get_breakExit() );
             set_breakLabel( e.get_breakExit() );
             //newBody->get_kids().push_back( new BranchStmt( ls, "", BranchStmt::Break ) );
         } // if
         if ( e.get_breakExit() != "" || e.get_contExit() != "" ){
             if (dynamic_cast< NullStmt *>( newBody->get_kids().back() ))
                 newBody->get_kids().back()->get_labels().push_back( endLabel );
             else {
                 std::list < Label > ls; ls.push_back( endLabel );
                 newBody->get_kids().push_back( new NullStmt( ls ) );
             } // if
         } // if
         return newBody;
+    }
     //*** Entry's methods
     void MLEMutator::Entry::set_contExit( Label l ) {
         assert ( contExit == "" || contExit == l );
         contExit = l;
+    }
     void MLEMutator::Entry::set_breakExit( Label l ) {
         assert ( breakExit == "" || breakExit == l );
         breakExit = l;
+    }
+        MLEMutator::~MLEMutator() {
+                delete targetTable;
+                targetTable = 0;
+        }
+        CompoundStmt* MLEMutator::mutate( CompoundStmt *cmpndStmt ) {
+                bool labeledBlock = false;
+                if ( !((cmpndStmt->get_labels()).empty()) ) {
+                        labeledBlock = true;
+                        enclosingBlocks.push_back( Entry( cmpndStmt ) );
+                } // if
+                std::list< Statement * > &kids = cmpndStmt->get_kids();
+                for ( std::list< Statement * >::iterator k = kids.begin(); k != kids.end(); k++ ) {
+                        *k = (*k)->acceptMutator(*this);
+                        if ( ! get_breakLabel().empty() ) {
+                                std::list< Statement * >::iterator next = k; next++;
+                                if ( next == kids.end() ) {
+                                        std::list<Label> ls; ls.push_back( get_breakLabel() );
+                                        kids.push_back( new NullStmt( ls ) );
+                                } else
+                                        (*next)->get_labels().push_back( get_breakLabel() );
+                                set_breakLabel("");
+                        } // if
+                } // for
+                if ( labeledBlock ) {
+                        assert( ! enclosingBlocks.empty() );
+                        if ( ! enclosingBlocks.back().get_breakExit().empty() )
+                                set_breakLabel( enclosingBlocks.back().get_breakExit() );
+                        enclosingBlocks.pop_back();
+                } // if
+                //mutateAll( cmpndStmt->get_kids(), *this );
+                return cmpndStmt;
+        }
+        Statement *MLEMutator::mutate( WhileStmt *whileStmt ) {
+                enclosingLoops.push_back( Entry( whileStmt ) );
+                whileStmt->set_body ( whileStmt->get_body()->acceptMutator( *this ) );
+                Entry &e = enclosingLoops.back();
+                assert ( e == whileStmt );
+                whileStmt->set_body( mutateLoop( whileStmt->get_body(), e ) );
+                enclosingLoops.pop_back();
+                return whileStmt;
+        }
+        Statement *MLEMutator::mutate( ForStmt *forStmt ) {
+                enclosingLoops.push_back( Entry( forStmt ) );
+                maybeMutate( forStmt->get_body(), *this );
+                Entry &e = enclosingLoops.back();
+                assert ( e == forStmt );
+                forStmt->set_body( mutateLoop( forStmt->get_body(), e ) );
+                enclosingLoops.pop_back();
+                return forStmt;
+        }
+        Statement *MLEMutator::mutate( BranchStmt *branchStmt ) throw ( SemanticError ) {
+                if ( branchStmt->get_type() == BranchStmt::Goto )
+                        return branchStmt;
+                // test if continue target is a loop
+                if ( branchStmt->get_type() == BranchStmt::Continue && enclosingLoops.empty() )
+                        throw SemanticError( "'continue' outside a loop" );
+                if ( branchStmt->get_type() == BranchStmt::Break && (enclosingLoops.empty() && enclosingSwitches.empty() && enclosingBlocks.empty() ) )
+                        throw SemanticError( "'break' outside a loop or switch" );
+                if ( branchStmt->get_target() == "" ) return branchStmt;
+                if ( targetTable->find( branchStmt->get_target() ) == targetTable->end() )
+                        throw SemanticError("The label defined in the exit loop statement does not exist." );  // shouldn't happen (since that's already checked)
+                std::list< Entry >::iterator check;
+                if ( ( check = std::find( enclosingLoops.begin(), enclosingLoops.end(), (*targetTable)[branchStmt->get_target()] ) ) == enclosingLoops.end() )
+                        // not in loop, checking if in block
+                        if ( (check = std::find( enclosingBlocks.begin(), enclosingBlocks.end(), (*targetTable)[branchStmt->get_target()] )) == enclosingBlocks.end() )
+                                // neither in loop nor in block, checking if in switch/choose
+                                if ( (check = std::find( enclosingSwitches.begin(), enclosingSwitches.end(), (*targetTable)[branchStmt->get_target()] )) == enclosingSwitches.end() )
+                                        throw SemanticError("The target specified in the exit loop statement does not correspond to an enclosing loop.");
+                if ( enclosingLoops.back() == (*check) )
+                        return branchStmt;                              // exit the innermost loop (labels unnecessary)
+                Label newLabel;
+                switch ( branchStmt->get_type() ) {
+                  case BranchStmt::Break:
+                        if ( check->get_breakExit() != "" )
+                                newLabel = check->get_breakExit();
+                        else {
+                                newLabel = generator->newLabel();
+                                check->set_breakExit( newLabel );
+                        } // if
+                        break;
+                  case BranchStmt::Continue:
+                        if ( check->get_contExit() != "" )
+                                newLabel = check->get_contExit();
+                        else {
+                                newLabel = generator->newLabel();
+                                check->set_contExit( newLabel );
+                        } // if
+                        break;
+                  default:
+                        return 0;                                       // shouldn't be here
+                } // switch
+                return new BranchStmt( std::list<Label>(), newLabel, BranchStmt::Goto );
+        }
+        Statement *MLEMutator::mutate( SwitchStmt *switchStmt ) {
+                Label brkLabel = generator->newLabel();
+                enclosingSwitches.push_back( Entry(switchStmt, "", brkLabel) );
+                mutateAll( switchStmt->get_branches(), *this ); {
+                        // check if this is necessary (if there is a break to this point, otherwise do not generate
+                        std::list<Label> temp; temp.push_back( brkLabel );
+                        switchStmt->get_branches().push_back( new BranchStmt( temp, Label(""), BranchStmt::Break ) );
+                }
+                assert ( enclosingSwitches.back() == switchStmt );
+                enclosingSwitches.pop_back();
+                return switchStmt;
+        }
+        Statement *MLEMutator::mutate( ChooseStmt *switchStmt ) {
+                Label brkLabel = generator->newLabel();
+                enclosingSwitches.push_back( Entry(switchStmt,"", brkLabel) );
+                mutateAll( switchStmt->get_branches(), *this ); {
+                        // check if this is necessary (if there is a break to this point, otherwise do not generate
+                        std::list<Label> temp; temp.push_back( brkLabel );
+                        switchStmt->get_branches().push_back( new BranchStmt( temp, Label(""), BranchStmt::Break ) );
+                }
+                assert ( enclosingSwitches.back() == switchStmt );
+                enclosingSwitches.pop_back();
+                return switchStmt;
+        }
+        Statement *MLEMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
+                CompoundStmt *newBody;
+                if ( ! (newBody = dynamic_cast<CompoundStmt *>( bodyLoop )) ) {
+                        newBody = new CompoundStmt( std::list< Label >() );
+                        newBody->get_kids().push_back( bodyLoop );
+                } // if
+                Label endLabel = e.get_contExit();
+                if ( e.get_breakExit() != "" ) {
+                        if ( endLabel == "" ) endLabel = generator->newLabel();
+                        // check for whether this label is used or not, so as to not generate extraneous gotos
+                        if (e.breakExitUsed)
+                                newBody->get_kids().push_back( new BranchStmt( std::list< Label >(), endLabel, BranchStmt::Goto ) );
+                        // xxx
+                        //std::list< Label > ls; ls.push_back( e.get_breakExit() );
+                        set_breakLabel( e.get_breakExit() );
+                        //newBody->get_kids().push_back( new BranchStmt( ls, "", BranchStmt::Break ) );
+                } // if
+                if ( e.get_breakExit() != "" || e.get_contExit() != "" ) {
+                        if (dynamic_cast< NullStmt *>( newBody->get_kids().back() ))
+                                newBody->get_kids().back()->get_labels().push_back( endLabel );
+                        else {
+                                std::list < Label > ls; ls.push_back( endLabel );
+                                newBody->get_kids().push_back( new NullStmt( ls ) );
+                        } // if
+                } // if
+                return newBody;
+        }
+        //*** Entry's methods
+        void MLEMutator::Entry::set_contExit( Label l ) {
+                assert ( contExit == "" || contExit == l );
+                contExit = l;
+        }
+        void MLEMutator::Entry::set_breakExit( Label l ) {
+                assert ( breakExit == "" || breakExit == l );
+                breakExit = l;
+        }
 } // namespace ControlStruct
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/MLEMutator.h

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// MLEMutator.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:32:39 2015
+// Update Count     : 3
 //
 #ifndef MLE_MUTATOR_H
 #define MLE_MUTATOR_H
 …
 namespace ControlStruct {
     class MLEMutator : public Mutator {
         class Entry;
       public:
         MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
         ~MLEMutator();
+        class MLEMutator : public Mutator {
+                class Entry;
+          public:
+                MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
+                ~MLEMutator();
         CompoundStmt *mutate( CompoundStmt *cmpndStmt );
         Statement *mutate( WhileStmt *whileStmt );
         Statement *mutate( ForStmt *forStmt );
         Statement *mutate( BranchStmt *branchStmt ) throw ( SemanticError );
+                CompoundStmt *mutate( CompoundStmt *cmpndStmt );
+                Statement *mutate( WhileStmt *whileStmt );
+                Statement *mutate( ForStmt *forStmt );
+                Statement *mutate( BranchStmt *branchStmt ) throw ( SemanticError );
         Statement *mutate( SwitchStmt *switchStmt );
         Statement *mutate( ChooseStmt *switchStmt );
+                Statement *mutate( SwitchStmt *switchStmt );
+                Statement *mutate( ChooseStmt *switchStmt );
         Statement *mutateLoop( Statement *bodyLoop, Entry &e );
+                Statement *mutateLoop( Statement *bodyLoop, Entry &e );
         Label &get_breakLabel() { return breakLabel; }
         void set_breakLabel( Label newValue ) { breakLabel = newValue; }
       private:
         class Entry {
           public:
             explicit Entry( Statement *_loop = 0, Label _contExit = Label(""), Label _breakExit = Label("") ) :
                 loop( _loop ), contExit( _contExit ), breakExit( _breakExit ), contExitUsed( false ), breakExitUsed( false ) {}
+                Label &get_breakLabel() { return breakLabel; }
+                void set_breakLabel( Label newValue ) { breakLabel = newValue; }
+          private:
+                class Entry {
+                  public:
+                        explicit Entry( Statement *_loop = 0, Label _contExit = Label(""), Label _breakExit = Label("") ) :
+                                loop( _loop ), contExit( _contExit ), breakExit( _breakExit ), contExitUsed( false ), breakExitUsed( false ) {}
             bool operator==( const Statement *stmt ) { return ( loop == stmt ); }
             bool operator!=( const Statement *stmt ) { return ( loop != stmt ); }
+                        bool operator==( const Statement *stmt ) { return ( loop == stmt ); }
+                        bool operator!=( const Statement *stmt ) { return ( loop != stmt ); }
             bool operator==( const Entry &other ) { return ( loop == other.get_loop() ); }
+                        bool operator==( const Entry &other ) { return ( loop == other.get_loop() ); }
             Statement *get_loop() const { return loop; }
+                        Statement *get_loop() const { return loop; }
             Label get_contExit() const { return contExit; }
             void set_contExit( Label );
+                        Label get_contExit() const { return contExit; }
+                        void set_contExit( Label );
             Label get_breakExit() const { return breakExit; }
             void set_breakExit( Label );
+                        Label get_breakExit() const { return breakExit; }
+                        void set_breakExit( Label );
+          private:
+            Statement *loop;
+            Label contExit, breakExit;
+          public: // hack, provide proper [sg]etters
+            bool contExitUsed, breakExitUsed;
+                  private:
+                        Statement *loop;
+                        Label contExit, breakExit;
+                  public: // hack, provide proper [sg]etters
+                        bool contExitUsed, breakExitUsed;
+                };
+                std::map< Label, Statement * > *targetTable;
+                std::list< Entry > enclosingBlocks, enclosingLoops, enclosingSwitches;
+                Label breakLabel;
+                LabelGenerator *generator;
         };
-        std::map< Label, Statement * > *targetTable;
-        std::list< Entry > enclosingBlocks, enclosingLoops, enclosingSwitches;
-        Label breakLabel;
-        LabelGenerator *generator;
-    };
 } // namespace ControlStruct
 #endif
+#endif // MLE_MUTATOR_H
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/Mutate.cc

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// Mutate.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:32:52 2015
+// Update Count     : 2
 //
 #include <algorithm>
 #include <iostream>
 …
 namespace ControlStruct {
     void mutate( std::list< Declaration * > translationUnit ) {
         // ForExprMutator formut;
         LabelFixer lfix;
         ChooseMutator chmut;
         CaseRangeMutator ranges;  // has to run after ChooseMutator
         //ExceptMutator exc;
         // LabelTypeChecker lbl;
+        void mutate( std::list< Declaration * > translationUnit ) {
+                // ForExprMutator formut;
+                LabelFixer lfix;
+                ChooseMutator chmut;
+                CaseRangeMutator ranges;  // has to run after ChooseMutator
+                //ExceptMutator exc;
+                // LabelTypeChecker lbl;
         // mutateAll( translationUnit, formut );
         acceptAll( translationUnit, lfix );
         mutateAll( translationUnit, chmut );
         mutateAll( translationUnit, ranges );
         //mutateAll( translationUnit, exc );
         //acceptAll( translationUnit, lbl );
+    }
+                // mutateAll( translationUnit, formut );
+                acceptAll( translationUnit, lfix );
+                mutateAll( translationUnit, chmut );
+                mutateAll( translationUnit, ranges );
+                //mutateAll( translationUnit, exc );
+                //acceptAll( translationUnit, lbl );
+        }
 } // namespace CodeGen
 // Local Variables: //
 // tab-width: 4 //

translator/ControlStruct/Mutate.h

-              r01aeade
+              ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// Mutate.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 15:31:20 2015
+// Update Count     : 2
 //
 #ifndef CTRLS_MUTATE_H
 #define CTRLS_MUTATE_H
 …
 namespace ControlStruct {
     void mutate( std::list< Declaration* > translationUnit );
+        void mutate( std::list< Declaration* > translationUnit );
 } // namespace ControlStruct
 #endif // CTRLS_MUTATE_H
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

Context Navigation

Legend:

translator/ControlStruct/CaseRangeMutator.cc

translator/ControlStruct/CaseRangeMutator.h

translator/ControlStruct/ChooseMutator.cc

translator/ControlStruct/ChooseMutator.h

translator/ControlStruct/ForExprMutator.cc

translator/ControlStruct/ForExprMutator.h

translator/ControlStruct/LabelFixer.cc

translator/ControlStruct/LabelFixer.h

translator/ControlStruct/LabelGenerator.cc

translator/ControlStruct/LabelGenerator.h

translator/ControlStruct/LabelTypeChecker.cc

translator/ControlStruct/LabelTypeChecker.h

translator/ControlStruct/MLEMutator.cc

translator/ControlStruct/MLEMutator.h

translator/ControlStruct/Mutate.cc

translator/ControlStruct/Mutate.h

Download in other formats: