Back to index...

	/*
	* 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
	* 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 sun.rmi.rmic.newrmic;

	import com.sun.javadoc.ClassDoc;
	import com.sun.javadoc.RootDoc;
	import java.io.File;
	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.io.PrintStream;
	import java.io.PrintWriter;
	import java.lang.reflect.Constructor;
	import java.lang.reflect.InvocationTargetException;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import sun.rmi.rmic.newrmic.jrmp.JrmpGenerator;
	import sun.tools.util.CommandLine;

	/**
	* The rmic front end. This class contains the "main" method for rmic
	* command line invocation.
	*
	* A Main instance contains the stream to output error messages and
	* other diagnostics to.
	*
	* An rmic compilation batch (for example, one rmic command line
	* invocation) is executed by invoking the "compile" method of a Main
	* instance.
	*
	* WARNING: The contents of this source file are not part of any
	* supported API. Code that depends on them does so at its own risk:
	* they are subject to change or removal without notice.
	*
	* NOTE: If and when there is a J2SE API for invoking SDK tools, this
	* class should be updated to support that API.
	*
	* NOTE: This class is the front end for a "new" rmic implementation,
	* which uses javadoc and the doclet API for reading class files and
	* javac for compiling generated source files. This implementation is
	* incomplete: it lacks any CORBA-based back end implementations, and
	* thus the command line options "-idl", "-iiop", and their related
	* options are not yet supported. The front end for the "old",
	* oldjavac-based rmic implementation is sun.rmi.rmic.Main.
	*
	* @author Peter Jones
	**/
	public class Main {

	/*
	* Implementation note:
	*
	* In order to use the doclet API to read class files, much of
	* this implementation of rmic executes as a doclet within an
	* invocation of javadoc. This class is used as the doclet class
	* for such javadoc invocations, via its static "start" and
	* "optionLength" methods. There is one javadoc invocation per
	* rmic compilation batch.
	*
	* The only guaranteed way to pass data to a doclet through a
	* javadoc invocation is through doclet-specific options on the
	* javadoc "command line". Rather than passing numerous pieces of
	* individual data in string form as javadoc options, we use a
	* single doclet-specific option ("-batchID") to pass a numeric
	* identifier that uniquely identifies the rmic compilation batch
	* that the javadoc invocation is for, and that identifier can
	* then be used as a key in a global table to retrieve an object
	* containing all of batch-specific data (rmic command line
	* arguments, etc.).
	*/

	/** guards "batchCount" */
	private static final Object batchCountLock = new Object();

	/** number of batches run; used to generated batch IDs */
	private static long batchCount = 0;

	/** maps batch ID to batch data */
	private static final Map<Long,Batch> batchTable =
	Collections.synchronizedMap(new HashMap<Long,Batch>());

	/** stream to output error messages and other diagnostics to */
	private final PrintStream out;

	/** name of this program, to use in error messages */
	private final String program;

	/**
	* Command line entry point.
	**/
	public static void main(String[] args) {
	Main rmic = new Main(System.err, "rmic");
	System.exit(rmic.compile(args) ? 0 : 1);
	}

	/**
	* Creates a Main instance that writes output to the specified
	* stream. The specified program name is used in error messages.
	**/
	public Main(OutputStream out, String program) {
	this.out = out instanceof PrintStream ?
	(PrintStream) out : new PrintStream(out);
	this.program = program;
	}

	/**
	* Compiles a batch of input classes, as given by the specified
	* command line arguments. Protocol-specific generators are
	* determined by the choice options on the command line. Returns
	* true if successful, or false if an error occurred.
	*
	* NOTE: This method is retained for transitional consistency with
	* previous implementations.
	**/
	public boolean compile(String[] args) {
	long startTime = System.currentTimeMillis();

	long batchID;
	synchronized (batchCountLock) {
	batchID = batchCount++; // assign batch ID
	}

	// process command line
	Batch batch = parseArgs(args);
	if (batch == null) {
	return false; // terminate if error occurred
	}

	/*
	* With the batch data retrievable in the global table, run
	* javadoc to continue the rest of the batch's compliation as
	* a doclet.
	*/
	boolean status;
	try {
	batchTable.put(batchID, batch);
	status = invokeJavadoc(batch, batchID);
	} finally {
	batchTable.remove(batchID);
	}

	if (batch.verbose) {
	long deltaTime = System.currentTimeMillis() - startTime;
	output(Resources.getText("rmic.done_in",
	Long.toString(deltaTime)));
	}

	return status;
	}

	/**
	* Prints the specified string to the output stream of this Main
	* instance.
	**/
	public void output(String msg) {
	out.println(msg);
	}

	/**
	* Prints an error message to the output stream of this Main
	* instance. The first argument is used as a key in rmic's
	* resource bundle, and the rest of the arguments are used as
	* arguments in the formatting of the resource string.
	**/
	public void error(String msg, String... args) {
	output(Resources.getText(msg, args));
	}

	/**
	* Prints rmic's usage message to the output stream of this Main
	* instance.
	*
	* This method is public so that it can be used by the "parseArgs"
	* methods of Generator implementations.
	**/
	public void usage() {
	error("rmic.usage", program);
	}

	/**
	* Processes rmic command line arguments. Returns a Batch object
	* representing the command line arguments if successful, or null
	* if an error occurred. Processed elements of the args array are
	* set to null.
	**/
	private Batch parseArgs(String[] args) {
	Batch batch = new Batch();

	/*
	* Pre-process command line for @file arguments.
	*/
	try {
	args = CommandLine.parse(args);
	} catch (FileNotFoundException e) {
	error("rmic.cant.read", e.getMessage());
	return null;
	} catch (IOException e) {
	e.printStackTrace(out);
	return null;
	}

	for (int i = 0; i < args.length; i++) {

	if (args[i] == null) {
	// already processed by a generator
	continue;

	} else if (args[i].equals("-Xnew")) {
	// we're already using the "new" implementation
	args[i] = null;

	} else if (args[i].equals("-show")) {
	// obselete: fail
	error("rmic.option.unsupported", args[i]);
	usage();
	return null;

	} else if (args[i].equals("-O")) {
	// obselete: warn but tolerate
	error("rmic.option.unsupported", args[i]);
	args[i] = null;

	} else if (args[i].equals("-debug")) {
	// obselete: warn but tolerate
	error("rmic.option.unsupported", args[i]);
	args[i] = null;

	} else if (args[i].equals("-depend")) {
	// obselete: warn but tolerate
	// REMIND: should this fail instead?
	error("rmic.option.unsupported", args[i]);
	args[i] = null;

	} else if (args[i].equals("-keep") \|\|
	args[i].equals("-keepgenerated"))
	{
	batch.keepGenerated = true;
	args[i] = null;

	} else if (args[i].equals("-g")) {
	batch.debug = true;
	args[i] = null;

	} else if (args[i].equals("-nowarn")) {
	batch.noWarn = true;
	args[i] = null;

	} else if (args[i].equals("-nowrite")) {
	batch.noWrite = true;
	args[i] = null;

	} else if (args[i].equals("-verbose")) {
	batch.verbose = true;
	args[i] = null;

	} else if (args[i].equals("-Xnocompile")) {
	batch.noCompile = true;
	batch.keepGenerated = true;
	args[i] = null;

	} else if (args[i].equals("-bootclasspath")) {
	if ((i + 1) >= args.length) {
	error("rmic.option.requires.argument", args[i]);
	usage();
	return null;
	}
	if (batch.bootClassPath != null) {
	error("rmic.option.already.seen", args[i]);
	usage();
	return null;
	}
	args[i] = null;
	batch.bootClassPath = args[++i];
	assert batch.bootClassPath != null;
	args[i] = null;

	} else if (args[i].equals("-extdirs")) {
	if ((i + 1) >= args.length) {
	error("rmic.option.requires.argument", args[i]);
	usage();
	return null;
	}
	if (batch.extDirs != null) {
	error("rmic.option.already.seen", args[i]);
	usage();
	return null;
	}
	args[i] = null;
	batch.extDirs = args[++i];
	assert batch.extDirs != null;
	args[i] = null;

	} else if (args[i].equals("-classpath")) {
	if ((i + 1) >= args.length) {
	error("rmic.option.requires.argument", args[i]);
	usage();
	return null;
	}
	if (batch.classPath != null) {
	error("rmic.option.already.seen", args[i]);
	usage();
	return null;
	}
	args[i] = null;
	batch.classPath = args[++i];
	assert batch.classPath != null;
	args[i] = null;

	} else if (args[i].equals("-d")) {
	if ((i + 1) >= args.length) {
	error("rmic.option.requires.argument", args[i]);
	usage();
	return null;
	}
	if (batch.destDir != null) {
	error("rmic.option.already.seen", args[i]);
	usage();
	return null;
	}
	args[i] = null;
	batch.destDir = new File(args[++i]);
	assert batch.destDir != null;
	args[i] = null;
	if (!batch.destDir.exists()) {
	error("rmic.no.such.directory", batch.destDir.getPath());
	usage();
	return null;
	}

	} else if (args[i].equals("-v1.1") \|\|
	args[i].equals("-vcompat") \|\|
	args[i].equals("-v1.2"))
	{
	Generator gen = new JrmpGenerator();
	batch.generators.add(gen);
	// JrmpGenerator only requires base BatchEnvironment class
	if (!gen.parseArgs(args, this)) {
	return null;
	}

	} else if (args[i].equalsIgnoreCase("-iiop")) {
	error("rmic.option.unimplemented", args[i]);
	return null;

	// Generator gen = new IiopGenerator();
	// batch.generators.add(gen);
	// if (!batch.envClass.isAssignableFrom(gen.envClass())) {
	// error("rmic.cannot.use.both",
	// batch.envClass.getName(), gen.envClass().getName());
	// return null;
	// }
	// batch.envClass = gen.envClass();
	// if (!gen.parseArgs(args, this)) {
	// return null;
	// }

	} else if (args[i].equalsIgnoreCase("-idl")) {
	error("rmic.option.unimplemented", args[i]);
	return null;

	// see implementation sketch above

	} else if (args[i].equalsIgnoreCase("-xprint")) {
	error("rmic.option.unimplemented", args[i]);
	return null;

	// see implementation sketch above
	}
	}

	/*
	* At this point, all that remains non-null in the args
	* array are input class names or illegal options.
	*/
	for (int i = 0; i < args.length; i++) {
	if (args[i] != null) {
	if (args[i].startsWith("-")) {
	error("rmic.no.such.option", args[i]);
	usage();
	return null;
	} else {
	batch.classes.add(args[i]);
	}
	}
	}
	if (batch.classes.isEmpty()) {
	usage();
	return null;
	}

	/*
	* If options did not specify at least one protocol-specific
	* generator, then JRMP is the default.
	*/
	if (batch.generators.isEmpty()) {
	batch.generators.add(new JrmpGenerator());
	}
	return batch;
	}

	/**
	* Doclet class entry point.
	**/
	public static boolean start(RootDoc rootDoc) {

	/*
	* Find batch ID among javadoc options, and retrieve
	* corresponding batch data from global table.
	*/
	long batchID = -1;
	for (String[] option : rootDoc.options()) {
	if (option[0].equals("-batchID")) {
	try {
	batchID = Long.parseLong(option[1]);
	} catch (NumberFormatException e) {
	throw new AssertionError(e);
	}
	}
	}
	Batch batch = batchTable.get(batchID);
	assert batch != null;

	/*
	* Construct batch environment using class agreed upon by
	* generator implementations.
	*/
	BatchEnvironment env;
	try {
	Constructor<? extends BatchEnvironment> cons =
	batch.envClass.getConstructor(new Class<?>[] { RootDoc.class });
	env = cons.newInstance(rootDoc);
	} catch (NoSuchMethodException e) {
	throw new AssertionError(e);
	} catch (IllegalAccessException e) {
	throw new AssertionError(e);
	} catch (InstantiationException e) {
	throw new AssertionError(e);
	} catch (InvocationTargetException e) {
	throw new AssertionError(e);
	}

	env.setVerbose(batch.verbose);

	/*
	* Determine the destination directory (the top of the package
	* hierarchy) for the output of this batch; if no destination
	* directory was specified on the command line, then the
	* default is the current working directory.
	*/
	File destDir = batch.destDir;
	if (destDir == null) {
	destDir = new File(System.getProperty("user.dir"));
	}

	/*
	* Run each input class through each generator.
	*/
	for (String inputClassName : batch.classes) {
	ClassDoc inputClass = rootDoc.classNamed(inputClassName);
	try {
	for (Generator gen : batch.generators) {
	gen.generate(env, inputClass, destDir);
	}
	} catch (NullPointerException e) {
	/*
	* We assume that this means that some class that was
	* needed (perhaps even a bootstrap class) was not
	* found, and that javadoc has already reported this
	* as an error. There is nothing for us to do here
	* but try to continue with the next input class.
	*
	* REMIND: More explicit error checking throughout
	* would be preferable, however.
	*/
	}
	}

	/*
	* Compile any generated source files, if configured to do so.
	*/
	boolean status = true;
	List<File> generatedFiles = env.generatedFiles();
	if (!batch.noCompile && !batch.noWrite && !generatedFiles.isEmpty()) {
	status = batch.enclosingMain().invokeJavac(batch, generatedFiles);
	}

	/*
	* Delete any generated source files, if configured to do so.
	*/
	if (!batch.keepGenerated) {
	for (File file : generatedFiles) {
	file.delete();
	}
	}

	return status;
	}

	/**
	* Doclet class method that indicates that this doclet class
	* recognizes (only) the "-batchID" option on the javadoc command
	* line, and that the "-batchID" option comprises two arguments on
	* the javadoc command line.
	**/
	public static int optionLength(String option) {
	if (option.equals("-batchID")) {
	return 2;
	} else {
	return 0;
	}
	}

	/**
	* Runs the javadoc tool to invoke this class as a doclet, passing
	* command line options derived from the specified batch data and
	* indicating the specified batch ID.
	*
	* NOTE: This method currently uses a J2SE-internal API to run
	* javadoc. If and when there is a J2SE API for invoking SDK
	* tools, this method should be updated to use that API instead.
	**/
	private boolean invokeJavadoc(Batch batch, long batchID) {
	List<String> javadocArgs = new ArrayList<String>();

	// include all types, regardless of language-level access
	javadocArgs.add("-private");

	// inputs are class names, not source files
	javadocArgs.add("-Xclasses");

	// reproduce relevant options from rmic invocation
	if (batch.verbose) {
	javadocArgs.add("-verbose");
	}
	if (batch.bootClassPath != null) {
	javadocArgs.add("-bootclasspath");
	javadocArgs.add(batch.bootClassPath);
	}
	if (batch.extDirs != null) {
	javadocArgs.add("-extdirs");
	javadocArgs.add(batch.extDirs);
	}
	if (batch.classPath != null) {
	javadocArgs.add("-classpath");
	javadocArgs.add(batch.classPath);
	}

	// specify batch ID
	javadocArgs.add("-batchID");
	javadocArgs.add(Long.toString(batchID));

	/*
	* Run javadoc on union of rmic input classes and all
	* generators' bootstrap classes, so that they will all be
	* available to the doclet code.
	*/
	Set<String> classNames = new HashSet<String>();
	for (Generator gen : batch.generators) {
	classNames.addAll(gen.bootstrapClassNames());
	}
	classNames.addAll(batch.classes);
	for (String s : classNames) {
	javadocArgs.add(s);
	}

	// run javadoc with our program name and output stream
	int status = com.sun.tools.javadoc.Main.execute(
	program,
	new PrintWriter(out, true),
	new PrintWriter(out, true),
	new PrintWriter(out, true),
	this.getClass().getName(), // doclet class is this class
	javadocArgs.toArray(new String[javadocArgs.size()]));
	return status == 0;
	}

	/**
	* Runs the javac tool to compile the specified source files,
	* passing command line options derived from the specified batch
	* data.
	*
	* NOTE: This method currently uses a J2SE-internal API to run
	* javac. If and when there is a J2SE API for invoking SDK tools,
	* this method should be updated to use that API instead.
	**/
	private boolean invokeJavac(Batch batch, List<File> files) {
	List<String> javacArgs = new ArrayList<String>();

	// rmic never wants to display javac warnings
	javacArgs.add("-nowarn");

	// reproduce relevant options from rmic invocation
	if (batch.debug) {
	javacArgs.add("-g");
	}
	if (batch.verbose) {
	javacArgs.add("-verbose");
	}
	if (batch.bootClassPath != null) {
	javacArgs.add("-bootclasspath");
	javacArgs.add(batch.bootClassPath);
	}
	if (batch.extDirs != null) {
	javacArgs.add("-extdirs");
	javacArgs.add(batch.extDirs);
	}
	if (batch.classPath != null) {
	javacArgs.add("-classpath");
	javacArgs.add(batch.classPath);
	}

	/*
	* For now, rmic still always produces class files that have a
	* class file format version compatible with JDK 1.1.
	*/
	javacArgs.add("-source");
	javacArgs.add("1.3");
	javacArgs.add("-target");
	javacArgs.add("1.1");

	// add source files to compile
	for (File file : files) {
	javacArgs.add(file.getPath());
	}

	// run javac with our output stream
	int status = com.sun.tools.javac.Main.compile(
	javacArgs.toArray(new String[javacArgs.size()]),
	new PrintWriter(out, true));
	return status == 0;
	}

	/**
	* The data for an rmic compliation batch: the processed command
	* line arguments.
	**/
	private class Batch {
	boolean keepGenerated = false; // -keep or -keepgenerated
	boolean debug = false; // -g
	boolean noWarn = false; // -nowarn
	boolean noWrite = false; // -nowrite
	boolean verbose = false; // -verbose
	boolean noCompile = false; // -Xnocompile
	String bootClassPath = null; // -bootclasspath
	String extDirs = null; // -extdirs
	String classPath = null; // -classpath
	File destDir = null; // -d
	List<Generator> generators = new ArrayList<Generator>();
	Class<? extends BatchEnvironment> envClass = BatchEnvironment.class;
	List<String> classes = new ArrayList<String>();

	Batch() { }

	/**
	* Returns the Main instance for this batch.
	**/
	Main enclosingMain() {
	return Main.this;
	}
	}
	}

Back to index...