Changeset 057b34f for src/ControlStruct/CaseRangeMutator.cc

Timestamp:

Jul 31, 2016, 12:41:25 AM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

08061589, c45170a

Parents:

3778cb2

Message:

more case range clean up

File:

• src/ControlStruct/CaseRangeMutator.cc (modified) (5 diffs)

src/ControlStruct/CaseRangeMutator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 28 01:56:47 2016
-// Update Count     : 14
+// Last Modified On : Sun Jul 31 00:14:16 2016
+// Update Count     : 29
 //
 
@@ -34 +34 @@
                 std::list< Statement * >::iterator i = cases.begin();
                 while ( i != cases.end() ) {
-                        (*i )->acceptMutator( *this );
+                        (*i)->acceptMutator( *this );
 
                         if ( ! newCaseLabels.empty() ) {
@@ -41 +41 @@
                                 // 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;
+                                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 ( CaseStmt *currentCase = dynamic_cast< CaseStmt * >( *i ) )
                                         if ( ! currentCase->get_statements().empty() ) {
-                                                CaseStmt *lastCase = dynamic_cast< CaseStmt * > ( newCases.back() );
+                                                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 );
+                                std::list< Statement * >::iterator j = i;
+                                advance( j, 1 );
+                                replace( cases, i, newCases );
                                 i = j;
                                 newCaseLabels.clear();
@@ -67 +67 @@
 
         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() == "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
+                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++ )
@@ -86 +74 @@
 
                 std::list< Statement * > &stmts = caseStmt->get_statements();
-                mutateAll ( stmts, *this );
+                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 ) {
-                        std::cout << ce_lo->get_constant()->get_value() << " " << ce_hi->get_constant()->get_value() << std::endl;
-                        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
-#if 0
-                switch ( ty_lo->get_kind() ) {
-                  case BasicType::Char:
-                  case BasicType::UnsignedChar:
-                        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
-#endif
-                /* End: */{ 
-                        // invalid range, signal a warning (it still generates the two case labels)
-//                      newCaseLabels.push_back( lo );
-//                      newCaseLabels.push_back( hi );
-                        return;
-                }
         }
 } // namespace ControlStruct