xref: /openjdk10/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Arguments.java

/*
 * Copyright (c) 1999, 2017, 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 com.sun.tools.javac.main;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;

import javax.lang.model.SourceVersion;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileManager.Location;
import javax.tools.JavaFileObject;
import javax.tools.JavaFileObject.Kind;
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;

import com.sun.tools.doclint.DocLint;
import com.sun.tools.javac.code.Lint.LintCategory;
import com.sun.tools.javac.code.Source;
import com.sun.tools.javac.file.BaseFileManager;
import com.sun.tools.javac.file.JavacFileManager;
import com.sun.tools.javac.jvm.Profile;
import com.sun.tools.javac.jvm.Target;
import com.sun.tools.javac.main.OptionHelper.GrumpyHelper;
import com.sun.tools.javac.platform.PlatformDescription;
import com.sun.tools.javac.platform.PlatformUtils;
import com.sun.tools.javac.resources.CompilerProperties.Errors;
import com.sun.tools.javac.resources.CompilerProperties.Warnings;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.JCDiagnostic;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.ListBuffer;
import com.sun.tools.javac.util.Log;
import com.sun.tools.javac.util.Log.PrefixKind;
import com.sun.tools.javac.util.Log.WriterKind;
import com.sun.tools.javac.util.Options;
import com.sun.tools.javac.util.PropagatedException;

/**
 * Shared option and argument handling for command line and API usage of javac.
 */
public class Arguments {

    /**
     * The context key for the arguments.
     */
    public static final Context.Key<Arguments> argsKey = new Context.Key<>();

    private String ownName;
    private Set<String> classNames;
    private Set<Path> files;
    private Map<Option, String> deferredFileManagerOptions;
    private Set<JavaFileObject> fileObjects;
    private boolean emptyAllowed;
    private final Options options;

    private JavaFileManager fileManager;
    private final Log log;
    private final Context context;

    private enum ErrorMode { ILLEGAL_ARGUMENT, ILLEGAL_STATE, LOG };
    private ErrorMode errorMode;
    private boolean errors;

    /**
     * Gets the Arguments instance for this context.
     *
     * @param context the content
     * @return the Arguments instance for this context.
     */
    public static Arguments instance(Context context) {
        Arguments instance = context.get(argsKey);
        if (instance == null) {
            instance = new Arguments(context);
        }
        return instance;
    }

    protected Arguments(Context context) {
        context.put(argsKey, this);
        options = Options.instance(context);
        log = Log.instance(context);
        this.context = context;

        // Ideally, we could init this here and update/configure it as
        // needed, but right now, initializing a file manager triggers
        // initialization of other items in the context, such as Lint
        // and FSInfo, which should not be initialized until after
        // processArgs
        //        fileManager = context.get(JavaFileManager.class);
    }

    private final OptionHelper cmdLineHelper = new OptionHelper() {
        @Override
        public String get(Option option) {
            return options.get(option);
        }

        @Override
        public void put(String name, String value) {
            options.put(name, value);
        }

        @Override
        public void remove(String name) {
            options.remove(name);
        }

        @Override
        public boolean handleFileManagerOption(Option option, String value) {
            options.put(option, value);
            deferredFileManagerOptions.put(option, value);
            return true;
        }

        @Override
        public Log getLog() {
            return log;
        }

        @Override
        public String getOwnName() {
            return ownName;
        }

        @Override
        public void addFile(Path p) {
            files.add(p);
        }

        @Override
        public void addClassName(String s) {
            classNames.add(s);
        }

    };

    /**
     * Initializes this Args instance with a set of command line args.
     * The args will be processed in conjunction with the full set of
     * command line options, including -help, -version etc.
     * The args may also contain class names and filenames.
     * Any errors during this call, and later during validate, will be reported
     * to the log.
     * @param ownName the name of this tool; used to prefix messages
     * @param args the args to be processed
     */
    public void init(String ownName, String... args) {
        this.ownName = ownName;
        errorMode = ErrorMode.LOG;
        files = new LinkedHashSet<>();
        deferredFileManagerOptions = new LinkedHashMap<>();
        fileObjects = null;
        classNames = new LinkedHashSet<>();
        processArgs(List.from(args), Option.getJavaCompilerOptions(), cmdLineHelper, true, false);
        if (errors) {
            log.printLines(PrefixKind.JAVAC, "msg.usage", ownName);
        }
    }

