mbstringmodule.java

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

    EregSearch ereg = new EregSearch(env, string, pattern, option);
    env.setSpecialValue("mb.search", ereg);

    return BooleanValue.TRUE;
  }

  /**
   * Returns index and position after matching.
   */
  public static Value mb_ereg_search_pos(Env env,
                              @Optional Value pattern,
                              @Optional Value option)
  {
    EregSearch ereg = getEreg(env, pattern, option);

    if (ereg == null) {
      env.warning(L.l("Regular expression not set"));
      return BooleanValue.FALSE;
    }

    return ereg.search(env, true);
  }

  /**
   * Returns match array after matching.
   */
  public static Value mb_ereg_search_regs(Env env,
                              @Optional Value pattern,
                              @Optional Value option)
  {
    EregSearch ereg = getEreg(env, pattern, option);

    if (ereg == null) {
      env.warning(L.l("Regular expression not set"));
      return BooleanValue.FALSE;
    }

    if (ereg.search(env, false) == BooleanValue.FALSE)
      return BooleanValue.FALSE;

    return ereg._lastMatch;
  }

  /**
   * Sets the position of the ereg state object.
   */
  public static BooleanValue mb_ereg_search_setpos(Env env,
                              int position)
  {
    EregSearch ereg = getEreg(env);

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

    ereg._position = position;
    return BooleanValue.TRUE;
  }

  /**
   * Returns whether or not pattern matches string.
   */
  public static BooleanValue mb_ereg_search(Env env,
                              @Optional Value pattern,
                              @Optional Value option)
  {
    EregSearch ereg = getEreg(env, pattern, option);

    if (ereg == null) {
      env.warning(L.l("Regular expression not set"));
      return BooleanValue.FALSE;
    }

    Value result = ereg.search(env, false);

    return BooleanValue.create(result.toBoolean());
  }

  /**
   * Returns the ereg state object from the environment.
   */
  private static EregSearch getEreg(Env env)
  {
    Object obj = env.getSpecialValue("mb.search");

    if (obj == null)
      return null;

    return (EregSearch) obj;
  }

  /**
   * Returns the ereg state object from the environment iff the ereg object
   * is a valid one.
   */
  private static EregSearch getEreg(Env env,
                                    Value pattern,
                                    Value option)
  {
    Object obj = env.getSpecialValue("mb.search");

    if (obj != null) {
      EregSearch ereg = (EregSearch) obj;

      ereg.init(env, pattern, option);

      if (ereg._isValidRegexp)
        return ereg;
      else
        return null;
    }
    else
      return null;
  }

  /**
   * Returns current mb settings.
   */
  public static Value mb_get_info(Env env,
                              @Optional("") String type)
  {
    if (type.length() == 0) {
      ArrayValue array = new ArrayValueImpl();

      array.put(env.createString("internal_encoding"),
                env.createString(getEncoding(env)));
      
      array.put(env.createString("http_output"),
                env.createString(getOutputEncoding(env)));

      return array;
    }
    else if (type.equals("internal_encoding")) {
      return env.createString(getEncoding(env));
    }
    else if (type.equals("http_output")) {
      return env.createString(getOutputEncoding(env));
    }
    else {
      env.warning(L.l("unsupported option: {0}", type));
      
      return BooleanValue.FALSE;
    }
  }

  /**
   * Returns and/or sets the http input encoding
   */
  public static Value mb_http_input(Env env,
                              @Optional String type)
  {
    throw new UnimplementedException("mb_http_input");
  }
 
  /**
   * Returns and/or sets the http output encoding
   */
  public static Value mb_http_output(Env env,
                                     @Optional String encoding)
  {
    if (encoding.length() == 0) {
      return env.createString(getOutputEncoding(env));
    }
    else {
      env.setIni("mbstring.http_output", encoding);
      
      return BooleanValue.TRUE;
    }
  }

  /**
   * Returns and/or sets the internal encoding.
   */
  public static Value mb_internal_encoding(Env env,
                              @Optional String encoding)
  {
    if (encoding.length() == 0)
      return env.createString(getEncoding(env));
    else {
      setEncoding(env, encoding);
      return BooleanValue.TRUE;
    }
  }

  /**
   * Returns and/or sets the encoding for mail.
   */
  public static Value mb_language(Env env,
                              @Optional String language)
  {
    String encoding = getEncoding(env);

    if (language.length() == 0) {
      if (encoding.equalsIgnoreCase("ISO-2022-JP"))
        return env.createString("Japanese");
      else if (encoding.equalsIgnoreCase("ISO-8859-1"))
        return env.createString("English");
      else if (encoding.equalsIgnoreCase("UTF-8"))
        return env.createString("uni");
    }
    else if (language.equals("Japanese") || language.equals("ja"))
      setEncoding(env, "ISO-2022-JP");
    else if (language.equals("English") || language.equals("en"))
      setEncoding(env, "ISO-8859-1");
    else if (language.equals("uni"))
      setEncoding(env, "UTF-8");
    else
      return BooleanValue.FALSE;

    return BooleanValue.TRUE;
  }

  /**
   * Get all supported encodings.
   */
  public static ArrayValue mb_list_encodings(Env env)
  {
    ArrayValue array = new ArrayValueImpl();

    Map<String,Charset> charsetMap = Charset.availableCharsets();

    for (String name : charsetMap.keySet()) {
      array.put(env.createString(name));
    }

    return array;
  }

  /**
   * ob_start() handler
   */
  public static StringValue mb_output_handler(Env env,
                                              StringValue contents,
                                              int status)
  {
    // XXX: status?

    String toEncoding = getOutputEncoding(env);

    if (toEncoding.equals("pass"))
      return contents;
    
    String fromEncoding = getEncoding(env);

    contents = contents.convertToUnicode(env, fromEncoding);

    try {
      byte []bytes = contents.toString().getBytes(toEncoding);

      return env.createBinaryBuilder(bytes);
    }
    catch (UnsupportedEncodingException e) {
      throw new QuercusModuleException(e);
    }
  }

  /**
   * Multibyte version of parse_str.
   */
  public static BooleanValue mb_parse_str(Env env,
                              StringValue strValue,
                              @Optional @Reference Value result)
  {
    String encoding = getEncoding(env);
    StringModule.parse_str(env,strValue.toString(), result);

    if (result == null) {
      // XXX: encode newly added global variables
      return BooleanValue.TRUE;
    }
    else {
      Value array = encodeAll(env, result, encoding);
      result.set(array);

      return BooleanValue.TRUE;
    }
  }

  /**
   * Returns the preferred mime name of this encoding.
   */
  public static StringValue mb_preferred_mime_name(Env env,
                              StringValue encoding)
  {
    String mimeName = Encoding.getMimeName(encoding.toString());

    return env.createString(mimeName);
  }

  /**
   * Returns and/or sets encoding for mb regular expressions.
   */
  public static Value mb_regex_encoding(Env env,
                              @Optional("") String encoding)
  {
    return mb_internal_encoding(env, encoding);
  }

  /**
   * XXX: what does this actually do?
   */
  public static StringValue mb_regex_set_options(Env env,
                              @Optional String options)
  {
    throw new UnimplementedException("mb_regex_set_options");
  }

  /**
   * Multibyte version of mail.
   */
  public static BooleanValue mb_send_mail(Env env,
                              StringValue to,
                              StringValue subject,
                              StringValue message,
                              @Optional StringValue additionalHeaders,
                              @Optional StringValue additionalParameters)
  {
    String encoding = getEncoding(env);

    subject = subject.toBinaryValue(env, encoding);
    message = message.toBinaryValue(env, encoding);
    additionalHeaders = additionalHeaders.toBinaryValue(env, encoding);

    boolean result = MailModule.mail(env,
                                     to.toString(),
                                     subject.toString(),
                                     message,
                                     additionalHeaders.toString(),
                                     additionalParameters.toString());

    return BooleanValue.create(result);
  }

  /**
   * Multibyte version of split.
   */
  public static Value mb_split(Env env,
                              StringValue pattern,
                              StringValue string,
                              @Optional("-1") long limit)
  {
    String encoding = getEncoding(env);

    pattern = pattern.convertToUnicode(env, encoding);
    string = string.convertToUnicode(env, encoding);

    Value val = RegexpModule.split(env, pattern, string, limit);

    return encodeAll(env, val, encoding);
  }

  /**
   * Similar to substr except start index is at the beginning of char
   * boundaries.
   */
  public static StringValue mb_strcut(Env env,
                              StringValue str,
                              int start,
                              @Optional("7fffffff") int length,
                              @Optional String encoding)
  {
    encoding = getEncoding(env, encoding);

    str = str.convertToUnicode(env, encoding);

    int len = str.length();
    int end = start + length;

    if (end > len)
      end = len;

    if (start < 0 || start > end)
      return StringValue.EMPTY;

    // XXX: not quite exactly the same behavior as PHP
    if (Character.isHighSurrogate(str.charAt(start)))
      start--;

    str = str.substring(start, end);

    return str.toBinaryValue(env, encoding);
  }

  /**
   * Truncates the string.
   */
  public static StringValue mb_strimwidth(Env env,
                              StringValue str,
                              int start,
                              int width,
                              @Optional() StringValue trimmarker,
                              @Optional("") String encoding)
  {
    encoding = getEncoding(env, encoding);

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

    int len = unicodeStr.length();
    int end = start + width;

    if (end > len)
      end = len;

    if (start < 0 || start > end)
      return str.getEmptyString();

    unicodeStr = unicodeStr.substring(start, end);

    if (end < len && trimmarker.length() > 0) {
      StringValue sb = env.createUnicodeBuilder();

      sb.append(unicodeStr);
      sb.append(trimmarker.convertToUnicode(env, encoding));

      unicodeStr = sb;
    }

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