mbstringmodule.java

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

  }

  /**
   * Multibyte version of strlen.
   */
  public static LongValue mb_strlen(Env env,
                              StringValue str,
                              @Optional("") String encoding)
  {
    encoding = getEncoding(env, encoding);

    str = str.convertToUnicode(env, encoding);

    return LongValue.create(str.length());
  }

  /**
   * Multibyte version of strpos.
   */
  public static Value mb_strpos(Env env,
                              StringValue haystack,
                              StringValue needle,
                              @Optional("0") int offset,
                              @Optional("") String encoding)
  {
    encoding = getEncoding(env, encoding);

    haystack = haystack.convertToUnicode(env, encoding);
    needle = needle.convertToUnicode(env, encoding);

   return StringModule.strpos(haystack, needle, offset);
  }

  /**
   * Multibyte version of strrpos.
   */
  public static Value mb_strrpos(Env env,
                              StringValue haystack,
                              StringValue needle,
                              @Optional Value offsetV,
                              @Optional("") String encoding)
  {
    encoding = getEncoding(env, encoding);

    haystack = haystack.convertToUnicode(env, encoding);
    needle = needle.convertToUnicode(env, encoding);

    return StringModule.strrpos(haystack, needle, offsetV);
  }

  /**
   * Converts all characters to lower-case.
   */
  public static StringValue mb_strtolower(Env env,
                              StringValue str,
                              @Optional("") String encoding)
  {
    encoding = getEncoding(env, encoding);

    StringValue unicodeStr = str.convertToUnicode(env, encoding);
    unicodeStr = StringModule.strtolower(str);

    return str.create(env, unicodeStr, encoding);
  }

  /**
   * Converts all characters to upper-case.
   */
  public static StringValue mb_strtoupper(Env env,
                              StringValue str,
                              @Optional("") String encoding)
  {
    encoding = getEncoding(env, encoding);

    StringValue unicodeStr = str.convertToUnicode(env, encoding);
    unicodeStr = StringModule.strtoupper(str);

    return str.create(env, unicodeStr, encoding);
  }

  /**
   * Returns the width of this multibyte string.
   */
  public static LongValue mb_strwidth(Env env,
                              StringValue str,
                              @Optional("") String encoding)
  {
    encoding = getEncoding(env, encoding);

    str = str.convertToUnicode(env, encoding);

    return LongValue.create(str.length());

/*
    int width = 0;
    int len = string.length();

    // Per PHP manual
    for (int i = 0; i < len; i++) {
      char ch = string.charAt(i);

      if (ch <= 0x19)
        continue;
      else if (ch <= 0x1fff)
        width += 1;
      else if (ch <= 0xff60)
        width += 2;
      else if (ch <= 0xff9f)
        width += 1;
      else
        width += 2;
    }

    return LongValue.create(width);
*/
  }

  /**
   * Sets the character to use when decoding/encoding fails on a character.
   */
  public static Value mb_substitute_character(Value substrchar)
  {
    throw new UnimplementedException("mb_substitute_character");
  }

  public static LongValue mb_substr_count(Env env,
                              StringValue haystack,
                              StringValue needle,
                              @Optional("") String encoding)
  {
    encoding = getEncoding(env, encoding);

    haystack = haystack.convertToUnicode(env, encoding);
    needle = needle.convertToUnicode(env, encoding);

    int count = 0;
    int sublen = needle.length();

    int i = haystack.indexOf(needle);

    while (i >= 0) {
      i = haystack.indexOf(needle, i + sublen);
      count++;
    }

    return LongValue.create(count);
  }

  /**
   * Multibyte version of substr.
   */
  public static StringValue mb_substr(Env env,
                              StringValue str,
                              int start,
                              @Optional Value lengthV,
                              @Optional String encoding)
  {
    encoding = getEncoding(env, encoding);

    StringValue unicodeStr = str.convertToUnicode(env, encoding);

    Value val = StringModule.substr(env, unicodeStr, start, lengthV);

    if (val == BooleanValue.FALSE)
      return str.getEmptyString();
    
    return str.create(env, val.toStringValue(), encoding);
  }


  // Private helper functions

  /**
   * Returns string with words capitalized and intermediate letters are
   * made lower-case.
   */
  private static StringValue toUpperCaseTitle(Env env, StringValue string)
  {
    StringValue sb = string.createStringBuilder();

    int strLen = string.length();
    boolean isWordStart = true;

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

      switch (ch) {
      case ' ': case '\t': case '\r': case '\n':
        isWordStart = true;
        sb.append(ch);
        break;
      default:
        if (isWordStart) {
          sb.append(Character.toUpperCase(ch));
          isWordStart = false;
        }
        else
          sb.append(Character.toLowerCase(ch));
        break;
      }
    }

    return sb;
  }

  private static String getEncoding(Env env)
  {
    Value encoding = env.getIni("mbstring.internal_encoding");
    
    if (encoding.length() > 0)
      return encoding.toString();
    else
      return env.getRuntimeEncoding();
  }

  private static String getEncoding(Env env, String encoding)
  {
    if (encoding == null || encoding.length() == 0)
      return getEncoding(env);
    else
      return encoding;
  }

  private static void setEncoding(Env env, String encoding)
  {
    env.setIni("mbstring.internal_encoding", encoding);
  }
  
  private static String getOutputEncoding(Env env)
  {
    Value encoding = env.getIni("mbstring.http_output");
    
    if (encoding.length() != 0)
      return encoding.toString();
    else
      return env.getOutputEncoding();
  }

  /**
   * Recursively decodes objects and arrays.
   */
  private static Value decodeAll(Env env,
                              Value val,
                              String encoding)
  {
    val = val.toValue();

    if (val instanceof StringValue)
      return ((StringValue)val).convertToUnicode(env, encoding);

    else if (val instanceof ArrayValue) {
      ArrayValue array = new ArrayValueImpl();

      for (Map.Entry<Value,Value> entry : ((ArrayValue)val).entrySet()) {
        array.put(entry.getKey(),
                  decodeAll(env, entry.getValue(), encoding));
      }

      return array;
    } else if (val instanceof ObjectValue) {

      ObjectValue obj = (ObjectValue)val;

      for (Map.Entry<Value,Value> entry : obj.entrySet()) {
        obj.putField(env,
                     entry.getKey().toStringValue(),
                     decodeAll(env, entry.getValue(), encoding));
      }

      return obj;
    } else
      return val;
  }

  /**
   * Recursively encodes objects and arrays.
   */
  private static Value encodeAll(Env env,
                                 Value val,
                                 String encoding)
  {
    val = val.toValue();

    if (val instanceof StringValue) {
      StringValue sb = env.createBinaryBuilder();
      
      sb.append(env, (StringValue) val, encoding);
      
      return sb;
    }
    else if (val instanceof ArrayValue) {
      ArrayValue array = new ArrayValueImpl();

      for (Map.Entry<Value,Value> entry : ((ArrayValue)val).entrySet()) {
        array.put(entry.getKey(),
                  encodeAll(env, entry.getValue(), encoding));
      }

      return array;
    } else if (val instanceof ObjectValue) {

      ObjectValue obj = (ObjectValue)val;

      for (Map.Entry<Value,Value> entry : obj.entrySet()) {
        obj.putField(env,
                     entry.getKey().toStringValue(),
                     encodeAll(env, entry.getValue(), encoding));
      }

      return obj;
    } else
      return val;
  }

  private static StringValue decodeEncode(Env env,
                              StringValue val,
                              String srcEncoding,
                              String destEncoding)
  {
    try {
      return UnicodeUtility.decodeEncode(env, val, srcEncoding, destEncoding);
    } catch (UnsupportedEncodingException e) {
      throw new QuercusModuleException(e.getMessage());
    }
  }

  /**
   * ereg state object (saves previous match and other info)
   *
   * XXX: option
   */
  static class EregSearch {
    private StringValue _string;
    private StringValue _pattern;
    private Value _option;
    private int _length;

    ArrayValue _lastMatch;
    int _position;
    boolean _isValidRegexp;

    EregSearch(Env env,
                 StringValue string,
                 Value pattern,
                 Value option)
    {
      _string = string.convertToUnicode(env, getEncoding(env));
      _position = 0;
      _length = _string.length();

      init(env, pattern, option);
    }

    void init(Env env, Value pattern, Value option)
    {
      _option = option;
      initPattern(env, pattern);
    }

    void initPattern(Env env, Value pattern)
    {
      if (pattern instanceof StringValue) {
        _pattern = pattern.toStringValue();
        _isValidRegexp = true;
      }
      else
        _isValidRegexp = (_pattern != null);
    }

    StringValue getString(Env env)
    {
      if (_position == 0)
        return _string;
      else if (_position < _length)
        return _string.substring(_position);
      else
        return StringValue.EMPTY;
    }

    Value search(Env env, boolean isArrayReturn)
    {
      StringValue string = getString(env);

      ArrayValue regs = new ArrayValueImpl();
      Value val = eregImpl(env, _pattern, string, regs, true);

      if (val == BooleanValue.FALSE)
        return BooleanValue.FALSE;

      StringValue match = regs.get(LongValue.ZERO).toStringValue();
      int matchIndex = _string.indexOf(match, _position);
      int matchLength = match.length();

      _position = matchIndex + matchLength;
      _lastMatch = regs;

      if (isArrayReturn) {
        ArrayValue array = new ArrayValueImpl();

        array.put(LongValue.create(matchIndex));
        array.put(LongValue.create(matchLength));

        return array;

      } else
        return BooleanValue.TRUE;
    }
  }

  static final IniDefinition INI_MBSTRING_HTTP_INPUT
    = _iniDefinitions.add("mbstring.http_input", "pass", PHP_INI_ALL);
  static final IniDefinition INI_MBSTRING_HTTP_OUTPUT
    = _iniDefinitions.add("mbstring.http_output", "pass", PHP_INI_ALL);
}