    private final OptionHelper apiHelper = new GrumpyHelper(null) {
        @Override
        public String get(Option option) {
            return options.get(option);
        }

        @Override
        public void put(String name, String value) {
            options.put(name, value);
        }

        @Override
        public void remove(String name) {
            options.remove(name);
        }

        @Override
        public Log getLog() {
            return Arguments.this.log;
        }
    };

    /**
     * Initializes this Args instance with the parameters for a JavacTask.
     * The options will be processed in conjunction with the restricted set
     * of tool options, which does not include -help, -version, etc,
     * nor does it include classes and filenames, which should be specified
     * separately.
     * File manager options are handled directly by the file manager.
     * Any errors found while processing individual args will be reported
     * via IllegalArgumentException.
     * Any subsequent errors during validate will be reported via IllegalStateException.
     * @param ownName the name of this tool; used to prefix messages
     * @param options the options to be processed
     * @param classNames the classes to be subject to annotation processing
     * @param files the files to be compiled
     */
    public void init(String ownName,
            Iterable<String> options,
            Iterable<String> classNames,
            Iterable<? extends JavaFileObject> files) {
        this.ownName = ownName;
        this.classNames = toSet(classNames);
        this.fileObjects = toSet(files);
        this.files = null;
        errorMode = ErrorMode.ILLEGAL_ARGUMENT;
        if (options != null) {
            processArgs(toList(options), Option.getJavacToolOptions(), apiHelper, false, true);
        }
        errorMode = ErrorMode.ILLEGAL_STATE;
    }

    /**
     * Minimal initialization for tools, like javadoc,
     * to be able to process javac options for themselves,
     * and then call validate.
     * @param ownName  the name of this tool; used to prefix messages
     */
    public void init(String ownName) {
        this.ownName = ownName;
        errorMode = ErrorMode.LOG;
    }

    /**
     * Gets the files to be compiled.
     * @return the files to be compiled
     */
    public Set<JavaFileObject> getFileObjects() {
        if (fileObjects == null) {
            fileObjects = new LinkedHashSet<>();
        }
        if (files != null) {
            JavacFileManager jfm = (JavacFileManager) getFileManager();
            for (JavaFileObject fo: jfm.getJavaFileObjectsFromPaths(files))
                fileObjects.add(fo);
        }
        return fileObjects;
    }

    /**
     * Gets the classes to be subject to annotation processing.
     * @return the classes to be subject to annotation processing
     */
    public Set<String> getClassNames() {
        return classNames;
    }

