flex-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aha...@apache.org
Subject [18/26] fork a bunch of files from SDK's FB compiler integration. Several files are intact, but many have been gutted to reduce the number of files required. It appears that the Report isn't used for basic compilation, so removing all of the compilatio
Date Sun, 06 Apr 2014 05:39:40 GMT
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/dff3a518/flex-compiler-oem/src/flex2/compiler/common/CompilerConfiguration.java
----------------------------------------------------------------------
diff --git a/flex-compiler-oem/src/flex2/compiler/common/CompilerConfiguration.java b/flex-compiler-oem/src/flex2/compiler/common/CompilerConfiguration.java
new file mode 100644
index 0000000..ba7411c
--- /dev/null
+++ b/flex-compiler-oem/src/flex2/compiler/common/CompilerConfiguration.java
@@ -0,0 +1,3293 @@
+/*
+ *
+ *  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 flex2.compiler.common;
+
+import flex2.compiler.config.ServicesDependenciesWrapper;
+import flex2.compiler.io.LocalFile;
+import flex2.compiler.io.VirtualFile;
+import flex2.compiler.as3.As3Configuration;
+import flex2.compiler.config.AdvancedConfigurationInfo;
+import flex2.compiler.config.ConfigurationException;
+import flex2.compiler.config.ConfigurationValue;
+import flex2.compiler.config.ConfigurationInfo;
+import flex2.compiler.extensions.ExtensionsConfiguration;
+import flex2.compiler.mxml.lang.StandardDefs;
+import macromedia.asc.embedding.ConfigVar;
+import macromedia.asc.util.ObjectList;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
+/**
+ * This class defines the compiler related configuration options.  All
+ * of these options have an optional prefix of "compiler", as long as
+ * the option can be resolved unambiguously.  For example,
+ * "-compiler.debug", can be abbreviated to "-debug".
+ *
+ * @author Roger Gonzalez
+ */
+public class CompilerConfiguration implements As3Configuration,
+                                              flex2.compiler.mxml.MxmlConfiguration, Cloneable
+{
+	// ATTENTION: Please set default values in DefaultsConfigurator.
+
+	public static final String LOCALE_TOKEN = "{locale}";
+    public static final String TARGET_PLAYER_MAJOR_VERSION_TOKEN = "{targetPlayerMajorVersion}";
+    public static final String TARGET_PLAYER_MINOR_VERSION_TOKEN = "{targetPlayerMinorVersion}";
+ 
+    // Special Case for Apache.  These are not currently exposed with command line options.
+    public static final String PLAYERGLOBAL_HOME_TOKEN = "{playerglobalHome}";
+    public static final String AIR_HOME_TOKEN = "{airHome}";
+    
+    // this is passed as the list of soft prerequisites for options like
+    // library-path, source-path which need to have {locale}, etc., set already
+    private static final String[] PATH_TOKENS = {
+        "locale", // compiler.locale
+        // Jono: "target-player" -- target-player is one level 'above' compiler.*
+        // which, I hope, means that it's guaranteed to be committed already
+    };
+    
+    public static final String STRICT = "compiler.strict";
+	public static final String AS3 = "compiler.as3";
+	public static final String ES = "compiler.es";
+    
+    private final Configuration parentConfiguration;
+
+	public CompilerConfiguration(Configuration parentConfiguration)
+	{
+        assert parentConfiguration != null;
+        this.parentConfiguration = parentConfiguration;
+        
+		namespaces = new NamespacesConfiguration();
+        fontsConfig = new FontsConfiguration();
+		fontsConfig.setCompilerConfiguration(this);
+		mxmlConfig = new MxmlConfiguration();
+		extensionsConfig = new ExtensionsConfiguration();
+	}
+
+    /**
+     * Generate SWFs for debugging.
+     */
+    private ConfigurationPathResolver configResolver;
+
+    public void setConfigPathResolver( ConfigurationPathResolver resolver )
+    {
+        this.configResolver = resolver;
+        this.fontsConfig.setConfigPathResolver(configResolver);
+        this.namespaces.setConfigPathResolver(configResolver);
+        this.mxmlConfig.setConfigPathResolver(configResolver);
+        this.extensionsConfig.setConfigPathResolver(configResolver);
+    }
+
+    /**
+     * Fast utility method to merge arrays.
+     */
+    public static <T> Object[] merge( Object[] a, Object[] b, Class<T> klass)
+    {
+        if(a == null) return b;
+        if(b == null) return a;
+
+        Object[] arrrrray = (Object[]) Array.newInstance(klass, (a.length + b.length));
+        System.arraycopy(a, 0, arrrrray, 0, a.length);
+        System.arraycopy(b, 0, arrrrray, a.length, b.length);
+
+        return arrrrray;
+    }
+    
+    /**
+     * All path-tokens get expanded from this method, e.g. {locale} and {targetPlayerMajorVersion}
+     */
+    public VirtualFile[] expandTokens(String[] pathlist, String[] locales, ConfigurationValue cv)
+        throws ConfigurationException
+    {
+        // {playerglobalHome} and {airHome}
+        pathlist = expandRuntimeTokens(pathlist);
+        
+        // {targetPlayerMajorVersion}, {targetPlayerMinorVersion}
+        pathlist = expandTargetPlayerToken(pathlist, parentConfiguration);
+        
+        // {locale}
+        return expandLocaleToken(pathlist, locales, cv);
+    }
+
+    /**
+     * Replaces instances of {targetPlayerMajorVersion} and {targetPlayerMinorVersion} 
+     * with configuration. Doesn't turn the paths into VirtualFiles (yet, 
+     * @see expandLocaleToken()). 
+     */
+    private static String[] expandTargetPlayerToken(String[] pathlist, Configuration configuration)
+    {
+        final String[] processed = new String[pathlist.length];
+        
+        final String targetPlayerMajorVersion
+            = String.valueOf(configuration.getTargetPlayerMajorVersion());
+        
+        final String targetPlayerMinorVersion
+            = String.valueOf(configuration.getTargetPlayerMinorVersion());
+        
+        for (int i = 0; i < pathlist.length; i++)
+        {
+            processed[i] = pathlist[i].replace(
+                TARGET_PLAYER_MAJOR_VERSION_TOKEN, targetPlayerMajorVersion);
+            processed[i] = processed[i].replace(
+            	TARGET_PLAYER_MINOR_VERSION_TOKEN, targetPlayerMinorVersion);
+        }
+
+        return processed;
+    }
+      
+    /**
+     * Load the env.properties file from the classpath.
+     
+     * @return null if env.properties does not exist in classpath or could not be loaded
+     */
+    private Properties loadEnvPropertyFile()
+    {
+        Properties properties = null;
+        InputStream in = null;
+         
+        try 
+        {
+            in = getClass().getClassLoader().getResourceAsStream("env.properties");
+            if (in == null)
+               return null;
+            
+            properties = new Properties();
+            properties.load(in);
+            in.close();
+        } 
+        catch (Exception e) 
+        {
+        }
+        
+        return properties;
+    }
+
+    /**
+     * Replaces instances of {playerglobalHome} and {airHome}.
+     * Values can come from either ../env.properties (relative to jar file) or
+     * environment variables. The property file values have precedence.
+     * The pairs are env.PLAYERGLOBAL_HOME and PLAYERGLOBAL_HOME, and,
+     * env.AIR_HOME and AIR_HOME.
+     */
+    private String[] expandRuntimeTokens(String[] pathlist)
+    {
+        final String[] processed = new String[pathlist.length];
+           
+        // Look at property file first, if it exists, and see if the particular property
+        // is defined.  If not found, then look for the environment variable.
+        // If there is neither leave the token in place since it is easier to
+        // diagnose the problem with a token in the error message path then it is with
+        // a "" in the path.
+        Properties envProperties = loadEnvPropertyFile();
+        
+        String playerglobalHome = envProperties != null ?
+            envProperties.getProperty("env.PLAYERGLOBAL_HOME", System.getenv("PLAYERGLOBAL_HOME")) :
+            System.getenv("PLAYERGLOBAL_HOME");
+        
+        if (playerglobalHome == null)
+            playerglobalHome = PLAYERGLOBAL_HOME_TOKEN;
+            
+        String airHome = envProperties != null ?
+            envProperties.getProperty("env.AIR_HOME", System.getenv("AIR_HOME")) :
+            System.getenv("AIR_HOME");
+
+        if (airHome == null)
+            airHome = AIR_HOME_TOKEN;
+            
+        for (int i = 0; i < pathlist.length; i++)
+        {
+            processed[i] = pathlist[i].replace(
+                PLAYERGLOBAL_HOME_TOKEN, playerglobalHome);
+            processed[i] = processed[i].replace( 
+                AIR_HOME_TOKEN, airHome);
+        }
+        
+        return processed;
+    }
+
+	/**
+	 * Expands the {locale} token in a list of path elements
+	 * for the source-path or library-path,
+	 * and converts each path element from a String
+	 * to a VirtualFile.
+	 *
+	 * The treatment of a path element containing "{locale}"
+	 * depends on whether we are processing a source-path
+	 * or a library-path, and on whether we are compiling for
+	 * a single locale, multiple locales, or no locale:
+	 *
+	 * -source-path=foo,bar/{locale},baz -locale=en_US
+	 *   -> foo,bar/en_US,baz
+	 * -source-path=foo,bar/{locale},baz -locale=en_US,ja_JP
+	 *   -> foo,bar/en_US,bar/ja_JP,baz
+	 * -source-path=foo,bar/{locale},baz -locale=
+	 *   -> foo,baz
+	 * -library-path=foo,bar/{locale},baz -locale=en_US
+	 *   -> foo,bar/en_US,baz
+	 * -library-path=foo,bar/{locale},baz -locale=en_US,ja_JP
+	 *   -> foo,bar/en_US,bar/ja_JP,baz
+	 * -library-path=foo,bar/{locale},baz -locale=
+	 *   -> foo,baz
+	 */
+	private VirtualFile[] expandLocaleToken(String[] pathlist, String[] locales, ConfigurationValue cv)
+		throws ConfigurationException
+	{
+		ArrayList<VirtualFile> list = new ArrayList<VirtualFile>(pathlist.length);
+
+		// Process each path element.
+		for (int i = 0; i < pathlist.length; i++)
+		{
+			String pathElement = pathlist[i];
+
+			// Look for "{locale}".
+			int localeTokenIndex = pathElement.indexOf(LOCALE_TOKEN);
+			if (localeTokenIndex != -1)
+			{
+				// Expand this {locale}-containing path element
+				// into 0, 1, or N path elements.
+				for (int j = 0; j < locales.length; j++)
+				{
+					String pathElementWithSubstitution = pathElement.replace(LOCALE_TOKEN, locales[j]);
+					addPathElementToListAsVirtualFile(pathElementWithSubstitution, list, cv);
+				}
+			}
+			else
+			{
+				addPathElementToListAsVirtualFile(pathElement, list, cv);
+			}
+		}
+
+		VirtualFile[] vfa = new VirtualFile[list.size()];
+		list.toArray(vfa);
+		return vfa;
+	}
+
+	/**
+	 * Helper method for getLocaleFileList().
+	 */
+	private void addPathElementToListAsVirtualFile(String pathElement, ArrayList<VirtualFile> list, ConfigurationValue cv)
+		throws ConfigurationException
+	{
+		try
+		{
+			VirtualFile vf = getVirtualFile(pathElement, cv);
+			list.add(vf);
+		}
+		catch(ConfigurationException e)
+		{
+			if (cv == null)
+			{
+				throw new ConfigurationException.CannotOpen(
+						pathElement, null, null, -1);
+			}
+			else
+			{
+				throw new ConfigurationException.CannotOpen(
+						pathElement, cv.getVar(), cv.getSource(), cv.getLine());
+			}
+		}
+	}
+
+    private VirtualFile[] toVirtualFileArray(String[] files, ConfigurationValue cv)
+    	throws ConfigurationException
+    {
+    	VirtualFile[] vfiles = new VirtualFile[files != null ? files.length : 0];
+    	for (int i = 0, length = vfiles.length; i < length; i++)
+    	{
+    		vfiles[i] = getVirtualFile(files[i], cv);
+    	}
+    	return vfiles;
+    }
+
+    private VirtualFile getVirtualFile(String file, ConfigurationValue cv)
+    	throws ConfigurationException
+    {
+    	return ConfigurationPathResolver.getVirtualFile( file, configResolver, cv );
+    }
+
+    private File[] toFileArray(String[] files)
+    {
+    	File[] fileArray = new File[files != null ? files.length : 0];
+    	for (int i = 0, length = files.length; i < length; i++)
+    	{
+    		fileArray[i] = new File(files[i]);
+    	}
+    	return fileArray;
+    }
+
+    private Set<String> externs = new HashSet<String>();
+
+    Set<String> getExterns()
+    {
+        return externs;
+    }
+
+    public void addExtern(String extern)
+    {
+        this.externs.add(extern);
+    }
+
+    //
+    // 'compiler.accessible' option
+    //
+
+    private boolean accessible;
+
+    public boolean accessible()
+    {
+        return accessible;
+    }
+
+    public void setAccessible(boolean accessible)
+    {
+        this.accessible = accessible;
+    }
+
+    public void cfgAccessible( ConfigurationValue cv, boolean accessible )
+    {
+        this.accessible = accessible;
+    }
+
+	//
+    // 'compiler.actionscript-file-encoding' option
+    //
+
+	// user-defined AS3 file encoding
+	private String actionscriptFileEncoding = null;
+
+	public String getActionscriptFileEncoding()
+	{
+		return actionscriptFileEncoding;
+	}
+
+	public String getEncoding()
+	{
+		return getActionscriptFileEncoding();
+	}
+
+	public void cfgActionscriptFileEncoding(ConfigurationValue cv, String encoding)
+	{
+		actionscriptFileEncoding = encoding;
+	}
+
+	//
+    // 'compiler.adjust-opdebugline' option (hidden)
+    //
+
+	// C: for internal use only. set it to false so that debugging mxmlc auto-generated code is easier.
+	private boolean adjustOpDebugLine = true;
+
+	public boolean adjustOpDebugLine()
+	{
+		return adjustOpDebugLine;
+	}
+
+	public void cfgAdjustOpdebugline(ConfigurationValue cv, boolean b)
+	{
+		adjustOpDebugLine = b;
+	}
+
+	public static ConfigurationInfo getAdjustOpdebuglineInfo()
+	{
+	    return new AdvancedConfigurationInfo()
+	    {
+		    public boolean isHidden()
+		    {
+			    return true;
+		    }
+	    };
+	}
+
+	//
+    // 'compiler.allow-source-path-overlap' option
+    //
+
+	private boolean allowSourcePathOverlap = false;
+
+	public boolean allowSourcePathOverlap()
+	{
+		return allowSourcePathOverlap;
+	}
+
+	public void cfgAllowSourcePathOverlap(ConfigurationValue cv, boolean b)
+	{
+		allowSourcePathOverlap = b;
+	}
+
+	public static ConfigurationInfo getAllowSourcePathOverlapInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.as3' option
+    //
+
+	public static final int AS3Dialect = 10, ESDialect = 9;
+	private int dialect = AS3Dialect;
+
+	public int dialect()
+	{
+		return dialect;
+	}
+
+	public void cfgAs3(ConfigurationValue cv, boolean b)
+	{
+		dialect = b ? AS3Dialect : ESDialect;
+	}
+
+	public static ConfigurationInfo getAs3Info()
+	{
+	    return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.define' option
+    //
+
+    /**
+     * Syntax:<br/>
+     * <code>-define=&lt;name&gt;,&lt;value&gt;</code>
+     * where name is <code>NAMESPACE::name</code> and value is a legal definition value
+     * (e.g. <code>true</code> or <code>1</code> or <code>!CONFIG::debugging</code>)
+     *
+     * Example: <code>-define=CONFIG::debugging,true</code>
+     *
+     * In <code>flex-config.xml</code>:<br/>
+     * <pre>
+     * <flex-config>
+     *    <compiler>
+     *       <define>
+     *          <name>CONFIG::debugging</name>
+     *          <value>true</value>
+     *       </define>
+     *       ...
+     *    </compile>
+     * </flex-config>
+     * </pre>
+     *
+     * Values:<br/>
+     * Values are ActionScript expressions that must coerce and evaluate to constants at compile-time.
+     * Effectively, they are replaced in AS code, verbatim, so <code>-define=TEST::oneGreaterTwo,"1>2"</code>
+     * will get coerced and evaluated, at compile-time, to <code>false</code>.
+     *
+     * It is good practice to wrap values with double-quotes,
+     * so that MXMLC correctly parses them as a single argument:<br/>
+     * <code>-define=TEST::oneShiftRightTwo,"1 >> 2"</code>
+     *
+     * Values may contain compile-time constants and other configuration values:<br/>
+     * <code>-define=CONFIG::bool2,false -define=CONFIG::and1,"CONFIG::bool2 && false" TestApp.mxml</code>
+     *
+     * String values on the command-line <i>must</i> be surrounded by double-quotes, and either
+     * escape-quoted (<code>"\"foo\""</code> or <code>"\'foo\'"</code>) or single-quoted
+     * (<code>"'foo'"</code>).
+     *
+     * String values in configuration files need only be single- or double- quoted:<br/>
+     * <pre>
+     * <flex-config>
+     *    <compiler>
+     *       <define>
+     *          <name>NAMES::Company</name>
+     *          <value>'Apache Software Foundation'</value>
+     *       </define>
+     *       <define>
+     *          <name>NAMES::Application</name>
+     *          <value>"Flex 4.7"</value>
+     *       </define>
+     *       ...
+     *    </compile>
+     * </flex-config>
+     * </pre>
+     *
+     * Empty strings <i>must</i> be passed as <code>"''"</code> on the command-line, and
+     * <code>''</code> or <code>""</code> in configuration files.
+     * 
+     * Finally, if you have existing definitions in a configuration file, and you would
+     * like to add to them with the command-line (let's say most of your build settings
+     * are in the configuration, and that you are adding one temporarily using the
+     * command-line), you use the following syntax:
+     * <code>-define+=TEST::temporary,false</code> (noting the plus sign)
+     * 
+     * Note that definitions can be overridden/redefined if you use the append ("+=") syntax
+     * (on the commandline or in a user config file, for instance) with the same namespace
+     * and name, and a new value.
+     * 
+     * Definitions cannot be removed/undefined. You can undefine ALL existing definitions
+     * from (e.g. from flex-config.xml) if you do not use append syntax ("=" or append="false").
+     * 
+     * IMPORTANT FOR FLEXBUILDER
+     * If you are using "Additional commandline arguments" to "-define", don't use the following
+     * syntax though I suggest it above:
+     *     -define+=CONFIG::foo,"'value'"
+     * The trouble is that FB parses the double quotes incorrectly as <"'value'> -- the trailing
+     * double-quote is dropped. The solution is to avoid inner double-quotes and put them around the whole expression:
+     *    -define+="CONFIG::foo,'value'"
+     */
+	private ObjectList<ConfigVar> configVars = new ObjectList<ConfigVar>();
+    
+    /**
+     * @return A list of ConfigVars
+     */
+    public ObjectList<ConfigVar> getDefine()
+    {
+        return configVars;
+    }
+
+    public void cfgDefine( ConfigurationValue _cv, final String _name, String _value )
+        throws ConfigurationException
+    {
+        assert _name  != null;
+        assert _value != null;
+        assert _cv    != null;
+
+        // macromedia.asc.embedding.Main.parseConfigVar(_name + "=" + _value)
+        final int ns_end = _name.indexOf("::");
+        if( (ns_end == -1) || (ns_end == 0) || (ns_end == _name.length()-2) )
+        {
+            throw new ConfigurationException.BadDefinition(_name + " " + _value,
+                                                           _cv.getVar(),
+                                                           _cv.getSource(),
+                                                           _cv.getLine());
+        }
+        
+        final String ns = _name.substring(0, ns_end);
+        final String name = _name.substring(ns_end + 2);
+        
+        if (configVars == null)
+        {
+            configVars = new ObjectList<ConfigVar>();
+        }
+
+        // try removing any existing definition
+        for (final Iterator<ConfigVar> iter = configVars.iterator(); iter.hasNext();)
+        {
+            final ConfigVar other = iter.next();
+            if (ns.equals(other.ns) && name.equals(other.name))
+            {
+                iter.remove();
+                break;
+            }
+        }
+        
+        configVars.add(new ConfigVar(ns, name, _value));
+    }
+    
+    public static ConfigurationInfo getDefineInfo()
+    {
+        return new ConfigurationInfo(new String[] {"name", "value"})
+        {
+            public boolean allowMultiple() { return true; }
+            public boolean isAdvanced()    { return true; }
+        };
+    }
+
+	//
+    // 'compiler.conservative' option (hidden)
+    //
+
+	// compiler algorithm settings
+	private boolean useConservativeAlgorithm = false;
+
+	public boolean useConservativeAlgorithm()
+	{
+		return useConservativeAlgorithm;
+	}
+
+	public void cfgConservative(ConfigurationValue cv, boolean c)
+	{
+		useConservativeAlgorithm = c;
+	}
+
+	public static ConfigurationInfo getConservativeInfo()
+	{
+	    return new AdvancedConfigurationInfo()
+	    {
+	        public boolean isHidden()
+	        {
+	            return true;
+	        }
+	    };
+	}
+
+    //
+    // 'compiler.context-root' option
+    //
+
+    /**
+     * --context-root is used to resolve {context.root} tokens
+     * in services configuration files to improve portability.
+     */
+    private String contextRoot;
+
+    public String getContextRoot()
+    {
+        return contextRoot;
+    }
+
+    public void setContextRoot(String contextRoot)
+    {
+        this.contextRoot = contextRoot;
+    }
+
+    public void cfgContextRoot( ConfigurationValue cv, String contextRoot )
+    {
+        this.contextRoot = contextRoot;
+    }
+
+    public static ConfigurationInfo getContextRootInfo()
+    {
+        return new ConfigurationInfo( 1, "context-path" )
+        {
+        };
+    }
+
+    //
+    // 'compiler.debug' option
+    //
+
+    // this general debug setting in the CompilerConfiguration maps to different
+    // settings on the implemented interfaces; they get split up here for clarity
+    private boolean debug;
+    
+    public boolean debug()
+    {
+        return debug;
+    }
+    
+    public void setDebug(boolean debug)
+    {
+        this.debug = debug;
+    }
+
+    public void cfgDebug(ConfigurationValue cv, boolean debug)
+    {
+        this.debug = debug;
+    }
+
+    //
+    // 'compiler.compress' option (default is true)
+    //
+    
+    private boolean useCompression = true;
+    
+    public void cfgCompress( ConfigurationValue cv, boolean useCompression )
+    {
+        this.useCompression = useCompression;
+    }
+    
+    /**
+     * Setting {@code -compiler.compress=false} will force compiler not to compress the output SWF.
+     */
+    public boolean useCompression()
+    {
+        return this.useCompression;
+    }
+    
+    //
+    // 'compiler.defaults-css-url' option
+    //
+
+    /**
+     * Location of defaults stylesheet.
+     */
+    private VirtualFile defaultsCssUrl;
+
+    public VirtualFile getDefaultsCssUrl()
+    {
+        return defaultsCssUrl;
+    }
+
+    public void cfgDefaultsCssUrl( ConfigurationValue cv, String defaultsCssUrlPath ) throws ConfigurationException
+    {
+        defaultsCssUrl = ConfigurationPathResolver.getVirtualFile( defaultsCssUrlPath,
+                                                                   configResolver,
+                                                                   cv );
+    }
+
+    public static ConfigurationInfo getDefaultsCssUrlInfo()
+    {
+        return new AdvancedConfigurationInfo();
+    }
+
+    //
+    // 'compiler.doc' option (hidden)
+    //
+
+	private boolean doc;
+
+	public boolean doc()
+	{
+		return this.doc;
+	}
+
+	public void cfgDoc(ConfigurationValue cv, boolean doc)
+	{
+		this.doc = doc;
+	}
+
+	public static ConfigurationInfo getDocInfo()
+	{
+	    return new AdvancedConfigurationInfo()
+	    {
+		    public boolean isHidden()
+		    {
+		    	return true;
+		    }
+	    };
+	}
+
+	//
+    // 'compiler.es' option
+    //
+
+	public void cfgEs(ConfigurationValue cv, boolean b)
+	{
+		dialect = b ? ESDialect : AS3Dialect;
+	}
+
+	public static ConfigurationInfo getEsInfo()
+	{
+	    return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.external-library-path' option
+    //
+
+    private VirtualFile[] externalLibraryPath;
+
+    public VirtualFile[] getExternalLibraryPath()
+    {
+        return externalLibraryPath;
+    }
+
+	private boolean compilingForAIR = false;
+
+	public boolean getCompilingForAIR()
+	{
+		return compilingForAIR;
+	}
+
+    public void cfgExternalLibraryPath( ConfigurationValue cv, String[] pathlist ) throws ConfigurationException
+    {
+		// We are "compiling for AIR" if airglobal.swc is in the pathlist.
+		for (int i = 0; i < pathlist.length; i++)
+		{
+			String path = pathlist[i];
+			if (path.equals(StandardDefs.SWC_AIRGLOBAL) ||
+				path.endsWith("/" + StandardDefs.SWC_AIRGLOBAL) ||
+				path.endsWith("\\" + StandardDefs.SWC_AIRGLOBAL))
+			{
+				compilingForAIR = true;
+				break;
+			}
+		}
+
+    	String[] locales = getLocales();
+    	VirtualFile[] newPathElements = expandTokens(pathlist, locales, cv);
+    	externalLibraryPath = (VirtualFile[])merge(externalLibraryPath, newPathElements, VirtualFile.class);
+	}
+
+    public static ConfigurationInfo getExternalLibraryPathInfo()
+    {
+        return new ConfigurationInfo( -1, new String[] { "path-element" } )
+        {
+            public boolean allowMultiple()
+            {
+                return true;
+            }
+
+	        public String[] getSoftPrerequisites()
+	        {
+		        return PATH_TOKENS;
+	        }
+
+            public boolean isPath()
+            {
+                return true;
+            }
+
+            public boolean doChecksum()
+            {
+            	return false;
+            }
+        };
+    }
+
+    //
+    // 'compiler.fonts.*' options
+    //
+
+    private FontsConfiguration fontsConfig;
+
+    public FontsConfiguration getFontsConfiguration()
+    {
+        return fontsConfig;
+    }
+
+    public void setFontsConfiguration(FontsConfiguration fc)
+    {
+        fontsConfig = fc;
+	    fontsConfig.setCompilerConfiguration(this);
+    }
+
+    //
+    // 'compiler.generated-directory' option (incomplete)
+    //
+
+    private String generatedDir = null;     // set based on the target file
+
+    public String getGeneratedDirectory()
+    {
+        return generatedDir;
+    }
+
+    public void setGeneratedDirectory( String gd )
+    {
+        this.generatedDir = gd;
+    }
+
+    //
+    // 'compiler.headless-server' option
+    //
+
+    private boolean headlessServer;
+
+    public boolean headlessServer()
+    {
+        return headlessServer;
+    }
+
+    public void cfgHeadlessServer( ConfigurationValue cv, boolean headlessServer )
+    {
+        this.headlessServer = headlessServer;
+    }
+
+    public static ConfigurationInfo getHeadlessServerInfo()
+    {
+        return new AdvancedConfigurationInfo();
+    }
+
+    //
+    // 'compiler.include-libraries' option
+    //
+
+	private VirtualFile[] includeLibraries;
+
+	public VirtualFile[] getIncludeLibraries()
+	{
+		return includeLibraries;
+	}
+
+	public void cfgIncludeLibraries(ConfigurationValue cv, String[] pathlist)
+			throws ConfigurationException
+	{
+    	String[] locales = getLocales();
+    	VirtualFile[] newPathElements = expandTokens(pathlist, locales, cv);
+		includeLibraries = (VirtualFile[])merge(includeLibraries, newPathElements, VirtualFile.class);
+	}
+
+	public static ConfigurationInfo getIncludeLibrariesInfo()
+	{
+		return new ConfigurationInfo( -1, new String[] { "library" } )
+		{
+			public boolean allowMultiple()
+			{
+				return true;
+			}
+
+	        public String[] getSoftPrerequisites()
+	        {
+		        return PATH_TOKENS;
+	        }
+
+            public boolean isPath()
+            {
+                return true;
+            }
+
+            public boolean doChecksum()
+            {
+            	return false;
+            }
+        };
+	}
+
+    //
+    // 'compiler.incremental' option
+    //
+
+	private boolean incremental = false;
+
+	public boolean getIncremental()
+	{
+		return incremental;
+	}
+
+	public void cfgIncremental(ConfigurationValue cv, boolean b)
+	{
+		incremental = b;
+	}
+
+    //
+    // 'compiler.keep-all-type-selectors' option.  This was initially
+    // used by Flex Builder when building design view, but they no
+    // longer use it.
+    //
+
+	private boolean keepAllTypeSelectors;
+
+	public boolean keepAllTypeSelectors()
+	{
+		return keepAllTypeSelectors;
+	}
+
+	public void setKeepAllTypeSelectors( boolean keepAllTypeSelectors )
+	{
+		this.keepAllTypeSelectors = keepAllTypeSelectors;
+	}
+
+	public void cfgKeepAllTypeSelectors( ConfigurationValue cv, boolean keepAllTypeSelectors )
+	{
+		this.keepAllTypeSelectors = keepAllTypeSelectors;
+	}
+
+    public static ConfigurationInfo getKeepAllTypeSelectorsInfo()
+    {
+        return new AdvancedConfigurationInfo();
+    }
+
+    //
+    // 'compiler.keep-as3-metadata' option
+    //
+
+    private String[] as3metadata = null;
+
+    public String[] getKeepAs3Metadata()
+    {
+    	return as3metadata;
+    }
+
+    public void cfgKeepAs3Metadata(ConfigurationValue cv, String[] md)
+    {
+    	if (as3metadata == null)
+    	{
+    		as3metadata = md;
+    	}
+    	else if (md != null)
+    	{
+    		Set<String> s = new HashSet<String>(Arrays.asList(as3metadata));
+    		s.addAll(Arrays.asList(md));
+    		as3metadata = new String[s.size()];
+    		int k = 0;
+    		for (Iterator<String> i = s.iterator(); i.hasNext(); k++)
+    		{
+    			as3metadata[k] = i.next();
+    		}
+    	}
+    }
+
+    public boolean keepEmbedMetadata()
+    {
+        if( as3metadata != null )
+        {
+            for( int i = 0; i < as3metadata.length; ++i )
+            {
+                if(StandardDefs.MD_EMBED.equals(as3metadata[i]))
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public static ConfigurationInfo getKeepAs3MetadataInfo()
+    {
+        return new ConfigurationInfo(-1, new String[] { "name" })
+        {
+            public boolean isAdvanced()
+            {
+            	return true;
+            }
+
+			public boolean allowMultiple()
+			{
+				return true;
+			}
+        };
+    }
+
+    //
+    // 'compiler.keep-generated-actionscript' option
+    //
+
+    private boolean keepGeneratedActionScript = true;
+
+    public boolean keepGeneratedActionScript()
+    {
+        return keepGeneratedActionScript;
+    }
+
+    public void setKeepGeneratedActionScript(boolean keepGeneratedActionScript)
+    {
+        this.keepGeneratedActionScript = keepGeneratedActionScript;
+
+        // Force AST generation off if the user wants to see the AS equivalent.
+        if (keepGeneratedActionScript)
+        {
+            generateAbstractSyntaxTree = false;
+        }
+    }
+
+    public void cfgKeepGeneratedActionscript(ConfigurationValue cv, boolean keep)
+    {
+        setKeepGeneratedActionScript(keep);
+    }
+
+    public static ConfigurationInfo getKeepGeneratedActionscriptInfo()
+    {
+        return new AdvancedConfigurationInfo();
+    }
+
+    //
+    // 'compiler.keep-generated-signatures' option (hidden)
+    //
+    private boolean keepGeneratedSignatures; // = false;
+
+    public boolean getKeepGeneratedSignatures()
+    {
+        return keepGeneratedSignatures;
+    }
+
+    public void setKeepGeneratedSignatures(boolean keepGeneratedSignatures)
+    {
+        this.keepGeneratedSignatures = keepGeneratedSignatures;
+    }
+
+    public void cfgKeepGeneratedSignatures(ConfigurationValue cv, boolean keep)
+    {
+        this.keepGeneratedSignatures = keep;
+    }
+
+    public static ConfigurationInfo getKeepGeneratedSignaturesInfo()
+    {
+        return new AdvancedConfigurationInfo()
+        {
+            public boolean isHidden()
+            {
+                return true;
+            }
+        };
+    }
+    
+    //
+    // 'compiler.enable-runtime-design-layers' option
+    //
+
+    private boolean enableRuntimeDesignLayers = true;
+
+    public boolean enableRuntimeDesignLayers()
+    {
+        return enableRuntimeDesignLayers;
+    }
+
+    public void setEnableRuntimeDesignLayers(boolean enableDesignLayers)
+    {
+        this.enableRuntimeDesignLayers = enableDesignLayers;
+    }
+
+    public void cfgEnableRuntimeDesignLayers(ConfigurationValue cv, boolean enable)
+    {
+        setEnableRuntimeDesignLayers(enable);
+    }
+    
+    //
+    // 'compiler.enable-swc-version-filtering' option
+    //
+
+    private boolean enableSwcVersionFiltering = true;
+
+    public boolean enableSwcVersionFiltering()
+    {
+        return enableSwcVersionFiltering;
+    }
+
+    public void setEnableSwcVersionFiltering(boolean enableSwcFiltering)
+    {
+        this.enableSwcVersionFiltering = enableSwcFiltering;
+    }
+
+    public void cfgEnableSwcVersionFiltering(ConfigurationValue cv, boolean enable)
+    {
+    	setEnableSwcVersionFiltering(enable);
+    }
+    
+    public static ConfigurationInfo getEnableSwcVersionFilteringInfo()
+    {
+        return new AdvancedConfigurationInfo()
+        {
+            public boolean isHidden()
+            {
+                 return true;
+            }
+        };
+    }
+    
+    //
+    // 'compiler.library-path' option
+    //
+
+    /**
+     * A list of SWC component libraries or directories containing SWCs.
+     * All SWCs found in the library-path are merged together
+     * and resolved via priority and version.
+     * The order in the library-path is ignored.
+     *
+     * The specified compiler.library-path can have path elements
+     * which contain a special {locale} token.
+     * If you compile for a single locale,
+     * this token is replaced by the specified locale.
+     * If you compile for multiple locales,
+     * any path element with the {locale} token
+	 * is expanded into multiple path elements,
+	 * one for each locale.
+     * If you compile for no locale,
+     * any path element with {locale} is ignored.
+     */
+    private VirtualFile[] libraryPath;
+
+    public VirtualFile[] getLibraryPath()
+    {
+        return libraryPath;
+    }
+
+    public void cfgLibraryPath( ConfigurationValue cv, String[] pathlist ) throws ConfigurationException
+    {
+    	String[] locales = getLocales();
+    	VirtualFile[] newPathElements = expandTokens(pathlist, locales, cv);
+    	libraryPath = (VirtualFile[])merge(libraryPath, newPathElements, VirtualFile.class);
+    }
+
+    public static ConfigurationInfo getLibraryPathInfo()
+    {
+        return new ConfigurationInfo( -1, new String[] { "path-element" } )
+        {
+            public boolean allowMultiple()
+            {
+                return true;
+            }
+
+	        public String[] getSoftPrerequisites()
+	        {
+		        return PATH_TOKENS;
+	        }
+
+            public boolean isPath()
+            {
+                return true;
+            }
+
+            public boolean doChecksum()
+            {
+            	return false;
+            }
+        };
+    }
+
+    //
+    // 'compiler.locale' option
+    //
+
+    /*
+     * This is never null. If you specify "no locales"
+     * with -locale= then it is an empty array.
+     */
+    private String[] locales = new String[] {};
+
+    public String[] getLocales()
+    {
+        return locales;
+    }
+
+	public String locale()
+	{
+		return locales.length > 0 ? locales[0] : null;
+	}
+
+    public void cfgLocale( ConfigurationValue cv, String[] newLocales )
+    {
+        locales = (String[])merge(newLocales, locales, String.class);
+    }
+
+    public static ConfigurationInfo getLocaleInfo()
+    {
+        return new ConfigurationInfo( -1, new String[] { "locale-element" } )
+        {
+            public boolean allowMultiple()
+            {
+                return true;
+            }
+        };
+    }
+
+    //
+    // 'compiler.local-fonts-snapshot' option (hidden)
+    //
+
+	/**
+	 * Location of localFonts.ser
+	 */
+	/**private VirtualFile localFontsSnapshot;
+
+	public VirtualFile getLocalFontsSnapshot()
+	{
+	    return localFontsSnapshot;
+	}
+
+	public void cfgLocalFontsSnapshot( ConfigurationValue cv, String localFontsSnapshotPath ) throws ConfigurationException
+	{
+		try
+		{
+			localFontsSnapshot = ConfigurationPathResolver.getVirtualFile( localFontsSnapshotPath,
+					configResolver,
+					cv );
+
+			System.out.println(localFontsSnapshot);
+
+		}
+		catch(ConfigurationException ce)
+		{
+			// ignore, error will be shown later if needed
+		}
+	}
+
+	public static ConfigurationInfo getLocalFontsSnapshotInfo()
+	{
+	    return new ConfigurationInfo()
+	    {
+	        public boolean isHidden()
+	        {
+	            return true;
+	        }
+	    };
+	}
+	**/
+
+	//
+    // 'compiler.memory-usage-factor' option (hidden)
+    //
+
+	private int factor = 1000;
+
+	public int factor()
+	{
+		return factor;
+	}
+
+	public void cfgMemoryUsageFactor(ConfigurationValue cv, int f)
+	{
+		factor = f;
+	}
+
+	public static ConfigurationInfo getMemoryUsageFactorInfo()
+	{
+	    return new AdvancedConfigurationInfo()
+	    {
+	        public boolean isHidden()
+	        {
+	            return true;
+	        }
+	    };
+	}
+
+    //
+    // 'compiler.metadata-export' option (incomplete)
+    //
+
+    private boolean metadataExport;
+
+    public boolean metadataExport()
+    {
+        return metadataExport;
+    }
+
+    // metadataExport does not have the normal configuration setter because it is not
+    // a normal configuration value but rather something set by the compiler
+    public void setMetadataExport(boolean metadataExport)
+    {
+        this.metadataExport = metadataExport;
+    }
+
+
+    //
+    // 'compiler.mobile' option
+    //
+
+    private boolean mobile = false;
+
+    /**
+     * @return determines whether the target runtime is a mobile device. This
+     * may alter the features available, such as certain blend-modes when
+     * compiling FXG.
+     */
+    public boolean getMobile()
+    {
+        return mobile;
+    }
+
+    public void setMobile(boolean value)
+    {
+        mobile = value;
+	}
+
+    public void cfgMobile(ConfigurationValue cv, boolean b)
+    {
+        mobile = b;
+    }
+
+
+    // 'compiler.mxml.*' options
+
+    private MxmlConfiguration mxmlConfig;
+
+    public MxmlConfiguration getMxmlConfiguration()
+    {
+    	return mxmlConfig;
+    }
+
+    //
+    // 'compiler.mxml.compatibility-version' option
+    //
+
+    public String getCompatibilityVersionString()
+    {
+        return mxmlConfig.getCompatibilityVersionString();
+    }
+
+	public int getCompatibilityVersion()
+	{
+		return mxmlConfig.getCompatibilityVersion();
+	}
+
+    //
+    // 'compiler.mxml.minimum-supported-version' option
+    //
+
+    public String getMinimumSupportedVersionString()
+    {
+        return mxmlConfig.getMinimumSupportedVersionString();
+    }
+
+    public int getMinimumSupportedVersion()
+    {
+        return mxmlConfig.getMinimumSupportedVersion();
+    }
+
+    public void cfgMinimumSupportedVersion(ConfigurationValue cv, String version) throws ConfigurationException
+    {
+        mxmlConfig.cfgMinimumSupportedVersion(cv, version);
+    }
+    
+    //
+    // 'qualified-type-selectors' option
+    //
+	
+    public boolean getQualifiedTypeSelectors()
+    {
+        return mxmlConfig.getQualifiedTypeSelectors();
+    }
+
+    //
+    // 'compiler.namespaces.*' options
+    //
+
+	private NamespacesConfiguration namespaces;
+
+	public NamespacesConfiguration getNamespacesConfiguration()
+	{
+		return namespaces;
+	}
+
+    //
+    // 'compiler.omit-trace-statements' option
+    //
+
+	private boolean omitTraceStatements = true;
+
+	public boolean omitTraceStatements()
+	{
+		return omitTraceStatements;
+	}
+
+	public void cfgOmitTraceStatements(ConfigurationValue cv, boolean b)
+	{
+		omitTraceStatements = b;
+	}
+
+    //
+    // 'compiler.optimize' option
+    //
+
+	private boolean optimize = false;
+
+	public boolean optimize()
+	{
+		return optimize;
+	}
+
+	public boolean getOptimize()
+	{
+		return optimize;
+	}
+
+	public void setOptimize(boolean optimize)
+	{
+		this.optimize = optimize;
+	}
+
+	public void cfgOptimize(ConfigurationValue cv, boolean b)
+	{
+		optimize = b;
+	}
+	
+	//
+    // 'compiler.preloader' option
+    //
+
+	private String preloader = null;
+
+	public String getPreloader()
+	{
+		return preloader;
+	}
+
+	public void cfgPreloader(ConfigurationValue cv, String value)
+	{
+		preloader = value;
+	}
+
+	//
+    // 'compiler.resource-hack' option
+    //
+
+    // This undocumented option is for compiler performance testing.
+	// It allows the Flex 3 compiler to compile the Flex 2 framework
+	// and Flex 2 apps. This is not an officially-supported combination.
+	private boolean resourceHack = false;
+
+	public boolean getResourceHack()
+	{
+		return resourceHack;
+	}
+
+	public void cfgResourceHack(ConfigurationValue cv, boolean b)
+	{
+		resourceHack = b;
+	}
+
+	public static ConfigurationInfo getResourceHackInfo()
+	{
+	    return new ConfigurationInfo()
+	    {
+	        public boolean isHidden()
+	        {
+	            return true;
+	        }
+	    };
+	}
+
+	//
+    // 'compiler.services' option
+    //
+
+	private VirtualFile servicesConfigFile;
+
+	protected ServicesDependenciesWrapper servicesDependencies;
+
+	public VirtualFile getServices()
+	{
+		return servicesConfigFile;
+	}
+
+    /**
+     * Used by the compiler to record the client dependencies
+     * from the Flex Data Services configuration file.
+     */
+    public ServicesDependenciesWrapper getServicesDependencies()
+    {
+        if (servicesDependencies == null && servicesConfigFile != null)
+        {
+            String servicesPath = servicesConfigFile.getName();
+            servicesDependencies = new ServicesDependenciesWrapper(servicesPath, null, getContextRoot());
+        }
+
+        return servicesDependencies;
+    }
+
+    public void setServicesDependencies(ServicesDependenciesWrapper deps)
+    {
+        servicesDependencies = deps;
+    }
+
+    public void cfgServices(ConfigurationValue cv, String servicesPath) throws ConfigurationException
+    {
+        try
+        {
+	        servicesConfigFile = ConfigurationPathResolver.getVirtualFile(servicesPath,
+	                                                                      configResolver, cv);
+        }
+        catch(Throwable t)
+        {
+            throw new ConfigurationException.CannotOpen( servicesPath, cv.getVar(), cv.getSource(), cv.getLine() );
+        }
+    }
+
+    public static ConfigurationInfo getServicesInfo()
+    {
+        return new ConfigurationInfo( 1, "filename" )
+        {
+        };
+    }
+
+    //
+    // 'compiler.show-actionscript-warnings' option
+    //
+
+    /**
+     * Enable asc -warnings
+     */
+    private boolean ascWarnings;
+
+    public boolean warnings()
+    {
+        return this.ascWarnings;
+    }
+
+    public void cfgShowActionscriptWarnings( ConfigurationValue cv, boolean ascWarnings )
+    {
+        this.ascWarnings = ascWarnings;
+    }
+
+    //
+    // 'compiler.show-binding-warnings' option
+    //
+
+    /**
+     * Controls whether binding warnings are displayed.
+     */
+    private boolean showBindingWarnings = true;
+
+    public boolean showBindingWarnings()
+    {
+        return showBindingWarnings;
+    }
+
+    public void cfgShowBindingWarnings(ConfigurationValue cv, boolean show)
+    {
+        this.showBindingWarnings = show;
+    }
+
+    //
+    // 'compiler.show-dependency-warnings' option (hidden)
+    //
+
+    private boolean showDependencyWarnings = false;
+
+    public boolean showDependencyWarnings()
+    {
+        return showDependencyWarnings;
+    }
+
+    public void cfgShowDependencyWarnings(ConfigurationValue cv, boolean show)
+    {
+        this.showDependencyWarnings = show;
+    }
+
+    public static ConfigurationInfo getShowDependencyWarningsInfo()
+    {
+        return new AdvancedConfigurationInfo()
+        {
+            public boolean isHidden()
+            {
+            	return true;
+            }
+        };
+    }
+
+    //
+    // 'compiler.report-invalid-styles-as-warnings' option
+    /**
+     * Controls whether invalid styles are report as errors or
+     * warnings.
+     */
+    private boolean reportInvalidStylesAsWarnings = false;
+
+    public boolean reportInvalidStylesAsWarnings()
+    {
+        return reportInvalidStylesAsWarnings;
+    }
+
+    public void setReportInvalidStylesAsWarnings(boolean reportInvalidStylesAsWarnings)
+    {
+        this.reportInvalidStylesAsWarnings = reportInvalidStylesAsWarnings;
+    }
+
+    public void cfgReportInvalidStylesAsWarnings(ConfigurationValue cv, boolean show)
+    {
+        this.reportInvalidStylesAsWarnings = show;
+    }
+    
+    //
+    // 'compiler.report-missing-required-skin-parts-as-warnings' option
+    //
+
+    private boolean reportMissingRequiredSkinPartsAsWarnings = false;
+
+    /**
+     * Allow the user to configure whether it should be considered an error to
+     * not create a required skin part or if it should just be a warning.
+     */
+    public boolean reportMissingRequiredSkinPartsAsWarnings()
+    {
+        return reportMissingRequiredSkinPartsAsWarnings;
+    }
+
+    public void cfgReportMissingRequiredSkinPartsAsWarnings(ConfigurationValue cv, boolean b)
+    {
+        reportMissingRequiredSkinPartsAsWarnings = b;
+    }
+
+    public static ConfigurationInfo getReportMissingRequiredSkinPartsAsWarningsInfo()
+    {
+        return new AdvancedConfigurationInfo();
+    }
+
+    //
+    // 'compiler.show-invalid-css-property-warnings' option
+    /**
+     * Controls whether warnings are displayed when styles, which
+     * don't apply to the current theme(s), are used in CSS.
+     */
+    private boolean showInvalidCssPropertyWarnings = true;
+
+    public boolean showInvalidCssPropertyWarnings()
+    {
+        return showInvalidCssPropertyWarnings;
+    }
+
+    public void setShowInvalidCssPropertyWarnings(boolean showInvalidCssPropertyWarnings)
+    {
+        this.showInvalidCssPropertyWarnings = showInvalidCssPropertyWarnings;
+    }
+
+    public void cfgShowInvalidCssPropertyWarnings(ConfigurationValue cv, boolean show)
+    {
+        this.showInvalidCssPropertyWarnings = show;
+    }
+
+    //
+    // 'compiler.show-deprecation-warnings' option
+    //
+
+    /**
+     * Controls whether warnings are displayed when a deprecated API is used.
+     */
+    private boolean showDeprecationWarnings = false;
+
+    public boolean showDeprecationWarnings()
+    {
+        return showDeprecationWarnings;
+    }
+
+    public void setShowDeprecationWarnings(boolean showDeprecationWarnings)
+    {
+        this.showDeprecationWarnings = showDeprecationWarnings;
+    }
+
+    public void cfgShowDeprecationWarnings(ConfigurationValue cv, boolean show)
+    {
+        this.showDeprecationWarnings = show;
+    }
+    
+    public static ConfigurationInfo getShowDeprecationWarningsInfo()
+    {
+        return new AdvancedConfigurationInfo()
+        {
+            public boolean isHidden()
+            {
+                return true;
+            }
+        };
+    }
+
+    //
+    // 'compiler.show-shadowed-device-font-warnings' option
+    //
+
+    /**
+     * Controls whether warnings are displayed when an embedded font name
+     * shadows a device font name. The default is true.
+     */
+    private boolean showShadowedDeviceFontWarnings = true;
+
+    public boolean showShadowedDeviceFontWarnings()
+    {
+        return showShadowedDeviceFontWarnings;
+    }
+
+    public void setShowShadowedDeviceFontWarnings(boolean showShadowedDeviceFontWarnings)
+    {
+        this.showShadowedDeviceFontWarnings = showShadowedDeviceFontWarnings;
+    }
+
+    public void cfgShowShadowedDeviceFontWarnings(ConfigurationValue cv, boolean show)
+    {
+        this.showShadowedDeviceFontWarnings = show;
+    }
+    
+    //
+    // 'compiler.show-unused-type-selector-warnings' option
+    //
+
+    private boolean showUnusedTypeSelectorWarnings = true;
+
+    public boolean showUnusedTypeSelectorWarnings()
+    {
+        return showUnusedTypeSelectorWarnings;
+    }
+
+    public void setShowUnusedTypeSelectorWarnings(boolean showUnusedTypeSelectorWarnings)
+    {
+        this.showUnusedTypeSelectorWarnings = showUnusedTypeSelectorWarnings;
+    }
+
+    public void cfgShowUnusedTypeSelectorWarnings(ConfigurationValue cv, boolean show)
+    {
+        this.showUnusedTypeSelectorWarnings = show;
+    }
+
+    //
+    // 'disable-incremental-optimizations' option (hidden)
+    // Back-door to disable optimizations in case they are causing problems.
+    //
+
+    private boolean disableIncrementalOptimizations = false;
+    public boolean getDisableIncrementalOptimizations()
+    {
+        return disableIncrementalOptimizations;
+    }
+    public void setDisableIncrementalOptimizations(boolean disable)
+    {
+        disableIncrementalOptimizations = disable;
+    }
+    public void cfgDisableIncrementalOptimizations(ConfigurationValue cv, boolean disable)
+    {
+        disableIncrementalOptimizations = disable;
+    }
+    public static ConfigurationInfo getDisableIncrementalOptimizationsInfo()
+    {
+        return new ConfigurationInfo()
+        {
+
+            public boolean isAdvanced()
+            {
+                return true;
+            }
+
+            public boolean isHidden()
+            {
+                return true;
+            }
+        };
+    }
+
+    //
+    // 'compiler.signature-directory' option (hidden)
+    //
+
+    private String signatureDirectory;
+
+    public String getSignatureDirectory()
+    {
+        return signatureDirectory;
+    }
+
+    public void setSignatureDirectory(String signatureDirectory) throws ConfigurationException
+    {
+        this.signatureDirectory = signatureDirectory;
+    }
+
+    public void cfgSignatureDirectory( ConfigurationValue cv, String path ) throws ConfigurationException
+    {
+        // configure to a canonical path
+        final File dir;
+        {
+            String parent = null;
+
+            if (cv != null)
+            {
+                parent = cv.getBuffer().getToken(flex2.tools.oem.Configuration.DEFAULT_OUTPUT_DIRECTORY_TOKEN);
+            }
+
+            if (parent == null)
+            {
+                parent = configResolver.resolve(".").getNameForReporting();
+            }
+
+            if (!(new File(path)).isAbsolute())
+            {
+                // if the given path is relative... to the parent
+                dir = new File(parent + File.separatorChar + path);
+            }
+            else
+            {
+                // otherwise it's absolute
+                dir = new File(path);
+            }
+
+            try {   
+                signatureDirectory = dir.getCanonicalPath();
+            } catch (IOException e)
+            {
+                
+            }
+
+        }
+
+        // create the directory and validate it
+        if (!(dir.isDirectory() || dir.mkdirs()))
+        {
+            if (cv == null)
+            {
+                throw new ConfigurationException.NotDirectory( path, null, null, -1 );
+            }
+            else
+            {
+                throw new ConfigurationException.NotDirectory( path, cv.getVar(), cv.getSource(), cv.getLine() );
+            }
+        }
+    }
+
+    public static ConfigurationInfo getSignatureDirectoryInfo()
+    {
+        return new ConfigurationInfo(new String[] { "relative-directory" } )
+        {
+            public boolean isPath()
+            {
+                return true;
+            }
+
+            public boolean isAdvanced()
+            {
+                return true;
+            }
+
+            public boolean isHidden()
+            {
+                return true;
+            }
+        };
+    }
+
+    //
+    // 'compiler.source-path' option
+    //
+
+    /**
+     * Source path elements searched for ActionScript class files,
+	 * possibly containing a {locale} token.
+     */
+    private File[] unexpandedSourcePath;
+
+    /**
+     * Directories searched for ActionScript class files.
+     *
+     * The specified compiler.source-path can have path elements
+     * which contain a special {locale} token.
+     * If you compile for a single locale,
+     * this token is replaced by the specified locale.
+     * If you compile for multiple locales,
+     * any path element with the {locale} token is ignored,
+     * because we do not support compiling, for example,
+     * both en_US and ja_JP versions of MyComponent into the same SWF.
+     * A path element with {locale} is similarly ignored
+     * if you compile for no locale.
+     */
+    private VirtualFile[] sourcePath;
+    
+    public void setSourcePath(VirtualFile[] sourcePath) {
+        this.sourcePath = sourcePath;
+    }
+
+    /**
+     * Directories searched for .properties files for resource bundles,
+     * for each locale.
+     *
+     * These are determined by the same compiler.source-path option
+     * which determines sourcePath
+     * There is a separate list for each locale.
+     * For example, if you set
+     *   -source-path=foo,bar/{locale},baz -locale=en_US,ja_JP
+     * then the source directories searched when compiling the
+     * en_US resource bundles are foo, bar/en_US, and baz
+     * while the source directories searched when compiling the
+     * ja_JP resource bundles are foo, bar/ja_JP, and baz.
+     */
+    private Map<String, VirtualFile[]> resourceBundlePaths = new HashMap<String, VirtualFile[]>();
+
+    public File[] getUnexpandedSourcePath()
+    {
+    	return unexpandedSourcePath;
+    }
+
+    public VirtualFile[] getSourcePath()
+    {
+        return sourcePath;
+    }
+
+    public VirtualFile[] getResourceBundlePathForLocale(String locale)
+    {
+    	VirtualFile[] path = resourceBundlePaths.get(locale);
+    	return path;
+    }
+
+	public void cfgSourcePath( ConfigurationValue cv, String[] pathlist ) throws ConfigurationException
+	{
+		unexpandedSourcePath = (File[])merge(unexpandedSourcePath, toFileArray(pathlist), File.class);
+
+        String[] locales = getLocales();
+
+        VirtualFile[] newPathElements = expandTokens(pathlist, locales, cv);
+        checkNewSourcePathElements(newPathElements, cv);
+        sourcePath = (VirtualFile[])merge(sourcePath, newPathElements, VirtualFile.class);
+
+		for (int i = 0; i < locales.length; i++)
+		{
+			String locale = locales[i];
+			newPathElements = expandTokens(pathlist, new String[] { locale }, cv);
+			checkNewSourcePathElements(newPathElements, cv);
+			VirtualFile[] bundlePath = resourceBundlePaths.get(locale);
+			bundlePath = (VirtualFile[])merge(bundlePath, newPathElements, VirtualFile.class);
+			resourceBundlePaths.put(locale, bundlePath);
+		}
+	}
+
+	private void checkNewSourcePathElements(VirtualFile[] newPathElements, ConfigurationValue cv) throws ConfigurationException
+	{
+        for (int i = 0; i < newPathElements.length; i++)
+		{
+			VirtualFile pathElement = newPathElements[i];
+			if (!pathElement.isDirectory())
+			{
+				if (cv == null)
+				{
+					throw new ConfigurationException.NotDirectory(
+							pathElement.getName(), null, null, -1);
+				}
+				else
+				{
+					throw new ConfigurationException.NotDirectory(
+							pathElement.getName(), cv.getVar(), cv.getSource(), cv.getLine());
+				}
+			}
+		}
+	}
+
+	public static ConfigurationInfo getSourcePathInfo()
+	{
+		return new ConfigurationInfo( -1, new String[] { "path-element" } )
+		{
+			public boolean allowMultiple()
+			{
+				return true;
+			}
+
+			public String[] getSoftPrerequisites()
+			{
+				return PATH_TOKENS;
+			}
+
+            public boolean isPath()
+            {
+                return true;
+            }
+        };
+	}
+
+    //
+    // 'compiler.strict' option
+    //
+
+    /**
+     * Run the AS3 compiler in strict mode
+     */
+    private boolean strict;
+
+    public boolean strict()
+    {
+        return this.strict;
+    }
+
+    public void cfgStrict( ConfigurationValue cv, boolean strict )
+    {
+        this.strict = strict;
+    }
+
+	//
+    // 'compiler.suppress-warnings-in-incremental' option (incomplete)
+    //
+
+	// for Zorn
+	//
+	// When doing incremental compilation, the compiler doesn't recompile codes that are previously compiled with
+	// warnings. It only outputs the warning messages so as to remind users of the warnings.
+	//
+	// The command-line tool and Zorn work differently in that Zorn keeps the warning logger while the commnad-line
+	// tool, of course, can't keep the warning logger alive...
+	//
+	// Zorn needs this flag to tell the compiler not to output warnings again in incremental compilations because
+	// it keeps its own log.
+	private boolean suppressWarningsInIncremental = false;
+
+	public boolean suppressWarningsInIncremental()
+	{
+		return suppressWarningsInIncremental;
+	}
+
+	public void setSuppressWarningsInIncremental(boolean b)
+	{
+		suppressWarningsInIncremental = b;
+	}
+
+    //
+    // 'compiler.theme' option
+    //
+
+    private VirtualFile[] themeFiles;
+
+    public VirtualFile[] getThemeFiles()
+    {
+        // Swap in the default Flex 3 theme of Halo.
+        if ((mxmlConfig.getCompatibilityVersion() <= MxmlConfiguration.VERSION_3_0) &&
+            ((themeFiles != null) && ((themeFiles.length == 1))))
+        {
+            File file = new File("/themes/Spark/spark.css");
+
+            if (themeFiles[0].getName().endsWith(file.getPath()))
+            {
+                String name = themeFiles[0].getName();
+                int index = name.indexOf(file.getPath());
+                themeFiles[0] = new LocalFile(new File(name.substring(0, index) + "/themes/Halo/halo.swc"));
+                themeNames.remove("spark");
+                themeNames.add("halo");
+            }
+        }
+
+        return themeFiles;
+    }
+
+    public void cfgTheme( ConfigurationValue cv, List paths ) throws ConfigurationException
+    {
+        VirtualFile[] vfa = new VirtualFile[paths.size()];
+
+        int i = 0;
+        for (Iterator it = paths.iterator(); it.hasNext();)
+        {
+            String path = (String) it.next();
+            addThemeName(path);
+            VirtualFile theme = ConfigurationPathResolver.getVirtualFile( path,
+                                                                          configResolver,
+                                                                          cv );
+            if (theme == null)
+            {
+                throw new ConfigurationException.ConfigurationIOError( path, cv.getVar(), cv.getSource(), cv.getLine() );
+            }
+            vfa[i++] = theme;
+        }
+        themeFiles = (VirtualFile[])merge( themeFiles, vfa, VirtualFile.class );
+    }
+
+    public static ConfigurationInfo getThemeInfo()
+    {
+        return new ConfigurationInfo( -1, new String[] { "filename" } )
+        {
+            public boolean allowMultiple()
+            {
+                return true;
+            }
+
+            public boolean doChecksum()
+            {
+            	return false;
+            }
+        };
+    }
+
+    private Set<String> themeNames = new HashSet<String>();
+    
+    private void addThemeName(String path)
+    {
+        File file = new File(path);
+        String fileName = file.getName();
+        int end = fileName.indexOf("-");
+
+        if (end == -1)
+        {
+            end = fileName.lastIndexOf(".");
+        }
+
+        if (end != -1)
+        {
+            String themeName = fileName.substring(0, end);
+            themeNames.add(themeName);
+        }
+    }
+
+    public Set<String> getThemeNames()
+    {
+        return themeNames;
+    }
+    
+    //
+    // 'compiler.defaults-css-files' option
+    //
+    
+    /*
+     * This allows you to insert CSS files into compilation the same way that a per-SWC
+     * defaults.css file works, but without having to re-zip the SWC to test each change.
+     * 
+     * These CSS files have a higher precedence than those already in existing SWCs (e.g. specifying
+     * this option will override definitions in framework.swc$defaults.css), however, they have the
+     * same overall precedence as SWCs.
+     * 
+     * This takes one-or-more files, the CSS precedence is left-to-right, then SWCs.
+     * 
+     * NOTE: This does NOT actually insert the CSS file into the SWC, it simulates it. When you are
+     * done developing the CSS, you should rebuild the SWC with the new CSS integrated.
+     */
+    
+    /**
+     * Location of defaults style stylesheets (css only).
+     * 
+     * Contract: -defaults-css-files=A,B,C
+     *    'A' should have precedence over 'B', then 'C', then SWCs
+     *    defaultsCssFiles should have the order: SWCS, C, B, A
+     */
+    private List<VirtualFile> defaultsCssFiles = new LinkedList<VirtualFile>();
+    
+    public List<VirtualFile> getDefaultsCssFiles()
+    {
+        return defaultsCssFiles;
+    }
+
+    public void addDefaultsCssFiles( Collection<VirtualFile> files )
+    {
+        // this list works backwards, the first CSS has lowest precedence
+        // so each add should insert at the front
+        // (see the javadoc for defaultsCssFiles)
+        defaultsCssFiles.addAll( 0, files );
+    }
+
+    public void cfgDefaultsCssFiles( ConfigurationValue cv, List paths )
+        throws ConfigurationException
+    {
+        final int defaultsCssFilesLastIndex = defaultsCssFiles.size();
+        
+        // verify and add the paths given
+        for (Iterator it = paths.iterator(); it.hasNext();)
+        {
+            final String path = (String) it.next();
+            VirtualFile css = ConfigurationPathResolver.getVirtualFile(path,
+                                                                       configResolver,
+                                                                       cv);
+            if (css == null)
+            {
+                throw new ConfigurationException.ConfigurationIOError(path,
+                                                                      cv.getVar(),
+                                                                      cv.getSource(),
+                                                                      cv.getLine());
+            }
+
+            // I start from defaultsCssFilesLastIndex so that the paths are in the correct
+            // precedence order (see the javadoc for defaultsCssFiles)
+            defaultsCssFiles.add(defaultsCssFilesLastIndex, css);
+        }
+    }
+
+    public static ConfigurationInfo getDefaultsCssFilesInfo()
+    {
+        return new ConfigurationInfo( -1, new String[] { "filename" } )
+        {
+            public boolean allowMultiple() { return true;  }
+            public boolean isAdvanced()    { return true;  }
+            public boolean doChecksum()    { return false; }
+        };
+    }
+    
+    /**
+     * Location of theme style stylesheets (css only, configured via themefiles above).
+     */
+    private List<VirtualFile> themeCssFiles = new LinkedList<VirtualFile>();
+
+    public List<VirtualFile> getThemeCssFiles()
+    {
+        return themeCssFiles;
+    }
+
+    public void addThemeCssFiles( List<VirtualFile> files )
+    {
+        themeCssFiles.addAll( files );
+    }
+
+    //
+    // 'compiler.translation-format' option (hidden)
+    //
+
+	private String translationFormat;
+
+    public String getTranslationFormat()
+    {
+        return translationFormat;
+    }
+
+    public void cfgTranslationFormat(ConfigurationValue cv, String t)
+    {
+        this.translationFormat = t;
+    }
+
+    public static ConfigurationInfo getTranslationFormatInfo()
+    {
+        return new ConfigurationInfo()
+        {
+            public boolean isHidden()
+            {
+                return true;
+            }
+        };
+    }
+
+	//
+    // 'compiler.use-resource-bundle-metadata' option
+    //
+
+	private boolean useResourceBundleMetadata = false;
+
+	public boolean useResourceBundleMetadata()
+	{
+		return useResourceBundleMetadata;
+	}
+
+	public void cfgUseResourceBundleMetadata(ConfigurationValue cv, boolean b)
+	{
+		useResourceBundleMetadata = b;
+	}
+
+	public static ConfigurationInfo getuseResourceBundleMetadataInfo()
+	{
+	    return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.verbose-stacktraces' option
+    //
+
+    private boolean verboseStacktraces;
+
+    public boolean verboseStacktraces()
+    {
+        return verboseStacktraces;
+    }
+
+    public void setVerboseStacktraces(boolean verboseStacktraces)
+	{
+	    this.verboseStacktraces = verboseStacktraces;
+	}
+
+    public void cfgVerboseStacktraces( ConfigurationValue cv, boolean verboseStacktraces )
+    {
+        this.verboseStacktraces = verboseStacktraces;
+    }
+
+	//
+    // 'compiler.warn-array-tostring-changes' option
+    //
+
+	private boolean warn_array_tostring_changes = false;
+
+	public boolean warn_array_tostring_changes()
+	{
+		return warn_array_tostring_changes;
+	}
+
+	public void cfgWarnArrayTostringChanges(ConfigurationValue cv, boolean b)
+	{
+		warn_array_tostring_changes = b;
+	}
+
+	public static ConfigurationInfo getWarnArrayTostringChangesInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-assignment-within-conditional' option
+    //
+
+	private boolean warn_assignment_within_conditional = true;
+
+	public boolean warn_assignment_within_conditional()
+	{
+		return warn_assignment_within_conditional;
+	}
+
+	public void cfgWarnAssignmentWithinConditional(ConfigurationValue cv, boolean b)
+	{
+		warn_assignment_within_conditional = b;
+	}
+
+	public static ConfigurationInfo getWarnAssignmentWithinConditionalInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-bad-array-cast' option
+    //
+
+	private boolean warn_bad_array_cast = true;
+
+	public boolean warn_bad_array_cast()
+	{
+		return warn_bad_array_cast;
+	}
+
+	public void cfgWarnBadArrayCast(ConfigurationValue cv, boolean b)
+	{
+		warn_bad_array_cast = b;
+	}
+
+	public static ConfigurationInfo getWarnBadArrayCastInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-bad-bool-assignment' option
+    //
+
+	private boolean warn_bad_bool_assignment = true;
+
+	public boolean warn_bad_bool_assignment()
+	{
+		return warn_bad_bool_assignment;
+	}
+
+	public void cfgWarnBadBoolAssignment(ConfigurationValue cv, boolean b)
+	{
+		warn_bad_bool_assignment = b;
+	}
+
+	public static ConfigurationInfo getWarnBadBoolAssignmentInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-bad-date-cast' option
+    //
+
+	private boolean warn_bad_date_cast = true;
+
+	public boolean warn_bad_date_cast()
+	{
+		return warn_bad_date_cast;
+	}
+
+	public void cfgWarnBadDateCast(ConfigurationValue cv, boolean b)
+	{
+		warn_bad_date_cast = b;
+	}
+
+	public static ConfigurationInfo getWarnBadDateCastInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-bad-es3-type-method' option
+    //
+
+	private boolean warn_bad_es3_type_method = true;
+
+	public boolean warn_bad_es3_type_method()
+	{
+		return warn_bad_es3_type_method;
+	}
+
+	public void cfgWarnBadEs3TypeMethod(ConfigurationValue cv, boolean b)
+	{
+		warn_bad_es3_type_method = b;
+	}
+
+	public static ConfigurationInfo getWarnBadEs3TypeMethodInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-bad-es3-type-prop' option
+    //
+
+	private boolean warn_bad_es3_type_prop = true;
+
+	public boolean warn_bad_es3_type_prop()
+	{
+		return warn_bad_es3_type_prop;
+	}
+
+	public void cfgWarnBadEs3TypeProp(ConfigurationValue cv, boolean b)
+	{
+		warn_bad_es3_type_prop = b;
+	}
+
+	public static ConfigurationInfo getWarnBadEs3TypePropInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-bad-nan-comparison' option
+    //
+
+	private boolean warn_bad_nan_comparison = true;
+
+	public boolean warn_bad_nan_comparison()
+	{
+		return warn_bad_nan_comparison;
+	}
+
+	public void cfgWarnBadNanComparison(ConfigurationValue cv, boolean b)
+	{
+		warn_bad_nan_comparison = b;
+	}
+
+	public static ConfigurationInfo getWarnBadNanComparisonInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-bad-null-assignment' option
+    //
+
+	private boolean warn_bad_null_assignment = true;
+
+	public boolean warn_bad_null_assignment()
+	{
+		return warn_bad_null_assignment;
+	}
+
+	public void cfgWarnBadNullAssignment(ConfigurationValue cv, boolean b)
+	{
+		warn_bad_null_assignment = b;
+	}
+
+	public static ConfigurationInfo getWarnBadNullAssignmentInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-bad-null-comparison' option
+    //
+
+	private boolean warn_bad_null_comparison = true;
+
+	public boolean warn_bad_null_comparison()
+	{
+		return warn_bad_null_comparison;
+	}
+
+	public void cfgWarnBadNullComparison(ConfigurationValue cv, boolean b)
+	{
+		warn_bad_null_comparison = b;
+	}
+
+	public static ConfigurationInfo getWarnBadNullComparisonInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-bad-undefined-comparison' option
+    //
+
+	private boolean warn_bad_undefined_comparison = true;
+
+	public boolean warn_bad_undefined_comparison()
+	{
+		return warn_bad_undefined_comparison;
+	}
+
+	public void cfgWarnBadUndefinedComparison(ConfigurationValue cv, boolean b)
+	{
+		warn_bad_undefined_comparison = b;
+	}
+
+	public static ConfigurationInfo getWarnBadUndefinedComparisonInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-boolean-constructor-with-no-args' option
+    //
+
+	private boolean warn_boolean_constructor_with_no_args = false;
+
+	public boolean warn_boolean_constructor_with_no_args()
+	{
+		return warn_boolean_constructor_with_no_args;
+	}
+
+	public void cfgWarnBooleanConstructorWithNoArgs(ConfigurationValue cv, boolean b)
+	{
+		warn_boolean_constructor_with_no_args = b;
+	}
+
+	public static ConfigurationInfo getWarnBooleanConstructorWithNoArgsInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-changes-in-resolve' option
+    //
+
+	private boolean warn_changes_in_resolve = false;
+
+	public boolean warn_changes_in_resolve()
+	{
+		return warn_changes_in_resolve;
+	}
+
+	public void cfgWarnChangesInResolve(ConfigurationValue cv, boolean b)
+	{
+		warn_changes_in_resolve = b;
+	}
+
+	public static ConfigurationInfo getWarnChangesInResolveInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-class-is-sealed' option
+    //
+
+	private boolean warn_class_is_sealed = false;
+
+	public boolean warn_class_is_sealed()
+	{
+		return warn_class_is_sealed;
+	}
+
+	public void cfgWarnClassIsSealed(ConfigurationValue cv, boolean b)
+	{
+		warn_class_is_sealed = b;
+	}
+
+	public static ConfigurationInfo getWarnClassIsSealedInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-const-not-initialized' option
+    //
+
+	private boolean warn_const_not_initialized = true;
+
+	public boolean warn_const_not_initialized()
+	{
+		return warn_const_not_initialized;
+	}
+
+	public void cfgWarnConstNotInitialized(ConfigurationValue cv, boolean b)
+	{
+		warn_const_not_initialized = b;
+	}
+
+	public static ConfigurationInfo getWarnConstNotInitializedInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-constructor-returns-value' option
+    //
+
+	private boolean warn_constructor_returns_value = false;
+
+	public boolean warn_constructor_returns_value()
+	{
+		return warn_constructor_returns_value;
+	}
+
+	public void cfgWarnConstructorReturnsValue(ConfigurationValue cv, boolean b)
+	{
+		warn_constructor_returns_value = b;
+	}
+
+	public static ConfigurationInfo getWarnConstructorReturnsValueInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-deprecated-event-handler-error' option
+    //
+
+	private boolean warn_deprecated_event_handler_error = false;
+
+	public boolean warn_deprecated_event_handler_error()
+	{
+		return warn_deprecated_event_handler_error;
+	}
+
+	public void cfgWarnDeprecatedEventHandlerError(ConfigurationValue cv, boolean b)
+	{
+		warn_deprecated_event_handler_error = b;
+	}
+
+	public static ConfigurationInfo getWarnDeprecatedEventHandlerErrorInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-deprecated-function-error' option
+    //
+
+	private boolean warn_deprecated_function_error = false;
+
+	public boolean warn_deprecated_function_error()
+	{
+		return warn_deprecated_function_error;
+	}
+
+	public void cfgWarnDeprecatedFunctionError(ConfigurationValue cv, boolean b)
+	{
+		warn_deprecated_function_error = b;
+	}
+
+	public static ConfigurationInfo getWarnDeprecatedFunctionErrorInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-deprecated-property-error' option
+    //
+
+	private boolean warn_deprecated_property_error = false;
+
+	public boolean warn_deprecated_property_error()
+	{
+		return warn_deprecated_property_error;
+	}
+
+	public void cfgWarnDeprecatedPropertyError(ConfigurationValue cv, boolean b)
+	{
+		warn_deprecated_property_error = b;
+	}
+
+	public static ConfigurationInfo getWarnDeprecatedPropertyErrorInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-duplicate-argument-names' option
+    //
+
+	private boolean warn_duplicate_argument_names = true;
+
+	public boolean warn_duplicate_argument_names()
+	{
+		return warn_duplicate_argument_names;
+	}
+
+	public void cfgWarnDuplicateArgumentNames(ConfigurationValue cv, boolean b)
+	{
+		warn_duplicate_argument_names = b;
+	}
+
+	public static ConfigurationInfo getWarnDuplicateArgumentNamesInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-duplicate-variable-def' option
+    //
+
+	private boolean warn_duplicate_variable_def = true;
+
+	public boolean warn_duplicate_variable_def()
+	{
+		return warn_duplicate_variable_def;
+	}
+
+	public void cfgWarnDuplicateVariableDef(ConfigurationValue cv, boolean b)
+	{
+		warn_duplicate_variable_def = b;
+	}
+
+	public static ConfigurationInfo getWarnDuplicateVariableDefInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-for-var-in-changes' option
+    //
+
+	private boolean warn_for_var_in_changes = false;
+
+	public boolean warn_for_var_in_changes()
+	{
+		return warn_for_var_in_changes;
+	}
+
+	public void cfgWarnForVarInChanges(ConfigurationValue cv, boolean b)
+	{
+		warn_for_var_in_changes = b;
+	}
+
+	public static ConfigurationInfo getWarnForVarInChangesInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+    //
+    // 'compiler.warn-import-hides-class' option
+    //
+
+	private boolean warn_import_hides_class = true;
+
+	public boolean warn_import_hides_class()
+	{
+		return warn_import_hides_class;
+	}
+
+	public void cfgWarnImportHidesClass(ConfigurationValue cv, boolean b)
+	{
+		warn_import_hides_class = b;
+	}
+
+	public static ConfigurationInfo getWarnImportHidesClassInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-instance-of-changes' option
+    //
+
+	private boolean warn_instance_of_changes = true;
+
+	public boolean warn_instance_of_changes()
+	{
+		return warn_instance_of_changes;
+	}
+
+	public void cfgWarnInstanceOfChanges(ConfigurationValue cv, boolean b)
+	{
+		warn_instance_of_changes = b;
+	}
+
+	public static ConfigurationInfo getWarnInstanceOfChangesInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-internal-error' option
+    //
+
+	private boolean warn_internal_error = true;
+
+	public boolean warn_internal_error()
+	{
+		return warn_internal_error;
+	}
+
+	public void cfgWarnInternalError(ConfigurationValue cv, boolean b)
+	{
+		warn_internal_error = b;
+	}
+
+	public static ConfigurationInfo getWarnInternalErrorInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-level-not-supported' option
+    //
+
+	private boolean warn_level_not_supported = false;
+
+	public boolean warn_level_not_supported()
+	{
+		return warn_level_not_supported;
+	}
+
+	public void cfgWarnLevelNotSupported(ConfigurationValue cv, boolean b)
+	{
+		warn_level_not_supported = b;
+	}
+
+	public static ConfigurationInfo getWarnLevelNotSupportedInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-missing-namespace-decl' option
+    //
+
+	private boolean warn_missing_namespace_decl = true;
+
+	public boolean warn_missing_namespace_decl()
+	{
+		return warn_missing_namespace_decl;
+	}
+
+	public void cfgWarnMissingNamespaceDecl(ConfigurationValue cv, boolean b)
+	{
+		warn_missing_namespace_decl = b;
+	}
+
+	public static ConfigurationInfo getWarnMissingNamespaceDeclInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-negative-uint-literal' option
+    //
+
+	private boolean warn_negative_uint_literal = true;
+
+	public boolean warn_negative_uint_literal()
+	{
+		return warn_negative_uint_literal;
+	}
+
+	public void cfgWarnNegativeUintLiteral(ConfigurationValue cv, boolean b)
+	{
+		warn_negative_uint_literal = b;
+	}
+
+	public static ConfigurationInfo getWarnNegativeUintLiteralInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-no-constructor' option
+    //
+
+	private boolean warn_no_constructor = true;
+
+	public boolean warn_no_constructor()
+	{
+		return warn_no_constructor;
+	}
+
+	public void cfgWarnNoConstructor(ConfigurationValue cv, boolean b)
+	{
+		warn_no_constructor = b;
+	}
+
+	public static ConfigurationInfo getWarnNoConstructorInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-no-explicit-super-call-in-constructor' option
+    //
+
+	private boolean warn_no_explicit_super_call_in_constructor = false;
+
+	public boolean warn_no_explicit_super_call_in_constructor()
+	{
+		return warn_no_explicit_super_call_in_constructor;
+	}
+
+	public void cfgWarnNoExplicitSuperCallInConstructor(ConfigurationValue cv, boolean b)
+	{
+		warn_no_explicit_super_call_in_constructor = b;
+	}
+
+	public static ConfigurationInfo getWarnNoExplicitSuperCallInConstructorInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-no-type-decl' option
+    //
+
+	private boolean warn_no_type_decl = true;
+
+	public boolean warn_no_type_decl()
+	{
+		return warn_no_type_decl;
+	}
+
+	public void cfgWarnNoTypeDecl(ConfigurationValue cv, boolean b)
+	{
+		warn_no_type_decl = b;
+	}
+
+	public static ConfigurationInfo getWarnNoTypeDeclInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-number-from-string-changes' option
+    //
+
+	private boolean warn_number_from_string_changes = false;
+
+	public boolean warn_number_from_string_changes()
+	{
+		return warn_number_from_string_changes;
+	}
+
+	public void cfgWarnNumberFromStringChanges(ConfigurationValue cv, boolean b)
+	{
+		warn_number_from_string_changes = b;
+	}
+
+	public static ConfigurationInfo getWarnNumberFromStringChangesInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-scoping-change-in-this' option
+    //
+
+	private boolean warn_scoping_change_in_this = false;
+
+	public boolean warn_scoping_change_in_this()
+	{
+		return warn_scoping_change_in_this;
+	}
+
+	public void cfgWarnScopingChangeInThis(ConfigurationValue cv, boolean b)
+	{
+		warn_scoping_change_in_this = b;
+	}
+
+	public static ConfigurationInfo getWarnScopingChangeInThisInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-slow-text-field-addition' option
+    //
+
+	private boolean warn_slow_text_field_addition = true;
+
+	public boolean warn_slow_text_field_addition()
+	{
+		return warn_slow_text_field_addition;
+	}
+
+	public void cfgWarnSlowTextFieldAddition(ConfigurationValue cv, boolean b)
+	{
+		warn_slow_text_field_addition = b;
+	}
+
+	public static ConfigurationInfo getWarnSlowTextFieldAdditionInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-unlikely-function-value' option
+    //
+
+	private boolean warn_unlikely_function_value = true;
+
+	public boolean warn_unlikely_function_value()
+	{
+		return warn_unlikely_function_value;
+	}
+
+	public void cfgWarnUnlikelyFunctionValue(ConfigurationValue cv, boolean b)
+	{
+		warn_unlikely_function_value = b;
+	}
+
+	public static ConfigurationInfo getWarnUnlikelyFunctionValueInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+    // 'compiler.warn-xml-class-has-changed' option
+    //
+
+	private boolean warn_xml_class_has_changed = false;
+
+	public boolean warn_xml_class_has_changed()
+	{
+		return warn_xml_class_has_changed;
+	}
+
+	public void cfgWarnXmlClassHasChanged(ConfigurationValue cv, boolean b)
+	{
+		warn_xml_class_has_changed = b;
+	}
+
+	public static ConfigurationInfo getWarnXmlClassHasChangedInfo()
+	{
+		return new AdvancedConfigurationInfo();
+	}
+
+	//
+	// compiler.archive-classes-and-assets
+	//
+
+	private boolean archiveClassesAndAssets = false;
+
+	public boolean archiveClassesAndAssets()
+	{
+		return archiveClassesAndAssets;
+	}
+
+	public void cfgArchiveClassesAndAssets(ConfigurationValue cv, boolean b)
+	{
+		archiveClassesAndAssets = b;
+	}
+
+	public static ConfigurationInfo getArchiveClassesAndAssetsInfo()
+	{
+		return new ConfigurationInfo()
+		{
+			public boolean isHidden()
+			{
+				return true;
+			}
+
+			public boolean doChecksum()
+			{
+				return false;
+			}
+		};
+	}
+
+	//
+	// compiler.generate-abstract-syntax-tree
+	//
+
+	private boolean generateAbstractSyntaxTree = true;
+
+	public void cfgGenerateAbstractSyntaxTree(ConfigurationValue cv, boolean b)
+	{
+		generateAbstractSyntaxTree = b;
+	}
+
+	public boolean getGenerateAbstractSyntaxTree()
+	{
+		return generateAbstractSyntaxTree;
+	}
+
+	public static ConfigurationInfo getGenerateAbstractSyntaxTreeInfo()
+	{
+		return new ConfigurationInfo()
+		{
+			public boolean isHidden()
+			{
+				return true;
+			}
+
+			public boolean doChecksum()
+			{
+				return false;
+			}
+		};
+	}
+
+    //
+    // 'compiler.extensions.*' option
+    //
+
+    private ExtensionsConfiguration extensionsConfig;
+
+    public ExtensionsConfiguration getExtensionsConfiguration()
+    {
+        return this.extensionsConfig;
+    }
+
+    //
+    // 'compiler.isolateStyles' option
+    //
+
+    // Allow the user to decide if the compiled application/module should have its
+    // own style manager. Turn off isolate styles for compatibility less than 4.0.
+    private boolean isolateStyles = true;
+
+    public boolean getIsolateStyles()
+    {
+        return isolateStyles &&
+               (getCompatibilityVersion() >= flex2.compiler.common.MxmlConfiguration.VERSION_4_0);
+    }
+
+    public void cfgIsolateStyles( ConfigurationValue cv, boolean isolateStyles )
+    {
+        this.isolateStyles = isolateStyles;
+    }
+
+    public static ConfigurationInfo getIsolateStylesInfo()
+    {
+        return new AdvancedConfigurationInfo();
+    }
+
+    //
+    // 'compiler.allow-duplicate-style-declaration' option
+    //
+
+    // If true, a style manager will add style declarations to the local
+    // style manager without checking to see if the parent already
+    // has the same style selector with the same properties. If false,
+    // a style manager will check the parent to make sure a style
+    // with the same properties does not already exist before adding
+    // one locally.
+	// If there is no local style manager created for this application, 
+    // then don't check for duplicates. Just use the old "selector exists" test. 
+    private boolean allowDuplicateDefaultStyleDeclarations = false;
+
+    public boolean getAllowDuplicateDefaultStyleDeclarations()
+    {
+    	if (getIsolateStyles())
+    		return allowDuplicateDefaultStyleDeclarations;
+    	else
+    		return true;
+    }
+
+    public void cfgAllowDuplicateDefaultStyleDeclarations( ConfigurationValue cv, boolean allowDuplicateDefaultStyleDeclarations)
+    {
+        this.allowDuplicateDefaultStyleDeclarations = allowDuplicateDefaultStyleDeclarations;
+    }
+
+    public static ConfigurationInfo getAllowDuplicateDefaultStyleDeclarationsInfo()
+    {
+        return new AdvancedConfigurationInfo()
+        {
+			public boolean isHidden()
+            {
+                return true;
+            }
+        };
+    }
+
+    // 'compiler.java-profiler' option
+	
+    //  When set, the compiler will attempt to load the specified
+    //  profiler class by name and use it as the profile event sink.
+    private String javaProfilerClass = null;
+    
+    public void cfgJavaProfilerClass(ConfigurationValue cv, String profilerClass)
+    {
+        this.javaProfilerClass = profilerClass;
+    }
+    
+    public String getJavaProfilerClass()
+    {
+        return this.javaProfilerClass;
+    }
+    
+    public static ConfigurationInfo getJavaProfilerClassInfo()
+    {
+        return new AdvancedConfigurationInfo()
+        {
+            public boolean isHidden()
+            {
+                return true;
+            }
+        };
+    }
+    
+    //
+    // 'compiler.advanced-telemetry' option
+    //
+
+    private boolean advancedTelemetry;
+
+    public boolean getAdvancedTelemetry()
+    {
+        return advancedTelemetry;
+    }
+
+    public void setAdvancedTelemetry(boolean accessible)
+    {
+        this.advancedTelemetry = advancedTelemetry;
+    }
+
+    public void cfgAdvancedTelemetry( ConfigurationValue cv, boolean advancedTelemetry )
+    {
+        this.advancedTelemetry = advancedTelemetry;
+    }
+    
+    @Override
+    public Object clone()
+        throws CloneNotSupportedException
+    {
+        return super.clone();
+    }
+    
+    
+    
+}


Mime
View raw message