Changes in src/ControlStruct/CaseRangeMutator.cc [08061589:4e06c1e]

File:

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

src/ControlStruct/CaseRangeMutator.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : 
-// Last Modified On : Sun Jul 31 12:16:28 2016
-// Update Count     : 32
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Jul 12 17:35:13 2016
+// Update Count     : 9
 //
 
@@ -34 +34 @@
                 std::list< Statement * >::iterator i = cases.begin();
                 while ( i != cases.end() ) {
-                        (*i)->acceptMutator( *this );
+                        (*i )->acceptMutator( *this );
 
                         if ( ! newCaseLabels.empty() ) {
-                                std::cout << "FRED" << std::endl;
                                 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;
+                                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();
@@ -65 +64 @@
 
                 return switchStmt;
-        } // CaseRangeMutator::mutate
+        }
 
         Statement *CaseRangeMutator::mutate( CaseStmt *caseStmt ) {
-                // case list, e.g., case 1, 3, 5:
-                if ( TupleExpr *tcond = dynamic_cast< TupleExpr * >( caseStmt->get_condition() ) ) {
+                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?
-                        } // for
+                        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 );
+                mutateAll ( stmts, *this );
 
                 return caseStmt;
-        } // CaseRangeMutator::mutate
+        }
+
+        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() ) {
+                          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;
+                }
+        }
 } // namespace ControlStruct