Tanl Linguistic Pipeline

text/RegExp.h

/*
**      Tanl
**      text/RegExp.h:  regular expression matcher
** ----------------------------------------------------------------------
**      Copyright (c) 2003  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of Tanl.
**
**  Tanl is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  Tanl is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef Tanl_Text_RegExp_h
#define Tanl_Text_RegExp_h

// Local
#include "text/text.h"
#include "text/pcre/pcre.h"

// Standard
#include <string>
#include <vector>
#include <stdexcept>

namespace Tanl {
namespace Text {
namespace RegExp {

class RegExpException : public std::runtime_error {
    public:
    RegExpException(std::string const& msg) : std::runtime_error(msg) {}
};

enum CompileFlags
{
  IgnoreCase    = PCRE_CASELESS,
  NoNewLine     = PCRE_MULTILINE,
  DotAll        = PCRE_DOTALL,
  Extended      = PCRE_EXTENDED,
  Anchored      = PCRE_ANCHORED,
  DollarEndOnly = PCRE_DOLLAR_ENDONLY,
  Extra         = PCRE_EXTRA,
  UnGreedy      = PCRE_UNGREEDY,
  Utf8          = PCRE_UTF8
};

enum EvaluateFlags {
  NotBol        = PCRE_NOTBOL,
  NotEmpty      = PCRE_NOTEMPTY,
  NotEol        = PCRE_NOTEOL
  //  Anchored      = PCRE_ANCHORED // also an EvaluateFlag
};

class MatchGroups : std::vector<int>
{
public:
  MatchGroups(int size) :
    std::vector<int>(3 * size, -1)
  { }

  size_t size() { return std::vector<int>::size() / 3; }

  std::pair<int, int>& operator [](int i) {
    return *(std::pair<int, int>*)&std::vector<int>::operator[](2 * i); }
};

class Pattern
{
private:
  int           _errorCode;     
  pcre*         _pcre; 
  pcre_extra*   _pcre_extra;

  int           subpatterns;

public:

  Pattern() { }

  Pattern(std::string const& expression, int cflags = 0);

  Pattern(char const* expression, int cflags = 0);

  Pattern(Pattern const& other) {
    _errorCode = other._errorCode;
    _pcre = other._pcre;
    if (_pcre)
      pcre_refcount(_pcre, 1);
    _pcre_extra = other._pcre_extra;
    subpatterns = other.subpatterns;
  }

  ~Pattern();

  Pattern& operator =(Pattern const& other) {
    if (this != &other) {
      _errorCode = other._errorCode;
      _pcre = other._pcre;
      if (_pcre)
        pcre_refcount(_pcre, 1);
      _pcre_extra = other._pcre_extra;
      subpatterns = other.subpatterns;
    }
    return *this;
  }

  bool          test(std::string const& str, int eflags = 0) const;

  bool          test(char const* str, size_t len = 0, int eflags = 0);

  int           matchSize(std::string const& text, int eflags = 0);
  int           match(const char* start, const char* end,
                      MatchGroups& pos, int eflags = 0);
  int           match(std::string const& text, MatchGroups& pos, int eflags = 0);
  std::vector<std::string> match(std::string const& str, int eflags = 0);

  std::string   replace(std::string& text, std::string& rewrite, bool replaceAll = false);

  static std::string    escape(std::string& str);

  static const unsigned char*   setLocale(char const* locale);

  static const unsigned char* CharTables;
};

} // namespace RegExp
} // namespace Text 
} // namespace Tanl

#endif // Tanl_Text_RegExp_h

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.