This is the mail archive of the
java-patches@gcc.gnu.org
mailing list for the Java project.
Patch: FYI: Classpath merge
- From: Tom Tromey <tromey at redhat dot com>
- To: Java Patch List <java-patches at gcc dot gnu dot org>
- Date: 10 Nov 2002 14:57:41 -0700
- Subject: Patch: FYI: Classpath merge
- Reply-to: tromey at redhat dot com
I'm checking this in.
This copies over a bunch of classes from Classpath.
These are all bug fixes of one sort or another.
Tom
Index: ChangeLog
from Tom Tromey <tromey@redhat.com>
* java/io/Externalizable.java, java/io/FilePermission.java,
java/io/ObjectStreamConstants.java, java/io/Serializable.java,
java/io/SerializablePermission.java, java/text/Format.java,
java/util/AbstractMap.java, java/util/HashMap.java,
java/util/LinkedHashMap.java, javax/naming/BinaryRefAddr.java: New
versions from Classpath.
Index: java/io/Externalizable.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/Externalizable.java,v
retrieving revision 1.3
diff -u -r1.3 Externalizable.java
--- java/io/Externalizable.java 22 Jan 2002 22:40:14 -0000 1.3
+++ java/io/Externalizable.java 10 Nov 2002 21:41:29 -0000
@@ -62,6 +62,7 @@
*/
public interface Externalizable extends Serializable
{
+ static final long serialVersionUID = -282491828744381764L;
/**
* This method restores an object's state by reading in the instance data
Index: java/io/FilePermission.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/FilePermission.java,v
retrieving revision 1.3
diff -u -r1.3 FilePermission.java
--- java/io/FilePermission.java 22 Jan 2002 22:40:14 -0000 1.3
+++ java/io/FilePermission.java 10 Nov 2002 21:41:29 -0000
@@ -41,7 +41,10 @@
import java.security.*;
-public final class FilePermission extends Permission implements Serializable {
+public final class FilePermission extends Permission implements Serializable
+{
+ static final long serialVersionUID = 7930732926638008763L;
+
private static final String CURRENT_DIRECTORY = System.getProperty("user.dir");
private boolean usingPerms = false;
private boolean readPerm = false;
Index: java/io/ObjectStreamConstants.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/ObjectStreamConstants.java,v
retrieving revision 1.3
diff -u -r1.3 ObjectStreamConstants.java
--- java/io/ObjectStreamConstants.java 15 Jun 2002 18:59:15 -0000 1.3
+++ java/io/ObjectStreamConstants.java 10 Nov 2002 21:41:29 -0000
@@ -70,7 +70,7 @@
final static byte TC_PROXYCLASSDESC = (byte)125; //0x7D
final static byte TC_BASE = TC_NULL;
- final static byte TC_MAX = TC_EXCEPTION;
+ final static byte TC_MAX = TC_PROXYCLASSDESC;
final static int baseWireHandle = 0x7e0000;
Index: java/io/Serializable.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/Serializable.java,v
retrieving revision 1.5
diff -u -r1.5 Serializable.java
--- java/io/Serializable.java 22 Jan 2002 22:40:14 -0000 1.5
+++ java/io/Serializable.java 10 Nov 2002 21:41:30 -0000
@@ -51,4 +51,5 @@
*/
public interface Serializable
{
+ static final long serialVersionUID = 1196656838076753133L;
} // interface Serializable
Index: java/io/SerializablePermission.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/SerializablePermission.java,v
retrieving revision 1.3
diff -u -r1.3 SerializablePermission.java
--- java/io/SerializablePermission.java 22 Jan 2002 22:40:14 -0000 1.3
+++ java/io/SerializablePermission.java 10 Nov 2002 21:41:30 -0000
@@ -61,7 +61,8 @@
*/
public final class SerializablePermission extends BasicPermission
{
-
+ static final long serialVersionUID = 8537212141160296410L;
+
/*
* Class Variables
*/
Index: java/text/Format.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/text/Format.java,v
retrieving revision 1.6
diff -u -r1.6 Format.java
--- java/text/Format.java 22 Jan 2002 22:40:37 -0000 1.6
+++ java/text/Format.java 10 Nov 2002 21:41:30 -0000
@@ -59,6 +59,8 @@
*/
public abstract class Format implements Serializable, Cloneable
{
+ static final long serialVersionUID = -299282585814624189L;
+
/**
* This method initializes a new instance of <code>Format</code>.
* It performs no actions, but acts as a default constructor for
Index: java/util/AbstractMap.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/util/AbstractMap.java,v
retrieving revision 1.8
diff -u -r1.8 AbstractMap.java
--- java/util/AbstractMap.java 18 Jun 2002 15:39:46 -0000 1.8
+++ java/util/AbstractMap.java 10 Nov 2002 21:41:31 -0000
@@ -466,6 +466,11 @@
return AbstractMap.this.size();
}
+ public boolean contains(Object value)
+ {
+ return containsValue(value);
+ }
+
public Iterator iterator()
{
return new Iterator()
@@ -527,8 +532,9 @@
* @author Jon Zeppieri
* @author Eric Blake <ebb9@email.byu.edu>
*/
+ // XXX - FIXME Use fully qualified implements as gcj 3.1 workaround.
static class BasicMapEntry implements Map.Entry
- { // XXX - FIXME Use fully qualified implements as gcj 3.1 workaround.
+ {
/**
* The key. Package visible for direct manipulation.
*/
@@ -553,16 +559,14 @@
/**
* Compares the specified object with this entry. Returns true only if
* the object is a mapping of identical key and value. In other words,
- * this must be:
- *
-<pre>(o instanceof Map.Entry) &&
-(getKey() == null ? ((HashMap) o).getKey() == null
- : getKey().equals(((HashMap) o).getKey())) &&
-(getValue() == null ? ((HashMap) o).getValue() == null
- : getValue().equals(((HashMap) o).getValue()))</pre>
+ * this must be:<br>
+ * <pre>(o instanceof Map.Entry)
+ * && (getKey() == null ? ((HashMap) o).getKey() == null
+ * : getKey().equals(((HashMap) o).getKey()))
+ * && (getValue() == null ? ((HashMap) o).getValue() == null
+ * : getValue().equals(((HashMap) o).getValue()))</pre>
*
* @param o the object to compare
- *
* @return <code>true</code> if it is equal
*/
public final boolean equals(Object o)
@@ -605,10 +609,9 @@
/**
* Returns the hash code of the entry. This is defined as the exclusive-or
* of the hashcodes of the key and value (using 0 for null). In other
- * words, this must be:
- *
-<pre>(getKey() == null ? 0 : getKey().hashCode())
-^ (getValue() == null ? 0 : getValue().hashCode())</pre>
+ * words, this must be:<br>
+ * <pre>(getKey() == null ? 0 : getKey().hashCode())
+ * ^ (getValue() == null ? 0 : getValue().hashCode())</pre>
*
* @return the hash code
*/
Index: java/util/HashMap.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/util/HashMap.java,v
retrieving revision 1.12
diff -u -r1.12 HashMap.java
--- java/util/HashMap.java 18 Jun 2002 15:39:51 -0000 1.12
+++ java/util/HashMap.java 10 Nov 2002 21:41:31 -0000
@@ -180,6 +180,15 @@
}
/**
+ * Called when this entry is accessed via {@link #put(Object, Object)}.
+ * This version does nothing, but in LinkedHashMap, it must do some
+ * bookkeeping for access-traversal mode.
+ */
+ void access()
+ {
+ }
+
+ /**
* Called when this entry is removed from the map. This version simply
* returns the value, but in LinkedHashMap, it must also do bookkeeping.
*
@@ -338,8 +347,12 @@
while (e != null)
{
if (equals(key, e.key))
- // Must use this method for necessary bookkeeping in LinkedHashMap.
- return e.setValue(value);
+ {
+ e.access(); // Must call this for bookkeeping in LinkedHashMap.
+ Object r = e.value;
+ e.value = value;
+ return r;
+ }
else
e = e.next;
}
@@ -368,8 +381,8 @@
public void putAll(Map m)
{
Iterator itr = m.entrySet().iterator();
-
- for (int msize = m.size(); msize > 0; msize--)
+ int msize = m.size();
+ while (msize-- > 0)
{
Map.Entry e = (Map.Entry) itr.next();
// Optimize in case the Entry is one of our own.
@@ -379,9 +392,7 @@
put(entry.key, entry.value);
}
else
- {
- put(e.getKey(), e.getValue());
- }
+ put(e.getKey(), e.getValue());
}
}
@@ -520,7 +531,7 @@
public boolean remove(Object o)
{
// Test against the size of the HashMap to determine if anything
- // really got removed. This is neccessary because the return value
+ // really got removed. This is necessary because the return value
// of HashMap.remove() is ambiguous in the null case.
int oldsize = size;
HashMap.this.remove(o);
@@ -634,7 +645,6 @@
void addEntry(Object key, Object value, int idx, boolean callRemove)
{
HashEntry e = new HashEntry(key, value);
-
e.next = buckets[idx];
buckets[idx] = e;
}
@@ -648,17 +658,18 @@
* @see #entrySet()
*/
// Package visible, for use in nested classes.
- HashEntry getEntry(Object o)
+ final HashEntry getEntry(Object o)
{
- if (!(o instanceof Map.Entry))
+ if (! (o instanceof Map.Entry))
return null;
Map.Entry me = (Map.Entry) o;
- int idx = hash(me.getKey());
+ Object key = me.getKey();
+ int idx = hash(key);
HashEntry e = buckets[idx];
while (e != null)
{
- if (e.equals(me))
- return e;
+ if (equals(e.key, key))
+ return equals(e.value, me.getValue()) ? e : null;
e = e.next;
}
return null;
@@ -699,9 +710,8 @@
{
Iterator itr = m.entrySet().iterator();
int msize = m.size();
- this.size = msize;
-
- for (; msize > 0; msize--)
+ size = msize;
+ while (msize-- > 0)
{
Map.Entry e = (Map.Entry) itr.next();
Object key = e.getKey();
@@ -742,9 +752,7 @@
dest.next = e;
}
else
- {
- buckets[idx] = e;
- }
+ buckets[idx] = e;
HashEntry next = e.next;
e.next = null;
@@ -797,13 +805,14 @@
// Read the threshold and loadFactor fields.
s.defaultReadObject();
- // Read and use capacity.
+ // Read and use capacity, followed by key/value pairs.
buckets = new HashEntry[s.readInt()];
int len = s.readInt();
-
- // Read and use key/value pairs.
- for ( ; len > 0; len--)
- put(s.readObject(), s.readObject());
+ while (len-- > 0)
+ {
+ Object key = s.readObject();
+ addEntry(key, s.readObject(), hash(key), false);
+ }
}
/**
Index: java/util/LinkedHashMap.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/util/LinkedHashMap.java,v
retrieving revision 1.4
diff -u -r1.4 LinkedHashMap.java
--- java/util/LinkedHashMap.java 18 Jun 2002 15:39:53 -0000 1.4
+++ java/util/LinkedHashMap.java 10 Nov 2002 21:41:32 -0000
@@ -1,6 +1,6 @@
/* LinkedHashMap.java -- a class providing hashtable data structure,
mapping Object --> Object, with linked list traversal
- Copyright (C) 2001 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@@ -50,8 +50,17 @@
* can cause primary clustering) and rehashing (which does not fit very
* well with Java's method of precomputing hash codes) are avoided. In
* addition, this maintains a doubly-linked list which tracks either
- * insertion or access order. Note that the insertion order is not
- * modified if a <code>put</code> simply reinserts a key in the map.
+ * insertion or access order.
+ * <p>
+ *
+ * In insertion order, calling <code>put</code> adds the key to the end of
+ * traversal, unless the key was already in the map; changing traversal order
+ * requires removing and reinserting a key. On the other hand, in access
+ * order, all calls to <code>put</code> and <code>get</code> cause the
+ * accessed key to move to the end of the traversal list. Note that any
+ * accesses to the map's contents via its collection views and iterators do
+ * not affect the map's traversal order, since the collection views do not
+ * call <code>put</code> or <code>get</code>.
* <p>
*
* One of the nice features of tracking insertion order is that you can
@@ -61,19 +70,19 @@
* <p>
*
* When using this {@link #LinkedHashMap(int, float, boolean) constructor},
- * you build an access-order mapping. This can be used to implement LRU
- * caches, for example. In this case, every invocation of <code>put</code>,
- * <code>putAll</code>, or <code>get</code> moves the accessed entry to
- * the end of the iteration list. By overriding
- * {@link #removeEldestEntry(Map.Entry)}, you can also control the
- * removal of the oldest entry, and thereby do things like keep the map
- * at a fixed size.
+ * you can build an access-order mapping. This can be used to implement LRU
+ * caches, for example. By overriding {@link #removeEldestEntry(Map.Entry)},
+ * you can also control the removal of the oldest entry, and thereby do
+ * things like keep the map at a fixed size.
* <p>
*
* Under ideal circumstances (no collisions), LinkedHashMap offers O(1)
* performance on most operations (<code>containsValue()</code> is,
* of course, O(n)). In the worst case (all keys map to the same
- * hash code -- very unlikely), most operations are O(n).
+ * hash code -- very unlikely), most operations are O(n). Traversal is
+ * faster than in HashMap (proportional to the map size, and not the space
+ * allocated for the map), but other operations may be slower because of the
+ * overhead of the maintaining the traversal order list.
* <p>
*
* LinkedHashMap accepts the null key and null values. It is not
@@ -105,19 +114,15 @@
private static final long serialVersionUID = 3801124242820219131L;
/**
- * The first Entry to iterate over.
- */
- transient LinkedHashEntry head;
-
- /**
- * The last Entry to iterate over.
+ * The oldest Entry to begin iteration at.
*/
- transient LinkedHashEntry tail;
+ transient LinkedHashEntry root;
/**
* The iteration order of this linked hash map: <code>true</code> for
* access-order, <code>false</code> for insertion-order.
- * @serial
+ *
+ * @serial true for access order traversal
*/
final boolean accessOrder;
@@ -127,69 +132,91 @@
*/
class LinkedHashEntry extends HashEntry
{
- /** The predecessor in the iteration list, null if this is the eldest. */
+ /**
+ * The predecessor in the iteration list. If this entry is the root
+ * (eldest), pred points to the newest entry.
+ */
LinkedHashEntry pred;
+
/** The successor in the iteration list, null if this is the newest. */
LinkedHashEntry succ;
/**
* Simple constructor.
+ *
* @param key the key
* @param value the value
*/
LinkedHashEntry(Object key, Object value)
{
super(key, value);
- if (head == null)
- head = this;
- pred = tail;
- tail = this;
- if (pred != null)
- pred.succ = this;
+ if (root == null)
+ {
+ root = this;
+ pred = this;
+ }
+ else
+ {
+ pred = root.pred;
+ pred.succ = this;
+ root.pred = this;
+ }
}
/**
- * Sets the value of this entry, and shuffles it to the end of
- * the list if this is in access-order.
- * @param value the new value
- * @return the prior value
+ * Called when this entry is accessed via put or get. This version does
+ * the necessary bookkeeping to keep the doubly-linked list in order,
+ * after moving this element to the newest position in access order.
*/
- public Object setValue(Object value)
+ void access()
{
if (accessOrder && succ != null)
{
- succ.pred = pred;
- if (pred == null)
- head = succ;
+ modCount++;
+ if (this == root)
+ {
+ root = succ;
+ pred.succ = this;
+ succ = null;
+ }
else
- pred.succ = succ;
- succ = null;
- pred = tail;
- pred.succ = this;
- tail = this;
+ {
+ pred.succ = succ;
+ succ.pred = pred;
+ succ = null;
+ pred = root.pred;
+ pred.succ = this;
+ }
}
- return super.setValue(value);
}
/**
* Called when this entry is removed from the map. This version does
* the necessary bookkeeping to keep the doubly-linked list in order.
+ *
* @return the value of this key as it is removed
*/
Object cleanup()
{
- if (pred == null)
- head = succ;
- else
- pred.succ = succ;
- if (succ == null)
- tail = pred;
+ if (this == root)
+ {
+ root = succ;
+ if (succ != null)
+ succ.pred = pred;
+ }
+ else if (succ == null)
+ {
+ pred.succ = null;
+ root.pred = pred;
+ }
else
- succ.pred = pred;
-
+ {
+ pred.succ = succ;
+ succ.pred = pred;
+ }
return value;
}
- }
+ } // class LinkedHashEntry
/**
* Construct a new insertion-ordered LinkedHashMap with the default
@@ -253,10 +280,9 @@
* Construct a new LinkedHashMap with a specific inital capacity, load
* factor, and ordering mode.
*
- * @param initialCapacity the initial capacity (>=0)
- * @param loadFactor the load factor (>0, not NaN)
+ * @param initialCapacity the initial capacity (>=0)
+ * @param loadFactor the load factor (>0, not NaN)
* @param accessOrder true for access-order, false for insertion-order
- *
* @throws IllegalArgumentException if (initialCapacity < 0) ||
* ! (loadFactor > 0.0)
*/
@@ -273,8 +299,7 @@
public void clear()
{
super.clear();
- head = null;
- tail = null;
+ root = null;
}
/**
@@ -282,12 +307,11 @@
* <code>o</code>, such that <code>o.equals(value)</code>.
*
* @param value the value to search for in this HashMap
- *
* @return <code>true</code> if at least one key maps to the value
*/
public boolean containsValue(Object value)
{
- LinkedHashEntry e = head;
+ LinkedHashEntry e = root;
while (e != null)
{
if (equals(value, e.value))
@@ -318,23 +342,7 @@
{
if (equals(key, e.key))
{
- if (accessOrder)
- {
- modCount++;
- LinkedHashEntry l = (LinkedHashEntry) e;
- if (l.succ != null)
- {
- l.succ.pred = l.pred;
- if (l.pred == null)
- head = l.succ;
- else
- l.pred.succ = l.succ;
- l.succ = null;
- l.pred = tail;
- tail.succ = l;
- tail = l;
- }
- }
+ e.access();
return e.value;
}
e = e.next;
@@ -352,20 +360,21 @@
* <p>
*
* For example, to keep the Map limited to 100 entries, override as follows:
- *
-<pre>private static final int MAX_ENTRIES = 100;
-
-protected boolean removeEldestEntry(Map.Entry eldest)
-{
- return size() > MAX_ENTRIES;
-}
-</pre><p>
+ * <pre>
+ * private static final int MAX_ENTRIES = 100;
+ * protected boolean removeEldestEntry(Map.Entry eldest)
+ * {
+ * return size() > MAX_ENTRIES;
+ * }
+ * </pre><p>
*
* Typically, this method does not modify the map, but just uses the
* return value as an indication to <code>put</code> whether to proceed.
* However, if you override it to modify the map, you must return false
- * (indicating that <code>put</code> should do nothing), or face
- * unspecified behavior.
+ * (indicating that <code>put</code> should leave the modified map alone),
+ * or you face unspecified behavior. Remember that in access-order mode,
+ * even calling <code>get</code> is a structural modification, but using
+ * the collections views (such as <code>keySet</code>) is not.
* <p>
*
* This method is called after the eldest entry has been inserted, so
@@ -378,7 +387,6 @@
* returns true. For an access-order map, this is the least
* recently accessed; for an insertion-order map, this is the
* earliest element inserted.
- *
* @return true if <code>eldest</code> should be removed
*/
protected boolean removeEldestEntry(Map.Entry eldest)
@@ -396,33 +404,33 @@
* @param callRemove whether to call the removeEldestEntry method
* @see #put(Object, Object)
* @see #removeEldestEntry(Map.Entry)
+ * @see LinkedHashEntry#LinkedHashEntry(Object, Object)
*/
void addEntry(Object key, Object value, int idx, boolean callRemove)
{
LinkedHashEntry e = new LinkedHashEntry(key, value);
-
e.next = buckets[idx];
buckets[idx] = e;
-
- if (callRemove && removeEldestEntry(head))
- remove(head);
+ if (callRemove && removeEldestEntry(root))
+ remove(root);
}
/**
* Helper method, called by clone() to reset the doubly-linked list.
+ *
* @param m the map to add entries from
* @see #clone()
*/
void putAllInternal(Map m)
{
- head = null;
- tail = null;
+ root = null;
super.putAllInternal(m);
}
/**
* Generates a parameterized iterator. This allows traversal to follow
* the doubly-linked list instead of the random bin order of HashMap.
+ *
* @param type {@link #KEYS}, {@link #VALUES}, or {@link #ENTRIES}
* @return the appropriate iterator
*/
@@ -430,17 +438,18 @@
{
return new Iterator()
{
- /** The current Entry */
- LinkedHashEntry current = head;
+ /** The current Entry. */
+ LinkedHashEntry current = root;
- /** The previous Entry returned by next() */
+ /** The previous Entry returned by next(). */
LinkedHashEntry last;
- /** The number of known modifications to the backing HashMap */
+ /** The number of known modifications to the backing Map. */
int knownMod = modCount;
/**
* Returns true if the Iterator has more elements.
+ *
* @return true if there are more elements
* @throws ConcurrentModificationException if the HashMap was modified
*/
@@ -453,6 +462,7 @@
/**
* Returns the next element in the Iterator's sequential view.
+ *
* @return the next element
* @throws ConcurrentModificationException if the HashMap was modified
* @throws NoSuchElementException if there is none
@@ -473,7 +483,6 @@
* with the <code>next()</code> method.
*
* @throws ConcurrentModificationException if the HashMap was modified
- *
* @throws IllegalStateException if called when there is no last element
*/
public void remove()
@@ -482,11 +491,10 @@
throw new ConcurrentModificationException();
if (last == null)
throw new IllegalStateException();
-
LinkedHashMap.this.remove(last.key);
last = null;
knownMod++;
}
};
}
-}
+} // class LinkedHashMap
Index: javax/naming/BinaryRefAddr.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/javax/naming/BinaryRefAddr.java,v
retrieving revision 1.6
diff -u -r1.6 BinaryRefAddr.java
--- javax/naming/BinaryRefAddr.java 4 Oct 2002 08:48:03 -0000 1.6
+++ javax/naming/BinaryRefAddr.java 10 Nov 2002 21:41:32 -0000
@@ -51,7 +51,7 @@
public class BinaryRefAddr extends RefAddr
{
static final long serialVersionUID = -3415254970957330361L;
-
+
/**
* The possibly null content of this RefAddr.
* Set by the constructor and returned by getContent.