mirror of git://gcc.gnu.org/git/gcc.git
348 lines
10 KiB
Java
348 lines
10 KiB
Java
/* OutputStreamWriter.java -- Writer that converts chars to bytes
|
|
Copyright (C) 1998, 1999, 2000, 2001, 2003, 2005, 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 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.gcj.convert.UnicodeToBytes;
|
|
import gnu.gcj.convert.CharsetToBytesAdaptor;
|
|
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 (arenn@urbanophile.com)
|
|
* @author Per Bothner (bothner@cygnus.com)
|
|
* @date April 17, 1998.
|
|
*/
|
|
public class OutputStreamWriter extends Writer
|
|
{
|
|
BufferedOutputStream out;
|
|
|
|
/**
|
|
* This is the byte-character encoder class that does the writing and
|
|
* translation of characters to bytes before writing to the underlying
|
|
* class.
|
|
*/
|
|
UnicodeToBytes converter;
|
|
|
|
/* Temporary buffer. */
|
|
private char[] work;
|
|
private int wcount;
|
|
|
|
private OutputStreamWriter(OutputStream out, UnicodeToBytes encoder)
|
|
{
|
|
this.out = out instanceof BufferedOutputStream
|
|
? (BufferedOutputStream) out
|
|
: new BufferedOutputStream(out, 250);
|
|
/* Don't need to call super(out) here as long as the lock gets set. */
|
|
this.lock = out;
|
|
this.converter = encoder;
|
|
}
|
|
|
|
/**
|
|
* 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, UnicodeToBytes.getEncoder(encoding_scheme));
|
|
}
|
|
|
|
/**
|
|
* 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, UnicodeToBytes.getDefaultEncoder());
|
|
}
|
|
|
|
/**
|
|
* 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, new CharsetToBytesAdaptor(cs));
|
|
}
|
|
|
|
/**
|
|
* 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, new CharsetToBytesAdaptor(enc));
|
|
}
|
|
|
|
/**
|
|
* This method closes this stream, and the underlying
|
|
* <code>OutputStream</code>
|
|
*
|
|
* @exception IOException If an error occurs
|
|
*/
|
|
public void close () throws IOException
|
|
{
|
|
synchronized (lock)
|
|
{
|
|
if (out != null)
|
|
{
|
|
converter.setFinished();
|
|
flush();
|
|
out.close();
|
|
out = null;
|
|
}
|
|
work = 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 ? converter.getName() : null;
|
|
}
|
|
|
|
/**
|
|
* This method flushes any buffered bytes to the underlying output sink.
|
|
*
|
|
* @exception IOException If an error occurs
|
|
*/
|
|
public void flush () throws IOException
|
|
{
|
|
synchronized (lock)
|
|
{
|
|
if (out == null)
|
|
throw new IOException("Stream closed");
|
|
|
|
// Always write -- if we are close()ing then we want to make
|
|
// sure the converter is flushed.
|
|
if (work == null)
|
|
work = new char[100];
|
|
writeChars(work, 0, wcount);
|
|
wcount = 0;
|
|
|
|
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
|
|
{
|
|
synchronized (lock)
|
|
{
|
|
if (out == null)
|
|
throw new IOException("Stream closed");
|
|
|
|
if (wcount > 0)
|
|
{
|
|
writeChars(work, 0, wcount);
|
|
wcount = 0;
|
|
}
|
|
writeChars(buf, offset, count);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Writes characters through to the inferior BufferedOutputStream.
|
|
* Ignores wcount and the work buffer.
|
|
*/
|
|
private void writeChars(char[] buf, int offset, int count)
|
|
throws IOException
|
|
{
|
|
do
|
|
{
|
|
// We must flush if out.count == out.buf.length.
|
|
// It is probably a good idea to flush if out.buf is almost full.
|
|
// This test is an approximation for "almost full".
|
|
if (out.count + count >= out.buf.length)
|
|
{
|
|
out.flush();
|
|
if (out.count != 0)
|
|
throw new IOException("unable to flush output byte buffer");
|
|
}
|
|
converter.setOutput(out.buf, out.count);
|
|
int converted = converter.write(buf, offset, count);
|
|
// Must set this before we flush the output stream, because
|
|
// flushing will reset 'out.count'.
|
|
out.count = converter.count;
|
|
// Flush if we cannot make progress.
|
|
if (converted == 0 && out.count == converter.count)
|
|
{
|
|
out.flush();
|
|
if (out.count != 0)
|
|
throw new IOException("unable to flush output byte buffer");
|
|
}
|
|
offset += converted;
|
|
count -= converted;
|
|
}
|
|
while (count > 0 || converter.havePendingBytes());
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
{
|
|
synchronized (lock)
|
|
{
|
|
if (out == null)
|
|
throw new IOException("Stream closed");
|
|
|
|
if (work == null)
|
|
work = new char[100];
|
|
int wlength = work.length;
|
|
while (count > 0)
|
|
{
|
|
int size = count;
|
|
if (wcount + size > wlength)
|
|
{
|
|
if (2*wcount > wlength)
|
|
{
|
|
writeChars(work, 0, wcount);
|
|
wcount = 0;
|
|
}
|
|
if (wcount + size > wlength)
|
|
size = wlength - wcount;
|
|
}
|
|
str.getChars(offset, offset+size, work, wcount);
|
|
offset += size;
|
|
count -= size;
|
|
wcount += size;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
{
|
|
synchronized (lock)
|
|
{
|
|
if (out == null)
|
|
throw new IOException("Stream closed");
|
|
|
|
if (work == null)
|
|
work = new char[100];
|
|
if (wcount >= work.length)
|
|
{
|
|
writeChars(work, 0, wcount);
|
|
wcount = 0;
|
|
}
|
|
work[wcount++] = (char) ch;
|
|
}
|
|
}
|
|
|
|
} // class OutputStreamWriter
|
|
|