bugfixes

classpath/java/io/File.java

@@ -1,6 +1,10 @@
 package java.io;
 
 public class File {
+  static {
+    System.loadLibrary("natives");
+  }
+
   private final String path;
 
   public File(String path) {

classpath/java/io/FileInputStream.java

@@ -1,6 +1,10 @@
 package java.io;
 
 public class FileInputStream extends InputStream {
+  static {
+    System.loadLibrary("natives");
+  }
+
   private int fd;
 
   public FileInputStream(FileDescriptor fd) {

classpath/java/io/FileOutputStream.java

@@ -1,6 +1,10 @@
 package java.io;
 
 public class FileOutputStream extends OutputStream {
+  static {
+    System.loadLibrary("natives");
+  }
+
   private int fd;
 
   public FileOutputStream(FileDescriptor fd) {

classpath/java/lang/Object.java

@@ -1,7 +1,15 @@
 package java.lang;
 
 public class Object {
-  protected native Object clone() throws CloneNotSupportedException;
+  protected Object clone() throws CloneNotSupportedException {
+    if (this instanceof Cloneable) {
+      return clone(this);
+    } else {
+      throw new CloneNotSupportedException();
+    }
+  }
+
+  private static native Object clone(Object o);
 
   public boolean equals(Object o) {
     return this == o;

classpath/java/lang/String.java

@@ -31,6 +31,18 @@ public final class String implements Comparable<String> {
   }
 
   private String(Object data, int offset, int length, boolean copy) {
+    int l;
+    if (data instanceof char[]) {
+      l = ((char[]) data).length;
+    } else {
+      l = ((byte[]) data).length;
+    }
+
+    if (offset < 0 || offset + length > l) {
+      throw new IndexOutOfBoundsException
+        (offset + " < 0 or " + offset + " + " + length + " > " + l);
+    }
+
     if (copy) {
       Object c;
       if (data instanceof char[]) {
@@ -59,7 +71,9 @@ public final class String implements Comparable<String> {
 
   public int hashCode() {
     if (hash == 0) {
-      for (int i = 0; i < length; ++i) hash = (hash * 31) + charAt(i);
+      int h = 0;
+      for (int i = 0; i < length; ++i) h = (h * 31) + charAt(i);
+      hash = h;
     }
     return hash;
   }

classpath/java/lang/StringBuffer.java

@@ -21,6 +21,11 @@ public class StringBuffer {
     return this;
   }
 
+  public synchronized StringBuffer append(char v) {
+    sb.append(v);
+    return this;
+  }
+
   public synchronized StringBuffer append(int v) {
     sb.append(v);
     return this;

classpath/java/lang/StringBuilder.java

@@ -3,6 +3,8 @@ package java.lang;
 public class StringBuilder {
   private Cell chain;
   private int length;
+  private char[] buffer;
+  private int position;
 
   public StringBuilder(int capacity) { }
 
@@ -10,13 +12,29 @@ public class StringBuilder {
     this(0);
   }
 
+  private void flush() {
+    if (position > 0) {
+      char[] b = buffer;
+      int p = position;
+      buffer = null;
+      position = 0;
+      append(new String(b, 0, p, false));
+      length -= p;
+    }
+  }
+
   public StringBuilder append(String s) {
+    if (s == null) {
+      return append("null");
+    } else {
       if (s.length() > 0) {
+        flush();
         chain = new Cell(s, chain);
         length += s.length();
       }
       return this;
     }
+  }
 
   public StringBuilder append(char[] b, int offset, int length) {
     return append(new String(b, offset, length));
@@ -26,6 +44,20 @@ public class StringBuilder {
     return append(o == null ? "null" : o.toString());
   }
 
+  public StringBuilder append(char v) {
+    if (buffer == null) {
+      buffer = new char[32];
+    } else if (position >= buffer.length) {
+      flush();
+      buffer = new char[32];
+    }
+
+    buffer[position++] = v;
+    ++ length;
+
+    return this;
+  }
+
   public StringBuilder append(int v) {
     return append(String.valueOf(v));
   }
@@ -39,6 +71,8 @@ public class StringBuilder {
       throw new IndexOutOfBoundsException();
     }
 
+    flush();
+
     int index = length;
     -- length;
     Cell p = null;
@@ -83,6 +117,8 @@ public class StringBuilder {
       return;
     }
 
+    flush();
+
     int index = length;
     length = v;
     for (Cell c = chain; c != null; c = c.next) {
@@ -106,6 +142,8 @@ public class StringBuilder {
       throw new IndexOutOfBoundsException();
     }
 
+    flush();
+
     int index = length;
     for (Cell c = chain; c != null; c = c.next) {
       int start = index - c.value.length();

classpath/java/util/HashMap.java

@@ -5,7 +5,7 @@ public class HashMap<K, V> implements Map<K, V> {
   private Cell[] array;
   private final Helper helper;
 
-  HashMap(int capacity, Helper<K, V> helper) {
+  public HashMap(int capacity, Helper<K, V> helper) {
     if (capacity > 0) {
       array = new Cell[nextPowerOfTwo(capacity)];
     }
@@ -20,6 +20,22 @@ public class HashMap<K, V> implements Map<K, V> {
     this(0);
   }
 
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    sb.append("{");
+    for (Iterator<Entry<K, V>> it = iterator(); it.hasNext();) {
+      Entry<K, V> e = it.next();
+      sb.append(e.getKey())
+        .append("=")
+        .append(e.getValue());
+      if (it.hasNext()) {
+        sb.append(",");
+      }
+    }
+    sb.append("}");
+    return sb.toString();
+  }
+
   private static int nextPowerOfTwo(int n) {
     int r = 1;
     while (r < n) r <<= 1;
@@ -85,8 +101,7 @@ public class HashMap<K, V> implements Map<K, V> {
     array[index] = cell;
   }
 
-  // primarily for use by WeakHashMap:
-  void remove(Cell<K, V> cell) {
+  public void remove(Cell<K, V> cell) {
     int index = cell.hashCode() & (array.length - 1);
     Cell<K, V> p = null;
     for (Cell<K, V> c = array[index]; c != null; c = c.next()) {
@@ -366,7 +381,7 @@ public class HashMap<K, V> implements Map<K, V> {
           }
         }
       }
-      return false;
+      return nextCell != null;
     }
 
     public void remove() {

src/builtin.cpp

@@ -10,7 +10,7 @@ namespace {
 object
 doInvoke(Thread* t, object this_, object instance, object arguments)
 {
-  object v = pushReference(t, run2(t, this_, instance, arguments));
+  object v = run2(t, this_, instance, arguments);
   if (t->exception) {
     t->exception = makeInvocationTargetException(t, t->exception);
   }
@@ -64,6 +64,16 @@ Object_hashCode(Thread* t, jobject this_)
   return objectHash(t, *this_);
 }
 
+jobject
+Object_clone(Thread* t, jclass, jobject o)
+{
+  object clone = make(t, objectClass(t, *o));
+  memcpy(static_cast<void**>(clone) + 1,
+         static_cast<void**>(*o) + 1,
+         (baseSize(t, *o, objectClass(t, *o)) - 1) * BytesPerWord);
+  return pushReference(t, clone);
+}
+
 jclass
 ClassLoader_defineClass(Thread* t, jclass, jbyteArray b, jint offset,
                         jint length)
@@ -816,6 +826,8 @@ populateBuiltinMap(Thread* t, object map)
       reinterpret_cast<void*>(::Object_wait) },
     { "Java_java_lang_Object_hashCode",
       reinterpret_cast<void*>(::Object_hashCode) },
+    { "Java_java_lang_Object_clone",
+      reinterpret_cast<void*>(::Object_clone) },
 
     { "Java_java_lang_reflect_Array_get",
       reinterpret_cast<void*>(::Array_get) },

src/machine.h

@@ -1829,7 +1829,9 @@ inline uint32_t
 hash(const int8_t* s, unsigned length)
 {
   uint32_t h = 0;
-  for (unsigned i = 0; i < length; ++i) h = (h * 31) + s[i];
+  for (unsigned i = 0; i < length; ++i) {
+    h = (h * 31) + static_cast<unsigned>(s[i]);
+  }
   return h;  
 }
 
@@ -1837,7 +1839,9 @@ inline uint32_t
 hash(const uint16_t* s, unsigned length)
 {
   uint32_t h = 0;
-  for (unsigned i = 0; i < length; ++i) h = (h * 31) + s[i];
+  for (unsigned i = 0; i < length; ++i) {
+    h = (h * 31) + s[i];
+  }
   return h;  
 }
 
@@ -1934,9 +1938,11 @@ stringHash(Thread* t, object s)
     if (objectClass(t, data)
         == arrayBody(t, t->vm->types, Machine::ByteArrayType))
     {
-      stringHashCode(t, s) = byteArrayHash(t, data);
+      stringHashCode(t, s) = hash
+        (&byteArrayBody(t, data, stringOffset(t, s)), stringLength(t, s));
     } else {
-      stringHashCode(t, s) = charArrayHash(t, data);
+      stringHashCode(t, s) = hash
+        (&charArrayBody(t, data, stringOffset(t, s)), stringLength(t, s));
     }
   }
   return stringHashCode(t, s);

src/run.cpp

@@ -1570,12 +1570,13 @@ run(Thread* t)
       object class_ = resolveClass(t, codePool(t, code), index - 1);
       if (UNLIKELY(exception)) goto throw_;
 
-      if (instanceOf(t, class_, peekObject(t, sp - 1))) {
+      if (instanceOf(t, class_, popObject(t))) {
         pushInt(t, 1);
       } else {
         pushInt(t, 0);
       }
     } else {
+      popObject(t);
       pushInt(t, 0);
     }
   } goto loop;