Merge in gcc_4_0_0_release to gcc_4_0_1_release

git-svn-id: https://gcc.gnu.org/svn/gcc/branches/apple-local-200502-branch@101836 138bc75d-0d04-0410-961f-82ee72b054a4

13 files changed, 135 insertions, 52 deletions

diff --git a/libjava/java/lang/Class.h b/libjava/java/lang/Class.h
index 98ebcc13d38..f48654afa9b 100644
--- a/libjava/java/lang/Class.h
+++ b/libjava/java/lang/Class.h
@@ -32,6 +32,7 @@ extern "C" void _Jv_RegisterClasses_Counted (const jclass *classes,
 // This must be predefined with "C" linkage.
 extern "C" void *_Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface, 
                                                int meth_idx);
+extern "C" void *_Jv_ResolvePoolEntry (jclass this_class, jint index);
 
 // These are the possible values for the `state' field of the class
 // structure.  Note that ordering is important here.  Whenever the
@@ -492,6 +493,8 @@ private:
 
   friend void ::_Jv_sharedlib_register_hook (jclass klass);
 
+  friend void *::_Jv_ResolvePoolEntry (jclass this_class, jint index);
+
   // Chain for class pool.  This also doubles as the ABI version
   // number.  It is only used for this purpose at class registration
   // time, and only for precompiled classes.
diff --git a/libjava/java/lang/natObject.cc b/libjava/java/lang/natObject.cc
index d7b67d7fa2d..aa79500fa58 100644
--- a/libjava/java/lang/natObject.cc
+++ b/libjava/java/lang/natObject.cc
@@ -35,6 +35,8 @@ details.  */
 
 
 
+using namespace java::lang;
+
 // This is used to represent synchronization information.
 struct _Jv_SyncInfo
 {
@@ -926,12 +928,22 @@ retry:
 	  release_set(&(he -> address), (address | REQUEST_CONVERSION | HEAVY));
 				// release lock on he
 	  LOG(REQ_CONV, (address | REQUEST_CONVERSION | HEAVY), self);
+	  // If _Jv_CondWait is interrupted, we ignore the interrupt, but
+	  // restore the thread's interrupt status flag when done.
+	  jboolean interrupt_flag = false;
 	  while ((he -> address & ~FLAGS) == (address & ~FLAGS))
 	    {
 	      // Once converted, the lock has to retain heavyweight
-	      // status, since heavy_count > 0 . 
-	      _Jv_CondWait (&(hl->si.condition), &(hl->si.mutex), 0, 0);
+	      // status, since heavy_count > 0.
+	      int r = _Jv_CondWait (&(hl->si.condition), &(hl->si.mutex), 0, 0);
+	      if (r == _JV_INTERRUPTED)
+	        {
+		  interrupt_flag = true;
+		  Thread::currentThread()->interrupt_flag = false;
+		}
 	    }
+	  if (interrupt_flag)
+	    Thread::currentThread()->interrupt_flag = interrupt_flag;
 	  keep_live(addr);
 		// Guarantee that hl doesn't get unlinked by finalizer.
 		// This is only an issue if the client fails to release
diff --git a/libjava/java/lang/natString.cc b/libjava/java/lang/natString.cc
index e2558f4f747..e39df2460b0 100644
--- a/libjava/java/lang/natString.cc
+++ b/libjava/java/lang/natString.cc
@@ -1,6 +1,6 @@
 // natString.cc - Implementation of java.lang.String native methods.
 
-/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004  Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005  Free Software Foundation
 
    This file is part of libgcj.
 
@@ -64,7 +64,7 @@ _Jv_StringFindSlot (jchar* data, jint len, jint hash)
   int index = start_index;
   /* step must be non-zero, and relatively prime with strhash_size. */
   jint step = (hash ^ (hash >> 16)) | 1;
-  for (;;)
+  do
     {
       jstring* ptr = &strhash[index];
       jstring value = (jstring) UNMASK_PTR (*ptr);
@@ -81,8 +81,12 @@ _Jv_StringFindSlot (jchar* data, jint len, jint hash)
 	       && memcmp(JvGetStringChars(value), data, 2*len) == 0)
 	return (ptr);
       index = (index + step) & (strhash_size - 1);
-      JvAssert (index != start_index);
     }
