X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Fibex%2Fjs%2FJSRegexp.java;h=25b890f39c517132160ef665cb94419bb6128a65;hb=37cb1124382eec0585e92f91e9b0bfab579a9264;hp=da22d2e22ebd7af4be52a18485a1c1baae25c8b1;hpb=b1fa73c17b31f268fca5695d0876d7314fbacce3;p=org.ibex.js.git

diff --git a/src/org/ibex/js/JSRegexp.java b/src/org/ibex/js/JSRegexp.java
index da22d2e..25b890f 100644
--- a/src/org/ibex/js/JSRegexp.java
+++ b/src/org/ibex/js/JSRegexp.java
@@ -1,158 +1,179 @@
-// Copyright 2004 Adam Megacz, see the COPYING file for licensing [GPL]
-package org.ibex.js;
+// Copyright 2000-2005 the Contributors, as shown in the revision logs.
+// Licensed under the Apache Public Source License 2.0 ("the License").
+// You may not use this file except in compliance with the License.
 
-import gnu.regexp.*;
+package org.ibex.js;
 
 /** A JavaScript regular expression object */
-public class JSRegexp extends JS {
+public class JSRegexp extends JS.Immutable {
+    private static final JS.Method METHOD = new JS.Method();
+
     private boolean global;
-    private RE re;
+    private GnuRegexp.RE re;
     private int lastIndex;
+
+    private JS pattern;
+    private int flags;
     
-    public JSRegexp(Object arg0, Object arg1) throws JSExn {
+    public JSRegexp(JS arg0, JS arg1) throws JSExn {
         if(arg0 instanceof JSRegexp) {
             JSRegexp r = (JSRegexp) arg0;
             this.global = r.global;
             this.re = r.re;
             this.lastIndex = r.lastIndex;
+            this.pattern = r.pattern;
+            this.flags = r.flags;
         } else {
-            String pattern = (String)arg0;
+            String pattern = JSU.toString(arg0);
             String sFlags = null;
             int flags = 0;
-            if(arg1 != null) sFlags = (String)arg1;
+            if(arg1 != null) sFlags = JSU.toString(arg1);
             if(sFlags == null) sFlags = "";
             for(int i=0;i<sFlags.length();i++) {
                 switch(sFlags.charAt(i)) {
-                    case 'i': flags |= RE.REG_ICASE; break;
-                    case 'm': flags |= RE.REG_MULTILINE; break;
+                    case 'i': flags |= GnuRegexp.RE.REG_ICASE; break;
+                    case 'm': flags |= GnuRegexp.RE.REG_MULTILINE; break;
                     case 'g': global = true; break;
                     default: throw new JSExn("Invalid flag in regexp \"" + sFlags.charAt(i) + "\"");
                 }
             }
             re = newRE(pattern,flags);
-            put("source", pattern);
-            put("global", B(global));
-            put("ignoreCase", B(flags & RE.REG_ICASE));
-            put("multiline", B(flags & RE.REG_MULTILINE));
+            this.pattern = JSU.S(pattern);
+            this.flags = flags;
         }
     }
 
-    public Object callMethod(Object method, Object a0, Object a1, Object a2, Object[] rest, int nargs) throws JSExn {
-        switch(nargs) {
+    public JS call(JS method, JS[] args) throws JSExn {
+        switch(args.length) {
             case 1: {
-                //#switch(method)
+                //#switch(JSU.str(method))
                 case "exec": {
-                    String s = (String)a0;
+                    String s = JSU.toString(args[0]);
                     int start = global ? lastIndex : 0;
                     if(start < 0 || start >= s.length()) { lastIndex = 0; return null; }
-                    REMatch match = re.getMatch(s,start);
+                    GnuRegexp.REMatch match = re.getMatch(s,start);
                     if(global) lastIndex = match == null ? s.length() : match.getEndIndex();
                     return match == null ? null : matchToExecResult(match,re,s);
                 }
                 case "test": {
-                    String s = (String)a0;
-                    if (!global) return B(re.getMatch(s) != null);
+                    String s = JSU.toString(args[0]);
+                    if (!global) return JSU.B(re.getMatch(s) != null);
                     int start = global ? lastIndex : 0;
                     if(start < 0 || start >= s.length()) { lastIndex = 0; return null; }
-                    REMatch match = re.getMatch(s,start);
+                    GnuRegexp.REMatch match = re.getMatch(s,start);
                     lastIndex = match != null ? s.length() : match.getEndIndex();
-                    return B(match != null);
+                    return JSU.B(match != null);
                 }
-                case "toString": return toString(a0);
-                case "stringMatch": return stringMatch(a0,a1);
-                case "stringSearch": return stringSearch(a0,a1);
+                case "toString": return JSU.S(args[0].coerceToString());
                 //#end
                 break;
             }
             case 2: {
-                //#switch(method)
-                case "stringReplace": return stringReplace(a0, a1,a2);
+                //#switch(JSU.str(method))
+                case "stringMatch": return stringMatch(args[0], args[1]);
+                case "stringSearch": return stringSearch(args[0], args[1]);
+                //#end
+                break;
+            }
+            case 3: {
+                //#switch(JSU.str(method))
+                case "stringReplace": return stringReplace(args[0], args[1], args[2]);
                 //#end
                 break;
             }
         }
-        return super.callMethod(method, a0, a1, a2, rest, nargs);
+        return super.call(method, args);
     }
     
-    public Object get(Object key) throws JSExn {
-        //#switch(key)
+    public JS get(JS key) throws JSExn {
+        //#switch(JSU.str(key))
         case "exec": return METHOD;
         case "test": return METHOD;
         case "toString": return METHOD;
-        case "lastIndex": return N(lastIndex);
+        case "lastIndex": return JSU.N(lastIndex);
+        case "source": return pattern;
+        case "global": return JSU.B(global);
+        case "ignoreCase": return JSU.B(flags & GnuRegexp.RE.REG_ICASE);
+        case "multiline": return JSU.B(flags & GnuRegexp.RE.REG_MULTILINE);
         //#end
         return super.get(key);
     }
     
-    public void put(Object key, Object value) throws JSExn {
-        if(key.equals("lastIndex")) lastIndex = JS.toNumber(value).intValue();
+    public void put(JS key, JS value) throws JSExn {
+        if(JSU.isString(key)) {
+            if(JSU.toString(key).equals("lastIndex")) {
+                lastIndex = JSU.toInt(value);
+                return;
+            }
+        }
         super.put(key,value);
     }
   
-    private static Object matchToExecResult(REMatch match, RE re, String s) {
+    private static JS matchToExecResult(GnuRegexp.REMatch match, GnuRegexp.RE re, String s) {
+        if (match == null) return null;
         try {
-            JS ret = new JS();
-            ret.put("index", N(match.getStartIndex()));
-            ret.put("input",s);
+            JS ret = new JS.Obj();
+            ret.put(JSU.S("index"), JSU.N(match.getStartIndex()));
+            ret.put(JSU.S("input"), JSU.S(s));
             int n = re.getNumSubs();
-            ret.put("length", N(n+1));
-            ret.put("0",match.toString());
-            for(int i=1;i<=n;i++) ret.put(Integer.toString(i),match.toString(i));
+            ret.put(JSU.S("length"), JSU.N(n+1));
+            ret.put(JSU.ZERO, JSU.S(match.toString()));
+            for(int i=1;i<=n;i++) ret.put(JSU.N(i),JSU.S(match.toString(i)));
             return ret;
         } catch (JSExn e) {
             throw new Error("this should never happen");
         }
     }
     
-    public String toString() {
-        try {
-            StringBuffer sb = new StringBuffer();
-            sb.append('/');
-            sb.append(get("source"));
-            sb.append('/');
-            if(global) sb.append('g');
-            if(Boolean.TRUE.equals(get("ignoreCase"))) sb.append('i');
-            if(Boolean.TRUE.equals(get("multiline"))) sb.append('m');
-            return sb.toString();
-        } catch (JSExn e) {
-            throw new Error("this should never happen");
-        }
+    public String coerceToString() {
+        StringBuffer sb = new StringBuffer();
+        sb.append('/');
+        sb.append(pattern);
+        sb.append('/');
+        if(global) sb.append('g');
+        if((flags & GnuRegexp.RE.REG_ICASE) != 0) sb.append('i');
+        if((flags & GnuRegexp.RE.REG_MULTILINE) != 0) sb.append('m');
+        return sb.toString();
     }
     
-    public static Object stringMatch(Object o, Object arg0) throws JSExn {
-        String s = o.toString();
-        RE re;
+    private static final JS[] execarg = new JS[1];
+    static JS stringMatch(JS o, JS arg0) throws JSExn {
+        String s = JSU.toString(o);
+        GnuRegexp.RE re;
         JSRegexp regexp = null;
         if(arg0 instanceof JSRegexp) {
             regexp = (JSRegexp) arg0;
             re = regexp.re;
         } else {
-            re = newRE(arg0.toString(),0);
+            re = newRE(JSU.toString(arg0),0);
         }
         
         if(regexp == null) {
-            REMatch match = re.getMatch(s);
+            GnuRegexp.REMatch match = re.getMatch(s);
             return matchToExecResult(match,re,s);
         }
-        if(!regexp.global) return regexp.callMethod("exec", s, null, null, null, 1);
-        
-        JSArray ret = new JSArray();
-        REMatch[] matches = re.getAllMatches(s);
-        for(int i=0;i<matches.length;i++) ret.addElement(matches[i].toString());
+        try {
+            execarg[0] = o;
+            if(!regexp.global) return regexp.call(JSU.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(JSU.S(matches[i].toString()));
         regexp.lastIndex = matches.length > 0 ? matches[matches.length-1].getEndIndex() : s.length();
         return ret;
     }
     
-    public static Object stringSearch(Object o, Object arg0) throws JSExn  {
-        String s = o.toString();
-        RE re = arg0 instanceof JSRegexp ? ((JSRegexp)arg0).re : newRE(arg0.toString(),0);
-        REMatch match = re.getMatch(s);
-        return match == null ? N(-1) : N(match.getStartIndex());
+    static JS stringSearch(JS o, JS arg0) throws JSExn  {
+        String s = JSU.toString(o);
+        GnuRegexp.RE re = arg0 instanceof JSRegexp ? ((JSRegexp)arg0).re : newRE(JSU.toString(arg0),0);
+        GnuRegexp.REMatch match = re.getMatch(s);
+        return match == null ? JSU.N(-1) : JSU.N(match.getStartIndex());
     }
     
-    public static Object stringReplace(Object o, Object arg0, Object arg1) throws JSExn {
-        String s = o.toString();
-        RE re;
+    static JS stringReplace(JS o, JS arg0, JS arg1) throws JSExn {
+        String s = JSU.toString(o);
+        GnuRegexp.RE re;
         JSFunction replaceFunc = null;
         String replaceString = null;
         JSRegexp regexp = null;
@@ -165,8 +186,8 @@ public class JSRegexp extends JS {
         if(arg1 instanceof JSFunction)
             replaceFunc = (JSFunction) arg1;
         else
-            replaceString = JS.toString(arg1.toString());
-        REMatch[] matches;
+            replaceString = JSU.toString(arg1);
+        GnuRegexp.REMatch[] matches;
         if(regexp != null && regexp.global) {
             matches = re.getAllMatches(s);
             if(regexp != null) {
@@ -176,49 +197,33 @@ public class JSRegexp extends JS {
                     regexp.lastIndex = s.length();
             }
         } else {
-            REMatch match = re.getMatch(s);
+            GnuRegexp.REMatch match = re.getMatch(s);
             if(match != null)
-                matches = new REMatch[]{ match };
+                matches = new GnuRegexp.REMatch[]{ match };
             else
-                matches = new REMatch[0];
+                matches = new GnuRegexp.REMatch[0];
         }
         
         StringBuffer sb = new StringBuffer(s.length());
         int pos = 0;
         char[] sa = s.toCharArray();
         for(int i=0;i<matches.length;i++) {
-            REMatch match = matches[i];
+            GnuRegexp.REMatch match = matches[i];
             sb.append(sa,pos,match.getStartIndex()-pos);
             pos = match.getEndIndex();
             if(replaceFunc != null) {
                 int n = (regexp == null ? 0 : re.getNumSubs());
                 int numArgs = 3 + n;
-                Object[] rest = new Object[numArgs - 3];
-                Object a0 = match.toString();
-                Object a1 = null;
-                Object a2 = null;
-                for(int j=1;j<=n;j++)
-                    switch(j) {
-                        case 1: a1 = match.toString(j); break;
-                        case 2: a2 = match.toString(j); break;
-                        default: rest[j - 3] = match.toString(j); break;
-                    }
-                switch(numArgs) {
-                    case 3:
-                        a1 = N(match.getStartIndex());
-                        a2 = s;
-                        break;
-                    case 4:
-                        a2 = N(match.getStartIndex());
-                        rest[0] = s;
-                        break;
-                    default:
-                        rest[rest.length - 2] = N(match.getStartIndex());
-                        rest[rest.length - 1] = s;
-                }
+                JS[] args = new JS[3 + n];
+                args[0] = JSU.S(match.toString());
+                args[1] = null;
+                args[2] = null;
+                for(int j=1;j<=n;j++) args[j] = JSU.S(match.toString(j));
+                args[args.length - 2] = JSU.N(match.getStartIndex());
+                args[args.length - 1] = JSU.S(s);
 
                 // note: can't perform pausing operations in here
-                sb.append((String)replaceFunc.call(a0, a1, a2, rest, numArgs));
+                sb.append(JSU.toString(replaceFunc.call(args)));
 
             } else {
                 sb.append(mySubstitute(match,replaceString,s));
@@ -226,10 +231,10 @@ public class JSRegexp extends JS {
         }
         int end = matches.length == 0 ? 0 : matches[matches.length-1].getEndIndex();
         sb.append(sa,end,sa.length-end);
-        return sb.toString();
+        return JSU.S(sb.toString());
     }
     
-    private static String mySubstitute(REMatch match, String s, String source) {
+    private static String mySubstitute(GnuRegexp.REMatch match, String s, String source) {
         StringBuffer sb = new StringBuffer();
         int i,n;
         char c,c2;
@@ -271,12 +276,13 @@ public class JSRegexp extends JS {
     }
                     
     
-    public static Object stringSplit(String s, Object arg0, Object arg1, int nargs) {
-        int limit = nargs < 2 ? Integer.MAX_VALUE : JS.toInt(arg1);
+    static JS stringSplit(JS s_, JS arg0, JS arg1, int nargs) throws JSExn {
+        String s = JSU.toString(s_);
+        int limit = nargs < 2 ? Integer.MAX_VALUE : JSU.toInt(arg1);
         if(limit < 0) limit = Integer.MAX_VALUE;
-        if(limit == 0) return new JSArray();
+        if(limit == 0) return new JSArray(0);
         
-        RE re = null;
+        GnuRegexp.RE re = null;
         JSRegexp regexp = null;
         String sep = null;
         JSArray ret = new JSArray();
@@ -286,7 +292,7 @@ public class JSRegexp extends JS {
             regexp = (JSRegexp) arg0;
             re = regexp.re;
         } else {
-            sep = arg0.toString();
+            sep = JSU.toString(arg0);
         }
         
         // special case this for speed. additionally, the code below doesn't properly handle
@@ -294,43 +300,41 @@ public class JSRegexp extends JS {
         if(sep != null && sep.length()==0) {
             int len = s.length();
             for(int i=0;i<len;i++)
-                ret.addElement(s.substring(i,i+1));
+                ret.add(JSU.S(s.substring(i,i+1)));
             return ret;
         }
         
         OUTER: while(p < s.length()) {
             if(re != null) {
-                REMatch m = re.getMatch(s,p);
+                GnuRegexp.REMatch m = re.getMatch(s,p);
                 if(m == null) break OUTER;
                 boolean zeroLength = m.getStartIndex() == m.getEndIndex();
-                ret.addElement(s.substring(p,zeroLength ? m.getStartIndex()+1 : m.getStartIndex()));
+                ret.add(JSU.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(m.toString(i));
-                        if(ret.length() == limit) break OUTER;
+                        ret.add(JSU.S(m.toString(i)));
+                        if(ret.size() == limit) break OUTER;
                     }
                 }
             } else {
                 int x = s.indexOf(sep,p);
                 if(x == -1) break OUTER;
-                ret.addElement(s.substring(p,x));
+                ret.add(JSU.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(s.substring(p));
+        if(p < s.length() && ret.size() != limit)
+            ret.add(JSU.S(s.substring(p)));
         return ret;
     }
-    
-    public static RE newRE(String pattern, int flags) throws JSExn {
+   
+    public static GnuRegexp.RE newRE(String pattern, int flags) throws JSExn {
         try {
-            return new RE(pattern,flags,RESyntax.RE_SYNTAX_PERL5);
-        } catch(REException e) {
+            return new GnuRegexp.RE(pattern,flags,GnuRegexp.RESyntax.RE_SYNTAX_PERL5);
+        } catch(GnuRegexp.REException e) {
             throw new JSExn(e.toString());
         }
     }
-    
-    public String typeName() { return "regexp"; }
 }