Merge lp:~paul-lucas/zorba/pjl-misc into lp:zorba

[Paul J. Lucas]

regex clean-up:

* Split off Zorba's own regex engine from ICU's.
* Clean-up of some of the hack changes that Daniel made.

Also fixed build when ZORBA_NO_ICU=1.

regex clean-up:

* Split off Zorba's own regex engine from ICU's.
* Clean-up of some of the hack changes that Daniel made.

Also fixed build when ZORBA_NO_ICU=1.

[Paul J. Lucas (paul-lucas)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/pjl-misc-2013-04-12T04-39-45.281Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~paul-lucas/zorba/pjl-misc into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job pjl-misc-2013-04-12T04-39-45.281Z is finished. The
  final status was:

  26 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/pjl-misc-2013-04-12T05-38-39.33Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~paul-lucas/zorba/pjl-misc into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job pjl-misc-2013-04-12T05-38-39.33Z is finished. The
  final status was:

  1 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/pjl-misc-2013-04-12T06-13-41.393Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job pjl-misc-2013-04-12T06-13-41.393Z is finished. The final status was:

All tests succeeded!

[Zorba Build Bot (zorba-buildbot)]

Voting does not meet specified criteria. Required: Approve > 1, Disapprove < 1, Needs Fixing < 1, Pending < 1, Needs Information < 1, Resubmit < 1. Got: 1 Approve.

[Matthias Brantner (matthias-brantner)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/pjl-misc-2013-04-12T20-50-42.062Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job pjl-misc-2013-04-12T20-50-42.062Z is finished. The final status was:

All tests succeeded!

=== modified file 'src/runtime/full_text/latin_tokenizer.cpp'
--- src/runtime/full_text/latin_tokenizer.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/latin_tokenizer.cpp	2013-04-12 05:29:35 +0000
@@ -210,7 +210,7 @@
           // no break;
         case '!':
         case '?':
-          ++numbers().sent;
+          ++state().sent;
       }
   } // for
 
@@ -229,11 +229,11 @@
          << ": \"" << token << "\"\n";
 #endif /* PRINT_TOKENS */
 
-    callback(
+    callback.token(
       token.data(), token.size(), lang,
-      numbers().token, numbers().sent, numbers().para, item
+      state().token, state().sent, state().para, item
     );
-    ++numbers().token;
+    ++state().token;
     return true;
   }
   return false;

=== modified file 'src/runtime/full_text/latin_tokenizer.h'
--- src/runtime/full_text/latin_tokenizer.h	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/latin_tokenizer.h	2013-04-12 05:29:35 +0000
@@ -39,8 +39,8 @@
   // inherited
   void destroy() const;
   void properties( Properties* ) const;
-  void tokenize_string( char const*, size_type, iso639_1::type, bool, Callback&,
-                        Item const* );
+  void tokenize_string( char const*, size_type, locale::iso639_1::type, bool,
+                        Callback&, Item const* );
 
 private:
   typedef zstring string_type;
@@ -65,6 +65,8 @@
 
 class LatinTokenizerProvider : public TokenizerProvider {
 public:
+  LatinTokenizerProvider() { }          // needed to work-around compiler bug
+
   // inherited
   bool getTokenizer( locale::iso639_1::type, Tokenizer::State* = 0,
                      Tokenizer::ptr* = 0 ) const;

=== modified file 'src/runtime/strings/strings_impl.cpp'
--- src/runtime/strings/strings_impl.cpp	2013-03-15 08:22:41 +0000
+++ src/runtime/strings/strings_impl.cpp	2013-04-12 05:29:35 +0000
@@ -1900,7 +1900,7 @@
       break;
     }
 #ifndef ZORBA_NO_ICU
-    match_startg = rx.get_match_start(i+1);
+    match_startg = rx.get_group_start(i+1);
     if((match_startg < 0) && (gparent < 0))
       continue;
 #else
@@ -1920,7 +1920,7 @@
       GENV_ITEMFACTORY->createTextNode(non_group_text_item, parent.getp(), non_group_str);
     }
 #ifndef ZORBA_NO_ICU
-    match_endg = rx.get_match_end(i+1);
+    match_endg = rx.get_group_end(i+1);
 #else
     match_endg = temp_endg;
 #endif
@@ -2123,17 +2123,16 @@
 
     unicode::regex    rx;
     rx.compile(lib_pattern, flags.c_str());
-    int   nr_pattern_groups = rx.get_pattern_group_count();
+    int   nr_pattern_groups = rx.get_group_count();
     std::vector<int>    group_parent;
     computePatternGroupsParents(xquery_pattern, group_parent);
 
     //see if regex can match empty strings
     bool   reachedEnd = false;
     rx.set_string("", 0);
-    if (rx.find_next_match(&reachedEnd))
+    if (rx.next_match(&reachedEnd))
     {
       throw XQUERY_EXCEPTION(err::FORX0003, ERROR_PARAMS(lib_pattern));
-
     }
 
     store::Item_t null_parent;
@@ -2187,13 +2186,13 @@
       int    match_end1 = 0;
       unsigned int    match_end1_bytes = 0;
       reachedEnd = false;
