/*
*
* 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)
{
if(files != null) {
File[] fileArray = new File[files.length];
int length = files.length;
for (int i = 0; i < length; i++) {
fileArray[i] = new File(files[i]);
}
return fileArray;
}
return new File[0];
}
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=<name>,<value></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(Exception e)
{
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 advancedTelemetry)
{
this.advancedTelemetry = advancedTelemetry;
}
public void cfgAdvancedTelemetry( ConfigurationValue cv, boolean advancedTelemetry )
{
this.advancedTelemetry = advancedTelemetry;
}
@Override
public Object clone()
throws CloneNotSupportedException
{
return super.clone();
}
}