# HG changeset patch
# User Jaroslav Tulach <jaroslav.tulach@apidesign.org>
# Date 1348894025 -7200
# Node ID d7a291b7808d00e57709e3359122127590e09ad1
# Parent  94c1a17117f3b37dbbfdb88b08a28f6873a95a4a
3rd batch of classes

diff -r 94c1a17117f3 -r d7a291b7808d emul/src/main/java/java/io/IOException.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/emul/src/main/java/java/io/IOException.java	Sat Sep 29 06:47:05 2012 +0200
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 1994, 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.io;
+
+/**
+ * Signals that an I/O exception of some sort has occurred. This
+ * class is the general class of exceptions produced by failed or
+ * interrupted I/O operations.
+ *
+ * @author  unascribed
+ * @see     java.io.InputStream
+ * @see     java.io.OutputStream
+ * @since   JDK1.0
+ */
+public
+class IOException extends Exception {
+    static final long serialVersionUID = 7818375828146090155L;
+
+    /**
+     * Constructs an {@code IOException} with {@code null}
+     * as its error detail message.
+     */
+    public IOException() {
+        super();
+    }
+
+    /**
+     * Constructs an {@code IOException} with the specified detail message.
+     *
+     * @param message
+     *        The detail message (which is saved for later retrieval
+     *        by the {@link #getMessage()} method)
+     */
+    public IOException(String message) {
+        super(message);
+    }
+
+    /**
+     * Constructs an {@code IOException} with the specified detail message
+     * and cause.
+     *
+     * <p> Note that the detail message associated with {@code cause} is
+     * <i>not</i> automatically incorporated into 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 null value is permitted,
+     *        and indicates that the cause is nonexistent or unknown.)
+     *
+     * @since 1.6
+     */
+    public IOException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs an {@code IOException} 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 IO 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 null value is permitted,
+     *        and indicates that the cause is nonexistent or unknown.)
+     *
+     * @since 1.6
+     */
+    public IOException(Throwable cause) {
+        super(cause);
+    }
+}
diff -r 94c1a17117f3 -r d7a291b7808d emul/src/main/java/java/io/ObjectStreamField.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/emul/src/main/java/java/io/ObjectStreamField.java	Sat Sep 29 06:47:05 2012 +0200
@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) 1996, 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.io;
+
+import java.lang.reflect.Field;
+
+/**
+ * A description of a Serializable field from a Serializable class.  An array
+ * of ObjectStreamFields is used to declare the Serializable fields of a class.
+ *
+ * @author      Mike Warres
+ * @author      Roger Riggs
+ * @see ObjectStreamClass
+ * @since 1.2
+ */
+public class ObjectStreamField
+    implements Comparable<Object>
+{
+
+    /** field name */
+    private final String name;
+    /** canonical JVM signature of field type */
+    private final String signature;
+    /** field type (Object.class if unknown non-primitive type) */
+    private final Class<?> type;
+    /** whether or not to (de)serialize field values as unshared */
+    private final boolean unshared;
+    /** corresponding reflective field object, if any */
+    private final Field field;
+    /** offset of field value in enclosing field group */
+    private int offset = 0;
+
+    /**
+     * Create a Serializable field with the specified type.  This field should
+     * be documented with a <code>serialField</code> tag.
+     *
+     * @param   name the name of the serializable field
+     * @param   type the <code>Class</code> object of the serializable field
+     */
+    public ObjectStreamField(String name, Class<?> type) {
+        this(name, type, false);
+    }
+
+    /**
+     * Creates an ObjectStreamField representing a serializable field with the
+     * given name and type.  If unshared is false, values of the represented
+     * field are serialized and deserialized in the default manner--if the
+     * field is non-primitive, object values are serialized and deserialized as
+     * if they had been written and read by calls to writeObject and
+     * readObject.  If unshared is true, values of the represented field are
+     * serialized and deserialized as if they had been written and read by
+     * calls to writeUnshared and readUnshared.
+     *
+     * @param   name field name
+     * @param   type field type
+     * @param   unshared if false, write/read field values in the same manner
+     *          as writeObject/readObject; if true, write/read in the same
+     *          manner as writeUnshared/readUnshared
+     * @since   1.4
+     */
+    public ObjectStreamField(String name, Class<?> type, boolean unshared) {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        this.name = name;
+        this.type = type;
+        this.unshared = unshared;
+        signature = getClassSignature(type).intern();
+        field = null;
+    }
+
+    /**
+     * Creates an ObjectStreamField representing a field with the given name,
+     * signature and unshared setting.
+     */
+    ObjectStreamField(String name, String signature, boolean unshared) {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        this.name = name;
+        this.signature = signature.intern();
+        this.unshared = unshared;
+        field = null;
+
+        switch (signature.charAt(0)) {
+            case 'Z': type = Boolean.TYPE; break;
+            case 'B': type = Byte.TYPE; break;
+            case 'C': type = Character.TYPE; break;
+            case 'S': type = Short.TYPE; break;
+            case 'I': type = Integer.TYPE; break;
+            case 'J': type = Long.TYPE; break;
+            case 'F': type = Float.TYPE; break;
+            case 'D': type = Double.TYPE; break;
+            case 'L':
+            case '[': type = Object.class; break;
+            default: throw new IllegalArgumentException("illegal signature");
+        }
+    }
+
+    /**
+     * Creates an ObjectStreamField representing the given field with the
+     * specified unshared setting.  For compatibility with the behavior of
+     * earlier serialization implementations, a "showType" parameter is
+     * necessary to govern whether or not a getType() call on this
+     * ObjectStreamField (if non-primitive) will return Object.class (as
+     * opposed to a more specific reference type).
+     */
+    ObjectStreamField(Field field, boolean unshared, boolean showType) {
+        this.field = field;
+        this.unshared = unshared;
+        name = field.getName();
+        Class<?> ftype = field.getType();
+        type = (showType || ftype.isPrimitive()) ? ftype : Object.class;
+        signature = getClassSignature(ftype).intern();
+    }
+
+    /**
+     * Get the name of this field.
+     *
+     * @return  a <code>String</code> representing the name of the serializable
+     *          field
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Get the type of the field.  If the type is non-primitive and this
+     * <code>ObjectStreamField</code> was obtained from a deserialized {@link
+     * ObjectStreamClass} instance, then <code>Object.class</code> is returned.
+     * Otherwise, the <code>Class</code> object for the type of the field is
+     * returned.
+     *
+     * @return  a <code>Class</code> object representing the type of the
+     *          serializable field
+     */
+    public Class<?> getType() {
+        return type;
+    }
+
+    /**
+     * Returns character encoding of field type.  The encoding is as follows:
+     * <blockquote><pre>
+     * B            byte
+     * C            char
+     * D            double
+     * F            float
+     * I            int
+     * J            long
+     * L            class or interface
+     * S            short
+     * Z            boolean
+     * [            array
+     * </pre></blockquote>
+     *
+     * @return  the typecode of the serializable field
+     */
+    // REMIND: deprecate?
+    public char getTypeCode() {
+        return signature.charAt(0);
+    }
+
+    /**
+     * Return the JVM type signature.
+     *
+     * @return  null if this field has a primitive type.
+     */
+    // REMIND: deprecate?
+    public String getTypeString() {
+        return isPrimitive() ? null : signature;
+    }
+
+    /**
+     * Offset of field within instance data.
+     *
+     * @return  the offset of this field
+     * @see #setOffset
+     */
+    // REMIND: deprecate?
+    public int getOffset() {
+        return offset;
+    }
+
+    /**
+     * Offset within instance data.
+     *
+     * @param   offset the offset of the field
+     * @see #getOffset
+     */
+    // REMIND: deprecate?
+    protected void setOffset(int offset) {
+        this.offset = offset;
+    }
+
+    /**
+     * Return true if this field has a primitive type.
+     *
+     * @return  true if and only if this field corresponds to a primitive type
+     */
+    // REMIND: deprecate?
+    public boolean isPrimitive() {
+        char tcode = signature.charAt(0);
+        return ((tcode != 'L') && (tcode != '['));
+    }
+
+    /**
+     * Returns boolean value indicating whether or not the serializable field
+     * represented by this ObjectStreamField instance is unshared.
+     *
+     * @since 1.4
+     */
+    public boolean isUnshared() {
+        return unshared;
+    }
+
+    /**
+     * Compare this field with another <code>ObjectStreamField</code>.  Return
+     * -1 if this is smaller, 0 if equal, 1 if greater.  Types that are
+     * primitives are "smaller" than object types.  If equal, the field names
+     * are compared.
+     */
+    // REMIND: deprecate?
+    public int compareTo(Object obj) {
+        ObjectStreamField other = (ObjectStreamField) obj;
+        boolean isPrim = isPrimitive();
+        if (isPrim != other.isPrimitive()) {
+            return isPrim ? -1 : 1;
+        }
+        return name.compareTo(other.name);
+    }
+
+    /**
+     * Return a string that describes this field.
+     */
+    public String toString() {
+        return signature + ' ' + name;
+    }
+
+    /**
+     * Returns field represented by this ObjectStreamField, or null if
+     * ObjectStreamField is not associated with an actual field.
+     */
+    Field getField() {
+        return field;
+    }
+
+    /**
+     * Returns JVM type signature of field (similar to getTypeString, except
+     * that signature strings are returned for primitive fields as well).
+     */
+    String getSignature() {
+        return signature;
+    }
+
+    /**
+     * Returns JVM type signature for given class.
+     */
+    private static String getClassSignature(Class<?> cl) {
+        StringBuilder sbuf = new StringBuilder();
+        while (cl.isArray()) {
+            sbuf.append('[');
+            cl = cl.getComponentType();
+        }
+        if (cl.isPrimitive()) {
+            if (cl == Integer.TYPE) {
+                sbuf.append('I');
+            } else if (cl == Byte.TYPE) {
+                sbuf.append('B');
+            } else if (cl == Long.TYPE) {
+                sbuf.append('J');
+            } else if (cl == Float.TYPE) {
+                sbuf.append('F');
+            } else if (cl == Double.TYPE) {
+                sbuf.append('D');
+            } else if (cl == Short.TYPE) {
+                sbuf.append('S');
+            } else if (cl == Character.TYPE) {
+                sbuf.append('C');
+            } else if (cl == Boolean.TYPE) {
+                sbuf.append('Z');
+            } else if (cl == Void.TYPE) {
+                sbuf.append('V');
+            } else {
+                throw new InternalError();
+            }
+        } else {
+            sbuf.append('L' + cl.getName().replace('.', '/') + ';');
+        }
+        return sbuf.toString();
+    }
+}
diff -r 94c1a17117f3 -r d7a291b7808d emul/src/main/java/java/io/Serializable.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/emul/src/main/java/java/io/Serializable.java	Sat Sep 29 06:47:05 2012 +0200
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 1996, 2005, 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.io;
+
+/**
+ * Serializability of a class is enabled by the class implementing the
+ * java.io.Serializable interface. Classes that do not implement this
+ * interface will not have any of their state serialized or
+ * deserialized.  All subtypes of a serializable class are themselves
+ * serializable.  The serialization interface has no methods or fields
+ * and serves only to identify the semantics of being serializable. <p>
+ *
+ * To allow subtypes of non-serializable classes to be serialized, the
+ * subtype may assume responsibility for saving and restoring the
+ * state of the supertype's public, protected, and (if accessible)
+ * package fields.  The subtype may assume this responsibility only if
+ * the class it extends has an accessible no-arg constructor to
+ * initialize the class's state.  It is an error to declare a class
+ * Serializable if this is not the case.  The error will be detected at
+ * runtime. <p>
+ *
+ * During deserialization, the fields of non-serializable classes will
+ * be initialized using the public or protected no-arg constructor of
+ * the class.  A no-arg constructor must be accessible to the subclass
+ * that is serializable.  The fields of serializable subclasses will
+ * be restored from the stream. <p>
+ *
+ * When traversing a graph, an object may be encountered that does not
+ * support the Serializable interface. In this case the
+ * NotSerializableException will be thrown and will identify the class
+ * of the non-serializable object. <p>
+ *
+ * Classes that require special handling during the serialization and
+ * deserialization process must implement special methods with these exact
+ * signatures: <p>
+ *
+ * <PRE>
+ * private void writeObject(java.io.ObjectOutputStream out)
+ *     throws IOException
+ * private void readObject(java.io.ObjectInputStream in)
+ *     throws IOException, ClassNotFoundException;
+ * private void readObjectNoData()
+ *     throws ObjectStreamException;
+ * </PRE>
+ *
+ * <p>The writeObject method is responsible for writing the state of the
+ * object for its particular class so that the corresponding
+ * readObject method can restore it.  The default mechanism for saving
+ * the Object's fields can be invoked by calling
+ * out.defaultWriteObject. The method does not need to concern
+ * itself with the state belonging to its superclasses or subclasses.
+ * State is saved by writing the individual fields to the
+ * ObjectOutputStream using the writeObject method or by using the
+ * methods for primitive data types supported by DataOutput.
+ *
+ * <p>The readObject method is responsible for reading from the stream and
+ * restoring the classes fields. It may call in.defaultReadObject to invoke
+ * the default mechanism for restoring the object's non-static and
+ * non-transient fields.  The defaultReadObject method uses information in
+ * the stream to assign the fields of the object saved in the stream with the
+ * correspondingly named fields in the current object.  This handles the case
+ * when the class has evolved to add new fields. The method does not need to
+ * concern itself with the state belonging to its superclasses or subclasses.
+ * State is saved by writing the individual fields to the
+ * ObjectOutputStream using the writeObject method or by using the
+ * methods for primitive data types supported by DataOutput.
+ *
+ * <p>The readObjectNoData method is responsible for initializing the state of
+ * the object for its particular class in the event that the serialization
+ * stream does not list the given class as a superclass of the object being
+ * deserialized.  This may occur in cases where the receiving party uses a
+ * different version of the deserialized instance's class than the sending
+ * party, and the receiver's version extends classes that are not extended by
+ * the sender's version.  This may also occur if the serialization stream has
+ * been tampered; hence, readObjectNoData is useful for initializing
+ * deserialized objects properly despite a "hostile" or incomplete source
+ * stream.
+ *
+ * <p>Serializable classes that need to designate an alternative object to be
+ * used when writing an object to the stream should implement this
+ * special method with the exact signature: <p>
+ *
+ * <PRE>
+ * ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
+ * </PRE><p>
+ *
+ * This writeReplace method is invoked by serialization if the method
+ * exists and it would be accessible from a method defined within the
+ * class of the object being serialized. Thus, the method can have private,
+ * protected and package-private access. Subclass access to this method
+ * follows java accessibility rules. <p>
+ *
+ * Classes that need to designate a replacement when an instance of it
+ * is read from the stream should implement this special method with the
+ * exact signature.<p>
+ *
+ * <PRE>
+ * ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;
+ * </PRE><p>
+ *
+ * This readResolve method follows the same invocation rules and
+ * accessibility rules as writeReplace.<p>
+ *
+ * The serialization runtime associates with each serializable class a version
+ * number, called a serialVersionUID, which is used during deserialization to
+ * verify that the sender and receiver of a serialized object have loaded
+ * classes for that object that are compatible with respect to serialization.
+ * If the receiver has loaded a class for the object that has a different
+ * serialVersionUID than that of the corresponding sender's class, then
+ * deserialization will result in an {@link InvalidClassException}.  A
+ * serializable class can declare its own serialVersionUID explicitly by
+ * declaring a field named <code>"serialVersionUID"</code> that must be static,
+ * final, and of type <code>long</code>:<p>
+ *
+ * <PRE>
+ * ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;
+ * </PRE>
+ *
+ * If a serializable class does not explicitly declare a serialVersionUID, then
+ * the serialization runtime will calculate a default serialVersionUID value
+ * for that class based on various aspects of the class, as described in the
+ * Java(TM) Object Serialization Specification.  However, it is <em>strongly
+ * recommended</em> that all serializable classes explicitly declare
+ * serialVersionUID values, since the default serialVersionUID computation is
+ * highly sensitive to class details that may vary depending on compiler
+ * implementations, and can thus result in unexpected
+ * <code>InvalidClassException</code>s during deserialization.  Therefore, to
+ * guarantee a consistent serialVersionUID value across different java compiler
+ * implementations, a serializable class must declare an explicit
+ * serialVersionUID value.  It is also strongly advised that explicit
+ * serialVersionUID declarations use the <code>private</code> modifier where
+ * possible, since such declarations apply only to the immediately declaring
+ * class--serialVersionUID fields are not useful as inherited members. Array
+ * classes cannot declare an explicit serialVersionUID, so they always have
+ * the default computed value, but the requirement for matching
+ * serialVersionUID values is waived for array classes.
+ *
+ * @author  unascribed
+ * @see java.io.ObjectOutputStream
+ * @see java.io.ObjectInputStream
+ * @see java.io.ObjectOutput
+ * @see java.io.ObjectInput
+ * @see java.io.Externalizable
+ * @since   JDK1.1
+ */
+public interface Serializable {
+}
diff -r 94c1a17117f3 -r d7a291b7808d emul/src/main/java/java/io/UnsupportedEncodingException.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/emul/src/main/java/java/io/UnsupportedEncodingException.java	Sat Sep 29 06:47:05 2012 +0200
@@ -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.io;
+
+/**
+ * The Character Encoding is not supported.
+ *
+ * @author  Asmus Freytag
+ * @since   JDK1.1
+ */
+public class UnsupportedEncodingException
+    extends IOException
+{
+    private static final long serialVersionUID = -4274276298326136670L;
+
+    /**
+     * Constructs an UnsupportedEncodingException without a detail message.
+     */
+    public UnsupportedEncodingException() {
+        super();
+    }
+
+    /**
+     * Constructs an UnsupportedEncodingException with a detail message.
+     * @param s Describes the reason for the exception.
+     */
+    public UnsupportedEncodingException(String s) {
+        super(s);
+    }
+}
diff -r 94c1a17117f3 -r d7a291b7808d emul/src/main/java/java/lang/AbstractStringBuilder.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/emul/src/main/java/java/lang/AbstractStringBuilder.java	Sat Sep 29 06:47:05 2012 +0200
@@ -0,0 +1,1407 @@
+/*
+ * Copyright (c) 2003, 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 sun.misc.FloatingDecimal;
+import java.util.Arrays;
+
+/**
+ * A mutable sequence of characters.
+ * <p>
+ * Implements a modifiable string. 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.
+ *
+ * @author      Michael McCloskey
+ * @author      Martin Buchholz
+ * @author      Ulf Zibis
+ * @since       1.5
+ */
+abstract class AbstractStringBuilder implements Appendable, CharSequence {
+    /**
+     * The value is used for character storage.
+     */
+    char[] value;
+
+    /**
+     * The count is the number of characters used.
+     */
+    int count;
+
+    /**
+     * This no-arg constructor is necessary for serialization of subclasses.
+     */
+    AbstractStringBuilder() {
+    }
+
+    /**
+     * Creates an AbstractStringBuilder of the specified capacity.
+     */
+    AbstractStringBuilder(int capacity) {
+        value = new char[capacity];
+    }
+
+    /**
+     * Returns the length (character count).
+     *
+     * @return  the length of the sequence of characters currently
+     *          represented by this object
+     */
+    public int length() {
+        return count;
+    }
+
+    /**
+     * Returns the current capacity. The capacity is the amount of storage
+     * available for newly inserted characters, beyond which an allocation
+     * will occur.
+     *
+     * @return  the current capacity
+     */
+    public int capacity() {
+        return value.length;
+    }
+
+    /**
+     * Ensures that the capacity is at least equal to the specified minimum.
+     * If the current capacity is less than the argument, then a new internal
+     * array is allocated with greater capacity. The new capacity is the
+     * larger of:
+     * <ul>
+     * <li>The <code>minimumCapacity</code> argument.
+     * <li>Twice the old capacity, plus <code>2</code>.
+     * </ul>
+     * If the <code>minimumCapacity</code> argument is nonpositive, this
+     * method takes no action and simply returns.
+     *
+     * @param   minimumCapacity   the minimum desired capacity.
+     */
+    public void ensureCapacity(int minimumCapacity) {
+        if (minimumCapacity > 0)
+            ensureCapacityInternal(minimumCapacity);
+    }
+
+    /**
+     * This method has the same contract as ensureCapacity, but is
+     * never synchronized.
+     */
+    private void ensureCapacityInternal(int minimumCapacity) {
+        // overflow-conscious code
+        if (minimumCapacity - value.length > 0)
+            expandCapacity(minimumCapacity);
+    }
+
+    /**
+     * This implements the expansion semantics of ensureCapacity with no
+     * size check or synchronization.
+     */
+    void expandCapacity(int minimumCapacity) {
+        int newCapacity = value.length * 2 + 2;
+        if (newCapacity - minimumCapacity < 0)
+            newCapacity = minimumCapacity;
+        if (newCapacity < 0) {
+            if (minimumCapacity < 0) // overflow
+                throw new OutOfMemoryError();
+            newCapacity = Integer.MAX_VALUE;
+        }
+        value = Arrays.copyOf(value, newCapacity);
+    }
+
+    /**
+     * Attempts to reduce storage used for the character sequence.
+     * If the buffer is larger than necessary to hold its current sequence of
+     * characters, then it may be resized to become more space efficient.
+     * Calling this method may, but is not required to, affect the value
+     * returned by a subsequent call to the {@link #capacity()} method.
+     */
+    public void trimToSize() {
+        if (count < value.length) {
+            value = Arrays.copyOf(value, count);
+        }
+    }
+
+    /**
+     * Sets the length of the character sequence.
+     * The sequence is changed to a new character sequence
+     * whose length is specified by the argument. For every nonnegative
+     * index <i>k</i> less than <code>newLength</code>, the character at
+     * index <i>k</i> in the new character sequence is the same as the
+     * character at index <i>k</i> in the old sequence if <i>k</i> is less
+     * than the length of the old character sequence; otherwise, it is the
+     * null character <code>'&#92;u0000'</code>.
+     *
+     * In other words, if the <code>newLength</code> argument is less than
+     * the current length, the length is changed to the specified length.
+     * <p>
+     * If the <code>newLength</code> argument is greater than or equal
+     * to the current length, sufficient null characters
+     * (<code>'&#92;u0000'</code>) are appended so that
+     * length becomes the <code>newLength</code> argument.
+     * <p>
+     * The <code>newLength</code> argument must be greater than or equal
+     * to <code>0</code>.
+     *
+     * @param      newLength   the new length
+     * @throws     IndexOutOfBoundsException  if the
+     *               <code>newLength</code> argument is negative.
+     */
+    public void setLength(int newLength) {
+        if (newLength < 0)
+            throw new StringIndexOutOfBoundsException(newLength);
+        ensureCapacityInternal(newLength);
+
+        if (count < newLength) {
+            for (; count < newLength; count++)
+                value[count] = '\0';
+        } else {
+            count = newLength;
+        }
+    }
+
+    /**
+     * Returns the <code>char</code> value in this sequence at the specified index.
+     * The first <code>char</code> value is at index <code>0</code>, the next at index
+     * <code>1</code>, and so on, as in array indexing.
+     * <p>
+     * The index argument must be greater than or equal to
+     * <code>0</code>, and less than the length of this sequence.
+     *
+     * <p>If the <code>char</code> value specified by the index is a
+     * <a href="Character.html#unicode">surrogate</a>, the surrogate
+     * value is returned.
+     *
+     * @param      index   the index of the desired <code>char</code> value.
+     * @return     the <code>char</code> value at the specified index.
+     * @throws     IndexOutOfBoundsException  if <code>index</code> is
+     *             negative or greater than or equal to <code>length()</code>.
+     */
+    public char charAt(int index) {
+        if ((index < 0) || (index >= count))
+            throw new StringIndexOutOfBoundsException(index);
+        return value[index];
+    }
+
+    /**
+     * Returns the character (Unicode code point) at the specified
+     * index. The index refers to <code>char</code> values
+     * (Unicode code units) and ranges from <code>0</code> to
+     * {@link #length()}<code> - 1</code>.
+     *
+     * <p> If the <code>char</code> value specified at the given index
+     * is in the high-surrogate range, the following index is less
+     * than the length of this sequence, and the
+     * <code>char</code> value at the following index is in the
+     * low-surrogate range, then the supplementary code point
+     * corresponding to this surrogate pair is returned. Otherwise,
+     * the <code>char</code> value at the given index is returned.
+     *
+     * @param      index the index to the <code>char</code> values
+     * @return     the code point value of the character at the
+     *             <code>index</code>
+     * @exception  IndexOutOfBoundsException  if the <code>index</code>
+     *             argument is negative or not less than the length of this
+     *             sequence.
+     */
+    public int codePointAt(int index) {
+        if ((index < 0) || (index >= count)) {
+            throw new StringIndexOutOfBoundsException(index);
+        }
+        return Character.codePointAt(value, index);
+    }
+
+    /**
+     * Returns the character (Unicode code point) before the specified
+     * index. The index refers to <code>char</code> values
+     * (Unicode code units) and ranges from <code>1</code> to {@link
+     * #length()}.
+     *
+     * <p> If the <code>char</code> value at <code>(index - 1)</code>
+     * is in the low-surrogate range, <code>(index - 2)</code> is not
+     * negative, and the <code>char</code> value at <code>(index -
+     * 2)</code> is in the high-surrogate range, then the
+     * supplementary code point value of the surrogate pair is
+     * returned. If the <code>char</code> value at <code>index -
+     * 1</code> is an unpaired low-surrogate or a high-surrogate, the
+     * surrogate value is returned.
+     *
+     * @param     index the index following the code point that should be returned
+     * @return    the Unicode code point value before the given index.
+     * @exception IndexOutOfBoundsException if the <code>index</code>
+     *            argument is less than 1 or greater than the length
+     *            of this sequence.
+     */
+    public int codePointBefore(int index) {
+        int i = index - 1;
+        if ((i < 0) || (i >= count)) {
+            throw new StringIndexOutOfBoundsException(index);
+        }
+        return Character.codePointBefore(value, index);
+    }
+
+    /**
+     * Returns the number of Unicode code points in the specified text
+     * range of this sequence. The text range begins at the specified
+     * <code>beginIndex</code> and extends to the <code>char</code> at
+     * index <code>endIndex - 1</code>. Thus the length (in
+     * <code>char</code>s) of the text range is
+     * <code>endIndex-beginIndex</code>. Unpaired surrogates within
+     * this sequence count as one code point each.
+     *
+     * @param beginIndex the index to the first <code>char</code> of
+     * the text range.
+     * @param endIndex the index after the last <code>char</code> of
+     * the text range.
+     * @return the number of Unicode code points in the specified text
+     * range
+     * @exception IndexOutOfBoundsException if the
+     * <code>beginIndex</code> is negative, or <code>endIndex</code>
+     * is larger than the length of this sequence, or
+     * <code>beginIndex</code> is larger than <code>endIndex</code>.
+     */
+    public int codePointCount(int beginIndex, int endIndex) {
+        if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) {
+            throw new IndexOutOfBoundsException();
+        }
+        return Character.codePointCountImpl(value, beginIndex, endIndex-beginIndex);
+    }
+
+    /**
+     * Returns the index within this sequence that is offset from the
+     * given <code>index</code> by <code>codePointOffset</code> code
+     * points. Unpaired surrogates within the text range given by
+     * <code>index</code> and <code>codePointOffset</code> count as
+     * one code point each.
+     *
+     * @param index the index to be offset
+     * @param codePointOffset the offset in code points
+     * @return the index within this sequence
+     * @exception IndexOutOfBoundsException if <code>index</code>
+     *   is negative or larger then the length of this sequence,
+     *   or if <code>codePointOffset</code> is positive and the subsequence
+     *   starting with <code>index</code> has fewer than
+     *   <code>codePointOffset</code> code points,
+     *   or if <code>codePointOffset</code> is negative and the subsequence
+     *   before <code>index</code> has fewer than the absolute value of
+     *   <code>codePointOffset</code> code points.
+     */
+    public int offsetByCodePoints(int index, int codePointOffset) {
+        if (index < 0 || index > count) {
+            throw new IndexOutOfBoundsException();
+        }
+        return Character.offsetByCodePointsImpl(value, 0, count,
+                                                index, codePointOffset);
+    }
+
+    /**
+     * Characters are copied from this sequence into the
+     * destination character array <code>dst</code>. The first character to
+     * be copied is at index <code>srcBegin</code>; the last character to
+     * be copied is at index <code>srcEnd-1</code>. The total number of
+     * characters to be copied is <code>srcEnd-srcBegin</code>. The
+     * characters are copied into the subarray of <code>dst</code> starting
+     * at index <code>dstBegin</code> and ending at index:
+     * <p><blockquote><pre>
+     * dstbegin + (srcEnd-srcBegin) - 1
+     * </pre></blockquote>
+     *
+     * @param      srcBegin   start copying at this offset.
+     * @param      srcEnd     stop copying at this offset.
+     * @param      dst        the array to copy the data into.
+     * @param      dstBegin   offset into <code>dst</code>.
+     * @throws     NullPointerException if <code>dst</code> is
+     *             <code>null</code>.
+     * @throws     IndexOutOfBoundsException  if any of the following is true:
+     *             <ul>
+     *             <li><code>srcBegin</code> is negative
+     *             <li><code>dstBegin</code> is negative
+     *             <li>the <code>srcBegin</code> argument is greater than
+     *             the <code>srcEnd</code> argument.
+     *             <li><code>srcEnd</code> is greater than
+     *             <code>this.length()</code>.
+     *             <li><code>dstBegin+srcEnd-srcBegin</code> is greater than
+     *             <code>dst.length</code>
+     *             </ul>
+     */
+    public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
+    {
+        if (srcBegin < 0)
+            throw new StringIndexOutOfBoundsException(srcBegin);
+        if ((srcEnd < 0) || (srcEnd > count))
+            throw new StringIndexOutOfBoundsException(srcEnd);
+        if (srcBegin > srcEnd)
+            throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
+        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
+    }
+
+    /**
+     * The character at the specified index is set to <code>ch</code>. This
+     * sequence is altered to represent a new character sequence that is
+     * identical to the old character sequence, except that it contains the
+     * character <code>ch</code> at position <code>index</code>.
+     * <p>
+     * The index argument must be greater than or equal to
+     * <code>0</code>, and less than the length of this sequence.
+     *
+     * @param      index   the index of the character to modify.
+     * @param      ch      the new character.
+     * @throws     IndexOutOfBoundsException  if <code>index</code> is
+     *             negative or greater than or equal to <code>length()</code>.
+     */
+    public void setCharAt(int index, char ch) {
+        if ((index < 0) || (index >= count))
+            throw new StringIndexOutOfBoundsException(index);
+        value[index] = ch;
+    }
+
+    /**
+     * Appends the string representation of the {@code Object} argument.
+     * <p>
+     * The overall effect is exactly as if the argument were converted
+     * to a string by the method {@link String#valueOf(Object)},
+     * and the characters of that string were then
+     * {@link #append(String) appended} to this character sequence.
+     *
+     * @param   obj   an {@code Object}.
+     * @return  a reference to this object.
+     */
+    public AbstractStringBuilder append(Object obj) {
+        return append(String.valueOf(obj));
+    }
+
+    /**
+     * Appends the specified string to this character sequence.
+     * <p>
+     * The characters of the {@code String} argument are appended, in
+     * order, increasing the length of this sequence by the length of the
+     * argument. If {@code str} is {@code null}, then the four
+     * characters {@code "null"} are appended.
+     * <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 str}.
+     *
+     * @param   str   a string.
+     * @return  a reference to this object.
+     */
+    public AbstractStringBuilder append(String str) {
+        if (str == null) str = "null";
+        int len = str.length();
+        ensureCapacityInternal(count + len);
+        str.getChars(0, len, value, count);
+        count += len;
+        return this;
+    }
+
+    // Documentation in subclasses because of synchro difference
+    public AbstractStringBuilder append(StringBuffer sb) {
+        if (sb == null)
+            return append("null");
+        int len = sb.length();
+        ensureCapacityInternal(count + len);
+        sb.getChars(0, len, value, count);
+        count += len;
+        return this;
+    }
+
+    // Documentation in subclasses because of synchro difference
+    public AbstractStringBuilder append(CharSequence s) {
+        if (s == null)
+            s = "null";
+        if (s instanceof String)
+            return this.append((String)s);
+        if (s instanceof StringBuffer)
+            return this.append((StringBuffer)s);
+        return this.append(s, 0, s.length());
+    }
+
+    /**
+     * Appends a subsequence of the specified {@code CharSequence} to this
+     * sequence.
+     * <p>
+     * Characters of the argument {@code s}, starting at
+     * index {@code start}, are appended, in order, to the contents of
+     * this sequence up to the (exclusive) index {@code end}. The length
+     * of this sequence is increased by the value of {@code end - start}.
+     * <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 this character sequence becomes equal to the
+     * character at index <i>k</i> in this sequence, if <i>k</i> is less than
+     * <i>n</i>; otherwise, it is equal to the character at index
+     * <i>k+start-n</i> in the argument {@code s}.
+     * <p>
+     * If {@code s} is {@code null}, then this method appends
+     * characters as if the s parameter was a sequence containing the four
+     * characters {@code "null"}.
+     *
+     * @param   s the sequence to append.
+     * @param   start   the starting index of the subsequence to be appended.
+     * @param   end     the end index of the subsequence to be appended.
+     * @return  a reference to this object.
+     * @throws     IndexOutOfBoundsException if
+     *             {@code start} is negative, or
+     *             {@code start} is greater than {@code end} or
+     *             {@code end} is greater than {@code s.length()}
+     */
+    public AbstractStringBuilder append(CharSequence s, int start, int end) {
+        if (s == null)
+            s = "null";
+        if ((start < 0) || (start > end) || (end > s.length()))
+            throw new IndexOutOfBoundsException(
+                "start " + start + ", end " + end + ", s.length() "
+                + s.length());
+        int len = end - start;
+        ensureCapacityInternal(count + len);
+        for (int i = start, j = count; i < end; i++, j++)
+            value[j] = s.charAt(i);
+        count += len;
+        return this;
+    }
+
+    /**
+     * Appends the string representation of the {@code char} array
+     * argument to this sequence.
+     * <p>
+     * The characters of the array argument are appended, in order, to
+     * the contents of this sequence. The length of this sequence
+     * increases by the length of the argument.
+     * <p>
+     * The overall effect is exactly as if the argument were converted
+     * to a string by the method {@link String#valueOf(char[])},
+     * and the characters of that string were then
+     * {@link #append(String) appended} to this character sequence.
+     *
+     * @param   str   the characters to be appended.
+     * @return  a reference to this object.
+     */
+    public AbstractStringBuilder append(char[] str) {
+        int len = str.length;
+        ensureCapacityInternal(count + len);
+        System.arraycopy(str, 0, value, count, len);
+        count += len;
+        return this;
+    }
+
+    /**
+     * Appends the string representation of a subarray of the
+     * {@code char} array argument to this sequence.
+     * <p>
+     * Characters of the {@code char} array {@code str}, starting at
+     * index {@code offset}, are appended, in order, to the contents
+     * of this sequence. The length of this sequence increases
+     * by the value of {@code len}.
+     * <p>
+     * The overall effect is exactly as if the arguments were converted
+     * to a string by the method {@link String#valueOf(char[],int,int)},
+     * and the characters of that string were then
+     * {@link #append(String) appended} to this character sequence.
+     *
+     * @param   str      the characters to be appended.
+     * @param   offset   the index of the first {@code char} to append.
+     * @param   len      the number of {@code char}s to append.
+     * @return  a reference to this object.
+     * @throws IndexOutOfBoundsException
+     *         if {@code offset < 0} or {@code len < 0}
+     *         or {@code offset+len > str.length}
+     */
+    public AbstractStringBuilder append(char str[], int offset, int len) {
+        if (len > 0)                // let arraycopy report AIOOBE for len < 0
+            ensureCapacityInternal(count + len);
+        System.arraycopy(str, offset, value, count, len);
+        count += len;
+        return this;
+    }
+
+    /**
+     * Appends the string representation of the {@code boolean}
+     * argument to the sequence.
+     * <p>
+     * The overall effect is exactly as if the argument were converted
+     * to a string by the method {@link String#valueOf(boolean)},
+     * and the characters of that string were then
+     * {@link #append(String) appended} to this character sequence.
+     *
+     * @param   b   a {@code boolean}.
+     * @return  a reference to this object.
+     */
+    public AbstractStringBuilder append(boolean b) {
+        if (b) {
+            ensureCapacityInternal(count + 4);
+            value[count++] = 't';
+            value[count++] = 'r';
+            value[count++] = 'u';
+            value[count++] = 'e';
+        } else {
+            ensureCapacityInternal(count + 5);
+            value[count++] = 'f';
+            value[count++] = 'a';
+            value[count++] = 'l';
+            value[count++] = 's';
+            value[count++] = 'e';
+        }
+        return this;
+    }
+
+    /**
+     * Appends the string representation of the {@code char}
+     * argument to this sequence.
+     * <p>
+     * The argument is appended to the contents of this sequence.
+     * The length of this sequence increases by {@code 1}.
+     * <p>
+     * The overall effect is exactly as if the argument were converted
+     * to a string by the method {@link String#valueOf(char)},
+     * and the character in that string were then
+     * {@link #append(String) appended} to this character sequence.
+     *
+     * @param   c   a {@code char}.
+     * @return  a reference to this object.
+     */
+    public AbstractStringBuilder append(char c) {
+        ensureCapacityInternal(count + 1);
+        value[count++] = c;
+        return this;
+    }
+
+    /**
+     * Appends the string representation of the {@code int}
+     * argument to this sequence.
+     * <p>
+     * The overall effect is exactly as if the argument were converted
+     * to a string by the method {@link String#valueOf(int)},
+     * and the characters of that string were then
+     * {@link #append(String) appended} to this character sequence.
+     *
+     * @param   i   an {@code int}.
+     * @return  a reference to this object.
+     */
+    public AbstractStringBuilder append(int i) {
+        if (i == Integer.MIN_VALUE) {
+            append("-2147483648");
+            return this;
+        }
+        int appendedLength = (i < 0) ? Integer.stringSize(-i) + 1
+                                     : Integer.stringSize(i);
+        int spaceNeeded = count + appendedLength;
+        ensureCapacityInternal(spaceNeeded);
+        Integer.getChars(i, spaceNeeded, value);
+        count = spaceNeeded;
+        return this;
+    }
+
+    /**
+     * Appends the string representation of the {@code long}
+     * argument to this sequence.
+     * <p>
+     * The overall effect is exactly as if the argument were converted
+     * to a string by the method {@link String#valueOf(long)},
+     * and the characters of that string were then
+     * {@link #append(String) appended} to this character sequence.
+     *
+     * @param   l   a {@code long}.
+     * @return  a reference to this object.
+     */
+    public AbstractStringBuilder append(long l) {
+        if (l == Long.MIN_VALUE) {
+            append("-9223372036854775808");
+            return this;
+        }
+        int appendedLength = (l < 0) ? Long.stringSize(-l) + 1
+                                     : Long.stringSize(l);
+        int spaceNeeded = count + appendedLength;
+        ensureCapacityInternal(spaceNeeded);
+        Long.getChars(l, spaceNeeded, value);
+        count = spaceNeeded;
+        return this;
+    }
+
+    /**
+     * Appends the string representation of the {@code float}
+     * argument to this sequence.
+     * <p>
+     * The overall effect is exactly as if the argument were converted
+     * to a string by the method {@link String#valueOf(float)},
+     * and the characters of that string were then
+     * {@link #append(String) appended} to this character sequence.
+     *
+     * @param   f   a {@code float}.
+     * @return  a reference to this object.
+     */
+    public AbstractStringBuilder append(float f) {
+        new FloatingDecimal(f).appendTo(this);
+        return this;
+    }
+
+    /**
+     * Appends the string representation of the {@code double}
+     * argument to this sequence.
+     * <p>
+     * The overall effect is exactly as if the argument were converted
+     * to a string by the method {@link String#valueOf(double)},
+     * and the characters of that string were then
+     * {@link #append(String) appended} to this character sequence.
+     *
+     * @param   d   a {@code double}.
+     * @return  a reference to this object.
+     */
+    public AbstractStringBuilder append(double d) {
+        new FloatingDecimal(d).appendTo(this);
+        return this;
+    }
+
+    /**
+     * Removes the characters in a substring of this sequence.
+     * The substring begins at the specified {@code start} and extends to
+     * the character at index {@code end - 1} or to the end of the
+     * sequence if no such character exists. If
+     * {@code start} is equal to {@code end}, no changes are made.
+     *
+     * @param      start  The beginning index, inclusive.
+     * @param      end    The ending index, exclusive.
+     * @return     This object.
+     * @throws     StringIndexOutOfBoundsException  if {@code start}
+     *             is negative, greater than {@code length()}, or
+     *             greater than {@code end}.
+     */
+    public AbstractStringBuilder delete(int start, int end) {
+        if (start < 0)
+            throw new StringIndexOutOfBoundsException(start);
+        if (end > count)
+            end = count;
+        if (start > end)
+            throw new StringIndexOutOfBoundsException();
+        int len = end - start;
+        if (len > 0) {
+            System.arraycopy(value, start+len, value, start, count-end);
+            count -= len;
+        }
+        return this;
+    }
+
+    /**
+     * Appends the string representation of the {@code codePoint}
+     * argument to this sequence.
+     *
+     * <p> The argument is appended to the contents of this sequence.
+     * The length of this sequence increases by
+     * {@link Character#charCount(int) Character.charCount(codePoint)}.
+     *
+     * <p> The overall effect is exactly as if the argument were
+     * converted to a {@code char} array by the method
+     * {@link Character#toChars(int)} and the character in that array
+     * were then {@link #append(char[]) appended} to this character
+     * sequence.
+     *
+     * @param   codePoint   a Unicode code point
+     * @return  a reference to this object.
+     * @exception IllegalArgumentException if the specified
+     * {@code codePoint} isn't a valid Unicode code point
+     */
+    public AbstractStringBuilder appendCodePoint(int codePoint) {
+        final int count = this.count;
+
+        if (Character.isBmpCodePoint(codePoint)) {
+            ensureCapacityInternal(count + 1);
+            value[count] = (char) codePoint;
+            this.count = count + 1;
+        } else if (Character.isValidCodePoint(codePoint)) {
+            ensureCapacityInternal(count + 2);
+            Character.toSurrogates(codePoint, value, count);
+            this.count = count + 2;
+        } else {
+            throw new IllegalArgumentException();
+        }
+        return this;
+    }
+
+    /**
+     * Removes the <code>char</code> at the specified position in this
+     * sequence. This sequence is shortened by one <code>char</code>.
+     *
+     * <p>Note: If the character at the given index is a supplementary
+     * character, this method does not remove the entire character. If
+     * correct handling of supplementary characters is required,
+     * determine the number of <code>char</code>s to remove by calling
+     * <code>Character.charCount(thisSequence.codePointAt(index))</code>,
+     * where <code>thisSequence</code> is this sequence.
+     *
+     * @param       index  Index of <code>char</code> to remove
+     * @return      This object.
+     * @throws      StringIndexOutOfBoundsException  if the <code>index</code>
+     *              is negative or greater than or equal to
+     *              <code>length()</code>.
+     */
+    public AbstractStringBuilder deleteCharAt(int index) {
+        if ((index < 0) || (index >= count))
+            throw new StringIndexOutOfBoundsException(index);
+        System.arraycopy(value, index+1, value, index, count-index-1);
+        count--;
+        return this;
+    }
+
+    /**
+     * Replaces the characters in a substring of this sequence
+     * with characters in the specified <code>String</code>. The substring
+     * begins at the specified <code>start</code> and extends to the character
+     * at index <code>end - 1</code> or to the end of the
+     * sequence if no such character exists. First the
+     * characters in the substring are removed and then the specified
+     * <code>String</code> is inserted at <code>start</code>. (This
+     * sequence will be lengthened to accommodate the
+     * specified String if necessary.)
+     *
+     * @param      start    The beginning index, inclusive.
+     * @param      end      The ending index, exclusive.
+     * @param      str   String that will replace previous contents.
+     * @return     This object.
+     * @throws     StringIndexOutOfBoundsException  if <code>start</code>
+     *             is negative, greater than <code>length()</code>, or
+     *             greater than <code>end</code>.
+     */
+    public AbstractStringBuilder replace(int start, int end, String str) {
+        if (start < 0)
+            throw new StringIndexOutOfBoundsException(start);
+        if (start > count)
+            throw new StringIndexOutOfBoundsException("start > length()");
+        if (start > end)
+            throw new StringIndexOutOfBoundsException("start > end");
+
+        if (end > count)
+            end = count;
+        int len = str.length();
+        int newCount = count + len - (end - start);
+        ensureCapacityInternal(newCount);
+
+        System.arraycopy(value, end, value, start + len, count - end);
+        str.getChars(value, start);
+        count = newCount;
+        return this;
+    }
+
+    /**
+     * Returns a new <code>String</code> that contains a subsequence of
+     * characters currently contained in this character sequence. The
+     * substring begins at the specified index and extends to the end of
+     * this sequence.
+     *
+     * @param      start    The beginning index, inclusive.
+     * @return     The new string.
+     * @throws     StringIndexOutOfBoundsException  if <code>start</code> is
+     *             less than zero, or greater than the length of this object.
+     */
+    public String substring(int start) {
+        return substring(start, count);
+    }
+
+    /**
+     * Returns a new character sequence that is a subsequence of this sequence.
+     *
+     * <p> An invocation of this method of the form
+     *
+     * <blockquote><pre>
+     * sb.subSequence(begin,&nbsp;end)</pre></blockquote>
+     *
+     * behaves in exactly the same way as the invocation
+     *
+     * <blockquote><pre>
+     * sb.substring(begin,&nbsp;end)</pre></blockquote>
+     *
+     * This method is provided so that this class can
+     * implement the {@link CharSequence} interface. </p>
+     *
+     * @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>
+     * @spec JSR-51
+     */
+    public CharSequence subSequence(int start, int end) {
+        return substring(start, end);
+    }
+
+    /**
+     * Returns a new <code>String</code> that contains a subsequence of
+     * characters currently contained in this sequence. The
+     * substring begins at the specified <code>start</code> and
+     * extends to the character at index <code>end - 1</code>.
+     *
+     * @param      start    The beginning index, inclusive.
+     * @param      end      The ending index, exclusive.
+     * @return     The new string.
+     * @throws     StringIndexOutOfBoundsException  if <code>start</code>
+     *             or <code>end</code> are negative or greater than
+     *             <code>length()</code>, or <code>start</code> is
+     *             greater than <code>end</code>.
+     */
+    public String substring(int start, int end) {
+        if (start < 0)
+            throw new StringIndexOutOfBoundsException(start);
+        if (end > count)
+            throw new StringIndexOutOfBoundsException(end);
+        if (start > end)
+            throw new StringIndexOutOfBoundsException(end - start);
+        return new String(value, start, end - start);
+    }
+
+    /**
+     * Inserts the string representation of a subarray of the {@code str}
+     * array argument into this sequence. The subarray begins at the
+     * specified {@code offset} and extends {@code len} {@code char}s.
+     * The characters of the subarray are inserted into this sequence at
+     * the position indicated by {@code index}. The length of this
+     * sequence increases by {@code len} {@code char}s.
+     *
+     * @param      index    position at which to insert subarray.
+     * @param      str       A {@code char} array.
+     * @param      offset   the index of the first {@code char} in subarray to
+     *             be inserted.
+     * @param      len      the number of {@code char}s in the subarray to
+     *             be inserted.
+     * @return     This object
+     * @throws     StringIndexOutOfBoundsException  if {@code index}
+     *             is negative or greater than {@code length()}, or
+     *             {@code offset} or {@code len} are negative, or
+     *             {@code (offset+len)} is greater than
+     *             {@code str.length}.
+     */
+    public AbstractStringBuilder insert(int index, char[] str, int offset,
+                                        int len)
+    {
+        if ((index < 0) || (index > length()))
+            throw new StringIndexOutOfBoundsException(index);
+        if ((offset < 0) || (len < 0) || (offset > str.length - len))
+            throw new StringIndexOutOfBoundsException(
+                "offset " + offset + ", len " + len + ", str.length "
+                + str.length);
+        ensureCapacityInternal(count + len);
+        System.arraycopy(value, index, value, index + len, count - index);
+        System.arraycopy(str, offset, value, index, len);
+        count += len;
+        return this;
+    }
+
+    /**
+     * Inserts the string representation of the {@code Object}
+     * argument into this character sequence.
+     * <p>
+     * The overall effect is exactly as if the second argument were
+     * converted to a string by the method {@link String#valueOf(Object)},
+     * and the characters of that string were then
+     * {@link #insert(int,String) inserted} into this character
+     * sequence at the indicated offset.
+     * <p>
+     * The {@code offset} argument must be greater than or equal to
+     * {@code 0}, and less than or equal to the {@linkplain #length() length}
+     * of this sequence.
+     *
+     * @param      offset   the offset.
+     * @param      obj      an {@code Object}.
+     * @return     a reference to this object.
+     * @throws     StringIndexOutOfBoundsException  if the offset is invalid.
+     */
+    public AbstractStringBuilder insert(int offset, Object obj) {
+        return insert(offset, String.valueOf(obj));
+    }
+
+    /**
+     * Inserts the string into this character sequence.
+     * <p>
+     * The characters of the {@code String} argument are inserted, in
+     * order, into this sequence at the indicated offset, moving up any
+     * characters originally above that position and increasing the length
+     * of this sequence by the length of the argument. If
+     * {@code str} is {@code null}, then the four characters
+     * {@code "null"} are inserted into this sequence.
+     * <p>
+     * The character at index <i>k</i> in the new character sequence is
+     * equal to:
+     * <ul>
+     * <li>the character at index <i>k</i> in the old character sequence, if
+     * <i>k</i> is less than {@code offset}
+     * <li>the character at index <i>k</i>{@code -offset} in the
+     * argument {@code str}, if <i>k</i> is not less than
+     * {@code offset} but is less than {@code offset+str.length()}
+     * <li>the character at index <i>k</i>{@code -str.length()} in the
+     * old character sequence, if <i>k</i> is not less than
+     * {@code offset+str.length()}
+     * </ul><p>
+     * The {@code offset} argument must be greater than or equal to
+     * {@code 0}, and less than or equal to the {@linkplain #length() length}
+     * of this sequence.
+     *
+     * @param      offset   the offset.
+     * @param      str      a string.
+     * @return     a reference to this object.
+     * @throws     StringIndexOutOfBoundsException  if the offset is invalid.
+     */
+    public AbstractStringBuilder insert(int offset, String str) {
+        if ((offset < 0) || (offset > length()))
+            throw new StringIndexOutOfBoundsException(offset);
+        if (str == null)
+            str = "null";
+        int len = str.length();
+        ensureCapacityInternal(count + len);
+        System.arraycopy(value, offset, value, offset + len, count - offset);
+        str.getChars(value, offset);
+        count += len;
+        return this;
+    }
+
+    /**
+     * Inserts the string representation of the {@code char} array
+     * argument into this sequence.
+     * <p>
+     * The characters of the array argument are inserted into the
+     * contents of this sequence at the position indicated by
+     * {@code offset}. The length of this sequence increases by
+     * the length of the argument.
+     * <p>
+     * The overall effect is exactly as if the second argument were
+     * converted to a string by the method {@link String#valueOf(char[])},
+     * and the characters of that string were then
+     * {@link #insert(int,String) inserted} into this character
+     * sequence at the indicated offset.
+     * <p>
+     * The {@code offset} argument must be greater than or equal to
+     * {@code 0}, and less than or equal to the {@linkplain #length() length}
+     * of this sequence.
+     *
+     * @param      offset   the offset.
+     * @param      str      a character array.
+     * @return     a reference to this object.
+     * @throws     StringIndexOutOfBoundsException  if the offset is invalid.
+     */
+    public AbstractStringBuilder insert(int offset, char[] str) {
+        if ((offset < 0) || (offset > length()))
+            throw new StringIndexOutOfBoundsException(offset);
+        int len = str.length;
+        ensureCapacityInternal(count + len);
+        System.arraycopy(value, offset, value, offset + len, count - offset);
+        System.arraycopy(str, 0, value, offset, len);
+        count += len;
+        return this;
+    }
+
+    /**
+     * Inserts the specified {@code CharSequence} into this sequence.
+     * <p>
+     * The characters of the {@code CharSequence} argument are inserted,
+     * in order, into this sequence at the indicated offset, moving up
+     * any characters originally above that position and increasing the length
+     * of this sequence by the length of the argument s.
+     * <p>
+     * The result of this method is exactly the same as if it were an
+     * invocation of this object's
+     * {@link #insert(int,CharSequence,int,int) insert}(dstOffset, s, 0, s.length())
+     * method.
+     *
+     * <p>If {@code s} is {@code null}, then the four characters
+     * {@code "null"} are inserted into this sequence.
+     *
+     * @param      dstOffset   the offset.
+     * @param      s the sequence to be inserted
+     * @return     a reference to this object.
+     * @throws     IndexOutOfBoundsException  if the offset is invalid.
+     */
+    public AbstractStringBuilder insert(int dstOffset, CharSequence s) {
+        if (s == null)
+            s = "null";
+        if (s instanceof String)
+            return this.insert(dstOffset, (String)s);
+        return this.insert(dstOffset, s, 0, s.length());
+    }
+
+    /**
+     * Inserts a subsequence of the specified {@code CharSequence} into
+     * this sequence.
+     * <p>
+     * The subsequence of the argument {@code s} specified by
+     * {@code start} and {@code end} are inserted,
+     * in order, into this sequence at the specified destination offset, moving
+     * up any characters originally above that position. The length of this
+     * sequence is increased by {@code end - start}.
+     * <p>
+     * The character at index <i>k</i> in this sequence becomes equal to:
+     * <ul>
+     * <li>the character at index <i>k</i> in this sequence, if
+     * <i>k</i> is less than {@code dstOffset}
+     * <li>the character at index <i>k</i>{@code +start-dstOffset} in
+     * the argument {@code s}, if <i>k</i> is greater than or equal to
+     * {@code dstOffset} but is less than {@code dstOffset+end-start}
+     * <li>the character at index <i>k</i>{@code -(end-start)} in this
+     * sequence, if <i>k</i> is greater than or equal to
+     * {@code dstOffset+end-start}
+     * </ul><p>
+     * The {@code dstOffset} argument must be greater than or equal to
+     * {@code 0}, and less than or equal to the {@linkplain #length() length}
+     * of this sequence.
+     * <p>The start argument must be nonnegative, and not greater than
+     * {@code end}.
+     * <p>The end argument must be greater than or equal to
+     * {@code start}, and less than or equal to the length of s.
+     *
+     * <p>If {@code s} is {@code null}, then this method inserts
+     * characters as if the s parameter was a sequence containing the four
+     * characters {@code "null"}.
+     *
+     * @param      dstOffset   the offset in this sequence.
+     * @param      s       the sequence to be inserted.
+     * @param      start   the starting index of the subsequence to be inserted.
+     * @param      end     the end index of the subsequence to be inserted.
+     * @return     a reference to this object.
+     * @throws     IndexOutOfBoundsException  if {@code dstOffset}
+     *             is negative or greater than {@code this.length()}, or
+     *              {@code start} or {@code end} are negative, or
+     *              {@code start} is greater than {@code end} or
+     *              {@code end} is greater than {@code s.length()}
+     */
+     public AbstractStringBuilder insert(int dstOffset, CharSequence s,
+                                         int start, int end) {
+        if (s == null)
+            s = "null";
+        if ((dstOffset < 0) || (dstOffset > this.length()))
+            throw new IndexOutOfBoundsException("dstOffset "+dstOffset);
+        if ((start < 0) || (end < 0) || (start > end) || (end > s.length()))
+            throw new IndexOutOfBoundsException(
+                "start " + start + ", end " + end + ", s.length() "
+                + s.length());
+        int len = end - start;
+        ensureCapacityInternal(count + len);
+        System.arraycopy(value, dstOffset, value, dstOffset + len,
+                         count - dstOffset);
+        for (int i=start; i<end; i++)
+            value[dstOffset++] = s.charAt(i);
+        count += len;
+        return this;
+    }
+
+    /**
+     * Inserts the string representation of the {@code boolean}
+     * argument into this sequence.
+     * <p>
+     * The overall effect is exactly as if the second argument were
+     * converted to a string by the method {@link String#valueOf(boolean)},
+     * and the characters of that string were then
+     * {@link #insert(int,String) inserted} into this character
+     * sequence at the indicated offset.
+     * <p>
+     * The {@code offset} argument must be greater than or equal to
+     * {@code 0}, and less than or equal to the {@linkplain #length() length}
+     * of this sequence.
+     *
+     * @param      offset   the offset.
+     * @param      b        a {@code boolean}.
+     * @return     a reference to this object.
+     * @throws     StringIndexOutOfBoundsException  if the offset is invalid.
+     */
+    public AbstractStringBuilder insert(int offset, boolean b) {
+        return insert(offset, String.valueOf(b));
+    }
+
+    /**
+     * Inserts the string representation of the {@code char}
+     * argument into this sequence.
+     * <p>
+     * The overall effect is exactly as if the second argument were
+     * converted to a string by the method {@link String#valueOf(char)},
+     * and the character in that string were then
+     * {@link #insert(int,String) inserted} into this character
+     * sequence at the indicated offset.
+     * <p>
+     * The {@code offset} argument must be greater than or equal to
+     * {@code 0}, and less than or equal to the {@linkplain #length() length}
+     * of this sequence.
+     *
+     * @param      offset   the offset.
+     * @param      c        a {@code char}.
+     * @return     a reference to this object.
+     * @throws     IndexOutOfBoundsException  if the offset is invalid.
+     */
+    public AbstractStringBuilder insert(int offset, char c) {
+        ensureCapacityInternal(count + 1);
+        System.arraycopy(value, offset, value, offset + 1, count - offset);
+        value[offset] = c;
+        count += 1;
+        return this;
+    }
+
+    /**
+     * Inserts the string representation of the second {@code int}
+     * argument into this sequence.
+     * <p>
+     * The overall effect is exactly as if the second argument were
+     * converted to a string by the method {@link String#valueOf(int)},
+     * and the characters of that string were then
+     * {@link #insert(int,String) inserted} into this character
+     * sequence at the indicated offset.
+     * <p>
+     * The {@code offset} argument must be greater than or equal to
+     * {@code 0}, and less than or equal to the {@linkplain #length() length}
+     * of this sequence.
+     *
+     * @param      offset   the offset.
+     * @param      i        an {@code int}.
+     * @return     a reference to this object.
+     * @throws     StringIndexOutOfBoundsException  if the offset is invalid.
+     */
+    public AbstractStringBuilder insert(int offset, int i) {
+        return insert(offset, String.valueOf(i));
+    }
+
+    /**
+     * Inserts the string representation of the {@code long}
+     * argument into this sequence.
+     * <p>
+     * The overall effect is exactly as if the second argument were
+     * converted to a string by the method {@link String#valueOf(long)},
+     * and the characters of that string were then
+     * {@link #insert(int,String) inserted} into this character
+     * sequence at the indicated offset.
+     * <p>
+     * The {@code offset} argument must be greater than or equal to
+     * {@code 0}, and less than or equal to the {@linkplain #length() length}
+     * of this sequence.
+     *
+     * @param      offset   the offset.
+     * @param      l        a {@code long}.
+     * @return     a reference to this object.
+     * @throws     StringIndexOutOfBoundsException  if the offset is invalid.
+     */
+    public AbstractStringBuilder insert(int offset, long l) {
+        return insert(offset, String.valueOf(l));
+    }
+
+    /**
+     * Inserts the string representation of the {@code float}
+     * argument into this sequence.
+     * <p>
+     * The overall effect is exactly as if the second argument were
+     * converted to a string by the method {@link String#valueOf(float)},
+     * and the characters of that string were then
+     * {@link #insert(int,String) inserted} into this character
+     * sequence at the indicated offset.
+     * <p>
+     * The {@code offset} argument must be greater than or equal to
+     * {@code 0}, and less than or equal to the {@linkplain #length() length}
+     * of this sequence.
+     *
+     * @param      offset   the offset.
+     * @param      f        a {@code float}.
+     * @return     a reference to this object.
+     * @throws     StringIndexOutOfBoundsException  if the offset is invalid.
+     */
+    public AbstractStringBuilder insert(int offset, float f) {
+        return insert(offset, String.valueOf(f));
+    }
+
+    /**
+     * Inserts the string representation of the {@code double}
+     * argument into this sequence.
+     * <p>
+     * The overall effect is exactly as if the second argument were
+     * converted to a string by the method {@link String#valueOf(double)},
+     * and the characters of that string were then
+     * {@link #insert(int,String) inserted} into this character
+     * sequence at the indicated offset.
+     * <p>
+     * The {@code offset} argument must be greater than or equal to
+     * {@code 0}, and less than or equal to the {@linkplain #length() length}
+     * of this sequence.
+     *
+     * @param      offset   the offset.
+     * @param      d        a {@code double}.
+     * @return     a reference to this object.
+     * @throws     StringIndexOutOfBoundsException  if the offset is invalid.
+     */
+    public AbstractStringBuilder insert(int offset, double d) {
+        return insert(offset, String.valueOf(d));
+    }
+
+    /**
+     * Returns the index within this string of the first occurrence of the
+     * specified substring. The integer returned is the smallest value
+     * <i>k</i> such that:
+     * <blockquote><pre>
+     * this.toString().startsWith(str, <i>k</i>)
+     * </pre></blockquote>
+     * is <code>true</code>.
+     *
+     * @param   str   any string.
+     * @return  if the string argument occurs as a substring within this
+     *          object, then the index of the first character of the first
+     *          such substring is returned; if it does not occur as a
+     *          substring, <code>-1</code> is returned.
+     * @throws  java.lang.NullPointerException if <code>str</code> is
+     *          <code>null</code>.
+     */
+    public int indexOf(String str) {
+        return indexOf(str, 0);
+    }
+
+    /**
+     * Returns the index within this string of the first occurrence of the
+     * specified substring, starting at the specified index.  The integer
+     * returned is the smallest value <tt>k</tt> for which:
+     * <blockquote><pre>
+     *     k >= Math.min(fromIndex, str.length()) &&
+     *                   this.toString().startsWith(str, k)
+     * </pre></blockquote>
+     * If no such value of <i>k</i> exists, then -1 is returned.
+     *
+     * @param   str         the substring for which to search.
+     * @param   fromIndex   the index from which to start the search.
+     * @return  the index within this string of the first occurrence of the
+     *          specified substring, starting at the specified index.
+     * @throws  java.lang.NullPointerException if <code>str</code> is
+     *            <code>null</code>.
+     */
+    public int indexOf(String str, int fromIndex) {
+        return String.indexOf(value, 0, count,
+                              str.toCharArray(), 0, str.length(), fromIndex);
+    }
+
+    /**
+     * Returns the index within this string of the rightmost occurrence
+     * of the specified substring.  The rightmost empty string "" is
+     * considered to occur at the index value <code>this.length()</code>.
+     * The returned index is the largest value <i>k</i> such that
+     * <blockquote><pre>
+     * this.toString().startsWith(str, k)
+     * </pre></blockquote>
+     * is true.
+     *
+     * @param   str   the substring to search for.
+     * @return  if the string argument occurs one or more times as a substring
+     *          within this object, then the index of the first character of
+     *          the last such substring is returned. If it does not occur as
+     *          a substring, <code>-1</code> is returned.
+     * @throws  java.lang.NullPointerException  if <code>str</code> is
+     *          <code>null</code>.
+     */
+    public int lastIndexOf(String str) {
+        return lastIndexOf(str, count);
+    }
+
+    /**
+     * Returns the index within this string of the last occurrence of the
+     * specified substring. The integer returned is the largest value <i>k</i>
+     * such that:
+     * <blockquote><pre>
+     *     k <= Math.min(fromIndex, str.length()) &&
+     *                   this.toString().startsWith(str, k)
+     * </pre></blockquote>
+     * If no such value of <i>k</i> exists, then -1 is returned.
+     *
+     * @param   str         the substring to search for.
+     * @param   fromIndex   the index to start the search from.
+     * @return  the index within this sequence of the last occurrence of the
+     *          specified substring.
+     * @throws  java.lang.NullPointerException if <code>str</code> is
+     *          <code>null</code>.
+     */
+    public int lastIndexOf(String str, int fromIndex) {
+        return String.lastIndexOf(value, 0, count,
+                              str.toCharArray(), 0, str.length(), fromIndex);
+    }
+
+    /**
+     * Causes this character sequence to be replaced by the reverse of
+     * the sequence. If there are any surrogate pairs included in the
+     * sequence, these are treated as single characters for the
+     * reverse operation. Thus, the order of the high-low surrogates
+     * is never reversed.
+     *
+     * Let <i>n</i> be the character length of this character sequence
+     * (not the length in <code>char</code> values) just prior to
+     * execution of the <code>reverse</code> method. Then the
+     * character at index <i>k</i> in the new character sequence is
+     * equal to the character at index <i>n-k-1</i> in the old
+     * character sequence.
+     *
+     * <p>Note that the reverse operation may result in producing
+     * surrogate pairs that were unpaired low-surrogates and
+     * high-surrogates before the operation. For example, reversing
+     * "&#92;uDC00&#92;uD800" produces "&#92;uD800&#92;uDC00" which is
+     * a valid surrogate pair.
+     *
+     * @return  a reference to this object.
+     */
+    public AbstractStringBuilder reverse() {
+        boolean hasSurrogate = false;
+        int n = count - 1;
+        for (int j = (n-1) >> 1; j >= 0; --j) {
+            char temp = value[j];
+            char temp2 = value[n - j];
+            if (!hasSurrogate) {
+                hasSurrogate = (temp >= Character.MIN_SURROGATE && temp <= Character.MAX_SURROGATE)
+                    || (temp2 >= Character.MIN_SURROGATE && temp2 <= Character.MAX_SURROGATE);
+            }
+            value[j] = temp2;
+            value[n - j] = temp;
+        }
+        if (hasSurrogate) {
+            // Reverse back all valid surrogate pairs
+            for (int i = 0; i < count - 1; i++) {
+                char c2 = value[i];
+                if (Character.isLowSurrogate(c2)) {
+                    char c1 = value[i + 1];
+                    if (Character.isHighSurrogate(c1)) {
+                        value[i++] = c1;
+                        value[i] = c2;
+                    }
+                }
+            }
+        }
+        return this;
+    }
+
+    /**
+     * Returns a string representing the data in this sequence.
+     * A new <code>String</code> object is allocated and initialized to
+     * contain the character sequence currently represented by this
+     * object. This <code>String</code> is then returned. Subsequent
+     * changes to this sequence do not affect the contents of the
+     * <code>String</code>.
+     *
+     * @return  a string representation of this sequence of characters.
+     */
+    public abstract String toString();
+
+    /**
+     * Needed by <tt>String</tt> for the contentEquals method.
+     */
+    final char[] getValue() {
+        return value;
+    }
+
+}
diff -r 94c1a17117f3 -r d7a291b7808d emul/src/main/java/java/lang/Class.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/emul/src/main/java/java/lang/Class.java	Sat Sep 29 06:47:05 2012 +0200
@@ -0,0 +1,3117 @@
+/*
+ * Copyright (c) 1994, 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.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Member;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.GenericDeclaration;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.ref.SoftReference;
+import java.io.InputStream;
+import java.io.ObjectStreamField;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.LinkedList;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.Map;
+import java.util.HashMap;
+import sun.misc.Unsafe;
+import sun.reflect.ConstantPool;
+import sun.reflect.Reflection;
+import sun.reflect.ReflectionFactory;
+import sun.reflect.SignatureIterator;
+import sun.reflect.generics.factory.CoreReflectionFactory;
+import sun.reflect.generics.factory.GenericsFactory;
+import sun.reflect.generics.repository.ClassRepository;
+import sun.reflect.generics.repository.MethodRepository;
+import sun.reflect.generics.repository.ConstructorRepository;
+import sun.reflect.generics.scope.ClassScope;
+import sun.security.util.SecurityConstants;
+import java.lang.annotation.Annotation;
+import sun.reflect.annotation.*;
+
+/**
+ * Instances of the class {@code Class} represent classes and
+ * interfaces in a running Java application.  An enum is a kind of
+ * class and an annotation is a kind of interface.  Every array also
+ * belongs to a class that is reflected as a {@code Class} object
+ * that is shared by all arrays with the same element type and number
+ * of dimensions.  The primitive Java types ({@code boolean},
+ * {@code byte}, {@code char}, {@code short},
+ * {@code int}, {@code long}, {@code float}, and
+ * {@code double}), and the keyword {@code void} are also
+ * represented as {@code Class} objects.
+ *
+ * <p> {@code Class} has no public constructor. Instead {@code Class}
+ * objects are constructed automatically by the Java Virtual Machine as classes
+ * are loaded and by calls to the {@code defineClass} method in the class
+ * loader.
+ *
+ * <p> The following example uses a {@code Class} object to print the
+ * class name of an object:
+ *
+ * <p> <blockquote><pre>
+ *     void printClassName(Object obj) {
+ *         System.out.println("The class of " + obj +
+ *                            " is " + obj.getClass().getName());
+ *     }
+ * </pre></blockquote>
+ *
+ * <p> It is also possible to get the {@code Class} object for a named
+ * type (or for void) using a class literal.  See Section 15.8.2 of
+ * <cite>The Java&trade; Language Specification</cite>.
+ * For example:
+ *
+ * <p> <blockquote>
+ *     {@code System.out.println("The name of class Foo is: "+Foo.class.getName());}
+ * </blockquote>
+ *
+ * @param <T> the type of the class modeled by this {@code Class}
+ * object.  For example, the type of {@code String.class} is {@code
+ * Class<String>}.  Use {@code Class<?>} if the class being modeled is
+ * unknown.
+ *
+ * @author  unascribed
+ * @see     java.lang.ClassLoader#defineClass(byte[], int, int)
+ * @since   JDK1.0
+ */
+public final
+    class Class<T> implements java.io.Serializable,
+                              java.lang.reflect.GenericDeclaration,
+                              java.lang.reflect.Type,
+                              java.lang.reflect.AnnotatedElement {
+    private static final int ANNOTATION= 0x00002000;
+    private static final int ENUM      = 0x00004000;
+    private static final int SYNTHETIC = 0x00001000;
+
+    private static native void registerNatives();
+    static {
+        registerNatives();
+    }
+
+    /*
+     * Constructor. Only the Java Virtual Machine creates Class
+     * objects.
+     */
+    private Class() {}
+
+
+    /**
+     * Converts the object to a string. The string representation is the
+     * string "class" or "interface", followed by a space, and then by the
+     * fully qualified name of the class in the format returned by
+     * {@code getName}.  If this {@code Class} object represents a
+     * primitive type, this method returns the name of the primitive type.  If
+     * this {@code Class} object represents void this method returns
+     * "void".
+     *
+     * @return a string representation of this class object.
+     */
+    public String toString() {
+        return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
+            + getName();
+    }
+
+
+    /**
+     * Returns the {@code Class} object associated with the class or
+     * interface with the given string name.  Invoking this method is
+     * equivalent to:
+     *
+     * <blockquote>
+     *  {@code Class.forName(className, true, currentLoader)}
+     * </blockquote>
+     *
+     * where {@code currentLoader} denotes the defining class loader of
+     * the current class.
+     *
+     * <p> For example, the following code fragment returns the
+     * runtime {@code Class} descriptor for the class named
+     * {@code java.lang.Thread}:
+     *
+     * <blockquote>
+     *   {@code Class t = Class.forName("java.lang.Thread")}
+     * </blockquote>
+     * <p>
+     * A call to {@code forName("X")} causes the class named
+     * {@code X} to be initialized.
+     *
+     * @param      className   the fully qualified name of the desired class.
+     * @return     the {@code Class} object for the class with the
+     *             specified name.
+     * @exception LinkageError if the linkage fails
+     * @exception ExceptionInInitializerError if the initialization provoked
+     *            by this method fails
+     * @exception ClassNotFoundException if the class cannot be located
+     */
+    public static Class<?> forName(String className)
+                throws ClassNotFoundException {
+        return forName0(className, true, ClassLoader.getCallerClassLoader());
+    }
+
+
+    /**
+     * Returns the {@code Class} object associated with the class or
+     * interface with the given string name, using the given class loader.
+     * Given the fully qualified name for a class or interface (in the same
+     * format returned by {@code getName}) this method attempts to
+     * locate, load, and link the class or interface.  The specified class
+     * loader is used to load the class or interface.  If the parameter
+     * {@code loader} is null, the class is loaded through the bootstrap
+     * class loader.  The class is initialized only if the
+     * {@code initialize} parameter is {@code true} and if it has
+     * not been initialized earlier.
+     *
+     * <p> If {@code name} denotes a primitive type or void, an attempt
+     * will be made to locate a user-defined class in the unnamed package whose
+     * name is {@code name}. Therefore, this method cannot be used to
+     * obtain any of the {@code Class} objects representing primitive
+     * types or void.
+     *
+     * <p> If {@code name} denotes an array class, the component type of
+     * the array class is loaded but not initialized.
+     *
+     * <p> For example, in an instance method the expression:
+     *
+     * <blockquote>
+     *  {@code Class.forName("Foo")}
+     * </blockquote>
+     *
+     * is equivalent to:
+     *
+     * <blockquote>
+     *  {@code Class.forName("Foo", true, this.getClass().getClassLoader())}
+     * </blockquote>
+     *
+     * Note that this method throws errors related to loading, linking or
+     * initializing as specified in Sections 12.2, 12.3 and 12.4 of <em>The
+     * Java Language Specification</em>.
+     * Note that this method does not check whether the requested class
+     * is accessible to its caller.
+     *
+     * <p> If the {@code loader} is {@code null}, and a security
+     * manager is present, and the caller's class loader is not null, then this
+     * method calls the security manager's {@code checkPermission} method
+     * with a {@code RuntimePermission("getClassLoader")} permission to
+     * ensure it's ok to access the bootstrap class loader.
+     *
+     * @param name       fully qualified name of the desired class
+     * @param initialize whether the class must be initialized
+     * @param loader     class loader from which the class must be loaded
+     * @return           class object representing the desired class
+     *
+     * @exception LinkageError if the linkage fails
+     * @exception ExceptionInInitializerError if the initialization provoked
+     *            by this method fails
+     * @exception ClassNotFoundException if the class cannot be located by
+     *            the specified class loader
+     *
+     * @see       java.lang.Class#forName(String)
+     * @see       java.lang.ClassLoader
+     * @since     1.2
+     */
+    public static Class<?> forName(String name, boolean initialize,
+                                   ClassLoader loader)
+        throws ClassNotFoundException
+    {
+        if (loader == null) {
+            SecurityManager sm = System.getSecurityManager();
+            if (sm != null) {
+                ClassLoader ccl = ClassLoader.getCallerClassLoader();
+                if (ccl != null) {
+                    sm.checkPermission(
+                        SecurityConstants.GET_CLASSLOADER_PERMISSION);
+                }
+            }
+        }
+        return forName0(name, initialize, loader);
+    }
+
+    /** Called after security checks have been made. */
+    private static native Class<?> forName0(String name, boolean initialize,
+                                            ClassLoader loader)
+        throws ClassNotFoundException;
+
+    /**
+     * Creates a new instance of the class represented by this {@code Class}
+     * object.  The class is instantiated as if by a {@code new}
+     * expression with an empty argument list.  The class is initialized if it
+     * has not already been initialized.
+     *
+     * <p>Note that this method propagates any exception thrown by the
+     * nullary constructor, including a checked exception.  Use of
+     * this method effectively bypasses the compile-time exception
+     * checking that would otherwise be performed by the compiler.
+     * The {@link
+     * java.lang.reflect.Constructor#newInstance(java.lang.Object...)
+     * Constructor.newInstance} method avoids this problem by wrapping
+     * any exception thrown by the constructor in a (checked) {@link
+     * java.lang.reflect.InvocationTargetException}.
+     *
+     * @return     a newly allocated instance of the class represented by this
+     *             object.
+     * @exception  IllegalAccessException  if the class or its nullary
+     *               constructor is not accessible.
+     * @exception  InstantiationException
+     *               if this {@code Class} represents an abstract class,
+     *               an interface, an array class, a primitive type, or void;
+     *               or if the class has no nullary constructor;
+     *               or if the instantiation fails for some other reason.
+     * @exception  ExceptionInInitializerError if the initialization
+     *               provoked by this method fails.
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.PUBLIC)} denies
+     *             creation of new instances of this class
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     */
+    public T newInstance()
+        throws InstantiationException, IllegalAccessException
+    {
+        if (System.getSecurityManager() != null) {
+            checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
+        }
+        return newInstance0();
+    }
+
+    private T newInstance0()
+        throws InstantiationException, IllegalAccessException
+    {
+        // NOTE: the following code may not be strictly correct under
+        // the current Java memory model.
+
+        // Constructor lookup
+        if (cachedConstructor == null) {
+            if (this == Class.class) {
+                throw new IllegalAccessException(
+                    "Can not call newInstance() on the Class for java.lang.Class"
+                );
+            }
+            try {
+                Class<?>[] empty = {};
+                final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
+                // Disable accessibility checks on the constructor
+                // since we have to do the security check here anyway
+                // (the stack depth is wrong for the Constructor's
+                // security check to work)
+                java.security.AccessController.doPrivileged(
+                    new java.security.PrivilegedAction<Void>() {
+                        public Void run() {
+                                c.setAccessible(true);
+                                return null;
+                            }
+                        });
+                cachedConstructor = c;
+            } catch (NoSuchMethodException e) {
+                throw new InstantiationException(getName());
+            }
+        }
+        Constructor<T> tmpConstructor = cachedConstructor;
+        // Security check (same as in java.lang.reflect.Constructor)
+        int modifiers = tmpConstructor.getModifiers();
+        if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
+            Class<?> caller = Reflection.getCallerClass(3);
+            if (newInstanceCallerCache != caller) {
+                Reflection.ensureMemberAccess(caller, this, null, modifiers);
+                newInstanceCallerCache = caller;
+            }
+        }
+        // Run constructor
+        try {
+            return tmpConstructor.newInstance((Object[])null);
+        } catch (InvocationTargetException e) {
+            Unsafe.getUnsafe().throwException(e.getTargetException());
+            // Not reached
+            return null;
+        }
+    }
+    private volatile transient Constructor<T> cachedConstructor;
+    private volatile transient Class<?>       newInstanceCallerCache;
+
+
+    /**
+     * Determines if the specified {@code Object} is assignment-compatible
+     * with the object represented by this {@code Class}.  This method is
+     * the dynamic equivalent of the Java language {@code instanceof}
+     * operator. The method returns {@code true} if the specified
+     * {@code Object} argument is non-null and can be cast to the
+     * reference type represented by this {@code Class} object without
+     * raising a {@code ClassCastException.} It returns {@code false}
+     * otherwise.
+     *
+     * <p> Specifically, if this {@code Class} object represents a
+     * declared class, this method returns {@code true} if the specified
+     * {@code Object} argument is an instance of the represented class (or
+     * of any of its subclasses); it returns {@code false} otherwise. If
+     * this {@code Class} object represents an array class, this method
+     * returns {@code true} if the specified {@code Object} argument
+     * can be converted to an object of the array class by an identity
+     * conversion or by a widening reference conversion; it returns
+     * {@code false} otherwise. If this {@code Class} object
+     * represents an interface, this method returns {@code true} if the
+     * class or any superclass of the specified {@code Object} argument
+     * implements this interface; it returns {@code false} otherwise. If
+     * this {@code Class} object represents a primitive type, this method
+     * returns {@code false}.
+     *
+     * @param   obj the object to check
+     * @return  true if {@code obj} is an instance of this class
+     *
+     * @since JDK1.1
+     */
+    public native boolean isInstance(Object obj);
+
+
+    /**
+     * Determines if the class or interface represented by this
+     * {@code Class} object is either the same as, or is a superclass or
+     * superinterface of, the class or interface represented by the specified
+     * {@code Class} parameter. It returns {@code true} if so;
+     * otherwise it returns {@code false}. If this {@code Class}
+     * object represents a primitive type, this method returns
+     * {@code true} if the specified {@code Class} parameter is
+     * exactly this {@code Class} object; otherwise it returns
+     * {@code false}.
+     *
+     * <p> Specifically, this method tests whether the type represented by the
+     * specified {@code Class} parameter can be converted to the type
+     * represented by this {@code Class} object via an identity conversion
+     * or via a widening reference conversion. See <em>The Java Language
+     * Specification</em>, sections 5.1.1 and 5.1.4 , for details.
+     *
+     * @param cls the {@code Class} object to be checked
+     * @return the {@code boolean} value indicating whether objects of the
+     * type {@code cls} can be assigned to objects of this class
+     * @exception NullPointerException if the specified Class parameter is
+     *            null.
+     * @since JDK1.1
+     */
+    public native boolean isAssignableFrom(Class<?> cls);
+
+
+    /**
+     * Determines if the specified {@code Class} object represents an
+     * interface type.
+     *
+     * @return  {@code true} if this object represents an interface;
+     *          {@code false} otherwise.
+     */
+    public native boolean isInterface();
+
+
+    /**
+     * Determines if this {@code Class} object represents an array class.
+     *
+     * @return  {@code true} if this object represents an array class;
+     *          {@code false} otherwise.
+     * @since   JDK1.1
+     */
+    public native boolean isArray();
+
+
+    /**
+     * Determines if the specified {@code Class} object represents a
+     * primitive type.
+     *
+     * <p> There are nine predefined {@code Class} objects to represent
+     * the eight primitive types and void.  These are created by the Java
+     * Virtual Machine, and have the same names as the primitive types that
+     * they represent, namely {@code boolean}, {@code byte},
+     * {@code char}, {@code short}, {@code int},
+     * {@code long}, {@code float}, and {@code double}.
+     *
+     * <p> These objects may only be accessed via the following public static
+     * final variables, and are the only {@code Class} objects for which
+     * this method returns {@code true}.
+     *
+     * @return true if and only if this class represents a primitive type
+     *
+     * @see     java.lang.Boolean#TYPE
+     * @see     java.lang.Character#TYPE
+     * @see     java.lang.Byte#TYPE
+     * @see     java.lang.Short#TYPE
+     * @see     java.lang.Integer#TYPE
+     * @see     java.lang.Long#TYPE
+     * @see     java.lang.Float#TYPE
+     * @see     java.lang.Double#TYPE
+     * @see     java.lang.Void#TYPE
+     * @since JDK1.1
+     */
+    public native boolean isPrimitive();
+
+    /**
+     * Returns true if this {@code Class} object represents an annotation
+     * type.  Note that if this method returns true, {@link #isInterface()}
+     * would also return true, as all annotation types are also interfaces.
+     *
+     * @return {@code true} if this class object represents an annotation
+     *      type; {@code false} otherwise
+     * @since 1.5
+     */
+    public boolean isAnnotation() {
+        return (getModifiers() & ANNOTATION) != 0;
+    }
+
+    /**
+     * Returns {@code true} if this class is a synthetic class;
+     * returns {@code false} otherwise.
+     * @return {@code true} if and only if this class is a synthetic class as
+     *         defined by the Java Language Specification.
+     * @since 1.5
+     */
+    public boolean isSynthetic() {
+        return (getModifiers() & SYNTHETIC) != 0;
+    }
+
+    /**
+     * Returns the  name of the entity (class, interface, array class,
+     * primitive type, or void) represented by this {@code Class} object,
+     * as a {@code String}.
+     *
+     * <p> If this class object represents a reference type that is not an
+     * array type then the binary name of the class is returned, as specified
+     * by
+     * <cite>The Java&trade; Language Specification</cite>.
+     *
+     * <p> If this class object represents a primitive type or void, then the
+     * name returned is a {@code String} equal to the Java language
+     * keyword corresponding to the primitive type or void.
+     *
+     * <p> If this class object represents a class of arrays, then the internal
+     * form of the name consists of the name of the element type preceded by
+     * one or more '{@code [}' characters representing the depth of the array
+     * nesting.  The encoding of element type names is as follows:
+     *
+     * <blockquote><table summary="Element types and encodings">
+     * <tr><th> Element Type <th> &nbsp;&nbsp;&nbsp; <th> Encoding
+     * <tr><td> boolean      <td> &nbsp;&nbsp;&nbsp; <td align=center> Z
+     * <tr><td> byte         <td> &nbsp;&nbsp;&nbsp; <td align=center> B
+     * <tr><td> char         <td> &nbsp;&nbsp;&nbsp; <td align=center> C
+     * <tr><td> class or interface
+     *                       <td> &nbsp;&nbsp;&nbsp; <td align=center> L<i>classname</i>;
+     * <tr><td> double       <td> &nbsp;&nbsp;&nbsp; <td align=center> D
+     * <tr><td> float        <td> &nbsp;&nbsp;&nbsp; <td align=center> F
+     * <tr><td> int          <td> &nbsp;&nbsp;&nbsp; <td align=center> I
+     * <tr><td> long         <td> &nbsp;&nbsp;&nbsp; <td align=center> J
+     * <tr><td> short        <td> &nbsp;&nbsp;&nbsp; <td align=center> S
+     * </table></blockquote>
+     *
+     * <p> The class or interface name <i>classname</i> is the binary name of
+     * the class specified above.
+     *
+     * <p> Examples:
+     * <blockquote><pre>
+     * String.class.getName()
+     *     returns "java.lang.String"
+     * byte.class.getName()
+     *     returns "byte"
+     * (new Object[3]).getClass().getName()
+     *     returns "[Ljava.lang.Object;"
+     * (new int[3][4][5][6][7][8][9]).getClass().getName()
+     *     returns "[[[[[[[I"
+     * </pre></blockquote>
+     *
+     * @return  the name of the class or interface
+     *          represented by this object.
+     */
+    public String getName() {
+        String name = this.name;
+        if (name == null)
+            this.name = name = getName0();
+        return name;
+    }
+
+    // cache the name to reduce the number of calls into the VM
+    private transient String name;
+    private native String getName0();
+
+    /**
+     * Returns the class loader for the class.  Some implementations may use
+     * null to represent the bootstrap class loader. This method will return
+     * null in such implementations if this class was loaded by the bootstrap
+     * class loader.
+     *
+     * <p> If a security manager is present, and the caller's class loader is
+     * not null and the caller's class loader is not the same as or an ancestor of
+     * the class loader for the class whose class loader is requested, then
+     * this method calls the security manager's {@code checkPermission}
+     * method with a {@code RuntimePermission("getClassLoader")}
+     * permission to ensure it's ok to access the class loader for the class.
+     *
+     * <p>If this object
+     * represents a primitive type or void, null is returned.
+     *
+     * @return  the class loader that loaded the class or interface
+     *          represented by this object.
+     * @throws SecurityException
+     *    if a security manager exists and its
+     *    {@code checkPermission} method denies
+     *    access to the class loader for the class.
+     * @see java.lang.ClassLoader
+     * @see SecurityManager#checkPermission
+     * @see java.lang.RuntimePermission
+     */
+    public ClassLoader getClassLoader() {
+        ClassLoader cl = getClassLoader0();
+        if (cl == null)
+            return null;
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            ClassLoader ccl = ClassLoader.getCallerClassLoader();
+            if (ccl != null && ccl != cl && !cl.isAncestor(ccl)) {
+                sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
+            }
+        }
+        return cl;
+    }
+
+    // Package-private to allow ClassLoader access
+    native ClassLoader getClassLoader0();
+
+
+    /**
+     * Returns an array of {@code TypeVariable} objects that represent the
+     * type variables declared by the generic declaration represented by this
+     * {@code GenericDeclaration} object, in declaration order.  Returns an
+     * array of length 0 if the underlying generic declaration declares no type
+     * variables.
+     *
+     * @return an array of {@code TypeVariable} objects that represent
+     *     the type variables declared by this generic declaration
+     * @throws java.lang.reflect.GenericSignatureFormatError if the generic
+     *     signature of this generic declaration does not conform to
+     *     the format specified in
+     *     <cite>The Java&trade; Virtual Machine Specification</cite>
+     * @since 1.5
+     */
+    public TypeVariable<Class<T>>[] getTypeParameters() {
+        if (getGenericSignature() != null)
+            return (TypeVariable<Class<T>>[])getGenericInfo().getTypeParameters();
+        else
+            return (TypeVariable<Class<T>>[])new TypeVariable<?>[0];
+    }
+
+
+    /**
+     * Returns the {@code Class} representing the superclass of the entity
+     * (class, interface, primitive type or void) represented by this
+     * {@code Class}.  If this {@code Class} represents either the
+     * {@code Object} class, an interface, a primitive type, or void, then
+     * null is returned.  If this object represents an array class then the
+     * {@code Class} object representing the {@code Object} class is
+     * returned.
+     *
+     * @return the superclass of the class represented by this object.
+     */
+    public native Class<? super T> getSuperclass();
+
+
+    /**
+     * Returns the {@code Type} representing the direct superclass of
+     * the entity (class, interface, primitive type or void) represented by
+     * this {@code Class}.
+     *
+     * <p>If the superclass is a parameterized type, the {@code Type}
+     * object returned must accurately reflect the actual type
+     * parameters used in the source code. The parameterized type
+     * representing the superclass is created if it had not been
+     * created before. See the declaration of {@link
+     * java.lang.reflect.ParameterizedType ParameterizedType} for the
+     * semantics of the creation process for parameterized types.  If
+     * this {@code Class} represents either the {@code Object}
+     * class, an interface, a primitive type, or void, then null is
+     * returned.  If this object represents an array class then the
+     * {@code Class} object representing the {@code Object} class is
+     * returned.
+     *
+     * @throws java.lang.reflect.GenericSignatureFormatError if the generic
+     *     class signature does not conform to the format specified in
+     *     <cite>The Java&trade; Virtual Machine Specification</cite>
+     * @throws TypeNotPresentException if the generic superclass
+     *     refers to a non-existent type declaration
+     * @throws java.lang.reflect.MalformedParameterizedTypeException if the
+     *     generic superclass refers to a parameterized type that cannot be
+     *     instantiated  for any reason
+     * @return the superclass of the class represented by this object
+     * @since 1.5
+     */
+    public Type getGenericSuperclass() {
+        if (getGenericSignature() != null) {
+            // Historical irregularity:
+            // Generic signature marks interfaces with superclass = Object
+            // but this API returns null for interfaces
+            if (isInterface())
+                return null;
+            return getGenericInfo().getSuperclass();
+        } else
+            return getSuperclass();
+    }
+
+    /**
+     * Gets the package for this class.  The class loader of this class is used
+     * to find the package.  If the class was loaded by the bootstrap class
+     * loader the set of packages loaded from CLASSPATH is searched to find the
+     * package of the class. Null is returned if no package object was created
+     * by the class loader of this class.
+     *
+     * <p> Packages have attributes for versions and specifications only if the
+     * information was defined in the manifests that accompany the classes, and
+     * if the class loader created the package instance with the attributes
+     * from the manifest.
+     *
+     * @return the package of the class, or null if no package
+     *         information is available from the archive or codebase.
+     */
+    public Package getPackage() {
+        return Package.getPackage(this);
+    }
+
+
+    /**
+     * Determines the interfaces implemented by the class or interface
+     * represented by this object.
+     *
+     * <p> If this object represents a class, the return value is an array
+     * containing objects representing all interfaces implemented by the
+     * class. The order of the interface objects in the array corresponds to
+     * the order of the interface names in the {@code implements} clause
+     * of the declaration of the class represented by this object. For
+     * example, given the declaration:
+     * <blockquote>
+     * {@code class Shimmer implements FloorWax, DessertTopping { ... }}
+     * </blockquote>
+     * suppose the value of {@code s} is an instance of
+     * {@code Shimmer}; the value of the expression:
+     * <blockquote>
+     * {@code s.getClass().getInterfaces()[0]}
+     * </blockquote>
+     * is the {@code Class} object that represents interface
+     * {@code FloorWax}; and the value of:
+     * <blockquote>
+     * {@code s.getClass().getInterfaces()[1]}
+     * </blockquote>
+     * is the {@code Class} object that represents interface
+     * {@code DessertTopping}.
+     *
+     * <p> If this object represents an interface, the array contains objects
+     * representing all interfaces extended by the interface. The order of the
+     * interface objects in the array corresponds to the order of the interface
+     * names in the {@code extends} clause of the declaration of the
+     * interface represented by this object.
+     *
+     * <p> If this object represents a class or interface that implements no
+     * interfaces, the method returns an array of length 0.
+     *
+     * <p> If this object represents a primitive type or void, the method
+     * returns an array of length 0.
+     *
+     * @return an array of interfaces implemented by this class.
+     */
+    public native Class<?>[] getInterfaces();
+
+    /**
+     * Returns the {@code Type}s representing the interfaces
+     * directly implemented by the class or interface represented by
+     * this object.
+     *
+     * <p>If a superinterface is a parameterized type, the
+     * {@code Type} object returned for it must accurately reflect
+     * the actual type parameters used in the source code. The
+     * parameterized type representing each superinterface is created
+     * if it had not been created before. See the declaration of
+     * {@link java.lang.reflect.ParameterizedType ParameterizedType}
+     * for the semantics of the creation process for parameterized
+     * types.
+     *
+     * <p> If this object represents a class, the return value is an
+     * array containing objects representing all interfaces
+     * implemented by the class. The order of the interface objects in
+     * the array corresponds to the order of the interface names in
+     * the {@code implements} clause of the declaration of the class
+     * represented by this object.  In the case of an array class, the
+     * interfaces {@code Cloneable} and {@code Serializable} are
+     * returned in that order.
+     *
+     * <p>If this object represents an interface, the array contains
+     * objects representing all interfaces directly extended by the
+     * interface.  The order of the interface objects in the array
+     * corresponds to the order of the interface names in the
+     * {@code extends} clause of the declaration of the interface
+     * represented by this object.
+     *
+     * <p>If this object represents a class or interface that
+     * implements no interfaces, the method returns an array of length
+     * 0.
+     *
+     * <p>If this object represents a primitive type or void, the
+     * method returns an array of length 0.
+     *
+     * @throws java.lang.reflect.GenericSignatureFormatError
+     *     if the generic class signature does not conform to the format
+     *     specified in
+     *     <cite>The Java&trade; Virtual Machine Specification</cite>
+     * @throws TypeNotPresentException if any of the generic
+     *     superinterfaces refers to a non-existent type declaration
+     * @throws java.lang.reflect.MalformedParameterizedTypeException
+     *     if any of the generic superinterfaces refer to a parameterized
+     *     type that cannot be instantiated for any reason
+     * @return an array of interfaces implemented by this class
+     * @since 1.5
+     */
+    public Type[] getGenericInterfaces() {
+        if (getGenericSignature() != null)
+            return getGenericInfo().getSuperInterfaces();
+        else
+            return getInterfaces();
+    }
+
+
+    /**
+     * Returns the {@code Class} representing the component type of an
+     * array.  If this class does not represent an array class this method
+     * returns null.
+     *
+     * @return the {@code Class} representing the component type of this
+     * class if this class is an array
+     * @see     java.lang.reflect.Array
+     * @since JDK1.1
+     */
+    public native Class<?> getComponentType();
+
+
+    /**
+     * Returns the Java language modifiers for this class or interface, encoded
+     * in an integer. The modifiers consist of the Java Virtual Machine's
+     * constants for {@code public}, {@code protected},
+     * {@code private}, {@code final}, {@code static},
+     * {@code abstract} and {@code interface}; they should be decoded
+     * using the methods of class {@code Modifier}.
+     *
+     * <p> If the underlying class is an array class, then its
+     * {@code public}, {@code private} and {@code protected}
+     * modifiers are the same as those of its component type.  If this
+     * {@code Class} represents a primitive type or void, its
+     * {@code public} modifier is always {@code true}, and its
+     * {@code protected} and {@code private} modifiers are always
+     * {@code false}. If this object represents an array class, a
+     * primitive type or void, then its {@code final} modifier is always
+     * {@code true} and its interface modifier is always
+     * {@code false}. The values of its other modifiers are not determined
+     * by this specification.
+     *
+     * <p> The modifier encodings are defined in <em>The Java Virtual Machine
+     * Specification</em>, table 4.1.
+     *
+     * @return the {@code int} representing the modifiers for this class
+     * @see     java.lang.reflect.Modifier
+     * @since JDK1.1
+     */
+    public native int getModifiers();
+
+
+    /**
+     * Gets the signers of this class.
+     *
+     * @return  the signers of this class, or null if there are no signers.  In
+     *          particular, this method returns null if this object represents
+     *          a primitive type or void.
+     * @since   JDK1.1
+     */
+    public native Object[] getSigners();
+
+
+    /**
+     * Set the signers of this class.
+     */
+    native void setSigners(Object[] signers);
+
+
+    /**
+     * If this {@code Class} object represents a local or anonymous
+     * class within a method, returns a {@link
+     * java.lang.reflect.Method Method} object representing the
+     * immediately enclosing method of the underlying class. Returns
+     * {@code null} otherwise.
+     *
+     * In particular, this method returns {@code null} if the underlying
+     * class is a local or anonymous class immediately enclosed by a type
+     * declaration, instance initializer or static initializer.
+     *
+     * @return the immediately enclosing method of the underlying class, if
+     *     that class is a local or anonymous class; otherwise {@code null}.
+     * @since 1.5
+     */
+    public Method getEnclosingMethod() {
+        EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();
+
+        if (enclosingInfo == null)
+            return null;
+        else {
+            if (!enclosingInfo.isMethod())
+                return null;
+
+            MethodRepository typeInfo = MethodRepository.make(enclosingInfo.getDescriptor(),
+                                                              getFactory());
+            Class<?>   returnType       = toClass(typeInfo.getReturnType());
+            Type []    parameterTypes   = typeInfo.getParameterTypes();
+            Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];
+
+            // Convert Types to Classes; returned types *should*
+            // be class objects since the methodDescriptor's used
+            // don't have generics information
+            for(int i = 0; i < parameterClasses.length; i++)
+                parameterClasses[i] = toClass(parameterTypes[i]);
+
+            /*
+             * Loop over all declared methods; match method name,
+             * number of and type of parameters, *and* return
+             * type.  Matching return type is also necessary
+             * because of covariant returns, etc.
+             */
+            for(Method m: enclosingInfo.getEnclosingClass().getDeclaredMethods()) {
+                if (m.getName().equals(enclosingInfo.getName()) ) {
+                    Class<?>[] candidateParamClasses = m.getParameterTypes();
+                    if (candidateParamClasses.length == parameterClasses.length) {
+                        boolean matches = true;
+                        for(int i = 0; i < candidateParamClasses.length; i++) {
+                            if (!candidateParamClasses[i].equals(parameterClasses[i])) {
+                                matches = false;
+                                break;
+                            }
+                        }
+
+                        if (matches) { // finally, check return type
+                            if (m.getReturnType().equals(returnType) )
+                                return m;
+                        }
+                    }
+                }
+            }
+
+            throw new InternalError("Enclosing method not found");
+        }
+    }
+
+    private native Object[] getEnclosingMethod0();
+
+    private EnclosingMethodInfo getEnclosingMethodInfo() {
+        Object[] enclosingInfo = getEnclosingMethod0();
+        if (enclosingInfo == null)
+            return null;
+        else {
+            return new EnclosingMethodInfo(enclosingInfo);
+        }
+    }
+
+    private final static class EnclosingMethodInfo {
+        private Class<?> enclosingClass;
+        private String name;
+        private String descriptor;
+
+        private EnclosingMethodInfo(Object[] enclosingInfo) {
+            if (enclosingInfo.length != 3)
+                throw new InternalError("Malformed enclosing method information");
+            try {
+                // The array is expected to have three elements:
+
+                // the immediately enclosing class
+                enclosingClass = (Class<?>) enclosingInfo[0];
+                assert(enclosingClass != null);
+
+                // the immediately enclosing method or constructor's
+                // name (can be null).
+                name            = (String)   enclosingInfo[1];
+
+                // the immediately enclosing method or constructor's
+                // descriptor (null iff name is).
+                descriptor      = (String)   enclosingInfo[2];
+                assert((name != null && descriptor != null) || name == descriptor);
+            } catch (ClassCastException cce) {
+                throw new InternalError("Invalid type in enclosing method information");
+            }
+        }
+
+        boolean isPartial() {
+            return enclosingClass == null || name == null || descriptor == null;
+        }
+
+        boolean isConstructor() { return !isPartial() && "<init>".equals(name); }
+
+        boolean isMethod() { return !isPartial() && !isConstructor() && !"<clinit>".equals(name); }
+
+        Class<?> getEnclosingClass() { return enclosingClass; }
+
+        String getName() { return name; }
+
+        String getDescriptor() { return descriptor; }
+
+    }
+
+    private static Class<?> toClass(Type o) {
+        if (o instanceof GenericArrayType)
+            return Array.newInstance(toClass(((GenericArrayType)o).getGenericComponentType()),
+                                     0)
+                .getClass();
+        return (Class<?>)o;
+     }
+
+    /**
+     * If this {@code Class} object represents a local or anonymous
+     * class within a constructor, returns a {@link
+     * java.lang.reflect.Constructor Constructor} object representing
+     * the immediately enclosing constructor of the underlying
+     * class. Returns {@code null} otherwise.  In particular, this
+     * method returns {@code null} if the underlying class is a local
+     * or anonymous class immediately enclosed by a type declaration,
+     * instance initializer or static initializer.
+     *
+     * @return the immediately enclosing constructor of the underlying class, if
+     *     that class is a local or anonymous class; otherwise {@code null}.
+     * @since 1.5
+     */
+    public Constructor<?> getEnclosingConstructor() {
+        EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();
+
+        if (enclosingInfo == null)
+            return null;
+        else {
+            if (!enclosingInfo.isConstructor())
+                return null;
+
+            ConstructorRepository typeInfo = ConstructorRepository.make(enclosingInfo.getDescriptor(),
+                                                                        getFactory());
+            Type []    parameterTypes   = typeInfo.getParameterTypes();
+            Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];
+
+            // Convert Types to Classes; returned types *should*
+            // be class objects since the methodDescriptor's used
+            // don't have generics information
+            for(int i = 0; i < parameterClasses.length; i++)
+                parameterClasses[i] = toClass(parameterTypes[i]);
+
+            /*
+             * Loop over all declared constructors; match number
+             * of and type of parameters.
+             */
+            for(Constructor<?> c: enclosingInfo.getEnclosingClass().getDeclaredConstructors()) {
+                Class<?>[] candidateParamClasses = c.getParameterTypes();
+                if (candidateParamClasses.length == parameterClasses.length) {
+                    boolean matches = true;
+                    for(int i = 0; i < candidateParamClasses.length; i++) {
+                        if (!candidateParamClasses[i].equals(parameterClasses[i])) {
+                            matches = false;
+                            break;
+                        }
+                    }
+
+                    if (matches)
+                        return c;
+                }
+            }
+
+            throw new InternalError("Enclosing constructor not found");
+        }
+    }
+
+
+    /**
+     * If the class or interface represented by this {@code Class} object
+     * is a member of another class, returns the {@code Class} object
+     * representing the class in which it was declared.  This method returns
+     * null if this class or interface is not a member of any other class.  If
+     * this {@code Class} object represents an array class, a primitive
+     * type, or void,then this method returns null.
+     *
+     * @return the declaring class for this class
+     * @since JDK1.1
+     */
+    public native Class<?> getDeclaringClass();
+
+
+    /**
+     * Returns the immediately enclosing class of the underlying
+     * class.  If the underlying class is a top level class this
+     * method returns {@code null}.
+     * @return the immediately enclosing class of the underlying class
+     * @since 1.5
+     */
+    public Class<?> getEnclosingClass() {
+        // There are five kinds of classes (or interfaces):
+        // a) Top level classes
+        // b) Nested classes (static member classes)
+        // c) Inner classes (non-static member classes)
+        // d) Local classes (named classes declared within a method)
+        // e) Anonymous classes
+
+
+        // JVM Spec 4.8.6: A class must have an EnclosingMethod
+        // attribute if and only if it is a local class or an
+        // anonymous class.
+        EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();
+
+        if (enclosingInfo == null) {
+            // This is a top level or a nested class or an inner class (a, b, or c)
+            return getDeclaringClass();
+        } else {
+            Class<?> enclosingClass = enclosingInfo.getEnclosingClass();
+            // This is a local class or an anonymous class (d or e)
+            if (enclosingClass == this || enclosingClass == null)
+                throw new InternalError("Malformed enclosing method information");
+            else
+                return enclosingClass;
+        }
+    }
+
+    /**
+     * Returns the simple name of the underlying class as given in the
+     * source code. Returns an empty string if the underlying class is
+     * anonymous.
+     *
+     * <p>The simple name of an array is the simple name of the
+     * component type with "[]" appended.  In particular the simple
+     * name of an array whose component type is anonymous is "[]".
+     *
+     * @return the simple name of the underlying class
+     * @since 1.5
+     */
+    public String getSimpleName() {
+        if (isArray())
+            return getComponentType().getSimpleName()+"[]";
+
+        String simpleName = getSimpleBinaryName();
+        if (simpleName == null) { // top level class
+            simpleName = getName();
+            return simpleName.substring(simpleName.lastIndexOf(".")+1); // strip the package name
+        }
+        // According to JLS3 "Binary Compatibility" (13.1) the binary
+        // name of non-package classes (not top level) is the binary
+        // name of the immediately enclosing class followed by a '$' followed by:
+        // (for nested and inner classes): the simple name.
+        // (for local classes): 1 or more digits followed by the simple name.
+        // (for anonymous classes): 1 or more digits.
+
+        // Since getSimpleBinaryName() will strip the binary name of
+        // the immediatly enclosing class, we are now looking at a
+        // string that matches the regular expression "\$[0-9]*"
+        // followed by a simple name (considering the simple of an
+        // anonymous class to be the empty string).
+
+        // Remove leading "\$[0-9]*" from the name
+        int length = simpleName.length();
+        if (length < 1 || simpleName.charAt(0) != '$')
+            throw new InternalError("Malformed class name");
+        int index = 1;
+        while (index < length && isAsciiDigit(simpleName.charAt(index)))
+            index++;
+        // Eventually, this is the empty string iff this is an anonymous class
+        return simpleName.substring(index);
+    }
+
+    /**
+     * Character.isDigit answers {@code true} to some non-ascii
+     * digits.  This one does not.
+     */
+    private static boolean isAsciiDigit(char c) {
+        return '0' <= c && c <= '9';
+    }
+
+    /**
+     * Returns the canonical name of the underlying class as
+     * defined by the Java Language Specification.  Returns null if
+     * the underlying class does not have a canonical name (i.e., if
+     * it is a local or anonymous class or an array whose component
+     * type does not have a canonical name).
+     * @return the canonical name of the underlying class if it exists, and
+     * {@code null} otherwise.
+     * @since 1.5
+     */
+    public String getCanonicalName() {
+        if (isArray()) {
+            String canonicalName = getComponentType().getCanonicalName();
+            if (canonicalName != null)
+                return canonicalName + "[]";
+            else
+                return null;
+        }
+        if (isLocalOrAnonymousClass())
+            return null;
+        Class<?> enclosingClass = getEnclosingClass();
+        if (enclosingClass == null) { // top level class
+            return getName();
+        } else {
+            String enclosingName = enclosingClass.getCanonicalName();
+            if (enclosingName == null)
+                return null;
+            return enclosingName + "." + getSimpleName();
+        }
+    }
+
+    /**
+     * Returns {@code true} if and only if the underlying class
+     * is an anonymous class.
+     *
+     * @return {@code true} if and only if this class is an anonymous class.
+     * @since 1.5
+     */
+    public boolean isAnonymousClass() {
+        return "".equals(getSimpleName());
+    }
+
+    /**
+     * Returns {@code true} if and only if the underlying class
+     * is a local class.
+     *
+     * @return {@code true} if and only if this class is a local class.
+     * @since 1.5
+     */
+    public boolean isLocalClass() {
+        return isLocalOrAnonymousClass() && !isAnonymousClass();
+    }
+
+    /**
+     * Returns {@code true} if and only if the underlying class
+     * is a member class.
+     *
+     * @return {@code true} if and only if this class is a member class.
+     * @since 1.5
+     */
+    public boolean isMemberClass() {
+        return getSimpleBinaryName() != null && !isLocalOrAnonymousClass();
+    }
+
+    /**
+     * Returns the "simple binary name" of the underlying class, i.e.,
+     * the binary name without the leading enclosing class name.
+     * Returns {@code null} if the underlying class is a top level
+     * class.
+     */
+    private String getSimpleBinaryName() {
+        Class<?> enclosingClass = getEnclosingClass();
+        if (enclosingClass == null) // top level class
+            return null;
+        // Otherwise, strip the enclosing class' name
+        try {
+            return getName().substring(enclosingClass.getName().length());
+        } catch (IndexOutOfBoundsException ex) {
+            throw new InternalError("Malformed class name");
+        }
+    }
+
+    /**
+     * Returns {@code true} if this is a local class or an anonymous
+     * class.  Returns {@code false} otherwise.
+     */
+    private boolean isLocalOrAnonymousClass() {
+        // JVM Spec 4.8.6: A class must have an EnclosingMethod
+        // attribute if and only if it is a local class or an
+        // anonymous class.
+        return getEnclosingMethodInfo() != null;
+    }
+
+    /**
+     * Returns an array containing {@code Class} objects representing all
+     * the public classes and interfaces that are members of the class
+     * represented by this {@code Class} object.  This includes public
+     * class and interface members inherited from superclasses and public class
+     * and interface members declared by the class.  This method returns an
+     * array of length 0 if this {@code Class} object has no public member
+     * classes or interfaces.  This method also returns an array of length 0 if
+     * this {@code Class} object represents a primitive type, an array
+     * class, or void.
+     *
+     * @return the array of {@code Class} objects representing the public
+     * members of this class
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.PUBLIC)} method
+     *             denies access to the classes within this class
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Class<?>[] getClasses() {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
+
+        // Privileged so this implementation can look at DECLARED classes,
+        // something the caller might not have privilege to do.  The code here
+        // is allowed to look at DECLARED classes because (1) it does not hand
+        // out anything other than public members and (2) public member access
+        // has already been ok'd by the SecurityManager.
+
+        return java.security.AccessController.doPrivileged(
+            new java.security.PrivilegedAction<Class<?>[]>() {
+                public Class[] run() {
+                    List<Class<?>> list = new ArrayList<>();
+                    Class<?> currentClass = Class.this;
+                    while (currentClass != null) {
+                        Class<?>[] members = currentClass.getDeclaredClasses();
+                        for (int i = 0; i < members.length; i++) {
+                            if (Modifier.isPublic(members[i].getModifiers())) {
+                                list.add(members[i]);
+                            }
+                        }
+                        currentClass = currentClass.getSuperclass();
+                    }
+                    return list.toArray(new Class[0]);
+                }
+            });
+    }
+
+
+    /**
+     * Returns an array containing {@code Field} objects reflecting all
+     * the accessible public fields of the class or interface represented by
+     * this {@code Class} object.  The elements in the array returned are
+     * not sorted and are not in any particular order.  This method returns an
+     * array of length 0 if the class or interface has no accessible public
+     * fields, or if it represents an array class, a primitive type, or void.
+     *
+     * <p> Specifically, if this {@code Class} object represents a class,
+     * this method returns the public fields of this class and of all its
+     * superclasses.  If this {@code Class} object represents an
+     * interface, this method returns the fields of this interface and of all
+     * its superinterfaces.
+     *
+     * <p> The implicit length field for array class is not reflected by this
+     * method. User code should use the methods of class {@code Array} to
+     * manipulate arrays.
+     *
+     * <p> See <em>The Java Language Specification</em>, sections 8.2 and 8.3.
+     *
+     * @return the array of {@code Field} objects representing the
+     * public fields
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.PUBLIC)} denies
+     *             access to the fields within this class
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Field[] getFields() throws SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
+        return copyFields(privateGetPublicFields(null));
+    }
+
+
+    /**
+     * Returns an array containing {@code Method} objects reflecting all
+     * the public <em>member</em> methods of the class or interface represented
+     * by this {@code Class} object, including those declared by the class
+     * or interface and those inherited from superclasses and
+     * superinterfaces.  Array classes return all the (public) member methods
+     * inherited from the {@code Object} class.  The elements in the array
+     * returned are not sorted and are not in any particular order.  This
+     * method returns an array of length 0 if this {@code Class} object
+     * represents a class or interface that has no public member methods, or if
+     * this {@code Class} object represents a primitive type or void.
+     *
+     * <p> The class initialization method {@code <clinit>} is not
+     * included in the returned array. If the class declares multiple public
+     * member methods with the same parameter types, they are all included in
+     * the returned array.
+     *
+     * <p> See <em>The Java Language Specification</em>, sections 8.2 and 8.4.
+     *
+     * @return the array of {@code Method} objects representing the
+     * public methods of this class
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.PUBLIC)} denies
+     *             access to the methods within this class
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Method[] getMethods() throws SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
+        return copyMethods(privateGetPublicMethods());
+    }
+
+
+    /**
+     * Returns an array containing {@code Constructor} objects reflecting
+     * all the public constructors of the class represented by this
+     * {@code Class} object.  An array of length 0 is returned if the
+     * class has no public constructors, or if the class is an array class, or
+     * if the class reflects a primitive type or void.
+     *
+     * Note that while this method returns an array of {@code
+     * Constructor<T>} objects (that is an array of constructors from
+     * this class), the return type of this method is {@code
+     * Constructor<?>[]} and <em>not</em> {@code Constructor<T>[]} as
+     * might be expected.  This less informative return type is
+     * necessary since after being returned from this method, the
+     * array could be modified to hold {@code Constructor} objects for
+     * different classes, which would violate the type guarantees of
+     * {@code Constructor<T>[]}.
+     *
+     * @return the array of {@code Constructor} objects representing the
+     *  public constructors of this class
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.PUBLIC)} denies
+     *             access to the constructors within this class
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Constructor<?>[] getConstructors() throws SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
+        return copyConstructors(privateGetDeclaredConstructors(true));
+    }
+
+
+    /**
+     * Returns a {@code Field} object that reflects the specified public
+     * member field of the class or interface represented by this
+     * {@code Class} object. The {@code name} parameter is a
+     * {@code String} specifying the simple name of the desired field.
+     *
+     * <p> The field to be reflected is determined by the algorithm that
+     * follows.  Let C be the class represented by this object:
+     * <OL>
+     * <LI> If C declares a public field with the name specified, that is the
+     *      field to be reflected.</LI>
+     * <LI> If no field was found in step 1 above, this algorithm is applied
+     *      recursively to each direct superinterface of C. The direct
+     *      superinterfaces are searched in the order they were declared.</LI>
+     * <LI> If no field was found in steps 1 and 2 above, and C has a
+     *      superclass S, then this algorithm is invoked recursively upon S.
+     *      If C has no superclass, then a {@code NoSuchFieldException}
+     *      is thrown.</LI>
+     * </OL>
+     *
+     * <p> See <em>The Java Language Specification</em>, sections 8.2 and 8.3.
+     *
+     * @param name the field name
+     * @return  the {@code Field} object of this class specified by
+     * {@code name}
+     * @exception NoSuchFieldException if a field with the specified name is
+     *              not found.
+     * @exception NullPointerException if {@code name} is {@code null}
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.PUBLIC)} denies
+     *             access to the field
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Field getField(String name)
+        throws NoSuchFieldException, SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
+        Field field = getField0(name);
+        if (field == null) {
+            throw new NoSuchFieldException(name);
+        }
+        return field;
+    }
+
+
+    /**
+     * Returns a {@code Method} object that reflects the specified public
+     * member method of the class or interface represented by this
+     * {@code Class} object. The {@code name} parameter is a
+     * {@code String} specifying the simple name of the desired method. The
+     * {@code parameterTypes} parameter is an array of {@code Class}
+     * objects that identify the method's formal parameter types, in declared
+     * order. If {@code parameterTypes} is {@code null}, it is
+     * treated as if it were an empty array.
+     *
+     * <p> If the {@code name} is "{@code <init>};"or "{@code <clinit>}" a
+     * {@code NoSuchMethodException} is raised. Otherwise, the method to
+     * be reflected is determined by the algorithm that follows.  Let C be the
+     * class represented by this object:
+     * <OL>
+     * <LI> C is searched for any <I>matching methods</I>. If no matching
+     *      method is found, the algorithm of step 1 is invoked recursively on
+     *      the superclass of C.</LI>
+     * <LI> If no method was found in step 1 above, the superinterfaces of C
+     *      are searched for a matching method. If any such method is found, it
+     *      is reflected.</LI>
+     * </OL>
+     *
+     * To find a matching method in a class C:&nbsp; If C declares exactly one
+     * public method with the specified name and exactly the same formal
+     * parameter types, that is the method reflected. If more than one such
+     * method is found in C, and one of these methods has a return type that is
+     * more specific than any of the others, that method is reflected;
+     * otherwise one of the methods is chosen arbitrarily.
+     *
+     * <p>Note that there may be more than one matching method in a
+     * class because while the Java language forbids a class to
+     * declare multiple methods with the same signature but different
+     * return types, the Java virtual machine does not.  This
+     * increased flexibility in the virtual machine can be used to
+     * implement various language features.  For example, covariant
+     * returns can be implemented with {@linkplain
+     * java.lang.reflect.Method#isBridge bridge methods}; the bridge
+     * method and the method being overridden would have the same
+     * signature but different return types.
+     *
+     * <p> See <em>The Java Language Specification</em>, sections 8.2 and 8.4.
+     *
+     * @param name the name of the method
+     * @param parameterTypes the list of parameters
+     * @return the {@code Method} object that matches the specified
+     * {@code name} and {@code parameterTypes}
+     * @exception NoSuchMethodException if a matching method is not found
+     *            or if the name is "&lt;init&gt;"or "&lt;clinit&gt;".
+     * @exception NullPointerException if {@code name} is {@code null}
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.PUBLIC)} denies
+     *             access to the method
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Method getMethod(String name, Class<?>... parameterTypes)
+        throws NoSuchMethodException, SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
+        Method method = getMethod0(name, parameterTypes);
+        if (method == null) {
+            throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
+        }
+        return method;
+    }
+
+
+    /**
+     * Returns a {@code Constructor} object that reflects the specified
+     * public constructor of the class represented by this {@code Class}
+     * object. The {@code parameterTypes} parameter is an array of
+     * {@code Class} objects that identify the constructor's formal
+     * parameter types, in declared order.
+     *
+     * If this {@code Class} object represents an inner class
+     * declared in a non-static context, the formal parameter types
+     * include the explicit enclosing instance as the first parameter.
+     *
+     * <p> The constructor to reflect is the public constructor of the class
+     * represented by this {@code Class} object whose formal parameter
+     * types match those specified by {@code parameterTypes}.
+     *
+     * @param parameterTypes the parameter array
+     * @return the {@code Constructor} object of the public constructor that
+     * matches the specified {@code parameterTypes}
+     * @exception NoSuchMethodException if a matching method is not found.
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.PUBLIC)} denies
+     *             access to the constructor
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Constructor<T> getConstructor(Class<?>... parameterTypes)
+        throws NoSuchMethodException, SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
+        return getConstructor0(parameterTypes, Member.PUBLIC);
+    }
+
+
+    /**
+     * Returns an array of {@code Class} objects reflecting all the
+     * classes and interfaces declared as members of the class represented by
+     * this {@code Class} object. This includes public, protected, default
+     * (package) access, and private classes and interfaces declared by the
+     * class, but excludes inherited classes and interfaces.  This method
+     * returns an array of length 0 if the class declares no classes or
+     * interfaces as members, or if this {@code Class} object represents a
+     * primitive type, an array class, or void.
+     *
+     * @return the array of {@code Class} objects representing all the
+     * declared members of this class
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.DECLARED)} denies
+     *             access to the declared classes within this class
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Class<?>[] getDeclaredClasses() throws SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
+        return getDeclaredClasses0();
+    }
+
+
+    /**
+     * Returns an array of {@code Field} objects reflecting all the fields
+     * declared by the class or interface represented by this
+     * {@code Class} object. This includes public, protected, default
+     * (package) access, and private fields, but excludes inherited fields.
+     * The elements in the array returned are not sorted and are not in any
+     * particular order.  This method returns an array of length 0 if the class
+     * or interface declares no fields, or if this {@code Class} object
+     * represents a primitive type, an array class, or void.
+     *
+     * <p> See <em>The Java Language Specification</em>, sections 8.2 and 8.3.
+     *
+     * @return    the array of {@code Field} objects representing all the
+     * declared fields of this class
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.DECLARED)} denies
+     *             access to the declared fields within this class
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Field[] getDeclaredFields() throws SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
+        return copyFields(privateGetDeclaredFields(false));
+    }
+
+
+    /**
+     * Returns an array of {@code Method} objects reflecting all the
+     * methods declared by the class or interface represented by this
+     * {@code Class} object. This includes public, protected, default
+     * (package) access, and private methods, but excludes inherited methods.
+     * The elements in the array returned are not sorted and are not in any
+     * particular order.  This method returns an array of length 0 if the class
+     * or interface declares no methods, or if this {@code Class} object
+     * represents a primitive type, an array class, or void.  The class
+     * initialization method {@code <clinit>} is not included in the
+     * returned array. If the class declares multiple public member methods
+     * with the same parameter types, they are all included in the returned
+     * array.
+     *
+     * <p> See <em>The Java Language Specification</em>, section 8.2.
+     *
+     * @return    the array of {@code Method} objects representing all the
+     * declared methods of this class
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.DECLARED)} denies
+     *             access to the declared methods within this class
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Method[] getDeclaredMethods() throws SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
+        return copyMethods(privateGetDeclaredMethods(false));
+    }
+
+
+    /**
+     * Returns an array of {@code Constructor} objects reflecting all the
+     * constructors declared by the class represented by this
+     * {@code Class} object. These are public, protected, default
+     * (package) access, and private constructors.  The elements in the array
+     * returned are not sorted and are not in any particular order.  If the
+     * class has a default constructor, it is included in the returned array.
+     * This method returns an array of length 0 if this {@code Class}
+     * object represents an interface, a primitive type, an array class, or
+     * void.
+     *
+     * <p> See <em>The Java Language Specification</em>, section 8.2.
+     *
+     * @return    the array of {@code Constructor} objects representing all the
+     * declared constructors of this class
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.DECLARED)} denies
+     *             access to the declared constructors within this class
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Constructor<?>[] getDeclaredConstructors() throws SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
+        return copyConstructors(privateGetDeclaredConstructors(false));
+    }
+
+
+    /**
+     * Returns a {@code Field} object that reflects the specified declared
+     * field of the class or interface represented by this {@code Class}
+     * object. The {@code name} parameter is a {@code String} that
+     * specifies the simple name of the desired field.  Note that this method
+     * will not reflect the {@code length} field of an array class.
+     *
+     * @param name the name of the field
+     * @return the {@code Field} object for the specified field in this
+     * class
+     * @exception NoSuchFieldException if a field with the specified name is
+     *              not found.
+     * @exception NullPointerException if {@code name} is {@code null}
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.DECLARED)} denies
+     *             access to the declared field
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Field getDeclaredField(String name)
+        throws NoSuchFieldException, SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
+        Field field = searchFields(privateGetDeclaredFields(false), name);
+        if (field == null) {
+            throw new NoSuchFieldException(name);
+        }
+        return field;
+    }
+
+
+    /**
+     * Returns a {@code Method} object that reflects the specified
+     * declared method of the class or interface represented by this
+     * {@code Class} object. The {@code name} parameter is a
+     * {@code String} that specifies the simple name of the desired
+     * method, and the {@code parameterTypes} parameter is an array of
+     * {@code Class} objects that identify the method's formal parameter
+     * types, in declared order.  If more than one method with the same
+     * parameter types is declared in a class, and one of these methods has a
+     * return type that is more specific than any of the others, that method is
+     * returned; otherwise one of the methods is chosen arbitrarily.  If the
+     * name is "&lt;init&gt;"or "&lt;clinit&gt;" a {@code NoSuchMethodException}
+     * is raised.
+     *
+     * @param name the name of the method
+     * @param parameterTypes the parameter array
+     * @return    the {@code Method} object for the method of this class
+     * matching the specified name and parameters
+     * @exception NoSuchMethodException if a matching method is not found.
+     * @exception NullPointerException if {@code name} is {@code null}
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.DECLARED)} denies
+     *             access to the declared method
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
+        throws NoSuchMethodException, SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
+        Method method = searchMethods(privateGetDeclaredMethods(false), name, parameterTypes);
+        if (method == null) {
+            throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
+        }
+        return method;
+    }
+
+
+    /**
+     * Returns a {@code Constructor} object that reflects the specified
+     * constructor of the class or interface represented by this
+     * {@code Class} object.  The {@code parameterTypes} parameter is
+     * an array of {@code Class} objects that identify the constructor's
+     * formal parameter types, in declared order.
+     *
+     * If this {@code Class} object represents an inner class
+     * declared in a non-static context, the formal parameter types
+     * include the explicit enclosing instance as the first parameter.
+     *
+     * @param parameterTypes the parameter array
+     * @return    The {@code Constructor} object for the constructor with the
+     * specified parameter list
+     * @exception NoSuchMethodException if a matching method is not found.
+     * @exception  SecurityException
+     *             If a security manager, <i>s</i>, is present and any of the
+     *             following conditions is met:
+     *
+     *             <ul>
+     *
+     *             <li> invocation of
+     *             {@link SecurityManager#checkMemberAccess
+     *             s.checkMemberAccess(this, Member.DECLARED)} denies
+     *             access to the declared constructor
+     *
+     *             <li> the caller's class loader is not the same as or an
+     *             ancestor of the class loader for the current class and
+     *             invocation of {@link SecurityManager#checkPackageAccess
+     *             s.checkPackageAccess()} denies access to the package
+     *             of this class
+     *
+     *             </ul>
+     *
+     * @since JDK1.1
+     */
+    public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
+        throws NoSuchMethodException, SecurityException {
+        // be very careful not to change the stack depth of this
+        // checkMemberAccess call for security reasons
+        // see java.lang.SecurityManager.checkMemberAccess
+        checkMemberAccess(Member.DECLARED, ClassLoader.getCallerClassLoader());
+        return getConstructor0(parameterTypes, Member.DECLARED);
+    }
+
+    /**
+     * Finds a resource with a given name.  The rules for searching resources
+     * associated with a given class are implemented by the defining
+     * {@linkplain ClassLoader class loader} of the class.  This method
+     * delegates to this object's class loader.  If this object was loaded by
+     * the bootstrap class loader, the method delegates to {@link
+     * ClassLoader#getSystemResourceAsStream}.
+     *
+     * <p> Before delegation, an absolute resource name is constructed from the
+     * given resource name using this algorithm:
+     *
+     * <ul>
+     *
+     * <li> If the {@code name} begins with a {@code '/'}
+     * (<tt>'&#92;u002f'</tt>), then the absolute name of the resource is the
+     * portion of the {@code name} following the {@code '/'}.
+     *
+     * <li> Otherwise, the absolute name is of the following form:
+     *
+     * <blockquote>
+     *   {@code modified_package_name/name}
+     * </blockquote>
+     *
+     * <p> Where the {@code modified_package_name} is the package name of this
+     * object with {@code '/'} substituted for {@code '.'}
+     * (<tt>'&#92;u002e'</tt>).
+     *
+     * </ul>
+     *
+     * @param  name name of the desired resource
+     * @return      A {@link java.io.InputStream} object or {@code null} if
+     *              no resource with this name is found
+     * @throws  NullPointerException If {@code name} is {@code null}
+     * @since  JDK1.1
+     */
+     public InputStream getResourceAsStream(String name) {
+        name = resolveName(name);
+        ClassLoader cl = getClassLoader0();
+        if (cl==null) {
+            // A system class.
+            return ClassLoader.getSystemResourceAsStream(name);
+        }
+        return cl.getResourceAsStream(name);
+    }
+
+    /**
+     * Finds a resource with a given name.  The rules for searching resources
+     * associated with a given class are implemented by the defining
+     * {@linkplain ClassLoader class loader} of the class.  This method
+     * delegates to this object's class loader.  If this object was loaded by
+     * the bootstrap class loader, the method delegates to {@link
+     * ClassLoader#getSystemResource}.
+     *
+     * <p> Before delegation, an absolute resource name is constructed from the
+     * given resource name using this algorithm:
+     *
+     * <ul>
+     *
+     * <li> If the {@code name} begins with a {@code '/'}
+     * (<tt>'&#92;u002f'</tt>), then the absolute name of the resource is the
+     * portion of the {@code name} following the {@code '/'}.
+     *
+     * <li> Otherwise, the absolute name is of the following form:
+     *
+     * <blockquote>
+     *   {@code modified_package_name/name}
+     * </blockquote>
+     *
+     * <p> Where the {@code modified_package_name} is the package name of this
+     * object with {@code '/'} substituted for {@code '.'}
+     * (<tt>'&#92;u002e'</tt>).
+     *
+     * </ul>
+     *
+     * @param  name name of the desired resource
+     * @return      A  {@link java.net.URL} object or {@code null} if no
+     *              resource with this name is found
+     * @since  JDK1.1
+     */
+    public java.net.URL getResource(String name) {
+        name = resolveName(name);
+        ClassLoader cl = getClassLoader0();
+        if (cl==null) {
+            // A system class.
+            return ClassLoader.getSystemResource(name);
+        }
+        return cl.getResource(name);
+    }
+
+
+
+    /** protection domain returned when the internal domain is null */
+    private static java.security.ProtectionDomain allPermDomain;
+
+
+    /**
+     * Returns the {@code ProtectionDomain} of this class.  If there is a
+     * security manager installed, this method first calls the security
+     * manager's {@code checkPermission} method with a
+     * {@code RuntimePermission("getProtectionDomain")} permission to
+     * ensure it's ok to get the
+     * {@code ProtectionDomain}.
+     *
+     * @return the ProtectionDomain of this class
+     *
+     * @throws SecurityException
+     *        if a security manager exists and its
+     *        {@code checkPermission} method doesn't allow
+     *        getting the ProtectionDomain.
+     *
+     * @see java.security.ProtectionDomain
+     * @see SecurityManager#checkPermission
+     * @see java.lang.RuntimePermission
+     * @since 1.2
+     */
+    public java.security.ProtectionDomain getProtectionDomain() {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            sm.checkPermission(SecurityConstants.GET_PD_PERMISSION);
+        }
+        java.security.ProtectionDomain pd = getProtectionDomain0();
+        if (pd == null) {
+            if (allPermDomain == null) {
+                java.security.Permissions perms =
+                    new java.security.Permissions();
+                perms.add(SecurityConstants.ALL_PERMISSION);
+                allPermDomain =
+                    new java.security.ProtectionDomain(null, perms);
+            }
+            pd = allPermDomain;
+        }
+        return pd;
+    }
+
+
+    /**
+     * Returns the ProtectionDomain of this class.
+     */
+    private native java.security.ProtectionDomain getProtectionDomain0();
+
+
+    /**
+     * Set the ProtectionDomain for this class. Called by
+     * ClassLoader.defineClass.
+     */
+    native void setProtectionDomain0(java.security.ProtectionDomain pd);
+
+
+    /*
+     * Return the Virtual Machine's Class object for the named
+     * primitive type.
+     */
+    static native Class getPrimitiveClass(String name);
+
+
+    /*
+     * Check if client is allowed to access members.  If access is denied,
+     * throw a SecurityException.
+     *
+     * Be very careful not to change the stack depth of this checkMemberAccess
+     * call for security reasons.
+     * See java.lang.SecurityManager.checkMemberAccess.
+     *
+     * <p> Default policy: allow all clients access with normal Java access
+     * control.
+     */
+    private void checkMemberAccess(int which, ClassLoader ccl) {
+        SecurityManager s = System.getSecurityManager();
+        if (s != null) {
+            s.checkMemberAccess(this, which);
+            ClassLoader cl = getClassLoader0();
+            if ((ccl != null) && (ccl != cl) &&
+                  ((cl == null) || !cl.isAncestor(ccl))) {
+                String name = this.getName();
+                int i = name.lastIndexOf('.');
+                if (i != -1) {
+                    s.checkPackageAccess(name.substring(0, i));
+                }
+            }
+        }
+    }
+
+    /**
+     * Add a package name prefix if the name is not absolute Remove leading "/"
+     * if name is absolute
+     */
+    private String resolveName(String name) {
+        if (name == null) {
+            return name;
+        }
+        if (!name.startsWith("/")) {
+            Class<?> c = this;
+            while (c.isArray()) {
+                c = c.getComponentType();
+            }
+            String baseName = c.getName();
+            int index = baseName.lastIndexOf('.');
+            if (index != -1) {
+                name = baseName.substring(0, index).replace('.', '/')
+                    +"/"+name;
+            }
+        } else {
+            name = name.substring(1);
+        }
+        return name;
+    }
+
+    /**
+     * Reflection support.
+     */
+
+    // Caches for certain reflective results
+    private static boolean useCaches = true;
+    private volatile transient SoftReference<Field[]> declaredFields;
+    private volatile transient SoftReference<Field[]> publicFields;
+    private volatile transient SoftReference<Method[]> declaredMethods;
+    private volatile transient SoftReference<Method[]> publicMethods;
+    private volatile transient SoftReference<Constructor<T>[]> declaredConstructors;
+    private volatile transient SoftReference<Constructor<T>[]> publicConstructors;
+    // Intermediate results for getFields and getMethods
+    private volatile transient SoftReference<Field[]> declaredPublicFields;
+    private volatile transient SoftReference<Method[]> declaredPublicMethods;
+
+    // Incremented by the VM on each call to JVM TI RedefineClasses()
+    // that redefines this class or a superclass.
+    private volatile transient int classRedefinedCount = 0;
+
+    // Value of classRedefinedCount when we last cleared the cached values
+    // that are sensitive to class redefinition.
+    private volatile transient int lastRedefinedCount = 0;
+
+    // Clears cached values that might possibly have been obsoleted by
+    // a class redefinition.
+    private void clearCachesOnClassRedefinition() {
+        if (lastRedefinedCount != classRedefinedCount) {
+            declaredFields = publicFields = declaredPublicFields = null;
+            declaredMethods = publicMethods = declaredPublicMethods = null;
+            declaredConstructors = publicConstructors = null;
+            annotations = declaredAnnotations = null;
+
+            // Use of "volatile" (and synchronization by caller in the case
+            // of annotations) ensures that no thread sees the update to
+            // lastRedefinedCount before seeing the caches cleared.
+            // We do not guard against brief windows during which multiple
+            // threads might redundantly work to fill an empty cache.
+            lastRedefinedCount = classRedefinedCount;
+        }
+    }
+
+    // Generic signature handling
+    private native String getGenericSignature();
+
+    // Generic info repository; lazily initialized
+    private transient ClassRepository genericInfo;
+
+    // accessor for factory
+    private GenericsFactory getFactory() {
+        // create scope and factory
+        return CoreReflectionFactory.make(this, ClassScope.make(this));
+    }
+
+    // accessor for generic info repository
+    private ClassRepository getGenericInfo() {
+        // lazily initialize repository if necessary
+        if (genericInfo == null) {
+            // create and cache generic info repository
+            genericInfo = ClassRepository.make(getGenericSignature(),
+                                               getFactory());
+        }
+        return genericInfo; //return cached repository
+    }
+
+    // Annotations handling
+    private native byte[] getRawAnnotations();
+
+    native ConstantPool getConstantPool();
+
+    //
+    //
+    // java.lang.reflect.Field handling
+    //
+    //
+
+    // Returns an array of "root" fields. These Field objects must NOT
+    // be propagated to the outside world, but must instead be copied
+    // via ReflectionFactory.copyField.
+    private Field[] privateGetDeclaredFields(boolean publicOnly) {
+        checkInitted();
+        Field[] res = null;
+        if (useCaches) {
+            clearCachesOnClassRedefinition();
+            if (publicOnly) {
+                if (declaredPublicFields != null) {
+                    res = declaredPublicFields.get();
+                }
+            } else {
+                if (declaredFields != null) {
+                    res = declaredFields.get();
+                }
+            }
+            if (res != null) return res;
+        }
+        // No cached value available; request value from VM
+        res = Reflection.filterFields(this, getDeclaredFields0(publicOnly));
+        if (useCaches) {
+            if (publicOnly) {
+                declaredPublicFields = new SoftReference<>(res);
+            } else {
+                declaredFields = new SoftReference<>(res);
+            }
+        }
+        return res;
+    }
+
+    // Returns an array of "root" fields. These Field objects must NOT
+    // be propagated to the outside world, but must instead be copied
+    // via ReflectionFactory.copyField.
+    private Field[] privateGetPublicFields(Set<Class<?>> traversedInterfaces) {
+        checkInitted();
+        Field[] res = null;
+        if (useCaches) {
+            clearCachesOnClassRedefinition();
+            if (publicFields != null) {
+                res = publicFields.get();
+            }
+            if (res != null) return res;
+        }
+
+        // No cached value available; compute value recursively.
+        // Traverse in correct order for getField().
+        List<Field> fields = new ArrayList<>();
+        if (traversedInterfaces == null) {
+            traversedInterfaces = new HashSet<>();
+        }
+
+        // Local fields
+        Field[] tmp = privateGetDeclaredFields(true);
+        addAll(fields, tmp);
+
+        // Direct superinterfaces, recursively
+        for (Class<?> c : getInterfaces()) {
+            if (!traversedInterfaces.contains(c)) {
+                traversedInterfaces.add(c);
+                addAll(fields, c.privateGetPublicFields(traversedInterfaces));
+            }
+        }
+
+        // Direct superclass, recursively
+        if (!isInterface()) {
+            Class<?> c = getSuperclass();
+            if (c != null) {
+                addAll(fields, c.privateGetPublicFields(traversedInterfaces));
+            }
+        }
+
+        res = new Field[fields.size()];
+        fields.toArray(res);
+        if (useCaches) {
+            publicFields = new SoftReference<>(res);
+        }
+        return res;
+    }
+
+    private static void addAll(Collection<Field> c, Field[] o) {
+        for (int i = 0; i < o.length; i++) {
+            c.add(o[i]);
+        }
+    }
+
+
+    //
+    //
+    // java.lang.reflect.Constructor handling
+    //
+    //
+
+    // Returns an array of "root" constructors. These Constructor
+    // objects must NOT be propagated to the outside world, but must
+    // instead be copied via ReflectionFactory.copyConstructor.
+    private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
+        checkInitted();
+        Constructor<T>[] res = null;
+        if (useCaches) {
+            clearCachesOnClassRedefinition();
+            if (publicOnly) {
+                if (publicConstructors != null) {
+                    res = publicConstructors.get();
+                }
+            } else {
+                if (declaredConstructors != null) {
+                    res = declaredConstructors.get();
+                }
+            }
+            if (res != null) return res;
+        }
+        // No cached value available; request value from VM
+        if (isInterface()) {
+            res = new Constructor[0];
+        } else {
+            res = getDeclaredConstructors0(publicOnly);
+        }
+        if (useCaches) {
+            if (publicOnly) {
+                publicConstructors = new SoftReference<>(res);
+            } else {
+                declaredConstructors = new SoftReference<>(res);
+            }
+        }
+        return res;
+    }
+
+    //
+    //
+    // java.lang.reflect.Method handling
+    //
+    //
+
+    // Returns an array of "root" methods. These Method objects must NOT
+    // be propagated to the outside world, but must instead be copied
+    // via ReflectionFactory.copyMethod.
+    private Method[] privateGetDeclaredMethods(boolean publicOnly) {
+        checkInitted();
+        Method[] res = null;
+        if (useCaches) {
+            clearCachesOnClassRedefinition();
+            if (publicOnly) {
+                if (declaredPublicMethods != null) {
+                    res = declaredPublicMethods.get();
+                }
+            } else {
+                if (declaredMethods != null) {
+                    res = declaredMethods.get();
+                }
+            }
+            if (res != null) return res;
+        }
+        // No cached value available; request value from VM
+        res = Reflection.filterMethods(this, getDeclaredMethods0(publicOnly));
+        if (useCaches) {
+            if (publicOnly) {
+                declaredPublicMethods = new SoftReference<>(res);
+            } else {
+                declaredMethods = new SoftReference<>(res);
+            }
+        }
+        return res;
+    }
+
+    static class MethodArray {
+        private Method[] methods;
+        private int length;
+
+        MethodArray() {
+            methods = new Method[20];
+            length = 0;
+        }
+
+        void add(Method m) {
+            if (length == methods.length) {
+                methods = Arrays.copyOf(methods, 2 * methods.length);
+            }
+            methods[length++] = m;
+        }
+
+        void addAll(Method[] ma) {
+            for (int i = 0; i < ma.length; i++) {
+                add(ma[i]);
+            }
+        }
+
+        void addAll(MethodArray ma) {
+            for (int i = 0; i < ma.length(); i++) {
+                add(ma.get(i));
+            }
+        }
+
+        void addIfNotPresent(Method newMethod) {
+            for (int i = 0; i < length; i++) {
+                Method m = methods[i];
+                if (m == newMethod || (m != null && m.equals(newMethod))) {
+                    return;
+                }
+            }
+            add(newMethod);
+        }
+
+        void addAllIfNotPresent(MethodArray newMethods) {
+            for (int i = 0; i < newMethods.length(); i++) {
+                Method m = newMethods.get(i);
+                if (m != null) {
+                    addIfNotPresent(m);
+                }
+            }
+        }
+
+        int length() {
+            return length;
+        }
+
+        Method get(int i) {
+            return methods[i];
+        }
+
+        void removeByNameAndSignature(Method toRemove) {
+            for (int i = 0; i < length; i++) {
+                Method m = methods[i];
+                if (m != null &&
+                    m.getReturnType() == toRemove.getReturnType() &&
+                    m.getName() == toRemove.getName() &&
+                    arrayContentsEq(m.getParameterTypes(),
+                                    toRemove.getParameterTypes())) {
+                    methods[i] = null;
+                }
+            }
+        }
+
+        void compactAndTrim() {
+            int newPos = 0;
+            // Get rid of null slots
+            for (int pos = 0; pos < length; pos++) {
+                Method m = methods[pos];
+                if (m != null) {
+                    if (pos != newPos) {
+                        methods[newPos] = m;
+                    }
+                    newPos++;
+                }
+            }
+            if (newPos != methods.length) {
+                methods = Arrays.copyOf(methods, newPos);
+            }
+        }
+
+        Method[] getArray() {
+            return methods;
+        }
+    }
+
+
+    // Returns an array of "root" methods. These Method objects must NOT
+    // be propagated to the outside world, but must instead be copied
+    // via ReflectionFactory.copyMethod.
+    private Method[] privateGetPublicMethods() {
+        checkInitted();
+        Method[] res = null;
+        if (useCaches) {
+            clearCachesOnClassRedefinition();
+            if (publicMethods != null) {
+                res = publicMethods.get();
+            }
+            if (res != null) return res;
+        }
+
+        // No cached value available; compute value recursively.
+        // Start by fetching public declared methods
+        MethodArray methods = new MethodArray();
+        {
+            Method[] tmp = privateGetDeclaredMethods(true);
+            methods.addAll(tmp);
+        }
+        // Now recur over superclass and direct superinterfaces.
+        // Go over superinterfaces first so we can more easily filter
+        // out concrete implementations inherited from superclasses at
+        // the end.
+        MethodArray inheritedMethods = new MethodArray();
+        Class<?>[] interfaces = getInterfaces();
+        for (int i = 0; i < interfaces.length; i++) {
+            inheritedMethods.addAll(interfaces[i].privateGetPublicMethods());
+        }
+        if (!isInterface()) {
+            Class<?> c = getSuperclass();
+            if (c != null) {
+                MethodArray supers = new MethodArray();
+                supers.addAll(c.privateGetPublicMethods());
+                // Filter out concrete implementations of any
+                // interface methods
+                for (int i = 0; i < supers.length(); i++) {
+                    Method m = supers.get(i);
+                    if (m != null && !Modifier.isAbstract(m.getModifiers())) {
+                        inheritedMethods.removeByNameAndSignature(m);
+                    }
+                }
+                // Insert superclass's inherited methods before
+                // superinterfaces' to satisfy getMethod's search
+                // order
+                supers.addAll(inheritedMethods);
+                inheritedMethods = supers;
+            }
+        }
+        // Filter out all local methods from inherited ones
+        for (int i = 0; i < methods.length(); i++) {
+            Method m = methods.get(i);
+            inheritedMethods.removeByNameAndSignature(m);
+        }
+        methods.addAllIfNotPresent(inheritedMethods);
+        methods.compactAndTrim();
+        res = methods.getArray();
+        if (useCaches) {
+            publicMethods = new SoftReference<>(res);
+        }
+        return res;
+    }
+
+
+    //
+    // Helpers for fetchers of one field, method, or constructor
+    //
+
+    private Field searchFields(Field[] fields, String name) {
+        String internedName = name.intern();
+        for (int i = 0; i < fields.length; i++) {
+            if (fields[i].getName() == internedName) {
+                return getReflectionFactory().copyField(fields[i]);
+            }
+        }
+        return null;
+    }
+
+    private Field getField0(String name) throws NoSuchFieldException {
+        // Note: the intent is that the search algorithm this routine
+        // uses be equivalent to the ordering imposed by
+        // privateGetPublicFields(). It fetches only the declared
+        // public fields for each class, however, to reduce the number
+        // of Field objects which have to be created for the common
+        // case where the field being requested is declared in the
+        // class which is being queried.
+        Field res = null;
+        // Search declared public fields
+        if ((res = searchFields(privateGetDeclaredFields(true), name)) != null) {
+            return res;
+        }
+        // Direct superinterfaces, recursively
+        Class<?>[] interfaces = getInterfaces();
+        for (int i = 0; i < interfaces.length; i++) {
+            Class<?> c = interfaces[i];
+            if ((res = c.getField0(name)) != null) {
+                return res;
+            }
+        }
+        // Direct superclass, recursively
+        if (!isInterface()) {
+            Class<?> c = getSuperclass();
+            if (c != null) {
+                if ((res = c.getField0(name)) != null) {
+                    return res;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static Method searchMethods(Method[] methods,
+                                        String name,
+                                        Class<?>[] parameterTypes)
+    {
+        Method res = null;
+        String internedName = name.intern();
+        for (int i = 0; i < methods.length; i++) {
+            Method m = methods[i];
+            if (m.getName() == internedName
+                && arrayContentsEq(parameterTypes, m.getParameterTypes())
+                && (res == null
+                    || res.getReturnType().isAssignableFrom(m.getReturnType())))
+                res = m;
+        }
+
+        return (res == null ? res : getReflectionFactory().copyMethod(res));
+    }
+
+
+    private Method getMethod0(String name, Class<?>[] parameterTypes) {
+        // Note: the intent is that the search algorithm this routine
+        // uses be equivalent to the ordering imposed by
+        // privateGetPublicMethods(). It fetches only the declared
+        // public methods for each class, however, to reduce the
+        // number of Method objects which have to be created for the
+        // common case where the method being requested is declared in
+        // the class which is being queried.
+        Method res = null;
+        // Search declared public methods
+        if ((res = searchMethods(privateGetDeclaredMethods(true),
+                                 name,
+                                 parameterTypes)) != null) {
+            return res;
+        }
+        // Search superclass's methods
+        if (!isInterface()) {
+            Class<? super T> c = getSuperclass();
+            if (c != null) {
+                if ((res = c.getMethod0(name, parameterTypes)) != null) {
+                    return res;
+                }
+            }
+        }
+        // Search superinterfaces' methods
+        Class<?>[] interfaces = getInterfaces();
+        for (int i = 0; i < interfaces.length; i++) {
+            Class<?> c = interfaces[i];
+            if ((res = c.getMethod0(name, parameterTypes)) != null) {
+                return res;
+            }
+        }
+        // Not found
+        return null;
+    }
+
+    private Constructor<T> getConstructor0(Class<?>[] parameterTypes,
+                                        int which) throws NoSuchMethodException
+    {
+        Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));
+        for (Constructor<T> constructor : constructors) {
+            if (arrayContentsEq(parameterTypes,
+                                constructor.getParameterTypes())) {
+                return getReflectionFactory().copyConstructor(constructor);
+            }
+        }
+        throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes));
+    }
+
+    //
+    // Other helpers and base implementation
+    //
+
+    private static boolean arrayContentsEq(Object[] a1, Object[] a2) {
+        if (a1 == null) {
+            return a2 == null || a2.length == 0;
+        }
+
+        if (a2 == null) {
+            return a1.length == 0;
+        }
+
+        if (a1.length != a2.length) {
+            return false;
+        }
+
+        for (int i = 0; i < a1.length; i++) {
+            if (a1[i] != a2[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static Field[] copyFields(Field[] arg) {
+        Field[] out = new Field[arg.length];
+        ReflectionFactory fact = getReflectionFactory();
+        for (int i = 0; i < arg.length; i++) {
+            out[i] = fact.copyField(arg[i]);
+        }
+        return out;
+    }
+
+    private static Method[] copyMethods(Method[] arg) {
+        Method[] out = new Method[arg.length];
+        ReflectionFactory fact = getReflectionFactory();
+        for (int i = 0; i < arg.length; i++) {
+            out[i] = fact.copyMethod(arg[i]);
+        }
+        return out;
+    }
+
+    private static <U> Constructor<U>[] copyConstructors(Constructor<U>[] arg) {
+        Constructor<U>[] out = arg.clone();
+        ReflectionFactory fact = getReflectionFactory();
+        for (int i = 0; i < out.length; i++) {
+            out[i] = fact.copyConstructor(out[i]);
+        }
+        return out;
+    }
+
+    private native Field[]       getDeclaredFields0(boolean publicOnly);
+    private native Method[]      getDeclaredMethods0(boolean publicOnly);
+    private native Constructor<T>[] getDeclaredConstructors0(boolean publicOnly);
+    private native Class<?>[]   getDeclaredClasses0();
+
+    private static String        argumentTypesToString(Class<?>[] argTypes) {
+        StringBuilder buf = new StringBuilder();
+        buf.append("(");
+        if (argTypes != null) {
+            for (int i = 0; i < argTypes.length; i++) {
+                if (i > 0) {
+                    buf.append(", ");
+                }
+                Class<?> c = argTypes[i];
+                buf.append((c == null) ? "null" : c.getName());
+            }
+        }
+        buf.append(")");
+        return buf.toString();
+    }
+
+    /** use serialVersionUID from JDK 1.1 for interoperability */
+    private static final long serialVersionUID = 3206093459760846163L;
+
+
+    /**
+     * Class Class is special cased within the Serialization Stream Protocol.
+     *
+     * A Class instance is written initially into an ObjectOutputStream in the
+     * following format:
+     * <pre>
+     *      {@code TC_CLASS} ClassDescriptor
+     *      A ClassDescriptor is a special cased serialization of
+     *      a {@code java.io.ObjectStreamClass} instance.
+     * </pre>
+     * A new handle is generated for the initial time the class descriptor
+     * is written into the stream. Future references to the class descriptor
+     * are written as references to the initial class descriptor instance.
+     *
+     * @see java.io.ObjectStreamClass
+     */
+    private static final ObjectStreamField[] serialPersistentFields =
+        new ObjectStreamField[0];
+
+
+    /**
+     * Returns the assertion status that would be assigned to this
+     * class if it were to be initialized at the time this method is invoked.
+     * If this class has had its assertion status set, the most recent
+     * setting will be returned; otherwise, if any package default assertion
+     * status pertains to this class, the most recent setting for the most
+     * specific pertinent package default assertion status is returned;
+     * otherwise, if this class is not a system class (i.e., it has a
+     * class loader) its class loader's default assertion status is returned;
+     * otherwise, the system class default assertion status is returned.
+     * <p>
+     * Few programmers will have any need for this method; it is provided
+     * for the benefit of the JRE itself.  (It allows a class to determine at
+     * the time that it is initialized whether assertions should be enabled.)
+     * Note that this method is not guaranteed to return the actual
+     * assertion status that was (or will be) associated with the specified
+     * class when it was (or will be) initialized.
+     *
+     * @return the desired assertion status of the specified class.
+     * @see    java.lang.ClassLoader#setClassAssertionStatus
+     * @see    java.lang.ClassLoader#setPackageAssertionStatus
+     * @see    java.lang.ClassLoader#setDefaultAssertionStatus
+     * @since  1.4
+     */
+    public boolean desiredAssertionStatus() {
+        ClassLoader loader = getClassLoader();
+        // If the loader is null this is a system class, so ask the VM
+        if (loader == null)
+            return desiredAssertionStatus0(this);
+
+        // If the classloader has been initialized with the assertion
+        // directives, ask it. Otherwise, ask the VM.
+        synchronized(loader.assertionLock) {
+            if (loader.classAssertionStatus != null) {
+                return loader.desiredAssertionStatus(getName());
+            }
+        }
+        return desiredAssertionStatus0(this);
+    }
+
+    // Retrieves the desired assertion status of this class from the VM
+    private static native boolean desiredAssertionStatus0(Class<?> clazz);
+
+    /**
+     * Returns true if and only if this class was declared as an enum in the
+     * source code.
+     *
+     * @return true if and only if this class was declared as an enum in the
+     *     source code
+     * @since 1.5
+     */
+    public boolean isEnum() {
+        // An enum must both directly extend java.lang.Enum and have
+        // the ENUM bit set; classes for specialized enum constants
+        // don't do the former.
+        return (this.getModifiers() & ENUM) != 0 &&
+        this.getSuperclass() == java.lang.Enum.class;
+    }
+
+    // Fetches the factory for reflective objects
+    private static ReflectionFactory getReflectionFactory() {
+        if (reflectionFactory == null) {
+            reflectionFactory =
+                java.security.AccessController.doPrivileged
+                    (new sun.reflect.ReflectionFactory.GetReflectionFactoryAction());
+        }
+        return reflectionFactory;
+    }
+    private static ReflectionFactory reflectionFactory;
+
+    // To be able to query system properties as soon as they're available
+    private static boolean initted = false;
+    private static void checkInitted() {
+        if (initted) return;
+        AccessController.doPrivileged(new PrivilegedAction<Void>() {
+                public Void run() {
+                    // Tests to ensure the system properties table is fully
+                    // initialized. This is needed because reflection code is
+                    // called very early in the initialization process (before
+                    // command-line arguments have been parsed and therefore
+                    // these user-settable properties installed.) We assume that
+                    // if System.out is non-null then the System class has been
+                    // fully initialized and that the bulk of the startup code
+                    // has been run.
+
+                    if (System.out == null) {
+                        // java.lang.System not yet fully initialized
+                        return null;
+                    }
+
+                    String val =
+                        System.getProperty("sun.reflect.noCaches");
+                    if (val != null && val.equals("true")) {
+                        useCaches = false;
+                    }
+
+                    initted = true;
+                    return null;
+                }
+            });
+    }
+
+    /**
+     * Returns the elements of this enum class or null if this
+     * Class object does not represent an enum type.
+     *
+     * @return an array containing the values comprising the enum class
+     *     represented by this Class object in the order they're
+     *     declared, or null if this Class object does not
+     *     represent an enum type
+     * @since 1.5
+     */
+    public T[] getEnumConstants() {
+        T[] values = getEnumConstantsShared();
+        return (values != null) ? values.clone() : null;
+    }
+
+    /**
+     * Returns the elements of this enum class or null if this
+     * Class object does not represent an enum type;
+     * identical to getEnumConstants except that the result is
+     * uncloned, cached, and shared by all callers.
+     */
+    T[] getEnumConstantsShared() {
+        if (enumConstants == null) {
+            if (!isEnum()) return null;
+            try {
+                final Method values = getMethod("values");
+                java.security.AccessController.doPrivileged(
+                    new java.security.PrivilegedAction<Void>() {
+                        public Void run() {
+                                values.setAccessible(true);
+                                return null;
+                            }
+                        });
+                enumConstants = (T[])values.invoke(null);
+            }
+            // These can happen when users concoct enum-like classes
+            // that don't comply with the enum spec.
+            catch (InvocationTargetException ex) { return null; }
+            catch (NoSuchMethodException ex) { return null; }
+            catch (IllegalAccessException ex) { return null; }
+        }
+        return enumConstants;
+    }
+    private volatile transient T[] enumConstants = null;
+
+    /**
+     * Returns a map from simple name to enum constant.  This package-private
+     * method is used internally by Enum to implement
+     *     public static <T extends Enum<T>> T valueOf(Class<T>, String)
+     * efficiently.  Note that the map is returned by this method is
+     * created lazily on first use.  Typically it won't ever get created.
+     */
+    Map<String, T> enumConstantDirectory() {
+        if (enumConstantDirectory == null) {
+            T[] universe = getEnumConstantsShared();
+            if (universe == null)
+                throw new IllegalArgumentException(
+                    getName() + " is not an enum type");
+            Map<String, T> m = new HashMap<>(2 * universe.length);
+            for (T constant : universe)
+                m.put(((Enum<?>)constant).name(), constant);
+            enumConstantDirectory = m;
+        }
+        return enumConstantDirectory;
+    }
+    private volatile transient Map<String, T> enumConstantDirectory = null;
+
+    /**
+     * Casts an object to the class or interface represented
+     * by this {@code Class} object.
+     *
+     * @param obj the object to be cast
+     * @return the object after casting, or null if obj is null
+     *
+     * @throws ClassCastException if the object is not
+     * null and is not assignable to the type T.
+     *
+     * @since 1.5
+     */
+    public T cast(Object obj) {
+        if (obj != null && !isInstance(obj))
+            throw new ClassCastException(cannotCastMsg(obj));
+        return (T) obj;
+    }
+
+    private String cannotCastMsg(Object obj) {
+        return "Cannot cast " + obj.getClass().getName() + " to " + getName();
+    }
+
+    /**
+     * Casts this {@code Class} object to represent a subclass of the class
+     * represented by the specified class object.  Checks that that the cast
+     * is valid, and throws a {@code ClassCastException} if it is not.  If
+     * this method succeeds, it always returns a reference to this class object.
+     *
+     * <p>This method is useful when a client needs to "narrow" the type of
+     * a {@code Class} object to pass it to an API that restricts the
+     * {@code Class} objects that it is willing to accept.  A cast would
+     * generate a compile-time warning, as the correctness of the cast
+     * could not be checked at runtime (because generic types are implemented
+     * by erasure).
+     *
+     * @return this {@code Class} object, cast to represent a subclass of
+     *    the specified class object.
+     * @throws ClassCastException if this {@code Class} object does not
+     *    represent a subclass of the specified class (here "subclass" includes
+     *    the class itself).
+     * @since 1.5
+     */
+    public <U> Class<? extends U> asSubclass(Class<U> clazz) {
+        if (clazz.isAssignableFrom(this))
+            return (Class<? extends U>) this;
+        else
+            throw new ClassCastException(this.toString());
+    }
+
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.5
+     */
+    public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
+        if (annotationClass == null)
+            throw new NullPointerException();
+
+        initAnnotationsIfNecessary();
+        return (A) annotations.get(annotationClass);
+    }
+
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     * @since 1.5
+     */
+    public boolean isAnnotationPresent(
+        Class<? extends Annotation> annotationClass) {
+        if (annotationClass == null)
+            throw new NullPointerException();
+
+        return getAnnotation(annotationClass) != null;
+    }
+
+
+    /**
+     * @since 1.5
+     */
+    public Annotation[] getAnnotations() {
+        initAnnotationsIfNecessary();
+        return AnnotationParser.toArray(annotations);
+    }
+
+    /**
+     * @since 1.5
+     */
+    public Annotation[] getDeclaredAnnotations()  {
+        initAnnotationsIfNecessary();
+        return AnnotationParser.toArray(declaredAnnotations);
+    }
+
+    // Annotations cache
+    private transient Map<Class<? extends Annotation>, Annotation> annotations;
+    private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
+
+    private synchronized void initAnnotationsIfNecessary() {
+        clearCachesOnClassRedefinition();
+        if (annotations != null)
+            return;
+        declaredAnnotations = AnnotationParser.parseAnnotations(
+            getRawAnnotations(), getConstantPool(), this);
+        Class<?> superClass = getSuperclass();
+        if (superClass == null) {
+            annotations = declaredAnnotations;
+        } else {
+            annotations = new HashMap<>();
+            superClass.initAnnotationsIfNecessary();
+            for (Map.Entry<Class<? extends Annotation>, Annotation> e : superClass.annotations.entrySet()) {
+                Class<? extends Annotation> annotationClass = e.getKey();
+                if (AnnotationType.getInstance(annotationClass).isInherited())
+                    annotations.put(annotationClass, e.getValue());
+            }
+            annotations.putAll(declaredAnnotations);
+        }
+    }
+
+    // Annotation types cache their internal (AnnotationType) form
+
+    private AnnotationType annotationType;
+
+    void setAnnotationType(AnnotationType type) {
+        annotationType = type;
+    }
+
+    AnnotationType getAnnotationType() {
+        return annotationType;
+    }
+}