+2002-10-31 Stephen Crawley <crawley@dstc.edu.au>
+
+ * java/lang/Double.java (valueOf): Return new Double(parseDouble(s)).
+
+2002-10-31 Wu Gansha <gansha.wu@intel.com>:
+
+ * java/util/ArrayList.java (readObject, writeObject): Only read/write
+ size items.
+
+2002-10-31 Wu Gansha <gansha.wu@intel.com>:
+
+ * java/io/DataInputStream.java (convertFromUTF): Give StringBuffer an
+ initial estimated size to avoid enlarge buffer frequently.
+
+2002-10-31 Wu Gansha <gansha.wu@intel.com>:
+
+ * java/lang/reflect/Proxy.java (ProxyType): Set loader to System
+ ClassLoader when null.
+ (ProxyType.hashCode): Loader null check no longer needed.
+ (ProxyType.sameTypes): New method.
+ (ProxyType.equals): Use new method.
+
+2002-10-31 Mark Wielaard <mark@klomp.org>
+
+ * java/net/URLDecoder.java (decode): Initialize Stringbuffer size to
+ length of String.
+ * java/net/URLEncoder.java (encode): Likewise.
+
+2002-10-31 Mark Wielaard <mark@klomp.org>
+
+ * java/util/zip/ZipInputStream.java (getNextEntry): Throw IOException
+ when stream is closed.
+ (closeEntry): Likewise.
+ (read): Likewise.
+ * java/util/zip/ZipOutputStream.java (putNextEntry): Throw
+ ZipException when no entry active.
+ (closeEntry): Likewise.
+ (write): Likewise.
+
2002-11-02 Tom Tromey <tromey@redhat.com>
* java/lang/Class.h: Move JV_STATE_ERROR before JV_STATE_DONE.
static String convertFromUTF(byte[] buf)
throws EOFException, UTFDataFormatException
{
- StringBuffer strbuf = new StringBuffer();
+ // Give StringBuffer an initial estimated size to avoid
+ // enlarge buffer frequently
+ StringBuffer strbuf = new StringBuffer(buf.length/2 + 2);
for (int i = 0; i < buf.length; )
{
*/
public static Double valueOf(String s)
{
- // XXX just call new Double(parseDouble(s));
- if (s == null)
- throw new NullPointerException();
- return new Double(s);
+ return new Double(parseDouble(s));
}
/**
private static native Class generateProxyClass0(ClassLoader loader,
ProxyData data);
-\f
/**
* Helper class for mapping unique ClassLoader and interface combinations
* to proxy classes.
*/
ProxyType(ClassLoader loader, Class[] interfaces)
{
+ if (loader == null)
+ loader = ClassLoader.getSystemClassLoader();
this.loader = loader;
this.interfaces = interfaces;
}
*/
public int hashCode()
{
- int hash = (loader == null) ? 0 : loader.hashCode();
+ //loader is always not null
+ int hash = loader.hashCode();
for (int i = 0; i < interfaces.length; i++)
hash = hash * 31 + interfaces[i].hashCode();
return hash;
}
+ // A more comprehensive comparison of two arrays,
+ // ignore array element order, and
+ // ignore redundant elements
+ private static boolean sameTypes(Class arr1[], Class arr2[]) {
+ if (arr1.length == 1 && arr2.length == 1) {
+ return arr1[0] == arr2[0];
+ }
+
+ // total occurrance of elements of arr1 in arr2
+ int total_occ_of_arr1_in_arr2 = 0;
+ each_type:
+ for (int i = arr1.length; --i >= 0; )
+ {
+ Class t = arr1[i];
+ for (int j = i; --j >= 0; )
+ {
+ if (t == arr1[j])
+ { //found duplicate type
+ continue each_type;
+ }
+ }
+
+ // count c(a unique element of arr1)'s
+ // occurrences in arr2
+ int occ_in_arr2 = 0;
+ for (int j = arr2.length; --j >= 0; )
+ {
+ if (t == arr2[j])
+ {
+ ++occ_in_arr2;
+ }
+ }
+ if (occ_in_arr2 == 0)
+ { // t does not occur in arr2
+ return false;
+ }
+
+ total_occ_of_arr1_in_arr2 += occ_in_arr2;
+ }
+ // now, each element of arr2 must have been visited
+ return total_occ_of_arr1_in_arr2 == arr2.length;
+ }
+
/**
* Calculates equality.
*
ProxyType pt = (ProxyType) other;
if (loader != pt.loader || interfaces.length != pt.interfaces.length)
return false;
- int i = interfaces.length;
- while (--i >= 0)
- if (interfaces[i] != pt.interfaces[i])
- return false;
- return true;
+ return sameTypes(interfaces, pt.interfaces);
}
} // class ProxyType
-\f
/**
* Helper class which allows hashing of a method name and signature
* without worrying about return type, declaring class, or throws clause,
}
} // class ProxySignature
-\f
/**
* A flat representation of all data needed to generate bytecode/instantiate
* a proxy class. This is basically a struct.
}
} // class ProxyData
-\f
/**
* Does all the work of building a class. By making this a nested class,
* this code is not loaded in memory if the VM has a native
public class URLDecoder
{
/**
- * Constructor for compatibility with Sun's JDK.
+ * Public contructor. Note that this class has only static methods.
*/
public URLDecoder ()
{
public static String decode(String s, String encoding)
throws UnsupportedEncodingException
{
- StringBuffer result = new StringBuffer();
-
// First convert all '+' characters to spaces.
String str = s.replace('+', ' ');
int start = 0;
byte[] bytes = null;
int length = str.length();
+ StringBuffer result = new StringBuffer(length);
while ((i = str.indexOf('%', start)) >= 0)
{
// Add all non-encoded characters to the result buffer
/* URLEncoder.java -- Class to convert strings to a properly encoded URL
- Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.io.UnsupportedEncodingException;
-/**
+/*
* Written using on-line Java Platform 1.2/1.4 API Specification, as well
* as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998).
* Status: Believed complete and correct.
public static String encode(String s, String encoding)
throws UnsupportedEncodingException
{
- StringBuffer result = new StringBuffer();
int length = s.length();
int start = 0;
int i = 0;
+ StringBuffer result = new StringBuffer(length);
while (true)
{
while ( i < length && isSafe(s.charAt(i)) )
// We serialize unused list entries to preserve capacity.
int len = data.length;
s.writeInt(len);
- for (int i = 0; i < len; i++)
+ // it would be more efficient to just write "size" items,
+ // this need readObject read "size" items too.
+ for (int i = 0; i < size; i++)
s.writeObject(data[i]);
}
s.defaultReadObject();
int capacity = s.readInt();
data = new Object[capacity];
- for (int i = 0; i < capacity; i++)
+ for (int i = 0; i < size; i++)
data[i] = s.readObject();
}
}
public ZipEntry getNextEntry() throws IOException
{
if (crc == null)
- throw new IllegalStateException("Closed.");
+ throw new IOException("Stream closed.");
if (entry != null)
closeEntry();
public void closeEntry() throws IOException
{
if (crc == null)
- throw new IllegalStateException("Closed.");
+ throw new IOException("Stream closed.");
if (entry == null)
return;
public int read(byte[] b, int off, int len) throws IOException
{
if (crc == null)
- throw new IllegalStateException("Closed.");
+ throw new IOException("Stream closed.");
if (entry == null)
return -1;
boolean finished = false;
* is not set in the entry, the current time is used.
* @param entry the entry.
* @exception IOException if an I/O error occured.
- * @exception IllegalStateException if stream was finished
+ * @exception ZipException if stream was finished.
*/
public void putNextEntry(ZipEntry entry) throws IOException
{
if (entries == null)
- throw new IllegalStateException("ZipOutputStream was finished");
+ throw new ZipException("ZipOutputStream was finished");
int method = entry.getMethod();
int flags = 0;
/**
* Closes the current entry.
* @exception IOException if an I/O error occured.
- * @exception IllegalStateException if no entry is active.
+ * @exception ZipException if no entry is active.
*/
public void closeEntry() throws IOException
{
if (curEntry == null)
- throw new IllegalStateException("No open entry");
+ throw new ZipException("No open entry");
/* First finish the deflater, if appropriate */
if (curMethod == DEFLATED)
/**
* Writes the given buffer to the current entry.
* @exception IOException if an I/O error occured.
- * @exception IllegalStateException if no entry is active.
+ * @exception ZipException if no entry is active.
*/
public void write(byte[] b, int off, int len) throws IOException
{
if (curEntry == null)
- throw new IllegalStateException("No open entry.");
+ throw new ZipException("No open entry.");
switch (curMethod)
{
git://gcc.gnu.org / gcc.git / commitdiff