Changeset a08ba92

translator/CodeGen/GenType.cc

-                      r01aeade
+                      ra08ba92
+        }
         void GenType::visit( ArrayType *arrayType ){
+        void GenType::visit( ArrayType *arrayType ) {
                 genArray( arrayType->get_qualifiers(), arrayType->get_base(), arrayType->get_dimension(), arrayType->get_isVarLen(), arrayType->get_isStatic() );
+        }
 …
                         cg.genCommaList( pars.begin(), pars.end() );
                         if ( funcType->get_isVarArgs() ){
+                        if ( funcType->get_isVarArgs() ) {
                                 os << ", ...";
                         } // if

translator/Common/utility.h

-                      r01aeade
+                      ra08ba92
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 19 07:27:38 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 15:34:57 2015
+// Update Count     : 3
 //
 …
         Ts ret;
         switch ( l.size() ){
+        switch ( l.size() ) {
           case 0:
                 return ret;
 …
         //if ( next != org.end() ) {
     org.erase( pos );
     org.splice( next, with );
     //}
+        org.erase( pos );
+        org.splice( next, with );
+        //}
         return;
 …
 template< typename T >
 struct is_null_pointer {
         bool operator()( const T *ptr ){ return ( ptr == 0 ); }
+        bool operator()( const T *ptr ) { return ( ptr == 0 ); }
 };

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 //

translator/Designators/Processor.cc

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// Processor.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 16:23:10 2015
+// Update Count     : 2
 //
 #include <vector>
 #include <algorithm>
 …
 namespace Designators {
+    Matcher::Matcher( const std::list< DeclarationWithType * > &decls ) {
+        int cnt = 0;
+        for ( std::list< DeclarationWithType * >::const_iterator i = decls.begin();
+             i != decls.end(); i++, cnt++ ) {
+            std::string newName = (*i)->get_name();
+            if ( table.find( newName ) == table.end() ) {
+                table.insert( std::pair<std::string, int>(newName, cnt) );
+                order.push_back( newName );
+                declarations.push_back( *i );
+                alternatives.push_back( 0 );
+            }
+        Matcher::Matcher( const std::list< DeclarationWithType * > &decls ) {
+                int cnt = 0;
+                for ( std::list< DeclarationWithType * >::const_iterator i = decls.begin();
+                          i != decls.end(); i++, cnt++ ) {
+                        std::string newName = (*i)->get_name();
+                        if ( table.find( newName ) == table.end() ) {
+                                table.insert( std::pair<std::string, int>(newName, cnt) );
+                                order.push_back( newName );
+                                declarations.push_back( *i );
+                                alternatives.push_back( 0 );
+                        } // if
+                } // for
+        }
+    }
+    template< class InputIterator >
+    bool Matcher::add(InputIterator begin, InputIterator end, ResolvExpr::Alternative &alt ) {
+        while ( begin != end ) {
+            if ( table.find( *begin ) != table.end() )
+                alternatives[ table[ *begin ] ] = new ResolvExpr::Alternative(alt);
+            else
+                return false;
+            begin++;
+        template< class InputIterator >
+        bool Matcher::add(InputIterator begin, InputIterator end, ResolvExpr::Alternative &alt ) {
+                while ( begin != end ) {
+                        if ( table.find( *begin ) != table.end() )
+                                alternatives[ table[ *begin ] ] = new ResolvExpr::Alternative(alt);
+                        else
+                                return false;
+                        begin++;
+                } // while
+                return true;
+        }
-        return true;
+    }
     template< class InputIterator, class OutputIterator >
     bool Matcher::slice(InputIterator begin, InputIterator end, OutputIterator out ) {
         while ( begin != end )
             if ( table.find( *begin ) != table.end() )
                 *out++ = declarations [ table[ *begin++ ] ];
             else
                 return false; // throw 0;
         return true;
+    }
+        template< class InputIterator, class OutputIterator >
+        bool Matcher::slice(InputIterator begin, InputIterator end, OutputIterator out ) {
+                while ( begin != end )
+                        if ( table.find( *begin ) != table.end() )
+                                *out++ = declarations [ table[ *begin++ ] ];
+                        else
+                                return false; // throw 0;
+                return true;
+        }
     template< class OutputIterator >
     bool Matcher::get_reorderedCall( OutputIterator out ) {
         // fill call with defaults, if need be
         for (Matcher::iterator o = begin(); o != end(); o++ )
             if ( alternatives[ table[ *o ] ] == 0 )
                 return false;
             else
                 out++ = *alternatives[table[ *o ]];
         return true;
+    }
+        template< class OutputIterator >
+        bool Matcher::get_reorderedCall( OutputIterator out ) {
+                // fill call with defaults, if need be
+                for (Matcher::iterator o = begin(); o != end(); o++ )
+                        if ( alternatives[ table[ *o ] ] == 0 )
+                                return false;
+                        else
+                                out++ = *alternatives[table[ *o ]];
+                return true;
+        }
     bool fixDesignations( ResolvExpr::AlternativeFinder &finder, Expression *designation ) {
         // Distribute `designation' over alternatives contained in `finder'
         if ( ! designation) return false;
         else
             for ( ResolvExpr::AlternativeFinder::iterator alt = finder.begin(); alt != finder.end(); alt++ )
                 alt->expr->set_argName( designation );
         return true;
+    }
+        bool fixDesignations( ResolvExpr::AlternativeFinder &finder, Expression *designation ) {
+                // Distribute `designation' over alternatives contained in `finder'
+                if ( ! designation) return false;
+                else
+                        for ( ResolvExpr::AlternativeFinder::iterator alt = finder.begin(); alt != finder.end(); alt++ )
+                                alt->expr->set_argName( designation );
+                return true;
+        }
     template < class OutputIterator >
     bool extractNames( Expression *expr, OutputIterator out, Matcher matcher ) {
         Expression *designator = expr->get_argName();
         if ( designator == 0 ) return false;
+        template < class OutputIterator >
+        bool extractNames( Expression *expr, OutputIterator out, Matcher matcher ) {
+                Expression *designator = expr->get_argName();
+                if ( designator == 0 ) return false;
         if ( NameExpr *ndes = dynamic_cast<NameExpr *>(designator) )
             out++ = ndes->get_name();
         else if ( TupleExpr *tdes = dynamic_cast<TupleExpr *>(designator) ) {
             std::cerr << "Tuple designation" << std::endl;
+                if ( NameExpr *ndes = dynamic_cast<NameExpr *>(designator) )
+                        out++ = ndes->get_name();
+                else if ( TupleExpr *tdes = dynamic_cast<TupleExpr *>(designator) ) {
+                        std::cerr << "Tuple designation" << std::endl;
 //      ObjectDecl *decl = extractTupleV(matcher, tdes); // xxx
             // transform?
             for ( std::list< Expression * >::iterator n = tdes->get_exprs().begin();
                  n != tdes->get_exprs().end(); n++ ) {
+                        // transform?
+                        for ( std::list< Expression * >::iterator n = tdes->get_exprs().begin();
+                                  n != tdes->get_exprs().end(); n++ ) {
+                if ( NameExpr *name = dynamic_cast<NameExpr *>(*n) )
+                    out++ = name->get_name();
+                else
+                    // flatten nested Tuples
+                    throw SemanticError( "Invalid tuple designation." );
+            }
+                                if ( NameExpr *name = dynamic_cast<NameExpr *>(*n) )
+                                        out++ = name->get_name();
+                                else
+                                        // flatten nested Tuples
+                                        throw SemanticError( "Invalid tuple designation." );
+                        } // for
+                } // if
+                return true;
+        }
-        return true;
+    }
     std::string extractName( Expression *expr ) /* throw NoNameExtraction */ {
         if ( NameExpr *name = dynamic_cast< NameExpr *>(expr) )
             return name->get_name();
         else /* if () */
             throw 0;
+    }
+        std::string extractName( Expression *expr ) /* throw NoNameExtraction */ {
+                if ( NameExpr *name = dynamic_cast< NameExpr *>(expr) )
+                        return name->get_name();
+                else /* if () */
+                        throw 0;
+        }
     DeclarationWithType *gensym( DeclarationWithType *, std::string prefix ) {
         return 0;
+    }
+        DeclarationWithType *gensym( DeclarationWithType *, std::string prefix ) {
+                return 0;
+        }
     ObjectDecl *extractTupleV( Matcher matcher, TupleExpr *nmTuple ) {
         // extract a subtuple of the function `fun' argument list, corresponding to the tuple of names requested by
         // `nmTuple'.
         std::list< Expression * > &exprs = nmTuple->get_exprs();
         std::cerr << "In extractTupleV, the tuple has " << exprs.size() << " components." << std::endl;
         std::list< std::string > names;
         std::transform( exprs.begin(), exprs.end(), back_inserter(names), extractName );
         std::list< DeclarationWithType * > decls;
         matcher.slice( names.begin(), names.end(), back_inserter(decls) );
         //std::for_each( decls.begin(), decls.end(), gensym );
         std::cerr << "Returning declaration with " << decls.size() << " components." << std::endl;
+        ObjectDecl *extractTupleV( Matcher matcher, TupleExpr *nmTuple ) {
+                // extract a subtuple of the function `fun' argument list, corresponding to the tuple of names requested by
+                // `nmTuple'.
+                std::list< Expression * > &exprs = nmTuple->get_exprs();
+                std::cerr << "In extractTupleV, the tuple has " << exprs.size() << " components." << std::endl;
+                std::list< std::string > names;
+                std::transform( exprs.begin(), exprs.end(), back_inserter(names), extractName );
+                std::list< DeclarationWithType * > decls;
+                matcher.slice( names.begin(), names.end(), back_inserter(decls) );
+                //std::for_each( decls.begin(), decls.end(), gensym );
+                std::cerr << "Returning declaration with " << decls.size() << " components." << std::endl;
         return 0;//new ObjectDecl()
+    }
+                return 0;//new ObjectDecl()
+        }
     void check_alternative( FunctionType *fun, ResolvExpr::AltList &args ) {
         using namespace ResolvExpr;
+        void check_alternative( FunctionType *fun, ResolvExpr::AltList &args ) {
+                using namespace ResolvExpr;
+        Matcher matcher( fun->get_parameters() );
+        for ( AltList::iterator a = args.begin(); a != args.end(); a++ ) {
+            std::list< std::string > actNames;
+            if ( ! extractNames( a->expr, back_inserter(actNames), matcher ) ) {
+                return; // not a designated call, leave alternative alone
+            } else {
+                // see if there's a match
+                matcher.add( actNames.begin(), actNames.end(), *a );
+            }
+                Matcher matcher( fun->get_parameters() );
+                for ( AltList::iterator a = args.begin(); a != args.end(); a++ ) {
+                        std::list< std::string > actNames;
+                        if ( ! extractNames( a->expr, back_inserter(actNames), matcher ) ) {
+                                return; // not a designated call, leave alternative alone
+                        } else {
+                                // see if there's a match
+                                matcher.add( actNames.begin(), actNames.end(), *a );
+                        } // if
+                } // for
+                //AltList newArgs;
+                args.clear();
+                matcher.get_reorderedCall( back_inserter(args) );
+                return;
+        }
-        //AltList newArgs;
-        args.clear();
-        matcher.get_reorderedCall( back_inserter(args) );
-        return;
+    }
 #if 0
+    void pruneAlternatives( Expression *expr, ResolvExpr::AlternativeFinder &finder ) {
+        if ( expr->get_argName() != 0 ) {
+            // Looking at designated expression
+            using namespace ResolvExpr;
+            AltList &alternatives = finder.get_alternatives();
+            std::cerr << "Now printing alternatives: " << std::endl;
+            for ( AltList::iterator a = alternatives.begin(); a != alternatives.end(); a++ )
+                a->expr->print( std::cerr );
+            //std::cerr << "Looking for constructions of length no more than: " << tdes->get_exprs().size() << "." << std::endl;
+        void pruneAlternatives( Expression *expr, ResolvExpr::AlternativeFinder &finder ) {
+                if ( expr->get_argName() != 0 ) {
+                        // Looking at designated expression
+                        using namespace ResolvExpr;
+                        AltList &alternatives = finder.get_alternatives();
+                        std::cerr << "Now printing alternatives: " << std::endl;
+                        for ( AltList::iterator a = alternatives.begin(); a != alternatives.end(); a++ )
+                                a->expr->print( std::cerr );
+                        //std::cerr << "Looking for constructions of length no more than: " << tdes->get_exprs().size() << "." << std::endl;
+                }
+                return;
+        }
-        return;
+    }
 #endif // 0
 } // namespaces Designators
 // Local Variables: //
 // tab-width: 4 //

translator/Designators/Processor.h

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// Processor.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 16:24:34 2015
+// Update Count     : 3
 //
 #include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
 …
 namespace Designators {
   class Matcher;
   class GenSym;
+        class Matcher;
+        class GenSym;
   template < class OutputIterator >  bool extractNames( std::list< DeclarationWithType * > &, OutputIterator );
   template < class OutputIterator >  bool extractNames( Expression *, OutputIterator, Matcher );
   void check_alternative( FunctionType *, ResolvExpr::AltList & );
   ObjectDecl *extractTupleV( Matcher, TupleExpr *names );
   bool fixDesignations( ResolvExpr::AlternativeFinder &finder, Expression *designation );
   DeclarationWithType *gensym( GenSym &, DeclarationWithType * );
+        template < class OutputIterator >  bool extractNames( std::list< DeclarationWithType * > &, OutputIterator );
+        template < class OutputIterator >  bool extractNames( Expression *, OutputIterator, Matcher );
+        void check_alternative( FunctionType *, ResolvExpr::AltList & );
+        ObjectDecl *extractTupleV( Matcher, TupleExpr *names );
+        bool fixDesignations( ResolvExpr::AlternativeFinder &finder, Expression *designation );
+        DeclarationWithType *gensym( GenSym &, DeclarationWithType * );
   class GenSym {
   public:
     GenSym( std::string prefix = "" ) : gensym_count(0) {}
     GenSym( GenSym &other ) { gensym_count = other.gensym_count; }
+        class GenSym {
+          public:
+                GenSym( std::string prefix = "" ) : gensym_count(0) {}
+                GenSym( GenSym &other ) { gensym_count = other.gensym_count; }
 //    std::string get_symbol() { }
   private:
     std::string prefix;
     int gensym_count;
   };
+          private:
+                std::string prefix;
+                int gensym_count;
+        };
   // template< typename Key >
   class Matcher {
   public:
     typedef std::vector< std::string >::iterator iterator;
+        // template< typename Key >
+        class Matcher {
+          public:
+                typedef std::vector< std::string >::iterator iterator;
     Matcher( const std::list< DeclarationWithType * > & );
     ~Matcher() {}
+                Matcher( const std::list< DeclarationWithType * > & );
+                ~Matcher() {}
     template< class OutputIterator > bool get_reorderedCall( OutputIterator );
     template< class InputIterator >  bool add(InputIterator, InputIterator, ResolvExpr::Alternative &);
     template< class InputIterator, class OutputIterator >  bool slice(InputIterator begin, InputIterator end, OutputIterator );
     //std::vector<std::string> &get_order() const { return order; }
+                template< class OutputIterator > bool get_reorderedCall( OutputIterator );
+                template< class InputIterator >  bool add(InputIterator, InputIterator, ResolvExpr::Alternative &);
+                template< class InputIterator, class OutputIterator >  bool slice(InputIterator begin, InputIterator end, OutputIterator );
+                //std::vector<std::string> &get_order() const { return order; }
     iterator begin() { return order.begin(); }
     iterator end() { return order.end(); }
+                iterator begin() { return order.begin(); }
+                iterator end() { return order.end(); }
+    //Expression *operator[]( int idx ) { return table( order[ idx ] ); }
+  private:
+    std::map< std::string, int > table;
+    std::vector<std::string> order;
+    std::vector<DeclarationWithType *> declarations;
+    std::vector<ResolvExpr::Alternative *> alternatives;
+  };
+  //  void pruneAlternatives( Expression *expr, ResolvExpr::AlternativeFinder & );
+                //Expression *operator[]( int idx ) { return table( order[ idx ] ); }
+          private:
+                std::map< std::string, int > table;
+                std::vector<std::string> order;
+                std::vector<DeclarationWithType *> declarations;
+                std::vector<ResolvExpr::Alternative *> alternatives;
+        };
+        //  void pruneAlternatives( Expression *expr, ResolvExpr::AlternativeFinder & );
 } // namespace Designators
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/GenPoly/ScrubTyVars.cc

-                      r01aeade
+                      ra08ba92
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 19 07:47:31 2015
 // Update Count     : 1
+// Last Modified On : Tue May 19 16:42:42 2015
+// Update Count     : 2
 //
 …
 namespace GenPoly {
     Type * ScrubTyVars::mutate( TypeInstType *typeInst ) {
+        Type * ScrubTyVars::mutate( TypeInstType *typeInst ) {
                 TyVarMap::const_iterator tyVar = tyVars.find( typeInst->get_name() );
                 if ( doAll || tyVar != tyVars.end() ) {
 …
                 } // if
                 return typeInst;
+    }
+        }
     Expression * ScrubTyVars::mutate( SizeofExpr *szeof ) {
+        Expression * ScrubTyVars::mutate( SizeofExpr *szeof ) {
                 // sizeof( T ) => T parameter, which is the size of T
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( szeof->get_type() ) ) {
 …
                         return Mutator::mutate( szeof );
                 } // if
+    }
+        }
     Type * ScrubTyVars::mutate( PointerType *pointer ) {
+        Type * ScrubTyVars::mutate( PointerType *pointer ) {
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( pointer->get_base() ) ) {
                         if ( doAll || tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
 …
                 } // if
                 return Mutator::mutate( pointer );
+    }
+        }
 } // namespace GenPoly

translator/InitTweak/Association.cc

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// Association.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 16:25:09 2015
+// Update Count     : 1
 //
 #include "Association.h"
 …
 const int RangeAssociation::RangeAssociation::UNDEF = -1;
 RangeAssociation::~RangeAssociation() {}
 // Local Variables: //
 // tab-width: 4 //

translator/InitTweak/Association.h

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// Association.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
+//
+#ifndef _ASSOCIATE_H_
+#define _ASSOCIATE_H_
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 16:27:09 2015
+// Update Count     : 2
+//
+#ifndef _ASSOCIATION_H_
+#define _ASSOCIATION_H_
 #include <map>
 …
 // ** exceptions
 class AssocException : public std::exception {
 public:
   AssocException() {}
   AssocException( std::string _what ) : what( _what ) {}
   ~AssocException() throw () {}
   std::string get_what() const { return what; }
   void set_what( std::string newValue ) { what = newValue; }
 private:
   std::string what;
+  public:
+        AssocException() {}
+        AssocException( std::string _what ) : what( _what ) {}
+        ~AssocException() throw () {}
+        std::string get_what() const { return what; }
+        void set_what( std::string newValue ) { what = newValue; }
+  private:
+        std::string what;
 };
 // ** visitors
 class AssociationVisitor {
 public:
   AssociationVisitor() {}
   virtual ~AssociationVisitor() {}
   virtual void visit( SingleName * ) = 0;
   virtual void visit( PointAssociation * ) = 0;
   virtual void visit( RangeAssociation * ) = 0;
+  public:
+        AssociationVisitor() {}
+        virtual ~AssociationVisitor() {}
+        virtual void visit( SingleName * ) = 0;
+        virtual void visit( PointAssociation * ) = 0;
+        virtual void visit( RangeAssociation * ) = 0;
 };
 // ** containers
 class Association {
  public:
   virtual ~Association();
   virtual Association *clone() = 0;
   virtual long int add_single( std::string, Expression *) = 0;
   virtual long int add_single( long int, Expression *expr) = 0;
   virtual Association *operator[]( int idx ) = 0;
   virtual Association *operator[]( std::string ) = 0;
   //  virtual AssociationIterator *get_iterator() = 0;
   virtual void accept( AssociationVisitor & ) = 0;
   virtual void display( std::ostream & ) = 0;
+  public:
+        virtual ~Association();
+        virtual Association *clone() = 0;
+        virtual long int add_single( std::string, Expression *) = 0;
+        virtual long int add_single( long int, Expression *expr) = 0;
+        virtual Association *operator[]( int idx ) = 0;
+        virtual Association *operator[]( std::string ) = 0;
+        //  virtual AssociationIterator *get_iterator() = 0;
+        virtual void accept( AssociationVisitor & ) = 0;
+        virtual void display( std::ostream & ) = 0;
 };
 class SingleName : public Association {
 public:
   SingleName( Expression *initExpr = 0 ) : expr( initExpr ) {}
   virtual ~SingleName();
   virtual SingleName *clone() {
     return 0; // XXX!
+  }
   virtual long int add_single( long int idx, Expression *newExpr) {
     if ( expr == 0 ) //|| *expr == *newExpr )
       expr = newExpr;
     return 0;
+  }
   virtual long int add_single( std::string str, Expression *newExpr) {
     if ( expr == 0 ) //|| *expr == *newExpr )
       expr = newExpr;
     return 0;
+  }
   virtual Association *operator[]( int idx ) { assert(false); }
   virtual Association *operator[]( std::string idx ) { assert(false); }
   virtual void accept( AssociationVisitor &v ) { v.visit( this ); }
   virtual void display( std::ostream &os ) {
     os << "Single association" << std::endl;
+  }
   Expression *get_expr() const { return expr; }
 private:
   Expression *expr;
   Expression *deflt;
+  public:
+        SingleName( Expression *initExpr = 0 ) : expr( initExpr ) {}
+        virtual ~SingleName();
+        virtual SingleName *clone() {
+                return 0; // XXX!
+        }
+        virtual long int add_single( long int idx, Expression *newExpr) {
+                if ( expr == 0 ) //|| *expr == *newExpr )
+                        expr = newExpr;
+                return 0;
+        }
+        virtual long int add_single( std::string str, Expression *newExpr ) {
+                if ( expr == 0 ) //|| *expr == *newExpr )
+                        expr = newExpr;
+                return 0;
+        }
+        virtual Association *operator[]( int idx ) { assert(false); }
+        virtual Association *operator[]( std::string idx ) { assert(false); }
+        virtual void accept( AssociationVisitor &v ) { v.visit( this ); }
+        virtual void display( std::ostream &os ) {
+                os << "Single association" << std::endl;
+        }
+        Expression *get_expr() const { return expr; }
+  private:
+        Expression *expr;
+        Expression *deflt;
 };
 class PointAssociation : public Association {
 public:
   typedef std::map< std::string, std::pair< long int, Association *> > map_type;
   PointAssociation() {}
   PointAssociation( const PointAssociation &other ) {
     copy( other.anonym.begin(), other.anonym.end(), back_inserter( anonym ));
+  }
   virtual ~PointAssociation();
   virtual PointAssociation *clone() {
     return ( new PointAssociation( *this ) );
+  }
   virtual long int add_single( long int idx, Expression *expr) {
     long int ret;
     if ( idx >= (long int)ordering.size() ) throw AssocException("extra (spurious) members");
     if ( ordering[ idx ] == "")
       std::cerr << "Checkpoint 2" << std::endl;
     else {
       assert( table[ordering[idx]].second != 0 );
       ret = idx;
       table[ ordering[idx] ].second->add_single("", expr );
+    }
     return ret;
+  }
   virtual long int add_single( std::string idx, Expression *expr) {
     if ( idx == "" )
       std::cerr << "Checkpoint 1" << std::endl;
     else {
       map_type::iterator j;
       if (  (j = table.find( idx )) == table.end() )  // this doesn't amount for reachable members deeper down the structure, fix
         throw AssocException("No such member");
       else
         return add_single( j->second.first, expr );
+    }
     return -1;
+  }
   void add_member( std::string str ) {
     if ( table.find( str ) != table.end() ) return;
     ordering.push_back( str );
     if ( str != "" ) {
       std::pair<long int, Association *> p( ordering.size() - 1, 0 );
       table.insert( std::pair< std::string, std::pair<long int, Association *> >(str, p) );
+    }
     return;
+  }
   virtual void set_member( std::string str, Association *assoc ) {
     if ( str == "" )
       anonym.push_back( assoc );
     else  if ( table.find( str ) == table.end() )
       throw AssocException( "no such member" );
     else
       table[ str ] = std::pair<long int, Association *>(ordering.size() - 1, assoc);
     return;
+  }
   virtual Association *operator[]( int idx ) {
     if ( ordering[idx] == "" ) {
       std::cerr << "Error, anonymous members not implemented yet" << std::endl;
       throw 0;
     } else
       return table[ ordering[idx] ].second;
+  }
   virtual Association *operator[]( std::string idx ) {
     if ( table.find( idx ) == table.end() )
       throw AssocException("Member not found");
     else
       return table[ idx ].second;
+  }
   /*
   virtual AssociationIterator *get_iterator() {
     PointAssocIterator *it;
     return it;
+  }
   */
   void accept( AssociationVisitor &v ) { v.visit( this ); }
   virtual void display( std::ostream &os ) {
     os << "Point association: " << std::endl;
     for ( map_type::iterator i = table.begin(); i != table.end(); i++ ) {
       os << "Member [" << i->first << ", index = " << i->second.first << "]";
       if ( i->second.second != 0 )
         i->second.second->display( os );
       else
         std::cerr << "No recursive association" << std::endl;
       os << std::endl;
+    }
+  }
   const int size() const { return ordering.size(); }
 private:
   PointAssociation &operator=(const PointAssociation &);
   std::vector<std::string> ordering;
   std::list< Association * > anonym;
   std::map< std::string, std::pair<long int, Association *> > table;
+  public:
+        typedef std::map< std::string, std::pair< long int, Association *> > map_type;
+        PointAssociation() {}
+        PointAssociation( const PointAssociation &other ) {
+                copy( other.anonym.begin(), other.anonym.end(), back_inserter( anonym ));
+        }
+        virtual ~PointAssociation();
+        virtual PointAssociation *clone() {
+                return ( new PointAssociation( *this ) );
+        }
+        virtual long int add_single( long int idx, Expression *expr) {
+                long int ret;
+                if ( idx >= (long int)ordering.size() ) throw AssocException("extra (spurious) members");
+                if ( ordering[ idx ] == "")
+                        std::cerr << "Checkpoint 2" << std::endl;
+                else {
+                        assert( table[ordering[idx]].second != 0 );
+                        ret = idx;
+                        table[ ordering[idx] ].second->add_single("", expr );
+                } // if
+                return ret;
+        }
+        virtual long int add_single( std::string idx, Expression *expr) {
+                if ( idx == "" )
+                        std::cerr << "Checkpoint 1" << std::endl;
+                else {
+                        map_type::iterator j;
+                        if (  (j = table.find( idx )) == table.end() )  // this doesn't amount for reachable members deeper down the structure, fix
+                                throw AssocException("No such member");
+                        else
+                                return add_single( j->second.first, expr );
+                } // if
+                return -1;
+        }
+        void add_member( std::string str ) {
+                if ( table.find( str ) != table.end() ) return;
+                ordering.push_back( str );
+                if ( str != "" ) {
+                        std::pair<long int, Association *> p( ordering.size() - 1, 0 );
+                        table.insert( std::pair< std::string, std::pair<long int, Association *> >(str, p) );
+                } // if
+                return;
+        }
+        virtual void set_member( std::string str, Association *assoc ) {
+                if ( str == "" )
+                        anonym.push_back( assoc );
+                else  if ( table.find( str ) == table.end() )
+                        throw AssocException( "no such member" );
+                else
+                        table[ str ] = std::pair<long int, Association *>(ordering.size() - 1, assoc);
+                return;
+        }
+        virtual Association *operator[]( int idx ) {
+                if ( ordering[idx] == "" ) {
+                        std::cerr << "Error, anonymous members not implemented yet" << std::endl;
+                        throw 0;
+                } else
+                        return table[ ordering[idx] ].second;
+        }
+        virtual Association *operator[]( std::string idx ) {
+                if ( table.find( idx ) == table.end() )
+                        throw AssocException("Member not found");
+                else
+                        return table[ idx ].second;
+        }
+        /*
+          virtual AssociationIterator *get_iterator() {
+          PointAssocIterator *it;
+          return it;
+          }
+        */
+        void accept( AssociationVisitor &v ) { v.visit( this ); }
+        virtual void display( std::ostream &os ) {
+                os << "Point association: " << std::endl;
+                for ( map_type::iterator i = table.begin(); i != table.end(); i++ ) {
+                        os << "Member [" << i->first << ", index = " << i->second.first << "]";
+                        if ( i->second.second != 0 )
+                                i->second.second->display( os );
+                        else
+                                std::cerr << "No recursive association" << std::endl;
+                        os << std::endl;
+                } // for
+        }
+        const int size() const { return ordering.size(); }
+  private:
+        PointAssociation &operator=(const PointAssociation &);
+        std::vector<std::string> ordering;
+        std::list< Association * > anonym;
+        std::map< std::string, std::pair<long int, Association *> > table;
 };
 class RangeAssociation : public Association {
 public:
   static const int UNDEF;
   RangeAssociation( int _hi= UNDEF ) : hi( _hi ) {
     std::cerr << "Constructed RangeAssociation with: [" << hi << "]" << std::endl;
+  }
   virtual ~RangeAssociation();
   virtual RangeAssociation *clone() {
     return 0; // XXX !!!!
+  }
   virtual Association *operator[]( int idx ) {
     return 0; // XXX !!!
+  }
   virtual Association *operator[]( std::string idx ) { assert(false); return 0; }
   /*
   virtual AssociationIterator *get_iterator() {
     RangeAssocIterator *it;
     return it;
+  }
   */
   virtual long int add_single( long int idx, Expression *newExpr) { return 0; }
   virtual long int add_single( std::string, Expression *) { return 0; }
   void accept( AssociationVisitor &v ) { v.visit( this ); }
   virtual void display( std::ostream &os ) {
     os << "Range association, with limit: " << std::endl;
+  }
 private:
   int hi;
   diet::diet_tree<int> tree;
   /*
   for ( diet_tree<int>::iterator i = tree.begin(); i != tree.end(); i++ )
     std::cout << "--(" << (*i).first << ", " << (*i).second << ")--" << std::endl;
   diet_tree<int> tree;
   tree.insert(100,200);
   */
+  public:
+        static const int UNDEF;
+        RangeAssociation( int _hi= UNDEF ) : hi( _hi ) {
+                std::cerr << "Constructed RangeAssociation with: [" << hi << "]" << std::endl;
+        }
+        virtual ~RangeAssociation();
+        virtual RangeAssociation *clone() {
+                return 0; // XXX !!!!
+        }
+        virtual Association *operator[]( int idx ) {
+                return 0; // XXX !!!
+        }
+        virtual Association *operator[]( std::string idx ) { assert(false); return 0; }
+        /*
+          virtual AssociationIterator *get_iterator() {
+          RangeAssocIterator *it;
+          return it;
+          }
+        */
+        virtual long int add_single( long int idx, Expression *newExpr) { return 0; }
+        virtual long int add_single( std::string, Expression *) { return 0; }
+        void accept( AssociationVisitor &v ) { v.visit( this ); }
+        virtual void display( std::ostream &os ) {
+                os << "Range association, with limit: " << std::endl;
+        }
+  private:
+        int hi;
+        diet::diet_tree<int> tree;
+        /*
+          for ( diet_tree<int>::iterator i = tree.begin(); i != tree.end(); i++ )
+          std::cout << "--(" << (*i).first << ", " << (*i).second << ")--" << std::endl;
+          diet_tree<int> tree;
+          tree.insert(100,200);
+        */
 };
 // ** builders
 class AssociationBuilder {
 public:
   /* AssociationBuilder( Declaration * ) */
   virtual ~AssociationBuilder() {}
   virtual Association *get_assoc() = 0;
   virtual Association *grab_assoc() = 0;
   virtual void set_assoc(   Association * ) = 0;
+  public:
+        /* AssociationBuilder( Declaration * ) */
+        virtual ~AssociationBuilder() {}
+        virtual Association *get_assoc() = 0;
+        virtual Association *grab_assoc() = 0;
+        virtual void set_assoc(   Association * ) = 0;
 };
 class AssociationFiller {
+public:
+  // AssociationFiller( Declaration * ) {}
+  virtual ~AssociationFiller() {}
+  virtual Association *get_assoc() = 0;
+  virtual void set_assoc( Association * ) = 0;
+};
+#endif //#define _ASSOCIATE_H_
+/*
+  Local Variables:
+  mode: c++
+  End:
+*/
+  public:
+        // AssociationFiller( Declaration * ) {}
+        virtual ~AssociationFiller() {}
+        virtual Association *get_assoc() = 0;
+        virtual void set_assoc( Association * ) = 0;
+};
+#endif // _ASSOCIATION_H_
 // Local Variables: //
 // tab-width: 4 //

translator/InitTweak/BasicInit.cc

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// BasicInit.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 16:30:43 2015
+// Update Count     : 1
+//
 #include <list>
 #include <cassert>
 …
 namespace InitTweak {
+  CompoundStmt* BasicInit::mutate(CompoundStmt *compoundStmt)
+  {
+    index.visit( compoundStmt );
+    std::list< Statement * > &kids = compoundStmt->get_kids();
+    std::list< Statement * > newKids;
+    for ( std::list< Statement * >::iterator i = kids.begin(); i!= kids.end(); i++ ) {
+      //BasicInit newMut(  );
+      (*i)->acceptMutator( *this );
+      newKids.push_back( *i );
+      if ( has_bindings() ) { //       if ( get_bindings() != 0  ) {
+        std::list< Statement *> newSt = get_statements();
+        //newSt.push_back( *i );
+        newKids.splice( newKids.end(), newSt );
+        bindings = 0;
+        stmts.clear();
+      }
+    }
+    compoundStmt->get_kids() = newKids;
+    return compoundStmt;
+  }
+  Statement * BasicInit::mutate(DeclStmt *declStmt) {
+    declStmt->accept( index );
+    ObjectDecl *odecl = 0;
+    if ( ( odecl = dynamic_cast<ObjectDecl *>(declStmt->get_decl()) ) != 0 ){
+      Initializer *init = odecl->get_init();
+      if ( init == 0 ) return declStmt;
+      if ( Classify::type( odecl->get_type() ) == Classify::COMPOUND_T )
+        if ( Classify::initializer(init) == Classify::SINGLE_I )
+          throw( 0 ); // mismatch of type and initializer
+        else {
+          NameInCollection *col = Classify::declaration( odecl, &index );
+          bindings = NameAssociation< Expression *, BreakInitializer >::createNameAssoc(col);
+          bindings->add_value( std::string(""), BreakInitializer(init) );
+          BasicInit::build_statements( bindings, odecl->get_name(), stmts );
+        }
+      else
+        if ( Classify::initializer(init) == Classify::COMPOUND_I )
+          throw( 0 ); // mismatch of type and initializer
+        else {
+          // Single inits
+          SingleInit *sinit = dynamic_cast< SingleInit * > ( init );
+          assert( sinit != 0);
+          std::list<Expression *> args;
+          args.push_back( new AddressExpr( new NameExpr( odecl->get_name() )) );    // have to get address of object
+          args.push_back( sinit->get_value() );
+          // replace declaration with initialization
+          stmts.push_back(new ExprStmt(std::list<Label>(), new UntypedExpr(new NameExpr("?=?"), args)));
+        }
+      delete init;
+      odecl->set_init( 0 );
+    } else {
+      // no declaration statement
+    }
+    return declStmt;
+  }
+  ExprStmt *assignFromDecl( DeclStmt *declStmt )
+  {
+    ObjectDecl *decl;
+    if ( (decl = dynamic_cast<ObjectDecl *>( declStmt->get_decl() )) != 0 )
+      {
+        SingleInit *init;
+        if ( (init = dynamic_cast<SingleInit *>(decl->get_init())) != 0 )
+          {
+          }
+      }
+    return 0;
+  }
+  bool isDeclStmtP(Statement *stmt)
+  {
+    return ( dynamic_cast< DeclStmt *>(stmt) != 0 );
+  }
+  BasicInit::Classify::TypeKind BasicInit::Classify::type( Type *toClassify ) {
+    if ( toClassify == 0 ) return NULL_T;
+    if ( dynamic_cast< StructInstType * >(toClassify) ||
+         dynamic_cast< UnionInstType * >(toClassify) ||
+         dynamic_cast< ArrayType * >(toClassify)         )
+      return COMPOUND_T;
+    else
+      return SINGLE_T;
+  }
+  BasicInit::Classify::InitKind BasicInit::Classify::initializer( Initializer *init) {
+    if ( init == 0 ) return NULL_I;
+    if ( dynamic_cast< ListInit * >(init) )
+      return COMPOUND_I;
+    if ( dynamic_cast< SingleInit * >(init) )
+      return SINGLE_I;
+    return NULL_I; // shouldn't be here anyways
+  }
+  NameInCollection *
+  BasicInit::Classify::declaration( ObjectDecl *objdecl, SymTab::Indexer *index ) {
+    assert ( index != 0 );
+    ReferenceToType *reftype;
+    if ( (reftype = dynamic_cast< StructInstType * >( objdecl->get_type() )) != 0 ){
+      StructDecl *strDecl = index->lookupStruct( reftype->get_name() );
+      if ( strDecl != 0 ) {
+        NameCollectionBuilder bld;
+        NameCollector nc( bld );
+        strDecl->accept( nc );
+        NameInCollection *col = nc.get_builder().get_collection();
+        nc.get_builder().set_collection( 0 );
+        return col;
+      } else
+        throw( SemanticError( std::string("No structure of name: ") + reftype->get_name() ) );
+    } else {
+      throw(SemanticError( reftype->get_name() + std::string("is not a reference to type") ));
+      return 0;
+    }
+  }
+  std::list< Statement * >
+  BasicInit::Classify::matchInit( NameInCollection *col,
+                                  ObjectDecl *toInitialize,
+                                  Initializer *init ) {
+    assert ( col != 0 );
+    std::list< Statement * > arranged(0); //( col->size() );
+    std::fill( arranged.begin(), arranged.end(), (Statement *)0 );
+    int current = 0;
+    if ( init == 0 )
+      // no initializer... shouldn't even bother... fix this.
+      return arranged;
+    {
+      ListInit *li = dynamic_cast< ListInit * >( init );
+      if ( li != 0 ) {
+        for ( std::list<Initializer *>::iterator i = li->begin_initializers();
+                                                         i != li->end_initializers();
+              i++) {
+          std::list<Expression *> d_orig = (*i)->get_designators();
+          NameInCollection *corrsp; // corresponding element to this initializer
+          if ( ! d_orig.empty() ) {
+            // 1) has designators
+            std::list<NameExpr *> des;
+            std::transform( d_orig.begin(), d_orig.end(),
+                            std::back_inserter( des ), cast_ptr<Expression, NameExpr > );
+            for ( std::list<NameExpr *>::iterator j = des.begin(); j != des.end(); j++ ) {
+              // check for existence of the element
+              if ( (corrsp = (*col)[ (*j)->get_name() ]) != 0 ) {
+                // current++;
+                SingleInit *sinit;
+                if ( (sinit = dynamic_cast< SingleInit * >( *i )) != 0 )
+                  arranged.push_back( constructAssgn( corrsp->get_name(), toInitialize, sinit ) );
+        CompoundStmt* BasicInit::mutate(CompoundStmt *compoundStmt) {
+                index.visit( compoundStmt );
+                std::list< Statement * > &kids = compoundStmt->get_kids();
+                std::list< Statement * > newKids;
+                for ( std::list< Statement * >::iterator i = kids.begin(); i!= kids.end(); i++ ) {
+                        //BasicInit newMut(  );
+                        (*i)->acceptMutator( *this );
+                        newKids.push_back( *i );
+                        if ( has_bindings() ) { //       if ( get_bindings() != 0  ) {
+                                std::list< Statement *> newSt = get_statements();
+                                //newSt.push_back( *i );
+                                newKids.splice( newKids.end(), newSt );
+                                bindings = 0;
+                                stmts.clear();
+                        } // if
+                } // for
+                compoundStmt->get_kids() = newKids;
+                return compoundStmt;
+        }
+        Statement * BasicInit::mutate(DeclStmt *declStmt) {
+                declStmt->accept( index );
+                ObjectDecl *odecl = 0;
+                if ( ( odecl = dynamic_cast<ObjectDecl *>(declStmt->get_decl()) ) != 0 ) {
+                        Initializer *init = odecl->get_init();
+                        if ( init == 0 ) return declStmt;
+                        if ( Classify::type( odecl->get_type() ) == Classify::COMPOUND_T )
+                                if ( Classify::initializer(init) == Classify::SINGLE_I )
+                                        throw( 0 ); // mismatch of type and initializer
+                                else {
+                                        NameInCollection *col = Classify::declaration( odecl, &index );
+                                        bindings = NameAssociation< Expression *, BreakInitializer >::createNameAssoc(col);
+                                        bindings->add_value( std::string(""), BreakInitializer(init) );
+                                        BasicInit::build_statements( bindings, odecl->get_name(), stmts );
+                                } // if
+                        else
+                                if ( Classify::initializer(init) == Classify::COMPOUND_I )
+                                        throw( 0 ); // mismatch of type and initializer
+                                else {
+                                        // Single inits
+                                        SingleInit *sinit = dynamic_cast< SingleInit * > ( init );
+                                        assert( sinit != 0);
+                                        std::list<Expression *> args;
+                                        args.push_back( new AddressExpr( new NameExpr( odecl->get_name() )) );    // have to get address of object
+                                        args.push_back( sinit->get_value() );
+                                        // replace declaration with initialization
+                                        stmts.push_back(new ExprStmt(std::list<Label>(), new UntypedExpr(new NameExpr("?=?"), args)));
+                                } // if
+                        delete init;
+                        odecl->set_init( 0 );
+                } else {
+                        // no declaration statement
+                } // if
+                return declStmt;
+        }
+        ExprStmt *assignFromDecl( DeclStmt *declStmt ) {
+                ObjectDecl *decl;
+                if ( (decl = dynamic_cast<ObjectDecl *>( declStmt->get_decl() )) != 0 ) {
+                        SingleInit *init;
+                        if ( (init = dynamic_cast<SingleInit *>(decl->get_init())) != 0 ) {
+                        } // if
+                } // if
+                return 0;
+        }
+        bool isDeclStmtP(Statement *stmt) {
+                return ( dynamic_cast< DeclStmt *>(stmt) != 0 );
+        }
+        BasicInit::Classify::TypeKind BasicInit::Classify::type( Type *toClassify ) {
+                if ( toClassify == 0 ) return NULL_T;
+                if ( dynamic_cast< StructInstType * >(toClassify) ||
+                         dynamic_cast< UnionInstType * >(toClassify) ||
+                         dynamic_cast< ArrayType * >(toClassify)         )
+                        return COMPOUND_T;
                 else
+                  ; // recursive call to matchInit
+              } else
+                // error, member doesn't exist
+                return arranged; // throw( 0 ); // XXX
+            }
+          } else {
+            // 2) doesn't have designators
+            if ( (corrsp = (*col)[ current++ ]) != 0 ) {
+              SingleInit *sinit;
+              if ( (sinit = dynamic_cast< SingleInit * >( *i )) != 0 )
+                arranged.push_back( constructAssgn( corrsp->get_name(), toInitialize, sinit ) );
+              else
+                ; // recursive call to matchInit
+            } else {
+              // Shouldn't be here... probably too many elements in initializer?
+            }
+          }
+        }
+      }
+    }
+    return arranged;
+  }
+  Statement *BasicInit::Classify::constructAssgn( std::string membName, ObjectDecl *toInit, SingleInit *sinit ) {
+    std::list< Expression * > args;
+    args.push_back(new AddressExpr( new UntypedMemberExpr( membName, new NameExpr(toInit->get_name()) )));
+    args.push_back( sinit->get_value() );
+    Statement *ret = new ExprStmt(std::list<Label>(), new UntypedExpr(new NameExpr("?=?"), args));
+    return ret;
+  }
+  void BasicInit::build_statements( NameAssociation< Expression *, BreakInitializer > *assoc,
+                                    std::string aggName, std::list< Statement *> &stmts ) {
+    assert( assoc != 0 );
+    static std::list< std::string > prefix;
+    NameInCollection *col = assoc->get_collection();
+    if ( col->isComposite() ) {
+      VariousNames *vc = dynamic_cast< VariousNames * >( col );
+      for ( VariousNames::key_iterator it = vc->keys_begin(); it != vc->keys_end(); it++ ) {
+        prefix.push_back( *it );
+        if ( (*assoc)[ *it ] != 0 )
+          build_statements( (*assoc)[ *it ], aggName, stmts );
+        prefix.pop_back();
+      }
+    } else {
+      SingleNameAssoc< Expression *, BreakInitializer > *sa = \
+        dynamic_cast< SingleNameAssoc< Expression *, BreakInitializer > * >( assoc );
+      assert( sa != 0 );
+      Expression * rh = sa->get_data();
+      if (rh != 0) {
+        // construct assignment statement list
+        Expression *lh = new NameExpr ( aggName );
+        for ( std::list< std::string >::iterator i = prefix.begin(); i != prefix.end(); i++ )
+          lh = new UntypedMemberExpr( *i, lh );
+        std::list< Expression * > args;
+        args.push_back( new AddressExpr(lh) );  args.push_back( rh );
+        stmts.push_back( new ExprStmt(std::list<Label>(), new UntypedExpr(new NameExpr("?=?"), args)) );
+      }
+    }
+    return;
+  }
+                        return SINGLE_T;
+        }
+        BasicInit::Classify::InitKind BasicInit::Classify::initializer( Initializer *init) {
+                if ( init == 0 ) return NULL_I;
+                if ( dynamic_cast< ListInit * >(init) )
+                        return COMPOUND_I;
+                if ( dynamic_cast< SingleInit * >(init) )
+                        return SINGLE_I;
+                return NULL_I; // shouldn't be here anyways
+        }
+        NameInCollection * BasicInit::Classify::declaration( ObjectDecl *objdecl, SymTab::Indexer *index ) {
+                assert ( index != 0 );
+                ReferenceToType *reftype;
+                if ( (reftype = dynamic_cast< StructInstType * >( objdecl->get_type() )) != 0 ) {
+                        StructDecl *strDecl = index->lookupStruct( reftype->get_name() );
+                        if ( strDecl != 0 ) {
+                                NameCollectionBuilder bld;
+                                NameCollector nc( bld );
+                                strDecl->accept( nc );
+                                NameInCollection *col = nc.get_builder().get_collection();
+                                nc.get_builder().set_collection( 0 );
+                                return col;
+                        } else
+                                throw( SemanticError( std::string("No structure of name: ") + reftype->get_name() ) );
+                } else {
+                        throw(SemanticError( reftype->get_name() + std::string("is not a reference to type") ));
+                        return 0;
+                } // if
+        }
+        std::list< Statement * >
+        BasicInit::Classify::matchInit( NameInCollection *col, ObjectDecl *toInitialize, Initializer *init ) {
+                assert ( col != 0 );
+                std::list< Statement * > arranged(0); //( col->size() );
+                std::fill( arranged.begin(), arranged.end(), (Statement *)0 );
+                int current = 0;
+                if ( init == 0 )
+                        // no initializer... shouldn't even bother... fix this.
+                        return arranged;
+                ListInit *li = dynamic_cast< ListInit * >( init );
+                if ( li != 0 ) {
+                        for ( std::list<Initializer *>::iterator i = li->begin_initializers();
+                                  i != li->end_initializers();
+                                  i++) {
+                                std::list<Expression *> d_orig = (*i)->get_designators();
+                                NameInCollection *corrsp; // corresponding element to this initializer
+                                if ( ! d_orig.empty() ) {
+                                        // 1) has designators
+                                        std::list<NameExpr *> des;
+                                        std::transform( d_orig.begin(), d_orig.end(),
+                                                                        std::back_inserter( des ), cast_ptr<Expression, NameExpr > );
+                                        for ( std::list<NameExpr *>::iterator j = des.begin(); j != des.end(); j++ ) {
+                                                // check for existence of the element
+                                                if ( (corrsp = (*col)[ (*j)->get_name() ]) != 0 ) {
+                                                        // current++;
+                                                        SingleInit *sinit;
+                                                        if ( (sinit = dynamic_cast< SingleInit * >( *i )) != 0 )
+                                                                arranged.push_back( constructAssgn( corrsp->get_name(), toInitialize, sinit ) );
+                                                        else
+                                                                ; // recursive call to matchInit
+                                                } else
+                                                        // error, member doesn't exist
+                                                        return arranged; // throw( 0 ); // XXX
+                                        }
+                                } else {
+                                        // 2) doesn't have designators
+                                        if ( (corrsp = (*col)[ current++ ]) != 0 ) {
+                                                SingleInit *sinit;
+                                                if ( (sinit = dynamic_cast< SingleInit * >( *i )) != 0 )
+                                                        arranged.push_back( constructAssgn( corrsp->get_name(), toInitialize, sinit ) );
+                                                else
+                                                        ; // recursive call to matchInit
+                                        } else {
+                                                // Shouldn't be here... probably too many elements in initializer?
+                                        } // if
+                                } // if
+                        } // for
+                } // if
+                return arranged;
+        }
+        Statement *BasicInit::Classify::constructAssgn( std::string membName, ObjectDecl *toInit, SingleInit *sinit ) {
+                std::list< Expression * > args;
+                args.push_back(new AddressExpr( new UntypedMemberExpr( membName, new NameExpr(toInit->get_name()) )));
+                args.push_back( sinit->get_value() );
+                Statement *ret = new ExprStmt(std::list<Label>(), new UntypedExpr(new NameExpr("?=?"), args));
+                return ret;
+        }
+        void BasicInit::build_statements( NameAssociation< Expression *, BreakInitializer > *assoc,  std::string aggName, std::list< Statement *> &stmts ) {
+                assert( assoc != 0 );
+                static std::list< std::string > prefix;
+                NameInCollection *col = assoc->get_collection();
+                if ( col->isComposite() ) {
+                        VariousNames *vc = dynamic_cast< VariousNames * >( col );
+                        for ( VariousNames::key_iterator it = vc->keys_begin(); it != vc->keys_end(); it++ ) {
+                                prefix.push_back( *it );
+                                if ( (*assoc)[ *it ] != 0 )
+                                        build_statements( (*assoc)[ *it ], aggName, stmts );
+                                prefix.pop_back();
+                        }
+                } else {
+                        SingleNameAssoc< Expression *, BreakInitializer > *sa = \
+                                dynamic_cast< SingleNameAssoc< Expression *, BreakInitializer > * >( assoc );
+                        assert( sa != 0 );
+                        Expression * rh = sa->get_data();
+                        if (rh != 0) {
+                                // construct assignment statement list
+                                Expression *lh = new NameExpr ( aggName );
+                                for ( std::list< std::string >::iterator i = prefix.begin(); i != prefix.end(); i++ )
+                                        lh = new UntypedMemberExpr( *i, lh );
+                                std::list< Expression * > args;
+                                args.push_back( new AddressExpr(lh) );  args.push_back( rh );
+                                stmts.push_back( new ExprStmt(std::list<Label>(), new UntypedExpr(new NameExpr("?=?"), args)) );
+                        } // if
+                } // if
+                return;
+        }
 } // namespace InitTweak

translator/InitTweak/BasicInit.h

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// BasicInit.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 16:32:21 2015
+// Update Count     : 3
+//
 #ifndef _BASINIT_H_
 #define _BASINIT_H_
 …
 namespace InitTweak {
+  bool isDeclStmtP(Statement *stmt);
+  class BreakInitializer;
+  class BreakDesignator;
+  class BasicInit: public Mutator
+    {
+    public:
+      BasicInit() : bindings( 0 ) {}
+      BasicInit( SymTab::Indexer &_index ) : bindings( 0 ), index( _index ) {}
+      BasicInit( const BasicInit &other ) {
+        bindings = other.get_bindings();
+        index = other.index;
+      }
+      ~BasicInit() { /* delete bindings; bindings = 0; */ }
+      NameAssociation< Expression *, BreakInitializer > *get_bindings() const { return bindings; }
+      void set_bindings( NameAssociation< Expression *, BreakInitializer > *newValue ) {
+        bindings = newValue;
+      }
+      bool has_bindings() {
+        return ( get_bindings() != 0 || ! stmts.empty() );
+      }
+      virtual ObjectDecl     *mutate( ObjectDecl *objectDecl )
+      { index.visit( objectDecl ); return objectDecl; }
+      virtual TypeDecl       *mutate( TypeDecl *typeDecl )
+      { index.visit( typeDecl ); return typeDecl; }
+      virtual TypedefDecl    *mutate( TypedefDecl *typeDecl )
+      { index.visit( typeDecl ); return typeDecl; }
+      virtual StructDecl     *mutate( StructDecl *aggregateDecl )
+      { index.visit( aggregateDecl ); return aggregateDecl; }
+      virtual UnionDecl      *mutate( UnionDecl *aggregateDecl )
+      { index.visit( aggregateDecl ); return aggregateDecl; }
+      virtual EnumDecl       *mutate( EnumDecl *aggregateDecl )
+      { index.visit( aggregateDecl ); return aggregateDecl; }
+      virtual Type           *mutate( StructInstType *aggrInst )
+      { index.visit( aggrInst ); return aggrInst; }
+      virtual Type           *mutate( UnionInstType *aggrInst )
+      { index.visit( aggrInst ); return aggrInst; }
+      virtual CompoundStmt   *mutate(CompoundStmt *compoundStmt);
+      virtual Statement *mutate(DeclStmt *declStmt);
+      std::list< Statement *> get_statements() const { return stmts;  }
+      static void build_statements( NameAssociation< Expression *, BreakInitializer > *assoc,
+                                    std::string aggName, std::list< Statement *> &stmts );
+    private:
+      NameAssociation< Expression *, BreakInitializer > *bindings;
+      Statement *assignFromDecl( DeclStmt *declStmt );
+      SymTab::Indexer index;
+      std::list< Statement *> stmts;
+      class Classify {
+      public:
+        enum TypeKind { NULL_T, SINGLE_T, COMPOUND_T };
+        enum InitKind { NULL_I, SINGLE_I, COMPOUND_I };
+        static TypeKind type( Type * );
+        static InitKind initializer( Initializer *);
+        static NameInCollection *declaration( ObjectDecl *objdecl, SymTab::Indexer *index );
+        static std::list< Statement * >
+           matchInit( NameInCollection *, ObjectDecl *, Initializer * );
+        static Statement *constructAssgn( std::string membname, ObjectDecl *toInit, SingleInit *sinit );
+        // static std::list< Statement * > constructListAssgn( NameAssociation<Expression *, BreakDesignator > assoc );
+      };
+  };
+  class BreakInitializer {
+    enum InitKind { EMPTY, SINGLE, COMPOUND };
+    class BreakDesignator;
+    typedef BreakDesignator NameSplitter;
+  public:
+    typedef std::list<Initializer *>::iterator element_iterator;
+    typedef std::list< NameSplitter >::iterator name_iterator;
+    BreakInitializer ( Initializer *_init ) : kind( EMPTY ), sinit(0), cinit(0) {
+      std::list<Expression *> temp;
+      if ( ( sinit=dynamic_cast< SingleInit * >(_init) ) != 0 ) {
+        kind = SINGLE;
+        temp = sinit->get_designators();
+      } else if ( ( cinit=dynamic_cast< ListInit * >(_init) ) != 0 ) {
+        kind = COMPOUND;
+        temp = cinit->get_designators();
+      }
+      std::transform( temp.begin(), temp.end(), std::back_inserter( designators ),
+                      ctor_noptr<NameSplitter, Expression *> );
+    }
+    //BreakInitializer( const BreakInitializer &other ) { this.col = other.col; }
+    ~BreakInitializer () {}
+    BreakInitializer set_name( NameSplitter &name ) {
+      designators.clear();
+      designators.push_back( name );
+      return *this;
+    }
+    element_iterator element_begin() {
+      assert( cinit != 0 );
+      return cinit->begin_initializers();
+    }
+    element_iterator element_end() {
+      assert( cinit != 0 );
+      return cinit->end_initializers();
+    }
+    name_iterator names_begin() { return designators.begin(); }
+    name_iterator names_end() { return designators.end(); }
+    int names_size() const { return designators.size(); }
+    bool has_index() const { return ! designators.empty(); }
+    bool is_single() const { return kind == SINGLE; }
+    bool is_composite() const { return kind == COMPOUND;  }
+    Expression *get_value() {
+      switch ( kind ) {
+      case EMPTY:
+        return 0;
+        break;
+      case SINGLE:
+        return sinit->get_value();
+        break;
+      case COMPOUND:
+        assert(false);
+        break;
+      default:
+        assert(false);
+      }
+      return 0;
+    }
+    // attributes
+  private:
+    InitKind kind;
+    SingleInit *sinit;
+    ListInit *cinit;
+    std::list< BreakDesignator > designators;
+    // helper classes
+  public:
+    class BreakDesignator {
+    public:
+      BreakDesignator( Expression *exp ) {
+        Expression *prfx = exp;
+        UntypedMemberExpr *me = 0;
+        do {
+          if ( (me=dynamic_cast< UntypedMemberExpr * >( prfx )) == 0 ) break;
+          blown_struct.push_front( me->get_member() );
+          prfx = me->get_aggregate();
+        } while ( prfx != 0 );
+        NameExpr *ne;
+        if ( (ne=dynamic_cast< NameExpr * >( prfx )) != 0 )
+          blown_struct.push_front( ne->get_name() );
+      }
+      BreakDesignator( std::string name ) {
+        blown_struct.push_front( name );
+      }
+      bool is_flat() const { return blown_struct.size() == 1; }
+      bool is_nested() const { return blown_struct.size() > 1; }
+      std::string get_name() { return blown_struct.front(); }
+      BreakDesignator &name_remainder() {
+        blown_struct.pop_front();
+        return *this;
+      }
+    private:
+      std::list< std::string > blown_struct;
+    };
+  };
+        bool isDeclStmtP(Statement *stmt);
+        class BreakInitializer;
+        class BreakDesignator;
+        class BasicInit: public Mutator {
+          public:
+                BasicInit() : bindings( 0 ) {}
+                BasicInit( SymTab::Indexer &_index ) : bindings( 0 ), index( _index ) {}
+                BasicInit( const BasicInit &other ) {
+                        bindings = other.get_bindings();
+                        index = other.index;
+                }
+                ~BasicInit() { /* delete bindings; bindings = 0; */ }
+                NameAssociation< Expression *, BreakInitializer > *get_bindings() const { return bindings; }
+                void set_bindings( NameAssociation< Expression *, BreakInitializer > *newValue ) {
+                        bindings = newValue;
+                }
+                bool has_bindings() {
+                        return ( get_bindings() != 0 || ! stmts.empty() );
+                }
+                virtual ObjectDecl     *mutate( ObjectDecl *objectDecl )
+                        { index.visit( objectDecl ); return objectDecl; }
+                virtual TypeDecl       *mutate( TypeDecl *typeDecl )
+                        { index.visit( typeDecl ); return typeDecl; }
+                virtual TypedefDecl    *mutate( TypedefDecl *typeDecl )
+                        { index.visit( typeDecl ); return typeDecl; }
+                virtual StructDecl     *mutate( StructDecl *aggregateDecl )
+                        { index.visit( aggregateDecl ); return aggregateDecl; }
+                virtual UnionDecl      *mutate( UnionDecl *aggregateDecl )
+                        { index.visit( aggregateDecl ); return aggregateDecl; }
+                virtual EnumDecl       *mutate( EnumDecl *aggregateDecl )
+                        { index.visit( aggregateDecl ); return aggregateDecl; }
+                virtual Type           *mutate( StructInstType *aggrInst )
+                        { index.visit( aggrInst ); return aggrInst; }
+                virtual Type           *mutate( UnionInstType *aggrInst )
+                        { index.visit( aggrInst ); return aggrInst; }
+                virtual CompoundStmt   *mutate(CompoundStmt *compoundStmt);
+                virtual Statement *mutate(DeclStmt *declStmt);
+                std::list< Statement *> get_statements() const { return stmts;  }
+                static void build_statements( NameAssociation< Expression *, BreakInitializer > *assoc, std::string aggName, std::list< Statement *> &stmts );
+          private:
+                NameAssociation< Expression *, BreakInitializer > *bindings;
+                Statement *assignFromDecl( DeclStmt *declStmt );
+                SymTab::Indexer index;
+                std::list< Statement *> stmts;
+                class Classify {
+                  public:
+                        enum TypeKind { NULL_T, SINGLE_T, COMPOUND_T };
+                        enum InitKind { NULL_I, SINGLE_I, COMPOUND_I };
+                        static TypeKind type( Type * );
+                        static InitKind initializer( Initializer *);
+                        static NameInCollection *declaration( ObjectDecl *objdecl, SymTab::Indexer *index );
+                        static std::list< Statement * >
+                        matchInit( NameInCollection *, ObjectDecl *, Initializer * );
+                        static Statement *constructAssgn( std::string membname, ObjectDecl *toInit, SingleInit *sinit );
+                        // static std::list< Statement * > constructListAssgn( NameAssociation<Expression *, BreakDesignator > assoc );
+                };
+        };
+        class BreakInitializer {
+                enum InitKind { EMPTY, SINGLE, COMPOUND };
+                class BreakDesignator;
+                typedef BreakDesignator NameSplitter;
+          public:
+                typedef std::list<Initializer *>::iterator element_iterator;
+                typedef std::list< NameSplitter >::iterator name_iterator;
+                BreakInitializer ( Initializer *_init ) : kind( EMPTY ), sinit(0), cinit(0) {
+                        std::list<Expression *> temp;
+                        if ( ( sinit=dynamic_cast< SingleInit * >(_init) ) != 0 ) {
+                                kind = SINGLE;
+                                temp = sinit->get_designators();
+                        } else if ( ( cinit=dynamic_cast< ListInit * >(_init) ) != 0 ) {
+                                kind = COMPOUND;
+                                temp = cinit->get_designators();
+                        } // if
+                        std::transform( temp.begin(), temp.end(), std::back_inserter( designators ), ctor_noptr<NameSplitter, Expression *> );
+                }
+                //BreakInitializer( const BreakInitializer &other ) { this.col = other.col; }
+                ~BreakInitializer () {}
+                BreakInitializer set_name( NameSplitter &name ) {
+                        designators.clear();
+                        designators.push_back( name );
+                        return *this;
+                }
+                element_iterator element_begin() {
+                        assert( cinit != 0 );
+                        return cinit->begin_initializers();
+                }
+                element_iterator element_end() {
+                        assert( cinit != 0 );
+                        return cinit->end_initializers();
+                }
+                name_iterator names_begin() { return designators.begin(); }
+                name_iterator names_end() { return designators.end(); }
+                int names_size() const { return designators.size(); }
+                bool has_index() const { return ! designators.empty(); }
+                bool is_single() const { return kind == SINGLE; }
+                bool is_composite() const { return kind == COMPOUND;  }
+                Expression *get_value() {
+                        switch ( kind ) {
+                          case EMPTY:
+                                return 0;
+                                break;
+                          case SINGLE:
+                                return sinit->get_value();
+                                break;
+                          case COMPOUND:
+                                assert(false);
+                                break;
+                          default:
+                                assert(false);
+                        } // switch
+                        return 0;
+                }
+                // attributes
+          private:
+                InitKind kind;
+                SingleInit *sinit;
+                ListInit *cinit;
+                std::list< BreakDesignator > designators;
+                // helper classes
+          public:
+                class BreakDesignator {
+                  public:
+                        BreakDesignator( Expression *exp ) {
+                                Expression *prfx = exp;
+                                UntypedMemberExpr *me = 0;
+                                do {
+                                        if ( (me=dynamic_cast< UntypedMemberExpr * >( prfx )) == 0 ) break;
+                                        blown_struct.push_front( me->get_member() );
+                                        prfx = me->get_aggregate();
+                                } while ( prfx != 0 );
+                                NameExpr *ne;
+                                if ( (ne=dynamic_cast< NameExpr * >( prfx )) != 0 )
+                                        blown_struct.push_front( ne->get_name() );
+                        }
+                        BreakDesignator( std::string name ) {
+                                blown_struct.push_front( name );
+                        }
+                        bool is_flat() const { return blown_struct.size() == 1; }
+                        bool is_nested() const { return blown_struct.size() > 1; }
+                        std::string get_name() { return blown_struct.front(); }
+                        BreakDesignator &name_remainder() {
+                                blown_struct.pop_front();
+                                return *this;
+                        }
+                  private:
+                        std::list< std::string > blown_struct;
+                };
+        };
 } // namespace InitTweak
+#endif // #ifndef _BASINIT_H_
+/*
+  Local Variables:
+  mode: c++
+  End:
+*/
+#endif // _BASINIT_H_
 // Local Variables: //
 // tab-width: 4 //

translator/InitTweak/DeclarationHoister.cc

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// DeclarationHoister.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 16:33:20 2015
+// Update Count     : 2
 //
 #include <list>
 #include <cassert>
 …
 #include "DeclarationHoister.h"
+namespace InitTweak {
+        CompoundStmt* DeclarationHoister::mutate( CompoundStmt *compoundStmt ) {
+                typedef std::list<Statement *>::iterator stmt_it;
+                // 1. collect Declaration Statements  in this scope
+                std::list<Statement *> &kids = compoundStmt->get_kids();
+                std::list<Statement *>::iterator result = kids.begin();
+                std::list< stmt_it > decls;
+namespace InitTweak {
+                while ( result !=  kids.end() ) {
+                        result = std::find_if (result, kids.end(), cast_ptr< Statement, DeclStmt > );
+  CompoundStmt* DeclarationHoister::mutate(CompoundStmt *compoundStmt) {
+    typedef std::list<Statement *>::iterator stmt_it;
+    // 1. collect Declaration Statements  in this scope
+    std::list<Statement *> &kids = compoundStmt->get_kids();
+    std::list<Statement *>::iterator result = kids.begin();
+    std::list< stmt_it > decls;
+                        if ( result != kids.end() ) {
+                                decls.push_back( result );
+                                std::advance( result, 1 );
+                        } // if
+                } // while
+    while ( result !=  kids.end() ) {
+      result = std::find_if (result, kids.end(), cast_ptr< Statement, DeclStmt > );
+                for ( std::list< stmt_it >::reverse_iterator i = decls.rbegin(); i!= decls.rend(); i++ ) {
+                        kids.push_front( **i );
+                        kids.erase( *i );
+                } // for
+      if ( result != kids.end() ) {
+        decls.push_back( result );
+        std::advance( result, 1 );
+      }
+    }
+    for ( std::list< stmt_it >::reverse_iterator i = decls.rbegin(); i!= decls.rend(); i++ ){
+      kids.push_front( **i );
+      kids.erase( *i );
+    }
+    return compoundStmt;
+  }
+                return compoundStmt;
+        }
 } // namespace InitTweak
 // Local Variables: //

translator/InitTweak/DeclarationHoister.h

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// DeclarationHoister.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 16:33:48 2015
+// Update Count     : 2
 //
 #include "SynTree/Visitor.h"
 #include "SymTab/Indexer.h"
 namespace InitTweak {
+        bool isDeclStmtP(Statement *stmt);
+  bool isDeclStmtP(Statement *stmt);
+  class DeclarationHoister: public Mutator {
+  public:
+    virtual CompoundStmt   *mutate(CompoundStmt *compoundStmt);
+  };
+        class DeclarationHoister: public Mutator {
+          public:
+                virtual CompoundStmt   *mutate(CompoundStmt *compoundStmt);
+        };
 }  // namespace InitTweak
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/InitTweak/InitExpander.cc

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// InitExpander.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 16:34:12 2015
+// Update Count     : 1
 //
 #include <list>
 #include <stack>
 #include <cassert>
 #include <algorithm>
 #include "utility.h"
 …
 namespace InitTweak {
+        InitExpander::InitExpander() {}
   InitExpander::InitExpander() {}
+        InitExpander::~InitExpander() {}
+  InitExpander::~InitExpander() {}
+        ObjectDecl *InitExpander::mutate( ObjectDecl *objectDecl ) {
+                index.visit( objectDecl );
+  ObjectDecl *InitExpander::mutate( ObjectDecl *objectDecl ) {
+    index.visit( objectDecl );
+                if ( objectDecl->get_init() == 0 ) return objectDecl;
+    if ( objectDecl->get_init() == 0 ) return objectDecl;
+                InitModelBuilder builder( objectDecl );
+                builder.get_assoc()->display( std::cerr ); // xxx
+                InitModelFiller filler( builder.get_assoc(), objectDecl->get_init(), true );
+                // filler.get_assoc()->display( std::cerr ); // xxx
+                InitUnspooler exp;
+                filler.get_assoc()->accept( exp );
+                objectDecl->set_init( exp.grab_initializer() );
+                objectDecl->get_init()->print( std::cerr );
+    InitModelBuilder builder( objectDecl );
+    builder.get_assoc()->display( std::cerr ); // xxx
+    InitModelFiller filler( builder.get_assoc(), objectDecl->get_init(), true );
+    // filler.get_assoc()->display( std::cerr ); // xxx
+    InitUnspooler exp;
+    filler.get_assoc()->accept( exp );
+    objectDecl->set_init( exp.grab_initializer() );
+    objectDecl->get_init()->print( std::cerr );
+    return objectDecl;
+  }
+                return objectDecl;
+        }
 } // namespace InitTweak

translator/InitTweak/InitExpander.h

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// InitExpander.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 16:35:33 2015
+// Update Count     : 2
 //
 #ifndef _INIT_EXPANDER_H_
 #define _INIT_EXPANDER_H_
 …
 namespace InitTweak {
+        class InitExpander : public Mutator {
+                typedef Mutator Parent;
+          public:
+                InitExpander();
+                ~InitExpander();
+  class InitExpander : public Mutator
+  {
+    typedef Mutator Parent;
+                virtual ObjectDecl *mutate( ObjectDecl * );
+  public:
+    InitExpander();
+    ~InitExpander();
+                // indexer runs
+                virtual FunctionDecl   *mutate( FunctionDecl *functionDecl ) {
+                        functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
+                        mutateAll( functionDecl->get_oldDecls(), *this );
+                        functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+    virtual ObjectDecl *mutate( ObjectDecl * );
+                        index.visit( functionDecl );
+                        return functionDecl;
+                }
+    // indexer runs
+    virtual FunctionDecl   *mutate( FunctionDecl *functionDecl )
+    {
+      functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
+      mutateAll( functionDecl->get_oldDecls(), *this );
+      functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+                virtual TypeDecl *mutate( TypeDecl *typeDecl )
+                        { index.visit( typeDecl ); return typeDecl; }
+                virtual TypedefDecl *mutate( TypedefDecl *typeDecl )
+                        { index.visit( typeDecl ); return typeDecl; }
+                virtual StructDecl *mutate( StructDecl *aggregateDecl )
+                        { index.visit( aggregateDecl ); return aggregateDecl; }
+                virtual UnionDecl *mutate( UnionDecl *aggregateDecl )
+                        { index.visit( aggregateDecl ); return aggregateDecl; }
+                virtual EnumDecl *mutate( EnumDecl *aggregateDecl )
+                        { index.visit( aggregateDecl ); return aggregateDecl; }
+      index.visit( functionDecl );
+      return functionDecl;
+    }
+    virtual TypeDecl       *mutate( TypeDecl *typeDecl )
+    { index.visit( typeDecl ); return typeDecl; }
+    virtual TypedefDecl    *mutate( TypedefDecl *typeDecl )
+    { index.visit( typeDecl ); return typeDecl; }
+    virtual StructDecl     *mutate( StructDecl *aggregateDecl )
+    { index.visit( aggregateDecl ); return aggregateDecl; }
+    virtual UnionDecl      *mutate( UnionDecl *aggregateDecl )
+    { index.visit( aggregateDecl ); return aggregateDecl; }
+    virtual EnumDecl       *mutate( EnumDecl *aggregateDecl )
+    { index.visit( aggregateDecl ); return aggregateDecl; }
+    virtual Type           *mutate( StructInstType *aggrInst )
+    { index.visit( aggrInst ); return aggrInst; }
+    virtual Type           *mutate( UnionInstType *aggrInst )
+    { index.visit( aggrInst ); return aggrInst; }
+  private:
+    SymTab::Indexer index;
+  };  // class InitExpander
+                virtual Type *mutate( StructInstType *aggrInst )
+                        { index.visit( aggrInst ); return aggrInst; }
+                virtual Type *mutate( UnionInstType *aggrInst )
+                        { index.visit( aggrInst ); return aggrInst; }
+          private:
+                SymTab::Indexer index;
+        };  // class InitExpander
 } // namespace InitTweak
+#endif // _INIT_EXPANDER_H_
-#endif // #ifndef _INIT_EXPANDER_H_
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/InitTweak/InitModel.cc

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// InitModel.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 16:37:08 2015
+// Update Count     : 1
+//
 #include "SynTree/Constant.h"
 #include "InitModel.h"
 …
 namespace InitTweak {
+  InitModelBuilder::InitModelBuilder( Declaration *_decl )
+    : taken( false ), decl( 0 ), building(0) {
+    ObjectDecl *_odecl = dynamic_cast< ObjectDecl * >( _decl );
+    assert( _odecl != 0 );
+    Type *objectType = _odecl->get_type();
+    /* this to be replaced by dynamic dispatch */
+    if ( dynamic_cast< BasicType * >(objectType) != 0 ) {
+      if ( building == 0 ) building = new SingleName;
+    } else if ( ReferenceToType *rt = dynamic_cast< ReferenceToType * >(objectType) ) {
+      rt->accept( *this );
+    } else if ( ArrayType *at = dynamic_cast< ArrayType * >(objectType) ) {
+      at->accept( *this );
+    } else // if (tuples)
+      std::cerr << "Got something else" << std::endl;
+    if ( decl != 0 ) init();
+  }
+  InitModelBuilder::~InitModelBuilder() { if ( ! taken ) { delete building; building = 0; } }
+  void InitModelBuilder::init() {
+    assert( decl != 0 );
+    decl->accept( *this );
+  }
+  // Visitor interface
+  void InitModelBuilder::visit( ArrayType *at ) {
+    if ( building == 0 ) building = new RangeAssociation(interpretDimension( at->get_dimension() ));
+    decl = 0;
+    return;
+  }
+  void InitModelBuilder::visit( StructInstType *st ) {
+    if ( building == 0 ) building = new PointAssociation;
+    decl = st->get_baseStruct();
+    return;
+  }
+  void InitModelBuilder::visit( UnionInstType *ut ) {
+    decl = ut->get_baseUnion();
+    return;
+  }
+  void InitModelBuilder::visit( EnumInstType * ) {}
+  void InitModelBuilder::visit( StructDecl *aggregateDecl) {
+    PointAssociation *pa = dynamic_cast< PointAssociation * >( building );
+    assert( pa != 0 );
+    std::list< Declaration * > mem = aggregateDecl->get_members();
+    for ( std::list<Declaration *>::iterator i = mem.begin(); i != mem.end(); i++ ) {
+      pa->add_member( (*i)->get_name() );
+      InitModelBuilder rec(*i);
+      pa->set_member( (*i)->get_name(), rec.grab_assoc() );
+    }
+    return;
+  }
+  void InitModelBuilder::visit( UnionDecl *) {}
+  void InitModelBuilder::visit( EnumDecl *) {}
+  // InitModelBuilder::ConstantFolder
+  void InitModelBuilder::ConstantFolder::visit( ConstantExpr *cnst ) {
+    Constant *c = cnst->get_constant();
+    assert (c != 0);
+    if ( BasicType *bt = dynamic_cast<BasicType *>( c->get_type() ) ) {
+      if ( bt->isInteger() ) {
+        // need more intelligence here, not necessarily base 10
+        value = std::strtol( c->get_value().c_str(), NULL, 10 );
+        return;
+      } else
+        std::cerr << "Basic type but not integer" << std::endl;
+    }
+    throw 0;
+  }
+  // InitModelFiller
+  InitModelFiller::InitModelFiller( Association *_model, Initializer *_init, bool _topLevel )
+      : model( _model ), orgInit( _init ), topLevel( _topLevel ), next( 0 ) {
+    //next = model.begin();
+    if ( orgInit != 0 ) init();
+  }
+  void InitModelFiller::init() {
+    assert( model != 0 ); // change it into a reference
+    assert( orgInit != 0 );
+    orgInit->accept( *this );
+  }
+  void InitModelFiller::visit( SingleInit *singleInit ) {
+    std::list< Expression *> &des = singleInit->get_designators();
+    if ( topLevel ) {
+      assert ( des.empty() );
+      assert ( dynamic_cast< SingleName * >(model) != 0 );
+      try {
+        model->add_single( next++, singleInit->get_value() );
+      } catch (...) {
+        std::cerr << "Illegal initialization" << std::endl;
+      }
+      return;
+    }
+    if ( des.empty() ) {
+      assert( model != 0 );
+      try {
+        model->add_single( next++, singleInit->get_value() );
+      } catch ( AssocException &e ) {
+        throw SemanticError( "Illegal initialization: " + e.get_what() );
+      } catch ( ... ) {
+        std::cerr << "Shouldn't be here" << std::endl;
+      }
+      return;
+    }
+    // not general enough (does not contend well with designated arrays)
+    std::list<std::string> desnames;
+    std::transform( des.begin(), des.end(), back_inserter(desnames), Initializer::designator_name );
+    for ( std::list<std::string>::iterator i = desnames.begin(); i != desnames.end(); i++ ) {
+      try {
+        next = model->add_single( *i, singleInit->get_value() );
+        next++;
+      } catch ( AssocException &e ) {
+        throw SemanticError( "Illegal initialization: " + e.get_what() );
+      } catch ( ... ) {
+        std::cerr << "Shouldn't happen, check association" << std::endl;
+      }
+    }
+    return;
+  }
+  void InitModelFiller::visit( ListInit *listInit ) {
+    assert( listInit != 0 );
+    // designators
+    std::list< Expression *> &des = listInit->get_designators();
+    std::list< Initializer *> &ini = listInit->get_initializers();
+    if (! des.empty() ) {
+      if (topLevel)
+        throw SemanticError( "Invalid initializer: designated at top level." );
+      std::list<Expression *> des2;
+      std::copy (des.begin(), des.end(), back_inserter( des2 ));
+      std::list< Expression * > empty;
+      listInit->set_designators( empty );
+      for ( std::list<Expression *>::iterator i = des2.begin(); i != des2.end(); i++ ) {
+        Association * newModel = 0;
+        if ( NameExpr *n = dynamic_cast< NameExpr * >( *i ) )
+          try {
+            newModel = (*model)[ n->get_name() ];
+          } catch( AssocException &e ) {
+            std::cerr << "Didn't find member: " << e.get_what() << std::endl;
+          }
+        else // if ( RangeExpr *r = dynamic_cast< RangeExpr * >( *i ) )
+          std::cerr << "Invalid designator specification" << std::endl;
+        InitModelFiller rec( newModel, listInit, true );
+      }
+    } else
+      if (topLevel) {
+        topLevel = false;
+        for ( std::list<Initializer*>::iterator i = ini.begin(); i != ini.end(); i++ )
+          (*i)->accept(*this);
+      } else
+        // next available uninitialized member
+        InitModelFiller rec( (*model)[next++], listInit, true );
+  }
+  void InitUnspooler::visit( SingleName *single ) {
+    assert(init == 0 && single != 0);
+    std::list< Expression * > empty;
+    init = new SingleInit( single->get_expr(), empty );
+    return;
+  }
+  void InitUnspooler::visit( PointAssociation *pa ) {
+    assert( pa != 0 );
+    std::list< Initializer * > contents;
+    for ( int i = 0; i < pa->size(); i++ )
+      if ( (*pa)[i] != 0 ) {
+        InitUnspooler rec;
+        (*pa)[i]->accept( rec );
+        assert( rec.get_initializer() != 0 );
+        contents.push_back( rec.grab_initializer() );
+      }
+    init = new ListInit( contents );
+    return;
+  }
+        InitModelBuilder::InitModelBuilder( Declaration *_decl )
+                : taken( false ), decl( 0 ), building(0) {
+                ObjectDecl *_odecl = dynamic_cast< ObjectDecl * >( _decl );
+                assert( _odecl != 0 );
+                Type *objectType = _odecl->get_type();
+                /* this to be replaced by dynamic dispatch */
+                if ( dynamic_cast< BasicType * >(objectType) != 0 ) {
+                        if ( building == 0 ) building = new SingleName;
+                } else if ( ReferenceToType *rt = dynamic_cast< ReferenceToType * >(objectType) ) {
+                        rt->accept( *this );
+                } else if ( ArrayType *at = dynamic_cast< ArrayType * >(objectType) ) {
+                        at->accept( *this );
+                } else // if (tuples)
+                        std::cerr << "Got something else" << std::endl;
+                if ( decl != 0 ) init();
+        }
+        InitModelBuilder::~InitModelBuilder() { if ( ! taken ) { delete building; building = 0; } }
+        void InitModelBuilder::init() {
+                assert( decl != 0 );
+                decl->accept( *this );
+        }
+        // Visitor interface
+        void InitModelBuilder::visit( ArrayType *at ) {
+                if ( building == 0 ) building = new RangeAssociation(interpretDimension( at->get_dimension() ));
+                decl = 0;
+                return;
+        }
+        void InitModelBuilder::visit( StructInstType *st ) {
+                if ( building == 0 ) building = new PointAssociation;
+                decl = st->get_baseStruct();
+                return;
+        }
+        void InitModelBuilder::visit( UnionInstType *ut ) {
+                decl = ut->get_baseUnion();
+                return;
+        }
+        void InitModelBuilder::visit( EnumInstType * ) {}
+        void InitModelBuilder::visit( StructDecl *aggregateDecl) {
+                PointAssociation *pa = dynamic_cast< PointAssociation * >( building );
+                assert( pa != 0 );
+                std::list< Declaration * > mem = aggregateDecl->get_members();
+                for ( std::list<Declaration *>::iterator i = mem.begin(); i != mem.end(); i++ ) {
+                        pa->add_member( (*i)->get_name() );
+                        InitModelBuilder rec(*i);
+                        pa->set_member( (*i)->get_name(), rec.grab_assoc() );
+                } // for
+                return;
+        }
+        void InitModelBuilder::visit( UnionDecl *) {}
+        void InitModelBuilder::visit( EnumDecl *) {}
+        // InitModelBuilder::ConstantFolder
+        void InitModelBuilder::ConstantFolder::visit( ConstantExpr *cnst ) {
+                Constant *c = cnst->get_constant();
+                assert (c != 0);
+                if ( BasicType *bt = dynamic_cast<BasicType *>( c->get_type() ) ) {
+                        if ( bt->isInteger() ) {
+                                // need more intelligence here, not necessarily base 10
+                                value = std::strtol( c->get_value().c_str(), NULL, 10 );
+                                return;
+                        } else
+                                std::cerr << "Basic type but not integer" << std::endl;
+                } // if
+                throw 0;
+        }
+        // InitModelFiller
+        InitModelFiller::InitModelFiller( Association *_model, Initializer *_init, bool _topLevel )
+                : model( _model ), orgInit( _init ), topLevel( _topLevel ), next( 0 ) {
+                //next = model.begin();
+                if ( orgInit != 0 ) init();
+        }
+        void InitModelFiller::init() {
+                assert( model != 0 ); // change it into a reference
+                assert( orgInit != 0 );
+                orgInit->accept( *this );
+        }
+        void InitModelFiller::visit( SingleInit *singleInit ) {
+                std::list< Expression *> &des = singleInit->get_designators();
+                if ( topLevel ) {
+                        assert ( des.empty() );
+                        assert ( dynamic_cast< SingleName * >(model) != 0 );
+                        try {
+                                model->add_single( next++, singleInit->get_value() );
+                        } catch (...) {
+                                std::cerr << "Illegal initialization" << std::endl;
+                        }
+                        return;
+                } // if
+                if ( des.empty() ) {
+                        assert( model != 0 );
+                        try {
+                                model->add_single( next++, singleInit->get_value() );
+                        } catch ( AssocException &e ) {
+                                throw SemanticError( "Illegal initialization: " + e.get_what() );
+                        } catch ( ... ) {
+                                std::cerr << "Shouldn't be here" << std::endl;
+                        } // try
+                        return;
+                } // if
+                // not general enough (does not contend well with designated arrays)
+                std::list<std::string> desnames;
+                std::transform( des.begin(), des.end(), back_inserter(desnames), Initializer::designator_name );
+                for ( std::list<std::string>::iterator i = desnames.begin(); i != desnames.end(); i++ ) {
+                        try {
+                                next = model->add_single( *i, singleInit->get_value() );
+                                next++;
+                        } catch ( AssocException &e ) {
+                                throw SemanticError( "Illegal initialization: " + e.get_what() );
+                        } catch ( ... ) {
+                                std::cerr << "Shouldn't happen, check association" << std::endl;
+                        } // try
+                } // for
+                return;
+        }
+        void InitModelFiller::visit( ListInit *listInit ) {
+                assert( listInit != 0 );
+                // designators
+                std::list< Expression *> &des = listInit->get_designators();
+                std::list< Initializer *> &ini = listInit->get_initializers();
+                if ( ! des.empty() ) {
+                        if (topLevel)
+                                throw SemanticError( "Invalid initializer: designated at top level." );
+                        std::list<Expression *> des2;
+                        std::copy (des.begin(), des.end(), back_inserter( des2 ));
+                        std::list< Expression * > empty;
+                        listInit->set_designators( empty );
+                        for ( std::list<Expression *>::iterator i = des2.begin(); i != des2.end(); i++ ) {
+                                Association * newModel = 0;
+                                if ( NameExpr *n = dynamic_cast< NameExpr * >( *i ) )
+                                        try {
+                                                newModel = (*model)[ n->get_name() ];
+                                        } catch( AssocException &e ) {
+                                                std::cerr << "Didn't find member: " << e.get_what() << std::endl;
+                                        }
+                                else // if ( RangeExpr *r = dynamic_cast< RangeExpr * >( *i ) )
+                                        std::cerr << "Invalid designator specification" << std::endl;
+                                InitModelFiller rec( newModel, listInit, true );
+                        } // for
+                } else
+                        if (topLevel) {
+                                topLevel = false;
+                                for ( std::list<Initializer*>::iterator i = ini.begin(); i != ini.end(); i++ )
+                                        (*i)->accept(*this);
+                        } else
+                                // next available uninitialized member
+                                InitModelFiller rec( (*model)[next++], listInit, true );
+        }
+        void InitUnspooler::visit( SingleName *single ) {
+                assert(init == 0 && single != 0);
+                std::list< Expression * > empty;
+                init = new SingleInit( single->get_expr(), empty );
+                return;
+        }
+        void InitUnspooler::visit( PointAssociation *pa ) {
+                assert( pa != 0 );
+                std::list< Initializer * > contents;
+                for ( int i = 0; i < pa->size(); i++ )
+                        if ( (*pa)[i] != 0 ) {
+                                InitUnspooler rec;
+                                (*pa)[i]->accept( rec );
+                                assert( rec.get_initializer() != 0 );
+                                contents.push_back( rec.grab_initializer() );
+                        } // if
+                init = new ListInit( contents );
+                return;
+        }
 } // namespace InitTweak
 // Local Variables: //
 // tab-width: 4 //

translator/InitTweak/InitModel.h

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// InitModel.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 16:37:52 2015
+// Update Count     : 2
 //
 #ifndef _INITTWEAK_MODEL_H_
 #define _INITTWEAK_MODEL_H_
 …
 namespace InitTweak {
     class InitModelBuilder : public AssociationBuilder, public Visitor {
       public:
         InitModelBuilder( Declaration * );
         ~InitModelBuilder();
+        class InitModelBuilder : public AssociationBuilder, public Visitor {
+          public:
+                InitModelBuilder( Declaration * );
+                ~InitModelBuilder();
         virtual Association *grab_assoc() { taken = true; return building; }
         virtual Association *get_assoc() { return building; }
         void set_assoc( Association *newAssoc ) { building = newAssoc; }
+                virtual Association *grab_assoc() { taken = true; return building; }
+                virtual Association *get_assoc() { return building; }
+                void set_assoc( Association *newAssoc ) { building = newAssoc; }
         void init();
         static int interpretDimension( Expression *exp ) {
             ConstantFolder folder( exp );
             try {
                 return folder.get_constant();
             } catch (...) {
                 throw SemanticError("Invalid array dimension");
+            }
+        }
+                void init();
+                static int interpretDimension( Expression *exp ) {
+                        ConstantFolder folder( exp );
+                        try {
+                                return folder.get_constant();
+                        } catch (...) {
+                                throw SemanticError("Invalid array dimension");
+                        }
+                }
+        // types
+        virtual void visit( ArrayType * );
+        virtual void visit( StructInstType * );
+        virtual void visit( UnionInstType * );
+        virtual void visit( EnumInstType * );
+        virtual void visit( ContextInstType * ) { throw 0; }
+        virtual void visit( TypeInstType * )    { throw 0; }
+        // virtual void visit( TupleType *tupleType );
+        // declarations
+        virtual void visit( StructDecl *);
+        virtual void visit( UnionDecl *);
+        virtual void visit( EnumDecl *);
+      private:
+        class ConstantFolder : public Visitor {
+          public:
+            ConstantFolder( Expression *_expr = 0 ): expr(_expr) {}
+            int get_constant() throw() { expr->accept( *this ); return value; }
+            void set_constant( Expression *newExp ) { expr = newExp; }
+            // Visitor interface
+            void visit( Expression * ) { throw 0; }
+            void visit( NameExpr * ) { throw 0; }
+            void visit( CastExpr * ) { throw 0; }
+            void visit( UntypedMemberExpr * ) { throw 0; }
+            void visit( VariableExpr * ) { throw 0; }
+            void visit( ConstantExpr * );
+            void visit( SizeofExpr * ) { throw 0; }
+            void visit( AttrExpr * ) { throw 0; }
+            void visit( LogicalExpr * ) { throw 0; }
+            void visit( ConditionalExpr * ) { throw 0; }
+            void visit( CommaExpr * ) { throw 0; }
+                // types
+                virtual void visit( ArrayType * );
+                virtual void visit( StructInstType * );
+                virtual void visit( UnionInstType * );
+                virtual void visit( EnumInstType * );
+                virtual void visit( ContextInstType * ) { throw 0; }
+                virtual void visit( TypeInstType * )    { throw 0; }
+                // virtual void visit( TupleType *tupleType );
+                // declarations
+                virtual void visit( StructDecl *);
+                virtual void visit( UnionDecl *);
+                virtual void visit( EnumDecl *);
           private:
+            Expression *expr;
+            int value;
+                class ConstantFolder : public Visitor {
+                  public:
+                        ConstantFolder( Expression *_expr = 0 ): expr(_expr) {}
+                        int get_constant() throw() { expr->accept( *this ); return value; }
+                        void set_constant( Expression *newExp ) { expr = newExp; }
+                        // Visitor interface
+                        void visit( Expression * ) { throw 0; }
+                        void visit( NameExpr * ) { throw 0; }
+                        void visit( CastExpr * ) { throw 0; }
+                        void visit( UntypedMemberExpr * ) { throw 0; }
+                        void visit( VariableExpr * ) { throw 0; }
+                        void visit( ConstantExpr * );
+                        void visit( SizeofExpr * ) { throw 0; }
+                        void visit( AttrExpr * ) { throw 0; }
+                        void visit( LogicalExpr * ) { throw 0; }
+                        void visit( ConditionalExpr * ) { throw 0; }
+                        void visit( CommaExpr * ) { throw 0; }
+                  private:
+                        Expression *expr;
+                        int value;
+                };
+                bool taken;
+                Declaration *decl;  // ?
+                Association *building;
         };
+        bool taken;
+        Declaration *decl;  // ?
+        Association *building;
+    };
+        class InitModelFiller : public AssociationFiller, public Visitor {
+          public:
+                InitModelFiller( Association *, Initializer *, bool _topLevel = false );
+                ~InitModelFiller() { /* pointers in here are not owned by object (never created by object either) */ }
+                virtual Association *get_assoc() { return model; }
+                virtual void set_assoc( Association *newAssoc ) { model = newAssoc; }
+    class InitModelFiller : public AssociationFiller, public Visitor {
+      public:
+        InitModelFiller( Association *, Initializer *, bool _topLevel = false );
+        ~InitModelFiller() { /* pointers in here are not owned by object (never created by object either) */ }
+        virtual Association *get_assoc() { return model; }
+        virtual void set_assoc( Association *newAssoc ) { model = newAssoc; }
+                void init();
+                // Visitor interface
+                virtual void visit( SingleInit *singleInit );
+                virtual void visit( ListInit *listInit );
+          private:
+                Association *model;
+                Initializer *orgInit;
+                bool topLevel;
+                long int next;
+        };
+        void init();
+        // Visitor interface
+        virtual void visit( SingleInit *singleInit );
+        virtual void visit( ListInit *listInit );
+      private:
+        Association *model;
+        Initializer *orgInit;
+        bool topLevel;
+        long int next;
+    };
+        class InitUnspooler : public AssociationVisitor {
+          public:
+                InitUnspooler() : init(0), taken( false ) {}
+                virtual ~InitUnspooler() { if ( ! taken && (init != 0)) { delete init; init = 0; } }
+                Initializer *get_initializer() { return init; }
+                Initializer *grab_initializer() { taken = true; return init; }
+    class InitUnspooler : public AssociationVisitor {
+      public:
+        InitUnspooler() : init(0), taken( false ) {}
+        virtual ~InitUnspooler() { if (! taken && (init != 0)) { delete init; init = 0; } }
+        Initializer *get_initializer() { return init; }
+        Initializer *grab_initializer() { taken = true; return init; }
+        virtual void visit( SingleName * );
+        virtual void visit( PointAssociation * );
+        virtual void visit( RangeAssociation * ) { std::cerr << "InitUnspooler - In a range assoc" << std::endl; return; }
+      private:
+        Initializer *init;
+        bool taken;
+    };
+                virtual void visit( SingleName * );
+                virtual void visit( PointAssociation * );
+                virtual void visit( RangeAssociation * ) { std::cerr << "InitUnspooler - In a range assoc" << std::endl; return; }
+          private:
+                Initializer *init;
+                bool taken;
+        };
 } // namespace InitTweak
 #endif // _INITTWEAK_MODEL_H_
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/InitTweak/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 16:38:19 2015
+// Update Count     : 1
 //
 #include "SynTree/Mutator.h"
 …
 namespace InitTweak {
+        void mutate( std::list< Declaration * > translationUnit ) {
+                //BasicInit bi;
+                InitExpander ini;
+                //DeclarationHoister dh;
+  void mutate( std::list< Declaration * > translationUnit )
+  {
+    //BasicInit bi;
+    InitExpander ini;
+    //DeclarationHoister dh;
+    //mutateAll( translationUnit, bi );
+    mutateAll( translationUnit, ini );
+    //mutateAll( translationUnit, dh );
+  }
+                //mutateAll( translationUnit, bi );
+                mutateAll( translationUnit, ini );
+                //mutateAll( translationUnit, dh );
+        }
 } // namespace InitTweak
 // Local Variables: //

translator/InitTweak/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 16:38:52 2015
+// Update Count     : 2
 //
 #ifndef INIT_MUTATE_H
 #define INIT_MUTATE_H
 …
 namespace InitTweak {
+  void mutate( std::list< Declaration* > translationUnit );
+        void mutate( std::list< Declaration* > translationUnit );
 } // namespace InitTweak
 #endif // #ifndef INIT_MUTATE_H
+#endif // INIT_MUTATE_H
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/InitTweak/RemoveInit.cc

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// RemoveInit.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 16:39:32 2015
+// Update Count     : 1
 //
 #include "RemoveInit.h"
 #include "SynTree/Declaration.h"
 …
 namespace InitTweak {
+        namespace {
+                const std::list<Label> noLabels;
+        }
+namespace {
+const std::list<Label> noLabels;
+}
+        void tweak( std::list< Declaration * > translationUnit ) {
+                RemoveInit remover;
+                mutateAll( translationUnit, remover );
+        }
+void tweak( std::list< Declaration * > translationUnit ) {
+  RemoveInit remover;
+  mutateAll( translationUnit, remover );
+}
+        void RemoveInit::mutateStatementList( std::list< Statement* > &statements ) {
+                for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
+                        if ( ! stmtsToAddAfter.empty() ) {
+                                statements.splice( i, stmtsToAddAfter );
+                        } // if
+                        *i = (*i)->acceptMutator( *this );
+                } // for
+                if ( ! stmtsToAddAfter.empty() ) {
+                        statements.splice( statements.end(), stmtsToAddAfter );
+                } // if
+        }
+void RemoveInit::mutateStatementList( std::list< Statement* > &statements ) {
+  for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
+    if ( ! stmtsToAddAfter.empty() ) {
+      statements.splice( i, stmtsToAddAfter );
+    }
+    *i = (*i)->acceptMutator( *this );
+  }
+  if ( ! stmtsToAddAfter.empty() ) {
+    statements.splice( statements.end(), stmtsToAddAfter );
+  }
+}
+CompoundStmt *RemoveInit::mutate(CompoundStmt *compoundStmt) {
+  mutateStatementList( compoundStmt->get_kids() );
+  return compoundStmt;
+}
+        CompoundStmt *RemoveInit::mutate(CompoundStmt *compoundStmt) {
+                mutateStatementList( compoundStmt->get_kids() );
+                return compoundStmt;
+        }
 // in the case where an object has an initializer and a polymorphic type, insert an assignment
 // immediately after the declaration. This will (seemingly) cause the later phases to do the right
 // thing with the assignment
 ObjectDecl *RemoveInit::mutate( ObjectDecl *objDecl ) {
   if (objDecl->get_init() && dynamic_cast<TypeInstType*>(objDecl->get_type())) {
     if (SingleInit * single = dynamic_cast<SingleInit*>(objDecl->get_init())) {
       UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
       assign->get_args().push_back( new AddressExpr (new NameExpr( objDecl->get_name() ) ) );
       assign->get_args().push_back( single->get_value()->clone() );
       stmtsToAddAfter.push_back(new ExprStmt(noLabels, assign));
+    }
+  }
   return objDecl;
+}
+        ObjectDecl *RemoveInit::mutate( ObjectDecl *objDecl ) {
+                if (objDecl->get_init() && dynamic_cast<TypeInstType*>(objDecl->get_type())) {
+                        if (SingleInit * single = dynamic_cast<SingleInit*>(objDecl->get_init())) {
+                                UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
+                                assign->get_args().push_back( new AddressExpr (new NameExpr( objDecl->get_name() ) ) );
+                                assign->get_args().push_back( single->get_value()->clone() );
+                                stmtsToAddAfter.push_back(new ExprStmt(noLabels, assign));
+                        } // if
+                } // if
+                return objDecl;
+        }
 } // namespace InitTweak

translator/InitTweak/RemoveInit.h

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// RemoveInit.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 16:40:11 2015
+// Update Count     : 1
 //
-/*
- * This file is part of the Cforall project
+ *
- * $Id: PolyMutator.h,v 1.8 2005/08/29 20:14:13 rcbilson Exp $
+ *
- */
 #ifndef REMOVE_INIT_H
 …
 namespace InitTweak {
+        void tweak( std::list< Declaration * > translationUnit );
+void tweak( std::list< Declaration * > translationUnit );
+class RemoveInit : public Mutator {
+public:
+  // RemoveInit();
+  virtual ObjectDecl *mutate(ObjectDecl *objDecl);
+  virtual CompoundStmt *mutate(CompoundStmt *compoundStmt);
+protected:
+  std::list< Statement* > stmtsToAddAfter;
+  void mutateStatementList( std::list< Statement* > &statements );
+};
+        class RemoveInit : public Mutator {
+          public:
+                // RemoveInit();
+                virtual ObjectDecl *mutate(ObjectDecl *objDecl);
+                virtual CompoundStmt *mutate(CompoundStmt *compoundStmt);
+          protected:
+                std::list< Statement* > stmtsToAddAfter;
+                void mutateStatementList( std::list< Statement* > &statements );
+        };
 } // namespace
+#endif /* #ifndef GENPOLY_POLYMUTATOR_H */
+#endif // GENPOLY_POLYMUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

translator/InitTweak/diet_map.h

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// diet_map.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 16:41:17 2015
+// Update Count     : 2
+//
 #include <cassert>
 #include <string>
 …
 namespace diet {
+  /* A DIET ( Discrete Interval Encoding Tree ) range-map
+   */
+  class diet_tree_exception : public std::exception {
+  public:
+    diet_tree_exception() {}
+    diet_tree_exception( std::string _what ) : what( _what ) {}
+    ~diet_tree_exception() throw () {}
+    std::string get_what() const { return what; }
+    void set_what( std::string newValue ) { what = newValue; }
+  private:
+    std::string what;
+  };
+  template < typename T > class diet_tree_node;
+  template < typename T > class diet_tree_iterator;
+  template< typename key_type >
+  class diet_tree {
+    typedef key_type OrderedValue;
+    typedef OrderedValue T;
+    friend class diet_tree_iterator<T>;
+  public:
+    typedef OrderedValue value_type;
+    typedef diet_tree_iterator<OrderedValue> iterator;
+    typedef std::pair<value_type, value_type> pair_type;
+    diet_tree() : root(0), left(0), right(0) {}
+    ~diet_tree() {
+      if ( root != 0 ) { delete root; root = 0; }
+      if ( left != 0 ) { delete left; left = 0; }
+      if ( right != 0 ) { delete right; right = 0; }
+    }
+    void insert( value_type _lo, value_type _hi ) {
+      if ( _lo > _hi ) return; // throw exception?
+      if ( root == 0 )
+        root = new diet_tree_node<value_type>(_lo, _hi);
+      else {
+        value_type lo = root->get_lo(), hi = root->get_hi();
+        if ( _lo < lo ) {
+          if ( _hi > hi ) {
+            /* can either minimize the work or minimize the number of nodes.
+               Let's minimize the work. */
+            if ( left == 0 ) left = new diet_tree<T>();
+            left->insert( _lo, lo );
+            if ( right == 0 ) right = new diet_tree<T>();
+            right->insert( _hi, hi );
+            return;
+          } else if ( _hi < lo ) {
+            if ( left == 0 ) left = new diet_tree<T>();
+            left->insert( _lo, _hi );
+          } else if ( _hi <= hi ) {
+            if ( left == 0 ) left = new diet_tree<T>();
+            left->insert( _lo, _hi );
+            root->set_range(_hi,hi);
+          }
+        } else if (_lo >= lo && _hi <= hi ) {
+          root->set_range(_lo,_hi);
+        } else if ( _hi > hi) {
+          if ( _lo > hi ) {
+            if ( right == 0 ) right = new diet_tree<T>();
+            right->insert( _lo, _hi );
+          } else if ( _lo < hi ) {
+            root->set_range(lo, _lo);
+            if ( right == 0 ) right = new diet_tree<T>();
+            right->insert(_lo, _hi);
+          }
+        }
+      }
+      return;
+    }
+    void insert( std::pair<value_type, value_type> p ) {
+      insert(p.first, p.second);
+    }
+    pair_type get_range_pair() const {
+      return pair_type(root->get_lo(),root->get_hi());
+    }
+    /*
+    void display( std::ostream &os = std::cout ) {
+      if ( root != 0 ) {
+        if ( left != 0 ) left->display(os);
+        os << "(" << root->get_lo() << ", " << root->get_hi() << ")" << std::endl;
+        if ( right != 0 ) right->display(os);
+      }
+      return;
+    }
+    */
+    iterator begin() { return iterator( this ); }
+    iterator end() { return iterator( (diet_tree< value_type > *)0 ); }
+  protected:
+    diet_tree( diet_tree_node< OrderedValue > *_root ) : root( _root ) {}
+  private:
+    diet_tree_node< value_type > *root;
+    diet_tree< value_type > *left, *right;
+  };
+  template< typename OrderedValue >
+  class diet_tree_node {
+  public:
+    typedef OrderedValue value_type;
+    diet_tree_node( const OrderedValue &_lo, const OrderedValue &_hi )
+      : lo( _lo ), hi( _hi ) {
+      if ( lo >= hi ) throw diet_tree_exception( "Invalid range" );
+    }
+    void set_range(const OrderedValue &newLo, const OrderedValue &newHi)
+    { lo = newLo; hi = newHi; }
+    OrderedValue get_lo() const { return lo; }
+    OrderedValue get_hi() const { return hi; }
+  private:
+    OrderedValue lo, hi;
+  };
+  /* forward iterator */
+  template < typename T >
+  class diet_tree_iterator {
+    typedef diet_tree_iterator<T> self;
+    typedef typename diet_tree<T>::pair_type pair_type;
+  public:
+    //    typedef forward_iterator_tag iterator_category;
+    diet_tree_iterator( diet_tree<T> *_tree ) : current( _tree ) {
+      // current is allowed to be 0 only for `end'
+      if (_tree != 0) go_leftmost();
+    }
+    ~diet_tree_iterator() {}
+    pair_type operator*() {
+      if ( current == 0 ) throw diet_tree_exception( "Invalid dereference" );
+      return current->get_range_pair();
+    }
+    bool operator==( const diet_tree_iterator<T> &other ) { return current == other.current;  }
+    bool operator!=( const diet_tree_iterator<T> &other ) { return current != other.current;  }
+    diet_tree_iterator<T> operator++() {
+      assert(current != 0);
+      if ( current->right == 0 )
+        if ( ! st.empty() )
+          { current = st.top(); st.pop(); }
+        else
+          current = 0;
+      else {
+        current = current->right;
+        go_leftmost();
+      }
+      return *this;
+    }
+    diet_tree_iterator<T> operator++(int) {
+      self temp = *this;
+      this->operator++();
+      return temp;
+    }
+  private:
+    void go_leftmost() {
+      assert(current != 0);
+      diet_tree<T> *next = 0;
+      while ( current->left != 0 ) {
+        next = current->left; st.push( current ); current = next;
+      }
+      return;
+    }
+    void defrag() {
+      /* join adjacent trees */
+      return;
+    }
+    diet_tree<T> *current;
+    std::stack< diet_tree<T> * > st;
+  };
+  template < typename Key, typename Value >
+  class diet_tree_assoc_node : public diet_tree_node<Key> {
+  public:
+    typedef Key key_type;
+    typedef Value data_type;
+    typedef std::pair<Key,Value> value_type;
+  private:
+    Value data;
+  };
+        /* A DIET ( Discrete Interval Encoding Tree ) range-map
+         */
+        class diet_tree_exception : public std::exception {
+          public:
+                diet_tree_exception() {}
+                diet_tree_exception( std::string _what ) : what( _what ) {}
+                ~diet_tree_exception() throw () {}
+                std::string get_what() const { return what; }
+                void set_what( std::string newValue ) { what = newValue; }
+          private:
+                std::string what;
+        };
+        template < typename T > class diet_tree_node;
+        template < typename T > class diet_tree_iterator;
+        template< typename key_type >
+        class diet_tree {
+                typedef key_type OrderedValue;
+                typedef OrderedValue T;
+                friend class diet_tree_iterator<T>;
+          public:
+                typedef OrderedValue value_type;
+                typedef diet_tree_iterator<OrderedValue> iterator;
+                typedef std::pair<value_type, value_type> pair_type;
+                diet_tree() : root(0), left(0), right(0) {}
+                ~diet_tree() {
+                        if ( root != 0 ) { delete root; root = 0; }
+                        if ( left != 0 ) { delete left; left = 0; }
+                        if ( right != 0 ) { delete right; right = 0; }
+                }
+                void insert( value_type _lo, value_type _hi ) {
+                        if ( _lo > _hi ) return; // throw exception?
+                        if ( root == 0 )
+                                root = new diet_tree_node<value_type>(_lo, _hi);
+                        else {
+                                value_type lo = root->get_lo(), hi = root->get_hi();
+                                if ( _lo < lo ) {
+                                        if ( _hi > hi ) {
+                                                /* can either minimize the work or minimize the number of nodes.
+                                                   Let's minimize the work. */
+                                                if ( left == 0 ) left = new diet_tree<T>();
+                                                left->insert( _lo, lo );
+                                                if ( right == 0 ) right = new diet_tree<T>();
+                                                right->insert( _hi, hi );
+                                                return;
+                                        } else if ( _hi < lo ) {
+                                                if ( left == 0 ) left = new diet_tree<T>();
+                                                left->insert( _lo, _hi );
+                                        } else if ( _hi <= hi ) {
+                                                if ( left == 0 ) left = new diet_tree<T>();
+                                                left->insert( _lo, _hi );
+                                                root->set_range(_hi,hi);
+                                        }
+                                } else if (_lo >= lo && _hi <= hi ) {
+                                        root->set_range(_lo,_hi);
+                                } else if ( _hi > hi) {
+                                        if ( _lo > hi ) {
+                                                if ( right == 0 ) right = new diet_tree<T>();
+                                                right->insert( _lo, _hi );
+                                        } else if ( _lo < hi ) {
+                                                root->set_range(lo, _lo);
+                                                if ( right == 0 ) right = new diet_tree<T>();
+                                                right->insert(_lo, _hi);
+                                        } // if
+                                } // if
+                        } // if
+                        return;
+                }
+                void insert( std::pair<value_type, value_type> p ) {
+                        insert(p.first, p.second);
+                }
+                pair_type get_range_pair() const {
+                        return pair_type(root->get_lo(),root->get_hi());
+                }
+                /*
+                  void display( std::ostream &os = std::cout ) {
+                  if ( root != 0 ) {
+                  if ( left != 0 ) left->display(os);
+                  os << "(" << root->get_lo() << ", " << root->get_hi() << ")" << std::endl;
+                  if ( right != 0 ) right->display(os);
+                  }
+                  return;
+                  }
+                */
+                iterator begin() { return iterator( this ); }
+                iterator end() { return iterator( (diet_tree< value_type > *)0 ); }
+          protected:
+                diet_tree( diet_tree_node< OrderedValue > *_root ) : root( _root ) {}
+          private:
+                diet_tree_node< value_type > *root;
+                diet_tree< value_type > *left, *right;
+        };
+        template< typename OrderedValue >
+        class diet_tree_node {
+          public:
+                typedef OrderedValue value_type;
+                diet_tree_node( const OrderedValue &_lo, const OrderedValue &_hi )
+                        : lo( _lo ), hi( _hi ) {
+                        if ( lo >= hi ) throw diet_tree_exception( "Invalid range" );
+                }
+                void set_range(const OrderedValue &newLo, const OrderedValue &newHi)
+                        { lo = newLo; hi = newHi; }
+                OrderedValue get_lo() const { return lo; }
+                OrderedValue get_hi() const { return hi; }
+          private:
+                OrderedValue lo, hi;
+        };
+        /* forward iterator */
+        template < typename T >
+        class diet_tree_iterator {
+                typedef diet_tree_iterator<T> self;
+                typedef typename diet_tree<T>::pair_type pair_type;
+          public:
+                //    typedef forward_iterator_tag iterator_category;
+                diet_tree_iterator( diet_tree<T> *_tree ) : current( _tree ) {
+                        // current is allowed to be 0 only for `end'
+                        if (_tree != 0) go_leftmost();
+                }
+                ~diet_tree_iterator() {}
+                pair_type operator*() {
+                        if ( current == 0 ) throw diet_tree_exception( "Invalid dereference" );
+                        return current->get_range_pair();
+                }
+                bool operator==( const diet_tree_iterator<T> &other ) { return current == other.current;  }
+                bool operator!=( const diet_tree_iterator<T> &other ) { return current != other.current;  }
+                diet_tree_iterator<T> operator++() {
+                        assert(current != 0);
+                        if ( current->right == 0 )
+                                if ( ! st.empty() )
+                                        { current = st.top(); st.pop(); }
+                                else
+                                        current = 0;
+                        else {
+                                current = current->right;
+                                go_leftmost();
+                        } // if
+                        return *this;
+                }
+                diet_tree_iterator<T> operator++(int) {
+                        self temp = *this;
+                        this->operator++();
+                        return temp;
+                }
+          private:
+                void go_leftmost() {
+                        assert(current != 0);
+                        diet_tree<T> *next = 0;
+                        while ( current->left != 0 ) {
+                                next = current->left; st.push( current ); current = next;
+                        }
+                        return;
+                }
+                void defrag() {
+                        /* join adjacent trees */
+                        return;
+                }
+                diet_tree<T> *current;
+                std::stack< diet_tree<T> * > st;
+        };
+        template < typename Key, typename Value >
+        class diet_tree_assoc_node : public diet_tree_node<Key> {
+          public:
+                typedef Key key_type;
+                typedef Value data_type;
+                typedef std::pair<Key,Value> value_type;
+          private:
+                Value data;
+        };
 } // namespace diet
-/*
-  Local Variables:
-  mode: c++
-  End:
-*/
 // Local Variables: //
 // tab-width: 4 //

translator/Parser/ExpressionNode.cc

-                      r01aeade
+                      ra08ba92
+}
 CommaExprNode *ExpressionNode::add_to_list( ExpressionNode *exp ){
+CommaExprNode *ExpressionNode::add_to_list( ExpressionNode *exp ) {
         return new CommaExprNode( this, exp );
+}
 …
+}
 void ConstantNode::classify( std::string &str ){
         switch ( type ){
+void ConstantNode::classify( std::string &str ) {
+        switch ( type ) {
           case Integer:
           case Float:
 …
                         std::transform( sfx.begin(), sfx.end(), sfx.begin(), tolower_hack );
                         if ( sfx.find("ll") != string::npos ){
+                        if ( sfx.find("ll") != string::npos ) {
                                 longs = 2;
                         } else if ( sfx.find("l") != string::npos ){
+                        } else if ( sfx.find("l") != string::npos ) {
                                 longs = 1;
                         } // if
 …
 ConstantNode *ConstantNode::append( std::string *newValue ) {
         if ( newValue ) {
                 if ( type == String ){
+                if ( type == String ) {
                         std::string temp = *newValue;
                         value.resize( value.size() - 1 );
 …
         BasicType *bt;
         switch ( get_type()){
+        switch ( get_type()) {
           case Integer:
                 /* Cfr. standard 6.4.4.1 */
 …
                 return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() ));
         } else {
                 switch ( op->get_type()){
+                switch ( op->get_type()) {
                   case OperatorNode::Incr:
                   case OperatorNode::Decr:
 …
+}
 void CompositeExprNode::set_function( ExpressionNode *f ){
+void CompositeExprNode::set_function( ExpressionNode *f ) {
         function = f;
+}
 void CompositeExprNode::set_args( ExpressionNode *args ){
+void CompositeExprNode::set_args( ExpressionNode *args ) {
         arguments = args;
+}
 …
+}
 void CompositeExprNode::add_arg( ExpressionNode *arg ){
+void CompositeExprNode::add_arg( ExpressionNode *arg ) {
         if ( arguments )
                 arguments->set_link( arg );
 …
+}
 CommaExprNode *CommaExprNode::add_to_list( ExpressionNode *exp ){
+CommaExprNode *CommaExprNode::add_to_list( ExpressionNode *exp ) {
         add_arg( exp );
 …
+}
 ForCtlExprNode::~ForCtlExprNode(){
+ForCtlExprNode::~ForCtlExprNode() {
         delete init;
         delete condition;

translator/Parser/ParseNode.cc

-                      r01aeade
+                      ra08ba92
 // Created On       : Sat May 16 13:26:29 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat May 16 13:27:51 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 16:48:30 2015
+// Update Count     : 3
 //
 …
 ParseNode *ParseNode::set_name( string _name ) {
     name = _name;
     return this;
+        name = _name;
+        return this;
+}
 ParseNode *ParseNode::set_name( string *_name ) {
     name = *_name; // deep copy
     delete _name;
+        name = *_name; // deep copy
+        delete _name;
     return this;
+        return this;
+}
 ParseNode::~ParseNode( void ) {
     delete next;
+        delete next;
 };
 string ParseNode::get_name( void ) {
     return name;
+        return name;
+}
 ParseNode *ParseNode::get_link( void ) const {
     return next;
+        return next;
+}
 ParseNode *ParseNode::get_last(void) {
     ParseNode *current = this;
+        ParseNode *current = this;
     while ( current->get_link() != 0 )
+        while ( current->get_link() != 0 )
         current = current->get_link();
     return current;
+        return current;
+}
 ParseNode *ParseNode::set_link(ParseNode *_next){
     ParseNode *follow;
+ParseNode *ParseNode::set_link(ParseNode *_next) {
+        ParseNode *follow;
     if ( _next == 0 ) return this;
+        if ( _next == 0 ) return this;
     for ( follow = this; follow->next != 0; follow = follow->next );
     follow->next = _next;
+        for ( follow = this; follow->next != 0; follow = follow->next );
+        follow->next = _next;
     return this;
+        return this;
+}
 const string ParseNode::get_name(void) const {
     return name;
+        return name;
+}
 …
 void ParseNode::printList( std::ostream &os, int indent ) const {
     print( os, indent );
+        print( os, indent );
     if ( next ) {
+        if ( next ) {
         next->printList( os, indent );
+    }
+        }
+}
 ParseNode &ParseNode::operator,( ParseNode &p ) {
     set_link( &p );
+        set_link( &p );
     return *this;
+        return *this;
+}
 ParseNode *mkList( ParseNode &pn ) {
     // it just relies on `operator,' to take care of the "arguments" and provides a nice interface to an awful-looking
     // address-of, rendering, for example (StatementNode *)(&(*$5 + *$7)) into (StatementNode *)mkList(($5, $7))
     // (although "nice" is probably not the word)
     return &pn;
+        // it just relies on `operator,' to take care of the "arguments" and provides a nice interface to an awful-looking
+        // address-of, rendering, for example (StatementNode *)(&(*$5 + *$7)) into (StatementNode *)mkList(($5, $7))
+        // (although "nice" is probably not the word)
+        return &pn;
+}

translator/Parser/StatementNode.cc

r01aeade	ra08ba92
171	171	void StatementNode::print( std::ostream &os, int indent ) const {
172	172	if ( labels != 0 )
173		if (! labels->empty()) {
	173	if ( ! labels->empty()) {
174	174	std::list<std::string>::const_iterator i;
175	175

translator/Parser/TypedefTable.cc

r01aeade	ra08ba92
123	123	for ( tableType::iterator i = table.begin(); i != table.end(); ) {
124	124	list<Entry> &declList = (*i ).second;
125		while (! declList.empty() && declList.front().scope == currentScope ) {
	125	while ( ! declList.empty() && declList.front().scope == currentScope ) {
126	126	declList.pop_front();
127	127	}

translator/Parser/lex.l

-                      r01aeade
+                      ra08ba92
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Sat May 16 12:14:18 2015
  * Update Count     : 330
+ * Last Modified On : Tue May 19 15:41:54 2015
+ * Update Count     : 331
  */

translator/ResolvExpr/ResolveTypeof.cc

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 12:12:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 12:13:38 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 16:49:04 2015
+// Update Count     : 3
 //
 …
 namespace ResolvExpr {
     namespace {
+        namespace {
 #if 0
                 void
 …
+                }
 #endif
+    }
+        }
     class ResolveTypeof : public Mutator {
       public:
+        class ResolveTypeof : public Mutator {
+          public:
                 ResolveTypeof( const SymTab::Indexer &indexer ) : indexer( indexer ) {}
                 Type *mutate( TypeofType *typeofType );
       private:
+          private:
                 const SymTab::Indexer &indexer;
     };
+        };
     Type *resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
+        Type *resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
                 ResolveTypeof mutator( indexer );
                 return type->acceptMutator( mutator );
+    }
+        }
     Type *ResolveTypeof::mutate( TypeofType *typeofType ) {
+        Type *ResolveTypeof::mutate( TypeofType *typeofType ) {
 #if 0
                 std::cout << "resolving typeof: ";
 …
                 } // if
                 return typeofType;
+    }
+        }
 } // namespace ResolvExpr

translator/SymTab/IdTable.cc

r01aeade	ra08ba92
139	139	std::stack<DeclEntry> stack = inner->second;
140	140	os << "dumping a stack" << std::endl;
141		while (! stack.empty()) {
	141	while ( ! stack.empty()) {
142	142	DeclEntry d = stack.top();
143	143	os << outer->first << " (" << inner->first << ") (" << d.second << ") " << std::endl;

translator/SymTab/IdTable.h

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 21:30:02 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 21:31:45 2015
 // Update Count     : 3
+// Last Modified On : Tue May 19 16:49:33 2015
+// Update Count     : 4
 //
 …
 namespace SymTab {
     class IdTable {
       public:
+        class IdTable {
+          public:
                 IdTable();
 …
                 void dump( std::ostream &os ) const;                    // debugging
       private:
+          private:
                 typedef std::pair< DeclarationWithType*, int > DeclEntry;
                 typedef std::map< std::string, std::stack< DeclEntry > > InnerTableType;
 …
                 OuterTableType table;
                 int scopeLevel;
     };
+        };
 } // namespace SymTab

translator/SymTab/Indexer.cc

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 21:37:33 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 21:38:44 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 16:49:55 2015
+// Update Count     : 3
 //
 …
 namespace SymTab {
     Indexer::Indexer( bool useDebug ) : doDebug( useDebug ) {}
     Indexer::~Indexer() {}
     void Indexer::visit( ObjectDecl *objectDecl ) {
+        Indexer::Indexer( bool useDebug ) : doDebug( useDebug ) {}
+        Indexer::~Indexer() {}
+        void Indexer::visit( ObjectDecl *objectDecl ) {
                 maybeAccept( objectDecl->get_type(), *this );
                 maybeAccept( objectDecl->get_init(), *this );
 …
                         idTable.addDecl( objectDecl );
                 } // if
+    }
     void Indexer::visit( FunctionDecl *functionDecl ) {
+        }
+        void Indexer::visit( FunctionDecl *functionDecl ) {
                 if ( functionDecl->get_name() == "" ) return;
                 debugPrint( "Adding function " << functionDecl->get_name() << std::endl );
 …
                 maybeAccept( functionDecl->get_statements(), *this );
                 leaveScope();
+    }
+        }
 /********
 …
  */
     void Indexer::visit( TypeDecl *typeDecl ) {
+        void Indexer::visit( TypeDecl *typeDecl ) {
                 // see A NOTE ON THE ORDER OF TRAVERSAL, above
                 // note that assertions come after the type is added to the symtab, since they aren't part
 …
                 typeTable.add( typeDecl );
                 acceptAll( typeDecl->get_assertions(), *this );
+    }
     void Indexer::visit( TypedefDecl *typeDecl ) {
+        }
+        void Indexer::visit( TypedefDecl *typeDecl ) {
                 enterScope();
                 acceptAll( typeDecl->get_parameters(), *this );
 …
                 debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl );
                 typeTable.add( typeDecl );
+    }
     void Indexer::visit( StructDecl *aggregateDecl ) {
+        }
+        void Indexer::visit( StructDecl *aggregateDecl ) {
                 // make up a forward declaration and add it before processing the members
                 StructDecl fwdDecl( aggregateDecl->get_name() );
 …
                 // this addition replaces the forward declaration
                 structTable.add( aggregateDecl );
+    }
     void Indexer::visit( UnionDecl *aggregateDecl ) {
+        }
+        void Indexer::visit( UnionDecl *aggregateDecl ) {
                 // make up a forward declaration and add it before processing the members
                 UnionDecl fwdDecl( aggregateDecl->get_name() );
 …
                 debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl );
                 unionTable.add( aggregateDecl );
+    }
     void Indexer::visit( EnumDecl *aggregateDecl ) {
+        }
+        void Indexer::visit( EnumDecl *aggregateDecl ) {
                 debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl );
                 enumTable.add( aggregateDecl );
                 // unlike structs, contexts, and unions, enums inject their members into the global scope
                 acceptAll( aggregateDecl->get_members(), *this );
+    }
     void Indexer::visit( ContextDecl *aggregateDecl ) {
+        }
+        void Indexer::visit( ContextDecl *aggregateDecl ) {
                 enterScope();
                 acceptAll( aggregateDecl->get_parameters(), *this );
 …
                 debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl );
                 contextTable.add( aggregateDecl );
+    }
     void Indexer::visit( CompoundStmt *compoundStmt ) {
+        }
+        void Indexer::visit( CompoundStmt *compoundStmt ) {
                 enterScope();
                 acceptAll( compoundStmt->get_kids(), *this );
                 leaveScope();
+    }
     void Indexer::visit( ContextInstType *contextInst ) {
+        }
+        void Indexer::visit( ContextInstType *contextInst ) {
                 acceptAll( contextInst->get_parameters(), *this );
                 acceptAll( contextInst->get_members(), *this );
+    }
     void Indexer::visit( StructInstType *structInst ) {
+        }
+        void Indexer::visit( StructInstType *structInst ) {
                 if ( ! structTable.lookup( structInst->get_name() ) ) {
                         debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl );
 …
                 acceptAll( structInst->get_parameters(), *this );
                 leaveScope();
+    }
     void Indexer::visit( UnionInstType *unionInst ) {
+        }
+        void Indexer::visit( UnionInstType *unionInst ) {
                 if ( ! unionTable.lookup( unionInst->get_name() ) ) {
                         debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl );
 …
                 acceptAll( unionInst->get_parameters(), *this );
                 leaveScope();
+    }
     void Indexer::visit( ForStmt *forStmt ) {
         // for statements introduce a level of scope
         enterScope();
         Visitor::visit( forStmt );
         leaveScope();
+    }
     void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &list ) const {
+        }
+        void Indexer::visit( ForStmt *forStmt ) {
+            // for statements introduce a level of scope
+            enterScope();
+            Visitor::visit( forStmt );
+            leaveScope();
+        }
+        void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &list ) const {
                 idTable.lookupId( id, list );
+    }
     DeclarationWithType* Indexer::lookupId( const std::string &id) const {
+        }
+        DeclarationWithType* Indexer::lookupId( const std::string &id) const {
                 return idTable.lookupId(id);
+    }
     NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
+        }
+        NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
                 return typeTable.lookup( id );
+    }
     StructDecl *Indexer::lookupStruct( const std::string &id ) const {
+        }
+        StructDecl *Indexer::lookupStruct( const std::string &id ) const {
                 return structTable.lookup( id );
+    }
     EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
+        }
+        EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
                 return enumTable.lookup( id );
+    }
     UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
+        }
+        UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
                 return unionTable.lookup( id );
+    }
     ContextDecl  * Indexer::lookupContext( const std::string &id ) const {
+        }
+        ContextDecl  * Indexer::lookupContext( const std::string &id ) const {
                 return contextTable.lookup( id );
+    }
     void Indexer::enterScope() {
+        }
+        void Indexer::enterScope() {
                 if ( doDebug ) {
                         std::cout << "--- Entering scope" << std::endl;
 …
                 unionTable.enterScope();
                 contextTable.enterScope();
+    }
     void Indexer::leaveScope() {
+        }
+        void Indexer::leaveScope() {
                 using std::cout;
                 using std::endl;
 …
                 unionTable.leaveScope();
                 contextTable.leaveScope();
+    }
     void Indexer::print( std::ostream &os, int indent ) const {
         using std::cerr;
         using std::endl;
         cerr << "===idTable===" << endl;
         idTable.dump( os );
         cerr << "===typeTable===" << endl;
         typeTable.dump( os );
         cerr << "===structTable===" << endl;
         structTable.dump( os );
         cerr << "===enumTable===" << endl;
         enumTable.dump( os );
         cerr << "===unionTable===" << endl;
         unionTable.dump( os );
         cerr << "===contextTable===" << endl;
         contextTable.dump( os );
+        }
+        void Indexer::print( std::ostream &os, int indent ) const {
+            using std::cerr;
+            using std::endl;
+            cerr << "===idTable===" << endl;
+            idTable.dump( os );
+            cerr << "===typeTable===" << endl;
+            typeTable.dump( os );
+            cerr << "===structTable===" << endl;
+            structTable.dump( os );
+            cerr << "===enumTable===" << endl;
+            enumTable.dump( os );
+            cerr << "===unionTable===" << endl;
+            unionTable.dump( os );
+            cerr << "===contextTable===" << endl;
+            contextTable.dump( os );
 #if 0
                 idTable.dump( os );
 …
                 contextTable.dump( os );
 #endif
+    }
+        }
 } // namespace SymTab

translator/SymTab/Indexer.h

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 21:38:55 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 21:40:17 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 16:51:21 2015
+// Update Count     : 3
 //
 …
 namespace SymTab {
     class Indexer : public Visitor {
       public:
         Indexer( bool useDebug = false );
         virtual ~Indexer();
+        class Indexer : public Visitor {
+          public:
+                Indexer( bool useDebug = false );
+                virtual ~Indexer();
         //using Visitor::visit;
         virtual void visit( ObjectDecl *objectDecl );
         virtual void visit( FunctionDecl *functionDecl );
         virtual void visit( TypeDecl *typeDecl );
         virtual void visit( TypedefDecl *typeDecl );
         virtual void visit( StructDecl *aggregateDecl );
         virtual void visit( UnionDecl *aggregateDecl );
         virtual void visit( EnumDecl *aggregateDecl );
         virtual void visit( ContextDecl *aggregateDecl );
+                //using Visitor::visit;
+                virtual void visit( ObjectDecl *objectDecl );
+                virtual void visit( FunctionDecl *functionDecl );
+                virtual void visit( TypeDecl *typeDecl );
+                virtual void visit( TypedefDecl *typeDecl );
+                virtual void visit( StructDecl *aggregateDecl );
+                virtual void visit( UnionDecl *aggregateDecl );
+                virtual void visit( EnumDecl *aggregateDecl );
+                virtual void visit( ContextDecl *aggregateDecl );
         virtual void visit( CompoundStmt *compoundStmt );
+                virtual void visit( CompoundStmt *compoundStmt );
         virtual void visit( ContextInstType *contextInst );
         virtual void visit( StructInstType *contextInst );
         virtual void visit( UnionInstType *contextInst );
+                virtual void visit( ContextInstType *contextInst );
+                virtual void visit( StructInstType *contextInst );
+                virtual void visit( UnionInstType *contextInst );
         virtual void visit( ForStmt *forStmt );
+                virtual void visit( ForStmt *forStmt );
         // when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer
         // explicitly when scopes begin and end
         void enterScope();
         void leaveScope();
+                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer
+                // explicitly when scopes begin and end
+                void enterScope();
+                void leaveScope();
         void lookupId( const std::string &id, std::list< DeclarationWithType* >& ) const;
         DeclarationWithType* lookupId( const std::string &id) const;
         NamedTypeDecl *lookupType( const std::string &id ) const;
         StructDecl *lookupStruct( const std::string &id ) const;
         EnumDecl *lookupEnum( const std::string &id ) const;
         UnionDecl *lookupUnion( const std::string &id ) const;
         ContextDecl *lookupContext( const std::string &id ) const;
+                void lookupId( const std::string &id, std::list< DeclarationWithType* >& ) const;
+                DeclarationWithType* lookupId( const std::string &id) const;
+                NamedTypeDecl *lookupType( const std::string &id ) const;
+                StructDecl *lookupStruct( const std::string &id ) const;
+                EnumDecl *lookupEnum( const std::string &id ) const;
+                UnionDecl *lookupUnion( const std::string &id ) const;
+                ContextDecl *lookupContext( const std::string &id ) const;
         void print( std::ostream &os, int indent = 0 ) const;
       private:
         IdTable idTable;
         TypeTable typeTable;
         StructTable structTable;
         EnumTable enumTable;
         UnionTable unionTable;
         ContextTable contextTable;
+                void print( std::ostream &os, int indent = 0 ) const;
+          private:
+                IdTable idTable;
+                TypeTable typeTable;
+                StructTable structTable;
+                EnumTable enumTable;
+                UnionTable unionTable;
+                ContextTable contextTable;
         bool doDebug;                                   // display debugging trace
     };
+                bool doDebug;                                   // display debugging trace
+        };
 } // namespace SymTab

translator/SymTab/Mangler.cc

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 21:40:29 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 21:43:49 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 16:50:47 2015
+// Update Count     : 3
 //
 …
 namespace SymTab {
     Mangler::Mangler() : nextVarNum( 0 ), isTopLevel( true ) {
+        Mangler::Mangler() : nextVarNum( 0 ), isTopLevel( true ) {
+        }
 …
 //{
 //}
     Mangler::Mangler( const Mangler &rhs ) : mangleName() {
+        Mangler::Mangler( const Mangler &rhs ) : mangleName() {
                 varNums = rhs.varNums;
                 nextVarNum = rhs.nextVarNum;
                 isTopLevel = rhs.isTopLevel;
+    }
     void Mangler::mangleDecl( DeclarationWithType *declaration ) {
+        }
+        void Mangler::mangleDecl( DeclarationWithType *declaration ) {
                 bool wasTopLevel = isTopLevel;
                 if ( isTopLevel ) {
 …
                 maybeAccept( declaration->get_type(), *this );
                 isTopLevel = wasTopLevel;
+    }
     void Mangler::visit( ObjectDecl *declaration ) {
+        }
+        void Mangler::visit( ObjectDecl *declaration ) {
                 mangleDecl( declaration );
+    }
     void Mangler::visit( FunctionDecl *declaration ) {
+        }
+        void Mangler::visit( FunctionDecl *declaration ) {
                 mangleDecl( declaration );
+    }
     void Mangler::visit( VoidType *voidType ) {
+        }
+        void Mangler::visit( VoidType *voidType ) {
                 printQualifiers( voidType );
                 mangleName << "v";
+    }
     void Mangler::visit( BasicType *basicType ) {
+        }
+        void Mangler::visit( BasicType *basicType ) {
                 static const char *btLetter[] = {
                         "b",    // Bool
 …
                 printQualifiers( basicType );
                 mangleName << btLetter[ basicType->get_kind() ];
+    }
     void Mangler::visit( PointerType *pointerType ) {
+        }
+        void Mangler::visit( PointerType *pointerType ) {
                 printQualifiers( pointerType );
                 mangleName << "P";
                 maybeAccept( pointerType->get_base(), *this );
+    }
     void Mangler::visit( ArrayType *arrayType ) {
+        }
+        void Mangler::visit( ArrayType *arrayType ) {
                 // TODO: encode dimension
                 printQualifiers( arrayType );
                 mangleName << "A0";
                 maybeAccept( arrayType->get_base(), *this );
+    }
     namespace {
+        }
+        namespace {
                 inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
                         std::list< Type* > ret;
 …
                         return ret;
+                }
+    }
     void Mangler::visit( FunctionType *functionType ) {
+        }
+        void Mangler::visit( FunctionType *functionType ) {
                 printQualifiers( functionType );
                 mangleName << "F";
 …
                 acceptAll( paramTypes, *this );
                 mangleName << "_";
+    }
     void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
+        }
+        void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
                 printQualifiers( refType );
                 mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
+    }
     void Mangler::visit( StructInstType *aggregateUseType ) {
+        }
+        void Mangler::visit( StructInstType *aggregateUseType ) {
                 mangleRef( aggregateUseType, "s" );
+    }
     void Mangler::visit( UnionInstType *aggregateUseType ) {
+        }
+        void Mangler::visit( UnionInstType *aggregateUseType ) {
                 mangleRef( aggregateUseType, "u" );
+    }
     void Mangler::visit( EnumInstType *aggregateUseType ) {
+        }
+        void Mangler::visit( EnumInstType *aggregateUseType ) {
                 mangleRef( aggregateUseType, "e" );
+    }
     void Mangler::visit( TypeInstType *typeInst ) {
+        }
+        void Mangler::visit( TypeInstType *typeInst ) {
                 VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
                 if ( varNum == varNums.end() ) {
 …
                         mangleName << std::string( numStream.str(), numStream.pcount() );
                 } // if
+    }
     void Mangler::visit( TupleType *tupleType ) {
+        }
+        void Mangler::visit( TupleType *tupleType ) {
                 printQualifiers( tupleType );
                 mangleName << "T";
                 acceptAll( tupleType->get_types(), *this );
                 mangleName << "_";
+    }
     void Mangler::visit( TypeDecl *decl ) {
+        }
+        void Mangler::visit( TypeDecl *decl ) {
                 static const char *typePrefix[] = { "BT", "BD", "BF" };
                 mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
+    }
     void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
+        }
+        void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
                 for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
                         os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
                 } // for
+    }
     void Mangler::printQualifiers( Type *type ) {
+        }
+        void Mangler::printQualifiers( Type *type ) {
                 if ( ! type->get_forall().empty() ) {
                         std::list< std::string > assertionNames;
 …
                         mangleName << "A";
                 } // if
+    }
+        }
 } // namespace SymTab

translator/SymTab/Mangler.h

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 21:44:03 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 21:45:05 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 16:49:21 2015
+// Update Count     : 3
 //
 …
 namespace SymTab {
     class Mangler : public Visitor {
       public:
+        class Mangler : public Visitor {
+          public:
                 template< typename SynTreeClass >
             static std::string mangle( SynTreeClass *decl ); // interface to clients
 …
                 std::string get_mangleName() { return std::string( mangleName.str(), mangleName.pcount() ); }
       private:
+          private:
                 std::ostrstream mangleName;
                 typedef std::map< std::string, std::pair< int, int > > VarMapType;
 …
                 void printQualifiers( Type *type );
     }; // Mangler
+        }; // Mangler
     template< typename SynTreeClass >
     std::string Mangler::mangle( SynTreeClass *decl ) {
+        template< typename SynTreeClass >
+        std::string Mangler::mangle( SynTreeClass *decl ) {
                 Mangler mangler;
                 maybeAccept( decl, mangler );
                 return mangler.get_mangleName();
+    }
+        }
 } // SymTab

translator/SymTab/StackTable.cc

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 21:45:15 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 21:46:59 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 16:51:53 2015
+// Update Count     : 3
 //
 …
 namespace SymTab {
     template< typename Element, typename ConflictFunction >
     StackTable< Element, ConflictFunction >::StackTable() : scopeLevel( 0 ) {
+        template< typename Element, typename ConflictFunction >
+        StackTable< Element, ConflictFunction >::StackTable() : scopeLevel( 0 ) {
+        }
     template< typename Element, typename ConflictFunction >
     void StackTable< Element, ConflictFunction >::enterScope() {
+        template< typename Element, typename ConflictFunction >
+        void StackTable< Element, ConflictFunction >::enterScope() {
                 scopeLevel++;
+    }
+        }
     template< typename Element, typename ConflictFunction >
     void StackTable< Element, ConflictFunction >::leaveScope() {
+        template< typename Element, typename ConflictFunction >
+        void StackTable< Element, ConflictFunction >::leaveScope() {
                 for ( typename TableType::iterator it = table.begin(); it != table.end(); ++it ) {
                         std::stack< Entry >& entry = it->second;
 …
                 scopeLevel--;
                 assert( scopeLevel >= 0 );
+    }
+        }
     template< typename Element, typename ConflictFunction >
     void StackTable< Element, ConflictFunction >::add( Element *type ) {
+        template< typename Element, typename ConflictFunction >
+        void StackTable< Element, ConflictFunction >::add( Element *type ) {
                 std::stack< Entry >& entry = table[ type->get_name() ];
                 if ( ! entry.empty() && entry.top().second == scopeLevel ) {
 …
                         entry.push( Entry( type, scopeLevel ) );
                 } // if
+    }
+        }
     template< typename Element, typename ConflictFunction >
     void StackTable< Element, ConflictFunction >::add( std::string fwdDeclName ) {
+        template< typename Element, typename ConflictFunction >
+        void StackTable< Element, ConflictFunction >::add( std::string fwdDeclName ) {
                 add( new Element( fwdDeclName ) );
+    }
+        }
     template< typename Element, typename ConflictFunction >
     Element *StackTable< Element, ConflictFunction >::lookup( std::string id ) const {
+        template< typename Element, typename ConflictFunction >
+        Element *StackTable< Element, ConflictFunction >::lookup( std::string id ) const {
                 typename TableType::const_iterator it = table.find( id );
                 if ( it == table.end() ) {
 …
                         return 0;
                 } // if
+    }
+        }
     template< typename Element, typename ConflictFunction >
     void StackTable< Element, ConflictFunction >::dump( std::ostream &os ) const {
+        template< typename Element, typename ConflictFunction >
+        void StackTable< Element, ConflictFunction >::dump( std::ostream &os ) const {
                 for ( typename TableType::const_iterator it = table.begin(); it != table.end(); ++it ) {
                         const std::stack< Entry >& entry = it->second;
 …
                         } // if
                 } // for
+    }
+        }
 } // namespace SymTab

translator/SymTab/StackTable.h

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 21:47:10 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 21:48:15 2015
 // Update Count     : 3
+// Last Modified On : Tue May 19 16:50:36 2015
+// Update Count     : 4
 //
 …
 namespace SymTab {
     template< typename Element, typename ConflictFunction >
+        template< typename Element, typename ConflictFunction >
         class StackTable {
       public:
+          public:
                 StackTable();
 …
                 void dump( std::ostream &os ) const;                    // debugging
       private:
+          private:
                 typedef std::pair< Element*, int > Entry;
                 typedef std::map< std::string, std::stack< Entry > > TableType;
 …
                 TableType table;
                 int scopeLevel;
     };
+        };
 } // SymTab

translator/SymTab/TypeTable.h

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 21:48:32 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 21:49:49 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 16:50:25 2015
+// Update Count     : 3
 //
 …
 namespace SymTab {
     class TypeTableConflictFunction : public std::binary_function< NamedTypeDecl *, NamedTypeDecl *, NamedTypeDecl * > {
       public:
+        class TypeTableConflictFunction : public std::binary_function< NamedTypeDecl *, NamedTypeDecl *, NamedTypeDecl * > {
+          public:
                 NamedTypeDecl *operator()( NamedTypeDecl *existing, NamedTypeDecl *added ) {
                         if ( existing->get_base() == 0 ) {
 …
                         return 0;
+                }
     };
+        };
     typedef StackTable< NamedTypeDecl, TypeTableConflictFunction > TypeTable;
+        typedef StackTable< NamedTypeDecl, TypeTableConflictFunction > TypeTable;
 } // namespace SymTab

translator/SymTab/Validate.cc

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 21:53:16 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 16:50:09 2015
+// Update Count     : 3
 //
 …
 namespace SymTab {
     class HoistStruct : public Visitor {
       public:
+        class HoistStruct : public Visitor {
+          public:
                 static void hoistStruct( std::list< Declaration * > &translationUnit );
 …
                 virtual void visit( CaseStmt *caseStmt );
                 virtual void visit( CatchStmt *catchStmt );
       private:
+          private:
                 HoistStruct();
 …
                 std::list< Declaration * > declsToAdd;
                 bool inStruct;
     };
     class Pass1 : public Visitor {
+        };
+        class Pass1 : public Visitor {
                 typedef Visitor Parent;
                 virtual void visit( EnumDecl *aggregateDecl );
                 virtual void visit( FunctionType *func );
     };
     class Pass2 : public Indexer {
+        };
+        class Pass2 : public Indexer {
                 typedef Indexer Parent;
       public:
+          public:
                 Pass2( bool doDebug, const Indexer *indexer );
       private:
+          private:
                 virtual void visit( StructInstType *structInst );
                 virtual void visit( UnionInstType *unionInst );
 …
                 ForwardStructsType forwardStructs;
                 ForwardUnionsType forwardUnions;
     };
     class Pass3 : public Indexer {
+        };
+        class Pass3 : public Indexer {
                 typedef Indexer Parent;
       public:
+          public:
                 Pass3( const Indexer *indexer );
       private:
+          private:
                 virtual void visit( ObjectDecl *object );
                 virtual void visit( FunctionDecl *func );
                 const Indexer *indexer;
     };
     class AddStructAssignment : public Visitor {
       public:
+        };
+        class AddStructAssignment : public Visitor {
+          public:
                 static void addStructAssignment( std::list< Declaration * > &translationUnit );
 …
                 AddStructAssignment() : functionNesting( 0 ) {}
       private:
+          private:
                 template< typename StmtClass > void visitStatement( StmtClass *stmt );
 …
                 std::set< std::string > structsDone;
                 unsigned int functionNesting;                   // current level of nested functions
     };
     class EliminateTypedef : public Mutator {
       public:
+        };
+        class EliminateTypedef : public Mutator {
+          public:
                 static void eliminateTypedef( std::list< Declaration * > &translationUnit );
       private:
+          private:
                 virtual Declaration *mutate( TypedefDecl *typeDecl );
                 virtual TypeDecl *mutate( TypeDecl *typeDecl );
 …
                 std::map< std::string, TypedefDecl * > typedefNames;
     };
     void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
+        };
+        void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 Pass1 pass1;
                 Pass2 pass2( doDebug, 0 );
 …
                 AddStructAssignment::addStructAssignment( translationUnit );
                 acceptAll( translationUnit, pass3 );
+    }
     void validateType( Type *type, const Indexer *indexer ) {
+        }
+        void validateType( Type *type, const Indexer *indexer ) {
                 Pass1 pass1;
                 Pass2 pass2( false, indexer );
 …
                 type->accept( pass2 );
                 type->accept( pass3 );
+    }
     template< typename Visitor >
     void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor, bool addBefore ) {
+        }
+        template< typename Visitor >
+        void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor, bool addBefore ) {
                 std::list< Declaration * >::iterator i = translationUnit.begin();
                 while ( i != translationUnit.end() ) {
 …
                         i = next;
                 } // while
+    }
     void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
+        }
+        void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
                 HoistStruct hoister;
                 acceptAndAdd( translationUnit, hoister, true );
+    }
     HoistStruct::HoistStruct() : inStruct( false ) {
+    }
     void filter( std::list< Declaration * > &declList, bool (*pred)( Declaration * ), bool doDelete ) {
+        }
+        HoistStruct::HoistStruct() : inStruct( false ) {
+        }
+        void filter( std::list< Declaration * > &declList, bool (*pred)( Declaration * ), bool doDelete ) {
                 std::list< Declaration * >::iterator i = declList.begin();
                 while ( i != declList.end() ) {
 …
                         i = next;
                 } // while
+    }
     bool isStructOrUnion( Declaration *decl ) {
+        }
+        bool isStructOrUnion( Declaration *decl ) {
                 return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl );
+    }
     template< typename AggDecl >
     void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
+        }
+        template< typename AggDecl >
+        void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
                 if ( inStruct ) {
                         // Add elements in stack order corresponding to nesting structure.
 …
                 // Always remove the hoisted aggregate from the inner structure.
                 filter( aggregateDecl->get_members(), isStructOrUnion, false );
+    }
     void HoistStruct::visit( StructDecl *aggregateDecl ) {
+        }
+        void HoistStruct::visit( StructDecl *aggregateDecl ) {
                 handleAggregate( aggregateDecl );
+    }
     void HoistStruct::visit( UnionDecl *aggregateDecl ) {
+        }
+        void HoistStruct::visit( UnionDecl *aggregateDecl ) {
                 handleAggregate( aggregateDecl );
+    }
     void HoistStruct::visit( CompoundStmt *compoundStmt ) {
+        }
+        void HoistStruct::visit( CompoundStmt *compoundStmt ) {
                 addVisit( compoundStmt, *this );
+    }
     void HoistStruct::visit( IfStmt *ifStmt ) {
+        }
+        void HoistStruct::visit( IfStmt *ifStmt ) {
                 addVisit( ifStmt, *this );
+    }
     void HoistStruct::visit( WhileStmt *whileStmt ) {
+        }
+        void HoistStruct::visit( WhileStmt *whileStmt ) {
                 addVisit( whileStmt, *this );
+    }
     void HoistStruct::visit( ForStmt *forStmt ) {
+        }
+        void HoistStruct::visit( ForStmt *forStmt ) {
                 addVisit( forStmt, *this );
+    }
     void HoistStruct::visit( SwitchStmt *switchStmt ) {
+        }
+        void HoistStruct::visit( SwitchStmt *switchStmt ) {
                 addVisit( switchStmt, *this );
+    }
     void HoistStruct::visit( ChooseStmt *switchStmt ) {
+        }
+        void HoistStruct::visit( ChooseStmt *switchStmt ) {
                 addVisit( switchStmt, *this );
+    }
     void HoistStruct::visit( CaseStmt *caseStmt ) {
+        }
+        void HoistStruct::visit( CaseStmt *caseStmt ) {
                 addVisit( caseStmt, *this );
+    }
     void HoistStruct::visit( CatchStmt *cathStmt ) {
+        }
+        void HoistStruct::visit( CatchStmt *cathStmt ) {
                 addVisit( cathStmt, *this );
+    }
     void Pass1::visit( EnumDecl *enumDecl ) {
+        }
+        void Pass1::visit( EnumDecl *enumDecl ) {
                 // Set the type of each member of the enumeration to be EnumConstant
 …
                 } // for
                 Parent::visit( enumDecl );
+    }
     namespace {
+        }
+        namespace {
                 template< typename DWTIterator >
                 void fixFunctionList( DWTIterator begin, DWTIterator end, FunctionType *func ) {
 …
                         } // if
+                }
+    }
     void Pass1::visit( FunctionType *func ) {
+        }
+        void Pass1::visit( FunctionType *func ) {
                 // Fix up parameters and return types
                 fixFunctionList( func->get_parameters().begin(), func->get_parameters().end(), func );
                 fixFunctionList( func->get_returnVals().begin(), func->get_returnVals().end(), func );
                 Visitor::visit( func );
+    }
     Pass2::Pass2( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
+        }
+        Pass2::Pass2( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
                 if ( other_indexer ) {
                         indexer = other_indexer;
 …
                         indexer = this;
                 } // if
+    }
     void Pass2::visit( StructInstType *structInst ) {
+        }
+        void Pass2::visit( StructInstType *structInst ) {
                 Parent::visit( structInst );
                 StructDecl *st = indexer->lookupStruct( structInst->get_name() );
 …
                         forwardStructs[ structInst->get_name() ].push_back( structInst );
                 } // if
+    }
     void Pass2::visit( UnionInstType *unionInst ) {
+        }
+        void Pass2::visit( UnionInstType *unionInst ) {
                 Parent::visit( unionInst );
                 UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
 …
                         forwardUnions[ unionInst->get_name() ].push_back( unionInst );
                 } // if
+    }
     void Pass2::visit( ContextInstType *contextInst ) {
+        }
+        void Pass2::visit( ContextInstType *contextInst ) {
                 Parent::visit( contextInst );
                 ContextDecl *ctx = indexer->lookupContext( contextInst->get_name() );
 …
                 } // for
                 applySubstitution( ctx->get_parameters().begin(), ctx->get_parameters().end(), contextInst->get_parameters().begin(), ctx->get_members().begin(), ctx->get_members().end(), back_inserter( contextInst->get_members() ) );
+    }
     void Pass2::visit( StructDecl *structDecl ) {
+        }
+        void Pass2::visit( StructDecl *structDecl ) {
                 if ( ! structDecl->get_members().empty() ) {
                         ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
 …
                 } // if
                 Indexer::visit( structDecl );
+    }
     void Pass2::visit( UnionDecl *unionDecl ) {
+        }
+        void Pass2::visit( UnionDecl *unionDecl ) {
                 if ( ! unionDecl->get_members().empty() ) {
                         ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
 …
                 } // if
                 Indexer::visit( unionDecl );
+    }
     void Pass2::visit( TypeInstType *typeInst ) {
+        }
+        void Pass2::visit( TypeInstType *typeInst ) {
                 if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
                         if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
 …
                         } // if
                 } // if
