fixes and additions to new js api

[org.ibex.core.git] / src / org / ibex / js / JSPrimitive.java

diff --git a/src/org/ibex/js/JSPrimitive.java b/src/org/ibex/js/JSPrimitive.java
new file mode 100644 (file)
index 0000000..1b574ea
--- /dev/null
+++ b/src/org/ibex/js/JSPrimitive.java
@@ -0,0 +1,114 @@
+package org.ibex.js;
+
+class JSPrimitive extends JS {
+    public JS callMethod(JS method_, JS arg0, JS arg1, JS arg2, JS[] rest, int alength) throws JSExn {
+        if(!JS.isString(method_)) return super.callMethod(method_,arg0,arg1,arg2,rest,alength);
+        String method = JS.toString(method_);
+        
+        //#switch(method)
+        case "toFixed": throw new JSExn("toFixed() not implemented");
+        case "toExponential": throw new JSExn("toExponential() not implemented");
+        case "toPrecision": throw new JSExn("toPrecision() not implemented");
+        case "toString": return this instanceof JSString ? this : JS.S(JS.toString(this));
+        //#end
+            
+        String s = coerceToString();
+        int slength = s.length();
+            
+        //#switch(method)
+        case "substring": {
+            int a = alength >= 1 ? JS.toInt(arg0) : 0;
+            int b = alength >= 2 ? JS.toInt(arg1) : slength;
+            if (a > slength) a = slength;
+            if (b > slength) b = slength;
+            if (a < 0) a = 0;
+            if (b < 0) b = 0;
+            if (a > b) { int tmp = a; a = b; b = tmp; }
+            return JS.S(s.substring(a,b));
+        }
+        case "substr": {
+            int start = alength >= 1 ? JS.toInt(arg0) : 0;
+            int len = alength >= 2 ? JS.toInt(arg1) : Integer.MAX_VALUE;
+            if (start < 0) start = slength + start;
+            if (start < 0) start = 0;
+            if (len < 0) len = 0;
+            if (len > slength - start) len = slength - start;
+            if (len <= 0) return JS.S("");
+            return JS.S(s.substring(start,start+len));
+        }
+        case "charAt": {
+            int p = alength >= 1 ? JS.toInt(arg0) : 0;
+            if (p < 0 || p >= slength) return JS.S("");
+            return JS.S(s.substring(p,p+1));
+        }
+        case "charCodeAt": {
+            int p = alength >= 1 ? JS.toInt(arg0) : 0;
+            if (p < 0 || p >= slength) return JS.N(Double.NaN);
+            return JS.N(s.charAt(p));
+        }
+        case "concat": {
+            StringBuffer sb = new StringBuffer(slength*2).append(s);
+            for(int i=0;i<alength;i++) sb.append(i==0?arg0:i==1?arg1:i==2?arg2:rest[i-3]);
+            return JS.S(sb.toString());
+        }
+        case "indexOf": {
+            String search = alength >= 1 ? JS.toString(arg0) : "null";
+            int start = alength >= 2 ? JS.toInt(arg1) : 0;
+            // Java's indexOf handles an out of bounds start index, it'll return -1
+            return JS.N(s.indexOf(search,start));
+        }
+        case "lastIndexOf": {
+            String search = alength >= 1 ? JS.toString(arg0) : "null";
+            int start = alength >= 2 ? JS.toInt(arg1) : 0;
+            // Java's indexOf handles an out of bounds start index, it'll return -1
+            return JS.N(s.lastIndexOf(search,start));            
+        }
+        case "match": return JSRegexp.stringMatch(this,arg0);
+        case "replace": return JSRegexp.stringReplace(this,arg0,arg1);
+        case "search": return JSRegexp.stringSearch(this,arg0);
+        case "split": return JSRegexp.stringSplit(this,arg0,arg1,alength);
+        case "toLowerCase": return JS.S(s.toLowerCase());
+        case "toUpperCase": return JS.S(s.toUpperCase());
+        case "slice": {
+            int a = alength >= 1 ? JS.toInt(arg0) : 0;
+            int b = alength >= 2 ? JS.toInt(arg1) : slength;
+            if (a < 0) a = slength + a;
+            if (b < 0) b = slength + b;
+            if (a < 0) a = 0;
+            if (b < 0) b = 0;
+            if (a > slength) a = slength;
+            if (b > slength) b = slength;
+            if (a > b) return JS.S("");
+            return JS.S(s.substring(a,b));
+        }
+        //#end
+        return super.callMethod(method_,arg0,arg1,arg2,rest,alength);
+    }
+    
+    public JS get(JS key_) throws JSExn {
+        if(!JS.isString(key_)) return super.get(key_);
+        String key = JS.toString(key_);
+        //#switch(key)
+        case "length": return JS.N(JS.toString(this).length());
+        case "substring": return METHOD;
+        case "charAt": return METHOD;
+        case "charCodeAt": return METHOD;
+        case "concat": return METHOD;
+        case "indexOf": return METHOD;
+        case "lastIndexOf": return METHOD; 
+        case "match": return METHOD;
+        case "replace": return METHOD;
+        case "search": return METHOD;
+        case "slice": return METHOD;
+        case "split": return METHOD;
+        case "toLowerCase": return METHOD; 
+        case "toUpperCase": return METHOD; 
+        case "toString": return METHOD; 
+        case "substr": return METHOD;  
+        case "toPrecision": return METHOD;
+        case "toExponential": return METHOD;
+        case "toFixed": return METHOD;
+        //#end
+        return super.get(key_);
+    }
+}