From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- .../java/nio/channels/AlreadyConnectedException.h | 35 +++++++++ .../java/nio/channels/AsynchronousCloseException.h | 35 +++++++++ libjava/java/nio/channels/ByteChannel.h | 36 +++++++++ libjava/java/nio/channels/CancelledKeyException.h | 35 +++++++++ libjava/java/nio/channels/Channel.h | 33 +++++++++ libjava/java/nio/channels/Channels.h | 47 ++++++++++++ .../java/nio/channels/ClosedByInterruptException.h | 35 +++++++++ libjava/java/nio/channels/ClosedChannelException.h | 35 +++++++++ .../java/nio/channels/ClosedSelectorException.h | 35 +++++++++ .../java/nio/channels/ConnectionPendingException.h | 35 +++++++++ libjava/java/nio/channels/DatagramChannel.h | 59 +++++++++++++++ libjava/java/nio/channels/FileChannel$MapMode.h | 40 ++++++++++ libjava/java/nio/channels/FileChannel.h | 64 ++++++++++++++++ libjava/java/nio/channels/FileLock.h | 48 ++++++++++++ .../nio/channels/FileLockInterruptionException.h | 35 +++++++++ libjava/java/nio/channels/GatheringByteChannel.h | 39 ++++++++++ .../nio/channels/IllegalBlockingModeException.h | 35 +++++++++ .../java/nio/channels/IllegalSelectorException.h | 35 +++++++++ libjava/java/nio/channels/InterruptibleChannel.h | 33 +++++++++ .../nio/channels/NoConnectionPendingException.h | 35 +++++++++ .../nio/channels/NonReadableChannelException.h | 35 +++++++++ .../nio/channels/NonWritableChannelException.h | 35 +++++++++ libjava/java/nio/channels/NotYetBoundException.h | 35 +++++++++ .../java/nio/channels/NotYetConnectedException.h | 35 +++++++++ .../nio/channels/OverlappingFileLockException.h | 35 +++++++++ libjava/java/nio/channels/Pipe$SinkChannel.h | 44 +++++++++++ libjava/java/nio/channels/Pipe$SourceChannel.h | 44 +++++++++++ libjava/java/nio/channels/Pipe.h | 38 ++++++++++ libjava/java/nio/channels/ReadableByteChannel.h | 35 +++++++++ libjava/java/nio/channels/ScatteringByteChannel.h | 39 ++++++++++ libjava/java/nio/channels/SelectableChannel.h | 48 ++++++++++++ libjava/java/nio/channels/SelectionKey.h | 55 ++++++++++++++ libjava/java/nio/channels/Selector.h | 47 ++++++++++++ libjava/java/nio/channels/ServerSocketChannel.h | 46 ++++++++++++ libjava/java/nio/channels/SocketChannel.h | 59 +++++++++++++++ .../java/nio/channels/UnresolvedAddressException.h | 35 +++++++++ .../nio/channels/UnsupportedAddressTypeException.h | 35 +++++++++ libjava/java/nio/channels/VMChannels.h | 52 +++++++++++++ libjava/java/nio/channels/VMChannels.java | 85 ++++++++++++++++++++++ libjava/java/nio/channels/WritableByteChannel.h | 35 +++++++++ libjava/java/nio/channels/natVMChannels.cc | 37 ++++++++++ .../channels/spi/AbstractInterruptibleChannel.h | 46 ++++++++++++ .../nio/channels/spi/AbstractSelectableChannel.h | 64 ++++++++++++++++ .../java/nio/channels/spi/AbstractSelectionKey.h | 41 +++++++++++ libjava/java/nio/channels/spi/AbstractSelector.h | 60 +++++++++++++++ libjava/java/nio/channels/spi/SelectorProvider.h | 52 +++++++++++++ 46 files changed, 1956 insertions(+) create mode 100644 libjava/java/nio/channels/AlreadyConnectedException.h create mode 100644 libjava/java/nio/channels/AsynchronousCloseException.h create mode 100644 libjava/java/nio/channels/ByteChannel.h create mode 100644 libjava/java/nio/channels/CancelledKeyException.h create mode 100644 libjava/java/nio/channels/Channel.h create mode 100644 libjava/java/nio/channels/Channels.h create mode 100644 libjava/java/nio/channels/ClosedByInterruptException.h create mode 100644 libjava/java/nio/channels/ClosedChannelException.h create mode 100644 libjava/java/nio/channels/ClosedSelectorException.h create mode 100644 libjava/java/nio/channels/ConnectionPendingException.h create mode 100644 libjava/java/nio/channels/DatagramChannel.h create mode 100644 libjava/java/nio/channels/FileChannel$MapMode.h create mode 100644 libjava/java/nio/channels/FileChannel.h create mode 100644 libjava/java/nio/channels/FileLock.h create mode 100644 libjava/java/nio/channels/FileLockInterruptionException.h create mode 100644 libjava/java/nio/channels/GatheringByteChannel.h create mode 100644 libjava/java/nio/channels/IllegalBlockingModeException.h create mode 100644 libjava/java/nio/channels/IllegalSelectorException.h create mode 100644 libjava/java/nio/channels/InterruptibleChannel.h create mode 100644 libjava/java/nio/channels/NoConnectionPendingException.h create mode 100644 libjava/java/nio/channels/NonReadableChannelException.h create mode 100644 libjava/java/nio/channels/NonWritableChannelException.h create mode 100644 libjava/java/nio/channels/NotYetBoundException.h create mode 100644 libjava/java/nio/channels/NotYetConnectedException.h create mode 100644 libjava/java/nio/channels/OverlappingFileLockException.h create mode 100644 libjava/java/nio/channels/Pipe$SinkChannel.h create mode 100644 libjava/java/nio/channels/Pipe$SourceChannel.h create mode 100644 libjava/java/nio/channels/Pipe.h create mode 100644 libjava/java/nio/channels/ReadableByteChannel.h create mode 100644 libjava/java/nio/channels/ScatteringByteChannel.h create mode 100644 libjava/java/nio/channels/SelectableChannel.h create mode 100644 libjava/java/nio/channels/SelectionKey.h create mode 100644 libjava/java/nio/channels/Selector.h create mode 100644 libjava/java/nio/channels/ServerSocketChannel.h create mode 100644 libjava/java/nio/channels/SocketChannel.h create mode 100644 libjava/java/nio/channels/UnresolvedAddressException.h create mode 100644 libjava/java/nio/channels/UnsupportedAddressTypeException.h create mode 100644 libjava/java/nio/channels/VMChannels.h create mode 100644 libjava/java/nio/channels/VMChannels.java create mode 100644 libjava/java/nio/channels/WritableByteChannel.h create mode 100644 libjava/java/nio/channels/natVMChannels.cc create mode 100644 libjava/java/nio/channels/spi/AbstractInterruptibleChannel.h create mode 100644 libjava/java/nio/channels/spi/AbstractSelectableChannel.h create mode 100644 libjava/java/nio/channels/spi/AbstractSelectionKey.h create mode 100644 libjava/java/nio/channels/spi/AbstractSelector.h create mode 100644 libjava/java/nio/channels/spi/SelectorProvider.h (limited to 'libjava/java/nio/channels') diff --git a/libjava/java/nio/channels/AlreadyConnectedException.h b/libjava/java/nio/channels/AlreadyConnectedException.h new file mode 100644 index 000000000..08d6d479e --- /dev/null +++ b/libjava/java/nio/channels/AlreadyConnectedException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_AlreadyConnectedException__ +#define __java_nio_channels_AlreadyConnectedException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class AlreadyConnectedException; + } + } + } +} + +class java::nio::channels::AlreadyConnectedException : public ::java::lang::IllegalStateException +{ + +public: + AlreadyConnectedException(); +private: + static const jlong serialVersionUID = -7331895245053773357LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_AlreadyConnectedException__ diff --git a/libjava/java/nio/channels/AsynchronousCloseException.h b/libjava/java/nio/channels/AsynchronousCloseException.h new file mode 100644 index 000000000..bfcbf2eb4 --- /dev/null +++ b/libjava/java/nio/channels/AsynchronousCloseException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_AsynchronousCloseException__ +#define __java_nio_channels_AsynchronousCloseException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class AsynchronousCloseException; + } + } + } +} + +class java::nio::channels::AsynchronousCloseException : public ::java::nio::channels::ClosedChannelException +{ + +public: + AsynchronousCloseException(); +private: + static const jlong serialVersionUID = 6891178312432313966LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_AsynchronousCloseException__ diff --git a/libjava/java/nio/channels/ByteChannel.h b/libjava/java/nio/channels/ByteChannel.h new file mode 100644 index 000000000..a81364813 --- /dev/null +++ b/libjava/java/nio/channels/ByteChannel.h @@ -0,0 +1,36 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_ByteChannel__ +#define __java_nio_channels_ByteChannel__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + class ByteBuffer; + namespace channels + { + class ByteChannel; + } + } + } +} + +class java::nio::channels::ByteChannel : public ::java::lang::Object +{ + +public: + virtual jint read(::java::nio::ByteBuffer *) = 0; + virtual jboolean isOpen() = 0; + virtual void close() = 0; + virtual jint write(::java::nio::ByteBuffer *) = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __java_nio_channels_ByteChannel__ diff --git a/libjava/java/nio/channels/CancelledKeyException.h b/libjava/java/nio/channels/CancelledKeyException.h new file mode 100644 index 000000000..742185f1f --- /dev/null +++ b/libjava/java/nio/channels/CancelledKeyException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_CancelledKeyException__ +#define __java_nio_channels_CancelledKeyException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class CancelledKeyException; + } + } + } +} + +class java::nio::channels::CancelledKeyException : public ::java::lang::IllegalStateException +{ + +public: + CancelledKeyException(); +private: + static const jlong serialVersionUID = -8438032138028814268LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_CancelledKeyException__ diff --git a/libjava/java/nio/channels/Channel.h b/libjava/java/nio/channels/Channel.h new file mode 100644 index 000000000..fc0177d6f --- /dev/null +++ b/libjava/java/nio/channels/Channel.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_Channel__ +#define __java_nio_channels_Channel__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class Channel; + } + } + } +} + +class java::nio::channels::Channel : public ::java::lang::Object +{ + +public: + virtual jboolean isOpen() = 0; + virtual void close() = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __java_nio_channels_Channel__ diff --git a/libjava/java/nio/channels/Channels.h b/libjava/java/nio/channels/Channels.h new file mode 100644 index 000000000..384156483 --- /dev/null +++ b/libjava/java/nio/channels/Channels.h @@ -0,0 +1,47 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_Channels__ +#define __java_nio_channels_Channels__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class Channels; + class ReadableByteChannel; + class WritableByteChannel; + } + namespace charset + { + class CharsetDecoder; + class CharsetEncoder; + } + } + } +} + +class java::nio::channels::Channels : public ::java::lang::Object +{ + + Channels(); +public: + static ::java::io::InputStream * newInputStream(::java::nio::channels::ReadableByteChannel *); + static ::java::io::OutputStream * newOutputStream(::java::nio::channels::WritableByteChannel *); + static ::java::nio::channels::ReadableByteChannel * newChannel(::java::io::InputStream *); + static ::java::nio::channels::WritableByteChannel * newChannel(::java::io::OutputStream *); + static ::java::io::Reader * newReader(::java::nio::channels::ReadableByteChannel *, ::java::nio::charset::CharsetDecoder *, jint); + static ::java::io::Reader * newReader(::java::nio::channels::ReadableByteChannel *, ::java::lang::String *); + static ::java::io::Writer * newWriter(::java::nio::channels::WritableByteChannel *, ::java::nio::charset::CharsetEncoder *, jint); + static ::java::io::Writer * newWriter(::java::nio::channels::WritableByteChannel *, ::java::lang::String *); + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_Channels__ diff --git a/libjava/java/nio/channels/ClosedByInterruptException.h b/libjava/java/nio/channels/ClosedByInterruptException.h new file mode 100644 index 000000000..742dddc60 --- /dev/null +++ b/libjava/java/nio/channels/ClosedByInterruptException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_ClosedByInterruptException__ +#define __java_nio_channels_ClosedByInterruptException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class ClosedByInterruptException; + } + } + } +} + +class java::nio::channels::ClosedByInterruptException : public ::java::nio::channels::AsynchronousCloseException +{ + +public: + ClosedByInterruptException(); +private: + static const jlong serialVersionUID = -4488191543534286750LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_ClosedByInterruptException__ diff --git a/libjava/java/nio/channels/ClosedChannelException.h b/libjava/java/nio/channels/ClosedChannelException.h new file mode 100644 index 000000000..3bca678e5 --- /dev/null +++ b/libjava/java/nio/channels/ClosedChannelException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_ClosedChannelException__ +#define __java_nio_channels_ClosedChannelException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class ClosedChannelException; + } + } + } +} + +class java::nio::channels::ClosedChannelException : public ::java::io::IOException +{ + +public: + ClosedChannelException(); +private: + static const jlong serialVersionUID = 882777185433553857LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_ClosedChannelException__ diff --git a/libjava/java/nio/channels/ClosedSelectorException.h b/libjava/java/nio/channels/ClosedSelectorException.h new file mode 100644 index 000000000..80b821ed4 --- /dev/null +++ b/libjava/java/nio/channels/ClosedSelectorException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_ClosedSelectorException__ +#define __java_nio_channels_ClosedSelectorException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class ClosedSelectorException; + } + } + } +} + +class java::nio::channels::ClosedSelectorException : public ::java::lang::IllegalStateException +{ + +public: + ClosedSelectorException(); +private: + static const jlong serialVersionUID = 6466297122317847835LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_ClosedSelectorException__ diff --git a/libjava/java/nio/channels/ConnectionPendingException.h b/libjava/java/nio/channels/ConnectionPendingException.h new file mode 100644 index 000000000..29f483071 --- /dev/null +++ b/libjava/java/nio/channels/ConnectionPendingException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_ConnectionPendingException__ +#define __java_nio_channels_ConnectionPendingException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class ConnectionPendingException; + } + } + } +} + +class java::nio::channels::ConnectionPendingException : public ::java::lang::IllegalStateException +{ + +public: + ConnectionPendingException(); +private: + static const jlong serialVersionUID = 2008393366501760879LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_ConnectionPendingException__ diff --git a/libjava/java/nio/channels/DatagramChannel.h b/libjava/java/nio/channels/DatagramChannel.h new file mode 100644 index 000000000..cb2dabcc0 --- /dev/null +++ b/libjava/java/nio/channels/DatagramChannel.h @@ -0,0 +1,59 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_DatagramChannel__ +#define __java_nio_channels_DatagramChannel__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace net + { + class DatagramSocket; + class SocketAddress; + } + namespace nio + { + class ByteBuffer; + namespace channels + { + class DatagramChannel; + namespace spi + { + class SelectorProvider; + } + } + } + } +} + +class java::nio::channels::DatagramChannel : public ::java::nio::channels::spi::AbstractSelectableChannel +{ + +public: // actually protected + DatagramChannel(::java::nio::channels::spi::SelectorProvider *); +public: + static ::java::nio::channels::DatagramChannel * open(); + virtual jlong read(JArray< ::java::nio::ByteBuffer * > *); + virtual jlong write(JArray< ::java::nio::ByteBuffer * > *); + virtual ::java::nio::channels::DatagramChannel * connect(::java::net::SocketAddress *) = 0; + virtual ::java::nio::channels::DatagramChannel * disconnect() = 0; + virtual jboolean isConnected() = 0; + virtual jint read(::java::nio::ByteBuffer *) = 0; + virtual jlong read(JArray< ::java::nio::ByteBuffer * > *, jint, jint) = 0; + virtual ::java::net::SocketAddress * receive(::java::nio::ByteBuffer *) = 0; + virtual jint send(::java::nio::ByteBuffer *, ::java::net::SocketAddress *) = 0; + virtual ::java::net::DatagramSocket * socket() = 0; + virtual jint write(::java::nio::ByteBuffer *) = 0; + virtual jlong write(JArray< ::java::nio::ByteBuffer * > *, jint, jint) = 0; + virtual jint validOps(); + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_DatagramChannel__ diff --git a/libjava/java/nio/channels/FileChannel$MapMode.h b/libjava/java/nio/channels/FileChannel$MapMode.h new file mode 100644 index 000000000..954e6979e --- /dev/null +++ b/libjava/java/nio/channels/FileChannel$MapMode.h @@ -0,0 +1,40 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_FileChannel$MapMode__ +#define __java_nio_channels_FileChannel$MapMode__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class FileChannel$MapMode; + } + } + } +} + +class java::nio::channels::FileChannel$MapMode : public ::java::lang::Object +{ + +public: // actually package-private + FileChannel$MapMode(jint); +public: + virtual ::java::lang::String * toString(); +public: // actually package-private + jint __attribute__((aligned(__alignof__( ::java::lang::Object)))) m; +public: + static ::java::nio::channels::FileChannel$MapMode * READ_ONLY; + static ::java::nio::channels::FileChannel$MapMode * READ_WRITE; + static ::java::nio::channels::FileChannel$MapMode * PRIVATE; + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_FileChannel$MapMode__ diff --git a/libjava/java/nio/channels/FileChannel.h b/libjava/java/nio/channels/FileChannel.h new file mode 100644 index 000000000..10cc314cc --- /dev/null +++ b/libjava/java/nio/channels/FileChannel.h @@ -0,0 +1,64 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_FileChannel__ +#define __java_nio_channels_FileChannel__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace nio + { + class ByteBuffer; + class MappedByteBuffer; + namespace channels + { + class FileChannel; + class FileChannel$MapMode; + class FileLock; + class ReadableByteChannel; + class WritableByteChannel; + } + } + } +} + +class java::nio::channels::FileChannel : public ::java::nio::channels::spi::AbstractInterruptibleChannel +{ + +public: // actually protected + FileChannel(); +public: + virtual ::java::nio::MappedByteBuffer * map(::java::nio::channels::FileChannel$MapMode *, jlong, jlong) = 0; + virtual jlong size() = 0; + virtual jlong write(JArray< ::java::nio::ByteBuffer * > *); + virtual jint write(::java::nio::ByteBuffer *) = 0; + virtual jint write(::java::nio::ByteBuffer *, jlong) = 0; + virtual jlong write(JArray< ::java::nio::ByteBuffer * > *, jint, jint) = 0; + virtual jlong read(JArray< ::java::nio::ByteBuffer * > *, jint, jint) = 0; + virtual jlong read(JArray< ::java::nio::ByteBuffer * > *); + virtual jint read(::java::nio::ByteBuffer *) = 0; + virtual jint read(::java::nio::ByteBuffer *, jlong) = 0; +public: // actually protected + virtual void implCloseChannel() = 0; +public: + virtual void force(jboolean) = 0; + virtual ::java::nio::channels::FileLock * lock(); + virtual ::java::nio::channels::FileLock * lock(jlong, jlong, jboolean) = 0; + virtual ::java::nio::channels::FileLock * tryLock(); + virtual ::java::nio::channels::FileLock * tryLock(jlong, jlong, jboolean) = 0; + virtual jlong position() = 0; + virtual ::java::nio::channels::FileChannel * position(jlong) = 0; + virtual jlong transferTo(jlong, jlong, ::java::nio::channels::WritableByteChannel *) = 0; + virtual jlong transferFrom(::java::nio::channels::ReadableByteChannel *, jlong, jlong) = 0; + virtual ::java::nio::channels::FileChannel * truncate(jlong) = 0; + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_FileChannel__ diff --git a/libjava/java/nio/channels/FileLock.h b/libjava/java/nio/channels/FileLock.h new file mode 100644 index 000000000..fb3585835 --- /dev/null +++ b/libjava/java/nio/channels/FileLock.h @@ -0,0 +1,48 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_FileLock__ +#define __java_nio_channels_FileLock__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class FileChannel; + class FileLock; + } + } + } +} + +class java::nio::channels::FileLock : public ::java::lang::Object +{ + +public: // actually protected + FileLock(::java::nio::channels::FileChannel *, jlong, jlong, jboolean); +public: + virtual jboolean isValid() = 0; + virtual void release() = 0; + virtual ::java::nio::channels::FileChannel * channel(); + virtual jboolean isShared(); + virtual jboolean overlaps(jlong, jlong); + virtual jlong position(); + virtual jlong size(); + virtual ::java::lang::String * toString(); +private: + ::java::nio::channels::FileChannel * __attribute__((aligned(__alignof__( ::java::lang::Object)))) channel__; + jlong position__; + jlong size__; + jboolean shared; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_FileLock__ diff --git a/libjava/java/nio/channels/FileLockInterruptionException.h b/libjava/java/nio/channels/FileLockInterruptionException.h new file mode 100644 index 000000000..ad5e25076 --- /dev/null +++ b/libjava/java/nio/channels/FileLockInterruptionException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_FileLockInterruptionException__ +#define __java_nio_channels_FileLockInterruptionException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class FileLockInterruptionException; + } + } + } +} + +class java::nio::channels::FileLockInterruptionException : public ::java::io::IOException +{ + +public: + FileLockInterruptionException(); +private: + static const jlong serialVersionUID = 7104080643653532383LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_FileLockInterruptionException__ diff --git a/libjava/java/nio/channels/GatheringByteChannel.h b/libjava/java/nio/channels/GatheringByteChannel.h new file mode 100644 index 000000000..c69c1954a --- /dev/null +++ b/libjava/java/nio/channels/GatheringByteChannel.h @@ -0,0 +1,39 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_GatheringByteChannel__ +#define __java_nio_channels_GatheringByteChannel__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace nio + { + class ByteBuffer; + namespace channels + { + class GatheringByteChannel; + } + } + } +} + +class java::nio::channels::GatheringByteChannel : public ::java::lang::Object +{ + +public: + virtual jlong write(JArray< ::java::nio::ByteBuffer * > *, jint, jint) = 0; + virtual jlong write(JArray< ::java::nio::ByteBuffer * > *) = 0; + virtual jint write(::java::nio::ByteBuffer *) = 0; + virtual jboolean isOpen() = 0; + virtual void close() = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __java_nio_channels_GatheringByteChannel__ diff --git a/libjava/java/nio/channels/IllegalBlockingModeException.h b/libjava/java/nio/channels/IllegalBlockingModeException.h new file mode 100644 index 000000000..38eda0379 --- /dev/null +++ b/libjava/java/nio/channels/IllegalBlockingModeException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_IllegalBlockingModeException__ +#define __java_nio_channels_IllegalBlockingModeException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class IllegalBlockingModeException; + } + } + } +} + +class java::nio::channels::IllegalBlockingModeException : public ::java::lang::IllegalStateException +{ + +public: + IllegalBlockingModeException(); +private: + static const jlong serialVersionUID = -3335774961855590474LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_IllegalBlockingModeException__ diff --git a/libjava/java/nio/channels/IllegalSelectorException.h b/libjava/java/nio/channels/IllegalSelectorException.h new file mode 100644 index 000000000..9f137e423 --- /dev/null +++ b/libjava/java/nio/channels/IllegalSelectorException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_IllegalSelectorException__ +#define __java_nio_channels_IllegalSelectorException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class IllegalSelectorException; + } + } + } +} + +class java::nio::channels::IllegalSelectorException : public ::java::lang::IllegalArgumentException +{ + +public: + IllegalSelectorException(); +private: + static const jlong serialVersionUID = -8406323347253320987LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_IllegalSelectorException__ diff --git a/libjava/java/nio/channels/InterruptibleChannel.h b/libjava/java/nio/channels/InterruptibleChannel.h new file mode 100644 index 000000000..fa8a68385 --- /dev/null +++ b/libjava/java/nio/channels/InterruptibleChannel.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_InterruptibleChannel__ +#define __java_nio_channels_InterruptibleChannel__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class InterruptibleChannel; + } + } + } +} + +class java::nio::channels::InterruptibleChannel : public ::java::lang::Object +{ + +public: + virtual void close() = 0; + virtual jboolean isOpen() = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __java_nio_channels_InterruptibleChannel__ diff --git a/libjava/java/nio/channels/NoConnectionPendingException.h b/libjava/java/nio/channels/NoConnectionPendingException.h new file mode 100644 index 000000000..5be57aefd --- /dev/null +++ b/libjava/java/nio/channels/NoConnectionPendingException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_NoConnectionPendingException__ +#define __java_nio_channels_NoConnectionPendingException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class NoConnectionPendingException; + } + } + } +} + +class java::nio::channels::NoConnectionPendingException : public ::java::lang::IllegalStateException +{ + +public: + NoConnectionPendingException(); +private: + static const jlong serialVersionUID = -8296561183633134743LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_NoConnectionPendingException__ diff --git a/libjava/java/nio/channels/NonReadableChannelException.h b/libjava/java/nio/channels/NonReadableChannelException.h new file mode 100644 index 000000000..210d8369b --- /dev/null +++ b/libjava/java/nio/channels/NonReadableChannelException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_NonReadableChannelException__ +#define __java_nio_channels_NonReadableChannelException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class NonReadableChannelException; + } + } + } +} + +class java::nio::channels::NonReadableChannelException : public ::java::lang::IllegalStateException +{ + +public: + NonReadableChannelException(); +private: + static const jlong serialVersionUID = -3200915679294993514LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_NonReadableChannelException__ diff --git a/libjava/java/nio/channels/NonWritableChannelException.h b/libjava/java/nio/channels/NonWritableChannelException.h new file mode 100644 index 000000000..4a56ef988 --- /dev/null +++ b/libjava/java/nio/channels/NonWritableChannelException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_NonWritableChannelException__ +#define __java_nio_channels_NonWritableChannelException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class NonWritableChannelException; + } + } + } +} + +class java::nio::channels::NonWritableChannelException : public ::java::lang::IllegalStateException +{ + +public: + NonWritableChannelException(); +private: + static const jlong serialVersionUID = -7071230488279011621LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_NonWritableChannelException__ diff --git a/libjava/java/nio/channels/NotYetBoundException.h b/libjava/java/nio/channels/NotYetBoundException.h new file mode 100644 index 000000000..d4f1ad2d6 --- /dev/null +++ b/libjava/java/nio/channels/NotYetBoundException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_NotYetBoundException__ +#define __java_nio_channels_NotYetBoundException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class NotYetBoundException; + } + } + } +} + +class java::nio::channels::NotYetBoundException : public ::java::lang::IllegalStateException +{ + +public: + NotYetBoundException(); +private: + static const jlong serialVersionUID = 4640999303950202242LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_NotYetBoundException__ diff --git a/libjava/java/nio/channels/NotYetConnectedException.h b/libjava/java/nio/channels/NotYetConnectedException.h new file mode 100644 index 000000000..a38417a82 --- /dev/null +++ b/libjava/java/nio/channels/NotYetConnectedException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_NotYetConnectedException__ +#define __java_nio_channels_NotYetConnectedException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class NotYetConnectedException; + } + } + } +} + +class java::nio::channels::NotYetConnectedException : public ::java::lang::IllegalStateException +{ + +public: + NotYetConnectedException(); +private: + static const jlong serialVersionUID = 4697316551909513464LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_NotYetConnectedException__ diff --git a/libjava/java/nio/channels/OverlappingFileLockException.h b/libjava/java/nio/channels/OverlappingFileLockException.h new file mode 100644 index 000000000..b2551f907 --- /dev/null +++ b/libjava/java/nio/channels/OverlappingFileLockException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_OverlappingFileLockException__ +#define __java_nio_channels_OverlappingFileLockException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class OverlappingFileLockException; + } + } + } +} + +class java::nio::channels::OverlappingFileLockException : public ::java::lang::IllegalStateException +{ + +public: + OverlappingFileLockException(); +private: + static const jlong serialVersionUID = 2047812138163068433LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_OverlappingFileLockException__ diff --git a/libjava/java/nio/channels/Pipe$SinkChannel.h b/libjava/java/nio/channels/Pipe$SinkChannel.h new file mode 100644 index 000000000..d6842b79b --- /dev/null +++ b/libjava/java/nio/channels/Pipe$SinkChannel.h @@ -0,0 +1,44 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_Pipe$SinkChannel__ +#define __java_nio_channels_Pipe$SinkChannel__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace nio + { + class ByteBuffer; + namespace channels + { + class Pipe$SinkChannel; + namespace spi + { + class SelectorProvider; + } + } + } + } +} + +class java::nio::channels::Pipe$SinkChannel : public ::java::nio::channels::spi::AbstractSelectableChannel +{ + +public: // actually protected + Pipe$SinkChannel(::java::nio::channels::spi::SelectorProvider *); +public: + virtual jint validOps(); + virtual jint write(::java::nio::ByteBuffer *) = 0; + virtual jlong write(JArray< ::java::nio::ByteBuffer * > *, jint, jint) = 0; + virtual jlong write(JArray< ::java::nio::ByteBuffer * > *) = 0; + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_Pipe$SinkChannel__ diff --git a/libjava/java/nio/channels/Pipe$SourceChannel.h b/libjava/java/nio/channels/Pipe$SourceChannel.h new file mode 100644 index 000000000..9bc78ea3b --- /dev/null +++ b/libjava/java/nio/channels/Pipe$SourceChannel.h @@ -0,0 +1,44 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_Pipe$SourceChannel__ +#define __java_nio_channels_Pipe$SourceChannel__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace nio + { + class ByteBuffer; + namespace channels + { + class Pipe$SourceChannel; + namespace spi + { + class SelectorProvider; + } + } + } + } +} + +class java::nio::channels::Pipe$SourceChannel : public ::java::nio::channels::spi::AbstractSelectableChannel +{ + +public: // actually protected + Pipe$SourceChannel(::java::nio::channels::spi::SelectorProvider *); +public: + virtual jint validOps(); + virtual jint read(::java::nio::ByteBuffer *) = 0; + virtual jlong read(JArray< ::java::nio::ByteBuffer * > *, jint, jint) = 0; + virtual jlong read(JArray< ::java::nio::ByteBuffer * > *) = 0; + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_Pipe$SourceChannel__ diff --git a/libjava/java/nio/channels/Pipe.h b/libjava/java/nio/channels/Pipe.h new file mode 100644 index 000000000..771dca23e --- /dev/null +++ b/libjava/java/nio/channels/Pipe.h @@ -0,0 +1,38 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_Pipe__ +#define __java_nio_channels_Pipe__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class Pipe; + class Pipe$SinkChannel; + class Pipe$SourceChannel; + } + } + } +} + +class java::nio::channels::Pipe : public ::java::lang::Object +{ + +public: // actually protected + Pipe(); +public: + static ::java::nio::channels::Pipe * open(); + virtual ::java::nio::channels::Pipe$SinkChannel * sink() = 0; + virtual ::java::nio::channels::Pipe$SourceChannel * source() = 0; + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_Pipe__ diff --git a/libjava/java/nio/channels/ReadableByteChannel.h b/libjava/java/nio/channels/ReadableByteChannel.h new file mode 100644 index 000000000..9f3e4cf01 --- /dev/null +++ b/libjava/java/nio/channels/ReadableByteChannel.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_ReadableByteChannel__ +#define __java_nio_channels_ReadableByteChannel__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + class ByteBuffer; + namespace channels + { + class ReadableByteChannel; + } + } + } +} + +class java::nio::channels::ReadableByteChannel : public ::java::lang::Object +{ + +public: + virtual jint read(::java::nio::ByteBuffer *) = 0; + virtual jboolean isOpen() = 0; + virtual void close() = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __java_nio_channels_ReadableByteChannel__ diff --git a/libjava/java/nio/channels/ScatteringByteChannel.h b/libjava/java/nio/channels/ScatteringByteChannel.h new file mode 100644 index 000000000..eeba864d4 --- /dev/null +++ b/libjava/java/nio/channels/ScatteringByteChannel.h @@ -0,0 +1,39 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_ScatteringByteChannel__ +#define __java_nio_channels_ScatteringByteChannel__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace nio + { + class ByteBuffer; + namespace channels + { + class ScatteringByteChannel; + } + } + } +} + +class java::nio::channels::ScatteringByteChannel : public ::java::lang::Object +{ + +public: + virtual jlong read(JArray< ::java::nio::ByteBuffer * > *, jint, jint) = 0; + virtual jlong read(JArray< ::java::nio::ByteBuffer * > *) = 0; + virtual jint read(::java::nio::ByteBuffer *) = 0; + virtual jboolean isOpen() = 0; + virtual void close() = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __java_nio_channels_ScatteringByteChannel__ diff --git a/libjava/java/nio/channels/SelectableChannel.h b/libjava/java/nio/channels/SelectableChannel.h new file mode 100644 index 000000000..82cf82880 --- /dev/null +++ b/libjava/java/nio/channels/SelectableChannel.h @@ -0,0 +1,48 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_SelectableChannel__ +#define __java_nio_channels_SelectableChannel__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class SelectableChannel; + class SelectionKey; + class Selector; + namespace spi + { + class SelectorProvider; + } + } + } + } +} + +class java::nio::channels::SelectableChannel : public ::java::nio::channels::spi::AbstractInterruptibleChannel +{ + +public: // actually protected + SelectableChannel(); +public: + virtual ::java::lang::Object * blockingLock() = 0; + virtual ::java::nio::channels::SelectableChannel * configureBlocking(jboolean) = 0; + virtual jboolean isBlocking() = 0; + virtual jboolean isRegistered() = 0; + virtual ::java::nio::channels::SelectionKey * keyFor(::java::nio::channels::Selector *) = 0; + virtual ::java::nio::channels::spi::SelectorProvider * provider() = 0; + virtual ::java::nio::channels::SelectionKey * register$(::java::nio::channels::Selector *, jint); + virtual ::java::nio::channels::SelectionKey * register$(::java::nio::channels::Selector *, jint, ::java::lang::Object *) = 0; + virtual jint validOps() = 0; + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_SelectableChannel__ diff --git a/libjava/java/nio/channels/SelectionKey.h b/libjava/java/nio/channels/SelectionKey.h new file mode 100644 index 000000000..1b6b03974 --- /dev/null +++ b/libjava/java/nio/channels/SelectionKey.h @@ -0,0 +1,55 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_SelectionKey__ +#define __java_nio_channels_SelectionKey__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class SelectableChannel; + class SelectionKey; + class Selector; + } + } + } +} + +class java::nio::channels::SelectionKey : public ::java::lang::Object +{ + +public: // actually protected + SelectionKey(); +public: + virtual ::java::lang::Object * attach(::java::lang::Object *); + virtual ::java::lang::Object * attachment(); + virtual jboolean isAcceptable(); + virtual jboolean isConnectable(); + virtual jboolean isReadable(); + virtual jboolean isWritable(); + virtual void cancel() = 0; + virtual ::java::nio::channels::SelectableChannel * channel() = 0; + virtual jint interestOps() = 0; + virtual ::java::nio::channels::SelectionKey * interestOps(jint) = 0; + virtual jboolean isValid() = 0; + virtual jint readyOps() = 0; + virtual ::java::nio::channels::Selector * selector() = 0; + static const jint OP_ACCEPT = 16; + static const jint OP_CONNECT = 8; + static const jint OP_READ = 1; + static const jint OP_WRITE = 4; +public: // actually package-private + ::java::lang::Object * __attribute__((aligned(__alignof__( ::java::lang::Object)))) attached; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_SelectionKey__ diff --git a/libjava/java/nio/channels/Selector.h b/libjava/java/nio/channels/Selector.h new file mode 100644 index 000000000..7d561adff --- /dev/null +++ b/libjava/java/nio/channels/Selector.h @@ -0,0 +1,47 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_Selector__ +#define __java_nio_channels_Selector__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class Selector; + namespace spi + { + class SelectorProvider; + } + } + } + } +} + +class java::nio::channels::Selector : public ::java::lang::Object +{ + +public: // actually protected + Selector(); +public: + static ::java::nio::channels::Selector * open(); + virtual void close() = 0; + virtual jboolean isOpen() = 0; + virtual ::java::util::Set * keys() = 0; + virtual ::java::nio::channels::spi::SelectorProvider * provider() = 0; + virtual jint select() = 0; + virtual jint select(jlong) = 0; + virtual ::java::util::Set * selectedKeys() = 0; + virtual jint selectNow() = 0; + virtual ::java::nio::channels::Selector * wakeup() = 0; + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_Selector__ diff --git a/libjava/java/nio/channels/ServerSocketChannel.h b/libjava/java/nio/channels/ServerSocketChannel.h new file mode 100644 index 000000000..b68d0b9a5 --- /dev/null +++ b/libjava/java/nio/channels/ServerSocketChannel.h @@ -0,0 +1,46 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_ServerSocketChannel__ +#define __java_nio_channels_ServerSocketChannel__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace net + { + class ServerSocket; + } + namespace nio + { + namespace channels + { + class ServerSocketChannel; + class SocketChannel; + namespace spi + { + class SelectorProvider; + } + } + } + } +} + +class java::nio::channels::ServerSocketChannel : public ::java::nio::channels::spi::AbstractSelectableChannel +{ + +public: // actually protected + ServerSocketChannel(::java::nio::channels::spi::SelectorProvider *); +public: + virtual ::java::nio::channels::SocketChannel * accept() = 0; + virtual ::java::net::ServerSocket * socket() = 0; + static ::java::nio::channels::ServerSocketChannel * open(); + virtual jint validOps(); + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_ServerSocketChannel__ diff --git a/libjava/java/nio/channels/SocketChannel.h b/libjava/java/nio/channels/SocketChannel.h new file mode 100644 index 000000000..b742cdbdc --- /dev/null +++ b/libjava/java/nio/channels/SocketChannel.h @@ -0,0 +1,59 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_SocketChannel__ +#define __java_nio_channels_SocketChannel__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace net + { + class Socket; + class SocketAddress; + } + namespace nio + { + class ByteBuffer; + namespace channels + { + class SocketChannel; + namespace spi + { + class SelectorProvider; + } + } + } + } +} + +class java::nio::channels::SocketChannel : public ::java::nio::channels::spi::AbstractSelectableChannel +{ + +public: // actually protected + SocketChannel(::java::nio::channels::spi::SelectorProvider *); +public: + static ::java::nio::channels::SocketChannel * open(); + static ::java::nio::channels::SocketChannel * open(::java::net::SocketAddress *); + virtual jlong read(JArray< ::java::nio::ByteBuffer * > *); + virtual jlong write(JArray< ::java::nio::ByteBuffer * > *); + virtual jint validOps(); + virtual jint read(::java::nio::ByteBuffer *) = 0; + virtual jboolean connect(::java::net::SocketAddress *) = 0; + virtual jboolean finishConnect() = 0; + virtual jboolean isConnected() = 0; + virtual jboolean isConnectionPending() = 0; + virtual jlong read(JArray< ::java::nio::ByteBuffer * > *, jint, jint) = 0; + virtual ::java::net::Socket * socket() = 0; + virtual jint write(::java::nio::ByteBuffer *) = 0; + virtual jlong write(JArray< ::java::nio::ByteBuffer * > *, jint, jint) = 0; + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_SocketChannel__ diff --git a/libjava/java/nio/channels/UnresolvedAddressException.h b/libjava/java/nio/channels/UnresolvedAddressException.h new file mode 100644 index 000000000..2a3eefdce --- /dev/null +++ b/libjava/java/nio/channels/UnresolvedAddressException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_UnresolvedAddressException__ +#define __java_nio_channels_UnresolvedAddressException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class UnresolvedAddressException; + } + } + } +} + +class java::nio::channels::UnresolvedAddressException : public ::java::lang::IllegalArgumentException +{ + +public: + UnresolvedAddressException(); +private: + static const jlong serialVersionUID = 6136959093620794148LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_UnresolvedAddressException__ diff --git a/libjava/java/nio/channels/UnsupportedAddressTypeException.h b/libjava/java/nio/channels/UnsupportedAddressTypeException.h new file mode 100644 index 000000000..7f63dd76e --- /dev/null +++ b/libjava/java/nio/channels/UnsupportedAddressTypeException.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_UnsupportedAddressTypeException__ +#define __java_nio_channels_UnsupportedAddressTypeException__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class UnsupportedAddressTypeException; + } + } + } +} + +class java::nio::channels::UnsupportedAddressTypeException : public ::java::lang::IllegalArgumentException +{ + +public: + UnsupportedAddressTypeException(); +private: + static const jlong serialVersionUID = -2964323842829700493LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_UnsupportedAddressTypeException__ diff --git a/libjava/java/nio/channels/VMChannels.h b/libjava/java/nio/channels/VMChannels.h new file mode 100644 index 000000000..3706d9d85 --- /dev/null +++ b/libjava/java/nio/channels/VMChannels.h @@ -0,0 +1,52 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_VMChannels__ +#define __java_nio_channels_VMChannels__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace nio + { + namespace channels + { + class FileChannelImpl; + } + } + } + } + namespace java + { + namespace nio + { + namespace channels + { + class ReadableByteChannel; + class VMChannels; + class WritableByteChannel; + } + } + } +} + +class java::nio::channels::VMChannels : public ::java::lang::Object +{ + + VMChannels(); +public: // actually package-private + static ::java::io::FileInputStream * newInputStream(::gnu::java::nio::channels::FileChannelImpl *); + static ::java::io::FileOutputStream * newOutputStream(::gnu::java::nio::channels::FileChannelImpl *); + static ::java::io::InputStream * newInputStream(::java::nio::channels::ReadableByteChannel *); + static ::java::io::OutputStream * newOutputStream(::java::nio::channels::WritableByteChannel *); +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_VMChannels__ diff --git a/libjava/java/nio/channels/VMChannels.java b/libjava/java/nio/channels/VMChannels.java new file mode 100644 index 000000000..4f43a42ad --- /dev/null +++ b/libjava/java/nio/channels/VMChannels.java @@ -0,0 +1,85 @@ +/* VMChannels.java -- + Copyright (C) 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.nio.channels; + +import gnu.java.nio.ChannelInputStream; +import gnu.java.nio.ChannelOutputStream; +import gnu.java.nio.channels.FileChannelImpl; + +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.InputStream; +import java.io.OutputStream; +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; + +final class VMChannels +{ + /** + * This class isn't intended to be instantiated. + */ + private VMChannels() + { + // Do nothing here. + } + + static native FileInputStream newInputStream(FileChannelImpl ch); + + static native FileOutputStream newOutputStream(FileChannelImpl ch); + + /** + * Constructs a stream that reads bytes from the given channel. + */ + static InputStream newInputStream(ReadableByteChannel ch) + { + if (ch instanceof FileChannelImpl) + return newInputStream((FileChannelImpl) ch); + return new ChannelInputStream(ch); + } + + /** + * Constructs a stream that writes bytes to the given channel. + */ + static OutputStream newOutputStream(WritableByteChannel ch) + { + if (ch instanceof FileChannelImpl) + return newOutputStream((FileChannelImpl) ch); + return new ChannelOutputStream(ch); + } +} diff --git a/libjava/java/nio/channels/WritableByteChannel.h b/libjava/java/nio/channels/WritableByteChannel.h new file mode 100644 index 000000000..ff413d27a --- /dev/null +++ b/libjava/java/nio/channels/WritableByteChannel.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_WritableByteChannel__ +#define __java_nio_channels_WritableByteChannel__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + class ByteBuffer; + namespace channels + { + class WritableByteChannel; + } + } + } +} + +class java::nio::channels::WritableByteChannel : public ::java::lang::Object +{ + +public: + virtual jint write(::java::nio::ByteBuffer *) = 0; + virtual jboolean isOpen() = 0; + virtual void close() = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __java_nio_channels_WritableByteChannel__ diff --git a/libjava/java/nio/channels/natVMChannels.cc b/libjava/java/nio/channels/natVMChannels.cc new file mode 100644 index 000000000..d40a51653 --- /dev/null +++ b/libjava/java/nio/channels/natVMChannels.cc @@ -0,0 +1,37 @@ +// natVMChannels.cc - Native part of VMChannels class. + +/* Copyright (C) 2004, 2006 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include +#include + +#include +#include +#include +#include +#include + +using java::nio::channels::VMChannels; +using java::io::FileInputStream; +using java::io::FileOutputStream; +using gnu::java::nio::channels::FileChannelImpl; + +FileInputStream* +VMChannels::newInputStream(FileChannelImpl* ch) +{ + // Needs to be native to bypass Java access protection. + return new FileInputStream (ch); +} + +FileOutputStream* +VMChannels::newOutputStream(FileChannelImpl* ch) +{ + // Needs to be native to bypass Java access protection. + return new FileOutputStream (ch); +} diff --git a/libjava/java/nio/channels/spi/AbstractInterruptibleChannel.h b/libjava/java/nio/channels/spi/AbstractInterruptibleChannel.h new file mode 100644 index 000000000..f830a752b --- /dev/null +++ b/libjava/java/nio/channels/spi/AbstractInterruptibleChannel.h @@ -0,0 +1,46 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_spi_AbstractInterruptibleChannel__ +#define __java_nio_channels_spi_AbstractInterruptibleChannel__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + namespace spi + { + class AbstractInterruptibleChannel; + } + } + } + } +} + +class java::nio::channels::spi::AbstractInterruptibleChannel : public ::java::lang::Object +{ + +public: // actually protected + AbstractInterruptibleChannel(); + virtual void begin(); +public: + virtual void close(); +public: // actually protected + virtual void end(jboolean); + virtual void implCloseChannel() = 0; +public: + virtual jboolean isOpen(); +private: + jboolean __attribute__((aligned(__alignof__( ::java::lang::Object)))) closed; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_spi_AbstractInterruptibleChannel__ diff --git a/libjava/java/nio/channels/spi/AbstractSelectableChannel.h b/libjava/java/nio/channels/spi/AbstractSelectableChannel.h new file mode 100644 index 000000000..f126f441e --- /dev/null +++ b/libjava/java/nio/channels/spi/AbstractSelectableChannel.h @@ -0,0 +1,64 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_spi_AbstractSelectableChannel__ +#define __java_nio_channels_spi_AbstractSelectableChannel__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class SelectableChannel; + class SelectionKey; + class Selector; + namespace spi + { + class AbstractSelectableChannel; + class SelectorProvider; + } + } + } + } +} + +class java::nio::channels::spi::AbstractSelectableChannel : public ::java::nio::channels::SelectableChannel +{ + +public: // actually protected + AbstractSelectableChannel(::java::nio::channels::spi::SelectorProvider *); +public: + virtual ::java::lang::Object * blockingLock(); + virtual ::java::nio::channels::SelectableChannel * configureBlocking(jboolean); +public: // actually protected + virtual void implCloseChannel(); + virtual void implCloseSelectableChannel() = 0; + virtual void implConfigureBlocking(jboolean) = 0; +public: + virtual jboolean isBlocking(); + virtual jboolean isRegistered(); + virtual ::java::nio::channels::SelectionKey * keyFor(::java::nio::channels::Selector *); + virtual ::java::nio::channels::spi::SelectorProvider * provider(); +private: + ::java::nio::channels::SelectionKey * locate(::java::nio::channels::Selector *); +public: + virtual ::java::nio::channels::SelectionKey * register$(::java::nio::channels::Selector *, jint, ::java::lang::Object *); +public: // actually package-private + virtual void addSelectionKey(::java::nio::channels::SelectionKey *); + virtual void removeSelectionKey(::java::nio::channels::SelectionKey *); +private: + jboolean __attribute__((aligned(__alignof__( ::java::nio::channels::SelectableChannel)))) blocking; + ::java::lang::Object * LOCK; + ::java::nio::channels::spi::SelectorProvider * provider__; + ::java::util::LinkedList * keys; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_spi_AbstractSelectableChannel__ diff --git a/libjava/java/nio/channels/spi/AbstractSelectionKey.h b/libjava/java/nio/channels/spi/AbstractSelectionKey.h new file mode 100644 index 000000000..d64a73bfd --- /dev/null +++ b/libjava/java/nio/channels/spi/AbstractSelectionKey.h @@ -0,0 +1,41 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_spi_AbstractSelectionKey__ +#define __java_nio_channels_spi_AbstractSelectionKey__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + namespace spi + { + class AbstractSelectionKey; + } + } + } + } +} + +class java::nio::channels::spi::AbstractSelectionKey : public ::java::nio::channels::SelectionKey +{ + +public: // actually protected + AbstractSelectionKey(); +public: + virtual void cancel(); + virtual jboolean isValid(); +private: + jboolean __attribute__((aligned(__alignof__( ::java::nio::channels::SelectionKey)))) cancelled; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_spi_AbstractSelectionKey__ diff --git a/libjava/java/nio/channels/spi/AbstractSelector.h b/libjava/java/nio/channels/spi/AbstractSelector.h new file mode 100644 index 000000000..cf3d2b7c4 --- /dev/null +++ b/libjava/java/nio/channels/spi/AbstractSelector.h @@ -0,0 +1,60 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_spi_AbstractSelector__ +#define __java_nio_channels_spi_AbstractSelector__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class SelectionKey; + namespace spi + { + class AbstractSelectableChannel; + class AbstractSelectionKey; + class AbstractSelector; + class SelectorProvider; + } + } + } + } +} + +class java::nio::channels::spi::AbstractSelector : public ::java::nio::channels::Selector +{ + +public: // actually protected + AbstractSelector(::java::nio::channels::spi::SelectorProvider *); +public: + virtual void close(); + virtual jboolean isOpen(); +public: // actually protected + virtual void begin(); + virtual void end(); +public: + virtual ::java::nio::channels::spi::SelectorProvider * provider(); +public: // actually protected + virtual ::java::util::Set * cancelledKeys(); +public: // actually package-private + virtual void cancelKey(::java::nio::channels::spi::AbstractSelectionKey *); +public: // actually protected + virtual void implCloseSelector() = 0; + virtual ::java::nio::channels::SelectionKey * register$(::java::nio::channels::spi::AbstractSelectableChannel *, jint, ::java::lang::Object *) = 0; + virtual void deregister(::java::nio::channels::spi::AbstractSelectionKey *); +private: + jboolean __attribute__((aligned(__alignof__( ::java::nio::channels::Selector)))) closed; + ::java::nio::channels::spi::SelectorProvider * provider__; + ::java::util::HashSet * cancelledKeys__; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_spi_AbstractSelector__ diff --git a/libjava/java/nio/channels/spi/SelectorProvider.h b/libjava/java/nio/channels/spi/SelectorProvider.h new file mode 100644 index 000000000..a6b7052be --- /dev/null +++ b/libjava/java/nio/channels/spi/SelectorProvider.h @@ -0,0 +1,52 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_nio_channels_spi_SelectorProvider__ +#define __java_nio_channels_spi_SelectorProvider__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace nio + { + namespace channels + { + class Channel; + class DatagramChannel; + class Pipe; + class ServerSocketChannel; + class SocketChannel; + namespace spi + { + class AbstractSelector; + class SelectorProvider; + } + } + } + } +} + +class java::nio::channels::spi::SelectorProvider : public ::java::lang::Object +{ + +public: // actually protected + SelectorProvider(); +public: + virtual ::java::nio::channels::DatagramChannel * openDatagramChannel() = 0; + virtual ::java::nio::channels::Pipe * openPipe() = 0; + virtual ::java::nio::channels::spi::AbstractSelector * openSelector() = 0; + virtual ::java::nio::channels::ServerSocketChannel * openServerSocketChannel() = 0; + virtual ::java::nio::channels::SocketChannel * openSocketChannel() = 0; + virtual ::java::nio::channels::Channel * inheritedChannel(); + static ::java::nio::channels::spi::SelectorProvider * provider(); +private: + static ::java::nio::channels::spi::SelectorProvider * systemDefaultProvider; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_nio_channels_spi_SelectorProvider__ -- cgit v1.2.3