-      while(rx.find_next_match(&reachedEnd))
+      while(rx.next_match(&reachedEnd))
       {
         int    match_start2;
         int    match_end2;
 #ifndef ZORBA_NO_ICU
-        match_start2 = rx.get_match_start();
-        match_end2 = rx.get_match_end();
+        match_start2 = rx.get_group_start();
+        match_end2 = rx.get_group_end();
 #else
         rx.get_match_start_end_bytes(0, &match_start2, &match_end2);
 #endif

=== modified file 'src/util/CMakeLists.txt'
--- src/util/CMakeLists.txt	2013-03-16 20:44:27 +0000
+++ src/util/CMakeLists.txt	2013-04-12 05:29:35 +0000
@@ -24,7 +24,6 @@
   json_parser.cpp
   json_util.cpp
   mem_streambuf.cpp
-  regex.cpp
   stream_util.cpp
   string_util.cpp
   time_util.cpp
@@ -44,18 +43,20 @@
   LIST(APPEND UTIL_SRCS cxx_util.cpp)
 ENDIF (NOT ZORBA_CXX_NULLPTR)
 
-IF(ZORBA_WITH_FILE_ACCESS)
+IF (ZORBA_WITH_FILE_ACCESS)
   LIST(APPEND UTIL_SRCS mmap_file.cpp)
-ENDIF(ZORBA_WITH_FILE_ACCESS)
+ENDIF (ZORBA_WITH_FILE_ACCESS)
 
-IF(ZORBA_NO_ICU)
-  LIST(APPEND UTIL_SRCS
-    regex_xquery.cpp
-    passthru_streambuf.cpp)
-ELSE(ZORBA_NO_ICU)
-  LIST(APPEND UTIL_SRCS
+IF (ZORBA_NO_ICU)
+  LIST(APPEND UTIL_SRCS
+    passthru_streambuf.cpp
+    zorba_regex.cpp
+    zorba_regex_engine.cpp)
+ELSE (ZORBA_NO_ICU)
+  LIST(APPEND UTIL_SRCS
+    icu_regex.cpp
     icu_streambuf.cpp)
-ENDIF(ZORBA_NO_ICU)
+ENDIF (ZORBA_NO_ICU)
 
 HEADER_GROUP_SUBFOLDER(UTIL_SRCS fx)
 HEADER_GROUP_SUBFOLDER(UTIL_SRCS win32)

=== renamed file 'src/util/regex.cpp' => 'src/util/icu_regex.cpp'
--- src/util/regex.cpp	2013-04-11 17:45:40 +0000
+++ src/util/icu_regex.cpp	2013-04-12 05:29:35 +0000
@@ -15,14 +15,17 @@
  */
 #include "stdafx.h"
 
+#include <zorba/config.h>
+
+#ifndef ZORBA_NO_ICU
+
 #include <cstring>
 #include <vector>
 
 #include <zorba/diagnostic_list.h>
-#include "diagnostics/xquery_exception.h"
-
 #include "diagnostics/assert.h"
 #include "diagnostics/dict.h"
+#include "diagnostics/xquery_exception.h"
 
 #include "ascii_util.h"
 #include "cxx_util.h"
@@ -32,13 +35,12 @@
 #define INVALID_RE_EXCEPTION(...) \
   XQUERY_EXCEPTION( err::FORX0002, ERROR_PARAMS( __VA_ARGS__ ) )
 
-#ifndef ZORBA_NO_ICU
-# include <unicode/uversion.h>
+#include <unicode/uversion.h>
 U_NAMESPACE_USE
 
-# ifndef U_ICU_VERSION_MAJOR_NUM
-#   error "U_ICU_VERSION_MAJOR_NUM not defined"
-# elif U_ICU_VERSION_MAJOR_NUM < 4
+#ifndef U_ICU_VERSION_MAJOR_NUM
+# error "U_ICU_VERSION_MAJOR_NUM not defined"
+#elif U_ICU_VERSION_MAJOR_NUM < 4
     //
     // UREGEX_LITERAL is only in ICU since 4.0.  For earlier versions, we
     // define it ourselves.  Of course it won't have any effect since it's not
@@ -46,8 +48,8 @@
     // though the constant is defined in 4.0, it's not actually implemented as
     // of 4.4.
     //
-#   define UREGEX_LITERAL 16
-# endif /* U_ICU_VERSION_MAJOR_NUM */
+# define UREGEX_LITERAL 16
+#endif /* U_ICU_VERSION_MAJOR_NUM */
 
 using namespace std;
 
@@ -559,7 +561,6 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-
 namespace unicode {
 
 void regex::compile( string const &u_pattern, char const *flags,
@@ -582,10 +583,27 @@
   }
 }
 
+int regex::get_group_count() {
+  ZORBA_ASSERT( matcher_ );
+  return matcher_->groupCount();
+}
+
+int regex::get_group_start( int group ) {
+  ZORBA_ASSERT( matcher_ );
+  UErrorCode status = U_ZERO_ERROR;
+  return matcher_->start( group, status );
+}
+
+int regex::get_group_end( int group ) {
+  ZORBA_ASSERT( matcher_ );
+  UErrorCode status = U_ZERO_ERROR;
+  return matcher_->end( group, status );
+}
+
 bool regex::match_part( string const &s ) {
   ZORBA_ASSERT( matcher_ );
   matcher_->reset( s );
-  return matcher_->find() != 0;
+  return !!matcher_->find();
 }
 
 bool regex::match_whole( string const &s ) {
@@ -645,6 +663,19 @@
   return false;
 }
 
+bool regex::next_match( bool *reached_end ) {
+  ZORBA_ASSERT( matcher_ );
+  bool const found = !!matcher_->find();
+  if ( reached_end ) {
+#if U_ICU_VERSION_MAJOR_NUM >= 4
+    *reached_end = !!matcher_->hitEnd();
+#else
+    *reached_end = true;
+#endif /* U_ICU_VERSION_MAJOR_NUM */
+  }
+  return found;
+}
+
 bool regex::replace_all( string const &in, string const &replacement,
                          string *out ) {
   ZORBA_ASSERT( matcher_ );
@@ -663,290 +694,16 @@
           replace_all( u_in, u_replacement, out );
 }
 
-void regex::set_string( char const *in, size_type len ) {
-  ZORBA_ASSERT( matcher_ );
-  to_string( in, len, &s_in_ );
-  matcher_->reset( s_in_ );
-}
-
-bool regex::find_next_match( bool *reachedEnd ) {
-  ZORBA_ASSERT( matcher_ );
-  UBool retfind = matcher_->find();
-  if ( reachedEnd ) {
-#if U_ICU_VERSION_MAJOR_NUM >= 4
-    *reachedEnd = matcher_->hitEnd() != 0;
-#else
-    *reachedEnd = true;
-#endif
-  }
-  return retfind != 0;
-}
-
-int regex::get_pattern_group_count() {
-  ZORBA_ASSERT( matcher_ );
-  return matcher_->groupCount();
-}
-
-int regex::get_match_start( int groupId ) {
-  ZORBA_ASSERT( matcher_ );
-  UErrorCode status = U_ZERO_ERROR;
-  return matcher_->start( groupId, status );
-}
-
-int regex::get_match_end( int groupId ) {
-  ZORBA_ASSERT( matcher_ );
-  UErrorCode status = U_ZERO_ERROR;
-  return matcher_->end( groupId, status );
-}
-
-} // namespace unicode
-} // namespace zorba
+void regex::set_string( char const *s, size_type s_len ) {
+  ZORBA_ASSERT( matcher_ );
+  to_string( s, s_len, &s_ );
+  matcher_->reset( s_ );
+}
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#else /* ZORBA_NO_ICU */
-
-#include "zorbatypes/zstring.h"
-
-namespace zorba {
-//no convertion
-void convert_xquery_re( zstring const &xq_re, zstring *lib_re,
-                        char const *flags)
-{
-  *lib_re = xq_re;
-}
-
-namespace unicode {
-
-uint32_t regex::parse_regex_flags(const char* flag_cstr) 
-{
-  uint32_t flags = 0;
-  for (const char* p = flag_cstr; *p != '\0'; ++p) 
-  {
-    switch (*p) 
-    {
-    case 'i': flags |= REGEX_ASCII_CASE_INSENSITIVE; break;
-    case 's': flags |= REGEX_ASCII_DOTALL; break;
-    case 'm': flags |= REGEX_ASCII_MULTILINE; break;
-    case 'x': flags |= REGEX_ASCII_NO_WHITESPACE; break;
-    case 'q': flags |= REGEX_ASCII_LITERAL; break;
-    default:
-      throw XQUERY_EXCEPTION( err::FORX0001, ERROR_PARAMS( *p ) );
-      break;
-    }
-  }
-  return flags;
-}
-
-void regex::compile( char const *pattern, char const *flags)
-{
-  parsed_flags = parse_regex_flags(flags);
-  regex_xquery::CRegexXQuery_parser regex_parser;
-  regex_matcher = regex_parser.parse(pattern, parsed_flags);
-  if(!regex_matcher)
-    throw INVALID_RE_EXCEPTION(pattern);
-}
-
-bool regex::match_part( char const *s )
-{
-  bool  retval;
-  int   match_pos;
-  int   matched_len;
-
-  retval = regex_matcher->match_anywhere(s, parsed_flags, &match_pos, &matched_len);
-
-  return retval;
-}
-
-bool regex::next_match( char const *s, size_type *pos, zstring *match )
-{
-  bool  retval;
-  int   match_pos;
-  int   matched_len;
-
-  retval = regex_matcher->match_anywhere(s+*pos, parsed_flags, &match_pos, &matched_len);
-  if(retval)
-  {
-    match->assign(s+*pos+match_pos, matched_len);
-    *pos += match_pos + matched_len;
-  }
-  return retval;
-}
-
-bool regex::next_token( char const *s, size_type *pos, zstring *token,
-                  bool *matched)
-{
-  if(!s[*pos])
-    return false;
-  bool  retval;
-  int   match_pos;
-  int   matched_len;
-
-  retval = regex_matcher->match_anywhere(s+*pos, parsed_flags, &match_pos, &matched_len);
-  if(retval)
-  {
-    if(token)
-      token->assign(s+*pos, match_pos);
-    *pos += match_pos + matched_len;
-    if(matched)
-      *matched = true;
-    return true;
-  }
-  else
-  {
-    if(token)
-      token->assign(s+*pos);
-    *pos += strlen(s+*pos);
-    if(matched)
-      *matched = false;
-    return true;
-  }
-}
-
-bool regex::match_whole( char const *s )
-{
-  bool  retval;
-  int   matched_pos;
-  int   matched_len;
-
-  retval = regex_matcher->match_anywhere(s, parsed_flags|REGEX_ASCII_WHOLE_MATCH, &matched_pos, &matched_len);
-  if(!retval)
-    return false;
-  return true;
-}
-
-bool regex::replace_all( char const *in, char const *replacement, zstring *result )
-{
-  int   match_pos;
-  int   matched_len;
-
-  const char  *start_str = in;
-  int  subregex_count = regex_matcher->get_indexed_regex_count();
-  bool retval = false;
-
-  while(regex_matcher->match_anywhere(start_str, parsed_flags, &match_pos, &matched_len))
-  {
-    if(match_pos)
-      result->append(start_str , match_pos);
-    retval = true;
-    const char *temprepl = replacement;
-    const char *submatched_source;
-    int   submatched_len;
-    int index;
-    while(*temprepl)
-    {
-      //look for dollars
-      if(*temprepl == '\\')
-      {
-        if(!(parsed_flags & REGEX_ASCII_LITERAL))
-        {
-          temprepl++;
-          if(!*temprepl) 
-            temprepl--;
-          else if((*temprepl != '\\') && (*temprepl != '$'))//Invalid replacement string.
-            throw XQUERY_EXCEPTION( err::FORX0004, ERROR_PARAMS( replacement ) );
-        }
-        result->append(1, *temprepl);
-        temprepl++;
-        continue;
-      }
-      if((*temprepl == '$') && !(parsed_flags & REGEX_ASCII_LITERAL))
-      {
-        temprepl++;
-        index = 0;
-        int   nr_digits = 0;
-        while(isdigit(*temprepl))
-        {
-          if(nr_digits && ((index*10 + (*temprepl)-'0') > subregex_count))
-            break;
-          index = index*10 + (*temprepl)-'0';
-          temprepl++;
-          nr_digits++;
-        }
-        if(!nr_digits)//Invalid replacement string.
-          throw XQUERY_EXCEPTION( err::FORX0004, ERROR_PARAMS( replacement ) );
-        else if(!index)
-        {
-          result->append(start_str+match_pos, matched_len);
-        }
-        else if(regex_matcher->get_indexed_match(index, &submatched_source, &submatched_len))
-        {
-          if(submatched_source && submatched_len)
-            result->append(submatched_source, submatched_len);
-        }
-      }
-      else
-      {
-        result->append(1, *temprepl);
-        temprepl++;
-      }
-    }
-    start_str += match_pos + matched_len;
-  }
-  result->append(start_str);
-
-  return retval;
-}
-
-void regex::set_string( const char* in, size_type len )
-{
-  s_in_.assign(in, len);
-  m_pos = 0;
-  m_match_pos = 0;
-  m_matched_len = 0;
-}
-
-bool regex::find_next_match( bool *reachedEnd )
-{
-  bool  retval;
-
-  retval = regex_matcher->match_anywhere(s_in_.c_str()+m_pos, parsed_flags, &m_match_pos, &m_matched_len);
-  if(retval)
-  {
-    m_match_pos += m_pos;
-    m_pos = m_match_pos + m_matched_len;
-  }
-  else
-  {
-    m_pos = s_in_.length();
-    m_match_pos = 0;
-    m_matched_len = 0;
-  }
-  if(reachedEnd)
-    *reachedEnd = regex_matcher->get_reachedEnd();
-  return retval;
-}
-
-int regex::get_pattern_group_count()
-{
-  return (int)regex_matcher->get_indexed_regex_count();
-}
-
-bool regex::get_match_start_end_bytes( int groupId, int *start, int *end )
-{
-  *start = -1;
-  *end = -1;
-  if(groupId == 0)
-  {
-    *start = m_match_pos;
-    *end = m_match_pos + m_matched_len;
-    return true;
-  }
-  if(groupId > (int)regex_matcher->get_indexed_regex_count())
-    return false;
-  const char *submatched_source;
-  int   submatched_len;
-  if(!regex_matcher->get_indexed_match(groupId, &submatched_source, &submatched_len))
-    return false;
-  *start = submatched_source - s_in_.c_str();
-  *end = *start + submatched_len;
-  return true;
-}
-
 } // namespace unicode
 } // namespace zorba