+  while (index != start_index);
+  // Note that we can have INDEX == START_INDEX if the table has no
+  // NULL entries but does have DELETED_STRING entries.
+  JvAssert (deleted_index >= 0);
+  return &strhash[deleted_index];
 }
 
 /* Calculate a hash code for the string starting at PTR at given LENGTH.
@@ -831,7 +835,10 @@ java::lang::String::substring (jint beginIndex, jint endIndex)
   if (beginIndex == 0 && endIndex == count)
     return this;
   jint newCount = endIndex - beginIndex;
-  if (newCount <= 8)  // Optimization, mainly for GC.
+  // For very small strings, just allocate a new one.  For other
+  // substrings, allocate a new one unless the substring is over half
+  // of the original string.
+  if (newCount <= 8 || newCount < (count >> 1))
     return JvNewString(JvGetStringChars(this) + beginIndex, newCount);
   jstring s = new String();
   s->data = data;
diff --git a/libjava/java/lang/ref/natReference.cc b/libjava/java/lang/ref/natReference.cc
index e322ae37cc8..5ad5b107405 100644
--- a/libjava/java/lang/ref/natReference.cc
+++ b/libjava/java/lang/ref/natReference.cc
@@ -1,6 +1,6 @@
 // natReference.cc - Native code for References
 
-/* Copyright (C) 2001, 2002, 2003  Free Software Foundation
+/* Copyright (C) 2001, 2002, 2003, 2005  Free Software Foundation
 
    This file is part of libgcj.
 
@@ -78,7 +78,7 @@ find_slot (jobject key)
   int start_index = hcode & (hash_size - 1);
   int index = start_index;
   int deleted_index = -1;
-  for (;;)
+  do
     {
       object_list *ptr = &hash[index];
       if (ptr->reference == key)
@@ -96,8 +96,12 @@ find_slot (jobject key)
 	  JvAssert (ptr->reference == DELETED_REFERENCE);
 	}
       index = (index + step) & (hash_size - 1);
-      JvAssert (index != start_index);
     }
+  while (index != start_index);
+  // Note that we can have INDEX == START_INDEX if the table has no
+  // NULL entries but does have DELETED entries.
+  JvAssert (deleted_index >= 0);
+  return &hash[deleted_index];
 }
 
 static void
diff --git a/libjava/java/net/URI.java b/libjava/java/net/URI.java
index 23e3e7c9e4a..c06775abaa9 100644
--- a/libjava/java/net/URI.java
+++ b/libjava/java/net/URI.java
@@ -255,9 +255,8 @@ public final class URI implements Comparable, Serializable
 	  {
 	    if (i + 2 >= str.length())
 	      throw new URISyntaxException(str, "Invalid quoted character");
-	    String hex = "0123456789ABCDEF";
-	    int hi = hex.indexOf(str.charAt(++i));
-	    int lo = hex.indexOf(str.charAt(++i));
+	    int hi = Character.digit(str.charAt(++i), 16);
+	    int lo = Character.digit(str.charAt(++i), 16);
 	    if (lo < 0 || hi < 0)
 	      throw new URISyntaxException(str, "Invalid quoted character");
 	    buf[pos++] = (byte) (hi * 16 + lo);
diff --git a/libjava/java/net/URL.java b/libjava/java/net/URL.java
index 576e2d3e55f..7ab30513b7c 100644
--- a/libjava/java/net/URL.java
+++ b/libjava/java/net/URL.java
@@ -125,7 +125,7 @@ import java.util.StringTokenizer;
 public final class URL implements Serializable
 {
   private static final String DEFAULT_SEARCH_PATH =
-    "org.metastatic.jessie|gnu.java.net.protocol|gnu.inet";
+    "gnu.java.net.protocol|gnu.inet";
 
   // Cached System ClassLoader
   private static ClassLoader systemClassLoader;
diff --git a/libjava/java/net/URLClassLoader.java b/libjava/java/net/URLClassLoader.java
index 9593e7d0fb0..ebec08e037f 100644
--- a/libjava/java/net/URLClassLoader.java
+++ b/libjava/java/net/URLClassLoader.java
@@ -63,7 +63,8 @@ import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 import java.util.jar.Manifest;
 import gnu.gcj.runtime.SharedLibHelper;
-
+import gnu.gcj.Core;
+import gnu.java.net.protocol.core.CoreInputStream;
 
 /**
  * A secure class loader that can load classes and resources from
@@ -652,6 +653,66 @@ public class URLClassLoader extends SecureClassLoader
     }
   }
 
+  /**
+   * A <code>CoreURLLoader</code> is a type of <code>URLLoader</code>
+   * only loading from core url.
+   */
+  static final class CoreURLLoader extends URLLoader
+  {
+    private String dir;
+
+    CoreURLLoader(URLClassLoader classloader, URL url)
+    {
+      super(classloader, url);
+      dir = baseURL.getFile();
+    }
+
+    /** get resource with the name "name" in the core url */
+    Resource getResource(String name)
+    {
+      Core core = Core.find (dir + name);
+      if (core != null)
+        return new CoreResource(this, name, core);
+      return null;
+    }
+  }
+
+  static final class CoreResource extends Resource
+  {
+    final Core core;
+
+    CoreResource(CoreURLLoader loader, String name, Core core)
+    {
+      super(loader, name);
+      this.core = core;
+    }
+
+    InputStream getInputStream() throws IOException
+    {
+      return new CoreInputStream(core);
+    }
+
+    public int getLength()
+    {
+      return core.length;
+    }
+
+    public URL getURL()
+    {
+      try
+        {
+          return new URL(loader.baseURL, name,
+                         loader.classloader.getURLStreamHandler("core"));
+        }
+      catch (MalformedURLException e)
+        {
+          InternalError ie = new InternalError();
+          ie.initCause(e);
+          throw ie;
+        }
+    }
+  }
+
   // Constructors
 
   /**
@@ -817,6 +878,8 @@ public class URLClassLoader extends SecureClassLoader
               loader = new JarURLLoader(this, newUrl);
             else if ("file".equals(protocol))
               loader = new FileURLLoader(this, newUrl);
+	    else if ("xxxFIXMExxxcore".equals(protocol))
+	      loader = new CoreURLLoader(this, newUrl);
             else
               loader = new RemoteURLLoader(this, newUrl);
 
diff --git a/libjava/java/nio/channels/FileLock.java b/libjava/java/nio/channels/FileLock.java
index 629f5ef79ec..46c5d812279 100644
--- a/libjava/java/nio/channels/FileLock.java
+++ b/libjava/java/nio/channels/FileLock.java
@@ -1,5 +1,5 @@
 /* FileLock.java --
-   Copyright (C) 2002 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2005 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -132,6 +132,19 @@ public abstract class FileLock
    */
   public final String toString()
   {
-    return "file-lock:pos=" + position + "size=" + size;
+    StringBuffer buf = new StringBuffer(getClass().getName());
+    buf.append("[");
+    buf.append(position);
+    buf.append(":");
+    buf.append(size);
+    if (shared)
+      buf.append(" shared");
+    else
+      buf.append(" exclusive");
+    if (isValid())
+      buf.append(" valid]");
+    else
+      buf.append(" invalid]");
+    return buf.toString();
   }
 }
