X-Git-Url: http://git.megacz.com/?p=org.ibex.js.git;a=blobdiff_plain;f=src%2Forg%2Fibex%2Fjs%2FJSRegexp.java;h=3353b1dd7ea445f88db8168f3ad846e1e442937b;hp=a98792169d09d9837c3e32e7063666728d92db41;hb=7113d47d1ef227732b610026bee8c22b9ada3525;hpb=2d38cf96f2ac17fe1961aadb8bf4f02e5a1b5294

diff --git a/src/org/ibex/js/JSRegexp.java b/src/org/ibex/js/JSRegexp.java
index a987921..3353b1d 100644
--- a/src/org/ibex/js/JSRegexp.java
+++ b/src/org/ibex/js/JSRegexp.java
@@ -24,10 +24,10 @@ public class JSRegexp extends JS.Immutable {
             this.pattern = r.pattern;
             this.flags = r.flags;
         } else {
-            String pattern = JS.toString(arg0);
+            String pattern = Script.toString(arg0);
             String sFlags = null;
             int flags = 0;
-            if(arg1 != null) sFlags = JS.toString(arg1);
+            if(arg1 != null) sFlags = Script.toString(arg1);
             if(sFlags == null) sFlags = "";
             for(int i=0;i<sFlags.length();i++) {
                 switch(sFlags.charAt(i)) {
@@ -38,7 +38,7 @@ public class JSRegexp extends JS.Immutable {
                 }
             }
             re = newRE(pattern,flags);
-            this.pattern = JS.S(pattern);
+            this.pattern = Script.S(pattern);
             this.flags = flags;
         }
     }
