changeset 1233:be069d72dde2 jdk8-b32

Merge
author lana
date Mon, 26 Mar 2012 17:32:17 -0700
parents ebfe9b8ce039 6b473c9ebf1e
children 46831c72b7f6
files
diffstat 16 files changed, 1959 insertions(+), 14 deletions(-) [+]
line wrap: on
line diff
--- a/src/share/classes/com/sun/tools/javac/code/Symtab.java	Thu Mar 22 12:41:36 2012 -0700
+++ b/src/share/classes/com/sun/tools/javac/code/Symtab.java	Mon Mar 26 17:32:17 2012 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -126,6 +126,7 @@
     public final Type cloneableType;
     public final Type serializableType;
     public final Type methodHandleType;
+    public final Type nativeHeaderType;
     public final Type polymorphicSignatureType;
     public final Type throwableType;
     public final Type errorType;
@@ -477,6 +478,7 @@
                                             List.of(exceptionType), methodClass),
                              autoCloseableType.tsym);
         trustMeType = enterClass("java.lang.SafeVarargs");
+        nativeHeaderType = enterClass("javax.tools.annotation.GenerateNativeHeader");
 
         synthesizeEmptyInterfaceIfMissing(autoCloseableType);
         synthesizeEmptyInterfaceIfMissing(cloneableType);
--- a/src/share/classes/com/sun/tools/javac/file/Locations.java	Thu Mar 22 12:41:36 2012 -0700
+++ b/src/share/classes/com/sun/tools/javac/file/Locations.java	Mon Mar 26 17:32:17 2012 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -648,7 +648,8 @@
             new SimpleLocationHandler(StandardLocation.SOURCE_PATH, Option.SOURCEPATH),
             new SimpleLocationHandler(StandardLocation.ANNOTATION_PROCESSOR_PATH, Option.PROCESSORPATH),
             new OutputLocationHandler((StandardLocation.CLASS_OUTPUT), Option.D),