    /**
     * Handles the {@code --release} option.
     *
     * @param additionalOptions a predicate to handle additional options implied by the
     * {@code --release} option. The predicate should return true if all the additional
     * options were processed successfully.
     * @return true if successful, false otherwise
     */
    public boolean handleReleaseOptions(Predicate<Iterable<String>> additionalOptions) {
        String platformString = options.get(Option.RELEASE);

        checkOptionAllowed(platformString == null,
                option -> error("err.release.bootclasspath.conflict", option.getPrimaryName()),
                Option.BOOT_CLASS_PATH, Option.XBOOTCLASSPATH, Option.XBOOTCLASSPATH_APPEND,
                Option.XBOOTCLASSPATH_PREPEND,
                Option.ENDORSEDDIRS, Option.DJAVA_ENDORSED_DIRS,
                Option.EXTDIRS, Option.DJAVA_EXT_DIRS,
                Option.SOURCE, Option.TARGET,
                Option.SYSTEM, Option.UPGRADE_MODULE_PATH);

        if (platformString != null) {
            PlatformDescription platformDescription = PlatformUtils.lookupPlatformDescription(platformString);

            if (platformDescription == null) {
                error("err.unsupported.release.version", platformString);
                return false;
            }

            options.put(Option.SOURCE, platformDescription.getSourceVersion());
            options.put(Option.TARGET, platformDescription.getTargetVersion());

            context.put(PlatformDescription.class, platformDescription);

            if (!additionalOptions.test(platformDescription.getAdditionalOptions()))
                return false;

            Collection<Path> platformCP = platformDescription.getPlatformPath();

            if (platformCP != null) {
                JavaFileManager fm = getFileManager();

                if (!(fm instanceof StandardJavaFileManager)) {
                    error("err.release.not.standard.file.manager");
                    return false;
                }

                try {
                    StandardJavaFileManager sfm = (StandardJavaFileManager) fm;

                    if (Source.instance(context).allowModules()) {
                        sfm.handleOption("--system", Arrays.asList("none").iterator());
                        sfm.setLocationFromPaths(StandardLocation.UPGRADE_MODULE_PATH, platformCP);
                    } else {
                        sfm.setLocationFromPaths(StandardLocation.PLATFORM_CLASS_PATH, platformCP);
                    }
                } catch (IOException ex) {
                    log.printLines(PrefixKind.JAVAC, "msg.io");
                    ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
                    return false;
                }
            }
        }

        return true;
    }

    /**
     * Processes strings containing options and operands.
     * @param args the strings to be processed
     * @param allowableOpts the set of option declarations that are applicable
     * @param helper a help for use by Option.process
     * @param allowOperands whether or not to check for files and classes
     * @param checkFileManager whether or not to check if the file manager can handle
     *      options which are not recognized by any of allowableOpts
     * @return true if all the strings were successfully processed; false otherwise
     * @throws IllegalArgumentException if a problem occurs and errorMode is set to
     *      ILLEGAL_ARGUMENT
     */
    private boolean processArgs(Iterable<String> args,
            Set<Option> allowableOpts, OptionHelper helper,
            boolean allowOperands, boolean checkFileManager) {
        if (!doProcessArgs(args, allowableOpts, helper, allowOperands, checkFileManager))
            return false;

        if (!handleReleaseOptions(extra -> doProcessArgs(extra, allowableOpts, helper, allowOperands, checkFileManager)))
            return false;

        options.notifyListeners();

        return true;
    }

    private boolean doProcessArgs(Iterable<String> args,
            Set<Option> allowableOpts, OptionHelper helper,
            boolean allowOperands, boolean checkFileManager) {
        JavaFileManager fm = checkFileManager ? getFileManager() : null;
        Iterator<String> argIter = args.iterator();
        while (argIter.hasNext()) {
            String arg = argIter.next();
            if (arg.isEmpty()) {
                error("err.invalid.flag", arg);
                return false;
            }

            Option option = null;

            // first, check the provided set of javac options
            if (arg.startsWith("-")) {
                option = Option.lookup(arg, allowableOpts);
            } else if (allowOperands && Option.SOURCEFILE.matches(arg)) {
                option = Option.SOURCEFILE;
            }

            if (option != null) {
                try {
                    option.handleOption(helper, arg, argIter);
                } catch (Option.InvalidValueException e) {
                    error(e);
                    return false;
                }
                continue;
            }

            // check file manager option
            if (fm != null && fm.handleOption(arg, argIter)) {
                continue;
            }

            // none of the above
            error("err.invalid.flag", arg);
            return false;
        }

        return true;
    }