+    }
     Pass3::Pass3( const Indexer *other_indexer ) :  Indexer( false ) {
+        }
+        Pass3::Pass3( const Indexer *other_indexer ) :  Indexer( false ) {
                 if ( other_indexer ) {
                         indexer = other_indexer;
 …
                         indexer = this;
                 } // if
+    }
     void forallFixer( Type *func ) {
+        }
+        void forallFixer( Type *func ) {
                 // Fix up assertions
                 for ( std::list< TypeDecl * >::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
 …
                         } // while
                 } // for
+    }
     void Pass3::visit( ObjectDecl *object ) {
+        }
+        void Pass3::visit( ObjectDecl *object ) {
                 forallFixer( object->get_type() );
                 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
 …
                 Parent::visit( object );
                 object->fixUniqueId();
+    }
     void Pass3::visit( FunctionDecl *func ) {
+        }
+        void Pass3::visit( FunctionDecl *func ) {
                 forallFixer( func->get_type() );
                 Parent::visit( func );
                 func->fixUniqueId();
+    }
     static const std::list< std::string > noLabels;
     void AddStructAssignment::addStructAssignment( std::list< Declaration * > &translationUnit ) {
+        }
+        static const std::list< std::string > noLabels;
+        void AddStructAssignment::addStructAssignment( std::list< Declaration * > &translationUnit ) {
                 AddStructAssignment visitor;
                 acceptAndAdd( translationUnit, visitor, false );
+    }
     template< typename OutputIterator >
     void makeScalarAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, OutputIterator out ) {
+        }
+        template< typename OutputIterator >
+        void makeScalarAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, OutputIterator out ) {
                 ObjectDecl *obj = dynamic_cast<ObjectDecl *>( member );
                 // unnamed bit fields are not copied as they cannot be accessed
 …
                 *out++ = new ExprStmt( noLabels, assignExpr );
+    }
     template< typename OutputIterator >
     void makeArrayAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, ArrayType *array, OutputIterator out ) {
+        }
+        template< typename OutputIterator >
+        void makeArrayAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, ArrayType *array, OutputIterator out ) {
                 static UniqueName indexName( "_index" );
 …
                 *out++ = new ForStmt( noLabels, initStmt, cond, inc, new ExprStmt( noLabels, assignExpr ) );
+    }
     Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
