PatchSet 5726
Date: 2005/04/19 20:28:30
Author: robilad
Branch: HEAD
Tag: (none)
Log:
resynced with GNU Classpath: move to nio charsets
2005-04-19 Dalibor Topic <[EMAIL PROTECTED]>
Resynced with GNU Classpath.
2005-04-15 Sven de Marothy <[EMAIL PROTECTED]>
* java/io/InputStreamReader.java,
* java/io/OutputStreamWriter.java,
* java/lang/String.java: Move to NIO charsets.
* java/io/PrintStream.java: Inline conversion using String.
Members:
ChangeLog:1.3893->1.3894
libraries/javalib/java/io/InputStreamReader.java:INITIAL->1.21
libraries/javalib/java/io/OutputStreamWriter.java:INITIAL->1.15
libraries/javalib/java/io/PrintStream.java:INITIAL->1.20
libraries/javalib/java/lang/String.java:INITIAL->1.47
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.3893 kaffe/ChangeLog:1.3894
--- kaffe/ChangeLog:1.3893 Tue Apr 19 19:41:56 2005
+++ kaffe/ChangeLog Tue Apr 19 20:28:30 2005
@@ -2,6 +2,17 @@
Resynced with GNU Classpath.
+ 2005-04-15 Sven de Marothy <[EMAIL PROTECTED]>
+
+ * java/io/InputStreamReader.java,
+ * java/io/OutputStreamWriter.java,
+ * java/lang/String.java: Move to NIO charsets.
+ * java/io/PrintStream.java: Inline conversion using String.
+
+2005-04-19 Dalibor Topic <[EMAIL PROTECTED]>
+
+ Resynced with GNU Classpath.
+
2005-04-14 Chris Burdess <[EMAIL PROTECTED]>
* java/io/DataOutputStream.java (writeUTF): Use block write for
===================================================================
Checking out kaffe/libraries/javalib/java/io/InputStreamReader.java
RCS: /home/cvs/kaffe/kaffe/libraries/javalib/java/io/InputStreamReader.java,v
VERS: 1.21
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/libraries/javalib/java/io/InputStreamReader.java Tue Apr 19
20:33:00 2005
@@ -0,0 +1,437 @@
+/* InputStreamReader.java -- Reader than transforms bytes to chars
+ Copyright (C) 1998, 1999, 2001, 2003, 2004, 2005 Free Software Foundation,
Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+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 java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.CharBuffer;
+import java.nio.ByteBuffer;
+import gnu.java.nio.charset.EncodingHelper;
+
+/**
+ * This class reads characters from a byte input stream. The characters
+ * read are converted from bytes in the underlying stream by a
+ * decoding layer. The decoding layer transforms bytes to chars according
+ * to an encoding standard. There are many available encodings to choose
+ * from. The desired encoding can either be specified by name, or if no
+ * encoding is selected, the system default encoding will be used. The
+ * system default encoding name is determined from the system property
+ * <code>file.encoding</code>. The only encodings that are guaranteed to
+ * be availalbe are "8859_1" (the Latin-1 character set) and "UTF8".
+ * Unforunately, Java does not provide a mechanism for listing the
+ * ecodings that are supported in a given implementation.
+ * <p>
+ * Here is a list of standard encoding names that may be available:
+ * <p>
+ * <ul>
+ * <li>8859_1 (ISO-8859-1/Latin-1)</li>
+ * <li>8859_2 (ISO-8859-2/Latin-2)</li>
+ * <li>8859_3 (ISO-8859-3/Latin-3)</li>
+ * <li>8859_4 (ISO-8859-4/Latin-4)</li>
+ * <li>8859_5 (ISO-8859-5/Latin-5)</li>
+ * <li>8859_6 (ISO-8859-6/Latin-6)</li>
+ * <li>8859_7 (ISO-8859-7/Latin-7)</li>
+ * <li>8859_8 (ISO-8859-8/Latin-8)</li>
+ * <li>8859_9 (ISO-8859-9/Latin-9)</li>
+ * <li>ASCII (7-bit ASCII)</li>
+ * <li>UTF8 (UCS Transformation Format-8)</li>
+ * <li>More later</li>
+ * </ul>
+ * <p>
+ * It is recommended that applications do not use
+ * <code>InputStreamReader</code>'s
+ * directly. Rather, for efficiency purposes, an object of this class
+ * should be wrapped by a <code>BufferedReader</code>.
+ * <p>
+ * Due to a deficiency the Java class library design, there is no standard
+ * way for an application to install its own byte-character encoding.
+ *
+ * @see BufferedReader
+ * @see InputStream
+ *
+ * @author Robert Schuster
+ * @author Aaron M. Renn ([EMAIL PROTECTED])
+ * @author Per Bothner ([EMAIL PROTECTED])
+ * @date April 22, 1998.
+ */
+public class InputStreamReader extends Reader
+{
+ /**
+ * The input stream.
+ */
+ private InputStream in;
+
+ /**
+ * The charset decoder.
+ */
+ private CharsetDecoder decoder;
+
+ /**
+ * End of stream reached.
+ */
+ private boolean isDone = false;
+
+ /**
+ * Need this.
+ */
+ private float maxBytesPerChar;
+
+ /**
+ * Buffer holding surplus loaded bytes (if any)
+ */
+ private ByteBuffer byteBuffer;
+
+ /**
+ * java.io canonical name of the encoding.
+ */
+ private String encoding;
+
+ /**
+ * We might decode to a 2-char UTF-16 surrogate, which won't fit in the
+ * output buffer. In this case we need to save the surrogate char.
+ */
+ private char savedSurrogate;
+ private boolean hasSavedSurrogate = false;
+
+ /**
+ * This method initializes a new instance of <code>InputStreamReader</code>
+ * to read from the specified stream using the default encoding.
+ *
+ * @param in The <code>InputStream</code> to read from
+ */
+ public InputStreamReader(InputStream in)
+ {
+ if (in == null)
+ throw new NullPointerException();
+ this.in = in;
+ try
+ {
+ encoding = System.getProperty("file.encoding");
+ // Don't use NIO if avoidable
+ if(EncodingHelper.isISOLatin1(encoding))
+ {
+ encoding = "ISO8859_1";
+ maxBytesPerChar = 1f;
+ decoder = null;
+ return;
+ }
+ Charset cs = EncodingHelper.getCharset(encoding);
+ decoder = cs.newDecoder();
+ encoding = EncodingHelper.getOldCanonical(cs.name());
+ try {
+ maxBytesPerChar = cs.newEncoder().maxBytesPerChar();
+ } catch(UnsupportedOperationException _){
+ maxBytesPerChar = 1f;
+ }
+ decoder.onMalformedInput(CodingErrorAction.REPLACE);
+ decoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
+ decoder.reset();
+ } catch(RuntimeException e) {
+ encoding = "ISO8859_1";
+ maxBytesPerChar = 1f;
+ decoder = null;
+ } catch(UnsupportedEncodingException e) {
+ encoding = "ISO8859_1";
+ maxBytesPerChar = 1f;
+ decoder = null;
+ }
+ }
+
+ /**
+ * This method initializes a new instance of <code>InputStreamReader</code>
+ * to read from the specified stream using a caller supplied character
+ * encoding scheme. Note that due to a deficiency in the Java language
+ * design, there is no way to determine which encodings are supported.
+ *
+ * @param in The <code>InputStream</code> to read from
+ * @param encoding_name The name of the encoding scheme to use
+ *
+ * @exception UnsupportedEncodingException If the encoding scheme
+ * requested is not available.
+ */
+ public InputStreamReader(InputStream in, String encoding_name)
+ throws UnsupportedEncodingException
+ {
+ if (in == null
+ || encoding_name == null)
+ throw new NullPointerException();
+
+ this.in = in;
+ // Don't use NIO if avoidable
+ if(EncodingHelper.isISOLatin1(encoding_name))
+ {
+ encoding = "ISO8859_1";
+ maxBytesPerChar = 1f;
+ decoder = null;
+ return;
+ }
+ try {
+ Charset cs = EncodingHelper.getCharset(encoding_name);
+ try {
+ maxBytesPerChar = cs.newEncoder().maxBytesPerChar();
+ } catch(UnsupportedOperationException _){
+ maxBytesPerChar = 1f;
+ }
+
+ decoder = cs.newDecoder();
+ decoder.onMalformedInput(CodingErrorAction.REPLACE);
+ decoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
+ decoder.reset();
+
+ // The encoding should be the old name, if such exists.
+ encoding = EncodingHelper.getOldCanonical(cs.name());
+ } catch(RuntimeException e) {
+ encoding = "ISO8859_1";
+ maxBytesPerChar = 1f;
+ decoder = null;
+ }
+ }
+
+ /**
+ * Creates an InputStreamReader that uses a decoder of the given
+ * charset to decode the bytes in the InputStream into
+ * characters.
+ */
+ public InputStreamReader(InputStream in, Charset charset) {
+ this.in = in;
+ decoder = charset.newDecoder();
+
+ // JDK reports errors, so we do the same.
+ decoder.onMalformedInput(CodingErrorAction.REPORT);
+ decoder.onUnmappableCharacter(CodingErrorAction.REPORT);
+ decoder.reset();
+ encoding = EncodingHelper.getOldCanonical(charset.name());
+ }
+
+ /**
+ * Creates an InputStreamReader that uses the given charset decoder
+ * to decode the bytes in the InputStream into characters.
+ */
+ public InputStreamReader(InputStream in, CharsetDecoder decoder) {
+ this.in = in;
+ this.decoder = decoder;
+
+ try {
+ maxBytesPerChar = decoder.charset().newEncoder().maxBytesPerChar();
+ } catch(UnsupportedOperationException _){
+ maxBytesPerChar = 1f;
+ }
+
+ // JDK reports errors, so we do the same.
+ decoder.onMalformedInput(CodingErrorAction.REPORT);
+ decoder.onUnmappableCharacter(CodingErrorAction.REPORT);
+ decoder.reset();
+ encoding = EncodingHelper.getOldCanonical(decoder.charset().name());
+ }
+
+ /**
+ * This method closes this stream, as well as the underlying
+ * <code>InputStream</code>.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void close() throws IOException
+ {
+ synchronized (lock)
+ {
+ // Makes sure all intermediate data is released by the decoder.
+ if (decoder != null)
+ decoder.reset();
+ if (in != null)
+ in.close();
+ in = null;
+ isDone = true;
+ decoder = null;
+ }
+ }
+
+ /**
+ * This method returns the name of the encoding that is currently in use
+ * by this object. If the stream has been closed, this method is allowed
+ * to return <code>null</code>.
+ *
+ * @return The current encoding name
+ */
+ public String getEncoding()
+ {
+ return in != null ? encoding : null;
+ }
+
+ /**
+ * This method checks to see if the stream is ready to be read. It
+ * will return <code>true</code> if is, or <code>false</code> if it is not.
+ * If the stream is not ready to be read, it could (although is not required
+ * to) block on the next read attempt.
+ *
+ * @return <code>true</code> if the stream is ready to be read,
+ * <code>false</code> otherwise
+ *
+ * @exception IOException If an error occurs
+ */
+ public boolean ready() throws IOException
+ {
+ if (in == null)
+ throw new IOException("Reader has been closed");
+
+ return in.available() != 0;
+ }
+
+ /**
+ * This method reads up to <code>length</code> characters from the stream
into
+ * the specified array starting at index <code>offset</code> into the
+ * array.
+ *
+ * @param buf The character array to recieve the data read
+ * @param offset The offset into the array to start storing characters
+ * @param length The requested number of characters to read.
+ *
+ * @return The actual number of characters read, or -1 if end of stream.
+ *
+ * @exception IOException If an error occurs
+ */
+ public int read(char[] buf, int offset, int length) throws IOException
+ {
+ if (in == null)
+ throw new IOException("Reader has been closed");
+ if (isDone)
+ return -1;
+
+ if(decoder != null){
+ int totalBytes = (int)((double)length * maxBytesPerChar);
+ byte[] bytes = new byte[totalBytes];
+
+ int remaining = 0;
+ if(byteBuffer != null)
+ {
+ remaining = byteBuffer.remaining();
+ byteBuffer.get(bytes, 0, remaining);
+ }
+ int read;
+ if(totalBytes - remaining > 0)
+ {
+ read = in.read(bytes, remaining, totalBytes - remaining);
+ if(read == -1){
+ read = remaining;
+ isDone = true;
+ } else
+ read += remaining;
+ } else
+ read = remaining;
+ byteBuffer = ByteBuffer.wrap(bytes, 0, read);
+ CharBuffer cb = CharBuffer.wrap(buf, offset, length);
+
+ if(hasSavedSurrogate){
+ hasSavedSurrogate = false;
+ cb.put(savedSurrogate);
+ read++;
+ }
+
+ CoderResult cr = decoder.decode(byteBuffer, cb, isDone);
+ decoder.reset();
+
+ // 1 char remains which is the first half of a surrogate pair.
+ if(cr.isOverflow() && cb.hasRemaining()){
+ CharBuffer overflowbuf = CharBuffer.allocate(2);
+ cr = decoder.decode(byteBuffer, overflowbuf, isDone);
+ overflowbuf.flip();
+ cb.put(overflowbuf.get());
+ savedSurrogate = overflowbuf.get();
+ hasSavedSurrogate = true;
+ isDone = false;
+ }
+
+ if(byteBuffer.hasRemaining()) {
+ byteBuffer.compact();
+ byteBuffer.flip();
+ isDone = false;
+ } else
+ byteBuffer = null;
+
+ return (read == 0)?-1:cb.position();
+ } else {
+ byte[] bytes = new byte[length];
+ int read = in.read(bytes);
+ for(int i=0;i<read;i++)
+ buf[offset+i] = (char)(bytes[i]&0xFF);
+ return read;
+ }
+ }
+
+ /**
+ * Reads an char from the input stream and returns it
+ * as an int in the range of 0-65535. This method also will return -1 if
+ * the end of the stream has been reached.
+ * <p>
+ * This method will block until the char can be read.
+ *
+ * @return The char read or -1 if end of stream
+ *
+ * @exception IOException If an error occurs
+ */
+ public int read() throws IOException
+ {
+ char[] buf = new char[1];
+ int count = read(buf, 0, 1);
+ return count > 0 ? buf[0] : -1;
+ }
+
+ /**
+ * Skips the specified number of chars in the stream. It
+ * returns the actual number of chars skipped, which may be less than the
+ * requested amount.
+ *
+ * @param count The requested number of chars to skip
+ *
+ * @return The actual number of chars skipped.
+ *
+ * @exception IOException If an error occurs
+ */
+ public long skip(long count) throws IOException
+ {
+ if (in == null)
+ throw new IOException("Reader has been closed");
+
+ return super.skip(count);
+ }
+}
===================================================================
Checking out kaffe/libraries/javalib/java/io/OutputStreamWriter.java
RCS: /home/cvs/kaffe/kaffe/libraries/javalib/java/io/OutputStreamWriter.java,v
VERS: 1.15
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/libraries/javalib/java/io/OutputStreamWriter.java Tue Apr 19
20:33:00 2005
@@ -0,0 +1,356 @@
+/* OutputStreamWriter.java -- Writer that converts chars to bytes
+ Copyright (C) 1998, 1999, 2000, 2001, 2003, 2005 Free Software Foundation,
Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+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;
+
+/**
+ * This class writes characters to an output stream that is byte oriented
+ * It converts the chars that are written to bytes using an encoding layer,
+ * which is specific to a particular encoding standard. The desired
+ * encoding can either be specified by name, or if no encoding is specified,
+ * the system default encoding will be used. The system default encoding
+ * name is determined from the system property <code>file.encoding</code>.
+ * The only encodings that are guaranteed to be available are "8859_1"
+ * (the Latin-1 character set) and "UTF8". Unfortunately, Java does not
+ * provide a mechanism for listing the encodings that are supported in
+ * a given implementation.
+ * <p>
+ * Here is a list of standard encoding names that may be available:
+ * <p>
+ * <ul>
+ * <li>8859_1 (ISO-8859-1/Latin-1)
+ * <li>8859_2 (ISO-8859-2/Latin-2)
+ * <li>8859_3 (ISO-8859-3/Latin-3)
+ * <li>8859_4 (ISO-8859-4/Latin-4)
+ * <li>8859_5 (ISO-8859-5/Latin-5)
+ * <li>8859_6 (ISO-8859-6/Latin-6)
+ * <li>8859_7 (ISO-8859-7/Latin-7)
+ * <li>8859_8 (ISO-8859-8/Latin-8)
+ * <li>8859_9 (ISO-8859-9/Latin-9)
+ * <li>ASCII (7-bit ASCII)
+ * <li>UTF8 (UCS Transformation Format-8)
+ * <li>More Later
+ * </ul>
+ *
+ * @author Aaron M. Renn ([EMAIL PROTECTED])
+ * @author Per Bothner ([EMAIL PROTECTED])
+ * @date April 17, 1998.
+ */
+public class OutputStreamWriter extends Writer
+{
+ /**
+ * The output stream.
+ */
+ private OutputStream out;
+
+ /**
+ * The charset encoder.
+ */
+ private CharsetEncoder encoder;
+
+ /**
+ * java.io canonical name of the encoding.
+ */
+ private String encodingName;
+
+ /**
+ * Buffer output before character conversion as it has costly overhead.
+ */
+ private CharBuffer outputBuffer;
+ private final static int BUFFER_SIZE = 1024;
+
+ /**
+ * This method initializes a new instance of <code>OutputStreamWriter</code>
+ * to write to the specified stream using a caller supplied character
+ * encoding scheme. Note that due to a deficiency in the Java language
+ * design, there is no way to determine which encodings are supported.
+ *
+ * @param out The <code>OutputStream</code> to write to
+ * @param encoding_scheme The name of the encoding scheme to use for
+ * character to byte translation
+ *
+ * @exception UnsupportedEncodingException If the named encoding is
+ * not available.
+ */
+ public OutputStreamWriter (OutputStream out, String encoding_scheme)
+ throws UnsupportedEncodingException
+ {
+ this.out = out;
+ try
+ {
+ // 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";
+ }
+ }
+
+ /**
+ * This method initializes a new instance of <code>OutputStreamWriter</code>
+ * to write to the specified stream using the default encoding.
+ *
+ * @param out The <code>OutputStream</code> to write to
+ */
+ public OutputStreamWriter (OutputStream out)
+ {
+ 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";
+ }
+ if(encoder != null)
+ {
+ encoder.onMalformedInput(CodingErrorAction.REPLACE);
+ encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
+ outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
+ }
+ }
+
+ /**
+ * This method closes this stream, and the underlying
+ * <code>OutputStream</code>
+ *
+ * @exception IOException If an error occurs
+ */
+ public void close () throws IOException
+ {
+ if(out == null)
+ throw new IOException("Stream is closed.");
+ flush();
+ out.close ();
+ out = null;
+ }
+
+ /**
+ * This method returns the name of the character encoding scheme currently
+ * in use by this stream. If the stream has been closed, then this method
+ * may return <code>null</code>.
+ *
+ * @return The encoding scheme name
+ */
+ public String getEncoding ()
+ {
+ return out != null ? encodingName : null;
+ }
+
+ /**
+ * This method flushes any buffered bytes to the underlying output sink.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void flush () throws IOException
+ {
+ if(out != null){
+ if(outputBuffer != null){
+ char[] buf = new char[outputBuffer.position()];
+ if(buf.length > 0){
+ outputBuffer.flip();
+ outputBuffer.get(buf);
+ writeConvert(buf, 0, buf.length);
+ outputBuffer.clear();
+ }
+ }
+ out.flush ();
+ }
+ }
+
+ /**
+ * This method writes <code>count</code> characters from the specified
+ * array to the output stream starting at position <code>offset</code>
+ * into the array.
+ *
+ * @param buf The array of character to write from
+ * @param offset The offset into the array to start writing chars from
+ * @param count The number of chars to write.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void write (char[] buf, int offset, int count) throws IOException
+ {
+ if(out == null)
+ throw new IOException("Stream is closed.");
+ if(buf == null)
+ throw new IOException("Buffer is null.");
+
+ if(outputBuffer != null)
+ {
+ if(count >= outputBuffer.remaining())
+ {
+ int r = outputBuffer.remaining();
+ outputBuffer.put(buf, offset, r);
+ writeConvert(outputBuffer.array(), 0, BUFFER_SIZE);
+ outputBuffer.clear();
+ offset += r;
+ count -= r;
+ // if the remaining bytes is larger than the whole buffer,
+ // just don't buffer.
+ if(count >= outputBuffer.remaining()){
+ writeConvert(buf, offset, count);
+ return;
+ }
+ }
+ outputBuffer.put(buf, offset, count);
+ } else writeConvert(buf, offset, count);
+ }
+
+ /**
+ * Converts and writes characters.
+ */
+ private void writeConvert (char[] buf, int offset, int count)
+ throws IOException
+ {
+ if(encoder == null)
+ {
+ byte[] b = new byte[count];
+ for(int i=0;i<count;i++)
+ b[i] = (byte)((buf[offset+i] <= 0xFF)?buf[offset+i]:'?');
+ out.write(b);
+ } else {
+ try {
+ ByteBuffer output = encoder.encode(CharBuffer.wrap(buf,offset,count));
+ encoder.reset();
+ if(output.hasArray())
+ out.write(output.array());
+ else
+ {
+ byte[] outbytes = new byte[output.remaining()];
+ output.get(outbytes);
+ out.write(outbytes);
+ }
+ } catch(IllegalStateException e) {
+ throw new IOException("Internal error.");
+ } catch(MalformedInputException e) {
+ throw new IOException("Invalid character sequence.");
+ } catch(CharacterCodingException e) {
+ throw new IOException("Unmappable character.");
+ }
+ }
+ }
+
+ /**
+ * This method writes <code>count</code> bytes from the specified
+ * <code>String</code> starting at position <code>offset</code> into the
+ * <code>String</code>.
+ *
+ * @param str The <code>String</code> to write chars from
+ * @param offset The position in the <code>String</code> to start
+ * writing chars from
+ * @param count The number of chars to write
+ *
+ * @exception IOException If an error occurs
+ */
+ public void write (String str, int offset, int count) throws IOException
+ {
+ if(str == null)
+ throw new IOException("String is null.");
+
+ write(str.toCharArray(), offset, count);
+ }
+
+ /**
+ * This method writes a single character to the output stream.
+ *
+ * @param ch The char to write, passed as an int.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void write (int ch) throws IOException
+ {
+ write(new char[]{ (char)ch }, 0, 1);
+ }
+} // class OutputStreamWriter
+
===================================================================
Checking out kaffe/libraries/javalib/java/io/PrintStream.java
RCS: /home/cvs/kaffe/kaffe/libraries/javalib/java/io/PrintStream.java,v
VERS: 1.20
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/libraries/javalib/java/io/PrintStream.java Tue Apr 19 20:33:00 2005
@@ -0,0 +1,553 @@
+/* PrintStream.java -- OutputStream for printing output
+ Copyright (C) 1998, 1999, 2001, 2003, 2004, 2005 Free Software Foundation,
Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package java.io;
+
+/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
+ * "The Java Language Specification", ISBN 0-201-63451-1
+ * Status: Believed complete and correct to 1.3
+ */
+
+/**
+ * This class prints Java primitive values and object to a stream as
+ * text. None of the methods in this class throw an exception. However,
+ * errors can be detected by calling the <code>checkError()</code> method.
+ * Additionally, this stream can be designated as "autoflush" when
+ * created so that any writes are automatically flushed to the underlying
+ * output sink when the current line is terminated.
+ * <p>
+ * This class converts char's into byte's using the system default encoding.
+ *
+ * @author Aaron M. Renn ([EMAIL PROTECTED])
+ * @author Tom Tromey ([EMAIL PROTECTED])
+ */
+public class PrintStream extends FilterOutputStream
+{
+ /* Notice the implementation is quite similar to OutputStreamWriter.
+ * This leads to some minor duplication, because neither inherits
+ * from the other, and we want to maximize performance. */
+
+ // Line separator string.
+ private static final char[] line_separator
+ = System.getProperty("line.separator").toCharArray();
+
+ /**
+ * Encoding name
+ */
+ private String encoding;
+
+ /**
+ * This boolean indicates whether or not an error has ever occurred
+ * on this stream.
+ */
+ private boolean error_occurred = false;
+
+ /**
+ * This is <code>true</code> if auto-flush is enabled,
+ * <code>false</code> otherwise
+ */
+ private boolean auto_flush;
+
+ /**
+ * This method intializes a new <code>PrintStream</code> object to write
+ * to the specified output sink.
+ *
+ * @param out The <code>OutputStream</code> to write to.
+ */
+ public PrintStream (OutputStream out)
+ {
+ this (out, false);
+ }
+
+ /**
+ * This method intializes a new <code>PrintStream</code> object to write
+ * to the specified output sink. This constructor also allows "auto-flush"
+ * functionality to be specified where the stream will be flushed after
+ * every <code>print</code> or <code>println</code> call, when the
+ * <code>write</code> methods with array arguments are called, or when a
+ * single new-line character is written.
+ * <p>
+ *
+ * @param out The <code>OutputStream</code> to write to.
+ * @param auto_flush <code>true</code> to flush the stream after every
+ * line, <code>false</code> otherwise
+ */
+ public PrintStream (OutputStream out, boolean auto_flush)
+ {
+ super (out);
+
+ try {
+ this.encoding = System.getProperty("file.encoding");
+ } catch (SecurityException e){
+ this.encoding = "ISO8859_1";
+ } catch (IllegalArgumentException e){
+ this.encoding = "ISO8859_1";
+ } catch (NullPointerException e){
+ this.encoding = "ISO8859_1";
+ }
+ this.auto_flush = auto_flush;
+ }
+
+ /**
+ * This method intializes a new <code>PrintStream</code> object to write
+ * to the specified output sink. This constructor also allows "auto-flush"
+ * functionality to be specified where the stream will be flushed after
+ * every <code>print</code> or <code>println</code> call, when the
+ * <code>write</code> methods with array arguments are called, or when a
+ * single new-line character is written.
+ * <p>
+ *
+ * @param out The <code>OutputStream</code> to write to.
*** Patch too long, truncated ***
_______________________________________________
kaffe mailing list
[email protected]
http://kaffe.org/cgi-bin/mailman/listinfo/kaffe
