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.util.Collections; 29 import java.util.Iterator; 30 import java.util.LinkedHashMap; 31 import java.util.LinkedHashSet; 32 import java.util.Map; 33 import java.util.Set; 34 35 import javax.tools.JavaFileManager; 36 import javax.tools.JavaFileObject; 37 38 import com.sun.tools.doclint.DocLint; 39 import com.sun.tools.javac.code.Lint.LintCategory; 40 import com.sun.tools.javac.code.Source; 41 import com.sun.tools.javac.file.JavacFileManager; 42 import com.sun.tools.javac.jvm.Profile; 43 import com.sun.tools.javac.jvm.Target; 44 import com.sun.tools.javac.main.OptionHelper.GrumpyHelper; 45 import com.sun.tools.javac.file.BaseFileManager; 46 import com.sun.tools.javac.util.Context; 47 import com.sun.tools.javac.util.List; 48 import com.sun.tools.javac.util.ListBuffer; 49 import com.sun.tools.javac.util.Log; 50 import com.sun.tools.javac.util.Log.PrefixKind; 51 import com.sun.tools.javac.util.Options; 52 import com.sun.tools.javac.util.PropagatedException; 53 54 /** 55 * Shared option and argument handling for command line and API usage of javac. 56 */ 57 public class Arguments { 58 59 /** 60 * The context key for the arguments. 61 */ 62 protected static final Context.Key<Arguments> argsKey = new Context.Key<>(); 63 64 private String ownName; 65 private Set<String> classNames; 66 private Set<File> files; 67 private Map<Option, String> deferredFileManagerOptions; 68 private Set<JavaFileObject> fileObjects; 69 private final Options options; 70 71 private JavaFileManager fileManager; 72 private final Log log; 73 private final Context context; 74 75 private enum ErrorMode { ILLEGAL_ARGUMENT, ILLEGAL_STATE, LOG }; 76 private ErrorMode errorMode; 77 private boolean errors; 78 79 /** 80 * Gets the Arguments instance for this context. 81 * 82 * @param context the content 83 * @return the Arguments instance for this context. 84 */ 85 public static Arguments instance(Context context) { 86 Arguments instance = context.get(argsKey); 87 if (instance == null) { 88 instance = new Arguments(context); 89 } 90 return instance; 91 } 92 93 protected Arguments(Context context) { 94 context.put(argsKey, this); 95 options = Options.instance(context); 96 log = Log.instance(context); 97 this.context = context; 98 99 // Ideally, we could init this here and update/configure it as 100 // needed, but right now, initializing a file manager triggers 101 // initialization of other items in the context, such as Lint 102 // and FSInfo, which should not be initialized until after 103 // processArgs 104 // fileManager = context.get(JavaFileManager.class); 105 } 106 107 private final OptionHelper cmdLineHelper = new OptionHelper() { 108 @Override 109 public String get(Option option) { 110 return options.get(option); 111 } 112 113 @Override 114 public void put(String name, String value) { 115 options.put(name, value); 116 } 117 118 @Override 119 public void remove(String name) { 120 options.remove(name); 121 } 122 123 @Override 124 public boolean handleFileManagerOption(Option option, String value) { 125 options.put(option.getText(), value); 126 deferredFileManagerOptions.put(option, value); 127 return true; 128 } 129 130 @Override 131 public Log getLog() { 132 return log; 133 } 134 135 @Override 136 public String getOwnName() { 137 return ownName; 138 } 139 140 @Override 141 public void error(String key, Object... args) { 142 Arguments.this.error(key, args); 143 } 144 145 @Override 146 public void addFile(File f) { 147 files.add(f); 148 } 149 150 @Override 151 public void addClassName(String s) { 152 classNames.add(s); 153 } 154 155 }; 156 157 /** 158 * Initializes this Args instance with a set of command line args. 159 * The args will be processed in conjunction with the full set of 160 * command line options, including -help, -version etc. 161 * The args may also contain class names and filenames. 162 * Any errors during this call, and later during validate, will be reported 163 * to the log. 164 * @param ownName the name of this tool; used to prefix messages 165 * @param args the args to be processed 166 */ 167 public void init(String ownName, String... args) { 168 this.ownName = ownName; 169 errorMode = ErrorMode.LOG; 170 files = new LinkedHashSet<>(); 171 deferredFileManagerOptions = new LinkedHashMap<>(); 172 fileObjects = null; 173 classNames = new LinkedHashSet<>(); 174 processArgs(List.from(args), Option.getJavaCompilerOptions(), cmdLineHelper, true, false); 175 } 176 177 private final OptionHelper apiHelper = new GrumpyHelper(null) { 178 @Override 179 public String get(Option option) { 180 return options.get(option.getText()); 181 } 182 183 @Override 184 public void put(String name, String value) { 185 options.put(name, value); 186 } 187 188 @Override 189 public void remove(String name) { 190 options.remove(name); 191 } 192 193 @Override 194 public void error(String key, Object... args) { 195 Arguments.this.error(key, args); 196 } 197 198 @Override 199 public Log getLog() { 200 return Arguments.this.log; 201 } 202 }; 203 204 /** 205 * Initializes this Args instance with the parameters for a JavacTask. 206 * The options will be processed in conjunction with the restricted set 207 * of tool options, which does not include -help, -version, etc, 208 * nor does it include classes and filenames, which should be specified 209 * separately. 210 * File manager options are handled directly by the file manager. 211 * Any errors found while processing individual args will be reported 212 * via IllegalArgumentException. 213 * Any subsequent errors during validate will be reported via IllegalStateException. 214 * @param ownName the name of this tool; used to prefix messages 215 * @param options the options to be processed 216 * @param classNames the classes to be subject to annotation processing 217 * @param files the files to be compiled 218 */ 219 public void init(String ownName, 220 Iterable<String> options, 221 Iterable<String> classNames, 222 Iterable<? extends JavaFileObject> files) { 223 this.ownName = ownName; 224 this.classNames = toSet(classNames); 225 this.fileObjects = toSet(files); 226 this.files = null; 227 errorMode = ErrorMode.ILLEGAL_ARGUMENT; 228 if (options != null) { 229 processArgs(toList(options), Option.getJavacToolOptions(), apiHelper, false, true); 230 } 231 errorMode = ErrorMode.ILLEGAL_STATE; 232 } 233 234 /** 235 * Gets the files to be compiled. 236 * @return the files to be compiled 237 */ 238 public Set<JavaFileObject> getFileObjects() { 239 if (fileObjects == null) { 240 if (files == null) { 241 fileObjects = Collections.emptySet(); 242 } else { 243 fileObjects = new LinkedHashSet<>(); 244 JavacFileManager jfm = (JavacFileManager) getFileManager(); 245 for (JavaFileObject fo: jfm.getJavaFileObjectsFromFiles(files)) 246 fileObjects.add(fo); 247 } 248 } 249 return fileObjects; 250 } 251 252 /** 253 * Gets the classes to be subject to annotation processing. 254 * @return the classes to be subject to annotation processing 255 */ 256 public Set<String> getClassNames() { 257 return classNames; 258 } 259 260 /** 261 * Processes strings containing options and operands. 262 * @param args the strings to be processed 263 * @param allowableOpts the set of option declarations that are applicable 264 * @param helper a help for use by Option.process 265 * @param allowOperands whether or not to check for files and classes 266 * @param checkFileManager whether or not to check if the file manager can handle 267 * options which are not recognized by any of allowableOpts 268 * @return true if all the strings were successfully processed; false otherwise 269 * @throws IllegalArgumentException if a problem occurs and errorMode is set to 270 * ILLEGAL_ARGUMENT 271 */ 272 private boolean processArgs(Iterable<String> args, 273 Set<Option> allowableOpts, OptionHelper helper, 274 boolean allowOperands, boolean checkFileManager) { 275 JavaFileManager fm = checkFileManager ? getFileManager() : null; 276 Iterator<String> argIter = args.iterator(); 277 while (argIter.hasNext()) { 278 String arg = argIter.next(); 279 if (arg.isEmpty()) { 280 error("err.invalid.flag", arg); 281 return false; 282 } 283 284 Option option = null; 285 if (arg.startsWith("-")) { 286 for (Option o : allowableOpts) { 287 if (o.matches(arg)) { 288 option = o; 289 break; 290 } 291 } 292 } else if (allowOperands && Option.SOURCEFILE.matches(arg)) { 293 option = Option.SOURCEFILE; 294 } 295 296 if (option == null) { 297 if (fm != null && fm.handleOption(arg, argIter)) { 298 continue; 299 } 300 error("err.invalid.flag", arg); 301 return false; 302 } 303 304 if (option.hasArg()) { 305 if (!argIter.hasNext()) { 306 error("err.req.arg", arg); 307 return false; 308 } 309 String operand = argIter.next(); 310 if (option.process(helper, arg, operand)) { 311 return false; 312 } 313 } else { 314 if (option.process(helper, arg)) { 315 return false; 316 } 317 } 318 319 } 320 321 options.notifyListeners(); 322 323 return true; 324 } 325 326 /** 327 * Validates the overall consistency of the options and operands 328 * processed by processOptions. 329 * @return true if all args are successfully validating; false otherwise. 330 * @throws IllegalStateException if a problem is found and errorMode is set to 331 * ILLEGAL_STATE 332 */ 333 public boolean validate() { 334 if (isEmpty()) { 335 // It is allowed to compile nothing if just asking for help or version info. 336 // But also note that none of these options are supported in API mode. 337 if (options.isSet(Option.HELP) 338 || options.isSet(Option.X) 339 || options.isSet(Option.VERSION) 340 || options.isSet(Option.FULLVERSION)) 341 return true; 342 343 if (JavaCompiler.explicitAnnotationProcessingRequested(options)) { 344 error("err.no.source.files.classes"); 345 } else { 346 error("err.no.source.files"); 347 } 348 return false; 349 } 350 351 if (!checkDirectory(Option.D)) { 352 return false; 353 } 354 if (!checkDirectory(Option.S)) { 355 return false; 356 } 357 358 String sourceString = options.get(Option.SOURCE); 359 Source source = (sourceString != null) 360 ? Source.lookup(sourceString) 361 : Source.DEFAULT; 362 String targetString = options.get(Option.TARGET); 363 Target target = (targetString != null) 364 ? Target.lookup(targetString) 365 : Target.DEFAULT; 366 367 // We don't check source/target consistency for CLDC, as J2ME 368 // profiles are not aligned with J2SE targets; moreover, a 369 // single CLDC target may have many profiles. In addition, 370 // this is needed for the continued functioning of the JSR14 371 // prototype. 372 if (Character.isDigit(target.name.charAt(0))) { 373 if (target.compareTo(source.requiredTarget()) < 0) { 374 if (targetString != null) { 375 if (sourceString == null) { 376 error("warn.target.default.source.conflict", 377 targetString, 378 source.requiredTarget().name); 379 } else { 380 error("warn.source.target.conflict", 381 sourceString, 382 source.requiredTarget().name); 383 } 384 return false; 385 } else { 386 target = source.requiredTarget(); 387 options.put("-target", target.name); 388 } 389 } 390 } 391 392 String profileString = options.get(Option.PROFILE); 393 if (profileString != null) { 394 Profile profile = Profile.lookup(profileString); 395 if (!profile.isValid(target)) { 396 error("warn.profile.target.conflict", profileString, target.name); 397 } 398 399 // This check is only effective in command line mode, 400 // where the file manager options are added to options 401 if (options.get(Option.BOOTCLASSPATH) != null) { 402 error("err.profile.bootclasspath.conflict"); 403 } 404 } 405 406 boolean lintOptions = options.isUnset(Option.XLINT_CUSTOM, "-" + LintCategory.OPTIONS.option); 407 408 if (lintOptions && source.compareTo(Source.DEFAULT) < 0) { 409 JavaFileManager fm = getFileManager(); 410 if (fm instanceof BaseFileManager) { 411 if (((BaseFileManager) fm).isDefaultBootClassPath()) 412 log.warning(LintCategory.OPTIONS, "source.no.bootclasspath", source.name); 413 } 414 } 415 416 boolean obsoleteOptionFound = false; 417 418 if (source.compareTo(Source.MIN) < 0) { 419 log.error("option.removed.source", source.name, Source.MIN.name); 420 } else if (source == Source.MIN && lintOptions) { 421 log.warning(LintCategory.OPTIONS, "option.obsolete.source", source.name); 422 obsoleteOptionFound = true; 423 } 424 425 if (target.compareTo(Target.MIN) < 0) { 426 log.error("option.removed.target", target.name, Target.MIN.name); 427 } else if (target == Target.MIN && lintOptions) { 428 log.warning(LintCategory.OPTIONS, "option.obsolete.target", target.name); 429 obsoleteOptionFound = true; 430 } 431 432 if (obsoleteOptionFound) 433 log.warning(LintCategory.OPTIONS, "option.obsolete.suppression"); 434 435 return !errors; 436 } 437 438 /** 439 * Returns true if there are no files or classes specified for use. 440 * @return true if there are no files or classes specified for use 441 */ 442 public boolean isEmpty() { 443 return ((files == null) || files.isEmpty()) 444 && ((fileObjects == null) || fileObjects.isEmpty()) 445 && classNames.isEmpty(); 446 } 447 448 /** 449 * Gets the file manager options which may have been deferred 450 * during processArgs. 451 * @return the deferred file manager options 452 */ 453 public Map<Option, String> getDeferredFileManagerOptions() { 454 return deferredFileManagerOptions; 455 } 456 457 /** 458 * Gets any options specifying plugins to be run. 459 * @return options for plugins 460 */ 461 public Set<List<String>> getPluginOpts() { 462 String plugins = options.get(Option.PLUGIN); 463 if (plugins == null) 464 return Collections.emptySet(); 465 466 Set<List<String>> pluginOpts = new LinkedHashSet<>(); 467 for (String plugin: plugins.split("\\x00")) { 468 pluginOpts.add(List.from(plugin.split("\\s+"))); 469 } 470 return Collections.unmodifiableSet(pluginOpts); 471 } 472 473 /** 474 * Gets any options specifying how doclint should be run. 475 * An empty list is returned if no doclint options are specified 476 * or if the only doclint option is -Xdoclint:none. 477 * @return options for doclint 478 */ 479 public List<String> getDocLintOpts() { 480 String xdoclint = options.get(Option.XDOCLINT); 481 String xdoclintCustom = options.get(Option.XDOCLINT_CUSTOM); 482 if (xdoclint == null && xdoclintCustom == null) 483 return List.nil(); 484 485 Set<String> doclintOpts = new LinkedHashSet<>(); 486 if (xdoclint != null) 487 doclintOpts.add(DocLint.XMSGS_OPTION); 488 if (xdoclintCustom != null) { 489 for (String s: xdoclintCustom.split("\\s+")) { 490 if (s.isEmpty()) 491 continue; 492 doclintOpts.add(s.replace(Option.XDOCLINT_CUSTOM.text, DocLint.XMSGS_CUSTOM_PREFIX)); 493 } 494 } 495 496 if (doclintOpts.equals(Collections.singleton(DocLint.XMSGS_CUSTOM_PREFIX + "none"))) 497 return List.nil(); 498 499 String checkPackages = options.get(Option.XDOCLINT_PACKAGE); 500 501 if (checkPackages != null) { 502 for (String s : checkPackages.split("\\s+")) { 503 doclintOpts.add(s.replace(Option.XDOCLINT_PACKAGE.text, DocLint.XCHECK_PACKAGE)); 504 } 505 } 506 507 // standard doclet normally generates H1, H2, 508 // so for now, allow user comments to assume that 509 doclintOpts.add(DocLint.XIMPLICIT_HEADERS + "2"); 510 511 return List.from(doclintOpts.toArray(new String[doclintOpts.size()])); 512 } 513 514 private boolean checkDirectory(Option option) { 515 String value = options.get(option); 516 if (value == null) { 517 return true; 518 } 519 File file = new File(value); 520 if (!file.exists()) { 521 error("err.dir.not.found", value); 522 return false; 523 } 524 if (!file.isDirectory()) { 525 error("err.file.not.directory", value); 526 return false; 527 } 528 return true; 529 } 530 531 void error(String key, Object... args) { 532 errors = true; 533 switch (errorMode) { 534 case ILLEGAL_ARGUMENT: { 535 String msg = log.localize(PrefixKind.JAVAC, key, args); 536 throw new PropagatedException(new IllegalArgumentException(msg)); 537 } 538 case ILLEGAL_STATE: { 539 String msg = log.localize(PrefixKind.JAVAC, key, args); 540 throw new PropagatedException(new IllegalStateException(msg)); 541 } 542 case LOG: 543 report(key, args); 544 log.printLines(PrefixKind.JAVAC, "msg.usage", ownName); 545 } 546 } 547 548 void warning(String key, Object... args) { 549 report(key, args); 550 } 551 552 private void report(String key, Object... args) { 553 log.printRawLines(ownName + ": " + log.localize(PrefixKind.JAVAC, key, args)); 554 } 555 556 private JavaFileManager getFileManager() { 557 if (fileManager == null) 558 fileManager = context.get(JavaFileManager.class); 559 return fileManager; 560 } 561 562 <T> ListBuffer<T> toList(Iterable<? extends T> items) { 563 ListBuffer<T> list = new ListBuffer<>(); 564 if (items != null) { 565 for (T item : items) { 566 list.add(item); 567 } 568 } 569 return list; 570 } 571 572 <T> Set<T> toSet(Iterable<? extends T> items) { 573 Set<T> set = new LinkedHashSet<>(); 574 if (items != null) { 575 for (T item : items) { 576 set.add(item); 577 } 578 } 579 return set; 580 } 581 }