+        }
+        Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
                 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
 …
                 return assignDecl;
+    }
     Declaration *makeUnionAssignment( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting ) {
+        }
+        Declaration *makeUnionAssignment( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting ) {
                 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
 …
                 return assignDecl;
+    }
     void AddStructAssignment::visit( StructDecl *structDecl ) {
+        }
+        void AddStructAssignment::visit( StructDecl *structDecl ) {
                 if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
                         StructInstType *structInst = new StructInstType( Type::Qualifiers(), structDecl->get_name() );
 …
                         structsDone.insert( structDecl->get_name() );
                 } // if
+    }
     void AddStructAssignment::visit( UnionDecl *unionDecl ) {
+        }
+        void AddStructAssignment::visit( UnionDecl *unionDecl ) {
                 if ( ! unionDecl->get_members().empty() ) {
                         UnionInstType *unionInst = new UnionInstType( Type::Qualifiers(), unionDecl->get_name() );
 …
                         declsToAdd.push_back( makeUnionAssignment( unionDecl, unionInst, functionNesting ) );
                 } // if
+    }
     void AddStructAssignment::visit( TypeDecl *typeDecl ) {
+        }
+        void AddStructAssignment::visit( TypeDecl *typeDecl ) {
                 CompoundStmt *stmts = 0;
                 TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
 …
                 FunctionDecl *func = new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::AutoGen, type, stmts, false );
                 declsToAdd.push_back( func );
