FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Imported GNU Classpath 0.19 + gcj-import-20051115.

Browse source 
* sources.am: Regenerated.
       * Makefile.in: Likewise.
       * scripts/makemake.tcl: Use glob -nocomplain.

From-SVN: r107049
This commit is contained in:
Mark Wielaard 2005-11-15 23:20:01 +00:00
parent 02e549bfaa
commit 8f523f3a10
1241 changed files with 97711 additions and 25284 deletions
Download patch file Download diff file Expand all files Collapse all files

5
libjava/classpath/java/io/ByteArrayOutputStream.java
View file

@ -1,5 +1,6 @@
/* BufferedReader.java
Copyright (C) 1998, 1999, 2000, 2001, 2003, 2005 Free Software Foundation, Inc.
Copyright (C) 1998, 1999, 2000, 2001, 2003, 2005
Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -192,7 +193,7 @@ public class ByteArrayOutputStream extends OutputStream
*/
public String toString (int hibyte)
{
return new String (buf, 0, count, hibyte);
return new String (buf, hibyte, 0, count);
}
// Resize buffer to accommodate new bytes.

6
libjava/classpath/java/io/DataOutputStream.java
View file

@ -302,7 +302,7 @@ public class DataOutputStream extends FilterOutputStream implements DataOutput
*
* @exception IOException If an error occurs
*
* @see writeInt
* @see #writeInt(int)
* @see DataInput#readFloat
* @see Float#floatToIntBits
*/
@ -326,7 +326,7 @@ public class DataOutputStream extends FilterOutputStream implements DataOutput
*
* @exception IOException If an error occurs
*
* @see writeLong
* @see #writeLong(long)
* @see DataInput#readDouble
* @see Double#doubleToLongBits
*/
@ -363,7 +363,7 @@ public class DataOutputStream extends FilterOutputStream implements DataOutput
*
* @exception IOException If an error occurs
*
* @see writeChar
* @see #writeChar(char)
*/
public final void writeChars (String value) throws IOException
{

39
libjava/classpath/java/io/File.java
View file

@ -100,6 +100,17 @@ public class File implements Serializable, Comparable
* may be an absolute or relative path name.
*/
private String path;
/**
* The time (millisecond), when the last temporary file was created.
*/
private static long last_tmp;
/**
* The number of files, created during the current millisecond.
*/
private static int n_created;
/**
* This method tests whether or not the current thread is allowed to
@ -446,6 +457,8 @@ public class File implements Serializable, Comparable
else
return drvDir;
}
else if (path.equals(""))
return System.getProperty ("user.dir");
else
return System.getProperty ("user.dir") + separatorChar + path;
}
@ -532,6 +545,9 @@ public class File implements Serializable, Comparable
{
String prefix = null;
int nameSeqIndex = 0;
if (path.equals(""))
return null;
// The "prefix", if present, is the leading "/" on UNIX and
// either the drive specifier (e.g. "C:") or the leading "\\"
@ -943,8 +959,8 @@ public class File implements Serializable, Comparable
public URI toURI()
{
String abspath = getAbsolutePath();
if (isDirectory())
if (isDirectory() || path.equals(""))
abspath = abspath + separatorChar;
if (separatorChar == '\\')
@ -1059,7 +1075,7 @@ public class File implements Serializable, Comparable
*
* @since 1.2
*/
public static File createTempFile(String prefix, String suffix,
public static synchronized File createTempFile(String prefix, String suffix,
File directory)
throws IOException
{
@ -1091,10 +1107,23 @@ public class File implements Serializable, Comparable
// Now identify a file name and make sure it doesn't exist.
File file;
if (!VMFile.IS_DOS_8_3)
{
{
do
{
String filename = prefix + System.currentTimeMillis() + suffix;
long now = System.currentTimeMillis();
if (now > last_tmp)
{
// The last temporary file was created more than 1 ms ago.
last_tmp = now;
n_created = 0;
}
else
n_created++;
String name = Long.toHexString(now);
if (n_created > 0)
name += '_'+Integer.toHexString(n_created);
String filename = prefix + name + suffix;
file = new File(directory, filename);
}
while (VMFile.exists(file.path));

2
libjava/classpath/java/io/FileWriter.java
View file

@ -119,7 +119,7 @@ public class FileWriter extends OutputStreamWriter
* This method intializes a new <code>FileWriter</code> object to
* write to the
* specified named file. This form of the constructor allows the caller
* to determin whether data should be written starting at the beginning or
* to determine whether data should be written starting at the beginning or
* the end of the file.
*
* @param name The name of the file to write to

2
libjava/classpath/java/io/FilterReader.java
View file

@ -131,7 +131,7 @@ public abstract class FilterReader extends Reader
/**
* Calls the <code>in.skip(long)</code> method
*
* @param numBytes The requested number of chars to skip.
* @param num_chars The requested number of chars to skip.
*
* @return The value returned from <code>in.skip(long)</code>
*

25
libjava/classpath/java/io/InputStreamReader.java
View file

@ -38,16 +38,14 @@ exception statement from your version. */
package java.io;
import java.nio.charset.UnsupportedCharsetException;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import gnu.java.nio.charset.EncodingHelper;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.CharBuffer;
import java.nio.ByteBuffer;
import gnu.java.nio.charset.EncodingHelper;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
/**
* This class reads characters from a byte input stream. The characters
@ -251,8 +249,12 @@ public class InputStreamReader extends Reader
this.in = in;
this.decoder = decoder;
Charset charset = decoder.charset();
try {
maxBytesPerChar = decoder.charset().newEncoder().maxBytesPerChar();
if (charset == null)
maxBytesPerChar = 1f;
else
maxBytesPerChar = charset.newEncoder().maxBytesPerChar();
} catch(UnsupportedOperationException _){
maxBytesPerChar = 1f;
}
@ -260,7 +262,10 @@ public class InputStreamReader extends Reader
decoder.onMalformedInput(CodingErrorAction.REPLACE);
decoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
decoder.reset();
encoding = EncodingHelper.getOldCanonical(decoder.charset().name());
if (charset == null)
encoding = "US-ASCII";
else
encoding = EncodingHelper.getOldCanonical(decoder.charset().name());
}
/**

6
libjava/classpath/java/io/LineNumberReader.java
View file

@ -115,7 +115,7 @@ public class LineNumberReader extends BufferedReader
/**
* This method sets the current line number to the specified value.
*
* @param line_number The new line number
* @param lineNumber The new line number
*/
public void setLineNumber(int lineNumber)
{
@ -139,7 +139,7 @@ public class LineNumberReader extends BufferedReader
* is called, the line number will be restored to the saved line number in
* addition to the stream position.
*
* @param readlimit The number of chars that can be read before the
* @param readLimit The number of chars that can be read before the
* mark becomes invalid
*
* @exception IOException If an error occurs
@ -269,7 +269,7 @@ public class LineNumberReader extends BufferedReader
*
* @param buf The array into which the chars read should be stored
* @param offset The offset into the array to start storing chars
* @param len The requested number of chars to read
* @param count The requested number of chars to read
*
* @return The actual number of chars read, or -1 if end of stream
*

612
libjava/classpath/java/io/ObjectInputStream.java
View file

@ -39,7 +39,6 @@ exception statement from your version. */
package java.io;
import gnu.classpath.Configuration;
import gnu.java.io.ObjectIdentityWrapper;
import java.lang.reflect.Array;
@ -53,6 +52,8 @@ import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.TreeSet;
import java.util.Vector;
public class ObjectInputStream extends InputStream
@ -91,7 +92,6 @@ public class ObjectInputStream extends InputStream
}
this.resolveEnabled = false;
this.isDeserializing = false;
this.blockDataPosition = 0;
this.blockDataBytes = 0;
this.blockData = new byte[BUFFER_SIZE];
@ -99,7 +99,6 @@ public class ObjectInputStream extends InputStream
this.realInputStream = new DataInputStream(in);
this.nextOID = baseWireHandle;
this.objectLookupTable = new Hashtable();
this.validators = new Vector();
this.classLookupTable = new Hashtable();
setBlockDataMode(true);
readStreamHeader();
@ -113,7 +112,10 @@ public class ObjectInputStream extends InputStream
* <code>private void readObject (ObjectInputStream)</code>.
*
* If an exception is thrown from this method, the stream is left in
* an undefined state.
* an undefined state. This method can also throw Errors and
* RuntimeExceptions if caused by existing readResolve() user code.
*
* @return The object read from the underlying stream.
*
* @exception ClassNotFoundException The class that an object being
* read in belongs to cannot be found.
@ -121,294 +123,315 @@ public class ObjectInputStream extends InputStream
* @exception IOException Exception from underlying
* <code>InputStream</code>.
*/
public final Object readObject() throws ClassNotFoundException, IOException
public final Object readObject()
throws ClassNotFoundException, IOException
{
if (this.useSubclassMethod)
return readObjectOverride();
boolean was_deserializing;
Object ret_val;
was_deserializing = this.isDeserializing;
boolean is_consumed = false;
boolean old_mode = setBlockDataMode(false);
this.isDeserializing = true;
byte marker = this.realInputStream.readByte();
depth += 2;
if (DEBUG)
depth += 2;
if(dump) dumpElement("MARKER: 0x" + Integer.toHexString(marker) + " ");
try
{
switch (marker)
{
case TC_ENDBLOCKDATA:
{
ret_val = null;
is_consumed = true;
break;
}
case TC_BLOCKDATA:
case TC_BLOCKDATALONG:
{
if (marker == TC_BLOCKDATALONG)
{ if(dump) dumpElementln("BLOCKDATALONG"); }
else
{ if(dump) dumpElementln("BLOCKDATA"); }
readNextBlock(marker);
throw new StreamCorruptedException("Unexpected blockData");
}
case TC_NULL:
{
if(dump) dumpElementln("NULL");
ret_val = null;
break;
}
case TC_REFERENCE:
{
if(dump) dumpElement("REFERENCE ");
Integer oid = new Integer(this.realInputStream.readInt());
if(dump) dumpElementln(Integer.toHexString(oid.intValue()));
ret_val = ((ObjectIdentityWrapper)
this.objectLookupTable.get(oid)).object;
break;
}
case TC_CLASS:
{
if(dump) dumpElementln("CLASS");
ObjectStreamClass osc = (ObjectStreamClass)readObject();
Class clazz = osc.forClass();
assignNewHandle(clazz);
ret_val = clazz;
break;
}
case TC_PROXYCLASSDESC:
{
if(dump) dumpElementln("PROXYCLASS");
int n_intf = this.realInputStream.readInt();
String[] intfs = new String[n_intf];
for (int i = 0; i < n_intf; i++)
{
intfs[i] = this.realInputStream.readUTF();
System.out.println(intfs[i]);
}
boolean oldmode = setBlockDataMode(true);
Class cl = resolveProxyClass(intfs);
setBlockDataMode(oldmode);
ObjectStreamClass osc = lookupClass(cl);
assignNewHandle(osc);
if (!is_consumed)
{
byte b = this.realInputStream.readByte();
if (b != TC_ENDBLOCKDATA)
throw new IOException("Data annotated to class was not consumed." + b);
}
else
is_consumed = false;
ObjectStreamClass superosc = (ObjectStreamClass)readObject();
osc.setSuperclass(superosc);
ret_val = osc;
break;
}
case TC_CLASSDESC:
{
ObjectStreamClass osc = readClassDescriptor();
if (!is_consumed)
{
byte b = this.realInputStream.readByte();
if (b != TC_ENDBLOCKDATA)
throw new IOException("Data annotated to class was not consumed." + b);
}
else
is_consumed = false;
osc.setSuperclass ((ObjectStreamClass)readObject());
ret_val = osc;
break;
}
case TC_STRING:
case TC_LONGSTRING:
{
if(dump) dumpElement("STRING=");
String s = this.realInputStream.readUTF();
if(dump) dumpElementln(s);
ret_val = processResolution(null, s, assignNewHandle(s));
break;
}
case TC_ARRAY:
{
if(dump) dumpElementln("ARRAY");
ObjectStreamClass osc = (ObjectStreamClass)readObject();
Class componentType = osc.forClass().getComponentType();
if(dump) dumpElement("ARRAY LENGTH=");
int length = this.realInputStream.readInt();
if(dump) dumpElementln (length + "; COMPONENT TYPE=" + componentType);
Object array = Array.newInstance(componentType, length);
int handle = assignNewHandle(array);
readArrayElements(array, componentType);
if(dump)
for (int i = 0, len = Array.getLength(array); i < len; i++)
dumpElementln(" ELEMENT[" + i + "]=" + Array.get(array, i));
ret_val = processResolution(null, array, handle);
break;
}
case TC_OBJECT:
{
if(dump) dumpElementln("OBJECT");
ObjectStreamClass osc = (ObjectStreamClass)readObject();
Class clazz = osc.forClass();
if (!osc.realClassIsSerializable)
throw new NotSerializableException
(clazz + " is not Serializable, and thus cannot be deserialized.");
if (osc.realClassIsExternalizable)
{
Externalizable obj = osc.newInstance();
int handle = assignNewHandle(obj);
boolean read_from_blocks = ((osc.getFlags() & SC_BLOCK_DATA) != 0);
boolean oldmode = this.readDataFromBlock;
if (read_from_blocks)
setBlockDataMode(true);
obj.readExternal(this);
if (read_from_blocks)
{
setBlockDataMode(oldmode);
if (!oldmode)
if (this.realInputStream.readByte() != TC_ENDBLOCKDATA)
throw new IOException("No end of block data seen for class with readExternal (ObjectInputStream) method.");
}
ret_val = processResolution(osc, obj, handle);
break;
} // end if (osc.realClassIsExternalizable)
Object obj = newObject(clazz, osc.firstNonSerializableParentConstructor);
int handle = assignNewHandle(obj);
Object prevObject = this.currentObject;
ObjectStreamClass prevObjectStreamClass = this.currentObjectStreamClass;
this.currentObject = obj;
ObjectStreamClass[] hierarchy =
inputGetObjectStreamClasses(clazz);
for (int i = 0; i < hierarchy.length; i++)
{
this.currentObjectStreamClass = hierarchy[i];
if(dump) dumpElementln("Reading fields of " + this.currentObjectStreamClass.getName ());
// XXX: should initialize fields in classes in the hierarchy
// that aren't in the stream
// should skip over classes in the stream that aren't in the
// real classes hierarchy
Method readObjectMethod = this.currentObjectStreamClass.readObjectMethod;
if (readObjectMethod != null)
{
fieldsAlreadyRead = false;
boolean oldmode = setBlockDataMode(true);
callReadMethod(readObjectMethod, this.currentObjectStreamClass.forClass(), obj);
setBlockDataMode(oldmode);
}
else
{
readFields(obj, currentObjectStreamClass);
}
if (this.currentObjectStreamClass.hasWriteMethod())
{
if(dump) dumpElement("ENDBLOCKDATA? ");
try
{
// FIXME: XXX: This try block is to
// catch EOF which is thrown for some
// objects. That indicates a bug in
// the logic.
if (this.realInputStream.readByte() != TC_ENDBLOCKDATA)
throw new IOException
("No end of block data seen for class with readObject (ObjectInputStream) method.");
if(dump) dumpElementln("yes");
}
// catch (EOFException e)
// {
// if(dump) dumpElementln("no, got EOFException");
// }
catch (IOException e)
{
if(dump) dumpElementln("no, got IOException");
}
}
}
this.currentObject = prevObject;
this.currentObjectStreamClass = prevObjectStreamClass;
ret_val = processResolution(osc, obj, handle);
break;
}
case TC_RESET:
if(dump) dumpElementln("RESET");
clearHandles();
ret_val = readObject();
break;
case TC_EXCEPTION:
{
if(dump) dumpElement("EXCEPTION=");
Exception e = (Exception)readObject();
if(dump) dumpElementln(e.toString());
clearHandles();
throw new WriteAbortedException("Exception thrown during writing of stream", e);
}
default:
throw new IOException("Unknown marker on stream: " + marker);
}
ret_val = parseContent(marker);
}
finally
{
setBlockDataMode(old_mode);
this.isDeserializing = was_deserializing;
depth -= 2;
if (! was_deserializing)
{
if (validators.size() > 0)
invokeValidators();
}
setBlockDataMode(old_mode);
if (DEBUG)
depth -= 2;
}
return ret_val;
}
/**
* Handles a content block within the stream, which begins with a marker
* byte indicating its type.
*
* @param marker the byte marker.
* @return an object which represents the parsed content.
* @throws ClassNotFoundException if the class of an object being
* read in cannot be found.
* @throws IOException if invalid data occurs or one is thrown by the
* underlying <code>InputStream</code>.
*/
private Object parseContent(byte marker)
throws ClassNotFoundException, IOException
{
Object ret_val;
boolean is_consumed = false;
switch (marker)
{
case TC_ENDBLOCKDATA:
{
ret_val = null;
is_consumed = true;
break;
}
case TC_BLOCKDATA:
case TC_BLOCKDATALONG:
{
if (marker == TC_BLOCKDATALONG)
{ if(dump) dumpElementln("BLOCKDATALONG"); }
else
{ if(dump) dumpElementln("BLOCKDATA"); }
readNextBlock(marker);
}
case TC_NULL:
{
if(dump) dumpElementln("NULL");
ret_val = null;
break;
}
case TC_REFERENCE:
{
if(dump) dumpElement("REFERENCE ");
Integer oid = new Integer(this.realInputStream.readInt());
if(dump) dumpElementln(Integer.toHexString(oid.intValue()));
ret_val = ((ObjectIdentityWrapper)
this.objectLookupTable.get(oid)).object;
break;
}
case TC_CLASS:
{
if(dump) dumpElementln("CLASS");
ObjectStreamClass osc = (ObjectStreamClass)readObject();
Class clazz = osc.forClass();
assignNewHandle(clazz);
ret_val = clazz;
break;
}
case TC_PROXYCLASSDESC:
{
if(dump) dumpElementln("PROXYCLASS");
int n_intf = this.realInputStream.readInt();
String[] intfs = new String[n_intf];
for (int i = 0; i < n_intf; i++)
{
intfs[i] = this.realInputStream.readUTF();
}
boolean oldmode = setBlockDataMode(true);
Class cl = resolveProxyClass(intfs);
setBlockDataMode(oldmode);
ObjectStreamClass osc = lookupClass(cl);
if (osc.firstNonSerializableParentConstructor == null)
{
osc.realClassIsSerializable = true;
osc.fields = osc.fieldMapping = new ObjectStreamField[0];
try
{
osc.firstNonSerializableParentConstructor =
Object.class.getConstructor(new Class[0]);
}
catch (NoSuchMethodException x)
{
throw (InternalError)
new InternalError("Object ctor missing").initCause(x);
}
}
assignNewHandle(osc);
if (!is_consumed)
{
byte b = this.realInputStream.readByte();
if (b != TC_ENDBLOCKDATA)
throw new IOException("Data annotated to class was not consumed." + b);
}
else
is_consumed = false;
ObjectStreamClass superosc = (ObjectStreamClass)readObject();
osc.setSuperclass(superosc);
ret_val = osc;
break;
}
case TC_CLASSDESC:
{
ObjectStreamClass osc = readClassDescriptor();
if (!is_consumed)
{
byte b = this.realInputStream.readByte();
if (b != TC_ENDBLOCKDATA)
throw new IOException("Data annotated to class was not consumed." + b);
}
else
is_consumed = false;
osc.setSuperclass ((ObjectStreamClass)readObject());
ret_val = osc;
break;
}
case TC_STRING:
case TC_LONGSTRING:
{
if(dump) dumpElement("STRING=");
String s = this.realInputStream.readUTF();
if(dump) dumpElementln(s);
ret_val = processResolution(null, s, assignNewHandle(s));
break;
}
case TC_ARRAY:
{
if(dump) dumpElementln("ARRAY");
ObjectStreamClass osc = (ObjectStreamClass)readObject();
Class componentType = osc.forClass().getComponentType();
if(dump) dumpElement("ARRAY LENGTH=");
int length = this.realInputStream.readInt();
if(dump) dumpElementln (length + "; COMPONENT TYPE=" + componentType);
Object array = Array.newInstance(componentType, length);
int handle = assignNewHandle(array);
readArrayElements(array, componentType);
if(dump)
for (int i = 0, len = Array.getLength(array); i < len; i++)
dumpElementln(" ELEMENT[" + i + "]=" + Array.get(array, i));
ret_val = processResolution(null, array, handle);
break;
}
case TC_OBJECT:
{
if(dump) dumpElementln("OBJECT");
ObjectStreamClass osc = (ObjectStreamClass)readObject();
Class clazz = osc.forClass();
if (!osc.realClassIsSerializable)
throw new NotSerializableException
(clazz + " is not Serializable, and thus cannot be deserialized.");
if (osc.realClassIsExternalizable)
{
Externalizable obj = osc.newInstance();
int handle = assignNewHandle(obj);
boolean read_from_blocks = ((osc.getFlags() & SC_BLOCK_DATA) != 0);
boolean oldmode = this.readDataFromBlock;
if (read_from_blocks)
setBlockDataMode(true);
obj.readExternal(this);
if (read_from_blocks)
{
setBlockDataMode(oldmode);
if (!oldmode)
if (this.realInputStream.readByte() != TC_ENDBLOCKDATA)
throw new IOException("No end of block data seen for class with readExternal (ObjectInputStream) method.");
}
ret_val = processResolution(osc, obj, handle);
break;
} // end if (osc.realClassIsExternalizable)
Object obj = newObject(clazz, osc.firstNonSerializableParentConstructor);
int handle = assignNewHandle(obj);
Object prevObject = this.currentObject;
ObjectStreamClass prevObjectStreamClass = this.currentObjectStreamClass;
TreeSet prevObjectValidators = this.currentObjectValidators;
this.currentObject = obj;
this.currentObjectValidators = null;
ObjectStreamClass[] hierarchy =
inputGetObjectStreamClasses(clazz);
for (int i = 0; i < hierarchy.length; i++)
{
this.currentObjectStreamClass = hierarchy[i];
if(dump) dumpElementln("Reading fields of " + this.currentObjectStreamClass.getName ());
// XXX: should initialize fields in classes in the hierarchy
// that aren't in the stream
// should skip over classes in the stream that aren't in the
// real classes hierarchy
Method readObjectMethod = this.currentObjectStreamClass.readObjectMethod;
if (readObjectMethod != null)
{
fieldsAlreadyRead = false;
boolean oldmode = setBlockDataMode(true);
callReadMethod(readObjectMethod, this.currentObjectStreamClass.forClass(), obj);
setBlockDataMode(oldmode);
}
else
{
readFields(obj, currentObjectStreamClass);
}
if (this.currentObjectStreamClass.hasWriteMethod())
{
if(dump) dumpElement("ENDBLOCKDATA? ");
try
{
/* Read blocks until an end marker */
byte writeMarker = this.realInputStream.readByte();
while (writeMarker != TC_ENDBLOCKDATA)
{
parseContent(writeMarker);
writeMarker = this.realInputStream.readByte();
}
if(dump) dumpElementln("yes");
}
catch (EOFException e)
{
throw (IOException) new IOException
("No end of block data seen for class with readObject (ObjectInputStream) method.").initCause(e);
}
}
}
this.currentObject = prevObject;
this.currentObjectStreamClass = prevObjectStreamClass;
ret_val = processResolution(osc, obj, handle);
if (currentObjectValidators != null)
invokeValidators();
this.currentObjectValidators = prevObjectValidators;
break;
}
case TC_RESET:
if(dump) dumpElementln("RESET");
clearHandles();
ret_val = readObject();
break;
case TC_EXCEPTION:
{
if(dump) dumpElement("EXCEPTION=");
Exception e = (Exception)readObject();
if(dump) dumpElementln(e.toString());
clearHandles();
throw new WriteAbortedException("Exception thrown during writing of stream", e);
}
default:
throw new IOException("Unknown marker on stream: " + marker);
}
return ret_val;
}
/**
* This method makes a partial check of types for the fields
* contained given in arguments. It checks primitive types of
@ -716,8 +739,10 @@ public class ObjectInputStream extends InputStream
throw new InvalidObjectException("attempt to add a null "
+ "ObjectInputValidation object");
this.validators.addElement(new ValidatorAndPriority (validator,
priority));
if (currentObjectValidators == null)
currentObjectValidators = new TreeSet();
currentObjectValidators.add(new ValidatorAndPriority(validator, priority));
}
@ -805,7 +830,7 @@ public class ObjectInputStream extends InputStream
/**
* Reconstruct class hierarchy the same way
* {@link java.io.ObjectStreamClass.getObjectStreamClasses(java.lang.Class)} does
* {@link java.io.ObjectStreamClass#getObjectStreamClasses(Class)} does
* but using lookupClass instead of ObjectStreamClass.lookup. This
* dup is necessary localize the lookup table. Hopefully some future
* rewritings will be able to prevent this.
@ -874,7 +899,7 @@ public class ObjectInputStream extends InputStream
}
else
for (int i = 0; i < intfs.length; i++)
clss[i] = cl.loadClass(intfs[i]);
clss[i] = Class.forName(intfs[i], false, cl);
try
{
return Proxy.getProxyClass(cl, clss);
@ -1195,7 +1220,7 @@ public class ObjectInputStream extends InputStream
* This method should be called by a method called 'readObject' in the
* deserializing class (if present). It cannot (and should not)be called
* outside of it. Its goal is to read all fields in the real input stream
* and keep them accessible through the {@link #GetField} class. Calling
* and keep them accessible through the {@link GetField} class. Calling
* this method will not alter the deserializing object.
*
* @return A valid freshly created 'GetField' instance to get access to
@ -1543,8 +1568,15 @@ public class ObjectInputStream extends InputStream
catch (IllegalAccessException ignore)
{
}
catch (InvocationTargetException ignore)
catch (InvocationTargetException exception)
{
Throwable cause = exception.getCause();
if (cause instanceof ObjectStreamException)
throw (ObjectStreamException) cause;
else if (cause instanceof RuntimeException)
throw (RuntimeException) cause;
else if (cause instanceof Error)
throw (Error) cause;
}
}
@ -1821,18 +1853,19 @@ public class ObjectInputStream extends InputStream
// on OBJ
private void invokeValidators() throws InvalidObjectException
{
Object[] validators = new Object[this.validators.size()];
this.validators.copyInto (validators);
Arrays.sort (validators);
try
{
for (int i=0; i < validators.length; i++)
((ObjectInputValidation)validators[i]).validateObject();
Iterator it = currentObjectValidators.iterator();
while(it.hasNext())
{
ValidatorAndPriority vap = (ValidatorAndPriority) it.next();
ObjectInputValidation validator = vap.validator;
validator.validateObject();
}
}
finally
{
this.validators.removeAllElements();
currentObjectValidators = null;
}
}
@ -1881,10 +1914,9 @@ public class ObjectInputStream extends InputStream
private Hashtable objectLookupTable;
private Object currentObject;
private ObjectStreamClass currentObjectStreamClass;
private TreeSet currentObjectValidators;
private boolean readDataFromBlock;
private boolean isDeserializing;
private boolean fieldsAlreadyRead;
private Vector validators;
private Hashtable classLookupTable;
private GetField prereadFields;
@ -1908,14 +1940,6 @@ public class ObjectInputStream extends InputStream
System.out.print (Thread.currentThread() + ": ");
}
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary ("javaio");
}
}
// used to keep a prioritized list of object validators
private static final class ValidatorAndPriority implements Comparable
{

85
libjava/classpath/java/io/ObjectOutputStream.java
View file

@ -39,7 +39,6 @@ exception statement from your version. */
package java.io;
import gnu.classpath.Configuration;
import gnu.java.io.ObjectIdentityWrapper;
import gnu.java.lang.reflect.TypeSignature;
import gnu.java.security.action.SetAccessibleAction;
@ -362,7 +361,9 @@ public class ObjectOutputStream extends OutputStream
break;
}
throw new NotSerializableException(clazz.getName ());
throw new NotSerializableException(clazz.getName()
+ " in "
+ obj.getClass());
} // end pseudo-loop
}
catch (ObjectStreamException ose)
@ -412,37 +413,53 @@ public class ObjectOutputStream extends OutputStream
protected void writeClassDescriptor(ObjectStreamClass osc) throws IOException
{
realOutput.writeByte(TC_CLASSDESC);
realOutput.writeUTF(osc.getName());
realOutput.writeLong(osc.getSerialVersionUID());
assignNewHandle(osc);
int flags = osc.getFlags();
if (protocolVersion == PROTOCOL_VERSION_2
&& osc.isExternalizable())
flags |= SC_BLOCK_DATA;
realOutput.writeByte(flags);
ObjectStreamField[] fields = osc.fields;
realOutput.writeShort(fields.length);
ObjectStreamField field;
for (int i = 0; i < fields.length; i++)
if (osc.isProxyClass)
{
field = fields[i];
realOutput.writeByte(field.getTypeCode ());
realOutput.writeUTF(field.getName ());
realOutput.writeByte(TC_PROXYCLASSDESC);
Class[] intfs = osc.forClass().getInterfaces();
realOutput.writeInt(intfs.length);
for (int i = 0; i < intfs.length; i++)
realOutput.writeUTF(intfs[i].getName());
if (! field.isPrimitive())
writeObject(field.getTypeString());
boolean oldmode = setBlockDataMode(true);
annotateProxyClass(osc.forClass());
setBlockDataMode(oldmode);
realOutput.writeByte(TC_ENDBLOCKDATA);
}
else
{
realOutput.writeByte(TC_CLASSDESC);
realOutput.writeUTF(osc.getName());
realOutput.writeLong(osc.getSerialVersionUID());
assignNewHandle(osc);
boolean oldmode = setBlockDataMode(true);
annotateClass(osc.forClass());
setBlockDataMode(oldmode);
realOutput.writeByte(TC_ENDBLOCKDATA);
int flags = osc.getFlags();
if (protocolVersion == PROTOCOL_VERSION_2
&& osc.isExternalizable())
flags |= SC_BLOCK_DATA;
realOutput.writeByte(flags);
ObjectStreamField[] fields = osc.fields;
realOutput.writeShort(fields.length);
ObjectStreamField field;
for (int i = 0; i < fields.length; i++)
{
field = fields[i];
realOutput.writeByte(field.getTypeCode ());
realOutput.writeUTF(field.getName ());
if (! field.isPrimitive())
writeObject(field.getTypeString());
}
boolean oldmode = setBlockDataMode(true);
annotateClass(osc.forClass());
setBlockDataMode(oldmode);
realOutput.writeByte(TC_ENDBLOCKDATA);
}
if (osc.isSerializable() || osc.isExternalizable())
writeObject(osc.getSuper());
@ -531,7 +548,7 @@ public class ObjectOutputStream extends OutputStream
* version)</code> is provided to change the default protocol
* version.
*
* For an explination of the differences beween the two protocols
* For an explanation of the differences between the two protocols
* see XXX: the Java ObjectSerialization Specification.
*
* @exception IOException if <code>version</code> is not a valid
@ -1567,12 +1584,4 @@ public class ObjectOutputStream extends OutputStream
private boolean dump = false;
private static final boolean DEBUG = false;
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javaio");
}
}
}