+
 #endif /* ZORBA_NO_ICU */
-
-///////////////////////////////////////////////////////////////////////////////
-
 /* vim:set et sw=2 ts=2: */

=== renamed file 'src/util/regex.h' => 'src/util/icu_regex.h'
--- src/util/regex.h	2013-02-07 17:24:36 +0000
+++ src/util/icu_regex.h	2013-04-12 05:29:35 +0000
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 #pragma once
-#ifndef ZORBA_REGEX_H
-#define ZORBA_REGEX_H
+#ifndef ZORBA_ICU_REGEX_H
+#define ZORBA_ICU_REGEX_H
 
 #include "cxx_util.h"
 #include "unicode_util.h"
@@ -42,7 +42,6 @@
 
 namespace unicode {
 
-
 /**
  * The %regex class wraps the underlying Unicode regular expression library.
  */
@@ -421,59 +420,61 @@
     return replace_all( in.c_str(), replacement.c_str(), out );
   }
 
-
-  /**
-   * Set the string to work on, without doing matching yet.
-   *
-   * @param in The UTF-8 input string.
-   * @param len the size in bytes.
-   */
-  void set_string( const char* in, size_type len );
-
-  /**
-   * Find the next match in string set by set_string().
-   * After finding a match, call get_match_start() and get_match_end() to get the position in the string.
-   *
-   * @param reachedEnd returns true if the end of string was reached while doing the match.
-   *    This works only for ICU greater than 4.0. For smaller versions, reachedEnd is always true.
-   */
-  bool find_next_match( bool *reachedEnd );
-
-  /**
-   * Get the number of parenthesized groups in the regular expression.
-   * This number depends only on regular expression, and not on the working string.
-   *
-   * @return the number of parenthesized groups in the regular expression
-   */
-  int get_pattern_group_count();
-
-  /**
-   * Get the start position of the matched group.
-   * If groupId is zero, then the start position of the whole match is returned.
-   * If groupId is non-zero, then the start position of that group is returned.
-   * If that group has not been matched, -1 is returned.
-   *
-   * @param groupId the id of the group, either zero for the entire regex,
-   *  or [1 .. group_count] for that specific group
-   * @return the start position, zero based, or -1 if that group didn't match
-   */
-  int get_match_start( int groupId = 0 );
-
-  /**
-   * Get the end position of the matched group.
-   * If groupId is zero, then the end position of the whole match is returned.
-   * If groupId is non-zero, then the end position of that group is returned.
-   * If that group has not been matched, -1 is returned.
-   *
-   * @param groupId the id of the group, either zero for the entire regex,
-   *  or [1 .. group_count] for that specific group
-   * @return the end position, zero based, or -1 if that group didn't match
-   */
-  int get_match_end( int groupId = 0 );
+  ////////// capturing subgroups //////////////////////////////////////////////
+
+  /**
+   * Gets the number of capturing subgroups in the regular expression.
+   *
+   * @return Returns said number.
+   */
+  int get_group_count();
+
+  /**
+   * Gets the start character position of the matched capturing subgroup.
+   *
+   * @param group The ID of the capturing subgroup [1-N] where N is the result
+   * of get_group_count(), or 0 for the whole match.
+   * @return Returns the start position (zero-based) or -1 if \a group didn't
+   * match.
+   */
+  int get_group_start( int group = 0 );
+
+  /**
+   * Gets the end character position of the matched group.
+   *
+   * @param group The ID of the capturing subgroup [1-N] where N is the result
+   * of get_group_count(), or 0 for the whole match.
+   * @return Returns the end position (zero-based) or -1 if \a group didn't
+   * match.
+   */
+  int get_group_end( int group = 0 );
+
+  /**
+   * Sets the string to work on, without doing matching yet.
+   *
+   * @param s The UTF-8 input string.
+   * @param s_len The length of \a s in bytes.
+   */
+  void set_string( char const *s, size_type s_len );
+
+  /**
+   * Finds the next match in the string set by set_string().  After finding a
+   * match, call get_group_start() and get_group_end() to get the position in
+   * the string.
+   *
+   * @param reached_end If not \c nullptr, set to \c true only if the end of
+   * string has been reached while doing the match.  (This works only for ICU
+   * version 4.0 or later; for earlier versions, this is always set to
+   * <code>true</code>.)
+   * @return Returns \c true only if the next match was found.
+   */
+  bool next_match( bool *reached_end );
+
+  /////////////////////////////////////////////////////////////////////////////
 
 private:
   U_NAMESPACE_QUALIFIER RegexMatcher *matcher_;