+    }
     void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
+        }
+        void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
                 if ( ! declsToAdd.empty() ) {
                         for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
 …
                         declsToAdd.clear();
                 } // if
+    }
     void AddStructAssignment::visit( FunctionType *) {
+        }
+        void AddStructAssignment::visit( FunctionType *) {
                 // ensure that we don't add assignment ops for types defined as part of the function
+    }
     void AddStructAssignment::visit( PointerType *) {
+        }
+        void AddStructAssignment::visit( PointerType *) {
                 // ensure that we don't add assignment ops for types defined as part of the pointer
+    }
     void AddStructAssignment::visit( ContextDecl *) {
+        }
+        void AddStructAssignment::visit( ContextDecl *) {
                 // ensure that we don't add assignment ops for types defined as part of the context
+    }
     template< typename StmtClass >
     inline void AddStructAssignment::visitStatement( StmtClass *stmt ) {
+        }
+        template< typename StmtClass >
+        inline void AddStructAssignment::visitStatement( StmtClass *stmt ) {
                 std::set< std::string > oldStructs = structsDone;
                 addVisit( stmt, *this );
                 structsDone = oldStructs;
+    }
     void AddStructAssignment::visit( FunctionDecl *functionDecl ) {
+        }
+        void AddStructAssignment::visit( FunctionDecl *functionDecl ) {
                 maybeAccept( functionDecl->get_functionType(), *this );
                 acceptAll( functionDecl->get_oldDecls(), *this );
 …
                 maybeAccept( functionDecl->get_statements(), *this );
                 functionNesting -= 1;
+    }
     void AddStructAssignment::visit( CompoundStmt *compoundStmt ) {
+        }
+        void AddStructAssignment::visit( CompoundStmt *compoundStmt ) {
                 visitStatement( compoundStmt );
+    }
     void AddStructAssignment::visit( IfStmt *ifStmt ) {
+        }
+        void AddStructAssignment::visit( IfStmt *ifStmt ) {
                 visitStatement( ifStmt );
+    }
     void AddStructAssignment::visit( WhileStmt *whileStmt ) {
+        }
+        void AddStructAssignment::visit( WhileStmt *whileStmt ) {
                 visitStatement( whileStmt );
+    }
     void AddStructAssignment::visit( ForStmt *forStmt ) {
+        }
+        void AddStructAssignment::visit( ForStmt *forStmt ) {
                 visitStatement( forStmt );
+    }
     void AddStructAssignment::visit( SwitchStmt *switchStmt ) {
+        }
+        void AddStructAssignment::visit( SwitchStmt *switchStmt ) {
                 visitStatement( switchStmt );
+    }
     void AddStructAssignment::visit( ChooseStmt *switchStmt ) {
+        }
+        void AddStructAssignment::visit( ChooseStmt *switchStmt ) {
                 visitStatement( switchStmt );
+    }
     void AddStructAssignment::visit( CaseStmt *caseStmt ) {
+        }
+        void AddStructAssignment::visit( CaseStmt *caseStmt ) {
                 visitStatement( caseStmt );
+    }
     void AddStructAssignment::visit( CatchStmt *cathStmt ) {
+        }
+        void AddStructAssignment::visit( CatchStmt *cathStmt ) {
                 visitStatement( cathStmt );
+    }
     bool isTypedef( Declaration *decl ) {
+        }
+        bool isTypedef( Declaration *decl ) {
                 return dynamic_cast< TypedefDecl * >( decl );
+    }
     void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
