jdk-sandbox: comparison langtools/src/jdk.javadoc/share/classes/jdk/javadoc/internal/tool/Start.java

equal deleted inserted replaced

-:a494e861787c
+:d213951c811b
 import jdk.javadoc.doclet.Doclet;
 import jdk.javadoc.doclet.Doclet.Option;
 import jdk.javadoc.doclet.DocletEnvironment;
 import static com.sun.tools.javac.main.Option.*;
 /**
 * Main program of Javadoc.
 * Previously named "Main".
 *
 *  <p><b>This is NOT part of any supported API.
 *
 * @author Robert Field
 * @author Neal Gafter (rewrite)
 */
 public class Start extends ToolOption.Helper {
+private static final Class<?> OldStdDoclet =
+com.sun.tools.doclets.standard.Standard.class;
+private static final Class<?> StdDoclet =
+jdk.javadoc.internal.doclets.standard.Standard.class;
 /** Context for this invocation. */
 private final Context context;
 private static final String ProgramName = "javadoc";
 .forEach(opt -> messager.printNotice(opt.toString()));
 }
 if (foot != null)
 messager.notice(foot);
-if (exit) exit();
+if (exit)
-}
+throw new Messager.ExitJavadoc();
+}
-/**
-* Exit
-*/
+/**
-private void exit() {
+* Main program - external wrapper. In order to maintain backward
-messager.exit();
+* CLI  compatibility, we dispatch to the old tool or the old doclet's
-}
+* Start mechanism, based on the options present on the command line
+* with the following precedence:
-/**
+*   1. presence of -Xold, dispatch to old tool
-* Main program - external wrapper
+*   2. doclet variant, if old, dispatch to old Start
+*   3. taglet variant, if old, dispatch to old Start
+*
+* Thus the presence of -Xold switches the tool, soon after command files
+* if any, are expanded, this is performed here, noting that the messager
+* is available at this point in time.
+* The doclet/taglet tests are performed in the begin method, further on,
+* this is to minimize argument processing and most importantly the impact
+* of class loader creation, needed to detect the doclet/taglet class variants.
 */
 int begin(String... argv) {
 // Preprocess @file arguments
 try {
 argv = CommandLine.parse(argv);
 } catch (FileNotFoundException e) {
 messager.error("main.cant.read", e.getMessage());
-exit();
+throw new Messager.ExitJavadoc();
 } catch (IOException e) {
 e.printStackTrace(System.err);
-exit();
+throw new Messager.ExitJavadoc();
 }
-List<String> argList = Arrays.asList(argv);
+if (argv.length > 0 && "-Xold".equals(argv[0])) {
-boolean ok = begin(argList, Collections.<JavaFileObject> emptySet());
+messager.warning("main.legacy_api");
+String[] nargv = Arrays.copyOfRange(argv, 1, argv.length);
+return com.sun.tools.javadoc.Main.execute(nargv);
+}
+boolean ok = begin(Arrays.asList(argv), Collections.<JavaFileObject> emptySet());
 return ok ? 0 : 1;
 }
 // Called by 199 API.
 public boolean begin(Class<?> docletClass,
 Iterable<? extends JavaFileObject> fileObjects) {
 this.docletClass = docletClass;
 List<String> opts = new ArrayList<>();
 for (String opt: options)
 opts.add(opt);
 return begin(opts, fileObjects);
 }
 private boolean begin(List<String> options, Iterable<? extends JavaFileObject> fileObjects) {
 fileManager = context.get(JavaFileManager.class);
 if (fileManager == null) {
 JavacFileManager.preRegister(context);
 fileManager = context.get(JavaFileManager.class);
 if (fileManager instanceof BaseFileManager) {
 ((BaseFileManager) fileManager).autoClose = true;
 }
 }
-// locale and doclet needs to be determined first
+// locale, doclet and maybe taglet, needs to be determined first
 docletClass = preProcess(fileManager, options);
 if (jdk.javadoc.doclet.Doclet.class.isAssignableFrom(docletClass)) {
 // no need to dispatch to old, safe to init now
 initMessager();
 messager.setLocale(locale);
 try {
 doclet = (Doclet) docletClass.newInstance();
 } catch (InstantiationException | IllegalAccessException exc) {
 exc.printStackTrace();
 if (!apiMode) {
 error("main.could_not_instantiate_class", docletClass);
-messager.exit();
+throw new Messager.ExitJavadoc();
 }
 throw new ClientCodeException(exc);
 }
 } else {
 if (this.apiMode) {
 com.sun.tools.javadoc.Start ostart
 = new com.sun.tools.javadoc.Start(context);
 return ostart.begin(docletClass, options, fileObjects);
 }
+warn("main.legacy_api");
 String[] array = options.toArray(new String[options.size()]);
 return com.sun.tools.javadoc.Main.execute(array) == 0;
 }
 boolean failed = false;
 private Class<?> preProcess(JavaFileManager jfm, List<String> argv) {
 // doclet specifying arguments
 String userDocletPath = null;
 String userDocletName = null;
+// taglet specifying arguments, since tagletpath is a doclet
+// functionality, assume they are repeated and inspect all.
+List<File> userTagletPath = new ArrayList<>();
+List<String> userTagletNames = new ArrayList<>();
 // Step 1: loop through the args, set locale early on, if found.
 for (int i = 0 ; i < argv.size() ; i++) {
 String arg = argv.get(i);
 if (arg.equals(ToolOption.LOCALE.opt)) {
 oneArg(argv, i++);
 locale = getLocale(lname);
 } else if (arg.equals(ToolOption.DOCLET.opt)) {
 oneArg(argv, i++);
 if (userDocletName != null) {
 usageError("main.more_than_one_doclet_specified_0_and_1",
 userDocletName, argv.get(i));
 }
 if (docletName != null) {
 usageError("main.more_than_one_doclet_specified_0_and_1",
 docletName, argv.get(i));
 }
 if (userDocletPath == null) {
 userDocletPath = argv.get(i);
 } else {
 userDocletPath += File.pathSeparator + argv.get(i);
 }
-}
+} else if ("-taglet".equals(arg)) {
-}
+userTagletNames.add(argv.get(i + 1));
-// Step 2: a doclet has already been provided,
+} else if ("-tagletpath".equals(arg)) {
-// nothing more to do.
+for (String pathname : argv.get(i + 1).split(File.pathSeparator)) {
+userTagletPath.add(new File(pathname));
+}
+}
+}
+// Step 2: a doclet is provided, nothing more to do.
 if (docletClass != null) {
 return docletClass;
 }
 // Step 3: doclet name specified ? if so find a ClassLoader,
 // and load it.
 if (userDocletName != null) {
 ClassLoader cl = classLoader;
 if (cl == null) {
 }
 }
 try {
 ((StandardJavaFileManager)fileManager).setLocation(DOCLET_PATH, paths);
 } catch (IOException ioe) {
-panic("main.doclet_no_classloader_found", ioe);
+error("main.doclet_could_not_set_location", paths);
-return null; // keep compiler happy
+throw new Messager.ExitJavadoc();
 }
 }
 cl = fileManager.getClassLoader(DOCLET_PATH);
 if (cl == null) {
 // despite doclet specified on cmdline no classloader found!
-panic("main.doclet_no_classloader_found", userDocletName);
+error("main.doclet_no_classloader_found", userDocletName);
-return null; // keep compiler happy
+throw new Messager.ExitJavadoc();
 }
