1 /*
   2  * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package com.sun.tools.javac.main;
  26 
  27 import java.io.File;
  28 import java.io.IOException;
  29 import java.nio.file.Path;
  30 import java.util.Collection;
  31 import java.util.Collections;
  32 import java.util.Iterator;
  33 import java.util.LinkedHashMap;
  34 import java.util.LinkedHashSet;
  35 import java.util.Map;
  36 import java.util.ServiceLoader;
  37 import java.util.Set;
  38 import java.util.stream.Stream;
  39 import java.util.stream.StreamSupport;
  40 
  41 import javax.tools.JavaFileManager;
  42 import javax.tools.JavaFileObject;
  43 import javax.tools.StandardJavaFileManager;
  44 import javax.tools.StandardLocation;
  45 
  46 import com.sun.tools.doclint.DocLint;
  47 import com.sun.tools.javac.code.Lint.LintCategory;
  48 import com.sun.tools.javac.code.Source;
  49 import com.sun.tools.javac.file.BaseFileManager;
  50 import com.sun.tools.javac.file.JavacFileManager;
  51 import com.sun.tools.javac.jvm.Profile;
  52 import com.sun.tools.javac.jvm.Target;
  53 import com.sun.tools.javac.main.OptionHelper.GrumpyHelper;
  54 import com.sun.tools.javac.platform.PlatformProvider;
  55 import com.sun.tools.javac.platform.PlatformProviderFactory;
  56 import com.sun.tools.javac.util.Context;
  57 import com.sun.tools.javac.util.List;
  58 import com.sun.tools.javac.util.ListBuffer;
  59 import com.sun.tools.javac.util.Log;
  60 import com.sun.tools.javac.util.Log.PrefixKind;
  61 import com.sun.tools.javac.util.Log.WriterKind;
  62 import com.sun.tools.javac.util.Options;
  63 import com.sun.tools.javac.util.PropagatedException;
  64 
  65 /**
  66  * Shared option and argument handling for command line and API usage of javac.
  67  */
  68 public class Arguments {
  69 
  70     /**
  71      * The context key for the arguments.
  72      */
  73     protected static final Context.Key<Arguments> argsKey = new Context.Key<>();
  74 
  75     private String ownName;
  76     private Set<String> classNames;
  77     private Set<File> files;
  78     private Map<Option, String> deferredFileManagerOptions;
  79     private Set<JavaFileObject> fileObjects;
  80     private final Options options;
  81 
  82     private JavaFileManager fileManager;
  83     private final Log log;
  84     private final Context context;
  85 
  86     private enum ErrorMode { ILLEGAL_ARGUMENT, ILLEGAL_STATE, LOG };
  87     private ErrorMode errorMode;
  88     private boolean errors;
  89 
  90     /**
  91      * Gets the Arguments instance for this context.
  92      *
  93      * @param context the content
  94      * @return the Arguments instance for this context.
  95      */
  96     public static Arguments instance(Context context) {
  97         Arguments instance = context.get(argsKey);
  98         if (instance == null) {
  99             instance = new Arguments(context);
 100         }
 101         return instance;
 102     }
 103 
 104     protected Arguments(Context context) {
 105         context.put(argsKey, this);
 106         options = Options.instance(context);
 107         log = Log.instance(context);
 108         this.context = context;
 109 
 110         // Ideally, we could init this here and update/configure it as
 111         // needed, but right now, initializing a file manager triggers
 112         // initialization of other items in the context, such as Lint
 113         // and FSInfo, which should not be initialized until after
 114         // processArgs
 115         //        fileManager = context.get(JavaFileManager.class);
 116     }
 117 
 118     private final OptionHelper cmdLineHelper = new OptionHelper() {
 119         @Override
 120         public String get(Option option) {
 121             return options.get(option);
 122         }
 123 
 124         @Override
 125         public void put(String name, String value) {
 126             options.put(name, value);
 127         }
 128 
 129         @Override
 130         public void remove(String name) {
 131             options.remove(name);
 132         }
 133 
 134         @Override
 135         public boolean handleFileManagerOption(Option option, String value) {
 136             options.put(option.getText(), value);
 137             deferredFileManagerOptions.put(option, value);
 138             return true;
 139         }
 140 
 141         @Override
 142         public Log getLog() {
 143             return log;
 144         }
 145 
 146         @Override
 147         public String getOwnName() {
 148             return ownName;
 149         }
 150 
 151         @Override
 152         public void error(String key, Object... args) {
 153             Arguments.this.error(key, args);
 154         }
 155 
 156         @Override
 157         public void addFile(File f) {
 158             files.add(f);
 159         }
 160 
 161         @Override
 162         public void addClassName(String s) {
 163             classNames.add(s);
 164         }
 165 
 166     };
 167 
 168     /**
 169      * Initializes this Args instance with a set of command line args.
 170      * The args will be processed in conjunction with the full set of
 171      * command line options, including -help, -version etc.
 172      * The args may also contain class names and filenames.
 173      * Any errors during this call, and later during validate, will be reported
 174      * to the log.
 175      * @param ownName the name of this tool; used to prefix messages
 176      * @param args the args to be processed
 177      */
 178     public void init(String ownName, String... args) {
 179         this.ownName = ownName;
 180         errorMode = ErrorMode.LOG;
 181         files = new LinkedHashSet<>();
 182         deferredFileManagerOptions = new LinkedHashMap<>();
 183         fileObjects = null;
 184         classNames = new LinkedHashSet<>();
 185         processArgs(List.from(args), Option.getJavaCompilerOptions(), cmdLineHelper, true, false);
 186     }
 187 
 188     private final OptionHelper apiHelper = new GrumpyHelper(null) {
 189         @Override
 190         public String get(Option option) {
 191             return options.get(option.getText());
 192         }
 193 
 194         @Override
 195         public void put(String name, String value) {
 196             options.put(name, value);
 197         }
 198 
 199         @Override
 200         public void remove(String name) {
 201             options.remove(name);
 202         }
 203 
 204         @Override
 205         public void error(String key, Object... args) {
 206             Arguments.this.error(key, args);
 207         }
 208 
 209         @Override
 210         public Log getLog() {
 211             return Arguments.this.log;
 212         }
 213     };
 214 
 215     /**
 216      * Initializes this Args instance with the parameters for a JavacTask.
 217      * The options will be processed in conjunction with the restricted set
 218      * of tool options, which does not include -help, -version, etc,
 219      * nor does it include classes and filenames, which should be specified
 220      * separately.
 221      * File manager options are handled directly by the file manager.
 222      * Any errors found while processing individual args will be reported
 223      * via IllegalArgumentException.
 224      * Any subsequent errors during validate will be reported via IllegalStateException.
 225      * @param ownName the name of this tool; used to prefix messages
 226      * @param options the options to be processed
 227      * @param classNames the classes to be subject to annotation processing
 228      * @param files the files to be compiled
 229      */
 230     public void init(String ownName,
 231             Iterable<String> options,
 232             Iterable<String> classNames,
 233             Iterable<? extends JavaFileObject> files) {
 234         this.ownName = ownName;
 235         this.classNames = toSet(classNames);
 236         this.fileObjects = toSet(files);
 237         this.files = null;
 238         errorMode = ErrorMode.ILLEGAL_ARGUMENT;
 239         if (options != null) {
 240             processArgs(toList(options), Option.getJavacToolOptions(), apiHelper, false, true);
 241         }
 242         errorMode = ErrorMode.ILLEGAL_STATE;
 243     }
 244 
 245     /**
 246      * Gets the files to be compiled.
 247      * @return the files to be compiled
 248      */
 249     public Set<JavaFileObject> getFileObjects() {
 250         if (fileObjects == null) {
 251             if (files == null) {
 252                 fileObjects = Collections.emptySet();
 253             } else {
 254                 fileObjects = new LinkedHashSet<>();
 255                 JavacFileManager jfm = (JavacFileManager) getFileManager();
 256                 for (JavaFileObject fo: jfm.getJavaFileObjectsFromFiles(files))
 257                     fileObjects.add(fo);
 258             }
 259         }
 260         return fileObjects;
 261     }
 262 
 263     /**
 264      * Gets the classes to be subject to annotation processing.
 265      * @return the classes to be subject to annotation processing
 266      */
 267     public Set<String> getClassNames() {
 268         return classNames;
 269     }
 270 
 271     /**
 272      * Processes strings containing options and operands.
 273      * @param args the strings to be processed
 274      * @param allowableOpts the set of option declarations that are applicable
 275      * @param helper a help for use by Option.process
 276      * @param allowOperands whether or not to check for files and classes
 277      * @param checkFileManager whether or not to check if the file manager can handle
 278      *      options which are not recognized by any of allowableOpts
 279      * @return true if all the strings were successfully processed; false otherwise
 280      * @throws IllegalArgumentException if a problem occurs and errorMode is set to
 281      *      ILLEGAL_ARGUMENT
 282      */
 283     private boolean processArgs(Iterable<String> args,
 284             Set<Option> allowableOpts, OptionHelper helper,
 285             boolean allowOperands, boolean checkFileManager) {
 286         if (!doProcessArgs(args, allowableOpts, helper, allowOperands, checkFileManager))
 287             return false;
 288 
 289         String platformString = options.get(Option.PLATFORM);
 290 
 291         checkOptionAllowed(platformString == null,
 292                 option -> error("err.platform.bootclasspath.conflict", option.getText()),
 293                 Option.BOOTCLASSPATH, Option.XBOOTCLASSPATH, Option.XBOOTCLASSPATH_APPEND,
 294                 Option.XBOOTCLASSPATH_PREPEND, Option.ENDORSEDDIRS, Option.EXTDIRS, Option.SOURCE,
 295                 Option.TARGET);
 296 
 297         if (platformString != null) {
 298             PlatformProvider platformProvider = lookupPlatformProvider(platformString);
 299 
 300             if (platformProvider == null) {
 301                 error("err.unsupported.platform.version", platformString);
 302                 return false;
 303             }
 304 
 305             options.put(Option.SOURCE, platformProvider.getSourceVersion());
 306             options.put(Option.TARGET, platformProvider.getTargetVersion());
 307 
 308             context.put(PlatformProvider.class, platformProvider);
 309 
 310             if (!doProcessArgs(platformProvider.getAdditionalOptions(), allowableOpts, helper, allowOperands, checkFileManager))
 311                 return false;
 312 
 313             Collection<Path> platformCP = platformProvider.getPlatformPath();
 314 
 315             if (platformCP != null) {
 316                 JavaFileManager fm = getFileManager();
 317 
 318                 if (!(fm instanceof StandardJavaFileManager)) {
 319                     error("err.platform.not.standard.file.manager");
 320                     return false;
 321                 }
 322 
 323                 try {
 324                     StandardJavaFileManager sfm = (StandardJavaFileManager) fm;
 325 
 326                     sfm.setLocationFromPaths(StandardLocation.PLATFORM_CLASS_PATH, platformCP);
 327                 } catch (IOException ex) {
 328                     log.printLines(PrefixKind.JAVAC, "msg.io");
 329                     ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
 330                     return false;
 331                 }
 332             }
 333         }
 334 
 335         options.notifyListeners();
 336 
 337         return true;
 338     }
 339 
 340     private boolean doProcessArgs(Iterable<String> args,
 341             Set<Option> allowableOpts, OptionHelper helper,
 342             boolean allowOperands, boolean checkFileManager) {
 343         JavaFileManager fm = checkFileManager ? getFileManager() : null;
 344         Iterator<String> argIter = args.iterator();
 345         while (argIter.hasNext()) {
 346             String arg = argIter.next();
 347             if (arg.isEmpty()) {
 348                 error("err.invalid.flag", arg);
 349                 return false;
 350             }
 351 
 352             Option option = null;
 353             if (arg.startsWith("-")) {
 354                 for (Option o : allowableOpts) {
 355                     if (o.matches(arg)) {
 356                         option = o;
 357                         break;
 358                     }
 359                 }
 360             } else if (allowOperands && Option.SOURCEFILE.matches(arg)) {
 361                 option = Option.SOURCEFILE;
 362             }
 363 
 364             if (option == null) {
 365                 if (fm != null && fm.handleOption(arg, argIter)) {
 366                     continue;
 367                 }
 368                 error("err.invalid.flag", arg);
 369                 return false;
 370             }
 371 
 372             if (option.hasArg()) {
 373                 if (!argIter.hasNext()) {
 374                     error("err.req.arg", arg);
 375                     return false;
 376                 }
 377                 String operand = argIter.next();
 378                 if (option.process(helper, arg, operand)) {
 379                     return false;
 380                 }
 381             } else {
 382                 if (option.process(helper, arg)) {
 383                     return false;
 384                 }
 385             }
 386         }
 387 
 388         return true;
 389     }
 390 
 391     /**
 392      * Validates the overall consistency of the options and operands
 393      * processed by processOptions.
 394      * @return true if all args are successfully validating; false otherwise.
 395      * @throws IllegalStateException if a problem is found and errorMode is set to
 396      *      ILLEGAL_STATE
 397      */
 398     public boolean validate() {
 399         if (isEmpty()) {
 400             // It is allowed to compile nothing if just asking for help or version info.
 401             // But also note that none of these options are supported in API mode.
 402             if (options.isSet(Option.HELP)
 403                 || options.isSet(Option.X)
 404                 || options.isSet(Option.VERSION)
 405                 || options.isSet(Option.FULLVERSION))
 406                 return true;
 407 
 408             if (JavaCompiler.explicitAnnotationProcessingRequested(options)) {
 409                 error("err.no.source.files.classes");
 410             } else {
 411                 error("err.no.source.files");
 412             }
 413             return false;
 414         }
 415 
 416         if (!checkDirectory(Option.D)) {
 417             return false;
 418         }
 419         if (!checkDirectory(Option.S)) {
 420             return false;
 421         }
 422 
 423         String sourceString = options.get(Option.SOURCE);
 424         Source source = (sourceString != null)
 425                 ? Source.lookup(sourceString)
 426                 : Source.DEFAULT;
 427         String targetString = options.get(Option.TARGET);
 428         Target target = (targetString != null)
 429                 ? Target.lookup(targetString)
 430                 : Target.DEFAULT;
 431 
 432         // We don't check source/target consistency for CLDC, as J2ME
 433         // profiles are not aligned with J2SE targets; moreover, a
 434         // single CLDC target may have many profiles.  In addition,
 435         // this is needed for the continued functioning of the JSR14
 436         // prototype.
 437         if (Character.isDigit(target.name.charAt(0))) {
 438             if (target.compareTo(source.requiredTarget()) < 0) {
 439                 if (targetString != null) {
 440                     if (sourceString == null) {
 441                         error("warn.target.default.source.conflict",
 442                                 targetString,
 443                                 source.requiredTarget().name);
 444                     } else {
 445                         error("warn.source.target.conflict",
 446                                 sourceString,
 447                                 source.requiredTarget().name);
 448                     }
 449                     return false;
 450                 } else {
 451                     target = source.requiredTarget();
 452                     options.put("-target", target.name);
 453                 }
 454             }
 455         }
 456 
 457         String profileString = options.get(Option.PROFILE);
 458         if (profileString != null) {
 459             Profile profile = Profile.lookup(profileString);
 460             if (!profile.isValid(target)) {
 461                 error("warn.profile.target.conflict", profileString, target.name);
 462             }
 463 
 464             // This check is only effective in command line mode,
 465             // where the file manager options are added to options
 466             if (options.get(Option.BOOTCLASSPATH) != null) {
 467                 error("err.profile.bootclasspath.conflict");
 468             }
 469         }
 470 
 471         boolean lintOptions = options.isUnset(Option.XLINT_CUSTOM, "-" + LintCategory.OPTIONS.option);
 472 
 473         if (lintOptions && source.compareTo(Source.DEFAULT) < 0 && !options.isSet(Option.PLATFORM)) {
 474             JavaFileManager fm = getFileManager();
 475             if (fm instanceof BaseFileManager) {
 476                 if (((BaseFileManager) fm).isDefaultBootClassPath())
 477                     log.warning(LintCategory.OPTIONS, "source.no.bootclasspath", source.name);
 478             }
 479         }
 480         
 481         boolean obsoleteOptionFound = false;
 482 
 483         if (source.compareTo(Source.MIN) < 0) {
 484             log.error("option.removed.source", source.name, Source.MIN.name);
 485         } else if (source == Source.MIN && lintOptions) {
 486             log.warning(LintCategory.OPTIONS, "option.obsolete.source", source.name);
 487             obsoleteOptionFound = true;
 488         }
 489 
 490         if (target.compareTo(Target.MIN) < 0) {
 491             log.error("option.removed.target", target.name, Target.MIN.name);
 492         } else if (target == Target.MIN && lintOptions) {
 493             log.warning(LintCategory.OPTIONS, "option.obsolete.target", target.name);
 494             obsoleteOptionFound = true;
 495         }
 496 
 497         if (obsoleteOptionFound)
 498             log.warning(LintCategory.OPTIONS, "option.obsolete.suppression");
 499 
 500         return !errors;
 501     }
 502 
 503     private PlatformProvider lookupPlatformProvider(String platform) {
 504         Iterable<PlatformProviderFactory> factories =
 505                 ServiceLoader.load(PlatformProviderFactory.class, Arguments.class.getClassLoader());
 506         return StreamSupport.stream(factories.spliterator(), false)
 507                             .flatMap(factory -> StreamSupport.stream(factory.createPlatformProviders()
 508                                                                             .spliterator(),
 509                                                                      false))
 510                             .filter(provider -> platform.equals(provider.getName()))
 511                             .findFirst()
 512                             .orElse(null);
 513     }
 514 
 515     /**
 516      * Returns true if there are no files or classes specified for use.
 517      * @return true if there are no files or classes specified for use
 518      */
 519     public boolean isEmpty() {
 520         return ((files == null) || files.isEmpty())
 521                 && ((fileObjects == null) || fileObjects.isEmpty())
 522                 && classNames.isEmpty();
 523     }
 524 
 525     /**
 526      * Gets the file manager options which may have been deferred
 527      * during processArgs.
 528      * @return the deferred file manager options
 529      */
 530     public Map<Option, String> getDeferredFileManagerOptions() {
 531         return deferredFileManagerOptions;
 532     }
 533 
 534     /**
 535      * Gets any options specifying plugins to be run.
 536      * @return options for plugins
 537      */
 538     public Set<List<String>> getPluginOpts() {
 539         String plugins = options.get(Option.PLUGIN);
 540         if (plugins == null)
 541             return Collections.emptySet();
 542 
 543         Set<List<String>> pluginOpts = new LinkedHashSet<>();
 544         for (String plugin: plugins.split("\\x00")) {
 545             pluginOpts.add(List.from(plugin.split("\\s+")));
 546         }
 547         return Collections.unmodifiableSet(pluginOpts);
 548     }
 549 
 550     /**
 551      * Gets any options specifying how doclint should be run.
 552      * An empty list is returned if no doclint options are specified
 553      * or if the only doclint option is -Xdoclint:none.
 554      * @return options for doclint
 555      */
 556     public List<String> getDocLintOpts() {
 557         String xdoclint = options.get(Option.XDOCLINT);
 558         String xdoclintCustom = options.get(Option.XDOCLINT_CUSTOM);
 559         if (xdoclint == null && xdoclintCustom == null)
 560             return List.nil();
 561 
 562         Set<String> doclintOpts = new LinkedHashSet<>();
 563         if (xdoclint != null)
 564             doclintOpts.add(DocLint.XMSGS_OPTION);
 565         if (xdoclintCustom != null) {
 566             for (String s: xdoclintCustom.split("\\s+")) {
 567                 if (s.isEmpty())
 568                     continue;
 569                 doclintOpts.add(s.replace(Option.XDOCLINT_CUSTOM.text, DocLint.XMSGS_CUSTOM_PREFIX));
 570             }
 571         }
 572 
 573         if (doclintOpts.equals(Collections.singleton(DocLint.XMSGS_CUSTOM_PREFIX + "none")))
 574             return List.nil();
 575 
 576         String checkPackages = options.get(Option.XDOCLINT_PACKAGE);
 577 
 578         if (checkPackages != null) {
 579             for (String s : checkPackages.split("\\s+")) {
 580                 doclintOpts.add(s.replace(Option.XDOCLINT_PACKAGE.text, DocLint.XCHECK_PACKAGE));
 581             }
 582         }
 583 
 584         // standard doclet normally generates H1, H2,
 585         // so for now, allow user comments to assume that
 586         doclintOpts.add(DocLint.XIMPLICIT_HEADERS + "2");
 587 
 588         return List.from(doclintOpts.toArray(new String[doclintOpts.size()]));
 589     }
 590 
 591     private boolean checkDirectory(Option option) {
 592         String value = options.get(option);
 593         if (value == null) {
 594             return true;
 595         }
 596         File file = new File(value);
 597         if (!file.exists()) {
 598             error("err.dir.not.found", value);
 599             return false;
 600         }
 601         if (!file.isDirectory()) {
 602             error("err.file.not.directory", value);
 603             return false;
 604         }
 605         return true;
 606     }
 607 
 608     private interface ErrorReporter {
 609         void report(Option o);
 610     }
 611 
 612     void checkOptionAllowed(boolean allowed, ErrorReporter r, Option... opts) {
 613         if (!allowed) {
 614             Stream.of(opts)
 615                   .filter(options :: isSet)
 616                   .forEach(r :: report);
 617         }
 618     }
 619 
 620     void error(String key, Object... args) {
 621         errors = true;
 622         switch (errorMode) {
 623             case ILLEGAL_ARGUMENT: {
 624                 String msg = log.localize(PrefixKind.JAVAC, key, args);
 625                 throw new PropagatedException(new IllegalArgumentException(msg));
 626             }
 627             case ILLEGAL_STATE: {
 628                 String msg = log.localize(PrefixKind.JAVAC, key, args);
 629                 throw new PropagatedException(new IllegalStateException(msg));
 630             }
 631             case LOG:
 632                 report(key, args);
 633                 log.printLines(PrefixKind.JAVAC, "msg.usage", ownName);
 634         }
 635     }
 636 
 637     void warning(String key, Object... args) {
 638         report(key, args);
 639     }
 640 
 641     private void report(String key, Object... args) {
 642         log.printRawLines(ownName + ": " + log.localize(PrefixKind.JAVAC, key, args));
 643     }
 644 
 645     private JavaFileManager getFileManager() {
 646         if (fileManager == null)
 647             fileManager = context.get(JavaFileManager.class);
 648         return fileManager;
 649     }
 650 
 651     <T> ListBuffer<T> toList(Iterable<? extends T> items) {
 652         ListBuffer<T> list = new ListBuffer<>();
 653         if (items != null) {
 654             for (T item : items) {
 655                 list.add(item);
 656             }
 657         }
 658         return list;
 659     }
 660 
 661     <T> Set<T> toSet(Iterable<? extends T> items) {
 662         Set<T> set = new LinkedHashSet<>();
 663         if (items != null) {
 664             for (T item : items) {
 665                 set.add(item);
 666             }
 667         }
 668         return set;
 669     }
 670 }