--- a/ChangeLog	Mon Jan 12 17:29:21 2009 +0000
+++ b/ChangeLog	Mon Jan 12 21:46:12 2009 +0000
@@ -1,3 +1,323 @@
+2009-01-12  Andrew John Hughes  <gnu_andrew@member.fsf.org>
+
+	Initial import of NIO2 code.
+	* patches/ecj/icedtea-pr261.patch: Moved to general patches.
+	* Makefile.am: Add NIO2 patch.
+	* configure.ac: Add --enable-nio2 option (on by default).
+	* overlays/nio2/openjdk/jdk/make/mkdemo/nio/Makefile,
+	* overlays/nio2/openjdk/jdk/make/mkdemo/nio/ZipFileSystem/Makefile,
+	* overlays/nio2/openjdk/jdk/make/mksample/nio/aio/Makefile,
+	* overlays/nio2/openjdk/jdk/make/mksample/nio/file/Makefile,
+	* overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedCopyOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedOpenOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedWatchEventModifier.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/io/File.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/io/FilePermission.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/io/Inputs.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/io/Outputs.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/AsynchronousByteChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/AsynchronousChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/AsynchronousDatagramChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/AsynchronousFileChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/AsynchronousServerSocketChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/AsynchronousSocketChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/Channels.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/CompletionHandler.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/FileChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/FileLock.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/SeekableByteChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/exceptions,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/package-info.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/spi/AsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/channels/spi/package.html,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/AccessDeniedException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/AccessMode.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/AtomicMoveNotSupportedException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/ClosedDirectoryStreamException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/ClosedFileSystemException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/ClosedWatchServiceException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/CopyOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/DirectoryNotEmptyException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/DirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/DirectoryStreamFilters.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileAction.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileAlreadyExistsException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileRef.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileStore.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileSystemAlreadyExistsException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileSystemException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileSystemNotFoundException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileSystems.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileTreeWalker.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileVisitOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileVisitResult.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/FileVisitor.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/Files.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/InvalidPathException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/LinkOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/LinkPermission.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/NoSuchFileException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/NotDirectoryException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/NotLinkException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/OpenOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/Path.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/PathMatcher.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/Paths.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/ProviderMismatchException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/ProviderNotFoundException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/ReadOnlyFileSystemException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/SecureDirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/SimpleFileVisitor.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/StandardCopyOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/StandardOpenOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/StandardWatchEventKind.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/WatchEvent.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/WatchKey.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/WatchService.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/Watchable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/AclEntry.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/AclEntryFlag.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/AclEntryPermission.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/AclEntryType.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/AclFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/AttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/Attributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/BasicFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/BasicFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/DosFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/DosFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/FileAttribute.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/FileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/FileOwnerAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/FileStoreAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/FileStoreSpaceAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/FileStoreSpaceAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/GroupPrincipal.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/NamedAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/PosixFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/PosixFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/PosixFilePermission.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/PosixFilePermissions.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/UserPrincipal.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/UserPrincipalLookupService.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/UserPrincipalNotFoundException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/attribute/package-info.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/package-info.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/spi/AbstractPath.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/spi/FileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/spi/FileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/nio/file/spi/package-info.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/util/Scanner.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AbstractFuture.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousChannelGroupImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousFileChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousFileLockImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousServerSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/Cancellable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/CompletedFuture.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/FileLockTable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/Groupable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/Invoker.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/PendingFuture.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/SimpleAsynchronousDatagramChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/SimpleAsynchronousFileChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/ThreadPool.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractAclFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractBasicFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractFileStoreSpaceAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractNamedAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractPoller.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractWatchKey.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/Cancellable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/FileOwnerAttributeViewImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/Globs.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/MimeType.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/NativeBuffer.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/NativeBuffers.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/PollingWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/Reflect.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/aio/EchoServer.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/AclEdit.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/Chmod.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/Copy.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/DiskUsage.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/FileType.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/WatchDir.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/Xdd.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/DefaultAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/LinuxAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/SolarisAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/SolarisEventPort.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/UnixAsynchronousServerSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/UnixAsynchronousSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/DefaultFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/DefaultFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/GnomeFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxDosFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxFileStore.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxFileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxNamedAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxNativeDispatcher.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisAclFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisFileStore.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisFileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisNamedAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisNativeDispatcher.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/SolarisWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixChannelFactory.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixCopyFile.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixDirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixException.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileAttributeViews.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileKey.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileModeAttribute.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileStore.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileStoreAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixMountEntry.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixNativeDispatcher.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixPath.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixSecureDirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixUriUtils.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixUserPrincipals.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/ch/EPollPort.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/ch/SolarisEventPort.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/ch/UnixAsynchronousServerSocketChannelImpl.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/ch/UnixAsynchronousSocketChannelImpl.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/GnomeFileTypeDetector.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/LinuxNativeDispatcher.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/SolarisNativeDispatcher.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/SolarisWatchService.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/UnixCopyFile.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/UnixNativeDispatcher.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/genSolarisConstants.c,
+	* overlays/nio2/openjdk/jdk/src/solaris/native/sun/nio/fs/genUnixConstants.c,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/DefaultAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/Iocp.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/PendingIoCache.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/WindowsAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/WindowsAsynchronousFileChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/WindowsAsynchronousServerSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/ch/WindowsAsynchronousSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/DefaultFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/DefaultFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/RegistryFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsAclFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsChannelFactory.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsConstants.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsDirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsException.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileAttributeViews.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileCopy.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileStore.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsLinkSupport.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsNamedAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsNativeDispatcher.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsPath.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsPathParser.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsPathType.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsSecurity.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsSecurityDescriptor.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsUriSupport.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsUserPrincipals.java,
+	* overlays/nio2/openjdk/jdk/src/windows/classes/sun/nio/fs/WindowsWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/ch/Iocp.c,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/ch/WindowsAsynchronousFileChannelImpl.c,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/ch/WindowsAsynchronousServerSocketChannelImpl.c,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/ch/WindowsAsynchronousSocketChannelImpl.c,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/fs/RegistryFileTypeDetector.c,
+	* overlays/nio2/openjdk/jdk/src/windows/native/sun/nio/fs/WindowsNativeDispatcher.c,
+	* overlays/nio2/openjdk/jdk/test/demo/nio/ZipFileSystem/Sanity.java,
+	* overlays/nio2/openjdk/jdk/test/demo/nio/ZipFileSystem/sanity.sh,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/io/Inputs/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup/AsExecutor.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup/Attack.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup/GroupOfOne.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup/Identity.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup/PrivilegedThreadFactory.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup/Restart.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup/Unbounded.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup/run_any_task.sh,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousDatagramChannel/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousFileChannel/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousFileChannel/CustomThreadPool.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousFileChannel/Lock.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousFileChannel/MyThreadFactory.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousServerSocketChannel/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousServerSocketChannel/WithSecurityManager.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousServerSocketChannel/java.policy.allow,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousServerSocketChannel/java.policy.deny,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousSocketChannel/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousSocketChannel/Leaky.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/Channels/Basic2.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/spi/AsynchronousChannelProvider/CheckProvider.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/spi/AsynchronousChannelProvider/META-INF/services/java.nio.channels.spi.AsynchronousChannelProvider,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/spi/AsynchronousChannelProvider/Provider1.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/spi/AsynchronousChannelProvider/Provider2.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/spi/AsynchronousChannelProvider/custom_provider.sh,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/DirectoryStream/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/DirectoryStream/Filters.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/DirectoryStream/SecureDS.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/FileStore/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/FileSystem/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Files/ContentType.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Files/CreateFileTree.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Files/ForceLoad.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Files/META-INF/services/java.nio.file.spi.FileTypeDetector,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Files/Misc.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Files/PrintFileTree.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Files/SimpleFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Files/SkipSiblings.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Files/TerminateWalk.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Files/content_type.sh,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Files/walk_file_tree.sh,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Path/CopyAndMove.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Path/DeleteOnClose.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Path/InterruptCopy.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Path/Links.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Path/Misc.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Path/PathOps.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Path/SBC.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Path/TemporaryFiles.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Path/UriImportExport.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Path/delete_on_close.sh,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/Path/temporary_files.sh,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/PathMatcher/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/TestUtil.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/WatchService/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/WatchService/FileTreeModifier.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/WatchService/WithSecurityManager.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/WatchService/denyAll.policy,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/WatchService/grantDirAndOneLevel.policy,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/WatchService/grantDirAndTree.policy,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/WatchService/grantDirOnly.policy,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/attribute/AclFileAttributeView/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/attribute/Attributes/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/attribute/BasicFileAttributeView/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/attribute/DosFileAttributeView/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/attribute/FileStoreAttributeView/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/attribute/NamedAttributeView/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/attribute/PosixFileAttributeView/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/spi/SetDefaultProvider.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/file/spi/TestProvider.java: Added.
+	* patches/icedtea-nio2.patch: New patch.
+	* patches/icedtea-pr261.patch: Moved from ecj-specific patches.
+
 2009-01-12  Andrew Haley  <aph@redhat.com>
 
 	* ports/hotspot/src/share/vm/shark/sharkBlock.cpp (SharkBlock::do_ldc):

--- a/Makefile.am	Mon Jan 12 17:29:21 2009 +0000
+++ b/Makefile.am	Mon Jan 12 21:46:12 2009 +0000
@@ -643,7 +643,8 @@
 	patches/icedtea-samejvm-safe.patch \
 	patches/icedtea-6728542-epoll.patch \
 	patches/icedtea-io_util-overflow.patch \
-	patches/icedtea-cc-interp-jvmti.patch
+	patches/icedtea-cc-interp-jvmti.patch \
+	patches/icedtea-pr261.patch
 
 if WITH_ALT_HSBUILD
 ICEDTEA_PATCHES += \
@@ -688,6 +689,10 @@
 ICEDTEA_PATCHES += $(sort $(subst $(abs_top_srcdir)/,,$(XRENDER_PATCH_FILES)))
 endif
 
+if ENABLE_NIO2
+ICEDTEA_PATCHES += patches/icedtea-nio2.patch
+endif
+
 ICEDTEA_PATCHES += \
 	$(DISTRIBUTION_PATCHES) \
 	patches/icedtea-a11y-property-change.patch \
@@ -883,8 +888,11 @@
 	fi
 
 stamps/overlay.stamp: stamps/patch.stamp
-	cp -r $(abs_top_srcdir)/overlays/openjdk/* openjdk/ \
-	  && touch stamps/overlay.stamp
+	cp -r $(abs_top_srcdir)/overlays/openjdk/* openjdk/
+if ENABLE_NIO2
+	cp -r $(abs_top_srcdir)/overlays/nio2/openjdk/* openjdk/
+endif
+	touch stamps/overlay.stamp
 
 # OpenJDK ecj Source Preparation Targets
 # ======================================
@@ -927,8 +935,7 @@
 ICEDTEA_ECJ_PATCHES = patches/ecj/icedtea.patch \
 	patches/ecj/icedtea-hotspot-$(HSBUILD).patch \
 	patches/ecj/icedtea-spp.patch \
-	patches/ecj/icedtea-jopt.patch \
-	patches/ecj/icedtea-pr261.patch
+	patches/ecj/icedtea-jopt.patch
 
 stamps/patch-ecj.stamp: stamps/extract-ecj.stamp
 	mkdir -p stamps; \

--- a/configure.ac	Mon Jan 12 17:29:21 2009 +0000
+++ b/configure.ac	Mon Jan 12 21:46:12 2009 +0000
@@ -149,6 +149,14 @@
 AM_CONDITIONAL([ENABLE_XRENDER], [test x$ENABLE_XRENDER = xyes])
 AC_MSG_RESULT(${ENABLE_XRENDER})
 
+AC_MSG_CHECKING(whether to include NIO2 support)
+AC_ARG_ENABLE([nio2],
+	      [AS_HELP_STRING([--disable-nio2],
+	      		      [Disable inclusion of backported NIO2])],
+	      [ENABLE_XRENDER="${enableval}"], [ENABLE_NIO2='yes'])
+AM_CONDITIONAL([ENABLE_NIO2], [test x$ENABLE_NIO2 = xyes])
+AC_MSG_RESULT(${ENABLE_NIO2})
+
 AC_MSG_CHECKING(whether to build VisualVM)
 AC_ARG_ENABLE([visualvm],
               [AS_HELP_STRING([--enable-visualvm],

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/overlays/nio2/openjdk/jdk/make/mkdemo/nio/Makefile	Mon Jan 12 21:46:12 2009 +0000
@@ -0,0 +1,37 @@
+#
+# Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This code is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 2 only, as
+# published by the Free Software Foundation.  Sun designates this
+# particular file as subject to the "Classpath" exception as provided
+# by Sun in the LICENSE file that accompanied this code.
+#
+# This code 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
+# version 2 for more details (a copy is included in the LICENSE file that
+# accompanied this code).
+#
+# You should have received a copy of the GNU General Public License version
+# 2 along with this work; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+# CA 95054 USA or visit www.sun.com if you need additional information or
+# have any questions.
+#
+
+#
+# Makefile for building the NIO demo(s)
+#
+
+BUILDDIR = ../..
+PRODUCT = demos
+include $(BUILDDIR)/common/Defs.gmk
+
+SUBDIRS = ZipFileSystem
+
+all build clean clobber::
+	$(SUBDIRS-loop)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/overlays/nio2/openjdk/jdk/make/mkdemo/nio/ZipFileSystem/Makefile	Mon Jan 12 21:46:12 2009 +0000
@@ -0,0 +1,40 @@
+#
+# Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This code is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 2 only, as
+# published by the Free Software Foundation.  Sun designates this
+# particular file as subject to the "Classpath" exception as provided
+# by Sun in the LICENSE file that accompanied this code.
+#
+# This code 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
+# version 2 for more details (a copy is included in the LICENSE file that
+# accompanied this code).
+#
+# You should have received a copy of the GNU General Public License version
+# 2 along with this work; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+# CA 95054 USA or visit www.sun.com if you need additional information or
+# have any questions.
+#
+
+BUILDDIR = ../../..
+PRODUCT = demo/nio
+DEMONAME = ZipFileSystem
+include $(BUILDDIR)/common/Defs.gmk
+
+DEMO_ROOT       = $(SHARE_SRC)/demo/nio/$(DEMONAME)
+DEMO_TOPFILES   = ./README.txt
+DEMO_MAINCLASS  = $(DEMONAME)
+DEMO_DESTDIR    = $(DEMODIR)/nio/$(DEMONAME)
+
+#
+# Demo jar building rules.
+#
+include $(BUILDDIR)/common/Demo.gmk
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/overlays/nio2/openjdk/jdk/make/mksample/nio/aio/Makefile	Mon Jan 12 21:46:12 2009 +0000
@@ -0,0 +1,50 @@
+#
+# Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This code is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 2 only, as
+# published by the Free Software Foundation.  Sun designates this
+# particular file as subject to the "Classpath" exception as provided
+# by Sun in the LICENSE file that accompanied this code.
+#
+# This code 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
+# version 2 for more details (a copy is included in the LICENSE file that
+# accompanied this code).
+#
+# You should have received a copy of the GNU General Public License version
+# 2 along with this work; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+# CA 95054 USA or visit www.sun.com if you need additional information or
+# have any questions.
+#
+
+#
+# Makefile for the nio/aio sample code
+#
+
+BUILDDIR = ../../..
+
+PRODUCT = java
+
+include $(BUILDDIR)/common/Defs.gmk
+
+SAMPLE_SRC_DIR = $(SHARE_SRC)/sample/nio/aio
+SAMPLE_DST_DIR = $(SAMPLEDIR)/nio/aio
+
+SAMPLE_FILES =							\
+	$(SAMPLE_DST_DIR)/EchoServer.java
+
+all build: $(SAMPLE_FILES)
+
+$(SAMPLE_DST_DIR)/%: $(SAMPLE_SRC_DIR)/%
+	$(install-file)
+
+clean clobber:
+	$(RM) -r $(SAMPLE_DST_DIR)
+
+.PHONY: all build clean clobber

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/overlays/nio2/openjdk/jdk/make/mksample/nio/file/Makefile	Mon Jan 12 21:46:12 2009 +0000
@@ -0,0 +1,56 @@
+#
+# Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This code is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 2 only, as
+# published by the Free Software Foundation.  Sun designates this
+# particular file as subject to the "Classpath" exception as provided
+# by Sun in the LICENSE file that accompanied this code.
+#
+# This code 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
+# version 2 for more details (a copy is included in the LICENSE file that
+# accompanied this code).
+#
+# You should have received a copy of the GNU General Public License version
+# 2 along with this work; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+# CA 95054 USA or visit www.sun.com if you need additional information or
+# have any questions.
+#
+
+#
+# Makefile for the nio/file sample code
+#
+
+BUILDDIR = ../../..
+
+PRODUCT = java
+
+include $(BUILDDIR)/common/Defs.gmk
+
+SAMPLE_SRC_DIR = $(SHARE_SRC)/sample/nio/file
+SAMPLE_DST_DIR = $(SAMPLEDIR)/nio/file
+
+SAMPLE_FILES =							\
+	$(SAMPLE_DST_DIR)/AclEdit.java				\
+	$(SAMPLE_DST_DIR)/Chmod.java				\
+	$(SAMPLE_DST_DIR)/Copy.java				\
+	$(SAMPLE_DST_DIR)/DiskUsage.java			\
+	$(SAMPLE_DST_DIR)/FileType.java				\
+	$(SAMPLE_DST_DIR)/WatchDir.java				\
+	$(SAMPLE_DST_DIR)/Xdd.java
+
+all build: $(SAMPLE_FILES)
+
+$(SAMPLE_DST_DIR)/%: $(SAMPLE_SRC_DIR)/%
+	$(install-file)
+
+clean clobber:
+	$(RM) -r $(SAMPLE_DST_DIR)
+
+.PHONY: all build clean clobber

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedCopyOption.java	Mon Jan 12 21:46:12 2009 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.nio.file;
+
+import java.nio.file.CopyOption;
+
+/**
+ * Defines <em>extended</em> copy options supported on some platforms
+ * by Sun's provider implementation.
+ *
+ * @since 1.7
+ */
+
+public enum ExtendedCopyOption implements CopyOption {
+    /**
+     * The copy may be interrupted by the {@link Thread#interrupt interrupt}
+     * method.
+     */
+    INTERRUPTIBLE,
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedOpenOption.java	Mon Jan 12 21:46:12 2009 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.nio.file;
+
+import java.nio.file.OpenOption;
+
+/**
+ * Defines <em>extended</em> open options supported on some platforms
+ * by Sun's provider implementation.
+ *
+ * @since 1.7
+ */
+
+public enum ExtendedOpenOption implements OpenOption {
+    /**
+     * Prevent operations on the file that request read access.
+     */
+    NOSHARE_READ,
+    /**
+     * Prevent operations on the file that request write access.
+     */
+    NOSHARE_WRITE,
+    /**
+     * Prevent operations on the file that request delete access.
+     */
+    NOSHARE_DELETE;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedWatchEventModifier.java	Mon Jan 12 21:46:12 2009 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.nio.file;
+
+import java.nio.file.WatchEvent.Modifier;
+
+/**
+ * Defines <em>extended</em> watch event modifiers supported on some platforms
+ * by Sun's provider implementation.
+ *
+ * @since 1.7
+ */
+
+public enum ExtendedWatchEventModifier implements Modifier {
+
+    /**
+     * Register a file tree instead of a single directory.
+     */
+    FILE_TREE,
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/io/File.java	Mon Jan 12 21:46:12 2009 +0000
@@ -0,0 +1,450 @@
+/*
+ * Copyright 1994-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package org.classpath.icedtea.java.io;
+
+import java.beans.ConstructorProperties;
+import java.net.URI;
+import java.net.URL;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+
+import java.io.IOException;
+import java.io.IOError;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import sun.security.action.GetPropertyAction;
+
+import org.classpath.icedtea.java.nio.file.FileAlreadyExistsException;
+import org.classpath.icedtea.java.nio.file.FileSystem;
+import org.classpath.icedtea.java.nio.file.FileSystems;
+import org.classpath.icedtea.java.nio.file.InvalidPathException;
+import org.classpath.icedtea.java.nio.file.Path;
+import org.classpath.icedtea.java.nio.file.Paths;
+
+import org.classpath.icedtea.java.nio.file.attribute.FileAttribute;
+import org.classpath.icedtea.java.nio.file.attribute.FileAttributeView;
+import org.classpath.icedtea.java.nio.file.attribute.PosixFilePermission;
+import org.classpath.icedtea.java.nio.file.attribute.PosixFilePermissions;
+
+import org.classpath.icedtea.misc.SharedSecrets;
+
+/**
+ * An abstract representation of file and directory pathnames.
+ *
+ * <p> User interfaces and operating systems use system-dependent <em>pathname
+ * strings</em> to name files and directories.  This class presents an
+ * abstract, system-independent view of hierarchical pathnames.  An
+ * <em>abstract pathname</em> has two components:
+ *
+ * <ol>
+ * <li> An optional system-dependent <em>prefix</em> string,
+ *      such as a disk-drive specifier, <code>"/"</code>&nbsp;for the UNIX root
+ *      directory, or <code>"\\\\"</code>&nbsp;for a Microsoft Windows UNC pathname, and
+ * <li> A sequence of zero or more string <em>names</em>.
+ * </ol>
+ *
+ * The first name in an abstract pathname may be a directory name or, in the
+ * case of Microsoft Windows UNC pathnames, a hostname.  Each subsequent name
+ * in an abstract pathname denotes a directory; the last name may denote
+ * either a directory or a file.  The <em>empty</em> abstract pathname has no
+ * prefix and an empty name sequence.
+ *
+ * <p> The conversion of a pathname string to or from an abstract pathname is
+ * inherently system-dependent.  When an abstract pathname is converted into a
+ * pathname string, each name is separated from the next by a single copy of
+ * the default <em>separator character</em>.  The default name-separator
+ * character is defined by the system property <code>file.separator</code>, and
+ * is made available in the public static fields <code>{@link
+ * #separator}</code> and <code>{@link #separatorChar}</code> of this class.
+ * When a pathname string is converted into an abstract pathname, the names
+ * within it may be separated by the default name-separator character or by any
+ * other name-separator character that is supported by the underlying system.
+ *
+ * <p> A pathname, whether abstract or in string form, may be either
+ * <em>absolute</em> or <em>relative</em>.  An absolute pathname is complete in
+ * that no other information is required in order to locate the file that it
+ * denotes.  A relative pathname, in contrast, must be interpreted in terms of
+ * information taken from some other pathname.  By default the classes in the
+ * <code>java.io</code> package always resolve relative pathnames against the
+ * current user directory.  This directory is named by the system property
+ * <code>user.dir</code>, and is typically the directory in which the Java
+ * virtual machine was invoked.
+ *
+ * <p> The <em>parent</em> of an abstract pathname may be obtained by invoking
+ * the {@link #getParent} method of this class and consists of the pathname's
+ * prefix and each name in the pathname's name sequence except for the last.
+ * Each directory's absolute pathname is an ancestor of any <tt>File</tt>
+ * object with an absolute abstract pathname which begins with the directory's
+ * absolute pathname.  For example, the directory denoted by the abstract
+ * pathname <tt>"/usr"</tt> is an ancestor of the directory denoted by the
+ * pathname <tt>"/usr/local/bin"</tt>.
+ *
+ * <p> The prefix concept is used to handle root directories on UNIX platforms,
+ * and drive specifiers, root directories and UNC pathnames on Microsoft Windows platforms,
+ * as follows:
+ *
+ * <ul>
+ *
+ * <li> For UNIX platforms, the prefix of an absolute pathname is always
+ * <code>"/"</code>.  Relative pathnames have no prefix.  The abstract pathname
+ * denoting the root directory has the prefix <code>"/"</code> and an empty
+ * name sequence.
+ *
+ * <li> For Microsoft Windows platforms, the prefix of a pathname that contains a drive
+ * specifier consists of the drive letter followed by <code>":"</code> and
+ * possibly followed by <code>"\\"</code> if the pathname is absolute.  The
+ * prefix of a UNC pathname is <code>"\\\\"</code>; the hostname and the share
+ * name are the first two names in the name sequence.  A relative pathname that
+ * does not specify a drive has no prefix.
+ *
+ * </ul>
+ *
+ * <p> Instances of this class may or may not denote an actual file-system
+ * object such as a file or a directory.  If it does denote such an object
+ * then that object resides in a <i>partition</i>.  A partition is an
+ * operating system-specific portion of storage for a file system.  A single
+ * storage device (e.g. a physical disk-drive, flash memory, CD-ROM) may
+ * contain multiple partitions.  The object, if any, will reside on the
+ * partition <a name="partName">named</a> by some ancestor of the absolute
+ * form of this pathname.
+ *
+ * <p> A file system may implement restrictions to certain operations on the
+ * actual file-system object, such as reading, writing, and executing.  These
+ * restrictions are collectively known as <i>access permissions</i>.  The file
+ * system may have multiple sets of access permissions on a single object.
+ * For example, one set may apply to the object's <i>owner</i>, and another
+ * may apply to all other users.  The access permissions on an object may
+ * cause some methods in this class to fail.
+ *
+ * <p> Instances of the <code>File</code> class are immutable; that is, once
+ * created, the abstract pathname represented by a <code>File</code> object
+ * will never change.
+ *
+ * <h4>Interoperability with {@code java.nio.file} package</h4>
+ *
+ * <p> {@note new}
+ * The <a href="../../java/nio/file/package-summary.html">{@code java.nio.file}</a>
+ * package defines interfaces and classes for the Java virtual machine to access
+ * files, file attributes, and file systems. This API may be used to overcome
+ * many of the limitations of the {@code java.io.File} class.
+ * The {@link #toPath toPath} method may be used to obtain a {@link
+ * Path} that uses the abstract path represented by a {@code File} object to
+ * locate a file. The resulting {@code Path} provides more efficient and
+ * extensive access to file attributes, additional file operations, and I/O
+ * exceptions to help diagnose errors when an operation on a file fails.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+
+public class File
+  extends java.io.File
+{
+
+    /**
+     * Creates a new <code>File</code> instance by converting the given
+     * pathname string into an abstract pathname.  If the given string is
+     * the empty string, then the result is the empty abstract pathname.
+     *
+     * @param   pathname  A pathname string
+     * @throws  NullPointerException
+     *          If the <code>pathname</code> argument is <code>null</code>
+     */
+    @ConstructorProperties("path")
+    public File(String pathname) {
+      super(pathname);
+    }
+
+    /* Note: The two-argument File constructors do not interpret an empty
+       parent abstract pathname as the current user directory.  An empty parent
+       instead causes the child to be resolved against the system-dependent
+       directory defined by the FileSystem.getDefaultParent method.  On Unix
+       this default is "/", while on Microsoft Windows it is "\\".  This is required for
+       compatibility with the original behavior of this class. */
+
+    /**
+     * Creates a new <code>File</code> instance from a parent pathname string
+     * and a child pathname string.
+     *
+     * <p> If <code>parent</code> is <code>null</code> then the new
+     * <code>File</code> instance is created as if by invoking the
+     * single-argument <code>File</code> constructor on the given
+     * <code>child</code> pathname string.
+     *
+     * <p> Otherwise the <code>parent</code> pathname string is taken to denote
+     * a directory, and the <code>child</code> pathname string is taken to
+     * denote either a directory or a file.  If the <code>child</code> pathname
+     * string is absolute then it is converted into a relative pathname in a
+     * system-dependent way.  If <code>parent</code> is the empty string then
+     * the new <code>File</code> instance is created by converting
+     * <code>child</code> into an abstract pathname and resolving the result
+     * against a system-dependent default directory.  Otherwise each pathname
+     * string is converted into an abstract pathname and the child abstract
+     * pathname is resolved against the parent.
+     *
+     * @param   parent  The parent pathname string
+     * @param   child   The child pathname string
+     * @throws  NullPointerException
+     *          If <code>child</code> is <code>null</code>
+     */
+    public File(String parent, String child) {
+      super(parent, child);
+    }
+
+    /**
+     * Creates a new <code>File</code> instance from a parent abstract
+     * pathname and a child pathname string.
+     *
+     * <p> If <code>parent</code> is <code>null</code> then the new
+     * <code>File</code> instance is created as if by invoking the
+     * single-argument <code>File</code> constructor on the given
+     * <code>child</code> pathname string.
+     *
+     * <p> Otherwise the <code>parent</code> abstract pathname is taken to
+     * denote a directory, and the <code>child</code> pathname string is taken
+     * to denote either a directory or a file.  If the <code>child</code>
+     * pathname string is absolute then it is converted into a relative
+     * pathname in a system-dependent way.  If <code>parent</code> is the empty
+     * abstract pathname then the new <code>File</code> instance is created by
+     * converting <code>child</code> into an abstract pathname and resolving
+     * the result against a system-dependent default directory.  Otherwise each
+     * pathname string is converted into an abstract pathname and the child
+     * abstract pathname is resolved against the parent.
+     *
+     * @param   parent  The parent abstract pathname
+     * @param   child   The child pathname string
+     * @throws  NullPointerException
+     *          If <code>child</code> is <code>null</code>
+     */
+    public File(File parent, String child) {
+      super(parent, child);
+    }
+
+
+
+    /* -- Temporary files -- */
+
+    private static class TemporaryDirectory {
+        private TemporaryDirectory() { }
+
+        static final File valueAsFile =
+            new File(AccessController.doPrivileged(new GetPropertyAction("java.io.tmpdir")));
+
+        // file name generation
+        private static final AtomicInteger counter =
+            new AtomicInteger(new Random().nextInt() & 0xffff);
+        static File generateFile(String prefix, String suffix, File dir) {
+            int n = counter.getAndIncrement();
+            return new File(dir, prefix + Integer.toString(n) + suffix);
+        }
+
+        // default file permissions
+        static final FileAttribute<Set<PosixFilePermission>> defaultPosixFilePermissions =
+            PosixFilePermissions.asFileAttribute(EnumSet
+                .of(PosixFilePermission.OWNER_READ, PosixFilePermission.OWNER_WRITE));
+        static final boolean isPosix = isPosix();
+        static boolean isPosix() {
+            return AccessController.doPrivileged(
+                new PrivilegedAction<Boolean>() {
+                    public Boolean run() {
+                        try {
+			  return FileSystems.getDefault().getPath(valueAsFile.getPath())
+                                .getFileStore().supportsFileAttributeView("posix");
+                        } catch (IOException e) {
+                            throw new IOError(e);
+                        }
+                    }
+                });
+        }
+    }
+
+    /**
+     * {@note new}
+     * Creates an empty file in the default temporary-file directory, using
+     * the given prefix and suffix to generate its name. This method is
+     * equivalent to invoking the {@link #createTempFile(String,String)
+     * createTempFile(prefix,&nbsp;suffix)} method with the addition that the
+     * resulting pathname may be requested to be deleted when the Java virtual
+     * machine terminates, and the initial file attributes to set atomically
+     * when creating the file may be specified.
+     *
+     * <p> When the value of the {@code deleteOnExit} method is {@code true}
+     * then the resulting file is requested to be deleted when the Java virtual
+     * machine terminates as if by invoking the {@link #deleteOnExit deleteOnExit}
+     * method.
+     *
+     * <p> The {@code attrs} parameter is an optional array of {@link FileAttribute
+     * attributes} to set atomically when creating the file. Each attribute is
+     * identified by its {@link FileAttribute#name name}. If more than one attribute
+     * of the same name is included in the array then all but the last occurrence
+     * is ignored.
+     *
+     * @param   prefix
+     *          The prefix string to be used in generating the file's
+     *          name; must be at least three characters long
+     * @param   suffix
+     *          The suffix string to be used in generating the file's
+     *          name; may be {@code null}, in which case the suffix
+     *          {@code ".tmp"} will be used
+     * @param   deleteOnExit
+     *          {@code true} if the file denoted by resulting pathname be
+     *          deleted when the Java virtual machine terminates
+     * @param   attrs
+     *          An optional list of file attributes to set atomically when creating
+     *          the file
+     *
+     * @return  An abstract pathname denoting a newly-created empty file
+     *
+     * @throws  IllegalArgumentException
+     *          If the <code>prefix</code> argument contains fewer than three
+     *          characters
+     * @throws  UnsupportedOperationException
+     *          If the array contains an attribute that cannot be set atomically
+     *          when creating the file
+     * @throws  IOException
+     *          If a file could not be created
+     * @throws  SecurityException
+     *          If a security manager exists and its <code>{@link
+     *          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
+     *          method does not allow a file to be created. When the {@code
+     *          deleteOnExit} parameter has the value {@code true} then the
+     *          security manager's {@link
+     *          java.lang.SecurityManager#checkDelete(java.lang.String)} is
+     *          invoked to check delete access to the file.
+     * @since 1.7
+     */
+    public static File createTempFile(String prefix,
+                                      String suffix,
+                                      boolean deleteOnExit,
+                                      FileAttribute<?>... attrs)
+        throws IOException
+    {
+        if (prefix.length() < 3)
+            throw new IllegalArgumentException("Prefix string too short");
+        suffix = (suffix == null) ? ".tmp" : suffix;
+
+        // special case POSIX environments so that 0600 is used as the file mode
+        if (TemporaryDirectory.isPosix) {
+            if (attrs.length == 0) {
+                // no attributes so use default permissions
+                attrs = new FileAttribute<?>[1];
+                attrs[0] = TemporaryDirectory.defaultPosixFilePermissions;
+            } else {
+                // check if posix permissions given; if not use default
+                boolean hasPermissions = false;
+                for (int i=0; i<attrs.length; i++) {
+                    if (attrs[i].name().equals("posix:permissions")) {
+                        hasPermissions = true;
+                        break;
+                    }
+                }
+                if (!hasPermissions) {
+                    FileAttribute<?>[] copy = new FileAttribute<?>[attrs.length+1];
+                    System.arraycopy(attrs, 0, copy, 0, attrs.length);
+                    attrs = copy;
+                    attrs[attrs.length-1] =
+                        TemporaryDirectory.defaultPosixFilePermissions;
+                }
+            }
+        }
+
+        // use Path#createFile to create file
+        SecurityManager sm = System.getSecurityManager();
+        for (;;) {
+            File f = TemporaryDirectory
+                .generateFile(prefix, suffix, TemporaryDirectory.valueAsFile);
+            if (sm != null && deleteOnExit)
+                sm.checkDelete(f.getPath());
+            try {
+                f.toPath().createFile(attrs);
+                if (deleteOnExit)
+		  SharedSecrets.getJavaIODeleteOnExitAccess().add(f.getPath());
+                return f;
+            } catch (InvalidPathException e) {
+                // don't reveal temporary directory location
+                if (sm != null)
+                    throw new IllegalArgumentException("Invalid prefix or suffix");
+                throw e;
+            } catch (SecurityException e) {
+                // don't reveal temporary directory location
+                if (sm != null)
+                    throw new SecurityException("Unable to create temporary file");
+                throw e;
+            } catch (FileAlreadyExistsException e) {
+                // ignore
+            }
+        }
+    }
+
+    // -- Integration with java.nio.file --
+
+    private volatile transient Path filePath;
+
+    /**
+     * {@note new}
+     * Returns a {@link Path java.nio.file.Path} object constructed from the
+     * this abstract path. The first invocation of this method works as if
+     * invoking it were equivalent to evaluating the expression:
+     * <blockquote><pre>
+     * {@link FileSystems#getDefault FileSystems.getDefault}().{@link FileSystem#getPath getPath}(this.{@link #getPath getPath}());
+     * </pre></blockquote>
+     * Subsequent invocations of this method return the same {@code Path}.
+     *
+     * <p> If this abstract pathname is the empty abstract pathname then this
+     * method returns a {@code Path} that may be used to access to the current
+     * user directory.
+     *
+     * @return  A {@code Path} constructed from this abstract path. The resulting
+     *          {@code Path} is associated with the {@link FileSystems#getDefault
+     *          default-filesystem}.
+     *
+     * @throws  InvalidPathException
+     *          If a {@code Path} object cannot be constructed from the abstract
+     *          path (see {@link java.nio.file.FileSystem#getPath FileSystem.getPath})
+     *
+     * @since   1.7
+     */
+    public Path toPath() {
+        if (filePath == null) {
+            synchronized (this) {
+                if (filePath == null) {
+		    String path = getPath();
+                    if (path.length() == 0) {
+                        // assume default file system treats "." as current directory
+                        filePath = Paths.get(".");
+                    } else {
+                        filePath = Paths.get(path);
+                    }
+                }
+            }
+        }
+        return filePath;
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/io/FilePermission.java	Mon Jan 12 21:46:12 2009 +0000
@@ -0,0 +1,852 @@
+/*
+ * Copyright 1997-2005 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package org.classpath.icedtea.java.io;
+
+import java.security.*;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Vector;
+import java.util.Collections;
+import java.io.IOException;
+import java.io.ObjectStreamField;
+import java.io.ObjectOutputStream;
+import java.io.ObjectInputStream;
+import java.io.Serializable;
+import sun.security.util.SecurityConstants;
+
+/**
+ * This class represents access to a file or directory.  A FilePermission consists
+ * of a pathname and a set of actions valid for that pathname.
+ * <P>
+ * Pathname is the pathname of the file or directory granted the specified
+ * actions. A pathname that ends in "/*" (where "/" is
+ * the file separator character, <code>File.separatorChar</code>) indicates
+ * all the files and directories contained in that directory. A pathname
+ * that ends with "/-" indicates (recursively) all files
+ * and subdirectories contained in that directory. A pathname consisting of
+ * the special token "&lt;&lt;ALL FILES&gt;&gt;" matches <b>any</b> file.
+ * <P>
+ * Note: A pathname consisting of a single "*" indicates all the files
+ * in the current directory, while a pathname consisting of a single "-"
+ * indicates all the files in the current directory and
+ * (recursively) all files and subdirectories contained in the current
+ * directory.
+ * <P>
+ * {@note revised}
+ * The actions to be granted are passed to the constructor in a string containing
+ * a list of one or more comma-separated keywords. The possible keywords are
+ * "read", "write", "execute", "delete", and "readlink". Their meaning is
+ * defined as follows:
+ * <P>
+ * <DL>
+ *    <DT> read <DD> read permission
+ *    <DT> write <DD> write permission
+ *    <DT> execute
+ *    <DD> execute permission. Allows <code>Runtime.exec</code> to
+ *         be called. Corresponds to <code>SecurityManager.checkExec</code>.
+ *    <DT> delete
+ *    <DD> delete permission. Allows <code>File.delete</code> to
+ *         be called. Corresponds to <code>SecurityManager.checkDelete</code>.
+ *    <DT> readlink
+ *    <DD> read link permission. Allows the target of a
+ *         <a href="../nio/file/package-summary.html#links">symbolic link</a>
+ *         to be read by invoking the {@link java.nio.file.Path#readSymbolicLink
+ *         readSymbolicLink } method.
+ * </DL>
+ * <P>
+ * The actions string is converted to lowercase before processing.
+ * <P>
+ * Be careful when granting FilePermissions. Think about the implications
+ * of granting read and especially write access to various files and
+ * directories. The "&lt;&lt;ALL FILES>>" permission with write action is
+ * especially dangerous. This grants permission to write to the entire
+ * file system. One thing this effectively allows is replacement of the
+ * system binary, including the JVM runtime environment.
+ *
+ * <p>Please note: Code can always read a file from the same
+ * directory it's in (or a subdirectory of that directory); it does not
+ * need explicit permission to do so.
+ *
+ * @see java.security.Permission
+ * @see java.security.Permissions
+ * @see java.security.PermissionCollection
+ *
+ *
+ * @author Marianne Mueller
+ * @author Roland Schemers
+ * @since 1.2
+ *
+ * @serial exclude
+ */
+
+public final class FilePermission extends Permission implements Serializable {
+
+    /**
+     * Execute action.
+     */
+    private final static int EXECUTE = 0x1;
+    /**
+     * Write action.
+     */
+    private final static int WRITE   = 0x2;
+    /**
+     * Read action.
+     */
+    private final static int READ    = 0x4;
+    /**
+     * Delete action.
+     */
+    private final static int DELETE  = 0x8;
+    /**
+     * Read link action.
+     */
+    private final static int READLINK    = 0x10;
+
+    /**
+     * All actions (read,write,execute,delete,readlink)
+     */
+    private final static int ALL     = READ|WRITE|EXECUTE|DELETE|READLINK;
+    /**
+     * No actions.
+     */
+    private final static int NONE    = 0x0;
+
+    // the actions mask
+    private transient int mask;
+
+    // does path indicate a directory? (wildcard or recursive)
+    private transient boolean directory;
+
+    // is it a recursive directory specification?
+    private transient boolean recursive;
+
+    /**
+     * the actions string.
+     *
+     * @serial
+     */
+    private String actions; // Left null as long as possible, then
+                            // created and re-used in the getAction function.
+
+    // canonicalized dir path. In the case of
+    // directories, it is the name "/blah/*" or "/blah/-" without
+    // the last character (the "*" or "-").
+
+    private transient String cpath;
+
+    // static Strings used by init(int mask)
+    private static final char RECURSIVE_CHAR = '-';
+    private static final char WILD_CHAR = '*';
+
+/*
+    public String toString()
+    {
+        StringBuffer sb = new StringBuffer();
+        sb.append("***\n");
+        sb.append("cpath = "+cpath+"\n");
+        sb.append("mask = "+mask+"\n");
+        sb.append("actions = "+getActions()+"\n");
+        sb.append("directory = "+directory+"\n");
+        sb.append("recursive = "+recursive+"\n");
+        sb.append("***\n");
+        return sb.toString();
+    }
+*/
+
+    private static final long serialVersionUID = 7930732926638008763L;
+
+    /**
+     * initialize a FilePermission object. Common to all constructors.
+     * Also called during de-serialization.
+     *
+     * @param mask the actions mask to use.
+     *
+     */
+    private void init(int mask)
+    {
+
+        if ((mask & ALL) != mask)
+                throw new IllegalArgumentException("invalid actions mask");
+
+        if (mask == NONE)
+                throw new IllegalArgumentException("invalid actions mask");
+
+        if ((cpath = getName()) == null)
+                throw new NullPointerException("name can't be null");
+
+        this.mask = mask;
+
+        if (cpath.equals("<<ALL FILES>>")) {
+            directory = true;
+            recursive = true;
+            cpath = "";
+            return;
+        }
+
+        // store only the canonical cpath if possible
+        cpath = AccessController.doPrivileged(new PrivilegedAction<String>() {
+            public String run() {
+                try {
+                    return sun.security.provider.PolicyFile.canonPath(cpath);
+                } catch (IOException ioe) {
+                    return cpath;
+                }
+            }
+        });
+
+        int len = cpath.length();
+        char last = ((len > 0) ? cpath.charAt(len - 1) : 0);
+
+        if (last == RECURSIVE_CHAR &&
+            cpath.charAt(len - 2) == File.separatorChar) {
+            directory = true;
+            recursive = true;
+            cpath = cpath.substring(0, --len);
+        } else if (last == WILD_CHAR &&
+            cpath.charAt(len - 2) == File.separatorChar) {
+            directory = true;
+            //recursive = false;
+            cpath = cpath.substring(0, --len);
+        } else {
+            // overkill since they are initialized to false, but
+            // commented out here to remind us...
+            //directory = false;
+            //recursive = false;
+        }
+
+        // XXX: at this point the path should be absolute. die if it isn't?
+    }
+
+    /**
+     * Creates a new FilePermission object with the specified actions.
+     * <i>path</i> is the pathname of a file or directory, and <i>actions</i>
+     * contains a comma-separated list of the desired actions granted on the
+     * file or directory. Possible actions are
+     * "read", "write", "execute", "delete", and "readlink".
+     *
+     * <p>A pathname that ends in "/*" (where "/" is
+     * the file separator character, <code>File.separatorChar</code>)
+     * indicates all the files and directories contained in that directory.
+     * A pathname that ends with "/-" indicates (recursively) all files and
+     * subdirectories contained in that directory. The special pathname
+     * "&lt;&lt;ALL FILES&gt;&gt;" matches any file.
+     *
+     * <p>A pathname consisting of a single "*" indicates all the files
+     * in the current directory, while a pathname consisting of a single "-"
+     * indicates all the files in the current directory and
+     * (recursively) all files and subdirectories contained in the current
+     * directory.
+     *
+     * <p>A pathname containing an empty string represents an empty path.
+     *
+     * @param path the pathname of the file/directory.
+     * @param actions the action string.
+     *
+     * @throws IllegalArgumentException
+     *          If actions is <code>null</code>, empty or contains an action
+     *          other than the specified possible actions.
+     */
+
+    public FilePermission(String path, String actions)
+    {
+        super(path);
+        init(getMask(actions));
+    }
+
+    /**
+     * Creates a new FilePermission object using an action mask.
+     * More efficient than the FilePermission(String, String) constructor.
+     * Can be used from within
+     * code that needs to create a FilePermission object to pass into the
+     * <code>implies</code> method.
+     *
+     * @param path the pathname of the file/directory.
+     * @param mask the action mask to use.
+     */
+
+    // package private for use by the FilePermissionCollection add method
+    FilePermission(String path, int mask)
+    {
+        super(path);
+        init(mask);
+    }
+
+    /**
+     * Checks if this FilePermission object "implies" the specified permission.
+     * <P>
+     * More specifically, this method returns true if:<p>
+     * <ul>
+     * <li> <i>p</i> is an instanceof FilePermission,<p>
+     * <li> <i>p</i>'s actions are a proper subset of this
+     * object's actions, and <p>
+     * <li> <i>p</i>'s pathname is implied by this object's
+     *      pathname. For example, "/tmp/*" implies "/tmp/foo", since
+     *      "/tmp/*" encompasses all files in the "/tmp" directory,
+     *      including the one named "foo".
+     * </ul>
+     *
+     * @param p the permission to check against.
+     *
+     * @return <code>true</code> if the specified permission is not
+     *                  <code>null</code> and is implied by this object,
+     *                  <code>false</code> otherwise.
+     */
+    public boolean implies(Permission p) {
+        if (!(p instanceof FilePermission))
+            return false;
+
+        FilePermission that = (FilePermission) p;
+
+        // we get the effective mask. i.e., the "and" of this and that.
+        // They must be equal to that.mask for implies to return true.
+
+        return ((this.mask & that.mask) == that.mask) && impliesIgnoreMask(that);
+    }
+
+    /**
+     * Checks if the Permission's actions are a proper subset of the
+     * this object's actions. Returns the effective mask iff the
+     * this FilePermission's path also implies that FilePermission's path.
+     *
+     * @param that the FilePermission to check against.
+     * @param exact return immediately if the masks are not equal
+     * @return the effective mask
+     */
+    boolean impliesIgnoreMask(FilePermission that) {
+        if (this.directory) {
+            if (this.recursive) {
+                // make sure that.path is longer then path so
+                // something like /foo/- does not imply /foo
+                if (that.directory) {
+                    return (that.cpath.length() >= this.cpath.length()) &&
+                            that.cpath.startsWith(this.cpath);
+                }  else {
+                    return ((that.cpath.length() > this.cpath.length()) &&
+                        that.cpath.startsWith(this.cpath));
+                }
+            } else {
+                if (that.directory) {
+                    // if the permission passed in is a directory
+                    // specification, make sure that a non-recursive
+                    // permission (i.e., this object) can't imply a recursive
+                    // permission.
+                    if (that.recursive)
+                        return false;
+                    else
+                        return (this.cpath.equals(that.cpath));
+                } else {
+                    int last = that.cpath.lastIndexOf(File.separatorChar);
+                    if (last == -1)
+                        return false;
+                    else {
+                        // this.cpath.equals(that.cpath.substring(0, last+1));
+                        // Use regionMatches to avoid creating new string
+                        return (this.cpath.length() == (last + 1)) &&
+                            this.cpath.regionMatches(0, that.cpath, 0, last+1);
+                    }
+                }
+            }
+        } else if (that.directory) {
+            // if this is NOT recursive/wildcarded,
+            // do not let it imply a recursive/wildcarded permission
+            return false;
+        } else {
+            return (this.cpath.equals(that.cpath));
+        }
+    }
+
+    /**
+     * Checks two FilePermission objects for equality. Checks that <i>obj</i> is
+     * a FilePermission, and has the same pathname and actions as this object.
+     * <P>
+     * @param obj the object we are testing for equality with this object.
+     * @return <code>true</code> if obj is a FilePermission, and has the same
+     *          pathname and actions as this FilePermission object,
+     *          <code>false</code> otherwise.
+     */
+    public boolean equals(Object obj) {
+        if (obj == this)
+            return true;
+
+        if (! (obj instanceof FilePermission))
+            return false;
+
+        FilePermission that = (FilePermission) obj;
+
+        return (this.mask == that.mask) &&
+            this.cpath.equals(that.cpath) &&
+            (this.directory == that.directory) &&
+            (this.recursive == that.recursive);
+    }
+
+    /**
+     * Returns the hash code value for this object.
+     *
+     * @return a hash code value for this object.
+     */
+
+    public int hashCode() {
+        return this.cpath.hashCode();
+    }
+
+    /**
+     * Converts an actions String to an actions mask.
+     *
+     * @param action the action string.
+     * @return the actions mask.
+     */
+    private static int getMask(String actions) {
+
+        int mask = NONE;
+
+        // Null action valid?
+        if (actions == null) {
+            return mask;
+        }
+        // Check against use of constants (used heavily within the JDK)
+        if (actions == SecurityConstants.FILE_READ_ACTION) {
+            return READ;
+        } else if (actions == SecurityConstants.FILE_WRITE_ACTION) {
+            return WRITE;
+        } else if (actions == SecurityConstants.FILE_EXECUTE_ACTION) {
+            return EXECUTE;
+        } else if (actions == SecurityConstants.FILE_DELETE_ACTION) {
+            return DELETE;
+        } else if (actions == SecurityConstants.FILE_READLINK_ACTION) {
+            return READLINK;
+        }
+
+        char[] a = actions.toCharArray();
+
+        int i = a.length - 1;
+        if (i < 0)
+            return mask;
+
+        while (i != -1) {
+            char c;
+
+            // skip whitespace
+            while ((i!=-1) && ((c = a[i]) == ' ' ||
+                               c == '\r' ||
+                               c == '\n' ||
+                               c == '\f' ||
+                               c == '\t'))
+                i--;
+
+            // check for the known strings
+            int matchlen;
+
+            if (i >= 3 && (a[i-3] == 'r' || a[i-3] == 'R') &&
+                          (a[i-2] == 'e' || a[i-2] == 'E') &&
+                          (a[i-1] == 'a' || a[i-1] == 'A') &&
+                          (a[i] == 'd' || a[i] == 'D'))
+            {
+                matchlen = 4;
+                mask |= READ;
+
+            } else if (i >= 4 && (a[i-4] == 'w' || a[i-4] == 'W') &&
+                                 (a[i-3] == 'r' || a[i-3] == 'R') &&
+                                 (a[i-2] == 'i' || a[i-2] == 'I') &&
+                                 (a[i-1] == 't' || a[i-1] == 'T') &&
+                                 (a[i] == 'e' || a[i] == 'E'))
+            {
+                matchlen = 5;
+                mask |= WRITE;
+
+            } else if (i >= 6 && (a[i-6] == 'e' || a[i-6] == 'E') &&
+                                 (a[i-5] == 'x' || a[i-5] == 'X') &&
+                                 (a[i-4] == 'e' || a[i-4] == 'E') &&
+                                 (a[i-3] == 'c' || a[i-3] == 'C') &&
+                                 (a[i-2] == 'u' || a[i-2] == 'U') &&
+                                 (a[i-1] == 't' || a[i-1] == 'T') &&
+                                 (a[i] == 'e' || a[i] == 'E'))
+            {
+                matchlen = 7;
+                mask |= EXECUTE;
+
+            } else if (i >= 5 && (a[i-5] == 'd' || a[i-5] == 'D') &&
+                                 (a[i-4] == 'e' || a[i-4] == 'E') &&
+                                 (a[i-3] == 'l' || a[i-3] == 'L') &&
+                                 (a[i-2] == 'e' || a[i-2] == 'E') &&
+                                 (a[i-1] == 't' || a[i-1] == 'T') &&
+                                 (a[i] == 'e' || a[i] == 'E'))
+            {
+                matchlen = 6;
+                mask |= DELETE;
+
+            } else if (i >= 7 && (a[i-7] == 'r' || a[i-7] == 'R') &&
+                                 (a[i-6] == 'e' || a[i-6] == 'E') &&
+                                 (a[i-5] == 'a' || a[i-5] == 'A') &&
+                                 (a[i-4] == 'd' || a[i-4] == 'D') &&
+                                 (a[i-3] == 'l' || a[i-3] == 'L') &&
+                                 (a[i-2] == 'i' || a[i-2] == 'I') &&
+                                 (a[i-1] == 'n' || a[i-1] == 'N') &&
+                                 (a[i] == 'k' || a[i] == 'K'))
+            {
+                matchlen = 8;
+                mask |= READLINK;
+
+            } else {
+                // parse error
+                throw new IllegalArgumentException(
+                        "invalid permission: " + actions);
+            }
+
+            // make sure we didn't just match the tail of a word
+            // like "ackbarfaccept".  Also, skip to the comma.
+            boolean seencomma = false;
+            while (i >= matchlen && !seencomma) {
+                switch(a[i-matchlen]) {
+                case ',':
+                    seencomma = true;
+                    /*FALLTHROUGH*/
+                case ' ': case '\r': case '\n':
+                case '\f': case '\t':
+                    break;
+                default:
+                    throw new IllegalArgumentException(
+                            "invalid permission: " + actions);
+                }
+                i--;
+            }
+
+            // point i at the location of the comma minus one (or -1).
+            i -= matchlen;
+        }
+
+        return mask;
+    }
+
+    /**
+     * Return the current action mask. Used by the FilePermissionCollection.
+     *
+     * @return the actions mask.
+     */
+
+    int getMask() {
+        return mask;
+    }
+
+    /**
+     * Return the canonical string representation of the actions.
+     * Always returns present actions in the following order:
+     * read, write, execute, delete, readlink.
+     *
+     * @return the canonical string representation of the actions.
+     */
+    private static String getActions(int mask)
+    {
+        StringBuilder sb = new StringBuilder();
+        boolean comma = false;
+
+        if ((mask & READ) == READ) {
+            comma = true;
+            sb.append("read");
+        }
+
+        if ((mask & WRITE) == WRITE) {
+            if (comma) sb.append(',');
+            else comma = true;
+            sb.append("write");
+        }
+
+        if ((mask & EXECUTE) == EXECUTE) {
+            if (comma) sb.append(',');
+            else comma = true;
+            sb.append("execute");
+        }
+
+        if ((mask & DELETE) == DELETE) {
+            if (comma) sb.append(',');
+            else comma = true;
+            sb.append("delete");
+        }
+
+        if ((mask & READLINK) == READLINK) {
+            if (comma) sb.append(',');
+            else comma = true;
+            sb.append("readlink");
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Returns the "canonical string representation" of the actions.
+     * That is, this method always returns present actions in the following order:
+     * read, write, execute, delete, readlink. For example, if this FilePermission
+     * object allows both write and read actions, a call to <code>getActions</code>
+     * will return the string "read,write".
+     *
+     * @return the canonical string representation of the actions.
+     */
+    public String getActions()
+    {
+        if (actions == null)
+            actions = getActions(this.mask);
+
+        return actions;
+    }
+
+
+    /**
+     * Returns a new PermissionCollection object for storing FilePermission
+     * objects.
+     * <p>
+     * FilePermission objects must be stored in a manner that allows them
+     * to be inserted into the collection in any order, but that also enables the
+     * PermissionCollection <code>implies</code>
+     * method to be implemented in an efficient (and consistent) manner.
+     *
+     * <p>For example, if you have two FilePermissions:
+     * <OL>
+     * <LI>  <code>"/tmp/-", "read"</code>
+     * <LI>  <code>"/tmp/scratch/foo", "write"</code>
+     * </OL>
+     *
+     * <p>and you are calling the <code>implies</code> method with the FilePermission:
+     *
+     * <pre>
+     *   "/tmp/scratch/foo", "read,write",
+     * </pre>
+     *
+     * then the <code>implies</code> function must
+     * take into account both the "/tmp/-" and "/tmp/scratch/foo"
+     * permissions, so the effective permission is "read,write",
+     * and <code>implies</code> returns true. The "implies" semantics for
+     * FilePermissions are handled properly by the PermissionCollection object
+     * returned by this <code>newPermissionCollection</code> method.
+     *
+     * @return a new PermissionCollection object suitable for storing
+     * FilePermissions.
+     */
+
+    public PermissionCollection newPermissionCollection() {
+        return new FilePermissionCollection();
+    }
+
+    /**
+     * WriteObject is called to save the state of the FilePermission
+     * to a stream. The actions are serialized, and the superclass
+     * takes care of the name.
+     */
+    private void writeObject(ObjectOutputStream s)
+        throws IOException
+    {
+        // Write out the actions. The superclass takes care of the name
+        // call getActions to make sure actions field is initialized
+        if (actions == null)
+            getActions();
+        s.defaultWriteObject();
+    }
+
+    /**
+     * readObject is called to restore the state of the FilePermission from
+     * a stream.
+     */
+    private void readObject(ObjectInputStream s)
+         throws IOException, ClassNotFoundException
+    {
+        // Read in the actions, then restore everything else by calling init.
+        s.defaultReadObject();
+        init(getMask(actions));
+    }
+}
+
+/**
+ * A FilePermissionCollection stores a set of FilePermission permissions.
+ * FilePermission objects
+ * must be stored in a manner that allows them to be inserted in any
+ * order, but enable the implies function to evaluate the implies
+ * method.
+ * For example, if you have two FilePermissions:
+ * <OL>
+ * <LI> "/tmp/-", "read"
+ * <LI> "/tmp/scratch/foo", "write"
+ * </OL>
+ * And you are calling the implies function with the FilePermission:
+ * "/tmp/scratch/foo", "read,write", then the implies function must
+ * take into account both the /tmp/- and /tmp/scratch/foo
+ * permissions, so the effective permission is "read,write".
+ *
+ * @see java.security.Permission
+ * @see java.security.Permissions
+ * @see java.security.PermissionCollection
+ *
+ *
+ * @author Marianne Mueller
+ * @author Roland Schemers
+ *
+ * @serial include
+ *
+ */
+
+final class FilePermissionCollection extends PermissionCollection
+implements Serializable {
+
+    // Not serialized; see serialization section at end of class
+    private transient List<Permission> perms;
+
+    /**
+     * Create an empty FilePermissions object.
+     *
+     */
+
+    public FilePermissionCollection() {
+        perms = new ArrayList<Permission>();
+    }
+
+    /**
+     * Adds a permission to the FilePermissions. The key for the hash is
+     * permission.path.
+     *
+     * @param permission the Permission object to add.
+     *
+     * @exception IllegalArgumentException - if the permission is not a
+     *                                       FilePermission
+     *
+     * @exception SecurityException - if this FilePermissionCollection object
+     *                                has been marked readonly
+     */
+
+    public void add(Permission permission)
+    {
+        if (! (permission instanceof FilePermission))
+            throw new IllegalArgumentException("invalid permission: "+
+                                               permission);
+        if (isReadOnly())
+            throw new SecurityException(
+                "attempt to add a Permission to a readonly PermissionCollection");
+
+        synchronized (this) {
+            perms.add(permission);
+        }
+    }
+
+    /**
+     * Check and see if this set of permissions implies the permissions
+     * expressed in "permission".
+     *
+     * @param p the Permission object to compare
+     *
+     * @return true if "permission" is a proper subset of a permission in
+     * the set, false if not.
+     */
+
+    public boolean implies(Permission permission)
+    {
+        if (! (permission instanceof FilePermission))
+                return false;
+
+        FilePermission fp = (FilePermission) permission;
+
+        int desired = fp.getMask();
+        int effective = 0;
+        int needed = desired;
+
+        synchronized (this) {
+            int len = perms.size();
+            for (int i = 0; i < len; i++) {
+                FilePermission x = (FilePermission) perms.get(i);
+                if (((needed & x.getMask()) != 0) && x.impliesIgnoreMask(fp)) {
+                    effective |=  x.getMask();
+                    if ((effective & desired) == desired)
+                        return true;
+                    needed = (desired ^ effective);
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Returns an enumeration of all the FilePermission objects in the
+     * container.
+     *
+     * @return an enumeration of all the FilePermission objects.
+     */
+
+    public Enumeration elements() {
+        // Convert Iterator into Enumeration
+        synchronized (this) {
+            return Collections.enumeration(perms);
+        }
+    }
+
+    private static final long serialVersionUID = 2202956749081564585L;
+
+    // Need to maintain serialization interoperability with earlier releases,
+    // which had the serializable field:
+    //    private Vector permissions;
+
+    /**
+     * @serialField permissions java.util.Vector
+     *     A list of FilePermission objects.
+     */
+    private static final ObjectStreamField[] serialPersistentFields = {
+        new ObjectStreamField("permissions", Vector.class),
+    };
+
+    /**
+     * @serialData "permissions" field (a Vector containing the FilePermissions).
+     */
+    /*
+     * Writes the contents of the perms field out as a Vector for
+     * serialization compatibility with earlier releases.
+     */
+    private void writeObject(ObjectOutputStream out) throws IOException {
+        // Don't call out.defaultWriteObject()
+
+        // Write out Vector
+        Vector<Permission> permissions = new Vector<Permission>(perms.size());
+        synchronized (this) {
+            permissions.addAll(perms);
+        }
+
+        ObjectOutputStream.PutField pfields = out.putFields();
+        pfields.put("permissions", permissions);
+        out.writeFields();
+    }
+
+    /*
+     * Reads in a Vector of FilePermissions and saves them in the perms field.
+     */
+    @SuppressWarnings("unchecked")
+    private void readObject(ObjectInputStream in) throws IOException,
+    ClassNotFoundException {
+        // Don't call defaultReadObject()
+
+        // Read in serialized fields
+        ObjectInputStream.GetField gfields = in.readFields();
+
+        // Get the one we want
+        Vector<Permission> permissions = (Vector<Permission>)gfields.get("permissions", null);
+        perms = new ArrayList<Permission>(permissions.size());
+        perms.addAll(permissions);
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/io/Inputs.java	Mon Jan 12 21:46:12 2009 +0000
@@ -0,0 +1,391 @@
+/*
+ * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA conne02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package org.classpath.icedtea.java.io;
+
+import java.io.Closeable;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import java.nio.charset.Charset;
+import java.nio.charset.UnsupportedCharsetException;
+import java.nio.channels.Channels;
+
+import java.util.Collections;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
+
+
+import org.classpath.icedtea.java.nio.file.FileRef;
+
+import org.classpath.icedtea.java.nio.file.attribute.Attributes;
+
+import org.classpath.icedtea.java.util.Scanner;
+
+/**
+ * {@note experimental}
+ * This class consists exclusively of static methods that operate on input
+ * sources.
+ *
+ * <p> The methods to read lines of text defined by this class recognize the
+ * following as Unicode line terminators:
+ * <ul>
+ *   <li> <code>&#92;u000D</code> followed by <code>&#92;u000A</code>,
+ *     CARRIAGE RETURN followed by LINE FEED </li>
+ *   <li> <code>&#92;u000A</code>, LINE FEED </li>
+ *   <li> <code>&#92;u000D</code>, CARRIAGE RETURN </li>
+ *   <li> <code>&#92;u2028</code>, LINE SEPARATOR </li>
+ *   <li> <code>&#92;u2029</code>, PARAGRAPH SEPARATOR </li>
+ *   <li> <code>&#92;u0085</code>, NEXT LINE (NEL)</li>
+ * </ul>
+ *
+ * @since 1.7
+ */
+
+public final class Inputs {
+    private Inputs() { }
+
+    // initial buffer size when reading (or writing)
+    private static final int INITIAL_BUFFER_SIZE = 8192;
+
+    // checks that charset is supported
+    private static void ensureCharsetIsSupported(String csn) {
+        if (csn == null)
+            throw new NullPointerException("'csn' is null");
+        if (!Charset.isSupported(csn))
+            throw new UnsupportedCharsetException(csn);
+    }
+
+    /**
+     * Closes the given data source by invoking its {@link Closeable#close close}
+     * method. If the {@code close} method throws an {@code IOException} then it
+     * is silently ignored. If the source is already closed then invoking this
+     * method has no effect.
+     *
+     * <p> This method should not be used to close destinations or output
+     * streams that may be buffered. An I/O error may occur when flushing
+     * buffered data.
+     *
+     * @param   source
+     *          The data source
+     */
+    public static void closeUnchecked(Closeable source) {
+        try {
+            source.close();
+        } catch (IOException ignore) { }
+    }
+
+    /**
+     * Read all bytes from the specified file. When all bytes have been read, or
+     * an I/O error occurs, then the file is closed.
+     *
+     * @param   source
+     *          The data source
+     *
+     * @return  A byte array containing the bytes read from the file
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     * @throws  OutOfMemoryError
+     *          If the required array size is too large
+     */
+    public static byte[] readAllBytes(FileRef source) throws IOException {
+        long size = Attributes.readBasicFileAttributes(source).size();
+        if (size > (long)Integer.MAX_VALUE)
+            throw new OutOfMemoryError("Required array size too large");
+        InputStream in = Channels.newInputStream(source.newByteChannel());
+        try {
+            return implReadAllBytes(in, Math.min((int)size, INITIAL_BUFFER_SIZE));
+        } finally {
+            in.close();
+        }
+    }
+
+    /**
+     * Read all bytes from the specified file. When all bytes have been read, or
+     * an I/O error occurs, then the file is closed.
+     *
+     * @param   source
+     *          The data source
+     *
+     * @return  A byte array containing the bytes read from the file
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     * @throws  OutOfMemoryError
+     *          If the required array size is too large
+     */
+    public static byte[] readAllBytes(File source) throws IOException {
+        InputStream in = new FileInputStream(source);
+        try {
+            return implReadAllBytes(in, INITIAL_BUFFER_SIZE);
+        } finally {
+            in.close();
+        }
+    }
+
+    /**
+     * Read all bytes from the specified input stream.
+     *
+     * <p> <b>Usage Example:</b>
+     * Suppose we want to open a connection to a resource identified by a URI,
+     * and read all bytes:
+     * <pre>
+     *   URI uri = ...
+     *   byte[] content = InputOutput.readAllBytes(uri.toURL().openStream());
+     * </pre>
+     *
+     * <p> On return, the input stream will be at end of stream.
+     *
+     * @param   source
+     *          The data source
+     *
+     * @return  A byte array containing the bytes read from the source
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     * @throws  OutOfMemoryError
+     *          If the required array size is too large
+     */
+    public static byte[] readAllBytes(InputStream source) throws IOException {
+        return implReadAllBytes(source, INITIAL_BUFFER_SIZE);
+    }
+
+    private static byte[] implReadAllBytes(InputStream source, int initialSize)
+        throws IOException
+    {
+        byte[] buf = new byte[initialSize];
+        int nread = 0;
+        int rem = buf.length;
+        int n;
+        while ((n = source.read(buf, nread, rem)) > 0) {
+            nread += n;
+            rem -= n;
+            if (rem <= 0) {
+                int newSize = buf.length << 1;
+                if (newSize <= buf.length) {
+                    if (buf.length == Integer.MAX_VALUE)
+                        throw new OutOfMemoryError("Required array size too large");
+                    newSize = Integer.MAX_VALUE;
+                }
+                rem = newSize - buf.length;
+                buf = Arrays.copyOf(buf, newSize);
+            }
+        }
+        return (buf.length == nread) ? buf : Arrays.copyOf(buf, nread);
+    }
+
+    /**
+     * Read all lines from the specified file. Bytes from the file are
+     * converted into characters using the specified charset. When all lines
+     * have been read, or an I/O error occurs, then the file is closed.
+     *
+     * @param   source
+     *          The data source
+     * @param   csn
+     *          The name of the charset to be used
+     *
+     * @throws  java.nio.charset.UnsupportedCharsetException
+     *          If no support for the named charset is available
+     *          in this instance of the Java virtual machine
+     * @throws  java.nio.charset.MalformedInputException
+     *          If the file contains a byte sequence that is not legal for the
+     *          charset
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static List<String> readAllLines(FileRef source, String csn)
+        throws IOException
+    {
+        ensureCharsetIsSupported(csn);
+        Scanner s = new Scanner(source, csn);
+        try {
+            return implReadAllLines(s);
+        } finally {
+            s.close();
+        }
+    }
+
+    /**
+     * Read all lines from the specified file. Bytes from the file are
+     * converted into characters using the underlying platform's {@linkplain
+     * java.nio.charset.Charset#defaultCharset() default charset}. When all lines
+     * have been read, or an I/O error occurs, then the file is closed.
+     *
+     * @param   source
+     *          The data source
+     *
+     * @throws  java.nio.charset.MalformedInputException
+     *          If the file contains a byte sequence that is not legal for the
+     *          default charset
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static List<String> readAllLines(FileRef source) throws IOException {
+        Scanner s = new Scanner(source);
+        try {
+            return implReadAllLines(s);
+        } finally {
+            s.close();
+        }
+    }
+
+    /**
+     * Read all lines from the specified file. Bytes from the file are
+     * converted into characters using the specified charset. When all lines
+     * have been read, or an I/O error occurs, then the file is closed.
+     *
+     * @param   source
+     *          The data source
+     * @param   csn
+     *          The name of the charset to be used
+     *
+     * @throws  UnsupportedCharsetException
+     *          If no support for the named charset is available
+     *          in this instance of the Java virtual machine
+     * @throws  java.nio.charset.MalformedInputException
+     *          If the file contains a byte sequence that is not legal for the
+     *          charset
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static List<String> readAllLines(File source, String csn)
+        throws IOException
+    {
+        ensureCharsetIsSupported(csn);
+        Scanner s = new Scanner(source, csn);
+        try {
+            return implReadAllLines(s);
+        } finally {
+            s.close();
+        }
+    }
+
+    /**
+     * Read all lines from the specified file. Bytes from the file are
+     * converted into characters using the underlying platform's {@linkplain
+     * Charset#defaultCharset() default charset}. When all lines have been read,
+     * or an I/O error occurs, then the file is closed.
+     *
+     * @param   source
+     *          The data source
+     * @throws  java.nio.charset.MalformedInputException
+     *          If the file contains a byte sequence that is not legal for the
+     *          default charset
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static List<String> readAllLines(File source) throws IOException {
+        Scanner s = new Scanner(source);
+        try {
+            return implReadAllLines(s);
+        } finally {
+            s.close();
+        }
+    }
+
+    /**
+     * Read all lines from the specified input stream. Bytes from the stream are
+     * converted into characters using the specified charset.
+     *
+     * <p> On return, the input stream will be at end of stream.
+     *
+     * @param   source
+     *          The input stream to read from
+     * @param   csn
+     *          The name of the charset to be used
+     *
+     * @throws  UnsupportedCharsetException
+     *          If no support for the named charset is available
+     *          in this instance of the Java virtual machine
+     * @throws  java.nio.charset.MalformedInputException
+     *          If a byte sequence that is not legal for the charset is read
+     *          from the input
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static List<String> readAllLines(InputStream source, String csn)
+        throws IOException
+    {
+        ensureCharsetIsSupported(csn);
+        return implReadAllLines(new Scanner(source, csn));
+    }
+
+    /**
+     * Read all lines from the specified input stream. Bytes from the stream are
+     * converted into characters using the underlying platform's {@linkplain
+     * Charset#defaultCharset() default charset}.
+     *
+     * <p> On return, the input stream will be at end of stream.
+     *
+     * @param   source
+     *          The input stream to read from
+     *
+     * @return  An unmodifiable list of the lines read from the input stream
+     *
+     * @throws  java.nio.charset.MalformedInputException
+     *          If a byte sequence that is not legal for the default charset is
+     *          read from the input
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static List<String> readAllLines(InputStream source) throws IOException {
+        return implReadAllLines(new Scanner(source));
+    }
+
+    /**
+     * Read all lines from the from the specified source.
+     *
+     * <p> On return, the input source will be at end of stream.
+     *
+     * @param   source
+     *          The input stream to read from
+     *
+     * @return  An unmodifiable list of the lines read from source
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static List<String> readAllLines(Readable source) throws IOException {
+        return implReadAllLines(new Scanner(source));
+    }
+
+    private static List<String> implReadAllLines(Scanner s) throws IOException {
+        try {
+            List<String> result = new ArrayList<String>();
+            while (s.hasNextLine()) {
+                result.add(s.nextLine());
+            }
+            return Collections.unmodifiableList(result);
+        } finally {
+            IOException ioe = s.ioException();
+            if (ioe != null)
+                throw ioe;
+        }
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/io/Outputs.java	Mon Jan 12 21:46:12 2009 +0000
@@ -0,0 +1,362 @@
+/*
+ * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA conne02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package org.classpath.icedtea.java.io;
+
+import java.io.BufferedWriter;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.UnsupportedCharsetException;
+import java.nio.channels.Channels;
+import java.nio.channels.WritableByteChannel;
+import java.util.Arrays;
+import java.util.List;
+
+import org.classpath.icedtea.java.nio.file.FileRef;
+
+import static org.classpath.icedtea.java.nio.file.StandardOpenOption.CREATE;
+import static org.classpath.icedtea.java.nio.file.StandardOpenOption.TRUNCATE_EXISTING;
+import static org.classpath.icedtea.java.nio.file.StandardOpenOption.WRITE;
+
+/**
+ * {@note experimental}
+ * This class consists exclusively of static methods that operate on output
+ * destinations.
+ *
+ * <p> The methods to write lines of text output a line terminator following
+ * each line. The line terminator that is output is platform line terminated,
+ * as defined by the {@code line.separator} system property.
+ *
+ * @since 1.7
+ */
+
+public final class Outputs {
+    private Outputs() { }
+
+    // checks that charset is supported
+    private static void ensureCharsetIsSupported(String csn) {
+        if (csn == null)
+            throw new NullPointerException("'csn' is null");
+        if (!Charset.isSupported(csn))
+            throw new UnsupportedCharsetException(csn);
+    }
+
+    /**
+     * Writes a byte array to a file. The file is created if it does not exist.
+     * If the file already exists, it is first truncated.
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void write(FileRef file, byte[] bytes) throws IOException {
+        write(file, bytes, 0, bytes.length);
+    }
+
+    /**
+     * Writes a byte array to a file. The file is created if it does not exist.
+     * If the file already exists, it is first truncated.
+     *
+     * @throws  IndexOutOfBoundsException
+     *          If {@code off} or {@code len} is negative, or {@code off+len}
+     *          is greater than the length of the array
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void write(FileRef file, byte[] bytes, int off, int len)
+        throws IOException
+    {
+        WritableByteChannel wbc = file.newByteChannel(WRITE, CREATE, TRUNCATE_EXISTING);
+        try {
+            int pos = off;
+            while (pos < len) {
+                int size = Math.min(len-pos, 8192);
+                ByteBuffer bb = ByteBuffer.wrap(bytes, pos, size);
+                int n = wbc.write(bb);
+                pos += n;
+            }
+        } finally {
+            wbc.close();
+        }
+    }
+
+    /**
+     * Writes the given lines of text to the specified file. The characters in
+     * each line are encoded into bytes using the specified charset. When all
+     * lines have been written, or an I/O error occurs, then the file is closed.
+     *
+     * @param   file
+     *          The file
+     * @param   lines
+     *          The list of lines to write (in order)
+     * @param   csn
+     *          The name of the charset to be used
+     *
+     * @throws  java.nio.charset.UnsupportedCharsetException
+     *          If no support for the named charset is available
+     *          in this instance of the Java virtual machine
+     * @throws  java.nio.charset.UnmappableCharacterException
+     *          Where a line contains a character that cannot be mapped to an
+     *          output byte sequence
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void writeLines(FileRef file, List<String> lines, String csn)
+        throws IOException
+    {
+        ensureCharsetIsSupported(csn);
+        WritableByteChannel wbc = file.newByteChannel(WRITE, CREATE, TRUNCATE_EXISTING);
+        BufferedWriter writer = new BufferedWriter(Channels.newWriter(wbc, csn));
+        try {
+            implWriteLines(writer, lines);
+        } finally {
+            writer.close();
+        }
+    }
+
+    /**
+     * Writes the given lines of text to the specified file. The characters in
+     * each line are encoded into bytes using the underlying platform's {@linkplain
+     * Charset#defaultCharset() default charset}. When all lines have been
+     * written, or an I/O error occurs, then the file is closed.
+     *
+     * @param   file
+     *          The file
+     * @param   lines
+     *          The list of lines to write (in order)
+     *
+     * @throws  java.nio.charset.UnmappableCharacterException
+     *          Where a line contains a character that cannot be mapped to an
+     *          output byte sequence
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void writeLines(FileRef file, List<String> lines)
+        throws IOException
+    {
+        writeLines(file, lines, Charset.defaultCharset().name());
+    }
+
+    /**
+     * Writes the given lines of text to the specified file. The characters in
+     * each line are encoded into bytes using the underlying platform's {@linkplain
+     * Charset#defaultCharset() default charset}. When all lines have been
+     * written, or an I/O error occurs, then the file is closed.
+     *
+     * @param   file
+     *          The file
+     * @param   lines
+     *          The array of lines to write (in order)
+     *
+     * @throws  java.nio.charset.UnmappableCharacterException
+     *          Where a line contains a character that cannot be mapped to an
+     *          output byte sequence
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void writeLines(FileRef file, String... lines)
+        throws IOException
+    {
+        writeLines(file, Arrays.asList(lines), Charset.defaultCharset().name());
+    }
+
+    /**
+     * Writes a byte array to a file. The file is created if it does not exist.
+     * If the file already exists, it is first truncated.
+     *
+     * @param   file
+     *          The file
+     * @param   bytes
+     *          The byte array to write to the file
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void write(File file, byte[] bytes) throws IOException {
+        write(file, bytes, 0, bytes.length);
+    }
+
+    /**
+     * Writes a byte array to a file. The file is created if it does not exist.
+     * If the file already exists, it is first truncated.
+     *
+     * @throws  IndexOutOfBoundsException
+     *          If {@code off} or {@code len} is negative, or {@code off+len}
+     *          is greater than the length of the array
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void write(File file, byte[] bytes, int off, int len)
+        throws IOException
+    {
+        FileOutputStream out = new FileOutputStream(file);
+        try {
+            out.write(bytes, off, len);
+        } finally {
+            out.close();
+        }
+    }
+
+    /**
+     * Writes the given lines of text to the specified file. The characters in
+     * each line are encoded into bytes using the specified charset. When all
+     * lines have been written, or an I/O error occurs, then the file is closed.
+     *
+     * @param   file
+     *          The file
+     * @param   lines
+     *          The list of lines to write (in order)
+     * @param   csn
+     *          The name of the charset to be used
+     *
+     * @throws  java.nio.charset.UnsupportedCharsetException
+     *          If no support for the named charset is available
+     *          in this instance of the Java virtual machine
+     * @throws  java.nio.charset.UnmappableCharacterException
+     *          Where a line contains a character that cannot be mapped to an
+     *          output byte sequence
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void writeLines(File file, List<String> lines, String csn)
+        throws IOException
+    {
+        ensureCharsetIsSupported(csn);
+        FileOutputStream out = new FileOutputStream(file);
+        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out, csn));
+        try {
+            implWriteLines(writer, lines);
+        } finally {
+            writer.close();
+        }
+    }
+
+    /**
+     * Writes the given lines of text to the specified file. The characters in
+     * each line are encoded into bytes using the underlying platform's {@linkplain
+     * Charset#defaultCharset() default charset}. When all lines have been
+     * written, or an I/O error occurs, then the file is closed.
+     *
+     * @param   file
+     *          The file
+     * @param   lines
+     *          The list of lines to write (in order)
+     *
+     * @throws  java.nio.charset.UnmappableCharacterException
+     *          Where a line contains a character that cannot be mapped to an
+     *          output byte sequence
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void writeLines(File file, List<String> lines)
+        throws IOException
+    {
+        writeLines(file, lines, Charset.defaultCharset().name());
+    }
+
+    /**
+     * Writes the given lines of text to the specified file. The characters in
+     * each line are encoded into bytes using the underlying platform's {@linkplain
+     * Charset#defaultCharset() default charset}. When all lines have been
+     * written, or an I/O error occurs, then the file is closed.
+     *
+     * @param   file
+     *          The file
+     * @param   lines
+     *          The array of lines to write (in order)
+     *
+     * @throws  java.nio.charset.UnmappableCharacterException
+     *          Where a line contains a character that cannot be mapped to an
+     *          output byte sequence
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void writeLines(File file, String... lines)
+        throws IOException
+    {
+        writeLines(file, Arrays.asList(lines), Charset.defaultCharset().name());
+    }
+
+    /**
+     * Writes the given lines of text to the specified output stream. The
+     * characters in each line are encoded into bytes using the specified charset.
+     *
+     * @param   out
+     *          The output stream
+     * @param   lines
+     *          The list of lines to write (in order)
+     * @param   csn
+     *          The name of the charset to be used
+     *
+     * @throws  java.nio.charset.UnmappableCharacterException
+     *          Where a line contains a character that cannot be mapped to an
+     *          output byte sequence
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void writeLines(OutputStream out, List<String> lines, String csn)
+        throws IOException
+    {
+        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out, csn));
+        implWriteLines(writer, lines);
+        writer.flush();
+    }
+
+    /**
+     * Writes the given lines of text to the specified output stream. The
+     * characters in each line are encoded into bytes using the underlying
+     * platform's {@linkplain Charset#defaultCharset() default charset}.
+     *
+     * @param   out
+     *          The output stream
+     * @param   lines
+     *          The list of lines to write (in order)
+     *
+     * @throws  java.nio.charset.UnmappableCharacterException
+     *          Where a line contains a character that cannot be mapped to an
+     *          output byte sequence
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public static void writeLines(OutputStream out, List<String> lines)
+        throws IOException
+    {
+        writeLines(out, lines, Charset.defaultCharset().name());
+    }
+
+    private static void implWriteLines(BufferedWriter writer, List<String> lines)
+        throws IOException
+    {
+        for (String line: lines) {
+            writer.write(line);
+            writer.newLine();
+        }
+    }
+}