-  string s_in_;
+  string s_;
 
   enum re_type_t {
     re_is_match,                        // RE specifies what to match
@@ -491,386 +492,13 @@
   regex& operator=( regex const& );
 };
 
-} // namespace unicode
-} // namespace zorba
-
-///////////////////////////////////////////////////////////////////////////////
-
-#else /* ZORBA_NO_ICU */
-
-#include "util/regex_xquery.h"
-#include <string>
-
-namespace zorba{
-/**
- * Converts an XQuery regular expression to the form used by the regular
- * expression library Zorba is using (here regex_xquery).
- *
- * @param xq_re The XQuery regular expression.
- * @param lib_re A pointer to the resuling library regular expression.
- * @param flags The flags to use, if any.
- */
-void convert_xquery_re( zstring const &xq_re, zstring *lib_re,
-                        char const *flags = "" );
-
-namespace unicode{
-////////// classes ////////////////////////////////////////////////////////////
-
-
-/**
- * The %regex class wraps the underlying Unicode regular expression library.
- */
-class regex {
-public:
-  /**
-   * Constructs a %regex.
-   */
-  regex() : regex_matcher( nullptr ) { }
-
-  /**
-   * Destroys a %regex.
-   */
-  ~regex() {
-    delete regex_matcher;
-  }
-
-  ////////// compile pattern //////////////////////////////////////////////////
-
-  /**
-   * Compiles a regular expression.  One of the compile functions must be
-   * called prior to calling one of the match functions.
-   *
-   * @param pattern The regular expression pattern to compile.
-   * @param flags The regular expression flags, if any.
-   * @param throws err:FORX0002 if the regular expression is invalid.
-   */
-  void compile( char const *pattern, char const *flags = "" ) ;
-
-  /**
-   * Compiles a regular expression.  One of the compile functions must be
-   * called prior to calling one of the match functions.
-   *
-   * @tparam StringType The pattern string type.
-   * @param pattern The regular expression pattern to compile.
-   * @param flags The regular expression flags, if any.
-   * @param throws err:FORX0002 if the regular expression is invalid.
-   */
-  template<class StringType>
-  void compile( StringType const &pattern, char const *flags = "" ) {
-    compile( pattern.c_str(), flags );
-  }
-
-  /**
-   * Compiles a regular expression.  One of the compile functions must be
-   * called prior to calling one of the match functions.
-   *
-   * @tparam PatternStringType The pattern string type.
-   * @tparam FlagsStringType The flags string type.
-   * @param pattern The regular expression pattern to compile.
-   * @param flags The regular expression flags, if any.
-   * @param throws err:FORX0002 if the regular expression is invalid.
-   */
-  template<class PatternStringType,class FlagsStringType>
-  void compile( PatternStringType const &pattern,
-                FlagsStringType const &flags ) {
-    compile( pattern.c_str(), flags.c_str() );
-  }
-
-  ////////// partial match ////////////////////////////////////////////////////
-
-  /**
-   * Checks whether the given string partially patches the previosuly compiled
-   * regular expression.  A "partial match" means that at least part of the
-   * string matches, e.g., "b" matches the regular expression "aba".
-   *
-   * @param s The null-terminated UTF-8 C string to attempt to match.
-   * @return Returns \c true only if the string partially matches.
-   */
-  bool match_part( char const *s );
-
-  /**
-   * Checks whether the given string partially patches the previosuly compiled
-   * regular expression.  A "partial match" means that at least part of the
-   * string matches, e.g., "b" matches the regular expression "aba".
-   *
-   * @param s The UTF-8 C string to attempt to match.
-   * @param s_len The length of the string in bytes.
-   * @return Returns \c true only if the string partially matches.
-   */
-  bool match_part( char const *s, size_type s_len )
-  {
-    zstring scut(s, s_len);
-    return match_part(scut.c_str());
-  }
-
-  /**
-   * Checks whether the given string partially patches the previosuly compiled
-   * regular expression.  A "partial match" means that at least part of the
-   * string matches, e.g., "b" matches the regular expression "aba".
-   *
-   * @tparam StringType The string type.
-   * @param s The UTF-8 string to attempt to match.
-   * @return Returns \c true only if the string partially matches.
-   */
-  template<class StringType>
-  bool match_part( StringType const &s ) {
-    return match_part(s.c_str());
-  }
-
-  ////////// partial match with substrings/tokenization ///////////////////////
-
-  /**
-   * Finds the next substring matching the pattern this %regex was compiled
-   * with.
-   *
-   * @param s The C string to attempt to match.
-   * @param pos A pointer to the position to start looking for a match.  On
-   * successful return, the position is updated to be one past the last
-   * character of the match.
-   * @param match A pointer to the string that is to be set to the substring
-   * matching the pattern or NULL if the substring is not needed.
-   * @return Returns \c true only if there is a match.
-   */
-  bool next_match( char const *s, size_type *pos, zstring *match );
-
-  /**
-   * Finds the next substring matching the pattern this %regex was compiled
-   * with.
-   *
-   * @param s The C string to attempt to match.
-   * @param s_len The length of the C string.
-   * @param pos A pointer to the position to start looking for a match.  On
-   * successful return, the position is updated to be one past the last
-   * character of the match.
-   * @param match A pointer to the string that is to be set to the substring
-   * matching the pattern or NULL if the substring is not needed.
-   * @return Returns \c true only if there is a match.
-   */
-  bool next_match( char const *s, size_type s_len, size_type *pos,
-                   zstring *match ) 
-  {
-    zstring scut(s, s_len);
-    return next_match(scut.c_str(), pos, match);
-  }
-
-  /**
-   * Finds the next substring matching the pattern this %regex was compiled
-   * with.
-   *
-   * @tparam StringType The string type.
-   * @param s The string to attempt to match.
-   * @param pos A pointer to the position to start looking for a match.  On
-   * successful return, the position is updated to be one past the last
-   * character of the match.
-   * @param match A pointer to the string that is to be set to the substring
-   * matching the pattern or NULL if the substring is not needed.
-   * @return Returns \c true only if there is a match.
-   */
-  template<class StringType>
-  bool next_match( StringType const &s, size_type *pos, zstring *match ) {
-    return next_match(s.c_str(), pos, match);
-  }
-
-
-  /**
-   * Finds the next substring separated by the pattern this %regex was compiled
-   * with (similar to <code>strtok</code>(3)).
-   *
-   * @param s The C string to attempt to find a token in.
-   * @param pos A pointer to the position to start looking for a token.  On
-   * successful return, the position is updated to be one past the last
-   * character of the token.
-   * @param token A pointer to the string that is to be set to the substring
-   * separated by the pattern or \c NULL if the substring is not needed.
-   * @param matched A pointer to a \c bool to indicate whether the pattern
-   * matched for the token or \c NULL if this is not needed.  If not \c NULL,
-   * it is set to \c false either if there is no token or the token is the
-   * final token after the last separator; it is set to \c true only for
-   * non-last tokens.
-   * @return Returns \c true only if there is a token.
-   */
-  bool next_token( char const *s, size_type *pos, zstring *token,
-                   bool *matched = NULL );
-
-  /**
-   * Finds the next substring separated by the pattern this %regex was compiled
-   * with (similar to <code>strtok</code>(3)).
-   *
-   * @param s The C string to attempt to find a token in.
-   * @param s_len The length of the C string.
-   * @param pos A pointer to the position to start looking for a token.  On
-   * successful return, the position is updated to be one past the last
-   * character of the token.
-   * @param token A pointer to the string that is to be set to the substring
-   * separated by the pattern or \c NULL if the substring is not needed.
-   * @param matched A pointer to a \c bool to indicate whether the pattern
-   * matched for the token or \c NULL if this is not needed.  If not \c NULL,
-   * it is set to \c false either if there is no token or the token is the
-   * final token after the last separator; it is set to \c true only for
-   * non-last tokens.
-   * @return Returns \c true only if there is a token.
-   */
-  bool next_token( char const *s, size_type s_len, size_type *pos,
-                   zstring *token, bool *matched = NULL )
-  {
-    zstring scut(s, s_len);
-    return next_token(scut.c_str(), pos, token, matched);
-  }
-
-  /**
-   * Finds the next substring separated by the pattern this %regex was compiled
-   * with (similar to <code>strtok</code>(3)).
-   *
-   * @tparam StringType The string type.
-   * @param s The string to attempt to find a token in.
-   * @param pos A pointer to the position to start looking for a token.  On
-   * successful return, the position is updated to be one past the last
-   * character of the token.
-   * @param token A pointer to the string that is to be set to the substring
-   * separated by the pattern or \c NULL if the substring is not needed.
-   * @return Returns \c true only if there is a token.
-   */
-  template<class StringType>
-  bool next_token( StringType const &s, size_type *pos, zstring *token,
-                   bool *matched = NULL ) {
-    return next_token(s.c_str(), pos, token, matched);
-  }
-
-  ////////// whole match //////////////////////////////////////////////////////
-
-  /**
-   * Checks whether the given string completely patches the previosuly compiled
-   * regular expression.  A "complete match" means that the entire string must
-   * match the regular expression as if the pattern were "^pattern$".
-   *
-   * @param s The null-terminated UTF-8 C string to attempt to match.
-   * @return Returns \c true only if the string completely matches.
-   */
-  bool match_whole( char const *s );
-
-  /**
-   * Checks whether the given string completely patches the previosuly compiled
-   * regular expression.  A "complete match" means that the entire string must
-   * match the regular expression as if the pattern were "^pattern$".
-   *
-   * @param s The UTF-8 C string to attempt to match.
-   * @param s_len The length of the string in bytes.
-   * @return Returns \c true only if the string completely matches.
-   */
-  bool match_whole( char const *s, size_type s_len ) 
-  {
-    zstring scut(s, s_len);
-    return match_whole(scut.c_str());
-  }
-
-  /**
-   * Checks whether the given string completely patches the previosuly compiled
-   * regular expression.  A "complete match" means that the entire string must
-   * match the regular expression as if the pattern were "^pattern$".
-   *
-   * @tparam StringType The string type.
-   * @param s The UTF-8 string to attempt to match.
-   * @return Returns \c true only if the string completely matches.
-   */
-  template<class StringType>
-  bool match_whole( StringType const &s ) {
-    return match_whole(s.c_str());
-  }
-
-  ////////// replacement //////////////////////////////////////////////////////
-
-  /**
-   * Replaces all occurrences of substrings that match the pattern this %regex
-   * was compiled with.
-   *
-   * @param in The UTF-8 input string.
-   * @param replacement The replacement string.
-   * @param out The output string.
-   * @param Returns \c true only if at least one replacement was made.
-   */
-  bool replace_all( char const *in, char const *replacement, zstring *out );
-
-  /**
-   * Replaces all occurrences of substrings that match the pattern this %regex
-   * was compiled with.
-   *
-   * @tparam InputStringType The input string type.
-   * @tparam ReplacementStringType The replacement string type.
-   * @param in The input string.
-   * @param replacement The replacement string.
-   * @param out The output string.
-   * @param Returns \c true only if at least one replacement was made.
-   */
-  template<class InputStringType,class ReplacementStringType>
-  bool replace_all( InputStringType const &in,
-                    ReplacementStringType const &replacement,
-                    zstring *out ) {
-    return replace_all( in.c_str(), replacement.c_str(), out );
-  }
-
-
-  /**
-   * Set the string to work on, without doing matching yet.
-   *
-   * @param in The UTF-8 input string.
-   * @param len the size in bytes.
-   */
-  void set_string( const char* in, size_type len );
-
-  /**
-   * Find the next match in string set by set_string().
-   * After finding a match, call get_match_start() and get_match_end() to get the position in the string.
-   *
-   * @param reachedEnd returns true if the end of string was reached while doing the match.
-   */
-  bool find_next_match( bool *reachedEnd );
-
-  /**
-   * Get the number of parenthesized groups in the regular expression.
-   * This number depends only on regular expression, and not on the working string.
-   *
-   * @return the number of parenthesized groups in the regular expression
-   */
-  int get_pattern_group_count();
-
-  /**
-   * Get the start position of the matched group.
-   * If groupId is zero, then the start and end position of the whole match is returned.
-   * If groupId is non-zero, then the start and end position of that group is returned.
-   * If that group has not been matched, false is returned.
-   *
-   * @param groupId the id of the group, either zero for the entire regex,
-   *  or [1 .. group_count] for that specific group
-   * @param start to return start position in bytes
-   * @param end to return end position in bytes
-   * @return true if that group exists and has been matched
-   */
-  bool get_match_start_end_bytes( int groupId, int *start, int *end );
-
-
-private:
-  regex_xquery::CRegexXQuery_regex  *regex_matcher;
-  uint32_t    parsed_flags;
-
-  zstring s_in_;
-  int     m_pos;
-  int     m_match_pos;
-  int     m_matched_len;
-
-  uint32_t parse_regex_flags(const char* flag_cstr);
-
-  // forbid
-  regex( regex const& );
-  regex& operator=( regex const& );
-};
-
 ///////////////////////////////////////////////////////////////////////////////
 
 } // namespace unicode
 } // namespace zorba
 
 #endif /* ZORBA_NO_ICU */