+        }
+        void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
                 EliminateTypedef eliminator;
                 mutateAll( translationUnit, eliminator );
                 filter( translationUnit, isTypedef, true );
+    }
     Type *EliminateTypedef::mutate( TypeInstType *typeInst ) {
+        }
+        Type *EliminateTypedef::mutate( TypeInstType *typeInst ) {
                 std::map< std::string, TypedefDecl * >::const_iterator def = typedefNames.find( typeInst->get_name() );
                 if ( def != typedefNames.end() ) {
 …
                 } // if
                 return typeInst;
+    }
     Declaration *EliminateTypedef::mutate( TypedefDecl *tyDecl ) {
+        }
+        Declaration *EliminateTypedef::mutate( TypedefDecl *tyDecl ) {
                 Declaration *ret = Mutator::mutate( tyDecl );
                 typedefNames[ tyDecl->get_name() ] = tyDecl;
 …
                         return ret;
                 } // if
+    }
     TypeDecl *EliminateTypedef::mutate( TypeDecl *typeDecl ) {
+        }
+        TypeDecl *EliminateTypedef::mutate( TypeDecl *typeDecl ) {
                 std::map< std::string, TypedefDecl * >::iterator i = typedefNames.find( typeDecl->get_name() );
                 if ( i != typedefNames.end() ) {
 …
                 } // if
                 return typeDecl;
+    }
     DeclarationWithType *EliminateTypedef::mutate( FunctionDecl *funcDecl ) {
+        }
+        DeclarationWithType *EliminateTypedef::mutate( FunctionDecl *funcDecl ) {
                 std::map< std::string, TypedefDecl * > oldNames = typedefNames;
                 DeclarationWithType *ret = Mutator::mutate( funcDecl );
                 typedefNames = oldNames;
                 return ret;
+    }
     ObjectDecl *EliminateTypedef::mutate( ObjectDecl *objDecl ) {
+        }
+        ObjectDecl *EliminateTypedef::mutate( ObjectDecl *objDecl ) {
                 std::map< std::string, TypedefDecl * > oldNames = typedefNames;
                 ObjectDecl *ret = Mutator::mutate( objDecl );
                 typedefNames = oldNames;
                 return ret;
+    }
     Expression *EliminateTypedef::mutate( CastExpr *castExpr ) {
+        }
+        Expression *EliminateTypedef::mutate( CastExpr *castExpr ) {
                 std::map< std::string, TypedefDecl * > oldNames = typedefNames;
                 Expression *ret = Mutator::mutate( castExpr );
                 typedefNames = oldNames;
                 return ret;
+    }
     CompoundStmt *EliminateTypedef::mutate( CompoundStmt *compoundStmt ) {
+        }
+        CompoundStmt *EliminateTypedef::mutate( CompoundStmt *compoundStmt ) {
                 std::map< std::string, TypedefDecl * > oldNames = typedefNames;
                 CompoundStmt *ret = Mutator::mutate( compoundStmt );
 …
                 typedefNames = oldNames;
                 return ret;
+    }
+        }
 } // namespace SymTab

