flex-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cd...@apache.org
Subject [26/51] [partial] - Migrated the directory structure to a more Maven style structure. - Started migrating the Parser from Antlr2+3 and JFlex to Antlr4.
Date Tue, 22 Jul 2014 13:35:52 GMT
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/59f6373b/compiler/src/main/java/org/apache/flex/compiler/config/Configurator.java
----------------------------------------------------------------------
diff --git a/compiler/src/main/java/org/apache/flex/compiler/config/Configurator.java b/compiler/src/main/java/org/apache/flex/compiler/config/Configurator.java
new file mode 100644
index 0000000..30543e7
--- /dev/null
+++ b/compiler/src/main/java/org/apache/flex/compiler/config/Configurator.java
@@ -0,0 +1,3432 @@
+/*
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package org.apache.flex.compiler.config;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import org.apache.flex.compiler.clients.MXMLC;
+import org.apache.flex.compiler.common.IPathResolver;
+import org.apache.flex.compiler.common.VersionInfo;
+import org.apache.flex.compiler.config.RSLSettings.RSLAndPolicyFileURLPair;
+import org.apache.flex.compiler.exceptions.ConfigurationException;
+import org.apache.flex.compiler.filespecs.FileSpecification;
+import org.apache.flex.compiler.filespecs.IFileSpecification;
+import org.apache.flex.compiler.internal.config.CompilerProblemSettings;
+import org.apache.flex.compiler.internal.config.DefaultsConfigurator;
+import org.apache.flex.compiler.internal.config.FileConfigurator;
+import org.apache.flex.compiler.internal.config.ICompilerSettings;
+import org.apache.flex.compiler.internal.config.IConfigurator;
+import org.apache.flex.compiler.internal.config.RuntimeSharedLibraryPathInfo;
+import org.apache.flex.compiler.internal.config.SystemPropertyConfigurator;
+import org.apache.flex.compiler.internal.config.TargetSettings;
+import org.apache.flex.compiler.internal.config.localization.LocalizationManager;
+import org.apache.flex.compiler.internal.config.localization.ResourceBundleLocalizer;
+import org.apache.flex.compiler.internal.projects.FlexProject;
+import org.apache.flex.compiler.internal.projects.FlexProjectConfigurator;
+import org.apache.flex.compiler.internal.projects.SourcePathManager;
+import org.apache.flex.compiler.internal.workspaces.Workspace;
+import org.apache.flex.compiler.mxml.IMXMLNamespaceMapping;
+import org.apache.flex.compiler.problems.ANELibraryNotAllowedProblem;
+import org.apache.flex.compiler.problems.ConfigurationProblem;
+import org.apache.flex.compiler.problems.ICompilerProblem;
+import org.apache.flex.compiler.projects.IFlexProject;
+import org.apache.flex.compiler.targets.ITargetSettings;
+import org.apache.flex.compiler.targets.ITarget.TargetType;
+import org.apache.flex.compiler.workspaces.IWorkspace;
+import org.apache.flex.swc.ISWC;
+import org.apache.flex.utils.FileUtils;
+import org.apache.flex.utils.FilenameNormalization;
+import org.apache.flex.utils.Trace;
+
+import com.google.common.base.Function;
+import com.google.common.collect.Lists;
+
+/**
+ * A class that allows a client change compiler settings and to 
+ * configure projects and targets from those settings.
+ */
+public class Configurator implements ICompilerSettings, IConfigurator, ICompilerSettingsConstants, Cloneable
+{
+
+    /**
+     * Marker class for RSLSettings because RSLSettings need special handling
+     * in getOptions(). 
+     */
+    static class RSLSettingsList extends ArrayList<RSLSettings>
+    {
+        public RSLSettingsList(int size)
+        {
+            super(size);
+        }
+        
+        public RSLSettingsList(Collection<? extends RSLSettings> c)
+        {
+            super(c);
+        }
+
+        private static final long serialVersionUID = 0L;        
+    }
+    
+    /**
+     *  Ditto for conditional compilation
+     */
+    static class CompilerDefinitionMap extends TreeMap<String, String>
+    {
+        private static final long serialVersionUID = 0L;
+    }
+    
+    static class ApplicationDomainsList extends ArrayList<String[]>
+    {
+        private static final long serialVersionUID = 0L;
+    }
+    
+    static class MXMLNamespaceMappingList extends ArrayList<IMXMLNamespaceMapping>
+    {
+        public MXMLNamespaceMappingList(int size)
+        {
+            super(size);
+        }
+        
+        public MXMLNamespaceMappingList(Collection<? extends IMXMLNamespaceMapping> namespaceMappings)
+        {
+            super(namespaceMappings);
+        }
+
+        private static final long serialVersionUID = 0L;
+        
+    }
+
+    static class ServicesContextRoot
+    {
+        public ServicesContextRoot(String path, String contextRoot)
+        {
+            this.path = path;
+            this.contextRoot = contextRoot;
+        }
+        
+        public String path;
+        public String contextRoot;
+    }
+
+    /**
+     *  Ditto for conditional compilation
+     */
+    static class FrameLabelMap extends TreeMap<String, List<String>>
+    {
+        private static final long serialVersionUID = 0L;
+    }
+    
+    /**
+     * Convert file path strings to {@code File} objects. Null values are
+     * discarded.
+     * 
+     * @param paths List of file paths
+     * @return List of File objects. No null values will be returned.
+     */
+    public static List<File> toFiles(final List<String> paths)
+    {
+        final List<File> result = new ArrayList<File>();
+        for (final String path : paths)
+        {
+            if (path != null)
+                result.add(new File(path));
+        }
+        return result;
+    }
+
+    /**
+     * Convert file path strings to {@code File} objects. Null values are
+     * discarded.
+     * 
+     * @param paths List of file paths
+     * @return Array of File objects. No null values will be returned.
+     */
+    public static List<File> toFileList(final List<String> paths)
+    {
+        final List<File> result = new ArrayList<File>();
+        for (final String path : paths)
+        {
+            if (path != null)
+                result.add(FilenameNormalization.normalize(new File(path)));
+        }
+        return result;
+    }
+
+    /**
+     * Convert {@code File} objects to {@code String}, where each {@code String} is 
+     * the absolute file path of the file. Null values are discarded.
+     * 
+     * @param files file specifications
+     * @return Array of File objects. No null values will be returned.
+     */
+    public static String[] toPaths(File[] files)
+    {
+        final List<String> result = new ArrayList<String>();
+        for (final File file : files)
+        {
+            if (file != null)
+                result.add(file.getAbsolutePath());
+        }
+        return result.toArray(new String[0]);
+    }
+
+    /**
+     * Resolve a list of normalized paths to {@link IFileSpecification} objects
+     * from the given {@code workspace}.
+     * 
+     * @param paths A list of normalized paths.
+     * @param workspace Workspace.
+     * @return A list of file specifications.
+     */
+    public static List<IFileSpecification> toFileSpecifications(
+            final List<String> paths,
+            final Workspace workspace)
+    {
+        return Lists.transform(paths, new Function<String, IFileSpecification>()
+        {
+            @Override
+            public IFileSpecification apply(final String path)
+            {
+                return workspace.getFileSpecification(path);
+            }
+        });
+    }
+
+    // Used to generate the command line
+    private static final String EQUALS_STRING = "=";
+    private static final String PLUS_EQUALS_STRING = "+=";
+    private static final String COMMA_STRING =  ",";
+    private static final String PLUS_STRING =  "+";
+    private static final Set<String> excludes = new HashSet<String>();
+
+    static
+    {
+        excludes.add("output");
+        excludes.add("warnings");
+        excludes.add("compiler.debug");
+        excludes.add("compiler.profile");
+        excludes.add("compiler.accessible");
+        excludes.add("compiler.strict");
+        excludes.add("compiler.show-actionscript-warnings");        
+        excludes.add("compiler.show-unused-type-selector-warnings");
+        excludes.add("compiler.show-deprecation-warnings");
+        excludes.add("compiler.show-shadowed-device-font-warnings");
+        excludes.add("compiler.show-binding-warnings");
+        excludes.add("compiler.verbose-stacktraces");
+        excludes.add("flex");
+    }
+    
+    /**
+     * Constructor
+     */
+    public Configurator()
+    {
+        this(Configuration.class);
+    }
+    
+    /**
+     * Constructor
+     */
+    public Configurator(Class<? extends Configuration> configurationClass)
+    {
+        this.configurationClass = configurationClass;
+        args = new LinkedHashMap<String, Object>();
+        more = new LinkedHashMap<String, Object>();
+        tokens = new TreeMap<String, String>();
+        
+        keepLinkReport = false;
+        keepSizeReport = false;
+        keepConfigurationReport = false;
+        reportMissingLibraries = true;
+        warnOnFlexOnlyOptionUsage = false;
+        isConfigurationDirty = true;
+        configurationDefaultVariable = ICompilerSettingsConstants.FILE_SPECS_VAR; // the default variable of the configuration.
+        configurationPathResolver = new ConfigurationPathResolver(System.getProperty("user.dir"));
+        configurationProblems = new ArrayList<ICompilerProblem>();
+
+        // initialize the localization manager.
+        LocalizationManager.get().addLocalizer(new ResourceBundleLocalizer());
+    }
+
+    private ConfigurationBuffer cfgbuf;
+    private Configuration configuration;
+    private Class<? extends Configuration> configurationClass;
+    
+    private Map<String, Object> args, more;
+    private String[] extras;
+    private String configurationDefaultVariable;
+    private boolean keepLinkReport, keepSizeReport, keepConfigurationReport;
+    private String mainDefinition;
+    private boolean reportMissingLibraries;
+    private boolean warnOnFlexOnlyOptionUsage;
+    private List<String> loadedConfigFiles;
+    private List<String> missingConfigFiles;
+    
+    private Map<String, String> tokens;
+    
+    private boolean isConfigurationDirty;
+    private boolean configurationSuccess;
+    private Collection<ICompilerProblem> configurationProblems;
+    private boolean extrasRequireDefaultVariable;
+    private IPathResolver configurationPathResolver;
+
+    // 
+    // IConfigurator related methods
+    //
+    
+    @Override
+    public List<String> getLoadedConfigurationFiles()
+    {
+        return loadedConfigFiles != null ? loadedConfigFiles :
+            Collections.<String>emptyList();
+    }
+    
+    @Override
+    public List<String> getMissingConfigurationFiles()
+    {
+        return missingConfigFiles != null ? missingConfigFiles :
+            Collections.<String>emptyList();
+    }
+    
+    @Override
+    public boolean applyToProject(IFlexProject project)
+    {
+        final IWorkspace workspace = project.getWorkspace();
+        boolean success = processConfiguration();
+        workspace.startIdleState();
+        try
+        {
+            
+            
+            if (configuration == null)
+                return false;
+            
+            if (project instanceof FlexProject)
+            {
+                FlexProject flexProject = (FlexProject)project;
+    
+                FlexProjectConfigurator.configure(flexProject, configuration);
+                setupCompatibilityVersion(flexProject);
+                setupConfigVariables(flexProject);
+                setupLocaleSettings(flexProject);
+                setupServices(flexProject);
+                setupThemeFiles(flexProject);
+                setupFlex(flexProject);
+                setupCodegenOptions(flexProject);
+            }
+            
+            project.setRuntimeSharedLibraryPath(getRSLSettingsFromConfiguration(configuration));
+    
+            if (!setupProjectLibraries(project))
+                success = false;
+            
+            setupNamespaces(project);
+        }
+        finally
+        {
+            workspace.endIdleState(IWorkspace.NIL_COMPILATIONUNITS_TO_UPDATE);
+        }
+        if (!setupSources(project))
+            success = false; 
+        return success;
+    }
+
+    private void setupFlex(FlexProject flexProject)
+    {
+        flexProject.setFlex(configuration.isFlex());
+    }
+
+    private void setupCodegenOptions(FlexProject flexProject)
+    {
+        flexProject.setEnableInlining(configuration.isInliningEnabled());
+    }
+
+    private String computeQNameForTargetFile()
+    {
+        List<String> computedSourcePath = new ArrayList<String>();
+        applySourcePathRules(computedSourcePath);
+        String targetSourceFileName = configuration.getTargetFile();
+        if (targetSourceFileName == null)
+            return null;
+        final File targetSourceFile = FilenameNormalization.normalize(new File(configuration.getTargetFile()));
+        for (final String sourcePathEntry : computedSourcePath)
+        {
+            final String computedQName = SourcePathManager.computeQName(new File(sourcePathEntry), targetSourceFile);
+            if (computedQName != null)
+                return computedQName;
+            
+        }
+        return null;
+    }
+    
+    @Override
+    public ITargetSettings getTargetSettings(TargetType targetType)
+    {
+        boolean wasConfigurationDirty = isConfigurationDirty;
+        
+        if (!processConfiguration())
+            return null;
+
+        // Special handling for dump config. If dump config was specified then
+        // dump it out again if the configuration was not dirty. The config is
+        // dumped as a side-effect of validating the configuration if it gets
+        // processed.
+        try
+        {
+            if (!wasConfigurationDirty)
+            {
+                if (cfgbuf.getVar(ICompilerSettingsConstants.DUMP_CONFIG_VAR) != null)
+                {
+                    // The file may have already been dumped as a side-effect of 
+                    // applyToProject() so only dump if it does not exist.
+                    String dumpConfigPath = configuration.getDumpConfig();
+                    if (dumpConfigPath != null && !(new File(dumpConfigPath).exists()))
+                        configuration.validateDumpConfig(cfgbuf);
+                }
+            }
+            
+            if (mainDefinition != null)
+            {
+                configuration.setMainDefinition(mainDefinition);
+            }
+            else if ((configuration.getMainDefinition() == null) && (targetType == TargetType.SWF))
+            {
+                String computedQName = computeQNameForTargetFile();
+                if (computedQName != null)
+                    configuration.setMainDefinition(computedQName);
+            }
+
+            if (targetType == TargetType.SWC)
+                validateSWCConfiguration();
+            else
+                Configuration.validateNoCompcOnlyOptions(cfgbuf);
+            
+        }
+        catch (ConfigurationException e)
+        {
+            reportConfigurationException(e);
+            return null;
+        }
+        
+        return new TargetSettings(configuration);
+    }
+
+    @Override    
+    public ICompilerProblemSettings getCompilerProblemSettings()
+    {
+        processConfiguration();
+        
+        return new CompilerProblemSettings(configuration);
+    }
+
+    @Override
+    public Collection<ICompilerProblem> validateConfiguration(String[] args, TargetType targetType)
+    {
+        if (args == null)
+            throw new NullPointerException("args may not be null");
+        
+        List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();
+        ConfigurationBuffer configurationBuffer = createConfigurationBuffer(configurationClass);
+        
+        try
+        {
+            CommandLineConfigurator.parse(configurationBuffer, null, args);
+
+            // verify SWC-only args are not used to for a SWF target.
+            if (targetType == TargetType.SWF)
+                Configuration.validateNoCompcOnlyOptions(configurationBuffer);
+        }
+        catch (ConfigurationException e)
+        {
+            final ICompilerProblem problem = new ConfigurationProblem(e);
+            problems.add(problem);
+        }
+        
+        return problems;
+    }
+    
+    @Override
+    public Collection<ICompilerProblem> getConfigurationProblems()
+    {
+        assert configuration != null : 
+            "Get the configuration problems after calling applyToProject() or getTargetSettings()";
+        
+        List<ICompilerProblem> problems = new ArrayList<ICompilerProblem>(configurationProblems.size() +
+                                            configuration.getConfigurationProblems().size());
+        problems.addAll(configurationProblems);
+        problems.addAll(configuration.getConfigurationProblems()); 
+        return problems;
+    }
+
+    @Override
+    public void setConfigurationPathResolver(IPathResolver pathResolver)
+    {
+        if (pathResolver == null)
+            throw new NullPointerException("pathResolver may not be null");
+        
+        this.configurationPathResolver = pathResolver;
+    }
+
+    // Needed by MXMLC for now.
+    public Configuration getConfiguration()
+    {
+        return configuration;
+    }
+    
+    // Needed by MXMLC for now.
+    public ConfigurationBuffer getConfigurationBuffer()
+    {
+        return cfgbuf;
+    }
+
+    /**
+     * Create a new configuration instance. The Configurator will need to 
+     * create a new configuration for each new configuration. For example,
+     * creating a new Configurator and getting the target settings will create
+     * a new configuration. If later on, the configuration is modified by calling
+     * any of the setter methods on the Configurator, then a new configuration 
+     * will be created the next time applyToProject() or getTargetSettings() is called.
+     * 
+     * The method may be overriden to allow for greater control when creating a 
+     * custom configuration that extends the built-in configuration.
+     * 
+     * @return a new configuration instance. If the custom configuration class
+     * cannot be created, the default configuration class will be created instead.
+     */
+    protected Configuration createConfiguration()
+    {
+        try
+        {
+            return configurationClass.newInstance();
+        }
+        catch (Exception e)
+        {
+            // If there is a problem initializing the configuration, then
+            // throw a ConfigurationException.
+            reportConfigurationException(new ConfigurationException.CouldNotInstantiate(configurationClass.getName()));
+
+            // Create the default configuration so we can report configuration
+            // problems.
+            try
+            {
+                return Configuration.class.newInstance();                
+            }
+            catch (Exception e2)
+            {
+                // this should never fail
+                assert(false);
+                return null;
+            }
+        }
+    }
+    
+    /**
+     * Initialize the configuration and the configuration buffer.
+     */
+    protected void initializeConfiguration()
+    {
+        // Create a clean configuration and configuration buffer
+        configuration = createConfiguration();
+        cfgbuf = createConfigurationBuffer(configuration.getClass());
+        assert configurationPathResolver != null : "No configuration path resolver was set.";
+        configuration.setPathResolver(configurationPathResolver);
+        configuration.setReportMissingCompilerLibraries(reportMissingLibraries);
+        configuration.setWarnOnFlexOnlyOptionUsage(warnOnFlexOnlyOptionUsage);
+    }
+
+    /**
+     * Create a configuration buffer.
+     * @param configurationClass    The Configuration object
+     * @return          the configuration buffer to use
+     */
+    protected ConfigurationBuffer createConfigurationBuffer(
+            Class<? extends Configuration> configurationClass)
+    {
+        return new ConfigurationBuffer(
+                configurationClass, Configuration.getAliases());
+    }
+
+    /**
+     * Setup theme files.
+     */
+    protected void setupThemeFiles(FlexProject project)
+    {
+        project.setThemeFiles(toFileSpecifications(configuration.getCompilerThemeFiles(), 
+                project.getWorkspace()));
+
+    }
+
+    /**
+     * Collect all of the different library paths and set them in the project.
+     * The libraries are ordered with RSL and external libraries having the
+     * highest priority.
+     * 
+     * <p>Libraries are ordered highest to lowest priority:
+     *     <ol>
+     *     <li>External Library Path
+     *     <li>RSL Library Path
+     *     <li>Include Library Path
+     *     <li>Library Path
+     *     </ol>
+     * </p>
+     * @param project
+     * @return true if successful, false if there is an error.
+     */
+    protected boolean setupProjectLibraries(IFlexProject project)
+    {
+        LinkedHashSet<File> libraries = new LinkedHashSet<File>();
+        
+        // add External Library Path
+        List<File> externalLibraryFiles = toFileList(configuration.getCompilerExternalLibraryPath()); 
+        libraries.addAll(externalLibraryFiles);
+        
+        // add RSLs
+        libraries.addAll(configuration.getRslExcludedLibraries());
+        
+        // add Include Library Path
+        libraries.addAll(toFileList(configuration.getCompilerIncludeLibraries()));
+        
+        // add Library Path
+        libraries.addAll(toFileList(configuration.getCompilerLibraryPath()));
+        
+        project.setLibraries(new ArrayList<File>(libraries));
+        
+        // After we set the library path we can check for ANE files more
+        // accurately because the library path manager in the project
+        // will read in all the swc files found in directories on the
+        // paths.
+        return validateNoANEFiles(project, externalLibraryFiles);
+    }
+    
+    /**
+     * Validate all of the ANE files are on the external library path.
+     * 
+     * @param project the project being configured.
+     * @param externalLibraryFiles the external library path.
+     * @return true if successful, false if there is an error.
+     */
+    private boolean validateNoANEFiles(IFlexProject project, 
+            List<File>externalLibraryFiles)
+    {
+        // Get all the library files in the project.
+        List<ISWC> libraries = project.getLibraries();
+        for (ISWC library : libraries)
+        {
+            if (library.isANE())
+            {
+                // must be on the external library path
+                if (!isOnExternalLibrayPath(library, externalLibraryFiles))
+                {
+                    configurationProblems.add(
+                            new ANELibraryNotAllowedProblem(
+                                    library.getSWCFile().getAbsolutePath()));
+                    return false;
+                }
+            }
+        }
+        
+        return true;
+    }
+
+    /** 
+     * Test if the SWC is explicitly on the external library path.
+     * 
+     * @param library
+     * @param externalLibraryFiles
+     * @return true if the library is on the external library path, false otherwise.
+     */
+    private boolean isOnExternalLibrayPath(ISWC library, List<File> externalLibraryFiles)
+    {
+        File aneFile = library.getSWCFile();
+        
+        for (File file : externalLibraryFiles)
+        {
+            if (file.equals(aneFile))
+                return true;
+        }
+        
+        return false;
+    }
+
+    /**
+     * Setup {@code -compatibility-version} level. Falcon only support Flex 3+.
+     * @param project 
+     */
+    protected void setupCompatibilityVersion(FlexProject project)
+    {
+        final int compatibilityVersion = configuration.getCompilerMxmlCompatibilityVersion();
+        if (compatibilityVersion < Configuration.MXML_VERSION_3_0)
+            throw new UnsupportedOperationException("Unsupported compatibility version: " + configuration.getCompilerCompatibilityVersionString());
+        project.setCompatibilityVersion(configuration.getCompilerMxmlMajorCompatibilityVersion(),
+                configuration.getCompilerMxmlMinorCompatibilityVersion(),
+                configuration.getCompilerMxmlRevisionCompatibilityVersion());
+    }
+
+    /**
+     * Transfers configuration settings to the project. Handles:
+     *     -services
+     *     -context-root
+     * 
+     */
+    protected void setupServices(FlexProject project)
+    {
+        if (configuration.getCompilerServices() != null)
+            project.setServicesXMLPath(configuration.getCompilerServices().getPath(), configuration.getCompilerContextRoot());
+    }
+
+    /**
+     * Setup the source paths.
+     * 
+     * @return true if successful, false otherwise.
+     */
+    protected boolean setupSources(IFlexProject project)
+    {
+        // -source-path
+        List<String> sourcePath = new ArrayList<String>();
+        applySourcePathRules(sourcePath);
+        
+        project.setSourcePath(toFiles(sourcePath));
+        
+        // -include-sources
+        try
+        {
+            project.setIncludeSources(toFileList(configuration.getIncludeSources()));
+        }
+        catch (InterruptedException e)
+        {
+            assert false : "InterruptedException should never be thrown here";
+            return false;
+        }
+        
+        return true;
+    }
+
+    /**
+     * Apply the follow source-path rules:
+     * 
+     * 1. If source-path is empty, the target file's directory will be added to 
+     *    source-path.
+     * 2. If source-path is not empty and if the target file's directory is a 
+     *    sub-directory of one of the directories in source-path, source-path 
+     *    remains unchanged.
+     * 3. If source-path is not empty and if the target file's directory is not
+     *    a sub-directory of any one of the directories in source-path, the target
+     *    file's directory is prepended to source-path.
+     *  
+     * @param sourcePath the source path to apply the rules to.
+     */
+    protected void applySourcePathRules(List<String> sourcePath)
+    {
+        String targetFileDirectory = configuration.getTargetFileDirectory();
+        List<String> configuredSourcePath = configuration.getCompilerSourcePath();
+        
+        if (targetFileDirectory != null)
+        {
+            
+            // This method is called with an empty sourcePath so any additions will
+            // have the effect of prepending to the sourcePath.
+            if (configuredSourcePath.isEmpty() || 
+                (!configuredSourcePath.contains(targetFileDirectory) &&
+                 !isSubdirectoryOf(targetFileDirectory, configuredSourcePath)))
+            {
+                sourcePath.add(targetFileDirectory);
+            }
+        }
+        
+        // The configuration system provides additional source paths.
+        sourcePath.addAll(configuredSourcePath);
+    }
+    
+    /**
+     * Check whether the provided path is a subdirectory of the list of 
+     * directories and vice versa.
+     * 
+     * @param path - absolute path name of directory to test.
+     * @param directories - {@link Iterable} of directories to test.
+     * @return true if path is a subdirectory, false otherwise
+     */
+    private static boolean isSubdirectoryOf(String path, Iterable<String> directories)
+    {
+        final File pathFile = FileUtils.canonicalFile(new File(path));
+
+        for (String directoryName : directories)
+        {
+            final File dirFile = FileUtils.canonicalFile(new File(directoryName));
+            final long dirFilenameLength = dirFile.getAbsolutePath().length();
+
+            File parentFile = pathFile.getParentFile();
+            while (parentFile != null)
+            {
+                if (dirFile.equals(parentFile))
+                    return true;
+
+                // if the dirFilenameLength is greater than the parentFilename length
+                // then break out and try the next path, rather than going all the
+                // way up to the root, as it can't be a sub directory.
+                if (dirFilenameLength > parentFile.getAbsolutePath().length())
+                    break;
+
+                parentFile = parentFile.getParentFile();
+            }
+        }
+
+        return false;
+    }
+
+    protected void setupConfigVariables(IFlexProject project)
+    {
+        final Map<String, String> compilerDefine = configuration.getCompilerDefine();
+        if (compilerDefine != null)
+            project.setDefineDirectives(compilerDefine);
+    }
+
+    protected void setupNamespaces(IFlexProject project)
+    {
+        final List<? extends IMXMLNamespaceMapping> configManifestMappings =
+                configuration.getCompilerNamespacesManifestMappings();
+        if (configManifestMappings != null)
+        {
+            project.setNamespaceMappings(configManifestMappings);
+        }
+    }
+
+    /**
+     * Setups the locale related settings.
+     */
+    protected void setupLocaleSettings(IFlexProject project)
+    {
+        project.setLocales(configuration.getCompilerLocales());
+        project.setLocaleDependentResources(configuration.getLocaleDependentSources());
+    }
+    
+    public static List<RSLSettings> getRSLSettingsFromConfiguration(Configuration configuration)
+    {
+        List<RuntimeSharedLibraryPathInfo> infoList = configuration.getRslPathInfo();
+
+        if (infoList == null || infoList.size() == 0)
+        {
+            return Collections.emptyList();
+        }
+
+        boolean verifyDigests = configuration.getVerifyDigests();
+        List<RSLSettings> rslSettingsList = new ArrayList<RSLSettings>(infoList.size());
+        for (RuntimeSharedLibraryPathInfo info : infoList)
+        {
+            // For each loop, convert an RSL and its failovers into
+            // the RSLSettings class.
+            RSLSettings rslSettings = new RSLSettings(info.getSWCFile());
+            List<String> rslURLs = info.getRSLURLs();
+            List<String> policyFileURLs = info.getPolicyFileURLs();
+
+            int n = info.getRSLURLs().size();
+            for (int i = 0; i < n; i++)
+            {
+                rslSettings.addRSLURLAndPolicyFileURL(rslURLs.get(i), policyFileURLs.get(i));
+            }
+
+            rslSettings.setVerifyDigest(verifyDigests);
+            
+            String swcPath = info.getSWCFile().getPath();
+            rslSettings.setApplicationDomain(configuration.getApplicationDomain(swcPath));
+            rslSettings.setForceLoad(configuration.getForceRsls().contains(swcPath));
+            
+            // Add an RSL to the list of RSL settings.
+            rslSettingsList.add(rslSettings);
+        }
+
+        return rslSettingsList;
+    }
+
+    /**
+     * Wrapper around the real processConfiguration.
+     * 
+     * @return true if success, false otherwise.
+     */
+    protected boolean processConfiguration()
+    {
+        boolean success = true;
+        
+        if (isConfigurationDirty)
+        {
+            configurationProblems.clear();
+            
+            try
+            {
+                success = processConfiguration(getOptions(args, more, processExtras(extras)));
+            }
+            catch (ConfigurationException e)
+            {
+                reportConfigurationException(e);
+                success = false;
+            }
+        }
+        else
+        {
+            success = configurationSuccess;
+        }
+        
+        isConfigurationDirty = false;
+        configurationSuccess = success;
+        return success;
+    }
+
+    /**
+     * Does all the work to set the command line arguments info the 
+     * configuration object.
+     *  
+     * @param argsArray - command line arguments
+     * 
+     * @return true if successful, false otherwise.
+     */
+    protected boolean processConfiguration(String[] argsArray)
+    {
+        initializeConfiguration();
+        
+        boolean success = true;
+
+        try
+        {
+            loadDefaults(cfgbuf);
+
+            // TODO This is needed until we can defer
+            // the default style loading in loadDefaults().  
+            byPassConfigurationsRequiringFlexSDK();
+            
+            SystemPropertyConfigurator.load(cfgbuf, "flex");
+
+            // Parse the command line a first time, to peak at stuff like
+            // "flexlib" and "load-config".  The first parse is thrown
+            // away after that and we intentionally parse a second time
+            // below.  See note below.
+            CommandLineConfigurator.parse(cfgbuf, configurationDefaultVariable, argsArray);
+
+            overrideDefaults();
+
+            // Return if "-version" is present so the command line can print the 
+            // version.
+            if (cfgbuf.getVar("version") != null)
+                return false;
+
+            // Return so the command line can print help if "-help" is present.
+            final List<ConfigurationValue> helpVar = cfgbuf.getVar("help");
+            if (helpVar != null)
+                return false;
+            
+            // Load configurations from files.
+            if (!loadConfig())
+                success = false;
+            
+            if (!loadProjectConfig())
+                success = false;
+            
+            // The command line needs to take precedence over all defaults and config files.
+            // By simply re-merging the command line back on top,
+            // we will get the behavior we want.
+            cfgbuf.clearSourceVars(CommandLineConfigurator.source);
+            CommandLineConfigurator.parse(cfgbuf, configurationDefaultVariable, argsArray);
+
+            // commit() reports problems instead of throwing an exception. This 
+            // allows us to process all the options in a configuration that
+            // are correct in the hopes that it will be enough to configure a
+            // project.
+            if (!cfgbuf.commit(configuration, configurationProblems))
+                success = false;
+            
+            configuration.validate(cfgbuf);
+        }
+        catch (ConfigurationException e)
+        {
+            reportConfigurationException(e);
+            success = false;
+        }
+        
+        return success;
+    }
+
+    /**
+     * Load the default values into the passed in config buffer
+     * @param cfgbuf                    the config buffer to set the default values in
+     * @throws ConfigurationException
+     */
+    protected void loadDefaults (ConfigurationBuffer cfgbuf) throws ConfigurationException
+    {
+        DefaultsConfigurator.loadDefaults(cfgbuf);
+    }
+
+    /**
+     * Do the validatation that the old COMPCConfiguration used to do.
+     */
+    protected void validateSWCConfiguration() throws ConfigurationException
+    {
+        validateSWCInputs();
+        
+        // verify that if -include-inheritance-dependencies is set that
+        // -include-classes is not null
+        if (configuration.getIncludeInheritanceDependenciesOnly() &&
+            configuration.getIncludeClasses().size() == 0)
+        {
+            throw new ConfigurationException.MissingIncludeClasses();
+        }
+    }
+
+    /**
+     * Basic validation of compc options. This code used to be
+     * in the old compiler's CompcConfiguration.
+     * 
+     * @throws ConfigurationException
+     */
+    protected void validateSWCInputs() throws ConfigurationException
+    {
+        if (configuration.getIncludeSources().isEmpty() && 
+            configuration.getIncludeClasses().isEmpty() &&
+            configuration.getIncludeNamespaces().isEmpty() &&
+            ((configuration.getCompilerIncludeLibraries() == null) || 
+             (configuration.getCompilerIncludeLibraries().size() == 0)) &&
+             configuration.getIncludeFiles().isEmpty() && 
+             configuration.getIncludeResourceBundles().isEmpty())
+        {
+            throw new ConfigurationException.NoSwcInputs( null, null, -1 );
+        }
+    }
+    
+    /**
+     * By-pass the configurations that requires Flex SDK.
+     */
+    protected void byPassConfigurationsRequiringFlexSDK() throws ConfigurationException
+    {
+        if (System.getProperty("flexlib") == null &&
+            System.getProperty("application.home") == null)
+        {
+            cfgbuf.clearVar("load-config", null, -1);
+            cfgbuf.clearVar("compiler.theme", null, -1);
+        }
+        
+    }
+
+    /**
+     * Override default values.
+     */
+    protected void overrideDefaults() throws ConfigurationException
+    {
+        String flexlib = cfgbuf.getToken("flexlib");
+        if (flexlib == null)
+        {
+            final String appHome = System.getProperty("application.home");
+            if (appHome == null)
+                cfgbuf.setToken("flexlib", ".");
+            else
+                cfgbuf.setToken("flexlib", appHome + File.separator + "frameworks");
+        }
+
+        // Framework Type: halo, gumbo, interop...
+        String framework = cfgbuf.getToken("framework");
+        if (framework == null)
+            cfgbuf.setToken("framework", "halo");
+
+        String configname = cfgbuf.getToken("configname");
+        if (configname == null)
+            cfgbuf.setToken("configname", "flex");
+
+        String buildNumber = cfgbuf.getToken("build.number");
+        if (buildNumber == null)
+        {
+            if ("".equals(VersionInfo.getBuild()))
+                buildNumber = "workspace";
+            else
+                buildNumber = VersionInfo.getBuild();
+            cfgbuf.setToken("build.number", buildNumber);
+        }   
+    }
+
+    /**
+     * Load configuration XML file specified in {@code -load-config} option on
+     * command-line.
+     * 
+     * @return true if successful, false otherwise.
+     */
+    protected boolean loadConfig()
+    {
+        boolean success = true;
+        
+        List<ConfigurationValue> configs;
+        try
+        {
+            configs = cfgbuf.peekConfigurationVar("load-config");
+            if (configs != null)
+            {
+                for (ConfigurationValue cv : configs)
+                {
+                    for (String path : cv.getArgs())
+                    {
+                        File configFile = configurationPathResolver.resolve(path);
+                        if (!configFile.exists())
+                        {
+                            success = false;
+                            if (missingConfigFiles == null)
+                                missingConfigFiles = new ArrayList<String>();
+                            
+                            missingConfigFiles.add(path);
+                        }
+                        else 
+                        {
+                           if (!loadConfigFromFile(
+                                    cfgbuf,
+                                    configFile,
+                                    new File(configFile.getPath()).getParent(),
+                                    "flex-config",
+                                    false))
+                           {
+                               success = false;
+                           }
+                        }
+                    }
+                }
+            }
+        }
+        catch (ConfigurationException e)
+        {
+            reportConfigurationException(e);
+            success = false;
+        }
+
+        return success;
+    }
+
+    /**
+     * Load a configuration from file. {@code FileConfigurator.load()} is
+     * wrapped in this method because we want to print a message after loading
+     * using {@link MXMLC#println(String)}.
+     * 
+     * @return true if successful, false otherwise.
+     */
+    protected final boolean loadConfigFromFile(final ConfigurationBuffer buffer,
+                                          final File fileSpec,
+                                          final String context,
+                                          final String rootElement,
+                                          final boolean ignoreUnknownItems)
+    {
+        boolean success = true;
+        
+        try
+        {
+            FileConfigurator.load(buffer, 
+                    new FileSpecification(fileSpec.getAbsolutePath()),
+                    context, rootElement, ignoreUnknownItems);
+        }
+        catch (ConfigurationException e)
+        {
+            // record exception
+            reportConfigurationException(e);
+            success = false;
+            
+        }
+
+        if (loadedConfigFiles == null)
+            loadedConfigFiles = new ArrayList<String>();
+        
+        loadedConfigFiles.add(fileSpec.getPath());
+        
+        return success;
+    }
+
+    /**
+     * Convert conifguration exceptions to problems and collect them for 
+     * reporting.
+     * 
+     * @param e
+     */
+    protected void reportConfigurationException(ConfigurationException e)
+    {
+        final ICompilerProblem problem = new ConfigurationProblem(e);
+        configurationProblems.add(problem);
+    }
+
+    /**
+     * Load project specific configuration. The configuration XML file is at the
+     * project root with naming convention of [project name]-config.xml.
+     * 
+     * @return true if successful, false otherwise.
+     */
+    protected boolean loadProjectConfig()
+    {
+        boolean success = true;
+        
+        // Load project file, if any...
+        List<ConfigurationValue> fileValues = cfgbuf.getVar(ICompilerSettingsConstants.FILE_SPECS_VAR);
+        if ((fileValues != null) && (fileValues.size() > 0))
+        {
+            ConfigurationValue cv = fileValues.get(fileValues.size() - 1);
+            if (cv.getArgs().size() > 0)
+            {
+                String val = cv.getArgs().get(cv.getArgs().size() - 1);
+                int index = val.lastIndexOf('.');
+                if (index != -1)
+                {
+                    String project = val.substring(0, index) + "-config.xml";
+                    File projectFile = configurationPathResolver.resolve(project);
+                    if (projectFile.exists())
+                    {
+                        if (!loadConfigFromFile(
+                                cfgbuf,
+                                projectFile,
+                                new File(project).getParent(),
+                                "flex-config",
+                                false))
+                        {
+                            success = false;
+                        }
+                    }
+                }
+            }
+        }
+        
+        return success;
+    }
+    
+    //
+    // Configuration related methods
+    //
+    protected String[] getOptions(Map<String, Object> args, Map<String, Object> more, 
+            String[] extras)
+    {
+        ArrayList<String> buffer = new ArrayList<String>();
+        
+        for (Map.Entry<String, String> tokenEntry : tokens.entrySet())
+        {
+            buffer.add(PLUS_STRING + tokenEntry.getKey() + EQUALS_STRING + tokenEntry.getValue());
+        }
+        
+        for (Map.Entry<String, Object> arg : args.entrySet())
+        {
+            String key = arg.getKey();
+            Object value = arg.getValue();
+
+            if (value instanceof Boolean)
+            {
+                buffer.add(key + EQUALS_STRING + value);
+            }
+            else if (value instanceof Number)
+            {
+                buffer.add(key);
+                buffer.add(value.toString());
+            }
+            else if (COMPILER_CONTEXT_ROOT.equals(key) && value instanceof String)
+            {               
+                buffer.add(key);
+                buffer.add((String)value);
+            }
+            else if (value instanceof String)
+            {               
+                if (!"".equals(value))
+                {
+                    buffer.add(key);
+                    buffer.add((String)value);
+                }
+                else
+                {
+                    buffer.add(key + EQUALS_STRING);
+                }
+            }
+            else if (value instanceof File)
+            {
+                String p = ((File) value).getPath();
+                if (!"".equals(p))
+                {
+                    buffer.add(key);
+                    buffer.add(p);
+                }
+                else
+                {
+                    buffer.add(key + EQUALS_STRING);
+                }
+            }
+            else if (value instanceof java.util.Date)
+            {
+                buffer.add(key);
+                buffer.add(value.toString());
+            }
+            else if (value instanceof MXMLNamespaceMappingList)
+            {
+                addNamespaceMappingsToBuffer(buffer, (MXMLNamespaceMappingList)value, false);
+            }
+            else if (value instanceof RSLSettingsList)
+            {
+                addRSLSettingsToBuffer(buffer, (RSLSettingsList)value, false);
+            }
+            else if (value instanceof CompilerDefinitionMap)
+            {
+                final CompilerDefinitionMap defs = (CompilerDefinitionMap)value;
+                for (Map.Entry<String, String> entry : defs.entrySet())
+                {
+                    // String.valueOf will help turn null into "null"
+                    String name = entry.getKey();
+                    String val  = entry.getValue();
+                    
+                    // handle empty-string values
+                    
+                    // technically, name should not ever be empty length (value can be),
+                    // but we don't want to do error handling, CompilerConfiguration.cfgDefine()
+                    // will do it for us later
+                    if (name.length() == 0)
+                    {
+                        name = "\"\"";
+                    }
+                    
+                    if (val.length() == 0)
+                    {
+                        val = "\"\"";
+                    }
+                    
+                    /* note '+=': defines from all flex-config.xmls will be collected (just '=' would
+                     * always ignore all but the most recent definitions), hopefully in a meaningful
+                     * order (flex-config, user-config, commandline) since we now allow re-definitions.
+                     */
+                    buffer.add(COMPILER_DEFINE + PLUS_EQUALS_STRING + name + COMMA_STRING + val);
+                }
+            }
+            else if (value instanceof Map)
+            {
+                @SuppressWarnings("unchecked")
+                Map<String, ?> m = (Map<String, ?>) value;
+                for (Map.Entry<String, ?>entry : m.entrySet())
+                {
+                    String k = entry.getKey();
+                    Object v = entry.getValue();
+                    
+                    if (v instanceof String)
+                    {
+                        buffer.add(key);
+                        buffer.add(k);
+                        buffer.add((String)v);
+                    }
+                    else if (v instanceof File)
+                    {
+                        buffer.add(key);
+                        buffer.add(k);
+                        buffer.add(((File) v).getPath());
+                    }
+                    else if (v instanceof Collection)
+                    {
+                        buffer.add(key);
+                        buffer.add(k);
+                        Collection<?> list = (Collection<?>)v;
+                        for (Object next : list)
+                        {
+                            if (next != null)
+                                buffer.add(next.toString());
+                        }
+                    }
+                    else if (v != null)
+                    {
+                        assert false;
+                    }
+                }
+            }
+            else if (value instanceof int[])
+            {
+                int[] a = (int[]) value;
+                buffer.add(key);
+                buffer.add(String.valueOf(a[0]));
+                buffer.add(String.valueOf(a[1]));
+            }
+            else if (value instanceof Collection)
+            {
+                Collection<Object> list = new LinkedList<Object>((Collection<?>)args.get(key));
+                
+                int length = list.size();
+                if (length > 0)
+                {
+                    buffer.add(key);
+                }
+                else if (!LOAD_CONFIG.equals(key))
+                {
+                    buffer.add(key + EQUALS_STRING);
+                }
+                for (Object obj : list)
+                {
+                    if (obj instanceof String)
+                    {
+                        buffer.add((String)obj);
+                    }
+                    else if (obj instanceof File)
+                    {
+                        buffer.add(((File)obj).getPath());
+                    }
+                }
+            }
+            else if (value != null)
+            {
+                assert false;
+            }
+            else
+            {
+                // System.err.println("unprocessed compiler options: " + key + EQUALS_STRING + value);
+            }
+        }
+        
+        for (Map.Entry<String, Object> moreEntry : more.entrySet())
+        {
+            String key = moreEntry.getKey();
+            Object value = moreEntry.getValue();
+
+            if (value instanceof Collection)
+            {
+                buffer.add(key + PLUS_EQUALS_STRING + toCommaSeparatedString((Collection<?>)value));
+            }
+            else if (value instanceof Map)
+            {
+                @SuppressWarnings("unchecked")
+                Map<String, ?> m = (Map<String, ?>) value;
+                for (Map.Entry<String, ?>entry : m.entrySet())
+                {
+                    String k = entry.getKey();
+                    Object v = entry.getValue();
+                    
+                    if (v instanceof Collection)
+                    {
+                        buffer.add(key + PLUS_EQUALS_STRING + k + COMMA_STRING +
+                                toCommaSeparatedString((Collection<?>)v));
+                    }
+                    else if (v != null)
+                    {
+                        assert false;
+                    }
+                }
+            }
+            else if (value instanceof MXMLNamespaceMappingList)
+            {
+                addNamespaceMappingsToBuffer(buffer, (MXMLNamespaceMappingList)value, true);
+            }
+            else if (value instanceof RSLSettingsList)
+            {
+                addRSLSettingsToBuffer(buffer, (RSLSettingsList)value, true);
+            }
+            else if (value != null)
+            {
+                assert false;
+            }
+            else
+            {
+                // System.err.println("unprocessed compiler options: " + key + EQUALS_STRING + value);
+            }
+        }
+
+        // Append extra command line args to the buffer.
+        if (extras != null && extras.length > 0)
+        {
+            for (int i = 0, length = extras == null ? 0 : extras.length; i < length; i++)
+            {
+                if (extras[i] != null)
+                {
+                    buffer.add(extras[i]);
+                }
+            }            
+        }
+        
+        String[] options = new String[buffer.size()];
+        buffer.toArray(options);
+    
+        if (Trace.config)
+            Trace.trace("Configurator: options = " + buffer.toString());
+        
+        return options;
+    }
+
+    /**
+     * Do special case handling of extra arguments for Flash Builder. FB needs 
+     * special handling for some arguments because it sets them using the 
+     * Configurator API and they can also be entered by a user in 
+     * "additional compiler arguments". When both are entered the 
+     * "additional" arguments win. This code isn't pretty but it mimics the behavior
+     * of the old compiler.
+     * 
+     * @param extraOptions
+     * 
+     * @return new array of extra arguments to use. Returns null if
+     * extraOptions is null. 
+     * @throws ConfigurationException 
+     */
+    protected String[] processExtras(String[] extraOptions) throws ConfigurationException
+    {
+        // If the extraOptions have default variables then don't process them 
+        // because stripping out options can introduce problems parsing the
+        // options. One specific case is 
+        // "-source-path . -output comps.swc MyComboBox.mxml MyButton.mxml"
+        // This is not ambiguous. Stripping out the "output" option leaves
+        // us with -source-path . MyComboBox.mxml MyButton.mxml" which is
+        // ambiguous.
+        if (extraOptions == null || extrasRequireDefaultVariable)
+            return extraOptions;
+        
+        List<Object> newArgs = new ArrayList<Object>();
+        ConfigurationBuffer extrasBuffer = createConfigurationBuffer(configurationClass);
+
+        CommandLineConfigurator.parse(extrasBuffer, null, extraOptions);
+        
+        List<Object[]> positions = extrasBuffer.getPositions();
+        for (int i = 0, length = positions.size(); i < length; i++)
+        {
+            Object[] a = positions.get(i);
+            String var = (String) a[0];
+            
+            if ("link-report".equals(var))
+            {
+                keepLinkReport(true);
+            }
+            else if ("compiler.debug".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    String debugPassword = extrasBuffer.peekSimpleConfigurationVar("debug-password");
+                    if ("true".equals(value))
+                    {
+                        enableDebugging(true, debugPassword);
+                    }
+                    else if ("false".equals(value))
+                    {
+                        enableDebugging(false, debugPassword);
+                    }
+                }
+                catch (ConfigurationException ex)
+                {
+                }
+            }
+            else if ("compiler.verbose-stacktraces".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    if ("true".equals(value))
+                    {
+                        enableVerboseStacktraces(true);
+                    }
+                    else if ("false".equals(value))
+                    {
+                        enableVerboseStacktraces(false);
+                    }
+                }
+                catch (ConfigurationException ex)
+                {
+                }                           
+            }
+            else if ("compiler.accessible".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    if ("true".equals(value))
+                    {
+                        enableAccessibility(true);
+                    }
+                    else if ("false".equals(value))
+                    {
+                        enableAccessibility(false);
+                    }
+                }
+                catch (ConfigurationException ex)
+                {
+                }
+            }
+            else if ("compiler.strict".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    if ("true".equals(value))
+                    {
+                        enableStrictChecking(true);
+                    }
+                    else if ("false".equals(value))
+                    {
+                        enableStrictChecking(false);
+                    }
+                }
+                catch (ConfigurationException ex)
+                {
+                }
+            }
+            else if ("output".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    setOutput(new File(value));
+                }
+                catch (ConfigurationException ex)
+                {
+                }
+            }
+            else if ("size-report".equals(var))
+            {
+                keepSizeReport(true);
+            }
+            else if ("warnings".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    if ("true".equals(value))
+                    {
+                        showActionScriptWarnings(true);
+                        showBindingWarnings(true);
+                        showDeprecationWarnings(true);
+                        showUnusedTypeSelectorWarnings(true);
+                    }
+                    else if ("false".equals(value))
+                    {
+                        showActionScriptWarnings(false);
+                        showBindingWarnings(false);
+                        showDeprecationWarnings(false);
+                        showUnusedTypeSelectorWarnings(false);
+                    }
+                }
+                catch (ConfigurationException ex)
+                {
+                }
+            }
+            else if ("compiler.show-actionscript-warnings".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    if ("true".equals(value))
+                    {
+                        showActionScriptWarnings(true);
+                    }
+                    else if ("false".equals(value))
+                    {
+                        showActionScriptWarnings(false);
+                    }
+                }
+                catch (ConfigurationException ex)
+                {
+                }
+            }
+            else if ("compiler.show-deprecation-warnings".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    if ("true".equals(value))
+                    {
+                        showDeprecationWarnings(true);
+                    }
+                    else if ("false".equals(value))
+                    {
+                        showDeprecationWarnings(false);
+                    }
+                }
+                catch (ConfigurationException ex)
+                {
+                }
+            }
+            else if ("compiler.show-binding-warnings".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    if ("true".equals(value))
+                    {
+                        showBindingWarnings(true);
+                    }
+                    else if ("false".equals(value))
+                    {
+                        showBindingWarnings(false);
+                    }
+                }
+                catch (ConfigurationException ex)
+                {
+                }
+            }
+            else if ("compiler.show-unused-type-selector-warnings".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    if ("true".equals(value))
+                    {
+                        showUnusedTypeSelectorWarnings(true);
+                    }
+                    else if ("false".equals(value))
+                    {
+                        showUnusedTypeSelectorWarnings(false);
+                    }
+                }
+                catch (ConfigurationException ex)
+                {
+                }
+            }
+            else if ("compiler.show-multiple-definition-warnings".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    if ("true".equals(value))
+                    {
+                        showMultipleDefinitionWarnings(true);
+                    }
+                    else if ("false".equals(value))
+                    {
+                        showMultipleDefinitionWarnings(false);
+                    }
+                }
+                catch (ConfigurationException ex)
+                {
+                }
+            }
+            else if ("flex".equals(var))
+            {
+                try
+                {
+                    String value = extrasBuffer.peekSimpleConfigurationVar(var);
+                    if ("true".equals(value))
+                    {
+                        setFlex(true);
+                    }
+                    else if ("false".equals(value))
+                    {
+                        setFlex(false);
+                    }
+                }
+                catch (ConfigurationException ex)
+                {
+                }
+            }
+            if (!excludes.contains(var))
+            {
+                // keep this variable
+                int iStart = ((Integer) a[1]).intValue();
+                int iEnd = ((Integer) a[2]).intValue();
+                for (int j = iStart; j < iEnd; j++)
+                {
+                    newArgs.add(extraOptions[j]);
+                }
+            }
+        }
+
+        extraOptions = new String[newArgs.size()];
+        newArgs.toArray(extraOptions);
+        return extraOptions;
+    }
+
+    /**
+     * Add namespace mappings to the command line buffer.
+     * 
+     * @param buffer
+     * @param valueList
+     * @param append true to use append the command in the buffer, otherwise set the command.
+     */
+    private void addNamespaceMappingsToBuffer(ArrayList<String> buffer, MXMLNamespaceMappingList valueList, 
+            boolean append)
+    {
+        if (valueList.isEmpty())
+        {
+            StringBuilder sb = new StringBuilder(COMPILER_NAMESPACES_NAMESPACE);
+            sb.append(append ? PLUS_EQUALS_STRING : EQUALS_STRING);            
+            buffer.add(sb.toString());
+            return;
+        }
+        
+        for (IMXMLNamespaceMapping value : valueList) 
+        {
+            StringBuilder sb = new StringBuilder(COMPILER_NAMESPACES_NAMESPACE);
+            sb.append(append ? PLUS_EQUALS_STRING : EQUALS_STRING);
+            sb.append(value.getURI());
+            sb.append(COMMA_STRING);
+            sb.append(value.getManifestFileName());
+            
+            buffer.add(sb.toString());
+        }
+        
+        
+    }
+
+    /**
+     * Append RSLSettings to the command line buffer.
+     * 
+     * @param buffer
+     * @param value
+     * @param append true if the values should be appended to existing RSL settings ("+="), false
+     * for override existing RSL settings ("=").
+     */
+    private void addRSLSettingsToBuffer(ArrayList<String> buffer, RSLSettingsList valueList, 
+            boolean append)
+    {
+        // if the list is empty, override any config files.
+        if (valueList.isEmpty())
+        {
+            StringBuilder sb = new StringBuilder(RUNTIME_SHARED_LIBRARY_PATH);
+            sb.append(append ? PLUS_EQUALS_STRING : EQUALS_STRING);
+            buffer.add(sb.toString());
+            return;
+        }
+        
+        // runtime-shared-library-path=path-element,rsl-url,policy-file-url,...
+        for (RSLSettings settings : valueList) 
+        {
+            StringBuilder sb = new StringBuilder(RUNTIME_SHARED_LIBRARY_PATH);
+            sb.append(append ? PLUS_EQUALS_STRING : EQUALS_STRING);
+            
+            sb.append(settings.getLibraryFile().getPath());
+            for (RSLAndPolicyFileURLPair urls : settings.getRSLURLs())
+            {
+                sb.append(COMMA_STRING);
+                sb.append(urls.getRSLURL());
+                sb.append(COMMA_STRING);
+                sb.append(urls.getPolicyFileURL());
+            }
+
+            buffer.add(sb.toString());
+            
+            // application-domain=path-element,application-domain-target
+            if (settings.getApplicationDomain() != ApplicationDomainTarget.DEFAULT)
+            {
+                sb = new StringBuilder(RUNTIME_SHARED_LIBRARY_SETTINGS_APPLICATION_DOMAIN);
+                sb.append(append ? PLUS_EQUALS_STRING : EQUALS_STRING);
+                sb.append(settings.getLibraryFile().getPath());
+                sb.append(COMMA_STRING);
+                sb.append(settings.getApplicationDomain().getApplicationDomainValue());                
+
+                buffer.add(sb.toString());
+            }
+
+            // force-rsls=path-element
+            if (settings.isForceLoad())
+            {
+                sb = new StringBuilder(RUNTIME_SHARED_LIBRARY_SETTINGS_FORCE_RSLS);
+                sb.append(append ? PLUS_EQUALS_STRING : EQUALS_STRING);
+                sb.append(settings.getLibraryFile().getPath());
+
+                buffer.add(sb.toString());                
+            }
+        }
+        
+    }
+
+    /**
+     * Enables accessibility in the application.
+     * This is equivalent to using <code>mxmlc/compc --compiler.accessible</code>.<p>
+     * By default, this is disabled.
+     * 
+     * @param b boolean value
+     */
+    @Override
+    public void enableAccessibility(boolean b)
+    {
+        args.put(COMPILER_ACCESSIBLE, b ? Boolean.TRUE : Boolean.FALSE);
+
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Sets the ActionScript file encoding. The compiler will use this encoding to read
+     * the ActionScript source files.
+     * This is equivalent to using <code>mxmlc/compc --compiler.actionscript-file-encoding</code>.<p>
+     * By default, the encoding is <code>UTF-8</code>.
+     * 
+     * @param encoding charactere encoding, e.g. <code>UTF-8</code>, <code>Big5</code>
+     */
+    @Override
+    public void setActionScriptFileEncoding(String encoding)
+    {
+        args.put(COMPILER_ACTIONSCRIPT_FILE_ENCODING, encoding);
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Allows some source path directories to be subdirectories of the other.
+     * This is equivalent to using <code>mxmlc/compc --compiler.allow-source-path-overlap</code>.<p>
+     * By default, this is disabled.<p>
+     * 
+     * In some J2EE settings, directory overlapping should be allowed. For example,
+     * 
+     * <pre>
+     * wwwroot/MyAppRoot
+     * wwwroot/WEB-INF/flex/source_path1
+     * </pre>
+     * 
+     * @param b boolean value
+     */
+    @Override
+    public void allowSourcePathOverlap(boolean b)
+    {
+        args.put(COMPILER_ALLOW_SOURCE_PATH_OVERLAP, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Sets the context root path so that the compiler can replace <code>{context.root}</code> tokens for
+     * service channel endpoints. This is equivalent to using the <code>compiler.context-root</code> option
+     * for the mxmlc or compc compilers.
+     * 
+     * <p>
+     * By default, this value is undefined.
+     * 
+     * @param path An instance of String.
+     */
+    @Override
+    public void setContextRoot(String path)
+    {
+        args.put(COMPILER_CONTEXT_ROOT, path);
+        
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Enables debugging in the application.
+     * This is equivalent to using <code>mxmlc/compc --compiler.debug</code> and <code>--debug-password</code>.<p>
+     * By default, debug is <code>false</code> and the debug password is "".
+     * 
+     * @param b boolean value
+     * @param debugPassword a password that is embedded in the application.
+     */
+    @Override
+    public void enableDebugging(boolean b, String debugPassword)
+    {
+        args.put(COMPILER_DEBUG, b ? Boolean.TRUE : Boolean.FALSE);
+        args.put(DEBUG_PASSWORD, debugPassword);
+        
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Enable or disable runtime shared libraries in the application.
+     * 
+     * This is equivalent to using <code>mxmlc --static-link-runtime-shared-libraries</code>.<p>
+     * 
+     * @param b boolean value
+     */
+    public void setStaticLinkRuntimeSharedLibraries(boolean b)
+    {
+        args.put(STATIC_LINK_RUNTIME_SHARED_LIBRARIES, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Sets the location of the default CSS file.
+     * This is equivalent to using <code>mxmlc/compc --compiler.defaults-css-url</code>.
+     * 
+     * @param url an instance of <code>java.io.File</code>.
+     */
+    public void setDefaultCSS(File url)
+    {
+        args.put(COMPILER_DEFAULTS_CSS_URL, url);
+
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Sets the list of SWC files or directories to compile against but to omit from linking.
+     * This is equivalent to using <code>mxmlc/compc --compiler.external-library-path</code>.
+     * 
+     * @param paths <code>File.isDirectory()</code> should return <code>true</code> or <code>File</code> instances should represent SWC files.
+     */
+    @Override
+    public void setExternalLibraryPath(Collection<File> paths)
+    {
+        args.put(COMPILER_EXTERNAL_LIBRARY_PATH, paths);
+        more.remove(COMPILER_EXTERNAL_LIBRARY_PATH);
+
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Adds to the existing list of SWC files.
+     * 
+     * @see #setExternalLibraryPath
+     * @param paths <code>File.isDirectory()</code> should return <code>true</code> or <code>File</code> instances should represent SWC files.
+     */
+    @Override
+    public void addExternalLibraryPath(Collection<File> paths)
+    {
+        addFiles(COMPILER_EXTERNAL_LIBRARY_PATH, paths);
+
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Sets the AS3 metadata the compiler should keep in the SWF.
+     * This is equivalent to using <code>mxmlc --compiler.keep-as3-metadata</code>.
+     * 
+     * <p>
+     * The default value is <code>{Bindable, Managed, ChangeEvent, NonCommittingChangeEvent, Transient}</code>.
+     * 
+     * @param md an array of AS3 metadata names
+     */
+    public void setASMetadataNames(String[] md)
+    {
+        args.put(COMPILER_KEEP_AS3_METADATA, md);
+        more.remove(COMPILER_KEEP_AS3_METADATA);
+
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Adds the list of AS3 metadata names to the existing list of AS3 metadata the compiler should
+     * keep in the SWF.
+     * 
+     * @param md an array of AS3 metadata names
+     */
+    public void addASMetadataNames(Collection<String> md)
+    {
+        addStrings(COMPILER_KEEP_AS3_METADATA, md);
+
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Disables the pruning of unused type selectors.
+     * This is equivalent to using <code>mxmlc/compc --compiler.keep-all-type-selectors</code>.
+     * By default, it is set to <code>false</code>.
+     * 
+     * @param b boolean value
+     */
+    public void keepAllTypeSelectors(boolean b)
+    {
+        args.put(COMPILER_KEEP_ALL_TYPE_SELECTORS, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+}
+    
+    /**
+     * Instructs the linker to keep a report of the content that is included in the application.
+     * Callers may use <code>Report.writeLinkReport()</code> to retrieve the linker report.
+     * 
+     * @param b boolean value
+     */
+    public void keepLinkReport(boolean b)
+    {
+        keepLinkReport = b;
+        
+        isConfigurationDirty = true;
+    }
+    
+    public boolean keepLinkReport()
+    {
+        return keepLinkReport;
+    }
+    
+    /**
+     * Instructs the linker to keep a SWF size report.
+     * Callers may use <code>Report.writeSizeReport()</code> to retrieve the size report.
+     * 
+     * @param b boolean value
+     */
+    public void keepSizeReport(boolean b)
+    {
+        keepSizeReport = b;
+        
+        isConfigurationDirty = true;
+    }
+    
+    public boolean keepSizeReport()
+    {
+        return keepSizeReport;
+    }
+    
+    /**
+     * Instructs the compiler to keep a report of the compiler configuration settings.
+     * Callers may use <code>Report.writeConfigurationReport()</code> to retrieve the configuration report.
+     * 
+     * @param b boolean value
+     */
+    public void keepConfigurationReport(boolean b)
+    {
+        keepConfigurationReport = b;
+        
+        isConfigurationDirty = true;
+    }
+    
+    public boolean keepConfigurationReport()
+    {
+        return keepConfigurationReport;
+    }
+
+
+    /**
+     * Instructs the compiler to report missing Libraries as a configuration error.
+     * 
+     * @param b boolean value
+     */
+    public void reportMissingsLibraries(boolean b)
+    {
+        reportMissingLibraries = b;
+
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Controls if the compiler warns when "Flex only" configuration options 
+     * are used in the compiler.
+     * 
+     * @param value True to enable warnings, false to disable warnings. The
+     * default is to not warn.
+     */
+    public void setWarnOnFlexOnlyOptionUsage(boolean value)
+    {
+        this.warnOnFlexOnlyOptionUsage = value;
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Includes a list of libraries (SWCs) to completely include in the application
+     * This is equivalent to using <code>mxmlc/compc --compiler.include-libraries</code>.
+     * 
+     * @param libraries a collection of <code>java.io.File</code> (<code>File.isDirectory()</code> should return <code>true</code> or instances must represent SWC files).
+     */
+    @Override
+    public void setIncludeLibraries(Collection<File> libraries)
+    {
+        args.put(COMPILER_INCLUDE_LIBRARIES, libraries);
+        
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Sets a list of resource bundles to include in the swf.
+     * This is equivalent to using <code>mxmlc/compc --include-resource-bundle</code>.
+     * 
+     * @param bundles an array of <code>java.lang.String</code>
+    */
+    @Override
+    public void setIncludeResourceBundles(Collection<String> bundles)
+    {
+        args.put(INCLUDE_RESOURCE_BUNDLES, bundles);        
+        
+        isConfigurationDirty = true;
+    }   
+
+    /**
+     * Adds a list of resource bundles to the existing list.
+     * 
+     * @see #setIncludeResourceBundles
+     * @param bundles an array of <code>java.lang.String</code>
+     */
+    public void addIncludeResourceBundles(Collection<String> bundles)
+    {
+        addStrings(INCLUDE_RESOURCE_BUNDLES, bundles);
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Sets a list of SWC files or directories that contain SWC files.
+     * This is equivalent to using <code>mxmlc/compc --compiler.library-path</code>.
+     * 
+     * @param paths an array of <code>File</code>. <code>File.isDirectory()</code> should return <code>true</code> or instances must represent SWC files.
+     */
+    @Override
+    public void setLibraryPath(Collection<File> paths)
+    {
+        args.put(COMPILER_LIBRARY_PATH, paths);
+        more.remove(COMPILER_LIBRARY_PATH);
+        
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Adds a list of SWC files or directories to the default library path.
+     * 
+     * @param paths an array of <code>File</code>. <code>File.isDirectory()</code> should return <code>true</code> or instances must represent SWC files.
+     * @see #setLibraryPath
+     */
+    public void addLibraryPath(Collection<File> paths)
+    {
+        addFiles(COMPILER_LIBRARY_PATH, paths);
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Sets the locales that the compiler would use to replace <code>{locale}</code> tokens that appear in some configuration values.
+     * This is equivalent to using <code>mxmlc/compc --compiler.locale</code>.
+     * For example,
+     * 
+     * <pre>
+     * addSourcePath(new File[] { "locale/{locale}" });
+     * addLocale(new String[] { "en_US" });
+     * </pre>
+     * 
+     * The <code>locale/en_US</code> directory will be added to the source path.
+     * @since 3.0
+     */
+    public void setLocale(String[] locales)
+    {
+        args.put(COMPILER_LOCALE, locales);
+        
+        isConfigurationDirty = true;
+    }
+    
+    @Override
+    public void setNamespaceMappings(List<? extends IMXMLNamespaceMapping> namespaceMappings)
+    {
+        args.put(COMPILER_NAMESPACES_NAMESPACE, 
+                namespaceMappings != null ? new MXMLNamespaceMappingList(namespaceMappings) : null);
+        more.remove(COMPILER_NAMESPACES_NAMESPACE);
+        
+        isConfigurationDirty = true;
+    }
+
+    @Override
+    public void addNamespaceMappings(Collection<IMXMLNamespaceMapping> namespaceMappings)
+    {
+        MXMLNamespaceMappingList currentSettings = (MXMLNamespaceMappingList)more.get(COMPILER_NAMESPACES_NAMESPACE);
+        if (currentSettings == null)
+            currentSettings = new MXMLNamespaceMappingList(namespaceMappings.size());
+        
+        currentSettings.addAll(namespaceMappings);
+
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Enables post-link optimization. This is equivalent to using <code>mxmlc/compc --compiler.optimize</code>.
+     * Application sizes are usually smaller with this option enabled.
+     * By default, it is set to <code>true</code>.
+     * 
+     * @param b boolean value
+     */
+    @Override
+    public void optimize(boolean b)
+    {
+        args.put(COMPILER_OPTIMIZE, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+    
+    @Override
+    public void compress(boolean b)
+    {
+        args.put(COMPILER_COMPRESS, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+
+    @Override
+    public void setServicesXMLPath(String path, String contextRoot)
+    {
+        if (path == null || contextRoot == null)
+            throw new NullPointerException("path and contenxtRoot may not be null.");
+        
+        args.put(COMPILER_SERVICES, new ServicesContextRoot(path, contextRoot));
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Runs the ActionScript compiler in a mode that detects legal but potentially incorrect code.
+     * This is equivalent to using <code>mxmlc/compc --compiler.show-actionscript-warnings</code>.
+     * By default, it is set to <code>true</code>.
+     * 
+     * @param b boolean value
+     * @see #checkActionScriptWarning(int, boolean)
+     */
+    @Override
+    public void showActionScriptWarnings(boolean b)
+    {
+        args.put(COMPILER_SHOW_ACTIONSCRIPT_WARNINGS, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Toggles whether warnings generated from data binding code are displayed.
+     * This is equivalent to using <code>mxmlc/compc --compiler.show-binding-warnings</code>.
+     * By default, it is set to <code>true</code>.
+     * 
+     * @param b boolean value
+     */
+    @Override
+    public void showBindingWarnings(boolean b)
+    {
+        args.put(COMPILER_SHOW_BINDING_WARNINGS, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Toggles whether the use of deprecated APIs generates a warning.
+     * This is equivalent to using <code>mxmlc/compc --compiler.show-deprecation-warnings</code>.
+     * By default, it is set to <code>true</code>.
+     * 
+     * @param b boolean value
+     */
+    @Override
+    public void showDeprecationWarnings(boolean b)
+    {
+        args.put(COMPILER_SHOW_DEPRECATION_WARNINGS, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Toggles whether warnings generated from unused type selectors are displayed.
+     * This is equivalent to using <code>mxmlc/compc --compiler.show-unused-type-selector-warnings</code>.
+     * By default, it is set to <code>true</code>.
+     * 
+     * @param b boolean value
+     */
+    @Override
+    public void showUnusedTypeSelectorWarnings(boolean b)
+    {
+        args.put(COMPILER_SHOW_UNUSED_TYPE_SELECTOR_WARNINGS, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+    
+
+    @Override
+    public void showMultipleDefinitionWarnings(boolean b)
+    {
+        args.put(COMPILER_SHOW_MULTIPLE_DEFINITION_WARNINGS, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+    
+
+    /**
+     * Sets a list of path elements that form the roots of ActionScript class hierarchies.
+     * This is equivalent to using <code>mxmlc/compc --compiler.source-path</code>.
+     * 
+     * @param paths an array of <code>java.io.File</code> (<code>File.isDirectory()</code> must return <code>true</code>).
+     */
+    @Override
+    public void setSourcePath(List<File> paths)
+    {
+        args.put(COMPILER_SOURCE_PATH, paths);
+        more.remove(COMPILER_SOURCE_PATH);
+        
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Adds a list of path elements to the existing source path list.
+     * 
+     * @param paths an array of <code>java.io.File</code> (<code>File.isDirectory()</code> must return <code>true</code>).
+     * @see #setSourcePath
+     */
+    @Override
+    public void addSourcePath(Collection<File> paths)
+    {
+        addFiles(COMPILER_SOURCE_PATH, paths);
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Runs the ActionScript compiler in strict error checking mode.
+     * This is equivalent to using <code>mxmlc/compc --compiler.strict</code>.
+     * By default, it is set to <code>true</code>.
+     * 
+     * @param b boolean value
+     */
+    @Override
+    public void enableStrictChecking(boolean b)
+    {
+        args.put(COMPILER_STRICT, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Sets a list of CSS or SWC files to apply as a theme.
+     * This is equivalent to using <code>mxmlc/compc --compiler.theme</code>.
+     * 
+     * @param files an array of <code>java.io.File</code>
+     */
+    @Override
+    public void setTheme(List<File> files)
+    {
+        args.put(COMPILER_THEME, files);
+        more.remove(COMPILER_THEME);
+        
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Adds a list of CSS or SWC files to the existing list of theme files.
+     * 
+     * @param files an array of <code>java.io.File</code>
+     * @see #setTheme
+     */
+    @Override
+    public void addTheme(List<File> files)
+    {
+        addFiles(COMPILER_THEME, files);
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Determines whether resources bundles are included in the application.
+     * This is equivalent to using <code>mxmlc/compc --compiler.use-resource-bundle-metadata</code>.
+     * By default, it is set to <code>true</code>.
+     * 
+     * @param b boolean value
+     */
+    @Override
+    public void useResourceBundleMetaData(boolean b)
+    {
+        args.put(COMPILER_USE_RESOURCE_BUNDLE_METADATA, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Generates bytecodes that include line numbers. When a run-time error occurs,
+     * the stacktrace shows these line numbers. Enabling this option generates larger SWF files.
+     * This is equivalent to using <code>mxmlc/compc --compiler.verbose-stacktraces</code>.
+     * By default, it is set to <code>false</code>.
+     * 
+     * @param b boolean value
+     */
+    public void enableVerboseStacktraces(boolean b)
+    {
+        args.put(COMPILER_VERBOSE_STACKTRACES, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+
+    /**
+     * Enables the removal of RSLs associated with libraries
+     * that are not used by an application.
+     * This is equivalent to using the
+     * <code>remove-unused-rsls</code> option of the mxmlc compiler.
+     * 
+     * <p>
+     * The default value is <code>false</code>.
+     * 
+     * @param b Boolean value that enables or disables the removal.
+     *    
+     * @since 4.5
+     */
+    @Override
+    public void removeUnusedRuntimeSharedLibraryPaths(boolean b)
+    {
+        args.put(REMOVE_UNUSED_RSLS, b ? Boolean.TRUE : Boolean.FALSE);
+        
+        isConfigurationDirty = true;
+    }
+    
+    /**
+     * Enables checking of ActionScript warnings. They are:
+     * 
+     * <pre>
+     * --compiler.warn-array-tostring-changes
+     * --compiler.warn-assignment-within-conditional
+     * --compiler.warn-bad-array-cast
+     * --compiler.warn-bad-bool-assignment
+     * --compiler.warn-bad-date-cast
+     * --compiler.warn-bad-es3-type-method
+     * --compiler.warn-bad-es3-type-prop
+     * --compiler.warn-bad-nan-comparison
+     * --compiler.warn-bad-null-assignment
+     * --compiler.warn-bad-null-comparison
+     * --compiler.warn-bad-undefined-comparison
+     * --compiler.warn-boolean-constructor-with-no-args
+     * --compiler.warn-changes-in-resolve
+     * --compiler.warn-class-is-sealed
+     * --compiler.warn-const-not-initialized
+     * --compiler.warn-constructor-returns-value
+     * --compiler.warn-deprecated-event-handler-error
+     * --compiler.warn-deprecated-function-error
+     * --compiler.warn-deprecated-property-error
+     * --compiler.warn-duplicate-argument-names
+     * --compiler.warn-duplicate-variable-def
+     * --compiler.warn-for-var-in-changes
+     * --compiler.warn-import-hides-class
+     * --compiler.warn-instance-of-changes
+     * --compiler.warn-internal-error
+     * --compiler.warn-level-not-supported
+     * --compiler.warn-missing-namespace-decl
+     * --compiler.warn-negative-uint-literal
+     * --compiler.warn-no-constructor
+     * --compiler.warn-no-explicit-super-call-in-constructor
+     * --compiler.warn-no-type-decl
+     * --compiler.warn-number-from-string-changes
+     * --compiler.warn-scoping-change-in-this
+     * --compiler.warn-slow-text-field-addition
+     * --compiler.warn-unlikely-function-value
+     * --compiler.warn-xml-class-has-changed
+     * </pre>
+     * 
+     * @param warningCode warning code
+     * @param b boolean value
+     * @see #WARN_ARRAY_TO_STRING_CHANGES
+     * @see #WARN_ASSIGNMENT_WITHIN_CONDITIONAL
+     * @see #WARN_BAD_ARRAY_CAST
+     * @see #WARN_BAD_BOOLEAN_ASSIGNMENT
+     * @see #WARN_BAD_DATE_CAST
+     * @see #WARN_BAD_ES3_TYPE_METHOD
+     * @see #WARN_BAD_ES3_TYPE_PROP
+     * @see #WARN_BAD_NAN_COMPARISON
+     * @see #WARN_BAD_NULL_ASSIGNMENT
+     * @see #WARN_BAD_NULL_COMPARISON
+     * @see #WARN_BAD_UNDEFINED_COMPARISON
+     * @see #WARN_BOOLEAN_CONSTRUCTOR_WITH_NO_ARGS
+     * @see #WARN_CHANGES_IN_RESOLVE
+     * @see #WARN_CLASS_IS_SEALED


<TRUNCATED>

Mime
View raw message