1 /* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
\r
3 * The contents of this file are subject to the Netscape Public
\r
4 * License Version 1.1 (the "License"); you may not use this file
\r
5 * except in compliance with the License. You may obtain a copy of
\r
6 * the License at http://www.mozilla.org/NPL/
\r
8 * Software distributed under the License is distributed on an "AS
\r
9 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
\r
10 * implied. See the License for the specific language governing
\r
11 * rights and limitations under the License.
\r
13 * The Original Code is Rhino code, released
\r
16 * The Initial Developer of the Original Code is Netscape
\r
17 * Communications Corporation. Portions created by Netscape are
\r
18 * Copyright (C) 1997-1999 Netscape Communications Corporation. All
\r
26 * Alternatively, the contents of this file may be used under the
\r
27 * terms of the GNU Public License (the "GPL"), in which case the
\r
28 * provisions of the GPL are applicable instead of those above.
\r
29 * If you wish to allow use of your version of this file only
\r
30 * under the terms of the GPL and not to allow others to use your
\r
31 * version of this file under the NPL, indicate your decision by
\r
32 * deleting the provisions above and replace them with the notice
\r
33 * and other provisions required by the GPL. If you do not delete
\r
34 * the provisions above, a recipient may use your version of this
\r
35 * file under either the NPL or the GPL.
\r
38 package org.mozilla.javascript;
\r
40 import java.lang.reflect.Method;
\r
41 import java.util.Vector;
\r
44 * This class implements the String native object.
\r
48 * String methods for dealing with regular expressions are
\r
49 * ported directly from C. Latest port is from version 1.40.12.19
\r
50 * in the JSFUN13_BRANCH.
\r
52 * @author Mike McCabe
\r
53 * @author Norris Boyd
\r
55 public class NativeString extends IdScriptable {
\r
57 public static void init(Context cx, Scriptable scope, boolean sealed) {
\r
58 NativeString obj = new NativeString();
\r
59 obj.prototypeFlag = true;
\r
60 obj.addAsPrototype(MAX_PROTOTYPE_ID, cx, scope, sealed);
\r
64 * Zero-parameter constructor: just used to create String.prototype
\r
66 public NativeString() {
\r
67 string = defaultValue;
\r
70 public NativeString(String s) {
\r
74 public String getClassName() {
\r
78 protected void fillConstructorProperties
\r
79 (Context cx, IdFunction ctor, boolean sealed)
\r
81 addIdFunctionProperty(ctor, ConstructorId_fromCharCode, sealed);
\r
82 super.fillConstructorProperties(cx, ctor, sealed);
\r
85 protected int getIdDefaultAttributes(int id) {
\r
86 if (id == Id_length) {
\r
87 return DONTENUM | READONLY | PERMANENT;
\r
89 return super.getIdDefaultAttributes(id);
\r
92 protected Object getIdValue(int id) {
\r
93 if (id == Id_length) {
\r
94 return wrap_int(string.length());
\r
96 return super.getIdValue(id);
\r
99 public int methodArity(int methodId) {
\r
100 if (prototypeFlag) {
\r
101 switch (methodId) {
\r
102 case ConstructorId_fromCharCode: return 1;
\r
104 case Id_constructor: return 1;
\r
105 case Id_toString: return 0;
\r
106 case Id_valueOf: return 0;
\r
107 case Id_charAt: return 1;
\r
108 case Id_charCodeAt: return 1;
\r
109 case Id_indexOf: return 2;
\r
110 case Id_lastIndexOf: return 2;
\r
111 case Id_split: return 1;
\r
112 case Id_substring: return 2;
\r
113 case Id_toLowerCase: return 0;
\r
114 case Id_toUpperCase: return 0;
\r
115 case Id_substr: return 2;
\r
116 case Id_concat: return 1;
\r
117 case Id_slice: return 2;
\r
118 case Id_bold: return 0;
\r
119 case Id_italics: return 0;
\r
120 case Id_fixed: return 0;
\r
121 case Id_strike: return 0;
\r
122 case Id_small: return 0;
\r
123 case Id_big: return 0;
\r
124 case Id_blink: return 0;
\r
125 case Id_sup: return 0;
\r
126 case Id_sub: return 0;
\r
127 case Id_fontsize: return 0;
\r
128 case Id_fontcolor: return 0;
\r
129 case Id_link: return 0;
\r
130 case Id_anchor: return 0;
\r
131 case Id_equals: return 1;
\r
132 case Id_equalsIgnoreCase: return 1;
\r
133 case Id_match: return 1;
\r
134 case Id_search: return 1;
\r
135 case Id_replace: return 1;
\r
138 return super.methodArity(methodId);
\r
141 public Object execMethod
\r
142 (int methodId, IdFunction f,
\r
143 Context cx, Scriptable scope, Scriptable thisObj, Object[] args)
\r
144 throws JavaScriptException
\r
146 if (prototypeFlag) {
\r
147 switch (methodId) {
\r
148 case ConstructorId_fromCharCode:
\r
149 return jsStaticFunction_fromCharCode(args);
\r
151 case Id_constructor:
\r
152 return jsConstructor(args, thisObj == null);
\r
155 return realThis(thisObj, f).jsFunction_toString();
\r
158 return realThis(thisObj, f).jsFunction_valueOf();
\r
161 return jsFunction_charAt
\r
162 (ScriptRuntime.toString(thisObj), args);
\r
164 case Id_charCodeAt:
\r
165 return wrap_double(jsFunction_charCodeAt
\r
166 (ScriptRuntime.toString(thisObj), args));
\r
169 return wrap_int(jsFunction_indexOf
\r
170 (ScriptRuntime.toString(thisObj), args));
\r
172 case Id_lastIndexOf:
\r
173 return wrap_int(jsFunction_lastIndexOf
\r
174 (ScriptRuntime.toString(thisObj), args));
\r
177 return jsFunction_split
\r
178 (cx, scope, ScriptRuntime.toString(thisObj), args);
\r
181 return jsFunction_substring
\r
182 (cx, ScriptRuntime.toString(thisObj), args);
\r
184 case Id_toLowerCase:
\r
185 return jsFunction_toLowerCase
\r
186 (ScriptRuntime.toString(thisObj));
\r
188 case Id_toUpperCase:
\r
189 return jsFunction_toUpperCase
\r
190 (ScriptRuntime.toString(thisObj));
\r
193 return jsFunction_substr
\r
194 (ScriptRuntime.toString(thisObj), args);
\r
197 return jsFunction_concat
\r
198 (ScriptRuntime.toString(thisObj), args);
\r
201 return jsFunction_slice
\r
202 (ScriptRuntime.toString(thisObj), args);
\r
205 return realThis(thisObj, f).tagify("b", null, null);
\r
208 return realThis(thisObj, f).tagify("i", null, null);
\r
211 return realThis(thisObj, f).tagify("tt", null, null);
\r
214 return realThis(thisObj, f).tagify("strike", null, null);
\r
217 return realThis(thisObj, f).tagify("small", null, null);
\r
220 return realThis(thisObj, f).tagify("big", null, null);
\r
223 return realThis(thisObj, f).tagify("blink", null, null);
\r
226 return realThis(thisObj, f).tagify("sup", null, null);
\r
229 return realThis(thisObj, f).tagify("sub", null, null);
\r
232 return realThis(thisObj, f).
\r
233 tagify("font size", "font",
\r
234 ScriptRuntime.toString(args, 0));
\r
237 return realThis(thisObj, f).
\r
238 tagify("font color", "font",
\r
239 ScriptRuntime.toString(args, 0));
\r
242 return realThis(thisObj, f).
\r
243 tagify("a href", "a", ScriptRuntime.toString(args, 0));
\r
246 return realThis(thisObj, f).
\r
247 tagify("a name", "a", ScriptRuntime.toString(args, 0));
\r
250 return wrap_boolean(jsFunction_equals
\r
251 (ScriptRuntime.toString(thisObj),
\r
252 ScriptRuntime.toString(args, 0)));
\r
254 case Id_equalsIgnoreCase:
\r
255 return wrap_boolean(jsFunction_equalsIgnoreCase
\r
256 (ScriptRuntime.toString(thisObj),
\r
257 ScriptRuntime.toString(args, 0)));
\r
260 return checkReProxy(cx).match(cx, scope, thisObj, args);
\r
263 return checkReProxy(cx).search(cx, scope, thisObj, args);
\r
266 return checkReProxy(cx).replace(cx, scope, thisObj, args);
\r
269 return super.execMethod(methodId, f, cx, scope, thisObj, args);
\r
272 private NativeString realThis(Scriptable thisObj, IdFunction f) {
\r
273 while (!(thisObj instanceof NativeString)) {
\r
274 thisObj = nextInstanceCheck(thisObj, f, true);
\r
276 return (NativeString)thisObj;
\r
279 private static RegExpProxy checkReProxy(Context cx) {
\r
280 RegExpProxy result = cx.getRegExpProxy();
\r
281 if (result == null) {
\r
282 throw cx.reportRuntimeError0("msg.no.regexp");
\r
288 * HTML composition aids.
\r
290 private String tagify(String begin, String end, String value) {
\r
291 StringBuffer result = new StringBuffer();
\r
292 result.append('<');
\r
293 result.append(begin);
\r
294 if (value != null) {
\r
295 result.append("=\"");
\r
296 result.append(value);
\r
297 result.append('"');
\r
299 result.append('>');
\r
300 result.append(this.string);
\r
301 result.append("</");
\r
302 result.append((end == null) ? begin : end);
\r
303 result.append('>');
\r
304 return result.toString();
\r
307 private static String jsStaticFunction_fromCharCode(Object[] args) {
\r
308 int N = args.length;
\r
311 StringBuffer s = new java.lang.StringBuffer(N);
\r
312 for (int i=0; i < N; i++) {
\r
313 s.append(ScriptRuntime.toUint16(args[i]));
\r
315 return s.toString();
\r
318 private static Object jsConstructor(Object[] args, boolean inNewExpr) {
\r
319 String s = args.length >= 1
\r
320 ? ScriptRuntime.toString(args[0])
\r
323 // new String(val) creates a new String object.
\r
324 return new NativeString(s);
\r
326 // String(val) converts val to a string value.
\r
330 public String toString() {
\r
334 /* ECMA 15.5.4.2: 'the toString function is not generic.' */
\r
335 private String jsFunction_toString() {
\r
339 private String jsFunction_valueOf() {
\r
343 /* Make array-style property lookup work for strings.
\r
344 * XXX is this ECMA? A version check is probably needed. In js too.
\r
346 public Object get(int index, Scriptable start) {
\r
347 if (index >= 0 && index < string.length())
\r
348 return string.substring(index, index + 1);
\r
349 return super.get(index, start);
\r
352 public void put(int index, Scriptable start, Object value) {
\r
353 if (index >= 0 && index < string.length())
\r
355 super.put(index, start, value);
\r
360 * See ECMA 15.5.4.[4,5]
\r
362 private static String jsFunction_charAt(String target, Object[] args)
\r
364 // this'll return 0 if undefined... seems
\r
366 double pos = ScriptRuntime.toInteger(args, 0);
\r
368 if (pos < 0 || pos >= target.length())
\r
371 return target.substring((int)pos, (int)pos + 1);
\r
374 private static double jsFunction_charCodeAt(String target, Object[] args)
\r
376 double pos = ScriptRuntime.toInteger(args, 0);
\r
378 if (pos < 0 || pos >= target.length()) {
\r
379 return ScriptRuntime.NaN;
\r
382 return target.charAt((int)pos);
\r
387 * See ECMA 15.5.4.6. Uses Java String.indexOf()
\r
388 * OPT to add - BMH searching from jsstr.c.
\r
390 private static int jsFunction_indexOf(String target, Object[] args) {
\r
391 String search = ScriptRuntime.toString(args, 0);
\r
392 double begin = ScriptRuntime.toInteger(args, 1);
\r
394 if (begin > target.length()) {
\r
399 return target.indexOf(search, (int)begin);
\r
405 * See ECMA 15.5.4.7
\r
408 private static int jsFunction_lastIndexOf(String target, Object[] args) {
\r
409 String search = ScriptRuntime.toString(args, 0);
\r
410 double end = ScriptRuntime.toNumber(args, 1);
\r
412 if (end != end || end > target.length())
\r
413 end = target.length();
\r
417 return target.lastIndexOf(search, (int)end);
\r
421 * Used by js_split to find the next split point in target,
\r
422 * starting at offset ip and looking either for the given
\r
423 * separator substring, or for the next re match. ip and
\r
424 * matchlen must be reference variables (assumed to be arrays of
\r
425 * length 1) so they can be updated in the leading whitespace or
\r
428 * Return -1 on end of string, >= 0 for a valid index of the next
\r
429 * separator occurrence if found, or the string length if no
\r
430 * separator is found.
\r
432 private static int find_split(Scriptable scope, String target,
\r
433 String separator, Object re,
\r
434 int[] ip, int[] matchlen, boolean[] matched,
\r
435 String[][] parensp)
\r
438 int length = target.length();
\r
439 Context cx = Context.getContext();
\r
440 int version = cx.getLanguageVersion();
\r
443 * Perl4 special case for str.split(' '), only if the user has selected
\r
444 * JavaScript1.2 explicitly. Split on whitespace, and skip leading w/s.
\r
445 * Strange but true, apparently modeled after awk.
\r
447 if (version == Context.VERSION_1_2 &&
\r
448 re == null && separator.length() == 1 && separator.charAt(0) == ' ')
\r
450 /* Skip leading whitespace if at front of str. */
\r
452 while (i < length && Character.isWhitespace(target.charAt(i)))
\r
457 /* Don't delimit whitespace at end of string. */
\r
461 /* Skip over the non-whitespace chars. */
\r
463 && !Character.isWhitespace(target.charAt(i)))
\r
466 /* Now skip the next run of whitespace. */
\r
468 while (j < length && Character.isWhitespace(target.charAt(j)))
\r
471 /* Update matchlen to count delimiter chars. */
\r
472 matchlen[0] = j - i;
\r
477 * Stop if past end of string. If at end of string, we will
\r
478 * return target length, so that
\r
480 * "ab,".split(',') => new Array("ab", "")
\r
482 * and the resulting array converts back to the string "ab,"
\r
483 * for symmetry. NB: This differs from perl, which drops the
\r
484 * trailing empty substring if the LIMIT argument is omitted.
\r
490 * Match a regular expression against the separator at or
\r
491 * above index i. Return -1 at end of string instead of
\r
492 * trying for a match, so we don't get stuck in a loop.
\r
495 return cx.getRegExpProxy().find_split(scope, target,
\r
497 ip, matchlen, matched,
\r
502 * Deviate from ECMA by never splitting an empty string by any separator
\r
503 * string into a non-empty array (an array of length 1 that contains the
\r
506 if (version != Context.VERSION_DEFAULT && version < Context.VERSION_1_3
\r
511 * Special case: if sep is the empty string, split str into
\r
512 * one character substrings. Let our caller worry about
\r
513 * whether to split once at end of string into an empty
\r
516 * For 1.2 compatibility, at the end of the string, we return the length as
\r
517 * the result, and set the separator length to 1 -- this allows the caller
\r
518 * to include an additional null string at the end of the substring list.
\r
520 if (separator.length() == 0) {
\r
521 if (version == Context.VERSION_1_2) {
\r
528 return (i == length) ? -1 : i + 1;
\r
531 /* Punt to j.l.s.indexOf; return target length if seperator is
\r
534 if (ip[0] >= length)
\r
537 i = target.indexOf(separator, ip[0]);
\r
539 return (i != -1) ? i : length;
\r
543 * See ECMA 15.5.4.8. Modified to match JS 1.2 - optionally takes
\r
544 * a limit argument and accepts a regular expression as the split
\r
547 private static Object jsFunction_split(Context cx, Scriptable scope,
\r
548 String target, Object[] args)
\r
550 // create an empty Array to return;
\r
551 Scriptable top = getTopLevelScope(scope);
\r
552 Scriptable result = ScriptRuntime.newObject(cx, top, "Array", null);
\r
554 // return an array consisting of the target if no separator given
\r
555 // don't check against undefined, because we want
\r
556 // 'fooundefinedbar'.split(void 0) to split to ['foo', 'bar']
\r
557 if (args.length < 1) {
\r
558 result.put(0, result, target);
\r
562 // Use the second argument as the split limit, if given.
\r
563 boolean limited = (args.length > 1) && (args[1] != Undefined.instance);
\r
564 long limit = 0; // Initialize to avoid warning.
\r
566 /* Clamp limit between 0 and 1 + string length. */
\r
567 limit = ScriptRuntime.toUint32(args[1]);
\r
568 if (limit > target.length())
\r
569 limit = 1 + target.length();
\r
572 String separator = null;
\r
573 int[] matchlen = { 0 };
\r
575 RegExpProxy reProxy = cx.getRegExpProxy();
\r
576 if (reProxy != null && reProxy.isRegExp(args[0])) {
\r
579 separator = ScriptRuntime.toString(args[0]);
\r
580 matchlen[0] = separator.length();
\r
583 // split target with separator or re
\r
587 boolean[] matched = { false };
\r
588 String[][] parens = { null };
\r
589 while ((match = find_split(scope, target, separator, re, ip,
\r
590 matchlen, matched, parens)) >= 0)
\r
592 if ((limited && len >= limit) || (match > target.length()))
\r
596 if (target.length() == 0)
\r
599 substr = target.substring(ip[0], match);
\r
601 result.put(len, result, substr);
\r
604 * Imitate perl's feature of including parenthesized substrings
\r
605 * that matched part of the delimiter in the new array, after the
\r
606 * split substring that was delimited.
\r
608 if (re != null && matched[0] == true) {
\r
609 int size = parens[0].length;
\r
610 for (int num = 0; num < size; num++) {
\r
611 if (limited && len >= limit)
\r
613 result.put(len, result, parens[0][num]);
\r
616 matched[0] = false;
\r
618 ip[0] = match + matchlen[0];
\r
620 if (cx.getLanguageVersion() < Context.VERSION_1_3
\r
621 && cx.getLanguageVersion() != Context.VERSION_DEFAULT)
\r
624 * Deviate from ECMA to imitate Perl, which omits a final
\r
625 * split unless a limit argument is given and big enough.
\r
627 if (!limited && ip[0] == target.length())
\r
635 * See ECMA 15.5.4.15
\r
637 private static String jsFunction_substring(Context cx, String target,
\r
640 int length = target.length();
\r
641 double start = ScriptRuntime.toInteger(args, 0);
\r
646 else if (start > length)
\r
649 if (args.length <= 1 || args[1] == Undefined.instance) {
\r
652 end = ScriptRuntime.toInteger(args[1]);
\r
655 else if (end > length)
\r
658 // swap if end < start
\r
660 if (cx.getLanguageVersion() != Context.VERSION_1_2) {
\r
661 double temp = start;
\r
665 // Emulate old JDK1.0 java.lang.String.substring()
\r
670 return target.substring((int)start, (int)end);
\r
675 * See ECMA 15.5.4.[11,12]
\r
677 private static String jsFunction_toLowerCase(String target) {
\r
678 return target.toLowerCase();
\r
681 private static String jsFunction_toUpperCase(String target) {
\r
682 return target.toUpperCase();
\r
685 public double jsGet_length() {
\r
686 return (double) string.length();
\r
690 * Non-ECMA methods.
\r
692 private static String jsFunction_substr(String target, Object[] args) {
\r
693 if (args.length < 1)
\r
696 double begin = ScriptRuntime.toInteger(args[0]);
\r
698 int length = target.length();
\r
704 } else if (begin > length) {
\r
708 if (args.length == 1) {
\r
711 end = ScriptRuntime.toInteger(args[1]);
\r
719 return target.substring((int)begin, (int)end);
\r
723 * Python-esque sequence operations.
\r
725 private static String jsFunction_concat(String target, Object[] args) {
\r
726 int N = args.length;
\r
727 if (N == 0) { return target; }
\r
729 StringBuffer result = new StringBuffer();
\r
730 result.append(target);
\r
732 for (int i = 0; i < N; i++)
\r
733 result.append(ScriptRuntime.toString(args[i]));
\r
735 return result.toString();
\r
738 private static String jsFunction_slice(String target, Object[] args) {
\r
739 if (args.length != 0) {
\r
740 double begin = ScriptRuntime.toInteger(args[0]);
\r
742 int length = target.length();
\r
747 } else if (begin > length) {
\r
751 if (args.length == 1) {
\r
754 end = ScriptRuntime.toInteger(args[1]);
\r
759 } else if (end > length) {
\r
765 return target.substring((int)begin, (int)end);
\r
770 private static boolean jsFunction_equals(String target, String strOther) {
\r
771 return target.equals(strOther);
\r
775 private static boolean jsFunction_equalsIgnoreCase(String target,
\r
778 return target.equalsIgnoreCase(strOther);
\r
781 protected int maxInstanceId() { return MAX_INSTANCE_ID; }
\r
783 protected String getIdName(int id) {
\r
784 if (id == Id_length) { return "length"; }
\r
786 if (prototypeFlag) {
\r
788 case ConstructorId_fromCharCode: return "fromCharCode";
\r
790 case Id_constructor: return "constructor";
\r
791 case Id_toString: return "toString";
\r
792 case Id_valueOf: return "valueOf";
\r
793 case Id_charAt: return "charAt";
\r
794 case Id_charCodeAt: return "charCodeAt";
\r
795 case Id_indexOf: return "indexOf";
\r
796 case Id_lastIndexOf: return "lastIndexOf";
\r
797 case Id_split: return "split";
\r
798 case Id_substring: return "substring";
\r
799 case Id_toLowerCase: return "toLowerCase";
\r
800 case Id_toUpperCase: return "toUpperCase";
\r
801 case Id_substr: return "substr";
\r
802 case Id_concat: return "concat";
\r
803 case Id_slice: return "slice";
\r
804 case Id_bold: return "bold";
\r
805 case Id_italics: return "italics";
\r
806 case Id_fixed: return "fixed";
\r
807 case Id_strike: return "strike";
\r
808 case Id_small: return "small";
\r
809 case Id_big: return "big";
\r
810 case Id_blink: return "blink";
\r
811 case Id_sup: return "sup";
\r
812 case Id_sub: return "sub";
\r
813 case Id_fontsize: return "fontsize";
\r
814 case Id_fontcolor: return "fontcolor";
\r
815 case Id_link: return "link";
\r
816 case Id_anchor: return "anchor";
\r
817 case Id_equals: return "equals";
\r
818 case Id_equalsIgnoreCase: return "equalsIgnoreCase";
\r
819 case Id_match: return "match";
\r
820 case Id_search: return "search";
\r
821 case Id_replace: return "replace";
\r
827 private static final int
\r
828 ConstructorId_fromCharCode = -1,
\r
830 MAX_INSTANCE_ID = 1;
\r
833 protected int mapNameToId(String s) {
\r
834 if (s.equals("length")) { return Id_length; }
\r
835 else if (prototypeFlag) {
\r
836 return toPrototypeId(s);
\r
843 private static int toPrototypeId(String s) {
\r
845 // #generated# Last update: 2001-04-23 12:50:07 GMT+02:00
\r
846 L0: { id = 0; String X = null; int c;
\r
847 L: switch (s.length()) {
\r
848 case 3: c=s.charAt(2);
\r
849 if (c=='b') { if (s.charAt(0)=='s' && s.charAt(1)=='u') {id=Id_sub; break L0;} }
\r
850 else if (c=='g') { if (s.charAt(0)=='b' && s.charAt(1)=='i') {id=Id_big; break L0;} }
\r
851 else if (c=='p') { if (s.charAt(0)=='s' && s.charAt(1)=='u') {id=Id_sup; break L0;} }
\r
853 case 4: c=s.charAt(0);
\r
854 if (c=='b') { X="bold";id=Id_bold; }
\r
855 else if (c=='l') { X="link";id=Id_link; }
\r
857 case 5: switch (s.charAt(4)) {
\r
858 case 'd': X="fixed";id=Id_fixed; break L;
\r
859 case 'e': X="slice";id=Id_slice; break L;
\r
860 case 'h': X="match";id=Id_match; break L;
\r
861 case 'k': X="blink";id=Id_blink; break L;
\r
862 case 'l': X="small";id=Id_small; break L;
\r
863 case 't': X="split";id=Id_split; break L;
\r
865 case 6: switch (s.charAt(1)) {
\r
866 case 'e': c=s.charAt(0);
\r
867 if (c=='l') { X="length";id=Id_length; }
\r
868 else if (c=='s') { X="search";id=Id_search; }
\r
870 case 'h': X="charAt";id=Id_charAt; break L;
\r
871 case 'n': X="anchor";id=Id_anchor; break L;
\r
872 case 'o': X="concat";id=Id_concat; break L;
\r
873 case 'q': X="equals";id=Id_equals; break L;
\r
874 case 't': X="strike";id=Id_strike; break L;
\r
875 case 'u': X="substr";id=Id_substr; break L;
\r
877 case 7: switch (s.charAt(1)) {
\r
878 case 'a': X="valueOf";id=Id_valueOf; break L;
\r
879 case 'e': X="replace";id=Id_replace; break L;
\r
880 case 'n': X="indexOf";id=Id_indexOf; break L;
\r
881 case 't': X="italics";id=Id_italics; break L;
\r
883 case 8: c=s.charAt(0);
\r
884 if (c=='f') { X="fontsize";id=Id_fontsize; }
\r
885 else if (c=='t') { X="toString";id=Id_toString; }
\r
887 case 9: c=s.charAt(0);
\r
888 if (c=='f') { X="fontcolor";id=Id_fontcolor; }
\r
889 else if (c=='s') { X="substring";id=Id_substring; }
\r
891 case 10: X="charCodeAt";id=Id_charCodeAt; break L;
\r
892 case 11: switch (s.charAt(2)) {
\r
893 case 'L': X="toLowerCase";id=Id_toLowerCase; break L;
\r
894 case 'U': X="toUpperCase";id=Id_toUpperCase; break L;
\r
895 case 'n': X="constructor";id=Id_constructor; break L;
\r
896 case 's': X="lastIndexOf";id=Id_lastIndexOf; break L;
\r
898 case 16: X="equalsIgnoreCase";id=Id_equalsIgnoreCase; break L;
\r
900 if (X!=null && X!=s && !X.equals(s)) id = 0;
\r
906 private static final int
\r
907 Id_constructor = MAX_INSTANCE_ID + 1,
\r
908 Id_toString = MAX_INSTANCE_ID + 2,
\r
909 Id_valueOf = MAX_INSTANCE_ID + 3,
\r
910 Id_charAt = MAX_INSTANCE_ID + 4,
\r
911 Id_charCodeAt = MAX_INSTANCE_ID + 5,
\r
912 Id_indexOf = MAX_INSTANCE_ID + 6,
\r
913 Id_lastIndexOf = MAX_INSTANCE_ID + 7,
\r
914 Id_split = MAX_INSTANCE_ID + 8,
\r
915 Id_substring = MAX_INSTANCE_ID + 9,
\r
916 Id_toLowerCase = MAX_INSTANCE_ID + 10,
\r
917 Id_toUpperCase = MAX_INSTANCE_ID + 11,
\r
918 Id_substr = MAX_INSTANCE_ID + 12,
\r
919 Id_concat = MAX_INSTANCE_ID + 13,
\r
920 Id_slice = MAX_INSTANCE_ID + 14,
\r
921 Id_bold = MAX_INSTANCE_ID + 15,
\r
922 Id_italics = MAX_INSTANCE_ID + 16,
\r
923 Id_fixed = MAX_INSTANCE_ID + 17,
\r
924 Id_strike = MAX_INSTANCE_ID + 18,
\r
925 Id_small = MAX_INSTANCE_ID + 19,
\r
926 Id_big = MAX_INSTANCE_ID + 20,
\r
927 Id_blink = MAX_INSTANCE_ID + 21,
\r
928 Id_sup = MAX_INSTANCE_ID + 22,
\r
929 Id_sub = MAX_INSTANCE_ID + 23,
\r
930 Id_fontsize = MAX_INSTANCE_ID + 24,
\r
931 Id_fontcolor = MAX_INSTANCE_ID + 25,
\r
932 Id_link = MAX_INSTANCE_ID + 26,
\r
933 Id_anchor = MAX_INSTANCE_ID + 27,
\r
934 Id_equals = MAX_INSTANCE_ID + 28,
\r
935 Id_equalsIgnoreCase = MAX_INSTANCE_ID + 29,
\r
936 Id_match = MAX_INSTANCE_ID + 30,
\r
937 Id_search = MAX_INSTANCE_ID + 31,
\r
938 Id_replace = MAX_INSTANCE_ID + 32,
\r
940 MAX_PROTOTYPE_ID = MAX_INSTANCE_ID + 32;
\r
942 // #/string_id_map#
\r
944 private static final String defaultValue = "";
\r
946 private String string;
\r
948 private boolean prototypeFlag;
\r