File lejos-java-9.patch of Package lejos

Overview Repositories Revisions Requests Users Attributes Meta

File lejos-java-9.patch of Package lejos (Revision 5c98d1c2117bd9d07530d9399271d781)

Currently displaying revision 5c98d1c2117bd9d07530d9399271d781 , Show latest

diff -pruN lejos.orig/src/java/classes/java/base/ArithmeticException.java lejos/src/java/classes/java/base/ArithmeticException.java
--- lejos.orig/src/java/classes/java/base/ArithmeticException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/ArithmeticException.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class ArithmeticException extends Exception
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/ArrayIndexOutOfBoundsException.java lejos/src/java/classes/java/base/ArrayIndexOutOfBoundsException.java
--- lejos.orig/src/java/classes/java/base/ArrayIndexOutOfBoundsException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/ArrayIndexOutOfBoundsException.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class ArrayIndexOutOfBoundsException extends RuntimeException
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/BitSet.java lejos/src/java/classes/java/base/BitSet.java
--- lejos.orig/src/java/classes/java/base/BitSet.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/BitSet.java	2018-06-19 13:13:37.000000000 +0200
@@ -0,0 +1,31 @@
+package java.base;
+
+/**
+ * Represents a long set of bits.
+ */
+public class BitSet
+{
+ byte[] iBytes;
+
+ public BitSet (int nbits)
+ {
+ iBytes = new byte[(nbits - 1) / 8 + 1];
+ }
+ 
+ public void clear (int n)
+ {
+ int idx = n / 8;
+ iBytes[idx] = (byte) ((iBytes[idx] & 0xFF) & ~(1 << (n%8)));
+ }
+ 
+ public void set (int n)
+ {
+ int idx = n / 8;
+ iBytes[idx] = (byte) ((iBytes[idx] & 0xFF) | (1 << (n%8)));
+ }
+ 
+ public boolean get (int n)
+ {
+ return ((iBytes[n/8] & 0xFF) & (1 << (n%8))) != 0;
+ }
+}
diff -pruN lejos.orig/src/java/classes/java/base/ClassCastException.java lejos/src/java/classes/java/base/ClassCastException.java
--- lejos.orig/src/java/classes/java/base/ClassCastException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/ClassCastException.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class ClassCastException extends RuntimeException
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/Class.java lejos/src/java/classes/java/base/Class.java
--- lejos.orig/src/java/classes/java/base/Class.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Class.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,16 @@
+package java.base;
+
+/**
+ * Not functional. It's here to satisfy javac and jikes.
+ */
+public class Class
+{
+ /**
+ * @exception java.lang.ClassNotFoundException Thrown always in TinyVM.
+ */
+ public static Class forName (String aName)
+ throws ClassNotFoundException
+ {
+ throw new ClassNotFoundException();
+ }
+}
diff -pruN lejos.orig/src/java/classes/java/base/ClassNotFoundException.java lejos/src/java/classes/java/base/ClassNotFoundException.java
--- lejos.orig/src/java/classes/java/base/ClassNotFoundException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/ClassNotFoundException.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class ClassNotFoundException extends Exception
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/Cloneable.java lejos/src/java/classes/java/base/Cloneable.java
--- lejos.orig/src/java/classes/java/base/Cloneable.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Cloneable.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,10 @@
+package java.base;
+
+/**
+ * This interface is not functional. It's here
+ * to satisfy jikes.
+ */
+public interface Cloneable
+{
+
+}
diff -pruN lejos.orig/src/java/classes/java/base/DataInputStream.java lejos/src/java/classes/java/base/DataInputStream.java
--- lejos.orig/src/java/classes/java/base/DataInputStream.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/DataInputStream.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,147 @@
+/*
+ * @(#)DataInputStream.java 1.00 01/12/14
+ *
+ * Adapted from the original Sun Microsystems code for leJOS.
+ * @author Brian Bagnall
+ */
+
+package java.base;
+
+public class DataInputStream extends InputStream {
+ 
+ protected InputStream in;
+ 
+ public DataInputStream(InputStream in) {
+ this.in = in;
+ }
+ 
+ /**
+ * Reads the next byte of data from this input stream. The value 
+ * byte is returned as an <code>int</code> in the range 
+ * <code>0</code> to <code>255</code>. If no byte is available 
+ * because the end of the stream has been reached, the value 
+ * <code>-1</code> is returned. This method blocks until input data 
+ * is available, the end of the stream is detected, or an exception 
+ * is thrown. 
+ * 
+ * This method
+ * simply performs <code>in.read()</code> and returns the result.
+ *
+ * @return the next byte of data, or <code>-1</code> if the end of the
+ * stream is reached.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterInputStream#in
+ */
+ public int read() throws IOException {
+ return in.read();
+ }
+ 
+ public final int read(byte b[]) throws IOException {
+ return in.read(b, 0, b.length);
+ }
+
+ public final int read(byte b[], int off, int len) throws IOException {
+ return in.read(b, off, len);
+ }
+/*
+ public final void readFully(byte b[]) throws IOException {
+ readFully(b, 0, b.length);
+ }
+*/
+/* public final void readFully(byte b[], int off, int len) throws IOException {
+	 if (len < 0)
+	 throw new IOException();
+
+ 	int n = 0;
+ 	while (n < len) {
+ int count = in.read(b, off + n, len - n);
+ 	 if (count < 0)
+ 		 throw new IOException();
+ 	 n += count;
+ }
+ }
+*/
+/* public final int skipBytes(int n) throws IOException {
+
+ int total = 0;
+ int cur = 0;
+ 
+ while ((total<n) && ((cur = (int) in.skip(n-total)) > 0)) {
+ total += cur;
+ }
+ return total;
+ }
+*/
+ public final boolean readBoolean() throws IOException {
+ int ch = in.read();
+ if (ch < 0)
+ throw new IOException();
+ return (ch != 0);
+ }
+
+ public final byte readByte() throws IOException {
+ int ch = in.read();
+ if (ch < 0)
+ throw new IOException();
+ return (byte)(ch);
+ }
+/*
+ public final int readUnsignedByte() throws IOException {
+	 int ch = in.read();
+	 if (ch < 0)
+	 throw new IOException();
+	 return ch;
+ }
+*/
+ public final short readShort() throws IOException {
+ int ch1 = in.read();
+ int ch2 = in.read();
+ if ((ch1 | ch2) < 0)
+ throw new IOException();
+ return (short)((ch1 << 8) + (ch2 << 0));
+ }
+ /*
+ public final int readUnsignedShort() throws IOException {
+ InputStream in = this.in;
+ int ch1 = in.read();
+ int ch2 = in.read();
+ if ((ch1 | ch2) < 0)
+ throw new IOException();
+ return (ch1 << 8) + (ch2 << 0);
+ }
+ */
+ 
+ public final char readChar() throws IOException {
+ InputStream in = this.in;
+ int ch1 = in.read();
+ int ch2 = in.read();
+ if ((ch1 | ch2) < 0)
+ throw new IOException();
+ return (char)((ch1 << 8) + (ch2 << 0));
+ }
+
+ public final int readInt() throws IOException {
+ int ch1 = in.read();
+ int ch2 = in.read();
+ int ch3 = in.read();
+ int ch4 = in.read();
+ if ((ch1 | ch2 | ch3 | ch4) < 0)
+ throw new IOException();
+ return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
+ }
+/*
+ public final long readLong() throws IOException {
+ InputStream in = this.in;
+ return ((long)(readInt()) << 32) + (readInt() & 0xFFFFFFFFL);
+ }
+ */
+
+ public final float readFloat() throws IOException {
+ return Float.intBitsToFloat(readInt());
+ }
+
+/*
+ public final double readDouble() throws IOException {
+ return Double.longBitsToDouble(readLong());
+ }*/
+}
\ Kein Zeilenumbruch am Dateiende.
diff -pruN lejos.orig/src/java/classes/java/base/DataOutputStream.java lejos/src/java/classes/java/base/DataOutputStream.java
--- lejos.orig/src/java/classes/java/base/DataOutputStream.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/DataOutputStream.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,231 @@
+ /*
+ * @(#)DataOutputStream.java 1.00 01/12/14
+ *
+ * Adapted from the original Sun Microsystems code for leJOS.
+ * @author Brian Bagnall
+ */
+package java.base;
+
+public class DataOutputStream extends OutputStream {
+ 
+ protected int written;
+ protected OutputStream out;
+ 
+ public DataOutputStream(OutputStream out) {
+ this.out = out;
+ }
+
+ /**
+ * Increases the written counter by the specified value
+ * until it reaches Integer.MAX_VALUE.
+ */
+ private void incCount(int value) {
+ int temp = written + value;
+ 
+ //if (temp < 0)
+ //temp = Integer.MAX_VALUE;
+ written = temp;
+ }
+
+ /**
+ * Writes the specified byte (the low eight bits of the argument 
+ * <code>b</code>) to the underlying output stream. If no exception 
+ * is thrown, the counter <code>written</code> is incremented by 
+ * <code>1</code>.
+ * 
+ * Implements the <code>write</code> method of <code>OutputStream</code>.
+ *
+ * @param b the <code>byte</code> to be written.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ */
+ public synchronized void write(int b) throws IOException {
+ out.write(b);
+ incCount(1);
+ }
+
+ /**
+ * Writes <code>len</code> bytes from the specified byte array 
+ * starting at offset <code>off</code> to the underlying output stream. 
+ * If no exception is thrown, the counter <code>written</code> is 
+ * incremented by <code>len</code>.
+ *
+ * @param b the data.
+ * @param off the start offset in the data.
+ * @param len the number of bytes to write.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ */
+ public synchronized void write(byte b[], int off, int len) throws IOException {
+ out.write(b, off, len);
+ incCount(len);
+ }
+
+ /**
+ * Flushes this data output stream. This forces any buffered output 
+ * bytes to be written out to the stream. 
+ * 
+ * The <code>flush</code> method of <code>DataOuputStream</code> 
+ * calls the <code>flush</code> method of its underlying output stream.
+ *
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ * @see java.io.OutputStream#flush()
+ */
+ public void flush() throws IOException {
+	out.flush();
+ }
+
+ /**
+ * Writes a <code>boolean</code> to the underlying output stream as 
+ * a 1-byte value. The value <code>true</code> is written out as the 
+ * value <code>(byte)1</code>; the value <code>false</code> is 
+ * written out as the value <code>(byte)0</code>. If no exception is 
+ * thrown, the counter <code>written</code> is incremented by 
+ * <code>1</code>.
+ *
+ * @param v a <code>boolean</code> value to be written.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ */
+ public final void writeBoolean(boolean v) throws IOException {
+ out.write(v ? 1 : 0);
+ incCount(1);
+ }
+
+ /**
+ * Writes out a <code>byte</code> to the underlying output stream as 
+ * a 1-byte value. If no exception is thrown, the counter 
+ * <code>written</code> is incremented by <code>1</code>.
+ *
+ * @param v a <code>byte</code> value to be written.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ */
+ public final void writeByte(int v) throws IOException {
+ out.write(v);
+ incCount(1);
+ }
+
+ /**
+ * Writes a <code>short</code> to the underlying output stream as two
+ * bytes, high byte first. If no exception is thrown, the counter 
+ * <code>written</code> is incremented by <code>2</code>.
+ *
+ * @param v a <code>short</code> to be written.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ */
+ public final void writeShort(int v) throws IOException {
+ OutputStream out = this.out;
+ out.write((v >>> 8) & 0xFF);
+ out.write((v >>> 0) & 0xFF);
+ incCount(2);
+ }
+
+ /**
+ * Writes a <code>char</code> to the underlying output stream as a 
+ * 2-byte value, high byte first. If no exception is thrown, the 
+ * counter <code>written</code> is incremented by <code>2</code>.
+ *
+ * @param v a <code>char</code> value to be written.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ */
+ public final void writeChar(int v) throws IOException {
+ OutputStream out = this.out;
+ out.write((v >>> 8) & 0xFF);
+ out.write((v >>> 0) & 0xFF);
+ incCount(2);
+ }
+
+ /**
+ * Writes an <code>int</code> to the underlying output stream as four
+ * bytes, high byte first. If no exception is thrown, the counter 
+ * <code>written</code> is incremented by <code>4</code>.
+ *
+ * @param v an <code>int</code> to be written.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ */
+ public final void writeInt(int v) throws IOException {
+ OutputStream out = this.out;
+ //for(byte i=24;i>=0;i-=8)
+ // out.write((int)(v >>> i) & 0xFF);
+ out.write((v >>> 24) & 0xFF);
+ out.write((v >>> 16) & 0xFF);
+ out.write((v >>> 8) & 0xFF);
+ out.write((v >>> 0) & 0xFF);
+ incCount(4);
+ }
+
+ /**
+ * Writes a <code>long</code> to the underlying output stream as eight
+ * bytes, high byte first. In no exception is thrown, the counter 
+ * <code>written</code> is incremented by <code>8</code>.
+ *
+ * @param v a <code>long</code> to be written.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ */
+/* public final void writeLong(long v) throws IOException {
+ OutputStream out = this.out;
+ out.write((int)(v >>> 56) & 0xFF);
+ out.write((int)(v >>> 48) & 0xFF);
+ out.write((int)(v >>> 40) & 0xFF);
+ out.write((int)(v >>> 32) & 0xFF);
+ out.write((int)(v >>> 24) & 0xFF);
+ out.write((int)(v >>> 16) & 0xFF);
+ out.write((int)(v >>> 8) & 0xFF);
+ out.write((int)(v >>> 0) & 0xFF);
+ //for(byte i=56;i>=0;i-=8)
+ // out.write((int)(v >>> i) & 0xFF);
+ incCount(8);
+ }
+*/
+ /**
+ * Converts the float argument to an <code>int</code> using the 
+ * <code>floatToIntBits</code> method in class <code>Float</code>, 
+ * and then writes that <code>int</code> value to the underlying 
+ * output stream as a 4-byte quantity, high byte first. If no 
+ * exception is thrown, the counter <code>written</code> is 
+ * incremented by <code>4</code>.
+ *
+ * @param v a <code>float</code> value to be written.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ * @see java.lang.Float#floatToIntBits(float)
+ */
+ public final void writeFloat(float v) throws IOException {
+ writeInt(Float.floatToIntBits(v));
+ }
+
+ /**
+ * Converts the double argument to a <code>long</code> using the 
+ * <code>doubleToLongBits</code> method in class <code>Double</code>, 
+ * and then writes that <code>long</code> value to the underlying 
+ * output stream as an 8-byte quantity, high byte first. If no 
+ * exception is thrown, the counter <code>written</code> is 
+ * incremented by <code>8</code>.
+ *
+ * @param v a <code>double</code> value to be written.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ * @see java.lang.Double#doubleToLongBits(double)
+ */
+ //public final void writeDouble(double v) throws IOException {
+ //writeLong(Double.doubleToLongBits(v));
+ //}
+
+ /**
+ * Returns the current value of the counter <code>written</code>, 
+ * the number of bytes written to this data output stream so far.
+ * If the counter overflows, it will be wrapped to Integer.MAX_VALUE.
+ *
+ * @return the value of the <code>written</code> field.
+ * @see java.io.DataOutputStream#written
+ */
+ public final int size() {
+ return written;
+ }
+}
diff -pruN lejos.orig/src/java/classes/java/base/EmptyQueueException.java lejos/src/java/classes/java/base/EmptyQueueException.java
--- lejos.orig/src/java/classes/java/base/EmptyQueueException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/EmptyQueueException.java	2018-06-19 13:13:37.000000000 +0200
@@ -0,0 +1,36 @@
+package java.base;
+/*
+* $Log: EmptyQueueException.java,v $
+* Revision 1.1 2003/08/17 14:59:42 mpscholz
+* enhanced Vector
+* added Stack and Queue and associated exception classes
+*
+*/
+
+/////////////////////////////////////////////////////////
+/**
+ * An exception thrown by some Queue class methods
+ * to indicate that the Queue is empty 
+ */
+public class EmptyQueueException extends RuntimeException {
+
+	////////////////////////////////////////////
+	// constants
+	////////////////////////////////////////////
+ 
+	////////////////////////////////////////////
+	// fields
+	////////////////////////////////////////////
+
+	////////////////////////////////////////////
+	// constructors
+	////////////////////////////////////////////
+
+	////////////////////////////////////////////
+	/**
+	 * creates a new exception wit null message string
+	 */
+ public EmptyQueueException() {
+ } // EmptyQueueException()
+
+} // class EmptyQueueException
diff -pruN lejos.orig/src/java/classes/java/base/EmptyStackException.java lejos/src/java/classes/java/base/EmptyStackException.java
--- lejos.orig/src/java/classes/java/base/EmptyStackException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/EmptyStackException.java	2018-06-19 13:13:37.000000000 +0200
@@ -0,0 +1,36 @@
+package java.base;
+/*
+* $Log: EmptyStackException.java,v $
+* Revision 1.1 2003/08/17 14:59:42 mpscholz
+* enhanced Vector
+* added Stack and Queue and associated exception classes
+*
+*/
+
+/////////////////////////////////////////////////////////
+/**
+ * An exception thrown by some stack class methods
+ * to indicate that the stack is empty 
+ */
+public class EmptyStackException extends RuntimeException {
+
+	////////////////////////////////////////////
+	// constants
+	////////////////////////////////////////////
+ 
+	////////////////////////////////////////////
+	// fields
+	////////////////////////////////////////////
+
+	////////////////////////////////////////////
+	// constructors
+	////////////////////////////////////////////
+
+	////////////////////////////////////////////
+	/**
+	 * creates a new exception wit null message string
+	 */
+ public EmptyStackException() {
+ } // EmptyStackException()
+
+} // class EmptyStackException
diff -pruN lejos.orig/src/java/classes/java/base/Error.java lejos/src/java/classes/java/base/Error.java
--- lejos.orig/src/java/classes/java/base/Error.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Error.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,9 @@
+package java.base;
+
+public class Error extends Throwable
+{
+}
+
+
+
+
diff -pruN lejos.orig/src/java/classes/java/base/Exception.java lejos/src/java/classes/java/base/Exception.java
--- lejos.orig/src/java/classes/java/base/Exception.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Exception.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,12 @@
+package java.base;
+
+public class Exception extends Throwable
+{
+	public Exception() {
+		super();
+	}
+	
+	public Exception(String message) {
+		super(message);
+	}
+}
diff -pruN lejos.orig/src/java/classes/java/base/Float.java lejos/src/java/classes/java/base/Float.java
--- lejos.orig/src/java/classes/java/base/Float.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Float.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,85 @@
+package java.base;
+
+/**
+ * Minimal Float implementation that supports 
+ * floatToIntBits and intBitsToFloat
+ *
+ * @author Lawrie Griffiths
+ */
+ public final class Float {
+
+ private Float() {
+ }
+ 
+ /**
+ * Returns the bit represention of a single-float value.
+ * The result is a representation of the floating-point argument 
+ * according to the IEEE 754 floating-point "single 
+ * precision" bit layout. 
+ * <ul>
+ * <li>Bit 31 (the bit that is selected by the mask 
+ * <code>0x80000000</code>) represents the sign of the floating-point 
+ * number. 
+ * <li>Bits 30-23 (the bits that are selected by the mask 
+ * <code>0x7f800000</code>) represent the exponent. 
+ * <li>Bits 22-0 (the bits that are selected by the mask 
+ * <code>0x007fffff</code>) represent the significand (sometimes called 
+ * the mantissa) of the floating-point number. 
+ * <li>If the argument is positive infinity, the result is 
+ * <code>0x7f800000</code>. 
+ * <li>If the argument is negative infinity, the result is 
+ * <code>0xff800000</code>.
+ * 
+ * If the argument is NaN, the result is the integer
+ * representing the actual NaN value. The lejos implementation 
+ * behaves like floatToRawIntBits and does not collapse NaN values.
+ * </ul>
+ * In all cases, the result is an integer that, when given to the 
+ * {@link #intBitsToFloat(int)} method, will produce a floating-point 
+ * value equal to the argument to <code>floatToRawIntBits</code>.
+ * 
+ * @param value a floating-point number.
+ * @return the bits that represent the floating-point number.
+ */
+ public static native int floatToIntBits(float value);
+
+ /**
+ * Returns the single-float corresponding to a given bit represention.
+ * The argument is considered to be a representation of a
+ * floating-point value according to the IEEE 754 floating-point
+ * "single precision" bit layout.
+ * 
+ * If the argument is <code>0x7f800000</code>, the result is positive
+ * infinity.
+ * 
+ * If the argument is <code>0xff800000</code>, the result is negative
+ * infinity.
+ * 
+ * If the argument is any value in the range <code>0x7f800001</code> 
+ * through <code>0x7fffffff</code> or in the range 
+ * <code>0xff800001</code> through <code>0xffffffff</code>, the result is 
+ * NaN. All IEEE 754 NaN values of type <code>float</code> are, in effect,
+ * lumped together by the Java programming language into a single 
+ * <code>float</code> value called NaN. Distinct values of NaN are only
+ * accessible by use of the <code>Float.floatToRawIntBits</code> method.
+ * 
+ * In all other cases, let s, e, and m be three 
+ * values that can be computed from the argument: 
+ * <blockquote><pre>
+ * int s = ((bits >> 31) == 0) ? 1 : -1;
+ * int e = ((bits >> 23) & 0xff);
+ * int m = (e == 0) ?
+ * (bits & 0x7fffff) << 1 :
+ * (bits & 0x7fffff) | 0x800000;
+ * </pre></blockquote>
+ * Then the floating-point result equals the value of the mathematical 
+ * expression s&#183;m&#183;2e-150.
+ *
+ * @param value an integer.
+ * @return the single-format floating-point value with the same bit
+ * pattern.
+ */
+ public static native float intBitsToFloat(int value);
+}
+
+ 
diff -pruN lejos.orig/src/java/classes/java/base/Hashtable.java lejos/src/java/classes/java/base/Hashtable.java
--- lejos.orig/src/java/classes/java/base/Hashtable.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Hashtable.java	2018-06-19 13:13:37.000000000 +0200
@@ -0,0 +1,95 @@
+package java.base;
+
+/**
+ * Maps keys to objects. It has a fixed-size table, so don't
+ * expect it to scale well.
+ */
+public class Hashtable
+{
+ private static final int TABLE_SIZE = 32;
+ private Object[] iTable = new Object[TABLE_SIZE];
+ 
+ public Hashtable()
+ { 
+ }
+
+ public synchronized Object get (Object aKey)
+ {
+ Object pElement = iTable[getTableIndex(aKey)];
+ if (pElement == null)
+ return null;
+ KeyValuePair pKeyValuePair = getKeyValuePair (pElement, aKey);
+ if (pKeyValuePair == null)
+ return null;
+ return pKeyValuePair.iValue;
+ }
+ 
+ public synchronized void put (Object aKey, Object aValue)
+ {
+ int pIndex = getTableIndex (aKey); 
+ Object pElement = iTable[pIndex];
+ KeyValuePair pKeyValuePair = null;
+ if (pElement != null)
+ pKeyValuePair = getKeyValuePair (pElement, aKey);
+ if (pKeyValuePair == null)
+ {
+ pKeyValuePair = new KeyValuePair();
+ pKeyValuePair.iKey = aKey;
+ pKeyValuePair.iValue = aValue;
+ }
+ if (pElement == null) 
+ {
+ iTable[pIndex] = pKeyValuePair;
+ } 
+ else if (pElement == pKeyValuePair)
+ {
+ pKeyValuePair.iValue = aValue;	 
+ }
+ else if (pElement instanceof KeyValuePair)
+ {	 
+ Vector pVector = new Vector();
+ pVector.addElement (pElement);
+ pVector.addElement (pKeyValuePair);
+ }
+ else
+ {
+ // pElement must be a Vector
+ ((Vector) pElement).addElement (pKeyValuePair);	 
+ }
+ }
+
+ private KeyValuePair getKeyValuePair (Object aPivot, Object aKey)
+ {
+ if (aPivot instanceof Vector)
+ {
+ Vector pVec = (Vector) aPivot;
+ int pSize = pVec.size();
+ for (int i = 0; i < pSize; i++)
+ {
+	KeyValuePair pPair = (KeyValuePair) pVec.elementAt (i);
+	if (aKey.equals (pPair.iKey))
+ return pPair;
+ }
+ return null;
+ }
+ // Not a Vector, must be a lone KeyValuePair
+ KeyValuePair pPair = (KeyValuePair) aPivot;
+ if (aKey.equals (pPair.iKey))
+ return pPair;
+ return null;
+ }
+ 
+ private int getTableIndex (Object aKey)
+ {
+ int pHash = aKey.hashCode();
+ if (pHash < 0)
+ pHash = -pHash;
+ return pHash % TABLE_SIZE;
+ }
+
+ private static class KeyValuePair
+ { 
+ Object iKey;
+ Object iValue;
+ }
+}
diff -pruN lejos.orig/src/java/classes/java/base/IllegalArgumentException.java lejos/src/java/classes/java/base/IllegalArgumentException.java
--- lejos.orig/src/java/classes/java/base/IllegalArgumentException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/IllegalArgumentException.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class IllegalArgumentException extends RuntimeException
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/IllegalMonitorStateException.java lejos/src/java/classes/java/base/IllegalMonitorStateException.java
--- lejos.orig/src/java/classes/java/base/IllegalMonitorStateException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/IllegalMonitorStateException.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,4 @@
+package java.base;
+
+public class IllegalMonitorStateException extends RuntimeException {
+}
diff -pruN lejos.orig/src/java/classes/java/base/IllegalStateException.java lejos/src/java/classes/java/base/IllegalStateException.java
--- lejos.orig/src/java/classes/java/base/IllegalStateException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/IllegalStateException.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class IllegalStateException extends RuntimeException
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/InputStream.java lejos/src/java/classes/java/base/InputStream.java
--- lejos.orig/src/java/classes/java/base/InputStream.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/InputStream.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,351 @@
+/*
+ * @(#)InputStream.java	1.36 00/02/02
+ *
+ * Copyright 1994-2000 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * This software is the proprietary information of Sun Microsystems, Inc. 
+ * Use is subject to license terms.
+ * 
+ */
+
+package java.base;
+
+/**
+ * This abstract class is the superclass of all classes representing
+ * an input stream of bytes.
+ *
+ * Applications that need to define a subclass of <code>InputStream</code>
+ * must always provide a method that returns the next byte of input.
+ *
+ * @author Arthur van Hoff
+ * @version 1.36, 02/02/00
+ * @see java.io.BufferedInputStream
+ * @see java.io.ByteArrayInputStream
+ * @see java.io.DataInputStream
+ * @see java.io.FilterInputStream
+ * @see java.io.InputStream#read()
+ * @see java.io.OutputStream
+ * @see java.io.PushbackInputStream
+ * @since JDK1.0
+ */
+public abstract class InputStream {
+
+ // SKIP_BUFFER_SIZE is used to determine the size of skipBuffer
+// private static final int SKIP_BUFFER_SIZE = 2048;
+ private static final int SKIP_BUFFER_SIZE = 32;
+ // skipBuffer is initialized in skip(long), if needed.
+ private static byte[] skipBuffer;
+
+ /**
+ * Reads the next byte of data from the input stream. The value byte is
+ * returned as an <code>int</code> in the range <code>0</code> to
+ * <code>255</code>. If no byte is available because the end of the stream
+ * has been reached, the value <code>-1</code> is returned. This method
+ * blocks until input data is available, the end of the stream is detected,
+ * or an exception is thrown.
+ *
+ * A subclass must provide an implementation of this method.
+ *
+ * @return the next byte of data, or <code>-1</code> if the end of the
+ * stream is reached.
+ * @exception IOException if an I/O error occurs.
+ */
+ public abstract int read() throws IOException;
+
+ /**
+ * Reads some number of bytes from the input stream and stores them into
+ * the buffer array <code>b</code>. The number of bytes actually read is
+ * returned as an integer. This method blocks until input data is
+ * available, end of file is detected, or an exception is thrown.
+ *
+ * If <code>b</code> is <code>null</code>, a
+ * <code>NullPointerException</code> is thrown. If the length of
+ * <code>b</code> is zero, then no bytes are read and <code>0</code> is
+ * returned; otherwise, there is an attempt to read at least one byte. If
+ * no byte is available because the stream is at end of file, the value
+ * <code>-1</code> is returned; otherwise, at least one byte is read and
+ * stored into <code>b</code>.
+ *
+ * The first byte read is stored into element <code>b[0]</code>, the
+ * next one into <code>b[1]</code>, and so on. The number of bytes read is,
+ * at most, equal to the length of <code>b</code>. Let k be the
+ * number of bytes actually read; these bytes will be stored in elements
+ * <code>b[0]</code> through <code>b[</code>k<code>-1]</code>,
+ * leaving elements <code>b[</code>k<code>]</code> through
+ * <code>b[b.length-1]</code> unaffected.
+ *
+ * If the first byte cannot be read for any reason other than end of
+ * file, then an <code>IOException</code> is thrown. In particular, an
+ * <code>IOException</code> is thrown if the input stream has been closed.
+ *
+ * The <code>read(b)</code> method for class <code>InputStream</code>
+ * has the same effect as: <pre><code> read(b, 0, b.length) </code></pre>
+ *
+ * @param b the buffer into which the data is read.
+ * @return the total number of bytes read into the buffer, or
+ * <code>-1</code> is there is no more data because the end of
+ * the stream has been reached.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.InputStream#read(byte[], int, int)
+ */
+ public int read(byte b[]) throws IOException {
+	return read(b, 0, b.length);
+ }
+
+ /**
+ * Reads up to <code>len</code> bytes of data from the input stream into
+ * an array of bytes. An attempt is made to read as many as
+ * <code>len</code> bytes, but a smaller number may be read, possibly
+ * zero. The number of bytes actually read is returned as an integer.
+ *
+ * This method blocks until input data is available, end of file is
+ * detected, or an exception is thrown.
+ *
+ * If <code>b</code> is <code>null</code>, a
+ * <code>NullPointerException</code> is thrown.
+ *
+ * If <code>off</code> is negative, or <code>len</code> is negative, or
+ * <code>off+len</code> is greater than the length of the array
+ * <code>b</code>, then an <code>IndexOutOfBoundsException</code> is
+ * thrown.
+ *
+ * If <code>len</code> is zero, then no bytes are read and
+ * <code>0</code> is returned; otherwise, there is an attempt to read at
+ * least one byte. If no byte is available because the stream is at end of
+ * file, the value <code>-1</code> is returned; otherwise, at least one
+ * byte is read and stored into <code>b</code>.
+ *
+ * The first byte read is stored into element <code>b[off]</code>, the
+ * next one into <code>b[off+1]</code>, and so on. The number of bytes read
+ * is, at most, equal to <code>len</code>. Let k be the number of
+ * bytes actually read; these bytes will be stored in elements
+ * <code>b[off]</code> through <code>b[off+</code>k<code>-1]</code>,
+ * leaving elements <code>b[off+</code>k<code>]</code> through
+ * <code>b[off+len-1]</code> unaffected.
+ *
+ * In every case, elements <code>b[0]</code> through
+ * <code>b[off]</code> and elements <code>b[off+len]</code> through
+ * <code>b[b.length-1]</code> are unaffected.
+ *
+ * If the first byte cannot be read for any reason other than end of
+ * file, then an <code>IOException</code> is thrown. In particular, an
+ * <code>IOException</code> is thrown if the input stream has been closed.
+ *
+ * The <code>read(b,</code> <code>off,</code> <code>len)</code> method
+ * for class <code>InputStream</code> simply calls the method
+ * <code>read()</code> repeatedly. If the first such call results in an
+ * <code>IOException</code>, that exception is returned from the call to
+ * the <code>read(b,</code> <code>off,</code> <code>len)</code> method. If
+ * any subsequent call to <code>read()</code> results in a
+ * <code>IOException</code>, the exception is caught and treated as if it
+ * were end of file; the bytes read up to that point are stored into
+ * <code>b</code> and the number of bytes read before the exception
+ * occurred is returned. Subclasses are encouraged to provide a more
+ * efficient implementation of this method.
+ *
+ * @param b the buffer into which the data is read.
+ * @param off the start offset in array <code>b</code>
+ * at which the data is written.
+ * @param len the maximum number of bytes to read.
+ * @return the total number of bytes read into the buffer, or
+ * <code>-1</code> if there is no more data because the end of
+ * the stream has been reached.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.InputStream#read()
+ */
+ public int read(byte b[], int off, int len) throws IOException {
+	if (b == null) {
+	 throw new NullPointerException();
+	} else if ((off < 0) || (off > b.length) || (len < 0) ||
+		 ((off + len) > b.length) || ((off + len) < 0)) {
+	 throw new RuntimeException();
+	} else if (len == 0) {
+	 return 0;
+	}
+
+	int c = read();
+	if (c == -1) {
+	 return -1;
+	}
+	b[off] = (byte)c;
+
+	int i = 1;
+	try {
+	 for (; i < len ; i++) {
+		c = read();
+		if (c == -1) {
+		 break;
+		}
+		if (b != null) {
+		 b[off + i] = (byte)c;
+		}
+	 }
+	} catch (IOException ee) {
+	}
+	return i;
+ }
+
+ /**
+ * Skips over and discards <code>n</code> bytes of data from this input
+ * stream. The <code>skip</code> method may, for a variety of reasons, end
+ * up skipping over some smaller number of bytes, possibly <code>0</code>.
+ * This may result from any of a number of conditions; reaching end of file
+ * before <code>n</code> bytes have been skipped is only one possibility.
+ * The actual number of bytes skipped is returned. If <code>n</code> is
+ * negative, no bytes are skipped.
+ *
+ * The <code>skip</code> method of <code>InputStream</code> creates a
+ * byte array and then repeatedly reads into it until <code>n</code> bytes
+ * have been read or the end of the stream has been reached. Subclasses are
+ * encouraged to provide a more efficient implementation of this method.
+ *
+ * @param n the number of bytes to be skipped.
+ * @return the actual number of bytes skipped.
+ * @exception IOException if an I/O error occurs.
+ */
+
+ public long skip(long n) throws IOException {
+/*
+	long remaining = n;
+	int nr;
+	if (skipBuffer == null)
+	 skipBuffer = new byte[SKIP_BUFFER_SIZE];
+
+	byte[] localSkipBuffer = skipBuffer;
+		
+	if (n <= 0) {
+	 return 0;
+	}
+
+	while (remaining > 0) {
+	 nr = read(localSkipBuffer, 0,
+		 (int) Math.min(SKIP_BUFFER_SIZE, remaining));
+	 if (nr < 0) {
+		break;
+	 }
+	 remaining -= nr;
+	}
+	*/
+	return n;
+ }
+
+ /**
+ * Returns the number of bytes that can be read (or skipped over) from
+ * this input stream without blocking by the next caller of a method for
+ * this input stream. The next caller might be the same thread or or
+ * another thread.
+ *
+ * The <code>available</code> method for class <code>InputStream</code>
+ * always returns <code>0</code>.
+ *
+ * This method should be overridden by subclasses.
+ *
+ * @return the number of bytes that can be read from this input stream
+ * without blocking.
+ * @exception IOException if an I/O error occurs.
+ */
+ public int available() throws IOException {
+	return 0;
+ }
+
+ /**
+ * Closes this input stream and releases any system resources associated
+ * with the stream.
+ *
+ * The <code>close</code> method of <code>InputStream</code> does
+ * nothing.
+ *
+ * @exception IOException if an I/O error occurs.
+ */
+ public void close() throws IOException {}
+
+ /**
+ * Marks the current position in this input stream. A subsequent call to
+ * the <code>reset</code> method repositions this stream at the last marked
+ * position so that subsequent reads re-read the same bytes.
+ *
+ * The <code>readlimit</code> arguments tells this input stream to
+ * allow that many bytes to be read before the mark position gets
+ * invalidated.
+ *
+ * The general contract of <code>mark</code> is that, if the method
+ * <code>markSupported</code> returns <code>true</code>, the stream somehow
+ * remembers all the bytes read after the call to <code>mark</code> and
+ * stands ready to supply those same bytes again if and whenever the method
+ * <code>reset</code> is called. However, the stream is not required to
+ * remember any data at all if more than <code>readlimit</code> bytes are
+ * read from the stream before <code>reset</code> is called.
+ *
+ * The <code>mark</code> method of <code>InputStream</code> does
+ * nothing.
+ *
+ * @param readlimit the maximum limit of bytes that can be read before
+ * the mark position becomes invalid.
+ * @see java.io.InputStream#reset()
+ */
+ public synchronized void mark(int readlimit) {}
+
+ /**
+ * Repositions this stream to the position at the time the
+ * <code>mark</code> method was last called on this input stream.
+ *
+ * The general contract of <code>reset</code> is:
+ *
+ * <ul>
+ *
+ * <li> If the method <code>markSupported</code> returns
+ * <code>true</code>, then:
+ *
+ * <ul><li> If the method <code>mark</code> has not been called since
+ * the stream was created, or the number of bytes read from the stream
+ * since <code>mark</code> was last called is larger than the argument
+ * to <code>mark</code> at that last call, then an
+ * <code>IOException</code> might be thrown.
+ *
+ * <li> If such an <code>IOException</code> is not thrown, then the
+ * stream is reset to a state such that all the bytes read since the
+ * most recent call to <code>mark</code> (or since the start of the
+ * file, if <code>mark</code> has not been called) will be resupplied
+ * to subsequent callers of the <code>read</code> method, followed by
+ * any bytes that otherwise would have been the next input data as of
+ * the time of the call to <code>reset</code>. </ul>
+ *
+ * <li> If the method <code>markSupported</code> returns
+ * <code>false</code>, then:
+ *
+ * <ul><li> The call to <code>reset</code> may throw an
+ * <code>IOException</code>.
+ *
+ * <li> If an <code>IOException</code> is not thrown, then the stream
+ * is reset to a fixed state that depends on the particular type of the
+ * input stream and how it was created. The bytes that will be supplied
+ * to subsequent callers of the <code>read</code> method depend on the
+ * particular type of the input stream. </ul></ul>
+ *
+ * The method <code>reset</code> for class <code>InputStream</code>
+ * does nothing and always throws an <code>IOException</code>.
+ *
+ * @exception IOException if this stream has not been marked or if the
+ * mark has been invalidated.
+ * @see java.io.InputStream#mark(int)
+ * @see java.io.IOException
+ */
+ public synchronized void reset() throws IOException {
+	throw new IOException("mark/reset not supported");
+ }
+
+ /**
+ * Tests if this input stream supports the <code>mark</code> and
+ * <code>reset</code> methods. The <code>markSupported</code> method of
+ * <code>InputStream</code> returns <code>false</code>.
+ *
+ * @return <code>true</code> if this true type supports the mark and reset
+ * method; <code>false</code> otherwise.
+ * @see java.io.InputStream#mark(int)
+ * @see java.io.InputStream#reset()
+ */
+ public boolean markSupported() {
+	return false;
+ }
+
+}
diff -pruN lejos.orig/src/java/classes/java/base/Integer.java lejos/src/java/classes/java/base/Integer.java
--- lejos.orig/src/java/classes/java/base/Integer.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Integer.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,88 @@
+package java.base;
+
+/**
+ * Minimal Integer implementation that supports converting an int to a String.
+ *
+ */
+
+ public final class Integer {
+ /**
+ * The smallest value of type <code>int</code>. The constant 
+ * value of this field is <tt>-2147483648</tt>.
+ */
+ public static final int MIN_VALUE = 0x80000000;
+
+ /**
+ * The largest value of type <code>int</code>. The constant 
+ * value of this field is <tt>2147483647</tt>.
+ */
+ public static final int MAX_VALUE = 0x7fffffff;
+
+ /**
+ * The value of the Integer.
+ *
+ * @serial
+ */
+ private int value;
+
+ /**
+ * Constructs a newly allocated <code>Integer</code> object that
+ * represents the primitive <code>int</code> argument.
+ *
+ * @param value the value to be represented by the <code>Integer</code>.
+ */
+ public Integer(int value) {
+	this.value = value;
+ }
+
+ static char buf [] = new char [12] ; 
+
+ /**
+ * Returns a new String object representing the specified integer. The 
+ * argument is converted to signed decimal representation and returned 
+ * as a string, exactly as if the argument and radix <tt>10</tt> were 
+ * given as arguments to the toString(int, int) method.
+ *
+ * @param i an integer to be converted.
+ * @return a string representation of the argument in base&nbsp;10.
+ */
+ public static synchronized String toString(int i) {
+ int q, r, charPos = 12; 
+ char sign = 0 ; 
+
+ if (i == Integer.MIN_VALUE) return "-2147483648";
+
+ if (i < 0) { 
+ sign = '-' ; 
+ i = -i ; 
+ }
+
+ for (;;) { 
+ q = i/10; ; 
+ r = i-(q*10) ;
+ buf [--charPos] = (char) ((int) '0' + r) ; 
+ i = q ; 
+ if (i == 0) break ; 
+ }
+
+ if (sign != 0) {
+ buf [--charPos] = sign ; 
+ }
+
+ return new String ( buf, charPos, 12 - charPos) ; 
+ }
+
+ /**
+ * Returns a String object representing this Integer's value. The 
+ * value is converted to signed decimal representation and returned 
+ * as a string.
+ *
+ * @return a string representation of the value of this object in
+ * base&nbsp;10.
+ */
+ public String toString() {
+	return toString(value);
+ }
+}
+
+ 
diff -pruN lejos.orig/src/java/classes/java/base/InterruptedException.java lejos/src/java/classes/java/base/InterruptedException.java
--- lejos.orig/src/java/classes/java/base/InterruptedException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/InterruptedException.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class InterruptedException extends Exception
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/IOException.java lejos/src/java/classes/java/base/IOException.java
--- lejos.orig/src/java/classes/java/base/IOException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/IOException.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,46 @@
+/*
+ * @(#)IOException.java	1.19 00/02/02
+ *
+ * Copyright 1994-2000 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * This software is the proprietary information of Sun Microsystems, Inc. 
+ * Use is subject to license terms.
+ * 
+ */
+
+package java.base;
+
+/**
+ * Signals that an I/O exception of some sort has occurred. This
+ * class is the general class of exceptions produced by failed or
+ * interrupted I/O operations.
+ *
+ * @author unascribed
+ * @version 1.19, 02/02/00
+ * @see java.io.InputStream
+ * @see java.io.OutputStream
+ * @since JDK1.0
+ */
+public
+class IOException extends Exception {
+ /**
+ * Constructs an <code>IOException</code> with <code>null</code>
+ * as its error detail message.
+ */
+ public IOException() {
+	super();
+ }
+
+ /**
+ * Constructs an <code>IOException</code> with the specified detail
+ * message. The error message string <code>s</code> can later be
+ * retrieved by the <code>{@link java.lang.Throwable#getMessage}</code>
+ * method of class <code>java.lang.Throwable</code>.
+ *
+ * @param s the detail message.
+ */
+
+ public IOException(String s) {
+	super();
+ }
+}
diff -pruN lejos.orig/src/java/classes/java/base/Math.java lejos/src/java/classes/java/base/Math.java
--- lejos.orig/src/java/classes/java/base/Math.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Math.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,323 @@
+package java.base;
+
+/**
+ * Mathematical functions.
+ *
+ * @author <a href="mailto:bbagnall@escape.ca">Brian Bagnall</a>
+ */
+public final class Math {
+		
+	// Math constants
+	public static final double E = 2.718281828459045;
+	public static final double PI = 3.141592653589793;
+ public static final double NaN = 0.0f / 0.0f;
+ 
+ static final float PI2 = 1.570796326794897f;
+	static final double ln10 = 2.30258509299405;
+	static final double ln2 = 0.69314718055995;
+	
+ // Used by log() and exp() methods
+	private static final float LOWER_BOUND = 0.9999999f;
+	private static final float UPPER_BOUND = 1.0f;
+
+	// Used to generate random numbers.
+	private static java.util.Random RAND = new java.util.Random(System.currentTimeMillis());
+
+	//public static boolean isNaN (double d) {
+	// return d != d;
+	//}
+	
+	private Math() {} // To make sure this class is not instantiated
+
+ // Private because it only works when -1 < x < 1 but it is used by atan2
+ private static double ArcTan(double x) // Using a Chebyshev-Pade approximation
+ {
+ double x2=x*x;
+ return (0.7162721433f+0.2996857769f*x2)*x/(0.7163164576f+(0.5377299313f+0.3951620469e-1f*x2)*x2);
+ }
+
+
+	/**
+	* Returns the smallest (closest to negative infinity) double value that is not
+	* less than the argument and is equal to a mathematical integer.
+ 	*/
+	public static double ceil(double a) {
+		return ((a<0)?(int)a:(int)(a+1));	
+	}
+	
+	/**
+	* Returns the largest (closest to positive infinity) double value that is not
+	* greater than the argument and is equal to a mathematical integer.
+	*/
+	public static double floor(double a) {	
+		return ((a<0)?(int)(a-1):(int)a);	
+	}
+	
+	/**
+	* Returns the closest int to the argument.
+	*/	
+	public static int round(float a) {	
+		return (int)floor(a + 0.5f);
+	}
+	
+	/**
+	* Returns the lesser of two integer values.
+	*/
+	public static int min(int a, int b) {	
+		return ((a<b)?a:b);
+	}
+	
+	/**
+	*Returns the lesser of two double values.
+	*/
+	public static double min(double a, double b) {	
+		return ((a<b)?a:b);
+	}
+	
+	/**
+	*Returns the greater of two integer values.
+	*/
+	public static int max(int a, int b) {	
+		return ((a>b)?a:b);
+	}
+	
+	/**
+	*Returns the greater of two double values.
+	*/
+	public static double max(double a, double b) {	
+		return ((a>b)?a:b);
+	}
+	
+	/**
+	* Random number generator.
+	* Returns a double greater than 0.0 and less than 1.0
+	*/
+	public static double random()
+ {
+ final int MAX_INT = 2147483647;
+ int n = MAX_INT;
+ 
+ // Just to ensure it does not return 1.0
+ while(n == MAX_INT)
+ 	n = abs (RAND.nextInt());
+ 
+ return n * (1.0 / MAX_INT);
+ }
+	
+	/**
+	* Exponential function. Returns E^x (where E is the base of natural logarithms).
+	* Thanks to David Edwards of England for conceiving the code and Martin E. Nielsen
+	* for modifying it to handle large arguments.
+ * = sum a^n/n!, i.e. 1 + x + x^2/2! + x^3/3!
+ * 
+ * Seems to work better for +ve numbers so force argument to be +ve.
+	*/	
+	public static double exp(double a)
+	{
+	 boolean neg = a < 0 ? true : false;
+	 if (a < 0)
+ a = -a;
+ int fac = 1;
+ 	 double term = a;
+ 	 double sum = 0;
+ 	 double oldsum = 0;
+ 	 double end;
+
+ 	 do {
+ 	 oldsum = sum;
+ 	 sum += term;
+ 
+ 	 fac++;
+ 
+ 	 term *= a/fac;
+	 end = sum/oldsum;
+ 	 } while (end < LOWER_BOUND || end > UPPER_BOUND);
+
+ sum += 1.0f;
+ 
+	 return neg ? 1.0f/sum : sum;
+	}
+	
+	/**
+	* Natural log function. Returns log(a) to base E
+	* Replaced with an algorithm that does not use exponents and so
+	* works with large arguments.
+	* @see <a href="http://www.geocities.com/zabrodskyvlada/aat/a_contents.html">here</a>
+	*/
+	public static double log(double x)
+	{
+	 if (x < 1.0)
+	 return -log(1.0/x);
+	 
+	 double m=0.0;
+	 double p=1.0;
+	 while (p <= x) {
+	 m++;
+	 p=p*2;
+	 }
+	 
+	 m = m - 1;
+	 double z = x/(p/2);
+	 
+	 double zeta = (1.0 - z)/(1.0 + z);
+	 double n=zeta;
+	 double ln=zeta;
+	 double zetasup = zeta * zeta;
+	 
+	 for (int j=1; true; j++)
+	 {
+	 n = n * zetasup;
+	 double newln = ln + n / (2 * j + 1);
+	 double term = ln/newln;
+	 if (term >= LOWER_BOUND && term <= UPPER_BOUND)
+	 return m * ln2 - 2 * ln;
+	 ln = newln;
+	 }
+	}
+
+	/**
+	* Power function. This is a slow but accurate method.
+	* Thanks to David Edwards of England for conceiving the code.
+	*/
+	public static double pow(double a, double b) {
+		return exp(b * log(a));
+	}
+	
+	/**
+	* Returns the absolute value of a double value. If the argument is not negative, the argument is
+ * returned. If the argument is negative, the negation of the argument is returned.
+	*/
+	public static double abs(double a) {
+		return ((a<0)?-a:a);
+	}
+
+	/**
+	* Returns the absolute value of an integer value. If the argument is not negative, the argument is
+ * returned. If the argument is negative, the negation of the argument is returned.
+	*/
+	public static int abs(int a) {
+		return ((a<0)?-a:a);
+	}
+	
+ /**
+ * Sine function using a Chebyshev-Pade approximation. Thanks to Paulo Costa for donating the code.
+ */
+ public static double sin(double x) // Using a Chebyshev-Pade approximation
+ {
+ int n=(int)(x/PI2)+1; // reduce to the 4th and 1st quadrants
+ if(n<1)n=n-1;
+ if ((n&2)==0) x=x-(n&0xFFFFFFFE)*PI2; // if it from the 2nd or the 3rd quadrants
+ else x=-(x-(n&0xFFFFFFFE)*PI2);
+
+ double x2=x*x;
+ return (0.9238318854f-0.9595498071e-1f*x2)*x/(0.9238400690f+(0.5797298195e-1f+0.2031791179e-2f*x2)*x2);
+ }
+
+ /**
+ * Cosine function using a Chebyshev-Pade approximation. Thanks to Paulo Costa for donating the code.
+ */
+ public static double cos(double x)
+ {
+ int n=(int)(x/PI2)+1;
+ if(n<1)n=n-1;
+ x=x-(n&0xFFFFFFFE)*PI2; // reduce to the 4th and 1st quadrants
+
+ double x2=x*x;
+
+ float si=1f;
+ if ((n&2)!=0) si=-1f; // if it from the 2nd or the 3rd quadrants
+ return si*(0.9457092528f+(-0.4305320537f+0.1914993010e-1f*x2)*x2)/(0.9457093212f+(0.4232119630e-1f+0.9106317690e-3f*x2)*x2);
+ }
+
+ /**
+ * Square root - thanks to Paulo Costa for donating the code.
+ */
+ public static double sqrt(double x)
+ {
+ double root = x, guess=0;
+
+ if(x<0) return NaN;
+
+ // the accuarcy test is percentual
+ for(int i=0; (i<16) && ((guess > x*(1+5e-7f)) || (guess < x*(1-5e-7f))); i++)
+ {
+ root = (root+x/root)*0.5f; // a multiplication is faster than a division
+ guess=root*root; // cache the square to the test
+ }
+ return root;
+ }
+	
+ /**
+ * Tangent function.
+ */
+ public static double tan(double a) {
+ return sin(a)/cos(a);
+ }
+		
+ /**
+ * Arc tangent function. Thanks to Paulo Costa for donating the code.
+ */
+ public static double atan(double x)
+ {
+ return atan2(x,1);
+ }
+
+ /**
+ * Arc tangent function valid to the four quadrants
+ * y and x can have any value without sigificant precision loss
+ * atan2(0,0) returns 0. Thanks to Paulo Costa for donating the code.
+ */
+ public static double atan2(double y, double x)
+ {
+ float ax=(float)abs(x);
+ float ay=(float)abs(y);
+
+ if ((ax<1e-7) && (ay<1e-7)) return 0f;
+
+ if (ax>ay)
+ {
+ if (x<0)
+ {
+ if (y>=0) return ArcTan(y/x)+PI;
+ else return ArcTan(y/x)-PI;
+ }
+ else return ArcTan(y/x);
+ }
+ else
+ {
+ if (y<0) return ArcTan(-x/y)-PI/2;
+ else return ArcTan(-x/y)+PI/2;
+ }
+ }
+
+ /**
+ * Arc cosine function.
+ */
+ public static double acos(double a) {
+ if ((a<-1)||(a>1)) {
+ return Double.NaN;
+ }
+ return PI/2 - atan(a/sqrt(1 - a * a));
+ }
+	
+ /**
+ * Arc sine function.
+ */
+ public static double asin(double a) {
+ return atan(a/sqrt(1-a*a));
+ }
+	
+ /**
+ * Converts radians to degrees.
+ */
+ public static double toDegrees(double angrad) {
+ return angrad * (360.0 / (2 * PI));
+ }
+	
+ /**
+ * Converts degrees to radians.
+ */
+ public static double toRadians(double angdeg) {
+ return angdeg * ((2 * PI) / 360.0);
+ }
+}
diff -pruN lejos.orig/src/java/classes/java/base/NoClassDefFoundError.java lejos/src/java/classes/java/base/NoClassDefFoundError.java
--- lejos.orig/src/java/classes/java/base/NoClassDefFoundError.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/NoClassDefFoundError.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,8 @@
+package java.base;
+
+public class NoClassDefFoundError extends Error
+{
+ public NoClassDefFoundError (String aMessage)
+ {
+ }
+}
diff -pruN lejos.orig/src/java/classes/java/base/NoSuchMethodError.java lejos/src/java/classes/java/base/NoSuchMethodError.java
--- lejos.orig/src/java/classes/java/base/NoSuchMethodError.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/NoSuchMethodError.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class NoSuchMethodError extends Error
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/NullPointerException.java lejos/src/java/classes/java/base/NullPointerException.java
--- lejos.orig/src/java/classes/java/base/NullPointerException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/NullPointerException.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class NullPointerException extends RuntimeException
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/Object.java lejos/src/java/classes/java/base/Object.java
--- lejos.orig/src/java/classes/java/base/Object.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Object.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,76 @@
+package java.base;
+
+/**
+ * All classes extend this one, implicitly.
+ */
+public class Object
+{
+ public boolean equals (Object aOther)
+ {
+ return this == aOther;
+ }
+
+ public int hashCode()
+ {
+ return getDataAddress (this);
+ }
+
+ /**
+ * Wake up one thread blocked on a wait(). Must be synchronized on
+ * this object otherwise an IllegalMonitorStateException will be thrown.
+ * 
+ * If multiple threads are waiting, higher priority threads will be woken
+ * in preference, otherwise the thread that gets woken is essentially
+ * random. 
+ */
+ public final native void notify();
+
+ /**
+ * Wake up all threads blocked on a wait(). Must be synchronized on
+ * this object otherwise an IllegalMonitorStateException will be thrown.
+ */
+ public final native void notifyAll();
+
+ /**
+ * This is the same as calling wait(0).
+ */
+ public final native void wait() throws InterruptedException;
+
+ /**
+ * Wait until notified. Must be synchronized on this object otherwise
+ * an IllegalMonitorStateException will be thrown. The wait can
+ * terminate if one of the following things occurs:
+ * <ol>
+ * <li>notify() or notifyAll() is called.
+ * <li>The calling thread is interrupted.
+ * <li>The timeout expires.
+ * </ol>
+ * @param timeout maximum time in milliseconds to wait. Zero means forever.
+ */
+ public final native void wait(long timeout) throws InterruptedException;
+ 
+ /**
+ * Returns the empty string. It's here to satisfy javac.
+ */
+ public String toString()
+ {
+ return "";
+ }
+
+ /**
+ * Returns <code>null</code>. It's here to satisfy javac.
+ */
+ public final Class getClass()
+ {
+ return null;
+ }
+
+ private native static int getDataAddress (Object obj);
+}
+
+
+
+
+
+
+
diff -pruN lejos.orig/src/java/classes/java/base/OutOfMemoryError.java lejos/src/java/classes/java/base/OutOfMemoryError.java
--- lejos.orig/src/java/classes/java/base/OutOfMemoryError.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/OutOfMemoryError.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class OutOfMemoryError extends Error
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/OutputStream.java lejos/src/java/classes/java/base/OutputStream.java
--- lejos.orig/src/java/classes/java/base/OutputStream.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/OutputStream.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,134 @@
+/*
+ * @(#)OutputStream.java	1.23 00/02/02
+ *
+ * Copyright 1994-2000 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * This software is the proprietary information of Sun Microsystems, Inc. 
+ * Use is subject to license terms.
+ * 
+ */
+
+package java.base;
+
+/**
+ * This abstract class is the superclass of all classes representing 
+ * an output stream of bytes. An output stream accepts output bytes 
+ * and sends them to some sink.
+ * 
+ * Applications that need to define a subclass of 
+ * <code>OutputStream</code> must always provide at least a method 
+ * that writes one byte of output. 
+ *
+ * @author Arthur van Hoff
+ * @version 1.23, 02/02/00
+ * @see java.io.BufferedOutputStream
+ * @see java.io.ByteArrayOutputStream
+ * @see java.io.DataOutputStream
+ * @see java.io.FilterOutputStream
+ * @see java.io.InputStream
+ * @see java.io.OutputStream#write(int)
+ * @since JDK1.0
+ */
+public abstract class OutputStream {
+ /**
+ * Writes the specified byte to this output stream. The general 
+ * contract for <code>write</code> is that one byte is written 
+ * to the output stream. The byte to be written is the eight 
+ * low-order bits of the argument <code>b</code>. The 24 
+ * high-order bits of <code>b</code> are ignored.
+ * 
+ * Subclasses of <code>OutputStream</code> must provide an 
+ * implementation for this method. 
+ *
+ * @param b the <code>byte</code>.
+ * @exception IOException if an I/O error occurs. In particular, 
+ * an <code>IOException</code> may be thrown if the 
+ * output stream has been closed.
+ */
+ public abstract void write(int b) throws IOException;
+
+ /**
+ * Writes <code>b.length</code> bytes from the specified byte array 
+ * to this output stream. The general contract for <code>write(b)</code> 
+ * is that it should have exactly the same effect as the call 
+ * <code>write(b, 0, b.length)</code>.
+ *
+ * @param b the data.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.OutputStream#write(byte[], int, int)
+ */
+ public void write(byte b[]) throws IOException {
+	write(b, 0, b.length);
+ }
+
+ /**
+ * Writes <code>len</code> bytes from the specified byte array 
+ * starting at offset <code>off</code> to this output stream. 
+ * The general contract for <code>write(b, off, len)</code> is that 
+ * some of the bytes in the array <code>b</code> are written to the 
+ * output stream in order; element <code>b[off]</code> is the first 
+ * byte written and <code>b[off+len-1]</code> is the last byte written 
+ * by this operation.
+ * 
+ * The <code>write</code> method of <code>OutputStream</code> calls 
+ * the write method of one argument on each of the bytes to be 
+ * written out. Subclasses are encouraged to override this method and 
+ * provide a more efficient implementation. 
+ * 
+ * If <code>b</code> is <code>null</code>, a 
+ * <code>NullPointerException</code> is thrown.
+ * 
+ * If <code>off</code> is negative, or <code>len</code> is negative, or 
+ * <code>off+len</code> is greater than the length of the array 
+ * <code>b</code>, then an <tt>IndexOutOfBoundsException</tt> is thrown.
+ *
+ * @param b the data.
+ * @param off the start offset in the data.
+ * @param len the number of bytes to write.
+ * @exception IOException if an I/O error occurs. In particular, 
+ * an <code>IOException</code> is thrown if the output 
+ * stream is closed.
+ */
+ public void write(byte b[], int off, int len) throws IOException {
+	if (b == null) {
+	 throw new NullPointerException();
+	} else if ((off < 0) || (off > b.length) || (len < 0) ||
+		 ((off + len) > b.length) || ((off + len) < 0)) {
+	 throw new RuntimeException();
+	} else if (len == 0) {
+	 return;
+	}
+	for (int i = 0 ; i < len ; i++) {
+	 write(b[off + i]);
+	}
+ }
+
+ /**
+ * Flushes this output stream and forces any buffered output bytes 
+ * to be written out. The general contract of <code>flush</code> is 
+ * that calling it is an indication that, if any bytes previously 
+ * written have been buffered by the implementation of the output 
+ * stream, such bytes should immediately be written to their 
+ * intended destination.
+ * 
+ * The <code>flush</code> method of <code>OutputStream</code> does nothing.
+ *
+ * @exception IOException if an I/O error occurs.
+ */
+ public void flush() throws IOException {
+ }
+
+ /**
+ * Closes this output stream and releases any system resources 
+ * associated with this stream. The general contract of <code>close</code> 
+ * is that it closes the output stream. A closed stream cannot perform 
+ * output operations and cannot be reopened.
+ * 
+ * The <code>close</code> method of <code>OutputStream</code> does nothing.
+ *
+ * @exception IOException if an I/O error occurs.
+ */
+ public void close() throws IOException {
+ }
+
+}
diff -pruN lejos.orig/src/java/classes/java/base/Queue.java lejos/src/java/classes/java/base/Queue.java
--- lejos.orig/src/java/classes/java/base/Queue.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Queue.java	2018-06-19 13:13:37.000000000 +0200
@@ -0,0 +1,90 @@
+package java.base;
+/*
+* $Log: Queue.java,v $
+* Revision 1.2 2005/11/23 17:46:45 mpscholz
+* minor javadoc related changes
+*
+* Revision 1.1 2003/08/17 14:59:42 mpscholz
+* enhanced Vector
+* added Stack and Queue and associated exception classes
+*
+*/
+
+/////////////////////////////////////////////////////////
+/**
+ * A FIFO Queue of objects. 
+ */
+public class Queue extends Vector {
+
+	////////////////////////////////////////////
+	// constants
+	////////////////////////////////////////////
+ 
+	////////////////////////////////////////////
+	// fields
+	////////////////////////////////////////////
+
+	////////////////////////////////////////////
+	// constructors
+	////////////////////////////////////////////
+
+	////////////////////////////////////////////
+ /**
+ * creates a new Queue instance
+ */
+ public Queue() {
+ 	// do nothing
+ } // Queue()
+
+	////////////////////////////////////////////
+	/**
+	 * pushes an object onto the Queue
+	 * @param anObject the object
+	 * @return Object the object pushed onto the Queue
+	 */
+ public Object push(Object anObject) {
+ 	// add the object to base vector
+		addElement(anObject);
+		return anObject;
+ } // push()
+
+	////////////////////////////////////////////
+	/**
+	 * fetches an object from the start of the Queue
+	 * and removes it
+	 * @return Object the object removed from the start of the stock
+	 * @throws EmptyQueueException
+	 */
+ public synchronized Object pop() throws EmptyQueueException {
+		// get object
+		Object popped = peek();
+		// remove and return object
+		removeElementAt(0);
+		return popped;
+ } // pop()
+
+	////////////////////////////////////////////
+	/**
+	 * fetches an object from the start of the Queue
+	 * does not remove it!
+	 * @return Object the object at the start of the Queue
+	 * @throws EmptyQueueException
+	 */
+ public synchronized Object peek() throws EmptyQueueException {
+		// empty Queue?
+		if(size()==0)
+	 	throw new EmptyQueueException();
+	 // return first element
+		return elementAt(0);
+ } // peek()
+
+	////////////////////////////////////////////
+	/**
+	 * is this Queue empty?
+	 * @return boolean true, if the Queue is empty
+	 */
+ public boolean empty() {
+		return (size()==0);
+ } // empty()
+
+} // class Queue
diff -pruN lejos.orig/src/java/classes/java/base/Random.java lejos/src/java/classes/java/base/Random.java
--- lejos.orig/src/java/classes/java/base/Random.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Random.java	2018-06-19 13:13:37.000000000 +0200
@@ -0,0 +1,42 @@
+package java.base;
+
+/**
+ * Pseudo-random number generation.
+ */
+public class Random
+{
+ private int iPrevSeed, iSeed;
+ 
+ public Random (long seed)
+ {
+ iPrevSeed = 1;
+ iSeed = (int) seed;
+ }
+
+ public Random()
+ {
+	this(System.currentTimeMillis());
+ }
+ 
+ /**
+ * @return A random positive or negative integer.
+ */
+ public int nextInt()
+ {
+ int pNewSeed = (iSeed * 48271) ^ iPrevSeed;
+ iPrevSeed = iSeed;
+ iSeed = pNewSeed;
+ return pNewSeed;
+ }
+
+ /**
+ * Returns a random integer in the range 0...n-1.
+ * @param n the bound
+ * @return A random integer in the range 0...n-1.
+ */
+ public int nextInt (int n)
+ {
+	int m = nextInt() % n;
+	return m >= 0 ? m : m + n;
+ }
+}
diff -pruN lejos.orig/src/java/classes/java/base/RuntimeException.java lejos/src/java/classes/java/base/RuntimeException.java
--- lejos.orig/src/java/classes/java/base/RuntimeException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/RuntimeException.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class RuntimeException extends Exception
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/Runtime.java lejos/src/java/classes/java/base/Runtime.java
--- lejos.orig/src/java/classes/java/base/Runtime.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Runtime.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,41 @@
+package java.base;
+
+/**
+ * Minimalist version of the standard Java Runtime class.
+ * @author Paul Andrews
+ */
+public class Runtime {
+ private static Runtime singleton;
+
+ /**
+ * Private so no one but us can create one.
+ */
+ private Runtime()
+ {
+ }
+
+ /**
+ * Get the single instance of us.
+ */
+ public static Runtime getRuntime()
+ {
+ if (singleton == null) {
+ singleton = new Runtime();
+ }
+ return singleton;
+ } 
+	
+ /**
+ * Return the amount of free memory.on the heap
+ *
+ * @return the free memory in bytes
+ */
+ public native long freeMemory();
+ 
+ /**
+ * Return the size of the heap in bytes.
+ *
+ * @return the free memory in bytes
+ */
+ public native long totalMemory();
+}
diff -pruN lejos.orig/src/java/classes/java/base/Serializable.java lejos/src/java/classes/java/base/Serializable.java
--- lejos.orig/src/java/classes/java/base/Serializable.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Serializable.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,10 @@
+package java.base;
+
+/**
+ * This interface is not functional. It's here
+ * to satisfy jikes.
+ */
+public interface Serializable
+{
+
+}
diff -pruN lejos.orig/src/java/classes/java/base/Stack.java lejos/src/java/classes/java/base/Stack.java
--- lejos.orig/src/java/classes/java/base/Stack.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Stack.java	2018-06-19 13:13:37.000000000 +0200
@@ -0,0 +1,93 @@
+package java.base;
+/*
+* $Log: Stack.java,v $
+* Revision 1.2 2005/11/23 17:46:45 mpscholz
+* minor javadoc related changes
+*
+* Revision 1.1 2003/08/17 14:59:42 mpscholz
+* enhanced Vector
+* added Stack and Queue and associated exception classes
+*
+*/
+
+/////////////////////////////////////////////////////////
+/**
+ * A LIFO stack of objects. 
+ * TODO recycable
+ */
+public class Stack extends Vector {
+
+	////////////////////////////////////////////
+	// constants
+	////////////////////////////////////////////
+ 
+	////////////////////////////////////////////
+	// fields
+	////////////////////////////////////////////
+
+	////////////////////////////////////////////
+	// constructors
+	////////////////////////////////////////////
+
+	////////////////////////////////////////////
+ /**
+ * creates a new Stack instance
+ */
+ public Stack() {
+ 	// do nothing
+ } // Stack()
+
+	////////////////////////////////////////////
+	/**
+	 * pushes an object onto the stack
+	 * @param anObject the object
+	 * @return Object the object pushed onto the stack
+	 */
+ public Object push(Object anObject) {
+ 	// add the object to base vector
+		addElement(anObject);
+		return anObject;
+ } // push()
+
+	////////////////////////////////////////////
+	/**
+	 * fetches an object from the top of the stack
+	 * and removes it
+	 * @return Object the object removed from the top of the stock
+	 * @throws EmptyStackException
+	 */
+ public synchronized Object pop() throws EmptyStackException {
+		// get object
+		Object popped = peek();
+		// remove and return object
+		removeElementAt(size() - 1);
+		return popped;
+ } // pop()
+
+	////////////////////////////////////////////
+	/**
+	 * fetches an object from the stack
+	 * does not remove it!
+	 * @return Object the object at the top of the stack
+	 * @throws EmptyStackException
+	 */
+ public synchronized Object peek() throws EmptyStackException {
+ 	// size of stack
+		int	sizeOfStack = size();
+		// empty stack?
+		if(sizeOfStack==0)
+	 	throw new EmptyStackException();
+	 // return top element
+		return elementAt(sizeOfStack-1);
+ } // peek()
+
+	////////////////////////////////////////////
+	/**
+	 * is this stack empty?
+	 * @return boolean true, if the stack is empty
+	 */
+ public boolean empty() {
+		return (size()==0);
+ } // empty()
+
+} // class Stack
diff -pruN lejos.orig/src/java/classes/java/base/StackOverflowError.java lejos/src/java/classes/java/base/StackOverflowError.java
--- lejos.orig/src/java/classes/java/base/StackOverflowError.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/StackOverflowError.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,5 @@
+package java.base;
+
+public class StackOverflowError extends Error
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/StringBuffer.java lejos/src/java/classes/java/base/StringBuffer.java
--- lejos.orig/src/java/classes/java/base/StringBuffer.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/StringBuffer.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,247 @@
+package java.base;
+
+/**
+ * An expandable string of characters. Actually not very expandable!
+ * 09/25/2001 added number formatting thanks to Martin E. Nielsen.
+ * You must ensure that the buffer is large enough to take the formatted
+ * number.
+ *
+ * @author <a href="mailto:martin@egholm-nielsen.dk">Martin E. Nielsen</a>
+ */
+public final class StringBuffer
+{
+ char[] characters;
+ int curPos = 0;
+
+ /**
+ * Conversion between integers from 0 to 9 and their respective
+ * chars.
+ **/
+ private static final char[] numbers = { '0', '1', '2', '3', '4',
+					 '5', '6', '7', '8', '9' };
+
+ /**
+ * The value of log(10) used for converting from base
+ * e to base 10.
+ **/
+ private static final float log10 = 2.30258509f;
+
+ public StringBuffer () {
+ 	characters = new char[0];
+ }
+ 
+ public StringBuffer (String aString)
+ {
+ characters = aString.toCharArray();
+ }
+
+ public StringBuffer (int length)
+ {
+ characters = new char[length];
+ }
+
+ public StringBuffer delete(int start, int end)
+ {
+ if (start >= 0 && start < end && start < curPos)
+ {
+ if (end >= curPos)
+ end = curPos;
+ else
+ System.arraycopy(characters, end, characters, start, curPos-end);
+ 
+ curPos -= end-start;
+ }
+ 
+ return this;
+ }
+
+ public StringBuffer append (String s)
+ {
+ // Reminder: compact code more important than speed
+ char[] sc = s.toCharArray();
+ int cl = characters.length;
+ int sl = sc.length;
+ char [] nc = characters;
+ if (sl + curPos > cl)
+ {
+ nc = new char[sl + curPos];
+ System.arraycopy (characters, 0, nc, 0, curPos);
+ }
+ System.arraycopy (sc, 0, nc, curPos, sl);
+ characters = nc;
+ curPos += sl;
+ return this;
+ }
+
+ public StringBuffer append (java.lang.Object aObject)
+ {
+ return append (aObject.toString());
+ }
+
+ public StringBuffer append (boolean aBoolean)
+ {
+ return append (aBoolean ? "true" : "false");
+ }
+ 
+ public StringBuffer append (char aChar)
+ {
+ return append (new String (new char[] { aChar }, 0, 1));
+ }
+
+ public StringBuffer append (int aInt)
+ {
+	if ( aInt < 0 ) {
+	 characters[ curPos++ ] = '-';
+	 aInt = -aInt;
+	} // if
+
+	int pow = ( int )Math.floor( Math.log( aInt ) / log10 );
+
+	int div = 0;
+	while ( pow >= 0 ) {
+	 div = ( int ) ( aInt / (int)Math.pow( 10, pow ) );
+	 
+	 characters[ curPos++ ] = numbers[ div ];
+	 aInt -= div * (int)Math.pow( 10, pow );
+	 pow--;
+	} // while
+	
+	return this;
+ }
+
+ public StringBuffer append (long aLong)
+ {
+ return append("<longs not supported>");
+ }
+
+ public StringBuffer append (float aFloat)
+ {
+ try {
+ append (aFloat, 8);
+ } catch (ArrayIndexOutOfBoundsException e) {
+ curPos = Math.min(characters.length, curPos);
+ }
+ 
+ return this;
+ }
+
+ public StringBuffer append (double aDouble)
+ {
+ try {
+ append ((float)aDouble, 8);
+ } catch (ArrayIndexOutOfBoundsException e) {
+ curPos = Math.min(characters.length, curPos);
+ }
+ 
+ return this;
+ }
+ 
+ public String toString()
+ {
+ return new String (characters, 0, curPos);
+ }
+
+ public char charAt(int i)
+ {
+ return characters[i];
+ }
+ 
+ public int length()
+ {
+ return curPos;
+ }
+
+ /**
+ * Retrieves the contents of the StringBuffer in the form of an array of characters.
+ */
+ public char [] getChars()
+ {
+ return characters;
+ }
+ 
+ /**
+ * Helper method for converting floats and doubles.
+ *
+ * @author Martin E. Nielsen
+ **/
+ private StringBuffer append( float number, int significantDigits ) {
+
+	if ( number == 0 ) {
+	 characters[ curPos++ ] = '0';
+	 return this;
+	} // if
+	 
+	if ( number < 0 ) {
+	 characters[ curPos++ ] = '-';
+	 number = -number;
+	} // if
+
+	// calc. the power (base 10) for the given number:
+	int pow = ( int )Math.floor( Math.log( number ) / log10 );
+	int exponent = 0;
+
+	// use exponential formatting if number too big or too small
+	if ( pow < -3 || pow > 6 ) {
+	 exponent = pow;
+	 number /= Math.exp( Math.ln10 * exponent );
+	} // if
+
+	// Recalc. the pow if exponent removed and d has changed
+	pow = ( int )Math.floor( Math.log( number ) / log10 );
+
+	// Decide how many insignificant zeros there will be in the
+	// lead of the number.
+	int insignificantDigits = -Math.min( 0, pow );
+
+	// Force it to start with at least "0." if necessarry
+	pow = Math.max( 0, pow );
+ double divisor = Math.pow(10, pow);
+ 
+	// Loop over the significant digits (17 for double, 8 for float)
+	for ( int i = 0, end = significantDigits+insignificantDigits, div; i < end; i++ ) {
+
+	 // Add the '.' when passing from 10^0 to 10^-1
+	 if ( pow == -1 ) {
+		characters[ curPos++ ] = '.';
+	 } // if
+	 
+	 // Find the divisor
+	 div = ( int ) ( number / divisor );
+	 // This might happen with 1e6: pow = 5 ( instead of 6 )
+	 if ( div == 10 ) {
+		characters[ curPos++ ] = '1';
+		characters[ curPos++ ] = '0';
+	 } // if
+	 else {
+//		characters[ curPos ] = numbers[ div ];
+		characters[ curPos ] = (char)(div + '0');
+		curPos++;
+	 } // else
+
+	 number -= div * divisor;
+	 divisor /= 10.0;
+	 pow--;
+
+	 // Break the loop if we have passed the '.'
+	 if ( number == 0 && divisor < 0.1 ) break;
+	} // for
+
+	// Remove trailing zeros
+ 	while ( characters[ curPos-1 ] == '0' )
+ 	 curPos--;
+
+	// Avoid "4." instead of "4.0"
+	if ( characters[ curPos-1 ] == '.' )
+	 curPos++;
+
+	// Restore the exponential format
+	if ( exponent != 0 ) {
+	 characters[ curPos++ ] = 'E';
+	 append( exponent );
+	} // if
+	
+	return this;
+ }
+}
+
+
diff -pruN lejos.orig/src/java/classes/java/base/String.java lejos/src/java/classes/java/base/String.java
--- lejos.orig/src/java/classes/java/base/String.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/String.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,99 @@
+package java.base;
+
+/**
+ * An immutable string of characters.
+ */
+public final class String
+{
+ // NOTE: The state of this class is mapped to
+ // native code (see vmsrc/classes.h).
+
+ char[] characters; // package protected, so StringUtils can access it
+
+ /**
+ * Create a String from a character array.
+ * @param c the character array
+ * @param off the offset - usually 0
+ * @param len the length of the String - must not be greater than c.length
+ **/
+ public String (char[] c, int off, int len)
+ {
+ characters = new char[len];
+ System.arraycopy (c, off, characters, 0, len);
+ }
+
+ /**
+ * Return the length of the String in characters
+ * @return the length of the String
+ **/
+ public int length()
+ {
+ return characters.length;
+ }
+
+ /**
+ * Return the character at the given index
+ * @return the characters at the given index
+ **/
+ public char charAt(int index) 
+ {
+ return characters[index];
+ }
+
+ /**
+ * Converts the String into an array of characters
+ * @return the character Array
+ **/
+ public char[] toCharArray()
+ {
+ int len = characters.length;
+ char[] ca = new char[len];
+ System.arraycopy (characters, 0, ca, 0, len);
+ return ca;
+ }
+
+ /**
+ * Converts an Object to a String
+ * @return the String that represents the object
+ **/
+ public static String valueOf (Object aObj)
+ {
+ return aObj.toString();
+ }
+
+ /**
+ * Returns itself.
+ * @return the String itself
+ */
+ public String toString()
+ {
+ return this;
+ }
+ 
+ /**
+ * Compares the String with an Object
+ * @return true if the String is equal to the object, false otherwise
+ **/
+ public boolean equals(Object other)
+ {
+ if (other == null)
+ return false;
+ 
+ try {
+ String os = (String)other;
+ if (os.characters.length != characters.length)
+ return false;
+ 
+ for (int i=0; i<characters.length; i++)
+ {
+ if (characters[i] != os.characters[i])
+ return false;
+ }
+ 
+ return true;
+ } catch (ClassCastException e) {
+ } 
+ return false;
+ }
+}
+
diff -pruN lejos.orig/src/java/classes/java/base/StringUtils.java lejos/src/java/classes/java/base/StringUtils.java
--- lejos.orig/src/java/classes/java/base/StringUtils.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/StringUtils.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,25 @@
+package java.base;
+
+/**
+ * Utilities for non-standard String maniplulation.
+ * Use of these utilities will make your programs non-standard.
+ */
+public final class StringUtils
+{
+ private StringUtils() {
+ }
+
+ /**
+ * Return the character array corresponding to the String without copying it.
+ * This method, unlike the toCharArray method of String, uses no memory.
+ * This method should be used with care as it is non-standard and allows
+ * the contents of a String to be overwritten.
+ * Use in user programs will make the programs non-standard and non-portable.
+ * @param s the String whose characters are required
+ * @return the character array (uncopied)
+ */
+ public static char [] getCharacters(String s) {
+ return s.characters;
+ }
+}
+
diff -pruN lejos.orig/src/java/classes/java/base/System.java lejos/src/java/classes/java/base/System.java
--- lejos.orig/src/java/classes/java/base/System.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/System.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,39 @@
+package java.base;
+
+/**
+ * System utilities.
+ */
+public final class System
+{
+ private System() {}
+ 
+ /**
+ * Copies one array to another.
+ */
+ //public static native void arraycopy (Object src, int srcOffset, Object dest, int destOffset, int length);
+ static void arraycopy (char[] src, int srcOffset, char[] dest, int destOffset, int length)
+ {
+ for (int i = 0; i < length; i++)
+ dest[i + destOffset] = src[i + srcOffset]; 
+ }
+
+ /**
+ * Terminate the application.
+ */
+ public static native void exit(int code);
+ 
+ /**
+ * Current time expressed in milliseconds. In the RCX, this is the number
+ * of milliseconds since the RCX has been on. (In Java, this would
+ * be since January 1st, 1970).
+ */
+ public static native long currentTimeMillis();
+ 
+ /**
+ * Get the singleton instance of Runtime.
+ */
+ public static Runtime getRuntime() {
+ 	return Runtime.getRuntime();
+ }
+}
+
diff -pruN lejos.orig/src/java/classes/java/base/ThreadDeath.java lejos/src/java/classes/java/base/ThreadDeath.java
--- lejos.orig/src/java/classes/java/base/ThreadDeath.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/ThreadDeath.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,9 @@
+package java.base;
+
+/**
+ * This is a special Error, which isn't reported by the
+ * VM if uncaught. The thread dies quietly.
+ */
+public class ThreadDeath extends Error
+{
+}
diff -pruN lejos.orig/src/java/classes/java/base/Thread.java lejos/src/java/classes/java/base/Thread.java
--- lejos.orig/src/java/classes/java/base/Thread.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Thread.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,114 @@
+package java.base;
+
+/**
+ * A thread of execution (or task). Now handles priorities, daemon threads
+ * and interruptions.
+ */
+public abstract class Thread
+{
+ /**
+ * The minimum priority that a thread can have. The value is 1.
+ */
+ public final static int MIN_PRIORITY = 1;
+
+ /**
+ * The priority that is assigned to the primordial thread. The value is 5.
+ */
+ public final static int NORM_PRIORITY = 5;
+
+ /**
+ * The maximum priority that a thread can have. The value is 10.
+ */
+ public final static int MAX_PRIORITY = 10;
+
+ // Note 1: This class cannot have a static initializer.
+
+ // Note 2: The following fields are used by the VM.
+ // Their sizes and location can only be changed
+ // if classes.h is changed accordingly. Needless
+ // to say, they are read-only.
+
+ private Thread _TVM_nextThread;
+ private int _TVM_waitingOn;
+ private int _TVM_sleepUntil;
+ private int _TVM_stackFrameArray;
+ private int _TVM_stackArray;
+ private byte _TVM_stackFrameArraySize;
+ private byte _TVM_monitorCount;
+ private byte _TVM_threadId; 
+ private byte _TVM_state; 
+ private byte _TVM_priority; 
+ private byte _TVM_interrupted; 
+ private byte _TVM_daemon; 
+
+ // Extra instance state follows:
+ 
+ private String name;
+
+ public final boolean isAlive()
+ {
+ return _TVM_state > 1;
+ } 
+	 
+ public Thread()
+ {
+ this ("");
+ }
+
+ public Thread (String name)
+ {
+ 	Thread t = currentThread();
+	if (t == null)
+		setPriority(NORM_PRIORITY);
+	else
+		setPriority(t.getPriority());	
+ this.name = name;
+ }
+
+ public abstract void run();
+ 
+ public final native void start();
+ public static native void yield();
+ public static native void sleep (long aMilliseconds) throws InterruptedException;
+ public static native Thread currentThread();
+ public final native int getPriority();
+ /**
+ * Set the priority of this thread. Higher number have higher priority.
+ * The scheduler will always run the highest priority thread in preference
+ * to any others. If more than one thread of that priority exists the
+ * scheduler will time-slice them. In order for lower priority threas
+ * to run a higher priority thread must cease to be runnable. i.e. it
+ * must exit, sleep or wait on a monitor. It is not sufficient to just
+ * yield.
+ * 
+ * Threads inherit the priority of their parent. The primordial thread
+ * has priority NORM_PRIORITY.
+ *
+ * @param priority must be between MIN_PRIORITY and MAX_PRIORITY.
+ */
+ public final native void setPriority(int priority);
+ 
+ /**
+ * Set the interrupted flag. If we are asleep we will wake up
+ * and an InterruptedException will be thrown.
+ */
+ public native void interrupt();
+ public static native boolean interrupted();
+ public final native boolean isInterrupted();
+ 
+ /**
+ * Set the daemon flag. If a thread is a daemon thread its existence will
+ * not prevent a JVM from exiting.
+ */
+ public final native boolean isDaemon();
+ public final native void setDaemon(boolean on);
+ 
+ /**
+ * Join not yet implemented
+ */
+ public final native void join() throws InterruptedException;
+ public final native void join(long timeout) throws InterruptedException;
+}
+
+
+
diff -pruN lejos.orig/src/java/classes/java/base/Throwable.java lejos/src/java/classes/java/base/Throwable.java
--- lejos.orig/src/java/classes/java/base/Throwable.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Throwable.java	2018-06-19 13:13:09.000000000 +0200
@@ -0,0 +1,21 @@
+package java.base;
+
+/**
+ * All exceptions and errors extend this class.
+ */
+public class Throwable
+{
+	private String _message;
+ public Throwable() {
+	 _message = "";
+ }
+
+ public Throwable(String message) {
+	 _message = message;
+ }
+
+ public String getMessage()
+ {
+ return _message;
+ }
+}
diff -pruN lejos.orig/src/java/classes/java/base/Vector.java lejos/src/java/classes/java/base/Vector.java
--- lejos.orig/src/java/classes/java/base/Vector.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/classes/java/base/Vector.java	2018-06-19 13:13:37.000000000 +0200
@@ -0,0 +1,553 @@
+package java.base;
+/*
+* $Log: Vector.java,v $
+* Revision 1.6 2005/11/23 17:46:45 mpscholz
+* minor javadoc related changes
+*
+* Revision 1.5 2003/08/17 14:59:42 mpscholz
+* enhanced Vector
+* added Stack and Queue and associated exception classes
+*
+*/
+
+/**
+ * A dynamic array.
+ */
+
+public class Vector
+{
+ //private Object[] iElements;
+ //private int iSize;
+
+ protected Object[] elementData;
+
+ protected int capacityIncrement;
+
+ protected int elementCount;
+
+
+
+ public Vector(int initialCapacity, int capacityIncrement)
+
+ {
+
+ if (initialCapacity < 0) initialCapacity = 0;
+
+ elementData = new Object[initialCapacity];
+
+ this.capacityIncrement = capacityIncrement;
+
+ elementCount = 0;
+
+ }
+
+
+
+ public Vector(int initialCapacity)
+
+ {
+
+ this(initialCapacity,0);
+
+ }
+
+
+
+
+
+ public Vector()
+
+ {
+
+ this(7);
+
+ }
+
+
+
+
+
+ public synchronized void addElement (Object aObj)
+
+ {
+
+ //int pOldSize = elementCount;
+
+ //setSize (pOldSize + 1);
+
+ ensureCapacityHelper(elementCount + 1);
+
+ elementData[elementCount] = aObj;
+
+ elementCount++;
+
+ }
+
+
+
+ public int capacity()
+
+ {
+
+ return elementData.length;
+
+ }
+
+
+
+
+
+ public void clear()
+
+ {
+
+ removeAllElements();
+
+ }
+
+
+
+
+
+ public synchronized Object elementAt (int aIndex)
+
+ {
+
+ if ((aIndex >= 0) && (aIndex < elementCount))
+
+ {
+
+ return elementData[aIndex];
+
+ }else{
+
+ throw new ArrayIndexOutOfBoundsException();
+
+ }
+
+ }
+
+
+
+ public synchronized void ensureCapacity(int minCapacity)
+
+ {
+
+ ensureCapacityHelper(minCapacity);
+
+ }
+
+
+
+
+
+ //internal unsynchronized method for better performance
+
+ private void ensureCapacityHelper(int minCapacity)
+
+ {
+
+ if (elementData.length < minCapacity)
+
+ {
+
+ int pNewCapacity;
+
+ if (capacityIncrement > 0)
+
+ {
+
+ pNewCapacity = elementData.length + capacityIncrement;
+
+ }else{
+
+ pNewCapacity = elementData.length * 2;
+
+ }
+
+ if (pNewCapacity < minCapacity) pNewCapacity = minCapacity;
+
+ Object oldData[] = elementData;
+
+ elementData = new Object[pNewCapacity];
+
+ arraycopy(oldData,0, elementData, 0, elementCount);
+
+
+
+ }
+
+ }
+
+
+
+
+
+ public boolean equals(Object aObj)
+
+ {
+
+ return super.equals(aObj);
+
+ }
+
+
+
+
+
+ public synchronized int indexOf(Object aObj)
+
+ {
+
+ return indexOf(aObj, 0);
+
+ }
+
+
+
+
+
+ public synchronized int indexOf(Object aObj, int aIndex)
+
+ {
+
+ if (aObj == null)
+
+ {
+
+ for (int i = aIndex; i < elementCount; i++)
+
+ {
+
+ if (elementData[i] == null) return i;
+
+ }
+
+ }else{
+
+ for (int i = aIndex; i < elementCount; i++)
+
+ {
+
+ if (elementData[i].equals(aObj)) return i;
+
+ }
+
+ }
+
+ return -1;
+
+ }
+
+
+
+ public synchronized void insertElementAt (Object aObj, int aIndex)
+
+ {
+
+ if (aIndex > elementCount)
+
+ {
+
+ throw new ArrayIndexOutOfBoundsException();
+
+ }else{
+
+ ensureCapacityHelper(elementCount + 1);
+
+ for (int i = elementCount; i > aIndex; i--)
+
+ {
+
+ elementData[i] = elementData[i - 1];
+
+ }
+
+ //arraycopy(elementData, aIndex, elementData, aIndex + 1, elementCount - aIndex);
+
+ elementData[aIndex] = aObj;
+
+ elementCount++;
+
+ }
+
+ }
+
+
+
+
+
+ public boolean isEmpty()
+
+ {
+
+ return (elementCount == 0);
+
+ }
+
+	/////////////////////////////////////////////////////
+ 	/**
+	* delivers the index of the last occurrence of the object
+	* @param anObject the object 
+	* @return the index of the last occurrence of the object
+	* or -1, if object is not found
+	*/
+	public synchronized int lastIndexOf(Object anObject) {
+		return lastIndexOf(anObject,elementCount-1);
+	} // lastIndexOf()
+
+	/////////////////////////////////////////////////////
+	/**
+	* delivers the index of the last occurrence of the object
+	* starting from some index
+	* @param anObject the object
+	* @param anIndex the starting index 
+	* @return the index of the last occurrence of the object
+	* or -1, if object is not found
+	* @throws ArrayIndexOutOfBoundsException
+	*/
+	public synchronized int lastIndexOf(Object anObject, 
+		int anIndex) throws ArrayIndexOutOfBoundsException {
+		// valid index?
+		if(anIndex>=elementCount)
+			throw new ArrayIndexOutOfBoundsException();
+		// null object?
+		if(anObject==null) {
+			// find last null object
+			for(int i=anIndex;i>=0;i--)
+				if(elementData[i]==null)
+					return i;
+		} else {
+			// find last equal object
+		for (int i=anIndex;i>=0;i--)
+			if(anObject.equals(elementData[i]))
+				return i;
+		} // else
+		// not found
+		return -1;
+	} // lastIndexOf()
+
+
+
+
+
+ public void removeAllElements()
+
+ {
+
+ for (int i = 0; i < elementCount; i++) elementData[i] = null;
+
+ elementCount = 0;
+
+ }
+
+
+
+ public synchronized boolean removeElement (Object aObj)
+
+ {
+
+ int index = indexOf(aObj);
+
+ if (index >= 0)
+
+ {
+
+ removeElementAt(index);
+
+ return true;
+
+ }else{
+
+ return false;
+
+ }
+
+ }
+
+
+
+ public synchronized void removeElementAt (int aIndex)
+
+ {
+
+ if ((aIndex >= 0) && (aIndex < elementCount))
+
+ {
+
+ int j = elementCount - aIndex - 1;
+
+ if (j > 0)
+
+ {
+
+ arraycopy(elementData, aIndex + 1, elementData, aIndex, j);
+
+ }
+
+ elementCount--;
+
+ elementData[elementCount] = null;
+
+ }else{
+
+ throw new ArrayIndexOutOfBoundsException();
+
+ }
+
+ }
+
+
+
+ public synchronized void setElementAt (Object aObj, int aIndex)
+
+ {
+
+ if (aIndex >= elementCount)
+
+ {
+
+ throw new ArrayIndexOutOfBoundsException();
+
+ }else{
+
+ elementData[aIndex] = aObj;
+
+ }
+
+ }
+
+
+
+
+
+
+
+
+
+ public synchronized void setSize (int aSize)
+
+ {
+
+ //elementCount = aSize;
+
+ if (elementCount < aSize)
+
+ {
+
+ /*int pNewCapacity;
+
+ if (capacityIncrement > 0) {
+
+ pNewCapacity = elementData.length + capacityIncrement;
+
+ }else{
+
+ pNewCapacity = elementData.length * 2;
+
+ }
+
+
+
+ if (pNewCapacity < aSize) pNewCapacity = aSize;
+
+ Object[] pNewElements = new Object[pNewCapacity];
+
+ arraycopy (elementData, 0, pNewElements, 0, elementData.length);
+
+ elementData = pNewElements;*/
+
+ ensureCapacityHelper(aSize);
+
+ }else{
+
+ for (int i = aSize; i < elementCount; i++) elementData[i] = null;
+
+ }
+
+ elementCount = aSize;
+
+ }
+
+
+
+ public synchronized int size()
+
+ {
+
+ return elementCount;
+
+ }
+
+
+
+ public synchronized Object[] toArray()
+
+ {
+
+ Object[] result = new Object[elementCount];
+
+ arraycopy(elementData, 0, result, 0, elementCount);
+
+ return result;
+
+ }
+
+
+
+
+
+ /*public String toString() {
+
+ if (elementCount < 1) {
+
+ return "[]";
+
+ }else{
+
+ String str = "[";
+
+ for (int i = 0; i < elementCount - 1;i++) str += String.valueOf(elementData[i]) + ", ";
+
+ str += String.valueOf(elementData[elementCount - 1]) + "]";
+
+ return str;
+
+ }
+
+ }*/
+
+
+
+ public synchronized void trimToSize()
+
+ {
+
+ if (elementCount < elementData.length)
+
+ {
+
+ Object oldData[] = elementData;
+
+ elementData = new Object[elementCount];
+
+ arraycopy(oldData, 0, elementData, 0, elementCount);
+
+ }
+
+ }
+
+ static void arraycopy (Object[] src, int srcoffset, Object[] dest, int destoffset, int length)
+
+ {
+
+ for (int i = 0; i < length; i++)
+
+ dest[i + destoffset] = src[i + srcoffset];
+
+ }
+
+ //private native void arraycopy (Object aSource, int aOffset1, Object aDest, int aOffset2, int aLength);
+
+}
+
diff -pruN lejos.orig/src/java/classes/java/io/DataInputStream.java lejos/src/java/classes/java/io/DataInputStream.java
--- lejos.orig/src/java/classes/java/io/DataInputStream.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/io/DataInputStream.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,147 +0,0 @@
-/*
- * @(#)DataInputStream.java 1.00 01/12/14
- *
- * Adapted from the original Sun Microsystems code for leJOS.
- * @author Brian Bagnall
- */
-
-package java.io;
-
-public class DataInputStream extends InputStream {
- 
- protected InputStream in;
- 
- public DataInputStream(InputStream in) {
- this.in = in;
- }
- 
- /**
- * Reads the next byte of data from this input stream. The value 
- * byte is returned as an <code>int</code> in the range 
- * <code>0</code> to <code>255</code>. If no byte is available 
- * because the end of the stream has been reached, the value 
- * <code>-1</code> is returned. This method blocks until input data 
- * is available, the end of the stream is detected, or an exception 
- * is thrown. 
- * 
- * This method
- * simply performs <code>in.read()</code> and returns the result.
- *
- * @return the next byte of data, or <code>-1</code> if the end of the
- * stream is reached.
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterInputStream#in
- */
- public int read() throws IOException {
- return in.read();
- }
- 
- public final int read(byte b[]) throws IOException {
- return in.read(b, 0, b.length);
- }
-
- public final int read(byte b[], int off, int len) throws IOException {
- return in.read(b, off, len);
- }
-/*
- public final void readFully(byte b[]) throws IOException {
- readFully(b, 0, b.length);
- }
-*/
-/* public final void readFully(byte b[], int off, int len) throws IOException {
-	 if (len < 0)
-	 throw new IOException();
-
- 	int n = 0;
- 	while (n < len) {
- int count = in.read(b, off + n, len - n);
- 	 if (count < 0)
- 		 throw new IOException();
- 	 n += count;
- }
- }
-*/
-/* public final int skipBytes(int n) throws IOException {
-
- int total = 0;
- int cur = 0;
- 
- while ((total<n) && ((cur = (int) in.skip(n-total)) > 0)) {
- total += cur;
- }
- return total;
- }
-*/
- public final boolean readBoolean() throws IOException {
- int ch = in.read();
- if (ch < 0)
- throw new IOException();
- return (ch != 0);
- }
-
- public final byte readByte() throws IOException {
- int ch = in.read();
- if (ch < 0)
- throw new IOException();
- return (byte)(ch);
- }
-/*
- public final int readUnsignedByte() throws IOException {
-	 int ch = in.read();
-	 if (ch < 0)
-	 throw new IOException();
-	 return ch;
- }
-*/
- public final short readShort() throws IOException {
- int ch1 = in.read();
- int ch2 = in.read();
- if ((ch1 | ch2) < 0)
- throw new IOException();
- return (short)((ch1 << 8) + (ch2 << 0));
- }
- /*
- public final int readUnsignedShort() throws IOException {
- InputStream in = this.in;
- int ch1 = in.read();
- int ch2 = in.read();
- if ((ch1 | ch2) < 0)
- throw new IOException();
- return (ch1 << 8) + (ch2 << 0);
- }
- */
- 
- public final char readChar() throws IOException {
- InputStream in = this.in;
- int ch1 = in.read();
- int ch2 = in.read();
- if ((ch1 | ch2) < 0)
- throw new IOException();
- return (char)((ch1 << 8) + (ch2 << 0));
- }
-
- public final int readInt() throws IOException {
- int ch1 = in.read();
- int ch2 = in.read();
- int ch3 = in.read();
- int ch4 = in.read();
- if ((ch1 | ch2 | ch3 | ch4) < 0)
- throw new IOException();
- return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
- }
-/*
- public final long readLong() throws IOException {
- InputStream in = this.in;
- return ((long)(readInt()) << 32) + (readInt() & 0xFFFFFFFFL);
- }
- */
-
- public final float readFloat() throws IOException {
- return Float.intBitsToFloat(readInt());
- }
-
-/*
- public final double readDouble() throws IOException {
- return Double.longBitsToDouble(readLong());
- }*/
-}
\ Kein Zeilenumbruch am Dateiende.
diff -pruN lejos.orig/src/java/classes/java/io/DataOutputStream.java lejos/src/java/classes/java/io/DataOutputStream.java
--- lejos.orig/src/java/classes/java/io/DataOutputStream.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/io/DataOutputStream.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,231 +0,0 @@
- /*
- * @(#)DataOutputStream.java 1.00 01/12/14
- *
- * Adapted from the original Sun Microsystems code for leJOS.
- * @author Brian Bagnall
- */
-package java.io;
-
-public class DataOutputStream extends OutputStream {
- 
- protected int written;
- protected OutputStream out;
- 
- public DataOutputStream(OutputStream out) {
- this.out = out;
- }
-
- /**
- * Increases the written counter by the specified value
- * until it reaches Integer.MAX_VALUE.
- */
- private void incCount(int value) {
- int temp = written + value;
- 
- //if (temp < 0)
- //temp = Integer.MAX_VALUE;
- written = temp;
- }
-
- /**
- * Writes the specified byte (the low eight bits of the argument 
- * <code>b</code>) to the underlying output stream. If no exception 
- * is thrown, the counter <code>written</code> is incremented by 
- * <code>1</code>.
- * 
- * Implements the <code>write</code> method of <code>OutputStream</code>.
- *
- * @param b the <code>byte</code> to be written.
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterOutputStream#out
- */
- public synchronized void write(int b) throws IOException {
- out.write(b);
- incCount(1);
- }
-
- /**
- * Writes <code>len</code> bytes from the specified byte array 
- * starting at offset <code>off</code> to the underlying output stream. 
- * If no exception is thrown, the counter <code>written</code> is 
- * incremented by <code>len</code>.
- *
- * @param b the data.
- * @param off the start offset in the data.
- * @param len the number of bytes to write.
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterOutputStream#out
- */
- public synchronized void write(byte b[], int off, int len) throws IOException {
- out.write(b, off, len);
- incCount(len);
- }
-
- /**
- * Flushes this data output stream. This forces any buffered output 
- * bytes to be written out to the stream. 
- * 
- * The <code>flush</code> method of <code>DataOuputStream</code> 
- * calls the <code>flush</code> method of its underlying output stream.
- *
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterOutputStream#out
- * @see java.io.OutputStream#flush()
- */
- public void flush() throws IOException {
-	out.flush();
- }
-
- /**
- * Writes a <code>boolean</code> to the underlying output stream as 
- * a 1-byte value. The value <code>true</code> is written out as the 
- * value <code>(byte)1</code>; the value <code>false</code> is 
- * written out as the value <code>(byte)0</code>. If no exception is 
- * thrown, the counter <code>written</code> is incremented by 
- * <code>1</code>.
- *
- * @param v a <code>boolean</code> value to be written.
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterOutputStream#out
- */
- public final void writeBoolean(boolean v) throws IOException {
- out.write(v ? 1 : 0);
- incCount(1);
- }
-
- /**
- * Writes out a <code>byte</code> to the underlying output stream as 
- * a 1-byte value. If no exception is thrown, the counter 
- * <code>written</code> is incremented by <code>1</code>.
- *
- * @param v a <code>byte</code> value to be written.
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterOutputStream#out
- */
- public final void writeByte(int v) throws IOException {
- out.write(v);
- incCount(1);
- }
-
- /**
- * Writes a <code>short</code> to the underlying output stream as two
- * bytes, high byte first. If no exception is thrown, the counter 
- * <code>written</code> is incremented by <code>2</code>.
- *
- * @param v a <code>short</code> to be written.
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterOutputStream#out
- */
- public final void writeShort(int v) throws IOException {
- OutputStream out = this.out;
- out.write((v >>> 8) & 0xFF);
- out.write((v >>> 0) & 0xFF);
- incCount(2);
- }
-
- /**
- * Writes a <code>char</code> to the underlying output stream as a 
- * 2-byte value, high byte first. If no exception is thrown, the 
- * counter <code>written</code> is incremented by <code>2</code>.
- *
- * @param v a <code>char</code> value to be written.
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterOutputStream#out
- */
- public final void writeChar(int v) throws IOException {
- OutputStream out = this.out;
- out.write((v >>> 8) & 0xFF);
- out.write((v >>> 0) & 0xFF);
- incCount(2);
- }
-
- /**
- * Writes an <code>int</code> to the underlying output stream as four
- * bytes, high byte first. If no exception is thrown, the counter 
- * <code>written</code> is incremented by <code>4</code>.
- *
- * @param v an <code>int</code> to be written.
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterOutputStream#out
- */
- public final void writeInt(int v) throws IOException {
- OutputStream out = this.out;
- //for(byte i=24;i>=0;i-=8)
- // out.write((int)(v >>> i) & 0xFF);
- out.write((v >>> 24) & 0xFF);
- out.write((v >>> 16) & 0xFF);
- out.write((v >>> 8) & 0xFF);
- out.write((v >>> 0) & 0xFF);
- incCount(4);
- }
-
- /**
- * Writes a <code>long</code> to the underlying output stream as eight
- * bytes, high byte first. In no exception is thrown, the counter 
- * <code>written</code> is incremented by <code>8</code>.
- *
- * @param v a <code>long</code> to be written.
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterOutputStream#out
- */
-/* public final void writeLong(long v) throws IOException {
- OutputStream out = this.out;
- out.write((int)(v >>> 56) & 0xFF);
- out.write((int)(v >>> 48) & 0xFF);
- out.write((int)(v >>> 40) & 0xFF);
- out.write((int)(v >>> 32) & 0xFF);
- out.write((int)(v >>> 24) & 0xFF);
- out.write((int)(v >>> 16) & 0xFF);
- out.write((int)(v >>> 8) & 0xFF);
- out.write((int)(v >>> 0) & 0xFF);
- //for(byte i=56;i>=0;i-=8)
- // out.write((int)(v >>> i) & 0xFF);
- incCount(8);
- }
-*/
- /**
- * Converts the float argument to an <code>int</code> using the 
- * <code>floatToIntBits</code> method in class <code>Float</code>, 
- * and then writes that <code>int</code> value to the underlying 
- * output stream as a 4-byte quantity, high byte first. If no 
- * exception is thrown, the counter <code>written</code> is 
- * incremented by <code>4</code>.
- *
- * @param v a <code>float</code> value to be written.
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterOutputStream#out
- * @see java.lang.Float#floatToIntBits(float)
- */
- public final void writeFloat(float v) throws IOException {
- writeInt(Float.floatToIntBits(v));
- }
-
- /**
- * Converts the double argument to a <code>long</code> using the 
- * <code>doubleToLongBits</code> method in class <code>Double</code>, 
- * and then writes that <code>long</code> value to the underlying 
- * output stream as an 8-byte quantity, high byte first. If no 
- * exception is thrown, the counter <code>written</code> is 
- * incremented by <code>8</code>.
- *
- * @param v a <code>double</code> value to be written.
- * @exception IOException if an I/O error occurs.
- * @see java.io.FilterOutputStream#out
- * @see java.lang.Double#doubleToLongBits(double)
- */
- //public final void writeDouble(double v) throws IOException {
- //writeLong(Double.doubleToLongBits(v));
- //}
-
- /**
- * Returns the current value of the counter <code>written</code>, 
- * the number of bytes written to this data output stream so far.
- * If the counter overflows, it will be wrapped to Integer.MAX_VALUE.
- *
- * @return the value of the <code>written</code> field.
- * @see java.io.DataOutputStream#written
- */
- public final int size() {
- return written;
- }
-}
diff -pruN lejos.orig/src/java/classes/java/io/InputStream.java lejos/src/java/classes/java/io/InputStream.java
--- lejos.orig/src/java/classes/java/io/InputStream.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/io/InputStream.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,351 +0,0 @@
-/*
- * @(#)InputStream.java	1.36 00/02/02
- *
- * Copyright 1994-2000 Sun Microsystems, Inc. All Rights Reserved.
- * 
- * This software is the proprietary information of Sun Microsystems, Inc. 
- * Use is subject to license terms.
- * 
- */
-
-package java.io;
-
-/**
- * This abstract class is the superclass of all classes representing
- * an input stream of bytes.
- *
- * Applications that need to define a subclass of <code>InputStream</code>
- * must always provide a method that returns the next byte of input.
- *
- * @author Arthur van Hoff
- * @version 1.36, 02/02/00
- * @see java.io.BufferedInputStream
- * @see java.io.ByteArrayInputStream
- * @see java.io.DataInputStream
- * @see java.io.FilterInputStream
- * @see java.io.InputStream#read()
- * @see java.io.OutputStream
- * @see java.io.PushbackInputStream
- * @since JDK1.0
- */
-public abstract class InputStream {
-
- // SKIP_BUFFER_SIZE is used to determine the size of skipBuffer
-// private static final int SKIP_BUFFER_SIZE = 2048;
- private static final int SKIP_BUFFER_SIZE = 32;
- // skipBuffer is initialized in skip(long), if needed.
- private static byte[] skipBuffer;
-
- /**
- * Reads the next byte of data from the input stream. The value byte is
- * returned as an <code>int</code> in the range <code>0</code> to
- * <code>255</code>. If no byte is available because the end of the stream
- * has been reached, the value <code>-1</code> is returned. This method
- * blocks until input data is available, the end of the stream is detected,
- * or an exception is thrown.
- *
- * A subclass must provide an implementation of this method.
- *
- * @return the next byte of data, or <code>-1</code> if the end of the
- * stream is reached.
- * @exception IOException if an I/O error occurs.
- */
- public abstract int read() throws IOException;
-
- /**
- * Reads some number of bytes from the input stream and stores them into
- * the buffer array <code>b</code>. The number of bytes actually read is
- * returned as an integer. This method blocks until input data is
- * available, end of file is detected, or an exception is thrown.
- *
- * If <code>b</code> is <code>null</code>, a
- * <code>NullPointerException</code> is thrown. If the length of
- * <code>b</code> is zero, then no bytes are read and <code>0</code> is
- * returned; otherwise, there is an attempt to read at least one byte. If
- * no byte is available because the stream is at end of file, the value
- * <code>-1</code> is returned; otherwise, at least one byte is read and
- * stored into <code>b</code>.
- *
- * The first byte read is stored into element <code>b[0]</code>, the
- * next one into <code>b[1]</code>, and so on. The number of bytes read is,
- * at most, equal to the length of <code>b</code>. Let k be the
- * number of bytes actually read; these bytes will be stored in elements
- * <code>b[0]</code> through <code>b[</code>k<code>-1]</code>,
- * leaving elements <code>b[</code>k<code>]</code> through
- * <code>b[b.length-1]</code> unaffected.
- *
- * If the first byte cannot be read for any reason other than end of
- * file, then an <code>IOException</code> is thrown. In particular, an
- * <code>IOException</code> is thrown if the input stream has been closed.
- *
- * The <code>read(b)</code> method for class <code>InputStream</code>
- * has the same effect as: <pre><code> read(b, 0, b.length) </code></pre>
- *
- * @param b the buffer into which the data is read.
- * @return the total number of bytes read into the buffer, or
- * <code>-1</code> is there is no more data because the end of
- * the stream has been reached.
- * @exception IOException if an I/O error occurs.
- * @see java.io.InputStream#read(byte[], int, int)
- */
- public int read(byte b[]) throws IOException {
-	return read(b, 0, b.length);
- }
-
- /**
- * Reads up to <code>len</code> bytes of data from the input stream into
- * an array of bytes. An attempt is made to read as many as
- * <code>len</code> bytes, but a smaller number may be read, possibly
- * zero. The number of bytes actually read is returned as an integer.
- *
- * This method blocks until input data is available, end of file is
- * detected, or an exception is thrown.
- *
- * If <code>b</code> is <code>null</code>, a
- * <code>NullPointerException</code> is thrown.
- *
- * If <code>off</code> is negative, or <code>len</code> is negative, or
- * <code>off+len</code> is greater than the length of the array
- * <code>b</code>, then an <code>IndexOutOfBoundsException</code> is
- * thrown.
- *
- * If <code>len</code> is zero, then no bytes are read and
- * <code>0</code> is returned; otherwise, there is an attempt to read at
- * least one byte. If no byte is available because the stream is at end of
- * file, the value <code>-1</code> is returned; otherwise, at least one
- * byte is read and stored into <code>b</code>.
- *
- * The first byte read is stored into element <code>b[off]</code>, the
- * next one into <code>b[off+1]</code>, and so on. The number of bytes read
- * is, at most, equal to <code>len</code>. Let k be the number of
- * bytes actually read; these bytes will be stored in elements
- * <code>b[off]</code> through <code>b[off+</code>k<code>-1]</code>,
- * leaving elements <code>b[off+</code>k<code>]</code> through
- * <code>b[off+len-1]</code> unaffected.
- *
- * In every case, elements <code>b[0]</code> through
- * <code>b[off]</code> and elements <code>b[off+len]</code> through
- * <code>b[b.length-1]</code> are unaffected.
- *
- * If the first byte cannot be read for any reason other than end of
- * file, then an <code>IOException</code> is thrown. In particular, an
- * <code>IOException</code> is thrown if the input stream has been closed.
- *
- * The <code>read(b,</code> <code>off,</code> <code>len)</code> method
- * for class <code>InputStream</code> simply calls the method
- * <code>read()</code> repeatedly. If the first such call results in an
- * <code>IOException</code>, that exception is returned from the call to
- * the <code>read(b,</code> <code>off,</code> <code>len)</code> method. If
- * any subsequent call to <code>read()</code> results in a
- * <code>IOException</code>, the exception is caught and treated as if it
- * were end of file; the bytes read up to that point are stored into
- * <code>b</code> and the number of bytes read before the exception
- * occurred is returned. Subclasses are encouraged to provide a more
- * efficient implementation of this method.
- *
- * @param b the buffer into which the data is read.
- * @param off the start offset in array <code>b</code>
- * at which the data is written.
- * @param len the maximum number of bytes to read.
- * @return the total number of bytes read into the buffer, or
- * <code>-1</code> if there is no more data because the end of
- * the stream has been reached.
- * @exception IOException if an I/O error occurs.
- * @see java.io.InputStream#read()
- */
- public int read(byte b[], int off, int len) throws IOException {
-	if (b == null) {
-	 throw new NullPointerException();
-	} else if ((off < 0) || (off > b.length) || (len < 0) ||
-		 ((off + len) > b.length) || ((off + len) < 0)) {
-	 throw new RuntimeException();
-	} else if (len == 0) {
-	 return 0;
-	}
-
-	int c = read();
-	if (c == -1) {
-	 return -1;
-	}
-	b[off] = (byte)c;
-
-	int i = 1;
-	try {
-	 for (; i < len ; i++) {
-		c = read();
-		if (c == -1) {
-		 break;
-		}
-		if (b != null) {
-		 b[off + i] = (byte)c;
-		}
-	 }
-	} catch (IOException ee) {
-	}
-	return i;
- }
-
- /**
- * Skips over and discards <code>n</code> bytes of data from this input
- * stream. The <code>skip</code> method may, for a variety of reasons, end
- * up skipping over some smaller number of bytes, possibly <code>0</code>.
- * This may result from any of a number of conditions; reaching end of file
- * before <code>n</code> bytes have been skipped is only one possibility.
- * The actual number of bytes skipped is returned. If <code>n</code> is
- * negative, no bytes are skipped.
- *
- * The <code>skip</code> method of <code>InputStream</code> creates a
- * byte array and then repeatedly reads into it until <code>n</code> bytes
- * have been read or the end of the stream has been reached. Subclasses are
- * encouraged to provide a more efficient implementation of this method.
- *
- * @param n the number of bytes to be skipped.
- * @return the actual number of bytes skipped.
- * @exception IOException if an I/O error occurs.
- */
-
- public long skip(long n) throws IOException {
-/*
-	long remaining = n;
-	int nr;
-	if (skipBuffer == null)
-	 skipBuffer = new byte[SKIP_BUFFER_SIZE];
-
-	byte[] localSkipBuffer = skipBuffer;
-		
-	if (n <= 0) {
-	 return 0;
-	}
-
-	while (remaining > 0) {
-	 nr = read(localSkipBuffer, 0,
-		 (int) Math.min(SKIP_BUFFER_SIZE, remaining));
-	 if (nr < 0) {
-		break;
-	 }
-	 remaining -= nr;
-	}
-	*/
-	return n;
- }
-
- /**
- * Returns the number of bytes that can be read (or skipped over) from
- * this input stream without blocking by the next caller of a method for
- * this input stream. The next caller might be the same thread or or
- * another thread.
- *
- * The <code>available</code> method for class <code>InputStream</code>
- * always returns <code>0</code>.
- *
- * This method should be overridden by subclasses.
- *
- * @return the number of bytes that can be read from this input stream
- * without blocking.
- * @exception IOException if an I/O error occurs.
- */
- public int available() throws IOException {
-	return 0;
- }
-
- /**
- * Closes this input stream and releases any system resources associated
- * with the stream.
- *
- * The <code>close</code> method of <code>InputStream</code> does
- * nothing.
- *
- * @exception IOException if an I/O error occurs.
- */
- public void close() throws IOException {}
-
- /**
- * Marks the current position in this input stream. A subsequent call to
- * the <code>reset</code> method repositions this stream at the last marked
- * position so that subsequent reads re-read the same bytes.
- *
- * The <code>readlimit</code> arguments tells this input stream to
- * allow that many bytes to be read before the mark position gets
- * invalidated.
- *
- * The general contract of <code>mark</code> is that, if the method
- * <code>markSupported</code> returns <code>true</code>, the stream somehow
- * remembers all the bytes read after the call to <code>mark</code> and
- * stands ready to supply those same bytes again if and whenever the method
- * <code>reset</code> is called. However, the stream is not required to
- * remember any data at all if more than <code>readlimit</code> bytes are
- * read from the stream before <code>reset</code> is called.
- *
- * The <code>mark</code> method of <code>InputStream</code> does
- * nothing.
- *
- * @param readlimit the maximum limit of bytes that can be read before
- * the mark position becomes invalid.
- * @see java.io.InputStream#reset()
- */
- public synchronized void mark(int readlimit) {}
-
- /**
- * Repositions this stream to the position at the time the
- * <code>mark</code> method was last called on this input stream.
- *
- * The general contract of <code>reset</code> is:
- *
- * <ul>
- *
- * <li> If the method <code>markSupported</code> returns
- * <code>true</code>, then:
- *
- * <ul><li> If the method <code>mark</code> has not been called since
- * the stream was created, or the number of bytes read from the stream
- * since <code>mark</code> was last called is larger than the argument
- * to <code>mark</code> at that last call, then an
- * <code>IOException</code> might be thrown.
- *
- * <li> If such an <code>IOException</code> is not thrown, then the
- * stream is reset to a state such that all the bytes read since the
- * most recent call to <code>mark</code> (or since the start of the
- * file, if <code>mark</code> has not been called) will be resupplied
- * to subsequent callers of the <code>read</code> method, followed by
- * any bytes that otherwise would have been the next input data as of
- * the time of the call to <code>reset</code>. </ul>
- *
- * <li> If the method <code>markSupported</code> returns
- * <code>false</code>, then:
- *
- * <ul><li> The call to <code>reset</code> may throw an
- * <code>IOException</code>.
- *
- * <li> If an <code>IOException</code> is not thrown, then the stream
- * is reset to a fixed state that depends on the particular type of the
- * input stream and how it was created. The bytes that will be supplied
- * to subsequent callers of the <code>read</code> method depend on the
- * particular type of the input stream. </ul></ul>
- *
- * The method <code>reset</code> for class <code>InputStream</code>
- * does nothing and always throws an <code>IOException</code>.
- *
- * @exception IOException if this stream has not been marked or if the
- * mark has been invalidated.
- * @see java.io.InputStream#mark(int)
- * @see java.io.IOException
- */
- public synchronized void reset() throws IOException {
-	throw new IOException("mark/reset not supported");
- }
-
- /**
- * Tests if this input stream supports the <code>mark</code> and
- * <code>reset</code> methods. The <code>markSupported</code> method of
- * <code>InputStream</code> returns <code>false</code>.
- *
- * @return <code>true</code> if this true type supports the mark and reset
- * method; <code>false</code> otherwise.
- * @see java.io.InputStream#mark(int)
- * @see java.io.InputStream#reset()
- */
- public boolean markSupported() {
-	return false;
- }
-
-}
diff -pruN lejos.orig/src/java/classes/java/io/IOException.java lejos/src/java/classes/java/io/IOException.java
--- lejos.orig/src/java/classes/java/io/IOException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/io/IOException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,46 +0,0 @@
-/*
- * @(#)IOException.java	1.19 00/02/02
- *
- * Copyright 1994-2000 Sun Microsystems, Inc. All Rights Reserved.
- * 
- * This software is the proprietary information of Sun Microsystems, Inc. 
- * Use is subject to license terms.
- * 
- */
-
-package java.io;
-
-/**
- * Signals that an I/O exception of some sort has occurred. This
- * class is the general class of exceptions produced by failed or
- * interrupted I/O operations.
- *
- * @author unascribed
- * @version 1.19, 02/02/00
- * @see java.io.InputStream
- * @see java.io.OutputStream
- * @since JDK1.0
- */
-public
-class IOException extends Exception {
- /**
- * Constructs an <code>IOException</code> with <code>null</code>
- * as its error detail message.
- */
- public IOException() {
-	super();
- }
-
- /**
- * Constructs an <code>IOException</code> with the specified detail
- * message. The error message string <code>s</code> can later be
- * retrieved by the <code>{@link java.lang.Throwable#getMessage}</code>
- * method of class <code>java.lang.Throwable</code>.
- *
- * @param s the detail message.
- */
-
- public IOException(String s) {
-	super();
- }
-}
diff -pruN lejos.orig/src/java/classes/java/io/OutputStream.java lejos/src/java/classes/java/io/OutputStream.java
--- lejos.orig/src/java/classes/java/io/OutputStream.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/io/OutputStream.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,134 +0,0 @@
-/*
- * @(#)OutputStream.java	1.23 00/02/02
- *
- * Copyright 1994-2000 Sun Microsystems, Inc. All Rights Reserved.
- * 
- * This software is the proprietary information of Sun Microsystems, Inc. 
- * Use is subject to license terms.
- * 
- */
-
-package java.io;
-
-/**
- * This abstract class is the superclass of all classes representing 
- * an output stream of bytes. An output stream accepts output bytes 
- * and sends them to some sink.
- * 
- * Applications that need to define a subclass of 
- * <code>OutputStream</code> must always provide at least a method 
- * that writes one byte of output. 
- *
- * @author Arthur van Hoff
- * @version 1.23, 02/02/00
- * @see java.io.BufferedOutputStream
- * @see java.io.ByteArrayOutputStream
- * @see java.io.DataOutputStream
- * @see java.io.FilterOutputStream
- * @see java.io.InputStream
- * @see java.io.OutputStream#write(int)
- * @since JDK1.0
- */
-public abstract class OutputStream {
- /**
- * Writes the specified byte to this output stream. The general 
- * contract for <code>write</code> is that one byte is written 
- * to the output stream. The byte to be written is the eight 
- * low-order bits of the argument <code>b</code>. The 24 
- * high-order bits of <code>b</code> are ignored.
- * 
- * Subclasses of <code>OutputStream</code> must provide an 
- * implementation for this method. 
- *
- * @param b the <code>byte</code>.
- * @exception IOException if an I/O error occurs. In particular, 
- * an <code>IOException</code> may be thrown if the 
- * output stream has been closed.
- */
- public abstract void write(int b) throws IOException;
-
- /**
- * Writes <code>b.length</code> bytes from the specified byte array 
- * to this output stream. The general contract for <code>write(b)</code> 
- * is that it should have exactly the same effect as the call 
- * <code>write(b, 0, b.length)</code>.
- *
- * @param b the data.
- * @exception IOException if an I/O error occurs.
- * @see java.io.OutputStream#write(byte[], int, int)
- */
- public void write(byte b[]) throws IOException {
-	write(b, 0, b.length);
- }
-
- /**
- * Writes <code>len</code> bytes from the specified byte array 
- * starting at offset <code>off</code> to this output stream. 
- * The general contract for <code>write(b, off, len)</code> is that 
- * some of the bytes in the array <code>b</code> are written to the 
- * output stream in order; element <code>b[off]</code> is the first 
- * byte written and <code>b[off+len-1]</code> is the last byte written 
- * by this operation.
- * 
- * The <code>write</code> method of <code>OutputStream</code> calls 
- * the write method of one argument on each of the bytes to be 
- * written out. Subclasses are encouraged to override this method and 
- * provide a more efficient implementation. 
- * 
- * If <code>b</code> is <code>null</code>, a 
- * <code>NullPointerException</code> is thrown.
- * 
- * If <code>off</code> is negative, or <code>len</code> is negative, or 
- * <code>off+len</code> is greater than the length of the array 
- * <code>b</code>, then an <tt>IndexOutOfBoundsException</tt> is thrown.
- *
- * @param b the data.
- * @param off the start offset in the data.
- * @param len the number of bytes to write.
- * @exception IOException if an I/O error occurs. In particular, 
- * an <code>IOException</code> is thrown if the output 
- * stream is closed.
- */
- public void write(byte b[], int off, int len) throws IOException {
-	if (b == null) {
-	 throw new NullPointerException();
-	} else if ((off < 0) || (off > b.length) || (len < 0) ||
-		 ((off + len) > b.length) || ((off + len) < 0)) {
-	 throw new RuntimeException();
-	} else if (len == 0) {
-	 return;
-	}
-	for (int i = 0 ; i < len ; i++) {
-	 write(b[off + i]);
-	}
- }
-
- /**
- * Flushes this output stream and forces any buffered output bytes 
- * to be written out. The general contract of <code>flush</code> is 
- * that calling it is an indication that, if any bytes previously 
- * written have been buffered by the implementation of the output 
- * stream, such bytes should immediately be written to their 
- * intended destination.
- * 
- * The <code>flush</code> method of <code>OutputStream</code> does nothing.
- *
- * @exception IOException if an I/O error occurs.
- */
- public void flush() throws IOException {
- }
-
- /**
- * Closes this output stream and releases any system resources 
- * associated with this stream. The general contract of <code>close</code> 
- * is that it closes the output stream. A closed stream cannot perform 
- * output operations and cannot be reopened.
- * 
- * The <code>close</code> method of <code>OutputStream</code> does nothing.
- *
- * @exception IOException if an I/O error occurs.
- */
- public void close() throws IOException {
- }
-
-}
diff -pruN lejos.orig/src/java/classes/java/io/Serializable.java lejos/src/java/classes/java/io/Serializable.java
--- lejos.orig/src/java/classes/java/io/Serializable.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/io/Serializable.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,10 +0,0 @@
-package java.io;
-
-/**
- * This interface is not functional. It's here
- * to satisfy jikes.
- */
-public interface Serializable
-{
-
-}
diff -pruN lejos.orig/src/java/classes/java/lang/ArithmeticException.java lejos/src/java/classes/java/lang/ArithmeticException.java
--- lejos.orig/src/java/classes/java/lang/ArithmeticException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/ArithmeticException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class ArithmeticException extends Exception
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/ArrayIndexOutOfBoundsException.java lejos/src/java/classes/java/lang/ArrayIndexOutOfBoundsException.java
--- lejos.orig/src/java/classes/java/lang/ArrayIndexOutOfBoundsException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/ArrayIndexOutOfBoundsException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class ArrayIndexOutOfBoundsException extends RuntimeException
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/ClassCastException.java lejos/src/java/classes/java/lang/ClassCastException.java
--- lejos.orig/src/java/classes/java/lang/ClassCastException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/ClassCastException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class ClassCastException extends RuntimeException
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/Class.java lejos/src/java/classes/java/lang/Class.java
--- lejos.orig/src/java/classes/java/lang/Class.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/Class.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,16 +0,0 @@
-package java.lang;
-
-/**
- * Not functional. It's here to satisfy javac and jikes.
- */
-public class Class
-{
- /**
- * @exception java.lang.ClassNotFoundException Thrown always in TinyVM.
- */
- public static Class forName (String aName)
- throws ClassNotFoundException
- {
- throw new ClassNotFoundException();
- }
-}
diff -pruN lejos.orig/src/java/classes/java/lang/ClassNotFoundException.java lejos/src/java/classes/java/lang/ClassNotFoundException.java
--- lejos.orig/src/java/classes/java/lang/ClassNotFoundException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/ClassNotFoundException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class ClassNotFoundException extends Exception
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/Cloneable.java lejos/src/java/classes/java/lang/Cloneable.java
--- lejos.orig/src/java/classes/java/lang/Cloneable.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/Cloneable.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,10 +0,0 @@
-package java.lang;
-
-/**
- * This interface is not functional. It's here
- * to satisfy jikes.
- */
-public interface Cloneable
-{
-
-}
diff -pruN lejos.orig/src/java/classes/java/lang/Error.java lejos/src/java/classes/java/lang/Error.java
--- lejos.orig/src/java/classes/java/lang/Error.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/Error.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,9 +0,0 @@
-package java.lang;
-
-public class Error extends Throwable
-{
-}
-
-
-
-
diff -pruN lejos.orig/src/java/classes/java/lang/Exception.java lejos/src/java/classes/java/lang/Exception.java
--- lejos.orig/src/java/classes/java/lang/Exception.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/Exception.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,12 +0,0 @@
-package java.lang;
-
-public class Exception extends Throwable
-{
-	public Exception() {
-		super();
-	}
-	
-	public Exception(String message) {
-		super(message);
-	}
-}
diff -pruN lejos.orig/src/java/classes/java/lang/Float.java lejos/src/java/classes/java/lang/Float.java
--- lejos.orig/src/java/classes/java/lang/Float.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/Float.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,85 +0,0 @@
-package java.lang;
-
-/**
- * Minimal Float implementation that supports 
- * floatToIntBits and intBitsToFloat
- *
- * @author Lawrie Griffiths
- */
- public final class Float {
-
- private Float() {
- }
- 
- /**
- * Returns the bit represention of a single-float value.
- * The result is a representation of the floating-point argument 
- * according to the IEEE 754 floating-point "single 
- * precision" bit layout. 
- * <ul>
- * <li>Bit 31 (the bit that is selected by the mask 
- * <code>0x80000000</code>) represents the sign of the floating-point 
- * number. 
- * <li>Bits 30-23 (the bits that are selected by the mask 
- * <code>0x7f800000</code>) represent the exponent. 
- * <li>Bits 22-0 (the bits that are selected by the mask 
- * <code>0x007fffff</code>) represent the significand (sometimes called 
- * the mantissa) of the floating-point number. 
- * <li>If the argument is positive infinity, the result is 
- * <code>0x7f800000</code>. 
- * <li>If the argument is negative infinity, the result is 
- * <code>0xff800000</code>.
- * 
- * If the argument is NaN, the result is the integer
- * representing the actual NaN value. The lejos implementation 
- * behaves like floatToRawIntBits and does not collapse NaN values.
- * </ul>
- * In all cases, the result is an integer that, when given to the 
- * {@link #intBitsToFloat(int)} method, will produce a floating-point 
- * value equal to the argument to <code>floatToRawIntBits</code>.
- * 
- * @param value a floating-point number.
- * @return the bits that represent the floating-point number.
- */
- public static native int floatToIntBits(float value);
-
- /**
- * Returns the single-float corresponding to a given bit represention.
- * The argument is considered to be a representation of a
- * floating-point value according to the IEEE 754 floating-point
- * "single precision" bit layout.
- * 
- * If the argument is <code>0x7f800000</code>, the result is positive
- * infinity.
- * 
- * If the argument is <code>0xff800000</code>, the result is negative
- * infinity.
- * 
- * If the argument is any value in the range <code>0x7f800001</code> 
- * through <code>0x7fffffff</code> or in the range 
- * <code>0xff800001</code> through <code>0xffffffff</code>, the result is 
- * NaN. All IEEE 754 NaN values of type <code>float</code> are, in effect,
- * lumped together by the Java programming language into a single 
- * <code>float</code> value called NaN. Distinct values of NaN are only
- * accessible by use of the <code>Float.floatToRawIntBits</code> method.
- * 
- * In all other cases, let s, e, and m be three 
- * values that can be computed from the argument: 
- * <blockquote><pre>
- * int s = ((bits >> 31) == 0) ? 1 : -1;
- * int e = ((bits >> 23) & 0xff);
- * int m = (e == 0) ?
- * (bits & 0x7fffff) << 1 :
- * (bits & 0x7fffff) | 0x800000;
- * </pre></blockquote>
- * Then the floating-point result equals the value of the mathematical 
- * expression s&#183;m&#183;2e-150.
- *
- * @param value an integer.
- * @return the single-format floating-point value with the same bit
- * pattern.
- */
- public static native float intBitsToFloat(int value);
-}
-
- 
diff -pruN lejos.orig/src/java/classes/java/lang/IllegalArgumentException.java lejos/src/java/classes/java/lang/IllegalArgumentException.java
--- lejos.orig/src/java/classes/java/lang/IllegalArgumentException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/IllegalArgumentException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class IllegalArgumentException extends RuntimeException
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/IllegalMonitorStateException.java lejos/src/java/classes/java/lang/IllegalMonitorStateException.java
--- lejos.orig/src/java/classes/java/lang/IllegalMonitorStateException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/IllegalMonitorStateException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,4 +0,0 @@
-package java.lang;
-
-public class IllegalMonitorStateException extends RuntimeException {
-}
diff -pruN lejos.orig/src/java/classes/java/lang/IllegalStateException.java lejos/src/java/classes/java/lang/IllegalStateException.java
--- lejos.orig/src/java/classes/java/lang/IllegalStateException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/IllegalStateException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class IllegalStateException extends RuntimeException
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/Integer.java lejos/src/java/classes/java/lang/Integer.java
--- lejos.orig/src/java/classes/java/lang/Integer.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/Integer.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,88 +0,0 @@
-package java.lang;
-
-/**
- * Minimal Integer implementation that supports converting an int to a String.
- *
- */
-
- public final class Integer {
- /**
- * The smallest value of type <code>int</code>. The constant 
- * value of this field is <tt>-2147483648</tt>.
- */
- public static final int MIN_VALUE = 0x80000000;
-
- /**
- * The largest value of type <code>int</code>. The constant 
- * value of this field is <tt>2147483647</tt>.
- */
- public static final int MAX_VALUE = 0x7fffffff;
-
- /**
- * The value of the Integer.
- *
- * @serial
- */
- private int value;
-
- /**
- * Constructs a newly allocated <code>Integer</code> object that
- * represents the primitive <code>int</code> argument.
- *
- * @param value the value to be represented by the <code>Integer</code>.
- */
- public Integer(int value) {
-	this.value = value;
- }
-
- static char buf [] = new char [12] ; 
-
- /**
- * Returns a new String object representing the specified integer. The 
- * argument is converted to signed decimal representation and returned 
- * as a string, exactly as if the argument and radix <tt>10</tt> were 
- * given as arguments to the toString(int, int) method.
- *
- * @param i an integer to be converted.
- * @return a string representation of the argument in base&nbsp;10.
- */
- public static synchronized String toString(int i) {
- int q, r, charPos = 12; 
- char sign = 0 ; 
-
- if (i == Integer.MIN_VALUE) return "-2147483648";
-
- if (i < 0) { 
- sign = '-' ; 
- i = -i ; 
- }
-
- for (;;) { 
- q = i/10; ; 
- r = i-(q*10) ;
- buf [--charPos] = (char) ((int) '0' + r) ; 
- i = q ; 
- if (i == 0) break ; 
- }
-
- if (sign != 0) {
- buf [--charPos] = sign ; 
- }
-
- return new String ( buf, charPos, 12 - charPos) ; 
- }
-
- /**
- * Returns a String object representing this Integer's value. The 
- * value is converted to signed decimal representation and returned 
- * as a string.
- *
- * @return a string representation of the value of this object in
- * base&nbsp;10.
- */
- public String toString() {
-	return toString(value);
- }
-}
-
- 
diff -pruN lejos.orig/src/java/classes/java/lang/InterruptedException.java lejos/src/java/classes/java/lang/InterruptedException.java
--- lejos.orig/src/java/classes/java/lang/InterruptedException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/InterruptedException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class InterruptedException extends Exception
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/Math.java lejos/src/java/classes/java/lang/Math.java
--- lejos.orig/src/java/classes/java/lang/Math.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/Math.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,323 +0,0 @@
-package java.lang;
-
-/**
- * Mathematical functions.
- *
- * @author <a href="mailto:bbagnall@escape.ca">Brian Bagnall</a>
- */
-public final class Math {
-		
-	// Math constants
-	public static final double E = 2.718281828459045;
-	public static final double PI = 3.141592653589793;
- public static final double NaN = 0.0f / 0.0f;
- 
- static final float PI2 = 1.570796326794897f;
-	static final double ln10 = 2.30258509299405;
-	static final double ln2 = 0.69314718055995;
-	
- // Used by log() and exp() methods
-	private static final float LOWER_BOUND = 0.9999999f;
-	private static final float UPPER_BOUND = 1.0f;
-
-	// Used to generate random numbers.
-	private static java.util.Random RAND = new java.util.Random(System.currentTimeMillis());
-
-	//public static boolean isNaN (double d) {
-	// return d != d;
-	//}
-	
-	private Math() {} // To make sure this class is not instantiated
-
- // Private because it only works when -1 < x < 1 but it is used by atan2
- private static double ArcTan(double x) // Using a Chebyshev-Pade approximation
- {
- double x2=x*x;
- return (0.7162721433f+0.2996857769f*x2)*x/(0.7163164576f+(0.5377299313f+0.3951620469e-1f*x2)*x2);
- }
-
-
-	/**
-	* Returns the smallest (closest to negative infinity) double value that is not
-	* less than the argument and is equal to a mathematical integer.
- 	*/
-	public static double ceil(double a) {
-		return ((a<0)?(int)a:(int)(a+1));	
-	}
-	
-	/**
-	* Returns the largest (closest to positive infinity) double value that is not
-	* greater than the argument and is equal to a mathematical integer.
-	*/
-	public static double floor(double a) {	
-		return ((a<0)?(int)(a-1):(int)a);	
-	}
-	
-	/**
-	* Returns the closest int to the argument.
-	*/	
-	public static int round(float a) {	
-		return (int)floor(a + 0.5f);
-	}
-	
-	/**
-	* Returns the lesser of two integer values.
-	*/
-	public static int min(int a, int b) {	
-		return ((a<b)?a:b);
-	}
-	
-	/**
-	*Returns the lesser of two double values.
-	*/
-	public static double min(double a, double b) {	
-		return ((a<b)?a:b);
-	}
-	
-	/**
-	*Returns the greater of two integer values.
-	*/
-	public static int max(int a, int b) {	
-		return ((a>b)?a:b);
-	}
-	
-	/**
-	*Returns the greater of two double values.
-	*/
-	public static double max(double a, double b) {	
-		return ((a>b)?a:b);
-	}
-	
-	/**
-	* Random number generator.
-	* Returns a double greater than 0.0 and less than 1.0
-	*/
-	public static double random()
- {
- final int MAX_INT = 2147483647;
- int n = MAX_INT;
- 
- // Just to ensure it does not return 1.0
- while(n == MAX_INT)
- 	n = abs (RAND.nextInt());
- 
- return n * (1.0 / MAX_INT);
- }
-	
-	/**
-	* Exponential function. Returns E^x (where E is the base of natural logarithms).
-	* Thanks to David Edwards of England for conceiving the code and Martin E. Nielsen
-	* for modifying it to handle large arguments.
- * = sum a^n/n!, i.e. 1 + x + x^2/2! + x^3/3!
- * 
- * Seems to work better for +ve numbers so force argument to be +ve.
-	*/	
-	public static double exp(double a)
-	{
-	 boolean neg = a < 0 ? true : false;
-	 if (a < 0)
- a = -a;
- int fac = 1;
- 	 double term = a;
- 	 double sum = 0;
- 	 double oldsum = 0;
- 	 double end;
-
- 	 do {
- 	 oldsum = sum;
- 	 sum += term;
- 
- 	 fac++;
- 
- 	 term *= a/fac;
-	 end = sum/oldsum;
- 	 } while (end < LOWER_BOUND || end > UPPER_BOUND);
-
- sum += 1.0f;
- 
-	 return neg ? 1.0f/sum : sum;
-	}
-	
-	/**
-	* Natural log function. Returns log(a) to base E
-	* Replaced with an algorithm that does not use exponents and so
-	* works with large arguments.
-	* @see <a href="http://www.geocities.com/zabrodskyvlada/aat/a_contents.html">here</a>
-	*/
-	public static double log(double x)
-	{
-	 if (x < 1.0)
-	 return -log(1.0/x);
-	 
-	 double m=0.0;
-	 double p=1.0;
-	 while (p <= x) {
-	 m++;
-	 p=p*2;
-	 }
-	 
-	 m = m - 1;
-	 double z = x/(p/2);
-	 
-	 double zeta = (1.0 - z)/(1.0 + z);
-	 double n=zeta;
-	 double ln=zeta;
-	 double zetasup = zeta * zeta;
-	 
-	 for (int j=1; true; j++)
-	 {
-	 n = n * zetasup;
-	 double newln = ln + n / (2 * j + 1);
-	 double term = ln/newln;
-	 if (term >= LOWER_BOUND && term <= UPPER_BOUND)
-	 return m * ln2 - 2 * ln;
-	 ln = newln;
-	 }
-	}
-
-	/**
-	* Power function. This is a slow but accurate method.
-	* Thanks to David Edwards of England for conceiving the code.
-	*/
-	public static double pow(double a, double b) {
-		return exp(b * log(a));
-	}
-	
-	/**
-	* Returns the absolute value of a double value. If the argument is not negative, the argument is
- * returned. If the argument is negative, the negation of the argument is returned.
-	*/
-	public static double abs(double a) {
-		return ((a<0)?-a:a);
-	}
-
-	/**
-	* Returns the absolute value of an integer value. If the argument is not negative, the argument is
- * returned. If the argument is negative, the negation of the argument is returned.
-	*/
-	public static int abs(int a) {
-		return ((a<0)?-a:a);
-	}
-	
- /**
- * Sine function using a Chebyshev-Pade approximation. Thanks to Paulo Costa for donating the code.
- */
- public static double sin(double x) // Using a Chebyshev-Pade approximation
- {
- int n=(int)(x/PI2)+1; // reduce to the 4th and 1st quadrants
- if(n<1)n=n-1;
- if ((n&2)==0) x=x-(n&0xFFFFFFFE)*PI2; // if it from the 2nd or the 3rd quadrants
- else x=-(x-(n&0xFFFFFFFE)*PI2);
-
- double x2=x*x;
- return (0.9238318854f-0.9595498071e-1f*x2)*x/(0.9238400690f+(0.5797298195e-1f+0.2031791179e-2f*x2)*x2);
- }
-
- /**
- * Cosine function using a Chebyshev-Pade approximation. Thanks to Paulo Costa for donating the code.
- */
- public static double cos(double x)
- {
- int n=(int)(x/PI2)+1;
- if(n<1)n=n-1;
- x=x-(n&0xFFFFFFFE)*PI2; // reduce to the 4th and 1st quadrants
-
- double x2=x*x;
-
- float si=1f;
- if ((n&2)!=0) si=-1f; // if it from the 2nd or the 3rd quadrants
- return si*(0.9457092528f+(-0.4305320537f+0.1914993010e-1f*x2)*x2)/(0.9457093212f+(0.4232119630e-1f+0.9106317690e-3f*x2)*x2);
- }
-
- /**
- * Square root - thanks to Paulo Costa for donating the code.
- */
- public static double sqrt(double x)
- {
- double root = x, guess=0;
-
- if(x<0) return NaN;
-
- // the accuarcy test is percentual
- for(int i=0; (i<16) && ((guess > x*(1+5e-7f)) || (guess < x*(1-5e-7f))); i++)
- {
- root = (root+x/root)*0.5f; // a multiplication is faster than a division
- guess=root*root; // cache the square to the test
- }
- return root;
- }
-	
- /**
- * Tangent function.
- */
- public static double tan(double a) {
- return sin(a)/cos(a);
- }
-		
- /**
- * Arc tangent function. Thanks to Paulo Costa for donating the code.
- */
- public static double atan(double x)
- {
- return atan2(x,1);
- }
-
- /**
- * Arc tangent function valid to the four quadrants
- * y and x can have any value without sigificant precision loss
- * atan2(0,0) returns 0. Thanks to Paulo Costa for donating the code.
- */
- public static double atan2(double y, double x)
- {
- float ax=(float)abs(x);
- float ay=(float)abs(y);
-
- if ((ax<1e-7) && (ay<1e-7)) return 0f;
-
- if (ax>ay)
- {
- if (x<0)
- {
- if (y>=0) return ArcTan(y/x)+PI;
- else return ArcTan(y/x)-PI;
- }
- else return ArcTan(y/x);
- }
- else
- {
- if (y<0) return ArcTan(-x/y)-PI/2;
- else return ArcTan(-x/y)+PI/2;
- }
- }
-
- /**
- * Arc cosine function.
- */
- public static double acos(double a) {
- if ((a<-1)||(a>1)) {
- return Double.NaN;
- }
- return PI/2 - atan(a/sqrt(1 - a * a));
- }
-	
- /**
- * Arc sine function.
- */
- public static double asin(double a) {
- return atan(a/sqrt(1-a*a));
- }
-	
- /**
- * Converts radians to degrees.
- */
- public static double toDegrees(double angrad) {
- return angrad * (360.0 / (2 * PI));
- }
-	
- /**
- * Converts degrees to radians.
- */
- public static double toRadians(double angdeg) {
- return angdeg * ((2 * PI) / 360.0);
- }
-}
diff -pruN lejos.orig/src/java/classes/java/lang/NoClassDefFoundError.java lejos/src/java/classes/java/lang/NoClassDefFoundError.java
--- lejos.orig/src/java/classes/java/lang/NoClassDefFoundError.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/NoClassDefFoundError.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,8 +0,0 @@
-package java.lang;
-
-public class NoClassDefFoundError extends Error
-{
- public NoClassDefFoundError (String aMessage)
- {
- }
-}
diff -pruN lejos.orig/src/java/classes/java/lang/NoSuchMethodError.java lejos/src/java/classes/java/lang/NoSuchMethodError.java
--- lejos.orig/src/java/classes/java/lang/NoSuchMethodError.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/NoSuchMethodError.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class NoSuchMethodError extends Error
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/NullPointerException.java lejos/src/java/classes/java/lang/NullPointerException.java
--- lejos.orig/src/java/classes/java/lang/NullPointerException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/NullPointerException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class NullPointerException extends RuntimeException
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/Object.java lejos/src/java/classes/java/lang/Object.java
--- lejos.orig/src/java/classes/java/lang/Object.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/Object.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,76 +0,0 @@
-package java.lang;
-
-/**
- * All classes extend this one, implicitly.
- */
-public class Object
-{
- public boolean equals (Object aOther)
- {
- return this == aOther;
- }
-
- public int hashCode()
- {
- return getDataAddress (this);
- }
-
- /**
- * Wake up one thread blocked on a wait(). Must be synchronized on
- * this object otherwise an IllegalMonitorStateException will be thrown.
- * 
- * If multiple threads are waiting, higher priority threads will be woken
- * in preference, otherwise the thread that gets woken is essentially
- * random. 
- */
- public final native void notify();
-
- /**
- * Wake up all threads blocked on a wait(). Must be synchronized on
- * this object otherwise an IllegalMonitorStateException will be thrown.
- */
- public final native void notifyAll();
-
- /**
- * This is the same as calling wait(0).
- */
- public final native void wait() throws InterruptedException;
-
- /**
- * Wait until notified. Must be synchronized on this object otherwise
- * an IllegalMonitorStateException will be thrown. The wait can
- * terminate if one of the following things occurs:
- * <ol>
- * <li>notify() or notifyAll() is called.
- * <li>The calling thread is interrupted.
- * <li>The timeout expires.
- * </ol>
- * @param timeout maximum time in milliseconds to wait. Zero means forever.
- */
- public final native void wait(long timeout) throws InterruptedException;
- 
- /**
- * Returns the empty string. It's here to satisfy javac.
- */
- public String toString()
- {
- return "";
- }
-
- /**
- * Returns <code>null</code>. It's here to satisfy javac.
- */
- public final Class getClass()
- {
- return null;
- }
-
- private native static int getDataAddress (Object obj);
-}
-
-
-
-
-
-
-
diff -pruN lejos.orig/src/java/classes/java/lang/OutOfMemoryError.java lejos/src/java/classes/java/lang/OutOfMemoryError.java
--- lejos.orig/src/java/classes/java/lang/OutOfMemoryError.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/OutOfMemoryError.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class OutOfMemoryError extends Error
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/RuntimeException.java lejos/src/java/classes/java/lang/RuntimeException.java
--- lejos.orig/src/java/classes/java/lang/RuntimeException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/RuntimeException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class RuntimeException extends Exception
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/Runtime.java lejos/src/java/classes/java/lang/Runtime.java
--- lejos.orig/src/java/classes/java/lang/Runtime.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/Runtime.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,41 +0,0 @@
-package java.lang;
-
-/**
- * Minimalist version of the standard Java Runtime class.
- * @author Paul Andrews
- */
-public class Runtime {
- private static Runtime singleton;
-
- /**
- * Private so no one but us can create one.
- */
- private Runtime()
- {
- }
-
- /**
- * Get the single instance of us.
- */
- public static Runtime getRuntime()
- {
- if (singleton == null) {
- singleton = new Runtime();
- }
- return singleton;
- } 
-	
- /**
- * Return the amount of free memory.on the heap
- *
- * @return the free memory in bytes
- */
- public native long freeMemory();
- 
- /**
- * Return the size of the heap in bytes.
- *
- * @return the free memory in bytes
- */
- public native long totalMemory();
-}
diff -pruN lejos.orig/src/java/classes/java/lang/StackOverflowError.java lejos/src/java/classes/java/lang/StackOverflowError.java
--- lejos.orig/src/java/classes/java/lang/StackOverflowError.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/StackOverflowError.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,5 +0,0 @@
-package java.lang;
-
-public class StackOverflowError extends Error
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/StringBuffer.java lejos/src/java/classes/java/lang/StringBuffer.java
--- lejos.orig/src/java/classes/java/lang/StringBuffer.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/StringBuffer.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,247 +0,0 @@
-package java.lang;
-
-/**
- * An expandable string of characters. Actually not very expandable!
- * 09/25/2001 added number formatting thanks to Martin E. Nielsen.
- * You must ensure that the buffer is large enough to take the formatted
- * number.
- *
- * @author <a href="mailto:martin@egholm-nielsen.dk">Martin E. Nielsen</a>
- */
-public final class StringBuffer
-{
- char[] characters;
- int curPos = 0;
-
- /**
- * Conversion between integers from 0 to 9 and their respective
- * chars.
- **/
- private static final char[] numbers = { '0', '1', '2', '3', '4',
-					 '5', '6', '7', '8', '9' };
-
- /**
- * The value of log(10) used for converting from base
- * e to base 10.
- **/
- private static final float log10 = 2.30258509f;
-
- public StringBuffer () {
- 	characters = new char[0];
- }
- 
- public StringBuffer (String aString)
- {
- characters = aString.toCharArray();
- }
-
- public StringBuffer (int length)
- {
- characters = new char[length];
- }
-
- public StringBuffer delete(int start, int end)
- {
- if (start >= 0 && start < end && start < curPos)
- {
- if (end >= curPos)
- end = curPos;
- else
- System.arraycopy(characters, end, characters, start, curPos-end);
- 
- curPos -= end-start;
- }
- 
- return this;
- }
-
- public StringBuffer append (String s)
- {
- // Reminder: compact code more important than speed
- char[] sc = s.toCharArray();
- int cl = characters.length;
- int sl = sc.length;
- char [] nc = characters;
- if (sl + curPos > cl)
- {
- nc = new char[sl + curPos];
- System.arraycopy (characters, 0, nc, 0, curPos);
- }
- System.arraycopy (sc, 0, nc, curPos, sl);
- characters = nc;
- curPos += sl;
- return this;
- }
-
- public StringBuffer append (java.lang.Object aObject)
- {
- return append (aObject.toString());
- }
-
- public StringBuffer append (boolean aBoolean)
- {
- return append (aBoolean ? "true" : "false");
- }
- 
- public StringBuffer append (char aChar)
- {
- return append (new String (new char[] { aChar }, 0, 1));
- }
-
- public StringBuffer append (int aInt)
- {
-	if ( aInt < 0 ) {
-	 characters[ curPos++ ] = '-';
-	 aInt = -aInt;
-	} // if
-
-	int pow = ( int )Math.floor( Math.log( aInt ) / log10 );
-
-	int div = 0;
-	while ( pow >= 0 ) {
-	 div = ( int ) ( aInt / (int)Math.pow( 10, pow ) );
-	 
-	 characters[ curPos++ ] = numbers[ div ];
-	 aInt -= div * (int)Math.pow( 10, pow );
-	 pow--;
-	} // while
-	
-	return this;
- }
-
- public StringBuffer append (long aLong)
- {
- return append("<longs not supported>");
- }
-
- public StringBuffer append (float aFloat)
- {
- try {
- append (aFloat, 8);
- } catch (ArrayIndexOutOfBoundsException e) {
- curPos = Math.min(characters.length, curPos);
- }
- 
- return this;
- }
-
- public StringBuffer append (double aDouble)
- {
- try {
- append ((float)aDouble, 8);
- } catch (ArrayIndexOutOfBoundsException e) {
- curPos = Math.min(characters.length, curPos);
- }
- 
- return this;
- }
- 
- public String toString()
- {
- return new String (characters, 0, curPos);
- }
-
- public char charAt(int i)
- {
- return characters[i];
- }
- 
- public int length()
- {
- return curPos;
- }
-
- /**
- * Retrieves the contents of the StringBuffer in the form of an array of characters.
- */
- public char [] getChars()
- {
- return characters;
- }
- 
- /**
- * Helper method for converting floats and doubles.
- *
- * @author Martin E. Nielsen
- **/
- private StringBuffer append( float number, int significantDigits ) {
-
-	if ( number == 0 ) {
-	 characters[ curPos++ ] = '0';
-	 return this;
-	} // if
-	 
-	if ( number < 0 ) {
-	 characters[ curPos++ ] = '-';
-	 number = -number;
-	} // if
-
-	// calc. the power (base 10) for the given number:
-	int pow = ( int )Math.floor( Math.log( number ) / log10 );
-	int exponent = 0;
-
-	// use exponential formatting if number too big or too small
-	if ( pow < -3 || pow > 6 ) {
-	 exponent = pow;
-	 number /= Math.exp( Math.ln10 * exponent );
-	} // if
-
-	// Recalc. the pow if exponent removed and d has changed
-	pow = ( int )Math.floor( Math.log( number ) / log10 );
-
-	// Decide how many insignificant zeros there will be in the
-	// lead of the number.
-	int insignificantDigits = -Math.min( 0, pow );
-
-	// Force it to start with at least "0." if necessarry
-	pow = Math.max( 0, pow );
- double divisor = Math.pow(10, pow);
- 
-	// Loop over the significant digits (17 for double, 8 for float)
-	for ( int i = 0, end = significantDigits+insignificantDigits, div; i < end; i++ ) {
-
-	 // Add the '.' when passing from 10^0 to 10^-1
-	 if ( pow == -1 ) {
-		characters[ curPos++ ] = '.';
-	 } // if
-	 
-	 // Find the divisor
-	 div = ( int ) ( number / divisor );
-	 // This might happen with 1e6: pow = 5 ( instead of 6 )
-	 if ( div == 10 ) {
-		characters[ curPos++ ] = '1';
-		characters[ curPos++ ] = '0';
-	 } // if
-	 else {
-//		characters[ curPos ] = numbers[ div ];
-		characters[ curPos ] = (char)(div + '0');
-		curPos++;
-	 } // else
-
-	 number -= div * divisor;
-	 divisor /= 10.0;
-	 pow--;
-
-	 // Break the loop if we have passed the '.'
-	 if ( number == 0 && divisor < 0.1 ) break;
-	} // for
-
-	// Remove trailing zeros
- 	while ( characters[ curPos-1 ] == '0' )
- 	 curPos--;
-
-	// Avoid "4." instead of "4.0"
-	if ( characters[ curPos-1 ] == '.' )
-	 curPos++;
-
-	// Restore the exponential format
-	if ( exponent != 0 ) {
-	 characters[ curPos++ ] = 'E';
-	 append( exponent );
-	} // if
-	
-	return this;
- }
-}
-
-
diff -pruN lejos.orig/src/java/classes/java/lang/String.java lejos/src/java/classes/java/lang/String.java
--- lejos.orig/src/java/classes/java/lang/String.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/String.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,99 +0,0 @@
-package java.lang;
-
-/**
- * An immutable string of characters.
- */
-public final class String
-{
- // NOTE: The state of this class is mapped to
- // native code (see vmsrc/classes.h).
-
- char[] characters; // package protected, so StringUtils can access it
-
- /**
- * Create a String from a character array.
- * @param c the character array
- * @param off the offset - usually 0
- * @param len the length of the String - must not be greater than c.length
- **/
- public String (char[] c, int off, int len)
- {
- characters = new char[len];
- System.arraycopy (c, off, characters, 0, len);
- }
-
- /**
- * Return the length of the String in characters
- * @return the length of the String
- **/
- public int length()
- {
- return characters.length;
- }
-
- /**
- * Return the character at the given index
- * @return the characters at the given index
- **/
- public char charAt(int index) 
- {
- return characters[index];
- }
-
- /**
- * Converts the String into an array of characters
- * @return the character Array
- **/
- public char[] toCharArray()
- {
- int len = characters.length;
- char[] ca = new char[len];
- System.arraycopy (characters, 0, ca, 0, len);
- return ca;
- }
-
- /**
- * Converts an Object to a String
- * @return the String that represents the object
- **/
- public static String valueOf (Object aObj)
- {
- return aObj.toString();
- }
-
- /**
- * Returns itself.
- * @return the String itself
- */
- public String toString()
- {
- return this;
- }
- 
- /**
- * Compares the String with an Object
- * @return true if the String is equal to the object, false otherwise
- **/
- public boolean equals(Object other)
- {
- if (other == null)
- return false;
- 
- try {
- String os = (String)other;
- if (os.characters.length != characters.length)
- return false;
- 
- for (int i=0; i<characters.length; i++)
- {
- if (characters[i] != os.characters[i])
- return false;
- }
- 
- return true;
- } catch (ClassCastException e) {
- } 
- return false;
- }
-}
-
diff -pruN lejos.orig/src/java/classes/java/lang/StringUtils.java lejos/src/java/classes/java/lang/StringUtils.java
--- lejos.orig/src/java/classes/java/lang/StringUtils.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/StringUtils.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,25 +0,0 @@
-package java.lang;
-
-/**
- * Utilities for non-standard String maniplulation.
- * Use of these utilities will make your programs non-standard.
- */
-public final class StringUtils
-{
- private StringUtils() {
- }
-
- /**
- * Return the character array corresponding to the String without copying it.
- * This method, unlike the toCharArray method of String, uses no memory.
- * This method should be used with care as it is non-standard and allows
- * the contents of a String to be overwritten.
- * Use in user programs will make the programs non-standard and non-portable.
- * @param s the String whose characters are required
- * @return the character array (uncopied)
- */
- public static char [] getCharacters(String s) {
- return s.characters;
- }
-}
-
diff -pruN lejos.orig/src/java/classes/java/lang/System.java lejos/src/java/classes/java/lang/System.java
--- lejos.orig/src/java/classes/java/lang/System.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/System.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,39 +0,0 @@
-package java.lang;
-
-/**
- * System utilities.
- */
-public final class System
-{
- private System() {}
- 
- /**
- * Copies one array to another.
- */
- //public static native void arraycopy (Object src, int srcOffset, Object dest, int destOffset, int length);
- static void arraycopy (char[] src, int srcOffset, char[] dest, int destOffset, int length)
- {
- for (int i = 0; i < length; i++)
- dest[i + destOffset] = src[i + srcOffset]; 
- }
-
- /**
- * Terminate the application.
- */
- public static native void exit(int code);
- 
- /**
- * Current time expressed in milliseconds. In the RCX, this is the number
- * of milliseconds since the RCX has been on. (In Java, this would
- * be since January 1st, 1970).
- */
- public static native long currentTimeMillis();
- 
- /**
- * Get the singleton instance of Runtime.
- */
- public static Runtime getRuntime() {
- 	return Runtime.getRuntime();
- }
-}
-
diff -pruN lejos.orig/src/java/classes/java/lang/ThreadDeath.java lejos/src/java/classes/java/lang/ThreadDeath.java
--- lejos.orig/src/java/classes/java/lang/ThreadDeath.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/ThreadDeath.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,9 +0,0 @@
-package java.lang;
-
-/**
- * This is a special Error, which isn't reported by the
- * VM if uncaught. The thread dies quietly.
- */
-public class ThreadDeath extends Error
-{
-}
diff -pruN lejos.orig/src/java/classes/java/lang/Thread.java lejos/src/java/classes/java/lang/Thread.java
--- lejos.orig/src/java/classes/java/lang/Thread.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/Thread.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,114 +0,0 @@
-package java.lang;
-
-/**
- * A thread of execution (or task). Now handles priorities, daemon threads
- * and interruptions.
- */
-public abstract class Thread
-{
- /**
- * The minimum priority that a thread can have. The value is 1.
- */
- public final static int MIN_PRIORITY = 1;
-
- /**
- * The priority that is assigned to the primordial thread. The value is 5.
- */
- public final static int NORM_PRIORITY = 5;
-
- /**
- * The maximum priority that a thread can have. The value is 10.
- */
- public final static int MAX_PRIORITY = 10;
-
- // Note 1: This class cannot have a static initializer.
-
- // Note 2: The following fields are used by the VM.
- // Their sizes and location can only be changed
- // if classes.h is changed accordingly. Needless
- // to say, they are read-only.
-
- private Thread _TVM_nextThread;
- private int _TVM_waitingOn;
- private int _TVM_sleepUntil;
- private int _TVM_stackFrameArray;
- private int _TVM_stackArray;
- private byte _TVM_stackFrameArraySize;
- private byte _TVM_monitorCount;
- private byte _TVM_threadId; 
- private byte _TVM_state; 
- private byte _TVM_priority; 
- private byte _TVM_interrupted; 
- private byte _TVM_daemon; 
-
- // Extra instance state follows:
- 
- private String name;
-
- public final boolean isAlive()
- {
- return _TVM_state > 1;
- } 
-	 
- public Thread()
- {
- this ("");
- }
-
- public Thread (String name)
- {
- 	Thread t = currentThread();
-	if (t == null)
-		setPriority(NORM_PRIORITY);
-	else
-		setPriority(t.getPriority());	
- this.name = name;
- }
-
- public abstract void run();
- 
- public final native void start();
- public static native void yield();
- public static native void sleep (long aMilliseconds) throws InterruptedException;
- public static native Thread currentThread();
- public final native int getPriority();
- /**
- * Set the priority of this thread. Higher number have higher priority.
- * The scheduler will always run the highest priority thread in preference
- * to any others. If more than one thread of that priority exists the
- * scheduler will time-slice them. In order for lower priority threas
- * to run a higher priority thread must cease to be runnable. i.e. it
- * must exit, sleep or wait on a monitor. It is not sufficient to just
- * yield.
- * 
- * Threads inherit the priority of their parent. The primordial thread
- * has priority NORM_PRIORITY.
- *
- * @param priority must be between MIN_PRIORITY and MAX_PRIORITY.
- */
- public final native void setPriority(int priority);
- 
- /**
- * Set the interrupted flag. If we are asleep we will wake up
- * and an InterruptedException will be thrown.
- */
- public native void interrupt();
- public static native boolean interrupted();
- public final native boolean isInterrupted();
- 
- /**
- * Set the daemon flag. If a thread is a daemon thread its existence will
- * not prevent a JVM from exiting.
- */
- public final native boolean isDaemon();
- public final native void setDaemon(boolean on);
- 
- /**
- * Join not yet implemented
- */
- public final native void join() throws InterruptedException;
- public final native void join(long timeout) throws InterruptedException;
-}
-
-
-
diff -pruN lejos.orig/src/java/classes/java/lang/Throwable.java lejos/src/java/classes/java/lang/Throwable.java
--- lejos.orig/src/java/classes/java/lang/Throwable.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/lang/Throwable.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,21 +0,0 @@
-package java.lang;
-
-/**
- * All exceptions and errors extend this class.
- */
-public class Throwable
-{
-	private String _message;
- public Throwable() {
-	 _message = "";
- }
-
- public Throwable(String message) {
-	 _message = message;
- }
-
- public String getMessage()
- {
- return _message;
- }
-}
diff -pruN lejos.orig/src/java/classes/java/util/BitSet.java lejos/src/java/classes/java/util/BitSet.java
--- lejos.orig/src/java/classes/java/util/BitSet.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/util/BitSet.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,31 +0,0 @@
-package java.util;
-
-/**
- * Represents a long set of bits.
- */
-public class BitSet
-{
- byte[] iBytes;
-
- public BitSet (int nbits)
- {
- iBytes = new byte[(nbits - 1) / 8 + 1];
- }
- 
- public void clear (int n)
- {
- int idx = n / 8;
- iBytes[idx] = (byte) ((iBytes[idx] & 0xFF) & ~(1 << (n%8)));
- }
- 
- public void set (int n)
- {
- int idx = n / 8;
- iBytes[idx] = (byte) ((iBytes[idx] & 0xFF) | (1 << (n%8)));
- }
- 
- public boolean get (int n)
- {
- return ((iBytes[n/8] & 0xFF) & (1 << (n%8))) != 0;
- }
-}
diff -pruN lejos.orig/src/java/classes/java/util/EmptyQueueException.java lejos/src/java/classes/java/util/EmptyQueueException.java
--- lejos.orig/src/java/classes/java/util/EmptyQueueException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/util/EmptyQueueException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,36 +0,0 @@
-package java.util;
-/*
-* $Log: EmptyQueueException.java,v $
-* Revision 1.1 2003/08/17 14:59:42 mpscholz
-* enhanced Vector
-* added Stack and Queue and associated exception classes
-*
-*/
-
-/////////////////////////////////////////////////////////
-/**
- * An exception thrown by some Queue class methods
- * to indicate that the Queue is empty 
- */
-public class EmptyQueueException extends RuntimeException {
-
-	////////////////////////////////////////////
-	// constants
-	////////////////////////////////////////////
- 
-	////////////////////////////////////////////
-	// fields
-	////////////////////////////////////////////
-
-	////////////////////////////////////////////
-	// constructors
-	////////////////////////////////////////////
-
-	////////////////////////////////////////////
-	/**
-	 * creates a new exception wit null message string
-	 */
- public EmptyQueueException() {
- } // EmptyQueueException()
-
-} // class EmptyQueueException
diff -pruN lejos.orig/src/java/classes/java/util/EmptyStackException.java lejos/src/java/classes/java/util/EmptyStackException.java
--- lejos.orig/src/java/classes/java/util/EmptyStackException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/util/EmptyStackException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,36 +0,0 @@
-package java.util;
-/*
-* $Log: EmptyStackException.java,v $
-* Revision 1.1 2003/08/17 14:59:42 mpscholz
-* enhanced Vector
-* added Stack and Queue and associated exception classes
-*
-*/
-
-/////////////////////////////////////////////////////////
-/**
- * An exception thrown by some stack class methods
- * to indicate that the stack is empty 
- */
-public class EmptyStackException extends RuntimeException {
-
-	////////////////////////////////////////////
-	// constants
-	////////////////////////////////////////////
- 
-	////////////////////////////////////////////
-	// fields
-	////////////////////////////////////////////
-
-	////////////////////////////////////////////
-	// constructors
-	////////////////////////////////////////////
-
-	////////////////////////////////////////////
-	/**
-	 * creates a new exception wit null message string
-	 */
- public EmptyStackException() {
- } // EmptyStackException()
-
-} // class EmptyStackException
diff -pruN lejos.orig/src/java/classes/java/util/Hashtable.java lejos/src/java/classes/java/util/Hashtable.java
--- lejos.orig/src/java/classes/java/util/Hashtable.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/util/Hashtable.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,95 +0,0 @@
-package java.util;
-
-/**
- * Maps keys to objects. It has a fixed-size table, so don't
- * expect it to scale well.
- */
-public class Hashtable
-{
- private static final int TABLE_SIZE = 32;
- private Object[] iTable = new Object[TABLE_SIZE];
- 
- public Hashtable()
- { 
- }
-
- public synchronized Object get (Object aKey)
- {
- Object pElement = iTable[getTableIndex(aKey)];
- if (pElement == null)
- return null;
- KeyValuePair pKeyValuePair = getKeyValuePair (pElement, aKey);
- if (pKeyValuePair == null)
- return null;
- return pKeyValuePair.iValue;
- }
- 
- public synchronized void put (Object aKey, Object aValue)
- {
- int pIndex = getTableIndex (aKey); 
- Object pElement = iTable[pIndex];
- KeyValuePair pKeyValuePair = null;
- if (pElement != null)
- pKeyValuePair = getKeyValuePair (pElement, aKey);
- if (pKeyValuePair == null)
- {
- pKeyValuePair = new KeyValuePair();
- pKeyValuePair.iKey = aKey;
- pKeyValuePair.iValue = aValue;
- }
- if (pElement == null) 
- {
- iTable[pIndex] = pKeyValuePair;
- } 
- else if (pElement == pKeyValuePair)
- {
- pKeyValuePair.iValue = aValue;	 
- }
- else if (pElement instanceof KeyValuePair)
- {	 
- Vector pVector = new Vector();
- pVector.addElement (pElement);
- pVector.addElement (pKeyValuePair);
- }
- else
- {
- // pElement must be a Vector
- ((Vector) pElement).addElement (pKeyValuePair);	 
- }
- }
-
- private KeyValuePair getKeyValuePair (Object aPivot, Object aKey)
- {
- if (aPivot instanceof Vector)
- {
- Vector pVec = (Vector) aPivot;
- int pSize = pVec.size();
- for (int i = 0; i < pSize; i++)
- {
-	KeyValuePair pPair = (KeyValuePair) pVec.elementAt (i);
-	if (aKey.equals (pPair.iKey))
- return pPair;
- }
- return null;
- }
- // Not a Vector, must be a lone KeyValuePair
- KeyValuePair pPair = (KeyValuePair) aPivot;
- if (aKey.equals (pPair.iKey))
- return pPair;
- return null;
- }
- 
- private int getTableIndex (Object aKey)
- {
- int pHash = aKey.hashCode();
- if (pHash < 0)
- pHash = -pHash;
- return pHash % TABLE_SIZE;
- }
-
- private static class KeyValuePair
- { 
- Object iKey;
- Object iValue;
- }
-}
diff -pruN lejos.orig/src/java/classes/java/util/Queue.java lejos/src/java/classes/java/util/Queue.java
--- lejos.orig/src/java/classes/java/util/Queue.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/util/Queue.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,90 +0,0 @@
-package java.util;
-/*
-* $Log: Queue.java,v $
-* Revision 1.2 2005/11/23 17:46:45 mpscholz
-* minor javadoc related changes
-*
-* Revision 1.1 2003/08/17 14:59:42 mpscholz
-* enhanced Vector
-* added Stack and Queue and associated exception classes
-*
-*/
-
-/////////////////////////////////////////////////////////
-/**
- * A FIFO Queue of objects. 
- */
-public class Queue extends Vector {
-
-	////////////////////////////////////////////
-	// constants
-	////////////////////////////////////////////
- 
-	////////////////////////////////////////////
-	// fields
-	////////////////////////////////////////////
-
-	////////////////////////////////////////////
-	// constructors
-	////////////////////////////////////////////
-
-	////////////////////////////////////////////
- /**
- * creates a new Queue instance
- */
- public Queue() {
- 	// do nothing
- } // Queue()
-
-	////////////////////////////////////////////
-	/**
-	 * pushes an object onto the Queue
-	 * @param anObject the object
-	 * @return Object the object pushed onto the Queue
-	 */
- public Object push(Object anObject) {
- 	// add the object to base vector
-		addElement(anObject);
-		return anObject;
- } // push()
-
-	////////////////////////////////////////////
-	/**
-	 * fetches an object from the start of the Queue
-	 * and removes it
-	 * @return Object the object removed from the start of the stock
-	 * @throws EmptyQueueException
-	 */
- public synchronized Object pop() throws EmptyQueueException {
-		// get object
-		Object popped = peek();
-		// remove and return object
-		removeElementAt(0);
-		return popped;
- } // pop()
-
-	////////////////////////////////////////////
-	/**
-	 * fetches an object from the start of the Queue
-	 * does not remove it!
-	 * @return Object the object at the start of the Queue
-	 * @throws EmptyQueueException
-	 */
- public synchronized Object peek() throws EmptyQueueException {
-		// empty Queue?
-		if(size()==0)
-	 	throw new EmptyQueueException();
-	 // return first element
-		return elementAt(0);
- } // peek()
-
-	////////////////////////////////////////////
-	/**
-	 * is this Queue empty?
-	 * @return boolean true, if the Queue is empty
-	 */
- public boolean empty() {
-		return (size()==0);
- } // empty()
-
-} // class Queue
diff -pruN lejos.orig/src/java/classes/java/util/Random.java lejos/src/java/classes/java/util/Random.java
--- lejos.orig/src/java/classes/java/util/Random.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/util/Random.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,42 +0,0 @@
-package java.util;
-
-/**
- * Pseudo-random number generation.
- */
-public class Random
-{
- private int iPrevSeed, iSeed;
- 
- public Random (long seed)
- {
- iPrevSeed = 1;
- iSeed = (int) seed;
- }
-
- public Random()
- {
-	this(System.currentTimeMillis());
- }
- 
- /**
- * @return A random positive or negative integer.
- */
- public int nextInt()
- {
- int pNewSeed = (iSeed * 48271) ^ iPrevSeed;
- iPrevSeed = iSeed;
- iSeed = pNewSeed;
- return pNewSeed;
- }
-
- /**
- * Returns a random integer in the range 0...n-1.
- * @param n the bound
- * @return A random integer in the range 0...n-1.
- */
- public int nextInt (int n)
- {
-	int m = nextInt() % n;
-	return m >= 0 ? m : m + n;
- }
-}
diff -pruN lejos.orig/src/java/classes/java/util/Stack.java lejos/src/java/classes/java/util/Stack.java
--- lejos.orig/src/java/classes/java/util/Stack.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/util/Stack.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,93 +0,0 @@
-package java.util;
-/*
-* $Log: Stack.java,v $
-* Revision 1.2 2005/11/23 17:46:45 mpscholz
-* minor javadoc related changes
-*
-* Revision 1.1 2003/08/17 14:59:42 mpscholz
-* enhanced Vector
-* added Stack and Queue and associated exception classes
-*
-*/
-
-/////////////////////////////////////////////////////////
-/**
- * A LIFO stack of objects. 
- * TODO recycable
- */
-public class Stack extends Vector {
-
-	////////////////////////////////////////////
-	// constants
-	////////////////////////////////////////////
- 
-	////////////////////////////////////////////
-	// fields
-	////////////////////////////////////////////
-
-	////////////////////////////////////////////
-	// constructors
-	////////////////////////////////////////////
-
-	////////////////////////////////////////////
- /**
- * creates a new Stack instance
- */
- public Stack() {
- 	// do nothing
- } // Stack()
-
-	////////////////////////////////////////////
-	/**
-	 * pushes an object onto the stack
-	 * @param anObject the object
-	 * @return Object the object pushed onto the stack
-	 */
- public Object push(Object anObject) {
- 	// add the object to base vector
-		addElement(anObject);
-		return anObject;
- } // push()
-
-	////////////////////////////////////////////
-	/**
-	 * fetches an object from the top of the stack
-	 * and removes it
-	 * @return Object the object removed from the top of the stock
-	 * @throws EmptyStackException
-	 */
- public synchronized Object pop() throws EmptyStackException {
-		// get object
-		Object popped = peek();
-		// remove and return object
-		removeElementAt(size() - 1);
-		return popped;
- } // pop()
-
-	////////////////////////////////////////////
-	/**
-	 * fetches an object from the stack
-	 * does not remove it!
-	 * @return Object the object at the top of the stack
-	 * @throws EmptyStackException
-	 */
- public synchronized Object peek() throws EmptyStackException {
- 	// size of stack
-		int	sizeOfStack = size();
-		// empty stack?
-		if(sizeOfStack==0)
-	 	throw new EmptyStackException();
-	 // return top element
-		return elementAt(sizeOfStack-1);
- } // peek()
-
-	////////////////////////////////////////////
-	/**
-	 * is this stack empty?
-	 * @return boolean true, if the stack is empty
-	 */
- public boolean empty() {
-		return (size()==0);
- } // empty()
-
-} // class Stack
diff -pruN lejos.orig/src/java/classes/java/util/Vector.java lejos/src/java/classes/java/util/Vector.java
--- lejos.orig/src/java/classes/java/util/Vector.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/classes/java/util/Vector.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,553 +0,0 @@
-package java.util;
-/*
-* $Log: Vector.java,v $
-* Revision 1.6 2005/11/23 17:46:45 mpscholz
-* minor javadoc related changes
-*
-* Revision 1.5 2003/08/17 14:59:42 mpscholz
-* enhanced Vector
-* added Stack and Queue and associated exception classes
-*
-*/
-
-/**
- * A dynamic array.
- */
-
-public class Vector
-{
- //private Object[] iElements;
- //private int iSize;
-
- protected Object[] elementData;
-
- protected int capacityIncrement;
-
- protected int elementCount;
-
-
-
- public Vector(int initialCapacity, int capacityIncrement)
-
- {
-
- if (initialCapacity < 0) initialCapacity = 0;
-
- elementData = new Object[initialCapacity];
-
- this.capacityIncrement = capacityIncrement;
-
- elementCount = 0;
-
- }
-
-
-
- public Vector(int initialCapacity)
-
- {
-
- this(initialCapacity,0);
-
- }
-
-
-
-
-
- public Vector()
-
- {
-
- this(7);
-
- }
-
-
-
-
-
- public synchronized void addElement (Object aObj)
-
- {
-
- //int pOldSize = elementCount;
-
- //setSize (pOldSize + 1);
-
- ensureCapacityHelper(elementCount + 1);
-
- elementData[elementCount] = aObj;
-
- elementCount++;
-
- }
-
-
-
- public int capacity()
-
- {
-
- return elementData.length;
-
- }
-
-
-
-
-
- public void clear()
-
- {
-
- removeAllElements();
-
- }
-
-
-
-
-
- public synchronized Object elementAt (int aIndex)
-
- {
-
- if ((aIndex >= 0) && (aIndex < elementCount))
-
- {
-
- return elementData[aIndex];
-
- }else{
-
- throw new ArrayIndexOutOfBoundsException();
-
- }
-
- }
-
-
-
- public synchronized void ensureCapacity(int minCapacity)
-
- {
-
- ensureCapacityHelper(minCapacity);
-
- }
-
-
-
-
-
- //internal unsynchronized method for better performance
-
- private void ensureCapacityHelper(int minCapacity)
-
- {
-
- if (elementData.length < minCapacity)
-
- {
-
- int pNewCapacity;
-
- if (capacityIncrement > 0)
-
- {
-
- pNewCapacity = elementData.length + capacityIncrement;
-
- }else{
-
- pNewCapacity = elementData.length * 2;
-
- }
-
- if (pNewCapacity < minCapacity) pNewCapacity = minCapacity;
-
- Object oldData[] = elementData;
-
- elementData = new Object[pNewCapacity];
-
- arraycopy(oldData,0, elementData, 0, elementCount);
-
-
-
- }
-
- }
-
-
-
-
-
- public boolean equals(Object aObj)
-
- {
-
- return super.equals(aObj);
-
- }
-
-
-
-
-
- public synchronized int indexOf(Object aObj)
-
- {
-
- return indexOf(aObj, 0);
-
- }
-
-
-
-
-
- public synchronized int indexOf(Object aObj, int aIndex)
-
- {
-
- if (aObj == null)
-
- {
-
- for (int i = aIndex; i < elementCount; i++)
-
- {
-
- if (elementData[i] == null) return i;
-
- }
-
- }else{
-
- for (int i = aIndex; i < elementCount; i++)
-
- {
-
- if (elementData[i].equals(aObj)) return i;
-
- }
-
- }
-
- return -1;
-
- }
-
-
-
- public synchronized void insertElementAt (Object aObj, int aIndex)
-
- {
-
- if (aIndex > elementCount)
-
- {
-
- throw new ArrayIndexOutOfBoundsException();
-
- }else{
-
- ensureCapacityHelper(elementCount + 1);
-
- for (int i = elementCount; i > aIndex; i--)
-
- {
-
- elementData[i] = elementData[i - 1];
-
- }
-
- //arraycopy(elementData, aIndex, elementData, aIndex + 1, elementCount - aIndex);
-
- elementData[aIndex] = aObj;
-
- elementCount++;
-
- }
-
- }
-
-
-
-
-
- public boolean isEmpty()
-
- {
-
- return (elementCount == 0);
-
- }
-
-	/////////////////////////////////////////////////////
- 	/**
-	* delivers the index of the last occurrence of the object
-	* @param anObject the object 
-	* @return the index of the last occurrence of the object
-	* or -1, if object is not found
-	*/
-	public synchronized int lastIndexOf(Object anObject) {
-		return lastIndexOf(anObject,elementCount-1);
-	} // lastIndexOf()
-
-	/////////////////////////////////////////////////////
-	/**
-	* delivers the index of the last occurrence of the object
-	* starting from some index
-	* @param anObject the object
-	* @param anIndex the starting index 
-	* @return the index of the last occurrence of the object
-	* or -1, if object is not found
-	* @throws ArrayIndexOutOfBoundsException
-	*/
-	public synchronized int lastIndexOf(Object anObject, 
-		int anIndex) throws ArrayIndexOutOfBoundsException {
-		// valid index?
-		if(anIndex>=elementCount)
-			throw new ArrayIndexOutOfBoundsException();
-		// null object?
-		if(anObject==null) {
-			// find last null object
-			for(int i=anIndex;i>=0;i--)
-				if(elementData[i]==null)
-					return i;
-		} else {
-			// find last equal object
-		for (int i=anIndex;i>=0;i--)
-			if(anObject.equals(elementData[i]))
-				return i;
-		} // else
-		// not found
-		return -1;
-	} // lastIndexOf()
-
-
-
-
-
- public void removeAllElements()
-
- {
-
- for (int i = 0; i < elementCount; i++) elementData[i] = null;
-
- elementCount = 0;
-
- }
-
-
-
- public synchronized boolean removeElement (Object aObj)
-
- {
-
- int index = indexOf(aObj);
-
- if (index >= 0)
-
- {
-
- removeElementAt(index);
-
- return true;
-
- }else{
-
- return false;
-
- }
-
- }
-
-
-
- public synchronized void removeElementAt (int aIndex)
-
- {
-
- if ((aIndex >= 0) && (aIndex < elementCount))
-
- {
-
- int j = elementCount - aIndex - 1;
-
- if (j > 0)
-
- {
-
- arraycopy(elementData, aIndex + 1, elementData, aIndex, j);
-
- }
-
- elementCount--;
-
- elementData[elementCount] = null;
-
- }else{
-
- throw new ArrayIndexOutOfBoundsException();
-
- }
-
- }
-
-
-
- public synchronized void setElementAt (Object aObj, int aIndex)
-
- {
-
- if (aIndex >= elementCount)
-
- {
-
- throw new ArrayIndexOutOfBoundsException();
-
- }else{
-
- elementData[aIndex] = aObj;
-
- }
-
- }
-
-
-
-
-
-
-
-
-
- public synchronized void setSize (int aSize)
-
- {
-
- //elementCount = aSize;
-
- if (elementCount < aSize)
-
- {
-
- /*int pNewCapacity;
-
- if (capacityIncrement > 0) {
-
- pNewCapacity = elementData.length + capacityIncrement;
-
- }else{
-
- pNewCapacity = elementData.length * 2;
-
- }
-
-
-
- if (pNewCapacity < aSize) pNewCapacity = aSize;
-
- Object[] pNewElements = new Object[pNewCapacity];
-
- arraycopy (elementData, 0, pNewElements, 0, elementData.length);
-
- elementData = pNewElements;*/
-
- ensureCapacityHelper(aSize);
-
- }else{
-
- for (int i = aSize; i < elementCount; i++) elementData[i] = null;
-
- }
-
- elementCount = aSize;
-
- }
-
-
-
- public synchronized int size()
-
- {
-
- return elementCount;
-
- }
-
-
-
- public synchronized Object[] toArray()
-
- {
-
- Object[] result = new Object[elementCount];
-
- arraycopy(elementData, 0, result, 0, elementCount);
-
- return result;
-
- }
-
-
-
-
-
- /*public String toString() {
-
- if (elementCount < 1) {
-
- return "[]";
-
- }else{
-
- String str = "[";
-
- for (int i = 0; i < elementCount - 1;i++) str += String.valueOf(elementData[i]) + ", ";
-
- str += String.valueOf(elementData[elementCount - 1]) + "]";
-
- return str;
-
- }
-
- }*/
-
-
-
- public synchronized void trimToSize()
-
- {
-
- if (elementCount < elementData.length)
-
- {
-
- Object oldData[] = elementData;
-
- elementData = new Object[elementCount];
-
- arraycopy(oldData, 0, elementData, 0, elementCount);
-
- }
-
- }
-
- static void arraycopy (Object[] src, int srcoffset, Object[] dest, int destoffset, int length)
-
- {
-
- for (int i = 0; i < length; i++)
-
- dest[i + destoffset] = src[i + srcoffset];
-
- }
-
- //private native void arraycopy (Object aSource, int aOffset1, Object aDest, int aOffset2, int aLength);
-
-}
-
diff -pruN lejos.orig/src/java/rcxcomm/java/base/MalformedURLException.java lejos/src/java/rcxcomm/java/base/MalformedURLException.java
--- lejos.orig/src/java/rcxcomm/java/base/MalformedURLException.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/rcxcomm/java/base/MalformedURLException.java	2018-06-19 13:27:29.000000000 +0200
@@ -0,0 +1,40 @@
+/*
+ * @(#)MalformedURLException.java	1.13 00/02/02
+ *
+ * Copyright 1995-2000 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * This software is the proprietary information of Sun Microsystems, Inc. 
+ * Use is subject to license terms.
+ * 
+ */
+
+package java.base;
+
+import java.base.IOException;
+
+/**
+ * Thrown to indicate that a malformed URL has occurred. Either no 
+ * legal protocol could be found in a specification string or the 
+ * string could not be parsed. 
+ *
+ * @author Arthur van Hoff
+ * @version 1.13, 02/02/00
+ * @since JDK1.0
+ */
+public class MalformedURLException extends IOException {
+ /**
+ * Constructs a <code>MalformedURLException</code> with no detail message.
+ */
+ public MalformedURLException() {
+ }
+
+ /**
+ * Constructs a <code>MalformedURLException</code> with the 
+ * specified detail message. 
+ *
+ * @param msg the detail message.
+ */
+ public MalformedURLException(String msg) {
+	super(msg);
+ }
+}
diff -pruN lejos.orig/src/java/rcxcomm/java/base/Socket.java lejos/src/java/rcxcomm/java/base/Socket.java
--- lejos.orig/src/java/rcxcomm/java/base/Socket.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/rcxcomm/java/base/Socket.java	2018-06-19 13:27:46.000000000 +0200
@@ -0,0 +1,69 @@
+package java.base;
+
+import java.base.DataOutputStream;
+import java.base.IOException;
+import java.base.InputStream;
+import java.base.OutputStream;
+
+import josx.rcxcomm.RCXPort;
+
+/** An RCX version of Socket that connects to TCP/IP ports via a 
+ * proxy called SocketProxy running on the PC. It uses the 
+ * josx.rcxcomm package.
+ * @author Lawrie Griffiths
+ */
+public class Socket {
+ private RCXPort rcxport;
+ private InputStream is;
+ private OutputStream os;
+
+ /**
+ * Connects to a Socket via the proxy on the PC.
+ * @param host the host to connect to
+ * @param port the port to connect to
+ */
+ public Socket(String host, int port) throws IOException {
+ 
+ // Open the RCX Port
+
+ rcxport = new RCXPort();
+ is = rcxport.getInputStream();
+ os = rcxport.getOutputStream();
+ DataOutputStream dos = new DataOutputStream(os);
+
+ // Send an end of stream marker
+
+ dos.writeByte((byte) 0xff);
+
+ // Send the host name
+ 
+ char [] hostChars = host.toCharArray();
+
+ dos.writeByte(hostChars.length);
+
+ for(int i=0;i<hostChars.length;i++) 
+ dos.writeByte((byte) hostChars[i]);
+
+ // Send the port number
+ 
+ dos.writeInt(port);
+
+ // Check the reply
+
+ if (is.read() != 0) throw new IOException();
+ }
+
+ /** Returns an input stream for this Socket.
+ * @return an input stream for reading bytes from this Socket.
+ */
+ public InputStream getInputStream() {
+ return is;
+ }
+ 
+ /** Returns an output stream for this Socket.
+ * @return an output stream for writing bytes to this Socket.
+ */
+ public OutputStream getOutputStream() {
+ return os;
+ }
+}
diff -pruN lejos.orig/src/java/rcxcomm/java/base/URLConnection.java lejos/src/java/rcxcomm/java/base/URLConnection.java
--- lejos.orig/src/java/rcxcomm/java/base/URLConnection.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/rcxcomm/java/base/URLConnection.java	2018-06-19 13:28:07.000000000 +0200
@@ -0,0 +1,81 @@
+package java.base;
+
+import java.base.IOException;
+import java.base.InputStream;
+import java.base.OutputStream;
+
+/** An RCX version of URLConnection that uses the RCX version of Socket. 
+ * Socket uses a proxy called SocketProxy running on the PC. It connects 
+ * to it using the josx.rcxcomm package.
+ * This version ignores all http headers.
+ * @author Lawrie Griffiths
+ */
+public class URLConnection {
+ private InputStream in;
+ private OutputStream out;
+ private Socket socket;
+
+ static final private char [] get = {'G','E','T',' '};
+ static final private char [] http = {' ','H','T','T','P','/','1','.','0','\r','\n','\r','\n'};
+
+ /**
+ * Connects to a Socket via the proxy on the PC.
+ * @param host the host to connect to
+ * @param port the port to connect to
+ * @param path the file to get 
+ */
+ public URLConnection(String host, int port, String path) throws IOException {
+
+ // Open the socket
+
+ socket = new Socket(host,port);
+ in = socket.getInputStream();
+ out = socket.getOutputStream();
+
+ // Do an http get
+
+ char [] pathChars = path.toCharArray();
+
+ for(int i=0;i<get.length;i++)
+ out.write((byte) get[i]);
+
+ for(int i=0;i<pathChars.length;i++)
+ out.write((byte) pathChars[i]);
+
+ for(int i=0;i<http.length;i++)
+ out.write((byte) http[i]);
+
+ int done = 0;
+
+ // Skip the headers
+
+ do {
+ int b = in.read();
+ if (b == '\r') {
+ if (done == 0 || done == 2) done++;
+ else done = 0;
+ } 
+ else if (b == '\n') { 
+ if (done == 1 || done == 3) done++;
+ else done = 0;
+ }
+ else done = 0;
+ } while (done < 4);
+ }
+
+ /** Returns an input stream for this URLConnection.
+ * @return an input stream for reading bytes from this URLConnection.
+ */
+ public InputStream getInputStream() {
+ return in;
+ }
+
+ /** Returns an output stream for this URLConnection.
+ * @return an output stream for writing bytes to this URLConnection.
+ */
+ public OutputStream getOutputStream() {
+ return out;
+ }
+} 
+ 
+
diff -pruN lejos.orig/src/java/rcxcomm/java/base/URL.java lejos/src/java/rcxcomm/java/base/URL.java
--- lejos.orig/src/java/rcxcomm/java/base/URL.java	1970-01-01 01:00:00.000000000 +0100
+++ lejos/src/java/rcxcomm/java/base/URL.java	2018-06-19 13:27:55.000000000 +0200
@@ -0,0 +1,85 @@
+package java.base;
+
+import java.base.IOException;
+
+/** An RCX version of URL that uses the RCX version of Socket.
+ * Socket connects to TCP/IP ports via a 
+ * proxy called SocketProxy running on the PC. It uses the 
+ * josx.rcxcomm package.
+ * The current version only deals with URLs in the form:
+ * <protocol>://<host>/<path>, e.g. http://locahost/default.htm
+ * It assumes a port of 80.
+ * @author Lawrie Griffiths
+ */
+public class URL {
+ private String path, host;
+ private int port = 80;
+
+ /**
+ * Create a URL from the supplied string.
+ * @param url the URL
+ * @throws MalformedURLException
+ */
+ public URL(String url) throws MalformedURLException {
+ char [] urlChars = url.toCharArray();
+ int l = urlChars.length;
+ int i = 0, hostStart, pathStart;
+
+ // Isolate the protocol
+ 
+ while (urlChars[i] != ':' && i<l) i++;
+ 
+ if (i == l) throw new MalformedURLException();
+
+ char [] protocolChars = new char[i];
+ 
+ for(int j=0;j<i;j++) 
+ protocolChars[j] = urlChars[j];
+
+ // Isolate the host
+
+ hostStart = i+3; // skip ://
+
+ if (hostStart >= l) throw new MalformedURLException();
+ 
+ i = hostStart;
+
+ while(urlChars[i] != '/'&& i < l) i++;
+
+ if (i == l) throw new MalformedURLException();
+
+ char [] hostChars = new char[i-hostStart];
+
+ for(int j=hostStart;j<i;j++) 
+ hostChars[j-hostStart] = urlChars[j];
+
+ host = new String(hostChars,0,i-hostStart);
+
+ // Isolate the path
+
+ pathStart = i;
+
+ char [] pathChars = new char[l-pathStart];
+
+ for(int j=pathStart;j<l;j++) 
+ pathChars[j-pathStart] = urlChars[j];
+
+ path = new String(pathChars,0,l-pathStart);
+ }
+
+ /**
+ * Create and open a URL connection using http get.
+ * @throws IOxception
+ */
+ public URLConnection openConnection() throws IOException{
+ return new URLConnection(host,port,path);
+ }
+}
+
+ 
+ 
+
+ 
+ 
+
+ 
diff -pruN lejos.orig/src/java/rcxcomm/java/net/MalformedURLException.java lejos/src/java/rcxcomm/java/net/MalformedURLException.java
--- lejos.orig/src/java/rcxcomm/java/net/MalformedURLException.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/rcxcomm/java/net/MalformedURLException.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,40 +0,0 @@
-/*
- * @(#)MalformedURLException.java	1.13 00/02/02
- *
- * Copyright 1995-2000 Sun Microsystems, Inc. All Rights Reserved.
- * 
- * This software is the proprietary information of Sun Microsystems, Inc. 
- * Use is subject to license terms.
- * 
- */
-
-package java.net;
-
-import java.io.IOException;
-
-/**
- * Thrown to indicate that a malformed URL has occurred. Either no 
- * legal protocol could be found in a specification string or the 
- * string could not be parsed. 
- *
- * @author Arthur van Hoff
- * @version 1.13, 02/02/00
- * @since JDK1.0
- */
-public class MalformedURLException extends IOException {
- /**
- * Constructs a <code>MalformedURLException</code> with no detail message.
- */
- public MalformedURLException() {
- }
-
- /**
- * Constructs a <code>MalformedURLException</code> with the 
- * specified detail message. 
- *
- * @param msg the detail message.
- */
- public MalformedURLException(String msg) {
-	super(msg);
- }
-}
diff -pruN lejos.orig/src/java/rcxcomm/java/net/Socket.java lejos/src/java/rcxcomm/java/net/Socket.java
--- lejos.orig/src/java/rcxcomm/java/net/Socket.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/rcxcomm/java/net/Socket.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,69 +0,0 @@
-package java.net;
-
-import java.io.DataOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-
-import josx.rcxcomm.RCXPort;
-
-/** An RCX version of Socket that connects to TCP/IP ports via a 
- * proxy called SocketProxy running on the PC. It uses the 
- * josx.rcxcomm package.
- * @author Lawrie Griffiths
- */
-public class Socket {
- private RCXPort rcxport;
- private InputStream is;
- private OutputStream os;
-
- /**
- * Connects to a Socket via the proxy on the PC.
- * @param host the host to connect to
- * @param port the port to connect to
- */
- public Socket(String host, int port) throws IOException {
- 
- // Open the RCX Port
-
- rcxport = new RCXPort();
- is = rcxport.getInputStream();
- os = rcxport.getOutputStream();
- DataOutputStream dos = new DataOutputStream(os);
-
- // Send an end of stream marker
-
- dos.writeByte((byte) 0xff);
-
- // Send the host name
- 
- char [] hostChars = host.toCharArray();
-
- dos.writeByte(hostChars.length);
-
- for(int i=0;i<hostChars.length;i++) 
- dos.writeByte((byte) hostChars[i]);
-
- // Send the port number
- 
- dos.writeInt(port);
-
- // Check the reply
-
- if (is.read() != 0) throw new IOException();
- }
-
- /** Returns an input stream for this Socket.
- * @return an input stream for reading bytes from this Socket.
- */
- public InputStream getInputStream() {
- return is;
- }
- 
- /** Returns an output stream for this Socket.
- * @return an output stream for writing bytes to this Socket.
- */
- public OutputStream getOutputStream() {
- return os;
- }
-}
diff -pruN lejos.orig/src/java/rcxcomm/java/net/URLConnection.java lejos/src/java/rcxcomm/java/net/URLConnection.java
--- lejos.orig/src/java/rcxcomm/java/net/URLConnection.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/rcxcomm/java/net/URLConnection.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,81 +0,0 @@
-package java.net;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-
-/** An RCX version of URLConnection that uses the RCX version of Socket. 
- * Socket uses a proxy called SocketProxy running on the PC. It connects 
- * to it using the josx.rcxcomm package.
- * This version ignores all http headers.
- * @author Lawrie Griffiths
- */
-public class URLConnection {
- private InputStream in;
- private OutputStream out;
- private Socket socket;
-
- static final private char [] get = {'G','E','T',' '};
- static final private char [] http = {' ','H','T','T','P','/','1','.','0','\r','\n','\r','\n'};
-
- /**
- * Connects to a Socket via the proxy on the PC.
- * @param host the host to connect to
- * @param port the port to connect to
- * @param path the file to get 
- */
- public URLConnection(String host, int port, String path) throws IOException {
-
- // Open the socket
-
- socket = new Socket(host,port);
- in = socket.getInputStream();
- out = socket.getOutputStream();
-
- // Do an http get
-
- char [] pathChars = path.toCharArray();
-
- for(int i=0;i<get.length;i++)
- out.write((byte) get[i]);
-
- for(int i=0;i<pathChars.length;i++)
- out.write((byte) pathChars[i]);
-
- for(int i=0;i<http.length;i++)
- out.write((byte) http[i]);
-
- int done = 0;
-
- // Skip the headers
-
- do {
- int b = in.read();
- if (b == '\r') {
- if (done == 0 || done == 2) done++;
- else done = 0;
- } 
- else if (b == '\n') { 
- if (done == 1 || done == 3) done++;
- else done = 0;
- }
- else done = 0;
- } while (done < 4);
- }
-
- /** Returns an input stream for this URLConnection.
- * @return an input stream for reading bytes from this URLConnection.
- */
- public InputStream getInputStream() {
- return in;
- }
-
- /** Returns an output stream for this URLConnection.
- * @return an output stream for writing bytes to this URLConnection.
- */
- public OutputStream getOutputStream() {
- return out;
- }
-} 
- 
-
diff -pruN lejos.orig/src/java/rcxcomm/java/net/URL.java lejos/src/java/rcxcomm/java/net/URL.java
--- lejos.orig/src/java/rcxcomm/java/net/URL.java	2006-09-17 11:51:34.000000000 +0200
+++ lejos/src/java/rcxcomm/java/net/URL.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,85 +0,0 @@
-package java.net;
-
-import java.io.IOException;
-
-/** An RCX version of URL that uses the RCX version of Socket.
- * Socket connects to TCP/IP ports via a 
- * proxy called SocketProxy running on the PC. It uses the 
- * josx.rcxcomm package.
- * The current version only deals with URLs in the form:
- * <protocol>://<host>/<path>, e.g. http://locahost/default.htm
- * It assumes a port of 80.
- * @author Lawrie Griffiths
- */
-public class URL {
- private String path, host;
- private int port = 80;
-
- /**
- * Create a URL from the supplied string.
- * @param url the URL
- * @throws MalformedURLException
- */
- public URL(String url) throws MalformedURLException {
- char [] urlChars = url.toCharArray();
- int l = urlChars.length;
- int i = 0, hostStart, pathStart;
-
- // Isolate the protocol
- 
- while (urlChars[i] != ':' && i<l) i++;
- 
- if (i == l) throw new MalformedURLException();
-
- char [] protocolChars = new char[i];
- 
- for(int j=0;j<i;j++) 
- protocolChars[j] = urlChars[j];
-
- // Isolate the host
-
- hostStart = i+3; // skip ://
-
- if (hostStart >= l) throw new MalformedURLException();
- 
- i = hostStart;
-
- while(urlChars[i] != '/'&& i < l) i++;
-
- if (i == l) throw new MalformedURLException();
-
- char [] hostChars = new char[i-hostStart];
-
- for(int j=hostStart;j<i;j++) 
- hostChars[j-hostStart] = urlChars[j];
-
- host = new String(hostChars,0,i-hostStart);
-
- // Isolate the path
-
- pathStart = i;
-
- char [] pathChars = new char[l-pathStart];
-
- for(int j=pathStart;j<l;j++) 
- pathChars[j-pathStart] = urlChars[j];
-
- path = new String(pathChars,0,l-pathStart);
- }
-
- /**
- * Create and open a URL connection using http get.
- * @throws IOxception
- */
- public URLConnection openConnection() throws IOException{
- return new URLConnection(host,port,path);
- }
-}
-
- 
- 
-
- 
- 
-
-

Places

File lejos-java-9.patch of Package lejos (Revision 5c98d1c2117bd9d07530d9399271d781)

Places