cauchoregexpmodule.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 1,953 行 · 第 1/4 页

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

        // group is unmatched, skip
        if (end - start <= 0)
          continue;

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

        Value result = NullValue.NULL;

        if (groupValue != null) {

          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 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
        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,
				   Value pattern,
				   Value replacement,
				   Value subject,
				   @Optional("-1") long limit,
				   @Optional @Reference Value count)
  {
    try {
      if (subject instanceof ArrayValue) {
        ArrayValue result = new ArrayValueImpl();

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

        return result;

      }
      else if (subject.isset()) {
        return pregReplace(env, pattern, 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,
				   Value patternValue,
				   Value replacement,
				   StringValue subject,
				   @Optional("-1") long limit,
				   Value countV)
    throws IllegalRegexpException
  {
    StringValue string = subject;

    if (limit < 0)
      limit = LONG_MAX;

    if (patternValue.isArray() && replacement.isArray()) {
      ArrayValue patternArray = (ArrayValue) patternValue;
      ArrayValue replacementArray = (ArrayValue) replacement;

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

      while (patternIter.hasNext()) {
        StringValue replacementStr;

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

        string = pregReplaceString(env,
				   patternIter.next().toStringValue(),
				   replacementStr,
				   string,
				   limit,
				   countV);
      }
    } else if (patternValue.isArray()) {
      ArrayValue patternArray = (ArrayValue) patternValue;

      for (Value value : patternArray.values()) {
        string = pregReplaceString(env,
				   value.toStringValue(),
				   replacement.toStringValue(),
				   string,
				   limit,
				   countV);
      }
    } else {
      return pregReplaceString(env,
			       patternValue.toStringValue(),
			       replacement.toStringValue(),
			       string,
			       limit,
			       countV);
    }

    return string;
  }

  /**
   * 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,
						     StringValue patternString,
						     Callback fun,
						     StringValue subject,
						     long limit,
						     Value countV)
    throws IllegalRegexpException
  {
    StringValue empty = subject.getEmptyString();
    
    long numberOfMatches = 0;

    if (limit < 0)
      limit = LONG_MAX;

    Regexp regexp = getRegexp(env, patternString);
    RegexpState regexpState = new RegexpState(env, regexp, subject);

    StringValue result = patternString.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 = ((Var) countV).getRawValue().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)
          regs.put(group);
        else
          regs.put(empty);
      }

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

      result = result.append(replacement);

      tail = regexpState.end();

      numberOfMatches++;
    }

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

    return result;
  }

  /**
   * Replaces values using regexps
   */
  private static StringValue pregReplaceString(Env env,
					       StringValue patternString,
					       StringValue replacement,
					       StringValue subject,
					       long limit,
					       Value countV)
    throws IllegalRegexpException
  {
    Regexp regexp = getRegexp(env, patternString);
    RegexpState regexpState = new RegexpState(env, regexp, subject);

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

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

    if (replacementProgram == null) {
      replacementProgram = compileReplacement(env, replacement, isEval);
      _replacementCache.put(replacement, replacementProgram);
    }

    return pregReplaceStringImpl(env,
				 regexp,
				 regexpState,
				 replacementProgram,
				 subject,
				 limit,
				 countV,
				 isEval);
  }

  /**
   * Replaces values using regexps
   */
  public static Value ereg_replace(Env env,
          Value pattern,
          Value replacement,
          StringValue subject)
  {
    return eregReplaceImpl(env, pattern, replacement, subject, false);
  }

  /**
   * Replaces values using regexps
   */
  public static Value eregi_replace(Env env,
          Value pattern,
          Value replacement,
          StringValue subject)
  {
    return eregReplaceImpl(env, pattern, replacement, subject, true);
  }

  /**
   * Replaces values using regexps
   */

  protected static Value eregReplaceImpl(Env env,
                                  Value pattern,
                                  Value replacement,
                                  StringValue subject,
                                  boolean isCaseInsensitive)
  {
    StringValue patternStr;
    StringValue replacementStr;

    // php/1511 : error when pattern argument is null or an empty string

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

    // 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 (pattern instanceof StringValue) {
      patternStr = pattern.toStringValue();
    } else {
      patternStr = env.createString(
        String.valueOf((char) pattern.toLong()));
    }

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

    try {
      patternStr = cleanEregRegexp(env, patternStr, false);
      if (isCaseInsensitive)
        patternStr = addDelimiters(env, patternStr, "/", "/i");
      else
        patternStr = addDelimiters(env, patternStr, "/", "/");

      Regexp regexp = getRegexp(env, patternStr);
      RegexpState regexpState = new RegexpState(env, regexp, subject);

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

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

      return pregReplaceStringImpl(env,
				   regexp,
				   regexpState,
				   replacementProgram,
				   subject,
				   -1,
				   NullValue.NULL,
				   false);
    }
    catch (IllegalRegexpException e) {
      log.log(Level.FINE, e.getMessage(), e);
      env.warning(e);
      
      return BooleanValue.FALSE;
    }
  }

  /**
   * 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;

    int length = subject.length();

    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();

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

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

        try {
          if (evalString.length() > 0) { // php/152z
            result = result.append(env.evalCode(evalString.toString()));
          }
        } catch (IOException e) {
          throw new QuercusException(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 < length)
      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,
          Value pattern,