-#endif /* ZORBA_REGEX_H */
+#endif /* ZORBA_ICU_REGEX_H */
 /*
  * Local variables:
  * mode: c++

=== modified file 'src/util/passthru_streambuf.cpp'
--- src/util/passthru_streambuf.cpp	2013-02-07 17:24:36 +0000
+++ src/util/passthru_streambuf.cpp	2013-04-12 05:29:35 +0000
@@ -26,7 +26,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 passthru_streambuf::passthru_streambuf( char const*, streambuf *orig ) :
-  proxy_streambuf( orig )
+  internal::proxy_streambuf( orig )
 {
   if ( !orig )
     throw invalid_argument( "null streambuf" );
@@ -85,7 +85,7 @@
 
 passthru_streambuf::int_type passthru_streambuf::pbackfail( int_type c ) {
   return  traits_type::eq_int_type( c, traits_type::eof() ) ?
-          c : proxy_buf_->sputbackc( traits_type::to_char_type( c ) );
+          c : original()->sputbackc( traits_type::to_char_type( c ) );
 }
 
 passthru_streambuf::int_type passthru_streambuf::uflow() {

=== modified file 'src/util/passthru_streambuf.h'
--- src/util/passthru_streambuf.h	2013-02-07 17:24:36 +0000
+++ src/util/passthru_streambuf.h	2013-04-12 05:29:35 +0000
@@ -30,7 +30,7 @@
  * A %passthru_streambuf is-a std::streambuf that simply passes through
  * characters unchanged.
  */
-class passthru_streambuf : public proxy_streambuf {
+class passthru_streambuf : public internal::proxy_streambuf {
 public:
 #ifdef WIN32
   // These typedefs are needed (but shouldn't be) when using MSVC++.

=== added file 'src/util/regex.h'
--- src/util/regex.h	1970-01-01 00:00:00 +0000
+++ src/util/regex.h	2013-04-12 05:29:35 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#ifndef ZORBA_REGEX_H
+#define ZORBA_REGEX_H
+
+#include <zorba/config.h>
+
+#ifdef ZORBA_NO_ICU
+#include "zorba_regex.h"
+#else
+#include "icu_regex.h"
+#endif /* ZORBA_NO_ICU */
+
+#endif /* ZORBA_REGEX_H */
+/*
+ * Local variables:
+ * mode: c++
+ * End:
+ */
+/* vim:set et sw=2 ts=2: */

=== added file 'src/util/zorba_regex.cpp'
--- src/util/zorba_regex.cpp	1970-01-01 00:00:00 +0000
+++ src/util/zorba_regex.cpp	2013-04-12 05:29:35 +0000
@@ -0,0 +1,265 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "stdafx.h"
+
+#include <cstring>
+
+#include <zorba/diagnostic_list.h>
+#include "diagnostics/dict.h"
+#include "diagnostics/xquery_exception.h"
+
+#include "stl_util.h"
+#include "zorba_regex.h"
+
+#define INVALID_RE_EXCEPTION(...) \
+  XQUERY_EXCEPTION( err::FORX0002, ERROR_PARAMS( __VA_ARGS__ ) )
+
+namespace zorba {
+namespace unicode {
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint32_t regex::parse_regex_flags(const char* flag_cstr) 
+{
+  uint32_t flags = 0;
+  for (const char* p = flag_cstr; *p != '\0'; ++p) 
+  {
+    switch (*p) 
+    {
+    case 'i': flags |= REGEX_ASCII_CASE_INSENSITIVE; break;
+    case 's': flags |= REGEX_ASCII_DOTALL; break;
+    case 'm': flags |= REGEX_ASCII_MULTILINE; break;
+    case 'x': flags |= REGEX_ASCII_NO_WHITESPACE; break;
+    case 'q': flags |= REGEX_ASCII_LITERAL; break;
+    default:
+      throw XQUERY_EXCEPTION( err::FORX0001, ERROR_PARAMS( *p ) );
+      break;
+    }
+  }
+  return flags;
+}
+
+void regex::compile( char const *pattern, char const *flags)
+{
+  parsed_flags = parse_regex_flags(flags);
+  regex_engine::CRegexXQuery_parser regex_parser;
+  regex_matcher = regex_parser.parse(pattern, parsed_flags);
+  if(!regex_matcher)
+    throw INVALID_RE_EXCEPTION(pattern);
+}
+
+bool regex::match_part( char const *s )
+{
+  bool  retval;
+  int   match_pos;
+  int   matched_len;
+
+  retval = regex_matcher->match_anywhere(s, parsed_flags, &match_pos, &matched_len);
+
+  return retval;
+}
+
+bool regex::next_match( char const *s, size_type *pos, zstring *match )
+{
+  bool  retval;
+  int   match_pos;
+  int   matched_len;
+
+  retval = regex_matcher->match_anywhere(s+*pos, parsed_flags, &match_pos, &matched_len);
+  if(retval)
+  {
+    match->assign(s+*pos+match_pos, matched_len);
+    *pos += match_pos + matched_len;
+  }
+  return retval;
+}
+
+bool regex::next_token( char const *s, size_type *pos, zstring *token,
+                  bool *matched)
+{
+  if(!s[*pos])
+    return false;
+  bool  retval;
+  int   match_pos;
+  int   matched_len;
+
+  retval = regex_matcher->match_anywhere(s+*pos, parsed_flags, &match_pos, &matched_len);
+  if(retval)
+  {
+    if(token)
+      token->assign(s+*pos, match_pos);
+    *pos += match_pos + matched_len;
+    if(matched)
+      *matched = true;
+    return true;
+  }
+  else
+  {
+    if(token)
+      token->assign(s+*pos);
+    *pos += strlen(s+*pos);
+    if(matched)
+      *matched = false;
+    return true;
+  }
+}
+
+bool regex::match_whole( char const *s )
+{
+  bool  retval;
+  int   matched_pos;
+  int   matched_len;
+
+  retval = regex_matcher->match_anywhere(s, parsed_flags|REGEX_ASCII_WHOLE_MATCH, &matched_pos, &matched_len);
+  if(!retval)
+    return false;
+  return true;
+}
+
+bool regex::replace_all( char const *in, char const *replacement, zstring *result )
+{
+  int   match_pos;
+  int   matched_len;
+
+  const char  *start_str = in;
+  int  subregex_count = regex_matcher->get_indexed_regex_count();
+  bool retval = false;
+
+  while(regex_matcher->match_anywhere(start_str, parsed_flags, &match_pos, &matched_len))
+  {
+    if(match_pos)
+      result->append(start_str , match_pos);
+    retval = true;
+    const char *temprepl = replacement;
+    const char *submatched_source;
+    int   submatched_len;
+    int index;
+    while(*temprepl)
+    {
+      //look for dollars
+      if(*temprepl == '\\')
+      {
+        if(!(parsed_flags & REGEX_ASCII_LITERAL))
+        {
+          temprepl++;
+          if(!*temprepl) 
+            temprepl--;
+          else if((*temprepl != '\\') && (*temprepl != '$'))//Invalid replacement string.
+            throw XQUERY_EXCEPTION( err::FORX0004, ERROR_PARAMS( replacement ) );
+        }
+        result->append(1, *temprepl);
+        temprepl++;
+        continue;
+      }
+      if((*temprepl == '$') && !(parsed_flags & REGEX_ASCII_LITERAL))
+      {
+        temprepl++;
+        index = 0;
+        int   nr_digits = 0;
+        while(isdigit(*temprepl))
+        {
+          if(nr_digits && ((index*10 + (*temprepl)-'0') > subregex_count))
+            break;
+          index = index*10 + (*temprepl)-'0';
+          temprepl++;
+          nr_digits++;
+        }
+        if(!nr_digits)//Invalid replacement string.
+          throw XQUERY_EXCEPTION( err::FORX0004, ERROR_PARAMS( replacement ) );
+        else if(!index)
+        {
+          result->append(start_str+match_pos, matched_len);
+        }
+        else if(regex_matcher->get_indexed_match(index, &submatched_source, &submatched_len))
+        {
+          if(submatched_source && submatched_len)
+            result->append(submatched_source, submatched_len);
+        }
+      }
+      else
+      {
+        result->append(1, *temprepl);
+        temprepl++;
+      }
+    }
+    start_str += match_pos + matched_len;
+  }
+  result->append(start_str);
+
+  return retval;
+}
+
+void regex::set_string( const char* in, size_type len )
+{
+  s_in_.assign(in, len);
+  m_pos = 0;
+  m_match_pos = 0;
+  m_matched_len = 0;
+}
+
+bool regex::next_match( bool *reachedEnd )
+{
+  bool  retval;
+
+  retval = regex_matcher->match_anywhere(s_in_.c_str()+m_pos, parsed_flags, &m_match_pos, &m_matched_len);
+  if(retval)
+  {
+    m_match_pos += m_pos;
+    m_pos = m_match_pos + m_matched_len;
+  }
+  else
+  {
+    m_pos = s_in_.length();
+    m_match_pos = 0;
+    m_matched_len = 0;
+  }
+  if(reachedEnd)
+    *reachedEnd = regex_matcher->get_reachedEnd();
+  return retval;
+}
+
+int regex::get_group_count()
+{
+  return (int)regex_matcher->get_indexed_regex_count();
+}
+
+bool regex::get_match_start_end_bytes( int groupId, int *start, int *end )
+{
+  *start = -1;
+  *end = -1;
+  if(groupId == 0)
+  {
+    *start = m_match_pos;
+    *end = m_match_pos + m_matched_len;
+    return true;
+  }
+  if(groupId > (int)regex_matcher->get_indexed_regex_count())
+    return false;
+  const char *submatched_source;
+  int   submatched_len;
+  if(!regex_matcher->get_indexed_match(groupId, &submatched_source, &submatched_len))
+    return false;
+  *start = submatched_source - s_in_.c_str();
+  *end = *start + submatched_len;
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace unicode
+} // namespace zorba
+
+/* vim:set et sw=2 ts=2: */

=== added file 'src/util/zorba_regex.h'
--- src/util/zorba_regex.h	1970-01-01 00:00:00 +0000
+++ src/util/zorba_regex.h	2013-04-12 05:29:35 +0000
@@ -0,0 +1,406 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#ifndef ZORBA_ZORBA_REGEX_H
+#define ZORBA_ZORBA_REGEX_H
+
+#include <zorba/config.h>
+
+#ifdef ZORBA_NO_ICU
+
+#include "cxx_util.h"
+#include "unicode_util.h"
+#include "zorba_regex_engine.h"
+#include "zorbatypes/zstring.h"
+
+namespace zorba {
+
+/**
+ * Converts an XQuery regular expression to the form used by the regular
+ * expression library Zorba is using (here regex_engine).
+ *
+ * @param xq_re The XQuery regular expression.
+ * @param lib_re A pointer to the resuling library regular expression.
+ * @param flags The flags to use, if any.
+ */
+inline void convert_xquery_re( zstring const &xq_re, zstring *lib_re,
+                               char const *flags = "" ) {
+  *lib_re = xq_re;                      // no converseion neeeded
+}
+
+////////// classes ////////////////////////////////////////////////////////////
+
+namespace unicode {
+
+/**
+ * The %regex class wraps the underlying Unicode regular expression library.
+ */
+class regex {
+public:
+  /**
+   * Constructs a %regex.
+   */
+  regex() : regex_matcher( nullptr ) { }
+
+  /**
+   * Destroys a %regex.
+   */
+  ~regex() {
+    delete regex_matcher;
+  }
+
+  ////////// compile pattern //////////////////////////////////////////////////
+
+  /**
+   * Compiles a regular expression.  One of the compile functions must be
+   * called prior to calling one of the match functions.
+   *
+   * @param pattern The regular expression pattern to compile.
+   * @param flags The regular expression flags, if any.
+   * @param throws err:FORX0002 if the regular expression is invalid.
+   */
+  void compile( char const *pattern, char const *flags = "" ) ;
+
+  /**
+   * Compiles a regular expression.  One of the compile functions must be
+   * called prior to calling one of the match functions.
+   *
+   * @tparam StringType The pattern string type.
+   * @param pattern The regular expression pattern to compile.
+   * @param flags The regular expression flags, if any.
+   * @param throws err:FORX0002 if the regular expression is invalid.
+   */
+  template<class StringType>
+  void compile( StringType const &pattern, char const *flags = "" ) {
+    compile( pattern.c_str(), flags );
+  }
+
+  /**
+   * Compiles a regular expression.  One of the compile functions must be
+   * called prior to calling one of the match functions.
+   *
+   * @tparam PatternStringType The pattern string type.
+   * @tparam FlagsStringType The flags string type.
+   * @param pattern The regular expression pattern to compile.
+   * @param flags The regular expression flags, if any.
+   * @param throws err:FORX0002 if the regular expression is invalid.
+   */
+  template<class PatternStringType,class FlagsStringType>
+  void compile( PatternStringType const &pattern,
+                FlagsStringType const &flags ) {
+    compile( pattern.c_str(), flags.c_str() );
+  }
+
+  ////////// partial match ////////////////////////////////////////////////////
+
+  /**
+   * Checks whether the given string partially patches the previosuly compiled
+   * regular expression.  A "partial match" means that at least part of the
+   * string matches, e.g., "b" matches the regular expression "aba".
+   *
+   * @param s The null-terminated UTF-8 C string to attempt to match.
+   * @return Returns \c true only if the string partially matches.
+   */
+  bool match_part( char const *s );
+
+  /**
+   * Checks whether the given string partially patches the previosuly compiled
+   * regular expression.  A "partial match" means that at least part of the
+   * string matches, e.g., "b" matches the regular expression "aba".
+   *
+   * @param s The UTF-8 C string to attempt to match.
+   * @param s_len The length of the string in bytes.
+   * @return Returns \c true only if the string partially matches.
+   */
+  bool match_part( char const *s, size_type s_len )
+  {
+    zstring scut(s, s_len);
+    return match_part(scut.c_str());
+  }
+
+  /**
+   * Checks whether the given string partially patches the previosuly compiled
+   * regular expression.  A "partial match" means that at least part of the
+   * string matches, e.g., "b" matches the regular expression "aba".
+   *
+   * @tparam StringType The string type.
+   * @param s The UTF-8 string to attempt to match.
+   * @return Returns \c true only if the string partially matches.
+   */
+  template<class StringType>
+  bool match_part( StringType const &s ) {
+    return match_part(s.c_str());
+  }
+
+  ////////// partial match with substrings/tokenization ///////////////////////
+
+  /**
+   * Finds the next substring matching the pattern this %regex was compiled
+   * with.
+   *
+   * @param s The C string to attempt to match.
+   * @param pos A pointer to the position to start looking for a match.  On
+   * successful return, the position is updated to be one past the last
+   * character of the match.
+   * @param match A pointer to the string that is to be set to the substring
+   * matching the pattern or NULL if the substring is not needed.
+   * @return Returns \c true only if there is a match.
+   */
+  bool next_match( char const *s, size_type *pos, zstring *match );
+
+  /**
+   * Finds the next substring matching the pattern this %regex was compiled
+   * with.
+   *
+   * @param s The C string to attempt to match.
+   * @param s_len The length of the C string.
+   * @param pos A pointer to the position to start looking for a match.  On
+   * successful return, the position is updated to be one past the last
+   * character of the match.
+   * @param match A pointer to the string that is to be set to the substring
+   * matching the pattern or NULL if the substring is not needed.
+   * @return Returns \c true only if there is a match.
+   */
+  bool next_match( char const *s, size_type s_len, size_type *pos,
+                   zstring *match ) 
+  {
+    zstring scut(s, s_len);
+    return next_match(scut.c_str(), pos, match);
+  }
+
+  /**
+   * Finds the next substring matching the pattern this %regex was compiled
+   * with.
+   *
+   * @tparam StringType The string type.
+   * @param s The string to attempt to match.
+   * @param pos A pointer to the position to start looking for a match.  On
+   * successful return, the position is updated to be one past the last
+   * character of the match.
+   * @param match A pointer to the string that is to be set to the substring
+   * matching the pattern or NULL if the substring is not needed.
+   * @return Returns \c true only if there is a match.
+   */
+  template<class StringType>
+  bool next_match( StringType const &s, size_type *pos, zstring *match ) {
+    return next_match(s.c_str(), pos, match);
+  }
+
+
+  /**
+   * Finds the next substring separated by the pattern this %regex was compiled
+   * with (similar to <code>strtok</code>(3)).
+   *
+   * @param s The C string to attempt to find a token in.
+   * @param pos A pointer to the position to start looking for a token.  On
+   * successful return, the position is updated to be one past the last
+   * character of the token.
+   * @param token A pointer to the string that is to be set to the substring
+   * separated by the pattern or \c NULL if the substring is not needed.
+   * @param matched A pointer to a \c bool to indicate whether the pattern
+   * matched for the token or \c NULL if this is not needed.  If not \c NULL,
+   * it is set to \c false either if there is no token or the token is the
+   * final token after the last separator; it is set to \c true only for
+   * non-last tokens.
+   * @return Returns \c true only if there is a token.
+   */
+  bool next_token( char const *s, size_type *pos, zstring *token,
+                   bool *matched = NULL );
+
+  /**
+   * Finds the next substring separated by the pattern this %regex was compiled
+   * with (similar to <code>strtok</code>(3)).
+   *
+   * @param s The C string to attempt to find a token in.
+   * @param s_len The length of the C string.
+   * @param pos A pointer to the position to start looking for a token.  On
+   * successful return, the position is updated to be one past the last
+   * character of the token.
+   * @param token A pointer to the string that is to be set to the substring
+   * separated by the pattern or \c NULL if the substring is not needed.
+   * @param matched A pointer to a \c bool to indicate whether the pattern
+   * matched for the token or \c NULL if this is not needed.  If not \c NULL,
+   * it is set to \c false either if there is no token or the token is the
+   * final token after the last separator; it is set to \c true only for
+   * non-last tokens.
+   * @return Returns \c true only if there is a token.
+   */
+  bool next_token( char const *s, size_type s_len, size_type *pos,
+                   zstring *token, bool *matched = NULL )
+  {
+    zstring scut(s, s_len);
+    return next_token(scut.c_str(), pos, token, matched);
+  }
+
+  /**
+   * Finds the next substring separated by the pattern this %regex was compiled
+   * with (similar to <code>strtok</code>(3)).
+   *
+   * @tparam StringType The string type.
+   * @param s The string to attempt to find a token in.
+   * @param pos A pointer to the position to start looking for a token.  On
+   * successful return, the position is updated to be one past the last
+   * character of the token.
+   * @param token A pointer to the string that is to be set to the substring
+   * separated by the pattern or \c NULL if the substring is not needed.
+   * @return Returns \c true only if there is a token.
+   */
+  template<class StringType>
+  bool next_token( StringType const &s, size_type *pos, zstring *token,
+                   bool *matched = NULL ) {
+    return next_token(s.c_str(), pos, token, matched);
+  }
+
+  ////////// whole match //////////////////////////////////////////////////////
+
+  /**
+   * Checks whether the given string completely patches the previosuly compiled
+   * regular expression.  A "complete match" means that the entire string must
+   * match the regular expression as if the pattern were "^pattern$".
+   *
+   * @param s The null-terminated UTF-8 C string to attempt to match.
+   * @return Returns \c true only if the string completely matches.
+   */
+  bool match_whole( char const *s );
+
+  /**
+   * Checks whether the given string completely patches the previosuly compiled
+   * regular expression.  A "complete match" means that the entire string must
+   * match the regular expression as if the pattern were "^pattern$".
+   *
+   * @param s The UTF-8 C string to attempt to match.
+   * @param s_len The length of the string in bytes.
+   * @return Returns \c true only if the string completely matches.
+   */
+  bool match_whole( char const *s, size_type s_len ) 
+  {
+    zstring scut(s, s_len);
+    return match_whole(scut.c_str());
+  }
+
+  /**
+   * Checks whether the given string completely patches the previosuly compiled
+   * regular expression.  A "complete match" means that the entire string must
+   * match the regular expression as if the pattern were "^pattern$".
+   *
+   * @tparam StringType The string type.
+   * @param s The UTF-8 string to attempt to match.
+   * @return Returns \c true only if the string completely matches.
+   */
+  template<class StringType>
+  bool match_whole( StringType const &s ) {
+    return match_whole(s.c_str());
+  }
+
+  ////////// replacement //////////////////////////////////////////////////////
+
+  /**
+   * Replaces all occurrences of substrings that match the pattern this %regex
+   * was compiled with.
+   *
+   * @param in The UTF-8 input string.
+   * @param replacement The replacement string.
+   * @param out The output string.
+   * @param Returns \c true only if at least one replacement was made.
+   */
+  bool replace_all( char const *in, char const *replacement, zstring *out );
+
+  /**
+   * Replaces all occurrences of substrings that match the pattern this %regex
+   * was compiled with.
+   *
+   * @tparam InputStringType The input string type.
+   * @tparam ReplacementStringType The replacement string type.
+   * @param in The input string.
+   * @param replacement The replacement string.
+   * @param out The output string.
+   * @param Returns \c true only if at least one replacement was made.
+   */
+  template<class InputStringType,class ReplacementStringType>
+  bool replace_all( InputStringType const &in,
+                    ReplacementStringType const &replacement,
+                    zstring *out ) {
+    return replace_all( in.c_str(), replacement.c_str(), out );
+  }
+
+
+  /**
+   * Set the string to work on, without doing matching yet.
+   *
+   * @param in The UTF-8 input string.
+   * @param len the size in bytes.
+   */
+  void set_string( const char* in, size_type len );
+
+  /**
+   * Find the next match in string set by set_string().
+   * After finding a match, call get_group_start() and get_group_end() to get the position in the string.
+   *
+   * @param reachedEnd returns true if the end of string was reached while doing the match.
+   */
+  bool next_match( bool *reachedEnd );
+
+  /**
+   * Get the number of parenthesized groups in the regular expression.
+   * This number depends only on regular expression, and not on the working string.
+   *
+   * @return the number of parenthesized groups in the regular expression
+   */
+  int get_group_count();
+
+  /**
+   * Get the start position of the matched group.
+   * If groupId is zero, then the start and end position of the whole match is returned.
+   * If groupId is non-zero, then the start and end position of that group is returned.
+   * If that group has not been matched, false is returned.
+   *
+   * @param groupId the id of the group, either zero for the entire regex,
+   *  or [1 .. group_count] for that specific group
+   * @param start to return start position in bytes
+   * @param end to return end position in bytes
+   * @return true if that group exists and has been matched
+   */
+  bool get_match_start_end_bytes( int groupId, int *start, int *end );
+
+private:
+  regex_engine::CRegexXQuery_regex  *regex_matcher;
+  uint32_t    parsed_flags;
+
+  zstring s_in_;
+  int     m_pos;
+  int     m_match_pos;
+  int     m_matched_len;
+
+  uint32_t parse_regex_flags(const char* flag_cstr);
+
+  // forbid
+  regex( regex const& );
+  regex& operator=( regex const& );
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace unicode
+} // namespace zorba
+
+#endif /* ZORBA_NO_ICU */
+#endif /* ZORBA_ZORBA_REGEX_H */
+/*
+ * Local variables:
+ * mode: c++
+ * End:
+ */
+/* vim:set et sw=2 ts=2: */

=== renamed file 'src/util/regex_xquery.cpp' => 'src/util/zorba_regex_engine.cpp'
--- src/util/regex_xquery.cpp	2013-02-28 11:15:32 +0000
+++ src/util/zorba_regex_engine.cpp	2013-04-12 05:29:35 +0000
@@ -16,19 +16,18 @@
 
 #include "stdafx.h"
 
-#include <ctype.h>
-#include <string.h>
+#include <cctype>
+#include <cstring>
 
+#include "ascii_util.h"
 #include "diagnostics/xquery_diagnostics.h"
-#include "util/ascii_util.h"
-#include "util/unicode_util.h"
-#include "util/utf8_string.h"
+#include "unicode_util.h"
+#include "utf8_string.h"
+#include "zorba_regex_engine.h"
 #include "zorbatypes/chartype.h"
 
-#include "regex_xquery.h"
-
 namespace zorba {
-  namespace regex_xquery{
+  namespace regex_engine{
 //ascii regular expression matching
 
 /*http://www.w3.org/TR/xmlschema-2/#regexs
@@ -2525,6 +2524,6 @@
   return false;
 }
 
-  }//end namespace regex_xquery
+  }//end namespace regex_engine
 }//end namespace zorba
 /* vim:set et sw=2 ts=2: */

=== renamed file 'src/util/regex_xquery.h' => 'src/util/zorba_regex_engine.h'
--- src/util/regex_xquery.h	2013-02-07 17:24:36 +0000
+++ src/util/zorba_regex_engine.h	2013-04-12 05:29:35 +0000
@@ -21,7 +21,7 @@
 #include <vector>
 #include <util/unicode_util.h>
 namespace zorba {
-  namespace regex_xquery{
+  namespace regex_engine{
 
 //matching flags
 #define REGEX_ASCII_CASE_INSENSITIVE    1   //i
@@ -456,7 +456,7 @@
 };
 
 }
-}//end namespace zorba::regex_xquery
+}//end namespace zorba::regex_engine
 
 #endif
 /* vim:set et sw=2 ts=2: */