@@ -46,9 +46,9 @@ public class JSRegexp extends JS.Immutable {
     public JS call(JS method, JS[] args) throws JSExn {
         switch(args.length) {
             case 1: {
-                //#switch(JS.str(method))
+                //#switch(Script.str(method))
                 case "exec": {
-                    String s = JS.toString(a0);
+                    String s = Script.toString(args[0]);
                     int start = global ? lastIndex : 0;
                     if(start < 0 || start >= s.length()) { lastIndex = 0; return null; }
                     GnuRegexp.REMatch match = re.getMatch(s,start);
@@ -56,27 +56,27 @@ public class JSRegexp extends JS.Immutable {
                     return match == null ? null : matchToExecResult(match,re,s);
                 }
                 case "test": {
-                    String s = JS.toString(a0);
-                    if (!global) return B(re.getMatch(s) != null);
+                    String s = Script.toString(args[0]);
+                    if (!global) return Script.B(re.getMatch(s) != null);
                     int start = global ? lastIndex : 0;
                     if(start < 0 || start >= s.length()) { lastIndex = 0; return null; }
                     GnuRegexp.REMatch match = re.getMatch(s,start);
                     lastIndex = match != null ? s.length() : match.getEndIndex();
-                    return B(match != null);
+                    return Script.B(match != null);
                 }
-                case "toString": return JS.S(args[0].coerceToString());
+                case "toString": return Script.S(args[0].coerceToString());
                 //#end
                 break;
             }
             case 2: {
-                //#switch(JS.str(method))
+                //#switch(Script.str(method))
                 case "stringMatch": return stringMatch(args[0], args[1]);
                 case "stringSearch": return stringSearch(args[0], args[1]);
                 //#end
                 break;
             }
             case 3: {
-                //#switch(JS.str(method))
+                //#switch(Script.str(method))
                 case "stringReplace": return stringReplace(args[0], args[1], args[2]);
                 //#end
                 break;
@@ -86,23 +86,23 @@ public class JSRegexp extends JS.Immutable {
     }
     
     public JS get(JS key) throws JSExn {
-        //#switch(JS.str(key))
+        //#switch(Script.str(key))
         case "exec": return METHOD;
         case "test": return METHOD;
         case "toString": return METHOD;
-        case "lastIndex": return JS.N(lastIndex);
+        case "lastIndex": return Script.N(lastIndex);
         case "source": return pattern;
-        case "global": return JS.B(global);
-        case "ignoreCase": return JS.B(flags & GnuRegexp.RE.REG_ICASE);
-        case "multiline": return JS.B(flags & GnuRegexp.RE.REG_MULTILINE);
+        case "global": return Script.B(global);
+        case "ignoreCase": return Script.B(flags & GnuRegexp.RE.REG_ICASE);
+        case "multiline": return Script.B(flags & GnuRegexp.RE.REG_MULTILINE);
         //#end
         return super.get(key);
     }
     
     public void put(JS key, JS value) throws JSExn {
-        if(JS.isString(key)) {
-            if(JS.toString(key).equals("lastIndex")) {
-                lastIndex = JS.toInt(value);
+        if(Script.isString(key)) {
+            if(Script.toString(key).equals("lastIndex")) {
+                lastIndex = Script.toInt(value);
                 return;
             }
         }
@@ -112,12 +112,12 @@ public class JSRegexp extends JS.Immutable {
     private static JS matchToExecResult(GnuRegexp.REMatch match, GnuRegexp.RE re, String s) {
         try {
             JS ret = new JS.Obj();
-            ret.put(JS.S("index"), JS.N(match.getStartIndex()));
-            ret.put(JS.S("input"), JS.S(s));
+            ret.put(Script.S("index"), Script.N(match.getStartIndex()));
+            ret.put(Script.S("input"), Script.S(s));
             int n = re.getNumSubs();
-            ret.put(JS.S("length"), JS.N(n+1));
-            ret.put(ZERO,JS.S(match.toString()));
-            for(int i=1;i<=n;i++) ret.put(JS.N(i),JS.S(match.toString(i)));
+            ret.put(Script.S("length"), Script.N(n+1));
+            ret.put(Script.ZERO, Script.S(match.toString()));
+            for(int i=1;i<=n;i++) ret.put(Script.N(i),Script.S(match.toString(i)));
             return ret;
         } catch (JSExn e) {
             throw new Error("this should never happen");
@@ -137,14 +137,14 @@ public class JSRegexp extends JS.Immutable {
     
     private static final JS[] execarg = new JS[1];
     static JS stringMatch(JS o, JS arg0) throws JSExn {
-        String s = JS.toString(o);
+        String s = Script.toString(o);
         GnuRegexp.RE re;
         JSRegexp regexp = null;
         if(arg0 instanceof JSRegexp) {
             regexp = (JSRegexp) arg0;
             re = regexp.re;
         } else {
-            re = newRE(JS.toString(arg0),0);
+            re = newRE(Script.toString(arg0),0);
         }
         
         if(regexp == null) {
@@ -153,25 +153,25 @@ public class JSRegexp extends JS.Immutable {
         }
         try {
             execarg[0] = o;
-            if(!regexp.global) return regexp.call(JS.S("exec"), execarg);
+            if(!regexp.global) return regexp.call(Script.S("exec"), execarg);
         } finally { execarg[0] = null; }
 
         GnuRegexp.REMatch[] matches = re.getAllMatches(s);
         JSArray ret = new JSArray(matches.length);
-        for(int i=0;i<matches.length;i++) ret.add(JS.S(matches[i].toString()));
+        for(int i=0;i<matches.length;i++) ret.add(Script.S(matches[i].toString()));
         regexp.lastIndex = matches.length > 0 ? matches[matches.length-1].getEndIndex() : s.length();
         return ret;
     }
     
     static JS stringSearch(JS o, JS arg0) throws JSExn  {
-        String s = JS.toString(o);
-        GnuRegexp.RE re = arg0 instanceof JSRegexp ? ((JSRegexp)arg0).re : newRE(JS.toString(arg0),0);
+        String s = Script.toString(o);
+        GnuRegexp.RE re = arg0 instanceof JSRegexp ? ((JSRegexp)arg0).re : newRE(Script.toString(arg0),0);
         GnuRegexp.REMatch match = re.getMatch(s);
-        return match == null ? JS.N(-1) : JS.N(match.getStartIndex());
+        return match == null ? Script.N(-1) : Script.N(match.getStartIndex());
     }
     
     static JS stringReplace(JS o, JS arg0, JS arg1) throws JSExn {
-        String s = JS.toString(o);
+        String s = Script.toString(o);
         GnuRegexp.RE re;
         JSFunction replaceFunc = null;
         String replaceString = null;
@@ -185,7 +185,7 @@ public class JSRegexp extends JS.Immutable {
         if(arg1 instanceof JSFunction)
             replaceFunc = (JSFunction) arg1;
         else
-            replaceString = JS.toString(arg1);
+            replaceString = Script.toString(arg1);
         GnuRegexp.REMatch[] matches;
         if(regexp != null && regexp.global) {
             matches = re.getAllMatches(s);
@@ -214,15 +214,15 @@ public class JSRegexp extends JS.Immutable {
                 int n = (regexp == null ? 0 : re.getNumSubs());
                 int numArgs = 3 + n;
                 JS[] args = new JS[3 + n];
-                args[0] = JS.S(match.toString());
+                args[0] = Script.S(match.toString());
                 args[1] = null;
                 args[2] = null;
-                for(int j=1;j<=n;j++) args[j] = JS.S(match.toString(j));
-                args[args.length - 2] = JS.N(match.getStartIndex());
-                args[args.length - 1] = JS.S(s);
+                for(int j=1;j<=n;j++) args[j] = Script.S(match.toString(j));
+                args[args.length - 2] = Script.N(match.getStartIndex());
+                args[args.length - 1] = Script.S(s);
 
                 // note: can't perform pausing operations in here
-                sb.append(JS.toString(replaceFunc.call(args)));
+                sb.append(Script.toString(replaceFunc.call(args)));
 
             } else {
                 sb.append(mySubstitute(match,replaceString,s));
@@ -230,7 +230,7 @@ public class JSRegexp extends JS.Immutable {
         }
         int end = matches.length == 0 ? 0 : matches[matches.length-1].getEndIndex();
         sb.append(sa,end,sa.length-end);
-        return JS.S(sb.toString());
+        return Script.S(sb.toString());
     }
     
     private static String mySubstitute(GnuRegexp.REMatch match, String s, String source) {
@@ -276,8 +276,8 @@ public class JSRegexp extends JS.Immutable {
                     
     
     static JS stringSplit(JS s_, JS arg0, JS arg1, int nargs) throws JSExn {
-        String s = JS.toString(s_);
-        int limit = nargs < 2 ? Integer.MAX_VALUE : JS.toInt(arg1);
+        String s = Script.toString(s_);
+        int limit = nargs < 2 ? Integer.MAX_VALUE : Script.toInt(arg1);
         if(limit < 0) limit = Integer.MAX_VALUE;
         if(limit == 0) return new JSArray(0);
         
@@ -291,7 +291,7 @@ public class JSRegexp extends JS.Immutable {
             regexp = (JSRegexp) arg0;
             re = regexp.re;
         } else {
-            sep = JS.toString(arg0);
+            sep = Script.toString(arg0);
         }
         
         // special case this for speed. additionally, the code below doesn't properly handle
@@ -299,7 +299,7 @@ public class JSRegexp extends JS.Immutable {
         if(sep != null && sep.length()==0) {
             int len = s.length();
             for(int i=0;i<len;i++)
-                ret.addElement(JS.S(s.substring(i,i+1)));
+                ret.add(Script.S(s.substring(i,i+1)));
             return ret;
         }
         
@@ -308,24 +308,24 @@ public class JSRegexp extends JS.Immutable {
                 GnuRegexp.REMatch m = re.getMatch(s,p);
                 if(m == null) break OUTER;
                 boolean zeroLength = m.getStartIndex() == m.getEndIndex();
-                ret.addElement(JS.S(s.substring(p,zeroLength ? m.getStartIndex()+1 : m.getStartIndex())));
+                ret.add(Script.S(s.substring(p,zeroLength ? m.getStartIndex()+1 : m.getStartIndex())));
                 p = zeroLength ? p + 1 : m.getEndIndex();
                 if(!zeroLength) {
                     for(int i=1;i<=re.getNumSubs();i++) {
-                        ret.addElement(JS.S(m.toString(i)));
-                        if(ret.length() == limit) break OUTER;
+                        ret.add(Script.S(m.toString(i)));
+                        if(ret.size() == limit) break OUTER;
                     }
                 }
             } else {
                 int x = s.indexOf(sep,p);
                 if(x == -1) break OUTER;
-                ret.addElement(JS.S(s.substring(p,x)));
+                ret.add(Script.S(s.substring(p,x)));
                 p = x + sep.length();
             }
-            if(ret.length() == limit) break;
+            if(ret.size() == limit) break;
         }
-        if(p < s.length() && ret.length() != limit)
-            ret.addElement(JS.S(s.substring(p)));
+        if(p < s.length() && ret.size() != limit)
+            ret.add(Script.S(s.substring(p)));
         return ret;
     }