    /**
     * Validates the overall consistency of the options and operands
     * processed by processOptions.
     * @return true if all args are successfully validated; false otherwise.
     * @throws IllegalStateException if a problem is found and errorMode is set to
     *      ILLEGAL_STATE
     */
    public boolean validate() {
        JavaFileManager fm = getFileManager();
        if (options.isSet(Option.MODULE)) {
            if (!fm.hasLocation(StandardLocation.CLASS_OUTPUT)) {
                log.error(Errors.OutputDirMustBeSpecifiedWithDashMOption);
            } else if (!fm.hasLocation(StandardLocation.MODULE_SOURCE_PATH)) {
                log.error(Errors.ModulesourcepathMustBeSpecifiedWithDashMOption);
            } else {
                java.util.List<String> modules = Arrays.asList(options.get(Option.MODULE).split(","));
                try {
                    for (String module : modules) {
                        Location sourceLoc = fm.getLocationForModule(StandardLocation.MODULE_SOURCE_PATH, module);
                        if (sourceLoc == null) {
                            log.error(Errors.ModuleNotFoundInModuleSourcePath(module));
                        } else {
                            Location classLoc = fm.getLocationForModule(StandardLocation.CLASS_OUTPUT, module);

                            for (JavaFileObject file : fm.list(sourceLoc, "", EnumSet.of(JavaFileObject.Kind.SOURCE), true)) {
                                String className = fm.inferBinaryName(sourceLoc, file);
                                JavaFileObject classFile = fm.getJavaFileForInput(classLoc, className, Kind.CLASS);

                                if (classFile == null || classFile.getLastModified() < file.getLastModified()) {
                                    if (fileObjects == null)
                                        fileObjects = new HashSet<>();
                                    fileObjects.add(file);
                                }
                            }
                        }
                    }
                } catch (IOException ex) {
                    log.printLines(PrefixKind.JAVAC, "msg.io");
                    ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
                    return false;
                }
            }
        }

        if (isEmpty()) {
            // It is allowed to compile nothing if just asking for help or version info.
            // But also note that none of these options are supported in API mode.
            if (options.isSet(Option.HELP)
                    || options.isSet(Option.X)
                    || options.isSet(Option.VERSION)
                    || options.isSet(Option.FULLVERSION)
                    || options.isSet(Option.MODULE)) {
                return true;
            }

            if (!emptyAllowed) {
                if (!errors) {
                    if (JavaCompiler.explicitAnnotationProcessingRequested(options)) {
                        error("err.no.source.files.classes");
                    } else {
                        error("err.no.source.files");
                    }
                }
                return false;
            }
        }

        if (!checkDirectory(Option.D)) {
            return false;
        }
        if (!checkDirectory(Option.S)) {
            return false;
        }
        if (!checkDirectory(Option.H)) {
            return false;
        }

        // The following checks are to help avoid accidental confusion between
        // directories of modules and exploded module directories.
        if (fm instanceof StandardJavaFileManager) {
            StandardJavaFileManager sfm = (StandardJavaFileManager) fileManager;
            if (sfm.hasLocation(StandardLocation.CLASS_OUTPUT)) {
                Path outDir = sfm.getLocationAsPaths(StandardLocation.CLASS_OUTPUT).iterator().next();
                if (sfm.hasLocation(StandardLocation.MODULE_SOURCE_PATH)) {
                    // multi-module mode
                    if (Files.exists(outDir.resolve("module-info.class"))) {
                        log.error(Errors.MultiModuleOutdirCannotBeExplodedModule(outDir));
                    }
                } else {
                    // single-module or legacy mode
                    boolean lintPaths = options.isUnset(Option.XLINT_CUSTOM,
                            "-" + LintCategory.PATH.option);
                    if (lintPaths) {
                        Path outDirParent = outDir.getParent();
                        if (outDirParent != null && Files.exists(outDirParent.resolve("module-info.class"))) {
                            log.warning(LintCategory.PATH, Warnings.OutdirIsInExplodedModule(outDir));
                        }
                    }
                }
            }
        }


        String sourceString = options.get(Option.SOURCE);
        Source source = (sourceString != null)
                ? Source.lookup(sourceString)
                : Source.DEFAULT;
        String targetString = options.get(Option.TARGET);
        Target target = (targetString != null)
                ? Target.lookup(targetString)
                : Target.DEFAULT;

        // We don't check source/target consistency for CLDC, as J2ME
        // profiles are not aligned with J2SE targets; moreover, a
        // single CLDC target may have many profiles.  In addition,
        // this is needed for the continued functioning of the JSR14
        // prototype.
        if (Character.isDigit(target.name.charAt(0))) {
            if (target.compareTo(source.requiredTarget()) < 0) {
                if (targetString != null) {
                    if (sourceString == null) {
                        error("warn.target.default.source.conflict",
                                targetString,
                                source.requiredTarget().name);
                    } else {
                        error("warn.source.target.conflict",
                                sourceString,
                                source.requiredTarget().name);
                    }
                    return false;
                } else {
                    target = source.requiredTarget();
                    options.put("-target", target.name);
                }
            }
        }

        String profileString = options.get(Option.PROFILE);
        if (profileString != null) {
            Profile profile = Profile.lookup(profileString);
            if (!profile.isValid(target)) {
                error("warn.profile.target.conflict", profileString, target.name);
            }

            // This check is only effective in command line mode,
            // where the file manager options are added to options
            if (options.get(Option.BOOT_CLASS_PATH) != null) {
                error("err.profile.bootclasspath.conflict");
            }
        }

        if (options.isSet(Option.SOURCE_PATH) && options.isSet(Option.MODULE_SOURCE_PATH)) {
            error("err.sourcepath.modulesourcepath.conflict");
        }

        boolean lintOptions = options.isUnset(Option.XLINT_CUSTOM, "-" + LintCategory.OPTIONS.option);
        if (lintOptions && source.compareTo(Source.DEFAULT) < 0 && !options.isSet(Option.RELEASE)) {
            if (fm instanceof BaseFileManager) {
                if (((BaseFileManager) fm).isDefaultBootClassPath())
                    log.warning(LintCategory.OPTIONS, "source.no.bootclasspath", source.name);
            }
        }

        boolean obsoleteOptionFound = false;

        if (source.compareTo(Source.MIN) < 0) {
            log.error(Errors.OptionRemovedSource(source.name, Source.MIN.name));
        } else if (source == Source.MIN && lintOptions) {
            log.warning(LintCategory.OPTIONS, Warnings.OptionObsoleteSource(source.name));
            obsoleteOptionFound = true;
        }

        if (target.compareTo(Target.MIN) < 0) {
            log.error(Errors.OptionRemovedTarget(target.name, Target.MIN.name));
        } else if (target == Target.MIN && lintOptions) {
            log.warning(LintCategory.OPTIONS, Warnings.OptionObsoleteTarget(target.name));
            obsoleteOptionFound = true;
        }

        final Target t = target;
        checkOptionAllowed(t.compareTo(Target.JDK1_8) <= 0,
                option -> error("err.option.not.allowed.with.target", option.getPrimaryName(), t.name),
                Option.BOOT_CLASS_PATH,
                Option.XBOOTCLASSPATH_PREPEND, Option.XBOOTCLASSPATH, Option.XBOOTCLASSPATH_APPEND,
                Option.ENDORSEDDIRS, Option.DJAVA_ENDORSED_DIRS,
                Option.EXTDIRS, Option.DJAVA_EXT_DIRS,
                Option.PROFILE);

        checkOptionAllowed(t.compareTo(Target.JDK1_9) >= 0,
                option -> error("err.option.not.allowed.with.target", option.getPrimaryName(), t.name),
                Option.MODULE_SOURCE_PATH, Option.UPGRADE_MODULE_PATH,
                Option.SYSTEM, Option.MODULE_PATH, Option.ADD_MODULES,
                Option.ADD_EXPORTS, Option.ADD_OPENS, Option.ADD_READS,
                Option.LIMIT_MODULES,
                Option.PATCH_MODULE);

        if (fm.hasLocation(StandardLocation.MODULE_SOURCE_PATH)) {
            if (!options.isSet(Option.PROC, "only")
                    && !fm.hasLocation(StandardLocation.CLASS_OUTPUT)) {
                log.error(Errors.NoOutputDir);
            }
        }

        if (fm.hasLocation(StandardLocation.ANNOTATION_PROCESSOR_MODULE_PATH) &&
            fm.hasLocation(StandardLocation.ANNOTATION_PROCESSOR_PATH)) {
            log.error(Errors.ProcessorpathNoProcessormodulepath);
        }

        if (obsoleteOptionFound && lintOptions) {
            log.warning(LintCategory.OPTIONS, "option.obsolete.suppression");
        }

        SourceVersion sv = Source.toSourceVersion(source);
        validateAddExports(sv);
        validateAddModules(sv);
        validateAddReads(sv);
        validateLimitModules(sv);
        validateDefaultModuleForCreatedFiles(sv);

        if (lintOptions && options.isSet(Option.ADD_OPENS)) {
            log.warning(LintCategory.OPTIONS, Warnings.AddopensIgnored);
        }

        return !errors && (log.nerrors == 0);
    }

