simple_regex.cxx

Go to the documentation of this file.

//
// Copyright 2002, 2009 Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.

#include <cxxtls/simple_regex.h>
#include <regex.h>
#include <memory.h>
#include <string>

#ifdef RE_DUP_MAX
# undef RE_DUP_MAX
#endif

#include <algorithm>

using namespace std;

namespace cxxtls
{


//
// the following table of error message strings comes directly out of regex.h
// Most of the regex functions return a numeric error which is an array index
// into the table.  location 0 means 'no error' and is a null pointer.
static char const *errors[]=
{
  0,
  "no match",
  "invalid pattern",
  "collation error",
  "Invalid character class name",
  "Trailing backslash",
  "Invalid back reference",
  "Unmatched left bracket",
  "Parenthesis imbalance",
  "Unmatched \\{",
  "Invalid contents of \\{\\}",
  "Invalid range end",
  "Out of memory",
  "No preceding re for repetition operator",
  "Premature end",
  "Compiled pattern bigger than 2^16 bytes",
  "Unmatched ) or \\); not returned from regcomp"
};

static char const * compile_helper(char const *string, 
                                   regex_t *compiledPattern,
                                   std::string const &options
                                  )
  // perform the actual compilation of the regular expression
{
    static int initialized=0;

    if(!initialized)
        {
            initialized=1;
            re_set_syntax(RE_SYNTAX_GREP);
        }

    int opts=0;

    if(options.find_first_of('i') < options.size())
    {
      opts |= REG_ICASE;
    }

    int err = regcomp(compiledPattern, string, opts);

    return errors[err];
}

//
//  Regular expression constructors
//

SimpleRegex::
SimpleRegex(string const &r, string const &options)
:  expression_(r)
,  options_(options)
{
  match_count_ = 0;

  if(r.size() == 2  && r[0] != '.' ) // correct for an invalid regex:  'd*' is equivalent to '.' but causes an infinite loop
  {

    // huh?  This code makes no sense, but I do remember some bug involving having the first letter
    // be optional -- I'll bet the bug is in my code, but maybe no.  It was too long ago.

    if(r[1] == '*' )
    {
      expression_ = ".";
    }
  }

  error_ = compile_helper(expression_.c_str(), 
                          &compiled_expression, 
                          options_.c_str()
                         );

  ok_ = (error_ == 0);

}

SimpleRegex::
SimpleRegex(char const *r, char const *options)
:  expression_(r)
,  options_(options)
{
  match_count_ = 0;

  if(expression_.size() == 2) // correct for an invalid regex:  'd*' is equivalent to '.' but causes an infinite loop
  {
    if(r[1] == '*' )
    {
      expression_ = ".";
    }
  }

  error_ = compile_helper(expression_.c_str(), 
                          &compiled_expression,
                          options_.c_str()
                         );

  ok_ = (error_ == 0);

}

SimpleRegex::
SimpleRegex(SimpleRegex const &r)
:  expression_(r.expression_)
,  options_(r.options_)
{
  match_count_ = 0;

  error_ = compile_helper(expression_.c_str(), 
                          &compiled_expression,
                          options_.c_str()
                         );

  ok_ = (error_ == 0);

}

//
// Since the text string of the expression is kept in a SimpleRegex we can
// treat it as a 'value object' and the following assignment operators
// make life easier -- although they all cost a compilation
//
SimpleRegex &
SimpleRegex::
operator=(SimpleRegex const &r)
{
  match_count_ = 0;
  expression_  = r.expression_;
  options_     = r.options_;

  error_ = compile_helper(expression_.c_str(), 
                          &compiled_expression,
                          options_.c_str()
                         );

  return *this;
}

SimpleRegex &
SimpleRegex::
operator=(char const * r)
{
  match_count_ = 0;
  expression_ = r;
  options_="";

  error_ = compile_helper(expression_.c_str(), 
                          &compiled_expression,
                          options_.c_str()
                         );

  return *this;

}

SimpleRegex &
SimpleRegex::
operator=(string const &r)
{
  match_count_ = 0;
  expression_  = r;
  options_     = "";

  error_ = compile_helper(expression_.c_str(), &compiled_expression, "");

  return *this;

}

SimpleRegex::
~SimpleRegex()
{
   regfree(&compiled_expression);
}

int
SimpleRegex::
operator() (char const *s, int sLength) const
  //
  // returns a count of matched strings and sets the error() value.
  // matches can be found by looking at matches()
  //
{
  match_count_ = 0;

  if(!ok_)
    return 0;

  regmatch_t matches[max_matches];

  int rc = regexec1(&compiled_expression, s, sLength, max_matches, matches, 0);

  if(rc != 0)
  {
     error_ = errors[rc];

     return 0;
  }

  int i;

  for(i=0; i < max_matches; ++i)
  {

      if( matches[i].rm_so >= 0 )
          {
              matches_[i].offset = matches[i].rm_so;
              matches_[i].length = matches[i].rm_eo - matches[i].rm_so;
          }
      else
          {
              break;
          }
  }

  if(i == 0)
    error_ = errors[1];


  match_count_ = i;

  return i;


}

int
SimpleRegex::
operator() (string const &s, int offset, int length) const
{
  match_count_ = 0;

  if(!ok_)
    return 0;

  int string_length = s.size();

  if(offset >= string_length)
  {
    // the offset into the string where the search is
    // supposed to start is beyond the length of the
    // string.  Normally this is an error, but
    // what if the search is for an empty string?

    if( 
          (expression_ == "^$")
       || (   (expression_.size() == 4)
           && (expression_[0] == '^')
           && (expression_[2] == '*')
           && (expression_[3] == '$')
          )
      )
    {
      // in this case, the user is check for empty
      // string, so call it a find
    }
    else
    {
      error_ = errors[1];   // not found
      return 0;
    }
  }

  if(offset + length > string_length)
    length = string_length - offset;

  char const *p = s.c_str();

  p += offset;

  int count = SimpleRegex::operator() (p, length);

  if(count)
  {
    int i;

    for(i=0; i < count; ++i)
    {
      matches_[i].offset += offset; // incorporate the input offset
    }

  }

  return count;

}


string
SimpleRegex::
expand(string const &original, string const &in) const
{
  // expand a given string by replacing \0 - \9 with matched
  // components of the input string.

  string rv;

  size_t offset=0;

  size_t in_size = in.size();

  while(offset < in_size)
  {
     string::const_iterator start  = in.begin() + offset;
     string::const_iterator end    = in.end();
     string::const_iterator slash = find(start, end, '\\');

     if(slash == end)
     {
       // whoops, out of text

       rv.append(start, end);
       return rv;

     }
     else
     {
       // perform a substitituion

       rv.append(start, slash);

       ++slash;

       if(slash == end)  // last char in string was slash, thats baaaaad
         return rv;
        
       char c = *slash;

       if(c >= '0' && c < '9')
       {
         // parm substitution
        
         ++slash;
        
         c -= '0';
        
         // c is now a parm index
        
         if( c < match_count_)
         {
        
           rv.append(original.begin() + matches_[int(c)].offset,
                     original.begin() + matches_[int(c)].offset +
                                        matches_[int(c)].length
                    );
         }
        
       }
       else
       {
         rv += *slash++;
        
       }

       offset = slash - in.begin();

     }
  }

  return rv;

}


string
SimpleRegex::
substitute(string const &original, string const &replacement) const
{
  if(match_count_ == 0)
    return original;

  // first, compute the replacement value

  string real_replacement = expand(original, replacement);

  string rv;

  size_t start = matches_[0].offset;
  size_t end   = start + matches_[0].length;

  rv.append(original.begin(),
            original.begin() + start
           );
        
  rv.append(real_replacement);

  rv.append(original.begin() + end, original.end() );

  return rv;
}

bool
SimpleRegex::
anchored() const
{
  if(expression_.size() && expression_[0] == '^')
    return true;

  return false;
}

bool 
SimpleRegex::
replace(string &rv, string const &source, string const &replacement, int maxIterations) const
  //  Replace pattern within source with replacement at most maxReplacements times and return true if at least one replacement
  //  occurred.
{
    SimpleRegex const &expr = *this;

    bool matchFound=false;

    string const &pattern = expr; 

    if(pattern.size() && pattern[0] == '^')
    {
      // if the regex is nailed to the front of the expression, then at most
      // one substitution is possible.

      maxIterations = 1;
    }


    // begin a loop to perform as many substitutions as are necessary
    {
      rv=source;

      int offset = 0;
      int length = rv.size();

      if(expr.empty())
        maxIterations = 0;
      else
        if(maxIterations && expr.anchored())
          maxIterations = 1;

      while(maxIterations--)
      {
        int matchCount = expr(rv, offset, length);

        if(matchCount)
        {
          // a match was found

          string result = expr.substitute(rv, replacement);

          int sizeDelta = int(result.size()) - int(rv.size());

          SimpleRegex::match const *matches = expr.matches();

          int endOfMatch = matches[0].offset + matches[0].length;

          offset = endOfMatch;

          offset += sizeDelta;

          length = result.size() - offset;

          matchFound = true;

          rv = result;

        }
        else
        {
          break;
        }

      } // maxIterations--

    }

    return matchFound;
}
} // namespace cxxtls