/FileExtraction/Java_unseen/dlitz_resin/modules/quercus/src/com/caucho/quercus/lib/regexp/RegexpModule.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source 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, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.quercus.lib.regexp;

import com.caucho.quercus.QuercusException;
import com.caucho.quercus.QuercusRuntimeException;
import com.caucho.quercus.annotation.Hide;
import com.caucho.quercus.annotation.Optional;
import com.caucho.quercus.annotation.NotNull;
import com.caucho.quercus.annotation.Reference;
import com.caucho.quercus.annotation.UsesSymbolTable;
import com.caucho.quercus.env.*;
import com.caucho.quercus.lib.i18n.MbstringModule;
import com.caucho.quercus.module.AbstractQuercusModule;
import com.caucho.util.L10N;
import com.caucho.util.LruCache;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

public class RegexpModule
  extends AbstractQuercusModule
{
  private static final Logger log =
    Logger.getLogger(RegexpModule.class.getName());

  private static final L10N L = new L10N(RegexpModule.class);

  public static final int PREG_REPLACE_EVAL = 0x01;
  public static final int PCRE_UTF8 = 0x02;

  public static final int PREG_PATTERN_ORDER = 0x01;
  public static final int PREG_SET_ORDER = 0x02;
  public static final int PREG_OFFSET_CAPTURE = 0x100;

  public static final int PREG_SPLIT_NO_EMPTY = 0x01;
  public static final int PREG_SPLIT_DELIM_CAPTURE = 0x02;
  public static final int PREG_SPLIT_OFFSET_CAPTURE = 0x04;

  public static final int PREG_GREP_INVERT = 1;

  public static final int PREG_NO_ERROR = 0;
  public static final int PREG_INTERNAL_ERROR = 1;
  public static final int PREG_BACKTRACK_LIMIT_ERROR = 2;
  public static final int PREG_RECURSION_LIMIT_ERROR = 3;
  public static final int PREG_BAD_UTF8_ERROR = 4;
  public static final int PREG_BAD_UTF8_OFFSET_ERROR = 5;
  public static final String PCRE_VERSION = "7.0 18-Dec-2006";

  // #2526, possible JIT/OS problem with max comparison
  private static final long LONG_MAX = Long.MAX_VALUE - 1;

  public static final boolean [] PREG_QUOTE = new boolean[256];

  private static LruCache<StringValue, RegexpCacheItem> _regexpCache
    = new LruCache<StringValue, RegexpCacheItem>(1024);

  private static LruCache<StringValue, Ereg> _eregCache
    = new LruCache<StringValue, Ereg>(1024);

  private static LruCache<StringValue, Eregi> _eregiCache
    = new LruCache<StringValue, Eregi>(1024);

  private static LruCache<UnicodeEregKey, UnicodeEreg> _unicodeEregCache
    = new LruCache<UnicodeEregKey, UnicodeEreg>(1024);

  private static LruCache<UnicodeEregKey, UnicodeEregi> _unicodeEregiCache
    = new LruCache<UnicodeEregKey, UnicodeEregi>(1024);

  private static LruCache<StringValue, ArrayList<Replacement>> _replacementCache
    = new LruCache<StringValue, ArrayList<Replacement>>(1024);

  @Override
  public String []getLoadedExtensions()
  {
    return new String[] { "ereg", "pcre" };
  }

  @Hide
  public static int getRegexpCacheSize()
  {
    return _regexpCache.getCapacity();
  }

  @Hide
  public static void setRegexpCacheSize(int size)
  {
    if (size < 0 || size == _regexpCache.getCapacity())
      return;

    _regexpCache = new LruCache<StringValue, RegexpCacheItem>(size);

    _eregCache = new LruCache<StringValue, Ereg>(size);

    _eregiCache = new LruCache<StringValue, Eregi>(size);

    _unicodeEregCache = new LruCache<UnicodeEregKey, UnicodeEreg>(size);

    _unicodeEregiCache = new LruCache<UnicodeEregKey, UnicodeEregi>(size);

    _replacementCache
      = new LruCache<StringValue, ArrayList<Replacement>>(size);
  }

  /**
   * Returns the index of the first match.
   *
   * @param env the calling environment
   */
  public static Value ereg(Env env,
                           Ereg regexp,
                           StringValue string,
                           @Optional @Reference Value regsV)
  {

    if (regexp.getRawRegexp().length() == 0) {
      env.warning(L.l("empty pattern argument"));
      return BooleanValue.FALSE;
    }

    return eregImpl(env, regexp, string, regsV);
  }

  /**
   * Returns the index of the first match.
   *
   * @param env the calling environment
   */
  public static Value eregi(Env env,
                            Eregi regexp,
                            StringValue string,
                            @Optional @Reference Value regsV)
  {

    if (regexp.getRawRegexp().length() == 0) {
      env.warning(L.l("empty pattern argument"));
      return BooleanValue.FALSE;
    }

    //  php/1511 : error when pattern argument is null or an empty string
    return eregImpl(env, regexp, string, regsV);
  }

  /**
   * Returns the index of the first match.
   *
   * @param env the calling environment
   */
  public static Value eregImpl(Env env,
                               Ereg regexp,
                               StringValue string,
                               Value regsV)
  {
    if (regexp == null)
      return BooleanValue.FALSE;

    // php/1512 : non-string pattern argument is converted to
    // an integer value and formatted as a string.

    /*
    if (! rawPattern.isString())
      rawPatternStr = rawPattern.toLongValue().toStringValue();
    else
      rawPatternStr = rawPattern.toStringValue();
    */

    RegexpState regexpState = RegexpState.create(env, regexp, string);

    if (regexpState.exec(env, string, 0) < 0) {
      RegexpState.free(env, regexpState);

      return BooleanValue.FALSE;
    }

    if (regsV != null && ! (regsV instanceof NullValue)) {
      ArrayValue regs = new ArrayValueImpl();
      regsV.set(regs);

      regs.put(LongValue.ZERO, regexpState.group(env));
      int count = regexpState.groupCount();

      for (int i = 1; i < count; i++) {
        StringValue group = regexpState.group(env, i);

        Value value;
        if (group == null || group.length() == 0)
          value = BooleanValue.FALSE;
        else
          value = group;

        regs.put(LongValue.create(i), value);
      }

      int len = regexpState.end() - regexpState.start();

      RegexpState.free(env, regexpState);

      if (len == 0)
        return LongValue.ONE;
      else
        return LongValue.create(len);
    }
    else {
      RegexpState.free(env, regexpState);

      return LongValue.ONE;
    }
  }

  public static Regexp compileRegexp(StringValue regexpValue)
  {
    try {
      return createRegexp(regexpValue);
    } catch (Exception e) {
      // XXX: should create special error regexp.
      log.log(Level.WARNING, e.toString(), e);

      return null;
    }
  }

  public static Regexp createRegexp(StringValue regexpValue)
  {
    try {
      return createRegexpImpl(regexpValue);
    }
    catch (IllegalRegexpException e) {
      throw new QuercusException(e);
    }
  }

  public static Regexp createRegexp(Env env, StringValue regexpValue)
  {
    try {
      return createRegexpImpl(regexpValue);
    }
    catch (IllegalRegexpException e) {
      log.log(Level.FINE, e.getMessage(), e);
      env.warning(e);

      return null;
    }
  }

  private static Regexp createRegexpImpl(StringValue regexpValue)
    throws IllegalRegexpException
  {
    if (regexpValue.length() < 2) {
      throw new QuercusException(
          L.l("Regexp pattern must have opening and closing delimiters"));
    }

    RegexpCacheItem cacheItem = _regexpCache.get(regexpValue);

    if (cacheItem == null) {
      cacheItem = new RegexpCacheItem(regexpValue);
        
      _regexpCache.putIfNew(regexpValue, cacheItem);
        
      cacheItem = _regexpCache.get(regexpValue);
    }
      
    return cacheItem.get();
  }

  public static Regexp []createRegexpArray(Value pattern)
  {
    if (pattern.isArray()) {
      ArrayValue array = (ArrayValue) pattern;

      Regexp []regexpArray = new Regexp[array.getSize()];

      int i = 0;
      for (Value value : array.values()) {
        Regexp regexp = createRegexp(value.toStringValue());
        regexpArray[i++] = regexp;
      }

      return regexpArray;
    }
    else {
      Regexp regexp = createRegexp(pattern.toStringValue());

      return new Regexp [] { regexp };
    }
  }

  public static Regexp []createRegexpArray(Env env, Value pattern)
  {
    try {
      if (pattern.isArray()) {
        ArrayValue array = pattern.toArrayValue(env);

        Regexp []regexpArray = new Regexp[array.getSize()];

        int i = 0;
        for (Value value : array.values()) {
          Regexp regexp = createRegexp(env, value.toStringValue(env));
          regexpArray[i++] = regexp;
        }

        return regexpArray;
      }
      else {
        Regexp regexp = createRegexp(env, pattern.toStringValue(env));

        return new Regexp [] { regexp };
      }
    } catch (Exception e) {
      env.warning(e);

      return null;
    }
  }

  public static Ereg createEreg(Env env, Value value)
  {
    try {
      StringValue regexpStr;

      if (value.isNull() || value.isBoolean())
        regexpStr = env.getEmptyString();
      else if (! value.isString())
        regexpStr = value.toLongValue().toStringValue();
      else
        regexpStr = value.toStringValue();

      Ereg ereg = _eregCache.get(regexpStr);

      if (ereg == null) {
        StringValue cleanPattern = cleanEregRegexp(regexpStr, false);

        ereg = new Ereg(cleanPattern);

        _eregCache.put(regexpStr, ereg);
      }

      return ereg;
    }
    catch (IllegalRegexpException e) {
      log.log(Level.FINE, e.getMessage(), e);
      env.warning(e);

      return null;
    }
  }

  public static Ereg createEreg(Value value)
  {
    try {
      StringValue regexpStr;

      if (value.isNull() || value.isBoolean())
        regexpStr = StringValue.EMPTY;
      else if (! value.isString())
        regexpStr = value.toLongValue().toStringValue();
      else
        regexpStr = value.toStringValue();

      Ereg ereg = _eregCache.get(regexpStr);

      if (ereg == null) {
        StringValue cleanPattern = cleanEregRegexp(regexpStr, false);

        ereg = new Ereg(cleanPattern);

        _eregCache.put(regexpStr, ereg);
      }

      return ereg;
    }
    catch (IllegalRegexpException e) {
      throw new QuercusException(e);
    }
  }

  public static Eregi createEregi(Env env, Value value)
  {
    try {
      StringValue regexpStr;

      if (value.isNull() || value.isBoolean())
        regexpStr = env.getEmptyString();
      else if (! value.isString())
        regexpStr = value.toLongValue().toStringValue();
      else
        regexpStr = value.toStringValue();

      Eregi eregi = _eregiCache.get(regexpStr);

      if (eregi == null) {
        StringValue cleanPattern = cleanEregRegexp(regexpStr, false);

        eregi = new Eregi(cleanPattern);

        _eregiCache.put(regexpStr, eregi);
      }

      return eregi;
    }
    catch (IllegalRegexpException e) {
      log.log(Level.FINE, e.getMessage(), e);
      env.warning(e);

      return null;
    }
  }

  public static Eregi createEregi(Value value)
  {
    try {
      StringValue regexpStr;

      if (value.isNull() || value.isBoolean())
        regexpStr = StringValue.EMPTY;
      else if (! value.isString())
        regexpStr = value.toLongValue().toStringValue();
      else
        regexpStr = value.toStringValue();

      Eregi eregi = _eregiCache.get(regexpStr);

      if (eregi == null) {
        StringValue cleanPattern = cleanEregRegexp(regexpStr, false);

        eregi = new Eregi(cleanPattern);

        _eregiCache.put(regexpStr, eregi);
      }

      return eregi;
    }
    catch (IllegalRegexpException e) {
      throw new QuercusException(e);
    }
  }

  public static UnicodeEreg createUnicodeEreg(Env env, StringValue pattern)
  {
    return createUnicodeEreg(env, pattern, MbstringModule.getEncoding(env));
  }

  public static UnicodeEreg createUnicodeEreg(Env env,
                                              StringValue pattern,
                                              String encoding)
  {
    try {
      UnicodeEregKey key = new UnicodeEregKey(pattern, encoding);

      UnicodeEreg ereg = _unicodeEregCache.get(key);

      if (ereg == null) {
        pattern = pattern.convertToUnicode(env, encoding);

        StringValue cleanPattern = cleanEregRegexp(pattern, false);

        ereg = new UnicodeEreg(cleanPattern);

        _unicodeEregCache.put(key, ereg);
      }

      return ereg;
    }
    catch (IllegalRegexpException e) {
      log.log(Level.FINE, e.getMessage(), e);
      env.warning(e);

      return null;
    }
  }

  public static UnicodeEregi createUnicodeEregi(Env env, StringValue pattern)
  {
    return createUnicodeEregi(env, pattern, MbstringModule.getEncoding(env));
  }

  public static UnicodeEregi createUnicodeEregi(Env env,
                                               StringValue pattern,
                                               String encoding)
  {
    try {
      UnicodeEregKey key = new UnicodeEregKey(pattern, encoding);

      UnicodeEregi ereg = _unicodeEregiCache.get(key);

      if (ereg == null) {
        pattern = pattern.convertToUnicode(env, encoding);

        StringValue cleanPattern = cleanEregRegexp(pattern, false);

        ereg = new UnicodeEregi(cleanPattern);

        _unicodeEregiCache.put(key, ereg);
      }

      return ereg;
    }
    catch (IllegalRegexpException e) {
      log.log(Level.FINE, e.getMessage(), e);
      env.warning(e);

      return null;
    }
  }

  /**
   * Returns the last regexp error
   */
  public static Value preg_last_error(Env env)
  {
    return LongValue.ZERO;
  }

  public static Value preg_match(Env env,
                                 Regexp regexp,
                                 StringValue subject,
                                 @Optional @Reference Value matchRef,
                                 @Optional int flags,
                                 @Optional int offset)
  {
    if (regexp == null)
      return BooleanValue.FALSE;

    StringValue empty = subject.EMPTY;

    RegexpState regexpState = RegexpState.create(env, regexp, subject);

    ArrayValue regs;

    if (matchRef.isDefault())
      regs = null;
    else
      regs = new ArrayValueImpl();

    if (regexpState == null || regexpState.exec(env, subject, offset) < 0) {
      if (regs != null)
        matchRef.set(regs);

      env.freeRegexpState(regexpState);

      return LongValue.ZERO;
    }

    boolean isOffsetCapture = (flags & PREG_OFFSET_CAPTURE) != 0;

    if (regs != null) {
      if (isOffsetCapture) {
        ArrayValueImpl part = new ArrayValueImpl();
        part.append(regexpState.group(env));
        part.append(LongValue.create(regexpState.start()));

        regs.put(LongValue.ZERO, part);
      }
      else
        regs.put(LongValue.ZERO, regexpState.group(env));

      int count = regexpState.groupCount();
      for (int i = 1; i < count; i++) {
        if (! regexpState.isMatchedGroup(i))
          continue;

        StringValue group = regexpState.group(env, i);

        if (isOffsetCapture) {
          // php/151u
          // add unmatched groups first
          for (int j = regs.getSize(); j < i; j++) {
            ArrayValue part = new ArrayValueImpl();

            part.append(empty);
            part.append(LongValue.MINUS_ONE);

            regs.put(LongValue.create(j), part);
          }

          ArrayValueImpl part = new ArrayValueImpl();
          part.append(group);
          part.append(LongValue.create(regexpState.start(i)));

          StringValue name = regexpState.getGroupName(i);
          if (name != null)
            regs.put(name, part);

          regs.put(LongValue.create(i), part);
        }
        else {
          // php/151u
          // add unmatched groups first
          for (int j = regs.getSize(); j < i; j++) {
            regs.put(LongValue.create(j), empty);
          }

          StringValue name = regexp.getGroupName(i);
          if (name != null)
            regs.put(name, group);

          regs.put(LongValue.create(i), group);
        }
      }

      matchRef.set(regs);
    }

    env.freeRegexpState(regexpState);

    return LongValue.ONE;
  }

  /**
   * Returns the number of full pattern matches or FALSE on error.
   *
   * @param env the calling environment
   */
  public static Value preg_match_all(Env env,
                                     Regexp regexp,
                                     StringValue subject,
                                     @Reference Value matchRef,
                                     @Optional("PREG_PATTERN_ORDER") int flags,
                                     @Optional int offset)
  {
    if (regexp == null)
      return BooleanValue.FALSE;

    if (offset < 0)
      offset = subject.length() + offset;

    if ((flags & PREG_PATTERN_ORDER) == 0) {
      // php/152m
      if ((flags & PREG_SET_ORDER) == 0) {
        flags = flags | PREG_PATTERN_ORDER;
      }
    }
    else {
      if ((flags & PREG_SET_ORDER) != 0) {
        env.warning((
            L.l("Cannot combine PREG_PATTER_ORDER and PREG_SET_ORDER")));
        return BooleanValue.FALSE;
      }
    }

    RegexpState regexpState = RegexpState.create(env, regexp, subject);

    if (offset > 0)
      regexpState.setFirst(offset);

    ArrayValue matches;

    if (matchRef instanceof ArrayValue)
      matches = (ArrayValue) matchRef;
    else
      matches = new ArrayValueImpl();

    matches.clear();

    matchRef.set(matches);

    Value result = null;

    if ((flags & PREG_PATTERN_ORDER) != 0) {
      result = pregMatchAllPatternOrder(env,
                                        regexpState,
                                        subject,
                                        matches,
                                        flags,
                                        offset);
    }
    else if ((flags & PREG_SET_ORDER) != 0) {
      result = pregMatchAllSetOrder(env,
                                    regexp,
                                    regexpState,
                                    subject,
                                    matches,
                                    flags,
                                    offset);
    }
    else
      throw new UnsupportedOperationException();

    env.freeRegexpState(regexpState);

    return result;
  }

  /**
   * Returns the index of the first match.
   *
   * @param env the calling environment
   */
  public static LongValue pregMatchAllPatternOrder(Env env,
                                                   RegexpState regexpState,
                                                   StringValue subject,
                                                   ArrayValue matches,
                                                   int flags,
                                                   int offset)
  {
    int groupCount = regexpState == null ? 0 : regexpState.groupCount();

    ArrayValue []matchList = new ArrayValue[groupCount + 1];

    StringValue emptyStr = subject.EMPTY;

    for (int j = 0; j < groupCount; j++) {
      ArrayValue values = new ArrayValueImpl();

      Value patternName = regexpState.getGroupName(j);

      // XXX: named subpatterns causing conflicts with array indexes?
      if (patternName != null)
        matches.put(patternName, values);

      matches.put(values);
      matchList[j] = values;
    }

    int count = 0;

    while (regexpState.find()) {
      count++;

      for (int j = 0; j < groupCount; j++) {
        ArrayValue values = matchList[j];

        if (! regexpState.isMatchedGroup(j)) {
          /*
          if (j == groupCount || (flags & PREG_OFFSET_CAPTURE) == 0)
            values.put(emptyStr);
          else {
            Value result = new ArrayValueImpl();

            result.put(emptyStr);
            result.put(LongValue.MINUS_ONE);

            values.put(result);
          }
          */

          values.put(emptyStr);

          continue;
        }

        StringValue groupValue = regexpState.group(env, j);

        Value result = NullValue.NULL;

        if (groupValue != null) {
          if ((flags & PREG_OFFSET_CAPTURE) != 0) {
            result = new ArrayValueImpl();
            result.put(groupValue);

            result.put(LongValue.create(regexpState.getBegin(j)));
          } else {
            result = groupValue;
          }
        }

        values.put(result);
      }
    }

    return LongValue.create(count);
  }

  /**
   * Returns the index of the first match.
   *
   * @param env the calling environment
   */
  private static LongValue pregMatchAllSetOrder(Env env,
                                                Regexp regexp,
                                                RegexpState regexpState,
                                                StringValue subject,
                                                ArrayValue matches,
                                                int flags,
                                                int offset)
  {
    if (regexpState == null || ! regexpState.find()) {
      return LongValue.ZERO;
    }

    StringValue empty = subject.EMPTY;

    int count = 0;

    do {
      count++;

      ArrayValue matchResult = new ArrayValueImpl();
      matches.put(matchResult);

      int groupCount = regexpState.groupCount();

      for (int i = 0; i < groupCount; i++) {
        int start = regexpState.start(i);
        int end = regexpState.end(i);

        // php/1542
        // php/1545
        // group is unmatched, skip
        if (start < 0 || end < start
            || (end == start && i == groupCount - 1))
          continue;

        StringValue groupValue = regexpState.group(env, i);

        Value result = NullValue.NULL;

        if (groupValue != null) {
          // php/1544
          Value patternName = regexpState.getGroupName(i);

          if (patternName != null)
            matchResult.put(patternName, groupValue);

          if ((flags & PREG_OFFSET_CAPTURE) != 0) {

            // php/152n
            // add unmatched groups first
            for (int j = matchResult.getSize(); j < i; j++) {
              ArrayValue part = new ArrayValueImpl();

              part.append(empty);
              part.append(LongValue.MINUS_ONE);

              matchResult.put(LongValue.create(j), part);
            }

            result = new ArrayValueImpl();

            result.put(groupValue);
            result.put(LongValue.create(start));
          } else {
            // php/
            // add any unmatched groups that was skipped
            for (int j = matchResult.getSize(); j < i; j++) {
              matchResult.put(LongValue.create(j), empty);
            }

            result = groupValue;
          }
        }

        matchResult.put(result);
      }
    } while (regexpState.find());

    return LongValue.create(count);
  }

  /**
   * Quotes regexp values
   */
  public static StringValue preg_quote(StringValue string,
                                       @Optional StringValue delim)
  {
    StringValue sb = string.createStringBuilder();

    boolean []extra = null;

    if (delim != null && delim.length() > 0) {
      extra = new boolean[256];

      for (int i = 0; i < delim.length(); i++)
        extra[delim.charAt(i)] = true;
    }

    int length = string.length();
    for (int i = 0; i < length; i++) {
      char ch = string.charAt(i);

      if (ch >= 256)
        sb.append(ch);
      else if (PREG_QUOTE[ch]) {
        sb.append('\\');
        sb.append(ch);
      }
      else if (extra != null && extra[ch]) {
        sb.append('\\');
        sb.append(ch);
      }
      else if (ch == 0) {
        // php/153q
        sb.append("\\000");
      }
      else
        sb.append(ch);
    }

    return sb;
  }

  /**
   * Loops through subject if subject is array of strings
   *
   * @param env
   * @param pattern string or array
   * @param replacement string or array
   * @param subject string or array
   * @param limit
   * @param count
   * @return
   */
  @UsesSymbolTable
  public static Value preg_replace(Env env,
                                   Regexp regexp,
                                   Value replacement,
                                   Value subject,
                                   @Optional("-1") long limit,
                                   @Optional @Reference Value count)
  {
    if (regexp == null)
      return BooleanValue.FALSE;

    if (count != null)
      count.set(LongValue.ZERO);

    try {
      if (subject instanceof ArrayValue) {
        ArrayValue result = new ArrayValueImpl();

        for (Map.Entry<Value,Value> entry : ((ArrayValue) subject).entrySet()) {
          Value key = entry.getKey();
          Value value = entry.getValue();

          result.put(key, pregReplace(env,
                                      regexp,
                                      replacement,
                                      value.toStringValue(),
                                      limit,
                                      count));
        }

        return result;

      }
      else if (subject.isset()) {
        return pregReplace(env,
                           regexp,
                           replacement,
                           subject.toStringValue(),
                           limit, count);
      } else
        return env.getEmptyString();
    }
    catch (IllegalRegexpException e) {
      log.log(Level.FINE, e.getMessage(), e);
      env.warning(e);

      return BooleanValue.FALSE;
    }
  }

  /**
   * Replaces values using regexps
   */
  private static Value pregReplace(Env env,
                                   Regexp regexp,
                                   Value replacement,
                                   StringValue subject,
                                   @Optional("-1") long limit,
                                   Value countV)
    throws IllegalRegexpException
  {
    StringValue string = subject;

    if (limit < 0)
      limit = LONG_MAX;

    if (replacement.isArray()) {
      ArrayValue replacementArray = (ArrayValue) replacement;

      Iterator<Value> replacementIter = replacementArray.values().iterator();

      StringValue replacementStr;

      if (replacementIter.hasNext())
        replacementStr = replacementIter.next().toStringValue();
      else
        replacementStr = env.getEmptyString();

      string = pregReplaceString(env,
                                 regexp,
                                 replacementStr,
                                 string,
                                 limit,
                                 countV);
    } else {
      string = pregReplaceString(env,
                                 regexp,
                                 replacement.toStringValue(),
                                 string,
                                 limit,
                                 countV);
    }

    if (string != null)
      return string;
    else
      return NullValue.NULL;
  }

  /**
   * Loops through subject if subject is array of strings
   *
   * @param env
   * @param pattern string or array
   * @param replacement string or array
   * @param subject string or array
   * @param limit
   * @param count
   * @return
   */
  @UsesSymbolTable
  public static Value preg_replace(Env env,
                                   Value pattern,
                                   Value replacement,
                                   Value subject,
                                   @Optional("-1") long limit,
                                   @Optional @Reference Value count)
  {
    try {
      Regexp []regexpList = createRegexpArray(env, pattern);

      if (regexpList == null)
        return NullValue.NULL;

      if (subject instanceof ArrayValue) {
        ArrayValue result = new ArrayValueImpl();

        for (Value value : ((ArrayValue) subject).values()) {
          result.put(pregReplace(env,
                                 regexpList,
                                 replacement,
                                 value.toStringValue(),
                                 limit,
                                 count));
        }

        return result;

      }
      else if (subject.isset()) {
        return pregReplace(env,
                           regexpList,
                           replacement,
                           subject.toStringValue(),
                           limit, count);
      } else
        return env.getEmptyString();
    }
    catch (IllegalRegexpException e) {
      log.log(Level.FINE, e.getMessage(), e);
      env.warning(e);

      return BooleanValue.FALSE;
    }
  }

  /**
   * Replaces values using regexps
   */
  private static Value pregReplace(Env env,
                                   Regexp []regexpList,
                                   Value replacement,
                                   StringValue subject,
                                   @Optional("-1") long limit,
                                   Value countV)
    throws IllegalRegexpException
  {
    StringValue string = subject;

    if (limit < 0)
      limit = LONG_MAX;

    if (replacement.isArray()) {
      ArrayValue replacementArray = (ArrayValue) replacement;

      Iterator<Value> replacementIter = replacementArray.values().iterator();

      for (int i = 0; i < regexpList.length; i++) {
        StringValue replacementStr;

        if (replacementIter.hasNext())
          replacementStr = replacementIter.next().toStringValue();
        else
          replacementStr = env.getEmptyString();

        string = pregReplaceString(env,
                                   regexpList[i],
                                   replacementStr,
                                   string,
                                   limit,
                                   countV);
      }
    } else {
      for (int i = 0; i < regexpList.length; i++) {
        string = pregReplaceString(env,
                                   regexpList[i],
                                   replacement.toStringValue(),
                                   string,
                                   limit,
                                   countV);
      }
    }

    if (string != null)
      return string;
    else
      return NullValue.NULL;
  }

  /**
   * replaces values using regexps and callback fun
   * @param env
   * @param patternString
   * @param fun
   * @param subject
   * @param limit
   * @param countV
   * @return subject with everything replaced
   */
  private static StringValue pregReplaceCallbackImpl(Env env,
                                                     Regexp regexp,
                                                     Callable fun,
                                                     StringValue subject,
                                                     long limit,
                                                     Value countV)
    throws IllegalRegexpException
  {
    StringValue empty = subject.EMPTY;

    long numberOfMatches = 0;

    if (limit < 0)
      limit = LONG_MAX;

    RegexpState regexpState = RegexpState.create(env, regexp);

    regexpState.setSubject(env, subject);

    StringValue result = subject.createStringBuilder();
    int tail = 0;

    while (regexpState.find() && numberOfMatches < limit) {
      // Increment countV (note: if countV != null, then it should be a Var)
      if (countV != null && countV instanceof Var) {
        long count = countV.toValue().toLong();
        countV.set(LongValue.create(count + 1));
      }

      int start = regexpState.start();
      if (tail < start)
        result = result.append(regexpState.substring(env, tail, start));

      ArrayValue regs = new ArrayValueImpl();

      for (int i = 0; i < regexpState.groupCount(); i++) {
        StringValue group = regexpState.group(env, i);

        if (group != null && !group.isEmpty()) // php/154b
          regs.put(group);
        /* PHP's preg_replace_callback does not return empty groups
        else
          regs.put(empty);
*/
      }

      Value replacement = fun.call(env, regs);

      result = result.append(replacement);

      tail = regexpState.end();

      numberOfMatches++;
    }

    if (tail < regexpState.getSubjectLength())
      result = result.append(regexpState.substring(env, tail));

    env.freeRegexpState(regexpState);

    return result;
  }

  static StringValue pregReplaceString(Env env,
                                       Regexp regexp,
                                       StringValue replacement,
                                       StringValue subject,
                                       long limit,
                                       Value countV)
  {
    RegexpState regexpState = RegexpState.create(env, regexp);

    if (! regexpState.setSubject(env, subject))
      return null;

    // check for e modifier in patternString
    boolean isEval = regexp.isEval();

    ArrayList<Replacement> replacementProgram
      = _replacementCache.get(replacement);

    if (replacementProgram == null) {
      replacementProgram = compileReplacement(env, replacement, isEval);
      if (replacementProgram == null)
        return null;

      _replacementCache.put(replacement, replacementProgram);
    }

    StringValue result = pregReplaceStringImpl(env,
                                               regexp,
                                               regexpState,
                                               replacementProgram,
                                               subject,
                                               limit,
                                               countV,
                                               isEval);

    env.freeRegexpState(regexpState);

    return result;
  }

  /**
   * Replaces values using regexps
   */
  public static Value ereg_replace(Env env,
                                   Value regexpValue,
                                   Value replacement,
                                   StringValue subject)
  {
    StringValue regexpStr;

    if (regexpValue.isLong())
      regexpStr = env.createString((char) regexpValue.toInt());
    else
      regexpStr = regexpValue.toStringValue(env);

    if (regexpStr.length() == 0) {
      env.warning(L.l("empty pattern argument"));
      return BooleanValue.FALSE;
    }

    Ereg regexp = createEreg(env, regexpStr);

    return eregReplaceImpl(env, regexp, replacement, subject, false);
  }

  /**
   * Replaces values using regexps
   */
  public static Value eregi_replace(Env env,
                                    Value regexpValue,
                                    Value replacement,
                                    StringValue subject)
  {
    StringValue regexpStr;

    if (regexpValue.isLong())
      regexpStr = env.createString((char) regexpValue.toInt());
    else
      regexpStr = regexpValue.toStringValue(env);

    if (regexpStr.length() == 0) {
      env.warning(L.l("empty pattern argument"));
      return BooleanValue.FALSE;
    }

    Ereg regexp = createEregi(env, regexpStr);

    return eregReplaceImpl(env, regexp, replacement, subject, true);
  }

  /**
   * Replaces values using regexps
   */

  public static Value eregReplaceImpl(Env env,
                                      Ereg regexp,
                                      Value replacement,
                                      StringValue subject,
                                      boolean isCaseInsensitive)
  {
    StringValue replacementStr;

    // php/150u : If a non-string type argument is passed
    // for the pattern or replacement argument, it is
    // converted to a string of length 1 that contains
    // a single character.

    if (replacement instanceof NullValue) {
      replacementStr = env.getEmptyString();
    } else if (replacement instanceof StringValue) {
      replacementStr = replacement.toStringValue();
    } else {
      replacementStr = env.createString(
        String.valueOf((char) replacement.toLong()));
    }

    RegexpState regexpState = RegexpState.create(env, regexp);

    regexpState.setSubject(env, subject);

    ArrayList<Replacement> replacementProgram
      = _replacementCache.get(replacementStr);

    if (replacementProgram == null) {
      replacementProgram = compileReplacement(env, replacementStr, false);
      if (replacementProgram == null)
        return null;
      _replacementCache.put(replacementStr, replacementProgram);
    }

    StringValue result = pregReplaceStringImpl(env,
                                               regexp,
                                               regexpState,
                                               replacementProgram,
                                               subject,
                                               -1,
                                               NullValue.NULL,
                                               false);

    env.freeRegexpState(regexpState);

    return result;
  }

  /**
   * Replaces values using regexps
   */
  private static StringValue
      pregReplaceStringImpl(Env env,
                            Regexp regexp,
                            RegexpState regexpState,
                            ArrayList<Replacement> replacementProgram,
                            StringValue subject,
                            long limit,
                            Value countV,
                            boolean isEval)
  {
    if (limit < 0)
      limit = LONG_MAX;

    StringValue result = subject.createStringBuilder();

    int tail = 0;
    boolean isMatched = false;

    int replacementLen = replacementProgram.size();

    while (limit-- > 0 && regexpState.find()) {
      isMatched = true;

      // Increment countV (note: if countV != null, then it should be a Var)
      if (countV != null && countV instanceof Var) {
        countV.set(LongValue.create(countV.toLong() + 1));
      }

      // append all text up to match
      int start = regexpState.start();
      if (tail < start)
        result = result.append(regexpState.substring(env, tail, start));

      // if isEval then append replacement evaluated as PHP code
      // else append replacement string
      if (isEval) {
        StringValue evalString = subject.createStringBuilder();

        try {
          for (int i = 0; i < replacementLen; i++) {
            Replacement replacement = replacementProgram.get(i);

            evalString = replacement.eval(env, evalString, regexpState);
          }
        } catch (Exception e) {
          env.warning(e);
        }

        try {
          if (evalString.length() > 0) { // php/152z
            result = result.append(env.evalCode(evalString.toString()));
          }
        } catch (Exception e) {
          env.warning(e);
        }

      } else {
        for (int i = 0; i < replacementLen; i++) {
          Replacement replacement = replacementProgram.get(i);

          result = replacement.eval(env, result, regexpState);
        }
      }

      tail = regexpState.end();
    }

    if (! isMatched)
      return subject;

    if (tail < regexpState.getSubjectLength())
      result = result.append(regexpState.substring(env, tail));

    return result;
  }

  /**
   * Loops through subject if subject is array of strings
   *
   * @param env
   * @param pattern
   * @param fun
   * @param subject
   * @param limit
   * @param count
   * @return
   */
  public static Value preg_replace_callback(Env env,
                                            Regexp regexp,
                                            @NotNull Callable fun,
                                            Value subject,
                                            @Optional("-1") long limit,
                                            @Optional @Reference Value count)
  {
    if (fun == null) {
      env.warning(
          L.l("callable argument can't be null in preg_replace_callback"));
      return subject;
    }

    if (regexp == null)
      return NullValue.NULL;
    else if (regexp.isEval()) {
      env.warning(L.l("regexp can't use /e preg_replace_callback /{0}/",
                      regexp.getPattern()));

      return NullValue.NULL;
    }

    // php/153s
    if (count != null)
      count.set(LongValue.ZERO);

    try {
      if (subject instanceof ArrayValue) {
        ArrayValue result = new ArrayValueImpl();

        for (Value value : ((ArrayValue) subject).values()) {
          result.put(pregReplaceCallback(env,
                                         regexp,
                                         fun,
                                         value.toStringValue(),
                                         limit,
                                         count));
        }

        return result;
      } else if (subject.isset()) {
        return pregReplaceCallback(env,
                                   regexp,
                                   fun,
                                   subject.toStringValue(),
                                   limit,
                                   count);
      } else {
        return env.getEmptyString();
      }
    }
    catch (IllegalRegexpException e) {
      log.log(Level.FINE, e.getMessage(), e);
      env.warning(e);

      return BooleanValue.FALSE;
    }
  }

  /**
   * Loops through subject if subject is array of strings
   */
  public static Value preg_replace_callback(Env env,
                                            Value regexpValue,
                                            Callable fun,
                                            Value subject,
                                            @Optional("-1") long limit,
                                            @Optional @Reference Value count)
  {
    if (! regexpValue.isArray()) {
      Regexp regexp = createRegexp(env, regexpValue.toStringValue());


      return preg_replace_callback(env, regexp,
                                   fun, subject, limit, count);
    }

    Regexp []regexpList = createRegexpArray(env, regexpValue);

    if (regexpList == null)
      return NullValue.NULL;

    try {
      if (subject instanceof ArrayValue) {
        ArrayValue result = new ArrayValueImpl();

        for (Value value : ((ArrayValue) subject).values()) {
          result.put(pregReplaceCallback(env,
                                         regexpList,
                                         fun,
                                         value.toStringValue(),
                                         limit,
                                         count));
        }

        return result;

      } else if (subject.isset()) {
        return pregReplaceCallback(env,
                                   regexpList,
                                   fun,
                                   subject.toStringValue(),
                                   limit,
                                   count);
      } else {
        return env.getEmptyString();
      }
    }
    catch (IllegalRegexpException e) {
      log.log(Level.FINE, e.getMessage(), e);
      env.warning(e);

      return BooleanValue.FALSE;
    }
  }

  /**
   * Replaces values using regexps
   */
  private static Value pregReplaceCallback(Env env,
                                           Regexp regexp,
                                           Callable fun,
                                           StringValue subject,
                                           @Optional("-1") long limit,
                                           @Optional @Reference Value countV)
    throws IllegalRegexpException
  {
    if (limit < 0)
      limit = LONG_MAX;

    if (! subject.isset()) {
      return env.getEmptyString();
    }
    else {
      return pregReplaceCallbackImpl(env,
                                     regexp,
                                     fun,
                                     subject,
                                     limit,
                                     countV);
    }
  }

  /**
   * Replaces values using regexps
   */
  private static Value pregReplaceCallback(Env env,
                                           Regexp []regexpList,
                                           Callable fun,
                                           StringValue subject,
                                           @Optional("-1") long limit,
                                           @Optional @Reference Value countV)
    throws IllegalRegexpException
  {
    if (limit < 0)
      limit = LONG_MAX;

    if (! subject.isset()) {
      return env.getEmptyString();
    }
    else {
      for (int i = 0; i < regexpList.length; i++) {
        subject = pregReplaceCallbackImpl(env,
                                          regexpList[i],
                                          fun,
                                          subject,
                                          limit,
                                          countV);
      }

      return subject;
    }
  }

  /**
   * Returns array of substrings or
   * of arrays ([0] => substring [1] => offset) if
   * PREG_SPLIT_OFFSET_CAPTURE is set
   *
   * @param env the calling environment
   */
  public static Value preg_split(Env env,
                                 Regexp regexp,
                                 StringValue string,
                                 @Optional("-1") long limit,
                                 @Optional int flags)
  {
    if (regexp == null)
      return BooleanValue.FALSE;

    if (limit <= 0)
      limit = LONG_MAX;

    StringValue empty = StringValue.EMPTY;

    RegexpState regexpState = RegexpState.create(env, regexp);
    regexpState.setSubject(env, string);

    ArrayValue result = new ArrayValueImpl();

    int head = 0;
    long count = 0;

    boolean allowEmpty = (flags & PREG_SPLIT_NO_EMPTY) == 0;
    boolean isCaptureOffset = (flags & PREG_SPLIT_OFFSET_CAPTURE) != 0;
    boolean isCaptureDelim = (flags & PREG_SPLIT_DELIM_CAPTURE) != 0;

    GroupNeighborMap neighborMap
      = new GroupNeighborMap(regexp.getPattern(), regexpState.groupCount());

    while (regexpState.find()) {
      int startPosition = head;
      StringValue unmatched;

      // Get non-matching sequence
      if (count == limit - 1) {
        unmatched = regexpState.substring(env, head);
        head = regexpState.getSubjectLength();
      }
      else {
        // php/153y
        unmatched = regexpState.substring(env, head, regexpState.start());
        head = regexpState.end();
      }

      // Append non-matching sequence
      if (unmatched.length() != 0 || allowEmpty) {
        if (isCaptureOffset) {
          ArrayValue part = new ArrayValueImpl();

          part.put(unmatched);
          part.put(LongValue.create(startPosition));

          result.put(part);
        }
        else {
          result.put(unmatched);
        }

        count++;
      }

      if (count == limit)
        break;

      // Append parameterized delimiters
      if (isCaptureDelim) {
        for (int i = 1; i < regexpState.groupCount(); i++) {
          int start = regexpState.start(i);
          int end = regexpState.end(i);

          // Skip empty groups
          if (! regexpState.isMatchedGroup(i)) {
            continue;
          }

          // Append empty OR neighboring groups that were skipped
          // php/152r
          if (allowEmpty) {
            int group = i;
            while (neighborMap.hasNeighbor(group)) {
              group = neighborMap.getNeighbor(group);

              if (regexpState.isMatchedGroup(group))
                break;

              if (isCaptureOffset) {
                ArrayValue part = new ArrayValueImpl();

                part.put(empty);
                part.put(LongValue.create(startPosition));

                result.put(part);
              }
              else
                result.put(empty);
            }
          }

          if (end - start <= 0 && ! allowEmpty) {
            continue;
          }

          StringValue groupValue = regexpState.group(env, i);

          if (isCaptureOffset) {
            ArrayValue part = new ArrayValueImpl();

            part.put(groupValue);
            part.put(LongValue.create(start));

            result.put(part);
          }
          else {
            result.put(groupValue);
          }
        }
      }
    }

    // Append non-matching sequence at the end
    if (count < limit
        && (head < regexpState.getSubjectLength() || allowEmpty)) {
      if (isCaptureOffset) {
        ArrayValue part = new ArrayValueImpl();

        part.put(regexpState.substring(env, head));
        part.put(LongValue.create(head));

        result.put(part);
      }
      else {
        result.put(regexpState.substring(env, head));
      }
    }

    env.freeRegexpState(regexpState);

    return result;
  }

  /**
   * Makes a regexp for a case-insensitive match.
   */
  public static StringValue sql_regcase(StringValue string)
  {
    StringValue sb = string.createStringBuilder();

    int len = string.length();
    for (int i = 0; i < len; i++) {
      char ch = string.charAt(i);

      if (Character.isLowerCase(ch)) {
        sb.append('[');
        sb.append(Character.toUpperCase(ch));
        sb.append(ch);
        sb.append(']');
      }
      else if (Character.isUpperCase(ch)) {
        sb.append('[');
        sb.append(ch);
        sb.append(Character.toLowerCase(ch));
        sb.append(']');
      }
      else
        sb.append(ch);
    }

    return sb;
  }

  /**
   * Returns an array of strings produces from splitting the passed string
   * around the provided pattern.  The pattern is case sensitive.
   *
   * @param patternString the pattern
   * @param string the string to split
   * @param limit if specified, the maximum number of elements in the array
   * @return an array of strings split around the pattern string
   */
  public static Value split(Env env,
                            Ereg regexp,
                            StringValue string,
                            @Optional("-1") long limit)
  {
    return splitImpl(env, regexp, string, limit);
  }

  /**
   * Returns an array of strings produces from splitting the passed string
   * around the provided pattern.  The pattern is case insensitive.
   *
   * @param patternString the pattern
   * @param string the string to split
   * @param limit if specified, the maximum number of elements in the array
   * @return an array of strings split around the pattern string
   */
  public static Value spliti(Env env,
                             Eregi regexp,
                             StringValue string,
                             @Optional("-1") long limit)
  {
    return splitImpl(env, regexp, string, limit);
  }

  /**
   * Split string into array by regular expression
   *
   * @param env the calling environment
   */

  private static Value splitImpl(Env env,
                                 Ereg regexp,
                                 StringValue string,
                                 long limit)
  {
    if (limit < 0)
      limit = LONG_MAX;

    // php/151c

    RegexpState regexpState = RegexpState.create(env, regexp);

    regexpState.setSubject(env, string);

    ArrayValue result = new ArrayValueImpl();

    long count = 0;
    int head = 0;

    while (regexpState.find() && count < limit) {
      StringValue value;
      if (count == limit - 1) {
        value = regexpState.substring(env, head);
        head = string.length();
      } else {
        value = regexpState.substring(env, head, regexpState.start());
        head = regexpState.end();
      }

      result.put(value);

      count++;
    }

    if (head <= string.length() && count != limit) {
      result.put(regexpState.substring(env, head));
    }

    env.freeRegexpState(regexpState);

    return result;
  }

  /**
   * Returns an array of all the values that matched the given pattern if the
   * flag no flag is passed.  Otherwise it will return an array of all the
   * values that did not match.
   *
   * @param patternString the pattern
   * @param input the array to check the pattern against
   * @param flag 0 for matching and 1 for elements that do not match
   * @return an array of either matching elements are non-matching elements
   */
  public static Value preg_grep(Env env,
                                Regexp regexp,
                                ArrayValue input,
                                @Optional("0") int flag)
  {
    if (input == null)
      return NullValue.NULL;

    if (regexp == null)
      return BooleanValue.FALSE;

    RegexpState regexpState = RegexpState.create(env, regexp);

    ArrayValue matchArray = new ArrayValueImpl();

    for (ArrayValue.Entry entry = input.getHead();
         entry != null;
         entry = entry.getNext()) {
      // php/153v
      Value entryValue = entry.getRawValue();
      Value entryKey = entry.getKey();

      boolean found = regexpState.find(env, entryValue.toStringValue());

      if (! found && flag == PREG_GREP_INVERT)
        matchArray.append(entryKey, entryValue);
      else if (found && flag != PREG_GREP_INVERT)
        matchArray.append(entryKey, entryValue);
    }

    env.freeRegexpState(regexpState);

    return matchArray;
  }

  private static StringValue addDelimiters(Env env,
                                           StringValue str,
                                           String startDelim,
                                           String endDelim)
  {
    StringValue sb = str.createStringBuilder();

    sb = sb.appendBytes(startDelim);
    sb = sb.append(str);
    sb = sb.appendBytes(endDelim);

    return sb;
  }

  private static ArrayList<Replacement>
    compileReplacement(Env env, StringValue replacement, boolean isEval)
  {
    ArrayList<Replacement> program = new ArrayList<Replacement>();
    StringBuilder text = new StringBuilder();

    for (int i = 0; i < replacement.length(); i++) {
      char ch = replacement.charAt(i);

      if ((ch == '\\' || ch == '$') && i + 1 < replacement.length()) {
        char digit;

        if ('0' <= (digit = replacement.charAt(i + 1)) && digit <= '9') {
          int group = digit - '0';
          i++;

          if (i + 1 < replacement.length()
          && '0' <= (digit = replacement.charAt(i + 1)) && digit <= '9') {
            group = 10 * group + digit - '0';
            i++;
          }

          if (text.length() > 0) {
            program.add(new TextReplacement(text));
          }

          if (isEval)
            program.add(new GroupEscapeReplacement(group));
          else
            program.add(new GroupReplacement(group));

          text.setLength(0);
        }
        else if (ch == '\\') {
          i++;

          if (digit != '\\') {
            text.append('\\');
          }
          text.append(digit);
          // took out test for ch == '$' because must be true
          //} else if (ch == '$' && digit == '{') {
        } else if (digit == '{') {
          i += 2;

          int group = 0;

          while (i < replacement.length()
                 && '0' <= (digit = replacement.charAt(i)) && digit <= '9') {
            group = 10 * group + digit - '0';

            i++;
          }

          if (digit != '}') {
//             env.warning(L.l("expected '}' to close replacement at '{1}' " +
//                 "replacement {0}", (char) digit, replacement));
            text.append("${");
            text.append(group);
            continue;
          }

          if (text.length() > 0)
            program.add(new TextReplacement(text));

          if (isEval)
            program.add(new GroupEscapeReplacement(group));
          else
            program.add(new GroupReplacement(group));

          text.setLength(0);
        }
        else
          text.append(ch);
      }
      else
        text.append(ch);
    }

    if (text.length() > 0)
      program.add(new TextReplacement(text));

    return program;
  }

  /**
   * Cleans the regexp from valid values that the Java regexps can't handle.
   * Ereg has a different syntax so need to handle it differently from preg.
   */
  private static StringValue cleanEregRegexp(StringValue regexp,
                                             boolean isComments)
  {
    int len = regexp.length();

    StringValue sb = regexp.createStringBuilder();
    char quote = 0;

    for (int i = 0; i < len; i++) {
      char ch = regexp.charAt(i);

      switch (ch) {
      case '\\':
        if (quote == '[') {
          sb = sb.appendByte('\\');
          sb = sb.appendByte('\\');
          continue;
        }

        if (i + 1 < len) {
          i++;

          ch = regexp.charAt(i);

          if (
              ch == '0'
              || '1' <= ch && ch <= '3'
              && i + 1 < len
              && '0' <= regexp.charAt(i + 1)
              && ch <= '7'
              ) {
            // Java's regexp requires \0 for octal

            sb = sb.appendByte('\\');
            sb = sb.appendByte('0');
            sb = sb.appendByte(ch);
          }
          else if (ch == 'x' && i + 1 < len && regexp.charAt(i + 1) == '{') {
            sb = sb.appendByte('\\');

            int tail = regexp.indexOf('}', i + 1);

            if (tail > 0) {
              StringValue hex = regexp.substring(i + 2, tail);

              int length = hex.length();

              if (length == 1)
                sb = sb.appendBytes("x0" + hex);
              else if (length == 2)
                sb = sb.appendBytes("x" + hex);
              else if (length == 3)
                sb = sb.appendBytes("u0" + hex);
              else if (length == 4)
                sb = sb.appendBytes("u" + hex);
              else
                throw new QuercusRuntimeException(L.l("illegal hex escape"));

              i = tail;
            }
            else {
              sb = sb.appendByte('\\');
              sb = sb.appendByte('x');
            }
          }
          else if (Character.isLetter(ch)) {
            switch (ch) {
            case 'a':
            case 'c':
            case 'e':
            case 'f':
            case 'n':
            case 'r':
            case 't':
            case 'x':
            case 'd':
            case 'D':
            case 's':
            case 'S':
            case 'w':
            case 'W':
            case 'b':
            case 'B':
            case 'A':
            case 'Z':
            case 'z':
            case 'G':
            case 'p': //XXX: need to translate PHP properties to Java ones
            case 'P': //XXX: need to translate PHP properties to Java ones
            case 'X':
              //case 'C': byte matching, not supported
              sb = sb.appendByte('\\');
              sb = sb.appendByte(ch);
              break;
            default:
              sb = sb.appendByte(ch);
            }
          }
          else {
            sb = sb.appendByte('\\');
            sb = sb.appendByte(ch);
          }
        }
        else
          sb = sb.appendByte('\\');
        break;

      case '[':
        if (quote == '[') {
          if (i + 1 < len && regexp.charAt(i + 1) == ':') {
            sb = sb.appendByte('[');
          }
          else {
            sb = sb.appendByte('\\');
            sb = sb.appendByte('[');
          }
        }
        else if (i + 1 < len && regexp.charAt(i + 1) == '['
          && ! (i + 2 < len && regexp.charAt(i + 2) == ':')) {
          // XXX: check regexp grammar
          // php/151n
          sb = sb.appendByte('[');
          sb = sb.appendByte('\\');
          sb = sb.appendByte('[');
          i += 1;
        }
        /*
        else if (i + 2 < len &&
                regexp.charAt(i + 1) == '^' &&
                regexp.charAt(i + 2) == ']') {
          sb.append("[^\\]");
          i += 2;
        }
        */
        else
          sb = sb.appendByte('[');

        if (quote == 0)
          quote = '[';
        break;

      case '#':
        if (quote == '[') {
          sb = sb.appendByte('\\');
          sb = sb.appendByte('#');
        }
        else if (isComments) {
          sb = sb.appendByte(ch);

          for (i++; i < len; i++) {
            ch = regexp.charAt(i);

            sb = sb.appendByte(ch);

            if (ch == '\n' || ch == '\r')
              break;
          }
        }
        else {
          sb = sb.appendByte(ch);
        }

        break;

      case ']':
        sb = sb.appendByte(ch);

        if (quote == '[')
          quote = 0;
        break;

      case '{':
        if (i + 1 < len
            && (
              '0' <= (ch = regexp.charAt(i + 1))
              && ch <= '9'
              || ch == ','
              )
            ) {
          sb = sb.appendByte('{');
          for (i++;
          i < len
              && ('0' <= (ch = regexp.charAt(i)) && ch <= '9' || ch == ',');
          i++) {
            sb = sb.appendByte(ch);
          }

          if (i < len)
            sb = sb.appendByte(regexp.charAt(i));
        }
        else {
          sb = sb.appendByte('\\');
          sb = sb.appendByte('{');
        }
        break;

      case '}':
        sb = sb.appendByte('\\');
        sb = sb.appendByte('}');
        break;

      case '|':
        sb = sb.appendByte('|');
        break;

      default:
        sb = sb.appendByte(ch);
      }
    }

    return sb;
  }

  abstract static class Replacement {
    abstract StringValue eval(Env env,
                  StringValue sb,
                  RegexpState regexpState);

    public String toString()
    {
      return getClass().getSimpleName() + "[]";
    }
  }

  static class TextReplacement
    extends Replacement
  {
    private char []_text;

    TextReplacement(StringBuilder text)
    {
      int length = text.length();

      _text = new char[length];

      text.getChars(0, length, _text, 0);
    }

    @Override
    StringValue eval(Env env,
                     StringValue sb,
                     RegexpState regexpState)
    {
      return sb.appendBytes(_text, 0, _text.length);
    }

    public String toString()
    {
      StringBuilder sb = new StringBuilder();
      sb.append(getClass().getSimpleName());

      sb.append('[');

      for (char ch : _text)
        sb.append(ch);

      sb.append(']');

      return sb.toString();
    }
  }

  static class GroupReplacement
    extends Replacement
  {
    private int _group;

    GroupReplacement(int group)
    {
      _group = group;
    }

    @Override
    StringValue eval(Env env,
                     StringValue sb,
                     RegexpState regexpState)
    {
      if (_group < regexpState.groupCount())
        sb = sb.append(regexpState.group(env, _group));

      return sb;
    }

    public String toString()
    {
      return getClass().getSimpleName() + "[" + _group + "]";
    }
  }

  static class GroupEscapeReplacement
    extends Replacement
  {
    private int _group;

    GroupEscapeReplacement(int group)
    {
      _group = group;
    }

    @Override
    StringValue eval(Env env,
                     StringValue sb,
                     RegexpState regexpState)
    {
      if (_group < regexpState.groupCount()) {
        StringValue group = regexpState.group(env, _group);

        int len = group.length();

        for (int i = 0; i < len; i++) {
          char ch = group.charAt(i);

          switch (ch) {
            case '\'':
              sb = sb.appendByte('\\');
              sb = sb.appendByte('\'');
              break;
            case '"':
              sb = sb.appendByte('\\');
              sb = sb.appendByte('"');
              break;
            case '\\':
              sb = sb.appendByte('\\');
              sb = sb.appendByte('\\');
              break;
            case 0:
              sb = sb.appendByte('\\');
              sb = sb.appendByte('0');
              break;
            default:
              sb = sb.appendByte(ch);
          }
        }
      }

      return sb;
    }

    public String toString()
    {
      return getClass().getSimpleName() + "[" + _group + "]";
    }
  }

  /**
   * Holds information about the left neighbor of a particular group.
   */
  static class GroupNeighborMap
  {
    private int []_neighborMap;

    private static int UNSET = -1;

    public GroupNeighborMap(CharSequence regexp, int groups)
    {
      _neighborMap = new int[groups + 1];

      for (int i = 1; i <= groups; i++) {
        _neighborMap[i] = UNSET;
      }

      boolean sawEscape = false;
      boolean sawVerticalBar = false;
      boolean isLiteral = false;

      int group = 0;
      int parent = UNSET;
      int length = regexp.length();

      ArrayList<Boolean> openParenStack = new ArrayList<Boolean>(groups);

      for (int i = 0; i < length; i++) {
        char ch = regexp.charAt(i);

        if (ch == ' ' || ch == '\t' || ch == '\n' || ch == 'r' || ch == '\f') {
          continue;
        }
        else if (ch == '\\') {
          sawEscape = ! sawEscape;
          continue;
        }
        else if (ch == '[' && ! sawEscape) {
          isLiteral = true;
        }
        else if (ch == ']' && ! sawEscape) {
          isLiteral = false;
        }
        else if (isLiteral || sawEscape) {
          sawEscape = false;
        }
        else if (ch == '(') {
          if (i + 1 < length && regexp.charAt(i + 1) == '?') {
            openParenStack.add(true);
            continue;
          }

          openParenStack.add(false);
          group++;

          if (sawVerticalBar) {
            sawVerticalBar = false;
            _neighborMap[group] = group - 1;
          }
          else {
            _neighborMap[group] = parent;
            parent = group;
          }
        }
        else if (ch == ')') {
          if (openParenStack.remove(openParenStack.size() - 1))
            continue;

          sawVerticalBar = false;
        }
        else if (ch == '|') {
          sawVerticalBar = true;
        }
        else {
        }
      }
    }

    public boolean hasNeighbor(int group)
    {
      return _neighborMap[group] != UNSET;
    }

    public int getNeighbor(int group)
    {
      return _neighborMap[group];
    }
  }

  static class UnicodeEregKey
  {
    StringValue _regexpValue;
    String _encoding;

    UnicodeEregKey(StringValue regexpValue, String encoding)
    {
      _regexpValue = regexpValue;
      _encoding = encoding;
    }

    public boolean equals(Object o)
    {
      if (! (o instanceof UnicodeEregKey))
        return false;

      UnicodeEregKey ereg = (UnicodeEregKey) o;

      return _regexpValue.equals(ereg._regexpValue)
        && _encoding.equals(ereg._encoding);
    }
  }
  
  static final class RegexpCacheItem {
    private final StringValue _pattern;
    
    private Regexp _regexp;
    private IllegalRegexpException _exn;
    
    RegexpCacheItem(StringValue pattern)
    {
      _pattern = pattern;
    }
    
    public Regexp get()
      throws IllegalRegexpException
    {
      if (_regexp != null)
        return _regexp;
      else if (_exn != null)
        throw _exn;
      
      synchronized (this) {
        try {
          _regexp = new Regexp(_pattern);
          
          return _regexp;
        } catch (IllegalRegexpException e) {
          _exn = e;
          
          throw e;
        }
      }
    }
  }

  static {
    PREG_QUOTE['\\'] = true;
    PREG_QUOTE['+'] = true;
    PREG_QUOTE['*'] = true;
    PREG_QUOTE['?'] = true;
    PREG_QUOTE['['] = true;
    PREG_QUOTE['^'] = true;
    PREG_QUOTE[']'] = true;
    PREG_QUOTE['$'] = true;
    PREG_QUOTE['('] = true;
    PREG_QUOTE[')'] = true;
    PREG_QUOTE['{'] = true;
    PREG_QUOTE['}'] = true;
    PREG_QUOTE['='] = true;
    PREG_QUOTE['!'] = true;
    PREG_QUOTE['<'] = true;
    PREG_QUOTE['>'] = true;
    PREG_QUOTE['|'] = true;
    PREG_QUOTE[':'] = true;
    PREG_QUOTE['.'] = true;
    PREG_QUOTE['-'] = true; // php/153w

  }
}