diff --git a/libjava/java/nio/charset/Charset.java b/libjava/java/nio/charset/Charset.java
index c7672c1c3df..53abe79f65b 100644
--- a/libjava/java/nio/charset/Charset.java
+++ b/libjava/java/nio/charset/Charset.java
@@ -1,5 +1,5 @@
 /* Charset.java -- 
-   Copyright (C) 2002, 2004  Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -227,21 +227,10 @@ public abstract class Charset implements Comparable
   {
     try
       {
-        // NB: This implementation serializes different threads calling
-        // Charset.encode(), a potential performance problem.  It might
-        // be better to remove the cache, or use ThreadLocal to cache on
-        // a per-thread basis.
-        synchronized (Charset.class)
-          {
-            if (cachedEncoder == null)
-              {
-                cachedEncoder = newEncoder ()
-                  .onMalformedInput (CodingErrorAction.REPLACE)
-                  .onUnmappableCharacter (CodingErrorAction.REPLACE);
-              }
-
-            return cachedEncoder.encode (cb);
-          }
+	CharsetEncoder enc = newEncoder ()
+	  .onMalformedInput (CodingErrorAction.REPLACE)
+	  .onUnmappableCharacter (CodingErrorAction.REPLACE);
+	return enc.encode (cb);
       }
     catch (CharacterCodingException e)
       {
@@ -258,21 +247,10 @@ public abstract class Charset implements Comparable
   {
     try
       {
-        // NB: This implementation serializes different threads calling
-        // Charset.decode(), a potential performance problem.  It might
-        // be better to remove the cache, or use ThreadLocal to cache on
-        // a per-thread basis.
-        synchronized (Charset.class)
-          {
-            if (cachedDecoder == null)
-              {
-                cachedDecoder = newDecoder ()
-                  .onMalformedInput (CodingErrorAction.REPLACE)
-                  .onUnmappableCharacter (CodingErrorAction.REPLACE);
-              }
-
-            return cachedDecoder.decode (bb);
-          }
+	CharsetDecoder dec = newDecoder ()
+	  .onMalformedInput (CodingErrorAction.REPLACE)
+	  .onUnmappableCharacter (CodingErrorAction.REPLACE);
+	return dec.decode (bb);
       }
     catch (CharacterCodingException e)
       {
diff --git a/libjava/java/text/MessageFormat.java b/libjava/java/text/MessageFormat.java
index 6c1b0508bda..4a24afd1f44 100644
--- a/libjava/java/text/MessageFormat.java
+++ b/libjava/java/text/MessageFormat.java
@@ -113,6 +113,7 @@ public class MessageFormat extends Format
 	  formatClass = java.util.Date.class;
 
 	  int val = DateFormat.DEFAULT;
+	  boolean styleIsPattern = false;
 	  if (style == null)
 	    ;
 	  else if (style.equals("short"))
@@ -123,13 +124,15 @@ public class MessageFormat extends Format
 	    val = DateFormat.LONG;
 	  else if (style.equals("full"))
 	    val = DateFormat.FULL;
+	  else
+	    styleIsPattern = true;
 
 	  if (type.equals("time"))
 	    format = DateFormat.getTimeInstance(val, loc);
 	  else
 	    format = DateFormat.getDateInstance(val, loc);
 
-	  if (style != null && val == DateFormat.DEFAULT)
+	  if (styleIsPattern)
 	    {
 	      SimpleDateFormat sdf = (SimpleDateFormat) format;
 	      sdf.applyPattern(style);
diff --git a/libjava/java/util/BitSet.java b/libjava/java/util/BitSet.java
index cf7a83ed083..d6822d9fb90 100644
--- a/libjava/java/util/BitSet.java
+++ b/libjava/java/util/BitSet.java
@@ -380,7 +380,7 @@ public class BitSet implements Cloneable, Serializable
       }
 
     int len = Math.min(hi_offset, bits.length - 1);
-    int reverse = ~lo_bit;
+    int reverse = 64 - lo_bit;
     int i;
     for (i = 0; lo_offset < len; lo_offset++, i++)
       bs.bits[i] = ((bits[lo_offset] >>> lo_bit)
diff --git a/libjava/java/util/LinkedHashMap.java b/libjava/java/util/LinkedHashMap.java
index f58cf3fe70e..d18d6f8e4a4 100644
--- a/libjava/java/util/LinkedHashMap.java
+++ b/libjava/java/util/LinkedHashMap.java
@@ -1,6 +1,6 @@
 /* LinkedHashMap.java -- a class providing hashtable data structure,
    mapping Object --> Object, with linked list traversal
-   Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -186,6 +186,7 @@ public class LinkedHashMap extends HashMap
               succ = null;
               pred = root.pred;
               pred.succ = this;
+              root.pred = this;
             }
         }
     }
diff --git a/libjava/java/util/logging/natLogger.cc b/libjava/java/util/logging/natLogger.cc
index 15d1ab70efd..4e13e76bfcd 100644
--- a/libjava/java/util/logging/natLogger.cc
+++ b/libjava/java/util/logging/natLogger.cc
@@ -1,6 +1,6 @@
 // natLogger.cc - Native part of Logger class.
 
-/* Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2005  Free Software Foundation
 
    This Logger is part of libgcj.
 
@@ -31,7 +31,7 @@ java::util::logging::Logger::getCallerStackFrame ()
   gnu::gcj::runtime::StackTrace *t 
     = new gnu::gcj::runtime::StackTrace(4);
   java::lang::Class *klass = NULL;
-  int i = 2;
+  int i = 1;
   try
     {
       // skip until this class