diff -r 000000000000 -r 724f3e1ea53e emul/compact/src/main/java/java/lang/System.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/emul/compact/src/main/java/java/lang/System.java Sat Sep 07 13:51:24 2013 +0200
@@ -0,0 +1,1206 @@
+/*
+ * Copyright (c) 1994, 2011, Oracle and/or its affiliates. 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.lang;
+
+import java.io.*;
+import java.util.Properties;
+import java.util.PropertyPermission;
+import java.util.StringTokenizer;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.security.AllPermission;
+import java.nio.channels.Channel;
+import java.nio.channels.spi.SelectorProvider;
+import sun.nio.ch.Interruptible;
+import sun.reflect.Reflection;
+import sun.security.util.SecurityConstants;
+import sun.reflect.annotation.AnnotationType;
+
+/**
+ * The System class contains several useful class fields
+ * and methods. It cannot be instantiated.
+ *
+ *
Among the facilities provided by the System class
+ * are standard input, standard output, and error output streams;
+ * access to externally defined properties and environment
+ * variables; a means of loading files and libraries; and a utility
+ * method for quickly copying a portion of an array.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public final class System {
+
+ /* register the natives via the static initializer.
+ *
+ * VM will invoke the initializeSystemClass method to complete
+ * the initialization for this class separated from clinit.
+ * Note that to use properties set by the VM, see the constraints
+ * described in the initializeSystemClass method.
+ */
+ private static native void registerNatives();
+ static {
+ registerNatives();
+ }
+
+ /** Don't let anyone instantiate this class */
+ private System() {
+ }
+
+ /**
+ * The "standard" input stream. This stream is already
+ * open and ready to supply input data. Typically this stream
+ * corresponds to keyboard input or another input source specified by
+ * the host environment or user.
+ */
+ public final static InputStream in = null;
+
+ /**
+ * The "standard" output stream. This stream is already
+ * open and ready to accept output data. Typically this stream
+ * corresponds to display output or another output destination
+ * specified by the host environment or user.
+ *
+ * For simple stand-alone Java applications, a typical way to write
+ * a line of output data is:
+ *
+ * System.out.println(data)
+ *
+ *
+ * See the println methods in class PrintStream.
+ *
+ * @see java.io.PrintStream#println()
+ * @see java.io.PrintStream#println(boolean)
+ * @see java.io.PrintStream#println(char)
+ * @see java.io.PrintStream#println(char[])
+ * @see java.io.PrintStream#println(double)
+ * @see java.io.PrintStream#println(float)
+ * @see java.io.PrintStream#println(int)
+ * @see java.io.PrintStream#println(long)
+ * @see java.io.PrintStream#println(java.lang.Object)
+ * @see java.io.PrintStream#println(java.lang.String)
+ */
+ public final static PrintStream out = null;
+
+ /**
+ * The "standard" error output stream. This stream is already
+ * open and ready to accept output data.
+ *
+ * Typically this stream corresponds to display output or another
+ * output destination specified by the host environment or user. By
+ * convention, this output stream is used to display error messages
+ * or other information that should come to the immediate attention
+ * of a user even if the principal output stream, the value of the
+ * variable out, has been redirected to a file or other
+ * destination that is typically not continuously monitored.
+ */
+ public final static PrintStream err = null;
+
+ /* The security manager for the system.
+ */
+ private static volatile SecurityManager security = null;
+
+ /**
+ * Reassigns the "standard" input stream.
+ *
+ *
First, if there is a security manager, its checkPermission
+ * method is called with a RuntimePermission("setIO") permission
+ * to see if it's ok to reassign the "standard" input stream.
+ *
+ *
+ * @param in the new standard input stream.
+ *
+ * @throws SecurityException
+ * if a security manager exists and its
+ * checkPermission method doesn't allow
+ * reassigning of the standard input stream.
+ *
+ * @see SecurityManager#checkPermission
+ * @see java.lang.RuntimePermission
+ *
+ * @since JDK1.1
+ */
+ public static void setIn(InputStream in) {
+ checkIO();
+ setIn0(in);
+ }
+
+ /**
+ * Reassigns the "standard" output stream.
+ *
+ *
First, if there is a security manager, its checkPermission
+ * method is called with a RuntimePermission("setIO") permission
+ * to see if it's ok to reassign the "standard" output stream.
+ *
+ * @param out the new standard output stream
+ *
+ * @throws SecurityException
+ * if a security manager exists and its
+ * checkPermission method doesn't allow
+ * reassigning of the standard output stream.
+ *
+ * @see SecurityManager#checkPermission
+ * @see java.lang.RuntimePermission
+ *
+ * @since JDK1.1
+ */
+ public static void setOut(PrintStream out) {
+ checkIO();
+ setOut0(out);
+ }
+
+ /**
+ * Reassigns the "standard" error output stream.
+ *
+ *
First, if there is a security manager, its checkPermission
+ * method is called with a RuntimePermission("setIO") permission
+ * to see if it's ok to reassign the "standard" error output stream.
+ *
+ * @param err the new standard error output stream.
+ *
+ * @throws SecurityException
+ * if a security manager exists and its
+ * checkPermission method doesn't allow
+ * reassigning of the standard error output stream.
+ *
+ * @see SecurityManager#checkPermission
+ * @see java.lang.RuntimePermission
+ *
+ * @since JDK1.1
+ */
+ public static void setErr(PrintStream err) {
+ checkIO();
+ setErr0(err);
+ }
+
+ private static volatile Console cons = null;
+ /**
+ * Returns the unique {@link java.io.Console Console} object associated
+ * with the current Java virtual machine, if any.
+ *
+ * @return The system console, if any, otherwise null.
+ *
+ * @since 1.6
+ */
+ public static Console console() {
+ if (cons == null) {
+ synchronized (System.class) {
+ cons = sun.misc.SharedSecrets.getJavaIOAccess().console();
+ }
+ }
+ return cons;
+ }
+
+ /**
+ * Returns the channel inherited from the entity that created this
+ * Java virtual machine.
+ *
+ *
This method returns the channel obtained by invoking the
+ * {@link java.nio.channels.spi.SelectorProvider#inheritedChannel
+ * inheritedChannel} method of the system-wide default
+ * {@link java.nio.channels.spi.SelectorProvider} object.
+ *
+ *
In addition to the network-oriented channels described in
+ * {@link java.nio.channels.spi.SelectorProvider#inheritedChannel
+ * inheritedChannel}, this method may return other kinds of
+ * channels in the future.
+ *
+ * @return The inherited channel, if any, otherwise null.
+ *
+ * @throws IOException
+ * If an I/O error occurs
+ *
+ * @throws SecurityException
+ * If a security manager is present and it does not
+ * permit access to the channel.
+ *
+ * @since 1.5
+ */
+ public static Channel inheritedChannel() throws IOException {
+ return SelectorProvider.provider().inheritedChannel();
+ }
+
+ private static void checkIO() {
+ SecurityManager sm = getSecurityManager();
+ if (sm != null) {
+ sm.checkPermission(new RuntimePermission("setIO"));
+ }
+ }
+
+ private static native void setIn0(InputStream in);
+ private static native void setOut0(PrintStream out);
+ private static native void setErr0(PrintStream err);
+
+ /**
+ * Sets the System security.
+ *
+ *
If there is a security manager already installed, this method first
+ * calls the security manager's checkPermission method
+ * with a RuntimePermission("setSecurityManager")
+ * permission to ensure it's ok to replace the existing
+ * security manager.
+ * This may result in throwing a SecurityException.
+ *
+ *
Otherwise, the argument is established as the current
+ * security manager. If the argument is null and no
+ * security manager has been established, then no action is taken and
+ * the method simply returns.
+ *
+ * @param s the security manager.
+ * @exception SecurityException if the security manager has already
+ * been set and its checkPermission method
+ * doesn't allow it to be replaced.
+ * @see #getSecurityManager
+ * @see SecurityManager#checkPermission
+ * @see java.lang.RuntimePermission
+ */
+ public static
+ void setSecurityManager(final SecurityManager s) {
+ try {
+ s.checkPackageAccess("java.lang");
+ } catch (Exception e) {
+ // no-op
+ }
+ setSecurityManager0(s);
+ }
+
+ private static synchronized
+ void setSecurityManager0(final SecurityManager s) {
+ SecurityManager sm = getSecurityManager();
+ if (sm != null) {
+ // ask the currently installed security manager if we
+ // can replace it.
+ sm.checkPermission(new RuntimePermission
+ ("setSecurityManager"));
+ }
+
+ if ((s != null) && (s.getClass().getClassLoader() != null)) {
+ // New security manager class is not on bootstrap classpath.
+ // Cause policy to get initialized before we install the new
+ // security manager, in order to prevent infinite loops when
+ // trying to initialize the policy (which usually involves
+ // accessing some security and/or system properties, which in turn
+ // calls the installed security manager's checkPermission method
+ // which will loop infinitely if there is a non-system class
+ // (in this case: the new security manager class) on the stack).
+ AccessController.doPrivileged(new PrivilegedAction