translator/SymTab/Validate.h

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 21:55:09 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 16:49:43 2015
+// Update Count     : 3
 //
 …
 namespace SymTab {
     class Indexer;
+        class Indexer;
     void validate( std::list< Declaration * > &translationUnit, bool doDebug = false );
     void validateType( Type *type, const Indexer *indexer );
+        void validate( std::list< Declaration * > &translationUnit, bool doDebug = false );
+        void validateType( Type *type, const Indexer *indexer );
 } // namespace SymTab

translator/SynTree/AddressExpr.cc

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 23:54:44 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May 18 07:48:14 2015
 // Update Count     : 5
+// Last Modified On : Tue May 19 16:52:51 2015
+// Update Count     : 6
 //
 …
 AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
     for ( std::list< Type* >::const_iterator i = arg->get_results().begin(); i != arg->get_results().end(); ++i ) {
+        for ( std::list< Type* >::const_iterator i = arg->get_results().begin(); i != arg->get_results().end(); ++i ) {
                 get_results().push_back( new PointerType( Type::Qualifiers(), (*i)->clone() ) );
     } // for
+        } // for
+}
 …
 AddressExpr::~AddressExpr() {
     delete arg;
+        delete arg;
+}
 void AddressExpr::print( std::ostream &os, int indent ) const {
     os << std::string( indent, ' ' ) << "Address of:" << std::endl;
     if ( arg ) {
+        os << std::string( indent, ' ' ) << "Address of:" << std::endl;
+        if ( arg ) {
                 arg->print( os, indent+2 );
     } // if
+        } // if
+}

