1 // Copyright 2000-2005 the Contributors, as shown in the revision logs.
2 // Licensed under the Apache Public Source License 2.0 ("the License").
3 // You may not use this file except in compliance with the License.
7 import java.io.InputStream;
8 import org.ibex.util.*;
10 /** A JavaScript JSArray */
11 public class JSArray extends Basket.Array implements JS, Basket.CompareFunc {
12 private static final JS.Method METHOD = new JS.Method();
13 private static final String[] empty = new String[0];
16 JSArray(int size) { super(size); }
17 JSArray(JS[] args) { super(args.length); addAll(args); }
18 JSArray(JS arg) { super(1); add(arg); }
20 public JS unclone() { return this; }
21 public JS.Enumeration keys() throws JSExn {
22 return new Enumeration(null) {
24 public boolean _hasNext() { return n < size(); }
25 public JS _next() { return JSU.N(n++); }
28 public JS get(JS key) throws JSExn {
29 if (key == null || !(key instanceof JSNumber.I)) {
30 //#switch(JSU.str(key))
31 case "pop": return METHOD;
32 case "reverse": return METHOD;
33 case "toString": return METHOD;
34 case "shift": return METHOD;
35 case "join": return METHOD;
36 case "sort": return METHOD;
37 case "slice": return METHOD;
38 case "push": return METHOD;
39 case "unshift": return METHOD;
40 case "splice": return METHOD;
41 case "length": return JSU.N(size());
43 throw new JSExn("arrays only support positive integer keys, can not use: "+JSU.str(key));
45 return (JS)get(((JSNumber.I)key).toInt());
47 public void put(JS key, JS val) throws JSExn {
48 if (JSU.str(key).equals("length")) { setSize(JSU.toInt(val)); }
50 if (key == null || !(key instanceof JSNumber.I)) throw new JSExn(
51 "arrays only support positive integer keys, can not use: "+JSU.str(key));
52 int i = ((JSNumber.I)key).toInt();
53 if (i < 0) throw new JSExn("arrays can not use negative integer keys "+i);
54 size(i + 1); while (size() < i) add(null);
58 public String[] getFormalArgs() { return empty; }
59 public String coerceToString() throws JSExn { throw new JSExn("cannot coerce a "+getClass().getName()+" to a string"); }
61 public JS call(JS method, JS[] args) throws JSExn {
62 //#switch(JSU.str(method))
63 case "pop": return size() == 0 ? null : (JS)remove(size() - 1);
64 case "push": addAll(args); return JSU.N(size());
65 case "reverse": reverse(); return this;
66 case "toString": return join(",");
67 case "shift": return size() == 0 ? null : (JS)remove(0);
68 case "join": return join(args.length == 0 ? "," : JSU.str(args[0]));
69 case "sort": return sort(args.length == 0 ? null : args[0]);
71 int start = JSU.toInt(args.length < 1 ? null : args[0]);
72 int end = args.length < 2 ? size() : JSU.toInt(args[1]);
73 return slice(start, end);
75 for (int i=0; i < args.length; i++) add(i, args[i]);
77 case "splice": return splice(args);
79 throw new JSExn("arrays have no function: "+JSU.str(method));
82 public JS putAndTriggerTraps(JS key, JS val) throws JSExn { put(key, val); return val; }
83 public JS getAndTriggerTraps(JS key) throws JSExn { return get(key); }
84 public JS justTriggerTraps(JS key, JS val) throws JSExn { return val; }
86 public void addTrap(JS k, JS f) throws JSExn { throw new JSExn("arrays do not support traps"); }
87 public void delTrap(JS k, JS f) throws JSExn { throw new JSExn("arrays do not support traps"); }
88 public JS.Trap getTrap(JS k) throws JSExn { throw new JSExn("arrays do not support traps"); }
90 /** FEATURE: move to specialised ArrayStore superclass. */
91 public void addAll(JS[] entries) { for (int i=0; i < entries.length; i++) add(entries[i]); }
93 public void setSize(int newSize) {
95 for (int i=size(); i < newSize; i++) add(null);
96 for (int i=size() - 1; i >= newSize; i--) remove(i);
100 // ECMA Implementation ////////////////////////////////////////////////////
102 private JS join(String sep) throws JSExn {
104 if(length == 0) return JSU.S("");
105 StringBuffer sb = new StringBuffer(64);
109 if(o != null) sb.append(JSU.toString(o));
110 if(++i == length) break;
113 return JSU.S(sb.toString());
116 private JS slice(int start, int end) {
118 if(start < 0) start = length+start;
119 if(end < 0) end = length+end;
120 if(start < 0) start = 0;
122 if(start > length) start = length;
123 if(end > length) end = length;
124 JSArray a = new JSArray(end-start);
125 for(int i=0;i<end-start;i++) // FEATURE: with ArrayStore do System.arraycopy()
126 a.set(i, get(start+i));
130 private JS splice(JS[] args) throws JSExn {
131 int oldLength = size();
132 int start = JSU.toInt(args.length < 1 ? null : args[0]);
133 int deleteCount = JSU.toInt(args.length < 2 ? null : args[1]);
134 int newCount = args.length - 2;
135 if(newCount < 0) newCount = 0;
136 if(start < 0) start = oldLength+start;
137 if(start < 0) start = 0;
138 if(start > oldLength) start = oldLength;
139 if(deleteCount < 0) deleteCount = 0;
140 if(deleteCount > oldLength-start) deleteCount = oldLength-start;
141 int newLength = oldLength - deleteCount + newCount;
142 int lengthChange = newLength - oldLength;
143 JSArray ret = new JSArray(deleteCount);
144 for(int i=0;i<deleteCount;i++) // FEATURE: ArrayStore System.arraycopy()
145 ret.set(i, get(start+i));
146 if(lengthChange > 0) {
148 for(int i=newLength-1;i>=start+newCount;i--)
149 set(i, get(i-lengthChange));
150 } else if(lengthChange < 0) {
151 for(int i=start+newCount;i<newLength;i++)
152 set(i, get(i-lengthChange));
155 for(int i=0;i<newCount;i++)
156 set(start+i, args[i+2]);
160 private static final Basket.CompareFunc defaultSort = new Basket.CompareFunc() {
161 public int compare(Object a, Object b) {
162 try { return JSU.toString((JS)a).compareTo(JSU.toString((JS)b)); }
163 catch (JSExn e) { throw new JSExn.Wrapper(e); }
166 private JS sort(JS comparator) throws JSExn {
168 if (comparator == null) sort(defaultSort);
169 else { sort = comparator; sort((CompareFunc)this); }
171 } catch (JSExn.Wrapper w) { throw w.unwrap();
172 } finally { sort = null; }
175 private JS sort = null;
176 private final JS[] sortargs = new JS[2];
177 public int compare(Object a, Object b) throws JSExn.Wrapper {
179 sortargs[0] = (JS)a; sortargs[1] = (JS)b;
180 return JSU.toInt(sort.call(null, sortargs));
181 } catch (JSExn e) { throw new JSExn.Wrapper(e);
182 } finally { sortargs[0] = null; sortargs[1] = null; }