muSED.cxx

Go to the documentation of this file.

#include <cxxtls/muSED.h>

namespace cxxtls
{
namespace muSED
{

     void expandEscapes(std::string &input)
     {
        // modify input such that \n is newline.  Do not modify \0-\n

        std::string tmp;

        char const *scan = input.data();
        char const *end  = scan + input.size();

        while(scan != end)
        {
           char c= *scan;

           if(c == '\\')
           {
              ++scan;

              if(scan == end)
              {
                tmp += '\\';

                break;
              }
              else
              switch(c = *scan++)
              {
                 case 'n':  tmp += '\n'; break;
                 case 'r':  tmp += '\r'; break;
                 case 't':  tmp += '\t'; break;
                 case 'a':  tmp += '\a'; break;
                 case 'b':  tmp += '\b'; break;

                 case 'e':  tmp += char(0x1b); break;

                 default: 
                     tmp += '\\';
                     tmp += c;

              }


           }
           else
           {
              tmp += c;
              ++scan;
           }



        }


        input.swap(tmp);

     }

        bool Filter::passes(size_t lineNo, bool isLast, std::string const &line)
        {
            switch(type_)
            {
                case regex:

                    if(!regex_(line))
                      return false;

                    // drop thorugh to true

                    break;

                case lineNumber:

                   return line_ == lineNo;

                case lastLine:
                    return isLast;

                default:  
                  break;  // drop through

            }

            return true;  // none means true for all lines

        }
        std::string Filter::debugString() const
        {
           switch(type_)
           {
              case regex:       return std::string("regex(") + std::string(regex_) + ")";
              case lastLine:    return std::string("lastLine()");

              case lineNumber:
              {
                 char buffer[256];

                 snprintf(buffer, sizeof(buffer), "line(%d)", int(line_));

                 return buffer;
              }

              default:
                break; // drop through
           }

           return "<none>";
        }
         LineRangeActivationState Statement::activationState() 
         {
            ActivationMap  *am= 0;

            if(parentStatement_)
               am = &parentStatement_->childStatementActivationMap_;
            else
               am = & childStatementActivationMap_;

            if(am->find(this) == am->end())
            {
               return neverExecuted;
            }
            
            return (*am)[this];


         }
        void Statement::setActivationState(LineRangeActivationState newState)
        {
            ActivationMap *am = 0;

            if(parentStatement_)
               am = &parentStatement_->childStatementActivationMap_;
            else
               am = &childStatementActivationMap_;
               
            ActivationMap::iterator loc = am->find(this);

            if(loc == am->end())
            {
                if(newState  == inRange)
                {
                   // transition from inactive to active

                   childStatementActivationMap_.clear(); // all my kid's go back to never executed
                   
                }

                (*am)[this] = newState;
            }
            else
            {
                if(newState == inRange && loc->second != inRange)
                {
                   childStatementActivationMap_.clear(); // all my kid's go back to never executed
                }

                loc->second = newState;
            }

        }
       void ScriptRuntimeContext::print(bool firstLineOnly)
       {
          char const *start = patternBuffer()->data();
          char const *end   = start + patternBuffer()->size();

          for(;;)
          {
              char const *scan;

              // find the end of the next line to be sent to the output 
              // stream.

              for(scan = start; scan != end; ++scan)
                 if(*scan == '\n')
                    break;

              if(scan == end)
              {
                  // hit the end of pattern buffer with no newlines.
                  // send this line and quit

                  output_->push_back( std::string(start, scan) );
                  break;
              }
              else
              {
                  // send this line to the output and set up for
                  // the next line's processing

                  output_->push_back( std::string(start, scan) );
                  start = scan+1;

                  if(firstLineOnly)
                  {
                     break;  // stop after the first ilne
                  }

              }

          }


       }

    bool SubstStatement::execute(ScriptRuntimeContext *context)
    {
       
       if(!active(context, this))
          return false;

       
       std::string *pattern = context->patternBuffer();

       std::string rv;

       if(target_(*pattern))
       {
          std::string rv;

          int replaced;
          
          if(count_)
          {  
              replaced = target_.replace(rv, *pattern, replacement_, count_);
          }
          else
          {
              // a count_ of 0 means replace all

              replaced = target_.replace(rv, *pattern, replacement_);
          }


          if(replaced)
          {
            // a substitution actually occurred.

            *pattern = rv;
          }

       }


       return false; 
    }

