// Copyright 2003 Adam Megacz, see the COPYING file for licensing [GPL]
-
package org.xwt.js;
+
import org.xwt.util.*;
import java.io.*;
import java.util.*;
-/** A JavaScript Array */
-class ArrayImpl extends JS.Obj {
+/** A JavaScript JSArray */
+public class JSArray extends JSCallable {
private Vec vec = new Vec();
- public ArrayImpl() { }
- public ArrayImpl(int size) { vec.setSize(size); }
+ public JSArray() { }
+ public JSArray(int size) { vec.setSize(size); }
private static int intVal(Object o) {
if (o instanceof Number) {
int intVal = ((Number)o).intValue();
return Integer.parseInt(s);
}
- public Object callMethod(Object method, JS.Array args,boolean justChecking) {
+ public Object call(Object method, JSArray args) {
if(method.equals("push")) {
- if(justChecking) return Boolean.TRUE;
for(int i=0;i<args.length();i++)
vec.push(args.elementAt(i));
return new Integer(vec.size());
}
if(method.equals("pop")) {
- if(justChecking) return Boolean.TRUE;
return vec.pop(); // this'll return null on size()==0
}
if(method.equals("shift")) {
- if(justChecking) return Boolean.TRUE;
if(length() > 0) {
Object o = vec.elementAt(0);
vec.removeElementAt(0);
}
}
if(method.equals("unshift")) {
- if(justChecking) return Boolean.TRUE;
// FEATURE: could be optimized a bit with some help from Vec
for(int i=0;i<args.length();i++)
vec.insertElementAt(args.elementAt(i),i);
return new Integer(vec.size());
}
- if(method.equals("slice")) return justChecking ? Boolean.TRUE : slice(args);
- if(method.equals("join")) return justChecking ? Boolean.TRUE : join(args);
- if(method.equals("reverse")) return justChecking ? Boolean.TRUE : reverse(args);
- if(method.equals("toString")) return justChecking ? Boolean.TRUE : join(",");
- if(method.equals("sort")) return justChecking ? Boolean.TRUE : sort(args);
- if(method.equals("splice")) return justChecking ? Boolean.TRUE : splice(args);
- return super.callMethod(method,args,justChecking);
+ if(method.equals("slice")) return slice(args);
+ if(method.equals("join")) return join(args);
+ if(method.equals("reverse")) return reverse(args);
+ if(method.equals("toString")) return join(",");
+ if(method.equals("sort")) return sort(args);
+ if(method.equals("splice")) return splice(args);
+ throw new JS.Exn("unknown method " + method);
}
-
- // we use _get instead of get solely to work around a GCJ bug
- public Object _get(Object key) throws JS.Exn {
+ public Object get(Object key) throws JS.Exn {
if (key.equals("length")) return new Long(vec.size());
int i = intVal(key);
return null;
}
}
- // we use _put instead of put solely to work around a GCJ bug
- public void _put(Object key, Object val) {
+
+ public void put(Object key, Object val) {
if (key.equals("length")) vec.setSize(toNumber(val).intValue());
int i = intVal(key);
if (i == Integer.MIN_VALUE) super.put(key, val);
vec.setElementAt(val, i);
}
}
- public Object[] keys() {
- Object[] sup = super.keys();
- Object[] ret = new Object[vec.size() + 1 + sup.length];
- System.arraycopy(sup, 0, ret, vec.size(), sup.length);
- for(int i=0; i<vec.size(); i++) ret[i] = new Integer(i);
- ret[vec.size()] = "length";
- return ret;
+
+ public Enumeration keys() {
+ return new Enumeration() {
+ int cur = 0;
+ public boolean hasMoreElements() { return cur >= vec.size(); }
+ public Object nextElement() {
+ if (cur >= vec.size()) throw new NoSuchElementException();
+ return new Integer(cur++);
+ }
+ };
}
+
public void setSize(int i) { vec.setSize(i); }
public int length() { return vec.size(); }
public Object elementAt(int i) { return vec.elementAt(i); }
public void addElement(Object o) { vec.addElement(o); }
public void setElementAt(Object o, int i) { vec.setElementAt(o, i); }
-
+ public int size() { return vec.size(); }
public String typeName() { return "array"; }
- private Object join(JS.Array args) {
+ private Object join(JSArray args) {
return join(args.length() == 0 ? "," : JS.toString(args.elementAt(0)));
}
return sb.toString();
}
- private Object reverse(JS.Array args) {
+ private Object reverse(JSArray args) {
Vec oldVec = vec;
int size = oldVec.size();
if(size < 2) return this;
return this;
}
- private Object slice(JS.Array args) {
+ private Object slice(JSArray args) {
int length = length();
int start = JS.toInt(args.length() < 1 ? null : args.elementAt(0));
int end = args.length() < 2 ? length : JS.toInt(args.elementAt(1));
if(end < 0) end = 0;
if(start > length) start = length;
if(end > length) end = length;
- JS.Array a = new JS.Array(end-start);
+ JSArray a = new JSArray(end-start);
for(int i=0;i<end-start;i++)
a.setElementAt(elementAt(start+i),i);
return a;
return JS.toString(a).compareTo(JS.toString(b));
}
};
- private Object sort(JS.Array args) {
+ private Object sort(JSArray args) {
Object tmp = args.length() < 1 ? null : args.elementAt(0);
- if(tmp instanceof JS.Callable) {
- final JS.Array funcArgs = new JS.Array(2);
- final JS.Callable jsFunc = (JS.Callable) tmp;
+ if(tmp instanceof JSCallable) {
+ final JSArray funcArgs = new JSArray(2);
+ final JSCallable jsFunc = (JSCallable) tmp;
vec.sort(new Vec.CompareFunc() {
public int compare(Object a, Object b) {
funcArgs.setElementAt(a,0);
funcArgs.setElementAt(b,1);
- return JS.toInt(jsFunc.call(funcArgs));
+ return JS.toInt(jsFunc.call(null, funcArgs));
}
});
} else {
return this;
}
- private Object splice(JS.Array args) {
+ private Object splice(JSArray args) {
int oldLength = length();
int start = JS.toInt(args.length() < 1 ? null : args.elementAt(0));
int deleteCount = JS.toInt(args.length() < 2 ? null : args.elementAt(1));
if(deleteCount > oldLength-start) deleteCount = oldLength-start;
int newLength = oldLength - deleteCount + newCount;
int lengthChange = newLength - oldLength;
- JS.Array ret = new JS.Array(deleteCount);
+ JSArray ret = new JSArray(deleteCount);
for(int i=0;i<deleteCount;i++)
ret.setElementAt(elementAt(start+i),i);
if(lengthChange > 0) {
projects / org.ibex.core.git / blobdiff