src/org/ibex/js/JSArray.java

   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.
   4
   5 package org.ibex.js;
   6
   7 import java.io.InputStream;
   8 import org.ibex.util.*;
   9
  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];
  14
  15     JSArray() { }
  16     JSArray(int size) { super(size); }
  17     JSArray(JS[] args) { super(args.length); addAll(args); }
  18     JSArray(JS arg) { super(1); add(arg); }
  19
  20     public JS unclone() { return this; }
  21     public JS.Enumeration keys() throws JSExn {
  22         return new Enumeration(null) {
  23             private int n = 0;
  24             public boolean _hasNext() { return n < size(); }
  25             public JS _next() { return JSU.N(n++); }
  26         };
  27     }
  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());
  42             //#end
  43             throw new JSExn("arrays only support positive integer keys, can not use: "+JSU.str(key));
  44         }
  45         return (JS)get(((JSNumber.I)key).toInt());
  46     }
  47     public void put(JS key, JS val) throws JSExn {
  48         if (JSU.str(key).equals("length")) { setSize(JSU.toInt(val)); }
  49
  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);
  55         set(i, val);
  56     }
  57
  58     public String[] getFormalArgs() { return empty; }
  59     public String coerceToString() { return "array"; } // FIXME
  60
  61     public Object run(Object o) throws JSExn { return call(null, null); }
  62     public void pause() throws NotPausableException { throw new NotPausableException(); }
  63     public JS call(JS method, JS[] args) throws JSExn {
  64         //#switch(JSU.str(method))
  65         case "pop": return size() == 0 ? null : (JS)remove(size() - 1);
  66         case "push": addAll(args); return JSU.N(size());
  67         case "reverse": reverse(); return this;
  68         case "toString": return join(",");
  69         case "shift": return size() == 0 ? null : (JS)remove(0);
  70         case "join": return join(args.length == 0 ? "," : JSU.str(args[0]));
  71         case "sort": return sort(args.length == 0 ? null : args[0]);
  72         case "slice":
  73             int start = JSU.toInt(args.length < 1 ? null : args[0]);
  74             int end = args.length < 2 ? size() : JSU.toInt(args[1]);
  75             return slice(start, end);
  76         case "unshift":
  77             for (int i=0; i < args.length; i++) add(i, args[i]);
  78             return JSU.N(size());
  79         case "splice": return splice(args);
  80         //#end
  81         throw new JSExn("arrays have no function: "+JSU.str(method));
  82     }
  83
  84     public JS putAndTriggerTraps(JS key, JS val) throws JSExn { put(key, val); return val; }
  85     public JS getAndTriggerTraps(JS key) throws JSExn { return get(key); }
  86     public JS justTriggerTraps(JS key, JS val) throws JSExn { return val; }
  87
  88     public void addTrap(JS k, JS f) throws JSExn { throw new JSExn("arrays do not support traps"); }
  89     public void delTrap(JS k, JS f) throws JSExn { throw new JSExn("arrays do not support traps"); }
  90     public JS.Trap getTrap(JS k) throws JSExn { throw new JSExn("arrays do not support traps"); }
  91
  92     /** FIXME: move to specialised ArrayStore superclass. */
  93     public void addAll(JS[] entries) { for (int i=0; i < entries.length; i++) add(entries[i]); }
  94
  95     public void setSize(int newSize) {
  96         size(newSize);
  97         for (int i=size(); i < newSize; i++) add(null);
  98         for (int i=size() - 1; i >= newSize; i--) remove(i);
  99     }
 100
 101
 102     // ECMA Implementation ////////////////////////////////////////////////////
 103
 104     private JS join(String sep) throws JSExn {
 105         int length = size();
 106         if(length == 0) return JSU.S("");
 107         StringBuffer sb = new StringBuffer(64);
 108         int i=0;
 109         while(true) {
 110             JS o = (JS)get(i);
 111             if(o != null) sb.append(JSU.toString(o));
 112             if(++i == length) break;
 113             sb.append(sep);
 114         }
 115         return JSU.S(sb.toString());
 116     }
 117
 118     private JS slice(int start, int end) {
 119         int length = size();
 120         if(start < 0) start = length+start;
 121         if(end < 0) end = length+end;
 122         if(start < 0) start = 0;
 123         if(end < 0) end = 0;
 124         if(start > length) start = length;
 125         if(end > length) end = length;
 126         JSArray a = new JSArray(end-start);
 127         for(int i=0;i<end-start;i++) // FIXME: with ArrayStore do System.arraycopy()
 128             a.set(i, get(start+i));
 129         return a;
 130     }
 131
 132     private JS splice(JS[] args) throws JSExn {
 133         int oldLength = size();
 134         int start = JSU.toInt(args.length < 1 ? null : args[0]);
 135         int deleteCount = JSU.toInt(args.length < 2 ? null : args[1]);
 136         int newCount = args.length - 2;
 137         if(newCount < 0) newCount = 0;
 138         if(start < 0) start = oldLength+start;
 139         if(start < 0) start = 0;
 140         if(start > oldLength) start = oldLength;
 141         if(deleteCount < 0) deleteCount = 0;
 142         if(deleteCount > oldLength-start) deleteCount = oldLength-start;
 143         int newLength = oldLength - deleteCount + newCount;
 144         int lengthChange = newLength - oldLength;
 145         JSArray ret = new JSArray(deleteCount);
 146         for(int i=0;i<deleteCount;i++) // FIXME: ArrayStore System.arraycopy()
 147             ret.set(i, get(start+i));
 148         if(lengthChange > 0) {
 149             setSize(newLength);
 150             for(int i=newLength-1;i>=start+newCount;i--)
 151                 set(i, get(i-lengthChange));
 152         } else if(lengthChange < 0) {
 153             for(int i=start+newCount;i<newLength;i++)
 154                 set(i, get(i-lengthChange));
 155             setSize(newLength);
 156         }
 157         for(int i=0;i<newCount;i++)
 158             set(start+i, args[i+2]);
 159         return ret;
 160     }
 161
 162     private static final Basket.CompareFunc defaultSort = new Basket.CompareFunc() {
 163         public int compare(Object a, Object b) {
 164             try { return JSU.toString((JS)a).compareTo(JSU.toString((JS)b)); }
 165             catch (JSExn e) { throw new JSExn.Wrapper(e); }
 166         }
 167     };
 168     private JS sort(JS comparator) throws JSExn {
 169         try {
 170             if (comparator == null) sort(defaultSort);
 171             else { sort = comparator; sort((CompareFunc)this); }
 172             return this;
 173         } catch (JSExn.Wrapper w) { throw w.unwrap();
 174         } finally { sort = null; }
 175     }
 176
 177     private JS sort = null;
 178     private final JS[] sortargs = new JS[2];
 179     public int compare(Object a, Object b) throws JSExn.Wrapper {
 180         try {
 181             sortargs[0] = (JS)a; sortargs[1] = (JS)b;
 182             return JSU.toInt(sort.call(null, sortargs));
 183         } catch (JSExn e) { throw new JSExn.Wrapper(e);
 184         } finally { sortargs[0] = null; sortargs[1] = null; }
 185     }
 186
 187 }