-try {
+}
-Class<?> klass = cl.loadClass(userDocletName);
+try {
-ensureReadable(klass);
+Class<?> klass = cl.loadClass(userDocletName);
-return klass;
+ensureReadable(klass);
-} catch (ClassNotFoundException cnfe) {
+return klass;
-panic("main.doclet_class_not_found", userDocletName);
+} catch (ClassNotFoundException cnfe) {
-return null; // keep compiler happy
+error("main.doclet_class_not_found", userDocletName);
-}
+throw new Messager.ExitJavadoc();
 }
 }
-// Step 4: we have a doclet, try loading it, otherwise
-// return back the standard doclet
+// Step 4: we have a doclet, try loading it
 if (docletName != null) {
 try {
 return Class.forName(docletName, true, getClass().getClassLoader());
 } catch (ClassNotFoundException cnfe) {
-panic("main.doclet_class_not_found", userDocletName);
+error("main.doclet_class_not_found", userDocletName);
-return null; // happy compiler, should not happen
+throw new Messager.ExitJavadoc();
 }
-} else {
+}
-return jdk.javadoc.internal.doclets.standard.Standard.class;
-}
+// Step 5: we don't have a doclet specified, do we have taglets ?
+if (!userTagletNames.isEmpty() && hasOldTaglet(userTagletNames, userTagletPath)) {
+// found a bogey, return the old doclet
+return OldStdDoclet;
+}
+// finally
+return StdDoclet;
+}
+/*
+* This method returns true iff it finds a legacy taglet, but for
+* all other conditions including errors it returns false, allowing
+* nature to take its own course.
+*/
+private boolean hasOldTaglet(List<String> tagletNames, List<File> tagletPaths) {
+if (!fileManager.hasLocation(TAGLET_PATH)) {
+try {
+((StandardJavaFileManager) fileManager).setLocation(TAGLET_PATH, tagletPaths);
+} catch (IOException ioe) {
+error("main.doclet_could_not_set_location", tagletPaths);
+throw new Messager.ExitJavadoc();
+}
+}
+ClassLoader cl = fileManager.getClassLoader(TAGLET_PATH);
+if (cl == null) {
+// no classloader found!
+error("main.doclet_no_classloader_found", tagletNames.get(0));
+throw new Messager.ExitJavadoc();
+}
+for (String tagletName : tagletNames) {
+try {
+Class<?> klass = cl.loadClass(tagletName);
+ensureReadable(klass);
+if (com.sun.tools.doclets.Taglet.class.isAssignableFrom(klass)) {
+return true;
+}
+} catch (ClassNotFoundException cnfe) {
+error("main.doclet_class_not_found", tagletName);
+throw new Messager.ExitJavadoc();
+}
+}
+return false;
 }
 private void parseArgs(List<String> args, List<String> javaNames) {
 for (int i = 0 ; i < args.size() ; i++) {
 String arg = args.get(i);
 void usageError(String key, Object... args) {
 error(key, args);
 usage(true);
 }
-// a terminal call, will not return
-void panic(String key, Object... args) {
-error(key, args);
-messager.exit();
-}
 void error(String key, Object... args) {
 messager.error(key, args);
+}
+void warn(String key, Object... args)  {
+messager.warning(key, args);
 }
 /**
 * indicate an option with no arguments was given.
 */

changeset 37750	d213951c811b
parent 37393	a9ba8bd6697b
child 37757	f38cc75b6fa0