    bool TranslateStatement::execute(ScriptRuntimeContext *context)
    {
       
       if(!active(context, this))
          return false;

       std::string *pattern = context->patternBuffer();

       *pattern = translator_.translate(*pattern);

       return false; 
    }

    bool BlockStatement::execute(ScriptRuntimeContext *context)
    {
       if(!active(context, this))
          return false;

       int maxCount = context->maxWhileIterations();

       if(whileCondition_.get())
       {
           SimpleRegex const &condition(*whileCondition_);

           for(;;)
           {
               --maxCount;

               if(maxCount == 0)
                  return true; // something is way wrong if we get to 1M iterations

               if(!condition(*context->patternBuffer()) )
                  break;

               CXXTLS_FOREACH(Statement *s, childStatements_)
               {
                  if(s->execute(context))
                     return true;
               }
           }
       }
       else
       {
           CXXTLS_FOREACH(Statement *s, childStatements_)
           {
              if(s->execute(context))
                 return true;
           }
       }

       return false; 
    }

    bool FilterableStatement::active(ScriptRuntimeContext *context, Statement *statement)
    {

        if(filters_)
        {
            // if this line has filters, evaluate them to determine if the current statement is active
            // in the current context.


            if(filters_ == 1)
            {

                // if the statement has only one filter, execute the filter to determine if this
                // statement main body should be executed.

    
                bool f1Passed = 
                        filter1_.passes(context->lineNumber_,
                                                context->isLast_,
                                                *context->patternBuffer()
                                                );
    
                if(inverted_)
                   return !f1Passed;
                else
                   return f1Passed;
            }
            else
            {
               // there must be 2 filters -- which means that this is line range filter.

               LineRangeActivationState currentState = activationState();

               switch(currentState)
               {
                   case neverExecuted:
                   {
                      if(!inverted_)
                      {
                         // this is the normal logic case -- we are in range only between lines
                         // matching the first and second filters.

                         bool passed;

                         passed = 
                               filter1_.passes(context->lineNumber_,
                                               context->isLast_,
                                               *context->patternBuffer()
                                              );

                         if(passed)
                         {
                             // this line puts us in range, but maybe only temporarily

                             passed = 
                               filter2_.passes(context->lineNumber_,
                                               context->isLast_,
                                               *context->patternBuffer()
                                              );

                            if(!passed)
                            {
                               // we are in range and not at the end of the range

                               setActivationState(inRange);
                               return true;

                            }
                            else
                            {
                               return true;  // in range but at end thereof, so don't set the state
                                             // but do return true for this one line
                            }

                         }
                         else
                         {
                            return false;  // not previously in range and this line does not
                                           // put us in range.
                         }

                      }
                      else
                      {
                         // we are in the inverted case.

                         bool passed;

                         passed = 
                               filter1_.passes(context->lineNumber_,
                                               context->isLast_,
                                               *context->patternBuffer()
                                              );

                         if(passed)
                         {
                            // imaginee are on the first line of the file, we are not yet inRange,
                            //
                            // the first line matches the first filter, so we are going to the out of range
                            // case unless the first line also matches the second filter.
                            //

                             passed = 
                               filter2_.passes(context->lineNumber_,
                                               context->isLast_,
                                               *context->patternBuffer()
                                              );

                             if(passed)
                             {
                                // in the inverted case, the match with the first filter turned us to the 
                                // !inrange sitaution,
                                // but the second filter match turned it back to inrange.

                                setActivationState(inRange);
                                return true;
                             }
                             else
                             {
                                setActivationState(neverExecuted);
                                return false;
                             }
                         }
                         else
                         {
                            // we start in the never executed case, and the first filter does not match,
                            // so we are going to the inRange case

                            setActivationState(inRange);
                            return true;
                         }
                      }
                   }


                   case inRange:
                   {
                      if(!inverted_)
                      {
                          // normal case, we are in range and only need to know if the range
                          // ends on this line

                          bool passed;

                           passed = 
                               filter2_.passes(context->lineNumber_,
                                               context->isLast_,
                                               *context->patternBuffer()
                                              );

                           if(!passed)
                           {
                              return true;  // we are still in range
                           }
                           else
                           {
                              // this is the last line of the range, this line is
                              // executable no more are

                              setActivationState(neverExecuted);
                              return true;
                           }

                      }
                      else
                      {
                         // inverted filter situation

                          bool passed;

                           passed = 
                               filter1_.passes(context->lineNumber_,
                                               context->isLast_,
                                               *context->patternBuffer()
                                              );

                           if(passed)
                           {
                              // we have encountered the end of the range because
                              // the first filter matches the line

                              setActivationState(neverExecuted);
                              return true;


                           }
                           else
                             return true; // not changing state, but we are still in range

                      }
                   }



                   default:

                     debugPrint(this);

                     throw int(9);  // we should never get here

                     return false;
               }

            }


            throw float(10);  // we should never get here
            return false;
        }

        if(inverted_)
          return false;

        return true;  // either there are no filters or they both pass.
    }

        bool OuterStatement::execute(ScriptRuntimeContext *context)
        {
            CXXTLS_FOREACH(Statement *s, childStatements_)
            {
               if(s->execute(context))
                  return true;
            }
     
            return false; 
        }

        std::string FilterableStatement::debugStringPrefix() const
        {
           if(filters_ == 0)
           {
              return debugPrefix();
           }
           
           std::string rv = debugPrefix() + filter1_.debugString();

           if(filters_ > 1)
           {
             rv += ",";
             rv += filter2_.debugString();
           }

           if(inverted_)
           {
               rv += "!";
           }

           return rv;

        }

         std::string BlockStatement::debugString() const
         {
             std::string rv = debugStringPrefix();

             rv += "{";

             CXXTLS_FOREACH(Statement *cur, childStatements_)
             {
                rv += cur->debugString();
                rv += ";";
             }

             rv += "}";

             return rv;
         }


         std::string SubstStatement::debugString() const
         {
             std::string rv = debugStringPrefix();

             rv += "s/";
             rv += target_;
             rv += "/";
             rv += replacement_;

             char buffer[40];

             snprintf(buffer, sizeof(buffer), "%d", count_);

             rv += buffer;

             return rv;
         }


         std::string TranslateStatement::debugString() const
         {
             std::string rv = debugStringPrefix();

             rv += "y/";
             rv += target_;
             rv += "/";
             rv += replacement_;

             return rv;
         }

         std::string PrintStatement::debugString() const
         {
             std::string rv = debugStringPrefix();

             rv += "p";

             return rv;
         }

         std::string SwapStatement::debugString() const
         {
             std::string rv = debugStringPrefix();

             rv += "x";

             return rv;
         }


         std::string DeleteStatement::debugString() const
         {
             std::string rv = debugStringPrefix();

             rv += "d";

             return rv;
         }
         std::string QuitStatement::debugString() const
         {
             std::string rv = debugStringPrefix();

             if(printCurrent_)
                 rv += "q";
             else
                 rv += "Q";

             return rv;
         }

         std::string HoldStatement::debugString() const
         {
             std::string rv = debugStringPrefix();

             if(append_)
                 rv += "H";
             else
                 rv += "h";

             return rv;
         }

         std::string GetStatement::debugString() const
         {
             std::string rv = debugStringPrefix();

             if(append_)
                 rv += "G";
             else
                 rv += "g";

             return rv;
         }


    bool PrintStatement::execute(ScriptRuntimeContext *context)
    {
       if(!active(context, this))
          return false;

       context->print(firstLineOnly_);  


       return false; 
    }


    bool HoldStatement::execute(ScriptRuntimeContext *context)
    {
       if(!active(context, this))
          return false;


       if(append_)
           context->Hold();  
       else
           context->hold();  


       return false; 
    }


    bool SwapStatement::execute(ScriptRuntimeContext *context)
    {
       if(!active(context, this))
          return false;

       context->bufferSwap();

       return false; 
    }



    bool GetStatement::execute(ScriptRuntimeContext *context)
    {
       if(!active(context, this))
          return false;

       if(append_)
           context->Get();  
       else
           context->get();  


       return false; 
    }

    bool DeleteStatement::execute(ScriptRuntimeContext *context)
    {
       if(!active(context, this))
          return false;

       return true; 
    }


    bool QuitStatement::execute(ScriptRuntimeContext *context)
    {
       if(!active(context, this))
          return false;

       if(printCurrent_)
          context->print(false);

       context->stop(); // not just this line but the whole script

       return true; 
    }



}; // namespace muSED
}; // namespace cxxtls