(Arrays.asList(toolChoices));
+ l.add(0, "");
+ toolChoices = l.toArray(new String[l.size()]);
+ }
+ toolChoice = new JComboBox(toolChoices);
+ if (toolName != null)
+ toolChoice.setSelectedItem(toolName);
+ toolChoice.addItemListener(new ItemListener() {
+ public void itemStateChanged(ItemEvent e) {
+ String tn = (String) e.getItem();
+ argsField.setText(getDefaultArgsForTool(props, tn));
+ if (toolProperty != null)
+ okButton.setEnabled(!tn.equals(""));
+ }
+ });
+ body.add(toolChoice, fc);
+
+ argsField = new JTextField(getDefaultArgsForTool(props, toolName), 40);
+ if (toolProperty == null || argsProperty != null) {
+ JLabel argsLabel = new JLabel("Args:");
+ body.add(argsLabel, lc);
+ body.add(argsField, fc);
+ argsField.addFocusListener(new FocusListener() {
+ public void focusGained(FocusEvent e) {
+ }
+ public void focusLost(FocusEvent e) {
+ String toolName = (String) toolChoice.getSelectedItem();
+ if (toolName.length() > 0)
+ props.put(toolName + ".args", argsField.getText());
+ }
+ });
+ }
+
+ defaultCheck = new JCheckBox("Set as default");
+ if (toolProperty == null)
+ defaultCheck.setSelected(true);
+ else
+ body.add(defaultCheck, fc);
+
+ final JOptionPane p = new JOptionPane(body);
+ okButton = new JButton("OK");
+ okButton.setEnabled(toolProperty == null || (toolName != null && !toolName.equals("")));
+ okButton.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ JDialog d = (JDialog) SwingUtilities.getAncestorOfClass(JDialog.class, p);
+ d.setVisible(false);
+ }
+ });
+ p.setOptions(new Object[] { okButton });
+
+ return p;
+ }
+
+ Properties readProperties(File file) {
+ Properties p = new Properties();
+ if (file != null && file.exists()) {
+ Reader in = null;
+ try {
+ in = new BufferedReader(new FileReader(file));
+ p.load(in);
+ in.close();
+ } catch (IOException e) {
+ throw new BuildException("error reading property file", e);
+ } finally {
+ if (in != null) {
+ try {
+ in.close();
+ } catch (IOException e) {
+ throw new BuildException("cannot close property file", e);
+ }
+ }
+ }
+ }
+ return p;
+ }
+
+ void writeProperties(File file, Properties p) {
+ if (file != null) {
+ Writer out = null;
+ try {
+ File dir = file.getParentFile();
+ if (dir != null && !dir.exists())
+ dir.mkdirs();
+ out = new BufferedWriter(new FileWriter(file));
+ p.store(out, "langtools properties");
+ out.close();
+ } catch (IOException e) {
+ throw new BuildException("error writing property file", e);
+ } finally {
+ if (out != null) {
+ try {
+ out.close();
+ } catch (IOException e) {
+ throw new BuildException("cannot close property file", e);
+ }
+ }
+ }
+ }
+ }
+
+ String getDefaultArgsForTool(Properties props, String tn) {
+ return (tn == null || tn.equals("")) ? "" : props.getProperty(tn + ".args", "");
+ }
+
+ // Ant task parameters
+ private boolean askIfUnset;
+ private String toolProperty;
+ private String argsProperty;
+ private File propertyFile;
+
+ // GUI components
+ private JComboBox toolChoice;
+ private JTextField argsField;
+ private JCheckBox defaultCheck;
+ private JButton okButton;
+
+ // Result values for the client
+ private String toolName;
+ private String toolArgs;
+}
--- /dev/null 2012-02-29 08:26:07.944315018 +0100
+++ new/make/tools/compileproperties/CompileProperties.java 2012-03-02 15:59:37.449604472 +0100
@@ -0,0 +1,404 @@
+/*
+ * Copyright (c) 2002, 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 compileproperties;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Properties;
+
+/** Translates a .properties file into a .java file containing the
+ * definition of a java.util.Properties subclass which can then be
+ * compiled with javac.
+ *
+ * Usage: java CompileProperties [path to .properties file] [path to .java file to be output] [super class]
+ *
+ * Infers the package by looking at the common suffix of the two
+ * inputs, eliminating "classes" from it.
+ *
+ * @author Scott Violet
+ * @author Kenneth Russell
+ */
+
+public class CompileProperties {
+
+ public static void main(String[] args) {
+ CompileProperties cp = new CompileProperties();
+ boolean ok = cp.run(args);
+ if ( !ok ) {
+ System.exit(1);
+ }
+ }
+
+ public static interface Log {
+ void info(String msg);
+ void verbose(String msg);
+ void error(String msg, Exception e);
+ }
+
+ private String propfiles[];
+ private String outfiles[] ;
+ private String supers[] ;
+ private int compileCount = 0;
+ private boolean quiet = false;
+ public Log log;
+
+ public void setLog(Log log) {
+ this.log = log;
+ }
+
+ public boolean run(String[] args) {
+ if (log == null) {
+ log = new Log() {
+ public void error(String msg, Exception e) {
+ System.err.println("ERROR: CompileProperties: " + msg);
+ if ( e != null ) {
+ System.err.println("EXCEPTION: " + e.toString());
+ e.printStackTrace();
+ }
+ }
+ public void info(String msg) {
+ System.out.println(msg);
+ }
+ public void verbose(String msg) {
+ if (!quiet)
+ System.out.println(msg);
+ }
+ };
+ }
+
+ boolean ok = true;
+ /* Original usage */
+ if (args.length == 2 && args[0].charAt(0) != '-' ) {
+ ok = createFile(args[0], args[1], "java.util.ListResourceBundle");
+ } else if (args.length == 3) {
+ ok = createFile(args[0], args[1], args[2]);
+ } else if (args.length == 0) {
+ usage(log);
+ ok = false;
+ } else {
+ /* New batch usage */
+ ok = parseOptions(args);
+ if ( ok && compileCount == 0 ) {
+ log.error("options parsed but no files to compile", null);
+ ok = false;
+ }
+ /* Need at least one file. */
+ if ( !ok ) {
+ usage(log);
+ } else {
+ /* Process files */
+ for ( int i = 0; i < compileCount && ok ; i++ ) {
+ ok = createFile(propfiles[i], outfiles[i], supers[i]);
+ }
+ }
+ }
+ return ok;
+ }
+
+ private boolean parseOptions(String args[]) {
+ boolean ok = true;
+ if ( compileCount > 0 ) {
+ String new_propfiles[] = new String[compileCount + args.length];
+ String new_outfiles[] = new String[compileCount + args.length];
+ String new_supers[] = new String[compileCount + args.length];
+ System.arraycopy(propfiles, 0, new_propfiles, 0, compileCount);
+ System.arraycopy(outfiles, 0, new_outfiles, 0, compileCount);
+ System.arraycopy(supers, 0, new_supers, 0, compileCount);
+ propfiles = new_propfiles;
+ outfiles = new_outfiles;
+ supers = new_supers;
+ } else {
+ propfiles = new String[args.length];
+ outfiles = new String[args.length];
+ supers = new String[args.length];
+ }
+
+ for ( int i = 0; i < args.length ; i++ ) {
+ if ( "-compile".equals(args[i]) && i+3 < args.length ) {
+ propfiles[compileCount] = args[++i];
+ outfiles[compileCount] = args[++i];
+ supers[compileCount] = args[++i];
+ compileCount++;
+ } else if ( "-optionsfile".equals(args[i]) && i+1 < args.length ) {
+ String filename = args[++i];
+ FileInputStream finput = null;
+ byte contents[] = null;
+ try {
+ finput = new FileInputStream(filename);
+ int byteCount = finput.available();
+ if ( byteCount <= 0 ) {
+ log.error("The -optionsfile file is empty", null);
+ ok = false;
+ } else {
+ contents = new byte[byteCount];
+ int bytesRead = finput.read(contents);
+ if ( byteCount != bytesRead ) {
+ log.error("Cannot read all of -optionsfile file", null);
+ ok = false;
+ }
+ }
+ } catch ( IOException e ) {
+ log.error("cannot open " + filename, e);
+ ok = false;
+ }
+ if ( finput != null ) {
+ try {
+ finput.close();
+ } catch ( IOException e ) {
+ ok = false;
+ log.error("cannot close " + filename, e);
+ }
+ }
+ if ( ok = true && contents != null ) {
+ String tokens[] = (new String(contents)).split("\\s+");
+ if ( tokens.length > 0 ) {
+ ok = parseOptions(tokens);
+ }
+ }
+ if ( !ok ) {
+ break;
+ }
+ } else if ( "-quiet".equals(args[i]) ) {
+ quiet = true;
+ } else {
+ log.error("argument error", null);
+ ok = false;
+ }
+ }
+ return ok;
+ }
+
+ private boolean createFile(String propertiesPath, String outputPath,
+ String superClass) {
+ boolean ok = true;
+ log.verbose("parsing: " + propertiesPath);
+ Properties p = new Properties();
+ try {
+ p.load(new FileInputStream(propertiesPath));
+ } catch ( FileNotFoundException e ) {
+ ok = false;
+ log.error("Cannot find file " + propertiesPath, e);
+ } catch ( IOException e ) {
+ ok = false;
+ log.error("IO error on file " + propertiesPath, e);
+ }
+ if ( ok ) {
+ String packageName = inferPackageName(propertiesPath, outputPath);
+ log.verbose("inferred package name: " + packageName);
+ List sortedKeys = new ArrayList();
+ for ( Object key : p.keySet() ) {
+ sortedKeys.add((String)key);
+ }
+ Collections.sort(sortedKeys);
+ Iterator keys = sortedKeys.iterator();
+
+ StringBuffer data = new StringBuffer();
+
+ while (keys.hasNext()) {
+ String key = keys.next();
+ data.append(" { \"" + escape(key) + "\", \"" +
+ escape((String)p.get(key)) + "\" },\n");
+ }
+
+ // Get class name from java filename, not the properties filename.
+ // (zh_TW properties might be used to create zh_HK files)
+ File file = new File(outputPath);
+ String name = file.getName();
+ int dotIndex = name.lastIndexOf('.');
+ String className;
+ if (dotIndex == -1) {
+ className = name;
+ } else {
+ className = name.substring(0, dotIndex);
+ }
+
+ String packageString = "";
+ if (packageName != null && !packageName.equals("")) {
+ packageString = "package " + packageName + ";\n\n";
+ }
+
+ Writer writer = null;
+ try {
+ writer = new BufferedWriter(
+ new OutputStreamWriter(new FileOutputStream(outputPath), "8859_1"));
+ MessageFormat format = new MessageFormat(FORMAT);
+ writer.write(format.format(new Object[] { packageString, className, superClass, data }));
+ } catch ( IOException e ) {
+ ok = false;
+ log.error("IO error writing to file " + outputPath, e);
+ }
+ if ( writer != null ) {
+ try {
+ writer.flush();
+ } catch ( IOException e ) {
+ ok = false;
+ log.error("IO error flush " + outputPath, e);
+ }
+ try {
+ writer.close();
+ } catch ( IOException e ) {
+ ok = false;
+ log.error("IO error close " + outputPath, e);
+ }
+ }
+ log.verbose("wrote: " + outputPath);
+ }
+ return ok;
+ }
+
+ private static void usage(Log log) {
+ log.info("usage:");
+ log.info(" java CompileProperties path_to_properties_file path_to_java_output_file [super_class]");
+ log.info(" -OR-");
+ log.info(" java CompileProperties {-compile path_to_properties_file path_to_java_output_file super_class} -or- -optionsfile filename");
+ log.info("");
+ log.info("Example:");
+ log.info(" java CompileProperties -compile test.properties test.java java.util.ListResourceBundle");
+ log.info(" java CompileProperties -optionsfile option_file");
+ log.info("option_file contains: -compile test.properties test.java java.util.ListResourceBundle");
+ }
+
+ private static String escape(String theString) {
+ // This is taken from Properties.saveConvert with changes for Java strings
+ int len = theString.length();
+ StringBuffer outBuffer = new StringBuffer(len*2);
+
+ for(int x=0; x 0x007e)) {
+ outBuffer.append('\\');
+ outBuffer.append('u');
+ outBuffer.append(toHex((aChar >> 12) & 0xF));
+ outBuffer.append(toHex((aChar >> 8) & 0xF));
+ outBuffer.append(toHex((aChar >> 4) & 0xF));
+ outBuffer.append(toHex( aChar & 0xF));
+ } else {
+ if (specialSaveChars.indexOf(aChar) != -1) {
+ outBuffer.append('\\');
+ }
+ outBuffer.append(aChar);
+ }
+ }
+ }
+ return outBuffer.toString();
+ }
+
+ private static String inferPackageName(String inputPath, String outputPath) {
+ // Normalize file names
+ inputPath = new File(inputPath).getPath();
+ outputPath = new File(outputPath).getPath();
+ // Split into components
+ String sep;
+ if (File.separatorChar == '\\') {
+ sep = "\\\\";
+ } else {
+ sep = File.separator;
+ }
+ String[] inputs = inputPath.split(sep);
+ String[] outputs = outputPath.split(sep);
+ // Match common names, eliminating first "classes" entry from
+ // each if present
+ int inStart = 0;
+ int inEnd = inputs.length - 2;
+ int outEnd = outputs.length - 2;
+ int i = inEnd;
+ int j = outEnd;
+ while (i >= 0 && j >= 0) {
+ if (!inputs[i].equals(outputs[j]) ||
+ (inputs[i].equals("gensrc") && inputs[j].equals("gensrc"))) {
+ ++i;
+ ++j;
+ break;
+ }
+ --i;
+ --j;
+ }
+ String result;
+ if (i < 0 || j < 0 || i >= inEnd || j >= outEnd) {
+ result = "";
+ } else {
+ if (inputs[i].equals("classes") && outputs[j].equals("classes")) {
+ ++i;
+ }
+ inStart = i;
+ StringBuffer buf = new StringBuffer();
+ for (i = inStart; i <= inEnd; i++) {
+ buf.append(inputs[i]);
+ if (i < inEnd) {
+ buf.append('.');
+ }
+ }
+ result = buf.toString();
+ }
+ return result;
+ }
+
+ private static final String FORMAT =
+ "{0}" +
+ "public final class {1} extends {2} '{'\n" +
+ " protected final Object[][] getContents() '{'\n" +
+ " return new Object[][] '{'\n" +
+ "{3}" +
+ " };\n" +
+ " }\n" +
+ "}\n";
+
+ // This comes from Properties
+ private static char toHex(int nibble) {
+ return hexDigit[(nibble & 0xF)];
+ }
+
+ // This comes from Properties
+ private static final char[] hexDigit = {
+ '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
+ };
+
+ // Note: different from that in Properties
+ private static final String specialSaveChars = "\"";
+}
--- /dev/null 2012-02-29 08:26:07.944315018 +0100
+++ new/make/tools/genstubs/GenStubs.java 2012-03-02 15:59:38.001604498 +0100
@@ -0,0 +1,316 @@
+/*
+ * Copyright (c) 2009, 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 genstubs;
+
+import java.io.*;
+import java.util.*;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
+
+import com.sun.source.tree.CompilationUnitTree;
+import com.sun.source.util.JavacTask;
+import com.sun.tools.javac.api.JavacTool;
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.code.TypeTags;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
+import com.sun.tools.javac.tree.JCTree.JCIdent;
+import com.sun.tools.javac.tree.JCTree.JCImport;
+import com.sun.tools.javac.tree.JCTree.JCLiteral;
+import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
+import com.sun.tools.javac.tree.JCTree.JCModifiers;
+import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
+import com.sun.tools.javac.tree.Pretty;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.TreeScanner;
+import com.sun.tools.javac.tree.TreeTranslator;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.ListBuffer;
+import com.sun.tools.javac.util.Name;
+import javax.tools.JavaFileManager;
+
+/**
+ * Generate stub source files by removing implementation details from input files.
+ *
+ * This is a special purpose stub generator, specific to the needs of generating
+ * stub files for JDK 7 API that are needed to compile langtools files that depend
+ * on that API. The stub generator works by removing as much of the API source code
+ * as possible without affecting the public signature, in order to reduce the
+ * transitive closure of the API being referenced. The resulting stubs can be
+ * put on the langtools sourcepath with -implicit:none to compile the langtools
+ * files that depend on the JDK 7 API.
+ *
+ * Usage:
+ * genstubs -s -sourcepath
+ *
+ * The specified class names are looked up on the sourcepath, and corresponding
+ * stubs are written to the source output directory.
+ *
+ * Classes are parsed into javac ASTs, then processed with a javac TreeTranslator
+ * to remove implementation details, and written out in the source output directory.
+ * Documentation comments and annotations are removed. Method bodies are removed
+ * and methods are marked native. Private and package-private field definitions
+ * have their initializers replace with 0, 0.0, false, null as appropriate.
+ */
+
+public class GenStubs {
+ static class Fault extends Exception {
+ private static final long serialVersionUID = 0;
+ Fault(String message) {
+ super(message);
+ }
+ Fault(String message, Throwable cause) {
+ super(message);
+ initCause(cause);
+ }
+ }
+
+ public static void main(String[] args) {
+ boolean ok = new GenStubs().run(args);
+ if (!ok)
+ System.exit(1);
+ }
+
+ public boolean run(String... args) {
+ File outdir = null;
+ String sourcepath = null;
+ List classes = new ArrayList();
+ for (ListIterator iter = Arrays.asList(args).listIterator(); iter.hasNext(); ) {
+ String arg = iter.next();
+ if (arg.equals("-s") && iter.hasNext())
+ outdir = new File(iter.next());
+ else if (arg.equals("-sourcepath") && iter.hasNext())
+ sourcepath = iter.next();
+ else if (arg.startsWith("-"))
+ throw new IllegalArgumentException(arg);
+ else {
+ classes.add(arg);
+ while (iter.hasNext())
+ classes.add(iter.next());
+ }
+ }
+
+ return run(sourcepath, outdir, classes);
+ }
+
+ public boolean run(String sourcepath, File outdir, List classes) {
+ //System.err.println("run: sourcepath:" + sourcepath + " outdir:" + outdir + " classes:" + classes);
+ if (sourcepath == null)
+ throw new IllegalArgumentException("sourcepath not set");
+ if (outdir == null)
+ throw new IllegalArgumentException("source output dir not set");
+
+ JavacTool tool = JavacTool.create();
+ StandardJavaFileManager fm = tool.getStandardFileManager(null, null, null);
+
+ try {
+ fm.setLocation(StandardLocation.SOURCE_OUTPUT, Collections.singleton(outdir));
+ fm.setLocation(StandardLocation.SOURCE_PATH, splitPath(sourcepath));
+ List files = new ArrayList();
+ for (String c: classes) {
+ JavaFileObject fo = fm.getJavaFileForInput(
+ StandardLocation.SOURCE_PATH, c, JavaFileObject.Kind.SOURCE);
+ if (fo == null)
+ error("class not found: " + c);
+ else
+ files.add(fo);
+ }
+
+ JavacTask t = tool.getTask(null, fm, null, null, null, files);
+ Iterable trees = t.parse();
+ for (CompilationUnitTree tree: trees) {
+ makeStub(fm, tree);
+ }
+ } catch (IOException e) {
+ error("IO error " + e, e);
+ }
+
+ return (errors == 0);
+ }
+
+ void makeStub(StandardJavaFileManager fm, CompilationUnitTree tree) throws IOException {
+ CompilationUnitTree tree2 = new StubMaker().translate(tree);
+ CompilationUnitTree tree3 = new ImportCleaner(fm).removeRedundantImports(tree2);
+
+ String className = fm.inferBinaryName(StandardLocation.SOURCE_PATH, tree.getSourceFile());
+ JavaFileObject fo = fm.getJavaFileForOutput(StandardLocation.SOURCE_OUTPUT,
+ className, JavaFileObject.Kind.SOURCE, null);
+ // System.err.println("Writing " + className + " to " + fo.getName());
+ Writer out = fo.openWriter();
+ try {
+ new Pretty(out, true).printExpr((JCTree) tree3);
+ } finally {
+ out.close();
+ }
+ }
+
+ List splitPath(String path) {
+ List list = new ArrayList();
+ for (String p: path.split(File.pathSeparator)) {
+ if (p.length() > 0)
+ list.add(new File(p));
+ }
+ return list;
+ }
+
+ void error(String message) {
+ System.err.println(message);
+ errors++;
+ }
+
+ void error(String message, Throwable cause) {
+ error(message);
+ }
+
+ int errors;
+
+ class StubMaker extends TreeTranslator {
+ CompilationUnitTree translate(CompilationUnitTree tree) {
+ return super.translate((JCCompilationUnit) tree);
+ }
+
+ /**
+ * compilation units: remove javadoc comments
+ * -- required, in order to remove @deprecated tags, since we
+ * (separately) remove all annotations, including @Deprecated
+ */
+ public void visitTopLevel(JCCompilationUnit tree) {
+ super.visitTopLevel(tree);
+ tree.docComments = Collections.emptyMap();
+ }
+
+ /**
+ * methods: remove method bodies, make methods native
+ */
+ @Override
+ public void visitMethodDef(JCMethodDecl tree) {
+ tree.mods = translate(tree.mods);
+ tree.restype = translate(tree.restype);
+ tree.typarams = translateTypeParams(tree.typarams);
+ tree.params = translateVarDefs(tree.params);
+ tree.thrown = translate(tree.thrown);
+ if (tree.restype != null && tree.body != null) {
+ tree.mods.flags |= Flags.NATIVE;
+ tree.body = null;
+ }
+ result = tree;
+ }
+
+ /**
+ * modifiers: remove annotations
+ */
+ @Override
+ public void visitModifiers(JCModifiers tree) {
+ tree.annotations = com.sun.tools.javac.util.List.nil();
+ result = tree;
+ }
+
+ /**
+ * field definitions: replace initializers with 0, 0.0, false etc
+ * when possible -- i.e. leave public, protected initializers alone
+ */
+ @Override
+ public void visitVarDef(JCVariableDecl tree) {
+ tree.mods = translate(tree.mods);
+ tree.vartype = translate(tree.vartype);
+ if (tree.init != null) {
+ if ((tree.mods.flags & (Flags.PUBLIC | Flags.PROTECTED)) != 0)
+ tree.init = translate(tree.init);
+ else {
+ String t = tree.vartype.toString();
+ if (t.equals("boolean"))
+ tree.init = new JCLiteral(TypeTags.BOOLEAN, 0) { };
+ else if (t.equals("byte"))
+ tree.init = new JCLiteral(TypeTags.BYTE, 0) { };
+ else if (t.equals("char"))
+ tree.init = new JCLiteral(TypeTags.CHAR, 0) { };
+ else if (t.equals("double"))
+ tree.init = new JCLiteral(TypeTags.DOUBLE, 0.d) { };
+ else if (t.equals("float"))
+ tree.init = new JCLiteral(TypeTags.FLOAT, 0.f) { };
+ else if (t.equals("int"))
+ tree.init = new JCLiteral(TypeTags.INT, 0) { };
+ else if (t.equals("long"))
+ tree.init = new JCLiteral(TypeTags.LONG, 0) { };
+ else if (t.equals("short"))
+ tree.init = new JCLiteral(TypeTags.SHORT, 0) { };
+ else
+ tree.init = new JCLiteral(TypeTags.BOT, null) { };
+ }
+ }
+ result = tree;
+ }
+ }
+
+ class ImportCleaner extends TreeScanner {
+ private Set names = new HashSet();
+ private TreeMaker m;
+
+ ImportCleaner(JavaFileManager fm) {
+ // ImportCleaner itself doesn't require a filemanager, but instantiating
+ // a TreeMaker does, indirectly (via ClassReader, sigh)
+ Context c = new Context();
+ c.put(JavaFileManager.class, fm);
+ m = TreeMaker.instance(c);
+ }
+
+ CompilationUnitTree removeRedundantImports(CompilationUnitTree t) {
+ JCCompilationUnit tree = (JCCompilationUnit) t;
+ tree.accept(this);
+ ListBuffer defs = new ListBuffer();
+ for (JCTree def: tree.defs) {
+ if (def.getTag() == JCTree.Tag.IMPORT) {
+ JCImport imp = (JCImport) def;
+ if (imp.qualid.getTag() == JCTree.Tag.SELECT) {
+ JCFieldAccess qualid = (JCFieldAccess) imp.qualid;
+ if (!qualid.name.toString().equals("*")
+ && !names.contains(qualid.name)) {
+ continue;
+ }
+ }
+ }
+ defs.add(def);
+ }
+ return m.TopLevel(tree.packageAnnotations, tree.pid, defs.toList());
+ }
+
+ @Override
+ public void visitImport(JCImport tree) { } // ignore names found in imports
+
+ @Override
+ public void visitIdent(JCIdent tree) {
+ names.add(tree.name);
+ }
+
+ @Override
+ public void visitSelect(JCFieldAccess tree) {
+ super.visitSelect(tree);
+ names.add(tree.name);
+ }
+ }
+}