translator/SynTree/AggregateDecl.cc

-                      r01aeade
+                      ra08ba92
 // Created On       : Sun May 17 23:56:39 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May 18 07:48:23 2015
 // Update Count     : 4
+// Last Modified On : Tue May 19 16:52:08 2015
+// Update Count     : 5
 //
 …
 AggregateDecl::AggregateDecl( const AggregateDecl &other ) : Parent( other ) {
     cloneAll( other.members, members );
     cloneAll( other.parameters, parameters );
+        cloneAll( other.members, members );
+        cloneAll( other.parameters, parameters );
+}
 AggregateDecl::~AggregateDecl() {
     deleteAll( members );
     deleteAll( parameters );
+        deleteAll( members );
+        deleteAll( parameters );
+}
 void AggregateDecl::print( std::ostream &os, int indent ) const {
     using std::string;
     using std::endl;
+        using std::string;
+        using std::endl;
     os << typeString() << " " << get_name();
     if ( ! parameters.empty() ) {
+        os << typeString() << " " << get_name();
+        if ( ! parameters.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+4 );
     } // if
     if ( ! members.empty() ) {
+        } // if
+        if ( ! members.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with members" << endl;
                 printAll( members, os, indent+4 );
     } // if
+        } // if
+}
 void AggregateDecl::printShort( std::ostream &os, int indent ) const {
     using std::string;
     using std::endl;
+        using std::string;
+        using std::endl;
     os << typeString() << " " << get_name();
     if ( ! parameters.empty() ) {
+        os << typeString() << " " << get_name();
+        if ( ! parameters.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+4 );
     } // if
+        } // if
+}

