nativestring.java

RESIN 3.2 最新源码

      return array;
    }
    else if (eval.getArg(0) instanceof ESRegexp) {
      throw new UnsupportedOperationException();
      
      // splitter = (ESRegexp) eval.getArg(0);
    }
    else {
      String arg = eval.getArg(0).toString();

      String []values = string.toString().split(arg);

      for (int i = 0; i < values.length; i++) {
	array.setProperty(i, ESString.create(values[i]));
      }
      
      /*
      if (arg.length() == 1 && arg.charAt(0) == ' ') {
	splitter = new ESRegexp("\\s", "g");
      } else
	splitter = new ESRegexp(escapeRegexp(arg), "g");
      */
    }

    return array;
  }

  private ESBase substring(Call eval, int length) throws Throwable
  {
    ESString string = eval.getArg(-1).toStr();

    if (length == 0)
      return string;

    int start = (int) eval.getArg(0).toNum();
    int end = string.length();

    if (length > 1)
      end = (int) eval.getArg(1).toNum();

    if (start < 0)
      start = 0;
    if (end > string.length())
      end = string.length();
    if (start > end)
      return string.substring(end, start);
    else
      return string.substring(start, end);
  }

  private ESBase concat(Call eval, int length) throws Throwable
  {
    ESString string = eval.getArg(-1).toStr();

    if (length == 0)
      return string;

    CharBuffer cb = new CharBuffer();
    cb.append(string.toString());

    for (int i = 0; i < length; i++) {
      ESString next = eval.getArg(i).toStr();

      cb.append(next.toString());
    }

    return ESString.create(cb);
  }

  private ESBase match(Call eval, int length) throws Throwable
  {
    /*
    if (length == 0)
      return esNull;
    
    Global resin = Global.getGlobalProto();
    ESString string = eval.getArg(-1).toStr();

    ESBase arg = eval.getArg(0);
    ESRegexp regexp;

    if (arg instanceof ESRegexp)
      regexp = (ESRegexp) arg;
    else if (length > 1)
      regexp = new ESRegexp(arg.toStr(), eval.getArg(1).toStr());
    else
      regexp = new ESRegexp(arg.toStr(), ESString.NULL);

    IntArray results = new IntArray();

    resin.getRegexp().setRegexp(regexp);
    regexp.setLastIndex(0);
    if (! regexp.exec(string))
      return esNull;

    ESArray array = resin.createArray();

    if (! regexp.regexp.isGlobal()) {
      for (int i = 0; i < regexp.regexp.length(); i++) {
	array.setProperty(i, string.substring(regexp.regexp.getBegin(i), 
					      regexp.regexp.getEnd(i)));
      }

      return array;
    }

    int i = 0;
    do {
      array.setProperty(i, string.substring(regexp.regexp.getBegin(0), 
					    regexp.regexp.getEnd(0)));
      i++;
    } while (regexp.exec(string));

    return array;
    */
    return esNull;
  }

  private void replaceFun(CharBuffer result, String pattern, 
			  ESRegexp regexp, ESBase fun)
    throws Throwable
  {
    /*
    Call call = Global.getGlobalProto().getCall();

    call.top = 1;
    call.setThis(regexp);
    for (int i = 0; i < regexp.regexp.length(); i++) {
      int begin = regexp.regexp.getBegin(i);
      int end = regexp.regexp.getEnd(i);
      call.setArg(i, ESString.create(pattern.substring(begin, end)));
    }

    ESBase value = fun.call(call, regexp.regexp.length());

    Global.getGlobalProto().freeCall(call);

    String string = value.toStr().toString();

    result.append(string);
    */
  }

  /*
  private void replaceString(CharBuffer result, String pattern, 
			     Pattern regexp, String replacement)
    throws Throwable
  {
    int len = replacement.length();

    for (int i = 0; i < len; i++) {
      char ch = replacement.charAt(i);
      
      if (ch == '$' && i + 1 < len) {
	i++;
	ch = replacement.charAt(i);

	if (ch >= '0' && ch <= '9') {
	  int index = ch - '0';

	  if (index < regexp.length()) {
	    int begin = regexp.getBegin(index);
	    int end = regexp.getEnd(index);
	    result.append(pattern.substring(begin, end));
	  }
	} else if (ch == '$')
	  result.append('$');
	else if (ch == '&') {
	  int begin = regexp.getBegin(0);
	  int end = regexp.getEnd(0);
	  result.append(pattern.substring(begin, end));
	} else if (ch == '+') {
	  int begin = regexp.getBegin(regexp.length() - 1);
	  int end = regexp.getEnd(regexp.length() - 1);
	  result.append(pattern.substring(begin, end));
	} else if (ch == '`') {
	  int begin = 0;
	  int end = regexp.getBegin(0);
	  result.append(pattern.substring(begin, end));
	} else if (ch == '\'') {
	  int begin = regexp.getEnd(0);
	  int end = pattern.length();
	  result.append(pattern.substring(begin, end));
	} else {
	  result.append('$');
	  result.append(ch);
	}
      } else {
	result.append(ch);
      }
    }
  }
  */

  private ESBase replace(Call eval, int length) throws Throwable
  {
    ESString string = eval.getArg(-1).toStr();

    if (length < 1)
      return string;

    Global resin = Global.getGlobalProto();
    ESBase arg = eval.getArg(0);
    ESRegexp regexp;

    if (arg instanceof ESRegexp)
      regexp = (ESRegexp) arg;
    else
      regexp = new ESRegexp(arg.toStr(), ESString.NULL);

    IntArray results = new IntArray();
    String pattern = string.toString();

    ESBase replace = null;
    String stringPattern = null;
    if (length > 1)
      replace = eval.getArg(1);

    /* XXX: convert to java.util.regex
    int last = 0;
    CharBuffer result = new CharBuffer();
    resin.getRegexp().setRegexp(regexp);
    if (regexp.regexp.isGlobal())
      regexp.setLastIndex(0);
    while (regexp.exec(string)) {
      result.append(pattern.substring(last, regexp.regexp.getBegin(0)));
      last = regexp.regexp.getEnd(0);

      if (replace instanceof ESClosure) {
	replaceFun(result, pattern, regexp, replace);
      } else {
	if (stringPattern == null)
	  stringPattern = replace == null ? "" : replace.toString();

	replaceString(result, pattern, regexp.regexp, stringPattern);
      }

      if (! regexp.regexp.isGlobal())
	break;

    }
        result.append(pattern.substring(last));

    return ESString.create(result);
    */

    return null;
  }

  private ESBase search(Call eval, int length) throws Throwable
  {
    if (length == 0)
      return ESNumber.create(-1);
    
    return ESNumber.create(-1);

    /* XXX: convert to java.util.regex
    ESString string = eval.getArg(-1).toStr();

    ESBase arg = eval.getArg(0);
    ESRegexp regexp;

    if (arg instanceof ESRegexp)
      regexp = (ESRegexp) arg;
    else if (length > 1)
      regexp = new ESRegexp(arg.toStr(), eval.getArg(1).toStr());
    else
      regexp = new ESRegexp(arg.toStr(), ESString.NULL);

    Global.getGlobalProto().getRegexp().setRegexp(regexp);
    if (! regexp.exec(string, false))
      return ESNumber.create(-1);
    else
      return ESNumber.create(regexp.regexp.getBegin(0));
    */
  }

  private ESBase slice(Call eval, int length) throws Throwable
  {
    ESString string = eval.getArg(-1).toStr();

    if (length == 0)
      return string;

    int start = (int) eval.getArg(0).toNum();
    int end = string.length();

    if (length > 1)
      end = (int) eval.getArg(1).toNum();

    if (start < 0)
      start += string.length();
    if (end < 0)
      end += string.length();

    if (start < 0)
      start = 0;
    if (start > string.length())
      start = string.length();

    if (end < 0)
      end = 0;
    if (end > string.length())
      end = string.length();

    if (start <= end)
      return string.substring(start, end);
    else
      return ESString.NULL;
  }

  private ESBase substr(Call eval, int length) throws Throwable
  {
    ESString string = eval.getArg(-1).toStr();

    if (length == 0)
      return string;

    int start = (int) eval.getArg(0).toNum();
    int len = string.length();

    if (length > 1)
      len = (int) eval.getArg(1).toNum();

    if (start < 0)
      start += string.length();

    if (start < 0)
      start = 0;
    if (start > string.length())
      start = string.length();

    if (len <= 0)
      return ESString.NULL;

    int end = start + len;

    if (end > string.length())
      end = string.length();

    return string.substring(start, end);
  }

  private ESBase printf(Call eval, int length) throws Throwable
  {
    if (length == 0)
      return ESString.NULL;

    ESString format = eval.getArg(0).toStr();
    CharBuffer cb = new CharBuffer();

    Printf.printf(cb, format, eval, length);
    
    return ESString.create(cb.toString());
  }
}