-            new OutputLocationHandler((StandardLocation.SOURCE_OUTPUT), Option.S)
+            new OutputLocationHandler((StandardLocation.SOURCE_OUTPUT), Option.S),
+            new OutputLocationHandler((StandardLocation.NATIVE_HEADER_OUTPUT), Option.H)
         };
 
         for (LocationHandler h: handlers) {
--- a/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Thu Mar 22 12:41:36 2012 -0700
+++ b/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Mon Mar 26 17:32:17 2012 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -69,11 +69,11 @@
      */
     private boolean verbose;
 
-    /** Switch: scrable private names.
+    /** Switch: scramble private names.
      */
     private boolean scramble;
 
-    /** Switch: scrable private names.
+    /** Switch: scramble private names.
      */
     private boolean scrambleAll;
 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/share/classes/com/sun/tools/javac/jvm/JNIWriter.java	Mon Mar 26 17:32:17 2012 -0700
@@ -0,0 +1,856 @@
+/*
+ * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.sun.tools.javac.jvm;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+import java.util.StringTokenizer;
+
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.Name;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.NoType;
+import javax.lang.model.type.PrimitiveType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVariable;
+import javax.lang.model.type.TypeVisitor;
+import javax.lang.model.util.ElementFilter;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.SimpleTypeVisitor8;
+import javax.lang.model.util.Types;
+
+import javax.tools.FileObject;
+import javax.tools.JavaFileManager;
+import javax.tools.StandardLocation;
+
+import com.sun.tools.javac.code.Attribute;
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.code.Kinds;
+import com.sun.tools.javac.code.Scope;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symtab;
+import com.sun.tools.javac.model.JavacElements;
+import com.sun.tools.javac.model.JavacTypes;
+import com.sun.tools.javac.util.Assert;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.Log;
+import com.sun.tools.javac.util.Options;
+
+import static com.sun.tools.javac.main.Option.*;
+
+/** This class provides operations to write native header files for classes.
+ *
+ *  <p><b>This is NOT part of any supported API.
+ *  If you write code that depends on this, you do so at your own risk.
+ *  This code and its internal interfaces are subject to change or
+ *  deletion without notice.</b>
+ */
+public class JNIWriter {
+    protected static final Context.Key<JNIWriter> jniWriterKey =
+        new Context.Key<JNIWriter>();
+
+    /** Access to files. */
+    private final JavaFileManager fileManager;
+
+    JavacElements elements;
+    JavacTypes types;
+
+    /** The log to use for verbose output.
+     */
+    private final Log log;
+
+    /** Switch: verbose output.
+     */
+    private boolean verbose;
+
+    /** Switch: check all nested classes of top level class
+     */
+    private boolean checkAll;
+
+    private Mangle mangler;
+
+    private Context context;
+
+    private Symtab syms;
+
+    private String lineSep;
+
+    private final boolean isWindows =
+        System.getProperty("os.name").startsWith("Windows");
+
+    /** Get the ClassWriter instance for this context. */
+    public static JNIWriter instance(Context context) {
+        JNIWriter instance = context.get(jniWriterKey);
+        if (instance == null)
+            instance = new JNIWriter(context);
+        return instance;
+    }
+
+    /** Construct a class writer, given an options table.
+     */
+    private JNIWriter(Context context) {
+        context.put(jniWriterKey, this);
+        fileManager = context.get(JavaFileManager.class);
+        log = Log.instance(context);
+
+        Options options = Options.instance(context);
+        verbose = options.isSet(VERBOSE);
+        checkAll = options.isSet("javah:full");
+
+        this.context = context; // for lazyInit()
+        syms = Symtab.instance(context);
+
+        lineSep = System.getProperty("line.separator");
+    }
+
+    private void lazyInit() {
+        if (mangler == null) {
+            elements = JavacElements.instance(context);
+            types = JavacTypes.instance(context);
+            mangler = new Mangle(elements, types);
+        }
+    }
+
+    public boolean needsHeader(ClassSymbol c) {
+        if (c.isLocal() || (c.flags() & Flags.SYNTHETIC) != 0)
+            return false;
+
+        if (checkAll)
+            return needsHeader(c.outermostClass(), true);
+        else
+            return needsHeader(c, false);
+    }
+
+    private boolean needsHeader(ClassSymbol c, boolean checkNestedClasses) {
+        if (c.isLocal() || (c.flags() & Flags.SYNTHETIC) != 0)
+            return false;
+
+        for (Attribute.Compound a: c.attributes_field) {
+            if (a.type.tsym == syms.nativeHeaderType.tsym)
+                return true;
+        }
+        for (Scope.Entry i = c.members_field.elems; i != null; i = i.sibling) {
+            if (i.sym.kind == Kinds.MTH && (i.sym.flags() & Flags.NATIVE) != 0)
+                return true;
+        }
+        if (checkNestedClasses) {
+            for (Scope.Entry i = c.members_field.elems; i != null; i = i.sibling) {
+                if ((i.sym.kind == Kinds.TYP) && needsHeader(((ClassSymbol) i.sym), true))
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    /** Emit a class file for a given class.
+     *  @param c      The class from which a class file is generated.
+     */
+    public FileObject write(ClassSymbol c)
+        throws IOException
+    {
+        String className = c.flatName().toString();
+        FileObject outFile
+            = fileManager.getFileForOutput(StandardLocation.NATIVE_HEADER_OUTPUT,
+                "", className.replaceAll("[.$]", "_") + ".h", null);
+        Writer out = outFile.openWriter();
+        try {
+            write(out, c);
+            if (verbose)
+                log.printVerbose("wrote.file", outFile);
+            out.close();
+            out = null;
+        } finally {
+            if (out != null) {
+                // if we are propogating an exception, delete the file
+                out.close();
+                outFile.delete();
+                outFile = null;
+            }
+        }
+        return outFile; // may be null if write failed
+    }
+
+    public void write(Writer out, ClassSymbol sym)
+            throws IOException {
+        lazyInit();
+        try {
+            String cname = mangler.mangle(sym.fullname, Mangle.Type.CLASS);
+            println(out, fileTop());
+            println(out, includes());
+            println(out, guardBegin(cname));
+            println(out, cppGuardBegin());
+
+            writeStatics(out, sym);
+            writeMethods(out, sym, cname);
+
+            println(out, cppGuardEnd());
+            println(out, guardEnd(cname));
+        } catch (TypeSignature.SignatureException e) {
+            throw new IOException(e);
+        }
+    }
+
+    protected void writeStatics(Writer out, ClassSymbol sym) throws IOException {
+        List<VariableElement> classfields = getAllFields(sym);
+
+        for (VariableElement v: classfields) {
+            if (!v.getModifiers().contains(Modifier.STATIC))
+                continue;
+            String s = null;
+            s = defineForStatic(sym, v);
+            if (s != null) {
+                println(out, s);
+            }
+        }
+    }
+
+    /**
+     * Including super class fields.
+     */
+    List<VariableElement> getAllFields(TypeElement subclazz) {
+        List<VariableElement> fields = new ArrayList<VariableElement>();
+        TypeElement cd = null;
+        Stack<TypeElement> s = new Stack<TypeElement>();
+
+        cd = subclazz;
+        while (true) {
+            s.push(cd);
+            TypeElement c = (TypeElement) (types.asElement(cd.getSuperclass()));
+            if (c == null)
+                break;
+            cd = c;
+        }
+
+        while (!s.empty()) {
+            cd = s.pop();
+            fields.addAll(ElementFilter.fieldsIn(cd.getEnclosedElements()));
+        }
+
+        return fields;
+    }
+
+    protected String defineForStatic(TypeElement c, VariableElement f) {
+        CharSequence cnamedoc = c.getQualifiedName();
+        CharSequence fnamedoc = f.getSimpleName();
+
+        String cname = mangler.mangle(cnamedoc, Mangle.Type.CLASS);
+        String fname = mangler.mangle(fnamedoc, Mangle.Type.FIELDSTUB);
+
+        Assert.check(f.getModifiers().contains(Modifier.STATIC));
+
+        if (f.getModifiers().contains(Modifier.FINAL)) {
+            Object value = null;
+
+            value = f.getConstantValue();
+
+            if (value != null) { /* so it is a ConstantExpression */
+                String constString = null;
+                if ((value instanceof Integer)
+                    || (value instanceof Byte)
+                    || (value instanceof Short)) {
+                    /* covers byte, short, int */
+                    constString = value.toString() + "L";
+                } else if (value instanceof Boolean) {
+                    constString = ((Boolean) value) ? "1L" : "0L";
+                } else if (value instanceof Character) {
+                    Character ch = (Character) value;
+                    constString = String.valueOf(((int) ch) & 0xffff) + "L";
+                } else if (value instanceof Long) {
+                    // Visual C++ supports the i64 suffix, not LL.
+                    if (isWindows)
+                        constString = value.toString() + "i64";
+                    else
+                        constString = value.toString() + "LL";
+                } else if (value instanceof Float) {
+                    /* bug for bug */
+                    float fv = ((Float)value).floatValue();
+                    if (Float.isInfinite(fv))
+                        constString = ((fv < 0) ? "-" : "") + "Inff";
+                    else
+                        constString = value.toString() + "f";
+                } else if (value instanceof Double) {
+                    /* bug for bug */
+                    double d = ((Double)value).doubleValue();
+                    if (Double.isInfinite(d))
+                        constString = ((d < 0) ? "-" : "") + "InfD";
+                    else
+                        constString = value.toString();
+                }
+
+                if (constString != null) {
+                    StringBuilder s = new StringBuilder("#undef ");
+                    s.append(cname); s.append("_"); s.append(fname); s.append(lineSep);
+                    s.append("#define "); s.append(cname); s.append("_");
+                    s.append(fname); s.append(" "); s.append(constString);
+                    return s.toString();
+                }
+
+            }
+        }
+
+        return null;
+    }
+
+
+    protected void writeMethods(Writer out, ClassSymbol sym, String cname)
+            throws IOException, TypeSignature.SignatureException {
+        List<ExecutableElement> classmethods = ElementFilter.methodsIn(sym.getEnclosedElements());
+        for (ExecutableElement md: classmethods) {
+            if(md.getModifiers().contains(Modifier.NATIVE)){
+                TypeMirror mtr = types.erasure(md.getReturnType());
+                String sig = signature(md);
+                TypeSignature newtypesig = new TypeSignature(elements);
+                CharSequence methodName = md.getSimpleName();
+                boolean longName = false;
+                for (ExecutableElement md2: classmethods) {
+                    if ((md2 != md)
+                        && (methodName.equals(md2.getSimpleName()))
+                        && (md2.getModifiers().contains(Modifier.NATIVE)))
+                        longName = true;
+
+                }
+                println(out, "/*");
+                println(out, " * Class:     " + cname);
+                println(out, " * Method:    " +
+                           mangler.mangle(methodName, Mangle.Type.FIELDSTUB));
+                println(out, " * Signature: " + newtypesig.getTypeSignature(sig, mtr));
+                println(out, " */");
+                println(out, "JNIEXPORT " + jniType(mtr) +
+                           " JNICALL " +
+                           mangler.mangleMethod(md, sym,
+                                               (longName) ?
+                                               Mangle.Type.METHOD_JNI_LONG :
+                                               Mangle.Type.METHOD_JNI_SHORT));
+                print(out, "  (JNIEnv *, ");
+                List<? extends VariableElement> paramargs = md.getParameters();
+                List<TypeMirror> args = new ArrayList<TypeMirror>();
+                for (VariableElement p: paramargs) {
+                    args.add(types.erasure(p.asType()));
+                }
+                if (md.getModifiers().contains(Modifier.STATIC))
+                    print(out, "jclass");
+                else
+                    print(out, "jobject");
+
+                for (TypeMirror arg: args) {
+                    print(out, ", ");
+                    print(out, jniType(arg));
+                }
+                println(out, ");"
+                        + lineSep);
+            }
+        }
+    }
+
+    // c.f. MethodDoc.signature
+    String signature(ExecutableElement e) {
+        StringBuilder sb = new StringBuilder("(");
+        String sep = "";
+        for (VariableElement p: e.getParameters()) {
+            sb.append(sep);
+            sb.append(types.erasure(p.asType()).toString());
+            sep = ",";
+        }
+        sb.append(")");
+        return sb.toString();
+    }
+
+    protected final String jniType(TypeMirror t) {
+        TypeElement throwable = elements.getTypeElement("java.lang.Throwable");
+        TypeElement jClass = elements.getTypeElement("java.lang.Class");
+        TypeElement jString = elements.getTypeElement("java.lang.String");
+        Element tclassDoc = types.asElement(t);
+
+
+        switch (t.getKind()) {
+            case ARRAY: {
+                TypeMirror ct = ((ArrayType) t).getComponentType();
+                switch (ct.getKind()) {
+                    case BOOLEAN:  return "jbooleanArray";
+                    case BYTE:     return "jbyteArray";
+                    case CHAR:     return "jcharArray";
+                    case SHORT:    return "jshortArray";
+                    case INT:      return "jintArray";
+                    case LONG:     return "jlongArray";
+                    case FLOAT:    return "jfloatArray";
+                    case DOUBLE:   return "jdoubleArray";
+                    case ARRAY:
+                    case DECLARED: return "jobjectArray";
+                    default: throw new Error(ct.toString());
+                }
+            }
+
+            case VOID:     return "void";
+            case BOOLEAN:  return "jboolean";
+            case BYTE:     return "jbyte";
+            case CHAR:     return "jchar";
+            case SHORT:    return "jshort";
+            case INT:      return "jint";
+            case LONG:     return "jlong";
+            case FLOAT:    return "jfloat";
+            case DOUBLE:   return "jdouble";
+
+            case DECLARED: {
+                if (tclassDoc.equals(jString))
+                    return "jstring";
+                else if (types.isAssignable(t, throwable.asType()))
+                    return "jthrowable";
+                else if (types.isAssignable(t, jClass.asType()))
+                    return "jclass";
+                else
+                    return "jobject";
+            }
+        }
+
+        Assert.check(false, "jni unknown type");
+        return null; /* dead code. */
+    }
+
+    protected String fileTop() {
+        return "/* DO NOT EDIT THIS FILE - it is machine generated */";
+    }
+
+    protected String includes() {
+        return "#include <jni.h>";
+    }
+
+    /*
+     * Deal with the C pre-processor.
+     */
+    protected String cppGuardBegin() {
+        return "#ifdef __cplusplus" + lineSep
+                + "extern \"C\" {" + lineSep
+                + "#endif";
+    }
+
+    protected String cppGuardEnd() {
+        return "#ifdef __cplusplus" + lineSep
+                + "}" + lineSep
+                + "#endif";
+    }
+
+    protected String guardBegin(String cname) {
+        return "/* Header for class " + cname + " */" + lineSep
+                + lineSep
+                + "#ifndef _Included_" + cname + lineSep
+                + "#define _Included_" + cname;
+    }
+
+    protected String guardEnd(String cname) {
+        return "#endif";
+    }
+
+    protected void print(Writer out, String text) throws IOException {
+        out.write(text);
+    }
+
+    protected void println(Writer out, String text) throws IOException {
+        out.write(text);
+        out.write(lineSep);
+    }
+
+
+    private static class Mangle {
+
+        public static class Type {
+            public static final int CLASS            = 1;
+            public static final int FIELDSTUB        = 2;
+            public static final int FIELD            = 3;
+            public static final int JNI              = 4;
+            public static final int SIGNATURE        = 5;
+            public static final int METHOD_JDK_1     = 6;
+            public static final int METHOD_JNI_SHORT = 7;
+            public static final int METHOD_JNI_LONG  = 8;
+        };
+
+        private Elements elems;
+        private Types types;
+
+        Mangle(Elements elems, Types types) {
+            this.elems = elems;
+            this.types = types;
+        }
+
+        public final String mangle(CharSequence name, int mtype) {
+            StringBuilder result = new StringBuilder(100);
+            int length = name.length();
+
+            for (int i = 0; i < length; i++) {
+                char ch = name.charAt(i);
+                if (isalnum(ch)) {
+                    result.append(ch);
+                } else if ((ch == '.') &&
+                           mtype == Mangle.Type.CLASS) {
+                    result.append('_');
+                } else if (( ch == '$') &&
+                           mtype == Mangle.Type.CLASS) {
+                    result.append('_');
+                    result.append('_');
+                } else if (ch == '_' && mtype == Mangle.Type.FIELDSTUB) {
+                    result.append('_');
+                } else if (ch == '_' && mtype == Mangle.Type.CLASS) {
+                    result.append('_');
+                } else if (mtype == Mangle.Type.JNI) {
+                    String esc = null;
+                    if (ch == '_')
+                        esc = "_1";
+                    else if (ch == '.')
+                        esc = "_";
+                    else if (ch == ';')
+                        esc = "_2";
+                    else if (ch == '[')
+                        esc = "_3";
+                    if (esc != null) {
+                        result.append(esc);
+                    } else {
+                        result.append(mangleChar(ch));
+                    }
+                } else if (mtype == Mangle.Type.SIGNATURE) {
+                    if (isprint(ch)) {
+                        result.append(ch);
+                    } else {
+                        result.append(mangleChar(ch));
+                    }
+                } else {
+                    result.append(mangleChar(ch));
+                }
+            }
+
+            return result.toString();
+        }
+
+        public String mangleMethod(ExecutableElement method, TypeElement clazz,
+                                          int mtype) throws TypeSignature.SignatureException {
+            StringBuilder result = new StringBuilder(100);
+            result.append("Java_");
+
+            if (mtype == Mangle.Type.METHOD_JDK_1) {
+                result.append(mangle(clazz.getQualifiedName(), Mangle.Type.CLASS));
+                result.append('_');
+                result.append(mangle(method.getSimpleName(),
+                                     Mangle.Type.FIELD));
+                result.append("_stub");
+                return result.toString();
+            }
+
+            /* JNI */
+            result.append(mangle(getInnerQualifiedName(clazz), Mangle.Type.JNI));
+            result.append('_');
+            result.append(mangle(method.getSimpleName(),
+                                 Mangle.Type.JNI));
+            if (mtype == Mangle.Type.METHOD_JNI_LONG) {
+                result.append("__");
+                String typesig = signature(method);
+                TypeSignature newTypeSig = new TypeSignature(elems);
+                String sig = newTypeSig.getTypeSignature(typesig,  method.getReturnType());
+                sig = sig.substring(1);
+                sig = sig.substring(0, sig.lastIndexOf(')'));
+                sig = sig.replace('/', '.');
+                result.append(mangle(sig, Mangle.Type.JNI));
+            }
+
+            return result.toString();
+        }
+        //where
+            private String getInnerQualifiedName(TypeElement clazz) {
+                return elems.getBinaryName(clazz).toString();
+            }
+
+        public final String mangleChar(char ch) {
+            String s = Integer.toHexString(ch);
+            int nzeros = 5 - s.length();
+            char[] result = new char[6];
+            result[0] = '_';
+            for (int i = 1; i <= nzeros; i++)
+                result[i] = '0';
+            for (int i = nzeros+1, j = 0; i < 6; i++, j++)
+                result[i] = s.charAt(j);
+            return new String(result);
+        }
+
+        // Warning: duplicated in Gen
+        private String signature(ExecutableElement e) {
+            StringBuilder sb = new StringBuilder();
+            String sep = "(";
+            for (VariableElement p: e.getParameters()) {
+                sb.append(sep);
+                sb.append(types.erasure(p.asType()).toString());
+                sep = ",";
+            }
+            sb.append(")");
+            return sb.toString();
+        }
+
+        /* Warning: Intentional ASCII operation. */
+        private static boolean isalnum(char ch) {
+            return ch <= 0x7f && /* quick test */
+                ((ch >= 'A' && ch <= 'Z') ||
+                 (ch >= 'a' && ch <= 'z') ||
+                 (ch >= '0' && ch <= '9'));
+        }
+
+        /* Warning: Intentional ASCII operation. */
+        private static boolean isprint(char ch) {
+            return ch >= 32 && ch <= 126;
+        }
+    }
+
+    private static class TypeSignature {
+        static class SignatureException extends Exception {
+            private static final long serialVersionUID = 1L;
+            SignatureException(String reason) {
+                super(reason);
+            }
+        }
+
+        Elements elems;
+
+        /* Signature Characters */
+
+        private static final String SIG_VOID                   = "V";
+        private static final String SIG_BOOLEAN                = "Z";
+        private static final String SIG_BYTE                   = "B";
+        private static final String SIG_CHAR                   = "C";
+        private static final String SIG_SHORT                  = "S";
+        private static final String SIG_INT                    = "I";
+        private static final String SIG_LONG                   = "J";
+        private static final String SIG_FLOAT                  = "F";
+        private static final String SIG_DOUBLE                 = "D";
+        private static final String SIG_ARRAY                  = "[";
+        private static final String SIG_CLASS                  = "L";
+
+
+
+        public TypeSignature(Elements elems){
+            this.elems = elems;
+        }
+
+        /*
+         * Returns the type signature of a field according to JVM specs
+         */
+        public String getTypeSignature(String javasignature) throws SignatureException {
+            return getParamJVMSignature(javasignature);
+        }
+
+        /*
+         * Returns the type signature of a method according to JVM specs
+         */
+        public String getTypeSignature(String javasignature, TypeMirror returnType)
+                throws SignatureException {
+            String signature = null; //Java type signature.
+            String typeSignature = null; //Internal type signature.
+            List<String> params = new ArrayList<String>(); //List of parameters.
+            String paramsig = null; //Java parameter signature.
+            String paramJVMSig = null; //Internal parameter signature.
+            String returnSig = null; //Java return type signature.
+            String returnJVMType = null; //Internal return type signature.
+            int dimensions = 0; //Array dimension.
+
+            int startIndex = -1;
+            int endIndex = -1;
+            StringTokenizer st = null;
+            int i = 0;
+
+            // Gets the actual java signature without parentheses.
+            if (javasignature != null) {
+                startIndex = javasignature.indexOf("(");
+                endIndex = javasignature.indexOf(")");
+            }
+
+            if (((startIndex != -1) && (endIndex != -1))
+                &&(startIndex+1 < javasignature.length())
+                &&(endIndex < javasignature.length())) {
+                signature = javasignature.substring(startIndex+1, endIndex);
+            }
+
+            // Separates parameters.
+            if (signature != null) {
+                if (signature.indexOf(",") != -1) {
+                    st = new StringTokenizer(signature, ",");
+                    if (st != null) {
+                        while (st.hasMoreTokens()) {
+                            params.add(st.nextToken());
+                        }
+                    }
+                } else {
+                    params.add(signature);
+                }
+            }
+
+            /* JVM type signature. */
+            typeSignature = "(";
+
+            // Gets indivisual internal parameter signature.
+            while (params.isEmpty() != true) {
+                paramsig = params.remove(i).trim();
+                paramJVMSig  = getParamJVMSignature(paramsig);
+                if (paramJVMSig != null) {
+                    typeSignature += paramJVMSig;
+                }
+            }
+
+            typeSignature += ")";
+
+            // Get internal return type signature.
+
+            returnJVMType = "";
+            if (returnType != null) {
+                dimensions = dimensions(returnType);
+            }
+
+            //Gets array dimension of return type.
+            while (dimensions-- > 0) {
+                returnJVMType += "[";
+            }
+            if (returnType != null) {
+                returnSig = qualifiedTypeName(returnType);
+                returnJVMType += getComponentType(returnSig);
+            } else {
+                System.out.println("Invalid return type.");
+            }
+
+            typeSignature += returnJVMType;
+
+            return typeSignature;
+        }
+
+        /*
+         * Returns internal signature of a parameter.
+         */
+        private String getParamJVMSignature(String paramsig) throws SignatureException {
+            String paramJVMSig = "";
+            String componentType ="";
+
+            if(paramsig != null){
+
+                if(paramsig.indexOf("[]") != -1) {
+                    // Gets array dimension.
+                    int endindex = paramsig.indexOf("[]");
+                    componentType = paramsig.substring(0, endindex);
+                    String dimensionString =  paramsig.substring(endindex);
+                    if(dimensionString != null){
+                        while(dimensionString.indexOf("[]") != -1){
+                            paramJVMSig += "[";
+                            int beginindex = dimensionString.indexOf("]") + 1;
+                            if(beginindex < dimensionString.length()){
+                                dimensionString = dimensionString.substring(beginindex);
+                            }else
+                                dimensionString = "";
+                        }
+                    }
+                } else componentType = paramsig;
+
+                paramJVMSig += getComponentType(componentType);
+            }
+            return paramJVMSig;
+        }
+
+        /*
+         * Returns internal signature of a component.
+         */
+        private String getComponentType(String componentType) throws SignatureException {
+
+            String JVMSig = "";
+
+            if(componentType != null){
+                if(componentType.equals("void")) JVMSig += SIG_VOID ;
+                else if(componentType.equals("boolean"))  JVMSig += SIG_BOOLEAN ;
+                else if(componentType.equals("byte")) JVMSig += SIG_BYTE ;
+                else if(componentType.equals("char"))  JVMSig += SIG_CHAR ;
+                else if(componentType.equals("short"))  JVMSig += SIG_SHORT ;
+                else if(componentType.equals("int"))  JVMSig += SIG_INT ;
+                else if(componentType.equals("long"))  JVMSig += SIG_LONG ;
+                else if(componentType.equals("float")) JVMSig += SIG_FLOAT ;
+                else if(componentType.equals("double"))  JVMSig += SIG_DOUBLE ;
+                else {
+                    if(!componentType.equals("")){
+                        TypeElement classNameDoc = elems.getTypeElement(componentType);
+
+                        if(classNameDoc == null){
+                            throw new SignatureException(componentType);
+                        }else {
+                            String classname = classNameDoc.getQualifiedName().toString();
+                            String newclassname = classname.replace('.', '/');
+                            JVMSig += "L";
+                            JVMSig += newclassname;
+                            JVMSig += ";";
+                        }
+                    }
+                }
+            }
+            return JVMSig;
+        }
+
+        int dimensions(TypeMirror t) {
+            if (t.getKind() != TypeKind.ARRAY)
+                return 0;
+            return 1 + dimensions(((ArrayType) t).getComponentType());
+        }
+
+
+        String qualifiedTypeName(TypeMirror type) {
+            TypeVisitor<Name, Void> v = new SimpleTypeVisitor8<Name, Void>() {
+                @Override
+                public Name visitArray(ArrayType t, Void p) {
+                    return t.getComponentType().accept(this, p);
+                }
+
+                @Override
+                public Name visitDeclared(DeclaredType t, Void p) {
+                    return ((TypeElement) t.asElement()).getQualifiedName();
+                }
+
+                @Override
+                public Name visitPrimitive(PrimitiveType t, Void p) {
+                    return elems.getName(t.toString());
+                }
+
+                @Override
+                public Name visitNoType(NoType t, Void p) {
+                    if (t.getKind() == TypeKind.VOID)
+                        return elems.getName("void");
+                    return defaultAction(t, p);
+                }
+
+                @Override
+                public Name visitTypeVariable(TypeVariable t, Void p) {
+                    return t.getUpperBound().accept(this, p);
+                }
+            };
+            return v.visit(type).toString();
+        }
+    }
+
+}
--- a/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Thu Mar 22 12:41:36 2012 -0700
+++ b/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Mon Mar 26 17:32:17 2012 -0700
@@ -44,6 +44,8 @@
 import javax.tools.DiagnosticListener;
 import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
+import javax.tools.StandardLocation;
+
 import static javax.tools.StandardLocation.CLASS_OUTPUT;
 
 import com.sun.source.util.TaskEvent;
@@ -60,6 +62,7 @@
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.Log.WriterKind;
+
 import static com.sun.tools.javac.main.Option.*;
 import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag.*;
 import static com.sun.tools.javac.util.ListBuffer.lb;
@@ -227,6 +230,10 @@
      */
     protected ClassWriter writer;
 
+    /** The native header writer.
+     */
+    protected JNIWriter jniWriter;
+
     /** The module for the symbol table entry phases.
      */
     protected Enter enter;
@@ -330,6 +337,7 @@
         reader = ClassReader.instance(context);
         make = TreeMaker.instance(context);
         writer = ClassWriter.instance(context);
+        jniWriter = JNIWriter.instance(context);
         enter = Enter.instance(context);
         todo = Todo.instance(context);
 
@@ -1450,8 +1458,13 @@
                 JavaFileObject file;
                 if (usePrintSource)
                     file = printSource(env, cdef);
-                else
+                else {
+                    if (fileManager.hasLocation(StandardLocation.NATIVE_HEADER_OUTPUT)
+                            && jniWriter.needsHeader(cdef.sym)) {
+                        jniWriter.write(cdef.sym);
+                    }
                     file = genCode(env, cdef);
+                }
                 if (results != null && file != null)
                     results.add(file);
             } catch (IOException ex) {
--- a/src/share/classes/com/sun/tools/javac/main/Option.java	Thu Mar 22 12:41:36 2012 -0700
+++ b/src/share/classes/com/sun/tools/javac/main/Option.java	Mon Mar 26 17:32:17 2012 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -160,6 +160,8 @@
 
     S("-s", "opt.arg.directory", "opt.sourceDest", STANDARD, FILEMANAGER),
 
+    H("-h", "opt.arg.directory", "opt.headerDest", STANDARD, FILEMANAGER),
+
     IMPLICIT("-implicit:", "opt.implicit", STANDARD, BASIC, ONEOF, "none", "class"),
 
     ENCODING("-encoding", "opt.arg.encoding", "opt.encoding", STANDARD, FILEMANAGER) {
--- a/src/share/classes/com/sun/tools/javac/resources/javac.properties	Thu Mar 22 12:41:36 2012 -0700
+++ b/src/share/classes/com/sun/tools/javac/resources/javac.properties	Mon Mar 26 17:32:17 2012 -0700
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 #
 # This code is free software; you can redistribute it and/or modify it
@@ -61,6 +61,8 @@
     Specify where to place generated class files
 javac.opt.sourceDest=\
     Specify where to place generated source files
+javac.opt.headerDest=\
+    Specify where to place generated native header files
 javac.opt.J=\
     Pass <flag> directly to the runtime system
 javac.opt.encoding=\
--- a/src/share/classes/javax/tools/StandardLocation.java	Thu Mar 22 12:41:36 2012 -0700
+++ b/src/share/classes/javax/tools/StandardLocation.java	Mon Mar 26 17:32:17 2012 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -66,7 +66,13 @@
      * Location to search for platform classes.  Sometimes called
      * the boot class path.
      */
-    PLATFORM_CLASS_PATH;
+    PLATFORM_CLASS_PATH,
+
+    /**
+     * Location of new native header files.
+     * @since 1.8
+     */
+    NATIVE_HEADER_OUTPUT;
 
     /**
      * Gets a location object with the given name.  The following
@@ -97,6 +103,13 @@
     public String getName() { return name(); }
 
     public boolean isOutputLocation() {
-        return this == CLASS_OUTPUT || this == SOURCE_OUTPUT;
+        switch (this) {
+            case CLASS_OUTPUT:
+            case SOURCE_OUTPUT:
+            case NATIVE_HEADER_OUTPUT:
+                return true;
+            default:
+                return false;
+        }
     }
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/share/classes/javax/tools/annotation/GenerateNativeHeader.java	Mon Mar 26 17:32:17 2012 -0700
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package javax.tools.annotation;
+
+import java.lang.annotation.*;
+import static java.lang.annotation.RetentionPolicy.*;
+import static java.lang.annotation.ElementType.*;
+
+/**
+ * An annotation used to indicate that a native header file
+ * should be generated for this class.
+ *
+ * Normally, the presence of native methods is a sufficient
+ * indication of the need for a native header file.  However,
+ * in some cases, a class may contain constants of interest to
+ * native code, without containing any native methods.
+ *
+ * @since 1.8
+ */
+@Documented
+@Target(TYPE)
+@Retention(SOURCE)
+public @interface GenerateNativeHeader {
+}
--- a/test/tools/javac/api/7086261/T7086261.java	Thu Mar 22 12:41:36 2012 -0700
+++ b/test/tools/javac/api/7086261/T7086261.java	Mon Mar 26 17:32:17 2012 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 20011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
--- a/test/tools/javac/diags/CheckResourceKeys.java	Thu Mar 22 12:41:36 2012 -0700
+++ b/test/tools/javac/diags/CheckResourceKeys.java	Mon Mar 26 17:32:17 2012 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -259,6 +259,7 @@
             "application.home", // in Paths.java
             "env.class.path",
             "line.separator",
+            "os.name",
             "user.dir",
             // file names
             "ct.sym",
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/nativeHeaders/NativeHeaderTest.java	Mon Mar 26 17:32:17 2012 -0700
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 7150368
+ * @summary javac should include basic ability to generate native headers
+ */
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
+
+import com.sun.source.util.JavacTask;
+import com.sun.tools.javac.api.JavacTool;
+
+public class NativeHeaderTest {
+    public static void main(String... args) throws Exception {
+        new NativeHeaderTest().run();
+    }
+
+    /** How to invoke javac. */
+    enum RunKind {
+        /** Use the command line entry point. */
+        CMD,
+        /** Use the JavaCompiler API. */
+        API
+    };
+
+    /** Which classes for which to generate headers. */
+    enum GenKind {
+        /** Just classes with native methods or the marker annotation. */
+        SIMPLE,
+        /** All appropriate classes within the top level class. */
+        FULL
+    };
+
+    // ---------- Test cases, invoked reflectively via run. ----------
+
+    @Test
+    void simpleTest(RunKind rk, GenKind gk) throws Exception {
+        List<File> files = new ArrayList<File>();
+        files.add(createFile("p/C.java",
+                "class C { native void m(); }"));
+
+        Set<String> expect = createSet("C.h");
+
+        test(rk, gk, files, expect);
+    }
+
+    @Test
+    void nestedClassTest(RunKind rk, GenKind gk) throws Exception {
+        List<File> files = new ArrayList<File>();
+        files.add(createFile("p/C.java",
+                "class C { static class Inner { native void m(); } }"));
+
+        Set<String> expect = createSet("C_Inner.h");
+        if (gk == GenKind.FULL) expect.add("C.h");
+
+        test(rk, gk, files, expect);
+    }
+
+    @Test
+    void localClassTest(RunKind rk, GenKind gk) throws Exception {
+        List<File> files = new ArrayList<File>();
+        files.add(createFile("p/C.java",
+                "class C { native void m(); void m2() { class Local { } } }"));
+
+        Set<String> expect = createSet("C.h");
+
+        test(rk, gk, files, expect);
+    }
+
+    @Test
+    void syntheticClassTest(RunKind rk, GenKind gk) throws Exception {
+        List<File> files = new ArrayList<File>();
+        files.add(createFile("p/C.java",
+                "class C {\n"
+                + "    private C() { }\n"
+                + "    class Inner extends C { native void m(); }\n"
+                + "}"));
+
+        Set<String> expect = createSet("C_Inner.h");
+        if (gk == GenKind.FULL) expect.add("C.h");
+
+        test(rk, gk, files, expect);
+
+        // double check the synthetic class was generated
+        checkEqual("generatedClasses",
+                createSet("C.class", "C$1.class", "C$Inner.class"),
+                createSet(classesDir.list()));
+    }
+
+    @Test
+    void annoTest(RunKind rk, GenKind gk) throws Exception {
+        List<File> files = new ArrayList<File>();
+        files.add(createFile("p/C.java",
+                "@javax.tools.annotation.GenerateNativeHeader class C { }"));
+
+        Set<String> expect = createSet("C.h");
+
+        test(rk, gk, files, expect);
+    }
+
+    @Test
+    void annoNestedClassTest(RunKind rk, GenKind gk) throws Exception {
+        List<File> files = new ArrayList<File>();
+        files.add(createFile("p/C.java",
+                "class C { @javax.tools.annotation.GenerateNativeHeader class Inner { } }"));
+
+        Set<String> expect = createSet("C_Inner.h");
+        if (gk == GenKind.FULL) expect.add("C.h");
+
+        test(rk, gk, files, expect);
+    }
+
+    /**
+     * The worker method for each test case.
+     * Compile the files and verify that exactly the expected set of header files
+     * is generated.
+     */
+    void test(RunKind rk, GenKind gk, List<File> files, Set<String> expect) throws Exception {
+        List<String> args = new ArrayList<String>();
+        if (gk == GenKind.FULL)
+            args.add("-XDjavah:full");
+
+        switch (rk) {
+            case CMD:
+                args.add("-d");
+                args.add(classesDir.getPath());
+                args.add("-h");
+                args.add(headersDir.getPath());
+                for (File f: files)
+                    args.add(f.getPath());
+                int rc = com.sun.tools.javac.Main.compile(args.toArray(new String[args.size()]));
+                if (rc != 0)
+                    throw new Exception("compilation failed, rc=" + rc);
+                break;
+
+            case API:
+                fm.setLocation(StandardLocation.SOURCE_PATH, Arrays.asList(srcDir));
+                fm.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(classesDir));
+                fm.setLocation(StandardLocation.NATIVE_HEADER_OUTPUT, Arrays.asList(headersDir));
+                JavacTask task = javac.getTask(null, fm, null, args, null,
+                        fm.getJavaFileObjectsFromFiles(files));
+                if (!task.call())
+                    throw new Exception("compilation failed");
+                break;
+        }
+
+        Set<String> found = createSet(headersDir.list());
+        checkEqual("header files", expect, found);
+    }
+
+    /** Marker annotation for test cases. */
+    @Retention(RetentionPolicy.RUNTIME)
+    @interface Test { }
+
+    /** Combo test to run all test cases in all modes. */
+    void run() throws Exception {
+        javac = JavacTool.create();
+        fm = javac.getStandardFileManager(null, null, null);
+
+        for (RunKind rk: RunKind.values()) {
+            for (GenKind gk: GenKind.values()) {
+                for (Method m: getClass().getDeclaredMethods()) {
+                    Annotation a = m.getAnnotation(Test.class);
+                    if (a != null) {
+                        init(rk, gk, m.getName());
+                        try {
+                            m.invoke(this, new Object[] { rk, gk });
+                        } catch (InvocationTargetException e) {
+                            Throwable cause = e.getCause();
+                            throw (cause instanceof Exception) ? ((Exception) cause) : e;
+                        }
+                        System.err.println();
+                    }
+                }
+            }
+        }
+        System.err.println(testCount + " tests" + ((errorCount == 0) ? "" : ", " + errorCount + " errors"));
+        if (errorCount > 0)
+            throw new Exception(errorCount + " errors found");
+    }
+
+    /**
+     * Init directories for a test case.
+     */
+    void init(RunKind rk, GenKind gk, String name) throws IOException {
+        System.err.println("Test " + rk + " " + gk + " " + name);
+        testCount++;
+
+        testDir = new File(rk.toString().toLowerCase() + "_" + gk.toString().toLowerCase() + "-" + name);
+        srcDir = new File(testDir, "src");
+        srcDir.mkdirs();
+        classesDir = new File(testDir, "classes");
+        classesDir.mkdirs();
+        headersDir = new File(testDir, "headers");
+        headersDir.mkdirs();
+    }
+
+    /** Create a source file with given body text. */
+    File createFile(String path, final String body) throws IOException {
+        File f = new File(srcDir, path);
+        f.getParentFile().mkdirs();
+        try (FileWriter out = new FileWriter(f)) {
+            out.write(body);
+        }
+        return f;
+    }
+
+    /** Convenience method to create a set of items. */
+    <T> Set<T> createSet(T... items) {
+        return new HashSet<T>(Arrays.asList(items));
+    }
+
+    /** Convenience method to check two values are equal, and report an error if not. */
+    <T> void checkEqual(String label, T expect, T found) {
+        if ((found == null) ? (expect == null) : found.equals(expect))
+            return;
+        System.err.println("Error: mismatch");
+        System.err.println("  expected: " + expect);
+        System.err.println("     found: " + found);
+        errorCount++;
+    }
+
+    // Shared across API test cases
+    JavacTool javac;
+    StandardJavaFileManager fm;
+
+    // Directories set up by init
+    File testDir;
+    File srcDir;
+    File classesDir;
+    File headersDir;
+
+    // Statistics
+    int testCount;
+    int errorCount;
+}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/nativeHeaders/javahComparison/CompareTest.java	Mon Mar 26 17:32:17 2012 -0700
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2007,2012 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 7150368
+ * @summary javac should include basic ability to generate native headers
+ */
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class CompareTest {
+    public static void main(String... args) throws Exception {
+        new CompareTest().run();
+    }
+
+    void run() throws Exception {
+        File srcDir = new File(System.getProperty("test.src"));
+        File classesDir = new File("classes");
+        classesDir.mkdirs();
+        File javacHeaders = new File("headers.javac");
+        javacHeaders.mkdirs();
+        File javahHeaders = new File("headers.javah");
+        javahHeaders.mkdirs();
+
+        List<String> javacArgs = new ArrayList<String>();
+        javacArgs.add("-d");
+        javacArgs.add(classesDir.getPath());
+        javacArgs.add("-h");
+        javacArgs.add(javacHeaders.getPath());
+        javacArgs.add("-XDjavah:full");
+
+        for (File f: srcDir.listFiles()) {
+            if (f.getName().matches("TestClass[0-9]+\\.java")) {
+                sourceFileCount++;
+                javacArgs.add(f.getPath());
+            }
+        }
+
+        int rc = com.sun.tools.javac.Main.compile(javacArgs.toArray(new String[javacArgs.size()]));
+        if (rc != 0)
+            throw new Exception("javac failed; rc=" + rc);
+
+        List<String> javahArgs = new ArrayList<String>();
+        javahArgs.add("-d");
+        javahArgs.add(javahHeaders.getPath());
+
+        for (File f: classesDir.listFiles()) {
+            if (f.getName().endsWith(".class")) {
+                javahArgs.add(inferBinaryName(f));
+            }
+        }
+
+        PrintWriter pw = new PrintWriter(System.out, true);
+        rc = com.sun.tools.javah.Main.run(javahArgs.toArray(new String[javahArgs.size()]), pw);
+        if (rc != 0)
+            throw new Exception("javah failed; rc=" + rc);
+
+        compare(javahHeaders, javacHeaders);
+
+        int javahHeaderCount = javahHeaders.list().length;
+        int javacHeaderCount = javacHeaders.list().length;
+
+        System.out.println(sourceFileCount + " .java files found");
+        System.out.println(javacHeaderCount + " .h files generated by javac");
+        System.out.println(javahHeaderCount + " .h files generated by javah");
+        System.out.println(compareCount + " header files compared");
+
+        if (javacHeaderCount != javahHeaderCount || javacHeaderCount != compareCount)
+            error("inconsistent counts");
+
+        if (errors > 0)
+            throw new Exception(errors + " errors occurred");
+    }
+
+    String inferBinaryName(File file) {
+        String name = file.getName();
+        return name.substring(0, name.length() - ".class".length()).replace("$", ".");
+    }
+
+    /** Compare two directories.
+     *  @param f1 The golden directory
+     *  @param f2 The directory to be compared
+     */
+    void compare(File f1, File f2) {
+        compare(f1, f2, null);
+    }
+
+    /** Compare two files or directories
+     *  @param f1 The golden directory
+     *  @param f2 The directory to be compared
+     *  @param p An optional path identifying a file within the two directories
+     */
+    void compare(File f1, File f2, String p) {
+        File f1p = (p == null ? f1 : new File(f1, p));
+        File f2p = (p == null ? f2 : new File(f2, p));
+        if (f1p.isDirectory() && f2p.isDirectory()) {
+            Set<String> children = new HashSet<String>();
+            children.addAll(Arrays.asList(f1p.list()));
+            children.addAll(Arrays.asList(f2p.list()));
+            for (String c: children) {
+                compare(f1, f2, new File(p, c).getPath()); // null-safe for p
+            }
+        }
+        else if (f1p.isFile() && f2p.isFile()) {
+            System.out.println("checking " + p);
+            compareCount++;
+            String s1 = read(f1p);
+            String s2 = read(f2p);
+            if (!s1.equals(s2)) {
+                System.out.println("File: " + f1p + "\n" + s1);
+                System.out.println("File: " + f2p + "\n" + s2);
+                error("Files differ: " + f1p + " " + f2p);
+            }
+        }
+        else if (f1p.exists() && !f2p.exists())
+            error("Only in " + f1 + ": " + p);
+        else if (f2p.exists() && !f1p.exists())
+            error("Only in " + f2 + ": " + p);
+        else
+            error("Files differ: " + f1p + " " + f2p);
+    }
+
+    private String read(File f) {
+        try {
+            return new String(Files.readAllBytes(f.toPath()));
+        } catch (IOException e) {
+            error("error reading " + f + ": " + e);
+            return "";
+        }
+    }
+
+    private void error(String msg) {
+        System.out.println(msg);
+        errors++;
+    }
+
+    private int errors;
+    private int compareCount;
+    private int sourceFileCount;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/nativeHeaders/javahComparison/TestClass1.java	Mon Mar 26 17:32:17 2012 -0700
@@ -0,0 +1,475 @@
+/*
+ * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+import java.util.List;
+
+public class TestClass1 {
+    // simple types
+    byte b;
+    short s;
+    int i;
+    long l;
+    float f;
+    double d;
+    Object o;
+    String t;
+    List<String> g;
+
+    // constants
+    static final byte bc = 0;
+    static final short sc = 0;
+    static final int ic = 0;
+    static final long lc = 0;
+    static final float fc = 0;
+    static final double dc = 0;
+    static final Object oc = null;
+    static final String tc = "";
+    static final List<String> gc = null;
+
+    // simple arrays
+    byte[] ba;
+    short[] sa; // not handled corrected by javah v6
+    int[] ia;
+    long[] la;
+    float[] fa;
+    double[] da;
+    Object[] oa;
+    String[] ta;
+    List<String>[] ga;
+
+    // multidimensional arrays
+    byte[][] baa;
+    short[][] saa;
+    int[][] iaa;
+    long[][] laa;
+    float[][] faa;
+    double[][] daa;
+    Object[][] oaa;
+    String[][] taa;
+    List<String>[] gaa;
+
+    // simple Java methods
+    byte bm() { return 0; }
+    short sm() { return 0; }
+    int im() { return 0; }
+    long lm() { return 0; }
+    float fm() { return 0; }
+    double dm() { return 0; }
+    Object om() { return null; }
+    String tm() { return ""; }
+    List<String> gm() { return null; }
+    void vm() { }
+    byte[] bam() { return null; }
+    short[] sam() { return null; }
+    int[] iam() { return null; }
+    long[] lam() { return null; }
+    float[] fam() { return null; }
+    double[] dam() { return null; }
+    Object[] oam() { return null; }
+    String[] tam() { return null; }
+    List<String>[] gam() { return null; }
+    byte[][] baam() { return null; }
+    short[][] saam() { return null; }
+    int[][] iaam() { return null; }
+    long[][] laam() { return null; }
+    float[][] faam() { return null; }
+    double[][] daam() { return null; }
+    Object[][] oaam() { return null; }
+    String[][] taam() { return null; }
+    List<String>[] gaam() { return null; }
+
+    // simple native methods
+    native byte bmn();
+    native short smn();
+    native int imn();
+    native long lmn();
+    native float fmn();
+    native double dmn();
+    native Object omn();
+    native String tmn();
+    native List<String> gmn();
+    native void vmn();
+    native byte[] bamn();
+    native short[] samn();
+    native int[] iamn();
+    native long[] lamn();
+    native float[] famn();
+    native double[] damn();
+    native Object[] oamn();
+    native String[] tamn();
+    native List<String>[] gamn();
+    native byte[][] baamn();
+    native short[][] saamn();
+    native int[][] iaamn();
+    native long[][] laamn();
+    native float[][] faamn();
+    native double[][] daamn();
+    native Object[][] oaamn();
+    native String[][] taamn();
+    native List<String>[] gaamn();
+
+    // overloaded Java methods
+    byte bm1() { return 0; }
+    short sm1() { return 0; }
+    int im1() { return 0; }
+    long lm1() { return 0; }
+    float fm1() { return 0; }
+    double dm1() { return 0; }
+    Object om1() { return null; }
+    String tm1() { return ""; }
+    List<String> gm1() { return null; }
+    void vm1() { }
+
+    byte bm2(int i) { return 0; }
+    short sm2(int i) { return 0; }
+    int im2(int i) { return 0; }
+    long lm2(int i) { return 0; }
+    float fm2(int i) { return 0; }
+    double dm2(int i) { return 0; }
+    Object om2(int i) { return null; }
+    String tm2(int i) { return ""; }
+    List<String> gm2(int i) { return null; }
+    void vm2(int i) { }
+
+    // overloaded native methods
+    native byte bmn1();
+    native short smn1();
+    native int imn1();
+    native long lmn1();
+    native float fmn1();
+    native double dmn1();
+    native Object omn1();
+    native String tmn1();
+    native List<String> gmn1();
+    native void vmn1();
+
+    native byte bmn2(int i);
+    native short smn2(int i);
+    native int imn2(int i);
+    native long lmn2(int i);
+    native float fmn2(int i);
+    native double dmn2(int i);
+    native Object omn2(int i);
+    native String tmn2(int i);
+    native List<String> gmn2(int i);
+    native void vmn2(int i);
+
+    // arg types for Java methods
+    void mb(byte b) { }
+    void ms(short s) { }
+    void mi(int i) { }
+    void ml(long l) { }
+    void mf(float f) { }
+    void md(double d) { }
+    void mo(Object o) { }
+    void mt(String t) { }
+    void mg(List<String> g) { }
+
+    // arg types for native methods
+    native void mbn(byte b);
+    native void msn(short s);
+    native void min(int i);
+    native void mln(long l);
+    native void mfn(float f);
+    native void mdn(double d);
+    native void mon(Object o);
+    native void mtn(String t);
+    native void mgn(List<String> g);
+
+    static class Inner1 {
+        // simple types
+        byte b;
+        short s;
+        int i;
+        long l;
+        float f;
+        double d;
+        Object o;
+        String t;
+        List<String> g;
+
+        // constants
+        static final byte bc = 0;
+        static final short sc = 0;
+        static final int ic = 0;
+        static final long lc = 0;
+        static final float fc = 0;
+        static final double dc = 0;
+        static final Object oc = null;
+        static final String tc = "";
+        static final List<String> gc = null;
+
+        // simple arrays
+        byte[] ba;
+        // short[] sa; // not handled corrected by javah v6
+        int[] ia;
+        long[] la;
+        float[] fa;
+        double[] da;
+        Object[] oa;
+        String[] ta;
+        List<String>[] ga;
+
+        // multidimensional arrays
+        byte[][] baa;
+        short[][] saa;
+        int[][] iaa;
+        long[][] laa;
+        float[][] faa;
+        double[][] daa;
+        Object[][] oaa;
+        String[][] taa;
+        List<String>[] gaa;
+
+        // simple Java methods
+        byte bm() { return 0; }
+        short sm() { return 0; }
+        int im() { return 0; }
+        long lm() { return 0; }
+        float fm() { return 0; }
+        double dm() { return 0; }
+        Object om() { return null; }
+        String tm() { return ""; }
+        List<String> gm() { return null; }
+        void vm() { }
+
+        // simple native methods
+        native byte bmn();
+        native short smn();
+        native int imn();
+        native long lmn();
+        native float fmn();
+        native double dmn();
+        native Object omn();
+        native String tmn();
+        native List<String> gmn();
+        native void vmn();
+
+        // overloaded Java methods
+        byte bm1() { return 0; }
+        short sm1() { return 0; }
+        int im1() { return 0; }
+        long lm1() { return 0; }
+        float fm1() { return 0; }
+        double dm1() { return 0; }
+        Object om1() { return null; }
+        String tm1() { return ""; }
+        List<String> gm1() { return null; }
+        void vm1() { }
+
+        byte bm2(int i) { return 0; }
+        short sm2(int i) { return 0; }
+        int im2(int i) { return 0; }
+        long lm2(int i) { return 0; }
+        float fm2(int i) { return 0; }
+        double dm2(int i) { return 0; }
+        Object om2(int i) { return null; }
+        String tm2(int i) { return ""; }
+        List<String> gm2(int i) { return null; }
+        void vm2(int i) { }
+
+        // overloaded native methods
+        native byte bmn1();
+        native short smn1();
+        native int imn1();
+        native long lmn1();
+        native float fmn1();
+        native double dmn1();
+        native Object omn1();
+        native String tmn1();
+        native List<String> gmn1();
+        native void vmn1();
+
+        native byte bmn2(int i);
+        native short smn2(int i);
+        native int imn2(int i);
+        native long lmn2(int i);
+        native float fmn2(int i);
+        native double dmn2(int i);
+        native Object omn2(int i);
+        native String tmn2(int i);
+        native List<String> gmn2(int i);
+        native void vmn2(int i);
+
+        // arg types for Java methods
+        void mb(byte b) { }
+        void ms(short s) { }
+        void mi(int i) { }
+        void ml(long l) { }
+        void mf(float f) { }
+        void md(double d) { }
+        void mo(Object o) { }
+        void mt(String t) { }
+        void mg(List<String> g) { }
+
+        // arg types for native methods
+        native void mbn(byte b);
+        native void msn(short s);
+        native void min(int i);
+        native void mln(long l);
+        native void mfn(float f);
+        native void mdn(double d);
+        native void mon(Object o);
+        native void mtn(String t);
+        native void mgn(List<String> g);
+    }
+
+    class Inner2 {
+        // simple types
+        byte b;
+        short s;
+        int i;
+        long l;
+        float f;
+        double d;
+        Object o;
+        String t;
+        List<String> g;
+
+        // constants
+        static final byte bc = 0;
+        static final short sc = 0;
+        static final int ic = 0;
+        static final long lc = 0;
+        static final float fc = 0;
+        static final double dc = 0;
+        //static final Object oc = null;
+        static final String tc = "";
+        //static final List<String> gc = null;
+
+        // simple arrays
+        byte[] ba;
+        // short[] sa; // not handled corrected by javah v6
+        int[] ia;
+        long[] la;
+        float[] fa;
+        double[] da;
+        Object[] oa;
+        String[] ta;
+        List<String>[] ga;
+
+        // multidimensional arrays
+        byte[][] baa;
+        short[][] saa;
+        int[][] iaa;
+        long[][] laa;
+        float[][] faa;
+        double[][] daa;
+        Object[][] oaa;
+        String[][] taa;
+        List<String>[] gaa;
+
+        // simple Java methods
+        byte bm() { return 0; }
+        short sm() { return 0; }
+        int im() { return 0; }
+        long lm() { return 0; }
+        float fm() { return 0; }
+        double dm() { return 0; }
+        Object om() { return null; }
+        String tm() { return ""; }
+        List<String> gm() { return null; }
+        void vm() { }
+
+        // simple native methods
+        native byte bmn();
+        native short smn();
+        native int imn();
+        native long lmn();
+        native float fmn();
+        native double dmn();
+        native Object omn();
+        native String tmn();
+        native List<String> gmn();
+        native void vmn();
+
+        // overloaded Java methods
+        byte bm1() { return 0; }
+        short sm1() { return 0; }
+        int im1() { return 0; }
+        long lm1() { return 0; }
+        float fm1() { return 0; }
+        double dm1() { return 0; }
+        Object om1() { return null; }
+        String tm1() { return ""; }
+        List<String> gm1() { return null; }
+        void vm1() { }
+
+        byte bm2(int i) { return 0; }
+        short sm2(int i) { return 0; }
+        int im2(int i) { return 0; }
+        long lm2(int i) { return 0; }
+        float fm2(int i) { return 0; }
+        double dm2(int i) { return 0; }
+        Object om2(int i) { return null; }
+        String tm2(int i) { return ""; }
+        List<String> gm2(int i) { return null; }
+        void vm2(int i) { }
+
+        // overloaded native methods
+        native byte bmn1();
+        native short smn1();
+        native int imn1();
+        native long lmn1();
+        native float fmn1();
+        native double dmn1();
+        native Object omn1();
+        native String tmn1();
+        native List<String> gmn1();
+        native void vmn1();
+
+        native byte bmn2(int i);
+        native short smn2(int i);
+        native int imn2(int i);
+        native long lmn2(int i);
+        native float fmn2(int i);
+        native double dmn2(int i);
+        native Object omn2(int i);
+        native String tmn2(int i);
+        native List<String> gmn2(int i);
+        native void vmn2(int i);
+
+        // arg types for Java methods
+        void mb(byte b) { }
+        void ms(short s) { }
+        void mi(int i) { }
+        void ml(long l) { }
+        void mf(float f) { }
+        void md(double d) { }
+        void mo(Object o) { }
+        void mt(String t) { }
+        void mg(List<String> g) { }
+
+        // arg types for native methods
+        native void mbn(byte b);
+        native void msn(short s);
+        native void min(int i);
+        native void mln(long l);
+        native void mfn(float f);
+        native void mdn(double d);
+        native void mon(Object o);
+        native void mtn(String t);
+        native void mgn(List<String> g);
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/nativeHeaders/javahComparison/TestClass2.java	Mon Mar 26 17:32:17 2012 -0700
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+import javax.tools.annotation.GenerateNativeHeader;
+
+@GenerateNativeHeader
+public class TestClass2 {
+    byte b;
+    short s;
+    int i;
+    long l;
+    float f;
+    double d;
+    Object o;
+    String t;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/nativeHeaders/javahComparison/TestClass3.java	Mon Mar 26 17:32:17 2012 -0700
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+import javax.tools.annotation.GenerateNativeHeader;
+
+@GenerateNativeHeader
+public class TestClass3 {
+    public int tc3;
+
+    public class Inner1 {
+        public int tc3i1;
+
+        public class Inner1A {
+            public int tc3i1i1a;
+        }
+
+        public class Inner1B {
+            public int tc3i1i1b;
+        }
+    }
+
+    public class Inner2 {
+        public int tc321;
+
+        public class Inner2A {
+            public int tc3i2i2a;
+        }
+
+        public class Inner2B {
+            public int tc3i2i2b;
+        }
+    }
+}
+