translator/SynTree/AttrType.cc

-                      r01aeade
+                      ra08ba92
 // file "LICENCE" distributed with Cforall.
 //
 // XXX.cc --
+// AttrType.cc.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May 18 07:53:48 2015
 // Update Count     : 1
+// Last Modified On : Tue May 19 16:41:51 2015
+// Update Count     : 2
 //

translator/SynTree/CodeGenVisitor.cc

-                      r01aeade
+                      ra08ba92
 using namespace std;
 void CodeGenVisitor::visit( Type *type ){ }
+void CodeGenVisitor::visit( Type *type ) { }
 void CodeGenVisitor::visit( BasicType *basicType ) { }
 …
+}
 void CodeGenVisitor::visit( Expression *expr ){ }
+void CodeGenVisitor::visit( Expression *expr ) { }
 void CodeGenVisitor::visit( ConstantExpr *cnst ) {

translator/SynTree/Expression.cc

r01aeade	ra08ba92
295	295	}
296	296
297		LogicalExpr::~LogicalExpr(){
	297	LogicalExpr::~LogicalExpr() {
298	298	delete arg1;
299	299	delete arg2;

translator/SynTree/ReferenceToType.cc

-                      r01aeade
+                      ra08ba92
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May 18 10:49:00 2015
 // Update Count     : 2
+// Last Modified On : Tue May 19 16:52:40 2015
+// Update Count     : 3
 //
 …
 ReferenceToType::ReferenceToType( const ReferenceToType &other ) : Type( other ), name( other.name ) {
     cloneAll( other.parameters, parameters );
+        cloneAll( other.parameters, parameters );
+}
 ReferenceToType::~ReferenceToType() {
     deleteAll( parameters );
+        deleteAll( parameters );
+}
 void ReferenceToType::print( std::ostream &os, int indent ) const {
     using std::endl;
     Type::print( os, indent );
     os << "instance of " << typeString() << " " << name << " ";
     if ( ! parameters.empty() ) {
+        using std::endl;
+        Type::print( os, indent );
+        os << "instance of " << typeString() << " " << name << " ";
+        if ( ! parameters.empty() ) {
                 os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+2 );
     } // if
+        } // if
+}
 …
 void StructInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {
     assert( baseStruct );
     doLookup( baseStruct->get_members(), baseStruct->get_parameters(), parameters, name, foundDecls );
+        assert( baseStruct );
+        doLookup( baseStruct->get_members(), baseStruct->get_parameters(), parameters, name, foundDecls );
+}
 …
 void UnionInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {
     assert( baseUnion );
     doLookup( baseUnion->get_members(), baseUnion->get_parameters(), parameters, name, foundDecls );
+        assert( baseUnion );
+        doLookup( baseUnion->get_members(), baseUnion->get_parameters(), parameters, name, foundDecls );
+}
 …
 ContextInstType::ContextInstType( const ContextInstType &other ) : Parent( other ) {
     cloneAll( other.members, members );
+        cloneAll( other.members, members );
+}
 ContextInstType::~ContextInstType() {
     deleteAll( members );
+        deleteAll( members );
+}
 TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType ) : Parent( tq, name ) {
     set_baseType( baseType );
+        set_baseType( baseType );
+}
 …
 void TypeInstType::set_baseType( TypeDecl *newValue ) {
     baseType = newValue;
     isFtype = newValue->get_kind() == TypeDecl::Ftype;
+        baseType = newValue;
+        isFtype = newValue->get_kind() == TypeDecl::Ftype;
+}
 …
 void TypeInstType::print( std::ostream &os, int indent ) const {
     using std::endl;
     Type::print( os, indent );
     os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " a function type) ";
     if ( ! parameters.empty() ) {
+        using std::endl;
+        Type::print( os, indent );
+        os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " a function type) ";
+        if ( ! parameters.empty() ) {
                 os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+2 );
     } // if
+        } // if
+}

translator/SynTree/Statement.cc

r01aeade	ra08ba92
58	58	}
59	59
60		void BranchStmt::print( std::ostream &os, int indent ){
	60	void BranchStmt::print( std::ostream &os, int indent ) {
61	61	os << "\r" << string( indent, ' ') << "Branch (" << brType[type] << ")" << endl ;
62	62	}
…	…
79	79	IfStmt::~IfStmt() {}
80	80
81		void IfStmt::print( std::ostream &os, int indent ){
	81	void IfStmt::print( std::ostream &os, int indent ) {
82	82	os << "\r" << string( indent, ' ') << "If on condition: " << endl ;
83	83	condition->print( os, indent + 4 );
…	…
175	175	}
176	176
177		WhileStmt::~WhileStmt(){
	177	WhileStmt::~WhileStmt() {
178	178	delete body;
179	179	}
180	180
181		void WhileStmt::print( std::ostream &os, int indent ){
	181	void WhileStmt::print( std::ostream &os, int indent ) {
182	182	os << "\r" << string( indent, ' ') << "While on condition: " << endl ;
183	183	condition->print( os, indent + 4 );
…	…
199	199	}
200	200
201		void ForStmt::print( std::ostream &os, int indent ){
	201	void ForStmt::print( std::ostream &os, int indent ) {
202	202	os << "\r" << string( indent, ' ') << "For Statement" << endl ;
203	203
…	…
231	231	}
232	232
233		TryStmt::~TryStmt(){
	233	TryStmt::~TryStmt() {
234	234	delete block;
235	235	}
…	…
257	257	}
258	258
259		CatchStmt::~CatchStmt(){
	259	CatchStmt::~CatchStmt() {
260	260	delete decl;
261	261	delete body;

translator/SynTree/Type.cc

-                      r01aeade
+                      ra08ba92
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May 18 11:00:29 2015
 // Update Count     : 1
+// Last Modified On : Tue May 19 16:52:27 2015
+// Update Count     : 2
 //
 …
 const char *BasicType::typeNames[BasicType::NUMBER_OF_BASIC_TYPES] = {
     "_Bool",
     "char",
     "char",
     "unsigned char",
     "short",
     "short unsigned",
     "int",
     "unsigned int",
     "long int",
     "long unsigned int",
     "long long int",
     "long long unsigned int",
     "float",
     "double",
     "long double",
     "float _Complex",
     "double _Complex",
     "long double _Complex",
     "float _Imaginary",
     "double _Imaginary",
     "long double _Imaginary",
+        "_Bool",
+        "char",
+        "char",
+        "unsigned char",
+        "short",
+        "short unsigned",
+        "int",
+        "unsigned int",
+        "long int",
+        "long unsigned int",
+        "long long int",
+        "long long unsigned int",
+        "float",
+        "double",
+        "long double",
+        "float _Complex",
+        "double _Complex",
+        "long double _Complex",
+        "float _Imaginary",
+        "double _Imaginary",
+        "long double _Imaginary",
 };
 …
 Type::Type( const Type &other ) : tq( other.tq ) {
     cloneAll( other.forall, forall );
+        cloneAll( other.forall, forall );
+}
 Type::~Type() {
     deleteAll( forall );
+        deleteAll( forall );
+}
 void Type::print( std::ostream &os, int indent ) const {
     if ( ! forall.empty() ) {
+        if ( ! forall.empty() ) {
                 os << "forall" << std::endl;
                 printAll( forall, os, indent + 4 );
                 os << std::string( indent+2, ' ' );
     } // if
     if ( tq.isConst ) {
+        } // if
+        if ( tq.isConst ) {
                 os << "const ";
     } // if
     if ( tq.isVolatile ) {
+        } // if
+        if ( tq.isVolatile ) {
                 os << "volatile ";
     } // if
     if ( tq.isRestrict ) {
+        } // if
+        if ( tq.isRestrict ) {
                 os << "restrict ";
     } // if
     if ( tq.isLvalue ) {
+        } // if
+        if ( tq.isLvalue ) {
                 os << "lvalue ";
     } // if
     if ( tq.isAtomic ) {
+        } // if
+        if ( tq.isAtomic ) {
                 os << "_Atomic ";
     } // if
+        } // if
+}

translator/SynTree/Visitor.cc

r01aeade	ra08ba92
111	111	}
112	112
113		void Visitor::visit( FallthruStmt *fallthruStmt ){}
	113	void Visitor::visit( FallthruStmt *fallthruStmt ) {}
114	114
115	115	void Visitor::visit( CaseStmt *caseStmt ) {

translator/Tests/Syntax/Expression.c

-                      r01aeade
+                      ra08ba92
     // order of evaluation (GCC is different)
 /*
     i = sizeof( (int){3} );
     i = sizeof (int){3};
+    i = sizeof( (int) {3} );
+    i = sizeof (int) {3};
 */
     // operators

translator/Tests/Syntax/Forall.c

r01aeade	ra08ba92
16	16
17	17	type T1 \| { const T1 0; T1 ?+?(T1, T1); T1 ?++(T1); [T1] ?+=?(T1,T1); },
18		T2(type P1, type P2 ) \| (type Q, type W){ const Q 0; W ?+?(W, W); Q ?++(W); [Q] ?+=?(W,W); }(T1,T2(T1,f)),
	18	T2(type P1, type P2 ) \| (type Q, type W) { const Q 0; W ?+?(W, W); Q ?++(W); [Q] ?+=?(W,W); }(T1,T2(T1,f)),
19	19	T3 \| sumable(T3);
20	20

translator/Tests/Syntax/Initialization.c

-                      r01aeade
+                      ra08ba92
 struct quintet { int v, w, x, y, z;};
 int foo(){
+int foo() {
   return 4;
+}
 int main(){
+int main() {
   foo();
   int i;

translator/Tests/gcc/900516-1.c

r01aeade	ra08ba92
1	1	/* added 'int' to argument */
2		f(int c){ return!(c?2.0:1.0); }
	2	f(int c) { return!(c?2.0:1.0); }

translator/Tests/gcc/920301-1.c

r01aeade	ra08ba92
1		f(){static voidt[];/={&&x};*/ x:y:;}
2		g(){static unsigned p[5];}
	1	f() {static voidt[];/={&&x};*/ x:y:;}
	2	g() {static unsigned p[5];}

translator/Tests/gcc/920409-1.c

r01aeade	ra08ba92
1		x(){int y;y>0.0?y:y-1;}
	1	x() {int y;y>0.0?y:y-1;}

translator/Tests/gcc/920409-2.c

r01aeade	ra08ba92
1		double x(){int x1,x2;double v;
	1	double x() {int x1,x2;double v;
2	2	if (((long)(x1-x2))<1)return -1.0;v=t(v);v=y(1,v>0.0?(int)v:((int)v-1));}

translator/Tests/gcc/920501-1.c

r01aeade	ra08ba92
1		a(){int**b[]={&&c};c:;}
	1	a() {int**b[]={&&c};c:;}

translator/Tests/gcc/920501-11.c

r01aeade	ra08ba92
1		typedef struct{int s;}S;foo()~~{int i=(int)&(S){(void*)((int)&(S)~~{1})};}
	1	typedef struct{int s;}S;foo() {int i=(int)&(S) {(void*)((int)&(S) {1})};}

translator/Tests/gcc/920501-19.c

r01aeade	ra08ba92
1		long long x=0;y(){x=0;}
	1	long long x=0;y() {x=0;}

translator/Tuples/AssignExpand.cc

-                      r01aeade
+                      ra08ba92
                 CompoundStmt *newSt = 0;
                 if (! extra.empty() ) {
+                if ( ! extra.empty() ) {
                         if ( ! newSt )
                                 newSt= new CompoundStmt(std::list<Label>());
 …
                    if ( tupleExpr->get_type() == SolvedTupleExpr::MASS ) {
                    // extract lhs of assignments, assert that rhs is the same, create temporaries
                    assert (! exprs.empty());
+                   assert ( ! exprs.empty());
                    ApplicationExpr *ap1 = dynamic_cast< ApplicationExpr * >( exprs.front() );
                    std::list<Expression *> &args = ap1->get_args();

translator/Tuples/MultRet.h

r01aeade	ra08ba92
37	37	CompoundStmt *getVars() const { return newVars; }
38	38
39		bool hasResults() const { return (! results.empty()); }
	39	bool hasResults() const { return ( ! results.empty()); }
40	40	std::list<Expression *> &get_results() { return results; }
41	41	private:

translator/Tuples/TupleAssignment.cc

-                      r01aeade
+                      ra08ba92
                 std::list< Expression * > new_assigns;
                 if (! matcher->match(new_assigns) )
+                if ( ! matcher->match(new_assigns) )
                         return false;
 …
                                                 if ( best.size() == 1 ) {
                                                         std::list<Expression *> solved_assigns;
                                                         for ( ResolvExpr::AltList::iterator i = best.front().begin(); i != best.front().end(); ++i ){
+                                                        for ( ResolvExpr::AltList::iterator i = best.front().begin(); i != best.front().end(); ++i ) {
                                                                 solved_assigns.push_back( i->expr );
+                                                        }
 …
+                                                }
                                         } else {
                                                 assert(! optMass.empty() );
+                                                assert( ! optMass.empty() );
                                                 ResolvExpr::AltList winners;
                                                 for ( std::vector< ResolvExpr::AltList >::iterator i = optMass.begin(); i != optMass.end(); ++i )
 …
         template< class InputIterator, class OutputIterator >
         void TupleAssignSpotter::Options::lift_intersection( InputIterator begin, InputIterator end, OutputIterator out ){
+        void TupleAssignSpotter::Options::lift_intersection( InputIterator begin, InputIterator end, OutputIterator out ) {
                 if ( begin == end ) return;
                 InputIterator test = begin;

Context Navigation

Legend:

Download in other formats: