yggdrasil/gcc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Major merge with Classpath.

Browse Source 
Removed many duplicate files.
	* HACKING: Updated.x
	* classpath: Imported new directory.
	* standard.omit: New file.
	* Makefile.in, aclocal.m4, configure: Rebuilt.
	* sources.am: New file.
	* configure.ac: Run Classpath configure script.  Moved code around
	to support.  Disable xlib AWT peers (temporarily).
	* Makefile.am (SUBDIRS): Added 'classpath'
	(JAVAC): Removed.
	(AM_CPPFLAGS): Added more -I options.
	(BOOTCLASSPATH): Simplified.
	Completely redid how sources are built.
	Include sources.am.
	* include/Makefile.am (tool_include__HEADERS): Removed jni.h.
	* include/jni.h: Removed (in Classpath).
	* scripts/classes.pl: Updated to look at built classes.
	* scripts/makemake.tcl: New file.
	* testsuite/libjava.jni/jni.exp (gcj_jni_compile_c_to_so): Added
	-I options.
	(gcj_jni_invocation_compile_c_to_binary): Likewise.

From-SVN: r102082
This commit is contained in:
Tom Tromey
2005-07-16 01:27:14 +00:00
committed by Tom Tromey
parent ea54b29342
commit b0fa81eea9
2817 changed files with 11656 additions and 643398 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libjava/gnu/java/nio/ChannelInputStream.java
-79
View File
@@ -1,79 +0,0 @@
/* ChannelInputStream.java --
Copyright (C) 2003 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 gnu.java.nio;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.channels.IllegalBlockingModeException;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.SelectableChannel;
/**
* @author Michael Koch
*/
public final class ChannelInputStream extends InputStream
{
private ReadableByteChannel ch;
public ChannelInputStream (ReadableByteChannel ch)
{
super();
this.ch = ch;
}
public int read() throws IOException
{
if (ch instanceof SelectableChannel
&& (! ((SelectableChannel) ch).isBlocking()))
throw new IllegalBlockingModeException();
ByteBuffer buffer = ByteBuffer.allocate(1);
int result = ch.read(buffer);
if (result == -1)
return -1;
if (result == 0)
throw new IOException("Could not read from channel");
return buffer.get(0);
}
}
libjava/gnu/java/nio/ChannelOutputStream.java
-67
View File
@@ -1,67 +0,0 @@
/* ChannelOutputStream.java --
Copyright (C) 2003 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 gnu.java.nio;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.WritableByteChannel;
/**
* @author Michael Koch
*/
public final class ChannelOutputStream extends OutputStream
{
private WritableByteChannel ch;
public ChannelOutputStream (WritableByteChannel ch)
{
super();
this.ch = ch;
}
public void write (int value) throws IOException
{
ByteBuffer buffer = ByteBuffer.allocate (1);
buffer.put ((byte) (value & 0xff));
buffer.flip();
ch.write (buffer);
}
}
libjava/gnu/java/nio/ChannelReader.java
-211
View File
@@ -1,211 +0,0 @@
/* ChannelReader.java --
Copyright (C) 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., 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 gnu.java.nio;
import java.io.IOException;
import java.io.Reader;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.ReadableByteChannel;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
/**
* A Reader implementation that works using a ReadableByteChannel and a
* CharsetDecoder.
*
* <p>
* This is a bridge between NIO <-> IO character decoding.
* </p>
*
* @author Robert Schuster
*/
public class ChannelReader extends Reader
{
private static final int DEFAULT_BUFFER_CAP = 8192;
private ReadableByteChannel channel;
private CharsetDecoder decoder;
private ByteBuffer byteBuffer;
private CharBuffer charBuffer;
public ChannelReader(ReadableByteChannel channel, CharsetDecoder decoder,
int minBufferCap)
{
this.channel = channel;
this.decoder = decoder;
// JDK reports errors, so we do the same.
decoder.onMalformedInput(CodingErrorAction.REPORT);
decoder.onUnmappableCharacter(CodingErrorAction.REPORT);
decoder.reset();
int size = (minBufferCap == -1) ? DEFAULT_BUFFER_CAP : minBufferCap;
// Allocates the buffers and prepares them for reading, because that is the
// first operation being done on them.
byteBuffer = ByteBuffer.allocate(size);
byteBuffer.flip();
charBuffer = CharBuffer.allocate((int) (size * decoder.averageCharsPerByte()));
}
public int read(char[] buf, int offset, int count) throws IOException
{
// I declared channel being null meaning that the reader is closed.
if (!channel.isOpen())
throw new IOException("Reader was already closed.");
// I declared decoder being null meaning that there is no more data to read
// and convert.
if (decoder == null)
return -1;
// Stores the amount of character being read. It -1 so that if no conversion
// occured the caller will see this as an 'end of file'.
int sum = -1;
// Copies any characters which may be left from the last invocation into the
// destination array.
if (charBuffer.remaining() > 0)
{
sum = Math.min(count, charBuffer.remaining());
charBuffer.get(buf, offset, sum);
// Updates the control variables according to the latest copy operation.
offset += sum;
count -= sum;
}
// Copies the character which have not been put in the destination array to
// the beginning. If data is actually copied count will be 0. If no data is
// copied count is >0 and we can now convert some more characters.
charBuffer.compact();
int converted = 0;
boolean last = false;
while (count != 0)
{
// Tries to convert some bytes (Which will intentionally fail in the
// first place because we have not read any bytes yet.)
CoderResult result = decoder.decode(byteBuffer, charBuffer, last);
if (result.isMalformed() || result.isUnmappable())
{
// JDK throws exception when bytes are malformed for sure.
// FIXME: Unsure what happens when a character is simply
// unmappable.
result.throwException();
}
// Marks that we should end this loop regardless whether the caller
// wants more chars or not, when this was the last conversion.
if (last)
{
decoder = null;
}
else if (result.isUnderflow())
{
// We need more bytes to do the conversion.
// Copies the not yet converted bytes to the beginning making it
// being able to receive more bytes.
byteBuffer.compact();
// Reads in another bunch of bytes for being converted.
if (channel.read(byteBuffer) == -1)
{
// If there is no more data available in the channel we mark
// that state for the final character conversion run which is
// done in the next loop iteration.
last = true;
}
// Prepares the byteBuffer for the next character conversion run.
byteBuffer.flip();
}
// Prepares the charBuffer for being drained.
charBuffer.flip();
converted = Math.min(count, charBuffer.remaining());
charBuffer.get(buf, offset, converted);
// Copies characters which have not yet being copied into the char-Array
// to the beginning making it possible to read them later (If data is
// really copied here, then the caller has received enough characters so
// far.).
charBuffer.compact();
// Updates the control variables according to the latest copy operation.
offset += converted;
count -= converted;
// Updates the amount of transferred characters.
sum += converted;
if (decoder == null)
{
break;
}
// Now that more characters have been transfered we let the loop decide
// what to do next.
}
// Makes the charBuffer ready for reading on the next invocation.
charBuffer.flip();
return sum;
}
public void close() throws IOException
{
channel.close();
// Makes sure all intermediate data is released by the decoder.
if (decoder != null)
decoder.reset();
}
}
libjava/gnu/java/nio/FileLockImpl.java
-82
View File
@@ -1,82 +0,0 @@
/* FileLockImpl.java --
Copyright (C) 2002, 2004 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 gnu.java.nio;
import gnu.java.nio.channels.FileChannelImpl;
import java.io.IOException;
import java.nio.channels.FileLock;
/**
* @author Michael Koch
* @since 1.4
*/
public class FileLockImpl extends FileLock
{
private FileChannelImpl ch;
public FileLockImpl (FileChannelImpl channel, long position,
long size, boolean shared)
{
super (channel, position, size, shared);
ch = channel;
}
protected void finalize()
{
try
{
release();
}
catch (IOException e)
{
// Ignore this.
}
}
public boolean isValid ()
{
return channel().isOpen();
}
public synchronized void release () throws IOException
{
ch.unlock(position(), size());
}
}
libjava/gnu/java/nio/InputStreamChannel.java
-88
View File
@@ -1,88 +0,0 @@
/* InputStreamChannel.java --
Copyright (C) 2003 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 gnu.java.nio;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.ReadableByteChannel;
/**
* @author Michael Koch
*/
public final class InputStreamChannel implements ReadableByteChannel
{
private boolean closed = false;
private InputStream in;
public InputStreamChannel (InputStream in)
{
super();
this.in = in;
}
public void close() throws IOException
{
if (!closed)
{
in.close();
closed = true;
}
}
public boolean isOpen()
{
return !closed;
}
public int read (ByteBuffer dst) throws IOException
{
if (!isOpen())
throw new ClosedChannelException();
byte[] buffer = new byte [dst.remaining()];
int readBytes = in.read (buffer);
if (readBytes > 0)
dst.put (buffer, 0, readBytes);
return readBytes;
}
}
libjava/gnu/java/nio/NIOConstants.java
-47
View File
@@ -1,47 +0,0 @@
/* NIOConstants.java --
Copyright (C) 2003 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 gnu.java.nio;
/**
* @author Michael Koch
*/
public final class NIOConstants
{
public static final int DEFAULT_TIMEOUT = 50;
}
libjava/gnu/java/nio/NIODatagramSocket.java
-71
View File
@@ -1,71 +0,0 @@
/* NIODatagramSocket.java --
Copyright (C) 2003 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 gnu.java.nio;
import gnu.java.net.PlainDatagramSocketImpl;
import java.net.DatagramSocket;
import java.nio.channels.DatagramChannel;
/**
* @author Michael Koch
*/
public final class NIODatagramSocket extends DatagramSocket
{
private PlainDatagramSocketImpl impl;
private DatagramChannelImpl channel;
public NIODatagramSocket (PlainDatagramSocketImpl impl,
DatagramChannelImpl channel)
{
super (impl);
this.impl = impl;
this.channel = channel;
}
public final PlainDatagramSocketImpl getPlainDatagramSocketImpl()
{
return impl;
}
public final DatagramChannel getChannel()
{
return channel;
}
}
libjava/gnu/java/nio/NIOSocket.java
-77
View File
@@ -1,77 +0,0 @@
/* NIOSocket.java --
Copyright (C) 2003 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 gnu.java.nio;
import gnu.java.net.PlainSocketImpl;
import java.io.IOException;
import java.net.Socket;
import java.nio.channels.SocketChannel;
/**
* @author Michael Koch
*/
public final class NIOSocket extends Socket
{
private PlainSocketImpl impl;
private SocketChannelImpl channel;
protected NIOSocket (PlainSocketImpl impl, SocketChannelImpl channel)
throws IOException
{
super (impl);
this.impl = impl;
this.channel = channel;
}
public final PlainSocketImpl getPlainSocketImpl()
{
return impl;
}
final void setChannel (SocketChannelImpl channel)
{
this.impl = channel.getPlainSocketImpl();
this.channel = channel;
}
public final SocketChannel getChannel()
{
return channel;
}
}
libjava/gnu/java/nio/OutputStreamChannel.java
-87
View File
@@ -1,87 +0,0 @@
/* OutputStreamChannel.java --
Copyright (C) 2003 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 gnu.java.nio;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.WritableByteChannel;
/**
* @author Michael Koch
*/
public final class OutputStreamChannel implements WritableByteChannel
{
private boolean closed = false;
private OutputStream out;
public OutputStreamChannel (OutputStream out)
{
super();
this.out = out;
}
public void close() throws IOException
{
if (!closed)
{
out.close();
closed = true;
}
}
public boolean isOpen()
{
return !closed;
}
public int write (ByteBuffer src) throws IOException
{
if (!isOpen())
throw new ClosedChannelException();
int len = src.remaining();
byte[] buffer = new byte [len];
src.get (buffer);
out.write (buffer);
return len;
}
}
libjava/gnu/java/nio/PipeImpl.java
-184
View File
@@ -1,184 +0,0 @@
/* PipeImpl.java --
Copyright (C) 2002, 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., 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 gnu.java.nio;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;
import java.nio.channels.spi.SelectorProvider;
class PipeImpl extends Pipe
{
public static final class SourceChannelImpl extends Pipe.SourceChannel
{
private int native_fd;
public SourceChannelImpl (SelectorProvider selectorProvider,
int native_fd)
{
super (selectorProvider);
this.native_fd = native_fd;
}
protected final void implCloseSelectableChannel()
throws IOException
{
throw new Error ("Not implemented");
}
protected void implConfigureBlocking (boolean blocking)
throws IOException
{
throw new Error ("Not implemented");
}
public final int read (ByteBuffer src)
throws IOException
{
throw new Error ("Not implemented");
}
public final long read (ByteBuffer[] srcs)
throws IOException
{
return read (srcs, 0, srcs.length);
}
public final synchronized long read (ByteBuffer[] srcs, int offset,
int len)
throws IOException
{
if (offset < 0
|| offset > srcs.length
|| len < 0
|| len > srcs.length - offset)
throw new IndexOutOfBoundsException();
long bytesRead = 0;
for (int index = 0; index < len; index++)
bytesRead += read (srcs [offset + index]);
return bytesRead;
}
public final int getNativeFD()
{
return native_fd;
}
}
public static final class SinkChannelImpl extends Pipe.SinkChannel
{
private int native_fd;
public SinkChannelImpl (SelectorProvider selectorProvider,
int native_fd)
{
super (selectorProvider);
this.native_fd = native_fd;
}
protected final void implCloseSelectableChannel()
throws IOException
{
throw new Error ("Not implemented");
}
protected final void implConfigureBlocking (boolean blocking)
throws IOException
{
throw new Error ("Not implemented");
}
public final int write (ByteBuffer dst)
throws IOException
{
throw new Error ("Not implemented");
}
public final long write (ByteBuffer[] srcs)
throws IOException
{
return write (srcs, 0, srcs.length);
}
public final synchronized long write (ByteBuffer[] srcs, int offset, int len)
throws IOException
{
if (offset < 0
|| offset > srcs.length
|| len < 0
|| len > srcs.length - offset)
throw new IndexOutOfBoundsException();
long bytesWritten = 0;
for (int index = 0; index < len; index++)
bytesWritten += write (srcs [offset + index]);
return bytesWritten;
}
public final int getNativeFD()
{
return native_fd;
}
}
private SinkChannelImpl sink;
private SourceChannelImpl source;
public PipeImpl (SelectorProvider provider)
throws IOException
{
super();
VMPipe.init (this, provider);
}
public Pipe.SinkChannel sink()
{
return sink;
}
public Pipe.SourceChannel source()
{
return source;
}
}
libjava/gnu/java/nio/SelectionKeyImpl.java
-104
View File
@@ -1,104 +0,0 @@
/* SelectionKeyImpl.java --
Copyright (C) 2002, 2003 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 gnu.java.nio;
import java.nio.channels.CancelledKeyException;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.spi.AbstractSelectionKey;
public abstract class SelectionKeyImpl extends AbstractSelectionKey
{
private int readyOps;
private int interestOps;
private SelectorImpl impl;
SelectableChannel ch;
public SelectionKeyImpl (SelectableChannel ch, SelectorImpl impl)
{
this.ch = ch;
this.impl = impl;
}
public SelectableChannel channel ()
{
return ch;
}
public int readyOps ()
{
if (!isValid())
throw new CancelledKeyException();
return readyOps;
}
public SelectionKey readyOps (int ops)
{
if (!isValid())
throw new CancelledKeyException();
readyOps = ops;
return this;
}
public int interestOps ()
{
if (!isValid())
throw new CancelledKeyException();
return interestOps;
}
public SelectionKey interestOps (int ops)
{
if (!isValid())
throw new CancelledKeyException();
interestOps = ops;
return this;
}
public Selector selector ()
{
return impl;
}
public abstract int getNativeFD();
}
libjava/gnu/java/nio/SelectorImpl.java
-394
View File
@@ -1,394 +0,0 @@
/* SelectorImpl.java --
Copyright (C) 2002, 2003, 2004 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 gnu.java.nio;
import java.io.IOException;
import java.nio.channels.ClosedSelectorException;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.spi.AbstractSelectableChannel;
import java.nio.channels.spi.AbstractSelector;
import java.nio.channels.spi.SelectorProvider;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SelectorImpl extends AbstractSelector
{
private Set keys;
private Set selected;
/**
* A dummy object whose monitor regulates access to both our
* selectThread and unhandledWakeup fields.
*/
private Object selectThreadMutex = new Object ();
/**
* Any thread that's currently blocked in a select operation.
*/
private Thread selectThread;
/**
* Indicates whether we have an unhandled wakeup call. This can
* be due to either wakeup() triggering a thread interruption while
* a thread was blocked in a select operation (in which case we need
* to reset this thread's interrupt status after interrupting the
* select), or else that no thread was on a select operation at the
* time that wakeup() was called, in which case the following select()
* operation should return immediately with nothing selected.
*/
private boolean unhandledWakeup;
public SelectorImpl (SelectorProvider provider)
{
super (provider);
keys = new HashSet ();
selected = new HashSet ();
}
protected void finalize() throws Throwable
{
close();
}
protected final void implCloseSelector()
throws IOException
{
// Cancel any pending select operation.
wakeup();
synchronized (keys)
{
synchronized (selected)
{
synchronized (cancelledKeys ())
{
// FIXME: Release resources here.
}
}
}
}
public final Set keys()
{
if (!isOpen())
throw new ClosedSelectorException();
return Collections.unmodifiableSet (keys);
}
public final int selectNow()
throws IOException
{
// FIXME: We're simulating an immediate select
// via a select with a timeout of one millisecond.
return select (1);
}
public final int select()
throws IOException
{
return select (0);
}
private final int[] getFDsAsArray (int ops)
{
int[] result;
int counter = 0;
Iterator it = keys.iterator ();
// Count the number of file descriptors needed
while (it.hasNext ())
{
SelectionKeyImpl key = (SelectionKeyImpl) it.next ();
if ((key.interestOps () & ops) != 0)
{
counter++;
}
}
result = new int[counter];
counter = 0;
it = keys.iterator ();
// Fill the array with the file descriptors
while (it.hasNext ())
{
SelectionKeyImpl key = (SelectionKeyImpl) it.next ();
if ((key.interestOps () & ops) != 0)
{
result[counter] = key.getNativeFD();
counter++;
}
}
return result;
}
public synchronized int select (long timeout)
throws IOException
{
if (!isOpen())
throw new ClosedSelectorException();
synchronized (keys)
{
synchronized (selected)
{
deregisterCancelledKeys();
// Set only keys with the needed interest ops into the arrays.
int[] read = getFDsAsArray (SelectionKey.OP_READ
| SelectionKey.OP_ACCEPT);
int[] write = getFDsAsArray (SelectionKey.OP_WRITE
| SelectionKey.OP_CONNECT);
// FIXME: We dont need to check this yet
int[] except = new int [0];
// Test to see if we've got an unhandled wakeup call,
// in which case we return immediately. Otherwise,
// remember our current thread and jump into the select.
// The monitor for dummy object selectThreadMutex regulates
// access to these fields.
// FIXME: Not sure from the spec at what point we should
// return "immediately". Is it here or immediately upon
// entry to this function?
// NOTE: There's a possibility of another thread calling
// wakeup() immediately after our thread releases
// selectThreadMutex's monitor here, in which case we'll
// do the select anyway. Since calls to wakeup() and select()
// among different threads happen in non-deterministic order,
// I don't think this is an issue.
synchronized (selectThreadMutex)
{
if (unhandledWakeup)
{
unhandledWakeup = false;
return 0;
}
else
{
selectThread = Thread.currentThread ();
}
}
// Call the native select() on all file descriptors.
int result = 0;
try
{
begin();
result = VMSelector.select (read, write, except, timeout);
}
finally
{
end();
}
// If our unhandled wakeup flag is set at this point,
// reset our thread's interrupt flag because we were
// awakened by wakeup() instead of an external thread
// interruption.
//
// NOTE: If we were blocked in a select() and one thread
// called Thread.interrupt() on the blocked thread followed
// by another thread calling Selector.wakeup(), then race
// conditions could make it so that the thread's interrupt
// flag is reset even though the Thread.interrupt() call
// "was there first". I don't think we need to care about
// this scenario.
synchronized (selectThreadMutex)
{
if (unhandledWakeup)
{
unhandledWakeup = false;
Thread.interrupted ();
}
selectThread = null;
}
Iterator it = keys.iterator ();
while (it.hasNext ())
{
int ops = 0;
SelectionKeyImpl key = (SelectionKeyImpl) it.next ();
// If key is already selected retrieve old ready ops.
if (selected.contains (key))
{
ops = key.readyOps ();
}
// Set new ready read/accept ops
for (int i = 0; i < read.length; i++)
{
if (key.getNativeFD() == read[i])
{
if (key.channel () instanceof ServerSocketChannelImpl)
{
ops = ops | SelectionKey.OP_ACCEPT;
}
else
{
ops = ops | SelectionKey.OP_READ;
}
}
}
// Set new ready write ops
for (int i = 0; i < write.length; i++)
{
if (key.getNativeFD() == write[i])
{
ops = ops | SelectionKey.OP_WRITE;
// if (key.channel ().isConnected ())
// {
// ops = ops | SelectionKey.OP_WRITE;
// }
// else
// {
// ops = ops | SelectionKey.OP_CONNECT;
// }
}
}
// FIXME: We dont handle exceptional file descriptors yet.
// If key is not yet selected add it.
if (!selected.contains (key))
{
selected.add (key);
}
// Set new ready ops
key.readyOps (key.interestOps () & ops);
}
deregisterCancelledKeys();
return result;
}
}
}
public final Set selectedKeys()
{
if (!isOpen())
throw new ClosedSelectorException();
return selected;
}
public final Selector wakeup()
{
// IMPLEMENTATION NOTE: Whereas the specification says that
// thread interruption should trigger a call to wakeup, we
// do the reverse under the covers: wakeup triggers a thread
// interrupt followed by a subsequent reset of the thread's
// interrupt status within select().
// First, acquire the monitor of the object regulating
// access to our selectThread and unhandledWakeup fields.
synchronized (selectThreadMutex)
{
unhandledWakeup = true;
// Interrupt any thread which is currently blocked in
// a select operation.
if (selectThread != null)
selectThread.interrupt ();
}
return this;
}
private final void deregisterCancelledKeys()
{
Set ckeys = cancelledKeys ();
synchronized (ckeys)
{
Iterator it = ckeys.iterator();
while (it.hasNext ())
{
keys.remove ((SelectionKeyImpl) it.next ());
it.remove ();
}
}
}
protected SelectionKey register (SelectableChannel ch, int ops, Object att)
{
return register ((AbstractSelectableChannel) ch, ops, att);
}
protected final SelectionKey register (AbstractSelectableChannel ch, int ops,
Object att)
{
SelectionKeyImpl result;
if (ch instanceof SocketChannelImpl)
result = new SocketChannelSelectionKey (ch, this);
else if (ch instanceof DatagramChannelImpl)
result = new DatagramChannelSelectionKey (ch, this);
else if (ch instanceof ServerSocketChannelImpl)
result = new ServerSocketChannelSelectionKey (ch, this);
else
throw new InternalError ("No known channel type");
synchronized (keys)
{
keys.add (result);
}
result.interestOps (ops);
result.attach (att);
return result;
}
}
libjava/gnu/java/nio/SelectorProviderImpl.java
-83
View File
@@ -1,83 +0,0 @@
/* SelectorProviderImpl.java --
Copyright (C) 2002, 2003 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 gnu.java.nio;
import java.io.IOException;
import java.nio.channels.DatagramChannel;
import java.nio.channels.Pipe;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.AbstractSelector;
import java.nio.channels.spi.SelectorProvider;
public class SelectorProviderImpl extends SelectorProvider
{
public SelectorProviderImpl ()
{
}
public DatagramChannel openDatagramChannel ()
throws IOException
{
return new DatagramChannelImpl (this);
}
public Pipe openPipe ()
throws IOException
{
return new PipeImpl (this);
}
public AbstractSelector openSelector ()
throws IOException
{
return new SelectorImpl (this);
}
public ServerSocketChannel openServerSocketChannel ()
throws IOException
{
return new ServerSocketChannelImpl (this);
}
public SocketChannel openSocketChannel ()
throws IOException
{
return new SocketChannelImpl (this);
}
}
libjava/gnu/java/nio/charset/ISO_8859_1.java
-155
View File
@@ -1,155 +0,0 @@
/* ISO_8859_1.java --
Copyright (C) 2002, 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., 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 gnu.java.nio.charset;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
/**
* ISO-8859-1 charset.
*
* @author Jesse Rosenstock
*/
final class ISO_8859_1 extends Charset
{
ISO_8859_1 ()
{
/* Canonical charset name chosen according to:
* http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html
*/
super ("ISO-8859-1", new String[] {
/* These names are provided by
* http://www.iana.org/assignments/character-sets
*/
"iso-ir-100",
"ISO_8859-1",
"latin1",
"l1",
"IBM819",
"CP819",
"csISOLatin1",
"8859_1",
/* These names are provided by
* http://oss.software.ibm.com/cgi-bin/icu/convexp?s=ALL
*/
"ISO8859_1", "ISO_8859_1", "ibm-819", "ISO_8859-1:1987",
"819"
});
}
public boolean contains (Charset cs)
{
return cs instanceof US_ASCII || cs instanceof ISO_8859_1;
}
public CharsetDecoder newDecoder ()
{
return new Decoder (this);
}
public CharsetEncoder newEncoder ()
{
return new Encoder (this);
}
private static final class Decoder extends CharsetDecoder
{
// Package-private to avoid a trampoline constructor.
Decoder (Charset cs)
{
super (cs, 1.0f, 1.0f);
}
protected CoderResult decodeLoop (ByteBuffer in, CharBuffer out)
{
// TODO: Optimize this in the case in.hasArray() / out.hasArray()
while (in.hasRemaining ())
{
byte b = in.get ();
if (!out.hasRemaining ())
{
in.position (in.position () - 1);
return CoderResult.OVERFLOW;
}
out.put ((char) (b & 0xFF));
}
return CoderResult.UNDERFLOW;
}
}
private static final class Encoder extends CharsetEncoder
{
// Package-private to avoid a trampoline constructor.
Encoder (Charset cs)
{
super (cs, 1.0f, 1.0f);
}
protected CoderResult encodeLoop (CharBuffer in, ByteBuffer out)
{
// TODO: Optimize this in the case in.hasArray() / out.hasArray()
while (in.hasRemaining ())
{
char c = in.get ();
if (c > 0xFF)
{
in.position (in.position () - 1);
return CoderResult.unmappableForLength (1);
}
if (!out.hasRemaining ())
{
in.position (in.position () - 1);
return CoderResult.OVERFLOW;
}
out.put ((byte) c);
}
return CoderResult.UNDERFLOW;
}
}
}
libjava/gnu/java/nio/charset/US_ASCII.java
-161
View File
@@ -1,161 +0,0 @@
/* US_ASCII.java --
Copyright (C) 2002, 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., 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 gnu.java.nio.charset;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
/**
* US-ASCII charset.
*
* @author Jesse Rosenstock
*/
final class US_ASCII extends Charset
{
US_ASCII ()
{
/* Canonical charset name chosen according to:
* http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html
*/
super ("US-ASCII", new String[] {
/* These names are provided by
* http://www.iana.org/assignments/character-sets
*/
"iso-ir-6",
"ANSI_X3.4-1986",
"ISO_646.irv:1991",
"ASCII",
"ISO646-US",
"ASCII",
"us",
"IBM367",
"cp367",
"csASCII",
/* These names are provided by
* http://oss.software.ibm.com/cgi-bin/icu/convexp?s=ALL
*/
"ANSI_X3.4-1968", "iso_646.irv:1983", "ascii7", "646",
"windows-20127"
});
}
public boolean contains (Charset cs)
{
return cs instanceof US_ASCII;
}
public CharsetDecoder newDecoder ()
{
return new Decoder (this);
}
public CharsetEncoder newEncoder ()
{
return new Encoder (this);
}
private static final class Decoder extends CharsetDecoder
{
// Package-private to avoid a trampoline constructor.
Decoder (Charset cs)
{
super (cs, 1.0f, 1.0f);
}
protected CoderResult decodeLoop (ByteBuffer in, CharBuffer out)
{
// TODO: Optimize this in the case in.hasArray() / out.hasArray()
while (in.hasRemaining ())
{
byte b = in.get ();
if (b < 0)
{
in.position (in.position () - 1);
return CoderResult.malformedForLength (1);
}
if (!out.hasRemaining ())
{
in.position (in.position () - 1);
return CoderResult.OVERFLOW;
}
out.put ((char) b);
}
return CoderResult.UNDERFLOW;
}
}
private static final class Encoder extends CharsetEncoder
{
// Package-private to avoid a trampoline constructor.
Encoder (Charset cs)
{
super (cs, 1.0f, 1.0f);
}
protected CoderResult encodeLoop (CharBuffer in, ByteBuffer out)
{
// TODO: Optimize this in the case in.hasArray() / out.hasArray()
while (in.hasRemaining ())
{
char c = in.get ();
if (c > Byte.MAX_VALUE)
{
in.position (in.position () - 1);
return CoderResult.unmappableForLength (1);
}
if (!out.hasRemaining ())
{
in.position (in.position () - 1);
return CoderResult.OVERFLOW;
}
out.put ((byte) c);
}
return CoderResult.UNDERFLOW;
}
}
}
libjava/gnu/java/nio/charset/UTF_16.java
-80
View File
@@ -1,80 +0,0 @@
/* UTF_16.java --
Copyright (C) 2002, 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., 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 gnu.java.nio.charset;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
/**
* UTF-16 charset.
*
* @author Jesse Rosenstock
*/
final class UTF_16 extends Charset
{
UTF_16 ()
{
super ("UTF-16", new String[] {
// witnessed by the internet
"UTF16",
/* These names are provided by
* http://oss.software.ibm.com/cgi-bin/icu/convexp?s=ALL
*/
"ISO-10646-UCS-2", "unicode", "csUnicode", "ucs-2"
});
}
public boolean contains (Charset cs)
{
return cs instanceof US_ASCII || cs instanceof ISO_8859_1
|| cs instanceof UTF_8 || cs instanceof UTF_16BE
|| cs instanceof UTF_16LE || cs instanceof UTF_16;
}
public CharsetDecoder newDecoder ()
{
return new UTF_16Decoder (this, UTF_16Decoder.UNKNOWN_ENDIAN);
}
public CharsetEncoder newEncoder ()
{
return new UTF_16Encoder (this, UTF_16Encoder.BIG_ENDIAN, false);
}
}
libjava/gnu/java/nio/charset/UTF_16BE.java
-84
View File
@@ -1,84 +0,0 @@
/* UTF_16BE.java --
Copyright (C) 2002, 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., 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 gnu.java.nio.charset;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
/**
* UTF-16BE charset.
*
* @author Jesse Rosenstock
*/
final class UTF_16BE extends Charset
{
UTF_16BE ()
{
super ("UTF-16BE", new String[] {
// witnessed by the internet
"UTF16BE",
/* These names are provided by
* http://oss.software.ibm.com/cgi-bin/icu/convexp?s=ALL
*/
"x-utf-16be", "ibm-1200", "ibm-1201", "ibm-5297",
"ibm-13488", "ibm-17584", "windows-1201", "cp1200", "cp1201",
"UTF16_BigEndian",
// see http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html
"UnicodeBigUnmarked"
});
}
public boolean contains (Charset cs)
{
return cs instanceof US_ASCII || cs instanceof ISO_8859_1
|| cs instanceof UTF_8 || cs instanceof UTF_16BE
|| cs instanceof UTF_16LE || cs instanceof UTF_16;
}
public CharsetDecoder newDecoder ()
{
return new UTF_16Decoder (this, UTF_16Decoder.BIG_ENDIAN);
}
public CharsetEncoder newEncoder ()
{
return new UTF_16Encoder (this, UTF_16Encoder.BIG_ENDIAN, true);
}
}
libjava/gnu/java/nio/charset/UTF_16Decoder.java
-151
View File
@@ -1,151 +0,0 @@
/* UTF_16Decoder.java --
Copyright (C) 2002 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 gnu.java.nio.charset;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
/**
* Decoder for UTF-16, UTF-15LE, and UTF-16BE.
*
* @author Jesse Rosenstock
*/
final class UTF_16Decoder extends CharsetDecoder
{
// byte orders
static final int BIG_ENDIAN = 0;
static final int LITTLE_ENDIAN = 1;
static final int UNKNOWN_ENDIAN = 2;
private static final char BYTE_ORDER_MARK = '\uFEFF';
private static final char REVERSED_BYTE_ORDER_MARK = '\uFFFE';
private final int originalByteOrder;
private int byteOrder;
UTF_16Decoder (Charset cs, int byteOrder)
{
super (cs, 0.5f, 1.0f);
this.originalByteOrder = byteOrder;
this.byteOrder = byteOrder;
}
protected CoderResult decodeLoop (ByteBuffer in, CharBuffer out)
{
// TODO: Optimize this in the case in.hasArray() / out.hasArray()
int inPos = in.position ();
try
{
while (in.remaining () >= 2)
{
byte b1 = in.get ();
byte b2 = in.get ();
// handle byte order mark
if (byteOrder == UNKNOWN_ENDIAN)
{
char c = (char) ((b1 << 8) | b2);
if (c == BYTE_ORDER_MARK)
{
byteOrder = BIG_ENDIAN;
inPos += 2;
continue;
}
else if (c == REVERSED_BYTE_ORDER_MARK)
{
byteOrder = LITTLE_ENDIAN;
inPos += 2;
continue;
}
else
{
// assume big endian, do not consume bytes,
// continue with normal processing
byteOrder = BIG_ENDIAN;
}
}
char c = byteOrder == BIG_ENDIAN ? (char) ((b1 << 8) | b2)
: (char) ((b2 << 8) | b1);
if (0xD800 <= c && c <= 0xDFFF)
{
// c is a surrogate
// make sure c is a high surrogate
if (c > 0xDBFF)
return CoderResult.malformedForLength (2);
if (in.remaining () < 2)
return CoderResult.UNDERFLOW;
byte b3 = in.get ();
byte b4 = in.get ();
char d = byteOrder == BIG_ENDIAN ? (char) ((b3 << 8) | b4)
: (char) ((b4 << 8) | b3);
// make sure d is a low surrogate
if (d < 0xDC00 || d > 0xDFFF)
return CoderResult.malformedForLength (2);
out.put (c);
out.put (d);
inPos += 4;
}
else
{
if (!out.hasRemaining ())
return CoderResult.UNDERFLOW;
out.put (c);
inPos += 2;
}
}
return CoderResult.UNDERFLOW;
}
finally
{
in.position (inPos);
}
}
protected void implReset ()
{
byteOrder = originalByteOrder;
}
}
libjava/gnu/java/nio/charset/UTF_16Encoder.java
-153
View File
@@ -1,153 +0,0 @@
/* UTF_16Encoder.java --
Copyright (C) 2002 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 gnu.java.nio.charset;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
/**
* Encoder for UTF-16, UTF-15LE, and UTF-16BE.
*
* @author Jesse Rosenstock
*/
final class UTF_16Encoder extends CharsetEncoder
{
// byte orders
static final int BIG_ENDIAN = 0;
static final int LITTLE_ENDIAN = 1;
private static final char BYTE_ORDER_MARK = '\uFEFF';
private final int byteOrder;
private final boolean useByteOrderMark;
private boolean needsByteOrderMark;
UTF_16Encoder (Charset cs, int byteOrder, boolean useByteOrderMark)
{
super (cs, 2.0f,
useByteOrderMark ? 2.0f : 4.0f,
byteOrder == BIG_ENDIAN
? new byte[] { (byte) 0xFF, (byte) 0xFD }
: new byte[] { (byte) 0xFD, (byte) 0xFF });
this.byteOrder = byteOrder;
this.useByteOrderMark = useByteOrderMark;
this.needsByteOrderMark = useByteOrderMark;
}
protected CoderResult encodeLoop (CharBuffer in, ByteBuffer out)
{
// TODO: Optimize this in the case in.hasArray() / out.hasArray()
if (needsByteOrderMark)
{
if (out.remaining () < 2)
return CoderResult.OVERFLOW;
put (out, BYTE_ORDER_MARK);
needsByteOrderMark = false;
}
int inPos = in.position ();
try
{
while (in.hasRemaining ())
{
char c = in.get ();
if (0xD800 <= c && c <= 0xDFFF)
{
// c is a surrogate
// make sure c is a high surrogate
if (c > 0xDBFF)
return CoderResult.malformedForLength (1);
if (in.remaining () < 1)
return CoderResult.UNDERFLOW;
char d = in.get ();
// make sure d is a low surrogate
if (d < 0xDC00 || d > 0xDFFF)
return CoderResult.malformedForLength (1);
put (out, c);
put (out, d);
inPos += 2;
}
else
{
if (out.remaining () < 2)
return CoderResult.OVERFLOW;
put (out, c);
inPos++;
}
}
return CoderResult.UNDERFLOW;
}
finally
{
in.position (inPos);
}
}
/**
* Writes <code>c</code> to <code>out</code> in the byte order
* specified by <code>byteOrder</code>.
**/
private void put (ByteBuffer out, char c)
{
if (byteOrder == BIG_ENDIAN)
{
out.put ((byte) (c >> 8));
out.put ((byte) (c & 0xFF));
}
else
{
out.put ((byte) (c & 0xFF));
out.put ((byte) (c >> 8));
}
}
protected void implReset ()
{
needsByteOrderMark = useByteOrderMark;
}
// TODO: override canEncode(char) and canEncode(CharSequence)
// for performance
}
libjava/gnu/java/nio/charset/UTF_16LE.java
-83
View File
@@ -1,83 +0,0 @@
/* UTF_16LE.java --
Copyright (C) 2002, 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., 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 gnu.java.nio.charset;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
/**
* UTF-16LE charset.
*
* @author Jesse Rosenstock
*/
final class UTF_16LE extends Charset
{
UTF_16LE ()
{
super ("UTF-16LE", new String[] {
// witnessed by the internet
"UTF16LE",
/* These names are provided by
* http://oss.software.ibm.com/cgi-bin/icu/convexp?s=ALL
*/
"x-utf-16le", "ibm-1202", "ibm-13490", "ibm-17586",
"UTF16_LittleEndian",
// see http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html
"UnicodeLittleUnmarked"
});
}
public boolean contains (Charset cs)
{
return cs instanceof US_ASCII || cs instanceof ISO_8859_1
|| cs instanceof UTF_8 || cs instanceof UTF_16BE
|| cs instanceof UTF_16LE || cs instanceof UTF_16;
}
public CharsetDecoder newDecoder ()
{
return new UTF_16Decoder (this, UTF_16Decoder.LITTLE_ENDIAN);
}
public CharsetEncoder newEncoder ()
{
return new UTF_16Encoder (this, UTF_16Encoder.LITTLE_ENDIAN, true);
}
}
libjava/gnu/java/nio/charset/UTF_8.java
-289
View File
@@ -1,289 +0,0 @@
/* UTF_8.java --
Copyright (C) 2002, 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., 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 gnu.java.nio.charset;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
/**
* UTF-8 charset.
*
* <p> UTF-8 references:
* <ul>
* <li> <a href="http://ietf.org/rfc/rfc2279.txt">RFC 2279</a>
* <li> The <a href="http://www.unicode.org/unicode/standard/standard.html">
* Unicode standard</a> and
* <a href="http://www.unicode.org/versions/corrigendum1.html">
* Corrigendum</a>
* </ul>
*
* @author Jesse Rosenstock
*/
final class UTF_8 extends Charset
{
UTF_8 ()
{
super ("UTF-8", new String[] {
/* These names are provided by
* http://oss.software.ibm.com/cgi-bin/icu/convexp?s=ALL
*/
"ibm-1208", "ibm-1209", "ibm-5304", "ibm-5305",
"windows-65001", "cp1208",
// see http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html
"UTF8"
});
}
public boolean contains (Charset cs)
{
return cs instanceof US_ASCII || cs instanceof ISO_8859_1
|| cs instanceof UTF_8 || cs instanceof UTF_16BE
|| cs instanceof UTF_16LE || cs instanceof UTF_16;
}
public CharsetDecoder newDecoder ()
{
return new Decoder (this);
}
public CharsetEncoder newEncoder ()
{
return new Encoder (this);
}
private static final class Decoder extends CharsetDecoder
{
// Package-private to avoid a trampoline constructor.
Decoder (Charset cs)
{
super (cs, 1.0f, 1.0f);
}
protected CoderResult decodeLoop (ByteBuffer in, CharBuffer out)
{
// TODO: Optimize this in the case in.hasArray() / out.hasArray()
int inPos = in.position();
try
{
while (in.hasRemaining ())
{
char c;
byte b1 = in.get ();
int highNibble = (b1 >> 4) & 0xF;
switch (highNibble)
{
case 0: case 1: case 2: case 3:
case 4: case 5: case 6: case 7:
if (out.remaining () < 1)
return CoderResult.OVERFLOW;
out.put ((char) b1);
inPos++;
break;
case 0xC: case 0xD:
byte b2;
if (in.remaining () < 1)
return CoderResult.UNDERFLOW;
if (out.remaining () < 1)
return CoderResult.OVERFLOW;
if (!isContinuation (b2 = in.get ()))
return CoderResult.malformedForLength (1);
c = (char) (((b1 & 0x1F) << 6) | (b2 & 0x3F));
// check that we had the shortest encoding
if (c <= 0x7F)
return CoderResult.malformedForLength (2);
out.put (c);
inPos += 2;
break;
case 0xE:
byte b3;
if (in.remaining () < 2)
return CoderResult.UNDERFLOW;
if (out.remaining () < 1)
return CoderResult.OVERFLOW;
if (!isContinuation (b2 = in.get ()))
return CoderResult.malformedForLength (1);
if (!isContinuation (b3 = in.get ()))
return CoderResult.malformedForLength (1);
c = (char) (((b1 & 0x0F) << 12)
| ((b2 & 0x3F) << 6)
| (b3 & 0x3F));
// check that we had the shortest encoding
if (c <= 0x7FF)
return CoderResult.malformedForLength (3);
out.put (c);
inPos += 3;
break;
default:
return CoderResult.malformedForLength (1);
}
}
return CoderResult.UNDERFLOW;
}
finally
{
// In case we did a get(), then encountered an error, reset the
// position to before the error. If there was no error, this
// will benignly reset the position to the value it already has.
in.position (inPos);
}
}
private static boolean isContinuation (byte b)
{
return (b & 0xC0) == 0x80;
}
}
private static final class Encoder extends CharsetEncoder
{
// Package-private to avoid a trampoline constructor.
Encoder (Charset cs)
{
// According to
// http://www-106.ibm.com/developerworks/unicode/library/utfencodingforms/index.html
// On average, English takes slightly over one unit per code point.
// Most Latin-script languages take about 1.1 bytes. Greek, Russian,
// Arabic and Hebrew take about 1.7 bytes, and most others (including
// Japanese, Chinese, Korean and Hindi) take about 3 bytes.
// We assume we will be dealing with latin scripts, and use 1.1
// for averageBytesPerChar.
super (cs, 1.1f, 4.0f);
}
protected CoderResult encodeLoop (CharBuffer in, ByteBuffer out)
{
int inPos = in.position();
try
{
// TODO: Optimize this in the case in.hasArray() / out.hasArray()
while (in.hasRemaining ())
{
int remaining = out.remaining ();
char c = in.get ();
// UCS-4 range (hex.) UTF-8 octet sequence (binary)
// 0000 0000-0000 007F 0xxxxxxx
// 0000 0080-0000 07FF 110xxxxx 10xxxxxx
// 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
// Scalar Value UTF-16 byte 1 byte 2 byte 3 byte 4
// 0000 0000 0xxx xxxx 0000 0000 0xxx xxxx 0xxx xxxx
// 0000 0yyy yyxx xxxx 0000 0yyy yyxx xxxx 110y yyyy 10xx xxxx
// zzzz yyyy yyxx xxxx zzzz yyyy yyxx xxxx 1110 zzzz 10yy yyyy 10xx xxxx
// u uuuu zzzz yyyy yyxx xxxx 1101 10ww wwzz zzyy 1111 0uuu 10uu zzzz 10yy yyyy 10xx xxxx
// + 1101 11yy yyxx xxxx
// Note: uuuuu = wwww + 1
if (c <= 0x7F)
{
if (remaining < 1)
return CoderResult.OVERFLOW;
out.put ((byte) c);
inPos++;
}
else if (c <= 0x7FF)
{
if (remaining < 2)
return CoderResult.OVERFLOW;
out.put ((byte) (0xC0 | (c >> 6)));
out.put ((byte) (0x80 | (c & 0x3F)));
inPos++;
}
else if (0xD800 <= c && c <= 0xDFFF)
{
if (remaining < 4)
return CoderResult.OVERFLOW;
// we got a low surrogate without a preciding high one
if (c > 0xDBFF)
return CoderResult.malformedForLength (1);
// high surrogates
if (!in.hasRemaining ())
return CoderResult.UNDERFLOW;
char d = in.get ();
// make sure d is a low surrogate
if (d < 0xDC00 || d > 0xDFFF)
return CoderResult.malformedForLength (1);
// make the 32 bit value
// int value2 = (c - 0xD800) * 0x400 + (d - 0xDC00) + 0x10000;
int value = (((c & 0x3FF) << 10) | (d & 0x3FF)) + 0x10000;
// assert value == value2;
out.put ((byte) (0xF0 | (value >> 18)));
out.put ((byte) (0x80 | ((value >> 12) & 0x3F)));
out.put ((byte) (0x80 | ((value >> 6) & 0x3F)));
out.put ((byte) (0x80 | ((value ) & 0x3F)));
inPos += 2;
}
else
{
if (remaining < 3)
return CoderResult.OVERFLOW;
out.put ((byte) (0xE0 | (c >> 12)));
out.put ((byte) (0x80 | ((c >> 6) & 0x3F)));
out.put ((byte) (0x80 | (c & 0x3F)));
inPos++;
}
}
return CoderResult.UNDERFLOW;
}
finally
{
// In case we did a get(), then encountered an error, reset the
// position to before the error. If there was no error, this
// will benignly reset the position to the value it already has.
in.position (inPos);
}
}
}
}