import com.sun.tools.javac.main.Option; //导入依赖的package包/类
void initHandlers() {
    handlersForLocation = new HashMap<Location, LocationHandler>();
    handlersForOption = new EnumMap<Option, LocationHandler>(Option.class);

    LocationHandler[] handlers = {
        new BootClassPathLocationHandler(),
        new ClassPathLocationHandler(),
        new SimpleLocationHandler(StandardLocation.SOURCE_PATH, Option.SOURCEPATH),
        new SimpleLocationHandler(StandardLocation.ANNOTATION_PROCESSOR_PATH, Option.PROCESSORPATH),
        new OutputLocationHandler((StandardLocation.CLASS_OUTPUT), Option.D),
        new OutputLocationHandler((StandardLocation.SOURCE_OUTPUT), Option.S),
        new OutputLocationHandler((StandardLocation.NATIVE_HEADER_OUTPUT), Option.H)
    };

    for (LocationHandler h: handlers) {
        handlersForLocation.put(h.location, h);
        for (Option o: h.options)
            handlersForOption.put(o, h);
    }
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
/**
 * Returns an empty processor iterator if no processors are on the
 * relevant path, otherwise if processors are present, logs an
 * error.  Called when a service loader is unavailable for some
 * reason, either because a service loader class cannot be found
 * or because a security policy prevents class loaders from being
 * created.
 *
 * @param key The resource key to use to log an error message
 * @param e   If non-null, pass this exception to Abort
 */
private Iterator<Processor> handleServiceLoaderUnavailability(String key, Exception e) {
    if (fileManager instanceof JavacFileManager) {
        StandardJavaFileManager standardFileManager = (JavacFileManager) fileManager;
        Iterable<? extends Path> workingPath = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
            ? standardFileManager.getLocationAsPaths(ANNOTATION_PROCESSOR_PATH)
            : standardFileManager.getLocationAsPaths(CLASS_PATH);

        if (needClassLoader(options.get(Option.PROCESSOR), workingPath) )
            handleException(key, e);

    } else {
        handleException(key, e);
    }

    java.util.List<Processor> pl = Collections.emptyList();
    return pl.iterator();
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
/**
 * Common back end for OptionHelper handleFileManagerOption.
 * @param option the option whose value to be set
 * @param value the value for the option
 * @return true if successful, and false otherwise
 */
public boolean handleOption(Option option, String value) {
    switch (option) {
        case ENCODING:
            encodingName = value;
            return true;

        case MULTIRELEASE:
            multiReleaseValue = value;
            locations.setMultiReleaseValue(value);
            return true;

        default:
            return locations.handleOption(option, value);
    }
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
@Override
boolean handleOption(Option option, String value) {
    if (!options.contains(option)) {
        return false;
    }

    if (value == null) {
        systemJavaHome = Locations.javaHome;
    } else if (value.equals("none")) {
        systemJavaHome = null;
    } else {
        update(getPath(value));
    }

    modules = null;
    return true;
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
public int isSupportedOption(String option) {
    Set<Option> recognizedOptions = Option.getJavacToolOptions();
    for (Option o : recognizedOptions) {
        if (o.matches(option))
            return o.hasArg() ? 1 : 0;
    }
    return -1;
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
/**
 * Create a handler. The location and options provide a way to map
 * from a location or an option to the corresponding handler.
 * @see #initHandlers
 */
protected LocationHandler(Location location, Option... options) {
    this.location = location;
    this.options = options.length == 0 ?
        EnumSet.noneOf(Option.class):
        EnumSet.copyOf(Arrays.asList(options));
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
void update(Options optionTable) {
    for (Option o: options) {
        String v = optionTable.get(o);
        if (v != null) {
            handleOption(o, v);
        }
    }
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
@Override
boolean handleOption(Option option, String value) {
    if (!options.contains(option))
        return false;

    // TODO: could/should validate outputDir exists and is a directory
    // need to decide how best to report issue for benefit of
    // direct API call on JavaFileManager.handleOption(specifies IAE)
    // vs. command line decoding.
    outputDir = new File(value);
    return true;
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
BootClassPathLocationHandler() {
    super(StandardLocation.PLATFORM_CLASS_PATH,
            Option.BOOTCLASSPATH, Option.XBOOTCLASSPATH,
            Option.XBOOTCLASSPATH_PREPEND,
            Option.XBOOTCLASSPATH_APPEND,
            Option.ENDORSEDDIRS, Option.DJAVA_ENDORSED_DIRS,
            Option.EXTDIRS, Option.DJAVA_EXT_DIRS);
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
private Option canonicalize(Option option) {
    switch (option) {
        case XBOOTCLASSPATH:
            return Option.BOOTCLASSPATH;
        case DJAVA_ENDORSED_DIRS:
            return Option.ENDORSEDDIRS;
        case DJAVA_EXT_DIRS:
            return Option.EXTDIRS;
        default:
            return option;
    }
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
protected Source getSource() {
    String sourceName = options.get(Option.SOURCE);
    Source source = null;
    if (sourceName != null)
        source = Source.lookup(sourceName);
    return (source != null ? source : Source.DEFAULT);
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
public int isSupportedOption(String option) {
    for (Option o : javacFileManagerOptions) {
        if (o.matches(option))
            return o.hasArg() ? 1 : 0;
    }
    return -1;
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
public String getEncodingName() {
    String encName = options.get(Option.ENCODING);
    if (encName == null)
        return getDefaultEncodingName();
    else
        return encName;
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
private int getIntOption(Options options, Option option, int defaultValue) {
    String s = options.get(option);
    try {
        if (s != null) {
            int n = Integer.parseInt(s);
            return (n <= 0 ? Integer.MAX_VALUE : n);
        }
    } catch (NumberFormatException e) {
        // silently ignore ill-formed numbers
    }
    return defaultValue;
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
/** Construct a new class reader. */
protected ClassReader(Context context) {
    context.put(classReaderKey, this);
    annotate = Annotate.instance(context);
    names = Names.instance(context);
    syms = Symtab.instance(context);
    types = Types.instance(context);
    fileManager = context.get(JavaFileManager.class);
    if (fileManager == null)
        throw new AssertionError("FileManager initialization error");
    diagFactory = JCDiagnostic.Factory.instance(context);

    log = Log.instance(context);

    Options options = Options.instance(context);
    verbose         = options.isSet(Option.VERBOSE);

    Source source = Source.instance(context);
    allowSimplifiedVarargs = source.allowSimplifiedVarargs();
    allowModules     = source.allowModules();

    saveParameterNames = options.isSet(PARAMETERS);

    profile = Profile.instance(context);

    typevars = WriteableScope.create(syms.noSymbol);

    lintClassfile = Lint.instance(context).isEnabled(LintCategory.CLASSFILE);

    initAttributeReaders();
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
JavacFiler(Context context) {
    this.context = context;
    fileManager = context.get(JavaFileManager.class);
    elementUtils = JavacElements.instance(context);

    log = Log.instance(context);
    modules = Modules.instance(context);
    names = Names.instance(context);
    syms = Symtab.instance(context);

    initialInputs = synchronizedSet(new LinkedHashSet<>());
    fileObjectHistory = synchronizedSet(new LinkedHashSet<>());
    generatedSourceNames = synchronizedSet(new LinkedHashSet<>());
    generatedSourceFileObjects = synchronizedSet(new LinkedHashSet<>());

    generatedClasses = synchronizedMap(new LinkedHashMap<>());

    openTypeNames  = synchronizedSet(new LinkedHashSet<>());

    aggregateGeneratedSourceNames = new LinkedHashSet<>();
    aggregateGeneratedClassNames  = new LinkedHashSet<>();
    initialClassNames  = new LinkedHashSet<>();

    lint = (Lint.instance(context)).isEnabled(PROCESSING);

    Options options = Options.instance(context);

    defaultTargetModule = options.get(Option.DEFAULT_MODULE_FOR_CREATED_FILES);
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
@Override @DefinedBy(Api.COMPILER)
public int isSupportedOption(String option) {
    Set<Option> recognizedOptions = Option.getJavacToolOptions();
    for (Option o : recognizedOptions) {
        if (o.matches(option)) {
            return o.hasArg() ? 1 : 0;
        }
    }
    return -1;
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
protected Lint(Context context) {
    // initialize values according to the lint options
    Options options = Options.instance(context);

    if (options.isSet(Option.XLINT) || options.isSet(Option.XLINT_CUSTOM, "all")) {
        // If -Xlint or -Xlint:all is given, enable all categories by default
        values = EnumSet.allOf(LintCategory.class);
    } else if (options.isSet(Option.XLINT_CUSTOM, "none")) {
        // if -Xlint:none is given, disable all categories by default
        values = EnumSet.noneOf(LintCategory.class);
    } else {
        // otherwise, enable on-by-default categories
        values = EnumSet.noneOf(LintCategory.class);

        Source source = Source.instance(context);
        if (source.compareTo(Source.JDK1_9) >= 0) {
            values.add(LintCategory.DEP_ANN);
        }
        values.add(LintCategory.REQUIRES_TRANSITIVE_AUTOMATIC);
        values.add(LintCategory.OPENS);
        values.add(LintCategory.MODULE);
        values.add(LintCategory.REMOVAL);
    }

    // Look for specific overrides
    for (LintCategory lc : LintCategory.values()) {
        if (options.isSet(Option.XLINT_CUSTOM, lc.option)) {
            values.add(lc);
        } else if (options.isSet(Option.XLINT_CUSTOM, "-" + lc.option)) {
            values.remove(lc);
        }
    }

    suppressedValues = EnumSet.noneOf(LintCategory.class);

    context.put(lintKey, this);
    augmentor = new AugmentVisitor(context);
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
/**
 * Call handleOption for collection of options and corresponding values.
 * @param map a collection of options and corresponding values
 * @return true if all the calls are successful
 */
public boolean handleOptions(Map<Option, String> map) {
    boolean ok = true;
    for (Map.Entry<Option, String> e: map.entrySet()) {
        try {
            ok = ok & handleOption(e.getKey(), e.getValue());
        } catch (IllegalArgumentException ex) {
            log.error(Errors.IllegalArgumentForOption(e.getKey().getPrimaryName(), ex.getMessage()));
            ok = false;
        }
    }
    return ok;
}
 

import com.sun.tools.javac.main.Option; //导入依赖的package包/类
BootClassPathLocationHandler() {
    super(StandardLocation.PLATFORM_CLASS_PATH,
            Option.BOOT_CLASS_PATH, Option.XBOOTCLASSPATH,
            Option.XBOOTCLASSPATH_PREPEND,
            Option.XBOOTCLASSPATH_APPEND,
            Option.ENDORSEDDIRS, Option.DJAVA_ENDORSED_DIRS,
            Option.EXTDIRS, Option.DJAVA_EXT_DIRS);
}