DeSR Dependency Parser

text/RegExp.cpp

/*
**      Tanl
**      text/RegExp.cpp: regular expression matcher
** ----------------------------------------------------------------------
**      Copyright (c) 2003  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
*/
//
// Copyright (C) 2000-2003 by Roger Rene Kommer / artefaktur, Kassel, Germany.
// 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License (LGPL) or the Q public License (QPL).
// 
//

#include "text/RegExp.h"
#ifdef UNICODE
# include "text/Utf8CharIterator.h"
#endif

#include "text/strings.h"       // overloaded +(string, char*)

using namespace std;

namespace Tanl {
namespace Text {
namespace RegExp {

const unsigned char* Pattern::setLocale(char const* locale)
{
  free((void*)CharTables);
  char* oldLocale = setlocale(LC_CTYPE, NULL);
  setlocale(LC_CTYPE, locale);
  CharTables = pcre_maketables();
  setlocale(LC_CTYPE, oldLocale);
  return CharTables;
}

const unsigned char* Pattern::CharTables = Pattern::setLocale(setlocale(LC_CTYPE, 0));

Pattern::Pattern(char const* regExpr, int cflags) :
  _errorCode(0), _pcre_extra(0)
{
  const char* errtext = 0;
  int offset = -1;
  _pcre = pcre_compile(regExpr, cflags, &errtext, &offset, CharTables);
  if (_pcre == 0)
    throw ParseException(string("Error compiling RegExp: [") + regExpr +
                         "] at " + offset + ": " + errtext);
  if (!(cflags & Anchored))
    // useful only for non anchored patterns
    _pcre_extra = pcre_study(_pcre, 0, &errtext);
  pcre_fullinfo(_pcre, 0, PCRE_INFO_CAPTURECOUNT, &subpatterns);
  ++subpatterns;                // the whole string is a match
}

Pattern::Pattern(string& regExpr, int cflags) :
  _errorCode(0), _pcre_extra(0)
{
  const char* errtext = 0;
  int offset = -1;
  _pcre = pcre_compile(regExpr.c_str(), cflags, &errtext, &offset, CharTables);
  if (_pcre == 0)
    throw ParseException("Error compiling RegExp: [" + regExpr + "] at " + offset + ": " + errtext);
  if (!(cflags & Anchored))
    // useful only for non anchored patterns
    _pcre_extra = pcre_study(_pcre, 0, &errtext);
  pcre_fullinfo(_pcre, 0, PCRE_INFO_CAPTURECOUNT, &subpatterns);
}

Pattern::~Pattern()
{
  if (_pcre) {
    pcre_free(_pcre);
    _pcre = 0;
  }
  if (_pcre_extra) {
    pcre_free(_pcre_extra);
    _pcre_extra = 0;
  }
}

bool Pattern::test(string const& str, int eflags)
{
  MatchGroups matches(subpatterns);
  return pcre_exec(_pcre, _pcre_extra, (const char*)&str[0], str.length(),
                   0, eflags, (int*)&matches[0], 3 * subpatterns) >= 0;
}

bool Pattern::test(char const* str, size_t len, int eflags)
{
  MatchGroups matches(subpatterns);
  if (len == 0)
    len = strlen(str);
  return pcre_exec(_pcre, _pcre_extra, str, len,
                   0, eflags, (int*)&matches[0], 3 * subpatterns) >= 0;
}

#ifdef UNICODE
inline
static int utf8ByteToCharOffset(const char* begin, int offset)
{
  CharBuffer<Utf8Char>::iterator it1(begin);
  CharBuffer<Utf8Char>::iterator it2(begin + offset);
  return it2 - it1;
}

static void utf8ByteToCharOffsets(const char* begin, int offscount,
                      MatchGroups& matches)
{
  for (int i = 0; i < offscount; i += 2) {
    matches[i].first = utf8ByteToCharOffset(begin, matches[i].first);
    matches[i].second = utf8ByteToCharOffset(begin, matches[i].second);
  }
}
#endif

int Pattern::matchSize(string const& text, int eflags)
{
  const char* it = (const char*)&*text.begin();
  const char* end = (const char*)&*text.end();

  MatchGroups matches(subpatterns);

  int mcount = pcre_exec(_pcre, _pcre_extra, it, end - it, 0, eflags,
                         (int*)&matches[0], 3 * subpatterns);
  if (mcount < 0)
    return 0;
# ifdef UNICODE
  if (eflags & PCRE_UTF8)
    utf8ByteToCharOffsets(it, mcount, matches);
# endif
  return matches[0].second - matches[0].first;
}

int Pattern::match(string const& text, MatchGroups& pos, int eflags)
{
  const char* it = text.c_str();
  const char* end = it + text.length();
  return match(it, end, pos, eflags);
}

int Pattern::match(const char* it, const char* end, MatchGroups& pos,
                  int eflags)
{
  int slotnum = pos.size() * 3;
  int mcount = pcre_exec(_pcre, _pcre_extra, it, end - it, 0, eflags,
                         (int*)&pos[0], slotnum);
  if (mcount < 0)
    return 0;
# ifdef UNICODE
  if (eflags & PCRE_UTF8)
    utf8ByteToCharOffsets(it, mcount, pos);
# endif
  return mcount;
}

//virtual 
vector<string> Pattern::match(string const& str, int eflags)
{
  MatchGroups matches(subpatterns);
  int mcount = match(str, matches, eflags);
  if (mcount < 0)
    return vector<string>(0);
  vector<string> sa(mcount);
  for (int i = 0; i < mcount; ++i)
    sa[i] = str.substr(matches[i].first, matches[i].second);
  return sa;
}

string Pattern::replace(string& text, string& replwith, bool replaceAll)
{
  string rest = text;
  MatchGroups sa(1);

  string ret;
  while (match(rest, sa, 0)) {
    ret += rest.substr(0, sa[0].first) + replwith;
    rest = rest.substr(sa[0].second);
    if (!replaceAll)
      break;
  }
  ret += rest;
  return ret;
}

//static
string Pattern::escape(string& str)
{
  string sb;
  string::iterator end = str.end();
  for (string::iterator it = str.begin(); it < end; it++) {
    char c = *it;
    if (!((c >= 'a' && c <= 'z') ||
          (c >= 'A' && c <= 'Z') ||
          (c >= '0' && c <= '9')))
      sb += '\\';
    sb += c;
  }
  return sb;
}

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

 

Copyright © 2005-2007 G. Attardi. Generated on 13 Aug 2009 by doxygen 1.5.7.1.