    private void validateAddExports(SourceVersion sv) {
        String addExports = options.get(Option.ADD_EXPORTS);
        if (addExports != null) {
            // Each entry must be of the form sourceModule/sourcePackage=target-list where
            // target-list is a comma separated list of module or ALL-UNNAMED.
            // Empty items in the target-list are ignored.
            // There must be at least one item in the list; this is handled in Option.ADD_EXPORTS.
            Pattern p = Option.ADD_EXPORTS.getPattern();
            for (String e : addExports.split("\0")) {
                Matcher m = p.matcher(e);
                if (m.matches()) {
                    String sourceModuleName = m.group(1);
                    if (!SourceVersion.isName(sourceModuleName, sv)) {
                        // syntactically invalid source name:  e.g. --add-exports m!/p1=m2
                        log.warning(Warnings.BadNameForOption(Option.ADD_EXPORTS, sourceModuleName));
                    }
                    String sourcePackageName = m.group(2);
                    if (!SourceVersion.isName(sourcePackageName, sv)) {
                        // syntactically invalid source name:  e.g. --add-exports m1/p!=m2
                        log.warning(Warnings.BadNameForOption(Option.ADD_EXPORTS, sourcePackageName));
                    }

                    String targetNames = m.group(3);
                    for (String targetName : targetNames.split(",")) {
                        switch (targetName) {
                            case "":
                            case "ALL-UNNAMED":
                                break;

                            default:
                                if (!SourceVersion.isName(targetName, sv)) {
                                    // syntactically invalid target name:  e.g. --add-exports m1/p1=m!
                                    log.warning(Warnings.BadNameForOption(Option.ADD_EXPORTS, targetName));
                                }
                                break;
                        }
                    }
                }
            }
        }
    }

    private void validateAddReads(SourceVersion sv) {
        String addReads = options.get(Option.ADD_READS);
        if (addReads != null) {
            // Each entry must be of the form source=target-list where target-list is a
            // comma-separated list of module or ALL-UNNAMED.
            // Empty items in the target list are ignored.
            // There must be at least one item in the list; this is handled in Option.ADD_READS.
            Pattern p = Option.ADD_READS.getPattern();
            for (String e : addReads.split("\0")) {
                Matcher m = p.matcher(e);
                if (m.matches()) {
                    String sourceName = m.group(1);
                    if (!SourceVersion.isName(sourceName, sv)) {
                        // syntactically invalid source name:  e.g. --add-reads m!=m2
                        log.warning(Warnings.BadNameForOption(Option.ADD_READS, sourceName));
                    }

                    String targetNames = m.group(2);
                    for (String targetName : targetNames.split(",", -1)) {
                        switch (targetName) {
                            case "":
                            case "ALL-UNNAMED":
                                break;

                            default:
                                if (!SourceVersion.isName(targetName, sv)) {
                                    // syntactically invalid target name:  e.g. --add-reads m1=m!
                                    log.warning(Warnings.BadNameForOption(Option.ADD_READS, targetName));
                                }
                                break;
                        }
                    }
                }
            }
        }
    }

    private void validateAddModules(SourceVersion sv) {
        String addModules = options.get(Option.ADD_MODULES);
        if (addModules != null) {
            // Each entry must be of the form target-list where target-list is a
            // comma separated list of module names, or ALL-DEFAULT, ALL-SYSTEM,
            // or ALL-MODULE_PATH.
            // Empty items in the target list are ignored.
            // There must be at least one item in the list; this is handled in Option.ADD_MODULES.
            for (String moduleName : addModules.split(",")) {
                switch (moduleName) {
                    case "":
                    case "ALL-SYSTEM":
                    case "ALL-MODULE-PATH":
                        break;

                    default:
                        if (!SourceVersion.isName(moduleName, sv)) {
                            // syntactically invalid module name:  e.g. --add-modules m1,m!
                            log.error(Errors.BadNameForOption(Option.ADD_MODULES, moduleName));
                        }
                        break;
                }
            }
        }
    }

    private void validateLimitModules(SourceVersion sv) {
        String limitModules = options.get(Option.LIMIT_MODULES);
        if (limitModules != null) {
            // Each entry must be of the form target-list where target-list is a
            // comma separated list of module names, or ALL-DEFAULT, ALL-SYSTEM,
            // or ALL-MODULE_PATH.
            // Empty items in the target list are ignored.
            // There must be at least one item in the list; this is handled in Option.LIMIT_EXPORTS.
            for (String moduleName : limitModules.split(",")) {
                switch (moduleName) {
                    case "":
                        break;

                    default:
                        if (!SourceVersion.isName(moduleName, sv)) {
                            // syntactically invalid module name:  e.g. --limit-modules m1,m!
                            log.error(Errors.BadNameForOption(Option.LIMIT_MODULES, moduleName));
                        }
                        break;
                }
            }
        }
    }

    private void validateDefaultModuleForCreatedFiles(SourceVersion sv) {
        String moduleName = options.get(Option.DEFAULT_MODULE_FOR_CREATED_FILES);
        if (moduleName != null) {
            if (!SourceVersion.isName(moduleName, sv)) {
                // syntactically invalid module name:  e.g. --default-module-for-created-files m!
                log.error(Errors.BadNameForOption(Option.DEFAULT_MODULE_FOR_CREATED_FILES,
                                                  moduleName));
            }
        }
    }

    /**
     * Returns true if there are no files or classes specified for use.
     * @return true if there are no files or classes specified for use
     */
    public boolean isEmpty() {
        return ((files == null) || files.isEmpty())
                && ((fileObjects == null) || fileObjects.isEmpty())
                && (classNames == null || classNames.isEmpty());
    }

    public void allowEmpty() {
        this.emptyAllowed = true;
    }

    /**
     * Gets the file manager options which may have been deferred
     * during processArgs.
     * @return the deferred file manager options
     */
    public Map<Option, String> getDeferredFileManagerOptions() {
        return deferredFileManagerOptions;
    }

    /**
     * Gets any options specifying plugins to be run.
     * @return options for plugins
     */
    public Set<List<String>> getPluginOpts() {
        String plugins = options.get(Option.PLUGIN);
        if (plugins == null)
            return Collections.emptySet();

        Set<List<String>> pluginOpts = new LinkedHashSet<>();
        for (String plugin: plugins.split("\\x00")) {
            pluginOpts.add(List.from(plugin.split("\\s+")));
        }
        return Collections.unmodifiableSet(pluginOpts);
    }

    /**
     * Gets any options specifying how doclint should be run.
     * An empty list is returned if no doclint options are specified
     * or if the only doclint option is -Xdoclint:none.
     * @return options for doclint
     */
    public List<String> getDocLintOpts() {
        String xdoclint = options.get(Option.XDOCLINT);
        String xdoclintCustom = options.get(Option.XDOCLINT_CUSTOM);
        if (xdoclint == null && xdoclintCustom == null)
            return List.nil();

        Set<String> doclintOpts = new LinkedHashSet<>();
        if (xdoclint != null)
            doclintOpts.add(DocLint.XMSGS_OPTION);
        if (xdoclintCustom != null) {
            for (String s: xdoclintCustom.split("\\s+")) {
                if (s.isEmpty())
                    continue;
                doclintOpts.add(DocLint.XMSGS_CUSTOM_PREFIX + s);
            }
        }

        if (doclintOpts.equals(Collections.singleton(DocLint.XMSGS_CUSTOM_PREFIX + "none")))
            return List.nil();

        String checkPackages = options.get(Option.XDOCLINT_PACKAGE);
        if (checkPackages != null) {
            for (String s : checkPackages.split("\\s+")) {
                doclintOpts.add(DocLint.XCHECK_PACKAGE + s);
            }
        }

        String format = options.get(Option.DOCLINT_FORMAT);
        if (format != null) {
            doclintOpts.add(DocLint.XHTML_VERSION_PREFIX + format);
        }

        // standard doclet normally generates H1, H2,
        // so for now, allow user comments to assume that
        doclintOpts.add(DocLint.XIMPLICIT_HEADERS + "2");
        return List.from(doclintOpts.toArray(new String[doclintOpts.size()]));
    }

    private boolean checkDirectory(Option option) {
        String value = options.get(option);
        if (value == null) {
            return true;
        }
        Path file = Paths.get(value);
        if (Files.exists(file) && !Files.isDirectory(file)) {
            error("err.file.not.directory", value);
            return false;
        }
        return true;
    }

    private interface ErrorReporter {
        void report(Option o);
    }

    void checkOptionAllowed(boolean allowed, ErrorReporter r, Option... opts) {
        if (!allowed) {
            Stream.of(opts)
                  .filter(options :: isSet)
                  .forEach(r :: report);
        }
    }

    void error(JCDiagnostic.Error error) {
        errors = true;
        switch (errorMode) {
            case ILLEGAL_ARGUMENT: {
                String msg = log.localize(error);
                throw new PropagatedException(new IllegalArgumentException(msg));
            }
            case ILLEGAL_STATE: {
                String msg = log.localize(error);
                throw new PropagatedException(new IllegalStateException(msg));
            }
            case LOG:
                report(error);
        }
    }

    void error(String key, Object... args) {
        errors = true;
        switch (errorMode) {
            case ILLEGAL_ARGUMENT: {
                String msg = log.localize(PrefixKind.JAVAC, key, args);
                throw new PropagatedException(new IllegalArgumentException(msg));
            }
            case ILLEGAL_STATE: {
                String msg = log.localize(PrefixKind.JAVAC, key, args);
                throw new PropagatedException(new IllegalStateException(msg));
            }
            case LOG:
                report(key, args);
        }
    }

    void error(Option.InvalidValueException f) {
        String msg = f.getMessage();
        errors = true;
        switch (errorMode) {
            case ILLEGAL_ARGUMENT: {
                throw new PropagatedException(new IllegalArgumentException(msg, f.getCause()));
            }
            case ILLEGAL_STATE: {
                throw new PropagatedException(new IllegalStateException(msg, f.getCause()));
            }
            case LOG:
                log.printRawLines(ownName + ": " + msg);
        }
    }

    void warning(String key, Object... args) {
        report(key, args);
    }

    private void report(String key, Object... args) {
        // Would be good to have support for -XDrawDiagnostics here
        log.printRawLines(ownName + ": " + log.localize(PrefixKind.JAVAC, key, args));
    }

    private void report(JCDiagnostic.Error error) {
        // Would be good to have support for -XDrawDiagnostics here
        log.printRawLines(ownName + ": " + log.localize(error));
    }

    private JavaFileManager getFileManager() {
        if (fileManager == null)
            fileManager = context.get(JavaFileManager.class);
        return fileManager;
    }

    <T> ListBuffer<T> toList(Iterable<? extends T> items) {
        ListBuffer<T> list = new ListBuffer<>();
        if (items != null) {
            for (T item : items) {
                list.add(item);
            }
        }
        return list;
    }

    <T> Set<T> toSet(Iterable<? extends T> items) {
        Set<T> set = new LinkedHashSet<>();
        if (items != null) {
            for (T item : items) {
                set.add(item);
            }
        }
        return set;
    }
}