Makefile.def: Remove libjava.

2016-09-30  Andrew Haley  <aph@redhat.com>

	* Makefile.def: Remove libjava.
	* Makefile.tpl: Likewise.
	* Makefile.in: Regenerate.
	* configure.ac: Likewise.
	* configure: Likewise.
	* gcc/java: Remove.
	* libjava: Likewise.

From-SVN: r240662

1 files changed, 0 insertions, 347 deletions

diff --git a/libjava/java/io/OutputStreamWriter.java b/libjava/java/io/OutputStreamWriter.java
deleted file mode 100644
index aac1684..0000000
--- a/libjava/java/io/OutputStreamWriter.java
+++ /dev/null
@@ -1,347 +0,0 @@
-/* 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
-