feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/java/lang/AbstractMethodError.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 1994, 2008, 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;
+
+/**
+ * Thrown when an application tries to call an abstract method.
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of some class has
+ * incompatibly changed since the currently executing method was last
+ * compiled.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class AbstractMethodError extends IncompatibleClassChangeError {
+    private static final long serialVersionUID = -1654391082989018462L;
+
+    /**
+     * Constructs an <code>AbstractMethodError</code> with no detail  message.
+     */
+    public AbstractMethodError() {
+        super();
+    }
+
+    /**
+     * Constructs an <code>AbstractMethodError</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public AbstractMethodError(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/Appendable.java

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2003, 2004, 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.IOException;
+
+/**
+ * An object to which <tt>char</tt> sequences and values can be appended.  The
+ * <tt>Appendable</tt> interface must be implemented by any class whose
+ * instances are intended to receive formatted output from a {@link
+ * java.util.Formatter}.
+ *
+ * <p> The characters to be appended should be valid Unicode characters as
+ * described in <a href="Character.html#unicode">Unicode Character
+ * Representation</a>.  Note that supplementary characters may be composed of
+ * multiple 16-bit <tt>char</tt> values.
+ *
+ * <p> Appendables are not necessarily safe for multithreaded access.  Thread
+ * safety is the responsibility of classes that extend and implement this
+ * interface.
+ *
+ * <p> Since this interface may be implemented by existing classes
+ * with different styles of error handling there is no guarantee that
+ * errors will be propagated to the invoker.
+ *
+ * @since 1.5
+ */
+public interface Appendable {
+
+    /**
+     * Appends the specified character sequence to this <tt>Appendable</tt>.
+     *
+     * <p> Depending on which class implements the character sequence
+     * <tt>csq</tt>, the entire sequence may not be appended.  For
+     * instance, if <tt>csq</tt> is a {@link java.nio.CharBuffer} then
+     * the subsequence to append is defined by the buffer's position and limit.
+     *
+     * @param  csq
+     *         The character sequence to append.  If <tt>csq</tt> is
+     *         <tt>null</tt>, then the four characters <tt>"null"</tt> are
+     *         appended to this Appendable.
+     *
+     * @return  A reference to this <tt>Appendable</tt>
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    Appendable append(CharSequence csq) throws IOException;
+
+    /**
+     * Appends a subsequence of the specified character sequence to this
+     * <tt>Appendable</tt>.
+     *
+     * <p> An invocation of this method of the form <tt>out.append(csq, start,
+     * end)</tt> when <tt>csq</tt> is not <tt>null</tt>, behaves in
+     * exactly the same way as the invocation
+     *
+     * <pre>
+     *     out.append(csq.subSequence(start, end)) </pre>
+     *
+     * @param  csq
+     *         The character sequence from which a subsequence will be
+     *         appended.  If <tt>csq</tt> is <tt>null</tt>, then characters
+     *         will be appended as if <tt>csq</tt> contained the four
+     *         characters <tt>"null"</tt>.
+     *
+     * @param  start
+     *         The index of the first character in the subsequence
+     *
+     * @param  end
+     *         The index of the character following the last character in the
+     *         subsequence
+     *
+     * @return  A reference to this <tt>Appendable</tt>
+     *
+     * @throws  IndexOutOfBoundsException
+     *          If <tt>start</tt> or <tt>end</tt> are negative, <tt>start</tt>
+     *          is greater than <tt>end</tt>, or <tt>end</tt> is greater than
+     *          <tt>csq.length()</tt>
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    Appendable append(CharSequence csq, int start, int end) throws IOException;
+
+    /**
+     * Appends the specified character to this <tt>Appendable</tt>.
+     *
+     * @param  c
+     *         The character to append
+     *
+     * @return  A reference to this <tt>Appendable</tt>
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    Appendable append(char c) throws IOException;
+}

jdkSrc/jdk8/java/lang/ApplicationShutdownHooks.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2005, 2010, 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.util.*;
+
+/*
+ * Class to track and run user level shutdown hooks registered through
+ * <tt>{@link Runtime#addShutdownHook Runtime.addShutdownHook}</tt>.
+ *
+ * @see java.lang.Runtime#addShutdownHook
+ * @see java.lang.Runtime#removeShutdownHook
+ */
+
+class ApplicationShutdownHooks {
+    /* The set of registered hooks */
+    private static IdentityHashMap<Thread, Thread> hooks;
+    static {
+        try {
+            Shutdown.add(1 /* shutdown hook invocation order */,
+                false /* not registered if shutdown in progress */,
+                new Runnable() {
+                    public void run() {
+                        runHooks();
+                    }
+                }
+            );
+            hooks = new IdentityHashMap<>();
+        } catch (IllegalStateException e) {
+            // application shutdown hooks cannot be added if
+            // shutdown is in progress.
+            hooks = null;
+        }
+    }
+
+
+    private ApplicationShutdownHooks() {}
+
+    /* Add a new shutdown hook.  Checks the shutdown state and the hook itself,
+     * but does not do any security checks.
+     */
+    static synchronized void add(Thread hook) {
+        if(hooks == null)
+            throw new IllegalStateException("Shutdown in progress");
+
+        if (hook.isAlive())
+            throw new IllegalArgumentException("Hook already running");
+
+        if (hooks.containsKey(hook))
+            throw new IllegalArgumentException("Hook previously registered");
+
+        hooks.put(hook, hook);
+    }
+
+    /* Remove a previously-registered hook.  Like the add method, this method
+     * does not do any security checks.
+     */
+    static synchronized boolean remove(Thread hook) {
+        if(hooks == null)
+            throw new IllegalStateException("Shutdown in progress");
+
+        if (hook == null)
+            throw new NullPointerException();
+
+        return hooks.remove(hook) != null;
+    }
+
+    /* Iterates over all application hooks creating a new thread for each
+     * to run in. Hooks are run concurrently and this method waits for
+     * them to finish.
+     */
+    static void runHooks() {
+        Collection<Thread> threads;
+        synchronized(ApplicationShutdownHooks.class) {
+            threads = hooks.keySet();
+            hooks = null;
+        }
+
+        for (Thread hook : threads) {
+            hook.start();
+        }
+        for (Thread hook : threads) {
+            while (true) {
+                try {
+                    hook.join();
+                    break;
+                } catch (InterruptedException ignored) {
+                }
+            }
+        }
+    }
+}

jdkSrc/jdk8/java/lang/ArithmeticException.java

@@ -0,0 +1,61 @@
+/*
+ * 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;
+
+/**
+ * Thrown when an exceptional arithmetic condition has occurred. For
+ * example, an integer "divide by zero" throws an
+ * instance of this class.
+ *
+ * {@code ArithmeticException} objects may be constructed by the
+ * virtual machine as if {@linkplain Throwable#Throwable(String,
+ * Throwable, boolean, boolean) suppression were disabled and/or the
+ * stack trace was not writable}.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public class ArithmeticException extends RuntimeException {
+    private static final long serialVersionUID = 2256477558314496007L;
+
+    /**
+     * Constructs an {@code ArithmeticException} with no detail
+     * message.
+     */
+    public ArithmeticException() {
+        super();
+    }
+
+    /**
+     * Constructs an {@code ArithmeticException} with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public ArithmeticException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/ArrayIndexOutOfBoundsException.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1994, 2008, 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;
+
+/**
+ * Thrown to indicate that an array has been accessed with an
+ * illegal index. The index is either negative or greater than or
+ * equal to the size of the array.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException {
+    private static final long serialVersionUID = -5116101128118950844L;
+
+    /**
+     * Constructs an <code>ArrayIndexOutOfBoundsException</code> with no
+     * detail message.
+     */
+    public ArrayIndexOutOfBoundsException() {
+        super();
+    }
+
+    /**
+     * Constructs a new <code>ArrayIndexOutOfBoundsException</code>
+     * class with an argument indicating the illegal index.
+     *
+     * @param   index   the illegal index.
+     */
+    public ArrayIndexOutOfBoundsException(int index) {
+        super("Array index out of range: " + index);
+    }
+
+    /**
+     * Constructs an <code>ArrayIndexOutOfBoundsException</code> class
+     * with the specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public ArrayIndexOutOfBoundsException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/ArrayStoreException.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1995, 2013, 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;
+
+/**
+ * Thrown to indicate that an attempt has been made to store the
+ * wrong type of object into an array of objects. For example, the
+ * following code generates an <code>ArrayStoreException</code>:
+ * <blockquote><pre>
+ *     Object x[] = new String[3];
+ *     x[0] = new Integer(0);
+ * </pre></blockquote>
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class ArrayStoreException extends RuntimeException {
+    private static final long serialVersionUID = -4522193890499838241L;
+
+    /**
+     * Constructs an <code>ArrayStoreException</code> with no detail message.
+     */
+    public ArrayStoreException() {
+        super();
+    }
+
+    /**
+     * Constructs an <code>ArrayStoreException</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public ArrayStoreException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/AssertionError.java

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2000, 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;
+
+/**
+ * Thrown to indicate that an assertion has failed.
+ *
+ * <p>The seven one-argument public constructors provided by this
+ * class ensure that the assertion error returned by the invocation:
+ * <pre>
+ *     new AssertionError(<i>expression</i>)
+ * </pre>
+ * has as its detail message the <i>string conversion</i> of
+ * <i>expression</i> (as defined in section 15.18.1.1 of
+ * <cite>The Java&trade; Language Specification</cite>),
+ * regardless of the type of <i>expression</i>.
+ *
+ * @since   1.4
+ */
+public class AssertionError extends Error {
+    private static final long serialVersionUID = -5013299493970297370L;
+
+    /**
+     * Constructs an AssertionError with no detail message.
+     */
+    public AssertionError() {
+    }
+
+    /**
+     * This internal constructor does no processing on its string argument,
+     * even if it is a null reference.  The public constructors will
+     * never call this constructor with a null argument.
+     */
+    private AssertionError(String detailMessage) {
+        super(detailMessage);
+    }
+
+    /**
+     * Constructs an AssertionError with its detail message derived
+     * from the specified object, which is converted to a string as
+     * defined in section 15.18.1.1 of
+     * <cite>The Java&trade; Language Specification</cite>.
+     *<p>
+     * If the specified object is an instance of {@code Throwable}, it
+     * becomes the <i>cause</i> of the newly constructed assertion error.
+     *
+     * @param detailMessage value to be used in constructing detail message
+     * @see   Throwable#getCause()
+     */
+    public AssertionError(Object detailMessage) {
+        this(String.valueOf(detailMessage));
+        if (detailMessage instanceof Throwable)
+            initCause((Throwable) detailMessage);
+    }
+
+    /**
+     * Constructs an AssertionError with its detail message derived
+     * from the specified <code>boolean</code>, which is converted to
+     * a string as defined in section 15.18.1.1 of
+     * <cite>The Java&trade; Language Specification</cite>.
+     *
+     * @param detailMessage value to be used in constructing detail message
+     */
+    public AssertionError(boolean detailMessage) {
+        this(String.valueOf(detailMessage));
+    }
+
+    /**
+     * Constructs an AssertionError with its detail message derived
+     * from the specified <code>char</code>, which is converted to a
+     * string as defined in section 15.18.1.1 of
+     * <cite>The Java&trade; Language Specification</cite>.
+     *
+     * @param detailMessage value to be used in constructing detail message
+     */
+    public AssertionError(char detailMessage) {
+        this(String.valueOf(detailMessage));
+    }
+
+    /**
+     * Constructs an AssertionError with its detail message derived
+     * from the specified <code>int</code>, which is converted to a
+     * string as defined in section 15.18.1.1 of
+     * <cite>The Java&trade; Language Specification</cite>.
+     *
+     * @param detailMessage value to be used in constructing detail message
+     */
+    public AssertionError(int detailMessage) {
+        this(String.valueOf(detailMessage));
+    }
+
+    /**
+     * Constructs an AssertionError with its detail message derived
+     * from the specified <code>long</code>, which is converted to a
+     * string as defined in section 15.18.1.1 of
+     * <cite>The Java&trade; Language Specification</cite>.
+     *
+     * @param detailMessage value to be used in constructing detail message
+     */
+    public AssertionError(long detailMessage) {
+        this(String.valueOf(detailMessage));
+    }
+
+    /**
+     * Constructs an AssertionError with its detail message derived
+     * from the specified <code>float</code>, which is converted to a
+     * string as defined in section 15.18.1.1 of
+     * <cite>The Java&trade; Language Specification</cite>.
+     *
+     * @param detailMessage value to be used in constructing detail message
+     */
+    public AssertionError(float detailMessage) {
+        this(String.valueOf(detailMessage));
+    }
+
+    /**
+     * Constructs an AssertionError with its detail message derived
+     * from the specified <code>double</code>, which is converted to a
+     * string as defined in section 15.18.1.1 of
+     * <cite>The Java&trade; Language Specification</cite>.
+     *
+     * @param detailMessage value to be used in constructing detail message
+     */
+    public AssertionError(double detailMessage) {
+        this(String.valueOf(detailMessage));
+    }
+
+    /**
+     * Constructs a new {@code AssertionError} with the specified
+     * detail message and cause.
+     *
+     * <p>Note that the detail message associated with
+     * {@code cause} is <i>not</i> automatically incorporated in
+     * this error's detail message.
+     *
+     * @param  message the detail message, may be {@code null}
+     * @param  cause the cause, may be {@code null}
+     *
+     * @since 1.7
+     */
+    public AssertionError(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

jdkSrc/jdk8/java/lang/AssertionStatusDirectives.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2000, 2006, 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;
+
+/**
+ * A collection of assertion status directives (such as "enable assertions
+ * in package p" or "disable assertions in class c").  This class is used by
+ * the JVM to communicate the assertion status directives implied by
+ * the <tt>java</tt> command line flags <tt>-enableassertions</tt>
+ * (<tt>-ea</tt>) and <tt>-disableassertions</tt> (<tt>-da</tt>).
+ *
+ * @since  1.4
+ * @author Josh Bloch
+ */
+class AssertionStatusDirectives {
+    /**
+     * The classes for which assertions are to be enabled or disabled.
+     * The strings in this array are fully qualified class names (for
+     * example,"com.xyz.foo.Bar").
+     */
+    String[] classes;
+
+    /**
+     * A parallel array to <tt>classes</tt>, indicating whether each class
+     * is to have assertions enabled or disabled.  A value of <tt>true</tt>
+     * for <tt>classEnabled[i]</tt> indicates that the class named by
+     * <tt>classes[i]</tt> should have assertions enabled; a value of
+     * <tt>false</tt> indicates that it should have classes disabled.
+     * This array must have the same number of elements as <tt>classes</tt>.
+     *
+     * <p>In the case of conflicting directives for the same class, the
+     * last directive for a given class wins.  In other words, if a string
+     * <tt>s</tt> appears multiple times in the <tt>classes</tt> array
+     * and <tt>i</tt> is the highest integer for which
+     * <tt>classes[i].equals(s)</tt>, then <tt>classEnabled[i]</tt>
+     * indicates whether assertions are to be enabled in class <tt>s</tt>.
+     */
+    boolean[] classEnabled;
+
+    /**
+     * The package-trees for which assertions are to be enabled or disabled.
+     * The strings in this array are compete or partial package names
+     * (for example, "com.xyz" or "com.xyz.foo").
+     */
+    String[] packages;
+
+    /**
+     * A parallel array to <tt>packages</tt>, indicating whether each
+     * package-tree is to have assertions enabled or disabled.  A value of
+     * <tt>true</tt> for <tt>packageEnabled[i]</tt> indicates that the
+     * package-tree named by <tt>packages[i]</tt> should have assertions
+     * enabled; a value of <tt>false</tt> indicates that it should have
+     * assertions disabled.  This array must have the same number of
+     * elements as <tt>packages</tt>.
+     *
+     * In the case of conflicting directives for the same package-tree, the
+     * last directive for a given package-tree wins.  In other words, if a
+     * string <tt>s</tt> appears multiple times in the <tt>packages</tt> array
+     * and <tt>i</tt> is the highest integer for which
+     * <tt>packages[i].equals(s)</tt>, then <tt>packageEnabled[i]</tt>
+     * indicates whether assertions are to be enabled in package-tree
+     * <tt>s</tt>.
+     */
+    boolean[] packageEnabled;
+
+    /**
+     * Whether or not assertions in non-system classes are to be enabled
+     * by default.
+     */
+    boolean deflt;
+}

jdkSrc/jdk8/java/lang/AutoCloseable.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2009, 2013, 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;
+
+/**
+ * An object that may hold resources (such as file or socket handles)
+ * until it is closed. The {@link #close()} method of an {@code AutoCloseable}
+ * object is called automatically when exiting a {@code
+ * try}-with-resources block for which the object has been declared in
+ * the resource specification header. This construction ensures prompt
+ * release, avoiding resource exhaustion exceptions and errors that
+ * may otherwise occur.
+ *
+ * @apiNote
+ * <p>It is possible, and in fact common, for a base class to
+ * implement AutoCloseable even though not all of its subclasses or
+ * instances will hold releasable resources.  For code that must operate
+ * in complete generality, or when it is known that the {@code AutoCloseable}
+ * instance requires resource release, it is recommended to use {@code
+ * try}-with-resources constructions. However, when using facilities such as
+ * {@link java.util.stream.Stream} that support both I/O-based and
+ * non-I/O-based forms, {@code try}-with-resources blocks are in
+ * general unnecessary when using non-I/O-based forms.
+ *
+ * @author Josh Bloch
+ * @since 1.7
+ */
+public interface AutoCloseable {
+    /**
+     * Closes this resource, relinquishing any underlying resources.
+     * This method is invoked automatically on objects managed by the
+     * {@code try}-with-resources statement.
+     *
+     * <p>While this interface method is declared to throw {@code
+     * Exception}, implementers are <em>strongly</em> encouraged to
+     * declare concrete implementations of the {@code close} method to
+     * throw more specific exceptions, or to throw no exception at all
+     * if the close operation cannot fail.
+     *
+     * <p> Cases where the close operation may fail require careful
+     * attention by implementers. It is strongly advised to relinquish
+     * the underlying resources and to internally <em>mark</em> the
+     * resource as closed, prior to throwing the exception. The {@code
+     * close} method is unlikely to be invoked more than once and so
+     * this ensures that the resources are released in a timely manner.
+     * Furthermore it reduces problems that could arise when the resource
+     * wraps, or is wrapped, by another resource.
+     *
+     * <p><em>Implementers of this interface are also strongly advised
+     * to not have the {@code close} method throw {@link
+     * InterruptedException}.</em>
+     *
+     * This exception interacts with a thread's interrupted status,
+     * and runtime misbehavior is likely to occur if an {@code
+     * InterruptedException} is {@linkplain Throwable#addSuppressed
+     * suppressed}.
+     *
+     * More generally, if it would cause problems for an
+     * exception to be suppressed, the {@code AutoCloseable.close}
+     * method should not throw it.
+     *
+     * <p>Note that unlike the {@link java.io.Closeable#close close}
+     * method of {@link java.io.Closeable}, this {@code close} method
+     * is <em>not</em> required to be idempotent.  In other words,
+     * calling this {@code close} method more than once may have some
+     * visible side effect, unlike {@code Closeable.close} which is
+     * required to have no effect if called more than once.
+     *
+     * However, implementers of this interface are strongly encouraged
+     * to make their {@code close} methods idempotent.
+     *
+     * @throws Exception if this resource cannot be closed
+     */
+    void close() throws Exception;
+}

jdkSrc/jdk8/java/lang/Boolean.java

@@ -0,0 +1,335 @@
+/*
+ * Copyright (c) 1994, 2013, 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;
+
+/**
+ * The Boolean class wraps a value of the primitive type
+ * {@code boolean} in an object. An object of type
+ * {@code Boolean} contains a single field whose type is
+ * {@code boolean}.
+ * <p>
+ * In addition, this class provides many methods for
+ * converting a {@code boolean} to a {@code String} and a
+ * {@code String} to a {@code boolean}, as well as other
+ * constants and methods useful when dealing with a
+ * {@code boolean}.
+ *
+ * @author  Arthur van Hoff
+ * @since   JDK1.0
+ */
+public final class Boolean implements java.io.Serializable,
+                                      Comparable<Boolean>
+{
+    /**
+     * The {@code Boolean} object corresponding to the primitive
+     * value {@code true}.
+     */
+    public static final Boolean TRUE = new Boolean(true);
+
+    /**
+     * The {@code Boolean} object corresponding to the primitive
+     * value {@code false}.
+     */
+    public static final Boolean FALSE = new Boolean(false);
+
+    /**
+     * The Class object representing the primitive type boolean.
+     *
+     * @since   JDK1.1
+     */
+    @SuppressWarnings("unchecked")
+    public static final Class<Boolean> TYPE = (Class<Boolean>) Class.getPrimitiveClass("boolean");
+
+    /**
+     * The value of the Boolean.
+     *
+     * @serial
+     */
+    private final boolean value;
+
+    /** use serialVersionUID from JDK 1.0.2 for interoperability */
+    private static final long serialVersionUID = -3665804199014368530L;
+
+    /**
+     * Allocates a {@code Boolean} object representing the
+     * {@code value} argument.
+     *
+     * <p><b>Note: It is rarely appropriate to use this constructor.
+     * Unless a <i>new</i> instance is required, the static factory
+     * {@link #valueOf(boolean)} is generally a better choice. It is
+     * likely to yield significantly better space and time performance.</b>
+     *
+     * @param   value   the value of the {@code Boolean}.
+     */
+    public Boolean(boolean value) {
+        this.value = value;
+    }
+
+    /**
+     * Allocates a {@code Boolean} object representing the value
+     * {@code true} if the string argument is not {@code null}
+     * and is equal, ignoring case, to the string {@code "true"}.
+     * Otherwise, allocate a {@code Boolean} object representing the
+     * value {@code false}. Examples:<p>
+     * {@code new Boolean("True")} produces a {@code Boolean} object
+     * that represents {@code true}.<br>
+     * {@code new Boolean("yes")} produces a {@code Boolean} object
+     * that represents {@code false}.
+     *
+     * @param   s   the string to be converted to a {@code Boolean}.
+     */
+    public Boolean(String s) {
+        this(parseBoolean(s));
+    }
+
+    /**
+     * Parses the string argument as a boolean.  The {@code boolean}
+     * returned represents the value {@code true} if the string argument
+     * is not {@code null} and is equal, ignoring case, to the string
+     * {@code "true"}. <p>
+     * Example: {@code Boolean.parseBoolean("True")} returns {@code true}.<br>
+     * Example: {@code Boolean.parseBoolean("yes")} returns {@code false}.
+     *
+     * @param      s   the {@code String} containing the boolean
+     *                 representation to be parsed
+     * @return     the boolean represented by the string argument
+     * @since 1.5
+     */
+    public static boolean parseBoolean(String s) {
+        return ((s != null) && s.equalsIgnoreCase("true"));
+    }
+
+    /**
+     * Returns the value of this {@code Boolean} object as a boolean
+     * primitive.
+     *
+     * @return  the primitive {@code boolean} value of this object.
+     */
+    public boolean booleanValue() {
+        return value;
+    }
+
+    /**
+     * Returns a {@code Boolean} instance representing the specified
+     * {@code boolean} value.  If the specified {@code boolean} value
+     * is {@code true}, this method returns {@code Boolean.TRUE};
+     * if it is {@code false}, this method returns {@code Boolean.FALSE}.
+     * If a new {@code Boolean} instance is not required, this method
+     * should generally be used in preference to the constructor
+     * {@link #Boolean(boolean)}, as this method is likely to yield
+     * significantly better space and time performance.
+     *
+     * @param  b a boolean value.
+     * @return a {@code Boolean} instance representing {@code b}.
+     * @since  1.4
+     */
+    public static Boolean valueOf(boolean b) {
+        return (b ? TRUE : FALSE);
+    }
+
+    /**
+     * Returns a {@code Boolean} with a value represented by the
+     * specified string.  The {@code Boolean} returned represents a
+     * true value if the string argument is not {@code null}
+     * and is equal, ignoring case, to the string {@code "true"}.
+     *
+     * @param   s   a string.
+     * @return  the {@code Boolean} value represented by the string.
+     */
+    public static Boolean valueOf(String s) {
+        return parseBoolean(s) ? TRUE : FALSE;
+    }
+
+    /**
+     * Returns a {@code String} object representing the specified
+     * boolean.  If the specified boolean is {@code true}, then
+     * the string {@code "true"} will be returned, otherwise the
+     * string {@code "false"} will be returned.
+     *
+     * @param b the boolean to be converted
+     * @return the string representation of the specified {@code boolean}
+     * @since 1.4
+     */
+    public static String toString(boolean b) {
+        return b ? "true" : "false";
+    }
+
+    /**
+     * Returns a {@code String} object representing this Boolean's
+     * value.  If this object represents the value {@code true},
+     * a string equal to {@code "true"} is returned. Otherwise, a
+     * string equal to {@code "false"} is returned.
+     *
+     * @return  a string representation of this object.
+     */
+    public String toString() {
+        return value ? "true" : "false";
+    }
+
+    /**
+     * Returns a hash code for this {@code Boolean} object.
+     *
+     * @return  the integer {@code 1231} if this object represents
+     * {@code true}; returns the integer {@code 1237} if this
+     * object represents {@code false}.
+     */
+    @Override
+    public int hashCode() {
+        return Boolean.hashCode(value);
+    }
+
+    /**
+     * Returns a hash code for a {@code boolean} value; compatible with
+     * {@code Boolean.hashCode()}.
+     *
+     * @param value the value to hash
+     * @return a hash code value for a {@code boolean} value.
+     * @since 1.8
+     */
+    public static int hashCode(boolean value) {
+        return value ? 1231 : 1237;
+    }
+
+   /**
+     * Returns {@code true} if and only if the argument is not
+     * {@code null} and is a {@code Boolean} object that
+     * represents the same {@code boolean} value as this object.
+     *
+     * @param   obj   the object to compare with.
+     * @return  {@code true} if the Boolean objects represent the
+     *          same value; {@code false} otherwise.
+     */
+    public boolean equals(Object obj) {
+        if (obj instanceof Boolean) {
+            return value == ((Boolean)obj).booleanValue();
+        }
+        return false;
+    }
+
+    /**
+     * Returns {@code true} if and only if the system property
+     * named by the argument exists and is equal to the string
+     * {@code "true"}. (Beginning with version 1.0.2 of the
+     * Java<small><sup>TM</sup></small> platform, the test of
+     * this string is case insensitive.) A system property is accessible
+     * through {@code getProperty}, a method defined by the
+     * {@code System} class.
+     * <p>
+     * If there is no property with the specified name, or if the specified
+     * name is empty or null, then {@code false} is returned.
+     *
+     * @param   name   the system property name.
+     * @return  the {@code boolean} value of the system property.
+     * @throws  SecurityException for the same reasons as
+     *          {@link System#getProperty(String) System.getProperty}
+     * @see     java.lang.System#getProperty(java.lang.String)
+     * @see     java.lang.System#getProperty(java.lang.String, java.lang.String)
+     */
+    public static boolean getBoolean(String name) {
+        boolean result = false;
+        try {
+            result = parseBoolean(System.getProperty(name));
+        } catch (IllegalArgumentException | NullPointerException e) {
+        }
+        return result;
+    }
+
+    /**
+     * Compares this {@code Boolean} instance with another.
+     *
+     * @param   b the {@code Boolean} instance to be compared
+     * @return  zero if this object represents the same boolean value as the
+     *          argument; a positive value if this object represents true
+     *          and the argument represents false; and a negative value if
+     *          this object represents false and the argument represents true
+     * @throws  NullPointerException if the argument is {@code null}
+     * @see     Comparable
+     * @since  1.5
+     */
+    public int compareTo(Boolean b) {
+        return compare(this.value, b.value);
+    }
+
+    /**
+     * Compares two {@code boolean} values.
+     * The value returned is identical to what would be returned by:
+     * <pre>
+     *    Boolean.valueOf(x).compareTo(Boolean.valueOf(y))
+     * </pre>
+     *
+     * @param  x the first {@code boolean} to compare
+     * @param  y the second {@code boolean} to compare
+     * @return the value {@code 0} if {@code x == y};
+     *         a value less than {@code 0} if {@code !x && y}; and
+     *         a value greater than {@code 0} if {@code x && !y}
+     * @since 1.7
+     */
+    public static int compare(boolean x, boolean y) {
+        return (x == y) ? 0 : (x ? 1 : -1);
+    }
+
+    /**
+     * Returns the result of applying the logical AND operator to the
+     * specified {@code boolean} operands.
+     *
+     * @param a the first operand
+     * @param b the second operand
+     * @return the logical AND of {@code a} and {@code b}
+     * @see java.util.function.BinaryOperator
+     * @since 1.8
+     */
+    public static boolean logicalAnd(boolean a, boolean b) {
+        return a && b;
+    }
+
+    /**
+     * Returns the result of applying the logical OR operator to the
+     * specified {@code boolean} operands.
+     *
+     * @param a the first operand
+     * @param b the second operand
+     * @return the logical OR of {@code a} and {@code b}
+     * @see java.util.function.BinaryOperator
+     * @since 1.8
+     */
+    public static boolean logicalOr(boolean a, boolean b) {
+        return a || b;
+    }
+
+    /**
+     * Returns the result of applying the logical XOR operator to the
+     * specified {@code boolean} operands.
+     *
+     * @param a the first operand
+     * @param b the second operand
+     * @return  the logical XOR of {@code a} and {@code b}
+     * @see java.util.function.BinaryOperator
+     * @since 1.8
+     */
+    public static boolean logicalXor(boolean a, boolean b) {
+        return a ^ b;
+    }
+}

jdkSrc/jdk8/java/lang/BootstrapMethodError.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008, 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;
+
+/**
+ * Thrown to indicate that an {@code invokedynamic} instruction has
+ * failed to find its bootstrap method,
+ * or the bootstrap method has failed to provide a
+ * {@linkplain java.lang.invoke.CallSite call site} with a {@linkplain java.lang.invoke.CallSite#getTarget target}
+ * of the correct {@linkplain java.lang.invoke.MethodHandle#type method type}.
+ *
+ * @author John Rose, JSR 292 EG
+ * @since 1.7
+ */
+public class BootstrapMethodError extends LinkageError {
+    private static final long serialVersionUID = 292L;
+
+    /**
+     * Constructs a {@code BootstrapMethodError} with no detail message.
+     */
+    public BootstrapMethodError() {
+        super();
+    }
+
+    /**
+     * Constructs a {@code BootstrapMethodError} with the specified
+     * detail message.
+     *
+     * @param s the detail message.
+     */
+    public BootstrapMethodError(String s) {
+        super(s);
+    }
+
+    /**
+     * Constructs a {@code BootstrapMethodError} with the specified
+     * detail message and cause.
+     *
+     * @param s the detail message.
+     * @param cause the cause, may be {@code null}.
+     */
+    public BootstrapMethodError(String s, Throwable cause) {
+        super(s, cause);
+    }
+
+    /**
+     * Constructs a {@code BootstrapMethodError} with the specified
+     * cause.
+     *
+     * @param cause the cause, may be {@code null}.
+     */
+    public BootstrapMethodError(Throwable cause) {
+        // cf. Throwable(Throwable cause) constructor.
+        super(cause == null ? null : cause.toString());
+        initCause(cause);
+    }
+}

jdkSrc/jdk8/java/lang/Byte.java

@@ -0,0 +1,520 @@
+/*
+ * Copyright (c) 1996, 2013, 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;
+
+/**
+ *
+ * The {@code Byte} class wraps a value of primitive type {@code byte}
+ * in an object.  An object of type {@code Byte} contains a single
+ * field whose type is {@code byte}.
+ *
+ * <p>In addition, this class provides several methods for converting
+ * a {@code byte} to a {@code String} and a {@code String} to a {@code
+ * byte}, as well as other constants and methods useful when dealing
+ * with a {@code byte}.
+ *
+ * @author  Nakul Saraiya
+ * @author  Joseph D. Darcy
+ * @see     java.lang.Number
+ * @since   JDK1.1
+ */
+public final class Byte extends Number implements Comparable<Byte> {
+
+    /**
+     * A constant holding the minimum value a {@code byte} can
+     * have, -2<sup>7</sup>.
+     */
+    public static final byte   MIN_VALUE = -128;
+
+    /**
+     * A constant holding the maximum value a {@code byte} can
+     * have, 2<sup>7</sup>-1.
+     */
+    public static final byte   MAX_VALUE = 127;
+
+    /**
+     * The {@code Class} instance representing the primitive type
+     * {@code byte}.
+     */
+    @SuppressWarnings("unchecked")
+    public static final Class<Byte>     TYPE = (Class<Byte>) Class.getPrimitiveClass("byte");
+
+    /**
+     * Returns a new {@code String} object representing the
+     * specified {@code byte}. The radix is assumed to be 10.
+     *
+     * @param b the {@code byte} to be converted
+     * @return the string representation of the specified {@code byte}
+     * @see java.lang.Integer#toString(int)
+     */
+    public static String toString(byte b) {
+        return Integer.toString((int)b, 10);
+    }
+
+    private static class ByteCache {
+        private ByteCache(){}
+
+        static final Byte cache[] = new Byte[-(-128) + 127 + 1];
+
+        static {
+            for(int i = 0; i < cache.length; i++)
+                cache[i] = new Byte((byte)(i - 128));
+        }
+    }
+
+    /**
+     * Returns a {@code Byte} instance representing the specified
+     * {@code byte} value.
+     * If a new {@code Byte} instance is not required, this method
+     * should generally be used in preference to the constructor
+     * {@link #Byte(byte)}, as this method is likely to yield
+     * significantly better space and time performance since
+     * all byte values are cached.
+     *
+     * @param  b a byte value.
+     * @return a {@code Byte} instance representing {@code b}.
+     * @since  1.5
+     */
+    public static Byte valueOf(byte b) {
+        final int offset = 128;
+        return ByteCache.cache[(int)b + offset];
+    }
+
+    /**
+     * Parses the string argument as a signed {@code byte} in the
+     * radix specified by the second argument. The characters in the
+     * string must all be digits, of the specified radix (as
+     * determined by whether {@link java.lang.Character#digit(char,
+     * int)} returns a nonnegative value) except that the first
+     * character may be an ASCII minus sign {@code '-'}
+     * ({@code '\u005Cu002D'}) to indicate a negative value or an
+     * ASCII plus sign {@code '+'} ({@code '\u005Cu002B'}) to
+     * indicate a positive value.  The resulting {@code byte} value is
+     * returned.
+     *
+     * <p>An exception of type {@code NumberFormatException} is
+     * thrown if any of the following situations occurs:
+     * <ul>
+     * <li> The first argument is {@code null} or is a string of
+     * length zero.
+     *
+     * <li> The radix is either smaller than {@link
+     * java.lang.Character#MIN_RADIX} or larger than {@link
+     * java.lang.Character#MAX_RADIX}.
+     *
+     * <li> Any character of the string is not a digit of the
+     * specified radix, except that the first character may be a minus
+     * sign {@code '-'} ({@code '\u005Cu002D'}) or plus sign
+     * {@code '+'} ({@code '\u005Cu002B'}) provided that the
+     * string is longer than length 1.
+     *
+     * <li> The value represented by the string is not a value of type
+     * {@code byte}.
+     * </ul>
+     *
+     * @param s         the {@code String} containing the
+     *                  {@code byte}
+     *                  representation to be parsed
+     * @param radix     the radix to be used while parsing {@code s}
+     * @return          the {@code byte} value represented by the string
+     *                   argument in the specified radix
+     * @throws          NumberFormatException If the string does
+     *                  not contain a parsable {@code byte}.
+     */
+    public static byte parseByte(String s, int radix)
+        throws NumberFormatException {
+        int i = Integer.parseInt(s, radix);
+        if (i < MIN_VALUE || i > MAX_VALUE)
+            throw new NumberFormatException(
+                "Value out of range. Value:\"" + s + "\" Radix:" + radix);
+        return (byte)i;
+    }
+
+    /**
+     * Parses the string argument as a signed decimal {@code
+     * byte}. The characters in the string must all be decimal digits,
+     * except that the first character may be an ASCII minus sign
+     * {@code '-'} ({@code '\u005Cu002D'}) to indicate a negative
+     * value or an ASCII plus sign {@code '+'}
+     * ({@code '\u005Cu002B'}) to indicate a positive value. The
+     * resulting {@code byte} value is returned, exactly as if the
+     * argument and the radix 10 were given as arguments to the {@link
+     * #parseByte(java.lang.String, int)} method.
+     *
+     * @param s         a {@code String} containing the
+     *                  {@code byte} representation to be parsed
+     * @return          the {@code byte} value represented by the
+     *                  argument in decimal
+     * @throws          NumberFormatException if the string does not
+     *                  contain a parsable {@code byte}.
+     */
+    public static byte parseByte(String s) throws NumberFormatException {
+        return parseByte(s, 10);
+    }
+
+    /**
+     * Returns a {@code Byte} object holding the value
+     * extracted from the specified {@code String} when parsed
+     * with the radix given by the second argument. The first argument
+     * is interpreted as representing a signed {@code byte} in
+     * the radix specified by the second argument, exactly as if the
+     * argument were given to the {@link #parseByte(java.lang.String,
+     * int)} method. The result is a {@code Byte} object that
+     * represents the {@code byte} value specified by the string.
+     *
+     * <p> In other words, this method returns a {@code Byte} object
+     * equal to the value of:
+     *
+     * <blockquote>
+     * {@code new Byte(Byte.parseByte(s, radix))}
+     * </blockquote>
+     *
+     * @param s         the string to be parsed
+     * @param radix     the radix to be used in interpreting {@code s}
+     * @return          a {@code Byte} object holding the value
+     *                  represented by the string argument in the
+     *                  specified radix.
+     * @throws          NumberFormatException If the {@code String} does
+     *                  not contain a parsable {@code byte}.
+     */
+    public static Byte valueOf(String s, int radix)
+        throws NumberFormatException {
+        return valueOf(parseByte(s, radix));
+    }
+
+    /**
+     * Returns a {@code Byte} object holding the value
+     * given by the specified {@code String}. The argument is
+     * interpreted as representing a signed decimal {@code byte},
+     * exactly as if the argument were given to the {@link
+     * #parseByte(java.lang.String)} method. The result is a
+     * {@code Byte} object that represents the {@code byte}
+     * value specified by the string.
+     *
+     * <p> In other words, this method returns a {@code Byte} object
+     * equal to the value of:
+     *
+     * <blockquote>
+     * {@code new Byte(Byte.parseByte(s))}
+     * </blockquote>
+     *
+     * @param s         the string to be parsed
+     * @return          a {@code Byte} object holding the value
+     *                  represented by the string argument
+     * @throws          NumberFormatException If the {@code String} does
+     *                  not contain a parsable {@code byte}.
+     */
+    public static Byte valueOf(String s) throws NumberFormatException {
+        return valueOf(s, 10);
+    }
+
+    /**
+     * Decodes a {@code String} into a {@code Byte}.
+     * Accepts decimal, hexadecimal, and octal numbers given by
+     * the following grammar:
+     *
+     * <blockquote>
+     * <dl>
+     * <dt><i>DecodableString:</i>
+     * <dd><i>Sign<sub>opt</sub> DecimalNumeral</i>
+     * <dd><i>Sign<sub>opt</sub></i> {@code 0x} <i>HexDigits</i>
+     * <dd><i>Sign<sub>opt</sub></i> {@code 0X} <i>HexDigits</i>
+     * <dd><i>Sign<sub>opt</sub></i> {@code #} <i>HexDigits</i>
+     * <dd><i>Sign<sub>opt</sub></i> {@code 0} <i>OctalDigits</i>
+     *
+     * <dt><i>Sign:</i>
+     * <dd>{@code -}
+     * <dd>{@code +}
+     * </dl>
+     * </blockquote>
+     *
+     * <i>DecimalNumeral</i>, <i>HexDigits</i>, and <i>OctalDigits</i>
+     * are as defined in section 3.10.1 of
+     * <cite>The Java&trade; Language Specification</cite>,
+     * except that underscores are not accepted between digits.
+     *
+     * <p>The sequence of characters following an optional
+     * sign and/or radix specifier ("{@code 0x}", "{@code 0X}",
+     * "{@code #}", or leading zero) is parsed as by the {@code
+     * Byte.parseByte} method with the indicated radix (10, 16, or 8).
+     * This sequence of characters must represent a positive value or
+     * a {@link NumberFormatException} will be thrown.  The result is
+     * negated if first character of the specified {@code String} is
+     * the minus sign.  No whitespace characters are permitted in the
+     * {@code String}.
+     *
+     * @param     nm the {@code String} to decode.
+     * @return   a {@code Byte} object holding the {@code byte}
+     *          value represented by {@code nm}
+     * @throws  NumberFormatException  if the {@code String} does not
+     *            contain a parsable {@code byte}.
+     * @see java.lang.Byte#parseByte(java.lang.String, int)
+     */
+    public static Byte decode(String nm) throws NumberFormatException {
+        int i = Integer.decode(nm);
+        if (i < MIN_VALUE || i > MAX_VALUE)
+            throw new NumberFormatException(
+                    "Value " + i + " out of range from input " + nm);
+        return valueOf((byte)i);
+    }
+
+    /**
+     * The value of the {@code Byte}.
+     *
+     * @serial
+     */
+    private final byte value;
+
+    /**
+     * Constructs a newly allocated {@code Byte} object that
+     * represents the specified {@code byte} value.
+     *
+     * @param value     the value to be represented by the
+     *                  {@code Byte}.
+     */
+    public Byte(byte value) {
+        this.value = value;
+    }
+
+    /**
+     * Constructs a newly allocated {@code Byte} object that
+     * represents the {@code byte} value indicated by the
+     * {@code String} parameter. The string is converted to a
+     * {@code byte} value in exactly the manner used by the
+     * {@code parseByte} method for radix 10.
+     *
+     * @param s         the {@code String} to be converted to a
+     *                  {@code Byte}
+     * @throws           NumberFormatException If the {@code String}
+     *                  does not contain a parsable {@code byte}.
+     * @see        java.lang.Byte#parseByte(java.lang.String, int)
+     */
+    public Byte(String s) throws NumberFormatException {
+        this.value = parseByte(s, 10);
+    }
+
+    /**
+     * Returns the value of this {@code Byte} as a
+     * {@code byte}.
+     */
+    public byte byteValue() {
+        return value;
+    }
+
+    /**
+     * Returns the value of this {@code Byte} as a {@code short} after
+     * a widening primitive conversion.
+     * @jls 5.1.2 Widening Primitive Conversions
+     */
+    public short shortValue() {
+        return (short)value;
+    }
+
+    /**
+     * Returns the value of this {@code Byte} as an {@code int} after
+     * a widening primitive conversion.
+     * @jls 5.1.2 Widening Primitive Conversions
+     */
+    public int intValue() {
+        return (int)value;
+    }
+
+    /**
+     * Returns the value of this {@code Byte} as a {@code long} after
+     * a widening primitive conversion.
+     * @jls 5.1.2 Widening Primitive Conversions
+     */
+    public long longValue() {
+        return (long)value;
+    }
+
+    /**
+     * Returns the value of this {@code Byte} as a {@code float} after
+     * a widening primitive conversion.
+     * @jls 5.1.2 Widening Primitive Conversions
+     */
+    public float floatValue() {
+        return (float)value;
+    }
+
+    /**
+     * Returns the value of this {@code Byte} as a {@code double}
+     * after a widening primitive conversion.
+     * @jls 5.1.2 Widening Primitive Conversions
+     */
+    public double doubleValue() {
+        return (double)value;
+    }
+
+    /**
+     * Returns a {@code String} object representing this
+     * {@code Byte}'s value.  The value is converted to signed
+     * decimal representation and returned as a string, exactly as if
+     * the {@code byte} value were given as an argument to the
+     * {@link java.lang.Byte#toString(byte)} method.
+     *
+     * @return  a string representation of the value of this object in
+     *          base&nbsp;10.
+     */
+    public String toString() {
+        return Integer.toString((int)value);
+    }
+
+    /**
+     * Returns a hash code for this {@code Byte}; equal to the result
+     * of invoking {@code intValue()}.
+     *
+     * @return a hash code value for this {@code Byte}
+     */
+    @Override
+    public int hashCode() {
+        return Byte.hashCode(value);
+    }
+
+    /**
+     * Returns a hash code for a {@code byte} value; compatible with
+     * {@code Byte.hashCode()}.
+     *
+     * @param value the value to hash
+     * @return a hash code value for a {@code byte} value.
+     * @since 1.8
+     */
+    public static int hashCode(byte value) {
+        return (int)value;
+    }
+
+    /**
+     * Compares this object to the specified object.  The result is
+     * {@code true} if and only if the argument is not
+     * {@code null} and is a {@code Byte} object that
+     * contains the same {@code byte} value as this object.
+     *
+     * @param obj       the object to compare with
+     * @return          {@code true} if the objects are the same;
+     *                  {@code false} otherwise.
+     */
+    public boolean equals(Object obj) {
+        if (obj instanceof Byte) {
+            return value == ((Byte)obj).byteValue();
+        }
+        return false;
+    }
+
+    /**
+     * Compares two {@code Byte} objects numerically.
+     *
+     * @param   anotherByte   the {@code Byte} to be compared.
+     * @return  the value {@code 0} if this {@code Byte} is
+     *          equal to the argument {@code Byte}; a value less than
+     *          {@code 0} if this {@code Byte} is numerically less
+     *          than the argument {@code Byte}; and a value greater than
+     *           {@code 0} if this {@code Byte} is numerically
+     *           greater than the argument {@code Byte} (signed
+     *           comparison).
+     * @since   1.2
+     */
+    public int compareTo(Byte anotherByte) {
+        return compare(this.value, anotherByte.value);
+    }
+
+    /**
+     * Compares two {@code byte} values numerically.
+     * The value returned is identical to what would be returned by:
+     * <pre>
+     *    Byte.valueOf(x).compareTo(Byte.valueOf(y))
+     * </pre>
+     *
+     * @param  x the first {@code byte} to compare
+     * @param  y the second {@code byte} to compare
+     * @return the value {@code 0} if {@code x == y};
+     *         a value less than {@code 0} if {@code x < y}; and
+     *         a value greater than {@code 0} if {@code x > y}
+     * @since 1.7
+     */
+    public static int compare(byte x, byte y) {
+        return x - y;
+    }
+
+    /**
+     * Converts the argument to an {@code int} by an unsigned
+     * conversion.  In an unsigned conversion to an {@code int}, the
+     * high-order 24 bits of the {@code int} are zero and the
+     * low-order 8 bits are equal to the bits of the {@code byte} argument.
+     *
+     * Consequently, zero and positive {@code byte} values are mapped
+     * to a numerically equal {@code int} value and negative {@code
+     * byte} values are mapped to an {@code int} value equal to the
+     * input plus 2<sup>8</sup>.
+     *
+     * @param  x the value to convert to an unsigned {@code int}
+     * @return the argument converted to {@code int} by an unsigned
+     *         conversion
+     * @since 1.8
+     */
+    public static int toUnsignedInt(byte x) {
+        return ((int) x) & 0xff;
+    }
+
+    /**
+     * Converts the argument to a {@code long} by an unsigned
+     * conversion.  In an unsigned conversion to a {@code long}, the
+     * high-order 56 bits of the {@code long} are zero and the
+     * low-order 8 bits are equal to the bits of the {@code byte} argument.
+     *
+     * Consequently, zero and positive {@code byte} values are mapped
+     * to a numerically equal {@code long} value and negative {@code
+     * byte} values are mapped to a {@code long} value equal to the
+     * input plus 2<sup>8</sup>.
+     *
+     * @param  x the value to convert to an unsigned {@code long}
+     * @return the argument converted to {@code long} by an unsigned
+     *         conversion
+     * @since 1.8
+     */
+    public static long toUnsignedLong(byte x) {
+        return ((long) x) & 0xffL;
+    }
+
+
+    /**
+     * The number of bits used to represent a {@code byte} value in two's
+     * complement binary form.
+     *
+     * @since 1.5
+     */
+    public static final int SIZE = 8;
+
+    /**
+     * The number of bytes used to represent a {@code byte} value in two's
+     * complement binary form.
+     *
+     * @since 1.8
+     */
+    public static final int BYTES = SIZE / Byte.SIZE;
+
+    /** use serialVersionUID from JDK 1.1. for interoperability */
+    private static final long serialVersionUID = -7183698231559129828L;
+}

jdkSrc/jdk8/java/lang/CharSequence.java

@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2000, 2013, 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.util.NoSuchElementException;
+import java.util.PrimitiveIterator;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.IntConsumer;
+import java.util.stream.IntStream;
+import java.util.stream.StreamSupport;
+
+/**
+ * A <tt>CharSequence</tt> is a readable sequence of <code>char</code> values. This
+ * interface provides uniform, read-only access to many different kinds of
+ * <code>char</code> sequences.
+ * A <code>char</code> value represents a character in the <i>Basic
+ * Multilingual Plane (BMP)</i> or a surrogate. Refer to <a
+ * href="Character.html#unicode">Unicode Character Representation</a> for details.
+ *
+ * <p> This interface does not refine the general contracts of the {@link
+ * java.lang.Object#equals(java.lang.Object) equals} and {@link
+ * java.lang.Object#hashCode() hashCode} methods.  The result of comparing two
+ * objects that implement <tt>CharSequence</tt> is therefore, in general,
+ * undefined.  Each object may be implemented by a different class, and there
+ * is no guarantee that each class will be capable of testing its instances
+ * for equality with those of the other.  It is therefore inappropriate to use
+ * arbitrary <tt>CharSequence</tt> instances as elements in a set or as keys in
+ * a map. </p>
+ *
+ * @author Mike McCloskey
+ * @since 1.4
+ * @spec JSR-51
+ */
+
+public interface CharSequence {
+
+    /**
+     * Returns the length of this character sequence.  The length is the number
+     * of 16-bit <code>char</code>s in the sequence.
+     *
+     * @return  the number of <code>char</code>s in this sequence
+     */
+    int length();
+
+    /**
+     * Returns the <code>char</code> value at the specified index.  An index ranges from zero
+     * to <tt>length() - 1</tt>.  The first <code>char</code> value of the sequence is at
+     * index zero, the next at index one, and so on, as for array
+     * indexing.
+     *
+     * <p>If the <code>char</code> value specified by the index is a
+     * <a href="{@docRoot}/java/lang/Character.html#unicode">surrogate</a>, the surrogate
+     * value is returned.
+     *
+     * @param   index   the index of the <code>char</code> value to be returned
+     *
+     * @return  the specified <code>char</code> value
+     *
+     * @throws  IndexOutOfBoundsException
+     *          if the <tt>index</tt> argument is negative or not less than
+     *          <tt>length()</tt>
+     */
+    char charAt(int index);
+
+    /**
+     * Returns a <code>CharSequence</code> that is a subsequence of this sequence.
+     * The subsequence starts with the <code>char</code> value at the specified index and
+     * ends with the <code>char</code> value at index <tt>end - 1</tt>.  The length
+     * (in <code>char</code>s) of the
+     * returned sequence is <tt>end - start</tt>, so if <tt>start == end</tt>
+     * then an empty sequence is returned.
+     *
+     * @param   start   the start index, inclusive
+     * @param   end     the end index, exclusive
+     *
+     * @return  the specified subsequence
+     *
+     * @throws  IndexOutOfBoundsException
+     *          if <tt>start</tt> or <tt>end</tt> are negative,
+     *          if <tt>end</tt> is greater than <tt>length()</tt>,
+     *          or if <tt>start</tt> is greater than <tt>end</tt>
+     */
+    CharSequence subSequence(int start, int end);
+
+    /**
+     * Returns a string containing the characters in this sequence in the same
+     * order as this sequence.  The length of the string will be the length of
+     * this sequence.
+     *
+     * @return  a string consisting of exactly this sequence of characters
+     */
+    public String toString();
+
+    /**
+     * Returns a stream of {@code int} zero-extending the {@code char} values
+     * from this sequence.  Any char which maps to a <a
+     * href="{@docRoot}/java/lang/Character.html#unicode">surrogate code
+     * point</a> is passed through uninterpreted.
+     *
+     * <p>If the sequence is mutated while the stream is being read, the
+     * result is undefined.
+     *
+     * @return an IntStream of char values from this sequence
+     * @since 1.8
+     */
+    public default IntStream chars() {
+        class CharIterator implements PrimitiveIterator.OfInt {
+            int cur = 0;
+
+            public boolean hasNext() {
+                return cur < length();
+            }
+
+            public int nextInt() {
+                if (hasNext()) {
+                    return charAt(cur++);
+                } else {
+                    throw new NoSuchElementException();
+                }
+            }
+
+            @Override
+            public void forEachRemaining(IntConsumer block) {
+                for (; cur < length(); cur++) {
+                    block.accept(charAt(cur));
+                }
+            }
+        }
+
+        return StreamSupport.intStream(() ->
+                Spliterators.spliterator(
+                        new CharIterator(),
+                        length(),
+                        Spliterator.ORDERED),
+                Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
+                false);
+    }
+
+    /**
+     * Returns a stream of code point values from this sequence.  Any surrogate
+     * pairs encountered in the sequence are combined as if by {@linkplain
+     * Character#toCodePoint Character.toCodePoint} and the result is passed
+     * to the stream. Any other code units, including ordinary BMP characters,
+     * unpaired surrogates, and undefined code units, are zero-extended to
+     * {@code int} values which are then passed to the stream.
+     *
+     * <p>If the sequence is mutated while the stream is being read, the result
+     * is undefined.
+     *
+     * @return an IntStream of Unicode code points from this sequence
+     * @since 1.8
+     */
+    public default IntStream codePoints() {
+        class CodePointIterator implements PrimitiveIterator.OfInt {
+            int cur = 0;
+
+            @Override
+            public void forEachRemaining(IntConsumer block) {
+                final int length = length();
+                int i = cur;
+                try {
+                    while (i < length) {
+                        char c1 = charAt(i++);
+                        if (!Character.isHighSurrogate(c1) || i >= length) {
+                            block.accept(c1);
+                        } else {
+                            char c2 = charAt(i);
+                            if (Character.isLowSurrogate(c2)) {
+                                i++;
+                                block.accept(Character.toCodePoint(c1, c2));
+                            } else {
+                                block.accept(c1);
+                            }
+                        }
+                    }
+                } finally {
+                    cur = i;
+                }
+            }
+
+            public boolean hasNext() {
+                return cur < length();
+            }
+
+            public int nextInt() {
+                final int length = length();
+
+                if (cur >= length) {
+                    throw new NoSuchElementException();
+                }
+                char c1 = charAt(cur++);
+                if (Character.isHighSurrogate(c1) && cur < length) {
+                    char c2 = charAt(cur);
+                    if (Character.isLowSurrogate(c2)) {
+                        cur++;
+                        return Character.toCodePoint(c1, c2);
+                    }
+                }
+                return c1;
+            }
+        }
+
+        return StreamSupport.intStream(() ->
+                Spliterators.spliteratorUnknownSize(
+                        new CodePointIterator(),
+                        Spliterator.ORDERED),
+                Spliterator.ORDERED,
+                false);
+    }
+}

jdkSrc/jdk8/java/lang/CharacterData.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2006, 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;
+
+abstract class CharacterData {
+    abstract int getProperties(int ch);
+    abstract int getType(int ch);
+    abstract boolean isWhitespace(int ch);
+    abstract boolean isMirrored(int ch);
+    abstract boolean isJavaIdentifierStart(int ch);
+    abstract boolean isJavaIdentifierPart(int ch);
+    abstract boolean isUnicodeIdentifierStart(int ch);
+    abstract boolean isUnicodeIdentifierPart(int ch);
+    abstract boolean isIdentifierIgnorable(int ch);
+    abstract int toLowerCase(int ch);
+    abstract int toUpperCase(int ch);
+    abstract int toTitleCase(int ch);
+    abstract int digit(int ch, int radix);
+    abstract int getNumericValue(int ch);
+    abstract byte getDirectionality(int ch);
+
+    //need to implement for JSR204
+    int toUpperCaseEx(int ch) {
+        return toUpperCase(ch);
+    }
+
+    char[] toUpperCaseCharArray(int ch) {
+        return null;
+    }
+
+    boolean isOtherLowercase(int ch) {
+        return false;
+    }
+
+    boolean isOtherUppercase(int ch) {
+        return false;
+    }
+
+    boolean isOtherAlphabetic(int ch) {
+        return false;
+    }
+
+    boolean isIdeographic(int ch) {
+        return false;
+    }
+
+    // Character <= 0xff (basic latin) is handled by internal fast-path
+    // to avoid initializing large tables.
+    // Note: performance of this "fast-path" code may be sub-optimal
+    // in negative cases for some accessors due to complicated ranges.
+    // Should revisit after optimization of table initialization.
+
+    static final CharacterData of(int ch) {
+        if (ch >>> 8 == 0) {     // fast-path
+            return CharacterDataLatin1.instance;
+        } else {
+            switch(ch >>> 16) {  //plane 00-16
+            case(0):
+                return CharacterData00.instance;
+            case(1):
+                return CharacterData01.instance;
+            case(2):
+                return CharacterData02.instance;
+            case(14):
+                return CharacterData0E.instance;
+            case(15):   // Private Use
+            case(16):   // Private Use
+                return CharacterDataPrivateUse.instance;
+            default:
+                return CharacterDataUndefined.instance;
+            }
+        }
+    }
+}

jdkSrc/jdk8/java/lang/CharacterData01.java

@@ -0,0 +1,674 @@
+// This file was generated AUTOMATICALLY from a template file Thu Jul 10 21:34:13 UTC 2025
+/*
+ * Copyright (c) 2003, 2013, 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;
+
+/** The CharacterData class encapsulates the large tables once found in
+ *  java.lang.Character. 
+ */
+
+class CharacterData01 extends CharacterData {
+    /* The character properties are currently encoded into 32 bits in the following manner:
+        1 bit   mirrored property
+        4 bits  directionality property
+        9 bits  signed offset used for converting case
+        1 bit   if 1, adding the signed offset converts the character to lowercase
+        1 bit   if 1, subtracting the signed offset converts the character to uppercase
+        1 bit   if 1, this character has a titlecase equivalent (possibly itself)
+        3 bits  0  may not be part of an identifier
+                1  ignorable control; may continue a Unicode identifier or Java identifier
+                2  may continue a Java identifier but not a Unicode identifier (unused)
+                3  may continue a Unicode identifier or Java identifier
+                4  is a Java whitespace character
+                5  may start or continue a Java identifier;
+                   may continue but not start a Unicode identifier (underscores)
+                6  may start or continue a Java identifier but not a Unicode identifier ($)
+                7  may start or continue a Unicode identifier or Java identifier
+                Thus:
+                   5, 6, 7 may start a Java identifier
+                   1, 2, 3, 5, 6, 7 may continue a Java identifier
+                   7 may start a Unicode identifier
+                   1, 3, 5, 7 may continue a Unicode identifier
+                   1 is ignorable within an identifier
+                   4 is Java whitespace
+        2 bits  0  this character has no numeric property
+                1  adding the digit offset to the character code and then
+                   masking with 0x1F will produce the desired numeric value
+                2  this character has a "strange" numeric value
+                3  a Java supradecimal digit: adding the digit offset to the
+                   character code, then masking with 0x1F, then adding 10
+                   will produce the desired numeric value
+        5 bits  digit offset
+        5 bits  character type
+
+        The encoding of character properties is subject to change at any time.
+     */
+
+    int getProperties(int ch) {
+        char offset = (char)ch;
+        int props = A[(Y[(X[offset>>5]<<4)|((offset>>1)&0xF)]<<1)|(offset&0x1)];
+        return props;
+    }
+
+    int getPropertiesEx(int ch) {
+        char offset = (char)ch;
+        int props = B[(Y[(X[offset>>5]<<4)|((offset>>1)&0xF)]<<1)|(offset&0x1)];
+        return props;
+    }
+
+    int getType(int ch) {
+        int props = getProperties(ch);
+        return (props & 0x1F);
+    }
+
+    boolean isOtherLowercase(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0001) != 0;
+    }
+
+    boolean isOtherUppercase(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0002) != 0;
+    }
+ 
+    boolean isOtherAlphabetic(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0004) != 0;
+    }
+
+    boolean isIdeographic(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0010) != 0;
+    }
+
+    boolean isJavaIdentifierStart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) >= 0x00005000);
+    }
+
+    boolean isJavaIdentifierPart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00003000) != 0);
+    }
+
+    boolean isUnicodeIdentifierStart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) == 0x00007000);
+    }
+
+    boolean isUnicodeIdentifierPart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00001000) != 0);
+    }
+
+    boolean isIdentifierIgnorable(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) == 0x00001000);
+    }
+
+    int toLowerCase(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if ((val & 0x00020000) != 0) {
+            int offset = val << 5 >> (5+18);
+            mapChar = ch + offset;
+        }
+        return  mapChar;
+    }
+
+    int toUpperCase(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if ((val & 0x00010000) != 0) {
+            int offset = val  << 5 >> (5+18);
+            mapChar =  ch - offset;
+        }
+        return  mapChar;
+    }
+
+    int toTitleCase(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if ((val & 0x00008000) != 0) {
+            // There is a titlecase equivalent.  Perform further checks:
+            if ((val & 0x00010000) == 0) {
+                // The character does not have an uppercase equivalent, so it must
+                // already be uppercase; so add 1 to get the titlecase form.
+                mapChar = ch + 1;
+            }
+            else if ((val & 0x00020000) == 0) {
+                // The character does not have a lowercase equivalent, so it must
+                // already be lowercase; so subtract 1 to get the titlecase form.
+                mapChar = ch - 1;
+            }
+            // else {
+            // The character has both an uppercase equivalent and a lowercase
+            // equivalent, so it must itself be a titlecase form; return it.
+            // return ch;
+            //}
+        }
+        else if ((val & 0x00010000) != 0) {
+            // This character has no titlecase equivalent but it does have an
+            // uppercase equivalent, so use that (subtract the signed case offset).
+            mapChar = toUpperCase(ch);
+        }
+        return  mapChar;
+    }
+
+    int digit(int ch, int radix) {
+        int value = -1;
+        if (radix >= Character.MIN_RADIX && radix <= Character.MAX_RADIX) {
+            int val = getProperties(ch);
+            int kind = val & 0x1F;
+            if (kind == Character.DECIMAL_DIGIT_NUMBER) {
+                value = ch + ((val & 0x3E0) >> 5) & 0x1F;
+            }
+            else if ((val & 0xC00) == 0x00000C00) {
+                // Java supradecimal digit
+                value = (ch + ((val & 0x3E0) >> 5) & 0x1F) + 10;
+            }
+        }
+        return (value < radix) ? value : -1;
+    }
+
+    int getNumericValue(int ch) {
+        int val = getProperties(ch);
+        int retval = -1;
+
+        switch (val & 0xC00) {
+        default: // cannot occur
+        case (0x00000000):         // not numeric
+            retval = -1;
+            break;
+        case (0x00000400):              // simple numeric
+            retval = ch + ((val & 0x3E0) >> 5) & 0x1F;
+            break;
+        case (0x00000800)      :       // "strange" numeric
+            switch(ch) {
+            case 0x10113: retval = 40; break;      // AEGEAN NUMBER FORTY
+            case 0x10114: retval = 50; break;      // AEGEAN NUMBER FIFTY
+            case 0x10115: retval = 60; break;      // AEGEAN NUMBER SIXTY
+            case 0x10116: retval = 70; break;      // AEGEAN NUMBER SEVENTY
+            case 0x10117: retval = 80; break;      // AEGEAN NUMBER EIGHTY
+            case 0x10118: retval = 90; break;      // AEGEAN NUMBER NINETY
+            case 0x10119: retval = 100; break;     // AEGEAN NUMBER ONE HUNDRED
+            case 0x1011A: retval = 200; break;     // AEGEAN NUMBER TWO HUNDRED
+            case 0x1011B: retval = 300; break;     // AEGEAN NUMBER THREE HUNDRED
+            case 0x1011C: retval = 400; break;     // AEGEAN NUMBER FOUR HUNDRED
+            case 0x1011D: retval = 500; break;     // AEGEAN NUMBER FIVE HUNDRED
+            case 0x1011E: retval = 600; break;     // AEGEAN NUMBER SIX HUNDRED
+            case 0x1011F: retval = 700; break;     // AEGEAN NUMBER SEVEN HUNDRED
+            case 0x10120: retval = 800; break;     // AEGEAN NUMBER EIGHT HUNDRED
+            case 0x10121: retval = 900; break;     // AEGEAN NUMBER NINE HUNDRED
+            case 0x10122: retval = 1000; break;    // AEGEAN NUMBER ONE THOUSAND
+            case 0x10123: retval = 2000; break;    // AEGEAN NUMBER TWO THOUSAND
+            case 0x10124: retval = 3000; break;    // AEGEAN NUMBER THREE THOUSAND
+            case 0x10125: retval = 4000; break;    // AEGEAN NUMBER FOUR THOUSAND
+            case 0x10126: retval = 5000; break;    // AEGEAN NUMBER FIVE THOUSAND
+            case 0x10127: retval = 6000; break;    // AEGEAN NUMBER SIX THOUSAND
+            case 0x10128: retval = 7000; break;    // AEGEAN NUMBER SEVEN THOUSAND
+            case 0x10129: retval = 8000; break;    // AEGEAN NUMBER EIGHT THOUSAND
+            case 0x1012A: retval = 9000; break;    // AEGEAN NUMBER NINE THOUSAND
+            case 0x1012B: retval = 10000; break;   // AEGEAN NUMBER TEN THOUSAND
+            case 0x1012C: retval = 20000; break;   // AEGEAN NUMBER TWENTY THOUSAND
+            case 0x1012D: retval = 30000; break;   // AEGEAN NUMBER THIRTY THOUSAND
+            case 0x1012E: retval = 40000; break;   // AEGEAN NUMBER FORTY THOUSAND
+            case 0x1012F: retval = 50000; break;   // AEGEAN NUMBER FIFTY THOUSAND
+            case 0x10130: retval = 60000; break;   // AEGEAN NUMBER SIXTY THOUSAND
+            case 0x10131: retval = 70000; break;   // AEGEAN NUMBER SEVENTY THOUSAND
+            case 0x10132: retval = 80000; break;   // AEGEAN NUMBER EIGHTY THOUSAND
+            case 0x10133: retval = 90000; break;   // AEGEAN NUMBER NINETY THOUSAND
+            case 0x10323: retval = 50; break;      // OLD ITALIC NUMERAL FIFTY
+
+            case 0x010144: retval = 50; break;     // ACROPHONIC ATTIC FIFTY
+            case 0x010145: retval = 500; break;    // ACROPHONIC ATTIC FIVE HUNDRED
+            case 0x010146: retval = 5000; break;   // ACROPHONIC ATTIC FIVE THOUSAND
+            case 0x010147: retval = 50000; break;  // ACROPHONIC ATTIC FIFTY THOUSAND
+            case 0x01014A: retval = 50; break;     // ACROPHONIC ATTIC FIFTY TALENTS
+            case 0x01014B: retval = 100; break;    // ACROPHONIC ATTIC ONE HUNDRED TALENTS
+            case 0x01014C: retval = 500; break;    // ACROPHONIC ATTIC FIVE HUNDRED TALENTS
+            case 0x01014D: retval = 1000; break;   // ACROPHONIC ATTIC ONE THOUSAND TALENTS
+            case 0x01014E: retval = 5000; break;   // ACROPHONIC ATTIC FIVE THOUSAND TALENTS
+            case 0x010151: retval = 50; break;     // ACROPHONIC ATTIC FIFTY STATERS
+            case 0x010152: retval = 100; break;    // ACROPHONIC ATTIC ONE HUNDRED STATERS
+            case 0x010153: retval = 500; break;    // ACROPHONIC ATTIC FIVE HUNDRED STATERS
+            case 0x010154: retval = 1000; break;   // ACROPHONIC ATTIC ONE THOUSAND STATERS
+            case 0x010155: retval = 10000; break;  // ACROPHONIC ATTIC TEN THOUSAND STATERS
+            case 0x010156: retval = 50000; break;  // ACROPHONIC ATTIC FIFTY THOUSAND STATERS
+            case 0x010166: retval = 50; break;     // ACROPHONIC TROEZENIAN FIFTY
+            case 0x010167: retval = 50; break;     // ACROPHONIC TROEZENIAN FIFTY ALTERNATE FORM
+            case 0x010168: retval = 50; break;     // ACROPHONIC HERMIONIAN FIFTY
+            case 0x010169: retval = 50; break;     // ACROPHONIC THESPIAN FIFTY
+            case 0x01016A: retval = 100; break;    // ACROPHONIC THESPIAN ONE HUNDRED
+            case 0x01016B: retval = 300; break;    // ACROPHONIC THESPIAN THREE HUNDRED
+            case 0x01016C: retval = 500; break;    // ACROPHONIC EPIDAUREAN FIVE HUNDRED
+            case 0x01016D: retval = 500; break;    // ACROPHONIC TROEZENIAN FIVE HUNDRED
+            case 0x01016E: retval = 500; break;    // ACROPHONIC THESPIAN FIVE HUNDRED
+            case 0x01016F: retval = 500; break;    // ACROPHONIC CARYSTIAN FIVE HUNDRED
+            case 0x010170: retval = 500; break;    // ACROPHONIC NAXIAN FIVE HUNDRED
+            case 0x010171: retval = 1000; break;   // ACROPHONIC THESPIAN ONE THOUSAND
+            case 0x010172: retval = 5000; break;   // ACROPHONIC THESPIAN FIVE THOUSAND
+            case 0x010174: retval = 50; break;     // ACROPHONIC STRATIAN FIFTY MNAS
+            case 0x010341: retval = 90; break;     // GOTHIC LETTER NINETY
+            case 0x01034A: retval = 900; break;    // GOTHIC LETTER NINE HUNDRED
+            case 0x0103D5: retval = 100; break;    // OLD PERSIAN NUMBER HUNDRED
+            case 0x01085D: retval = 100; break;    // IMPERIAL ARAMAIC NUMBER ONE HUNDRED
+            case 0x01085E: retval = 1000; break;   // IMPERIAL ARAMAIC NUMBER ONE THOUSAND
+            case 0x01085F: retval = 10000; break;  // IMPERIAL ARAMAIC NUMBER TEN THOUSAND
+            case 0x010919: retval = 100; break;    // PHOENICIAN NUMBER ONE HUNDRED
+            case 0x010A46: retval = 100; break;    // KHAROSHTHI NUMBER ONE HUNDRED
+            case 0x010A47: retval = 1000; break;   // KHAROSHTHI NUMBER ONE THOUSAND
+            case 0x010A7E: retval = 50; break;     // OLD SOUTH ARABIAN NUMBER FIFTY
+            case 0x010B5E: retval = 100; break;    // INSCRIPTIONAL PARTHIAN NUMBER ONE HUNDRED
+            case 0x010B5F: retval = 1000; break;   // INSCRIPTIONAL PARTHIAN NUMBER ONE THOUSAND
+            case 0x010B7E: retval = 100; break;    // INSCRIPTIONAL PAHLAVI NUMBER ONE HUNDRED
+            case 0x010B7F: retval = 1000; break;   // INSCRIPTIONAL PAHLAVI NUMBER ONE THOUSAND
+            case 0x010E6C: retval = 40; break;     // RUMI NUMBER FORTY
+            case 0x010E6D: retval = 50; break;     // RUMI NUMBER FIFTY
+            case 0x010E6E: retval = 60; break;     // RUMI NUMBER SIXTY
+            case 0x010E6F: retval = 70; break;     // RUMI NUMBER SEVENTY
+            case 0x010E70: retval = 80; break;     // RUMI NUMBER EIGHTY
+            case 0x010E71: retval = 90; break;     // RUMI NUMBER NINETY
+            case 0x010E72: retval = 100; break;    // RUMI NUMBER ONE HUNDRED
+            case 0x010E73: retval = 200; break;    // RUMI NUMBER TWO HUNDRED
+            case 0x010E74: retval = 300; break;    // RUMI NUMBER THREE HUNDRED
+            case 0x010E75: retval = 400; break;    // RUMI NUMBER FOUR HUNDRED
+            case 0x010E76: retval = 500; break;    // RUMI NUMBER FIVE HUNDRED
+            case 0x010E77: retval = 600; break;    // RUMI NUMBER SIX HUNDRED
+            case 0x010E78: retval = 700; break;    // RUMI NUMBER SEVEN HUNDRED
+            case 0x010E79: retval = 800; break;    // RUMI NUMBER EIGHT HUNDRED
+            case 0x010E7A: retval = 900; break;    // RUMI NUMBER NINE HUNDRED
+            case 0x01105E: retval = 40; break;     // BRAHMI NUMBER FORTY
+            case 0x01105F: retval = 50; break;     // BRAHMI NUMBER FIFTY
+            case 0x011060: retval = 60; break;     // BRAHMI NUMBER SIXTY
+            case 0x011061: retval = 70; break;     // BRAHMI NUMBER SEVENTY
+            case 0x011062: retval = 80; break;     // BRAHMI NUMBER EIGHTY
+            case 0x011063: retval = 90; break;     // BRAHMI NUMBER NINETY
+            case 0x011064: retval = 100; break;    // BRAHMI NUMBER ONE HUNDRED
+            case 0x011065: retval = 1000; break;   // BRAHMI NUMBER ONE THOUSAND
+            case 0x012432: retval = 216000; break;   // CUNEIFORM NUMERIC SIGN SHAR2 TIMES GAL PLUS DISH
+            case 0x012433: retval = 432000; break;   // CUNEIFORM NUMERIC SIGN SHAR2 TIMES GAL PLUS MIN
+            case 0x01D36C: retval = 40; break;     // COUNTING ROD TENS DIGIT FOUR
+            case 0x01D36D: retval = 50; break;     // COUNTING ROD TENS DIGIT FIVE
+            case 0x01D36E: retval = 60; break;     // COUNTING ROD TENS DIGIT SIX
+            case 0x01D36F: retval = 70; break;     // COUNTING ROD TENS DIGIT SEVEN
+            case 0x01D370: retval = 80; break;     // COUNTING ROD TENS DIGIT EIGHT
+            case 0x01D371: retval = 90; break;     // COUNTING ROD TENS DIGIT NINE
+            default: retval = -2; break;
+            }
+            
+            break;
+        case (0x00000C00):           // Java supradecimal
+            retval = (ch + ((val & 0x3E0) >> 5) & 0x1F) + 10;
+            break;
+        }
+        return retval;
+    }
+
+    boolean isWhitespace(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) == 0x00004000);
+    }
+
+    byte getDirectionality(int ch) {
+        int val = getProperties(ch);
+        byte directionality = (byte)((val & 0x78000000) >> 27);
+        if (directionality == 0xF ) {
+            directionality = Character.DIRECTIONALITY_UNDEFINED;
+        }
+        return directionality;
+    }
+
+    boolean isMirrored(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x80000000) != 0);
+    }
+
+    static final CharacterData instance = new CharacterData01();
+    private CharacterData01() {};
+
+    // The following tables and code generated using:
+  // java GenerateCharacter -plane 1 -template c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/characterdata/CharacterData01.java.template -spec c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/UnicodeData.txt -specialcasing c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/SpecialCasing.txt -proplist c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/PropList.txt -o c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/build/windows-x86_64-normal-server-release/jdk/gensrc/java/lang/CharacterData01.java -string -usecharforbyte 11 4 1
+  // The X table has 2048 entries for a total of 4096 bytes.
+
+  static final char X[] = (
+    "\000\001\002\003\004\004\004\005\006\007\010\011\012\003\013\014\003\003\003"+
+    "\003\015\004\016\003\017\020\021\003\022\004\023\003\024\025\026\004\027\030"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\031\032\033\003\003\003\003\003\034\035\003\003"+
+    "\036\037\003\003\040\041\042\043\003\003\003\003\036\044\045\046\003\003\003"+
+    "\003\036\036\047\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\050\003\003\003\003\003\003\003\003\003\003\003\003\051\052\053\054\055"+
+    "\056\057\060\061\062\063\003\064\065\066\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\004\067\030\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\004\004\004\004\004\004\004\004\004\004"+
+    "\004\004\004\004\004\004\004\004\004\004\004\004\004\004\004\004\004\070\003"+
+    "\003\003\003\071\072\073\074\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\004\004\004\004\004\004\004\004\004\004\004\004\004\004\004"+
+    "\004\004\004\004\004\004\004\004\004\004\004\004\004\004\004\004\004\004\070"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\004\004\004\004"+
+    "\004\004\004\004\004\004\004\004\004\004\004\004\004\075\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\004\004\076\077\100"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\101\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\102\102\102\102\102\102\102\103"+
+    "\102\104\102\105\106\107\110\003\111\111\112\003\003\003\003\003\111\111\113"+
+    "\114\003\003\003\003\115\116\117\120\121\122\123\124\125\126\127\130\131\115"+
+    "\116\132\120\133\134\135\124\136\137\140\141\142\143\144\145\146\147\150\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\151\152\153\154\155\156\003\157\003\003\003\003\003\003\003"+
+    "\003\111\160\111\111\161\162\163\003\164\165\102\166\167\003\003\170\171\167"+
+    "\172\003\003\003\003\003\111\173\111\174\161\111\175\176\111\177\200\111\111"+
+    "\111\111\201\111\202\203\204\003\003\003\205\111\111\206\003\111\111\207\003"+
+    "\111\111\111\161\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\003\003").toCharArray();
+
+  // The Y table has 2176 entries for a total of 4352 bytes.
+
+  static final char Y[] = (
+    "\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\002\000\000\000\000\000\000\000\000\000\002\000\001\000\000\000\000\000\000"+
+    "\000\003\000\000\000\000\000\000\000\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\003"+
+    "\003\004\005\003\006\007\007\007\007\010\011\012\012\012\012\012\012\012\012"+
+    "\012\012\012\012\012\012\012\012\003\013\014\014\014\014\015\016\015\015\017"+
+    "\015\015\020\021\015\015\022\023\024\025\026\027\030\031\015\015\015\015\015"+
+    "\015\032\033\034\035\036\036\036\036\036\036\036\036\037\003\003\036\036\036"+
+    "\036\036\036\003\003\003\003\003\003\003\003\003\003\014\014\014\014\014\014"+
+    "\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\040\003\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\002\003\000\000\000\000"+
+    "\000\000\000\000\002\003\003\003\003\003\003\003\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\002\041\042\003\003\003\003\003\003\000\000"+
+    "\000\000\000\000\000\000\043\000\000\000\000\044\003\003\003\003\003\003\003"+
+    "\003\003\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\045"+
+    "\000\000\003\003\000\000\000\000\046\047\050\003\003\003\003\003\051\051\051"+
+    "\051\051\051\051\051\051\051\051\051\051\051\051\051\051\051\051\051\052\052"+
+    "\052\052\052\052\052\052\052\052\052\052\052\052\052\052\052\052\052\052\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\003\053\053\053\053\053\003\003\003\003\003\003\003\003\003\003"+
+    "\003\054\054\054\003\055\054\054\054\054\054\054\054\054\054\054\054\054\054"+
+    "\054\054\054\054\054\054\054\054\054\056\055\003\055\056\054\054\054\054\054"+
+    "\054\054\054\054\054\054\057\060\061\062\063\054\054\054\054\054\054\054\054"+
+    "\054\054\054\064\065\066\003\067\054\054\054\054\054\054\054\054\054\054\054"+
+    "\054\054\003\003\057\054\054\054\054\054\054\054\054\054\054\054\054\054\054"+
+    "\054\054\054\054\054\054\054\054\054\054\054\054\054\054\003\003\003\054\070"+
+    "\071\072\073\003\003\071\071\054\054\056\054\056\054\054\054\054\054\054\054"+
+    "\054\054\054\054\054\054\003\003\074\075\003\076\077\077\100\063\003\003\003"+
+    "\003\101\101\101\101\102\003\003\003\054\054\054\054\054\054\054\054\054\054"+
+    "\054\054\054\054\103\104\054\054\054\054\054\054\054\054\054\054\054\003\067"+
+    "\105\105\105\054\054\054\054\054\054\054\054\054\054\054\003\060\060\106\063"+
+    "\054\054\054\054\054\054\054\054\054\055\003\003\060\060\106\063\054\054\054"+
+    "\054\055\003\003\003\003\003\003\003\003\003\003\003\107\107\107\107\107\110"+
+    "\111\111\111\111\111\111\111\111\111\112\113\114\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\071\071\071\071\071\071\071\115\116\116\116\003\003\117\117\117\117\117\120"+
+    "\034\034\034\034\121\121\121\121\121\003\003\003\003\003\003\003\003\074\114"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\122\113\071\123\124\115\125\116\116\003\003\003\003\003\003\003"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\002\003\003\003\126\126\126"+
+    "\126\126\003\003\003\071\127\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\130\071\071\113\071\071\131\075\132\132\132\132\132\116"+
+    "\116\003\003\003\003\003\003\003\003\003\003\003\003\003\003\071\114\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\133\122\071\071\071\071\123\134\000\135\116\005\003\003\003\126\126"+
+    "\126\126\126\003\003\003\000\000\000\000\000\130\113\122\071\071\071\136\003"+
+    "\003\003\003\000\000\000\000\000\000\000\002\003\003\003\003\003\003\003\003"+
+    "\137\137\137\137\140\140\140\141\142\142\143\144\144\144\144\145\145\146\147"+
+    "\150\150\150\142\151\152\153\154\155\144\156\157\160\161\162\163\164\165\166"+
+    "\166\167\170\171\172\153\173\153\153\153\153\044\003\003\003\003\003\003\116"+
+    "\116\003\003\003\003\003\003\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\002\003\003\003\000\000\002\003\003\003\003\003\133\122\122\122\122\122\122"+
+    "\122\122\122\122\122\122\122\122\122\122\122\122\122\122\122\122\174\003\003"+
+    "\003\003\003\003\003\076\074\175\176\176\176\176\176\176\000\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\014\014\014\014\014\014\014\014"+
+    "\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014"+
+    "\003\003\003\003\003\014\014\014\177\013\014\014\014\014\014\014\014\014\014"+
+    "\014\014\014\014\200\136\074\014\200\201\201\202\203\203\203\204\074\074\074"+
+    "\205\040\074\074\074\014\014\014\014\014\014\014\014\014\014\014\014\014\014"+
+    "\014\074\074\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014"+
+    "\014\014\014\014\014\014\014\014\003\036\036\036\036\036\036\036\036\036\036"+
+    "\036\036\036\036\036\036\036\074\206\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\036\036\036\036\036\036\036\036\036\036\036\207\003\003\003\003"+
+    "\210\210\210\210\210\211\012\012\012\003\003\003\003\003\003\003\212\212\212"+
+    "\212\212\212\212\212\212\212\212\212\212\213\213\213\213\213\213\213\213\213"+
+    "\213\213\213\213\212\212\212\212\212\212\212\212\212\212\212\212\212\213\213"+
+    "\213\214\213\213\213\213\213\213\213\213\213\212\212\212\212\212\212\212\212"+
+    "\212\212\212\212\212\213\213\213\213\213\213\213\213\213\213\213\213\213\215"+
+    "\212\003\215\216\215\216\212\215\212\212\212\212\213\213\217\217\213\213\213"+
+    "\217\213\213\213\213\213\212\212\212\212\212\212\212\212\212\212\212\212\212"+
+    "\213\213\213\213\213\213\213\213\213\213\213\213\213\212\216\212\215\216\212"+
+    "\212\212\215\212\212\212\215\213\213\213\213\213\213\213\213\213\213\213\213"+
+    "\213\212\216\212\215\212\212\215\215\003\212\212\212\215\213\213\213\213\213"+
+    "\213\213\213\213\213\213\213\213\212\212\212\212\212\212\212\212\212\212\212"+
+    "\212\212\213\213\213\213\213\213\213\213\213\213\213\213\213\212\212\212\212"+
+    "\212\212\212\213\213\213\213\213\213\213\213\213\212\213\213\213\213\213\213"+
+    "\213\213\213\213\213\213\213\212\212\212\212\212\212\212\212\212\212\212\212"+
+    "\212\213\213\213\213\213\213\213\213\213\213\213\213\213\212\212\212\212\212"+
+    "\212\212\212\213\213\213\003\212\212\212\212\212\212\212\212\212\212\212\212"+
+    "\220\213\213\213\213\213\213\213\213\213\213\213\213\221\213\213\213\212\212"+
+    "\212\212\212\212\212\212\212\212\212\212\220\213\213\213\213\213\213\213\213"+
+    "\213\213\213\213\221\213\213\213\212\212\212\212\212\212\212\212\212\212\212"+
+    "\212\220\213\213\213\213\213\213\213\213\213\213\213\213\221\213\213\213\212"+
+    "\212\212\212\212\212\212\212\212\212\212\212\220\213\213\213\213\213\213\213"+
+    "\213\213\213\213\213\221\213\213\213\212\212\212\212\212\212\212\212\212\212"+
+    "\212\212\220\213\213\213\213\213\213\213\213\213\213\213\213\221\213\213\213"+
+    "\222\003\223\223\223\223\223\224\224\224\224\224\225\225\225\225\225\226\226"+
+    "\226\226\226\227\227\227\227\227\230\230\231\230\230\230\230\230\230\230\230"+
+    "\230\230\230\230\230\231\232\232\231\231\230\230\230\230\232\230\230\231\231"+
+    "\003\003\003\232\003\231\231\231\231\230\231\232\232\231\231\231\231\231\231"+
+    "\232\232\231\230\232\230\230\230\232\230\230\231\230\232\232\230\230\230\230"+
+    "\230\231\230\230\230\230\230\230\230\230\003\003\231\230\231\230\230\231\230"+
+    "\230\230\230\230\230\230\230\003\003\003\003\003\003\003\003\003\003\233\003"+
+    "\003\003\003\003\003\003\036\036\036\036\036\036\003\003\036\036\036\036\036"+
+    "\036\036\036\036\036\036\036\036\036\036\036\036\036\003\003\003\003\003\003"+
+    "\036\036\036\036\036\036\036\207\234\036\036\036\036\036\036\207\234\036\036"+
+    "\036\036\036\036\036\234\036\036\036\036\036\036\036\235\236\236\236\236\237"+
+    "\003\003\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\177\014"+
+    "\014\014\014\014\014\014\014\014\014\014\014\014\036\003\003\014\014\014\014"+
+    "\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\177\003"+
+    "\003\003\003\003\014\014\014\014\014\014\014\014\014\014\014\014\014\014\177"+
+    "\003\003\003\003\003\003\014\014\014\014\014\014\014\014\014\014\014\014\177"+
+    "\003\003\003\014\003\003\003\003\003\003\003\207\003\003\003\003\003\003\003"+
+    "\036\036\036\234\036\036\036\036\036\036\036\036\036\036\036\036\036\036\036"+
+    "\036\036\036\207\003\036\036\207\036\036\207\003\003\003\003\003\003\003\003"+
+    "\003\003\036\036\036\036\036\036\036\036\207\003\003\003\003\003\003\003\036"+
+    "\036\036\036\036\036\036\036\036\036\036\036\036\036\036\207\207\036\036\036"+
+    "\036\036\036\036\036\036\036\036\036\036\036\036\036\036\036\036\036\036\036"+
+    "\036\036\036\036\036\234\036\207\003\036\036\036\036\036\036\036\036\036\036"+
+    "\036\036\036\036\036\003\036\036\003\003\003\003\003\003\036\036\036\036\036"+
+    "\036\036\036\036\036\036\036\003\003\003\003\003\003\003\003\003\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003\003\003\003\234\036\036\207\003\234"+
+    "\036\036\036\036\036\003\003\003\003\003\003\003\003\036\036\036\003\003\003"+
+    "\003\003\003\003\003\003\003\003\003\003").toCharArray();
+
+  // The A table has 320 entries for a total of 1280 bytes.
+
+  static final int A[] = new int[320];
+  static final String A_DATA =
+    "\000\u7005\000\u7005\u7800\000\000\u7005\000\u7005\u7800\000\u7800\000\u7800"+
+    "\000\000\030\u6800\030\000\030\u7800\000\u7800\000\000\u074B\000\u074B\000"+
+    "\u074B\000\u074B\000\u046B\000\u058B\000\u080B\000\u080B\000\u080B\u7800\000"+
+    "\000\034\000\034\000\034\u6800\u780A\u6800\u780A\u6800\u77EA\u6800\u744A\u6800"+
+    "\u77AA\u6800\u742A\u6800\u780A\u6800\u76CA\u6800\u774A\u6800\u780A\u6800\u780A"+
+    "\u6800\u766A\u6800\u752A\u6800\u750A\u6800\u74EA\u6800\u74EA\u6800\u74CA\u6800"+
+    "\u74AA\u6800\u748A\u6800\u74CA\u6800\u754A\u6800\u752A\u6800\u750A\u6800\u74EA"+
+    "\u6800\u74CA\u6800\u772A\u6800\u780A\u6800\u764A\u6800\u780A\u6800\u080B\u6800"+
+    "\u080B\u6800\u080B\u6800\u080B\u6800\034\u6800\034\u6800\034\u6800\u06CB\u7800"+
+    "\000\000\034\u4000\u3006\000\u042B\000\u048B\000\u050B\000\u080B\000\u7005"+
+    "\000\u780A\000\u780A\u7800\000\u7800\000\000\030\000\030\000\u760A\000\u760A"+
+    "\000\u76EA\000\u740A\000\u780A\242\u7001\242\u7001\241\u7002\241\u7002\000"+
+    "\u3409\000\u3409\u0800\u7005\u0800\u7005\u0800\u7005\u7800\000\u7800\000\u0800"+
+    "\u7005\u7800\000\u0800\030\u0800\u052B\u0800\u052B\u0800\u052B\u0800\u05EB"+
+    "\u0800\u070B\u0800\u080B\u0800\u080B\u0800\u080B\u0800\u056B\u0800\u066B\u0800"+
+    "\u078B\u0800\u080B\u0800\u050B\u0800\u050B\u7800\000\u6800\030\u0800\u7005"+
+    "\u4000\u3006\u4000\u3006\u4000\u3006\u7800\000\u4000\u3006\u4000\u3006\u7800"+
+    "\000\u4000\u3006\u4000\u3006\u4000\u3006\u7800\000\u7800\000\u4000\u3006\u0800"+
+    "\u042B\u0800\u042B\u0800\u04CB\u0800\u05EB\u0800\030\u0800\030\u0800\030\u7800"+
+    "\000\u0800\u7005\u0800\u048B\u0800\u080B\u0800\030\u6800\030\u6800\030\u0800"+
+    "\u05CB\u0800\u06EB\u3000\u042B\u3000\u042B\u3000\u054B\u3000\u066B\u3000\u080B"+
+    "\u3000\u080B\u3000\u080B\u7800\000\000\u3008\u4000\u3006\000\u3008\000\u7005"+
+    "\u4000\u3006\000\030\000\030\000\030\u6800\u05EB\u6800\u05EB\u6800\u070B\u6800"+
+    "\u042B\000\u3749\000\u3749\000\u3008\000\u3008\u4000\u3006\000\u3008\000\u3008"+
+    "\u4000\u3006\000\030\000\u1010\000\u3609\000\u3609\u4000\u3006\000\u7005\000"+
+    "\u7005\u4000\u3006\u4000\u3006\u4000\u3006\000\u3549\000\u3549\000\u7005\000"+
+    "\u3008\000\u3008\000\u7005\000\u7005\000\030\000\u3008\u4000\u3006\000\u744A"+
+    "\000\u744A\000\u776A\000\u776A\000\u776A\000\u76AA\000\u76AA\000\u76AA\000"+
+    "\u76AA\000\u758A\000\u758A\000\u758A\000\u746A\000\u746A\000\u746A\000\u77EA"+
+    "\000\u77EA\000\u77CA\000\u77CA\000\u77CA\000\u76AA\000\u768A\000\u768A\000"+
+    "\u768A\000\u780A\000\u780A\000\u75AA\000\u75AA\000\u75AA\000\u758A\000\u752A"+
+    "\000\u750A\000\u750A\000\u74EA\000\u74CA\000\u74AA\000\u74CA\000\u74CA\000"+
+    "\u74AA\000\u748A\000\u748A\000\u746A\000\u746A\000\u744A\000\u742A\000\u740A"+
+    "\000\u770A\000\u770A\000\u770A\000\u764A\000\u764A\000\u764A\000\u764A\000"+
+    "\u762A\000\u762A\000\u760A\000\u752A\000\u752A\000\u3008\u7800\000\u4000\u3006"+
+    "\000\u7004\000\u7004\000\u7004\000\034\u7800\000\000\034\000\u3008\000\u3008"+
+    "\000\u3008\000\u3008\u4800\u1010\u4800\u1010\u4800\u1010\u4800\u1010\u4000"+
+    "\u3006\u4000\u3006\000\034\u4000\u3006\u6800\034\u6800\034\u7800\000\000\u042B"+
+    "\000\u042B\000\u054B\000\u066B\000\u7001\000\u7001\000\u7002\000\u7002\000"+
+    "\u7002\u7800\000\000\u7001\u7800\000\u7800\000\000\u7001\u7800\000\000\u7002"+
+    "\000\u7001\000\031\000\u7002\uE800\031\000\u7001\000\u7002\u1800\u3649\u1800"+
+    "\u3649\u1800\u3509\u1800\u3509\u1800\u37C9\u1800\u37C9\u1800\u3689\u1800\u3689"+
+    "\u1800\u3549\u1800\u3549\u1000\u7005\u1000\u7005\u7800\000\u1000\u7005\u1000"+
+    "\u7005\u7800\000\u6800\031\u6800\031\u7800\000\u6800\034\u1800\u040B\u1800"+
+    "\u07EB\u1800\u07EB\u1800\u07EB\u1800\u07EB\u7800\000";
+
+  // The B table has 320 entries for a total of 640 bytes.
+
+  static final char B[] = (
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004"+
+    "\004\004\000\004\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\004"+
+    "\004\000\000\000\000\000\000\000\000\000\000\000\004\004\004\004\004\000\000"+
+    "\000\000\000\004\000\000\004\004\000\000\000\000\004\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000").toCharArray();
+
+  // In all, the character property tables require 9728 bytes.
+
+    static {
+                { // THIS CODE WAS AUTOMATICALLY CREATED BY GenerateCharacter:
+            char[] data = A_DATA.toCharArray();
+            assert (data.length == (320 * 2));
+            int i = 0, j = 0;
+            while (i < (320 * 2)) {
+                int entry = data[i++] << 16;
+                A[j++] = entry | data[i++];
+            }
+        }
+
+    }        
+}

jdkSrc/jdk8/java/lang/CharacterData02.java

@@ -0,0 +1,402 @@
+// This file was generated AUTOMATICALLY from a template file Thu Jul 10 21:34:13 UTC 2025
+/*
+ * Copyright (c) 2003, 2013, 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;
+
+/** The CharacterData class encapsulates the large tables found in
+    Java.lang.Character. */
+
+class CharacterData02 extends CharacterData {
+    /* The character properties are currently encoded into 32 bits in the following manner:
+        1 bit   mirrored property
+        4 bits  directionality property
+        9 bits  signed offset used for converting case
+        1 bit   if 1, adding the signed offset converts the character to lowercase
+        1 bit   if 1, subtracting the signed offset converts the character to uppercase
+        1 bit   if 1, this character has a titlecase equivalent (possibly itself)
+        3 bits  0  may not be part of an identifier
+                1  ignorable control; may continue a Unicode identifier or Java identifier
+                2  may continue a Java identifier but not a Unicode identifier (unused)
+                3  may continue a Unicode identifier or Java identifier
+                4  is a Java whitespace character
+                5  may start or continue a Java identifier;
+                   may continue but not start a Unicode identifier (underscores)
+                6  may start or continue a Java identifier but not a Unicode identifier ($)
+                7  may start or continue a Unicode identifier or Java identifier
+                Thus:
+                   5, 6, 7 may start a Java identifier
+                   1, 2, 3, 5, 6, 7 may continue a Java identifier
+                   7 may start a Unicode identifier
+                   1, 3, 5, 7 may continue a Unicode identifier
+                   1 is ignorable within an identifier
+                   4 is Java whitespace
+        2 bits  0  this character has no numeric property
+                1  adding the digit offset to the character code and then
+                   masking with 0x1F will produce the desired numeric value
+                2  this character has a "strange" numeric value
+                3  a Java supradecimal digit: adding the digit offset to the
+                   character code, then masking with 0x1F, then adding 10
+                   will produce the desired numeric value
+        5 bits  digit offset
+        5 bits  character type
+
+        The encoding of character properties is subject to change at any time.
+     */
+
+    int getProperties(int ch) {
+	char offset = (char)ch;
+        int props = A[Y[X[offset>>5]|((offset>>1)&0xF)]|(offset&0x1)];
+        return props;
+    }
+
+    int getPropertiesEx(int ch) {
+        char offset = (char)ch;
+        int props = B[Y[X[offset>>5]|((offset>>1)&0xF)]|(offset&0x1)];
+        return props;
+    }
+
+    boolean isOtherLowercase(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0001) != 0;
+    }
+
+    boolean isOtherUppercase(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0002) != 0;
+    }
+
+    boolean isOtherAlphabetic(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0004) != 0;
+    }
+
+    boolean isIdeographic(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0010) != 0;
+    }
+
+    int getType(int ch) {
+        int props = getProperties(ch);
+        return (props & 0x1F);
+    }
+
+    boolean isJavaIdentifierStart(int ch) {
+        // isJavaIdentifierStart strictly conforms to code points assigned
+        // in Unicode 6.2.
+        if(Character.UnicodeBlock.of(ch) ==
+            Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_E)
+            return false;
+        int props = getProperties(ch);
+        return ((props & 0x00007000) >= 0x00005000);
+    }
+
+    boolean isJavaIdentifierPart(int ch) {
+        // isJavaIdentifierPart strictly conforms to code points assigned
+        // in Unicode 6.2.
+        if(Character.UnicodeBlock.of(ch) ==
+            Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_E)
+            return false;
+        int props = getProperties(ch);
+        return ((props & 0x00003000) != 0);
+    }
+
+    boolean isUnicodeIdentifierStart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) == 0x00007000);
+    }
+
+    boolean isUnicodeIdentifierPart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00001000) != 0);
+    }
+
+    boolean isIdentifierIgnorable(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) == 0x00001000);
+    }
+
+    int toLowerCase(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if ((val & 0x00020000) != 0) {
+            int offset = val << 5 >> (5+18);
+            mapChar = ch + offset;
+        }
+        return mapChar;
+    }
+
+    int toUpperCase(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if ((val & 0x00010000) != 0) {
+            int offset = val  << 5 >> (5+18);
+            mapChar =  ch - offset;
+        }
+        return mapChar;
+    }
+
+    int toTitleCase(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if ((val & 0x00008000) != 0) {
+            // There is a titlecase equivalent.  Perform further checks:
+            if ((val & 0x00010000) == 0) {
+                // The character does not have an uppercase equivalent, so it must
+                // already be uppercase; so add 1 to get the titlecase form.
+                mapChar = ch + 1;
+            }
+            else if ((val & 0x00020000) == 0) {
+                // The character does not have a lowercase equivalent, so it must
+                // already be lowercase; so subtract 1 to get the titlecase form.
+                mapChar = ch - 1;
+            }
+            // else {
+            // The character has both an uppercase equivalent and a lowercase
+            // equivalent, so it must itself be a titlecase form; return it.
+            // return ch;
+            //}
+        }
+        else if ((val & 0x00010000) != 0) {
+            // This character has no titlecase equivalent but it does have an
+            // uppercase equivalent, so use that (subtract the signed case offset).
+            mapChar = toUpperCase(ch);
+        }
+        return mapChar;
+    }
+
+    int digit(int ch, int radix) {
+        int value = -1;
+        if (radix >= Character.MIN_RADIX && radix <= Character.MAX_RADIX) {
+            int val = getProperties(ch);
+            int kind = val & 0x1F;
+            if (kind == Character.DECIMAL_DIGIT_NUMBER) {
+                value = ch + ((val & 0x3E0) >> 5) & 0x1F;
+            }
+            else if ((val & 0xC00) == 0x00000C00) {
+                // Java supradecimal digit
+                value = (ch + ((val & 0x3E0) >> 5) & 0x1F) + 10;
+            }
+        }
+        return (value < radix) ? value : -1;
+    }
+
+    int getNumericValue(int ch) {
+        int val = getProperties(ch);
+        int retval = -1;
+
+        switch (val & 0xC00) {
+        default: // cannot occur
+        case (0x00000000):         // not numeric
+            retval = -1;
+            break;
+        case (0x00000400):              // simple numeric
+            retval = ch + ((val & 0x3E0) >> 5) & 0x1F;
+            break;
+        case (0x00000800)      :       // "strange" numeric
+            retval = -2;
+            break;
+        case (0x00000C00):           // Java supradecimal
+            retval = (ch + ((val & 0x3E0) >> 5) & 0x1F) + 10;
+            break;
+        }
+        return retval;
+    }
+
+    boolean isWhitespace(int ch) {
+        return (getProperties(ch) & 0x00007000) == 0x00004000;
+    }
+
+    byte getDirectionality(int ch) {
+        int val = getProperties(ch);
+        byte directionality = (byte)((val & 0x78000000) >> 27);
+        if (directionality == 0xF ) {
+	        directionality = Character.DIRECTIONALITY_UNDEFINED;
+        }
+        return directionality;
+    }
+
+    boolean isMirrored(int ch) {
+        return (getProperties(ch) & 0x80000000) != 0;
+    }
+
+    static final CharacterData instance = new CharacterData02();
+    private CharacterData02() {};
+
+    // The following tables and code generated using:
+  // java GenerateCharacter -plane 2 -template c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/characterdata/CharacterData02.java.template -spec c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/UnicodeData.txt -specialcasing c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/SpecialCasing.txt -proplist c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/PropList.txt -o c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/build/windows-x86_64-normal-server-release/jdk/gensrc/java/lang/CharacterData02.java -string -usecharforbyte 11 4 1
+  // The X table has 2048 entries for a total of 4096 bytes.
+
+  static final char X[] = (
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\020\040\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\060\000\000\000\000\000\000\100\120\120\120\120\120\120\120\120\120"+
+    "\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120"+
+    "\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120"+
+    "\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120"+
+    "\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120"+
+    "\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120"+
+    "\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120"+
+    "\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120"+
+    "\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120"+
+    "\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120\120"+
+    "\140\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\000\000\000\000\160\000\000\000\000\000\000"+
+    "\000\000\000\000\000\100\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040").toCharArray();
+
+  // The Y table has 128 entries for a total of 256 bytes.
+
+  static final char Y[] = (
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\002\004\004\004\004\004\004\004\004\004\004"+
+    "\004\004\004\004\004\004\004\004\004\004\000\000\000\000\000\000\000\000\000"+
+    "\000\002\004\004\004\004\004\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\004\006\006\006\006\006\006\006\006\006\006\006\006\006\006\006"+
+    "\006\006\004\004\004\004\004\004\004\004\004\004\004\004\004\004\004\000\000"+
+    "\000\000\000\000\000\000\010\000\000\000\000\000\000\000").toCharArray();
+
+  // The A table has 10 entries for a total of 40 bytes.
+
+  static final int A[] = new int[10];
+  static final String A_DATA =
+    "\000\u7005\000\u7005\000\u7005\u7800\000\u7800\000\u7800\000\000\u7005\000"+
+    "\u7005\000\u7725\000\u7005";
+
+  // The B table has 10 entries for a total of 20 bytes.
+
+  static final char B[] = (
+    "\020\020\020\000\000\000\000\000\020\020").toCharArray();
+
+  // In all, the character property tables require 4392 bytes.
+
+    static {
+                { // THIS CODE WAS AUTOMATICALLY CREATED BY GenerateCharacter:
+            char[] data = A_DATA.toCharArray();
+            assert (data.length == (10 * 2));
+            int i = 0, j = 0;
+            while (i < (10 * 2)) {
+                int entry = data[i++] << 16;
+                A[j++] = entry | data[i++];
+            }
+        }
+
+    }        
+}

jdkSrc/jdk8/java/lang/CharacterData0E.java

@@ -0,0 +1,392 @@
+// This file was generated AUTOMATICALLY from a template file Thu Jul 10 21:34:13 UTC 2025
+/*
+ * Copyright (c) 2003, 2013, 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;
+
+/** The CharacterData class encapsulates the large tables found in
+    Java.lang.Character. */
+
+class CharacterData0E extends CharacterData {
+    /* The character properties are currently encoded into 32 bits in the following manner:
+        1 bit   mirrored property
+        4 bits  directionality property
+        9 bits  signed offset used for converting case
+        1 bit   if 1, adding the signed offset converts the character to lowercase
+        1 bit   if 1, subtracting the signed offset converts the character to uppercase
+        1 bit   if 1, this character has a titlecase equivalent (possibly itself)
+        3 bits  0  may not be part of an identifier
+                1  ignorable control; may continue a Unicode identifier or Java identifier
+                2  may continue a Java identifier but not a Unicode identifier (unused)
+                3  may continue a Unicode identifier or Java identifier
+                4  is a Java whitespace character
+                5  may start or continue a Java identifier;
+                   may continue but not start a Unicode identifier (underscores)
+                6  may start or continue a Java identifier but not a Unicode identifier ($)
+                7  may start or continue a Unicode identifier or Java identifier
+                Thus:
+                   5, 6, 7 may start a Java identifier
+                   1, 2, 3, 5, 6, 7 may continue a Java identifier
+                   7 may start a Unicode identifier
+                   1, 3, 5, 7 may continue a Unicode identifier
+                   1 is ignorable within an identifier
+                   4 is Java whitespace
+        2 bits  0  this character has no numeric property
+                1  adding the digit offset to the character code and then
+                   masking with 0x1F will produce the desired numeric value
+                2  this character has a "strange" numeric value
+                3  a Java supradecimal digit: adding the digit offset to the
+                   character code, then masking with 0x1F, then adding 10
+                   will produce the desired numeric value
+        5 bits  digit offset
+        5 bits  character type
+
+        The encoding of character properties is subject to change at any time.
+     */
+
+    int getProperties(int ch) {
+        char offset = (char)ch;
+        int props = A[Y[X[offset>>5]|((offset>>1)&0xF)]|(offset&0x1)];
+        return props;
+    }
+
+    int getPropertiesEx(int ch) {
+        char offset = (char)ch;
+        int props = B[Y[X[offset>>5]|((offset>>1)&0xF)]|(offset&0x1)];
+        return props;
+    }
+
+    boolean isOtherLowercase(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0001) != 0;
+    }
+
+    boolean isOtherUppercase(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0002) != 0;
+    }
+
+    boolean isOtherAlphabetic(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0004) != 0;
+    }
+
+    boolean isIdeographic(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0010) != 0;
+    }
+
+    int getType(int ch) {
+        int props = getProperties(ch);
+        return (props & 0x1F);
+    }
+
+    boolean isJavaIdentifierStart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) >= 0x00005000);
+    }
+
+    boolean isJavaIdentifierPart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00003000) != 0);
+    }
+
+    boolean isUnicodeIdentifierStart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) == 0x00007000);
+    }
+
+    boolean isUnicodeIdentifierPart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00001000) != 0);
+    }
+
+    boolean isIdentifierIgnorable(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) == 0x00001000);
+    }
+
+    int toLowerCase(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if ((val & 0x00020000) != 0) {
+            int offset = val << 5 >> (5+18);
+            mapChar = ch + offset;
+        }
+        return mapChar;
+    }
+
+    int toUpperCase(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if ((val & 0x00010000) != 0) {
+            int offset = val  << 5 >> (5+18);
+            mapChar =  ch - offset;
+        }
+        return mapChar;
+    }
+
+    int toTitleCase(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if ((val & 0x00008000) != 0) {
+            // There is a titlecase equivalent.  Perform further checks:
+            if ((val & 0x00010000) == 0) {
+                // The character does not have an uppercase equivalent, so it must
+                // already be uppercase; so add 1 to get the titlecase form.
+                mapChar = ch + 1;
+            }
+            else if ((val & 0x00020000) == 0) {
+                // The character does not have a lowercase equivalent, so it must
+                // already be lowercase; so subtract 1 to get the titlecase form.
+                mapChar = ch - 1;
+            }
+            // else {
+            // The character has both an uppercase equivalent and a lowercase
+            // equivalent, so it must itself be a titlecase form; return it.
+            // return ch;
+            //}
+        }
+        else if ((val & 0x00010000) != 0) {
+            // This character has no titlecase equivalent but it does have an
+            // uppercase equivalent, so use that (subtract the signed case offset).
+            mapChar = toUpperCase(ch);
+        }
+        return mapChar;
+    }
+
+    int digit(int ch, int radix) {
+        int value = -1;
+        if (radix >= Character.MIN_RADIX && radix <= Character.MAX_RADIX) {
+            int val = getProperties(ch);
+            int kind = val & 0x1F;
+            if (kind == Character.DECIMAL_DIGIT_NUMBER) {
+                value = ch + ((val & 0x3E0) >> 5) & 0x1F;
+            }
+            else if ((val & 0xC00) == 0x00000C00) {
+                // Java supradecimal digit
+                value = (ch + ((val & 0x3E0) >> 5) & 0x1F) + 10;
+            }
+        }
+        return (value < radix) ? value : -1;
+    }
+
+    int getNumericValue(int ch) {
+        int val = getProperties(ch);
+        int retval = -1;
+
+        switch (val & 0xC00) {
+        default: // cannot occur
+        case (0x00000000):         // not numeric
+            retval = -1;
+            break;
+        case (0x00000400):              // simple numeric
+            retval = ch + ((val & 0x3E0) >> 5) & 0x1F;
+            break;
+        case (0x00000800)      :       // "strange" numeric
+            retval = -2;
+            break;
+        case (0x00000C00):           // Java supradecimal
+            retval = (ch + ((val & 0x3E0) >> 5) & 0x1F) + 10;
+            break;
+        }
+        return retval;
+    }
+
+    boolean isWhitespace(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) == 0x00004000);
+    }
+
+    byte getDirectionality(int ch) {
+        int val = getProperties(ch);
+        byte directionality = (byte)((val & 0x78000000) >> 27);
+        if (directionality == 0xF ) {
+	        directionality = Character.DIRECTIONALITY_UNDEFINED;
+        }
+        return directionality;
+    }
+
+    boolean isMirrored(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x80000000) != 0);
+    }
+
+    static final CharacterData instance = new CharacterData0E();
+    private CharacterData0E() {};
+
+    // The following tables and code generated using:
+  // java GenerateCharacter -plane 14 -template c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/characterdata/CharacterData0E.java.template -spec c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/UnicodeData.txt -specialcasing c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/SpecialCasing.txt -proplist c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/PropList.txt -o c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/build/windows-x86_64-normal-server-release/jdk/gensrc/java/lang/CharacterData0E.java -string -usecharforbyte 11 4 1
+  // The X table has 2048 entries for a total of 4096 bytes.
+
+  static final char X[] = (
+    "\000\020\020\020\040\040\040\040\060\060\060\060\060\060\060\100\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040"+
+    "\040\040\040\040\040\040\040\040\040\040\040\040\040\040\040").toCharArray();
+
+  // The Y table has 80 entries for a total of 160 bytes.
+
+  static final char Y[] = (
+    "\000\002\002\002\002\002\002\002\002\002\002\002\002\002\002\002\004\004\004"+
+    "\004\004\004\004\004\004\004\004\004\004\004\004\004\002\002\002\002\002\002"+
+    "\002\002\002\002\002\002\002\002\002\002\006\006\006\006\006\006\006\006\006"+
+    "\006\006\006\006\006\006\006\006\006\006\006\006\006\006\006\002\002\002\002"+
+    "\002\002\002\002").toCharArray();
+
+  // The A table has 8 entries for a total of 32 bytes.
+
+  static final int A[] = new int[8];
+  static final String A_DATA =
+    "\u7800\000\u4800\u1010\u7800\000\u7800\000\u4800\u1010\u4800\u1010\u4000\u3006"+
+    "\u4000\u3006";
+
+  // The B table has 8 entries for a total of 16 bytes.
+
+  static final char B[] = (
+    "\000\000\000\000\000\000\000\000").toCharArray();
+
+  // In all, the character property tables require 4288 bytes.
+
+    static {
+                { // THIS CODE WAS AUTOMATICALLY CREATED BY GenerateCharacter:
+            char[] data = A_DATA.toCharArray();
+            assert (data.length == (8 * 2));
+            int i = 0, j = 0;
+            while (i < (8 * 2)) {
+                int entry = data[i++] << 16;
+                A[j++] = entry | data[i++];
+            }
+        }
+
+    }        
+}

jdkSrc/jdk8/java/lang/CharacterDataLatin1.java

@@ -0,0 +1,331 @@
+// This file was generated AUTOMATICALLY from a template file Thu Jul 10 21:34:13 UTC 2025
+/*
+ * Copyright (c) 2002, 2013, 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;
+
+/** The CharacterData class encapsulates the large tables found in
+    Java.lang.Character. */
+
+class CharacterDataLatin1 extends CharacterData {
+
+    /* The character properties are currently encoded into 32 bits in the following manner:
+        1 bit   mirrored property
+        4 bits  directionality property
+        9 bits  signed offset used for converting case
+        1 bit   if 1, adding the signed offset converts the character to lowercase
+        1 bit   if 1, subtracting the signed offset converts the character to uppercase
+        1 bit   if 1, this character has a titlecase equivalent (possibly itself)
+        3 bits  0  may not be part of an identifier
+                1  ignorable control; may continue a Unicode identifier or Java identifier
+                2  may continue a Java identifier but not a Unicode identifier (unused)
+                3  may continue a Unicode identifier or Java identifier
+                4  is a Java whitespace character
+                5  may start or continue a Java identifier;
+                   may continue but not start a Unicode identifier (underscores)
+                6  may start or continue a Java identifier but not a Unicode identifier ($)
+                7  may start or continue a Unicode identifier or Java identifier
+                Thus:
+                   5, 6, 7 may start a Java identifier
+                   1, 2, 3, 5, 6, 7 may continue a Java identifier
+                   7 may start a Unicode identifier
+                   1, 3, 5, 7 may continue a Unicode identifier
+                   1 is ignorable within an identifier
+                   4 is Java whitespace
+        2 bits  0  this character has no numeric property
+                1  adding the digit offset to the character code and then
+                   masking with 0x1F will produce the desired numeric value
+                2  this character has a "strange" numeric value
+                3  a Java supradecimal digit: adding the digit offset to the
+                   character code, then masking with 0x1F, then adding 10
+                   will produce the desired numeric value
+        5 bits  digit offset
+        5 bits  character type
+
+        The encoding of character properties is subject to change at any time.
+     */
+
+    int getProperties(int ch) {
+        char offset = (char)ch;
+        int props = A[offset];
+        return props;
+    }
+
+    int getPropertiesEx(int ch) {
+        char offset = (char)ch;
+        int props = B[offset];
+        return props;
+    }
+
+    boolean isOtherLowercase(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0001) != 0;
+    }
+
+    boolean isOtherUppercase(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0002) != 0;
+    }
+
+    boolean isOtherAlphabetic(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0004) != 0;
+    }
+
+    boolean isIdeographic(int ch) {
+        int props = getPropertiesEx(ch);
+        return (props & 0x0010) != 0;
+    }
+
+    int getType(int ch) {
+        int props = getProperties(ch);
+        return (props & 0x1F);
+    }
+
+    boolean isJavaIdentifierStart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) >= 0x00005000);
+    }
+
+    boolean isJavaIdentifierPart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00003000) != 0);
+    }
+
+    boolean isUnicodeIdentifierStart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) == 0x00007000);
+    }
+
+    boolean isUnicodeIdentifierPart(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00001000) != 0);
+    }
+
+    boolean isIdentifierIgnorable(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) == 0x00001000);
+    }
+
+    int toLowerCase(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if (((val & 0x00020000) != 0) && 
+                ((val & 0x07FC0000) != 0x07FC0000)) { 
+            int offset = val << 5 >> (5+18);
+            mapChar = ch + offset;
+        }
+        return mapChar;
+    }
+
+    int toUpperCase(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if ((val & 0x00010000) != 0) {
+            if ((val & 0x07FC0000) != 0x07FC0000) {
+                int offset = val  << 5 >> (5+18);
+                mapChar =  ch - offset;
+            } else if (ch == 0x00B5) {
+                mapChar = 0x039C;
+            }
+        }
+        return mapChar;
+    }
+
+    int toTitleCase(int ch) {
+        return toUpperCase(ch);
+    }
+
+    int digit(int ch, int radix) {
+        int value = -1;
+        if (radix >= Character.MIN_RADIX && radix <= Character.MAX_RADIX) {
+            int val = getProperties(ch);
+            int kind = val & 0x1F;
+            if (kind == Character.DECIMAL_DIGIT_NUMBER) {
+                value = ch + ((val & 0x3E0) >> 5) & 0x1F;
+            }
+            else if ((val & 0xC00) == 0x00000C00) {
+                // Java supradecimal digit
+                value = (ch + ((val & 0x3E0) >> 5) & 0x1F) + 10;
+            }
+        }
+        return (value < radix) ? value : -1;
+    }
+
+    int getNumericValue(int ch) {
+        int val = getProperties(ch);
+        int retval = -1;
+
+        switch (val & 0xC00) {
+            default: // cannot occur
+            case (0x00000000):         // not numeric
+                retval = -1;
+                break;
+            case (0x00000400):              // simple numeric
+                retval = ch + ((val & 0x3E0) >> 5) & 0x1F;
+                break;
+            case (0x00000800)      :       // "strange" numeric
+                 retval = -2; 
+                 break;
+            case (0x00000C00):           // Java supradecimal
+                retval = (ch + ((val & 0x3E0) >> 5) & 0x1F) + 10;
+                break;
+        }
+        return retval;
+    }
+
+    boolean isWhitespace(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x00007000) == 0x00004000);
+    }
+
+    byte getDirectionality(int ch) {
+        int val = getProperties(ch);
+        byte directionality = (byte)((val & 0x78000000) >> 27);
+
+        if (directionality == 0xF ) {
+            directionality = -1;
+        }
+        return directionality;
+    }
+
+    boolean isMirrored(int ch) {
+        int props = getProperties(ch);
+        return ((props & 0x80000000) != 0);
+    }
+
+    int toUpperCaseEx(int ch) {
+        int mapChar = ch;
+        int val = getProperties(ch);
+
+        if ((val & 0x00010000) != 0) {
+            if ((val & 0x07FC0000) != 0x07FC0000) {
+                int offset = val  << 5 >> (5+18);
+                mapChar =  ch - offset;
+            }
+            else {
+                switch(ch) {
+                    // map overflow characters
+                    case 0x00B5 : mapChar = 0x039C; break;
+                    default       : mapChar = Character.ERROR; break;
+                }
+            }
+        }
+        return mapChar;
+    }
+
+    static char[] sharpsMap = new char[] {'S', 'S'};
+
+    char[] toUpperCaseCharArray(int ch) {
+        char[] upperMap = {(char)ch};
+        if (ch == 0x00DF) {
+            upperMap = sharpsMap;
+        }
+        return upperMap;
+    }
+
+    static final CharacterDataLatin1 instance = new CharacterDataLatin1();
+    private CharacterDataLatin1() {};
+
+    // The following tables and code generated using:
+  // java GenerateCharacter -template c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/characterdata/CharacterDataLatin1.java.template -spec c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/UnicodeData.txt -specialcasing c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/SpecialCasing.txt -proplist c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/jdk/make/data/unicodedata/PropList.txt -o c:/wsjdk/Corretto8Src/installers/windows/zip/corretto-build/buildRoot/build/windows-x86_64-normal-server-release/jdk/gensrc/java/lang/CharacterDataLatin1.java -string -usecharforbyte -latin1 8
+  // The A table has 256 entries for a total of 1024 bytes.
+
+  static final int A[] = new int[256];
+  static final String A_DATA =
+    "\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800"+
+    "\u100F\u4800\u100F\u4800\u100F\u5800\u400F\u5000\u400F\u5800\u400F\u6000\u400F"+
+    "\u5000\u400F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800"+
+    "\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F"+
+    "\u4800\u100F\u4800\u100F\u5000\u400F\u5000\u400F\u5000\u400F\u5800\u400F\u6000"+
+    "\u400C\u6800\030\u6800\030\u2800\030\u2800\u601A\u2800\030\u6800\030\u6800"+
+    "\030\uE800\025\uE800\026\u6800\030\u2000\031\u3800\030\u2000\024\u3800\030"+
+    "\u3800\030\u1800\u3609\u1800\u3609\u1800\u3609\u1800\u3609\u1800\u3609\u1800"+
+    "\u3609\u1800\u3609\u1800\u3609\u1800\u3609\u1800\u3609\u3800\030\u6800\030"+
+    "\uE800\031\u6800\031\uE800\031\u6800\030\u6800\030\202\u7FE1\202\u7FE1\202"+
+    "\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1"+
+    "\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202"+
+    "\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1\202\u7FE1"+
+    "\202\u7FE1\uE800\025\u6800\030\uE800\026\u6800\033\u6800\u5017\u6800\033\201"+
+    "\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2"+
+    "\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201"+
+    "\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2\201\u7FE2"+
+    "\201\u7FE2\201\u7FE2\201\u7FE2\uE800\025\u6800\031\uE800\026\u6800\031\u4800"+
+    "\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u5000\u100F"+
+    "\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800"+
+    "\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F"+
+    "\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800"+
+    "\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F\u4800\u100F"+
+    "\u3800\014\u6800\030\u2800\u601A\u2800\u601A\u2800\u601A\u2800\u601A\u6800"+
+    "\034\u6800\030\u6800\033\u6800\034\000\u7005\uE800\035\u6800\031\u4800\u1010"+
+    "\u6800\034\u6800\033\u2800\034\u2800\031\u1800\u060B\u1800\u060B\u6800\033"+
+    "\u07FD\u7002\u6800\030\u6800\030\u6800\033\u1800\u050B\000\u7005\uE800\036"+
+    "\u6800\u080B\u6800\u080B\u6800\u080B\u6800\030\202\u7001\202\u7001\202\u7001"+
+    "\202\u7001\202\u7001\202\u7001\202\u7001\202\u7001\202\u7001\202\u7001\202"+
+    "\u7001\202\u7001\202\u7001\202\u7001\202\u7001\202\u7001\202\u7001\202\u7001"+
+    "\202\u7001\202\u7001\202\u7001\202\u7001\202\u7001\u6800\031\202\u7001\202"+
+    "\u7001\202\u7001\202\u7001\202\u7001\202\u7001\202\u7001\u07FD\u7002\201\u7002"+
+    "\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002\201"+
+    "\u7002\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002"+
+    "\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002\u6800"+
+    "\031\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002\201\u7002"+
+    "\u061D\u7002";
+
+  // The B table has 256 entries for a total of 512 bytes.
+
+  static final char B[] = (
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"+
+    "\000\000\000\000\000\000\000\000\000").toCharArray();
+
+  // In all, the character property tables require 1024 bytes.
+
+    static {
+                { // THIS CODE WAS AUTOMATICALLY CREATED BY GenerateCharacter:
+            char[] data = A_DATA.toCharArray();
+            assert (data.length == (256 * 2));
+            int i = 0, j = 0;
+            while (i < (256 * 2)) {
+                int entry = data[i++] << 16;
+                A[j++] = entry | data[i++];
+            }
+        }
+
+    }        
+}
+

jdkSrc/jdk8/java/lang/CharacterDataPrivateUse.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2003, 2013, 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;
+
+/** The CharacterData class encapsulates the large tables found in
+    Java.lang.Character. */
+
+class CharacterDataPrivateUse extends CharacterData {
+
+    int getProperties(int ch) {
+        return 0;
+    }
+
+    int getType(int ch) {
+	return (ch & 0xFFFE) == 0xFFFE
+	    ? Character.UNASSIGNED
+	    : Character.PRIVATE_USE;
+    }
+
+    boolean isJavaIdentifierStart(int ch) {
+		return false;
+    }
+
+    boolean isJavaIdentifierPart(int ch) {
+		return false;
+    }
+
+    boolean isUnicodeIdentifierStart(int ch) {
+		return false;
+    }
+
+    boolean isUnicodeIdentifierPart(int ch) {
+		return false;
+    }
+
+    boolean isIdentifierIgnorable(int ch) {
+		return false;
+    }
+
+    int toLowerCase(int ch) {
+		return ch;
+    }
+
+    int toUpperCase(int ch) {
+		return ch;
+    }
+
+    int toTitleCase(int ch) {
+		return ch;
+    }
+
+    int digit(int ch, int radix) {
+		return -1;
+    }
+
+    int getNumericValue(int ch) {
+		return -1;
+    }
+
+    boolean isWhitespace(int ch) {
+		return false;
+    }
+
+    byte getDirectionality(int ch) {
+	return (ch & 0xFFFE) == 0xFFFE
+	    ? Character.DIRECTIONALITY_UNDEFINED
+	    : Character.DIRECTIONALITY_LEFT_TO_RIGHT;
+    }
+
+    boolean isMirrored(int ch) {
+		return false;
+    }
+
+    static final CharacterData instance = new CharacterDataPrivateUse();
+    private CharacterDataPrivateUse() {};
+}
+
+	

jdkSrc/jdk8/java/lang/CharacterDataUndefined.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2003, 2013, 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;
+
+/** The CharacterData class encapsulates the large tables found in
+    Java.lang.Character. */
+
+class CharacterDataUndefined extends CharacterData {
+
+    int getProperties(int ch) {
+        return 0;
+    }
+
+    int getType(int ch) {
+	return Character.UNASSIGNED;
+    }
+
+    boolean isJavaIdentifierStart(int ch) {
+		return false;
+    }
+
+    boolean isJavaIdentifierPart(int ch) {
+		return false;
+    }
+
+    boolean isUnicodeIdentifierStart(int ch) {
+		return false;
+    }
+
+    boolean isUnicodeIdentifierPart(int ch) {
+		return false;
+    }
+
+    boolean isIdentifierIgnorable(int ch) {
+		return false;
+    }
+
+    int toLowerCase(int ch) {
+		return ch;
+    }
+
+    int toUpperCase(int ch) {
+		return ch;
+    }
+
+    int toTitleCase(int ch) {
+		return ch;
+    }
+
+    int digit(int ch, int radix) {
+		return -1;
+    }
+
+    int getNumericValue(int ch) {
+		return -1;
+    }
+
+    boolean isWhitespace(int ch) {
+		return false;
+    }
+
+    byte getDirectionality(int ch) {
+		return Character.DIRECTIONALITY_UNDEFINED;
+    }
+
+    boolean isMirrored(int ch) {
+		return false;
+    }
+
+    static final CharacterData instance = new CharacterDataUndefined();
+    private CharacterDataUndefined() {};
+}

jdkSrc/jdk8/java/lang/CharacterName.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2010, 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.DataInputStream;
+import java.io.InputStream;
+import java.lang.ref.SoftReference;
+import java.util.Arrays;
+import java.util.zip.InflaterInputStream;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+class CharacterName {
+
+    private static SoftReference<byte[]> refStrPool;
+    private static int[][] lookup;
+
+    private static synchronized byte[] initNamePool() {
+        byte[] strPool = null;
+        if (refStrPool != null && (strPool = refStrPool.get()) != null)
+            return strPool;
+        DataInputStream dis = null;
+        try {
+            dis = new DataInputStream(new InflaterInputStream(
+                AccessController.doPrivileged(new PrivilegedAction<InputStream>()
+                {
+                    public InputStream run() {
+                        return getClass().getResourceAsStream("uniName.dat");
+                    }
+                })));
+
+            lookup = new int[(Character.MAX_CODE_POINT + 1) >> 8][];
+            int total = dis.readInt();
+            int cpEnd = dis.readInt();
+            byte ba[] = new byte[cpEnd];
+            dis.readFully(ba);
+
+            int nameOff = 0;
+            int cpOff = 0;
+            int cp = 0;
+            do {
+                int len = ba[cpOff++] & 0xff;
+                if (len == 0) {
+                    len = ba[cpOff++] & 0xff;
+                    // always big-endian
+                    cp = ((ba[cpOff++] & 0xff) << 16) |
+                         ((ba[cpOff++] & 0xff) <<  8) |
+                         ((ba[cpOff++] & 0xff));
+                }  else {
+                    cp++;
+                }
+                int hi = cp >> 8;
+                if (lookup[hi] == null) {
+                    lookup[hi] = new int[0x100];
+                }
+                lookup[hi][cp&0xff] = (nameOff << 8) | len;
+                nameOff += len;
+            } while (cpOff < cpEnd);
+            strPool = new byte[total - cpEnd];
+            dis.readFully(strPool);
+            refStrPool = new SoftReference<>(strPool);
+        } catch (Exception x) {
+            throw new InternalError(x.getMessage(), x);
+        } finally {
+            try {
+                if (dis != null)
+                    dis.close();
+            } catch (Exception xx) {}
+        }
+        return strPool;
+    }
+
+    public static String get(int cp) {
+        byte[] strPool = null;
+        if (refStrPool == null || (strPool = refStrPool.get()) == null)
+            strPool = initNamePool();
+        int off = 0;
+        if (lookup[cp>>8] == null ||
+            (off = lookup[cp>>8][cp&0xff]) == 0)
+            return null;
+        @SuppressWarnings("deprecation")
+        String result = new String(strPool, 0, off >>> 8, off & 0xff);  // ASCII
+        return result;
+    }
+}

jdkSrc/jdk8/java/lang/ClassCastException.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1994, 2013, 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;
+
+/**
+ * Thrown to indicate that the code has attempted to cast an object
+ * to a subclass of which it is not an instance. For example, the
+ * following code generates a <code>ClassCastException</code>:
+ * <blockquote><pre>
+ *     Object x = new Integer(0);
+ *     System.out.println((String)x);
+ * </pre></blockquote>
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class ClassCastException extends RuntimeException {
+    private static final long serialVersionUID = -9223365651070458532L;
+
+    /**
+     * Constructs a <code>ClassCastException</code> with no detail message.
+     */
+    public ClassCastException() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>ClassCastException</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public ClassCastException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/ClassCircularityError.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * Thrown when the Java Virtual Machine detects a circularity in the
+ * superclass hierarchy of a class being loaded.
+ *
+ * @author     unascribed
+ * @since      JDK1.0
+ */
+public class ClassCircularityError extends LinkageError {
+    private static final long serialVersionUID = 1054362542914539689L;
+
+    /**
+     * Constructs a {@code ClassCircularityError} with no detail message.
+     */
+    public ClassCircularityError() {
+        super();
+    }
+
+    /**
+     * Constructs a {@code ClassCircularityError} with the specified detail
+     * message.
+     *
+     * @param  s
+     *         The detail message
+     */
+    public ClassCircularityError(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/ClassFormatError.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 1994, 2008, 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;
+
+/**
+ * Thrown when the Java Virtual Machine attempts to read a class
+ * file and determines that the file is malformed or otherwise cannot
+ * be interpreted as a class file.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class ClassFormatError extends LinkageError {
+    private static final long serialVersionUID = -8420114879011949195L;
+
+    /**
+     * Constructs a <code>ClassFormatError</code> with no detail message.
+     */
+    public ClassFormatError() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>ClassFormatError</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public ClassFormatError(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/ClassLoaderHelper.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2012, 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.File;
+
+class ClassLoaderHelper {
+
+    private ClassLoaderHelper() {}
+
+    /**
+     * Returns an alternate path name for the given file
+     * such that if the original pathname did not exist, then the
+     * file may be located at the alternate location.
+     * For most platforms, this behavior is not supported and returns null.
+     */
+    static File mapAlternativeName(File lib) {
+        return null;
+    }
+}

jdkSrc/jdk8/java/lang/ClassNotFoundException.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 1995, 2004, 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;
+
+/**
+ * Thrown when an application tries to load in a class through its
+ * string name using:
+ * <ul>
+ * <li>The <code>forName</code> method in class <code>Class</code>.
+ * <li>The <code>findSystemClass</code> method in class
+ *     <code>ClassLoader</code> .
+ * <li>The <code>loadClass</code> method in class <code>ClassLoader</code>.
+ * </ul>
+ * <p>
+ * but no definition for the class with the specified name could be found.
+ *
+ * <p>As of release 1.4, this exception has been retrofitted to conform to
+ * the general purpose exception-chaining mechanism.  The "optional exception
+ * that was raised while loading the class" that may be provided at
+ * construction time and accessed via the {@link #getException()} method is
+ * now known as the <i>cause</i>, and may be accessed via the {@link
+ * Throwable#getCause()} method, as well as the aforementioned "legacy method."
+ *
+ * @author  unascribed
+ * @see     java.lang.Class#forName(java.lang.String)
+ * @see     java.lang.ClassLoader#findSystemClass(java.lang.String)
+ * @see     java.lang.ClassLoader#loadClass(java.lang.String, boolean)
+ * @since   JDK1.0
+ */
+public class ClassNotFoundException extends ReflectiveOperationException {
+    /**
+     * use serialVersionUID from JDK 1.1.X for interoperability
+     */
+     private static final long serialVersionUID = 9176873029745254542L;
+
+    /**
+     * This field holds the exception ex if the
+     * ClassNotFoundException(String s, Throwable ex) constructor was
+     * used to instantiate the object
+     * @serial
+     * @since 1.2
+     */
+    private Throwable ex;
+
+    /**
+     * Constructs a <code>ClassNotFoundException</code> with no detail message.
+     */
+    public ClassNotFoundException() {
+        super((Throwable)null);  // Disallow initCause
+    }
+
+    /**
+     * Constructs a <code>ClassNotFoundException</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public ClassNotFoundException(String s) {
+        super(s, null);  //  Disallow initCause
+    }
+
+    /**
+     * Constructs a <code>ClassNotFoundException</code> with the
+     * specified detail message and optional exception that was
+     * raised while loading the class.
+     *
+     * @param s the detail message
+     * @param ex the exception that was raised while loading the class
+     * @since 1.2
+     */
+    public ClassNotFoundException(String s, Throwable ex) {
+        super(s, null);  //  Disallow initCause
+        this.ex = ex;
+    }
+
+    /**
+     * Returns the exception that was raised if an error occurred while
+     * attempting to load the class. Otherwise, returns <tt>null</tt>.
+     *
+     * <p>This method predates the general-purpose exception chaining facility.
+     * The {@link Throwable#getCause()} method is now the preferred means of
+     * obtaining this information.
+     *
+     * @return the <code>Exception</code> that was raised while loading a class
+     * @since 1.2
+     */
+    public Throwable getException() {
+        return ex;
+    }
+
+    /**
+     * Returns the cause of this exception (the exception that was raised
+     * if an error occurred while attempting to load the class; otherwise
+     * <tt>null</tt>).
+     *
+     * @return  the cause of this exception.
+     * @since   1.4
+     */
+    public Throwable getCause() {
+        return ex;
+    }
+}

jdkSrc/jdk8/java/lang/ClassValue.java

@@ -0,0 +1,772 @@
+/*
+ * Copyright (c) 2010, 2013, 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.lang.ClassValue.ClassValueMap;
+import java.util.WeakHashMap;
+import java.lang.ref.WeakReference;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import sun.misc.Unsafe;
+
+import static java.lang.ClassValue.ClassValueMap.probeHomeLocation;
+import static java.lang.ClassValue.ClassValueMap.probeBackupLocations;
+
+/**
+ * Lazily associate a computed value with (potentially) every type.
+ * For example, if a dynamic language needs to construct a message dispatch
+ * table for each class encountered at a message send call site,
+ * it can use a {@code ClassValue} to cache information needed to
+ * perform the message send quickly, for each class encountered.
+ * @author John Rose, JSR 292 EG
+ * @since 1.7
+ */
+public abstract class ClassValue<T> {
+    /**
+     * Sole constructor.  (For invocation by subclass constructors, typically
+     * implicit.)
+     */
+    protected ClassValue() {
+    }
+
+    /**
+     * Computes the given class's derived value for this {@code ClassValue}.
+     * <p>
+     * This method will be invoked within the first thread that accesses
+     * the value with the {@link #get get} method.
+     * <p>
+     * Normally, this method is invoked at most once per class,
+     * but it may be invoked again if there has been a call to
+     * {@link #remove remove}.
+     * <p>
+     * If this method throws an exception, the corresponding call to {@code get}
+     * will terminate abnormally with that exception, and no class value will be recorded.
+     *
+     * @param type the type whose class value must be computed
+     * @return the newly computed value associated with this {@code ClassValue}, for the given class or interface
+     * @see #get
+     * @see #remove
+     */
+    protected abstract T computeValue(Class<?> type);
+
+    /**
+     * Returns the value for the given class.
+     * If no value has yet been computed, it is obtained by
+     * an invocation of the {@link #computeValue computeValue} method.
+     * <p>
+     * The actual installation of the value on the class
+     * is performed atomically.
+     * At that point, if several racing threads have
+     * computed values, one is chosen, and returned to
+     * all the racing threads.
+     * <p>
+     * The {@code type} parameter is typically a class, but it may be any type,
+     * such as an interface, a primitive type (like {@code int.class}), or {@code void.class}.
+     * <p>
+     * In the absence of {@code remove} calls, a class value has a simple
+     * state diagram:  uninitialized and initialized.
+     * When {@code remove} calls are made,
+     * the rules for value observation are more complex.
+     * See the documentation for {@link #remove remove} for more information.
+     *
+     * @param type the type whose class value must be computed or retrieved
+     * @return the current value associated with this {@code ClassValue}, for the given class or interface
+     * @throws NullPointerException if the argument is null
+     * @see #remove
+     * @see #computeValue
+     */
+    public T get(Class<?> type) {
+        // non-racing this.hashCodeForCache : final int
+        Entry<?>[] cache;
+        Entry<T> e = probeHomeLocation(cache = getCacheCarefully(type), this);
+        // racing e : current value <=> stale value from current cache or from stale cache
+        // invariant:  e is null or an Entry with readable Entry.version and Entry.value
+        if (match(e))
+            // invariant:  No false positive matches.  False negatives are OK if rare.
+            // The key fact that makes this work: if this.version == e.version,
+            // then this thread has a right to observe (final) e.value.
+            return e.value();
+        // The fast path can fail for any of these reasons:
+        // 1. no entry has been computed yet
+        // 2. hash code collision (before or after reduction mod cache.length)
+        // 3. an entry has been removed (either on this type or another)
+        // 4. the GC has somehow managed to delete e.version and clear the reference
+        return getFromBackup(cache, type);
+    }
+
+    /**
+     * Removes the associated value for the given class.
+     * If this value is subsequently {@linkplain #get read} for the same class,
+     * its value will be reinitialized by invoking its {@link #computeValue computeValue} method.
+     * This may result in an additional invocation of the
+     * {@code computeValue} method for the given class.
+     * <p>
+     * In order to explain the interaction between {@code get} and {@code remove} calls,
+     * we must model the state transitions of a class value to take into account
+     * the alternation between uninitialized and initialized states.
+     * To do this, number these states sequentially from zero, and note that
+     * uninitialized (or removed) states are numbered with even numbers,
+     * while initialized (or re-initialized) states have odd numbers.
+     * <p>
+     * When a thread {@code T} removes a class value in state {@code 2N},
+     * nothing happens, since the class value is already uninitialized.
+     * Otherwise, the state is advanced atomically to {@code 2N+1}.
+     * <p>
+     * When a thread {@code T} queries a class value in state {@code 2N},
+     * the thread first attempts to initialize the class value to state {@code 2N+1}
+     * by invoking {@code computeValue} and installing the resulting value.
+     * <p>
+     * When {@code T} attempts to install the newly computed value,
+     * if the state is still at {@code 2N}, the class value will be initialized
+     * with the computed value, advancing it to state {@code 2N+1}.
+     * <p>
+     * Otherwise, whether the new state is even or odd,
+     * {@code T} will discard the newly computed value
+     * and retry the {@code get} operation.
+     * <p>
+     * Discarding and retrying is an important proviso,
+     * since otherwise {@code T} could potentially install
+     * a disastrously stale value.  For example:
+     * <ul>
+     * <li>{@code T} calls {@code CV.get(C)} and sees state {@code 2N}
+     * <li>{@code T} quickly computes a time-dependent value {@code V0} and gets ready to install it
+     * <li>{@code T} is hit by an unlucky paging or scheduling event, and goes to sleep for a long time
+     * <li>...meanwhile, {@code T2} also calls {@code CV.get(C)} and sees state {@code 2N}
+     * <li>{@code T2} quickly computes a similar time-dependent value {@code V1} and installs it on {@code CV.get(C)}
+     * <li>{@code T2} (or a third thread) then calls {@code CV.remove(C)}, undoing {@code T2}'s work
+     * <li> the previous actions of {@code T2} are repeated several times
+     * <li> also, the relevant computed values change over time: {@code V1}, {@code V2}, ...
+     * <li>...meanwhile, {@code T} wakes up and attempts to install {@code V0}; <em>this must fail</em>
+     * </ul>
+     * We can assume in the above scenario that {@code CV.computeValue} uses locks to properly
+     * observe the time-dependent states as it computes {@code V1}, etc.
+     * This does not remove the threat of a stale value, since there is a window of time
+     * between the return of {@code computeValue} in {@code T} and the installation
+     * of the the new value.  No user synchronization is possible during this time.
+     *
+     * @param type the type whose class value must be removed
+     * @throws NullPointerException if the argument is null
+     */
+    public void remove(Class<?> type) {
+        ClassValueMap map = getMap(type);
+        map.removeEntry(this);
+    }
+
+    // Possible functionality for JSR 292 MR 1
+    /*public*/ void put(Class<?> type, T value) {
+        ClassValueMap map = getMap(type);
+        map.changeEntry(this, value);
+    }
+
+    /// --------
+    /// Implementation...
+    /// --------
+
+    /** Return the cache, if it exists, else a dummy empty cache. */
+    private static Entry<?>[] getCacheCarefully(Class<?> type) {
+        // racing type.classValueMap{.cacheArray} : null => new Entry[X] <=> new Entry[Y]
+        ClassValueMap map = type.classValueMap;
+        if (map == null)  return EMPTY_CACHE;
+        Entry<?>[] cache = map.getCache();
+        return cache;
+        // invariant:  returned value is safe to dereference and check for an Entry
+    }
+
+    /** Initial, one-element, empty cache used by all Class instances.  Must never be filled. */
+    private static final Entry<?>[] EMPTY_CACHE = { null };
+
+    /**
+     * Slow tail of ClassValue.get to retry at nearby locations in the cache,
+     * or take a slow lock and check the hash table.
+     * Called only if the first probe was empty or a collision.
+     * This is a separate method, so compilers can process it independently.
+     */
+    private T getFromBackup(Entry<?>[] cache, Class<?> type) {
+        Entry<T> e = probeBackupLocations(cache, this);
+        if (e != null)
+            return e.value();
+        return getFromHashMap(type);
+    }
+
+    // Hack to suppress warnings on the (T) cast, which is a no-op.
+    @SuppressWarnings("unchecked")
+    Entry<T> castEntry(Entry<?> e) { return (Entry<T>) e; }
+
+    /** Called when the fast path of get fails, and cache reprobe also fails.
+     */
+    private T getFromHashMap(Class<?> type) {
+        // The fail-safe recovery is to fall back to the underlying classValueMap.
+        ClassValueMap map = getMap(type);
+        for (;;) {
+            Entry<T> e = map.startEntry(this);
+            if (!e.isPromise())
+                return e.value();
+            try {
+                // Try to make a real entry for the promised version.
+                e = makeEntry(e.version(), computeValue(type));
+            } finally {
+                // Whether computeValue throws or returns normally,
+                // be sure to remove the empty entry.
+                e = map.finishEntry(this, e);
+            }
+            if (e != null)
+                return e.value();
+            // else try again, in case a racing thread called remove (so e == null)
+        }
+    }
+
+    /** Check that e is non-null, matches this ClassValue, and is live. */
+    boolean match(Entry<?> e) {
+        // racing e.version : null (blank) => unique Version token => null (GC-ed version)
+        // non-racing this.version : v1 => v2 => ... (updates are read faithfully from volatile)
+        return (e != null && e.get() == this.version);
+        // invariant:  No false positives on version match.  Null is OK for false negative.
+        // invariant:  If version matches, then e.value is readable (final set in Entry.<init>)
+    }
+
+    /** Internal hash code for accessing Class.classValueMap.cacheArray. */
+    final int hashCodeForCache = nextHashCode.getAndAdd(HASH_INCREMENT) & HASH_MASK;
+
+    /** Value stream for hashCodeForCache.  See similar structure in ThreadLocal. */
+    private static final AtomicInteger nextHashCode = new AtomicInteger();
+
+    /** Good for power-of-two tables.  See similar structure in ThreadLocal. */
+    private static final int HASH_INCREMENT = 0x61c88647;
+
+    /** Mask a hash code to be positive but not too large, to prevent wraparound. */
+    static final int HASH_MASK = (-1 >>> 2);
+
+    /**
+     * Private key for retrieval of this object from ClassValueMap.
+     */
+    static class Identity {
+    }
+    /**
+     * This ClassValue's identity, expressed as an opaque object.
+     * The main object {@code ClassValue.this} is incorrect since
+     * subclasses may override {@code ClassValue.equals}, which
+     * could confuse keys in the ClassValueMap.
+     */
+    final Identity identity = new Identity();
+
+    /**
+     * Current version for retrieving this class value from the cache.
+     * Any number of computeValue calls can be cached in association with one version.
+     * But the version changes when a remove (on any type) is executed.
+     * A version change invalidates all cache entries for the affected ClassValue,
+     * by marking them as stale.  Stale cache entries do not force another call
+     * to computeValue, but they do require a synchronized visit to a backing map.
+     * <p>
+     * All user-visible state changes on the ClassValue take place under
+     * a lock inside the synchronized methods of ClassValueMap.
+     * Readers (of ClassValue.get) are notified of such state changes
+     * when this.version is bumped to a new token.
+     * This variable must be volatile so that an unsynchronized reader
+     * will receive the notification without delay.
+     * <p>
+     * If version were not volatile, one thread T1 could persistently hold onto
+     * a stale value this.value == V1, while while another thread T2 advances
+     * (under a lock) to this.value == V2.  This will typically be harmless,
+     * but if T1 and T2 interact causally via some other channel, such that
+     * T1's further actions are constrained (in the JMM) to happen after
+     * the V2 event, then T1's observation of V1 will be an error.
+     * <p>
+     * The practical effect of making this.version be volatile is that it cannot
+     * be hoisted out of a loop (by an optimizing JIT) or otherwise cached.
+     * Some machines may also require a barrier instruction to execute
+     * before this.version.
+     */
+    private volatile Version<T> version = new Version<>(this);
+    Version<T> version() { return version; }
+    void bumpVersion() { version = new Version<>(this); }
+    static class Version<T> {
+        private final ClassValue<T> classValue;
+        private final Entry<T> promise = new Entry<>(this);
+        Version(ClassValue<T> classValue) { this.classValue = classValue; }
+        ClassValue<T> classValue() { return classValue; }
+        Entry<T> promise() { return promise; }
+        boolean isLive() { return classValue.version() == this; }
+    }
+
+    /** One binding of a value to a class via a ClassValue.
+     *  States are:<ul>
+     *  <li> promise if value == Entry.this
+     *  <li> else dead if version == null
+     *  <li> else stale if version != classValue.version
+     *  <li> else live </ul>
+     *  Promises are never put into the cache; they only live in the
+     *  backing map while a computeValue call is in flight.
+     *  Once an entry goes stale, it can be reset at any time
+     *  into the dead state.
+     */
+    static class Entry<T> extends WeakReference<Version<T>> {
+        final Object value;  // usually of type T, but sometimes (Entry)this
+        Entry(Version<T> version, T value) {
+            super(version);
+            this.value = value;  // for a regular entry, value is of type T
+        }
+        private void assertNotPromise() { assert(!isPromise()); }
+        /** For creating a promise. */
+        Entry(Version<T> version) {
+            super(version);
+            this.value = this;  // for a promise, value is not of type T, but Entry!
+        }
+        /** Fetch the value.  This entry must not be a promise. */
+        @SuppressWarnings("unchecked")  // if !isPromise, type is T
+        T value() { assertNotPromise(); return (T) value; }
+        boolean isPromise() { return value == this; }
+        Version<T> version() { return get(); }
+        ClassValue<T> classValueOrNull() {
+            Version<T> v = version();
+            return (v == null) ? null : v.classValue();
+        }
+        boolean isLive() {
+            Version<T> v = version();
+            if (v == null)  return false;
+            if (v.isLive())  return true;
+            clear();
+            return false;
+        }
+        Entry<T> refreshVersion(Version<T> v2) {
+            assertNotPromise();
+            @SuppressWarnings("unchecked")  // if !isPromise, type is T
+            Entry<T> e2 = new Entry<>(v2, (T) value);
+            clear();
+            // value = null -- caller must drop
+            return e2;
+        }
+        static final Entry<?> DEAD_ENTRY = new Entry<>(null, null);
+    }
+
+    /** Return the backing map associated with this type. */
+    private static ClassValueMap getMap(Class<?> type) {
+        // racing type.classValueMap : null (blank) => unique ClassValueMap
+        // if a null is observed, a map is created (lazily, synchronously, uniquely)
+        // all further access to that map is synchronized
+        ClassValueMap map = type.classValueMap;
+        if (map != null)  return map;
+        return initializeMap(type);
+    }
+
+    private static final Object CRITICAL_SECTION = new Object();
+    private static final Unsafe UNSAFE = Unsafe.getUnsafe();
+    private static ClassValueMap initializeMap(Class<?> type) {
+        ClassValueMap map;
+        synchronized (CRITICAL_SECTION) {  // private object to avoid deadlocks
+            // happens about once per type
+            if ((map = type.classValueMap) == null) {
+                map = new ClassValueMap(type);
+                // Place a Store fence after construction and before publishing to emulate
+                // ClassValueMap containing final fields. This ensures it can be
+                // published safely in the non-volatile field Class.classValueMap,
+                // since stores to the fields of ClassValueMap will not be reordered
+                // to occur after the store to the field type.classValueMap
+                UNSAFE.storeFence();
+
+                type.classValueMap = map;
+            }
+        }
+        return map;
+    }
+
+    static <T> Entry<T> makeEntry(Version<T> explicitVersion, T value) {
+        // Note that explicitVersion might be different from this.version.
+        return new Entry<>(explicitVersion, value);
+
+        // As soon as the Entry is put into the cache, the value will be
+        // reachable via a data race (as defined by the Java Memory Model).
+        // This race is benign, assuming the value object itself can be
+        // read safely by multiple threads.  This is up to the user.
+        //
+        // The entry and version fields themselves can be safely read via
+        // a race because they are either final or have controlled states.
+        // If the pointer from the entry to the version is still null,
+        // or if the version goes immediately dead and is nulled out,
+        // the reader will take the slow path and retry under a lock.
+    }
+
+    // The following class could also be top level and non-public:
+
+    /** A backing map for all ClassValues, relative a single given type.
+     *  Gives a fully serialized "true state" for each pair (ClassValue cv, Class type).
+     *  Also manages an unserialized fast-path cache.
+     */
+    static class ClassValueMap extends WeakHashMap<ClassValue.Identity, Entry<?>> {
+        private final Class<?> type;
+        private Entry<?>[] cacheArray;
+        private int cacheLoad, cacheLoadLimit;
+
+        /** Number of entries initially allocated to each type when first used with any ClassValue.
+         *  It would be pointless to make this much smaller than the Class and ClassValueMap objects themselves.
+         *  Must be a power of 2.
+         */
+        private static final int INITIAL_ENTRIES = 32;
+
+        /** Build a backing map for ClassValues, relative the given type.
+         *  Also, create an empty cache array and install it on the class.
+         */
+        ClassValueMap(Class<?> type) {
+            this.type = type;
+            sizeCache(INITIAL_ENTRIES);
+        }
+
+        Entry<?>[] getCache() { return cacheArray; }
+
+        /** Initiate a query.  Store a promise (placeholder) if there is no value yet. */
+        synchronized
+        <T> Entry<T> startEntry(ClassValue<T> classValue) {
+            @SuppressWarnings("unchecked")  // one map has entries for all value types <T>
+            Entry<T> e = (Entry<T>) get(classValue.identity);
+            Version<T> v = classValue.version();
+            if (e == null) {
+                e = v.promise();
+                // The presence of a promise means that a value is pending for v.
+                // Eventually, finishEntry will overwrite the promise.
+                put(classValue.identity, e);
+                // Note that the promise is never entered into the cache!
+                return e;
+            } else if (e.isPromise()) {
+                // Somebody else has asked the same question.
+                // Let the races begin!
+                if (e.version() != v) {
+                    e = v.promise();
+                    put(classValue.identity, e);
+                }
+                return e;
+            } else {
+                // there is already a completed entry here; report it
+                if (e.version() != v) {
+                    // There is a stale but valid entry here; make it fresh again.
+                    // Once an entry is in the hash table, we don't care what its version is.
+                    e = e.refreshVersion(v);
+                    put(classValue.identity, e);
+                }
+                // Add to the cache, to enable the fast path, next time.
+                checkCacheLoad();
+                addToCache(classValue, e);
+                return e;
+            }
+        }
+
+        /** Finish a query.  Overwrite a matching placeholder.  Drop stale incoming values. */
+        synchronized
+        <T> Entry<T> finishEntry(ClassValue<T> classValue, Entry<T> e) {
+            @SuppressWarnings("unchecked")  // one map has entries for all value types <T>
+            Entry<T> e0 = (Entry<T>) get(classValue.identity);
+            if (e == e0) {
+                // We can get here during exception processing, unwinding from computeValue.
+                assert(e.isPromise());
+                remove(classValue.identity);
+                return null;
+            } else if (e0 != null && e0.isPromise() && e0.version() == e.version()) {
+                // If e0 matches the intended entry, there has not been a remove call
+                // between the previous startEntry and now.  So now overwrite e0.
+                Version<T> v = classValue.version();
+                if (e.version() != v)
+                    e = e.refreshVersion(v);
+                put(classValue.identity, e);
+                // Add to the cache, to enable the fast path, next time.
+                checkCacheLoad();
+                addToCache(classValue, e);
+                return e;
+            } else {
+                // Some sort of mismatch; caller must try again.
+                return null;
+            }
+        }
+
+        /** Remove an entry. */
+        synchronized
+        void removeEntry(ClassValue<?> classValue) {
+            Entry<?> e = remove(classValue.identity);
+            if (e == null) {
+                // Uninitialized, and no pending calls to computeValue.  No change.
+            } else if (e.isPromise()) {
+                // State is uninitialized, with a pending call to finishEntry.
+                // Since remove is a no-op in such a state, keep the promise
+                // by putting it back into the map.
+                put(classValue.identity, e);
+            } else {
+                // In an initialized state.  Bump forward, and de-initialize.
+                classValue.bumpVersion();
+                // Make all cache elements for this guy go stale.
+                removeStaleEntries(classValue);
+            }
+        }
+
+        /** Change the value for an entry. */
+        synchronized
+        <T> void changeEntry(ClassValue<T> classValue, T value) {
+            @SuppressWarnings("unchecked")  // one map has entries for all value types <T>
+            Entry<T> e0 = (Entry<T>) get(classValue.identity);
+            Version<T> version = classValue.version();
+            if (e0 != null) {
+                if (e0.version() == version && e0.value() == value)
+                    // no value change => no version change needed
+                    return;
+                classValue.bumpVersion();
+                removeStaleEntries(classValue);
+            }
+            Entry<T> e = makeEntry(version, value);
+            put(classValue.identity, e);
+            // Add to the cache, to enable the fast path, next time.
+            checkCacheLoad();
+            addToCache(classValue, e);
+        }
+
+        /// --------
+        /// Cache management.
+        /// --------
+
+        // Statics do not need synchronization.
+
+        /** Load the cache entry at the given (hashed) location. */
+        static Entry<?> loadFromCache(Entry<?>[] cache, int i) {
+            // non-racing cache.length : constant
+            // racing cache[i & (mask)] : null <=> Entry
+            return cache[i & (cache.length-1)];
+            // invariant:  returned value is null or well-constructed (ready to match)
+        }
+
+        /** Look in the cache, at the home location for the given ClassValue. */
+        static <T> Entry<T> probeHomeLocation(Entry<?>[] cache, ClassValue<T> classValue) {
+            return classValue.castEntry(loadFromCache(cache, classValue.hashCodeForCache));
+        }
+
+        /** Given that first probe was a collision, retry at nearby locations. */
+        static <T> Entry<T> probeBackupLocations(Entry<?>[] cache, ClassValue<T> classValue) {
+            if (PROBE_LIMIT <= 0)  return null;
+            // Probe the cache carefully, in a range of slots.
+            int mask = (cache.length-1);
+            int home = (classValue.hashCodeForCache & mask);
+            Entry<?> e2 = cache[home];  // victim, if we find the real guy
+            if (e2 == null) {
+                return null;   // if nobody is at home, no need to search nearby
+            }
+            // assume !classValue.match(e2), but do not assert, because of races
+            int pos2 = -1;
+            for (int i = home + 1; i < home + PROBE_LIMIT; i++) {
+                Entry<?> e = cache[i & mask];
+                if (e == null) {
+                    break;   // only search within non-null runs
+                }
+                if (classValue.match(e)) {
+                    // relocate colliding entry e2 (from cache[home]) to first empty slot
+                    cache[home] = e;
+                    if (pos2 >= 0) {
+                        cache[i & mask] = Entry.DEAD_ENTRY;
+                    } else {
+                        pos2 = i;
+                    }
+                    cache[pos2 & mask] = ((entryDislocation(cache, pos2, e2) < PROBE_LIMIT)
+                                          ? e2                  // put e2 here if it fits
+                                          : Entry.DEAD_ENTRY);
+                    return classValue.castEntry(e);
+                }
+                // Remember first empty slot, if any:
+                if (!e.isLive() && pos2 < 0)  pos2 = i;
+            }
+            return null;
+        }
+
+        /** How far out of place is e? */
+        private static int entryDislocation(Entry<?>[] cache, int pos, Entry<?> e) {
+            ClassValue<?> cv = e.classValueOrNull();
+            if (cv == null)  return 0;  // entry is not live!
+            int mask = (cache.length-1);
+            return (pos - cv.hashCodeForCache) & mask;
+        }
+
+        /// --------
+        /// Below this line all functions are private, and assume synchronized access.
+        /// --------
+
+        private void sizeCache(int length) {
+            assert((length & (length-1)) == 0);  // must be power of 2
+            cacheLoad = 0;
+            cacheLoadLimit = (int) ((double) length * CACHE_LOAD_LIMIT / 100);
+            cacheArray = new Entry<?>[length];
+        }
+
+        /** Make sure the cache load stays below its limit, if possible. */
+        private void checkCacheLoad() {
+            if (cacheLoad >= cacheLoadLimit) {
+                reduceCacheLoad();
+            }
+        }
+        private void reduceCacheLoad() {
+            removeStaleEntries();
+            if (cacheLoad < cacheLoadLimit)
+                return;  // win
+            Entry<?>[] oldCache = getCache();
+            if (oldCache.length > HASH_MASK)
+                return;  // lose
+            sizeCache(oldCache.length * 2);
+            for (Entry<?> e : oldCache) {
+                if (e != null && e.isLive()) {
+                    addToCache(e);
+                }
+            }
+        }
+
+        /** Remove stale entries in the given range.
+         *  Should be executed under a Map lock.
+         */
+        private void removeStaleEntries(Entry<?>[] cache, int begin, int count) {
+            if (PROBE_LIMIT <= 0)  return;
+            int mask = (cache.length-1);
+            int removed = 0;
+            for (int i = begin; i < begin + count; i++) {
+                Entry<?> e = cache[i & mask];
+                if (e == null || e.isLive())
+                    continue;  // skip null and live entries
+                Entry<?> replacement = null;
+                if (PROBE_LIMIT > 1) {
+                    // avoid breaking up a non-null run
+                    replacement = findReplacement(cache, i);
+                }
+                cache[i & mask] = replacement;
+                if (replacement == null)  removed += 1;
+            }
+            cacheLoad = Math.max(0, cacheLoad - removed);
+        }
+
+        /** Clearing a cache slot risks disconnecting following entries
+         *  from the head of a non-null run, which would allow them
+         *  to be found via reprobes.  Find an entry after cache[begin]
+         *  to plug into the hole, or return null if none is needed.
+         */
+        private Entry<?> findReplacement(Entry<?>[] cache, int home1) {
+            Entry<?> replacement = null;
+            int haveReplacement = -1, replacementPos = 0;
+            int mask = (cache.length-1);
+            for (int i2 = home1 + 1; i2 < home1 + PROBE_LIMIT; i2++) {
+                Entry<?> e2 = cache[i2 & mask];
+                if (e2 == null)  break;  // End of non-null run.
+                if (!e2.isLive())  continue;  // Doomed anyway.
+                int dis2 = entryDislocation(cache, i2, e2);
+                if (dis2 == 0)  continue;  // e2 already optimally placed
+                int home2 = i2 - dis2;
+                if (home2 <= home1) {
+                    // e2 can replace entry at cache[home1]
+                    if (home2 == home1) {
+                        // Put e2 exactly where he belongs.
+                        haveReplacement = 1;
+                        replacementPos = i2;
+                        replacement = e2;
+                    } else if (haveReplacement <= 0) {
+                        haveReplacement = 0;
+                        replacementPos = i2;
+                        replacement = e2;
+                    }
+                    // And keep going, so we can favor larger dislocations.
+                }
+            }
+            if (haveReplacement >= 0) {
+                if (cache[(replacementPos+1) & mask] != null) {
+                    // Be conservative, to avoid breaking up a non-null run.
+                    cache[replacementPos & mask] = (Entry<?>) Entry.DEAD_ENTRY;
+                } else {
+                    cache[replacementPos & mask] = null;
+                    cacheLoad -= 1;
+                }
+            }
+            return replacement;
+        }
+
+        /** Remove stale entries in the range near classValue. */
+        private void removeStaleEntries(ClassValue<?> classValue) {
+            removeStaleEntries(getCache(), classValue.hashCodeForCache, PROBE_LIMIT);
+        }
+
+        /** Remove all stale entries, everywhere. */
+        private void removeStaleEntries() {
+            Entry<?>[] cache = getCache();
+            removeStaleEntries(cache, 0, cache.length + PROBE_LIMIT - 1);
+        }
+
+        /** Add the given entry to the cache, in its home location, unless it is out of date. */
+        private <T> void addToCache(Entry<T> e) {
+            ClassValue<T> classValue = e.classValueOrNull();
+            if (classValue != null)
+                addToCache(classValue, e);
+        }
+
+        /** Add the given entry to the cache, in its home location. */
+        private <T> void addToCache(ClassValue<T> classValue, Entry<T> e) {
+            if (PROBE_LIMIT <= 0)  return;  // do not fill cache
+            // Add e to the cache.
+            Entry<?>[] cache = getCache();
+            int mask = (cache.length-1);
+            int home = classValue.hashCodeForCache & mask;
+            Entry<?> e2 = placeInCache(cache, home, e, false);
+            if (e2 == null)  return;  // done
+            if (PROBE_LIMIT > 1) {
+                // try to move e2 somewhere else in his probe range
+                int dis2 = entryDislocation(cache, home, e2);
+                int home2 = home - dis2;
+                for (int i2 = home2; i2 < home2 + PROBE_LIMIT; i2++) {
+                    if (placeInCache(cache, i2 & mask, e2, true) == null) {
+                        return;
+                    }
+                }
+            }
+            // Note:  At this point, e2 is just dropped from the cache.
+        }
+
+        /** Store the given entry.  Update cacheLoad, and return any live victim.
+         *  'Gently' means return self rather than dislocating a live victim.
+         */
+        private Entry<?> placeInCache(Entry<?>[] cache, int pos, Entry<?> e, boolean gently) {
+            Entry<?> e2 = overwrittenEntry(cache[pos]);
+            if (gently && e2 != null) {
+                // do not overwrite a live entry
+                return e;
+            } else {
+                cache[pos] = e;
+                return e2;
+            }
+        }
+
+        /** Note an entry that is about to be overwritten.
+         *  If it is not live, quietly replace it by null.
+         *  If it is an actual null, increment cacheLoad,
+         *  because the caller is going to store something
+         *  in its place.
+         */
+        private <T> Entry<T> overwrittenEntry(Entry<T> e2) {
+            if (e2 == null)  cacheLoad += 1;
+            else if (e2.isLive())  return e2;
+            return null;
+        }
+
+        /** Percent loading of cache before resize. */
+        private static final int CACHE_LOAD_LIMIT = 67;  // 0..100
+        /** Maximum number of probes to attempt. */
+        private static final int PROBE_LIMIT      =  6;       // 1..
+        // N.B.  Set PROBE_LIMIT=0 to disable all fast paths.
+    }
+}

jdkSrc/jdk8/java/lang/CloneNotSupportedException.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * Thrown to indicate that the <code>clone</code> method in class
+ * <code>Object</code> has been called to clone an object, but that
+ * the object's class does not implement the <code>Cloneable</code>
+ * interface.
+ * <p>
+ * Applications that override the <code>clone</code> method can also
+ * throw this exception to indicate that an object could not or
+ * should not be cloned.
+ *
+ * @author  unascribed
+ * @see     java.lang.Cloneable
+ * @see     java.lang.Object#clone()
+ * @since   JDK1.0
+ */
+
+public
+class CloneNotSupportedException extends Exception {
+    private static final long serialVersionUID = 5195511250079656443L;
+
+    /**
+     * Constructs a <code>CloneNotSupportedException</code> with no
+     * detail message.
+     */
+    public CloneNotSupportedException() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>CloneNotSupportedException</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public CloneNotSupportedException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/Cloneable.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 1995, 2004, 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;
+
+/**
+ * A class implements the <code>Cloneable</code> interface to
+ * indicate to the {@link java.lang.Object#clone()} method that it
+ * is legal for that method to make a
+ * field-for-field copy of instances of that class.
+ * <p>
+ * Invoking Object's clone method on an instance that does not implement the
+ * <code>Cloneable</code> interface results in the exception
+ * <code>CloneNotSupportedException</code> being thrown.
+ * <p>
+ * By convention, classes that implement this interface should override
+ * <tt>Object.clone</tt> (which is protected) with a public method.
+ * See {@link java.lang.Object#clone()} for details on overriding this
+ * method.
+ * <p>
+ * Note that this interface does <i>not</i> contain the <tt>clone</tt> method.
+ * Therefore, it is not possible to clone an object merely by virtue of the
+ * fact that it implements this interface.  Even if the clone method is invoked
+ * reflectively, there is no guarantee that it will succeed.
+ *
+ * @author  unascribed
+ * @see     java.lang.CloneNotSupportedException
+ * @see     java.lang.Object#clone()
+ * @since   JDK1.0
+ */
+public interface Cloneable {
+}

jdkSrc/jdk8/java/lang/Comparable.java

@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 1997, 2013, 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.util.*;
+
+/**
+ * This interface imposes a total ordering on the objects of each class that
+ * implements it.  This ordering is referred to as the class's <i>natural
+ * ordering</i>, and the class's <tt>compareTo</tt> method is referred to as
+ * its <i>natural comparison method</i>.<p>
+ *
+ * Lists (and arrays) of objects that implement this interface can be sorted
+ * automatically by {@link Collections#sort(List) Collections.sort} (and
+ * {@link Arrays#sort(Object[]) Arrays.sort}).  Objects that implement this
+ * interface can be used as keys in a {@linkplain SortedMap sorted map} or as
+ * elements in a {@linkplain SortedSet sorted set}, without the need to
+ * specify a {@linkplain Comparator comparator}.<p>
+ *
+ * The natural ordering for a class <tt>C</tt> is said to be <i>consistent
+ * with equals</i> if and only if <tt>e1.compareTo(e2) == 0</tt> has
+ * the same boolean value as <tt>e1.equals(e2)</tt> for every
+ * <tt>e1</tt> and <tt>e2</tt> of class <tt>C</tt>.  Note that <tt>null</tt>
+ * is not an instance of any class, and <tt>e.compareTo(null)</tt> should
+ * throw a <tt>NullPointerException</tt> even though <tt>e.equals(null)</tt>
+ * returns <tt>false</tt>.<p>
+ *
+ * It is strongly recommended (though not required) that natural orderings be
+ * consistent with equals.  This is so because sorted sets (and sorted maps)
+ * without explicit comparators behave "strangely" when they are used with
+ * elements (or keys) whose natural ordering is inconsistent with equals.  In
+ * particular, such a sorted set (or sorted map) violates the general contract
+ * for set (or map), which is defined in terms of the <tt>equals</tt>
+ * method.<p>
+ *
+ * For example, if one adds two keys <tt>a</tt> and <tt>b</tt> such that
+ * {@code (!a.equals(b) && a.compareTo(b) == 0)} to a sorted
+ * set that does not use an explicit comparator, the second <tt>add</tt>
+ * operation returns false (and the size of the sorted set does not increase)
+ * because <tt>a</tt> and <tt>b</tt> are equivalent from the sorted set's
+ * perspective.<p>
+ *
+ * Virtually all Java core classes that implement <tt>Comparable</tt> have natural
+ * orderings that are consistent with equals.  One exception is
+ * <tt>java.math.BigDecimal</tt>, whose natural ordering equates
+ * <tt>BigDecimal</tt> objects with equal values and different precisions
+ * (such as 4.0 and 4.00).<p>
+ *
+ * For the mathematically inclined, the <i>relation</i> that defines
+ * the natural ordering on a given class C is:<pre>
+ *       {(x, y) such that x.compareTo(y) &lt;= 0}.
+ * </pre> The <i>quotient</i> for this total order is: <pre>
+ *       {(x, y) such that x.compareTo(y) == 0}.
+ * </pre>
+ *
+ * It follows immediately from the contract for <tt>compareTo</tt> that the
+ * quotient is an <i>equivalence relation</i> on <tt>C</tt>, and that the
+ * natural ordering is a <i>total order</i> on <tt>C</tt>.  When we say that a
+ * class's natural ordering is <i>consistent with equals</i>, we mean that the
+ * quotient for the natural ordering is the equivalence relation defined by
+ * the class's {@link Object#equals(Object) equals(Object)} method:<pre>
+ *     {(x, y) such that x.equals(y)}. </pre><p>
+ *
+ * This interface is a member of the
+ * <a href="{@docRoot}/../technotes/guides/collections/index.html">
+ * Java Collections Framework</a>.
+ *
+ * @param <T> the type of objects that this object may be compared to
+ *
+ * @author  Josh Bloch
+ * @see java.util.Comparator
+ * @since 1.2
+ */
+public interface Comparable<T> {
+    /**
+     * Compares this object with the specified object for order.  Returns a
+     * negative integer, zero, or a positive integer as this object is less
+     * than, equal to, or greater than the specified object.
+     *
+     * <p>The implementor must ensure <tt>sgn(x.compareTo(y)) ==
+     * -sgn(y.compareTo(x))</tt> for all <tt>x</tt> and <tt>y</tt>.  (This
+     * implies that <tt>x.compareTo(y)</tt> must throw an exception iff
+     * <tt>y.compareTo(x)</tt> throws an exception.)
+     *
+     * <p>The implementor must also ensure that the relation is transitive:
+     * <tt>(x.compareTo(y)&gt;0 &amp;&amp; y.compareTo(z)&gt;0)</tt> implies
+     * <tt>x.compareTo(z)&gt;0</tt>.
+     *
+     * <p>Finally, the implementor must ensure that <tt>x.compareTo(y)==0</tt>
+     * implies that <tt>sgn(x.compareTo(z)) == sgn(y.compareTo(z))</tt>, for
+     * all <tt>z</tt>.
+     *
+     * <p>It is strongly recommended, but <i>not</i> strictly required that
+     * <tt>(x.compareTo(y)==0) == (x.equals(y))</tt>.  Generally speaking, any
+     * class that implements the <tt>Comparable</tt> interface and violates
+     * this condition should clearly indicate this fact.  The recommended
+     * language is "Note: this class has a natural ordering that is
+     * inconsistent with equals."
+     *
+     * <p>In the foregoing description, the notation
+     * <tt>sgn(</tt><i>expression</i><tt>)</tt> designates the mathematical
+     * <i>signum</i> function, which is defined to return one of <tt>-1</tt>,
+     * <tt>0</tt>, or <tt>1</tt> according to whether the value of
+     * <i>expression</i> is negative, zero or positive.
+     *
+     * @param   o the object to be compared.
+     * @return  a negative integer, zero, or a positive integer as this object
+     *          is less than, equal to, or greater than the specified object.
+     *
+     * @throws NullPointerException if the specified object is null
+     * @throws ClassCastException if the specified object's type prevents it
+     *         from being compared to this object.
+     */
+    public int compareTo(T o);
+}

jdkSrc/jdk8/java/lang/Compiler.java

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * The {@code Compiler} class is provided to support Java-to-native-code
+ * compilers and related services. By design, the {@code Compiler} class does
+ * nothing; it serves as a placeholder for a JIT compiler implementation.
+ *
+ * <p> When the Java Virtual Machine first starts, it determines if the system
+ * property {@code java.compiler} exists. (System properties are accessible
+ * through {@link System#getProperty(String)} and {@link
+ * System#getProperty(String, String)}.  If so, it is assumed to be the name of
+ * a library (with a platform-dependent exact location and type); {@link
+ * System#loadLibrary} is called to load that library. If this loading
+ * succeeds, the function named {@code java_lang_Compiler_start()} in that
+ * library is called.
+ *
+ * <p> If no compiler is available, these methods do nothing.
+ *
+ * @author  Frank Yellin
+ * @since   JDK1.0
+ */
+public final class Compiler  {
+    private Compiler() {}               // don't make instances
+
+    private static native void initialize();
+
+    private static native void registerNatives();
+
+    static {
+        registerNatives();
+        java.security.AccessController.doPrivileged(
+            new java.security.PrivilegedAction<Void>() {
+                public Void run() {
+                    boolean loaded = false;
+                    String jit = System.getProperty("java.compiler");
+                    if ((jit != null) && (!jit.equals("NONE")) &&
+                        (!jit.equals("")))
+                    {
+                        try {
+                            System.loadLibrary(jit);
+                            initialize();
+                            loaded = true;
+                        } catch (UnsatisfiedLinkError e) {
+                            System.err.println("Warning: JIT compiler \"" +
+                              jit + "\" not found. Will use interpreter.");
+                        }
+                    }
+                    String info = System.getProperty("java.vm.info");
+                    if (loaded) {
+                        System.setProperty("java.vm.info", info + ", " + jit);
+                    } else {
+                        System.setProperty("java.vm.info", info + ", nojit");
+                    }
+                    return null;
+                }
+            });
+    }
+
+    /**
+     * Compiles the specified class.
+     *
+     * @param  clazz
+     *         A class
+     *
+     * @return  {@code true} if the compilation succeeded; {@code false} if the
+     *          compilation failed or no compiler is available
+     *
+     * @throws  NullPointerException
+     *          If {@code clazz} is {@code null}
+     */
+    public static native boolean compileClass(Class<?> clazz);
+
+    /**
+     * Compiles all classes whose name matches the specified string.
+     *
+     * @param  string
+     *         The name of the classes to compile
+     *
+     * @return  {@code true} if the compilation succeeded; {@code false} if the
+     *          compilation failed or no compiler is available
+     *
+     * @throws  NullPointerException
+     *          If {@code string} is {@code null}
+     */
+    public static native boolean compileClasses(String string);
+
+    /**
+     * Examines the argument type and its fields and perform some documented
+     * operation.  No specific operations are required.
+     *
+     * @param  any
+     *         An argument
+     *
+     * @return  A compiler-specific value, or {@code null} if no compiler is
+     *          available
+     *
+     * @throws  NullPointerException
+     *          If {@code any} is {@code null}
+     */
+    public static native Object command(Object any);
+
+    /**
+     * Cause the Compiler to resume operation.
+     */
+    public static native void enable();
+
+    /**
+     * Cause the Compiler to cease operation.
+     */
+    public static native void disable();
+}

jdkSrc/jdk8/java/lang/ConditionalSpecialCasing.java

@@ -0,0 +1,472 @@
+/*
+ * Copyright (c) 2003, 2013, 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.text.BreakIterator;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Locale;
+import sun.text.Normalizer;
+
+
+/**
+ * This is a utility class for <code>String.toLowerCase()</code> and
+ * <code>String.toUpperCase()</code>, that handles special casing with
+ * conditions.  In other words, it handles the mappings with conditions
+ * that are defined in
+ * <a href="http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt">Special
+ * Casing Properties</a> file.
+ * <p>
+ * Note that the unconditional case mappings (including 1:M mappings)
+ * are handled in <code>Character.toLower/UpperCase()</code>.
+ */
+final class ConditionalSpecialCasing {
+
+    // context conditions.
+    final static int FINAL_CASED =              1;
+    final static int AFTER_SOFT_DOTTED =        2;
+    final static int MORE_ABOVE =               3;
+    final static int AFTER_I =                  4;
+    final static int NOT_BEFORE_DOT =           5;
+
+    // combining class definitions
+    final static int COMBINING_CLASS_ABOVE = 230;
+
+    // Special case mapping entries
+    static Entry[] entry = {
+        //# ================================================================================
+        //# Conditional mappings
+        //# ================================================================================
+        new Entry(0x03A3, new char[]{0x03C2}, new char[]{0x03A3}, null, FINAL_CASED), // # GREEK CAPITAL LETTER SIGMA
+        new Entry(0x0130, new char[]{0x0069, 0x0307}, new char[]{0x0130}, null, 0), // # LATIN CAPITAL LETTER I WITH DOT ABOVE
+
+        //# ================================================================================
+        //# Locale-sensitive mappings
+        //# ================================================================================
+        //# Lithuanian
+        new Entry(0x0307, new char[]{0x0307}, new char[]{}, "lt",  AFTER_SOFT_DOTTED), // # COMBINING DOT ABOVE
+        new Entry(0x0049, new char[]{0x0069, 0x0307}, new char[]{0x0049}, "lt", MORE_ABOVE), // # LATIN CAPITAL LETTER I
+        new Entry(0x004A, new char[]{0x006A, 0x0307}, new char[]{0x004A}, "lt", MORE_ABOVE), // # LATIN CAPITAL LETTER J
+        new Entry(0x012E, new char[]{0x012F, 0x0307}, new char[]{0x012E}, "lt", MORE_ABOVE), // # LATIN CAPITAL LETTER I WITH OGONEK
+        new Entry(0x00CC, new char[]{0x0069, 0x0307, 0x0300}, new char[]{0x00CC}, "lt", 0), // # LATIN CAPITAL LETTER I WITH GRAVE
+        new Entry(0x00CD, new char[]{0x0069, 0x0307, 0x0301}, new char[]{0x00CD}, "lt", 0), // # LATIN CAPITAL LETTER I WITH ACUTE
+        new Entry(0x0128, new char[]{0x0069, 0x0307, 0x0303}, new char[]{0x0128}, "lt", 0), // # LATIN CAPITAL LETTER I WITH TILDE
+
+        //# ================================================================================
+        //# Turkish and Azeri
+        new Entry(0x0130, new char[]{0x0069}, new char[]{0x0130}, "tr", 0), // # LATIN CAPITAL LETTER I WITH DOT ABOVE
+        new Entry(0x0130, new char[]{0x0069}, new char[]{0x0130}, "az", 0), // # LATIN CAPITAL LETTER I WITH DOT ABOVE
+        new Entry(0x0307, new char[]{}, new char[]{0x0307}, "tr", AFTER_I), // # COMBINING DOT ABOVE
+        new Entry(0x0307, new char[]{}, new char[]{0x0307}, "az", AFTER_I), // # COMBINING DOT ABOVE
+        new Entry(0x0049, new char[]{0x0131}, new char[]{0x0049}, "tr", NOT_BEFORE_DOT), // # LATIN CAPITAL LETTER I
+        new Entry(0x0049, new char[]{0x0131}, new char[]{0x0049}, "az", NOT_BEFORE_DOT), // # LATIN CAPITAL LETTER I
+        new Entry(0x0069, new char[]{0x0069}, new char[]{0x0130}, "tr", 0), // # LATIN SMALL LETTER I
+        new Entry(0x0069, new char[]{0x0069}, new char[]{0x0130}, "az", 0)  // # LATIN SMALL LETTER I
+    };
+
+    // A hash table that contains the above entries
+    static Hashtable<Integer, HashSet<Entry>> entryTable = new Hashtable<>();
+    static {
+        // create hashtable from the entry
+        for (int i = 0; i < entry.length; i ++) {
+            Entry cur = entry[i];
+            Integer cp = new Integer(cur.getCodePoint());
+            HashSet<Entry> set = entryTable.get(cp);
+            if (set == null) {
+                set = new HashSet<Entry>();
+            }
+            set.add(cur);
+            entryTable.put(cp, set);
+        }
+    }
+
+    static int toLowerCaseEx(String src, int index, Locale locale) {
+        char[] result = lookUpTable(src, index, locale, true);
+
+        if (result != null) {
+            if (result.length == 1) {
+                return result[0];
+            } else {
+                return Character.ERROR;
+            }
+        } else {
+            // default to Character class' one
+            return Character.toLowerCase(src.codePointAt(index));
+        }
+    }
+
+    static int toUpperCaseEx(String src, int index, Locale locale) {
+        char[] result = lookUpTable(src, index, locale, false);
+
+        if (result != null) {
+            if (result.length == 1) {
+                return result[0];
+            } else {
+                return Character.ERROR;
+            }
+        } else {
+            // default to Character class' one
+            return Character.toUpperCaseEx(src.codePointAt(index));
+        }
+    }
+
+    static char[] toLowerCaseCharArray(String src, int index, Locale locale) {
+        return lookUpTable(src, index, locale, true);
+    }
+
+    static char[] toUpperCaseCharArray(String src, int index, Locale locale) {
+        char[] result = lookUpTable(src, index, locale, false);
+        if (result != null) {
+            return result;
+        } else {
+            return Character.toUpperCaseCharArray(src.codePointAt(index));
+        }
+    }
+
+    private static char[] lookUpTable(String src, int index, Locale locale, boolean bLowerCasing) {
+        HashSet<Entry> set = entryTable.get(new Integer(src.codePointAt(index)));
+        char[] ret = null;
+
+        if (set != null) {
+            Iterator<Entry> iter = set.iterator();
+            String currentLang = locale.getLanguage();
+            while (iter.hasNext()) {
+                Entry entry = iter.next();
+                String conditionLang = entry.getLanguage();
+                if (((conditionLang == null) || (conditionLang.equals(currentLang))) &&
+                        isConditionMet(src, index, locale, entry.getCondition())) {
+                    ret = bLowerCasing ? entry.getLowerCase() : entry.getUpperCase();
+                    if (conditionLang != null) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        return ret;
+    }
+
+    private static boolean isConditionMet(String src, int index, Locale locale, int condition) {
+        switch (condition) {
+        case FINAL_CASED:
+            return isFinalCased(src, index, locale);
+
+        case AFTER_SOFT_DOTTED:
+            return isAfterSoftDotted(src, index);
+
+        case MORE_ABOVE:
+            return isMoreAbove(src, index);
+
+        case AFTER_I:
+            return isAfterI(src, index);
+
+        case NOT_BEFORE_DOT:
+            return !isBeforeDot(src, index);
+
+        default:
+            return true;
+        }
+    }
+
+    /**
+     * Implements the "Final_Cased" condition
+     *
+     * Specification: Within the closest word boundaries containing C, there is a cased
+     * letter before C, and there is no cased letter after C.
+     *
+     * Regular Expression:
+     *   Before C: [{cased==true}][{wordBoundary!=true}]*
+     *   After C: !([{wordBoundary!=true}]*[{cased}])
+     */
+    private static boolean isFinalCased(String src, int index, Locale locale) {
+        BreakIterator wordBoundary = BreakIterator.getWordInstance(locale);
+        wordBoundary.setText(src);
+        int ch;
+
+        // Look for a preceding 'cased' letter
+        for (int i = index; (i >= 0) && !wordBoundary.isBoundary(i);
+                i -= Character.charCount(ch)) {
+
+            ch = src.codePointBefore(i);
+            if (isCased(ch)) {
+
+                int len = src.length();
+                // Check that there is no 'cased' letter after the index
+                for (i = index + Character.charCount(src.codePointAt(index));
+                        (i < len) && !wordBoundary.isBoundary(i);
+                        i += Character.charCount(ch)) {
+
+                    ch = src.codePointAt(i);
+                    if (isCased(ch)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Implements the "After_I" condition
+     *
+     * Specification: The last preceding base character was an uppercase I,
+     * and there is no intervening combining character class 230 (ABOVE).
+     *
+     * Regular Expression:
+     *   Before C: [I]([{cc!=230}&{cc!=0}])*
+     */
+    private static boolean isAfterI(String src, int index) {
+        int ch;
+        int cc;
+
+        // Look for the last preceding base character
+        for (int i = index; i > 0; i -= Character.charCount(ch)) {
+
+            ch = src.codePointBefore(i);
+
+            if (ch == 'I') {
+                return true;
+            } else {
+                cc = Normalizer.getCombiningClass(ch);
+                if ((cc == 0) || (cc == COMBINING_CLASS_ABOVE)) {
+                    return false;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Implements the "After_Soft_Dotted" condition
+     *
+     * Specification: The last preceding character with combining class
+     * of zero before C was Soft_Dotted, and there is no intervening
+     * combining character class 230 (ABOVE).
+     *
+     * Regular Expression:
+     *   Before C: [{Soft_Dotted==true}]([{cc!=230}&{cc!=0}])*
+     */
+    private static boolean isAfterSoftDotted(String src, int index) {
+        int ch;
+        int cc;
+
+        // Look for the last preceding character
+        for (int i = index; i > 0; i -= Character.charCount(ch)) {
+
+            ch = src.codePointBefore(i);
+
+            if (isSoftDotted(ch)) {
+                return true;
+            } else {
+                cc = Normalizer.getCombiningClass(ch);
+                if ((cc == 0) || (cc == COMBINING_CLASS_ABOVE)) {
+                    return false;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Implements the "More_Above" condition
+     *
+     * Specification: C is followed by one or more characters of combining
+     * class 230 (ABOVE) in the combining character sequence.
+     *
+     * Regular Expression:
+     *   After C: [{cc!=0}]*[{cc==230}]
+     */
+    private static boolean isMoreAbove(String src, int index) {
+        int ch;
+        int cc;
+        int len = src.length();
+
+        // Look for a following ABOVE combining class character
+        for (int i = index + Character.charCount(src.codePointAt(index));
+                i < len; i += Character.charCount(ch)) {
+
+            ch = src.codePointAt(i);
+            cc = Normalizer.getCombiningClass(ch);
+
+            if (cc == COMBINING_CLASS_ABOVE) {
+                return true;
+            } else if (cc == 0) {
+                return false;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Implements the "Before_Dot" condition
+     *
+     * Specification: C is followed by <code>U+0307 COMBINING DOT ABOVE</code>.
+     * Any sequence of characters with a combining class that is
+     * neither 0 nor 230 may intervene between the current character
+     * and the combining dot above.
+     *
+     * Regular Expression:
+     *   After C: ([{cc!=230}&{cc!=0}])*[\u0307]
+     */
+    private static boolean isBeforeDot(String src, int index) {
+        int ch;
+        int cc;
+        int len = src.length();
+
+        // Look for a following COMBINING DOT ABOVE
+        for (int i = index + Character.charCount(src.codePointAt(index));
+                i < len; i += Character.charCount(ch)) {
+
+            ch = src.codePointAt(i);
+
+            if (ch == '\u0307') {
+                return true;
+            } else {
+                cc = Normalizer.getCombiningClass(ch);
+                if ((cc == 0) || (cc == COMBINING_CLASS_ABOVE)) {
+                    return false;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Examines whether a character is 'cased'.
+     *
+     * A character C is defined to be 'cased' if and only if at least one of
+     * following are true for C: uppercase==true, or lowercase==true, or
+     * general_category==titlecase_letter.
+     *
+     * The uppercase and lowercase property values are specified in the data
+     * file DerivedCoreProperties.txt in the Unicode Character Database.
+     */
+    private static boolean isCased(int ch) {
+        int type = Character.getType(ch);
+        if (type == Character.LOWERCASE_LETTER ||
+                type == Character.UPPERCASE_LETTER ||
+                type == Character.TITLECASE_LETTER) {
+            return true;
+        } else {
+            // Check for Other_Lowercase and Other_Uppercase
+            //
+            if ((ch >= 0x02B0) && (ch <= 0x02B8)) {
+                // MODIFIER LETTER SMALL H..MODIFIER LETTER SMALL Y
+                return true;
+            } else if ((ch >= 0x02C0) && (ch <= 0x02C1)) {
+                // MODIFIER LETTER GLOTTAL STOP..MODIFIER LETTER REVERSED GLOTTAL STOP
+                return true;
+            } else if ((ch >= 0x02E0) && (ch <= 0x02E4)) {
+                // MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP
+                return true;
+            } else if (ch == 0x0345) {
+                // COMBINING GREEK YPOGEGRAMMENI
+                return true;
+            } else if (ch == 0x037A) {
+                // GREEK YPOGEGRAMMENI
+                return true;
+            } else if ((ch >= 0x1D2C) && (ch <= 0x1D61)) {
+                // MODIFIER LETTER CAPITAL A..MODIFIER LETTER SMALL CHI
+                return true;
+            } else if ((ch >= 0x2160) && (ch <= 0x217F)) {
+                // ROMAN NUMERAL ONE..ROMAN NUMERAL ONE THOUSAND
+                // SMALL ROMAN NUMERAL ONE..SMALL ROMAN NUMERAL ONE THOUSAND
+                return true;
+            } else if ((ch >= 0x24B6) && (ch <= 0x24E9)) {
+                // CIRCLED LATIN CAPITAL LETTER A..CIRCLED LATIN CAPITAL LETTER Z
+                // CIRCLED LATIN SMALL LETTER A..CIRCLED LATIN SMALL LETTER Z
+                return true;
+            } else {
+                return false;
+            }
+        }
+    }
+
+    private static boolean isSoftDotted(int ch) {
+        switch (ch) {
+        case 0x0069: // Soft_Dotted # L&       LATIN SMALL LETTER I
+        case 0x006A: // Soft_Dotted # L&       LATIN SMALL LETTER J
+        case 0x012F: // Soft_Dotted # L&       LATIN SMALL LETTER I WITH OGONEK
+        case 0x0268: // Soft_Dotted # L&       LATIN SMALL LETTER I WITH STROKE
+        case 0x0456: // Soft_Dotted # L&       CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
+        case 0x0458: // Soft_Dotted # L&       CYRILLIC SMALL LETTER JE
+        case 0x1D62: // Soft_Dotted # L&       LATIN SUBSCRIPT SMALL LETTER I
+        case 0x1E2D: // Soft_Dotted # L&       LATIN SMALL LETTER I WITH TILDE BELOW
+        case 0x1ECB: // Soft_Dotted # L&       LATIN SMALL LETTER I WITH DOT BELOW
+        case 0x2071: // Soft_Dotted # L&       SUPERSCRIPT LATIN SMALL LETTER I
+            return true;
+        default:
+            return false;
+        }
+    }
+
+    /**
+     * An internal class that represents an entry in the Special Casing Properties.
+     */
+    static class Entry {
+        int ch;
+        char [] lower;
+        char [] upper;
+        String lang;
+        int condition;
+
+        Entry(int ch, char[] lower, char[] upper, String lang, int condition) {
+            this.ch = ch;
+            this.lower = lower;
+            this.upper = upper;
+            this.lang = lang;
+            this.condition = condition;
+        }
+
+        int getCodePoint() {
+            return ch;
+        }
+
+        char[] getLowerCase() {
+            return lower;
+        }
+
+        char[] getUpperCase() {
+            return upper;
+        }
+
+        String getLanguage() {
+            return lang;
+        }
+
+        int getCondition() {
+            return condition;
+        }
+    }
+}

jdkSrc/jdk8/java/lang/Deprecated.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2003, 2013, 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.lang.annotation.*;
+import static java.lang.annotation.ElementType.*;
+
+/**
+ * A program element annotated @Deprecated is one that programmers
+ * are discouraged from using, typically because it is dangerous,
+ * or because a better alternative exists.  Compilers warn when a
+ * deprecated program element is used or overridden in non-deprecated code.
+ *
+ * @author  Neal Gafter
+ * @since 1.5
+ * @jls 9.6.3.6 @Deprecated
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
+public @interface Deprecated {
+}

jdkSrc/jdk8/java/lang/Enum.java

@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2003, 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.Serializable;
+import java.io.IOException;
+import java.io.InvalidObjectException;
+import java.io.ObjectInputStream;
+import java.io.ObjectStreamException;
+
+/**
+ * This is the common base class of all Java language enumeration types.
+ *
+ * More information about enums, including descriptions of the
+ * implicitly declared methods synthesized by the compiler, can be
+ * found in section 8.9 of
+ * <cite>The Java&trade; Language Specification</cite>.
+ *
+ * <p> Note that when using an enumeration type as the type of a set
+ * or as the type of the keys in a map, specialized and efficient
+ * {@linkplain java.util.EnumSet set} and {@linkplain
+ * java.util.EnumMap map} implementations are available.
+ *
+ * @param <E> The enum type subclass
+ * @author  Josh Bloch
+ * @author  Neal Gafter
+ * @see     Class#getEnumConstants()
+ * @see     java.util.EnumSet
+ * @see     java.util.EnumMap
+ * @since   1.5
+ */
+public abstract class Enum<E extends Enum<E>>
+        implements Comparable<E>, Serializable {
+    /**
+     * The name of this enum constant, as declared in the enum declaration.
+     * Most programmers should use the {@link #toString} method rather than
+     * accessing this field.
+     */
+    private final String name;
+
+    /**
+     * Returns the name of this enum constant, exactly as declared in its
+     * enum declaration.
+     *
+     * <b>Most programmers should use the {@link #toString} method in
+     * preference to this one, as the toString method may return
+     * a more user-friendly name.</b>  This method is designed primarily for
+     * use in specialized situations where correctness depends on getting the
+     * exact name, which will not vary from release to release.
+     *
+     * @return the name of this enum constant
+     */
+    public final String name() {
+        return name;
+    }
+
+    /**
+     * The ordinal of this enumeration constant (its position
+     * in the enum declaration, where the initial constant is assigned
+     * an ordinal of zero).
+     *
+     * Most programmers will have no use for this field.  It is designed
+     * for use by sophisticated enum-based data structures, such as
+     * {@link java.util.EnumSet} and {@link java.util.EnumMap}.
+     */
+    private final int ordinal;
+
+    /**
+     * Returns the ordinal of this enumeration constant (its position
+     * in its enum declaration, where the initial constant is assigned
+     * an ordinal of zero).
+     *
+     * Most programmers will have no use for this method.  It is
+     * designed for use by sophisticated enum-based data structures, such
+     * as {@link java.util.EnumSet} and {@link java.util.EnumMap}.
+     *
+     * @return the ordinal of this enumeration constant
+     */
+    public final int ordinal() {
+        return ordinal;
+    }
+
+    /**
+     * Sole constructor.  Programmers cannot invoke this constructor.
+     * It is for use by code emitted by the compiler in response to
+     * enum type declarations.
+     *
+     * @param name - The name of this enum constant, which is the identifier
+     *               used to declare it.
+     * @param ordinal - The ordinal of this enumeration constant (its position
+     *         in the enum declaration, where the initial constant is assigned
+     *         an ordinal of zero).
+     */
+    protected Enum(String name, int ordinal) {
+        this.name = name;
+        this.ordinal = ordinal;
+    }
+
+    /**
+     * Returns the name of this enum constant, as contained in the
+     * declaration.  This method may be overridden, though it typically
+     * isn't necessary or desirable.  An enum type should override this
+     * method when a more "programmer-friendly" string form exists.
+     *
+     * @return the name of this enum constant
+     */
+    public String toString() {
+        return name;
+    }
+
+    /**
+     * Returns true if the specified object is equal to this
+     * enum constant.
+     *
+     * @param other the object to be compared for equality with this object.
+     * @return  true if the specified object is equal to this
+     *          enum constant.
+     */
+    public final boolean equals(Object other) {
+        return this==other;
+    }
+
+    /**
+     * Returns a hash code for this enum constant.
+     *
+     * @return a hash code for this enum constant.
+     */
+    public final int hashCode() {
+        return super.hashCode();
+    }
+
+    /**
+     * Throws CloneNotSupportedException.  This guarantees that enums
+     * are never cloned, which is necessary to preserve their "singleton"
+     * status.
+     *
+     * @return (never returns)
+     */
+    protected final Object clone() throws CloneNotSupportedException {
+        throw new CloneNotSupportedException();
+    }
+
+    /**
+     * Compares this enum with the specified object for order.  Returns a
+     * negative integer, zero, or a positive integer as this object is less
+     * than, equal to, or greater than the specified object.
+     *
+     * Enum constants are only comparable to other enum constants of the
+     * same enum type.  The natural order implemented by this
+     * method is the order in which the constants are declared.
+     */
+    public final int compareTo(E o) {
+        Enum<?> other = (Enum<?>)o;
+        Enum<E> self = this;
+        if (self.getClass() != other.getClass() && // optimization
+            self.getDeclaringClass() != other.getDeclaringClass())
+            throw new ClassCastException();
+        return self.ordinal - other.ordinal;
+    }
+
+    /**
+     * Returns the Class object corresponding to this enum constant's
+     * enum type.  Two enum constants e1 and  e2 are of the
+     * same enum type if and only if
+     *   e1.getDeclaringClass() == e2.getDeclaringClass().
+     * (The value returned by this method may differ from the one returned
+     * by the {@link Object#getClass} method for enum constants with
+     * constant-specific class bodies.)
+     *
+     * @return the Class object corresponding to this enum constant's
+     *     enum type
+     */
+    @SuppressWarnings("unchecked")
+    public final Class<E> getDeclaringClass() {
+        Class<?> clazz = getClass();
+        Class<?> zuper = clazz.getSuperclass();
+        return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
+    }
+
+    /**
+     * Returns the enum constant of the specified enum type with the
+     * specified name.  The name must match exactly an identifier used
+     * to declare an enum constant in this type.  (Extraneous whitespace
+     * characters are not permitted.)
+     *
+     * <p>Note that for a particular enum type {@code T}, the
+     * implicitly declared {@code public static T valueOf(String)}
+     * method on that enum may be used instead of this method to map
+     * from a name to the corresponding enum constant.  All the
+     * constants of an enum type can be obtained by calling the
+     * implicit {@code public static T[] values()} method of that
+     * type.
+     *
+     * @param <T> The enum type whose constant is to be returned
+     * @param enumType the {@code Class} object of the enum type from which
+     *      to return a constant
+     * @param name the name of the constant to return
+     * @return the enum constant of the specified enum type with the
+     *      specified name
+     * @throws IllegalArgumentException if the specified enum type has
+     *         no constant with the specified name, or the specified
+     *         class object does not represent an enum type
+     * @throws NullPointerException if {@code enumType} or {@code name}
+     *         is null
+     * @since 1.5
+     */
+    public static <T extends Enum<T>> T valueOf(Class<T> enumType,
+                                                String name) {
+        T result = enumType.enumConstantDirectory().get(name);
+        if (result != null)
+            return result;
+        if (name == null)
+            throw new NullPointerException("Name is null");
+        throw new IllegalArgumentException(
+            "No enum constant " + enumType.getCanonicalName() + "." + name);
+    }
+
+    /**
+     * enum classes cannot have finalize methods.
+     */
+    protected final void finalize() { }
+
+    /**
+     * prevent default deserialization
+     */
+    private void readObject(ObjectInputStream in) throws IOException,
+        ClassNotFoundException {
+        throw new InvalidObjectException("can't deserialize enum");
+    }
+
+    private void readObjectNoData() throws ObjectStreamException {
+        throw new InvalidObjectException("can't deserialize enum");
+    }
+}

jdkSrc/jdk8/java/lang/EnumConstantNotPresentException.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2004, 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;
+
+/**
+ * Thrown when an application tries to access an enum constant by name
+ * and the enum type contains no constant with the specified name.
+ * This exception can be thrown by the {@linkplain
+ * java.lang.reflect.AnnotatedElement API used to read annotations
+ * reflectively}.
+ *
+ * @author  Josh Bloch
+ * @see     java.lang.reflect.AnnotatedElement
+ * @since   1.5
+ */
+@SuppressWarnings("rawtypes") /* rawtypes are part of the public api */
+public class EnumConstantNotPresentException extends RuntimeException {
+    private static final long serialVersionUID = -6046998521960521108L;
+
+    /**
+     * The type of the missing enum constant.
+     */
+    private Class<? extends Enum> enumType;
+
+    /**
+     * The name of the missing enum constant.
+     */
+    private String constantName;
+
+    /**
+     * Constructs an <tt>EnumConstantNotPresentException</tt> for the
+     * specified constant.
+     *
+     * @param enumType the type of the missing enum constant
+     * @param constantName the name of the missing enum constant
+     */
+    public EnumConstantNotPresentException(Class<? extends Enum> enumType,
+                                           String constantName) {
+        super(enumType.getName() + "." + constantName);
+        this.enumType = enumType;
+        this.constantName  = constantName;
+    }
+
+    /**
+     * Returns the type of the missing enum constant.
+     *
+     * @return the type of the missing enum constant
+     */
+    public Class<? extends Enum> enumType() { return enumType; }
+
+    /**
+     * Returns the name of the missing enum constant.
+     *
+     * @return the name of the missing enum constant
+     */
+    public String constantName() { return constantName; }
+}

jdkSrc/jdk8/java/lang/Error.java

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 1995, 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;
+
+/**
+ * An {@code Error} is a subclass of {@code Throwable}
+ * that indicates serious problems that a reasonable application
+ * should not try to catch. Most such errors are abnormal conditions.
+ * The {@code ThreadDeath} error, though a "normal" condition,
+ * is also a subclass of {@code Error} because most applications
+ * should not try to catch it.
+ * <p>
+ * A method is not required to declare in its {@code throws}
+ * clause any subclasses of {@code Error} that might be thrown
+ * during the execution of the method but not caught, since these
+ * errors are abnormal conditions that should never occur.
+ *
+ * That is, {@code Error} and its subclasses are regarded as unchecked
+ * exceptions for the purposes of compile-time checking of exceptions.
+ *
+ * @author  Frank Yellin
+ * @see     java.lang.ThreadDeath
+ * @jls 11.2 Compile-Time Checking of Exceptions
+ * @since   JDK1.0
+ */
+public class Error extends Throwable {
+    static final long serialVersionUID = 4980196508277280342L;
+
+    /**
+     * Constructs a new error with {@code null} as its detail message.
+     * The cause is not initialized, and may subsequently be initialized by a
+     * call to {@link #initCause}.
+     */
+    public Error() {
+        super();
+    }
+
+    /**
+     * Constructs a new error with the specified detail message.  The
+     * cause is not initialized, and may subsequently be initialized by
+     * a call to {@link #initCause}.
+     *
+     * @param   message   the detail message. The detail message is saved for
+     *          later retrieval by the {@link #getMessage()} method.
+     */
+    public Error(String message) {
+        super(message);
+    }
+
+    /**
+     * Constructs a new error with the specified detail message and
+     * cause.  <p>Note that the detail message associated with
+     * {@code cause} is <i>not</i> automatically incorporated in
+     * this error's detail message.
+     *
+     * @param  message the detail message (which is saved for later retrieval
+     *         by the {@link #getMessage()} method).
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link #getCause()} method).  (A {@code null} value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since  1.4
+     */
+    public Error(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs a new error with the specified cause and a detail
+     * message of {@code (cause==null ? null : cause.toString())} (which
+     * typically contains the class and detail message of {@code cause}).
+     * This constructor is useful for errors that are little more than
+     * wrappers for other throwables.
+     *
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link #getCause()} method).  (A {@code null} value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since  1.4
+     */
+    public Error(Throwable cause) {
+        super(cause);
+    }
+
+    /**
+     * Constructs a new error with the specified detail message,
+     * cause, suppression enabled or disabled, and writable stack
+     * trace enabled or disabled.
+     *
+     * @param  message the detail message.
+     * @param cause the cause.  (A {@code null} value is permitted,
+     * and indicates that the cause is nonexistent or unknown.)
+     * @param enableSuppression whether or not suppression is enabled
+     *                          or disabled
+     * @param writableStackTrace whether or not the stack trace should
+     *                           be writable
+     *
+     * @since 1.7
+     */
+    protected Error(String message, Throwable cause,
+                    boolean enableSuppression,
+                    boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}

jdkSrc/jdk8/java/lang/Exception.java

@@ -0,0 +1,124 @@
+/*
+ * 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;
+
+/**
+ * The class {@code Exception} and its subclasses are a form of
+ * {@code Throwable} that indicates conditions that a reasonable
+ * application might want to catch.
+ *
+ * <p>The class {@code Exception} and any subclasses that are not also
+ * subclasses of {@link RuntimeException} are <em>checked
+ * exceptions</em>.  Checked exceptions need to be declared in a
+ * method or constructor's {@code throws} clause if they can be thrown
+ * by the execution of the method or constructor and propagate outside
+ * the method or constructor boundary.
+ *
+ * @author  Frank Yellin
+ * @see     java.lang.Error
+ * @jls 11.2 Compile-Time Checking of Exceptions
+ * @since   JDK1.0
+ */
+public class Exception extends Throwable {
+    static final long serialVersionUID = -3387516993124229948L;
+
+    /**
+     * Constructs a new exception with {@code null} as its detail message.
+     * The cause is not initialized, and may subsequently be initialized by a
+     * call to {@link #initCause}.
+     */
+    public Exception() {
+        super();
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message.  The
+     * cause is not initialized, and may subsequently be initialized by
+     * a call to {@link #initCause}.
+     *
+     * @param   message   the detail message. The detail message is saved for
+     *          later retrieval by the {@link #getMessage()} method.
+     */
+    public Exception(String message) {
+        super(message);
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message and
+     * cause.  <p>Note that the detail message associated with
+     * {@code cause} is <i>not</i> automatically incorporated in
+     * this exception's detail message.
+     *
+     * @param  message the detail message (which is saved for later retrieval
+     *         by the {@link #getMessage()} method).
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link #getCause()} method).  (A <tt>null</tt> value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since  1.4
+     */
+    public Exception(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs a new exception with the specified cause and a detail
+     * message of <tt>(cause==null ? null : cause.toString())</tt> (which
+     * typically contains the class and detail message of <tt>cause</tt>).
+     * This constructor is useful for exceptions that are little more than
+     * wrappers for other throwables (for example, {@link
+     * java.security.PrivilegedActionException}).
+     *
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link #getCause()} method).  (A <tt>null</tt> value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since  1.4
+     */
+    public Exception(Throwable cause) {
+        super(cause);
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message,
+     * cause, suppression enabled or disabled, and writable stack
+     * trace enabled or disabled.
+     *
+     * @param  message the detail message.
+     * @param cause the cause.  (A {@code null} value is permitted,
+     * and indicates that the cause is nonexistent or unknown.)
+     * @param enableSuppression whether or not suppression is enabled
+     *                          or disabled
+     * @param writableStackTrace whether or not the stack trace should
+     *                           be writable
+     * @since 1.7
+     */
+    protected Exception(String message, Throwable cause,
+                        boolean enableSuppression,
+                        boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}

jdkSrc/jdk8/java/lang/ExceptionInInitializerError.java

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 1996, 2000, 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;
+
+/**
+ * Signals that an unexpected exception has occurred in a static initializer.
+ * An <code>ExceptionInInitializerError</code> is thrown to indicate that an
+ * exception occurred during evaluation of a static initializer or the
+ * initializer for a static variable.
+ *
+ * <p>As of release 1.4, this exception has been retrofitted to conform to
+ * the general purpose exception-chaining mechanism.  The "saved throwable
+ * object" that may be provided at construction time and accessed via
+ * the {@link #getException()} method is now known as the <i>cause</i>,
+ * and may be accessed via the {@link Throwable#getCause()} method, as well
+ * as the aforementioned "legacy method."
+ *
+ * @author  Frank Yellin
+ * @since   JDK1.1
+ */
+public class ExceptionInInitializerError extends LinkageError {
+    /**
+     * Use serialVersionUID from JDK 1.1.X for interoperability
+     */
+    private static final long serialVersionUID = 1521711792217232256L;
+
+    /**
+     * This field holds the exception if the
+     * ExceptionInInitializerError(Throwable thrown) constructor was
+     * used to instantiate the object
+     *
+     * @serial
+     *
+     */
+    private Throwable exception;
+
+    /**
+     * Constructs an <code>ExceptionInInitializerError</code> with
+     * <code>null</code> as its detail message string and with no saved
+     * throwable object.
+     * A detail message is a String that describes this particular exception.
+     */
+    public ExceptionInInitializerError() {
+        initCause(null);  // Disallow subsequent initCause
+    }
+
+    /**
+     * Constructs a new <code>ExceptionInInitializerError</code> class by
+     * saving a reference to the <code>Throwable</code> object thrown for
+     * later retrieval by the {@link #getException()} method. The detail
+     * message string is set to <code>null</code>.
+     *
+     * @param thrown The exception thrown
+     */
+    public ExceptionInInitializerError(Throwable thrown) {
+        initCause(null);  // Disallow subsequent initCause
+        this.exception = thrown;
+    }
+
+    /**
+     * Constructs an ExceptionInInitializerError with the specified detail
+     * message string.  A detail message is a String that describes this
+     * particular exception. The detail message string is saved for later
+     * retrieval by the {@link Throwable#getMessage()} method. There is no
+     * saved throwable object.
+     *
+     *
+     * @param s the detail message
+     */
+    public ExceptionInInitializerError(String s) {
+        super(s);
+        initCause(null);  // Disallow subsequent initCause
+    }
+
+    /**
+     * Returns the exception that occurred during a static initialization that
+     * caused this error to be created.
+     *
+     * <p>This method predates the general-purpose exception chaining facility.
+     * The {@link Throwable#getCause()} method is now the preferred means of
+     * obtaining this information.
+     *
+     * @return the saved throwable object of this
+     *         <code>ExceptionInInitializerError</code>, or <code>null</code>
+     *         if this <code>ExceptionInInitializerError</code> has no saved
+     *         throwable object.
+     */
+    public Throwable getException() {
+        return exception;
+    }
+
+    /**
+     * Returns the cause of this error (the exception that occurred
+     * during a static initialization that caused this error to be created).
+     *
+     * @return  the cause of this error or <code>null</code> if the
+     *          cause is nonexistent or unknown.
+     * @since   1.4
+     */
+    public Throwable getCause() {
+        return exception;
+    }
+}

jdkSrc/jdk8/java/lang/Float.java

@@ -0,0 +1,965 @@
+/*
+ * Copyright (c) 1994, 2013, 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 sun.misc.FloatingDecimal;
+import sun.misc.FloatConsts;
+import sun.misc.DoubleConsts;
+
+/**
+ * The {@code Float} class wraps a value of primitive type
+ * {@code float} in an object. An object of type
+ * {@code Float} contains a single field whose type is
+ * {@code float}.
+ *
+ * <p>In addition, this class provides several methods for converting a
+ * {@code float} to a {@code String} and a
+ * {@code String} to a {@code float}, as well as other
+ * constants and methods useful when dealing with a
+ * {@code float}.
+ *
+ * @author  Lee Boynton
+ * @author  Arthur van Hoff
+ * @author  Joseph D. Darcy
+ * @since JDK1.0
+ */
+public final class Float extends Number implements Comparable<Float> {
+    /**
+     * A constant holding the positive infinity of type
+     * {@code float}. It is equal to the value returned by
+     * {@code Float.intBitsToFloat(0x7f800000)}.
+     */
+    public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
+
+    /**
+     * A constant holding the negative infinity of type
+     * {@code float}. It is equal to the value returned by
+     * {@code Float.intBitsToFloat(0xff800000)}.
+     */
+    public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;
+
+    /**
+     * A constant holding a Not-a-Number (NaN) value of type
+     * {@code float}.  It is equivalent to the value returned by
+     * {@code Float.intBitsToFloat(0x7fc00000)}.
+     */
+    public static final float NaN = 0.0f / 0.0f;
+
+    /**
+     * A constant holding the largest positive finite value of type
+     * {@code float}, (2-2<sup>-23</sup>)&middot;2<sup>127</sup>.
+     * It is equal to the hexadecimal floating-point literal
+     * {@code 0x1.fffffeP+127f} and also equal to
+     * {@code Float.intBitsToFloat(0x7f7fffff)}.
+     */
+    public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f
+
+    /**
+     * A constant holding the smallest positive normal value of type
+     * {@code float}, 2<sup>-126</sup>.  It is equal to the
+     * hexadecimal floating-point literal {@code 0x1.0p-126f} and also
+     * equal to {@code Float.intBitsToFloat(0x00800000)}.
+     *
+     * @since 1.6
+     */
+    public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f
+
+    /**
+     * A constant holding the smallest positive nonzero value of type
+     * {@code float}, 2<sup>-149</sup>. It is equal to the
+     * hexadecimal floating-point literal {@code 0x0.000002P-126f}
+     * and also equal to {@code Float.intBitsToFloat(0x1)}.
+     */
+    public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f
+
+    /**
+     * Maximum exponent a finite {@code float} variable may have.  It
+     * is equal to the value returned by {@code
+     * Math.getExponent(Float.MAX_VALUE)}.
+     *
+     * @since 1.6
+     */
+    public static final int MAX_EXPONENT = 127;
+
+    /**
+     * Minimum exponent a normalized {@code float} variable may have.
+     * It is equal to the value returned by {@code
+     * Math.getExponent(Float.MIN_NORMAL)}.
+     *
+     * @since 1.6
+     */
+    public static final int MIN_EXPONENT = -126;
+
+    /**
+     * The number of bits used to represent a {@code float} value.
+     *
+     * @since 1.5
+     */
+    public static final int SIZE = 32;
+
+    /**
+     * The number of bytes used to represent a {@code float} value.
+     *
+     * @since 1.8
+     */
+    public static final int BYTES = SIZE / Byte.SIZE;
+
+    /**
+     * The {@code Class} instance representing the primitive type
+     * {@code float}.
+     *
+     * @since JDK1.1
+     */
+    @SuppressWarnings("unchecked")
+    public static final Class<Float> TYPE = (Class<Float>) Class.getPrimitiveClass("float");
+
+    /**
+     * Returns a string representation of the {@code float}
+     * argument. All characters mentioned below are ASCII characters.
+     * <ul>
+     * <li>If the argument is NaN, the result is the string
+     * "{@code NaN}".
+     * <li>Otherwise, the result is a string that represents the sign and
+     *     magnitude (absolute value) of the argument. If the sign is
+     *     negative, the first character of the result is
+     *     '{@code -}' ({@code '\u005Cu002D'}); if the sign is
+     *     positive, no sign character appears in the result. As for
+     *     the magnitude <i>m</i>:
+     * <ul>
+     * <li>If <i>m</i> is infinity, it is represented by the characters
+     *     {@code "Infinity"}; thus, positive infinity produces
+     *     the result {@code "Infinity"} and negative infinity
+     *     produces the result {@code "-Infinity"}.
+     * <li>If <i>m</i> is zero, it is represented by the characters
+     *     {@code "0.0"}; thus, negative zero produces the result
+     *     {@code "-0.0"} and positive zero produces the result
+     *     {@code "0.0"}.
+     * <li> If <i>m</i> is greater than or equal to 10<sup>-3</sup> but
+     *      less than 10<sup>7</sup>, then it is represented as the
+     *      integer part of <i>m</i>, in decimal form with no leading
+     *      zeroes, followed by '{@code .}'
+     *      ({@code '\u005Cu002E'}), followed by one or more
+     *      decimal digits representing the fractional part of
+     *      <i>m</i>.
+     * <li> If <i>m</i> is less than 10<sup>-3</sup> or greater than or
+     *      equal to 10<sup>7</sup>, then it is represented in
+     *      so-called "computerized scientific notation." Let <i>n</i>
+     *      be the unique integer such that 10<sup><i>n</i> </sup>&le;
+     *      <i>m</i> {@literal <} 10<sup><i>n</i>+1</sup>; then let <i>a</i>
+     *      be the mathematically exact quotient of <i>m</i> and
+     *      10<sup><i>n</i></sup> so that 1 &le; <i>a</i> {@literal <} 10.
+     *      The magnitude is then represented as the integer part of
+     *      <i>a</i>, as a single decimal digit, followed by
+     *      '{@code .}' ({@code '\u005Cu002E'}), followed by
+     *      decimal digits representing the fractional part of
+     *      <i>a</i>, followed by the letter '{@code E}'
+     *      ({@code '\u005Cu0045'}), followed by a representation
+     *      of <i>n</i> as a decimal integer, as produced by the
+     *      method {@link java.lang.Integer#toString(int)}.
+     *
+     * </ul>
+     * </ul>
+     * How many digits must be printed for the fractional part of
+     * <i>m</i> or <i>a</i>? There must be at least one digit
+     * to represent the fractional part, and beyond that as many, but
+     * only as many, more digits as are needed to uniquely distinguish
+     * the argument value from adjacent values of type
+     * {@code float}. That is, suppose that <i>x</i> is the
+     * exact mathematical value represented by the decimal
+     * representation produced by this method for a finite nonzero
+     * argument <i>f</i>. Then <i>f</i> must be the {@code float}
+     * value nearest to <i>x</i>; or, if two {@code float} values are
+     * equally close to <i>x</i>, then <i>f</i> must be one of
+     * them and the least significant bit of the significand of
+     * <i>f</i> must be {@code 0}.
+     *
+     * <p>To create localized string representations of a floating-point
+     * value, use subclasses of {@link java.text.NumberFormat}.
+     *
+     * @param   f   the float to be converted.
+     * @return a string representation of the argument.
+     */
+    public static String toString(float f) {
+        return FloatingDecimal.toJavaFormatString(f);
+    }
+
+    /**
+     * Returns a hexadecimal string representation of the
+     * {@code float} argument. All characters mentioned below are
+     * ASCII characters.
+     *
+     * <ul>
+     * <li>If the argument is NaN, the result is the string
+     *     "{@code NaN}".
+     * <li>Otherwise, the result is a string that represents the sign and
+     * magnitude (absolute value) of the argument. If the sign is negative,
+     * the first character of the result is '{@code -}'
+     * ({@code '\u005Cu002D'}); if the sign is positive, no sign character
+     * appears in the result. As for the magnitude <i>m</i>:
+     *
+     * <ul>
+     * <li>If <i>m</i> is infinity, it is represented by the string
+     * {@code "Infinity"}; thus, positive infinity produces the
+     * result {@code "Infinity"} and negative infinity produces
+     * the result {@code "-Infinity"}.
+     *
+     * <li>If <i>m</i> is zero, it is represented by the string
+     * {@code "0x0.0p0"}; thus, negative zero produces the result
+     * {@code "-0x0.0p0"} and positive zero produces the result
+     * {@code "0x0.0p0"}.
+     *
+     * <li>If <i>m</i> is a {@code float} value with a
+     * normalized representation, substrings are used to represent the
+     * significand and exponent fields.  The significand is
+     * represented by the characters {@code "0x1."}
+     * followed by a lowercase hexadecimal representation of the rest
+     * of the significand as a fraction.  Trailing zeros in the
+     * hexadecimal representation are removed unless all the digits
+     * are zero, in which case a single zero is used. Next, the
+     * exponent is represented by {@code "p"} followed
+     * by a decimal string of the unbiased exponent as if produced by
+     * a call to {@link Integer#toString(int) Integer.toString} on the
+     * exponent value.
+     *
+     * <li>If <i>m</i> is a {@code float} value with a subnormal
+     * representation, the significand is represented by the
+     * characters {@code "0x0."} followed by a
+     * hexadecimal representation of the rest of the significand as a
+     * fraction.  Trailing zeros in the hexadecimal representation are
+     * removed. Next, the exponent is represented by
+     * {@code "p-126"}.  Note that there must be at
+     * least one nonzero digit in a subnormal significand.
+     *
+     * </ul>
+     *
+     * </ul>
+     *
+     * <table border>
+     * <caption>Examples</caption>
+     * <tr><th>Floating-point Value</th><th>Hexadecimal String</th>
+     * <tr><td>{@code 1.0}</td> <td>{@code 0x1.0p0}</td>
+     * <tr><td>{@code -1.0}</td>        <td>{@code -0x1.0p0}</td>
+     * <tr><td>{@code 2.0}</td> <td>{@code 0x1.0p1}</td>
+     * <tr><td>{@code 3.0}</td> <td>{@code 0x1.8p1}</td>
+     * <tr><td>{@code 0.5}</td> <td>{@code 0x1.0p-1}</td>
+     * <tr><td>{@code 0.25}</td>        <td>{@code 0x1.0p-2}</td>
+     * <tr><td>{@code Float.MAX_VALUE}</td>
+     *     <td>{@code 0x1.fffffep127}</td>
+     * <tr><td>{@code Minimum Normal Value}</td>
+     *     <td>{@code 0x1.0p-126}</td>
+     * <tr><td>{@code Maximum Subnormal Value}</td>
+     *     <td>{@code 0x0.fffffep-126}</td>
+     * <tr><td>{@code Float.MIN_VALUE}</td>
+     *     <td>{@code 0x0.000002p-126}</td>
+     * </table>
+     * @param   f   the {@code float} to be converted.
+     * @return a hex string representation of the argument.
+     * @since 1.5
+     * @author Joseph D. Darcy
+     */
+    public static String toHexString(float f) {
+        if (Math.abs(f) < FloatConsts.MIN_NORMAL
+            &&  f != 0.0f ) {// float subnormal
+            // Adjust exponent to create subnormal double, then
+            // replace subnormal double exponent with subnormal float
+            // exponent
+            String s = Double.toHexString(Math.scalb((double)f,
+                                                     /* -1022+126 */
+                                                     DoubleConsts.MIN_EXPONENT-
+                                                     FloatConsts.MIN_EXPONENT));
+            return s.replaceFirst("p-1022$", "p-126");
+        }
+        else // double string will be the same as float string
+            return Double.toHexString(f);
+    }
+
+    /**
+     * Returns a {@code Float} object holding the
+     * {@code float} value represented by the argument string
+     * {@code s}.
+     *
+     * <p>If {@code s} is {@code null}, then a
+     * {@code NullPointerException} is thrown.
+     *
+     * <p>Leading and trailing whitespace characters in {@code s}
+     * are ignored.  Whitespace is removed as if by the {@link
+     * String#trim} method; that is, both ASCII space and control
+     * characters are removed. The rest of {@code s} should
+     * constitute a <i>FloatValue</i> as described by the lexical
+     * syntax rules:
+     *
+     * <blockquote>
+     * <dl>
+     * <dt><i>FloatValue:</i>
+     * <dd><i>Sign<sub>opt</sub></i> {@code NaN}
+     * <dd><i>Sign<sub>opt</sub></i> {@code Infinity}
+     * <dd><i>Sign<sub>opt</sub> FloatingPointLiteral</i>
+     * <dd><i>Sign<sub>opt</sub> HexFloatingPointLiteral</i>
+     * <dd><i>SignedInteger</i>
+     * </dl>
+     *
+     * <dl>
+     * <dt><i>HexFloatingPointLiteral</i>:
+     * <dd> <i>HexSignificand BinaryExponent FloatTypeSuffix<sub>opt</sub></i>
+     * </dl>
+     *
+     * <dl>
+     * <dt><i>HexSignificand:</i>
+     * <dd><i>HexNumeral</i>
+     * <dd><i>HexNumeral</i> {@code .}
+     * <dd>{@code 0x} <i>HexDigits<sub>opt</sub>
+     *     </i>{@code .}<i> HexDigits</i>
+     * <dd>{@code 0X}<i> HexDigits<sub>opt</sub>
+     *     </i>{@code .} <i>HexDigits</i>
+     * </dl>
+     *
+     * <dl>
+     * <dt><i>BinaryExponent:</i>
+     * <dd><i>BinaryExponentIndicator SignedInteger</i>
+     * </dl>
+     *
+     * <dl>
+     * <dt><i>BinaryExponentIndicator:</i>
+     * <dd>{@code p}
+     * <dd>{@code P}
+     * </dl>
+     *
+     * </blockquote>
+     *
+     * where <i>Sign</i>, <i>FloatingPointLiteral</i>,
+     * <i>HexNumeral</i>, <i>HexDigits</i>, <i>SignedInteger</i> and
+     * <i>FloatTypeSuffix</i> are as defined in the lexical structure
+     * sections of
+     * <cite>The Java&trade; Language Specification</cite>,
+     * except that underscores are not accepted between digits.
+     * If {@code s} does not have the form of
+     * a <i>FloatValue</i>, then a {@code NumberFormatException}
+     * is thrown. Otherwise, {@code s} is regarded as
+     * representing an exact decimal value in the usual
+     * "computerized scientific notation" or as an exact
+     * hexadecimal value; this exact numerical value is then
+     * conceptually converted to an "infinitely precise"
+     * binary value that is then rounded to type {@code float}
+     * by the usual round-to-nearest rule of IEEE 754 floating-point
+     * arithmetic, which includes preserving the sign of a zero
+     * value.
+     *
+     * Note that the round-to-nearest rule also implies overflow and
+     * underflow behaviour; if the exact value of {@code s} is large
+     * enough in magnitude (greater than or equal to ({@link
+     * #MAX_VALUE} + {@link Math#ulp(float) ulp(MAX_VALUE)}/2),
+     * rounding to {@code float} will result in an infinity and if the
+     * exact value of {@code s} is small enough in magnitude (less
+     * than or equal to {@link #MIN_VALUE}/2), rounding to float will
+     * result in a zero.
+     *
+     * Finally, after rounding a {@code Float} object representing
+     * this {@code float} value is returned.
+     *
+     * <p>To interpret localized string representations of a
+     * floating-point value, use subclasses of {@link
+     * java.text.NumberFormat}.
+     *
+     * <p>Note that trailing format specifiers, specifiers that
+     * determine the type of a floating-point literal
+     * ({@code 1.0f} is a {@code float} value;
+     * {@code 1.0d} is a {@code double} value), do
+     * <em>not</em> influence the results of this method.  In other
+     * words, the numerical value of the input string is converted
+     * directly to the target floating-point type.  In general, the
+     * two-step sequence of conversions, string to {@code double}
+     * followed by {@code double} to {@code float}, is
+     * <em>not</em> equivalent to converting a string directly to
+     * {@code float}.  For example, if first converted to an
+     * intermediate {@code double} and then to
+     * {@code float}, the string<br>
+     * {@code "1.00000017881393421514957253748434595763683319091796875001d"}<br>
+     * results in the {@code float} value
+     * {@code 1.0000002f}; if the string is converted directly to
+     * {@code float}, <code>1.000000<b>1</b>f</code> results.
+     *
+     * <p>To avoid calling this method on an invalid string and having
+     * a {@code NumberFormatException} be thrown, the documentation
+     * for {@link Double#valueOf Double.valueOf} lists a regular
+     * expression which can be used to screen the input.
+     *
+     * @param   s   the string to be parsed.
+     * @return  a {@code Float} object holding the value
+     *          represented by the {@code String} argument.
+     * @throws  NumberFormatException  if the string does not contain a
+     *          parsable number.
+     */
+    public static Float valueOf(String s) throws NumberFormatException {
+        return new Float(parseFloat(s));
+    }
+
+    /**
+     * Returns a {@code Float} instance representing the specified
+     * {@code float} value.
+     * If a new {@code Float} instance is not required, this method
+     * should generally be used in preference to the constructor
+     * {@link #Float(float)}, as this method is likely to yield
+     * significantly better space and time performance by caching
+     * frequently requested values.
+     *
+     * @param  f a float value.
+     * @return a {@code Float} instance representing {@code f}.
+     * @since  1.5
+     */
+    public static Float valueOf(float f) {
+        return new Float(f);
+    }
+
+    /**
+     * Returns a new {@code float} initialized to the value
+     * represented by the specified {@code String}, as performed
+     * by the {@code valueOf} method of class {@code Float}.
+     *
+     * @param  s the string to be parsed.
+     * @return the {@code float} value represented by the string
+     *         argument.
+     * @throws NullPointerException  if the string is null
+     * @throws NumberFormatException if the string does not contain a
+     *               parsable {@code float}.
+     * @see    java.lang.Float#valueOf(String)
+     * @since 1.2
+     */
+    public static float parseFloat(String s) throws NumberFormatException {
+        return FloatingDecimal.parseFloat(s);
+    }
+
+    /**
+     * Returns {@code true} if the specified number is a
+     * Not-a-Number (NaN) value, {@code false} otherwise.
+     *
+     * @param   v   the value to be tested.
+     * @return  {@code true} if the argument is NaN;
+     *          {@code false} otherwise.
+     */
+    public static boolean isNaN(float v) {
+        return (v != v);
+    }
+
+    /**
+     * Returns {@code true} if the specified number is infinitely
+     * large in magnitude, {@code false} otherwise.
+     *
+     * @param   v   the value to be tested.
+     * @return  {@code true} if the argument is positive infinity or
+     *          negative infinity; {@code false} otherwise.
+     */
+    public static boolean isInfinite(float v) {
+        return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
+    }
+
+
+    /**
+     * Returns {@code true} if the argument is a finite floating-point
+     * value; returns {@code false} otherwise (for NaN and infinity
+     * arguments).
+     *
+     * @param f the {@code float} value to be tested
+     * @return {@code true} if the argument is a finite
+     * floating-point value, {@code false} otherwise.
+     * @since 1.8
+     */
+     public static boolean isFinite(float f) {
+        return Math.abs(f) <= FloatConsts.MAX_VALUE;
+    }
+
+    /**
+     * The value of the Float.
+     *
+     * @serial
+     */
+    private final float value;
+
+    /**
+     * Constructs a newly allocated {@code Float} object that
+     * represents the primitive {@code float} argument.
+     *
+     * @param   value   the value to be represented by the {@code Float}.
+     */
+    public Float(float value) {
+        this.value = value;
+    }
+
+    /**
+     * Constructs a newly allocated {@code Float} object that
+     * represents the argument converted to type {@code float}.
+     *
+     * @param   value   the value to be represented by the {@code Float}.
+     */
+    public Float(double value) {
+        this.value = (float)value;
+    }
+
+    /**
+     * Constructs a newly allocated {@code Float} object that
+     * represents the floating-point value of type {@code float}
+     * represented by the string. The string is converted to a
+     * {@code float} value as if by the {@code valueOf} method.
+     *
+     * @param      s   a string to be converted to a {@code Float}.
+     * @throws  NumberFormatException  if the string does not contain a
+     *               parsable number.
+     * @see        java.lang.Float#valueOf(java.lang.String)
+     */
+    public Float(String s) throws NumberFormatException {
+        value = parseFloat(s);
+    }
+
+    /**
+     * Returns {@code true} if this {@code Float} value is a
+     * Not-a-Number (NaN), {@code false} otherwise.
+     *
+     * @return  {@code true} if the value represented by this object is
+     *          NaN; {@code false} otherwise.
+     */
+    public boolean isNaN() {
+        return isNaN(value);
+    }
+
+    /**
+     * Returns {@code true} if this {@code Float} value is
+     * infinitely large in magnitude, {@code false} otherwise.
+     *
+     * @return  {@code true} if the value represented by this object is
+     *          positive infinity or negative infinity;
+     *          {@code false} otherwise.
+     */
+    public boolean isInfinite() {
+        return isInfinite(value);
+    }
+
+    /**
+     * Returns a string representation of this {@code Float} object.
+     * The primitive {@code float} value represented by this object
+     * is converted to a {@code String} exactly as if by the method
+     * {@code toString} of one argument.
+     *
+     * @return  a {@code String} representation of this object.
+     * @see java.lang.Float#toString(float)
+     */
+    public String toString() {
+        return Float.toString(value);
+    }
+
+    /**
+     * Returns the value of this {@code Float} as a {@code byte} after
+     * a narrowing primitive conversion.
+     *
+     * @return  the {@code float} value represented by this object
+     *          converted to type {@code byte}
+     * @jls 5.1.3 Narrowing Primitive Conversions
+     */
+    public byte byteValue() {
+        return (byte)value;
+    }
+
+    /**
+     * Returns the value of this {@code Float} as a {@code short}
+     * after a narrowing primitive conversion.
+     *
+     * @return  the {@code float} value represented by this object
+     *          converted to type {@code short}
+     * @jls 5.1.3 Narrowing Primitive Conversions
+     * @since JDK1.1
+     */
+    public short shortValue() {
+        return (short)value;
+    }
+
+    /**
+     * Returns the value of this {@code Float} as an {@code int} after
+     * a narrowing primitive conversion.
+     *
+     * @return  the {@code float} value represented by this object
+     *          converted to type {@code int}
+     * @jls 5.1.3 Narrowing Primitive Conversions
+     */
+    public int intValue() {
+        return (int)value;
+    }
+
+    /**
+     * Returns value of this {@code Float} as a {@code long} after a
+     * narrowing primitive conversion.
+     *
+     * @return  the {@code float} value represented by this object
+     *          converted to type {@code long}
+     * @jls 5.1.3 Narrowing Primitive Conversions
+     */
+    public long longValue() {
+        return (long)value;
+    }
+
+    /**
+     * Returns the {@code float} value of this {@code Float} object.
+     *
+     * @return the {@code float} value represented by this object
+     */
+    public float floatValue() {
+        return value;
+    }
+
+    /**
+     * Returns the value of this {@code Float} as a {@code double}
+     * after a widening primitive conversion.
+     *
+     * @return the {@code float} value represented by this
+     *         object converted to type {@code double}
+     * @jls 5.1.2 Widening Primitive Conversions
+     */
+    public double doubleValue() {
+        return (double)value;
+    }
+
+    /**
+     * Returns a hash code for this {@code Float} object. The
+     * result is the integer bit representation, exactly as produced
+     * by the method {@link #floatToIntBits(float)}, of the primitive
+     * {@code float} value represented by this {@code Float}
+     * object.
+     *
+     * @return a hash code value for this object.
+     */
+    @Override
+    public int hashCode() {
+        return Float.hashCode(value);
+    }
+
+    /**
+     * Returns a hash code for a {@code float} value; compatible with
+     * {@code Float.hashCode()}.
+     *
+     * @param value the value to hash
+     * @return a hash code value for a {@code float} value.
+     * @since 1.8
+     */
+    public static int hashCode(float value) {
+        return floatToIntBits(value);
+    }
+
+    /**
+
+     * Compares this object against the specified object.  The result
+     * is {@code true} if and only if the argument is not
+     * {@code null} and is a {@code Float} object that
+     * represents a {@code float} with the same value as the
+     * {@code float} represented by this object. For this
+     * purpose, two {@code float} values are considered to be the
+     * same if and only if the method {@link #floatToIntBits(float)}
+     * returns the identical {@code int} value when applied to
+     * each.
+     *
+     * <p>Note that in most cases, for two instances of class
+     * {@code Float}, {@code f1} and {@code f2}, the value
+     * of {@code f1.equals(f2)} is {@code true} if and only if
+     *
+     * <blockquote><pre>
+     *   f1.floatValue() == f2.floatValue()
+     * </pre></blockquote>
+     *
+     * <p>also has the value {@code true}. However, there are two exceptions:
+     * <ul>
+     * <li>If {@code f1} and {@code f2} both represent
+     *     {@code Float.NaN}, then the {@code equals} method returns
+     *     {@code true}, even though {@code Float.NaN==Float.NaN}
+     *     has the value {@code false}.
+     * <li>If {@code f1} represents {@code +0.0f} while
+     *     {@code f2} represents {@code -0.0f}, or vice
+     *     versa, the {@code equal} test has the value
+     *     {@code false}, even though {@code 0.0f==-0.0f}
+     *     has the value {@code true}.
+     * </ul>
+     *
+     * This definition allows hash tables to operate properly.
+     *
+     * @param obj the object to be compared
+     * @return  {@code true} if the objects are the same;
+     *          {@code false} otherwise.
+     * @see java.lang.Float#floatToIntBits(float)
+     */
+    public boolean equals(Object obj) {
+        return (obj instanceof Float)
+               && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
+    }
+
+    /**
+     * Returns a representation of the specified floating-point value
+     * according to the IEEE 754 floating-point "single format" bit
+     * layout.
+     *
+     * <p>Bit 31 (the bit that is selected by the mask
+     * {@code 0x80000000}) represents the sign of the floating-point
+     * number.
+     * Bits 30-23 (the bits that are selected by the mask
+     * {@code 0x7f800000}) represent the exponent.
+     * Bits 22-0 (the bits that are selected by the mask
+     * {@code 0x007fffff}) represent the significand (sometimes called
+     * the mantissa) of the floating-point number.
+     *
+     * <p>If the argument is positive infinity, the result is
+     * {@code 0x7f800000}.
+     *
+     * <p>If the argument is negative infinity, the result is
+     * {@code 0xff800000}.
+     *
+     * <p>If the argument is NaN, the result is {@code 0x7fc00000}.
+     *
+     * <p>In all cases, the result is an integer that, when given to the
+     * {@link #intBitsToFloat(int)} method, will produce a floating-point
+     * value the same as the argument to {@code floatToIntBits}
+     * (except all NaN values are collapsed to a single
+     * "canonical" NaN value).
+     *
+     * @param   value   a floating-point number.
+     * @return the bits that represent the floating-point number.
+     */
+    public static int floatToIntBits(float value) {
+        int result = floatToRawIntBits(value);
+        // Check for NaN based on values of bit fields, maximum
+        // exponent and nonzero significand.
+        if ( ((result & FloatConsts.EXP_BIT_MASK) ==
+              FloatConsts.EXP_BIT_MASK) &&
+             (result & FloatConsts.SIGNIF_BIT_MASK) != 0)
+            result = 0x7fc00000;
+        return result;
+    }
+
+    /**
+     * Returns a representation of the specified floating-point value
+     * according to the IEEE 754 floating-point "single format" bit
+     * layout, preserving Not-a-Number (NaN) values.
+     *
+     * <p>Bit 31 (the bit that is selected by the mask
+     * {@code 0x80000000}) represents the sign of the floating-point
+     * number.
+     * Bits 30-23 (the bits that are selected by the mask
+     * {@code 0x7f800000}) represent the exponent.
+     * Bits 22-0 (the bits that are selected by the mask
+     * {@code 0x007fffff}) represent the significand (sometimes called
+     * the mantissa) of the floating-point number.
+     *
+     * <p>If the argument is positive infinity, the result is
+     * {@code 0x7f800000}.
+     *
+     * <p>If the argument is negative infinity, the result is
+     * {@code 0xff800000}.
+     *
+     * <p>If the argument is NaN, the result is the integer representing
+     * the actual NaN value.  Unlike the {@code floatToIntBits}
+     * method, {@code floatToRawIntBits} does not collapse all the
+     * bit patterns encoding a NaN to a single "canonical"
+     * NaN value.
+     *
+     * <p>In all cases, the result is an integer that, when given to the
+     * {@link #intBitsToFloat(int)} method, will produce a
+     * floating-point value the same as the argument to
+     * {@code floatToRawIntBits}.
+     *
+     * @param   value   a floating-point number.
+     * @return the bits that represent the floating-point number.
+     * @since 1.3
+     */
+    public static native int floatToRawIntBits(float value);
+
+    /**
+     * Returns the {@code float} value corresponding to a given
+     * bit representation.
+     * The argument is considered to be a representation of a
+     * floating-point value according to the IEEE 754 floating-point
+     * "single format" bit layout.
+     *
+     * <p>If the argument is {@code 0x7f800000}, the result is positive
+     * infinity.
+     *
+     * <p>If the argument is {@code 0xff800000}, the result is negative
+     * infinity.
+     *
+     * <p>If the argument is any value in the range
+     * {@code 0x7f800001} through {@code 0x7fffffff} or in
+     * the range {@code 0xff800001} through
+     * {@code 0xffffffff}, the result is a NaN.  No IEEE 754
+     * floating-point operation provided by Java can distinguish
+     * between two NaN values of the same type with different bit
+     * patterns.  Distinct values of NaN are only distinguishable by
+     * use of the {@code Float.floatToRawIntBits} method.
+     *
+     * <p>In all other cases, let <i>s</i>, <i>e</i>, and <i>m</i> be three
+     * values that can be computed from the argument:
+     *
+     * <blockquote><pre>{@code
+     * int s = ((bits >> 31) == 0) ? 1 : -1;
+     * int e = ((bits >> 23) & 0xff);
+     * int m = (e == 0) ?
+     *                 (bits & 0x7fffff) << 1 :
+     *                 (bits & 0x7fffff) | 0x800000;
+     * }</pre></blockquote>
+     *
+     * Then the floating-point result equals the value of the mathematical
+     * expression <i>s</i>&middot;<i>m</i>&middot;2<sup><i>e</i>-150</sup>.
+     *
+     * <p>Note that this method may not be able to return a
+     * {@code float} NaN with exactly same bit pattern as the
+     * {@code int} argument.  IEEE 754 distinguishes between two
+     * kinds of NaNs, quiet NaNs and <i>signaling NaNs</i>.  The
+     * differences between the two kinds of NaN are generally not
+     * visible in Java.  Arithmetic operations on signaling NaNs turn
+     * them into quiet NaNs with a different, but often similar, bit
+     * pattern.  However, on some processors merely copying a
+     * signaling NaN also performs that conversion.  In particular,
+     * copying a signaling NaN to return it to the calling method may
+     * perform this conversion.  So {@code intBitsToFloat} may
+     * not be able to return a {@code float} with a signaling NaN
+     * bit pattern.  Consequently, for some {@code int} values,
+     * {@code floatToRawIntBits(intBitsToFloat(start))} may
+     * <i>not</i> equal {@code start}.  Moreover, which
+     * particular bit patterns represent signaling NaNs is platform
+     * dependent; although all NaN bit patterns, quiet or signaling,
+     * must be in the NaN range identified above.
+     *
+     * @param   bits   an integer.
+     * @return  the {@code float} floating-point value with the same bit
+     *          pattern.
+     */
+    public static native float intBitsToFloat(int bits);
+
+    /**
+     * Compares two {@code Float} objects numerically.  There are
+     * two ways in which comparisons performed by this method differ
+     * from those performed by the Java language numerical comparison
+     * operators ({@code <, <=, ==, >=, >}) when
+     * applied to primitive {@code float} values:
+     *
+     * <ul><li>
+     *          {@code Float.NaN} is considered by this method to
+     *          be equal to itself and greater than all other
+     *          {@code float} values
+     *          (including {@code Float.POSITIVE_INFINITY}).
+     * <li>
+     *          {@code 0.0f} is considered by this method to be greater
+     *          than {@code -0.0f}.
+     * </ul>
+     *
+     * This ensures that the <i>natural ordering</i> of {@code Float}
+     * objects imposed by this method is <i>consistent with equals</i>.
+     *
+     * @param   anotherFloat   the {@code Float} to be compared.
+     * @return  the value {@code 0} if {@code anotherFloat} is
+     *          numerically equal to this {@code Float}; a value
+     *          less than {@code 0} if this {@code Float}
+     *          is numerically less than {@code anotherFloat};
+     *          and a value greater than {@code 0} if this
+     *          {@code Float} is numerically greater than
+     *          {@code anotherFloat}.
+     *
+     * @since   1.2
+     * @see Comparable#compareTo(Object)
+     */
+    public int compareTo(Float anotherFloat) {
+        return Float.compare(value, anotherFloat.value);
+    }
+
+    /**
+     * Compares the two specified {@code float} values. The sign
+     * of the integer value returned is the same as that of the
+     * integer that would be returned by the call:
+     * <pre>
+     *    new Float(f1).compareTo(new Float(f2))
+     * </pre>
+     *
+     * @param   f1        the first {@code float} to compare.
+     * @param   f2        the second {@code float} to compare.
+     * @return  the value {@code 0} if {@code f1} is
+     *          numerically equal to {@code f2}; a value less than
+     *          {@code 0} if {@code f1} is numerically less than
+     *          {@code f2}; and a value greater than {@code 0}
+     *          if {@code f1} is numerically greater than
+     *          {@code f2}.
+     * @since 1.4
+     */
+    public static int compare(float f1, float f2) {
+        if (f1 < f2)
+            return -1;           // Neither val is NaN, thisVal is smaller
+        if (f1 > f2)
+            return 1;            // Neither val is NaN, thisVal is larger
+
+        // Cannot use floatToRawIntBits because of possibility of NaNs.
+        int thisBits    = Float.floatToIntBits(f1);
+        int anotherBits = Float.floatToIntBits(f2);
+
+        return (thisBits == anotherBits ?  0 : // Values are equal
+                (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
+                 1));                          // (0.0, -0.0) or (NaN, !NaN)
+    }
+
+    /**
+     * Adds two {@code float} values together as per the + operator.
+     *
+     * @param a the first operand
+     * @param b the second operand
+     * @return the sum of {@code a} and {@code b}
+     * @jls 4.2.4 Floating-Point Operations
+     * @see java.util.function.BinaryOperator
+     * @since 1.8
+     */
+    public static float sum(float a, float b) {
+        return a + b;
+    }
+
+    /**
+     * Returns the greater of two {@code float} values
+     * as if by calling {@link Math#max(float, float) Math.max}.
+     *
+     * @param a the first operand
+     * @param b the second operand
+     * @return the greater of {@code a} and {@code b}
+     * @see java.util.function.BinaryOperator
+     * @since 1.8
+     */
+    public static float max(float a, float b) {
+        return Math.max(a, b);
+    }
+
+    /**
+     * Returns the smaller of two {@code float} values
+     * as if by calling {@link Math#min(float, float) Math.min}.
+     *
+     * @param a the first operand
+     * @param b the second operand
+     * @return the smaller of {@code a} and {@code b}
+     * @see java.util.function.BinaryOperator
+     * @since 1.8
+     */
+    public static float min(float a, float b) {
+        return Math.min(a, b);
+    }
+
+    /** use serialVersionUID from JDK 1.0.2 for interoperability */
+    private static final long serialVersionUID = -2671257302660747028L;
+}

jdkSrc/jdk8/java/lang/FunctionalInterface.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2012, 2013, 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.lang.annotation.*;
+
+/**
+ * An informative annotation type used to indicate that an interface
+ * type declaration is intended to be a <i>functional interface</i> as
+ * defined by the Java Language Specification.
+ *
+ * Conceptually, a functional interface has exactly one abstract
+ * method.  Since {@linkplain java.lang.reflect.Method#isDefault()
+ * default methods} have an implementation, they are not abstract.  If
+ * an interface declares an abstract method overriding one of the
+ * public methods of {@code java.lang.Object}, that also does
+ * <em>not</em> count toward the interface's abstract method count
+ * since any implementation of the interface will have an
+ * implementation from {@code java.lang.Object} or elsewhere.
+ *
+ * <p>Note that instances of functional interfaces can be created with
+ * lambda expressions, method references, or constructor references.
+ *
+ * <p>If a type is annotated with this annotation type, compilers are
+ * required to generate an error message unless:
+ *
+ * <ul>
+ * <li> The type is an interface type and not an annotation type, enum, or class.
+ * <li> The annotated type satisfies the requirements of a functional interface.
+ * </ul>
+ *
+ * <p>However, the compiler will treat any interface meeting the
+ * definition of a functional interface as a functional interface
+ * regardless of whether or not a {@code FunctionalInterface}
+ * annotation is present on the interface declaration.
+ *
+ * @jls 4.3.2. The Class Object
+ * @jls 9.8 Functional Interfaces
+ * @jls 9.4.3 Interface Method Body
+ * @since 1.8
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface FunctionalInterface {}

jdkSrc/jdk8/java/lang/IllegalAccessError.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * Thrown if an application attempts to access or modify a field, or
+ * to call a method that it does not have access to.
+ * <p>
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of a class has
+ * incompatibly changed.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public class IllegalAccessError extends IncompatibleClassChangeError {
+    private static final long serialVersionUID = -8988904074992417891L;
+
+    /**
+     * Constructs an <code>IllegalAccessError</code> with no detail message.
+     */
+    public IllegalAccessError() {
+        super();
+    }
+
+    /**
+     * Constructs an <code>IllegalAccessError</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public IllegalAccessError(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/IllegalAccessException.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * An IllegalAccessException is thrown when an application tries
+ * to reflectively create an instance (other than an array),
+ * set or get a field, or invoke a method, but the currently
+ * executing method does not have access to the definition of
+ * the specified class, field, method or constructor.
+ *
+ * @author  unascribed
+ * @see     Class#newInstance()
+ * @see     java.lang.reflect.Field#set(Object, Object)
+ * @see     java.lang.reflect.Field#setBoolean(Object, boolean)
+ * @see     java.lang.reflect.Field#setByte(Object, byte)
+ * @see     java.lang.reflect.Field#setShort(Object, short)
+ * @see     java.lang.reflect.Field#setChar(Object, char)
+ * @see     java.lang.reflect.Field#setInt(Object, int)
+ * @see     java.lang.reflect.Field#setLong(Object, long)
+ * @see     java.lang.reflect.Field#setFloat(Object, float)
+ * @see     java.lang.reflect.Field#setDouble(Object, double)
+ * @see     java.lang.reflect.Field#get(Object)
+ * @see     java.lang.reflect.Field#getBoolean(Object)
+ * @see     java.lang.reflect.Field#getByte(Object)
+ * @see     java.lang.reflect.Field#getShort(Object)
+ * @see     java.lang.reflect.Field#getChar(Object)
+ * @see     java.lang.reflect.Field#getInt(Object)
+ * @see     java.lang.reflect.Field#getLong(Object)
+ * @see     java.lang.reflect.Field#getFloat(Object)
+ * @see     java.lang.reflect.Field#getDouble(Object)
+ * @see     java.lang.reflect.Method#invoke(Object, Object[])
+ * @see     java.lang.reflect.Constructor#newInstance(Object[])
+ * @since   JDK1.0
+ */
+public class IllegalAccessException extends ReflectiveOperationException {
+    private static final long serialVersionUID = 6616958222490762034L;
+
+    /**
+     * Constructs an <code>IllegalAccessException</code> without a
+     * detail message.
+     */
+    public IllegalAccessException() {
+        super();
+    }
+
+    /**
+     * Constructs an <code>IllegalAccessException</code> with a detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public IllegalAccessException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/IllegalArgumentException.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 1994, 2012, 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;
+
+/**
+ * Thrown to indicate that a method has been passed an illegal or
+ * inappropriate argument.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class IllegalArgumentException extends RuntimeException {
+    /**
+     * Constructs an <code>IllegalArgumentException</code> with no
+     * detail message.
+     */
+    public IllegalArgumentException() {
+        super();
+    }
+
+    /**
+     * Constructs an <code>IllegalArgumentException</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public IllegalArgumentException(String s) {
+        super(s);
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message and
+     * cause.
+     *
+     * <p>Note that the detail message associated with <code>cause</code> is
+     * <i>not</i> automatically incorporated in this exception's detail
+     * message.
+     *
+     * @param  message the detail message (which is saved for later retrieval
+     *         by the {@link Throwable#getMessage()} method).
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link Throwable#getCause()} method).  (A <tt>null</tt> value
+     *         is permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since 1.5
+     */
+    public IllegalArgumentException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs a new exception with the specified cause and a detail
+     * message of <tt>(cause==null ? null : cause.toString())</tt> (which
+     * typically contains the class and detail message of <tt>cause</tt>).
+     * This constructor is useful for exceptions that are little more than
+     * wrappers for other throwables (for example, {@link
+     * java.security.PrivilegedActionException}).
+     *
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link Throwable#getCause()} method).  (A <tt>null</tt> value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since  1.5
+     */
+    public IllegalArgumentException(Throwable cause) {
+        super(cause);
+    }
+
+    private static final long serialVersionUID = -5365630128856068164L;
+}

jdkSrc/jdk8/java/lang/IllegalMonitorStateException.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * Thrown to indicate that a thread has attempted to wait on an
+ * object's monitor or to notify other threads waiting on an object's
+ * monitor without owning the specified monitor.
+ *
+ * @author  unascribed
+ * @see     java.lang.Object#notify()
+ * @see     java.lang.Object#notifyAll()
+ * @see     java.lang.Object#wait()
+ * @see     java.lang.Object#wait(long)
+ * @see     java.lang.Object#wait(long, int)
+ * @since   JDK1.0
+ */
+public
+class IllegalMonitorStateException extends RuntimeException {
+    private static final long serialVersionUID = 3713306369498869069L;
+
+    /**
+     * Constructs an <code>IllegalMonitorStateException</code> with no
+     * detail message.
+     */
+    public IllegalMonitorStateException() {
+        super();
+    }
+
+    /**
+     * Constructs an <code>IllegalMonitorStateException</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public IllegalMonitorStateException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/IllegalStateException.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 1996, 2003, 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;
+
+/**
+ * Signals that a method has been invoked at an illegal or
+ * inappropriate time.  In other words, the Java environment or
+ * Java application is not in an appropriate state for the requested
+ * operation.
+ *
+ * @author  Jonni Kanerva
+ * @since   JDK1.1
+ */
+public
+class IllegalStateException extends RuntimeException {
+    /**
+     * Constructs an IllegalStateException with no detail message.
+     * A detail message is a String that describes this particular exception.
+     */
+    public IllegalStateException() {
+        super();
+    }
+
+    /**
+     * Constructs an IllegalStateException with the specified detail
+     * message.  A detail message is a String that describes this particular
+     * exception.
+     *
+     * @param s the String that contains a detailed message
+     */
+    public IllegalStateException(String s) {
+        super(s);
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message and
+     * cause.
+     *
+     * <p>Note that the detail message associated with <code>cause</code> is
+     * <i>not</i> automatically incorporated in this exception's detail
+     * message.
+     *
+     * @param  message the detail message (which is saved for later retrieval
+     *         by the {@link Throwable#getMessage()} method).
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link Throwable#getCause()} method).  (A <tt>null</tt> value
+     *         is permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since 1.5
+     */
+    public IllegalStateException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs a new exception with the specified cause and a detail
+     * message of <tt>(cause==null ? null : cause.toString())</tt> (which
+     * typically contains the class and detail message of <tt>cause</tt>).
+     * This constructor is useful for exceptions that are little more than
+     * wrappers for other throwables (for example, {@link
+     * java.security.PrivilegedActionException}).
+     *
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link Throwable#getCause()} method).  (A <tt>null</tt> value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since  1.5
+     */
+    public IllegalStateException(Throwable cause) {
+        super(cause);
+    }
+
+    static final long serialVersionUID = -1848914673093119416L;
+}

jdkSrc/jdk8/java/lang/IllegalThreadStateException.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 1994, 2008, 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;
+
+/**
+ * Thrown to indicate that a thread is not in an appropriate state
+ * for the requested operation. See, for example, the
+ * <code>suspend</code> and <code>resume</code> methods in class
+ * <code>Thread</code>.
+ *
+ * @author  unascribed
+ * @see     java.lang.Thread#resume()
+ * @see     java.lang.Thread#suspend()
+ * @since   JDK1.0
+ */
+public class IllegalThreadStateException extends IllegalArgumentException {
+    private static final long serialVersionUID = -7626246362397460174L;
+
+    /**
+     * Constructs an <code>IllegalThreadStateException</code> with no
+     * detail message.
+     */
+    public IllegalThreadStateException() {
+        super();
+    }
+
+    /**
+     * Constructs an <code>IllegalThreadStateException</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public IllegalThreadStateException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/IncompatibleClassChangeError.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 1994, 2008, 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;
+
+/**
+ * Thrown when an incompatible class change has occurred to some class
+ * definition. The definition of some class, on which the currently
+ * executing method depends, has since changed.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class IncompatibleClassChangeError extends LinkageError {
+    private static final long serialVersionUID = -4914975503642802119L;
+
+    /**
+     * Constructs an <code>IncompatibleClassChangeError</code> with no
+     * detail message.
+     */
+    public IncompatibleClassChangeError () {
+        super();
+    }
+
+    /**
+     * Constructs an <code>IncompatibleClassChangeError</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public IncompatibleClassChangeError(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/IndexOutOfBoundsException.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * Thrown to indicate that an index of some sort (such as to an array, to a
+ * string, or to a vector) is out of range.
+ * <p>
+ * Applications can subclass this class to indicate similar exceptions.
+ *
+ * @author  Frank Yellin
+ * @since   JDK1.0
+ */
+public
+class IndexOutOfBoundsException extends RuntimeException {
+    private static final long serialVersionUID = 234122996006267687L;
+
+    /**
+     * Constructs an <code>IndexOutOfBoundsException</code> with no
+     * detail message.
+     */
+    public IndexOutOfBoundsException() {
+        super();
+    }
+
+    /**
+     * Constructs an <code>IndexOutOfBoundsException</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public IndexOutOfBoundsException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/InheritableThreadLocal.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 1998, 2012, 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.lang.ref.*;
+
+/**
+ * This class extends <tt>ThreadLocal</tt> to provide inheritance of values
+ * from parent thread to child thread: when a child thread is created, the
+ * child receives initial values for all inheritable thread-local variables
+ * for which the parent has values.  Normally the child's values will be
+ * identical to the parent's; however, the child's value can be made an
+ * arbitrary function of the parent's by overriding the <tt>childValue</tt>
+ * method in this class.
+ *
+ * <p>Inheritable thread-local variables are used in preference to
+ * ordinary thread-local variables when the per-thread-attribute being
+ * maintained in the variable (e.g., User ID, Transaction ID) must be
+ * automatically transmitted to any child threads that are created.
+ *
+ * @author  Josh Bloch and Doug Lea
+ * @see     ThreadLocal
+ * @since   1.2
+ */
+
+public class InheritableThreadLocal<T> extends ThreadLocal<T> {
+    /**
+     * Computes the child's initial value for this inheritable thread-local
+     * variable as a function of the parent's value at the time the child
+     * thread is created.  This method is called from within the parent
+     * thread before the child is started.
+     * <p>
+     * This method merely returns its input argument, and should be overridden
+     * if a different behavior is desired.
+     *
+     * @param parentValue the parent thread's value
+     * @return the child thread's initial value
+     */
+    protected T childValue(T parentValue) {
+        return parentValue;
+    }
+
+    /**
+     * Get the map associated with a ThreadLocal.
+     *
+     * @param t the current thread
+     */
+    ThreadLocalMap getMap(Thread t) {
+       return t.inheritableThreadLocals;
+    }
+
+    /**
+     * Create the map associated with a ThreadLocal.
+     *
+     * @param t the current thread
+     * @param firstValue value for the initial entry of the table.
+     */
+    void createMap(Thread t, T firstValue) {
+        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
+    }
+}

jdkSrc/jdk8/java/lang/InstantiationError.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * Thrown when an application tries to use the Java <code>new</code>
+ * construct to instantiate an abstract class or an interface.
+ * <p>
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of a class has
+ * incompatibly changed.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+
+
+public
+class InstantiationError extends IncompatibleClassChangeError {
+    private static final long serialVersionUID = -4885810657349421204L;
+
+    /**
+     * Constructs an <code>InstantiationError</code> with no detail  message.
+     */
+    public InstantiationError() {
+        super();
+    }
+
+    /**
+     * Constructs an <code>InstantiationError</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public InstantiationError(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/InstantiationException.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * Thrown when an application tries to create an instance of a class
+ * using the {@code newInstance} method in class
+ * {@code Class}, but the specified class object cannot be
+ * instantiated.  The instantiation can fail for a variety of
+ * reasons including but not limited to:
+ *
+ * <ul>
+ * <li> the class object represents an abstract class, an interface,
+ *      an array class, a primitive type, or {@code void}
+ * <li> the class has no nullary constructor
+ *</ul>
+ *
+ * @author  unascribed
+ * @see     java.lang.Class#newInstance()
+ * @since   JDK1.0
+ */
+public
+class InstantiationException extends ReflectiveOperationException {
+    private static final long serialVersionUID = -8441929162975509110L;
+
+    /**
+     * Constructs an {@code InstantiationException} with no detail message.
+     */
+    public InstantiationException() {
+        super();
+    }
+
+    /**
+     * Constructs an {@code InstantiationException} with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public InstantiationException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/InternalError.java

@@ -0,0 +1,90 @@
+/*
+ * 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;
+
+/**
+ * Thrown to indicate some unexpected internal error has occurred in
+ * the Java Virtual Machine.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public class InternalError extends VirtualMachineError {
+    private static final long serialVersionUID = -9062593416125562365L;
+
+    /**
+     * Constructs an <code>InternalError</code> with no detail message.
+     */
+    public InternalError() {
+        super();
+    }
+
+    /**
+     * Constructs an <code>InternalError</code> with the specified
+     * detail message.
+     *
+     * @param   message   the detail message.
+     */
+    public InternalError(String message) {
+        super(message);
+    }
+
+
+    /**
+     * Constructs an {@code InternalError} with the specified detail
+     * message and cause.  <p>Note that the detail message associated
+     * with {@code cause} is <i>not</i> automatically incorporated in
+     * this error's detail message.
+     *
+     * @param  message the detail message (which is saved for later retrieval
+     *         by the {@link #getMessage()} method).
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link #getCause()} method).  (A {@code null} value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since  1.8
+     */
+    public InternalError(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs an {@code InternalError} with the specified cause
+     * and a detail message of {@code (cause==null ? null :
+     * cause.toString())} (which typically contains the class and
+     * detail message of {@code cause}).
+     *
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link #getCause()} method).  (A {@code null} value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since  1.8
+     */
+    public InternalError(Throwable cause) {
+        super(cause);
+    }
+
+}

jdkSrc/jdk8/java/lang/InterruptedException.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * Thrown when a thread is waiting, sleeping, or otherwise occupied,
+ * and the thread is interrupted, either before or during the activity.
+ * Occasionally a method may wish to test whether the current
+ * thread has been interrupted, and if so, to immediately throw
+ * this exception.  The following code can be used to achieve
+ * this effect:
+ * <pre>
+ *  if (Thread.interrupted())  // Clears interrupted status!
+ *      throw new InterruptedException();
+ * </pre>
+ *
+ * @author  Frank Yellin
+ * @see     java.lang.Object#wait()
+ * @see     java.lang.Object#wait(long)
+ * @see     java.lang.Object#wait(long, int)
+ * @see     java.lang.Thread#sleep(long)
+ * @see     java.lang.Thread#interrupt()
+ * @see     java.lang.Thread#interrupted()
+ * @since   JDK1.0
+ */
+public
+class InterruptedException extends Exception {
+    private static final long serialVersionUID = 6700697376100628473L;
+
+    /**
+     * Constructs an <code>InterruptedException</code> with no detail  message.
+     */
+    public InterruptedException() {
+        super();
+    }
+
+    /**
+     * Constructs an <code>InterruptedException</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public InterruptedException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/Iterable.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2003, 2013, 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.util.Iterator;
+import java.util.Objects;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.Consumer;
+
+/**
+ * Implementing this interface allows an object to be the target of
+ * the "for-each loop" statement. See
+ * <strong>
+ * <a href="{@docRoot}/../technotes/guides/language/foreach.html">For-each Loop</a>
+ * </strong>
+ *
+ * @param <T> the type of elements returned by the iterator
+ *
+ * @since 1.5
+ * @jls 14.14.2 The enhanced for statement
+ */
+public interface Iterable<T> {
+    /**
+     * Returns an iterator over elements of type {@code T}.
+     *
+     * @return an Iterator.
+     */
+    Iterator<T> iterator();
+
+    /**
+     * Performs the given action for each element of the {@code Iterable}
+     * until all elements have been processed or the action throws an
+     * exception.  Unless otherwise specified by the implementing class,
+     * actions are performed in the order of iteration (if an iteration order
+     * is specified).  Exceptions thrown by the action are relayed to the
+     * caller.
+     *
+     * @implSpec
+     * <p>The default implementation behaves as if:
+     * <pre>{@code
+     *     for (T t : this)
+     *         action.accept(t);
+     * }</pre>
+     *
+     * @param action The action to be performed for each element
+     * @throws NullPointerException if the specified action is null
+     * @since 1.8
+     */
+    default void forEach(Consumer<? super T> action) {
+        Objects.requireNonNull(action);
+        for (T t : this) {
+            action.accept(t);
+        }
+    }
+
+    /**
+     * Creates a {@link Spliterator} over the elements described by this
+     * {@code Iterable}.
+     *
+     * @implSpec
+     * The default implementation creates an
+     * <em><a href="Spliterator.html#binding">early-binding</a></em>
+     * spliterator from the iterable's {@code Iterator}.  The spliterator
+     * inherits the <em>fail-fast</em> properties of the iterable's iterator.
+     *
+     * @implNote
+     * The default implementation should usually be overridden.  The
+     * spliterator returned by the default implementation has poor splitting
+     * capabilities, is unsized, and does not report any spliterator
+     * characteristics. Implementing classes can nearly always provide a
+     * better implementation.
+     *
+     * @return a {@code Spliterator} over the elements described by this
+     * {@code Iterable}.
+     * @since 1.8
+     */
+    default Spliterator<T> spliterator() {
+        return Spliterators.spliteratorUnknownSize(iterator(), 0);
+    }
+}

jdkSrc/jdk8/java/lang/LinkageError.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 1995, 2010, 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;
+
+/**
+ * Subclasses of {@code LinkageError} indicate that a class has
+ * some dependency on another class; however, the latter class has
+ * incompatibly changed after the compilation of the former class.
+ *
+ *
+ * @author  Frank Yellin
+ * @since   JDK1.0
+ */
+public
+class LinkageError extends Error {
+    private static final long serialVersionUID = 3579600108157160122L;
+
+    /**
+     * Constructs a {@code LinkageError} with no detail message.
+     */
+    public LinkageError() {
+        super();
+    }
+
+    /**
+     * Constructs a {@code LinkageError} with the specified detail
+     * message.
+     *
+     * @param   s   the detail message.
+     */
+    public LinkageError(String s) {
+        super(s);
+    }
+
+    /**
+     * Constructs a {@code LinkageError} with the specified detail
+     * message and cause.
+     *
+     * @param s     the detail message.
+     * @param cause the cause, may be {@code null}
+     * @since 1.7
+     */
+    public LinkageError(String s, Throwable cause) {
+        super(s, cause);
+    }
+}

jdkSrc/jdk8/java/lang/NegativeArraySizeException.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 1994, 2008, 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;
+
+/**
+ * Thrown if an application tries to create an array with negative size.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class NegativeArraySizeException extends RuntimeException {
+    private static final long serialVersionUID = -8960118058596991861L;
+
+    /**
+     * Constructs a <code>NegativeArraySizeException</code> with no
+     * detail message.
+     */
+    public NegativeArraySizeException() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NegativeArraySizeException</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NegativeArraySizeException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/NoClassDefFoundError.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 1994, 2008, 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;
+
+/**
+ * Thrown if the Java Virtual Machine or a <code>ClassLoader</code> instance
+ * tries to load in the definition of a class (as part of a normal method call
+ * or as part of creating a new instance using the <code>new</code> expression)
+ * and no definition of the class could be found.
+ * <p>
+ * The searched-for class definition existed when the currently
+ * executing class was compiled, but the definition can no longer be
+ * found.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class NoClassDefFoundError extends LinkageError {
+    private static final long serialVersionUID = 9095859863287012458L;
+
+    /**
+     * Constructs a <code>NoClassDefFoundError</code> with no detail message.
+     */
+    public NoClassDefFoundError() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NoClassDefFoundError</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NoClassDefFoundError(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/NoSuchFieldError.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * Thrown if an application tries to access or modify a specified
+ * field of an object, and that object no longer has that field.
+ * <p>
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of a class has
+ * incompatibly changed.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class NoSuchFieldError extends IncompatibleClassChangeError {
+    private static final long serialVersionUID = -3456430195886129035L;
+
+    /**
+     * Constructs a <code>NoSuchFieldError</code> with no detail message.
+     */
+    public NoSuchFieldError() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NoSuchFieldError</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NoSuchFieldError(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/NoSuchFieldException.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 1996, 2008, 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;
+
+/**
+ * Signals that the class doesn't have a field of a specified name.
+ *
+ * @author  unascribed
+ * @since   JDK1.1
+ */
+public class NoSuchFieldException extends ReflectiveOperationException {
+    private static final long serialVersionUID = -6143714805279938260L;
+
+    /**
+     * Constructor.
+     */
+    public NoSuchFieldException() {
+        super();
+    }
+
+    /**
+     * Constructor with a detail message.
+     *
+     * @param s the detail message
+     */
+    public NoSuchFieldException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/NoSuchMethodError.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1994, 2008, 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;
+
+/**
+ * Thrown if an application tries to call a specified method of a
+ * class (either static or instance), and that class no longer has a
+ * definition of that method.
+ * <p>
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of a class has
+ * incompatibly changed.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class NoSuchMethodError extends IncompatibleClassChangeError {
+    private static final long serialVersionUID = -3765521442372831335L;
+
+    /**
+     * Constructs a <code>NoSuchMethodError</code> with no detail message.
+     */
+    public NoSuchMethodError() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NoSuchMethodError</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NoSuchMethodError(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/NoSuchMethodException.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1995, 2008, 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;
+
+/**
+ * Thrown when a particular method cannot be found.
+ *
+ * @author     unascribed
+ * @since      JDK1.0
+ */
+public
+class NoSuchMethodException extends ReflectiveOperationException {
+    private static final long serialVersionUID = 5034388446362600923L;
+
+    /**
+     * Constructs a <code>NoSuchMethodException</code> without a detail message.
+     */
+    public NoSuchMethodException() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NoSuchMethodException</code> with a detail message.
+     *
+     * @param      s   the detail message.
+     */
+    public NoSuchMethodException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/NullPointerException.java

@@ -0,0 +1,72 @@
+/*
+ * 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;
+
+/**
+ * Thrown when an application attempts to use {@code null} in a
+ * case where an object is required. These include:
+ * <ul>
+ * <li>Calling the instance method of a {@code null} object.
+ * <li>Accessing or modifying the field of a {@code null} object.
+ * <li>Taking the length of {@code null} as if it were an array.
+ * <li>Accessing or modifying the slots of {@code null} as if it
+ *     were an array.
+ * <li>Throwing {@code null} as if it were a {@code Throwable}
+ *     value.
+ * </ul>
+ * <p>
+ * Applications should throw instances of this class to indicate
+ * other illegal uses of the {@code null} object.
+ *
+ * {@code NullPointerException} objects may be constructed by the
+ * virtual machine as if {@linkplain Throwable#Throwable(String,
+ * Throwable, boolean, boolean) suppression were disabled and/or the
+ * stack trace was not writable}.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public
+class NullPointerException extends RuntimeException {
+    private static final long serialVersionUID = 5162710183389028792L;
+
+    /**
+     * Constructs a {@code NullPointerException} with no detail message.
+     */
+    public NullPointerException() {
+        super();
+    }
+
+    /**
+     * Constructs a {@code NullPointerException} with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NullPointerException(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/Number.java

@@ -0,0 +1,124 @@
+/*
+ * 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;
+
+/**
+ * The abstract class {@code Number} is the superclass of platform
+ * classes representing numeric values that are convertible to the
+ * primitive types {@code byte}, {@code double}, {@code float}, {@code
+ * int}, {@code long}, and {@code short}.
+ *
+ * The specific semantics of the conversion from the numeric value of
+ * a particular {@code Number} implementation to a given primitive
+ * type is defined by the {@code Number} implementation in question.
+ *
+ * For platform classes, the conversion is often analogous to a
+ * narrowing primitive conversion or a widening primitive conversion
+ * as defining in <cite>The Java&trade; Language Specification</cite>
+ * for converting between primitive types.  Therefore, conversions may
+ * lose information about the overall magnitude of a numeric value, may
+ * lose precision, and may even return a result of a different sign
+ * than the input.
+ *
+ * See the documentation of a given {@code Number} implementation for
+ * conversion details.
+ *
+ * @author      Lee Boynton
+ * @author      Arthur van Hoff
+ * @jls 5.1.2 Widening Primitive Conversions
+ * @jls 5.1.3 Narrowing Primitive Conversions
+ * @since   JDK1.0
+ */
+public abstract class Number implements java.io.Serializable {
+    /**
+     * Returns the value of the specified number as an {@code int},
+     * which may involve rounding or truncation.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code int}.
+     */
+    public abstract int intValue();
+
+    /**
+     * Returns the value of the specified number as a {@code long},
+     * which may involve rounding or truncation.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code long}.
+     */
+    public abstract long longValue();
+
+    /**
+     * Returns the value of the specified number as a {@code float},
+     * which may involve rounding.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code float}.
+     */
+    public abstract float floatValue();
+
+    /**
+     * Returns the value of the specified number as a {@code double},
+     * which may involve rounding.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code double}.
+     */
+    public abstract double doubleValue();
+
+    /**
+     * Returns the value of the specified number as a {@code byte},
+     * which may involve rounding or truncation.
+     *
+     * <p>This implementation returns the result of {@link #intValue} cast
+     * to a {@code byte}.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code byte}.
+     * @since   JDK1.1
+     */
+    public byte byteValue() {
+        return (byte)intValue();
+    }
+
+    /**
+     * Returns the value of the specified number as a {@code short},
+     * which may involve rounding or truncation.
+     *
+     * <p>This implementation returns the result of {@link #intValue} cast
+     * to a {@code short}.
+     *
+     * @return  the numeric value represented by this object after conversion
+     *          to type {@code short}.
+     * @since   JDK1.1
+     */
+    public short shortValue() {
+        return (short)intValue();
+    }
+
+    /** use serialVersionUID from JDK 1.0.2 for interoperability */
+    private static final long serialVersionUID = -8742448824652078965L;
+}

jdkSrc/jdk8/java/lang/NumberFormatException.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1994, 2012, 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;
+
+/**
+ * Thrown to indicate that the application has attempted to convert
+ * a string to one of the numeric types, but that the string does not
+ * have the appropriate format.
+ *
+ * @author  unascribed
+ * @see     java.lang.Integer#parseInt(String)
+ * @since   JDK1.0
+ */
+public
+class NumberFormatException extends IllegalArgumentException {
+    static final long serialVersionUID = -2848938806368998894L;
+
+    /**
+     * Constructs a <code>NumberFormatException</code> with no detail message.
+     */
+    public NumberFormatException () {
+        super();
+    }
+
+    /**
+     * Constructs a <code>NumberFormatException</code> with the
+     * specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public NumberFormatException (String s) {
+        super (s);
+    }
+
+    /**
+     * Factory method for making a <code>NumberFormatException</code>
+     * given the specified input which caused the error.
+     *
+     * @param   s   the input causing the error
+     */
+    static NumberFormatException forInputString(String s) {
+        return new NumberFormatException("For input string: \"" + s + "\"");
+    }
+}

jdkSrc/jdk8/java/lang/Object.java

@@ -0,0 +1,556 @@
+/*
+ * Copyright (c) 1994, 2012, 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;
+
+/**
+ * Class {@code Object} is the root of the class hierarchy.
+ * Every class has {@code Object} as a superclass. All objects,
+ * including arrays, implement the methods of this class.
+ *
+ * @author  unascribed
+ * @see     java.lang.Class
+ * @since   JDK1.0
+ */
+public class Object {
+
+    private static native void registerNatives();
+    static {
+        registerNatives();
+    }
+
+    /**
+     * Returns the runtime class of this {@code Object}. The returned
+     * {@code Class} object is the object that is locked by {@code
+     * static synchronized} methods of the represented class.
+     *
+     * <p><b>The actual result type is {@code Class<? extends |X|>}
+     * where {@code |X|} is the erasure of the static type of the
+     * expression on which {@code getClass} is called.</b> For
+     * example, no cast is required in this code fragment:</p>
+     *
+     * <p>
+     * {@code Number n = 0;                             }<br>
+     * {@code Class<? extends Number> c = n.getClass(); }
+     * </p>
+     *
+     * @return The {@code Class} object that represents the runtime
+     *         class of this object.
+     * @jls 15.8.2 Class Literals
+     */
+    public final native Class<?> getClass();
+
+    /**
+     * Returns a hash code value for the object. This method is
+     * supported for the benefit of hash tables such as those provided by
+     * {@link java.util.HashMap}.
+     * <p>
+     * The general contract of {@code hashCode} is:
+     * <ul>
+     * <li>Whenever it is invoked on the same object more than once during
+     *     an execution of a Java application, the {@code hashCode} method
+     *     must consistently return the same integer, provided no information
+     *     used in {@code equals} comparisons on the object is modified.
+     *     This integer need not remain consistent from one execution of an
+     *     application to another execution of the same application.
+     * <li>If two objects are equal according to the {@code equals(Object)}
+     *     method, then calling the {@code hashCode} method on each of
+     *     the two objects must produce the same integer result.
+     * <li>It is <em>not</em> required that if two objects are unequal
+     *     according to the {@link java.lang.Object#equals(java.lang.Object)}
+     *     method, then calling the {@code hashCode} method on each of the
+     *     two objects must produce distinct integer results.  However, the
+     *     programmer should be aware that producing distinct integer results
+     *     for unequal objects may improve the performance of hash tables.
+     * </ul>
+     * <p>
+     * As much as is reasonably practical, the hashCode method defined by
+     * class {@code Object} does return distinct integers for distinct
+     * objects. (This is typically implemented by converting the internal
+     * address of the object into an integer, but this implementation
+     * technique is not required by the
+     * Java&trade; programming language.)
+     *
+     * @return  a hash code value for this object.
+     * @see     java.lang.Object#equals(java.lang.Object)
+     * @see     java.lang.System#identityHashCode
+     */
+    public native int hashCode();
+
+    /**
+     * Indicates whether some other object is "equal to" this one.
+     * <p>
+     * The {@code equals} method implements an equivalence relation
+     * on non-null object references:
+     * <ul>
+     * <li>It is <i>reflexive</i>: for any non-null reference value
+     *     {@code x}, {@code x.equals(x)} should return
+     *     {@code true}.
+     * <li>It is <i>symmetric</i>: for any non-null reference values
+     *     {@code x} and {@code y}, {@code x.equals(y)}
+     *     should return {@code true} if and only if
+     *     {@code y.equals(x)} returns {@code true}.
+     * <li>It is <i>transitive</i>: for any non-null reference values
+     *     {@code x}, {@code y}, and {@code z}, if
+     *     {@code x.equals(y)} returns {@code true} and
+     *     {@code y.equals(z)} returns {@code true}, then
+     *     {@code x.equals(z)} should return {@code true}.
+     * <li>It is <i>consistent</i>: for any non-null reference values
+     *     {@code x} and {@code y}, multiple invocations of
+     *     {@code x.equals(y)} consistently return {@code true}
+     *     or consistently return {@code false}, provided no
+     *     information used in {@code equals} comparisons on the
+     *     objects is modified.
+     * <li>For any non-null reference value {@code x},
+     *     {@code x.equals(null)} should return {@code false}.
+     * </ul>
+     * <p>
+     * The {@code equals} method for class {@code Object} implements
+     * the most discriminating possible equivalence relation on objects;
+     * that is, for any non-null reference values {@code x} and
+     * {@code y}, this method returns {@code true} if and only
+     * if {@code x} and {@code y} refer to the same object
+     * ({@code x == y} has the value {@code true}).
+     * <p>
+     * Note that it is generally necessary to override the {@code hashCode}
+     * method whenever this method is overridden, so as to maintain the
+     * general contract for the {@code hashCode} method, which states
+     * that equal objects must have equal hash codes.
+     *
+     * @param   obj   the reference object with which to compare.
+     * @return  {@code true} if this object is the same as the obj
+     *          argument; {@code false} otherwise.
+     * @see     #hashCode()
+     * @see     java.util.HashMap
+     */
+    public boolean equals(Object obj) {
+        return (this == obj);
+    }
+
+    /**
+     * Creates and returns a copy of this object.  The precise meaning
+     * of "copy" may depend on the class of the object. The general
+     * intent is that, for any object {@code x}, the expression:
+     * <blockquote>
+     * <pre>
+     * x.clone() != x</pre></blockquote>
+     * will be true, and that the expression:
+     * <blockquote>
+     * <pre>
+     * x.clone().getClass() == x.getClass()</pre></blockquote>
+     * will be {@code true}, but these are not absolute requirements.
+     * While it is typically the case that:
+     * <blockquote>
+     * <pre>
+     * x.clone().equals(x)</pre></blockquote>
+     * will be {@code true}, this is not an absolute requirement.
+     * <p>
+     * By convention, the returned object should be obtained by calling
+     * {@code super.clone}.  If a class and all of its superclasses (except
+     * {@code Object}) obey this convention, it will be the case that
+     * {@code x.clone().getClass() == x.getClass()}.
+     * <p>
+     * By convention, the object returned by this method should be independent
+     * of this object (which is being cloned).  To achieve this independence,
+     * it may be necessary to modify one or more fields of the object returned
+     * by {@code super.clone} before returning it.  Typically, this means
+     * copying any mutable objects that comprise the internal "deep structure"
+     * of the object being cloned and replacing the references to these
+     * objects with references to the copies.  If a class contains only
+     * primitive fields or references to immutable objects, then it is usually
+     * the case that no fields in the object returned by {@code super.clone}
+     * need to be modified.
+     * <p>
+     * The method {@code clone} for class {@code Object} performs a
+     * specific cloning operation. First, if the class of this object does
+     * not implement the interface {@code Cloneable}, then a
+     * {@code CloneNotSupportedException} is thrown. Note that all arrays
+     * are considered to implement the interface {@code Cloneable} and that
+     * the return type of the {@code clone} method of an array type {@code T[]}
+     * is {@code T[]} where T is any reference or primitive type.
+     * Otherwise, this method creates a new instance of the class of this
+     * object and initializes all its fields with exactly the contents of
+     * the corresponding fields of this object, as if by assignment; the
+     * contents of the fields are not themselves cloned. Thus, this method
+     * performs a "shallow copy" of this object, not a "deep copy" operation.
+     * <p>
+     * The class {@code Object} does not itself implement the interface
+     * {@code Cloneable}, so calling the {@code clone} method on an object
+     * whose class is {@code Object} will result in throwing an
+     * exception at run time.
+     *
+     * @return     a clone of this instance.
+     * @throws  CloneNotSupportedException  if the object's class does not
+     *               support the {@code Cloneable} interface. Subclasses
+     *               that override the {@code clone} method can also
+     *               throw this exception to indicate that an instance cannot
+     *               be cloned.
+     * @see java.lang.Cloneable
+     */
+    protected native Object clone() throws CloneNotSupportedException;
+
+    /**
+     * Returns a string representation of the object. In general, the
+     * {@code toString} method returns a string that
+     * "textually represents" this object. The result should
+     * be a concise but informative representation that is easy for a
+     * person to read.
+     * It is recommended that all subclasses override this method.
+     * <p>
+     * The {@code toString} method for class {@code Object}
+     * returns a string consisting of the name of the class of which the
+     * object is an instance, the at-sign character `{@code @}', and
+     * the unsigned hexadecimal representation of the hash code of the
+     * object. In other words, this method returns a string equal to the
+     * value of:
+     * <blockquote>
+     * <pre>
+     * getClass().getName() + '@' + Integer.toHexString(hashCode())
+     * </pre></blockquote>
+     *
+     * @return  a string representation of the object.
+     */
+    public String toString() {
+        return getClass().getName() + "@" + Integer.toHexString(hashCode());
+    }
+
+    /**
+     * Wakes up a single thread that is waiting on this object's
+     * monitor. If any threads are waiting on this object, one of them
+     * is chosen to be awakened. The choice is arbitrary and occurs at
+     * the discretion of the implementation. A thread waits on an object's
+     * monitor by calling one of the {@code wait} methods.
+     * <p>
+     * The awakened thread will not be able to proceed until the current
+     * thread relinquishes the lock on this object. The awakened thread will
+     * compete in the usual manner with any other threads that might be
+     * actively competing to synchronize on this object; for example, the
+     * awakened thread enjoys no reliable privilege or disadvantage in being
+     * the next thread to lock this object.
+     * <p>
+     * This method should only be called by a thread that is the owner
+     * of this object's monitor. A thread becomes the owner of the
+     * object's monitor in one of three ways:
+     * <ul>
+     * <li>By executing a synchronized instance method of that object.
+     * <li>By executing the body of a {@code synchronized} statement
+     *     that synchronizes on the object.
+     * <li>For objects of type {@code Class,} by executing a
+     *     synchronized static method of that class.
+     * </ul>
+     * <p>
+     * Only one thread at a time can own an object's monitor.
+     *
+     * @throws  IllegalMonitorStateException  if the current thread is not
+     *               the owner of this object's monitor.
+     * @see        java.lang.Object#notifyAll()
+     * @see        java.lang.Object#wait()
+     */
+    public final native void notify();
+
+    /**
+     * Wakes up all threads that are waiting on this object's monitor. A
+     * thread waits on an object's monitor by calling one of the
+     * {@code wait} methods.
+     * <p>
+     * The awakened threads will not be able to proceed until the current
+     * thread relinquishes the lock on this object. The awakened threads
+     * will compete in the usual manner with any other threads that might
+     * be actively competing to synchronize on this object; for example,
+     * the awakened threads enjoy no reliable privilege or disadvantage in
+     * being the next thread to lock this object.
+     * <p>
+     * This method should only be called by a thread that is the owner
+     * of this object's monitor. See the {@code notify} method for a
+     * description of the ways in which a thread can become the owner of
+     * a monitor.
+     *
+     * @throws  IllegalMonitorStateException  if the current thread is not
+     *               the owner of this object's monitor.
+     * @see        java.lang.Object#notify()
+     * @see        java.lang.Object#wait()
+     */
+    public final native void notifyAll();
+
+    /**
+     * Causes the current thread to wait until either another thread invokes the
+     * {@link java.lang.Object#notify()} method or the
+     * {@link java.lang.Object#notifyAll()} method for this object, or a
+     * specified amount of time has elapsed.
+     * <p>
+     * The current thread must own this object's monitor.
+     * <p>
+     * This method causes the current thread (call it <var>T</var>) to
+     * place itself in the wait set for this object and then to relinquish
+     * any and all synchronization claims on this object. Thread <var>T</var>
+     * becomes disabled for thread scheduling purposes and lies dormant
+     * until one of four things happens:
+     * <ul>
+     * <li>Some other thread invokes the {@code notify} method for this
+     * object and thread <var>T</var> happens to be arbitrarily chosen as
+     * the thread to be awakened.
+     * <li>Some other thread invokes the {@code notifyAll} method for this
+     * object.
+     * <li>Some other thread {@linkplain Thread#interrupt() interrupts}
+     * thread <var>T</var>.
+     * <li>The specified amount of real time has elapsed, more or less.  If
+     * {@code timeout} is zero, however, then real time is not taken into
+     * consideration and the thread simply waits until notified.
+     * </ul>
+     * The thread <var>T</var> is then removed from the wait set for this
+     * object and re-enabled for thread scheduling. It then competes in the
+     * usual manner with other threads for the right to synchronize on the
+     * object; once it has gained control of the object, all its
+     * synchronization claims on the object are restored to the status quo
+     * ante - that is, to the situation as of the time that the {@code wait}
+     * method was invoked. Thread <var>T</var> then returns from the
+     * invocation of the {@code wait} method. Thus, on return from the
+     * {@code wait} method, the synchronization state of the object and of
+     * thread {@code T} is exactly as it was when the {@code wait} method
+     * was invoked.
+     * <p>
+     * A thread can also wake up without being notified, interrupted, or
+     * timing out, a so-called <i>spurious wakeup</i>.  While this will rarely
+     * occur in practice, applications must guard against it by testing for
+     * the condition that should have caused the thread to be awakened, and
+     * continuing to wait if the condition is not satisfied.  In other words,
+     * waits should always occur in loops, like this one:
+     * <pre>
+     *     synchronized (obj) {
+     *         while (&lt;condition does not hold&gt;)
+     *             obj.wait(timeout);
+     *         ... // Perform action appropriate to condition
+     *     }
+     * </pre>
+     * (For more information on this topic, see Section 3.2.3 in Doug Lea's
+     * "Concurrent Programming in Java (Second Edition)" (Addison-Wesley,
+     * 2000), or Item 50 in Joshua Bloch's "Effective Java Programming
+     * Language Guide" (Addison-Wesley, 2001).
+     *
+     * <p>If the current thread is {@linkplain java.lang.Thread#interrupt()
+     * interrupted} by any thread before or while it is waiting, then an
+     * {@code InterruptedException} is thrown.  This exception is not
+     * thrown until the lock status of this object has been restored as
+     * described above.
+     *
+     * <p>
+     * Note that the {@code wait} method, as it places the current thread
+     * into the wait set for this object, unlocks only this object; any
+     * other objects on which the current thread may be synchronized remain
+     * locked while the thread waits.
+     * <p>
+     * This method should only be called by a thread that is the owner
+     * of this object's monitor. See the {@code notify} method for a
+     * description of the ways in which a thread can become the owner of
+     * a monitor.
+     *
+     * @param      timeout   the maximum time to wait in milliseconds.
+     * @throws  IllegalArgumentException      if the value of timeout is
+     *               negative.
+     * @throws  IllegalMonitorStateException  if the current thread is not
+     *               the owner of the object's monitor.
+     * @throws  InterruptedException if any thread interrupted the
+     *             current thread before or while the current thread
+     *             was waiting for a notification.  The <i>interrupted
+     *             status</i> of the current thread is cleared when
+     *             this exception is thrown.
+     * @see        java.lang.Object#notify()
+     * @see        java.lang.Object#notifyAll()
+     */
+    public final native void wait(long timeout) throws InterruptedException;
+
+    /**
+     * Causes the current thread to wait until another thread invokes the
+     * {@link java.lang.Object#notify()} method or the
+     * {@link java.lang.Object#notifyAll()} method for this object, or
+     * some other thread interrupts the current thread, or a certain
+     * amount of real time has elapsed.
+     * <p>
+     * This method is similar to the {@code wait} method of one
+     * argument, but it allows finer control over the amount of time to
+     * wait for a notification before giving up. The amount of real time,
+     * measured in nanoseconds, is given by:
+     * <blockquote>
+     * <pre>
+     * 1000000*timeout+nanos</pre></blockquote>
+     * <p>
+     * In all other respects, this method does the same thing as the
+     * method {@link #wait(long)} of one argument. In particular,
+     * {@code wait(0, 0)} means the same thing as {@code wait(0)}.
+     * <p>
+     * The current thread must own this object's monitor. The thread
+     * releases ownership of this monitor and waits until either of the
+     * following two conditions has occurred:
+     * <ul>
+     * <li>Another thread notifies threads waiting on this object's monitor
+     *     to wake up either through a call to the {@code notify} method
+     *     or the {@code notifyAll} method.
+     * <li>The timeout period, specified by {@code timeout}
+     *     milliseconds plus {@code nanos} nanoseconds arguments, has
+     *     elapsed.
+     * </ul>
+     * <p>
+     * The thread then waits until it can re-obtain ownership of the
+     * monitor and resumes execution.
+     * <p>
+     * As in the one argument version, interrupts and spurious wakeups are
+     * possible, and this method should always be used in a loop:
+     * <pre>
+     *     synchronized (obj) {
+     *         while (&lt;condition does not hold&gt;)
+     *             obj.wait(timeout, nanos);
+     *         ... // Perform action appropriate to condition
+     *     }
+     * </pre>
+     * This method should only be called by a thread that is the owner
+     * of this object's monitor. See the {@code notify} method for a
+     * description of the ways in which a thread can become the owner of
+     * a monitor.
+     *
+     * @param      timeout   the maximum time to wait in milliseconds.
+     * @param      nanos      additional time, in nanoseconds range
+     *                       0-999999.
+     * @throws  IllegalArgumentException      if the value of timeout is
+     *                      negative or the value of nanos is
+     *                      not in the range 0-999999.
+     * @throws  IllegalMonitorStateException  if the current thread is not
+     *               the owner of this object's monitor.
+     * @throws  InterruptedException if any thread interrupted the
+     *             current thread before or while the current thread
+     *             was waiting for a notification.  The <i>interrupted
+     *             status</i> of the current thread is cleared when
+     *             this exception is thrown.
+     */
+    public final void wait(long timeout, int nanos) throws InterruptedException {
+        if (timeout < 0) {
+            throw new IllegalArgumentException("timeout value is negative");
+        }
+
+        if (nanos < 0 || nanos > 999999) {
+            throw new IllegalArgumentException(
+                                "nanosecond timeout value out of range");
+        }
+
+        if (nanos > 0) {
+            timeout++;
+        }
+
+        wait(timeout);
+    }
+
+    /**
+     * Causes the current thread to wait until another thread invokes the
+     * {@link java.lang.Object#notify()} method or the
+     * {@link java.lang.Object#notifyAll()} method for this object.
+     * In other words, this method behaves exactly as if it simply
+     * performs the call {@code wait(0)}.
+     * <p>
+     * The current thread must own this object's monitor. The thread
+     * releases ownership of this monitor and waits until another thread
+     * notifies threads waiting on this object's monitor to wake up
+     * either through a call to the {@code notify} method or the
+     * {@code notifyAll} method. The thread then waits until it can
+     * re-obtain ownership of the monitor and resumes execution.
+     * <p>
+     * As in the one argument version, interrupts and spurious wakeups are
+     * possible, and this method should always be used in a loop:
+     * <pre>
+     *     synchronized (obj) {
+     *         while (&lt;condition does not hold&gt;)
+     *             obj.wait();
+     *         ... // Perform action appropriate to condition
+     *     }
+     * </pre>
+     * This method should only be called by a thread that is the owner
+     * of this object's monitor. See the {@code notify} method for a
+     * description of the ways in which a thread can become the owner of
+     * a monitor.
+     *
+     * @throws  IllegalMonitorStateException  if the current thread is not
+     *               the owner of the object's monitor.
+     * @throws  InterruptedException if any thread interrupted the
+     *             current thread before or while the current thread
+     *             was waiting for a notification.  The <i>interrupted
+     *             status</i> of the current thread is cleared when
+     *             this exception is thrown.
+     * @see        java.lang.Object#notify()
+     * @see        java.lang.Object#notifyAll()
+     */
+    public final void wait() throws InterruptedException {
+        wait(0);
+    }
+
+    /**
+     * Called by the garbage collector on an object when garbage collection
+     * determines that there are no more references to the object.
+     * A subclass overrides the {@code finalize} method to dispose of
+     * system resources or to perform other cleanup.
+     * <p>
+     * The general contract of {@code finalize} is that it is invoked
+     * if and when the Java&trade; virtual
+     * machine has determined that there is no longer any
+     * means by which this object can be accessed by any thread that has
+     * not yet died, except as a result of an action taken by the
+     * finalization of some other object or class which is ready to be
+     * finalized. The {@code finalize} method may take any action, including
+     * making this object available again to other threads; the usual purpose
+     * of {@code finalize}, however, is to perform cleanup actions before
+     * the object is irrevocably discarded. For example, the finalize method
+     * for an object that represents an input/output connection might perform
+     * explicit I/O transactions to break the connection before the object is
+     * permanently discarded.
+     * <p>
+     * The {@code finalize} method of class {@code Object} performs no
+     * special action; it simply returns normally. Subclasses of
+     * {@code Object} may override this definition.
+     * <p>
+     * The Java programming language does not guarantee which thread will
+     * invoke the {@code finalize} method for any given object. It is
+     * guaranteed, however, that the thread that invokes finalize will not
+     * be holding any user-visible synchronization locks when finalize is
+     * invoked. If an uncaught exception is thrown by the finalize method,
+     * the exception is ignored and finalization of that object terminates.
+     * <p>
+     * After the {@code finalize} method has been invoked for an object, no
+     * further action is taken until the Java virtual machine has again
+     * determined that there is no longer any means by which this object can
+     * be accessed by any thread that has not yet died, including possible
+     * actions by other objects or classes which are ready to be finalized,
+     * at which point the object may be discarded.
+     * <p>
+     * The {@code finalize} method is never invoked more than once by a Java
+     * virtual machine for any given object.
+     * <p>
+     * Any exception thrown by the {@code finalize} method causes
+     * the finalization of this object to be halted, but is otherwise
+     * ignored.
+     *
+     * @throws Throwable the {@code Exception} raised by this method
+     * @see java.lang.ref.WeakReference
+     * @see java.lang.ref.PhantomReference
+     * @jls 12.6 Finalization of Class Instances
+     */
+    protected void finalize() throws Throwable { }
+}

jdkSrc/jdk8/java/lang/OutOfMemoryError.java

@@ -0,0 +1,60 @@
+/*
+ * 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;
+
+/**
+ * Thrown when the Java Virtual Machine cannot allocate an object
+ * because it is out of memory, and no more memory could be made
+ * available by the garbage collector.
+ *
+ * {@code OutOfMemoryError} objects may be constructed by the virtual
+ * machine as if {@linkplain Throwable#Throwable(String, Throwable,
+ * boolean, boolean) suppression were disabled and/or the stack trace was not
+ * writable}.
+ *
+ * @author  unascribed
+ * @since   JDK1.0
+ */
+public class OutOfMemoryError extends VirtualMachineError {
+    private static final long serialVersionUID = 8228564086184010517L;
+
+    /**
+     * Constructs an {@code OutOfMemoryError} with no detail message.
+     */
+    public OutOfMemoryError() {
+        super();
+    }
+
+    /**
+     * Constructs an {@code OutOfMemoryError} with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public OutOfMemoryError(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/Override.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2003, 2013, 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.lang.annotation.*;
+
+/**
+ * Indicates that a method declaration is intended to override a
+ * method declaration in a supertype. If a method is annotated with
+ * this annotation type compilers are required to generate an error
+ * message unless at least one of the following conditions hold:
+ *
+ * <ul><li>
+ * The method does override or implement a method declared in a
+ * supertype.
+ * </li><li>
+ * The method has a signature that is override-equivalent to that of
+ * any public method declared in {@linkplain Object}.
+ * </li></ul>
+ *
+ * @author  Peter von der Ah&eacute;
+ * @author  Joshua Bloch
+ * @jls 9.6.1.4 @Override
+ * @since 1.5
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.SOURCE)
+public @interface Override {
+}

jdkSrc/jdk8/java/lang/Package.java

@@ -0,0 +1,644 @@
+/*
+ * Copyright (c) 1997, 2013, 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.lang.reflect.AnnotatedElement;
+import java.io.InputStream;
+import java.util.Enumeration;
+
+import java.util.StringTokenizer;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.URL;
+import java.net.MalformedURLException;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+import java.util.jar.JarInputStream;
+import java.util.jar.Manifest;
+import java.util.jar.Attributes;
+import java.util.jar.Attributes.Name;
+import java.util.jar.JarException;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import sun.net.www.ParseUtil;
+import sun.reflect.CallerSensitive;
+import sun.reflect.Reflection;
+
+import java.lang.annotation.Annotation;
+
+/**
+ * {@code Package} objects contain version information
+ * about the implementation and specification of a Java package.
+ * This versioning information is retrieved and made available
+ * by the {@link ClassLoader} instance that
+ * loaded the class(es).  Typically, it is stored in the manifest that is
+ * distributed with the classes.
+ *
+ * <p>The set of classes that make up the package may implement a
+ * particular specification and if so the specification title, version number,
+ * and vendor strings identify that specification.
+ * An application can ask if the package is
+ * compatible with a particular version, see the {@link
+ * #isCompatibleWith isCompatibleWith}
+ * method for details.
+ *
+ * <p>Specification version numbers use a syntax that consists of nonnegative
+ * decimal integers separated by periods ".", for example "2.0" or
+ * "1.2.3.4.5.6.7".  This allows an extensible number to be used to represent
+ * major, minor, micro, etc. versions.  The version specification is described
+ * by the following formal grammar:
+ * <blockquote>
+ * <dl>
+ * <dt><i>SpecificationVersion:</i>
+ * <dd><i>Digits RefinedVersion<sub>opt</sub></i>
+
+ * <dt><i>RefinedVersion:</i>
+ * <dd>{@code .} <i>Digits</i>
+ * <dd>{@code .} <i>Digits RefinedVersion</i>
+ *
+ * <dt><i>Digits:</i>
+ * <dd><i>Digit</i>
+ * <dd><i>Digits</i>
+ *
+ * <dt><i>Digit:</i>
+ * <dd>any character for which {@link Character#isDigit} returns {@code true},
+ * e.g. 0, 1, 2, ...
+ * </dl>
+ * </blockquote>
+ *
+ * <p>The implementation title, version, and vendor strings identify an
+ * implementation and are made available conveniently to enable accurate
+ * reporting of the packages involved when a problem occurs. The contents
+ * all three implementation strings are vendor specific. The
+ * implementation version strings have no specified syntax and should
+ * only be compared for equality with desired version identifiers.
+ *
+ * <p>Within each {@code ClassLoader} instance all classes from the same
+ * java package have the same Package object.  The static methods allow a package
+ * to be found by name or the set of all packages known to the current class
+ * loader to be found.
+ *
+ * @see ClassLoader#definePackage
+ */
+public class Package implements java.lang.reflect.AnnotatedElement {
+    /**
+     * Return the name of this package.
+     *
+     * @return  The fully-qualified name of this package as defined in section 6.5.3 of
+     *          <cite>The Java&trade; Language Specification</cite>,
+     *          for example, {@code java.lang}
+     */
+    public String getName() {
+        return pkgName;
+    }
+
+
+    /**
+     * Return the title of the specification that this package implements.
+     * @return the specification title, null is returned if it is not known.
+     */
+    public String getSpecificationTitle() {
+        return specTitle;
+    }
+
+    /**
+     * Returns the version number of the specification
+     * that this package implements.
+     * This version string must be a sequence of nonnegative decimal
+     * integers separated by "."'s and may have leading zeros.
+     * When version strings are compared the most significant
+     * numbers are compared.
+     * @return the specification version, null is returned if it is not known.
+     */
+    public String getSpecificationVersion() {
+        return specVersion;
+    }
+
+    /**
+     * Return the name of the organization, vendor,
+     * or company that owns and maintains the specification
+     * of the classes that implement this package.
+     * @return the specification vendor, null is returned if it is not known.
+     */
+    public String getSpecificationVendor() {
+        return specVendor;
+    }
+
+    /**
+     * Return the title of this package.
+     * @return the title of the implementation, null is returned if it is not known.
+     */
+    public String getImplementationTitle() {
+        return implTitle;
+    }
+
+    /**
+     * Return the version of this implementation. It consists of any string
+     * assigned by the vendor of this implementation and does
+     * not have any particular syntax specified or expected by the Java
+     * runtime. It may be compared for equality with other
+     * package version strings used for this implementation
+     * by this vendor for this package.
+     * @return the version of the implementation, null is returned if it is not known.
+     */
+    public String getImplementationVersion() {
+        return implVersion;
+    }
+
+    /**
+     * Returns the name of the organization,
+     * vendor or company that provided this implementation.
+     * @return the vendor that implemented this package..
+     */
+    public String getImplementationVendor() {
+        return implVendor;
+    }
+
+    /**
+     * Returns true if this package is sealed.
+     *
+     * @return true if the package is sealed, false otherwise
+     */
+    public boolean isSealed() {
+        return sealBase != null;
+    }
+
+    /**
+     * Returns true if this package is sealed with respect to the specified
+     * code source url.
+     *
+     * @param url the code source url
+     * @return true if this package is sealed with respect to url
+     */
+    public boolean isSealed(URL url) {
+        return url.equals(sealBase);
+    }
+
+    /**
+     * Compare this package's specification version with a
+     * desired version. It returns true if
+     * this packages specification version number is greater than or equal
+     * to the desired version number. <p>
+     *
+     * Version numbers are compared by sequentially comparing corresponding
+     * components of the desired and specification strings.
+     * Each component is converted as a decimal integer and the values
+     * compared.
+     * If the specification value is greater than the desired
+     * value true is returned. If the value is less false is returned.
+     * If the values are equal the period is skipped and the next pair of
+     * components is compared.
+     *
+     * @param desired the version string of the desired version.
+     * @return true if this package's version number is greater
+     *          than or equal to the desired version number
+     *
+     * @exception NumberFormatException if the desired or current version
+     *          is not of the correct dotted form.
+     */
+    public boolean isCompatibleWith(String desired)
+        throws NumberFormatException
+    {
+        if (specVersion == null || specVersion.length() < 1) {
+            throw new NumberFormatException("Empty version string");
+        }
+
+        String [] sa = specVersion.split("\\.", -1);
+        int [] si = new int[sa.length];
+        for (int i = 0; i < sa.length; i++) {
+            si[i] = Integer.parseInt(sa[i]);
+            if (si[i] < 0)
+                throw NumberFormatException.forInputString("" + si[i]);
+        }
+
+        String [] da = desired.split("\\.", -1);
+        int [] di = new int[da.length];
+        for (int i = 0; i < da.length; i++) {
+            di[i] = Integer.parseInt(da[i]);
+            if (di[i] < 0)
+                throw NumberFormatException.forInputString("" + di[i]);
+        }
+
+        int len = Math.max(di.length, si.length);
+        for (int i = 0; i < len; i++) {
+            int d = (i < di.length ? di[i] : 0);
+            int s = (i < si.length ? si[i] : 0);
+            if (s < d)
+                return false;
+            if (s > d)
+                return true;
+        }
+        return true;
+    }
+
+    /**
+     * Find a package by name in the callers {@code ClassLoader} instance.
+     * The callers {@code ClassLoader} instance is used to find the package
+     * instance corresponding to the named class. If the callers
+     * {@code ClassLoader} instance is null then the set of packages loaded
+     * by the system {@code ClassLoader} instance is searched to find the
+     * named package. <p>
+     *
+     * Packages have attributes for versions and specifications only if the class
+     * loader created the package instance with the appropriate attributes. Typically,
+     * those attributes are defined in the manifests that accompany the classes.
+     *
+     * @param name a package name, for example, java.lang.
+     * @return the package of the requested name. It may be null if no package
+     *          information is available from the archive or codebase.
+     */
+    @CallerSensitive
+    public static Package getPackage(String name) {
+        ClassLoader l = ClassLoader.getClassLoader(Reflection.getCallerClass());
+        if (l != null) {
+            return l.getPackage(name);
+        } else {
+            return getSystemPackage(name);
+        }
+    }
+
+    /**
+     * Get all the packages currently known for the caller's {@code ClassLoader}
+     * instance.  Those packages correspond to classes loaded via or accessible by
+     * name to that {@code ClassLoader} instance.  If the caller's
+     * {@code ClassLoader} instance is the bootstrap {@code ClassLoader}
+     * instance, which may be represented by {@code null} in some implementations,
+     * only packages corresponding to classes loaded by the bootstrap
+     * {@code ClassLoader} instance will be returned.
+     *
+     * @return a new array of packages known to the callers {@code ClassLoader}
+     * instance.  An zero length array is returned if none are known.
+     */
+    @CallerSensitive
+    public static Package[] getPackages() {
+        ClassLoader l = ClassLoader.getClassLoader(Reflection.getCallerClass());
+        if (l != null) {
+            return l.getPackages();
+        } else {
+            return getSystemPackages();
+        }
+    }
+
+    /**
+     * Get the package for the specified class.
+     * The class's class loader is used to find the package instance
+     * corresponding to the specified class. If the class loader
+     * is the bootstrap class loader, which may be represented by
+     * {@code null} in some implementations, then the set of packages
+     * loaded by the bootstrap class loader is searched to find the package.
+     * <p>
+     * Packages have attributes for versions and specifications only
+     * if the class loader created the package
+     * instance with the appropriate attributes. Typically those
+     * attributes are defined in the manifests that accompany
+     * the classes.
+     *
+     * @param c the class to get the package of.
+     * @return the package of the class. It may be null if no package
+     *          information is available from the archive or codebase.  */
+    static Package getPackage(Class<?> c) {
+        String name = c.getName();
+        int i = name.lastIndexOf('.');
+        if (i != -1) {
+            name = name.substring(0, i);
+            ClassLoader cl = c.getClassLoader();
+            if (cl != null) {
+                return cl.getPackage(name);
+            } else {
+                return getSystemPackage(name);
+            }
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Return the hash code computed from the package name.
+     * @return the hash code computed from the package name.
+     */
+    public int hashCode(){
+        return pkgName.hashCode();
+    }
+
+    /**
+     * Returns the string representation of this Package.
+     * Its value is the string "package " and the package name.
+     * If the package title is defined it is appended.
+     * If the package version is defined it is appended.
+     * @return the string representation of the package.
+     */
+    public String toString() {
+        String spec = specTitle;
+        String ver =  specVersion;
+        if (spec != null && spec.length() > 0)
+            spec = ", " + spec;
+        else
+            spec = "";
+        if (ver != null && ver.length() > 0)
+            ver = ", version " + ver;
+        else
+            ver = "";
+        return "package " + pkgName + spec + ver;
+    }
+
+    private Class<?> getPackageInfo() {
+        if (packageInfo == null) {
+            try {
+                packageInfo = Class.forName(pkgName + ".package-info", false, loader);
+            } catch (ClassNotFoundException ex) {
+                // store a proxy for the package info that has no annotations
+                class PackageInfoProxy {}
+                packageInfo = PackageInfoProxy.class;
+            }
+        }
+        return packageInfo;
+    }
+
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.5
+     */
+    public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
+        return getPackageInfo().getAnnotation(annotationClass);
+    }
+
+    /**
+     * {@inheritDoc}
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.5
+     */
+    @Override
+    public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
+        return AnnotatedElement.super.isAnnotationPresent(annotationClass);
+    }
+
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.8
+     */
+    @Override
+    public  <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationClass) {
+        return getPackageInfo().getAnnotationsByType(annotationClass);
+    }
+
+    /**
+     * @since 1.5
+     */
+    public Annotation[] getAnnotations() {
+        return getPackageInfo().getAnnotations();
+    }
+
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.8
+     */
+    @Override
+    public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass) {
+        return getPackageInfo().getDeclaredAnnotation(annotationClass);
+    }
+
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.8
+     */
+    @Override
+    public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationClass) {
+        return getPackageInfo().getDeclaredAnnotationsByType(annotationClass);
+    }
+
+    /**
+     * @since 1.5
+     */
+    public Annotation[] getDeclaredAnnotations()  {
+        return getPackageInfo().getDeclaredAnnotations();
+    }
+
+    /**
+     * Construct a package instance with the specified version
+     * information.
+     * @param name the name of the package
+     * @param spectitle the title of the specification
+     * @param specversion the version of the specification
+     * @param specvendor the organization that maintains the specification
+     * @param impltitle the title of the implementation
+     * @param implversion the version of the implementation
+     * @param implvendor the organization that maintains the implementation
+     */
+    Package(String name,
+            String spectitle, String specversion, String specvendor,
+            String impltitle, String implversion, String implvendor,
+            URL sealbase, ClassLoader loader)
+    {
+        pkgName = name;
+        implTitle = impltitle;
+        implVersion = implversion;
+        implVendor = implvendor;
+        specTitle = spectitle;
+        specVersion = specversion;
+        specVendor = specvendor;
+        sealBase = sealbase;
+        this.loader = loader;
+    }
+
+    /*
+     * Construct a package using the attributes from the specified manifest.
+     *
+     * @param name the package name
+     * @param man the optional manifest for the package
+     * @param url the optional code source url for the package
+     */
+    private Package(String name, Manifest man, URL url, ClassLoader loader) {
+        String path = name.replace('.', '/').concat("/");
+        String sealed = null;
+        String specTitle= null;
+        String specVersion= null;
+        String specVendor= null;
+        String implTitle= null;
+        String implVersion= null;
+        String implVendor= null;
+        URL sealBase= null;
+        Attributes attr = man.getAttributes(path);
+        if (attr != null) {
+            specTitle   = attr.getValue(Name.SPECIFICATION_TITLE);
+            specVersion = attr.getValue(Name.SPECIFICATION_VERSION);
+            specVendor  = attr.getValue(Name.SPECIFICATION_VENDOR);
+            implTitle   = attr.getValue(Name.IMPLEMENTATION_TITLE);
+            implVersion = attr.getValue(Name.IMPLEMENTATION_VERSION);
+            implVendor  = attr.getValue(Name.IMPLEMENTATION_VENDOR);
+            sealed      = attr.getValue(Name.SEALED);
+        }
+        attr = man.getMainAttributes();
+        if (attr != null) {
+            if (specTitle == null) {
+                specTitle = attr.getValue(Name.SPECIFICATION_TITLE);
+            }
+            if (specVersion == null) {
+                specVersion = attr.getValue(Name.SPECIFICATION_VERSION);
+            }
+            if (specVendor == null) {
+                specVendor = attr.getValue(Name.SPECIFICATION_VENDOR);
+            }
+            if (implTitle == null) {
+                implTitle = attr.getValue(Name.IMPLEMENTATION_TITLE);
+            }
+            if (implVersion == null) {
+                implVersion = attr.getValue(Name.IMPLEMENTATION_VERSION);
+            }
+            if (implVendor == null) {
+                implVendor = attr.getValue(Name.IMPLEMENTATION_VENDOR);
+            }
+            if (sealed == null) {
+                sealed = attr.getValue(Name.SEALED);
+            }
+        }
+        if ("true".equalsIgnoreCase(sealed)) {
+            sealBase = url;
+        }
+        pkgName = name;
+        this.specTitle = specTitle;
+        this.specVersion = specVersion;
+        this.specVendor = specVendor;
+        this.implTitle = implTitle;
+        this.implVersion = implVersion;
+        this.implVendor = implVendor;
+        this.sealBase = sealBase;
+        this.loader = loader;
+    }
+
+    /*
+     * Returns the loaded system package for the specified name.
+     */
+    static Package getSystemPackage(String name) {
+        synchronized (pkgs) {
+            Package pkg = pkgs.get(name);
+            if (pkg == null) {
+                name = name.replace('.', '/').concat("/");
+                String fn = getSystemPackage0(name);
+                if (fn != null) {
+                    pkg = defineSystemPackage(name, fn);
+                }
+            }
+            return pkg;
+        }
+    }
+
+    /*
+     * Return an array of loaded system packages.
+     */
+    static Package[] getSystemPackages() {
+        // First, update the system package map with new package names
+        String[] names = getSystemPackages0();
+        synchronized (pkgs) {
+            for (int i = 0; i < names.length; i++) {
+                defineSystemPackage(names[i], getSystemPackage0(names[i]));
+            }
+            return pkgs.values().toArray(new Package[pkgs.size()]);
+        }
+    }
+
+    private static Package defineSystemPackage(final String iname,
+                                               final String fn)
+    {
+        return AccessController.doPrivileged(new PrivilegedAction<Package>() {
+            public Package run() {
+                String name = iname;
+                // Get the cached code source url for the file name
+                URL url = urls.get(fn);
+                if (url == null) {
+                    // URL not found, so create one
+                    File file = new File(fn);
+                    try {
+                        url = ParseUtil.fileToEncodedURL(file);
+                    } catch (MalformedURLException e) {
+                    }
+                    if (url != null) {
+                        urls.put(fn, url);
+                        // If loading a JAR file, then also cache the manifest
+                        if (file.isFile()) {
+                            mans.put(fn, loadManifest(fn));
+                        }
+                    }
+                }
+                // Convert to "."-separated package name
+                name = name.substring(0, name.length() - 1).replace('/', '.');
+                Package pkg;
+                Manifest man = mans.get(fn);
+                if (man != null) {
+                    pkg = new Package(name, man, url, null);
+                } else {
+                    pkg = new Package(name, null, null, null,
+                                      null, null, null, null, null);
+                }
+                pkgs.put(name, pkg);
+                return pkg;
+            }
+        });
+    }
+
+    /*
+     * Returns the Manifest for the specified JAR file name.
+     */
+    private static Manifest loadManifest(String fn) {
+        try (FileInputStream fis = new FileInputStream(fn);
+             JarInputStream jis = new JarInputStream(fis, false))
+        {
+            return jis.getManifest();
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    // The map of loaded system packages
+    private static Map<String, Package> pkgs = new HashMap<>(31);
+
+    // Maps each directory or zip file name to its corresponding url
+    private static Map<String, URL> urls = new HashMap<>(10);
+
+    // Maps each code source url for a jar file to its manifest
+    private static Map<String, Manifest> mans = new HashMap<>(10);
+
+    private static native String getSystemPackage0(String name);
+    private static native String[] getSystemPackages0();
+
+    /*
+     * Private storage for the package name and attributes.
+     */
+    private final String pkgName;
+    private final String specTitle;
+    private final String specVersion;
+    private final String specVendor;
+    private final String implTitle;
+    private final String implVersion;
+    private final String implVendor;
+    private final URL sealBase;
+    private transient final ClassLoader loader;
+    private transient Class<?> packageInfo;
+}

jdkSrc/jdk8/java/lang/Process.java

@@ -0,0 +1,265 @@
+/*
+ * Copyright (c) 1995, 2012, 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.concurrent.TimeUnit;
+
+/**
+ * The {@link ProcessBuilder#start()} and
+ * {@link Runtime#exec(String[],String[],File) Runtime.exec}
+ * methods create a native process and return an instance of a
+ * subclass of {@code Process} that can be used to control the process
+ * and obtain information about it.  The class {@code Process}
+ * provides methods for performing input from the process, performing
+ * output to the process, waiting for the process to complete,
+ * checking the exit status of the process, and destroying (killing)
+ * the process.
+ *
+ * <p>The methods that create processes may not work well for special
+ * processes on certain native platforms, such as native windowing
+ * processes, daemon processes, Win16/DOS processes on Microsoft
+ * Windows, or shell scripts.
+ *
+ * <p>By default, the created subprocess does not have its own terminal
+ * or console.  All its standard I/O (i.e. stdin, stdout, stderr)
+ * operations will be redirected to the parent process, where they can
+ * be accessed via the streams obtained using the methods
+ * {@link #getOutputStream()},
+ * {@link #getInputStream()}, and
+ * {@link #getErrorStream()}.
+ * The parent process uses these streams to feed input to and get output
+ * from the subprocess.  Because some native platforms only provide
+ * limited buffer size for standard input and output streams, failure
+ * to promptly write the input stream or read the output stream of
+ * the subprocess may cause the subprocess to block, or even deadlock.
+ *
+ * <p>Where desired, <a href="ProcessBuilder.html#redirect-input">
+ * subprocess I/O can also be redirected</a>
+ * using methods of the {@link ProcessBuilder} class.
+ *
+ * <p>The subprocess is not killed when there are no more references to
+ * the {@code Process} object, but rather the subprocess
+ * continues executing asynchronously.
+ *
+ * <p>There is no requirement that a process represented by a {@code
+ * Process} object execute asynchronously or concurrently with respect
+ * to the Java process that owns the {@code Process} object.
+ *
+ * <p>As of 1.5, {@link ProcessBuilder#start()} is the preferred way
+ * to create a {@code Process}.
+ *
+ * @since   JDK1.0
+ */
+public abstract class Process {
+    /**
+     * Returns the output stream connected to the normal input of the
+     * subprocess.  Output to the stream is piped into the standard
+     * input of the process represented by this {@code Process} object.
+     *
+     * <p>If the standard input of the subprocess has been redirected using
+     * {@link ProcessBuilder#redirectInput(Redirect)
+     * ProcessBuilder.redirectInput}
+     * then this method will return a
+     * <a href="ProcessBuilder.html#redirect-input">null output stream</a>.
+     *
+     * <p>Implementation note: It is a good idea for the returned
+     * output stream to be buffered.
+     *
+     * @return the output stream connected to the normal input of the
+     *         subprocess
+     */
+    public abstract OutputStream getOutputStream();
+
+    /**
+     * Returns the input stream connected to the normal output of the
+     * subprocess.  The stream obtains data piped from the standard
+     * output of the process represented by this {@code Process} object.
+     *
+     * <p>If the standard output of the subprocess has been redirected using
+     * {@link ProcessBuilder#redirectOutput(Redirect)
+     * ProcessBuilder.redirectOutput}
+     * then this method will return a
+     * <a href="ProcessBuilder.html#redirect-output">null input stream</a>.
+     *
+     * <p>Otherwise, if the standard error of the subprocess has been
+     * redirected using
+     * {@link ProcessBuilder#redirectErrorStream(boolean)
+     * ProcessBuilder.redirectErrorStream}
+     * then the input stream returned by this method will receive the
+     * merged standard output and the standard error of the subprocess.
+     *
+     * <p>Implementation note: It is a good idea for the returned
+     * input stream to be buffered.
+     *
+     * @return the input stream connected to the normal output of the
+     *         subprocess
+     */
+    public abstract InputStream getInputStream();
+
+    /**
+     * Returns the input stream connected to the error output of the
+     * subprocess.  The stream obtains data piped from the error output
+     * of the process represented by this {@code Process} object.
+     *
+     * <p>If the standard error of the subprocess has been redirected using
+     * {@link ProcessBuilder#redirectError(Redirect)
+     * ProcessBuilder.redirectError} or
+     * {@link ProcessBuilder#redirectErrorStream(boolean)
+     * ProcessBuilder.redirectErrorStream}
+     * then this method will return a
+     * <a href="ProcessBuilder.html#redirect-output">null input stream</a>.
+     *
+     * <p>Implementation note: It is a good idea for the returned
+     * input stream to be buffered.
+     *
+     * @return the input stream connected to the error output of
+     *         the subprocess
+     */
+    public abstract InputStream getErrorStream();
+
+    /**
+     * Causes the current thread to wait, if necessary, until the
+     * process represented by this {@code Process} object has
+     * terminated.  This method returns immediately if the subprocess
+     * has already terminated.  If the subprocess has not yet
+     * terminated, the calling thread will be blocked until the
+     * subprocess exits.
+     *
+     * @return the exit value of the subprocess represented by this
+     *         {@code Process} object.  By convention, the value
+     *         {@code 0} indicates normal termination.
+     * @throws InterruptedException if the current thread is
+     *         {@linkplain Thread#interrupt() interrupted} by another
+     *         thread while it is waiting, then the wait is ended and
+     *         an {@link InterruptedException} is thrown.
+     */
+    public abstract int waitFor() throws InterruptedException;
+
+    /**
+     * Causes the current thread to wait, if necessary, until the
+     * subprocess represented by this {@code Process} object has
+     * terminated, or the specified waiting time elapses.
+     *
+     * <p>If the subprocess has already terminated then this method returns
+     * immediately with the value {@code true}.  If the process has not
+     * terminated and the timeout value is less than, or equal to, zero, then
+     * this method returns immediately with the value {@code false}.
+     *
+     * <p>The default implementation of this methods polls the {@code exitValue}
+     * to check if the process has terminated. Concrete implementations of this
+     * class are strongly encouraged to override this method with a more
+     * efficient implementation.
+     *
+     * @param timeout the maximum time to wait
+     * @param unit the time unit of the {@code timeout} argument
+     * @return {@code true} if the subprocess has exited and {@code false} if
+     *         the waiting time elapsed before the subprocess has exited.
+     * @throws InterruptedException if the current thread is interrupted
+     *         while waiting.
+     * @throws NullPointerException if unit is null
+     * @since 1.8
+     */
+    public boolean waitFor(long timeout, TimeUnit unit)
+        throws InterruptedException
+    {
+        long startTime = System.nanoTime();
+        long rem = unit.toNanos(timeout);
+
+        do {
+            try {
+                exitValue();
+                return true;
+            } catch(IllegalThreadStateException ex) {
+                if (rem > 0)
+                    Thread.sleep(
+                        Math.min(TimeUnit.NANOSECONDS.toMillis(rem) + 1, 100));
+            }
+            rem = unit.toNanos(timeout) - (System.nanoTime() - startTime);
+        } while (rem > 0);
+        return false;
+    }
+
+    /**
+     * Returns the exit value for the subprocess.
+     *
+     * @return the exit value of the subprocess represented by this
+     *         {@code Process} object.  By convention, the value
+     *         {@code 0} indicates normal termination.
+     * @throws IllegalThreadStateException if the subprocess represented
+     *         by this {@code Process} object has not yet terminated
+     */
+    public abstract int exitValue();
+
+    /**
+     * Kills the subprocess. Whether the subprocess represented by this
+     * {@code Process} object is forcibly terminated or not is
+     * implementation dependent.
+     */
+    public abstract void destroy();
+
+    /**
+     * Kills the subprocess. The subprocess represented by this
+     * {@code Process} object is forcibly terminated.
+     *
+     * <p>The default implementation of this method invokes {@link #destroy}
+     * and so may not forcibly terminate the process. Concrete implementations
+     * of this class are strongly encouraged to override this method with a
+     * compliant implementation.  Invoking this method on {@code Process}
+     * objects returned by {@link ProcessBuilder#start} and
+     * {@link Runtime#exec} will forcibly terminate the process.
+     *
+     * <p>Note: The subprocess may not terminate immediately.
+     * i.e. {@code isAlive()} may return true for a brief period
+     * after {@code destroyForcibly()} is called. This method
+     * may be chained to {@code waitFor()} if needed.
+     *
+     * @return the {@code Process} object representing the
+     *         subprocess to be forcibly destroyed.
+     * @since 1.8
+     */
+    public Process destroyForcibly() {
+        destroy();
+        return this;
+    }
+
+    /**
+     * Tests whether the subprocess represented by this {@code Process} is
+     * alive.
+     *
+     * @return {@code true} if the subprocess represented by this
+     *         {@code Process} object has not yet terminated.
+     * @since 1.8
+     */
+    public boolean isAlive() {
+        try {
+            exitValue();
+            return false;
+        } catch(IllegalThreadStateException e) {
+            return true;
+        }
+    }
+}

jdkSrc/jdk8/java/lang/ProcessEnvironment.java

@@ -0,0 +1,351 @@
+/*
+ * Copyright (c) 2003, 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.
+ */
+
+/* We use APIs that access a so-called Windows "Environment Block",
+ * which looks like an array of jchars like this:
+ *
+ * FOO=BAR\u0000 ... GORP=QUUX\u0000\u0000
+ *
+ * This data structure has a number of peculiarities we must contend with:
+ * (see: http://windowssdk.msdn.microsoft.com/en-us/library/ms682009.aspx)
+ * - The NUL jchar separators, and a double NUL jchar terminator.
+ *   It appears that the Windows implementation requires double NUL
+ *   termination even if the environment is empty.  We should always
+ *   generate environments with double NUL termination, while accepting
+ *   empty environments consisting of a single NUL.
+ * - on Windows9x, this is actually an array of 8-bit chars, not jchars,
+ *   encoded in the system default encoding.
+ * - The block must be sorted by Unicode value, case-insensitively,
+ *   as if folded to upper case.
+ * - There are magic environment variables maintained by Windows
+ *   that start with a `=' (!) character.  These are used for
+ *   Windows drive current directory (e.g. "=C:=C:\WINNT") or the
+ *   exit code of the last command (e.g. "=ExitCode=0000001").
+ *
+ * Since Java and non-9x Windows speak the same character set, and
+ * even the same encoding, we don't have to deal with unreliable
+ * conversion to byte streams.  Just add a few NUL terminators.
+ *
+ * System.getenv(String) is case-insensitive, while System.getenv()
+ * returns a map that is case-sensitive, which is consistent with
+ * native Windows APIs.
+ *
+ * The non-private methods in this class are not for general use even
+ * within this package.  Instead, they are the system-dependent parts
+ * of the system-independent method of the same name.  Don't even
+ * think of using this class unless your method's name appears below.
+ *
+ * @author Martin Buchholz
+ * @since 1.5
+ */
+
+package java.lang;
+
+import java.io.*;
+import java.util.*;
+
+final class ProcessEnvironment extends HashMap<String,String>
+{
+
+    private static final long serialVersionUID = -8017839552603542824L;
+
+    private static String validateName(String name) {
+        // An initial `=' indicates a magic Windows variable name -- OK
+        if (name.indexOf('=', 1)   != -1 ||
+            name.indexOf('\u0000') != -1)
+            throw new IllegalArgumentException
+                ("Invalid environment variable name: \"" + name + "\"");
+        return name;
+    }
+
+    private static String validateValue(String value) {
+        if (value.indexOf('\u0000') != -1)
+            throw new IllegalArgumentException
+                ("Invalid environment variable value: \"" + value + "\"");
+        return value;
+    }
+
+    private static String nonNullString(Object o) {
+        if (o == null)
+            throw new NullPointerException();
+        return (String) o;
+    }
+
+    public String put(String key, String value) {
+        return super.put(validateName(key), validateValue(value));
+    }
+
+    public String get(Object key) {
+        return super.get(nonNullString(key));
+    }
+
+    public boolean containsKey(Object key) {
+        return super.containsKey(nonNullString(key));
+    }
+
+    public boolean containsValue(Object value) {
+        return super.containsValue(nonNullString(value));
+    }
+
+    public String remove(Object key) {
+        return super.remove(nonNullString(key));
+    }
+
+    private static class CheckedEntry
+        implements Map.Entry<String,String>
+    {
+        private final Map.Entry<String,String> e;
+        public CheckedEntry(Map.Entry<String,String> e) {this.e = e;}
+        public String getKey()   { return e.getKey();}
+        public String getValue() { return e.getValue();}
+        public String setValue(String value) {
+            return e.setValue(validateValue(value));
+        }
+        public String toString() { return getKey() + "=" + getValue();}
+        public boolean equals(Object o) {return e.equals(o);}
+        public int hashCode()    {return e.hashCode();}
+    }
+
+    private static class CheckedEntrySet
+        extends AbstractSet<Map.Entry<String,String>>
+    {
+        private final Set<Map.Entry<String,String>> s;
+        public CheckedEntrySet(Set<Map.Entry<String,String>> s) {this.s = s;}
+        public int size()        {return s.size();}
+        public boolean isEmpty() {return s.isEmpty();}
+        public void clear()      {       s.clear();}
+        public Iterator<Map.Entry<String,String>> iterator() {
+            return new Iterator<Map.Entry<String,String>>() {
+                Iterator<Map.Entry<String,String>> i = s.iterator();
+                public boolean hasNext() { return i.hasNext();}
+                public Map.Entry<String,String> next() {
+                    return new CheckedEntry(i.next());
+                }
+                public void remove() { i.remove();}
+            };
+        }
+        private static Map.Entry<String,String> checkedEntry(Object o) {
+            @SuppressWarnings("unchecked")
+            Map.Entry<String,String> e = (Map.Entry<String,String>) o;
+            nonNullString(e.getKey());
+            nonNullString(e.getValue());
+            return e;
+        }
+        public boolean contains(Object o) {return s.contains(checkedEntry(o));}
+        public boolean remove(Object o)   {return s.remove(checkedEntry(o));}
+    }
+
+    private static class CheckedValues extends AbstractCollection<String> {
+        private final Collection<String> c;
+        public CheckedValues(Collection<String> c) {this.c = c;}
+        public int size()                  {return c.size();}
+        public boolean isEmpty()           {return c.isEmpty();}
+        public void clear()                {       c.clear();}
+        public Iterator<String> iterator() {return c.iterator();}
+        public boolean contains(Object o)  {return c.contains(nonNullString(o));}
+        public boolean remove(Object o)    {return c.remove(nonNullString(o));}
+    }
+
+    private static class CheckedKeySet extends AbstractSet<String> {
+        private final Set<String> s;
+        public CheckedKeySet(Set<String> s) {this.s = s;}
+        public int size()                  {return s.size();}
+        public boolean isEmpty()           {return s.isEmpty();}
+        public void clear()                {       s.clear();}
+        public Iterator<String> iterator() {return s.iterator();}
+        public boolean contains(Object o)  {return s.contains(nonNullString(o));}
+        public boolean remove(Object o)    {return s.remove(nonNullString(o));}
+    }
+
+    public Set<String> keySet() {
+        return new CheckedKeySet(super.keySet());
+    }
+
+    public Collection<String> values() {
+        return new CheckedValues(super.values());
+    }
+
+    public Set<Map.Entry<String,String>> entrySet() {
+        return new CheckedEntrySet(super.entrySet());
+    }
+
+
+    private static final class NameComparator
+        implements Comparator<String> {
+        public int compare(String s1, String s2) {
+            // We can't use String.compareToIgnoreCase since it
+            // canonicalizes to lower case, while Windows
+            // canonicalizes to upper case!  For example, "_" should
+            // sort *after* "Z", not before.
+            int n1 = s1.length();
+            int n2 = s2.length();
+            int min = Math.min(n1, n2);
+            for (int i = 0; i < min; i++) {
+                char c1 = s1.charAt(i);
+                char c2 = s2.charAt(i);
+                if (c1 != c2) {
+                    c1 = Character.toUpperCase(c1);
+                    c2 = Character.toUpperCase(c2);
+                    if (c1 != c2)
+                        // No overflow because of numeric promotion
+                        return c1 - c2;
+                }
+            }
+            return n1 - n2;
+        }
+    }
+
+    private static final class EntryComparator
+        implements Comparator<Map.Entry<String,String>> {
+        public int compare(Map.Entry<String,String> e1,
+                           Map.Entry<String,String> e2) {
+            return nameComparator.compare(e1.getKey(), e2.getKey());
+        }
+    }
+
+    // Allow `=' as first char in name, e.g. =C:=C:\DIR
+    static final int MIN_NAME_LENGTH = 1;
+
+    private static final NameComparator nameComparator;
+    private static final EntryComparator entryComparator;
+    private static final ProcessEnvironment theEnvironment;
+    private static final Map<String,String> theUnmodifiableEnvironment;
+    private static final Map<String,String> theCaseInsensitiveEnvironment;
+
+    static {
+        nameComparator  = new NameComparator();
+        entryComparator = new EntryComparator();
+        theEnvironment  = new ProcessEnvironment();
+        theUnmodifiableEnvironment
+            = Collections.unmodifiableMap(theEnvironment);
+
+        String envblock = environmentBlock();
+        int beg, end, eql;
+        for (beg = 0;
+             ((end = envblock.indexOf('\u0000', beg  )) != -1 &&
+              // An initial `=' indicates a magic Windows variable name -- OK
+              (eql = envblock.indexOf('='     , beg+1)) != -1);
+             beg = end + 1) {
+            // Ignore corrupted environment strings.
+            if (eql < end)
+                theEnvironment.put(envblock.substring(beg, eql),
+                                   envblock.substring(eql+1,end));
+        }
+
+        theCaseInsensitiveEnvironment = new TreeMap<>(nameComparator);
+        theCaseInsensitiveEnvironment.putAll(theEnvironment);
+    }
+
+    private ProcessEnvironment() {
+        super();
+    }
+
+    private ProcessEnvironment(int capacity) {
+        super(capacity);
+    }
+
+    // Only for use by System.getenv(String)
+    static String getenv(String name) {
+        // The original implementation used a native call to _wgetenv,
+        // but it turns out that _wgetenv is only consistent with
+        // GetEnvironmentStringsW (for non-ASCII) if `wmain' is used
+        // instead of `main', even in a process created using
+        // CREATE_UNICODE_ENVIRONMENT.  Instead we perform the
+        // case-insensitive comparison ourselves.  At least this
+        // guarantees that System.getenv().get(String) will be
+        // consistent with System.getenv(String).
+        return theCaseInsensitiveEnvironment.get(name);
+    }
+
+    // Only for use by System.getenv()
+    static Map<String,String> getenv() {
+        return theUnmodifiableEnvironment;
+    }
+
+    // Only for use by ProcessBuilder.environment()
+    @SuppressWarnings("unchecked")
+    static Map<String,String> environment() {
+        return (Map<String,String>) theEnvironment.clone();
+    }
+
+    // Only for use by ProcessBuilder.environment(String[] envp)
+    static Map<String,String> emptyEnvironment(int capacity) {
+        return new ProcessEnvironment(capacity);
+    }
+
+    private static native String environmentBlock();
+
+    // Only for use by ProcessImpl.start()
+    String toEnvironmentBlock() {
+        // Sort Unicode-case-insensitively by name
+        List<Map.Entry<String,String>> list = new ArrayList<>(entrySet());
+        Collections.sort(list, entryComparator);
+
+        StringBuilder sb = new StringBuilder(size()*30);
+        int cmp = -1;
+
+        // Some versions of MSVCRT.DLL require SystemRoot to be set.
+        // So, we make sure that it is always set, even if not provided
+        // by the caller.
+        final String SYSTEMROOT = "SystemRoot";
+
+        for (Map.Entry<String,String> e : list) {
+            String key = e.getKey();
+            String value = e.getValue();
+            if (cmp < 0 && (cmp = nameComparator.compare(key, SYSTEMROOT)) > 0) {
+                // Not set, so add it here
+                addToEnvIfSet(sb, SYSTEMROOT);
+            }
+            addToEnv(sb, key, value);
+        }
+        if (cmp < 0) {
+            // Got to end of list and still not found
+            addToEnvIfSet(sb, SYSTEMROOT);
+        }
+        if (sb.length() == 0) {
+            // Environment was empty and SystemRoot not set in parent
+            sb.append('\u0000');
+        }
+        // Block is double NUL terminated
+        sb.append('\u0000');
+        return sb.toString();
+    }
+
+    // add the environment variable to the child, if it exists in parent
+    private static void addToEnvIfSet(StringBuilder sb, String name) {
+        String s = getenv(name);
+        if (s != null)
+            addToEnv(sb, name, s);
+    }
+
+    private static void addToEnv(StringBuilder sb, String name, String val) {
+        sb.append(name).append('=').append(val).append('\u0000');
+    }
+
+    static String toEnvironmentBlock(Map<String,String> map) {
+        return map == null ? null :
+            ((ProcessEnvironment)map).toEnvironmentBlock();
+    }
+}

jdkSrc/jdk8/java/lang/ProcessImpl.java

@@ -0,0 +1,617 @@
+/*
+ * Copyright (c) 1995, 2013, 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.IOException;
+import java.io.File;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileDescriptor;
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.lang.ProcessBuilder.Redirect;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.Locale;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import sun.security.action.GetPropertyAction;
+
+/* This class is for the exclusive use of ProcessBuilder.start() to
+ * create new processes.
+ *
+ * @author Martin Buchholz
+ * @since   1.5
+ */
+
+final class ProcessImpl extends Process {
+    private static final sun.misc.JavaIOFileDescriptorAccess fdAccess
+        = sun.misc.SharedSecrets.getJavaIOFileDescriptorAccess();
+
+    /**
+     * Open a file for writing. If {@code append} is {@code true} then the file
+     * is opened for atomic append directly and a FileOutputStream constructed
+     * with the resulting handle. This is because a FileOutputStream created
+     * to append to a file does not open the file in a manner that guarantees
+     * that writes by the child process will be atomic.
+     */
+    private static FileOutputStream newFileOutputStream(File f, boolean append)
+        throws IOException
+    {
+        if (append) {
+            String path = f.getPath();
+            SecurityManager sm = System.getSecurityManager();
+            if (sm != null)
+                sm.checkWrite(path);
+            long handle = openForAtomicAppend(path);
+            final FileDescriptor fd = new FileDescriptor();
+            fdAccess.setHandle(fd, handle);
+            return AccessController.doPrivileged(
+                new PrivilegedAction<FileOutputStream>() {
+                    public FileOutputStream run() {
+                        return new FileOutputStream(fd);
+                    }
+                }
+            );
+        } else {
+            return new FileOutputStream(f);
+        }
+    }
+
+    // System-dependent portion of ProcessBuilder.start()
+    static Process start(String cmdarray[],
+                         java.util.Map<String,String> environment,
+                         String dir,
+                         ProcessBuilder.Redirect[] redirects,
+                         boolean redirectErrorStream)
+        throws IOException
+    {
+        String envblock = ProcessEnvironment.toEnvironmentBlock(environment);
+
+        FileInputStream  f0 = null;
+        FileOutputStream f1 = null;
+        FileOutputStream f2 = null;
+
+        try {
+            long[] stdHandles;
+            if (redirects == null) {
+                stdHandles = new long[] { -1L, -1L, -1L };
+            } else {
+                stdHandles = new long[3];
+
+                if (redirects[0] == Redirect.PIPE)
+                    stdHandles[0] = -1L;
+                else if (redirects[0] == Redirect.INHERIT)
+                    stdHandles[0] = fdAccess.getHandle(FileDescriptor.in);
+                else {
+                    f0 = new FileInputStream(redirects[0].file());
+                    stdHandles[0] = fdAccess.getHandle(f0.getFD());
+                }
+
+                if (redirects[1] == Redirect.PIPE)
+                    stdHandles[1] = -1L;
+                else if (redirects[1] == Redirect.INHERIT)
+                    stdHandles[1] = fdAccess.getHandle(FileDescriptor.out);
+                else {
+                    f1 = newFileOutputStream(redirects[1].file(),
+                                             redirects[1].append());
+                    stdHandles[1] = fdAccess.getHandle(f1.getFD());
+                }
+
+                if (redirects[2] == Redirect.PIPE)
+                    stdHandles[2] = -1L;
+                else if (redirects[2] == Redirect.INHERIT)
+                    stdHandles[2] = fdAccess.getHandle(FileDescriptor.err);
+                else {
+                    f2 = newFileOutputStream(redirects[2].file(),
+                                             redirects[2].append());
+                    stdHandles[2] = fdAccess.getHandle(f2.getFD());
+                }
+            }
+
+            return new ProcessImpl(cmdarray, envblock, dir,
+                                   stdHandles, redirectErrorStream);
+        } finally {
+            // In theory, close() can throw IOException
+            // (although it is rather unlikely to happen here)
+            try { if (f0 != null) f0.close(); }
+            finally {
+                try { if (f1 != null) f1.close(); }
+                finally { if (f2 != null) f2.close(); }
+            }
+        }
+
+    }
+
+    private static class LazyPattern {
+        // Escape-support version:
+        //    "(\")((?:\\\\\\1|.)+?)\\1|([^\\s\"]+)";
+        private static final Pattern PATTERN =
+            Pattern.compile("[^\\s\"]+|\"[^\"]*\"");
+    };
+
+    /* Parses the command string parameter into the executable name and
+     * program arguments.
+     *
+     * The command string is broken into tokens. The token separator is a space
+     * or quota character. The space inside quotation is not a token separator.
+     * There are no escape sequences.
+     */
+    private static String[] getTokensFromCommand(String command) {
+        ArrayList<String> matchList = new ArrayList<>(8);
+        Matcher regexMatcher = LazyPattern.PATTERN.matcher(command);
+        while (regexMatcher.find())
+            matchList.add(regexMatcher.group());
+        return matchList.toArray(new String[matchList.size()]);
+    }
+
+    private static final int VERIFICATION_CMD_BAT = 0;
+    private static final int VERIFICATION_WIN32 = 1;
+    private static final int VERIFICATION_WIN32_SAFE = 2; // inside quotes not allowed
+    private static final int VERIFICATION_LEGACY = 3;
+    // See Command shell overview for documentation of special characters.
+    // https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-xp/bb490954(v=technet.10)
+    private static final String ESCAPE_VERIFICATION[] = {
+        // We guarantee the only command file execution for implicit [cmd.exe] run.
+        //    http://technet.microsoft.com/en-us/library/bb490954.aspx
+        // All space characters require quoting are checked in needsEscaping().
+        "\"<>&|^",
+        "\"<>",
+        "\"<>",
+        ""
+    };
+
+    private static String createCommandLine(int verificationType,
+                                     final String executablePath,
+                                     final String cmd[])
+    {
+        StringBuilder cmdbuf = new StringBuilder(80);
+
+        cmdbuf.append(executablePath);
+
+        for (int i = 1; i < cmd.length; ++i) {
+            cmdbuf.append(' ');
+            String s = cmd[i];
+            if (needsEscaping(verificationType, s)) {
+                cmdbuf.append('"');
+
+                if (verificationType == VERIFICATION_WIN32_SAFE) {
+                    // Insert the argument, adding '\' to quote any interior quotes
+                    int length = s.length();
+                    for (int j = 0; j < length; j++) {
+                        char c = s.charAt(j);
+                        if (c == DOUBLEQUOTE) {
+                            int count = countLeadingBackslash(verificationType, s, j);
+                            while (count-- > 0) {
+                                cmdbuf.append(BACKSLASH);   // double the number of backslashes
+                            }
+                            cmdbuf.append(BACKSLASH);       // backslash to quote the quote
+                        }
+                        cmdbuf.append(c);
+                    }
+                } else {
+                    cmdbuf.append(s);
+                }
+                // The code protects the [java.exe] and console command line
+                // parser, that interprets the [\"] combination as an escape
+                // sequence for the ["] char.
+                //     http://msdn.microsoft.com/en-us/library/17w5ykft.aspx
+                //
+                // If the argument is an FS path, doubling of the tail [\]
+                // char is not a problem for non-console applications.
+                //
+                // The [\"] sequence is not an escape sequence for the [cmd.exe]
+                // command line parser. The case of the [""] tail escape
+                // sequence could not be realized due to the argument validation
+                // procedure.
+                int count = countLeadingBackslash(verificationType, s, s.length());
+                while (count-- > 0) {
+                    cmdbuf.append(BACKSLASH);   // double the number of backslashes
+                }
+                cmdbuf.append('"');
+            } else {
+                cmdbuf.append(s);
+            }
+        }
+        return cmdbuf.toString();
+    }
+
+    /**
+     * Return the argument without quotes (1st and last) if properly quoted, else the arg.
+     * A properly quoted string has first and last characters as quote and
+     * the last quote is not escaped.
+     * @param str a string
+     * @return the string without quotes
+     */
+    private static String unQuote(String str) {
+        if (!str.startsWith("\"") || !str.endsWith("\"") || str.length() < 2)
+            return str;    // no beginning or ending quote, or too short not quoted
+
+        if (str.endsWith("\\\"")) {
+            return str;    // not properly quoted, treat as unquoted
+        }
+        // Strip leading and trailing quotes
+        return str.substring(1, str.length() - 1);
+    }
+
+    private static boolean needsEscaping(int verificationType, String arg) {
+        if (arg.isEmpty())
+            return true;            // Empty string is to be quoted
+
+        // Switch off MS heuristic for internal ["].
+        // Please, use the explicit [cmd.exe] call
+        // if you need the internal ["].
+        //    Example: "cmd.exe", "/C", "Extended_MS_Syntax"
+
+        // For [.exe] or [.com] file the unpaired/internal ["]
+        // in the argument is not a problem.
+        String unquotedArg = unQuote(arg);
+        boolean argIsQuoted = !arg.equals(unquotedArg);
+        boolean embeddedQuote = unquotedArg.indexOf(DOUBLEQUOTE) >= 0;
+
+        switch (verificationType) {
+            case VERIFICATION_CMD_BAT:
+                if (embeddedQuote) {
+                    throw new IllegalArgumentException("Argument has embedded quote, " +
+                            "use the explicit CMD.EXE call.");
+                }
+                break;  // break determine whether to quote
+            case VERIFICATION_WIN32_SAFE:
+                if (argIsQuoted && embeddedQuote)  {
+                    throw new IllegalArgumentException("Malformed argument has embedded quote: "
+                            + unquotedArg);
+                }
+                break;
+            default:
+                break;
+        }
+
+        if (!argIsQuoted) {
+            for (int i = 0; i < arg.length(); i++) {
+                char ch = arg.charAt(i);
+                if (Character.isLetterOrDigit(ch))
+                    continue;   // skip over common characters
+                // All space chars require quotes and other mode specific characters
+                if (Character.isSpaceChar(ch) ||
+                        Character.isWhitespace(ch) ||
+                        ESCAPE_VERIFICATION[verificationType].indexOf(ch) >= 0) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private static String getExecutablePath(String path)
+        throws IOException
+    {
+        String name = unQuote(path);
+        if (name.indexOf(DOUBLEQUOTE) >= 0) {
+            throw new IllegalArgumentException("Executable name has embedded quote, " +
+                    "split the arguments: " + name);
+        }
+        // Win32 CreateProcess requires path to be normalized
+        File fileToRun = new File(name);
+
+        // From the [CreateProcess] function documentation:
+        //
+        // "If the file name does not contain an extension, .exe is appended.
+        // Therefore, if the file name extension is .com, this parameter
+        // must include the .com extension. If the file name ends in
+        // a period (.) with no extension, or if the file name contains a path,
+        // .exe is not appended."
+        //
+        // "If the file name !does not contain a directory path!,
+        // the system searches for the executable file in the following
+        // sequence:..."
+        //
+        // In practice ANY non-existent path is extended by [.exe] extension
+        // in the [CreateProcess] function with the only exception:
+        // the path ends by (.)
+
+        return fileToRun.getPath();
+    }
+
+    /**
+     * An executable is any program that is an EXE or does not have an extension
+     * and the Windows createProcess will be looking for .exe.
+     * The comparison is case insensitive based on the name.
+     * @param executablePath the executable file
+     * @return true if the path ends in .exe or does not have an extension.
+     */
+    private boolean isExe(String executablePath) {
+        File file = new File(executablePath);
+        String upName = file.getName().toUpperCase(Locale.ROOT);
+        return (upName.endsWith(".EXE") || upName.indexOf('.') < 0);
+    }
+
+    // Old version that can be bypassed
+    private boolean isShellFile(String executablePath) {
+        String upPath = executablePath.toUpperCase();
+        return (upPath.endsWith(".CMD") || upPath.endsWith(".BAT"));
+    }
+
+    private String quoteString(String arg) {
+        StringBuilder argbuf = new StringBuilder(arg.length() + 2);
+        return argbuf.append('"').append(arg).append('"').toString();
+    }
+
+    // Count backslashes before start index of string.
+    // .bat files don't include backslashes as part of the quote
+    private static int countLeadingBackslash(int verificationType,
+                                             CharSequence input, int start) {
+        if (verificationType == VERIFICATION_CMD_BAT)
+            return 0;
+        int j;
+        for (j = start - 1; j >= 0 && input.charAt(j) == BACKSLASH; j--) {
+            // just scanning backwards
+        }
+        return (start - 1) - j;  // number of BACKSLASHES
+    }
+
+    private static final char DOUBLEQUOTE = '\"';
+    private static final char BACKSLASH = '\\';
+
+    private long handle = 0;
+    private OutputStream stdin_stream;
+    private InputStream stdout_stream;
+    private InputStream stderr_stream;
+
+    private ProcessImpl(String cmd[],
+                        final String envblock,
+                        final String path,
+                        final long[] stdHandles,
+                        final boolean redirectErrorStream)
+        throws IOException
+    {
+        String cmdstr;
+        final SecurityManager security = System.getSecurityManager();
+        String propertyValue = GetPropertyAction.
+                privilegedGetProperty("jdk.lang.Process.allowAmbiguousCommands");
+        final String value = propertyValue != null ? propertyValue
+                                                   : (security == null ? "true" : "false");
+        final boolean allowAmbiguousCommands = !"false".equalsIgnoreCase(value);
+
+        if (allowAmbiguousCommands && security == null) {
+            // Legacy mode.
+
+            // Normalize path if possible.
+            String executablePath = new File(cmd[0]).getPath();
+
+            // No worry about internal, unpaired ["], and redirection/piping.
+            if (needsEscaping(VERIFICATION_LEGACY, executablePath) )
+                executablePath = quoteString(executablePath);
+
+            cmdstr = createCommandLine(
+                //legacy mode doesn't worry about extended verification
+                VERIFICATION_LEGACY,
+                executablePath,
+                cmd);
+        } else {
+            String executablePath;
+            try {
+                executablePath = getExecutablePath(cmd[0]);
+            } catch (IllegalArgumentException e) {
+                // Workaround for the calls like
+                // Runtime.getRuntime().exec("\"C:\\Program Files\\foo\" bar")
+
+                // No chance to avoid CMD/BAT injection, except to do the work
+                // right from the beginning. Otherwise we have too many corner
+                // cases from
+                //    Runtime.getRuntime().exec(String[] cmd [, ...])
+                // calls with internal ["] and escape sequences.
+
+                // Restore original command line.
+                StringBuilder join = new StringBuilder();
+                // terminal space in command line is ok
+                for (String s : cmd)
+                    join.append(s).append(' ');
+
+                // Parse the command line again.
+                cmd = getTokensFromCommand(join.toString());
+                executablePath = getExecutablePath(cmd[0]);
+
+                // Check new executable name once more
+                if (security != null)
+                    security.checkExec(executablePath);
+            }
+
+            // Quotation protects from interpretation of the [path] argument as
+            // start of longer path with spaces. Quotation has no influence to
+            // [.exe] extension heuristic.
+            boolean isShell = allowAmbiguousCommands ? isShellFile(executablePath)
+                    : !isExe(executablePath);
+            cmdstr = createCommandLine(
+                    // We need the extended verification procedures
+                    isShell ? VERIFICATION_CMD_BAT
+                            : (allowAmbiguousCommands ? VERIFICATION_WIN32 : VERIFICATION_WIN32_SAFE),
+                    quoteString(executablePath),
+                    cmd);
+        }
+
+        handle = create(cmdstr, envblock, path,
+                        stdHandles, redirectErrorStream);
+
+        java.security.AccessController.doPrivileged(
+        new java.security.PrivilegedAction<Void>() {
+        public Void run() {
+            if (stdHandles[0] == -1L)
+                stdin_stream = ProcessBuilder.NullOutputStream.INSTANCE;
+            else {
+                FileDescriptor stdin_fd = new FileDescriptor();
+                fdAccess.setHandle(stdin_fd, stdHandles[0]);
+                stdin_stream = new BufferedOutputStream(
+                    new FileOutputStream(stdin_fd));
+            }
+
+            if (stdHandles[1] == -1L)
+                stdout_stream = ProcessBuilder.NullInputStream.INSTANCE;
+            else {
+                FileDescriptor stdout_fd = new FileDescriptor();
+                fdAccess.setHandle(stdout_fd, stdHandles[1]);
+                stdout_stream = new BufferedInputStream(
+                    new FileInputStream(stdout_fd));
+            }
+
+            if (stdHandles[2] == -1L)
+                stderr_stream = ProcessBuilder.NullInputStream.INSTANCE;
+            else {
+                FileDescriptor stderr_fd = new FileDescriptor();
+                fdAccess.setHandle(stderr_fd, stdHandles[2]);
+                stderr_stream = new FileInputStream(stderr_fd);
+            }
+
+            return null; }});
+    }
+
+    public OutputStream getOutputStream() {
+        return stdin_stream;
+    }
+
+    public InputStream getInputStream() {
+        return stdout_stream;
+    }
+
+    public InputStream getErrorStream() {
+        return stderr_stream;
+    }
+
+    protected void finalize() {
+        closeHandle(handle);
+    }
+
+    private static final int STILL_ACTIVE = getStillActive();
+    private static native int getStillActive();
+
+    public int exitValue() {
+        int exitCode = getExitCodeProcess(handle);
+        if (exitCode == STILL_ACTIVE)
+            throw new IllegalThreadStateException("process has not exited");
+        return exitCode;
+    }
+    private static native int getExitCodeProcess(long handle);
+
+    public int waitFor() throws InterruptedException {
+        waitForInterruptibly(handle);
+        if (Thread.interrupted())
+            throw new InterruptedException();
+        return exitValue();
+    }
+
+    private static native void waitForInterruptibly(long handle);
+
+    @Override
+    public boolean waitFor(long timeout, TimeUnit unit)
+        throws InterruptedException
+    {
+        long remainingNanos = unit.toNanos(timeout);    // throw NPE before other conditions
+        if (getExitCodeProcess(handle) != STILL_ACTIVE) return true;
+        if (timeout <= 0) return false;
+
+        long deadline = System.nanoTime() + remainingNanos;
+        do {
+            // Round up to next millisecond
+            long msTimeout = TimeUnit.NANOSECONDS.toMillis(remainingNanos + 999_999L);
+            if (msTimeout < 0) {
+                // if wraps around then wait a long while
+                msTimeout = Integer.MAX_VALUE;
+            }
+            waitForTimeoutInterruptibly(handle, msTimeout);
+            if (Thread.interrupted())
+                throw new InterruptedException();
+            if (getExitCodeProcess(handle) != STILL_ACTIVE) {
+                return true;
+            }
+            remainingNanos = deadline - System.nanoTime();
+        } while (remainingNanos > 0);
+
+        return (getExitCodeProcess(handle) != STILL_ACTIVE);
+    }
+
+    private static native void waitForTimeoutInterruptibly(
+        long handle, long timeoutMillis);
+
+    public void destroy() { terminateProcess(handle); }
+
+    @Override
+    public Process destroyForcibly() {
+        destroy();
+        return this;
+    }
+
+    private static native void terminateProcess(long handle);
+
+    @Override
+    public boolean isAlive() {
+        return isProcessAlive(handle);
+    }
+
+    private static native boolean isProcessAlive(long handle);
+
+    /**
+     * Create a process using the win32 function CreateProcess.
+     * The method is synchronized due to MS kb315939 problem.
+     * All native handles should restore the inherit flag at the end of call.
+     *
+     * @param cmdstr the Windows command line
+     * @param envblock NUL-separated, double-NUL-terminated list of
+     *        environment strings in VAR=VALUE form
+     * @param dir the working directory of the process, or null if
+     *        inheriting the current directory from the parent process
+     * @param stdHandles array of windows HANDLEs.  Indexes 0, 1, and
+     *        2 correspond to standard input, standard output and
+     *        standard error, respectively.  On input, a value of -1
+     *        means to create a pipe to connect child and parent
+     *        processes.  On output, a value which is not -1 is the
+     *        parent pipe handle corresponding to the pipe which has
+     *        been created.  An element of this array is -1 on input
+     *        if and only if it is <em>not</em> -1 on output.
+     * @param redirectErrorStream redirectErrorStream attribute
+     * @return the native subprocess HANDLE returned by CreateProcess
+     */
+    private static synchronized native long create(String cmdstr,
+                                      String envblock,
+                                      String dir,
+                                      long[] stdHandles,
+                                      boolean redirectErrorStream)
+        throws IOException;
+
+    /**
+     * Opens a file for atomic append. The file is created if it doesn't
+     * already exist.
+     *
+     * @param file the file to open or create
+     * @return the native HANDLE
+     */
+    private static native long openForAtomicAppend(String path)
+        throws IOException;
+
+    private static native boolean closeHandle(long handle);
+}

jdkSrc/jdk8/java/lang/Readable.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2003, 2013, 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.IOException;
+
+/**
+ * A <tt>Readable</tt> is a source of characters. Characters from
+ * a <tt>Readable</tt> are made available to callers of the read
+ * method via a {@link java.nio.CharBuffer CharBuffer}.
+ *
+ * @since 1.5
+ */
+public interface Readable {
+
+    /**
+     * Attempts to read characters into the specified character buffer.
+     * The buffer is used as a repository of characters as-is: the only
+     * changes made are the results of a put operation. No flipping or
+     * rewinding of the buffer is performed.
+     *
+     * @param cb the buffer to read characters into
+     * @return The number of {@code char} values added to the buffer,
+     *                 or -1 if this source of characters is at its end
+     * @throws IOException if an I/O error occurs
+     * @throws NullPointerException if cb is null
+     * @throws java.nio.ReadOnlyBufferException if cb is a read only buffer
+     */
+    public int read(java.nio.CharBuffer cb) throws IOException;
+}

jdkSrc/jdk8/java/lang/ReflectiveOperationException.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2009, 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;
+
+/**
+ * Common superclass of exceptions thrown by reflective operations in
+ * core reflection.
+ *
+ * @see LinkageError
+ * @since 1.7
+ */
+public class ReflectiveOperationException extends Exception {
+    static final long serialVersionUID = 123456789L;
+
+    /**
+     * Constructs a new exception with {@code null} as its detail
+     * message.  The cause is not initialized, and may subsequently be
+     * initialized by a call to {@link #initCause}.
+     */
+    public ReflectiveOperationException() {
+        super();
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message.
+     * The cause is not initialized, and may subsequently be
+     * initialized by a call to {@link #initCause}.
+     *
+     * @param   message   the detail message. The detail message is saved for
+     *          later retrieval by the {@link #getMessage()} method.
+     */
+    public ReflectiveOperationException(String message) {
+        super(message);
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message
+     * and cause.
+     *
+     * <p>Note that the detail message associated with
+     * {@code cause} is <em>not</em> automatically incorporated in
+     * this exception's detail message.
+     *
+     * @param  message the detail message (which is saved for later retrieval
+     *         by the {@link #getMessage()} method).
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link #getCause()} method).  (A {@code null} value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     */
+    public ReflectiveOperationException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs a new exception with the specified cause and a detail
+     * message of {@code (cause==null ? null : cause.toString())} (which
+     * typically contains the class and detail message of {@code cause}).
+     *
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link #getCause()} method).  (A {@code null} value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     */
+    public ReflectiveOperationException(Throwable cause) {
+        super(cause);
+    }
+}

jdkSrc/jdk8/java/lang/Runnable.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 1994, 2013, 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;
+
+/**
+ * The <code>Runnable</code> interface should be implemented by any
+ * class whose instances are intended to be executed by a thread. The
+ * class must define a method of no arguments called <code>run</code>.
+ * <p>
+ * This interface is designed to provide a common protocol for objects that
+ * wish to execute code while they are active. For example,
+ * <code>Runnable</code> is implemented by class <code>Thread</code>.
+ * Being active simply means that a thread has been started and has not
+ * yet been stopped.
+ * <p>
+ * In addition, <code>Runnable</code> provides the means for a class to be
+ * active while not subclassing <code>Thread</code>. A class that implements
+ * <code>Runnable</code> can run without subclassing <code>Thread</code>
+ * by instantiating a <code>Thread</code> instance and passing itself in
+ * as the target.  In most cases, the <code>Runnable</code> interface should
+ * be used if you are only planning to override the <code>run()</code>
+ * method and no other <code>Thread</code> methods.
+ * This is important because classes should not be subclassed
+ * unless the programmer intends on modifying or enhancing the fundamental
+ * behavior of the class.
+ *
+ * @author  Arthur van Hoff
+ * @see     java.lang.Thread
+ * @see     java.util.concurrent.Callable
+ * @since   JDK1.0
+ */
+@FunctionalInterface
+public interface Runnable {
+    /**
+     * When an object implementing interface <code>Runnable</code> is used
+     * to create a thread, starting the thread causes the object's
+     * <code>run</code> method to be called in that separately executing
+     * thread.
+     * <p>
+     * The general contract of the method <code>run</code> is that it may
+     * take any action whatsoever.
+     *
+     * @see     java.lang.Thread#run()
+     */
+    public abstract void run();
+}

jdkSrc/jdk8/java/lang/Runtime.java

@@ -0,0 +1,900 @@
+/*
+ * Copyright (c) 1995, 2022, 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.StringTokenizer;
+import sun.reflect.CallerSensitive;
+import sun.reflect.Reflection;
+
+/**
+ * Every Java application has a single instance of class
+ * <code>Runtime</code> that allows the application to interface with
+ * the environment in which the application is running. The current
+ * runtime can be obtained from the <code>getRuntime</code> method.
+ * <p>
+ * An application cannot create its own instance of this class.
+ *
+ * @author  unascribed
+ * @see     java.lang.Runtime#getRuntime()
+ * @since   JDK1.0
+ */
+
+public class Runtime {
+    private static Runtime currentRuntime = new Runtime();
+
+    /**
+     * Returns the runtime object associated with the current Java application.
+     * Most of the methods of class <code>Runtime</code> are instance
+     * methods and must be invoked with respect to the current runtime object.
+     *
+     * @return  the <code>Runtime</code> object associated with the current
+     *          Java application.
+     */
+    public static Runtime getRuntime() {
+        return currentRuntime;
+    }
+
+    /** Don't let anyone else instantiate this class */
+    private Runtime() {}
+
+    /**
+     * Terminates the currently running Java virtual machine by initiating its
+     * shutdown sequence.  This method never returns normally.  The argument
+     * serves as a status code; by convention, a nonzero status code indicates
+     * abnormal termination.
+     *
+     * <p> All registered {@linkplain #addShutdownHook shutdown hooks}, if any,
+     * are started in some unspecified order and allowed to run concurrently
+     * until they finish.  Once this is done the virtual machine
+     * {@linkplain #halt halts}.
+     *
+     * <p> If this method is invoked after all shutdown hooks have already
+     * been run and the status is nonzero then this method halts the
+     * virtual machine with the given status code. Otherwise, this method
+     * blocks indefinitely.
+     *
+     * <p> The {@link System#exit(int) System.exit} method is the
+     * conventional and convenient means of invoking this method.
+     *
+     * @param  status
+     *         Termination status.  By convention, a nonzero status code
+     *         indicates abnormal termination.
+     *
+     * @throws SecurityException
+     *         If a security manager is present and its
+     *         {@link SecurityManager#checkExit checkExit} method does not permit
+     *         exiting with the specified status
+     *
+     * @see java.lang.SecurityException
+     * @see java.lang.SecurityManager#checkExit(int)
+     * @see #addShutdownHook
+     * @see #removeShutdownHook
+     * @see #halt(int)
+     */
+    public void exit(int status) {
+        SecurityManager security = System.getSecurityManager();
+        if (security != null) {
+            security.checkExit(status);
+        }
+        Shutdown.exit(status);
+    }
+
+    /**
+     * Registers a new virtual-machine shutdown hook.
+     *
+     * <p> The Java virtual machine <i>shuts down</i> in response to two kinds
+     * of events:
+     *
+     *   <ul>
+     *
+     *   <li> The program <i>exits</i> normally, when the last non-daemon
+     *   thread exits or when the {@link #exit exit} (equivalently,
+     *   {@link System#exit(int) System.exit}) method is invoked, or
+     *
+     *   <li> The virtual machine is <i>terminated</i> in response to a
+     *   user interrupt, such as typing {@code ^C}, or a system-wide event,
+     *   such as user logoff or system shutdown.
+     *
+     *   </ul>
+     *
+     * <p> A <i>shutdown hook</i> is simply an initialized but unstarted
+     * thread.  When the virtual machine begins its shutdown sequence it will
+     * start all registered shutdown hooks in some unspecified order and let
+     * them run concurrently.  When all the hooks have finished it will then
+     * halt. Note that daemon threads will continue to run during the shutdown
+     * sequence, as will non-daemon threads if shutdown was initiated by
+     * invoking the {@link #exit exit} method.
+     *
+     * <p> Once the shutdown sequence has begun it can be stopped only by
+     * invoking the {@link #halt halt} method, which forcibly
+     * terminates the virtual machine.
+     *
+     * <p> Once the shutdown sequence has begun it is impossible to register a
+     * new shutdown hook or de-register a previously-registered hook.
+     * Attempting either of these operations will cause an
+     * {@link IllegalStateException} to be thrown.
+     *
+     * <p> Shutdown hooks run at a delicate time in the life cycle of a virtual
+     * machine and should therefore be coded defensively.  They should, in
+     * particular, be written to be thread-safe and to avoid deadlocks insofar
+     * as possible.  They should also not rely blindly upon services that may
+     * have registered their own shutdown hooks and therefore may themselves in
+     * the process of shutting down.  Attempts to use other thread-based
+     * services such as the AWT event-dispatch thread, for example, may lead to
+     * deadlocks.
+     *
+     * <p> Shutdown hooks should also finish their work quickly.  When a
+     * program invokes {@link #exit exit} the expectation is
+     * that the virtual machine will promptly shut down and exit.  When the
+     * virtual machine is terminated due to user logoff or system shutdown the
+     * underlying operating system may only allow a fixed amount of time in
+     * which to shut down and exit.  It is therefore inadvisable to attempt any
+     * user interaction or to perform a long-running computation in a shutdown
+     * hook.
+     *
+     * <p> Uncaught exceptions are handled in shutdown hooks just as in any
+     * other thread, by invoking the
+     * {@link ThreadGroup#uncaughtException uncaughtException} method of the
+     * thread's {@link ThreadGroup} object. The default implementation of this
+     * method prints the exception's stack trace to {@link System#err} and
+     * terminates the thread; it does not cause the virtual machine to exit or
+     * halt.
+     *
+     * <p> In rare circumstances the virtual machine may <i>abort</i>, that is,
+     * stop running without shutting down cleanly.  This occurs when the
+     * virtual machine is terminated externally, for example with the
+     * {@code SIGKILL} signal on Unix or the {@code TerminateProcess} call on
+     * Microsoft Windows.  The virtual machine may also abort if a native
+     * method goes awry by, for example, corrupting internal data structures or
+     * attempting to access nonexistent memory.  If the virtual machine aborts
+     * then no guarantee can be made about whether or not any shutdown hooks
+     * will be run.
+     *
+     * @param   hook
+     *          An initialized but unstarted {@link Thread} object
+     *
+     * @throws  IllegalArgumentException
+     *          If the specified hook has already been registered,
+     *          or if it can be determined that the hook is already running or
+     *          has already been run
+     *
+     * @throws  IllegalStateException
+     *          If the virtual machine is already in the process
+     *          of shutting down
+     *
+     * @throws  SecurityException
+     *          If a security manager is present and it denies
+     *          {@link RuntimePermission}{@code ("shutdownHooks")}
+     *
+     * @see #removeShutdownHook
+     * @see #halt(int)
+     * @see #exit(int)
+     * @since 1.3
+     */
+    public void addShutdownHook(Thread hook) {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            sm.checkPermission(new RuntimePermission("shutdownHooks"));
+        }
+        ApplicationShutdownHooks.add(hook);
+    }
+
+    /**
+     * De-registers a previously-registered virtual-machine shutdown hook. <p>
+     *
+     * @param hook the hook to remove
+     * @return <tt>true</tt> if the specified hook had previously been
+     * registered and was successfully de-registered, <tt>false</tt>
+     * otherwise.
+     *
+     * @throws  IllegalStateException
+     *          If the virtual machine is already in the process of shutting
+     *          down
+     *
+     * @throws  SecurityException
+     *          If a security manager is present and it denies
+     *          <tt>{@link RuntimePermission}("shutdownHooks")</tt>
+     *
+     * @see #addShutdownHook
+     * @see #exit(int)
+     * @since 1.3
+     */
+    public boolean removeShutdownHook(Thread hook) {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            sm.checkPermission(new RuntimePermission("shutdownHooks"));
+        }
+        return ApplicationShutdownHooks.remove(hook);
+    }
+
+    /**
+     * Forcibly terminates the currently running Java virtual machine.  This
+     * method never returns normally.
+     *
+     * <p> This method should be used with extreme caution.  Unlike the
+     * {@link #exit exit} method, this method does not cause shutdown
+     * hooks to be started.  If the shutdown sequence has already been
+     * initiated then this method does not wait for any running
+     * shutdown hooks to finish their work.
+     *
+     * @param  status
+     *         Termination status. By convention, a nonzero status code
+     *         indicates abnormal termination. If the {@link Runtime#exit exit}
+     *         (equivalently, {@link System#exit(int) System.exit}) method
+     *         has already been invoked then this status code
+     *         will override the status code passed to that method.
+     *
+     * @throws SecurityException
+     *         If a security manager is present and its
+     *         {@link SecurityManager#checkExit checkExit} method
+     *         does not permit an exit with the specified status
+     *
+     * @see #exit
+     * @see #addShutdownHook
+     * @see #removeShutdownHook
+     * @since 1.3
+     */
+    public void halt(int status) {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            sm.checkExit(status);
+        }
+        Shutdown.beforeHalt();
+        Shutdown.halt(status);
+    }
+
+    /**
+     * Throws {@code UnsupportedOperationException}.
+     *
+     * @param value ignored
+     *
+     * @deprecated This method was originally designed to enable or disable
+     * running finalizers on exit. Running finalizers on exit was disabled by default.
+     * If enabled, then the finalizers of all objects whose finalizers had not
+     * yet been automatically invoked were to be run before the Java runtime exits.
+     * That behavior is inherently unsafe. It may result in finalizers being called
+     * on live objects while other threads are concurrently manipulating those objects,
+     * resulting in erratic behavior or deadlock.
+     *
+     * @since JDK1.1
+     */
+    @Deprecated
+    public static void runFinalizersOnExit(boolean value) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Executes the specified string command in a separate process.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * <tt>exec(command)</tt>
+     * behaves in exactly the same way as the invocation
+     * <tt>{@link #exec(String, String[], File) exec}(command, null, null)</tt>.
+     *
+     * @param   command   a specified system command.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>command</code> is <code>null</code>
+     *
+     * @throws  IllegalArgumentException
+     *          If <code>command</code> is empty
+     *
+     * @see     #exec(String[], String[], File)
+     * @see     ProcessBuilder
+     */
+    public Process exec(String command) throws IOException {
+        return exec(command, null, null);
+    }
+
+    /**
+     * Executes the specified string command in a separate process with the
+     * specified environment.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * <tt>exec(command, envp)</tt>
+     * behaves in exactly the same way as the invocation
+     * <tt>{@link #exec(String, String[], File) exec}(command, envp, null)</tt>.
+     *
+     * @param   command   a specified system command.
+     *
+     * @param   envp      array of strings, each element of which
+     *                    has environment variable settings in the format
+     *                    <i>name</i>=<i>value</i>, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the environment of the current process.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>command</code> is <code>null</code>,
+     *          or one of the elements of <code>envp</code> is <code>null</code>
+     *
+     * @throws  IllegalArgumentException
+     *          If <code>command</code> is empty
+     *
+     * @see     #exec(String[], String[], File)
+     * @see     ProcessBuilder
+     */
+    public Process exec(String command, String[] envp) throws IOException {
+        return exec(command, envp, null);
+    }
+
+    /**
+     * Executes the specified string command in a separate process with the
+     * specified environment and working directory.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * <tt>exec(command, envp, dir)</tt>
+     * behaves in exactly the same way as the invocation
+     * <tt>{@link #exec(String[], String[], File) exec}(cmdarray, envp, dir)</tt>,
+     * where <code>cmdarray</code> is an array of all the tokens in
+     * <code>command</code>.
+     *
+     * <p>More precisely, the <code>command</code> string is broken
+     * into tokens using a {@link StringTokenizer} created by the call
+     * <code>new {@link StringTokenizer}(command)</code> with no
+     * further modification of the character categories.  The tokens
+     * produced by the tokenizer are then placed in the new string
+     * array <code>cmdarray</code>, in the same order.
+     *
+     * @param   command   a specified system command.
+     *
+     * @param   envp      array of strings, each element of which
+     *                    has environment variable settings in the format
+     *                    <i>name</i>=<i>value</i>, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the environment of the current process.
+     *
+     * @param   dir       the working directory of the subprocess, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the working directory of the current process.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>command</code> is <code>null</code>,
+     *          or one of the elements of <code>envp</code> is <code>null</code>
+     *
+     * @throws  IllegalArgumentException
+     *          If <code>command</code> is empty
+     *
+     * @see     ProcessBuilder
+     * @since 1.3
+     */
+    public Process exec(String command, String[] envp, File dir)
+        throws IOException {
+        if (command.length() == 0)
+            throw new IllegalArgumentException("Empty command");
+
+        StringTokenizer st = new StringTokenizer(command);
+        String[] cmdarray = new String[st.countTokens()];
+        for (int i = 0; st.hasMoreTokens(); i++)
+            cmdarray[i] = st.nextToken();
+        return exec(cmdarray, envp, dir);
+    }
+
+    /**
+     * Executes the specified command and arguments in a separate process.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * <tt>exec(cmdarray)</tt>
+     * behaves in exactly the same way as the invocation
+     * <tt>{@link #exec(String[], String[], File) exec}(cmdarray, null, null)</tt>.
+     *
+     * @param   cmdarray  array containing the command to call and
+     *                    its arguments.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>cmdarray</code> is <code>null</code>,
+     *          or one of the elements of <code>cmdarray</code> is <code>null</code>
+     *
+     * @throws  IndexOutOfBoundsException
+     *          If <code>cmdarray</code> is an empty array
+     *          (has length <code>0</code>)
+     *
+     * @see     ProcessBuilder
+     */
+    public Process exec(String cmdarray[]) throws IOException {
+        return exec(cmdarray, null, null);
+    }
+
+    /**
+     * Executes the specified command and arguments in a separate process
+     * with the specified environment.
+     *
+     * <p>This is a convenience method.  An invocation of the form
+     * <tt>exec(cmdarray, envp)</tt>
+     * behaves in exactly the same way as the invocation
+     * <tt>{@link #exec(String[], String[], File) exec}(cmdarray, envp, null)</tt>.
+     *
+     * @param   cmdarray  array containing the command to call and
+     *                    its arguments.
+     *
+     * @param   envp      array of strings, each element of which
+     *                    has environment variable settings in the format
+     *                    <i>name</i>=<i>value</i>, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the environment of the current process.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>cmdarray</code> is <code>null</code>,
+     *          or one of the elements of <code>cmdarray</code> is <code>null</code>,
+     *          or one of the elements of <code>envp</code> is <code>null</code>
+     *
+     * @throws  IndexOutOfBoundsException
+     *          If <code>cmdarray</code> is an empty array
+     *          (has length <code>0</code>)
+     *
+     * @see     ProcessBuilder
+     */
+    public Process exec(String[] cmdarray, String[] envp) throws IOException {
+        return exec(cmdarray, envp, null);
+    }
+
+
+    /**
+     * Executes the specified command and arguments in a separate process with
+     * the specified environment and working directory.
+     *
+     * <p>Given an array of strings <code>cmdarray</code>, representing the
+     * tokens of a command line, and an array of strings <code>envp</code>,
+     * representing "environment" variable settings, this method creates
+     * a new process in which to execute the specified command.
+     *
+     * <p>This method checks that <code>cmdarray</code> is a valid operating
+     * system command.  Which commands are valid is system-dependent,
+     * but at the very least the command must be a non-empty list of
+     * non-null strings.
+     *
+     * <p>If <tt>envp</tt> is <tt>null</tt>, the subprocess inherits the
+     * environment settings of the current process.
+     *
+     * <p>A minimal set of system dependent environment variables may
+     * be required to start a process on some operating systems.
+     * As a result, the subprocess may inherit additional environment variable
+     * settings beyond those in the specified environment.
+     *
+     * <p>{@link ProcessBuilder#start()} is now the preferred way to
+     * start a process with a modified environment.
+     *
+     * <p>The working directory of the new subprocess is specified by <tt>dir</tt>.
+     * If <tt>dir</tt> is <tt>null</tt>, the subprocess inherits the
+     * current working directory of the current process.
+     *
+     * <p>If a security manager exists, its
+     * {@link SecurityManager#checkExec checkExec}
+     * method is invoked with the first component of the array
+     * <code>cmdarray</code> as its argument. This may result in a
+     * {@link SecurityException} being thrown.
+     *
+     * <p>Starting an operating system process is highly system-dependent.
+     * Among the many things that can go wrong are:
+     * <ul>
+     * <li>The operating system program file was not found.
+     * <li>Access to the program file was denied.
+     * <li>The working directory does not exist.
+     * </ul>
+     *
+     * <p>In such cases an exception will be thrown.  The exact nature
+     * of the exception is system-dependent, but it will always be a
+     * subclass of {@link IOException}.
+     *
+     *
+     * @param   cmdarray  array containing the command to call and
+     *                    its arguments.
+     *
+     * @param   envp      array of strings, each element of which
+     *                    has environment variable settings in the format
+     *                    <i>name</i>=<i>value</i>, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the environment of the current process.
+     *
+     * @param   dir       the working directory of the subprocess, or
+     *                    <tt>null</tt> if the subprocess should inherit
+     *                    the working directory of the current process.
+     *
+     * @return  A new {@link Process} object for managing the subprocess
+     *
+     * @throws  SecurityException
+     *          If a security manager exists and its
+     *          {@link SecurityManager#checkExec checkExec}
+     *          method doesn't allow creation of the subprocess
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     *
+     * @throws  NullPointerException
+     *          If <code>cmdarray</code> is <code>null</code>,
+     *          or one of the elements of <code>cmdarray</code> is <code>null</code>,
+     *          or one of the elements of <code>envp</code> is <code>null</code>
+     *
+     * @throws  IndexOutOfBoundsException
+     *          If <code>cmdarray</code> is an empty array
+     *          (has length <code>0</code>)
+     *
+     * @see     ProcessBuilder
+     * @since 1.3
+     */
+    public Process exec(String[] cmdarray, String[] envp, File dir)
+        throws IOException {
+        return new ProcessBuilder(cmdarray)
+            .environment(envp)
+            .directory(dir)
+            .start();
+    }
+
+    /**
+     * Returns the number of processors available to the Java virtual machine.
+     *
+     * <p> This value may change during a particular invocation of the virtual
+     * machine.  Applications that are sensitive to the number of available
+     * processors should therefore occasionally poll this property and adjust
+     * their resource usage appropriately. </p>
+     *
+     * @return  the maximum number of processors available to the virtual
+     *          machine; never smaller than one
+     * @since 1.4
+     */
+    public native int availableProcessors();
+
+    /**
+     * Returns the amount of free memory in the Java Virtual Machine.
+     * Calling the
+     * <code>gc</code> method may result in increasing the value returned
+     * by <code>freeMemory.</code>
+     *
+     * @return  an approximation to the total amount of memory currently
+     *          available for future allocated objects, measured in bytes.
+     */
+    public native long freeMemory();
+
+    /**
+     * Returns the total amount of memory in the Java virtual machine.
+     * The value returned by this method may vary over time, depending on
+     * the host environment.
+     * <p>
+     * Note that the amount of memory required to hold an object of any
+     * given type may be implementation-dependent.
+     *
+     * @return  the total amount of memory currently available for current
+     *          and future objects, measured in bytes.
+     */
+    public native long totalMemory();
+
+    /**
+     * Returns the maximum amount of memory that the Java virtual machine will
+     * attempt to use.  If there is no inherent limit then the value {@link
+     * java.lang.Long#MAX_VALUE} will be returned.
+     *
+     * @return  the maximum amount of memory that the virtual machine will
+     *          attempt to use, measured in bytes
+     * @since 1.4
+     */
+    public native long maxMemory();
+
+    /**
+     * Runs the garbage collector.
+     * Calling this method suggests that the Java virtual machine expend
+     * effort toward recycling unused objects in order to make the memory
+     * they currently occupy available for quick reuse. When control
+     * returns from the method call, the virtual machine has made
+     * its best effort to recycle all discarded objects.
+     * <p>
+     * The name <code>gc</code> stands for "garbage
+     * collector". The virtual machine performs this recycling
+     * process automatically as needed, in a separate thread, even if the
+     * <code>gc</code> method is not invoked explicitly.
+     * <p>
+     * The method {@link System#gc()} is the conventional and convenient
+     * means of invoking this method.
+     */
+    public native void gc();
+
+    /* Wormhole for calling java.lang.ref.Finalizer.runFinalization */
+    private static native void runFinalization0();
+
+    /**
+     * Runs the finalization methods of any objects pending finalization.
+     * Calling this method suggests that the Java virtual machine expend
+     * effort toward running the <code>finalize</code> methods of objects
+     * that have been found to be discarded but whose <code>finalize</code>
+     * methods have not yet been run. When control returns from the
+     * method call, the virtual machine has made a best effort to
+     * complete all outstanding finalizations.
+     * <p>
+     * The virtual machine performs the finalization process
+     * automatically as needed, in a separate thread, if the
+     * <code>runFinalization</code> method is not invoked explicitly.
+     * <p>
+     * The method {@link System#runFinalization()} is the conventional
+     * and convenient means of invoking this method.
+     *
+     * @see     java.lang.Object#finalize()
+     */
+    public void runFinalization() {
+        runFinalization0();
+    }
+
+    /**
+     * Enables/Disables tracing of instructions.
+     * If the <code>boolean</code> argument is <code>true</code>, this
+     * method suggests that the Java virtual machine emit debugging
+     * information for each instruction in the virtual machine as it
+     * is executed. The format of this information, and the file or other
+     * output stream to which it is emitted, depends on the host environment.
+     * The virtual machine may ignore this request if it does not support
+     * this feature. The destination of the trace output is system
+     * dependent.
+     * <p>
+     * If the <code>boolean</code> argument is <code>false</code>, this
+     * method causes the virtual machine to stop performing the
+     * detailed instruction trace it is performing.
+     *
+     * @param   on   <code>true</code> to enable instruction tracing;
+     *               <code>false</code> to disable this feature.
+     */
+    public native void traceInstructions(boolean on);
+
+    /**
+     * Enables/Disables tracing of method calls.
+     * If the <code>boolean</code> argument is <code>true</code>, this
+     * method suggests that the Java virtual machine emit debugging
+     * information for each method in the virtual machine as it is
+     * called. The format of this information, and the file or other output
+     * stream to which it is emitted, depends on the host environment. The
+     * virtual machine may ignore this request if it does not support
+     * this feature.
+     * <p>
+     * Calling this method with argument false suggests that the
+     * virtual machine cease emitting per-call debugging information.
+     *
+     * @param   on   <code>true</code> to enable instruction tracing;
+     *               <code>false</code> to disable this feature.
+     */
+    public native void traceMethodCalls(boolean on);
+
+    /**
+     * Loads the native library specified by the filename argument.  The filename
+     * argument must be an absolute path name.
+     * (for example
+     * <code>Runtime.getRuntime().load("/home/avh/lib/libX11.so");</code>).
+     *
+     * If the filename argument, when stripped of any platform-specific library
+     * prefix, path, and file extension, indicates a library whose name is,
+     * for example, L, and a native library called L is statically linked
+     * with the VM, then the JNI_OnLoad_L function exported by the library
+     * is invoked rather than attempting to load a dynamic library.
+     * A filename matching the argument does not have to exist in the file
+     * system. See the JNI Specification for more details.
+     *
+     * Otherwise, the filename argument is mapped to a native library image in
+     * an implementation-dependent manner.
+     * <p>
+     * First, if there is a security manager, its <code>checkLink</code>
+     * method is called with the <code>filename</code> as its argument.
+     * This may result in a security exception.
+     * <p>
+     * This is similar to the method {@link #loadLibrary(String)}, but it
+     * accepts a general file name as an argument rather than just a library
+     * name, allowing any file of native code to be loaded.
+     * <p>
+     * The method {@link System#load(String)} is the conventional and
+     * convenient means of invoking this method.
+     *
+     * @param      filename   the file to load.
+     * @exception  SecurityException  if a security manager exists and its
+     *             <code>checkLink</code> method doesn't allow
+     *             loading of the specified dynamic library
+     * @exception  UnsatisfiedLinkError  if either the filename is not an
+     *             absolute path name, the native library is not statically
+     *             linked with the VM, or the library cannot be mapped to
+     *             a native library image by the host system.
+     * @exception  NullPointerException if <code>filename</code> is
+     *             <code>null</code>
+     * @see        java.lang.Runtime#getRuntime()
+     * @see        java.lang.SecurityException
+     * @see        java.lang.SecurityManager#checkLink(java.lang.String)
+     */
+    @CallerSensitive
+    public void load(String filename) {
+        load0(Reflection.getCallerClass(), filename);
+    }
+
+    synchronized void load0(Class<?> fromClass, String filename) {
+        SecurityManager security = System.getSecurityManager();
+        if (security != null) {
+            security.checkLink(filename);
+        }
+        if (!(new File(filename).isAbsolute())) {
+            throw new UnsatisfiedLinkError(
+                "Expecting an absolute path of the library: " + filename);
+        }
+        ClassLoader.loadLibrary(fromClass, filename, true);
+    }
+
+    /**
+     * Loads the native library specified by the <code>libname</code>
+     * argument.  The <code>libname</code> argument must not contain any platform
+     * specific prefix, file extension or path. If a native library
+     * called <code>libname</code> is statically linked with the VM, then the
+     * JNI_OnLoad_<code>libname</code> function exported by the library is invoked.
+     * See the JNI Specification for more details.
+     *
+     * Otherwise, the libname argument is loaded from a system library
+     * location and mapped to a native library image in an implementation-
+     * dependent manner.
+     * <p>
+     * First, if there is a security manager, its <code>checkLink</code>
+     * method is called with the <code>libname</code> as its argument.
+     * This may result in a security exception.
+     * <p>
+     * The method {@link System#loadLibrary(String)} is the conventional
+     * and convenient means of invoking this method. If native
+     * methods are to be used in the implementation of a class, a standard
+     * strategy is to put the native code in a library file (call it
+     * <code>LibFile</code>) and then to put a static initializer:
+     * <blockquote><pre>
+     * static { System.loadLibrary("LibFile"); }
+     * </pre></blockquote>
+     * within the class declaration. When the class is loaded and
+     * initialized, the necessary native code implementation for the native
+     * methods will then be loaded as well.
+     * <p>
+     * If this method is called more than once with the same library
+     * name, the second and subsequent calls are ignored.
+     *
+     * @param      libname   the name of the library.
+     * @exception  SecurityException  if a security manager exists and its
+     *             <code>checkLink</code> method doesn't allow
+     *             loading of the specified dynamic library
+     * @exception  UnsatisfiedLinkError if either the libname argument
+     *             contains a file path, the native library is not statically
+     *             linked with the VM,  or the library cannot be mapped to a
+     *             native library image by the host system.
+     * @exception  NullPointerException if <code>libname</code> is
+     *             <code>null</code>
+     * @see        java.lang.SecurityException
+     * @see        java.lang.SecurityManager#checkLink(java.lang.String)
+     */
+    @CallerSensitive
+    public void loadLibrary(String libname) {
+        loadLibrary0(Reflection.getCallerClass(), libname);
+    }
+
+    synchronized void loadLibrary0(Class<?> fromClass, String libname) {
+        SecurityManager security = System.getSecurityManager();
+        if (security != null) {
+            security.checkLink(libname);
+        }
+        if (libname.indexOf((int)File.separatorChar) != -1) {
+            throw new UnsatisfiedLinkError(
+    "Directory separator should not appear in library name: " + libname);
+        }
+        ClassLoader.loadLibrary(fromClass, libname, false);
+    }
+
+    /**
+     * Creates a localized version of an input stream. This method takes
+     * an <code>InputStream</code> and returns an <code>InputStream</code>
+     * equivalent to the argument in all respects except that it is
+     * localized: as characters in the local character set are read from
+     * the stream, they are automatically converted from the local
+     * character set to Unicode.
+     * <p>
+     * If the argument is already a localized stream, it may be returned
+     * as the result.
+     *
+     * @param      in InputStream to localize
+     * @return     a localized input stream
+     * @see        java.io.InputStream
+     * @see        java.io.BufferedReader#BufferedReader(java.io.Reader)
+     * @see        java.io.InputStreamReader#InputStreamReader(java.io.InputStream)
+     * @deprecated As of JDK&nbsp;1.1, the preferred way to translate a byte
+     * stream in the local encoding into a character stream in Unicode is via
+     * the <code>InputStreamReader</code> and <code>BufferedReader</code>
+     * classes.
+     */
+    @Deprecated
+    public InputStream getLocalizedInputStream(InputStream in) {
+        return in;
+    }
+
+    /**
+     * Creates a localized version of an output stream. This method
+     * takes an <code>OutputStream</code> and returns an
+     * <code>OutputStream</code> equivalent to the argument in all respects
+     * except that it is localized: as Unicode characters are written to
+     * the stream, they are automatically converted to the local
+     * character set.
+     * <p>
+     * If the argument is already a localized stream, it may be returned
+     * as the result.
+     *
+     * @deprecated As of JDK&nbsp;1.1, the preferred way to translate a
+     * Unicode character stream into a byte stream in the local encoding is via
+     * the <code>OutputStreamWriter</code>, <code>BufferedWriter</code>, and
+     * <code>PrintWriter</code> classes.
+     *
+     * @param      out OutputStream to localize
+     * @return     a localized output stream
+     * @see        java.io.OutputStream
+     * @see        java.io.BufferedWriter#BufferedWriter(java.io.Writer)
+     * @see        java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream)
+     * @see        java.io.PrintWriter#PrintWriter(java.io.OutputStream)
+     */
+    @Deprecated
+    public OutputStream getLocalizedOutputStream(OutputStream out) {
+        return out;
+    }
+
+}

jdkSrc/jdk8/java/lang/RuntimeException.java

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 1995, 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;
+
+/**
+ * {@code RuntimeException} is the superclass of those
+ * exceptions that can be thrown during the normal operation of the
+ * Java Virtual Machine.
+ *
+ * <p>{@code RuntimeException} and its subclasses are <em>unchecked
+ * exceptions</em>.  Unchecked exceptions do <em>not</em> need to be
+ * declared in a method or constructor's {@code throws} clause if they
+ * can be thrown by the execution of the method or constructor and
+ * propagate outside the method or constructor boundary.
+ *
+ * @author  Frank Yellin
+ * @jls 11.2 Compile-Time Checking of Exceptions
+ * @since   JDK1.0
+ */
+public class RuntimeException extends Exception {
+    static final long serialVersionUID = -7034897190745766939L;
+
+    /** Constructs a new runtime exception with {@code null} as its
+     * detail message.  The cause is not initialized, and may subsequently be
+     * initialized by a call to {@link #initCause}.
+     */
+    public RuntimeException() {
+        super();
+    }
+
+    /** Constructs a new runtime exception with the specified detail message.
+     * The cause is not initialized, and may subsequently be initialized by a
+     * call to {@link #initCause}.
+     *
+     * @param   message   the detail message. The detail message is saved for
+     *          later retrieval by the {@link #getMessage()} method.
+     */
+    public RuntimeException(String message) {
+        super(message);
+    }
+
+    /**
+     * Constructs a new runtime exception with the specified detail message and
+     * cause.  <p>Note that the detail message associated with
+     * {@code cause} is <i>not</i> automatically incorporated in
+     * this runtime exception's detail message.
+     *
+     * @param  message the detail message (which is saved for later retrieval
+     *         by the {@link #getMessage()} method).
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link #getCause()} method).  (A <tt>null</tt> value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since  1.4
+     */
+    public RuntimeException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /** Constructs a new runtime exception with the specified cause and a
+     * detail message of <tt>(cause==null ? null : cause.toString())</tt>
+     * (which typically contains the class and detail message of
+     * <tt>cause</tt>).  This constructor is useful for runtime exceptions
+     * that are little more than wrappers for other throwables.
+     *
+     * @param  cause the cause (which is saved for later retrieval by the
+     *         {@link #getCause()} method).  (A <tt>null</tt> value is
+     *         permitted, and indicates that the cause is nonexistent or
+     *         unknown.)
+     * @since  1.4
+     */
+    public RuntimeException(Throwable cause) {
+        super(cause);
+    }
+
+    /**
+     * Constructs a new runtime exception with the specified detail
+     * message, cause, suppression enabled or disabled, and writable
+     * stack trace enabled or disabled.
+     *
+     * @param  message the detail message.
+     * @param cause the cause.  (A {@code null} value is permitted,
+     * and indicates that the cause is nonexistent or unknown.)
+     * @param enableSuppression whether or not suppression is enabled
+     *                          or disabled
+     * @param writableStackTrace whether or not the stack trace should
+     *                           be writable
+     *
+     * @since 1.7
+     */
+    protected RuntimeException(String message, Throwable cause,
+                               boolean enableSuppression,
+                               boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}

jdkSrc/jdk8/java/lang/RuntimePermission.java

@@ -0,0 +1,387 @@
+/*
+ * Copyright (c) 1997, 2013, 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.security.*;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.StringTokenizer;
+
+/**
+ * This class is for runtime permissions. A RuntimePermission
+ * contains a name (also referred to as a "target name") but
+ * no actions list; you either have the named permission
+ * or you don't.
+ *
+ * <P>
+ * The target name is the name of the runtime permission (see below). The
+ * naming convention follows the  hierarchical property naming convention.
+ * Also, an asterisk
+ * may appear at the end of the name, following a ".", or by itself, to
+ * signify a wildcard match. For example: "loadLibrary.*" and "*" signify a
+ * wildcard match, while "*loadLibrary" and "a*b" do not.
+ * <P>
+ * The following table lists all the possible RuntimePermission target names,
+ * and for each provides a description of what the permission allows
+ * and a discussion of the risks of granting code the permission.
+ *
+ * <table border=1 cellpadding=5 summary="permission target name,
+ *  what the target allows,and associated risks">
+ * <tr>
+ * <th>Permission Target Name</th>
+ * <th>What the Permission Allows</th>
+ * <th>Risks of Allowing this Permission</th>
+ * </tr>
+ *
+ * <tr>
+ *   <td>createClassLoader</td>
+ *   <td>Creation of a class loader</td>
+ *   <td>This is an extremely dangerous permission to grant.
+ * Malicious applications that can instantiate their own class
+ * loaders could then load their own rogue classes into the system.
+ * These newly loaded classes could be placed into any protection
+ * domain by the class loader, thereby automatically granting the
+ * classes the permissions for that domain.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>getClassLoader</td>
+ *   <td>Retrieval of a class loader (e.g., the class loader for the calling
+ * class)</td>
+ *   <td>This would grant an attacker permission to get the
+ * class loader for a particular class. This is dangerous because
+ * having access to a class's class loader allows the attacker to
+ * load other classes available to that class loader. The attacker
+ * would typically otherwise not have access to those classes.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>setContextClassLoader</td>
+ *   <td>Setting of the context class loader used by a thread</td>
+ *   <td>The context class loader is used by system code and extensions
+ * when they need to lookup resources that might not exist in the system
+ * class loader. Granting setContextClassLoader permission would allow
+ * code to change which context class loader is used
+ * for a particular thread, including system threads.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>enableContextClassLoaderOverride</td>
+ *   <td>Subclass implementation of the thread context class loader methods</td>
+ *   <td>The context class loader is used by system code and extensions
+ * when they need to lookup resources that might not exist in the system
+ * class loader. Granting enableContextClassLoaderOverride permission would allow
+ * a subclass of Thread to override the methods that are used
+ * to get or set the context class loader for a particular thread.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>closeClassLoader</td>
+ *   <td>Closing of a ClassLoader</td>
+ *   <td>Granting this permission allows code to close any URLClassLoader
+ * that it has a reference to.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>setSecurityManager</td>
+ *   <td>Setting of the security manager (possibly replacing an existing one)
+ * </td>
+ *   <td>The security manager is a class that allows
+ * applications to implement a security policy. Granting the setSecurityManager
+ * permission would allow code to change which security manager is used by
+ * installing a different, possibly less restrictive security manager,
+ * thereby bypassing checks that would have been enforced by the original
+ * security manager.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>createSecurityManager</td>
+ *   <td>Creation of a new security manager</td>
+ *   <td>This gives code access to protected, sensitive methods that may
+ * disclose information about other classes or the execution stack.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>getenv.{variable name}</td>
+ *   <td>Reading of the value of the specified environment variable</td>
+ *   <td>This would allow code to read the value, or determine the
+ *       existence, of a particular environment variable.  This is
+ *       dangerous if the variable contains confidential data.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>exitVM.{exit status}</td>
+ *   <td>Halting of the Java Virtual Machine with the specified exit status</td>
+ *   <td>This allows an attacker to mount a denial-of-service attack
+ * by automatically forcing the virtual machine to halt.
+ * Note: The "exitVM.*" permission is automatically granted to all code
+ * loaded from the application class path, thus enabling applications
+ * to terminate themselves. Also, the "exitVM" permission is equivalent to
+ * "exitVM.*".</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>shutdownHooks</td>
+ *   <td>Registration and cancellation of virtual-machine shutdown hooks</td>
+ *   <td>This allows an attacker to register a malicious shutdown
+ * hook that interferes with the clean shutdown of the virtual machine.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>setFactory</td>
+ *   <td>Setting of the socket factory used by ServerSocket or Socket,
+ * or of the stream handler factory used by URL</td>
+ *   <td>This allows code to set the actual implementation
+ * for the socket, server socket, stream handler, or RMI socket factory.
+ * An attacker may set a faulty implementation which mangles the data
+ * stream.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>setIO</td>
+ *   <td>Setting of System.out, System.in, and System.err</td>
+ *   <td>This allows changing the value of the standard system streams.
+ * An attacker may change System.in to monitor and
+ * steal user input, or may set System.err to a "null" OutputStream,
+ * which would hide any error messages sent to System.err. </td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>modifyThread</td>
+ *   <td>Modification of threads, e.g., via calls to Thread
+ * <tt>interrupt</tt>, <tt>stop</tt>, <tt>suspend</tt>,
+ * <tt>resume</tt>, <tt>setDaemon</tt>, <tt>setPriority</tt>,
+ * <tt>setName</tt> and <tt>setUncaughtExceptionHandler</tt>
+ * methods</td>
+ * <td>This allows an attacker to modify the behaviour of
+ * any thread in the system.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>stopThread</td>
+ *   <td>Stopping of threads via calls to the Thread <code>stop</code>
+ * method</td>
+ *   <td>This allows code to stop any thread in the system provided that it is
+ * already granted permission to access that thread.
+ * This poses as a threat, because that code may corrupt the system by
+ * killing existing threads.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>modifyThreadGroup</td>
+ *   <td>modification of thread groups, e.g., via calls to ThreadGroup
+ * <code>destroy</code>, <code>getParent</code>, <code>resume</code>,
+ * <code>setDaemon</code>, <code>setMaxPriority</code>, <code>stop</code>,
+ * and <code>suspend</code> methods</td>
+ *   <td>This allows an attacker to create thread groups and
+ * set their run priority.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>getProtectionDomain</td>
+ *   <td>Retrieval of the ProtectionDomain for a class</td>
+ *   <td>This allows code to obtain policy information
+ * for a particular code source. While obtaining policy information
+ * does not compromise the security of the system, it does give
+ * attackers additional information, such as local file names for
+ * example, to better aim an attack.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>getFileSystemAttributes</td>
+ *   <td>Retrieval of file system attributes</td>
+ *   <td>This allows code to obtain file system information such as disk usage
+ *       or disk space available to the caller.  This is potentially dangerous
+ *       because it discloses information about the system hardware
+ *       configuration and some information about the caller's privilege to
+ *       write files.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>readFileDescriptor</td>
+ *   <td>Reading of file descriptors</td>
+ *   <td>This would allow code to read the particular file associated
+ *       with the file descriptor read. This is dangerous if the file
+ *       contains confidential data.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>writeFileDescriptor</td>
+ *   <td>Writing to file descriptors</td>
+ *   <td>This allows code to write to a particular file associated
+ *       with the descriptor. This is dangerous because it may allow
+ *       malicious code to plant viruses or at the very least, fill up
+ *       your entire disk.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>loadLibrary.{library name}</td>
+ *   <td>Dynamic linking of the specified library</td>
+ *   <td>It is dangerous to allow an applet permission to load native code
+ * libraries, because the Java security architecture is not designed to and
+ * does not prevent malicious behavior at the level of native code.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>accessClassInPackage.{package name}</td>
+ *   <td>Access to the specified package via a class loader's
+ * <code>loadClass</code> method when that class loader calls
+ * the SecurityManager <code>checkPackageAccess</code> method</td>
+ *   <td>This gives code access to classes in packages
+ * to which it normally does not have access. Malicious code
+ * may use these classes to help in its attempt to compromise
+ * security in the system.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>defineClassInPackage.{package name}</td>
+ *   <td>Definition of classes in the specified package, via a class
+ * loader's <code>defineClass</code> method when that class loader calls
+ * the SecurityManager <code>checkPackageDefinition</code> method.</td>
+ *   <td>This grants code permission to define a class
+ * in a particular package. This is dangerous because malicious
+ * code with this permission may define rogue classes in
+ * trusted packages like <code>java.security</code> or <code>java.lang</code>,
+ * for example.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>accessDeclaredMembers</td>
+ *   <td>Access to the declared members of a class</td>
+ *   <td>This grants code permission to query a class for its public,
+ * protected, default (package) access, and private fields and/or
+ * methods. Although the code would have
+ * access to the private and protected field and method names, it would not
+ * have access to the private/protected field data and would not be able
+ * to invoke any private methods. Nevertheless, malicious code
+ * may use this information to better aim an attack.
+ * Additionally, it may invoke any public methods and/or access public fields
+ * in the class.  This could be dangerous if
+ * the code would normally not be able to invoke those methods and/or
+ * access the fields  because
+ * it can't cast the object to the class/interface with those methods
+ * and fields.
+</td>
+ * </tr>
+ * <tr>
+ *   <td>queuePrintJob</td>
+ *   <td>Initiation of a print job request</td>
+ *   <td>This could print sensitive information to a printer,
+ * or simply waste paper.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>getStackTrace</td>
+ *   <td>Retrieval of the stack trace information of another thread.</td>
+ *   <td>This allows retrieval of the stack trace information of
+ * another thread.  This might allow malicious code to monitor the
+ * execution of threads and discover vulnerabilities in applications.</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>setDefaultUncaughtExceptionHandler</td>
+ *   <td>Setting the default handler to be used when a thread
+ *   terminates abruptly due to an uncaught exception</td>
+ *   <td>This allows an attacker to register a malicious
+ *   uncaught exception handler that could interfere with termination
+ *   of a thread</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>preferences</td>
+ *   <td>Represents the permission required to get access to the
+ *   java.util.prefs.Preferences implementations user or system root
+ *   which in turn allows retrieval or update operations within the
+ *   Preferences persistent backing store.) </td>
+ *   <td>This permission allows the user to read from or write to the
+ *   preferences backing store if the user running the code has
+ *   sufficient OS privileges to read/write to that backing store.
+ *   The actual backing store may reside within a traditional filesystem
+ *   directory or within a registry depending on the platform OS</td>
+ * </tr>
+ *
+ * <tr>
+ *   <td>usePolicy</td>
+ *   <td>Granting this permission disables the Java Plug-In's default
+ *   security prompting behavior.</td>
+ *   <td>For more information, refer to Java Plug-In's guides, <a href=
+ *   "../../../technotes/guides/plugin/developer_guide/security.html">
+ *   Applet Security Basics</a> and <a href=
+ *   "../../../technotes/guides/plugin/developer_guide/rsa_how.html#use">
+ *   usePolicy Permission</a>.</td>
+ * </tr>
+ * </table>
+ *
+ * @see java.security.BasicPermission
+ * @see java.security.Permission
+ * @see java.security.Permissions
+ * @see java.security.PermissionCollection
+ * @see java.lang.SecurityManager
+ *
+ *
+ * @author Marianne Mueller
+ * @author Roland Schemers
+ */
+
+public final class RuntimePermission extends BasicPermission {
+
+    private static final long serialVersionUID = 7399184964622342223L;
+
+    /**
+     * Creates a new RuntimePermission with the specified name.
+     * The name is the symbolic name of the RuntimePermission, such as
+     * "exit", "setFactory", etc. An asterisk
+     * may appear at the end of the name, following a ".", or by itself, to
+     * signify a wildcard match.
+     *
+     * @param name the name of the RuntimePermission.
+     *
+     * @throws NullPointerException if <code>name</code> is <code>null</code>.
+     * @throws IllegalArgumentException if <code>name</code> is empty.
+     */
+
+    public RuntimePermission(String name)
+    {
+        super(name);
+    }
+
+    /**
+     * Creates a new RuntimePermission object with the specified name.
+     * The name is the symbolic name of the RuntimePermission, and the
+     * actions String is currently unused and should be null.
+     *
+     * @param name the name of the RuntimePermission.
+     * @param actions should be null.
+     *
+     * @throws NullPointerException if <code>name</code> is <code>null</code>.
+     * @throws IllegalArgumentException if <code>name</code> is empty.
+     */
+
+    public RuntimePermission(String name, String actions)
+    {
+        super(name, actions);
+    }
+}

jdkSrc/jdk8/java/lang/SafeVarargs.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2010, 2013, 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.lang.annotation.*;
+
+/**
+ * A programmer assertion that the body of the annotated method or
+ * constructor does not perform potentially unsafe operations on its
+ * varargs parameter.  Applying this annotation to a method or
+ * constructor suppresses unchecked warnings about a
+ * <i>non-reifiable</i> variable arity (vararg) type and suppresses
+ * unchecked warnings about parameterized array creation at call
+ * sites.
+ *
+ * <p> In addition to the usage restrictions imposed by its {@link
+ * Target @Target} meta-annotation, compilers are required to implement
+ * additional usage restrictions on this annotation type; it is a
+ * compile-time error if a method or constructor declaration is
+ * annotated with a {@code @SafeVarargs} annotation, and either:
+ * <ul>
+ * <li>  the declaration is a fixed arity method or constructor
+ *
+ * <li> the declaration is a variable arity method that is neither
+ * {@code static} nor {@code final}.
+ *
+ * </ul>
+ *
+ * <p> Compilers are encouraged to issue warnings when this annotation
+ * type is applied to a method or constructor declaration where:
+ *
+ * <ul>
+ *
+ * <li> The variable arity parameter has a reifiable element type,
+ * which includes primitive types, {@code Object}, and {@code String}.
+ * (The unchecked warnings this annotation type suppresses already do
+ * not occur for a reifiable element type.)
+ *
+ * <li> The body of the method or constructor declaration performs
+ * potentially unsafe operations, such as an assignment to an element
+ * of the variable arity parameter's array that generates an unchecked
+ * warning.  Some unsafe operations do not trigger an unchecked
+ * warning.  For example, the aliasing in
+ *
+ * <blockquote><pre>
+ * &#64;SafeVarargs // Not actually safe!
+ * static void m(List&lt;String&gt;... stringLists) {
+ *   Object[] array = stringLists;
+ *   List&lt;Integer&gt; tmpList = Arrays.asList(42);
+ *   array[0] = tmpList; // Semantically invalid, but compiles without warnings
+ *   String s = stringLists[0].get(0); // Oh no, ClassCastException at runtime!
+ * }
+ * </pre></blockquote>
+ *
+ * leads to a {@code ClassCastException} at runtime.
+ *
+ * <p>Future versions of the platform may mandate compiler errors for
+ * such unsafe operations.
+ *
+ * </ul>
+ *
+ * @since 1.7
+ * @jls 4.7 Reifiable Types
+ * @jls 8.4.1 Formal Parameters
+ * @jls 9.6.3.7 @SafeVarargs
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})
+public @interface SafeVarargs {}

jdkSrc/jdk8/java/lang/SecurityException.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 1995, 2003, 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;
+
+/**
+ * Thrown by the security manager to indicate a security violation.
+ *
+ * @author  unascribed
+ * @see     java.lang.SecurityManager
+ * @since   JDK1.0
+ */
+public class SecurityException extends RuntimeException {
+
+    private static final long serialVersionUID = 6878364983674394167L;
+
+    /**
+     * Constructs a <code>SecurityException</code> with no detail  message.
+     */
+    public SecurityException() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>SecurityException</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public SecurityException(String s) {
+        super(s);
+    }
+
+    /**
+     * Creates a <code>SecurityException</code> with the specified
+     * detail message and cause.
+     *
+     * @param message the detail message (which is saved for later retrieval
+     *        by the {@link #getMessage()} method).
+     * @param cause the cause (which is saved for later retrieval by the
+     *        {@link #getCause()} method).  (A <tt>null</tt> value is permitted,
+     *        and indicates that the cause is nonexistent or unknown.)
+     * @since 1.5
+     */
+    public SecurityException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Creates a <code>SecurityException</code> with the specified cause
+     * and a detail message of <tt>(cause==null ? null : cause.toString())</tt>
+     * (which typically contains the class and detail message of
+     * <tt>cause</tt>).
+     *
+     * @param cause the cause (which is saved for later retrieval by the
+     *        {@link #getCause()} method).  (A <tt>null</tt> value is permitted,
+     *        and indicates that the cause is nonexistent or unknown.)
+     * @since 1.5
+     */
+    public SecurityException(Throwable cause) {
+        super(cause);
+    }
+}

jdkSrc/jdk8/java/lang/Short.java

@@ -0,0 +1,537 @@
+/*
+ * Copyright (c) 1996, 2013, 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;
+
+/**
+ * The {@code Short} class wraps a value of primitive type {@code
+ * short} in an object.  An object of type {@code Short} contains a
+ * single field whose type is {@code short}.
+ *
+ * <p>In addition, this class provides several methods for converting
+ * a {@code short} to a {@code String} and a {@code String} to a
+ * {@code short}, as well as other constants and methods useful when
+ * dealing with a {@code short}.
+ *
+ * @author  Nakul Saraiya
+ * @author  Joseph D. Darcy
+ * @see     java.lang.Number
+ * @since   JDK1.1
+ */
+public final class Short extends Number implements Comparable<Short> {
+
+    /**
+     * A constant holding the minimum value a {@code short} can
+     * have, -2<sup>15</sup>.
+     */
+    public static final short   MIN_VALUE = -32768;
+
+    /**
+     * A constant holding the maximum value a {@code short} can
+     * have, 2<sup>15</sup>-1.
+     */
+    public static final short   MAX_VALUE = 32767;
+
+    /**
+     * The {@code Class} instance representing the primitive type
+     * {@code short}.
+     */
+    @SuppressWarnings("unchecked")
+    public static final Class<Short>    TYPE = (Class<Short>) Class.getPrimitiveClass("short");
+
+    /**
+     * Returns a new {@code String} object representing the
+     * specified {@code short}. The radix is assumed to be 10.
+     *
+     * @param s the {@code short} to be converted
+     * @return the string representation of the specified {@code short}
+     * @see java.lang.Integer#toString(int)
+     */
+    public static String toString(short s) {
+        return Integer.toString((int)s, 10);
+    }
+
+    /**
+     * Parses the string argument as a signed {@code short} in the
+     * radix specified by the second argument. The characters in the
+     * string must all be digits, of the specified radix (as
+     * determined by whether {@link java.lang.Character#digit(char,
+     * int)} returns a nonnegative value) except that the first
+     * character may be an ASCII minus sign {@code '-'}
+     * ({@code '\u005Cu002D'}) to indicate a negative value or an
+     * ASCII plus sign {@code '+'} ({@code '\u005Cu002B'}) to
+     * indicate a positive value.  The resulting {@code short} value
+     * is returned.
+     *
+     * <p>An exception of type {@code NumberFormatException} is
+     * thrown if any of the following situations occurs:
+     * <ul>
+     * <li> The first argument is {@code null} or is a string of
+     * length zero.
+     *
+     * <li> The radix is either smaller than {@link
+     * java.lang.Character#MIN_RADIX} or larger than {@link
+     * java.lang.Character#MAX_RADIX}.
+     *
+     * <li> Any character of the string is not a digit of the
+     * specified radix, except that the first character may be a minus
+     * sign {@code '-'} ({@code '\u005Cu002D'}) or plus sign
+     * {@code '+'} ({@code '\u005Cu002B'}) provided that the
+     * string is longer than length 1.
+     *
+     * <li> The value represented by the string is not a value of type
+     * {@code short}.
+     * </ul>
+     *
+     * @param s         the {@code String} containing the
+     *                  {@code short} representation to be parsed
+     * @param radix     the radix to be used while parsing {@code s}
+     * @return          the {@code short} represented by the string
+     *                  argument in the specified radix.
+     * @throws          NumberFormatException If the {@code String}
+     *                  does not contain a parsable {@code short}.
+     */
+    public static short parseShort(String s, int radix)
+        throws NumberFormatException {
+        int i = Integer.parseInt(s, radix);
+        if (i < MIN_VALUE || i > MAX_VALUE)
+            throw new NumberFormatException(
+                "Value out of range. Value:\"" + s + "\" Radix:" + radix);
+        return (short)i;
+    }
+
+    /**
+     * Parses the string argument as a signed decimal {@code
+     * short}. The characters in the string must all be decimal
+     * digits, except that the first character may be an ASCII minus
+     * sign {@code '-'} ({@code '\u005Cu002D'}) to indicate a
+     * negative value or an ASCII plus sign {@code '+'}
+     * ({@code '\u005Cu002B'}) to indicate a positive value.  The
+     * resulting {@code short} value is returned, exactly as if the
+     * argument and the radix 10 were given as arguments to the {@link
+     * #parseShort(java.lang.String, int)} method.
+     *
+     * @param s a {@code String} containing the {@code short}
+     *          representation to be parsed
+     * @return  the {@code short} value represented by the
+     *          argument in decimal.
+     * @throws  NumberFormatException If the string does not
+     *          contain a parsable {@code short}.
+     */
+    public static short parseShort(String s) throws NumberFormatException {
+        return parseShort(s, 10);
+    }
+
+    /**
+     * Returns a {@code Short} object holding the value
+     * extracted from the specified {@code String} when parsed
+     * with the radix given by the second argument. The first argument
+     * is interpreted as representing a signed {@code short} in
+     * the radix specified by the second argument, exactly as if the
+     * argument were given to the {@link #parseShort(java.lang.String,
+     * int)} method. The result is a {@code Short} object that
+     * represents the {@code short} value specified by the string.
+     *
+     * <p>In other words, this method returns a {@code Short} object
+     * equal to the value of:
+     *
+     * <blockquote>
+     *  {@code new Short(Short.parseShort(s, radix))}
+     * </blockquote>
+     *
+     * @param s         the string to be parsed
+     * @param radix     the radix to be used in interpreting {@code s}
+     * @return          a {@code Short} object holding the value
+     *                  represented by the string argument in the
+     *                  specified radix.
+     * @throws          NumberFormatException If the {@code String} does
+     *                  not contain a parsable {@code short}.
+     */
+    public static Short valueOf(String s, int radix)
+        throws NumberFormatException {
+        return valueOf(parseShort(s, radix));
+    }
+
+    /**
+     * Returns a {@code Short} object holding the
+     * value given by the specified {@code String}. The argument
+     * is interpreted as representing a signed decimal
+     * {@code short}, exactly as if the argument were given to
+     * the {@link #parseShort(java.lang.String)} method. The result is
+     * a {@code Short} object that represents the
+     * {@code short} value specified by the string.
+     *
+     * <p>In other words, this method returns a {@code Short} object
+     * equal to the value of:
+     *
+     * <blockquote>
+     *  {@code new Short(Short.parseShort(s))}
+     * </blockquote>
+     *
+     * @param s the string to be parsed
+     * @return  a {@code Short} object holding the value
+     *          represented by the string argument
+     * @throws  NumberFormatException If the {@code String} does
+     *          not contain a parsable {@code short}.
+     */
+    public static Short valueOf(String s) throws NumberFormatException {
+        return valueOf(s, 10);
+    }
+
+    private static class ShortCache {
+        private ShortCache(){}
+
+        static final Short cache[] = new Short[-(-128) + 127 + 1];
+
+        static {
+            for(int i = 0; i < cache.length; i++)
+                cache[i] = new Short((short)(i - 128));
+        }
+    }
+
+    /**
+     * Returns a {@code Short} instance representing the specified
+     * {@code short} value.
+     * If a new {@code Short} instance is not required, this method
+     * should generally be used in preference to the constructor
+     * {@link #Short(short)}, as this method is likely to yield
+     * significantly better space and time performance by caching
+     * frequently requested values.
+     *
+     * This method will always cache values in the range -128 to 127,
+     * inclusive, and may cache other values outside of this range.
+     *
+     * @param  s a short value.
+     * @return a {@code Short} instance representing {@code s}.
+     * @since  1.5
+     */
+    public static Short valueOf(short s) {
+        final int offset = 128;
+        int sAsInt = s;
+        if (sAsInt >= -128 && sAsInt <= 127) { // must cache
+            return ShortCache.cache[sAsInt + offset];
+        }
+        return new Short(s);
+    }
+
+    /**
+     * Decodes a {@code String} into a {@code Short}.
+     * Accepts decimal, hexadecimal, and octal numbers given by
+     * the following grammar:
+     *
+     * <blockquote>
+     * <dl>
+     * <dt><i>DecodableString:</i>
+     * <dd><i>Sign<sub>opt</sub> DecimalNumeral</i>
+     * <dd><i>Sign<sub>opt</sub></i> {@code 0x} <i>HexDigits</i>
+     * <dd><i>Sign<sub>opt</sub></i> {@code 0X} <i>HexDigits</i>
+     * <dd><i>Sign<sub>opt</sub></i> {@code #} <i>HexDigits</i>
+     * <dd><i>Sign<sub>opt</sub></i> {@code 0} <i>OctalDigits</i>
+     *
+     * <dt><i>Sign:</i>
+     * <dd>{@code -}
+     * <dd>{@code +}
+     * </dl>
+     * </blockquote>
+     *
+     * <i>DecimalNumeral</i>, <i>HexDigits</i>, and <i>OctalDigits</i>
+     * are as defined in section 3.10.1 of
+     * <cite>The Java&trade; Language Specification</cite>,
+     * except that underscores are not accepted between digits.
+     *
+     * <p>The sequence of characters following an optional
+     * sign and/or radix specifier ("{@code 0x}", "{@code 0X}",
+     * "{@code #}", or leading zero) is parsed as by the {@code
+     * Short.parseShort} method with the indicated radix (10, 16, or
+     * 8).  This sequence of characters must represent a positive
+     * value or a {@link NumberFormatException} will be thrown.  The
+     * result is negated if first character of the specified {@code
+     * String} is the minus sign.  No whitespace characters are
+     * permitted in the {@code String}.
+     *
+     * @param     nm the {@code String} to decode.
+     * @return    a {@code Short} object holding the {@code short}
+     *            value represented by {@code nm}
+     * @throws    NumberFormatException  if the {@code String} does not
+     *            contain a parsable {@code short}.
+     * @see java.lang.Short#parseShort(java.lang.String, int)
+     */
+    public static Short decode(String nm) throws NumberFormatException {
+        int i = Integer.decode(nm);
+        if (i < MIN_VALUE || i > MAX_VALUE)
+            throw new NumberFormatException(
+                    "Value " + i + " out of range from input " + nm);
+        return valueOf((short)i);
+    }
+
+    /**
+     * The value of the {@code Short}.
+     *
+     * @serial
+     */
+    private final short value;
+
+    /**
+     * Constructs a newly allocated {@code Short} object that
+     * represents the specified {@code short} value.
+     *
+     * @param value     the value to be represented by the
+     *                  {@code Short}.
+     */
+    public Short(short value) {
+        this.value = value;
+    }
+
+    /**
+     * Constructs a newly allocated {@code Short} object that
+     * represents the {@code short} value indicated by the
+     * {@code String} parameter. The string is converted to a
+     * {@code short} value in exactly the manner used by the
+     * {@code parseShort} method for radix 10.
+     *
+     * @param s the {@code String} to be converted to a
+     *          {@code Short}
+     * @throws  NumberFormatException If the {@code String}
+     *          does not contain a parsable {@code short}.
+     * @see     java.lang.Short#parseShort(java.lang.String, int)
+     */
+    public Short(String s) throws NumberFormatException {
+        this.value = parseShort(s, 10);
+    }
+
+    /**
+     * Returns the value of this {@code Short} as a {@code byte} after
+     * a narrowing primitive conversion.
+     * @jls 5.1.3 Narrowing Primitive Conversions
+     */
+    public byte byteValue() {
+        return (byte)value;
+    }
+
+    /**
+     * Returns the value of this {@code Short} as a
+     * {@code short}.
+     */
+    public short shortValue() {
+        return value;
+    }
+
+    /**
+     * Returns the value of this {@code Short} as an {@code int} after
+     * a widening primitive conversion.
+     * @jls 5.1.2 Widening Primitive Conversions
+     */
+    public int intValue() {
+        return (int)value;
+    }
+
+    /**
+     * Returns the value of this {@code Short} as a {@code long} after
+     * a widening primitive conversion.
+     * @jls 5.1.2 Widening Primitive Conversions
+     */
+    public long longValue() {
+        return (long)value;
+    }
+
+    /**
+     * Returns the value of this {@code Short} as a {@code float}
+     * after a widening primitive conversion.
+     * @jls 5.1.2 Widening Primitive Conversions
+     */
+    public float floatValue() {
+        return (float)value;
+    }
+
+    /**
+     * Returns the value of this {@code Short} as a {@code double}
+     * after a widening primitive conversion.
+     * @jls 5.1.2 Widening Primitive Conversions
+     */
+    public double doubleValue() {
+        return (double)value;
+    }
+
+    /**
+     * Returns a {@code String} object representing this
+     * {@code Short}'s value.  The value is converted to signed
+     * decimal representation and returned as a string, exactly as if
+     * the {@code short} value were given as an argument to the
+     * {@link java.lang.Short#toString(short)} method.
+     *
+     * @return  a string representation of the value of this object in
+     *          base&nbsp;10.
+     */
+    public String toString() {
+        return Integer.toString((int)value);
+    }
+
+    /**
+     * Returns a hash code for this {@code Short}; equal to the result
+     * of invoking {@code intValue()}.
+     *
+     * @return a hash code value for this {@code Short}
+     */
+    @Override
+    public int hashCode() {
+        return Short.hashCode(value);
+    }
+
+    /**
+     * Returns a hash code for a {@code short} value; compatible with
+     * {@code Short.hashCode()}.
+     *
+     * @param value the value to hash
+     * @return a hash code value for a {@code short} value.
+     * @since 1.8
+     */
+    public static int hashCode(short value) {
+        return (int)value;
+    }
+
+    /**
+     * Compares this object to the specified object.  The result is
+     * {@code true} if and only if the argument is not
+     * {@code null} and is a {@code Short} object that
+     * contains the same {@code short} value as this object.
+     *
+     * @param obj       the object to compare with
+     * @return          {@code true} if the objects are the same;
+     *                  {@code false} otherwise.
+     */
+    public boolean equals(Object obj) {
+        if (obj instanceof Short) {
+            return value == ((Short)obj).shortValue();
+        }
+        return false;
+    }
+
+    /**
+     * Compares two {@code Short} objects numerically.
+     *
+     * @param   anotherShort   the {@code Short} to be compared.
+     * @return  the value {@code 0} if this {@code Short} is
+     *          equal to the argument {@code Short}; a value less than
+     *          {@code 0} if this {@code Short} is numerically less
+     *          than the argument {@code Short}; and a value greater than
+     *           {@code 0} if this {@code Short} is numerically
+     *           greater than the argument {@code Short} (signed
+     *           comparison).
+     * @since   1.2
+     */
+    public int compareTo(Short anotherShort) {
+        return compare(this.value, anotherShort.value);
+    }
+
+    /**
+     * Compares two {@code short} values numerically.
+     * The value returned is identical to what would be returned by:
+     * <pre>
+     *    Short.valueOf(x).compareTo(Short.valueOf(y))
+     * </pre>
+     *
+     * @param  x the first {@code short} to compare
+     * @param  y the second {@code short} to compare
+     * @return the value {@code 0} if {@code x == y};
+     *         a value less than {@code 0} if {@code x < y}; and
+     *         a value greater than {@code 0} if {@code x > y}
+     * @since 1.7
+     */
+    public static int compare(short x, short y) {
+        return x - y;
+    }
+
+    /**
+     * The number of bits used to represent a {@code short} value in two's
+     * complement binary form.
+     * @since 1.5
+     */
+    public static final int SIZE = 16;
+
+    /**
+     * The number of bytes used to represent a {@code short} value in two's
+     * complement binary form.
+     *
+     * @since 1.8
+     */
+    public static final int BYTES = SIZE / Byte.SIZE;
+
+    /**
+     * Returns the value obtained by reversing the order of the bytes in the
+     * two's complement representation of the specified {@code short} value.
+     *
+     * @param i the value whose bytes are to be reversed
+     * @return the value obtained by reversing (or, equivalently, swapping)
+     *     the bytes in the specified {@code short} value.
+     * @since 1.5
+     */
+    public static short reverseBytes(short i) {
+        return (short) (((i & 0xFF00) >> 8) | (i << 8));
+    }
+
+
+    /**
+     * Converts the argument to an {@code int} by an unsigned
+     * conversion.  In an unsigned conversion to an {@code int}, the
+     * high-order 16 bits of the {@code int} are zero and the
+     * low-order 16 bits are equal to the bits of the {@code short} argument.
+     *
+     * Consequently, zero and positive {@code short} values are mapped
+     * to a numerically equal {@code int} value and negative {@code
+     * short} values are mapped to an {@code int} value equal to the
+     * input plus 2<sup>16</sup>.
+     *
+     * @param  x the value to convert to an unsigned {@code int}
+     * @return the argument converted to {@code int} by an unsigned
+     *         conversion
+     * @since 1.8
+     */
+    public static int toUnsignedInt(short x) {
+        return ((int) x) & 0xffff;
+    }
+
+    /**
+     * Converts the argument to a {@code long} by an unsigned
+     * conversion.  In an unsigned conversion to a {@code long}, the
+     * high-order 48 bits of the {@code long} are zero and the
+     * low-order 16 bits are equal to the bits of the {@code short} argument.
+     *
+     * Consequently, zero and positive {@code short} values are mapped
+     * to a numerically equal {@code long} value and negative {@code
+     * short} values are mapped to a {@code long} value equal to the
+     * input plus 2<sup>16</sup>.
+     *
+     * @param  x the value to convert to an unsigned {@code long}
+     * @return the argument converted to {@code long} by an unsigned
+     *         conversion
+     * @since 1.8
+     */
+    public static long toUnsignedLong(short x) {
+        return ((long) x) & 0xffffL;
+    }
+
+    /** use serialVersionUID from JDK 1.1. for interoperability */
+    private static final long serialVersionUID = 7515723908773894738L;
+}

jdkSrc/jdk8/java/lang/Shutdown.java

@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 1999, 2022, 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;
+
+/**
+ * Package-private utility class containing data structures and logic
+ * governing the virtual-machine shutdown sequence.
+ *
+ * @author   Mark Reinhold
+ * @since    1.3
+ *
+ * @see java.io.Console
+ * @see ApplicationShutdownHooks
+ * @see java.io.DeleteOnExitHook
+ */
+
+class Shutdown {
+
+    // The system shutdown hooks are registered with a predefined slot.
+    // The list of shutdown hooks is as follows:
+    // (0) Console restore hook
+    // (1) ApplicationShutdownHooks that invokes all registered application
+    //     shutdown hooks and waits until they finish
+    // (2) DeleteOnExit hook
+    private static final int MAX_SYSTEM_HOOKS = 10;
+    private static final Runnable[] hooks = new Runnable[MAX_SYSTEM_HOOKS];
+
+    // the index of the currently running shutdown hook to the hooks array
+    private static int currentRunningHook = -1;
+
+    // track whether we have already (commenced) shutdown
+    private static boolean isShutdown;
+
+    /* The preceding static fields are protected by this lock */
+    private static class Lock { };
+    private static Object lock = new Lock();
+
+    /* Lock object for the native halt method */
+    private static Object haltLock = new Lock();
+
+    /**
+     * Add a new system shutdown hook.  Checks the shutdown state and
+     * the hook itself, but does not do any security checks.
+     *
+     * The registerShutdownInProgress parameter should be false except
+     * registering the DeleteOnExitHook since the first file may
+     * be added to the delete on exit list by the application shutdown
+     * hooks.
+     *
+     * @param slot  the slot in the shutdown hook array, whose element
+     *              will be invoked in order during shutdown
+     * @param registerShutdownInProgress true to allow the hook
+     *              to be registered even if the shutdown is in progress.
+     * @param hook  the hook to be registered
+     *
+     * @throws IllegalStateException
+     *         if registerShutdownInProgress is false and shutdown is in progress; or
+     *         if registerShutdownInProgress is true and the shutdown process
+     *         already passes the given slot
+     */
+    static void add(int slot, boolean registerShutdownInProgress, Runnable hook) {
+        if (slot < 0 || slot >= MAX_SYSTEM_HOOKS) {
+            throw new IllegalArgumentException("Invalid slot: " + slot);
+        }
+        synchronized (lock) {
+            if (hooks[slot] != null)
+                throw new InternalError("Shutdown hook at slot " + slot + " already registered");
+
+            if (!registerShutdownInProgress) {
+                if (currentRunningHook >= 0)
+                    throw new IllegalStateException("Shutdown in progress");
+            } else {
+                if (isShutdown || slot <= currentRunningHook)
+                    throw new IllegalStateException("Shutdown in progress");
+            }
+
+            hooks[slot] = hook;
+        }
+    }
+
+    /* Run all system shutdown hooks.
+     *
+     * The system shutdown hooks are run in the thread synchronized on
+     * Shutdown.class.  Other threads calling Runtime::exit, Runtime::halt
+     * or JNI DestroyJavaVM will block indefinitely.
+     *
+     * ApplicationShutdownHooks is registered as one single hook that starts
+     * all application shutdown hooks and waits until they finish.
+     */
+    private static void runHooks() {
+        synchronized (lock) {
+            /* Guard against the possibility of a daemon thread invoking exit
+             * after DestroyJavaVM initiates the shutdown sequence
+             */
+            if (isShutdown) return;
+        }
+
+        for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {
+            try {
+                Runnable hook;
+                synchronized (lock) {
+                    // acquire the lock to make sure the hook registered during
+                    // shutdown is visible here.
+                    currentRunningHook = i;
+                    hook = hooks[i];
+                }
+                if (hook != null) hook.run();
+            } catch (Throwable t) {
+                if (t instanceof ThreadDeath) {
+                    ThreadDeath td = (ThreadDeath)t;
+                    throw td;
+                }
+            }
+        }
+
+        // set shutdown state
+        // Synchronization is for visibility; only one thread
+        // can ever get here.
+        synchronized (lock) {
+            isShutdown = true;
+        }
+    }
+
+    /* Notify the VM that it's time to halt. */
+    static native void beforeHalt();
+
+    /* The halt method is synchronized on the halt lock
+     * to avoid corruption of the delete-on-shutdown file list.
+     * It invokes the true native halt method.
+     */
+    static void halt(int status) {
+        synchronized (haltLock) {
+            halt0(status);
+        }
+    }
+
+    static native void halt0(int status);
+
+    /* Invoked by Runtime.exit, which does all the security checks.
+     * Also invoked by handlers for system-provided termination events,
+     * which should pass a nonzero status code.
+     */
+    static void exit(int status) {
+        synchronized (lock) {
+            if (status != 0 && isShutdown) {
+                /* Halt immediately on nonzero status */
+                halt(status);
+            }
+        }
+        synchronized (Shutdown.class) {
+            /* Synchronize on the class object, causing any other thread
+             * that attempts to initiate shutdown to stall indefinitely
+             */
+            beforeHalt();
+            runHooks();
+            halt(status);
+        }
+    }
+
+
+    /* Invoked by the JNI DestroyJavaVM procedure when the last non-daemon
+     * thread has finished.  Unlike the exit method, this method does not
+     * actually halt the VM.
+     */
+    static void shutdown() {
+        synchronized (Shutdown.class) {
+            runHooks();
+        }
+    }
+
+}

jdkSrc/jdk8/java/lang/StackOverflowError.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 1994, 2008, 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;
+
+/**
+ * Thrown when a stack overflow occurs because an application
+ * recurses too deeply.
+ *
+ * @author unascribed
+ * @since   JDK1.0
+ */
+public
+class StackOverflowError extends VirtualMachineError {
+    private static final long serialVersionUID = 8609175038441759607L;
+
+    /**
+     * Constructs a <code>StackOverflowError</code> with no detail message.
+     */
+    public StackOverflowError() {
+        super();
+    }
+
+    /**
+     * Constructs a <code>StackOverflowError</code> with the specified
+     * detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public StackOverflowError(String s) {
+        super(s);
+    }
+}

jdkSrc/jdk8/java/lang/StackTraceElement.java

@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2000, 2013, 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.util.Objects;
+
+/**
+ * An element in a stack trace, as returned by {@link
+ * Throwable#getStackTrace()}.  Each element represents a single stack frame.
+ * All stack frames except for the one at the top of the stack represent
+ * a method invocation.  The frame at the top of the stack represents the
+ * execution point at which the stack trace was generated.  Typically,
+ * this is the point at which the throwable corresponding to the stack trace
+ * was created.
+ *
+ * @since  1.4
+ * @author Josh Bloch
+ */
+public final class StackTraceElement implements java.io.Serializable {
+    // Normally initialized by VM (public constructor added in 1.5)
+    private String declaringClass;
+    private String methodName;
+    private String fileName;
+    private int    lineNumber;
+
+    /**
+     * Creates a stack trace element representing the specified execution
+     * point.
+     *
+     * @param declaringClass the fully qualified name of the class containing
+     *        the execution point represented by the stack trace element
+     * @param methodName the name of the method containing the execution point
+     *        represented by the stack trace element
+     * @param fileName the name of the file containing the execution point
+     *         represented by the stack trace element, or {@code null} if
+     *         this information is unavailable
+     * @param lineNumber the line number of the source line containing the
+     *         execution point represented by this stack trace element, or
+     *         a negative number if this information is unavailable. A value
+     *         of -2 indicates that the method containing the execution point
+     *         is a native method
+     * @throws NullPointerException if {@code declaringClass} or
+     *         {@code methodName} is null
+     * @since 1.5
+     */
+    public StackTraceElement(String declaringClass, String methodName,
+                             String fileName, int lineNumber) {
+        this.declaringClass = Objects.requireNonNull(declaringClass, "Declaring class is null");
+        this.methodName     = Objects.requireNonNull(methodName, "Method name is null");
+        this.fileName       = fileName;
+        this.lineNumber     = lineNumber;
+    }
+
+    /**
+     * Returns the name of the source file containing the execution point
+     * represented by this stack trace element.  Generally, this corresponds
+     * to the {@code SourceFile} attribute of the relevant {@code class}
+     * file (as per <i>The Java Virtual Machine Specification</i>, Section
+     * 4.7.7).  In some systems, the name may refer to some source code unit
+     * other than a file, such as an entry in source repository.
+     *
+     * @return the name of the file containing the execution point
+     *         represented by this stack trace element, or {@code null} if
+     *         this information is unavailable.
+     */
+    public String getFileName() {
+        return fileName;
+    }
+
+    /**
+     * Returns the line number of the source line containing the execution
+     * point represented by this stack trace element.  Generally, this is
+     * derived from the {@code LineNumberTable} attribute of the relevant
+     * {@code class} file (as per <i>The Java Virtual Machine
+     * Specification</i>, Section 4.7.8).
+     *
+     * @return the line number of the source line containing the execution
+     *         point represented by this stack trace element, or a negative
+     *         number if this information is unavailable.
+     */
+    public int getLineNumber() {
+        return lineNumber;
+    }
+
+    /**
+     * Returns the fully qualified name of the class containing the
+     * execution point represented by this stack trace element.
+     *
+     * @return the fully qualified name of the {@code Class} containing
+     *         the execution point represented by this stack trace element.
+     */
+    public String getClassName() {
+        return declaringClass;
+    }
+
+    /**
+     * Returns the name of the method containing the execution point
+     * represented by this stack trace element.  If the execution point is
+     * contained in an instance or class initializer, this method will return
+     * the appropriate <i>special method name</i>, {@code <init>} or
+     * {@code <clinit>}, as per Section 3.9 of <i>The Java Virtual
+     * Machine Specification</i>.
+     *
+     * @return the name of the method containing the execution point
+     *         represented by this stack trace element.
+     */
+    public String getMethodName() {
+        return methodName;
+    }
+
+    /**
+     * Returns true if the method containing the execution point
+     * represented by this stack trace element is a native method.
+     *
+     * @return {@code true} if the method containing the execution point
+     *         represented by this stack trace element is a native method.
+     */
+    public boolean isNativeMethod() {
+        return lineNumber == -2;
+    }
+
+    /**
+     * Returns a string representation of this stack trace element.  The
+     * format of this string depends on the implementation, but the following
+     * examples may be regarded as typical:
+     * <ul>
+     * <li>
+     *   {@code "MyClass.mash(MyClass.java:9)"} - Here, {@code "MyClass"}
+     *   is the <i>fully-qualified name</i> of the class containing the
+     *   execution point represented by this stack trace element,
+     *   {@code "mash"} is the name of the method containing the execution
+     *   point, {@code "MyClass.java"} is the source file containing the
+     *   execution point, and {@code "9"} is the line number of the source
+     *   line containing the execution point.
+     * <li>
+     *   {@code "MyClass.mash(MyClass.java)"} - As above, but the line
+     *   number is unavailable.
+     * <li>
+     *   {@code "MyClass.mash(Unknown Source)"} - As above, but neither
+     *   the file name nor the line  number are available.
+     * <li>
+     *   {@code "MyClass.mash(Native Method)"} - As above, but neither
+     *   the file name nor the line  number are available, and the method
+     *   containing the execution point is known to be a native method.
+     * </ul>
+     * @see    Throwable#printStackTrace()
+     */
+    public String toString() {
+        return getClassName() + "." + methodName +
+            (isNativeMethod() ? "(Native Method)" :
+             (fileName != null && lineNumber >= 0 ?
+              "(" + fileName + ":" + lineNumber + ")" :
+              (fileName != null ?  "("+fileName+")" : "(Unknown Source)")));
+    }
+
+    /**
+     * Returns true if the specified object is another
+     * {@code StackTraceElement} instance representing the same execution
+     * point as this instance.  Two stack trace elements {@code a} and
+     * {@code b} are equal if and only if:
+     * <pre>{@code
+     *     equals(a.getFileName(), b.getFileName()) &&
+     *     a.getLineNumber() == b.getLineNumber()) &&
+     *     equals(a.getClassName(), b.getClassName()) &&
+     *     equals(a.getMethodName(), b.getMethodName())
+     * }</pre>
+     * where {@code equals} has the semantics of {@link
+     * java.util.Objects#equals(Object, Object) Objects.equals}.
+     *
+     * @param  obj the object to be compared with this stack trace element.
+     * @return true if the specified object is another
+     *         {@code StackTraceElement} instance representing the same
+     *         execution point as this instance.
+     */
+    public boolean equals(Object obj) {
+        if (obj==this)
+            return true;
+        if (!(obj instanceof StackTraceElement))
+            return false;
+        StackTraceElement e = (StackTraceElement)obj;
+        return e.declaringClass.equals(declaringClass) &&
+            e.lineNumber == lineNumber &&
+            Objects.equals(methodName, e.methodName) &&
+            Objects.equals(fileName, e.fileName);
+    }
+
+    /**
+     * Returns a hash code value for this stack trace element.
+     */
+    public int hashCode() {
+        int result = 31*declaringClass.hashCode() + methodName.hashCode();
+        result = 31*result + Objects.hashCode(fileName);
+        result = 31*result + lineNumber;
+        return result;
+    }
+
+    private static final long serialVersionUID = 6992337162326171013L;
+}

jdkSrc/jdk8/java/lang/StringBuffer.java

@@ -0,0 +1,725 @@
+/*
+ * Copyright (c) 1994, 2021, 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.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamField;
+import java.io.Serializable;
+import java.io.StreamCorruptedException;
+import java.util.Arrays;
+
+/**
+ * A thread-safe, mutable sequence of characters.
+ * A string buffer is like a {@link String}, but can be modified. At any
+ * point in time it contains some particular sequence of characters, but
+ * the length and content of the sequence can be changed through certain
+ * method calls.
+ * <p>
+ * String buffers are safe for use by multiple threads. The methods
+ * are synchronized where necessary so that all the operations on any
+ * particular instance behave as if they occur in some serial order
+ * that is consistent with the order of the method calls made by each of
+ * the individual threads involved.
+ * <p>
+ * The principal operations on a {@code StringBuffer} are the
+ * {@code append} and {@code insert} methods, which are
+ * overloaded so as to accept data of any type. Each effectively
+ * converts a given datum to a string and then appends or inserts the
+ * characters of that string to the string buffer. The
+ * {@code append} method always adds these characters at the end
+ * of the buffer; the {@code insert} method adds the characters at
+ * a specified point.
+ * <p>
+ * For example, if {@code z} refers to a string buffer object
+ * whose current contents are {@code "start"}, then
+ * the method call {@code z.append("le")} would cause the string
+ * buffer to contain {@code "startle"}, whereas
+ * {@code z.insert(4, "le")} would alter the string buffer to
+ * contain {@code "starlet"}.
+ * <p>
+ * In general, if sb refers to an instance of a {@code StringBuffer},
+ * then {@code sb.append(x)} has the same effect as
+ * {@code sb.insert(sb.length(), x)}.
+ * <p>
+ * Whenever an operation occurs involving a source sequence (such as
+ * appending or inserting from a source sequence), this class synchronizes
+ * only on the string buffer performing the operation, not on the source.
+ * Note that while {@code StringBuffer} is designed to be safe to use
+ * concurrently from multiple threads, if the constructor or the
+ * {@code append} or {@code insert} operation is passed a source sequence
+ * that is shared across threads, the calling code must ensure
+ * that the operation has a consistent and unchanging view of the source
+ * sequence for the duration of the operation.
+ * This could be satisfied by the caller holding a lock during the
+ * operation's call, by using an immutable source sequence, or by not
+ * sharing the source sequence across threads.
+ * <p>
+ * Every string buffer has a capacity. As long as the length of the
+ * character sequence contained in the string buffer does not exceed
+ * the capacity, it is not necessary to allocate a new internal
+ * buffer array. If the internal buffer overflows, it is
+ * automatically made larger.
+ * <p>
+ * Unless otherwise noted, passing a {@code null} argument to a constructor
+ * or method in this class will cause a {@link NullPointerException} to be
+ * thrown.
+ * <p>
+ * As of  release JDK 5, this class has been supplemented with an equivalent
+ * class designed for use by a single thread, {@link StringBuilder}.  The
+ * {@code StringBuilder} class should generally be used in preference to
+ * this one, as it supports all of the same operations but it is faster, as
+ * it performs no synchronization.
+ *
+ * @author      Arthur van Hoff
+ * @see     java.lang.StringBuilder
+ * @see     java.lang.String
+ * @since   JDK1.0
+ */
+ public final class StringBuffer
+    extends AbstractStringBuilder
+    implements Serializable, CharSequence
+{
+
+    /**
+     * A cache of the last value returned by toString. Cleared
+     * whenever the StringBuffer is modified.
+     */
+    private transient char[] toStringCache;
+
+    /** use serialVersionUID from JDK 1.0.2 for interoperability */
+    static final long serialVersionUID = 3388685877147921107L;
+
+    /**
+     * Constructs a string buffer with no characters in it and an
+     * initial capacity of 16 characters.
+     */
+    public StringBuffer() {
+        super(16);
+    }
+
+    /**
+     * Constructs a string buffer with no characters in it and
+     * the specified initial capacity.
+     *
+     * @param      capacity  the initial capacity.
+     * @exception  NegativeArraySizeException  if the {@code capacity}
+     *               argument is less than {@code 0}.
+     */
+    public StringBuffer(int capacity) {
+        super(capacity);
+    }
+
+    /**
+     * Constructs a string buffer initialized to the contents of the
+     * specified string. The initial capacity of the string buffer is
+     * {@code 16} plus the length of the string argument.
+     *
+     * @param   str   the initial contents of the buffer.
+     */
+    public StringBuffer(String str) {
+        super(str.length() + 16);
+        append(str);
+    }
+
+    /**
+     * Constructs a string buffer that contains the same characters
+     * as the specified {@code CharSequence}. The initial capacity of
+     * the string buffer is {@code 16} plus the length of the
+     * {@code CharSequence} argument.
+     * <p>
+     * If the length of the specified {@code CharSequence} is
+     * less than or equal to zero, then an empty buffer of capacity
+     * {@code 16} is returned.
+     *
+     * @param      seq   the sequence to copy.
+     * @since 1.5
+     */
+    public StringBuffer(CharSequence seq) {
+        this(seq.length() + 16);
+        append(seq);
+    }
+
+    @Override
+    public synchronized int length() {
+        return count;
+    }
+
+    @Override
+    public synchronized int capacity() {
+        return value.length;
+    }
+
+
+    @Override
+    public synchronized void ensureCapacity(int minimumCapacity) {
+        super.ensureCapacity(minimumCapacity);
+    }
+
+    /**
+     * @since      1.5
+     */
+    @Override
+    public synchronized void trimToSize() {
+        super.trimToSize();
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     * @see        #length()
+     */
+    @Override
+    public synchronized void setLength(int newLength) {
+        toStringCache = null;
+        super.setLength(newLength);
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     * @see        #length()
+     */
+    @Override
+    public synchronized char charAt(int index) {
+        if ((index < 0) || (index >= count))
+            throw new StringIndexOutOfBoundsException(index);
+        return value[index];
+    }
+
+    /**
+     * @since      1.5
+     */
+    @Override
+    public synchronized int codePointAt(int index) {
+        return super.codePointAt(index);
+    }
+
+    /**
+     * @since     1.5
+     */
+    @Override
+    public synchronized int codePointBefore(int index) {
+        return super.codePointBefore(index);
+    }
+
+    /**
+     * @since     1.5
+     */
+    @Override
+    public synchronized int codePointCount(int beginIndex, int endIndex) {
+        return super.codePointCount(beginIndex, endIndex);
+    }
+
+    /**
+     * @since     1.5
+     */
+    @Override
+    public synchronized int offsetByCodePoints(int index, int codePointOffset) {
+        return super.offsetByCodePoints(index, codePointOffset);
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,
+                                      int dstBegin)
+    {
+        super.getChars(srcBegin, srcEnd, dst, dstBegin);
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     * @see        #length()
+     */
+    @Override
+    public synchronized void setCharAt(int index, char ch) {
+        if ((index < 0) || (index >= count))
+            throw new StringIndexOutOfBoundsException(index);
+        toStringCache = null;
+        value[index] = ch;
+    }
+
+    @Override
+    public synchronized StringBuffer append(Object obj) {
+        toStringCache = null;
+        super.append(String.valueOf(obj));
+        return this;
+    }
+
+    @Override
+    public synchronized StringBuffer append(String str) {
+        toStringCache = null;
+        super.append(str);
+        return this;
+    }
+
+    /**
+     * Appends the specified {@code StringBuffer} to this sequence.
+     * <p>
+     * The characters of the {@code StringBuffer} argument are appended,
+     * in order, to the contents of this {@code StringBuffer}, increasing the
+     * length of this {@code StringBuffer} by the length of the argument.
+     * If {@code sb} is {@code null}, then the four characters
+     * {@code "null"} are appended to this {@code StringBuffer}.
+     * <p>
+     * Let <i>n</i> be the length of the old character sequence, the one
+     * contained in the {@code StringBuffer} just prior to execution of the
+     * {@code append} method. Then the character at index <i>k</i> in
+     * the new character sequence is equal to the character at index <i>k</i>
+     * in the old character sequence, if <i>k</i> is less than <i>n</i>;
+     * otherwise, it is equal to the character at index <i>k-n</i> in the
+     * argument {@code sb}.
+     * <p>
+     * This method synchronizes on {@code this}, the destination
+     * object, but does not synchronize on the source ({@code sb}).
+     *
+     * @param   sb   the {@code StringBuffer} to append.
+     * @return  a reference to this object.
+     * @since 1.4
+     */
+    public synchronized StringBuffer append(StringBuffer sb) {
+        toStringCache = null;
+        super.append(sb);
+        return this;
+    }
+
+    /**
+     * @since 1.8
+     */
+    @Override
+    synchronized StringBuffer append(AbstractStringBuilder asb) {
+        toStringCache = null;
+        super.append(asb);
+        return this;
+    }
+
+    /**
+     * Appends the specified {@code CharSequence} to this
+     * sequence.
+     * <p>
+     * The characters of the {@code CharSequence} argument are appended,
+     * in order, increasing the length of this sequence by the length of the
+     * argument.
+     *
+     * <p>The result of this method is exactly the same as if it were an
+     * invocation of this.append(s, 0, s.length());
+     *
+     * <p>This method synchronizes on {@code this}, the destination
+     * object, but does not synchronize on the source ({@code s}).
+     *
+     * <p>If {@code s} is {@code null}, then the four characters
+     * {@code "null"} are appended.
+     *
+     * @param   s the {@code CharSequence} to append.
+     * @return  a reference to this object.
+     * @since 1.5
+     */
+    @Override
+    public synchronized StringBuffer append(CharSequence s) {
+        toStringCache = null;
+        super.append(s);
+        return this;
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     * @since      1.5
+     */
+    @Override
+    public synchronized StringBuffer append(CharSequence s, int start, int end)
+    {
+        toStringCache = null;
+        super.append(s, start, end);
+        return this;
+    }
+
+    @Override
+    public synchronized StringBuffer append(char[] str) {
+        toStringCache = null;
+        super.append(str);
+        return this;
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public synchronized StringBuffer append(char[] str, int offset, int len) {
+        toStringCache = null;
+        super.append(str, offset, len);
+        return this;
+    }
+
+    @Override
+    public synchronized StringBuffer append(boolean b) {
+        toStringCache = null;
+        super.append(b);
+        return this;
+    }
+
+    @Override
+    public synchronized StringBuffer append(char c) {
+        toStringCache = null;
+        super.append(c);
+        return this;
+    }
+
+    @Override
+    public synchronized StringBuffer append(int i) {
+        toStringCache = null;
+        super.append(i);
+        return this;
+    }
+
+    /**
+     * @since 1.5
+     */
+    @Override
+    public synchronized StringBuffer appendCodePoint(int codePoint) {
+        toStringCache = null;
+        super.appendCodePoint(codePoint);
+        return this;
+    }
+
+    @Override
+    public synchronized StringBuffer append(long lng) {
+        toStringCache = null;
+        super.append(lng);
+        return this;
+    }
+
+    @Override
+    public synchronized StringBuffer append(float f) {
+        toStringCache = null;
+        super.append(f);
+        return this;
+    }
+
+    @Override
+    public synchronized StringBuffer append(double d) {
+        toStringCache = null;
+        super.append(d);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     * @since      1.2
+     */
+    @Override
+    public synchronized StringBuffer delete(int start, int end) {
+        toStringCache = null;
+        super.delete(start, end);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     * @since      1.2
+     */
+    @Override
+    public synchronized StringBuffer deleteCharAt(int index) {
+        toStringCache = null;
+        super.deleteCharAt(index);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     * @since      1.2
+     */
+    @Override
+    public synchronized StringBuffer replace(int start, int end, String str) {
+        toStringCache = null;
+        super.replace(start, end, str);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     * @since      1.2
+     */
+    @Override
+    public synchronized String substring(int start) {
+        return substring(start, count);
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     * @since      1.4
+     */
+    @Override
+    public synchronized CharSequence subSequence(int start, int end) {
+        return super.substring(start, end);
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     * @since      1.2
+     */
+    @Override
+    public synchronized String substring(int start, int end) {
+        return super.substring(start, end);
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     * @since      1.2
+     */
+    @Override
+    public synchronized StringBuffer insert(int index, char[] str, int offset,
+                                            int len)
+    {
+        toStringCache = null;
+        super.insert(index, str, offset, len);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public synchronized StringBuffer insert(int offset, Object obj) {
+        toStringCache = null;
+        super.insert(offset, String.valueOf(obj));
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public synchronized StringBuffer insert(int offset, String str) {
+        toStringCache = null;
+        super.insert(offset, str);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public synchronized StringBuffer insert(int offset, char[] str) {
+        toStringCache = null;
+        super.insert(offset, str);
+        return this;
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     * @since      1.5
+     */
+    @Override
+    public StringBuffer insert(int dstOffset, CharSequence s) {
+        // Note, synchronization achieved via invocations of other StringBuffer methods
+        // after narrowing of s to specific type
+        // Ditto for toStringCache clearing
+        super.insert(dstOffset, s);
+        return this;
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     * @since      1.5
+     */
+    @Override
+    public synchronized StringBuffer insert(int dstOffset, CharSequence s,
+            int start, int end)
+    {
+        toStringCache = null;
+        super.insert(dstOffset, s, start, end);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public  StringBuffer insert(int offset, boolean b) {
+        // Note, synchronization achieved via invocation of StringBuffer insert(int, String)
+        // after conversion of b to String by super class method
+        // Ditto for toStringCache clearing
+        super.insert(offset, b);
+        return this;
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public synchronized StringBuffer insert(int offset, char c) {
+        toStringCache = null;
+        super.insert(offset, c);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuffer insert(int offset, int i) {
+        // Note, synchronization achieved via invocation of StringBuffer insert(int, String)
+        // after conversion of i to String by super class method
+        // Ditto for toStringCache clearing
+        super.insert(offset, i);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuffer insert(int offset, long l) {
+        // Note, synchronization achieved via invocation of StringBuffer insert(int, String)
+        // after conversion of l to String by super class method
+        // Ditto for toStringCache clearing
+        super.insert(offset, l);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuffer insert(int offset, float f) {
+        // Note, synchronization achieved via invocation of StringBuffer insert(int, String)
+        // after conversion of f to String by super class method
+        // Ditto for toStringCache clearing
+        super.insert(offset, f);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuffer insert(int offset, double d) {
+        // Note, synchronization achieved via invocation of StringBuffer insert(int, String)
+        // after conversion of d to String by super class method
+        // Ditto for toStringCache clearing
+        super.insert(offset, d);
+        return this;
+    }
+
+    /**
+     * @since      1.4
+     */
+    @Override
+    public int indexOf(String str) {
+        // Note, synchronization achieved via invocations of other StringBuffer methods
+        return super.indexOf(str);
+    }
+
+    /**
+     * @since      1.4
+     */
+    @Override
+    public synchronized int indexOf(String str, int fromIndex) {
+        return super.indexOf(str, fromIndex);
+    }
+
+    /**
+     * @since      1.4
+     */
+    @Override
+    public int lastIndexOf(String str) {
+        // Note, synchronization achieved via invocations of other StringBuffer methods
+        return lastIndexOf(str, count);
+    }
+
+    /**
+     * @since      1.4
+     */
+    @Override
+    public synchronized int lastIndexOf(String str, int fromIndex) {
+        return super.lastIndexOf(str, fromIndex);
+    }
+
+    /**
+     * @since   JDK1.0.2
+     */
+    @Override
+    public synchronized StringBuffer reverse() {
+        toStringCache = null;
+        super.reverse();
+        return this;
+    }
+
+    @Override
+    public synchronized String toString() {
+        if (toStringCache == null) {
+            toStringCache = Arrays.copyOfRange(value, 0, count);
+        }
+        return new String(toStringCache, true);
+    }
+
+    /**
+     * Serializable fields for StringBuffer.
+     *
+     * @serialField value  char[]
+     *              The backing character array of this StringBuffer.
+     * @serialField count int
+     *              The number of characters in this StringBuffer.
+     * @serialField shared  boolean
+     *              A flag indicating whether the backing array is shared.
+     *              The value is ignored upon deserialization.
+     */
+    private static final ObjectStreamField[] serialPersistentFields =
+    {
+        new ObjectStreamField("value", char[].class),
+        new ObjectStreamField("count", Integer.TYPE),
+        new ObjectStreamField("shared", Boolean.TYPE),
+    };
+
+    /**
+     * The {@code writeObject} method is called to write the state of the
+     * {@code StringBuffer} to a stream.
+     */
+    private synchronized void writeObject(ObjectOutputStream s)
+        throws IOException {
+        ObjectOutputStream.PutField fields = s.putFields();
+        fields.put("value", value);
+        fields.put("count", count);
+        fields.put("shared", false);
+        s.writeFields();
+    }
+
+    /**
+     * The {@code readObject} method is called to restore the state of the
+     * {@code StringBuffer} from a stream.
+     */
+    private void readObject(ObjectInputStream s)
+        throws IOException, ClassNotFoundException {
+        ObjectInputStream.GetField fields = s.readFields();
+        value = (char[])fields.get("value", null);
+        int c = fields.get("count", 0);
+        if (c < 0 || c > value.length) {
+            throw new StreamCorruptedException("count value invalid");
+        }
+        count = c;
+    }
+}

jdkSrc/jdk8/java/lang/StringBuilder.java

@@ -0,0 +1,448 @@
+/*
+ * Copyright (c) 2003, 2021, 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.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.io.StreamCorruptedException;
+
+/**
+ * A mutable sequence of characters.  This class provides an API compatible
+ * with {@code StringBuffer}, but with no guarantee of synchronization.
+ * This class is designed for use as a drop-in replacement for
+ * {@code StringBuffer} in places where the string buffer was being
+ * used by a single thread (as is generally the case).   Where possible,
+ * it is recommended that this class be used in preference to
+ * {@code StringBuffer} as it will be faster under most implementations.
+ *
+ * <p>The principal operations on a {@code StringBuilder} are the
+ * {@code append} and {@code insert} methods, which are
+ * overloaded so as to accept data of any type. Each effectively
+ * converts a given datum to a string and then appends or inserts the
+ * characters of that string to the string builder. The
+ * {@code append} method always adds these characters at the end
+ * of the builder; the {@code insert} method adds the characters at
+ * a specified point.
+ * <p>
+ * For example, if {@code z} refers to a string builder object
+ * whose current contents are "{@code start}", then
+ * the method call {@code z.append("le")} would cause the string
+ * builder to contain "{@code startle}", whereas
+ * {@code z.insert(4, "le")} would alter the string builder to
+ * contain "{@code starlet}".
+ * <p>
+ * In general, if sb refers to an instance of a {@code StringBuilder},
+ * then {@code sb.append(x)} has the same effect as
+ * {@code sb.insert(sb.length(), x)}.
+ * <p>
+ * Every string builder has a capacity. As long as the length of the
+ * character sequence contained in the string builder does not exceed
+ * the capacity, it is not necessary to allocate a new internal
+ * buffer. If the internal buffer overflows, it is automatically made larger.
+ *
+ * <p>Instances of {@code StringBuilder} are not safe for
+ * use by multiple threads. If such synchronization is required then it is
+ * recommended that {@link java.lang.StringBuffer} be used.
+ *
+ * <p>Unless otherwise noted, passing a {@code null} argument to a constructor
+ * or method in this class will cause a {@link NullPointerException} to be
+ * thrown.
+ *
+ * @author      Michael McCloskey
+ * @see         java.lang.StringBuffer
+ * @see         java.lang.String
+ * @since       1.5
+ */
+public final class StringBuilder
+    extends AbstractStringBuilder
+    implements Serializable, CharSequence
+{
+
+    /** use serialVersionUID for interoperability */
+    static final long serialVersionUID = 4383685877147921099L;
+
+    /**
+     * Constructs a string builder with no characters in it and an
+     * initial capacity of 16 characters.
+     */
+    public StringBuilder() {
+        super(16);
+    }
+
+    /**
+     * Constructs a string builder with no characters in it and an
+     * initial capacity specified by the {@code capacity} argument.
+     *
+     * @param      capacity  the initial capacity.
+     * @throws     NegativeArraySizeException  if the {@code capacity}
+     *               argument is less than {@code 0}.
+     */
+    public StringBuilder(int capacity) {
+        super(capacity);
+    }
+
+    /**
+     * Constructs a string builder initialized to the contents of the
+     * specified string. The initial capacity of the string builder is
+     * {@code 16} plus the length of the string argument.
+     *
+     * @param   str   the initial contents of the buffer.
+     */
+    public StringBuilder(String str) {
+        super(str.length() + 16);
+        append(str);
+    }
+
+    /**
+     * Constructs a string builder that contains the same characters
+     * as the specified {@code CharSequence}. The initial capacity of
+     * the string builder is {@code 16} plus the length of the
+     * {@code CharSequence} argument.
+     *
+     * @param      seq   the sequence to copy.
+     */
+    public StringBuilder(CharSequence seq) {
+        this(seq.length() + 16);
+        append(seq);
+    }
+
+    @Override
+    public StringBuilder append(Object obj) {
+        return append(String.valueOf(obj));
+    }
+
+    @Override
+    public StringBuilder append(String str) {
+        super.append(str);
+        return this;
+    }
+
+    /**
+     * Appends the specified {@code StringBuffer} to this sequence.
+     * <p>
+     * The characters of the {@code StringBuffer} argument are appended,
+     * in order, to this sequence, increasing the
+     * length of this sequence by the length of the argument.
+     * If {@code sb} is {@code null}, then the four characters
+     * {@code "null"} are appended to this sequence.
+     * <p>
+     * Let <i>n</i> be the length of this character sequence just prior to
+     * execution of the {@code append} method. Then the character at index
+     * <i>k</i> in the new character sequence is equal to the character at
+     * index <i>k</i> in the old character sequence, if <i>k</i> is less than
+     * <i>n</i>; otherwise, it is equal to the character at index <i>k-n</i>
+     * in the argument {@code sb}.
+     *
+     * @param   sb   the {@code StringBuffer} to append.
+     * @return  a reference to this object.
+     */
+    public StringBuilder append(StringBuffer sb) {
+        super.append(sb);
+        return this;
+    }
+
+    @Override
+    public StringBuilder append(CharSequence s) {
+        super.append(s);
+        return this;
+    }
+
+    /**
+     * @throws     IndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder append(CharSequence s, int start, int end) {
+        super.append(s, start, end);
+        return this;
+    }
+
+    @Override
+    public StringBuilder append(char[] str) {
+        super.append(str);
+        return this;
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder append(char[] str, int offset, int len) {
+        super.append(str, offset, len);
+        return this;
+    }
+
+    @Override
+    public StringBuilder append(boolean b) {
+        super.append(b);
+        return this;
+    }
+
+    @Override
+    public StringBuilder append(char c) {
+        super.append(c);
+        return this;
+    }
+
+    @Override
+    public StringBuilder append(int i) {
+        super.append(i);
+        return this;
+    }
+
+    @Override
+    public StringBuilder append(long lng) {
+        super.append(lng);
+        return this;
+    }
+
+    @Override
+    public StringBuilder append(float f) {
+        super.append(f);
+        return this;
+    }
+
+    @Override
+    public StringBuilder append(double d) {
+        super.append(d);
+        return this;
+    }
+
+    /**
+     * @since 1.5
+     */
+    @Override
+    public StringBuilder appendCodePoint(int codePoint) {
+        super.appendCodePoint(codePoint);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder delete(int start, int end) {
+        super.delete(start, end);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder deleteCharAt(int index) {
+        super.deleteCharAt(index);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder replace(int start, int end, String str) {
+        super.replace(start, end, str);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int index, char[] str, int offset,
+                                int len)
+    {
+        super.insert(index, str, offset, len);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int offset, Object obj) {
+            super.insert(offset, obj);
+            return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int offset, String str) {
+        super.insert(offset, str);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int offset, char[] str) {
+        super.insert(offset, str);
+        return this;
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int dstOffset, CharSequence s) {
+            super.insert(dstOffset, s);
+            return this;
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int dstOffset, CharSequence s,
+                                int start, int end)
+    {
+        super.insert(dstOffset, s, start, end);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int offset, boolean b) {
+        super.insert(offset, b);
+        return this;
+    }
+
+    /**
+     * @throws IndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int offset, char c) {
+        super.insert(offset, c);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int offset, int i) {
+        super.insert(offset, i);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int offset, long l) {
+        super.insert(offset, l);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int offset, float f) {
+        super.insert(offset, f);
+        return this;
+    }
+
+    /**
+     * @throws StringIndexOutOfBoundsException {@inheritDoc}
+     */
+    @Override
+    public StringBuilder insert(int offset, double d) {
+        super.insert(offset, d);
+        return this;
+    }
+
+    @Override
+    public int indexOf(String str) {
+        return super.indexOf(str);
+    }
+
+    @Override
+    public int indexOf(String str, int fromIndex) {
+        return super.indexOf(str, fromIndex);
+    }
+
+    @Override
+    public int lastIndexOf(String str) {
+        return super.lastIndexOf(str);
+    }
+
+    @Override
+    public int lastIndexOf(String str, int fromIndex) {
+        return super.lastIndexOf(str, fromIndex);
+    }
+
+    @Override
+    public StringBuilder reverse() {
+        super.reverse();
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        // Create a copy, don't share the array
+        return new String(value, 0, count);
+    }
+
+    /**
+     * Save the state of the {@code StringBuilder} instance to a stream
+     * (that is, serialize it).
+     *
+     * @serialData the number of characters currently stored in the string
+     *             builder ({@code int}), followed by the characters in the
+     *             string builder ({@code char[]}).   The length of the
+     *             {@code char} array may be greater than the number of
+     *             characters currently stored in the string builder, in which
+     *             case extra characters are ignored.
+     */
+    private void writeObject(ObjectOutputStream s)
+        throws IOException {
+        s.defaultWriteObject();
+        s.writeInt(count);
+        s.writeObject(value);
+    }
+
+    /**
+     * readObject is called to restore the state of the StringBuilder from
+     * a stream.
+     */
+    private void readObject(ObjectInputStream s)
+        throws IOException, ClassNotFoundException {
+        s.defaultReadObject();
+        int c = s.readInt();
+        value = (char[]) s.readObject();
+        if (c < 0 || c > value.length) {
+            throw new StreamCorruptedException("count value invalid");
+        }
+        count = c;
+    }
+
+}

jdkSrc/jdk8/java/lang/StringCoding.java

@@ -0,0 +1,404 @@
+/*
+ * Copyright (c) 2000, 2012, 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.UnsupportedEncodingException;
+import java.lang.ref.SoftReference;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.CoderResult;
+import java.nio.charset.CodingErrorAction;
+import java.nio.charset.IllegalCharsetNameException;
+import java.nio.charset.UnsupportedCharsetException;
+import java.util.Arrays;
+import sun.misc.MessageUtils;
+import sun.nio.cs.HistoricallyNamedCharset;
+import sun.nio.cs.ArrayDecoder;
+import sun.nio.cs.ArrayEncoder;
+
+/**
+ * Utility class for string encoding and decoding.
+ */
+
+class StringCoding {
+
+    private StringCoding() { }
+
+    /** The cached coders for each thread */
+    private final static ThreadLocal<SoftReference<StringDecoder>> decoder =
+        new ThreadLocal<>();
+    private final static ThreadLocal<SoftReference<StringEncoder>> encoder =
+        new ThreadLocal<>();
+
+    private static boolean warnUnsupportedCharset = true;
+
+    private static <T> T deref(ThreadLocal<SoftReference<T>> tl) {
+        SoftReference<T> sr = tl.get();
+        if (sr == null)
+            return null;
+        return sr.get();
+    }
+
+    private static <T> void set(ThreadLocal<SoftReference<T>> tl, T ob) {
+        tl.set(new SoftReference<T>(ob));
+    }
+
+    // Trim the given byte array to the given length
+    //
+    private static byte[] safeTrim(byte[] ba, int len, Charset cs, boolean isTrusted) {
+        if (len == ba.length && (isTrusted || System.getSecurityManager() == null))
+            return ba;
+        else
+            return Arrays.copyOf(ba, len);
+    }
+
+    // Trim the given char array to the given length
+    //
+    private static char[] safeTrim(char[] ca, int len,
+                                   Charset cs, boolean isTrusted) {
+        if (len == ca.length && (isTrusted || System.getSecurityManager() == null))
+            return ca;
+        else
+            return Arrays.copyOf(ca, len);
+    }
+
+    private static int scale(int len, float expansionFactor) {
+        // We need to perform double, not float, arithmetic; otherwise
+        // we lose low order bits when len is larger than 2**24.
+        return (int)(len * (double)expansionFactor);
+    }
+
+    private static Charset lookupCharset(String csn) {
+        if (Charset.isSupported(csn)) {
+            try {
+                return Charset.forName(csn);
+            } catch (UnsupportedCharsetException x) {
+                throw new Error(x);
+            }
+        }
+        return null;
+    }
+
+    private static void warnUnsupportedCharset(String csn) {
+        if (warnUnsupportedCharset) {
+            // Use sun.misc.MessageUtils rather than the Logging API or
+            // System.err since this method may be called during VM
+            // initialization before either is available.
+            MessageUtils.err("WARNING: Default charset " + csn +
+                             " not supported, using ISO-8859-1 instead");
+            warnUnsupportedCharset = false;
+        }
+    }
+
+
+    // -- Decoding --
+    private static class StringDecoder {
+        private final String requestedCharsetName;
+        private final Charset cs;
+        private final CharsetDecoder cd;
+        private final boolean isTrusted;
+
+        private StringDecoder(Charset cs, String rcn) {
+            this.requestedCharsetName = rcn;
+            this.cs = cs;
+            this.cd = cs.newDecoder()
+                .onMalformedInput(CodingErrorAction.REPLACE)
+                .onUnmappableCharacter(CodingErrorAction.REPLACE);
+            this.isTrusted = (cs.getClass().getClassLoader0() == null);
+        }
+
+        String charsetName() {
+            if (cs instanceof HistoricallyNamedCharset)
+                return ((HistoricallyNamedCharset)cs).historicalName();
+            return cs.name();
+        }
+
+        final String requestedCharsetName() {
+            return requestedCharsetName;
+        }
+
+        char[] decode(byte[] ba, int off, int len) {
+            int en = scale(len, cd.maxCharsPerByte());
+            char[] ca = new char[en];
+            if (len == 0)
+                return ca;
+            if (cd instanceof ArrayDecoder) {
+                int clen = ((ArrayDecoder)cd).decode(ba, off, len, ca);
+                return safeTrim(ca, clen, cs, isTrusted);
+            } else {
+                cd.reset();
+                ByteBuffer bb = ByteBuffer.wrap(ba, off, len);
+                CharBuffer cb = CharBuffer.wrap(ca);
+                try {
+                    CoderResult cr = cd.decode(bb, cb, true);
+                    if (!cr.isUnderflow())
+                        cr.throwException();
+                    cr = cd.flush(cb);
+                    if (!cr.isUnderflow())
+                        cr.throwException();
+                } catch (CharacterCodingException x) {
+                    // Substitution is always enabled,
+                    // so this shouldn't happen
+                    throw new Error(x);
+                }
+                return safeTrim(ca, cb.position(), cs, isTrusted);
+            }
+        }
+    }
+
+    static char[] decode(String charsetName, byte[] ba, int off, int len)
+        throws UnsupportedEncodingException
+    {
+        StringDecoder sd = deref(decoder);
+        String csn = (charsetName == null) ? "ISO-8859-1" : charsetName;
+        if ((sd == null) || !(csn.equals(sd.requestedCharsetName())
+                              || csn.equals(sd.charsetName()))) {
+            sd = null;
+            try {
+                Charset cs = lookupCharset(csn);
+                if (cs != null)
+                    sd = new StringDecoder(cs, csn);
+            } catch (IllegalCharsetNameException x) {}
+            if (sd == null)
+                throw new UnsupportedEncodingException(csn);
+            set(decoder, sd);
+        }
+        return sd.decode(ba, off, len);
+    }
+
+    static char[] decode(Charset cs, byte[] ba, int off, int len) {
+        // (1)We never cache the "external" cs, the only benefit of creating
+        // an additional StringDe/Encoder object to wrap it is to share the
+        // de/encode() method. These SD/E objects are short-lifed, the young-gen
+        // gc should be able to take care of them well. But the best approash
+        // is still not to generate them if not really necessary.
+        // (2)The defensive copy of the input byte/char[] has a big performance
+        // impact, as well as the outgoing result byte/char[]. Need to do the
+        // optimization check of (sm==null && classLoader0==null) for both.
+        // (3)getClass().getClassLoader0() is expensive
+        // (4)There might be a timing gap in isTrusted setting. getClassLoader0()
+        // is only chcked (and then isTrusted gets set) when (SM==null). It is
+        // possible that the SM==null for now but then SM is NOT null later
+        // when safeTrim() is invoked...the "safe" way to do is to redundant
+        // check (... && (isTrusted || SM == null || getClassLoader0())) in trim
+        // but it then can be argued that the SM is null when the opertaion
+        // is started...
+        CharsetDecoder cd = cs.newDecoder();
+        int en = scale(len, cd.maxCharsPerByte());
+        char[] ca = new char[en];
+        if (len == 0)
+            return ca;
+        boolean isTrusted = false;
+        if (System.getSecurityManager() != null) {
+            if (!(isTrusted = (cs.getClass().getClassLoader0() == null))) {
+                ba =  Arrays.copyOfRange(ba, off, off + len);
+                off = 0;
+            }
+        }
+        cd.onMalformedInput(CodingErrorAction.REPLACE)
+          .onUnmappableCharacter(CodingErrorAction.REPLACE)
+          .reset();
+        if (cd instanceof ArrayDecoder) {
+            int clen = ((ArrayDecoder)cd).decode(ba, off, len, ca);
+            return safeTrim(ca, clen, cs, isTrusted);
+        } else {
+            ByteBuffer bb = ByteBuffer.wrap(ba, off, len);
+            CharBuffer cb = CharBuffer.wrap(ca);
+            try {
+                CoderResult cr = cd.decode(bb, cb, true);
+                if (!cr.isUnderflow())
+                    cr.throwException();
+                cr = cd.flush(cb);
+                if (!cr.isUnderflow())
+                    cr.throwException();
+            } catch (CharacterCodingException x) {
+                // Substitution is always enabled,
+                // so this shouldn't happen
+                throw new Error(x);
+            }
+            return safeTrim(ca, cb.position(), cs, isTrusted);
+        }
+    }
+
+    static char[] decode(byte[] ba, int off, int len) {
+        String csn = Charset.defaultCharset().name();
+        try {
+            // use charset name decode() variant which provides caching.
+            return decode(csn, ba, off, len);
+        } catch (UnsupportedEncodingException x) {
+            warnUnsupportedCharset(csn);
+        }
+        try {
+            return decode("ISO-8859-1", ba, off, len);
+        } catch (UnsupportedEncodingException x) {
+            // If this code is hit during VM initialization, MessageUtils is
+            // the only way we will be able to get any kind of error message.
+            MessageUtils.err("ISO-8859-1 charset not available: "
+                             + x.toString());
+            // If we can not find ISO-8859-1 (a required encoding) then things
+            // are seriously wrong with the installation.
+            System.exit(1);
+            return null;
+        }
+    }
+
+    // -- Encoding --
+    private static class StringEncoder {
+        private Charset cs;
+        private CharsetEncoder ce;
+        private final String requestedCharsetName;
+        private final boolean isTrusted;
+
+        private StringEncoder(Charset cs, String rcn) {
+            this.requestedCharsetName = rcn;
+            this.cs = cs;
+            this.ce = cs.newEncoder()
+                .onMalformedInput(CodingErrorAction.REPLACE)
+                .onUnmappableCharacter(CodingErrorAction.REPLACE);
+            this.isTrusted = (cs.getClass().getClassLoader0() == null);
+        }
+
+        String charsetName() {
+            if (cs instanceof HistoricallyNamedCharset)
+                return ((HistoricallyNamedCharset)cs).historicalName();
+            return cs.name();
+        }
+
+        final String requestedCharsetName() {
+            return requestedCharsetName;
+        }
+
+        byte[] encode(char[] ca, int off, int len) {
+            int en = scale(len, ce.maxBytesPerChar());
+            byte[] ba = new byte[en];
+            if (len == 0)
+                return ba;
+            if (ce instanceof ArrayEncoder) {
+                int blen = ((ArrayEncoder)ce).encode(ca, off, len, ba);
+                return safeTrim(ba, blen, cs, isTrusted);
+            } else {
+                ce.reset();
+                ByteBuffer bb = ByteBuffer.wrap(ba);
+                CharBuffer cb = CharBuffer.wrap(ca, off, len);
+                try {
+                    CoderResult cr = ce.encode(cb, bb, true);
+                    if (!cr.isUnderflow())
+                        cr.throwException();
+                    cr = ce.flush(bb);
+                    if (!cr.isUnderflow())
+                        cr.throwException();
+                } catch (CharacterCodingException x) {
+                    // Substitution is always enabled,
+                    // so this shouldn't happen
+                    throw new Error(x);
+                }
+                return safeTrim(ba, bb.position(), cs, isTrusted);
+            }
+        }
+    }
+
+    static byte[] encode(String charsetName, char[] ca, int off, int len)
+        throws UnsupportedEncodingException
+    {
+        StringEncoder se = deref(encoder);
+        String csn = (charsetName == null) ? "ISO-8859-1" : charsetName;
+        if ((se == null) || !(csn.equals(se.requestedCharsetName())
+                              || csn.equals(se.charsetName()))) {
+            se = null;
+            try {
+                Charset cs = lookupCharset(csn);
+                if (cs != null)
+                    se = new StringEncoder(cs, csn);
+            } catch (IllegalCharsetNameException x) {}
+            if (se == null)
+                throw new UnsupportedEncodingException (csn);
+            set(encoder, se);
+        }
+        return se.encode(ca, off, len);
+    }
+
+    static byte[] encode(Charset cs, char[] ca, int off, int len) {
+        CharsetEncoder ce = cs.newEncoder();
+        int en = scale(len, ce.maxBytesPerChar());
+        byte[] ba = new byte[en];
+        if (len == 0)
+            return ba;
+        boolean isTrusted = false;
+        if (System.getSecurityManager() != null) {
+            if (!(isTrusted = (cs.getClass().getClassLoader0() == null))) {
+                ca =  Arrays.copyOfRange(ca, off, off + len);
+                off = 0;
+            }
+        }
+        ce.onMalformedInput(CodingErrorAction.REPLACE)
+          .onUnmappableCharacter(CodingErrorAction.REPLACE)
+          .reset();
+        if (ce instanceof ArrayEncoder) {
+            int blen = ((ArrayEncoder)ce).encode(ca, off, len, ba);
+            return safeTrim(ba, blen, cs, isTrusted);
+        } else {
+            ByteBuffer bb = ByteBuffer.wrap(ba);
+            CharBuffer cb = CharBuffer.wrap(ca, off, len);
+            try {
+                CoderResult cr = ce.encode(cb, bb, true);
+                if (!cr.isUnderflow())
+                    cr.throwException();
+                cr = ce.flush(bb);
+                if (!cr.isUnderflow())
+                    cr.throwException();
+            } catch (CharacterCodingException x) {
+                throw new Error(x);
+            }
+            return safeTrim(ba, bb.position(), cs, isTrusted);
+        }
+    }
+
+    static byte[] encode(char[] ca, int off, int len) {
+        String csn = Charset.defaultCharset().name();
+        try {
+            // use charset name encode() variant which provides caching.
+            return encode(csn, ca, off, len);
+        } catch (UnsupportedEncodingException x) {
+            warnUnsupportedCharset(csn);
+        }
+        try {
+            return encode("ISO-8859-1", ca, off, len);
+        } catch (UnsupportedEncodingException x) {
+            // If this code is hit during VM initialization, MessageUtils is
+            // the only way we will be able to get any kind of error message.
+            MessageUtils.err("ISO-8859-1 charset not available: "
+                             + x.toString());
+            // If we can not find ISO-8859-1 (a required encoding) then things
+            // are seriously wrong with the installation.
+            System.exit(1);
+            return null;
+        }
+    }
+}

jdkSrc/jdk8/java/lang/StringIndexOutOfBoundsException.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 1994, 2012, 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;
+
+/**
+ * Thrown by {@code String} methods to indicate that an index
+ * is either negative or greater than the size of the string.  For
+ * some methods such as the charAt method, this exception also is
+ * thrown when the index is equal to the size of the string.
+ *
+ * @author  unascribed
+ * @see     java.lang.String#charAt(int)
+ * @since   JDK1.0
+ */
+public
+class StringIndexOutOfBoundsException extends IndexOutOfBoundsException {
+    private static final long serialVersionUID = -6762910422159637258L;
+
+    /**
+     * Constructs a {@code StringIndexOutOfBoundsException} with no
+     * detail message.
+     *
+     * @since   JDK1.0.
+     */
+    public StringIndexOutOfBoundsException() {
+        super();
+    }
+
+    /**
+     * Constructs a {@code StringIndexOutOfBoundsException} with
+     * the specified detail message.
+     *
+     * @param   s   the detail message.
+     */
+    public StringIndexOutOfBoundsException(String s) {
+        super(s);
+    }
+
+    /**
+     * Constructs a new {@code StringIndexOutOfBoundsException}
+     * class with an argument indicating the illegal index.
+     *
+     * @param   index   the illegal index.
+     */
+    public StringIndexOutOfBoundsException(int index) {
+        super("String index out of range: " + index);
+    }
+}