2
libjava/classpath/java/io/ObjectStreamField.java
View file

@ -208,7 +208,7 @@ public class ObjectStreamField implements Comparable
* This method sets the current offset of the field.
*
* @param off The offset of the field in bytes.
* @see getOffset()
* @see #getOffset()
*/
protected void setOffset (int off)
{

162
libjava/classpath/java/io/OutputStreamWriter.java
View file

@ -39,16 +39,14 @@ exception statement from your version. */
package java.io;
import gnu.java.nio.charset.EncodingHelper;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.MalformedInputException;
import java.nio.charset.UnsupportedCharsetException;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.MalformedInputException;
/**
* This class writes characters to an output stream that is byte oriented
@ -124,52 +122,58 @@ public class OutputStreamWriter extends Writer
{
this.out = out;
try
{
// Don't use NIO if avoidable
if(EncodingHelper.isISOLatin1(encoding_scheme))
{
// Don't use NIO if avoidable
if(EncodingHelper.isISOLatin1(encoding_scheme))
{
encodingName = "ISO8859_1";
encoder = null;
return;
}
/*
* Workraround for encodings with a byte-order-mark.
* We only want to write it once per stream.
*/
try
{
if(encoding_scheme.equalsIgnoreCase("UnicodeBig") ||
encoding_scheme.equalsIgnoreCase("UTF-16") ||
encoding_scheme.equalsIgnoreCase("UTF16"))
{
encoding_scheme = "UTF-16BE";
out.write((byte)0xFE);
out.write((byte)0xFF);
}
else if(encoding_scheme.equalsIgnoreCase("UnicodeLittle")){
encoding_scheme = "UTF-16LE";
out.write((byte)0xFF);
out.write((byte)0xFE);
}
}
catch(IOException ioe)
{
}
outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
Charset cs = EncodingHelper.getCharset(encoding_scheme);
if(cs == null)
throw new UnsupportedEncodingException("Encoding "+encoding_scheme+
" unknown");
encoder = cs.newEncoder();
encodingName = EncodingHelper.getOldCanonical(cs.name());
encoder.onMalformedInput(CodingErrorAction.REPLACE);
encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
}
catch(RuntimeException e)
{
// Default to ISO Latin-1, will happen if this is called, for instance,
// before the NIO provider is loadable.
encoder = null;
encodingName = "ISO8859_1";
encoder = null;
return;
}
/*
* Workraround for encodings with a byte-order-mark.
* We only want to write it once per stream.
*/
try {
if(encoding_scheme.equalsIgnoreCase("UnicodeBig") ||
encoding_scheme.equalsIgnoreCase("UTF-16") ||
encoding_scheme.equalsIgnoreCase("UTF16"))
{
encoding_scheme = "UTF-16BE";
out.write((byte)0xFE);
out.write((byte)0xFF);
} else if(encoding_scheme.equalsIgnoreCase("UnicodeLittle")){
encoding_scheme = "UTF-16LE";
out.write((byte)0xFF);
out.write((byte)0xFE);
}
} catch(IOException ioe){
}
outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
Charset cs = EncodingHelper.getCharset(encoding_scheme);
if(cs == null)
throw new UnsupportedEncodingException("Encoding "+encoding_scheme+
" unknown");
encoder = cs.newEncoder();
encodingName = EncodingHelper.getOldCanonical(cs.name());
encoder.onMalformedInput(CodingErrorAction.REPLACE);
encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
} catch(RuntimeException e) {
// Default to ISO Latin-1, will happen if this is called, for instance,
// before the NIO provider is loadable.
encoder = null;
encodingName = "ISO8859_1";
}
}
/**
@ -183,21 +187,55 @@ public class OutputStreamWriter extends Writer
this.out = out;
outputBuffer = null;
try
{
String encoding = System.getProperty("file.encoding");
Charset cs = Charset.forName(encoding);
encoder = cs.newEncoder();
encodingName = EncodingHelper.getOldCanonical(cs.name());
} catch(RuntimeException e) {
encoder = null;
encodingName = "ISO8859_1";
}
{
String encoding = System.getProperty("file.encoding");
Charset cs = Charset.forName(encoding);
encoder = cs.newEncoder();
encodingName = EncodingHelper.getOldCanonical(cs.name());
}
catch(RuntimeException e)
{
encoder = null;
encodingName = "ISO8859_1";
}
if(encoder != null)
{
encoder.onMalformedInput(CodingErrorAction.REPLACE);
encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
}
{
encoder.onMalformedInput(CodingErrorAction.REPLACE);
encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
}
}
/**
* This method initializes a new instance of <code>OutputStreamWriter</code>
* to write to the specified stream using a given <code>Charset</code>.
*
* @param out The <code>OutputStream</code> to write to
* @param cs The <code>Charset</code> of the encoding to use
*/
public OutputStreamWriter(OutputStream out, Charset cs)
{
this.out = out;
encoder = cs.newEncoder();
encoder.onMalformedInput(CodingErrorAction.REPLACE);
encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
}
/**
* This method initializes a new instance of <code>OutputStreamWriter</code>
* to write to the specified stream using a given
* <code>CharsetEncoder</code>.
*
* @param out The <code>OutputStream</code> to write to
* @param enc The <code>CharsetEncoder</code> to encode the output with
*/
public OutputStreamWriter(OutputStream out, CharsetEncoder enc)
{
this.out = out;
encoder = enc;
outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
}
/**

2
libjava/classpath/java/io/PipedInputStream.java
View file

@ -130,7 +130,7 @@ public class PipedInputStream extends InputStream
* This stream is then ready for reading. If this stream is already
* connected or has been previously closed, then an exception is thrown
*
* @param src The <code>PipedOutputStream</code> to connect this stream to
* @param source The <code>PipedOutputStream</code> to connect this stream to
*
* @exception IOException If this PipedInputStream or <code>source</code>
* has been connected already.

75
libjava/classpath/java/io/PrintWriter.java
View file

@ -70,6 +70,11 @@ public class PrintWriter extends Writer
* on this stream.
*/
private boolean error;
/**
* Indicates whether or not the stream has been closed.
*/
private boolean closed;
/**
* This is the underlying <code>Writer</code> we are sending output
@ -138,6 +143,68 @@ public class PrintWriter extends Writer
this.autoflush = autoflush;
}
/**
* This initializes a new PrintWriter object to write to the specified
* file. It creates a FileOutputStream object and wraps it in an
* OutputStreamWriter using the default encoding.
* @param file name of the file to write to
* @throws FileNotFoundException if the file cannot be written or created
*
* @since 1.5
*/
public PrintWriter(String file) throws FileNotFoundException
{
this(new FileOutputStream(file));
}
/**
* This initializes a new PrintWriter object to write to the specified
* file. It creates a FileOutputStream object and wraps it in an
* OutputStreamWriter using the specified encoding.
* @param file name of the file to write to
* @param enc the encoding to use
* @throws FileNotFoundException if the file cannot be written or created
* @throws UnsupportedEncodingException if the encoding is not supported
*
* @since 1.5
*/
public PrintWriter(String file, String enc)
throws FileNotFoundException, UnsupportedEncodingException
{
this(new OutputStreamWriter(new FileOutputStream(file), enc));
}
/**
* This initializes a new PrintWriter object to write to the specified
* file. It creates a FileOutputStream object and wraps it in an
* OutputStreamWriter using the default encoding.
* @param file the file to write to
* @throws FileNotFoundException if the file cannot be written or created
*
* @since 1.5
*/
public PrintWriter(File file) throws FileNotFoundException
{
this(new FileOutputStream(file));
}
/**
* This initializes a new PrintWriter object to write to the specified
* file. It creates a FileOutputStream object and wraps it in an
* OutputStreamWriter using the specified encoding.
* @param file the file to write to
* @param enc the encoding to use
* @throws FileNotFoundException if the file cannot be written or created
* @throws UnsupportedEncodingException if the encoding is not supported
*
* @since 1.5
*/
public PrintWriter(File file, String enc)
throws FileNotFoundException, UnsupportedEncodingException
{
this(new OutputStreamWriter(new FileOutputStream(file), enc));
}
/**
* This method can be called by subclasses to indicate that an error
* has occurred and should be reported by <code>checkError</code>.
@ -158,7 +225,8 @@ public class PrintWriter extends Writer
*/
public boolean checkError()
{
flush();
if (! closed)
flush();
return error;
}
@ -185,7 +253,8 @@ public class PrintWriter extends Writer
{
try
{
out.close();
out.close();
closed = true;
}
catch (IOException ex)
{
@ -310,7 +379,7 @@ public class PrintWriter extends Writer
* This is the system dependent line separator
*/
private static final char[] line_separator
= System.getProperty("line.separator").toCharArray();
= System.getProperty("line.separator", "\n").toCharArray();
/**
* This method prints a line separator sequence to the stream. The value

9
libjava/classpath/java/io/PushbackInputStream.java
View file

@ -116,7 +116,14 @@ public class PushbackInputStream extends FilterInputStream
*/
public int available() throws IOException
{
return (buf.length - pos) + super.available();
try
{
return (buf.length - pos) + super.available();
}
catch (NullPointerException npe)
{
throw new IOException ("Stream closed");
}
}
/**