Java tutorial
/* * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ package org.apache.flex.compiler.config; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.InputStream; import java.io.StringWriter; import java.io.Writer; import java.text.DateFormat; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Date; import java.util.Deque; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Properties; import java.util.Set; import java.util.TreeSet; import java.util.regex.Pattern; import javax.xml.stream.XMLOutputFactory; import javax.xml.stream.XMLStreamException; import javax.xml.stream.XMLStreamWriter; import org.apache.commons.io.FilenameUtils; import org.apache.commons.io.IOUtils; import org.apache.flex.compiler.common.IPathResolver; import org.apache.flex.compiler.common.VersionInfo; import org.apache.flex.compiler.exceptions.ConfigurationException; import org.apache.flex.compiler.exceptions.ConfigurationException.CannotOpen; import org.apache.flex.compiler.exceptions.ConfigurationException.IncorrectArgumentCount; import org.apache.flex.compiler.exceptions.ConfigurationException.NotAFile; import org.apache.flex.compiler.exceptions.ConfigurationException.NotDirectory; import org.apache.flex.compiler.exceptions.ConfigurationException.RedundantFile; import org.apache.flex.compiler.filespecs.FileSpecification; import org.apache.flex.compiler.filespecs.IFileSpecification; import org.apache.flex.compiler.internal.config.FileConfigurator; import org.apache.flex.compiler.internal.config.FrameInfo; import org.apache.flex.compiler.internal.config.LoadExternsParser; import org.apache.flex.compiler.internal.config.QNameNormalization; import org.apache.flex.compiler.internal.config.RSLArgumentNameGenerator; import org.apache.flex.compiler.internal.config.RuntimeSharedLibraryPathInfo; import org.apache.flex.compiler.internal.config.annotations.ArgumentNameGenerator; import org.apache.flex.compiler.internal.config.annotations.Arguments; import org.apache.flex.compiler.internal.config.annotations.Config; import org.apache.flex.compiler.internal.config.annotations.DefaultArgumentValue; import org.apache.flex.compiler.internal.config.annotations.DeprecatedConfig; import org.apache.flex.compiler.internal.config.annotations.FlexOnly; import org.apache.flex.compiler.internal.config.annotations.InfiniteArguments; import org.apache.flex.compiler.internal.config.annotations.Mapping; import org.apache.flex.compiler.internal.config.annotations.SoftPrerequisites; import org.apache.flex.compiler.internal.config.localization.LocalizationManager; import org.apache.flex.compiler.mxml.IMXMLTypeConstants; import org.apache.flex.compiler.mxml.MXMLNamespaceMapping; import org.apache.flex.compiler.problems.ConfigurationProblem; import org.apache.flex.compiler.problems.DeprecatedConfigurationOptionProblem; import org.apache.flex.compiler.problems.FlexOnlyConfigurationOptionNotSupported; import org.apache.flex.compiler.problems.ICompilerProblem; import org.apache.flex.compiler.problems.RemovedConfigurationOptionProblem; import org.apache.flex.swc.catalog.XMLFormatter; import org.apache.flex.utils.FileUtils; import org.apache.flex.utils.FilenameNormalization; import com.google.common.base.Function; import com.google.common.base.Splitter; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Iterables; import com.google.common.collect.Lists; /** * The model for all the configuration options supported by the compiler. Each * option is stored in a private field. It usually has a getter method, a setter * method and a configuration method (started with "cfg"). The configuration * methods are used by the configurators to set the values of a given option * name. * <p> * This class is currently being reviewed and refactored. See CMP-471 as the * master bug for the tasks. * <p> * Steps to refactor: * <ol> * <li>Check "mxmlc" manual (http://adobe.ly/bffN8A) and copy documents to * Javadoc on setters of options.</li> * <li>Check "configuration support" WIKI (http://bit.ly/oAI8gj) to see if an * option should be deprecated.</li> * <li>Merge {@code cfgXXX} to {@code setXXX}, and annotate the setter.</li> * <li>Remove {@code getXXXInfo()} static method.</li> * </ol> * * @see "http://bugs.adobe.com/jira/browse/CMP-471" */ public class Configuration { private static final int DEFAULT_HEIGHT_MAX = 4096; private static final int DEFAULT_HEIGHT_MIN = 1; private static final int DEFAULT_WIDTH_MAX = 4096; private static final int DEFAULT_WIDTH_MIN = 1; public static final String DEFAULT_OUTPUT_DIRECTORY_TOKEN = "org.apache.flex.default.output.directory"; public static final String SWC_AIRGLOBAL = "airglobal.swc"; /** * Singleton empty string list. All getters returning a list of string * should return this object when the field is null. */ private static final List<String> EMPTY_STRING_LIST = Collections.emptyList(); private static final List<String> compcOnlyOptions = new ArrayList<String>(9); static { compcOnlyOptions.add("directory"); compcOnlyOptions.add("include-classes"); compcOnlyOptions.add("include-file"); compcOnlyOptions.add("include-lookup-only"); compcOnlyOptions.add("include-namespaces"); compcOnlyOptions.add("include-sources"); compcOnlyOptions.add("include-stylesheet"); compcOnlyOptions.add("include-inheritance-dependencies-only"); } /** * Validate configuration options values. * * @param configurationBuffer Configuration buffer. * @throws ConfigurationException Error. */ public void validate(ConfigurationBuffer configurationBuffer) throws ConfigurationException { // process the merged configuration buffer. right, can't just process the args. processDeprecatedAndRemovedOptions(configurationBuffer); validateDumpConfig(configurationBuffer); } /** * Validate that no compc-only options are used in a given configuration buffer. * Use this method to verify no compc-only args are used in mxmlc. * * @param configurationBuffer the configuration buffer to check for compc-only options. * * @throws ConfigurationException if a compc-only option is found in the configuration buffer. */ public static void validateNoCompcOnlyOptions(ConfigurationBuffer configurationBuffer) throws ConfigurationException { for (String option : compcOnlyOptions) { List<ConfigurationValue> values = configurationBuffer.getVar(option); if (values != null && values.size() > 0) throw new ConfigurationException.UnknownVariable(values.get(0).getVar(), values.get(0).getSource(), values.get(0).getLine()); } } /** * The path of a given file name based on the context of the configuration * value or the default output directory token. * * @param cv * @param fileName * @return the full path of the file. */ protected String getOutputPath(ConfigurationValue cv, String fileName) { String result = fileName; if (fileName != null) { File file = new File(fileName); if (!FileUtils.isAbsolute(file)) { String directory = cv.getBuffer().getToken(DEFAULT_OUTPUT_DIRECTORY_TOKEN); // if no default output directory, then use the configuration context. if (directory == null) { directory = cv.getContext(); } if (directory != null) { result = FileUtils.addPathComponents(directory, fileName, File.separatorChar); } } } return pathResolver.resolve(result).getAbsolutePath(); } private static Map<String, String> aliases = null; public static Map<String, String> getAliases() { if (aliases == null) { aliases = new HashMap<String, String>(); aliases.put("l", "compiler.library-path"); aliases.put("el", "compiler.external-library-path"); aliases.put("sp", "compiler.source-path"); aliases.put("rsl", "runtime-shared-libraries"); aliases.put("keep", "compiler.keep-generated-actionscript"); aliases.put("o", "output"); aliases.put("rslp", "runtime-shared-library-path"); aliases.put("static-rsls", "static-link-runtime-shared-libraries"); } return aliases; } // // PathResolver // private IPathResolver pathResolver; /** * Set a path resolver to resolver files relative to a * configuration. Files inside of configuration files are resolved relative * to those configuration files and files on the command line are resolved * relative to the root directory of the compile. * * @param pathResolver a path resolver for this configuration. May not be null. */ public void setPathResolver(IPathResolver pathResolver) { this.pathResolver = pathResolver; } // // mainDefinition // private String mainDefinition; /** * Main definition is the root class of a SWF. {@code mxmlc} only takes one * file in the source list. The main definition name is the main source file * name. * * @return main definition */ public String getMainDefinition() { return mainDefinition; } public void setMainDefinition(String mainDefinition) { assert mainDefinition != null : "main definition can't be null"; assert !"".equals(mainDefinition) : "main definition can't be empty"; this.mainDefinition = mainDefinition; } // // 'benchmark' option // @Config(removed = true) @Mapping("benchmark") public void setBenchmark(ConfigurationValue cv, boolean b) { } // // 'debug-password' option // private String debugPassword; /** * Lets you engage in remote debugging sessions with the Flash IDE. */ public String getDebugPassword() { return debugPassword; } @Config(advanced = true) @Mapping("debug-password") @DefaultArgumentValue("") public void setDebugPassword(ConfigurationValue cv, String debugPassword) { this.debugPassword = debugPassword; } // // 'default-background-color' option // private int backgroundColor = 0x50727E; public int getDefaultBackgroundColor() { return this.backgroundColor; } @Config(advanced = true) @Mapping("default-background-color") public void setDefaultBackgroundColor(ConfigurationValue cv, int backgroundColor) { this.backgroundColor = backgroundColor; } // // 'default-frame-rate' option // private int frameRate = 24; public int getDefaultFrameRate() { return frameRate; } @Config(advanced = true) @Mapping("default-frame-rate") public void setDefaultFrameRate(ConfigurationValue cv, int rate) throws ConfigurationException { if (rate <= 0) throw new ConfigurationException.GreaterThanZero(cv.getVar(), cv.getSource(), cv.getLine()); frameRate = rate; } // // 'default-script-limits' option // private int scriptLimit = 60; private int scriptRecursionLimit = 1000; private boolean scriptLimitsSet = false; public int getScriptTimeLimit() { return scriptLimit; } public int getScriptRecursionLimit() { return scriptRecursionLimit; } public boolean scriptLimitsSet() { return scriptLimitsSet; } @Config(advanced = true) @Mapping("default-script-limits") @Arguments({ "max-recursion-depth", "max-execution-time" }) public void setDefaultScriptLimits(ConfigurationValue cv, int scriptLimit, int scriptRecursionLimit) throws ConfigurationException { if (scriptLimit <= 0) throw new ConfigurationException.GreaterThanZero(cv.getVar(), cv.getSource(), cv.getLine()); if (scriptRecursionLimit <= 0) throw new ConfigurationException.GreaterThanZero(cv.getVar(), cv.getSource(), cv.getLine()); this.scriptLimitsSet = true; this.scriptLimit = scriptRecursionLimit; this.scriptRecursionLimit = scriptLimit; } // // 'default-size' option // private int defaultWidth = 500; private int defaultHeight = 375; public int getDefaultWidth() { return defaultWidth; } public int getDefaultHeight() { return defaultHeight; } @Config(advanced = true) @Arguments({ "width", "height" }) @Mapping("default-size") public void setDefaultSize(ConfigurationValue cv, int width, int height) throws ConfigurationException { if (width < DEFAULT_WIDTH_MIN || width > DEFAULT_WIDTH_MAX || height < DEFAULT_HEIGHT_MIN || height > DEFAULT_HEIGHT_MAX) throw new ConfigurationException.IllegalDimensions(width, height, cv.getVar(), cv.getSource(), cv.getLine()); this.defaultWidth = width; this.defaultHeight = height; } // // 'externs' option // private final Set<String> externs = new LinkedHashSet<String>(); public Set<String> getExterns() { return externs; } /** * Sets a list of classes to exclude from linking when compiling a SWF file. * This option provides compile-time link checking for external references * that are dynamically linked. */ @Config(advanced = true, allowMultiple = true) @Mapping("externs") @Arguments("symbol") @InfiniteArguments public void setExterns(ConfigurationValue cfgval, List<String> vals) { externs.addAll(QNameNormalization.normalize(vals)); } // // 'includes' option // private final Set<String> includes = new LinkedHashSet<String>(); public Set<String> getIncludes() { return includes; } /** * Links one or more classes to the resulting application SWF file, whether * or not those classes are required at compile time. To link an entire SWC * file rather than individual classes, use the include-libraries option. */ @Config(allowMultiple = true, advanced = true) @Mapping("includes") @Arguments("symbol") @InfiniteArguments public void setIncludes(ConfigurationValue cfgval, List<String> vals) { includes.addAll(QNameNormalization.normalize(vals)); } // // 'framework' option // // @Config(allowMultiple = true, advanced = true, removed = true) @Mapping("framework") public void setFramework(ConfigurationValue cfgval, String value) { } // 'link-report' option // private String linkReportFileName = null; public File getLinkReport() { return linkReportFileName != null ? new File(linkReportFileName) : null; } /** * Prints linking information to the specified output file. This file is an * XML file that contains {@code def} tags, {@code pre} tags and {@code ext} * tags showing linker dependencies in the final SWF file. The file format * output by this command can be used to write a file for input to the * {@code load-externs} option. */ @Config(advanced = true) @Mapping("link-report") @Arguments("filename") public void setLinkReport(ConfigurationValue cv, String filename) { this.linkReportFileName = getOutputPath(cv, filename); } // // 'size-report' option // private String sizeReportFileName = null; public File getSizeReport() { return sizeReportFileName != null ? new File(sizeReportFileName) : null; } @Config(advanced = true) @Mapping("size-report") @Arguments("filename") public void setSizeReport(ConfigurationValue cv, String filename) { this.sizeReportFileName = getOutputPath(cv, filename); } // // 'load-externs' option // /** * Specifies the location of an XML file that contains def, pre, and ext * symbols to omit from linking when compiling a SWF file. The XML file uses * the same syntax as the one produced by the link-report option. * <p> * This option provides compile-time link checking for external components * that are dynamically linked. */ @Config(allowMultiple = true, advanced = true) @Mapping("load-externs") @Arguments("filename") public void setLoadExterns(ConfigurationValue cfgval, String filename) throws ConfigurationException { final String path = resolvePathStrict(filename, cfgval); final FileSpecification f = new FileSpecification(path); final List<String> externsFromFile = LoadExternsParser.collectExterns(cfgval, f); externs.addAll(externsFromFile); } // // 'raw-metadata' option // private String metadata = null; public String getRawMetadata() { if (metadata != null) return metadata; return generateMetadata(); } private static final String RDF_URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"; private static final String DC_URI = "http://purl.org/dc/elements/1.1"; /** * @return Metadata XML string. */ private final String generateMetadata() { final XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance(); assert xmlOutputFactory != null : "Expect XMLOutputFactory implementation."; final StringWriter stringWriter = new StringWriter(); XMLStreamWriter xmlWriter = null; try { xmlWriter = new XMLFormatter(xmlOutputFactory.createXMLStreamWriter(stringWriter)); xmlWriter.writeStartDocument(); xmlWriter.writeStartElement("rdf", "RDF", RDF_URI); xmlWriter.setPrefix("rdf", RDF_URI); xmlWriter.writeNamespace("rdf", RDF_URI); // write rdf:Description xmlWriter.writeStartElement(RDF_URI, "Description"); xmlWriter.setPrefix("dc", DC_URI); xmlWriter.setPrefix(VersionInfo.COMPILER_NAMESPACE_PREFIX, VersionInfo.COMPILER_NAMESPACE_URI); xmlWriter.writeNamespace("dc", DC_URI); xmlWriter.writeNamespace(VersionInfo.COMPILER_NAMESPACE_PREFIX, VersionInfo.COMPILER_NAMESPACE_URI); // write dc:format xmlWriter.writeStartElement(DC_URI, "format"); xmlWriter.writeCharacters("application/x-shockwave-flash"); xmlWriter.writeEndElement(); if (isFlex()) { // write localizedTitles writeMap(xmlWriter, DC_URI, "description", localizedDescriptions); // write localizedDescription writeMap(xmlWriter, DC_URI, "title", localizedTitles); // write publisher writeCollection(xmlWriter, DC_URI, "publisher", publishers); // write creators writeCollection(xmlWriter, DC_URI, "creator", creators); // write contributor writeCollection(xmlWriter, DC_URI, "contributor", contributors); // write language writeCollection(xmlWriter, DC_URI, "language", langs); // write date writeDate(xmlWriter); } // write compiledBy writeCompiledBy(xmlWriter); // write xmlWriter.writeEndElement(); // Description xmlWriter.writeEndDocument(); } catch (XMLStreamException e) { return ""; } return stringWriter.toString(); } /** * Write information about the compiler that compiled the swf. * * @param writer * @throws XMLStreamException */ private void writeCompiledBy(XMLStreamWriter writer) throws XMLStreamException { writer.writeEmptyElement(VersionInfo.COMPILER_NAMESPACE_URI, VersionInfo.COMPILER_ELEMENT); writer.writeAttribute(VersionInfo.COMPILER_NAME_ATTRIBUTE, VersionInfo.getCompilerName()); writer.writeAttribute(VersionInfo.COMPILER_VERSION_ATTRIBUTE, VersionInfo.getCompilerVersion()); writer.writeAttribute(VersionInfo.COMPILER_BUILD_ATTRIBUTE, VersionInfo.getCompilerBuild()); writer.writeEndElement(); // compiledBy } /** * Write the data to rdf/xml * * @param writer * @throws XMLStreamException */ private void writeDate(XMLStreamWriter writer) throws XMLStreamException { if (date == null) { date = DateFormat.getDateInstance().format(new Date()); } writer.writeStartElement(DC_URI, "date"); writer.writeCharacters(date); writer.writeEndElement(); } /** * Write a map of values to rdf/xml * * @param writer * @param namespaceURI * @param localName * @param mapData * @throws XMLStreamException */ private void writeMap(XMLStreamWriter writer, String namespaceURI, String localName, Map<String, String> mapData) throws XMLStreamException { if (mapData.size() > 0) { writer.writeStartElement(namespaceURI, localName); if ((mapData.size() == 1) && (mapData.get("x-default") != null)) { String data = mapData.get("x-default"); writer.writeCharacters(data); } else { writer.writeStartElement(RDF_URI, "Alt"); for (final String key : mapData.keySet()) { final String value = mapData.get(key); writer.writeStartElement(RDF_URI, "li"); writer.writeAttribute("xml", "", "lang", key); writer.writeCharacters(value); writer.writeEndElement(); } writer.writeEndElement(); } writer.writeEndElement(); } } /** * Write a collection values to rdf/xml. * * @param writer * @param namespaceURI * @param localName * @param values * @throws XMLStreamException */ private void writeCollection(XMLStreamWriter writer, String namespaceURI, String localName, Collection<String> values) throws XMLStreamException { if (values.isEmpty()) return; writer.writeStartElement(namespaceURI, localName); if (values.size() > 1) writer.writeStartElement(RDF_URI, "Bag"); for (String value : values) { writer.writeCharacters(value); } if (values.size() > 1) writer.writeEndElement(); writer.writeEndElement(); } /** * Defines the metadata for the resulting SWF file. The value of this option * overrides any metadata-related compiler options such as contributor, * creator, date, and description. */ @Config(advanced = true) @Mapping("raw-metadata") @Arguments("text") public void setRawMetadata(ConfigurationValue cv, String xml) throws ConfigurationException { if (metadata != null) { throw new ConfigurationException.BadMetadataCombo(cv.getVar(), cv.getSource(), cv.getLine()); } this.metadata = xml; } // // 'resource-bundle-list' option // private String rbListFileName = null; public String getResourceBundleList() { return rbListFileName; } // // 'include-resource-bundles' option // /** * include-resource-bundles [...] */ private List<String> includeResourceBundles = new ArrayList<String>(); /** * @return a list of resource bundles to include in the swc */ public List<String> getIncludeResourceBundles() { return includeResourceBundles; } /** * Sets the resource bundles that should be included in this SWC or SWF. This list * can have locale independent qualified name for property files * (with the name not including the suffix) or qualified name for classes that * extend ResourceBundle. * <p> * Qualified name of a properties file is determined by its relative path to its * parent source folder. Such as: * <p> * Source path: locale/{locale} * <p> * Path of properties file 1: locale/en_US/A.properties * Qualified name of properties file 1: A * <p> * Path of properties file 2: locale/en_US/com/resources/B.properties * Qualified name of properties file 1: com.resources.B * <p> * Note: Source folders of all the properties files passed using this argument * should be in the project's source path list. * * @param cv configuration value objects * @param values list of resource bundles to include in the swc or swf */ @Config(allowMultiple = true) @Mapping("include-resource-bundles") @Arguments("bundle") @FlexOnly public void setIncludeResourceBundles(ConfigurationValue cv, List<String> values) { includeResourceBundles.addAll(values); } /** * Prints a list of resource bundles that are used by the current * application to a file named with the filename argument. You then use this * list as input that you specify with the include-resource-bundles option * to create a resource module. */ @Config(advanced = true) @Mapping("resource-bundle-list") @Arguments("filename") @FlexOnly public void setResourceBundleList(ConfigurationValue cv, String filename) { this.rbListFileName = getOutputPath(cv, filename); } // // 'runtime-shared-libraries' option // private List<String> rslList = new LinkedList<String>(); public List<String> getRuntimeSharedLibraries() { return rslList; } /** * Specifies a list of runtime shared libraries (RSLs) to use for this * application. RSLs are dynamically-linked at run time. The compiler * externalizes the contents of the application that you are compiling that * overlap with the RSL. * <p> * You specify the location of the SWF file relative to the deployment * location of the application. For example, if you store a file named * library.swf file in the web_root/libraries directory on the web server, * and the application in the web root, you specify libraries/library.swf. */ @Config(allowMultiple = true) @Mapping("runtime-shared-libraries") @Arguments("url") @InfiniteArguments @FlexOnly public void setRuntimeSharedLibraries(ConfigurationValue cfgval, List<String> urls) throws ConfigurationException { rslList.addAll(urls); } // // 'use-network' option // private boolean useNetwork = true; public boolean getUseNetwork() { return useNetwork; } /** * Specifies that the current application uses network services. * <p> * The default value is true. * <p> * When the use-network property is set to false, the application can access * the local filesystem (for example, use the XML.load() method with file: * URLs) but not network services. In most circumstances, the value of this * property should be true. */ @Config @Mapping("use-network") public void setUseNetwork(ConfigurationValue cv, boolean b) { this.useNetwork = b; } // // runtime-shared-library-path // private List<RuntimeSharedLibraryPathInfo> rslPathInfoList; /** * @return List of of all the -runtime-shared-libraries-path options. * Each-runtime-shared-libraries-path option supplied results in a * RslPathInfo object. Each object in the list is of type RslPathInfo. * <p> * The list will be empty if -static-link-runtime-shared-libraries=true. * <p> * TODO Verify if this is still true and make the code do what it says. */ public List<RuntimeSharedLibraryPathInfo> getRslPathInfo() { if (rslPathInfoList == null) return Collections.emptyList(); else return rslPathInfoList; } public List<File> getRslExcludedLibraries() { if (rslPathInfoList == null || getStaticLinkRsl()) return Collections.emptyList(); return Lists.transform(rslPathInfoList, new Function<RuntimeSharedLibraryPathInfo, File>() { @Override public File apply(RuntimeSharedLibraryPathInfo info) { return info.getSWCFile(); } }); } /** * Specifies the location of a runtime shared library (RSL). The compiler * externalizes the contents of the application that you are compiling that * overlap with the RSL. * <p> * The path-element argument is the location of the SWC file or open * directory to compile against. For example, * c:\flexsdk\frameworks\libs\framework.swc. This is the equivalent of the * using the external-library-path option when compiling against an RSL * using the runtime-shared-libraries option. * <p> * The rsl-url argument is the URL of the RSL that will be used to load the * RSL at runtime. The compiler does not verify the existence of the SWF * file at this location at compile time. It does store this string in the * application, however, and uses it at run time. As a result, the SWF file * must be available at run time but necessarily not at compile time. * <p> * The policy-file-url is the location of the crossdomain.xml file that * gives permission to read the RSL from the server. This might be necessary * because the RSL can be on a separate server as the application. For * example, http://www.mydomain.com/rsls/crossdomain.xml. * <p> * The failover-url and second policy-file-url arguments specify the * location of the secondary RSL and crossdomain.xml file if the first RSL * cannot be loaded. This most commonly happens when the client Player * version does not support cross-domain RSLs. You can add any number of * failover RSLs, but must include a policy file URL for each one. * <p> * Do not include spaces between the comma-separated values. The following * example shows how to use this option: * * <pre> * mxmlc -o=../lib/app.swf -runtime-shared-library-path=../lib/mylib.swc,../bin/myrsl.swf Main.mxml * </pre> * * You can specify more than one library file to be used as an RSL. You do * this by adding additional runtime-shared-library-path options. * <p> * You can also use the runtime-shared-libraries command to use RSLs with * your applications. However, the runtime-shared-library-path option lets * you also specify the location of the policy file and failover RSL. * <p> */ // NOTE: if the annotations are modified, then also modify the annotations // in COMPCConfiguration. @Config(allowMultiple = true) @Mapping({ "runtime-shared-library-path" }) @SoftPrerequisites({ "static-link-runtime-shared-libraries" }) @ArgumentNameGenerator(RSLArgumentNameGenerator.class) @InfiniteArguments @FlexOnly public void setRuntimeSharedLibraryPath(ConfigurationValue cfgval, List<String> urls) throws ConfigurationException { if (urls.isEmpty()) return; // Usage rule: if you use -rslp on the command line // it will take effect unless you also specify -static-rsls=true on the command line. if (CommandLineConfigurator.SOURCE_COMMAND_LINE.equals(cfgval.getSource())) { setOverrideStaticLinkRsl(false); } // ignore rsl if told to if (getStaticLinkRsl()) { return; } if (urls.size() < 2) { // insufficent arguments throw new ConfigurationException.MissingArgument("rsl-url", "runtime-shared-library-path", cfgval.getSource(), cfgval.getLine()); } RuntimeSharedLibraryPathInfo info = new RuntimeSharedLibraryPathInfo(); // validate the first argument, the swc or open directory, required. String include = resolvePathStrict(urls.get(0), cfgval, true); info.setSWCPath(urls.get(0)); info.setSWCFile(new File(include)); // the rest of the args are: rsl-url, policy-file-url, rsl-url, policy-file-url,... for (int i = 1; i < urls.size(); ++i) { final String url = urls.get(i); if ((i + 1) % 2 == 0) { if ("".equals(url.length())) { // rsl urls is required throw new ConfigurationException.MissingArgument("rsl-url", "runtime-shared-library-path", cfgval.getSource(), cfgval.getLine()); } info.addRSLURL(url); } else { info.addPolicyFileURL(url); } } // if the last policy file was not specified, then add an empty one so // there are always the same number of rsls and policy files. if ((urls.size() % 2) == 0) { info.addPolicyFileURL(""); } // take local variables and add to overall arguments. if (rslPathInfoList == null) { rslPathInfoList = new ArrayList<RuntimeSharedLibraryPathInfo>(); } rslPathInfoList.add(info); } // // 'static-link-runtime-shared-libraries' option // private boolean staticLinkRsl = true; private String staticLinkRslSource; /** * @return true if -cd-rsl option should be used. False otherwise. */ public boolean getStaticLinkRsl() { return staticLinkRsl; } /** * Allow another option, namely -rslp to override the value of static-rsls. * But you can not override a -static-rsls option that came from the command * line. * * @param staticLinkRsl */ protected void setOverrideStaticLinkRsl(boolean staticLinkRsl) { if (CommandLineConfigurator.SOURCE_COMMAND_LINE.equals(staticLinkRslSource)) { return; } this.staticLinkRsl = staticLinkRsl; } /** * Determines whether to compile against libraries statically or use RSLs. * Set this option to true to ignore the RSLs specified by the * runtime-shared-library-path option. Set this option to false to use the * RSLs. * <p> * This option is useful so that you can quickly switch between a statically * and dynamically linked application without having to change the * runtime-shared-library-path option, which can be verbose, or edit the * configuration files. */ @Config @Mapping("static-link-runtime-shared-libraries") @FlexOnly public void setStaticLinkRuntimeSharedLibraries(ConfigurationValue cv, boolean b) { staticLinkRsl = b; staticLinkRslSource = cv.getSource(); } // // 'verify-digests' options // private boolean verifyDigests = true; /** * @return true if digest information associated with the -cd-rsl option is * used by the application at runtime. False otherwise. */ public boolean getVerifyDigests() { return verifyDigests; } /** * Instructs the application to check the digest of the RSL SWF file against * the digest that was compiled into the application at compile time. This * is a security measure that lets you load RSLs from remote domains or * different sub-domains. It also lets you enforce versioning of your RSLs * by forcing an application's digest to match the RSL's digest. If the * digests are out of sync, you must recompile your application or load a * different RSL SWF file. */ @Config(advanced = true) @FlexOnly public void setVerifyDigests(ConfigurationValue cv, boolean b) { verifyDigests = b; } // // 'remove-unused-rsls' option // private boolean removeUnusedRSLs = false; /** * @return true if the user wants to remove unused RSLs. Otherwise false. */ public boolean getRemoveUnusedRsls() { return removeUnusedRSLs; } @Config(advanced = true) @FlexOnly public void setRemoveUnusedRsls(ConfigurationValue cv, boolean b) { removeUnusedRSLs = b; } // // '-include-inheritance-dependencies-only' option // private boolean includeInheritanceDependenciesOnly = false; /** * @return true if the user want to include inheritance dependencies only. */ public boolean getIncludeInheritanceDependenciesOnly() { return includeInheritanceDependenciesOnly; } @Config(advanced = true) public void setIncludeInheritanceDependenciesOnly(ConfigurationValue cv, boolean b) { includeInheritanceDependenciesOnly = b; } // // 'target-player' option // // targeted player version (also set in DefaultsConfigurator) private int majorVersionTarget = 11; private int minorVersionTarget = 1; private int revisionTarget = 0; /** * The major part the earliest player version that this compiler can target. * The code generator generates bytecode which will not pass * verification on players earlier than 10.1. */ public static final int TARGET_PLAYER_MAJOR_VERSION_MIN = 10; /** * The minor part the earliest player version that this compiler can target. * The code generator generates bytecode which will not pass * verification on players earlier than 10.1. */ public static final int TARGET_PLAYER_MINOR_VERSION_MIN = 1; /** * @return The major version of the player targeted by this application. The * returned value will be greater to or equal to 9. */ public int getTargetPlayerMajorVersion() { return majorVersionTarget; } /** * @return The minor version of the player targeted by this application. The * returned value will be greater to or equal to 0. */ public int getTargetPlayerMinorVersion() { return minorVersionTarget; } /** * @return The revision of the player targeted by this application. The * returned value will be greater to or equal to 0. */ public int getTargetPlayerRevision() { return revisionTarget; } /** * Specifies the version of Flash Player that you want to target with the * application. Features requiring a later version of Flash Player are not * compiled into the application. * <p> * The player_version parameter has the following format:<br> * <code>major_version.minor_version.revision</code> * <p> * The major_version is required while minor_version and revision are * optional. The minimum value is 10.0.0. If you do not specify the * minor_version or revision, then the compiler uses zeros. * <p> * The value of major_version is also used by the {targetPlayerMajorVersion} * token in the flex-config.xml file. This token can be used in any * <path-element> element. * <p> * If you do not explicitly set the value of this option, the compiler uses * the default from the flex-config.xml file. The value in flex-config.xml * is the version of Flash Player that shipped with the SDK. * <p> * This option is useful if your application's audience has a specific * player and cannot upgrade. You can use this to "downgrade" your * application for that audience. */ @Config @Arguments("version") public void setTargetPlayer(ConfigurationValue cv, String version) throws ConfigurationException { if (version == null || version.equals("")) return; final String[] results = Iterables.toArray(Splitter.on(".").omitEmptyStrings().trimResults().split(version), String.class); // major.minor.revision // major is required, minor and revision are optional if (results.length < 1 || results.length > 3) throw new ConfigurationException.BadVersion(version, "target-player"); final String majorVersion = results[0]; final String minorVersion; if (results.length > 1) minorVersion = results[1]; else minorVersion = "0"; final String revision; if (results.length > 2) revision = results[2]; else revision = "0"; try { majorVersionTarget = Integer.parseInt(majorVersion); minorVersionTarget = Integer.parseInt(minorVersion); revisionTarget = Integer.parseInt(revision); } catch (NumberFormatException e) { throw new ConfigurationException.BadVersion(version, "target-player"); } if (majorVersionTarget < TARGET_PLAYER_MAJOR_VERSION_MIN || majorVersionTarget == TARGET_PLAYER_MAJOR_VERSION_MIN && minorVersionTarget < TARGET_PLAYER_MINOR_VERSION_MIN) { throw new ConfigurationException.BadVersion(version, "target-player"); } } // // 'swf-version' option // // swf version 13 is what shipped with player 11, and is the min version for // LZMA compression private static final Map<String, Integer> targetPlayerToSWFVersionMap = getSwfVersionMap(); private static Map<String, Integer> getSwfVersionMap() { // Player 9 and below are not supported. // 10.0 -> 10 // 10.1 -> 10 // 10.2 -> 11 // 10.3 -> 12 // 11.0 -> 13 // 11.1 -> 14 // 11.2 -> 15 // 11.3 -> 16 // 11.4 -> 17 Map<String, Integer> map = new HashMap<String, Integer>(10); map.put("10.0", 10); map.put("10.1", 10); map.put("10.2", 11); map.put("10.3", 12); map.put("11.0", 13); map.put("11.1", 14); map.put("11.2", 15); map.put("11.3", 16); map.put("11.4", 17); return map; } private int lookupSwfVersion() { int swfVersion = DEFAULT_SWF_VERSION; Integer lookupVersion = targetPlayerToSWFVersionMap.get(Integer.toString(getTargetPlayerMajorVersion()) + "." + Integer.toString(getTargetPlayerMinorVersion())); if (lookupVersion != null) swfVersion = lookupVersion; return swfVersion; } private final int UNSET_SWF_VERSION = -1; private final int DEFAULT_SWF_VERSION = 14; // matches default target-player private final int MINIMUM_SWF_VERSION = 10; // matches minimum target-player private int swfVersion = UNSET_SWF_VERSION; public int getSwfVersion() { if (swfVersion == UNSET_SWF_VERSION) swfVersion = lookupSwfVersion(); return swfVersion; } @Config @Mapping("swf-version") public void setSwfVersion(ConfigurationValue cv, int version) throws ConfigurationException { if (version < MINIMUM_SWF_VERSION) throw new ConfigurationException.BadVersion(Integer.toString(version), "swf-version"); swfVersion = version; } // // 'use-direct-blit' option // private boolean useDirectBlit = true; public boolean getUseDirectBlit() { return useDirectBlit; } @Config public void setUseDirectBlit(ConfigurationValue cv, boolean value) { useDirectBlit = value; } // // 'use-gpu' option // private boolean useGpu = true; public boolean getUseGpu() { return useGpu; } @Config public void setUseGpu(ConfigurationValue cv, boolean value) { useGpu = value; } // // 'tools-locale' options // private Locale toolsLocale = null; /** * @return locale to use when reporting compile time errors, or * <code>null</code> if not specified. In that case, system's * locale is used. */ public Locale getToolsLocale() { return toolsLocale; } /** * Configures the LocalizationManager's locale, which is used when reporting * compile time errors, warnings, and info. * * @param toolsLocale A locale in Java format. For example, "en" or "ja_JP". * @throws ConfigurationException When the specified toolsLocale is not * available a ToolsLocaleNotAvailable error is reported. */ @Config @Mapping("tools-locale") public void setToolsLocale(ConfigurationValue cv, String toolsLocale) throws ConfigurationException { Locale[] locales = Locale.getAvailableLocales(); for (int i = 0; i < locales.length; i++) { if (locales[i].toString().equals(toolsLocale)) { this.toolsLocale = locales[i]; LocalizationManager.get().setLocale(locales[i]); return; } } throw new ConfigurationException.ToolsLocaleNotAvailable(cv.getVar(), cv.getSource(), cv.getLine()); } // // 'compiler.accessible' option // private boolean accessible = false; public boolean getCompilerAccessible() { return accessible; } /** * Enables accessibility features when compiling the application or SWC * file. */ @Config @Mapping({ "compiler", "accessible" }) @FlexOnly public void setCompilerAccessible(ConfigurationValue cv, boolean accessible) { this.accessible = accessible; } // // 'compiler.actionscript-file-encoding' option // private String actionscriptFileEncoding = null; public String getCompilerActionscriptFileEncoding() { return actionscriptFileEncoding; } /** * Sets the file encoding for ActionScript files. */ @Config @Mapping({ "compiler", "actionscript-file-encoding" }) public void setCompilerActionscriptFileEncoding(ConfigurationValue cv, String encoding) { actionscriptFileEncoding = encoding; } // // 'compiler.adjust-opdebugline' option (hidden) // private boolean adjustOpDebugLine = true; public boolean getAdjustOpDebugLine() { return adjustOpDebugLine; } /** * For internal use only. Set it to false so that debugging mxmlc * auto-generated code is easier. */ @Config(advanced = true, hidden = true) public void setCompilerAdjustOpdebugline(ConfigurationValue cv, boolean b) { adjustOpDebugLine = b; } // // 'compiler.allow-source-path-overlap' option // private boolean allowSourcePathOverlap = false; public boolean getAllowSourcePathOverlap() { return allowSourcePathOverlap; } /** * Checks if a source-path entry is a sub-directory of another source-path * entry. It helps make the package names of MXML components unambiguous. */ @Config(advanced = true) public void setCompilerAllowSourcePathOverlap(ConfigurationValue cv, boolean b) { allowSourcePathOverlap = b; } /** * 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 getCompiler 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::Organization</name> * <value>'Apache Software Foundation'</value> * </define> * <define> * <name>NAMES::Application</name> * <value>"Flex 4.8.0"</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 setCompilertings * 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 Map<String, String> configVars; /** * @return A list of ConfigVars */ public Map<String, String> getCompilerDefine() { return configVars; } @Config(advanced = true, allowMultiple = true) @Arguments({ "name", "value" }) public void setCompilerDefine(ConfigurationValue cv, String name, String value) throws ConfigurationException { if (configVars == null) configVars = new LinkedHashMap<String, String>(); configVars.put(name, value); } // // 'compiler.conservative' option (hidden) // private boolean useConservativeAlgorithm = false; public boolean useConservativeAlgorithm() { return useConservativeAlgorithm; } @Config(advanced = true, hidden = true) @Mapping({ "compiler", "conservative" }) public void setCompilerConservative(ConfigurationValue cv, boolean c) { useConservativeAlgorithm = c; } // // 'compiler.context-root' option // private String contextRoot = null; public String getCompilerContextRoot() { return contextRoot; } /** * "Context root" is used to resolve {context.root} tokens in services * configuration files to improve portability. */ @Config @Mapping({ "compiler", "context-root" }) @Arguments("context-path") @FlexOnly public void setCompilerContextRoot(ConfigurationValue cv, String contextRoot) { this.contextRoot = contextRoot; } // // 'compiler.debug' option // private boolean generateDebugTags = false; public boolean isDebuggingEnabled() { return generateDebugTags; } protected void setDebug(boolean value) { generateDebugTags = value; } @Config @Mapping({ "compiler", "debug" }) public void setCompilerDebug(ConfigurationValue cv, boolean generateDebugTags) { this.generateDebugTags = generateDebugTags; } // // 'compiler.defaults-css-url' option // /** * Location of defaults stylesheet. */ private String defaultsCssUrl; public String getCompilerDefaultsCssUrl() { return defaultsCssUrl; } /** * Defines the location of the default style sheet. Setting this option * overrides the implicit use of the defaults.css style sheet in the * framework.swc file. */ @Config(advanced = true) @Mapping({ "compiler", "defaults-css-url" }) @FlexOnly public void setCompilerDefaultsCssUrl(ConfigurationValue cv, String defaultsCssUrlPath) throws CannotOpen { defaultsCssUrl = resolvePathStrict(defaultsCssUrlPath, cv); } // // 'compiler.doc' option (hidden) // private boolean doc = false; public boolean getCompilerDoc() { return this.doc; } @Config(advanced = true, hidden = true) @Mapping({ "compiler", "doc" }) public void setCompilerDoc(ConfigurationValue cv, boolean doc) { this.doc = doc; } // // 'compiler.external-library-path' option // private final List<String> externalLibraryPath = new ArrayList<String>(); public List<String> getCompilerExternalLibraryPath() { return externalLibraryPath; } private boolean compilingForAIR = false; /** * @return True if AIR libraries are included in the * {@code external-library-path}. */ public boolean getCompilingForAIR() { return compilingForAIR; } @Config(allowMultiple = true, isPath = true) @Mapping({ "compiler", "external-library-path" }) @Arguments(Arguments.PATH_ELEMENT) @InfiniteArguments public void setCompilerExternalLibraryPath(ConfigurationValue cv, String[] pathlist) throws ConfigurationException { final ImmutableList<String> pathElements = ImmutableList.copyOf(pathlist); final ImmutableList<String> resolvedPaths = expandTokens(pathElements, locales, cv, !reportMissingCompilerLibraries); externalLibraryPath.addAll(resolvedPaths); // TODO: Review usages of "compilingForAIR", because only looking at path elements // on library path isn't enough. There might be a folder on the library path that // contains AIR libraries. compilingForAIR = containsAIRLibraries(pathElements); } /** * Returns true if there's AIR libraries on the library paths. * * @param libraryPaths Library paths. * @return True if there's AIR libraries on the library paths. */ private static boolean containsAIRLibraries(final ImmutableList<String> libraryPaths) { for (final String path : libraryPaths) { if (path.equals(SWC_AIRGLOBAL) || path.endsWith("/" + SWC_AIRGLOBAL) || path.endsWith("\\" + SWC_AIRGLOBAL)) { return true; } } return false; } // // 'compiler.generated-directory' option // This can only be configured using getter and setter. // private String generatedDir = null; public String getCompilerGeneratedDirectory() { return generatedDir; } public void setCompilerGeneratedDirectory(String generatedDir) { this.generatedDir = generatedDir; } // // 'compiler.headless-server' option // private boolean headlessServer; public boolean isHeadlessServer() { return headlessServer; } @Config(advanced = true) @Mapping({ "compiler", "headless-server" }) @FlexOnly public void setCompilerHeadlessServer(ConfigurationValue cv, boolean headlessServer) { this.headlessServer = headlessServer; } // // 'compiler.include-libraries' option // private final List<String> includeLibraries = new ArrayList<String>(); public List<String> getCompilerIncludeLibraries() { return includeLibraries; } /** * Links all classes inside a SWC file to the resulting application SWF * file, regardless of whether or not they are used. * <p> * Contrast this option with the library-path option that includes only * those classes that are referenced at compile time. * <p> * To link one or more classes whether or not they are used and not an * entire SWC file, use the includes option. * <p> * This option is commonly used to specify resource bundles. */ @Config(allowMultiple = true, isPath = true) @Mapping({ "compiler", "include-libraries" }) @Arguments("library") @InfiniteArguments public void setCompilerIncludeLibraries(ConfigurationValue cv, String[] pathlist) throws CannotOpen { final ImmutableList<String> resolvedPaths = expandTokens(Arrays.asList(pathlist), locales, cv, !reportMissingCompilerLibraries); includeLibraries.addAll(resolvedPaths); } // // 'compiler.incremental' option // @Config(removed = true) @Mapping({ "compiler", "incremental" }) public void setCompilerIncremental(ConfigurationValue cv, boolean 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; } @Config(advanced = true) @Mapping({ "compiler", "keep-all-type-selectors" }) @FlexOnly public void setCompilerKeepAllTypeSelectors(ConfigurationValue cv, boolean keepAllTypeSelectors) { this.keepAllTypeSelectors = keepAllTypeSelectors; } // // 'compiler.keep-as3-metadata' option // private Set<String> as3metadata = null; public Set<String> getCompilerKeepAs3Metadata() { return as3metadata == null ? Collections.<String>emptySet() : as3metadata; } @Config(advanced = true, allowMultiple = true) @Mapping({ "compiler", "keep-as3-metadata" }) @Arguments("name") @InfiniteArguments public void setCompilerKeepAs3Metadata(ConfigurationValue cv, List<String> values) { if (as3metadata == null) as3metadata = new HashSet<String>(); as3metadata.addAll(values); } // // 'compiler.keep-generated-actionscript' option (removed) // @Config(removed = true) @Mapping({ "compiler", "keep-generated-actionscript" }) public void setCompilerKeepGeneratedActionscript(ConfigurationValue cv, boolean keep) { } // // 'compiler.keep-generated-signatures' option (removed) // @Config(removed = true) @Mapping({ "compiler", "keep-generated-signatures" }) public void setCompilerKeepGeneratedSignatures(ConfigurationValue cv, boolean keep) { } // // 'compiler.enable-runtime-design-layers' option // private boolean enableRuntimeDesignLayers = true; public boolean getEnableRuntimeDesignLayers() { return enableRuntimeDesignLayers; } @Config @Mapping({ "compiler", "enable-runtime-design-layers" }) @FlexOnly public void setCompilerEnableRuntimeDesignLayers(ConfigurationValue cv, boolean enable) { enableRuntimeDesignLayers = enable; } // // 'compiler.enable-swc-version-filtering' option // private boolean enableSwcVersionFiltering = true; public boolean getEnableSwcVersionFiltering() { return enableSwcVersionFiltering; } @Config(advanced = true, hidden = true) @Mapping({ "compiler", "enable-swc-version-filtering" }) public void setCompilerEnableSwcVersionFiltering(ConfigurationValue cv, boolean enable) { this.enableSwcVersionFiltering = enable; } // // 'compiler.library-path' option // private final List<String> libraryPath = new ArrayList<String>(); private boolean reportMissingCompilerLibraries = true; /** * Sets whether to report missing libraries in the configuration. If this is false * any missing libraries will not be warned about, and the filename will also be added to list * of libraries in the project when it doesn't exist. If reportMissingCompilerLibraries * is true, any missing libraries will not be added to the project. * * @param reportMissingCompilerLibraries true to report missing libraries */ public void setReportMissingCompilerLibraries(boolean reportMissingCompilerLibraries) { this.reportMissingCompilerLibraries = reportMissingCompilerLibraries; } public List<String> getCompilerLibraryPath() { return libraryPath; } /** * Links SWC files to the resulting application SWF file. The compiler only * links in those classes for the SWC file that are required. You can * specify a directory or individual SWC files. */ @Config(allowMultiple = true, isPath = true) @Mapping({ "compiler", "library-path" }) @Arguments(Arguments.PATH_ELEMENT) @InfiniteArguments @SoftPrerequisites("locale") public void setCompilerLibraryPath(ConfigurationValue cv, String[] pathlist) throws CannotOpen { final ImmutableList<String> resolvedPaths = expandTokens(Arrays.asList(pathlist), locales, cv, !reportMissingCompilerLibraries); libraryPath.addAll(resolvedPaths); } // // 'compiler.locale' option // private final List<String> locales = new ArrayList<String>(); public List<String> getCompilerLocales() { return locales; } /** * Specifies one or more locales to be compiled into the SWF file. If you do * not specify a locale, then the compiler uses the default locale from the * flex-config.xml file. The default value is en_US. You can append * additional locales to the default locale by using the += operator. If you * remove the default locale from the flex-config.xml file, and do not * specify one on the command line, then the compiler will use the machine's * locale. */ @Config(allowMultiple = true) @Mapping({ "compiler", "locale" }) @Arguments("locale-element") @InfiniteArguments @FlexOnly public void setCompilerLocale(ConfigurationValue cv, String[] newLocales) { locales.addAll(Arrays.asList(newLocales)); } // // 'compiler.metadata-export' option (incomplete) // private boolean metadataExport; public boolean metadataExport() { return metadataExport; } // metadataExport does not have the normal configuration setCompilerter because it is not // a normal configuration value but rather something setCompiler by the compiler public void setCompilerMetadataExport(boolean metadataExport) { this.metadataExport = metadataExport; } // // 'compiler.mxml.children-as-data' option // private Boolean childrenAsData = false; public Boolean getCompilerMxmlChildrenAsData() { return childrenAsData; } @Config @Mapping({ "compiler", "mxml", "children-as-data" }) @FlexOnly public void setCompilerMxmlChildrenAsData(ConfigurationValue cv, Boolean asData) throws ConfigurationException { childrenAsData = asData; } // // 'compiler.mxml.compatibility-version' option // public String getCompilerCompatibilityVersionString() { return getCompilerMxmlCompatibilityVersionString(); } public int getCompilerCompatibilityVersion() { return getCompilerMxmlCompatibilityVersion(); } // // 'compiler.mxml.minimum-supported-version' option // public String getCompilerMinimumSupportedVersionString() { return getCompilerMxmlMinimumSupportedVersionString(); } public int getCompilerMinimumSupportedVersion() { return getCompilerMxmlMinimumSupportedVersion(); } @Config @Mapping({ "compiler", "minimum-supported-version" }) @FlexOnly public void setCompilerMinimumSupportedVersion(ConfigurationValue cv, String version) throws ConfigurationException { setCompilerMxmlMinimumSupportedVersion(cv, version); } // // 'qualified-type-selectors' option // @Config(advanced = true, removed = true) @Mapping({ "compiler", "mxml", "qualified-type-selectors" }) public void setCompilerMxmlQualifiedTypeSelectors(ConfigurationValue cv, boolean b) { } // // 'compiler.omit-trace-statements' option // private boolean omitTraceStatements = true; public boolean omitTraceStatements() { return omitTraceStatements; } @Config @Mapping({ "compiler", "omit-trace-statements" }) public void setCompilerOmitTraceStatements(ConfigurationValue cv, boolean b) { omitTraceStatements = b; } // // 'compiler.optimize' option // private boolean optimize = false; public boolean optimize() { return optimize; } public boolean getCompilerOptimize() { return optimize; } @Config @Mapping({ "compiler", "optimize" }) public void setCompilerOptimize(ConfigurationValue cv, boolean b) { optimize = b; } // // 'compiler.preloader' option // private String preloader = null; /** * * @return Returns the preloader class configured by the user. If the * user did not configure a preloader, the * "mx.preloader.DownloaderProgressBar" preloader will be returned if the * compatibility version is less than 4.0. Otherwise the * "mx.preloaders.SparkDownloadProgressBar" preloader will be returned. */ public String getPreloader() { if (preloader != null) return preloader; if (getCompilerMxmlCompatibilityVersion() < MXML_VERSION_4_0) return IMXMLTypeConstants.DownloadProgressBar; else return IMXMLTypeConstants.SparkDownloadProgressBar; } public String getCompilerPreloader() { return preloader; } @Config @Mapping({ "compiler", "preloader" }) @FlexOnly public void setCompilerPreloader(ConfigurationValue cv, String value) { preloader = value; } // // 'compiler.services' option // private File servicesConfigFile; //protected ServicesDependencies servicesDependencies; public File getCompilerServices() { return servicesConfigFile; } /** * Used by the compiler to record the client dependencies from the Flex Data * Services configuration file. */ /* * public ServicesDependencies getCompilerServicesDependencies() { if * (servicesDependencies == null && servicesConfigFile != null) { String * servicesPath = servicesConfigFile.getName(); servicesDependencies = new * ServicesDependencies(servicesPath, null, getCompilerContextRoot()); } * return servicesDependencies; } public void * setCompilerServicesDependencies(ServicesDependencies deps) { * servicesDependencies = deps; } */ @Config @Mapping({ "compiler", "services" }) @Arguments("filename") @FlexOnly public void setCompilerServices(ConfigurationValue cv, String servicesPath) throws ConfigurationException { try { servicesConfigFile = new File(resolvePathStrict(servicesPath, cv)); } catch (Throwable t) { throw new ConfigurationException.CannotOpen(servicesPath, cv.getVar(), cv.getSource(), cv.getLine()); } } // // 'compiler.show-actionscript-warnings' option // /** * Enable asc -warnings */ private boolean ascWarnings; public boolean warnings() { return this.ascWarnings; } @Config @Mapping({ "compiler", "show-actionscript-warnings" }) public void setCompilerShowActionscriptWarnings(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; } @Config @Mapping({ "compiler", "show-binding-warnings" }) public void setCompilerShowBindingWarnings(ConfigurationValue cv, boolean show) { this.showBindingWarnings = show; } @Config @Mapping({ "compiler", "show-multiple-definition-warnings" }) public void setCompilerShowMultipleDefinitionWarnings(ConfigurationValue cv, boolean show) { this.showMultipleDefinitionWarnings = show; } // // 'compiler.show-dependency-warnings' option (hidden) // private boolean showDependencyWarnings = false; public boolean showDependencyWarnings() { return showDependencyWarnings; } @Config(advanced = true, hidden = true) @Mapping({ "compiler", "show-dependency-warnings" }) public void setCompilerShowDependencyWarnings(ConfigurationValue cv, boolean show) { this.showDependencyWarnings = show; } // // 'compiler.report-invalid-styles-as-warnings' option // /** * Controls whether invalid styles are report as errors or warnings. */ private boolean reportInvalidStylesAsWarnings = false; /** * Get value of {@code compiler.report-invalid-styles-as-warnings} option * value. * <p> * <h2>What's "invalid styles"?</h2> The term "invalid style" only applies * to MXML style specifier (a.k.a. inline style). If a style of a component * is defined with "theme" attribute, the style is only effective with such * theme. If a theme-specific style is used in an application who doesn't * use the required theme, the style is considered invalid. * <p> * For example, style "fooStyle" is defined to used only with theme called * "fooTheme": * * <pre> * [Style(name="fooStyle", type="uint", format="Color", inherit="yes", theme="fooTheme")] * public class MyComponent extends UIComponent * </pre> * * If "fooTheme" isn't used by the current application, the following style * specifier is considered "invalid styles". <br> * {@code <local:MyComponent fooStyle="white" />} * * @return True if invalid styles are reported as warnings instead of * errors. */ public boolean getReportInvalidStylesAsWarnings() { return reportInvalidStylesAsWarnings; } @Config @Mapping({ "compiler", "report-invalid-styles-as-warnings" }) @FlexOnly public void setCompilerReportInvalidStylesAsWarnings(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; } @Config(advanced = true) @Mapping({ "compiler", "report-missing-required-skin-parts-as-warnings" }) @FlexOnly public void setCompilerReportMissingRequiredSkinPartsAsWarnings(ConfigurationValue cv, boolean b) { reportMissingRequiredSkinPartsAsWarnings = b; } // // 'compiler.show-invalid-css-property-warnings' option // private boolean showInvalidCSSPropertyWarnings = true; /** * Controls whether warnings are displayed when styles, which don't apply to * the current theme(s), are used in CSS. * <p> * See {@link #getReportInvalidStylesAsWarnings()} for definition of * "invalid style". * <p> * This option applies to <i>invalid styles</i> in a {@code <fx:Style>} * block. */ public boolean getShowInvalidCSSPropertyWarnings() { return showInvalidCSSPropertyWarnings; } @Config @Mapping({ "compiler", "show-invalid-css-property-warnings" }) @FlexOnly public void setShowInvalidCssPropertyWarnings(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; } @Config(advanced = true, hidden = true) @Mapping({ "compiler", "show-deprecation-warnings" }) public void setCompilerShowDeprecationWarnings(ConfigurationValue cv, boolean show) { this.showDeprecationWarnings = show; } // // 'compiler.show-shadowed-device-font-warnings' option // @Config @Mapping({ "compiler", "show-shadowed-device-font-warnings" }) @FlexOnly public void setCompilerShowShadowedDeviceFontWarnings(ConfigurationValue cv, boolean show) { // intentionally do nothing here as feature removed, but don't annotate as removed // as to not generate warnings for flex-config's which still set this options } // // 'compiler.show-unused-type-selector-warnings' option // private boolean showUnusedTypeSelectorWarnings = true; public boolean showUnusedTypeSelectorWarnings() { return showUnusedTypeSelectorWarnings; } // // 'compiler.show-multiple-definition-warnings' option // private boolean showMultipleDefinitionWarnings = true; public boolean showMultipleDefinitionWarnings() { return showMultipleDefinitionWarnings; } @Config @Mapping({ "compiler", "show-unused-type-selector-warnings" }) @FlexOnly public void setCompilerShowUnusedTypeSelectorWarnings(ConfigurationValue cv, boolean show) { this.showUnusedTypeSelectorWarnings = show; } // // 'compiler.source-path' option // /** * Source path elements searched for ActionScript class files, possibly * containing a {locale} token. */ private final List<String> unexpandedSourcePath = new ArrayList<String>(); /** * 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 final List<String> sourcePath = new ArrayList<String>(); /** Context object for "source-path" option. */ private ConfigurationValue sourcePathContext = null; public List<String> getCompilerSourcePath() { return sourcePath; } /** * Get the source paths computed from the given {@code locale}. The locale * must be included in the configuration. * * @param locale Locale name. * @return Source paths computed from the given {@code locale}. * @throws CannotOpen Error resolving one of the paths from this locale. */ public ImmutableList<String> getCompilerResourceBundlePathForLocale(String locale) throws CannotOpen { assert locales.contains(locale) : "Locale is not configured: " + locale; return expandTokens(unexpandedSourcePath, ImmutableSet.of(locale), sourcePathContext, !reportMissingCompilerLibraries); } @Config(allowMultiple = true) @Arguments(Arguments.PATH_ELEMENT) @SoftPrerequisites("locale") public void setCompilerSourcePath(ConfigurationValue cv, String[] paths) throws ConfigurationException { final List<String> pathList = Arrays.asList(paths); unexpandedSourcePath.addAll(pathList); final ImmutableList<String> resolvedSourcePaths = expandTokens(pathList, locales, cv); assertThatAllPathsAreDirectories(resolvedSourcePaths, cv); sourcePath.addAll(resolvedSourcePaths); sourcePathContext = cv; } /** * Check that all paths in the path list are directories. * * @param paths A list of paths. * @param cv Context. * @throws NotDirectory Path is not a directory exception. */ public static void assertThatAllPathsAreDirectories(final List<String> paths, final ConfigurationValue cv) throws NotDirectory { assert paths != null : "Expected path list."; assert cv != null : "Expected ConfigurationValue as context."; for (final String path : paths) { final File file = new File(path); if (!file.isDirectory()) throw new NotDirectory(path, cv.getVar(), cv.getSource(), cv.getLine()); } } public static ConfigurationInfo getCompilerSourcePathInfo() { return new ConfigurationInfo(-1, new String[] { "path-element" }) { @Override public boolean allowMultiple() { return true; } @Override public boolean isPath() { return true; } }; } // // 'compiler.strict' option // /** * Run the AS3 compiler in strict mode */ private boolean strict; public boolean strict() { return this.strict; } @Config @Mapping({ "compiler", "strict" }) public void setCompilerStrict(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 setCompilerSuppressWarningsInIncremental(boolean b) { suppressWarningsInIncremental = b; } // // 'compiler.theme' option // private List<String> themeFiles = null; /** * Get normalized theme file paths. If a the compiler is in * "Flex 3 compatibility" mode and only "Spark" theme is used, it will be * replaced with the legacy "Halo" theme. * * @return A list of normalized paths to the theme files. */ public List<String> getCompilerThemeFiles() { if (themeFiles == null) return EMPTY_STRING_LIST; final boolean isVersion3OrEarlier = getCompilerMxmlCompatibilityVersion() <= MXML_VERSION_3_0; final boolean hasOnlyOneThemeFile = themeFiles.size() == 1; if (isVersion3OrEarlier && hasOnlyOneThemeFile) { // Swap in the default Flex 3 theme of Halo. final String path = FilenameUtils.normalize(themeFiles.get(0), true); final String sparkPath = "/themes/Spark/spark.css"; if (path.endsWith(sparkPath)) { int index = path.indexOf(sparkPath); final String haloPath = path.substring(0, index) + "/themes/Halo/halo.swc"; themeFiles.set(0, FilenameNormalization.normalize(haloPath)); } } return themeFiles; } @Config(allowMultiple = true) @Mapping({ "compiler", "theme" }) @Arguments("filename") @InfiniteArguments @FlexOnly public void setCompilerTheme(ConfigurationValue cv, List<String> paths) throws CannotOpen { // Use "resolvePathsStrict()" if invalid theme file can't be ignored. final ImmutableList<String> resolved = resolvePathsStrict(ImmutableList.copyOf(paths), cv); if (themeFiles == null) themeFiles = new ArrayList<String>(); themeFiles.addAll(resolved); } // // 'compiler.defaults-css-files' option // private Deque<String> defaultsCSSFiles = new ArrayDeque<String>(); /** * List of filenames of defaults style stylesheets (css only). * <p> * <b>For example:</b><br> * <code>-defaults-css-files=[A, B, C]</code><br> * Then, 'A' should have precedence over 'B', then 'C', then SWCs * defaultsCssFiles should have the order: SWCS, C, B, A * * @see #setDefaultsCSSFiles */ public Deque<String> getDefaultsCSSFiles() { return defaultsCSSFiles; } /** * Inserts CSS files into the output the same way that a per-SWC * defaults.css file works, but without having to re-archive the SWC file to * test each change. * <p> * CSS files included in the output with this option have a higher * precedence than default CSS files in existing SWCs. For example, a CSS * file included with this option overrides definitions in framework.swc's * defaults.css file, but it has the same overall precedence as other * included CSS files inside the SWC file. * <p> * This option does not actually insert the CSS file into the SWC file; it * simulates it. When you finish developing the CSS file, you should rebuild * the SWC file with the new integrated CSS file. * <p> * This option takes one or more files. The precedence for multiple CSS * files included with this option is from first to last. */ @Config(allowMultiple = true, advanced = true) @Mapping({ "compiler", "defaults-css-files" }) @Arguments("filename") @InfiniteArguments @FlexOnly public void setDefaultsCSSFiles(ConfigurationValue cv, List<String> paths) throws CannotOpen { final ImmutableList<String> resolved = resolvePathsStrict(ImmutableList.copyOf(paths), cv); for (final String path : resolved) { defaultsCSSFiles.addFirst(path); } } /** * Location of theme style stylesheets (css only, configured via themefiles * above). */ private List<IFileSpecification> themeCssFiles = new LinkedList<IFileSpecification>(); public List<IFileSpecification> getCompilerThemeCssFiles() { return themeCssFiles; } public void addThemeCssFiles(List<IFileSpecification> files) { themeCssFiles.addAll(files); } // // 'compiler.use-resource-bundle-metadata' option // @Config(removed = true) @Mapping({ "compiler", "use-resource-bundle-metadata" }) public void setCompilerUseResourceBundleMetadata(ConfigurationValue cv, boolean b) { } // // 'compiler.verbose-stacktraces' option // private boolean verboseStacktraces; // from as3 and mxml configuration interface public boolean debug() { // the debug() in as3 and mxml configuration maps to stacktraceLineNumbers return verboseStacktraces; } @Config @Mapping({ "compiler", "verbose-stacktraces" }) public void setCompilerVerboseStacktraces(ConfigurationValue cv, boolean verboseStacktraces) { if (generateDebugTags) { this.verboseStacktraces = true; } else { 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; } @Config(advanced = true) @Mapping({ "compiler", "warn-array-tostring-changes" }) public void setCompilerWarnArrayTostringChanges(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_array_tostring_changes) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-assignment-within-conditional' option // private boolean warn_assignment_within_conditional = true; public boolean warn_assignment_within_conditional() { return warn_assignment_within_conditional; } @Config(advanced = true) @Mapping({ "compiler", "warn-assignment-within-conditional" }) public void setCompilerWarnAssignmentWithinConditional(ConfigurationValue cv, boolean b) { warn_assignment_within_conditional = b; } // // 'compiler.warn-bad-array-cast' option // private boolean warn_bad_array_cast = true; public boolean warn_bad_array_cast() { return warn_bad_array_cast; } @Config(advanced = true) @Mapping({ "compiler", "warn-bad-array-cast" }) public void setCompilerWarnBadArrayCast(ConfigurationValue cv, boolean b) { warn_bad_array_cast = b; } // // 'compiler.warn-bad-bool-assignment' option // private boolean warn_bad_bool_assignment = true; public boolean warn_bad_bool_assignment() { return warn_bad_bool_assignment; } @Config(advanced = true) @Mapping({ "compiler", "warn-bad-bool-assignment" }) public void setCompilerWarnBadBoolAssignment(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_bad_bool_assignment) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-bad-date-cast' option // private boolean warn_bad_date_cast = true; public boolean warn_bad_date_cast() { return warn_bad_date_cast; } @Config(advanced = true) @Mapping({ "compiler", "warn-bad-date-cast" }) public void setCompilerWarnBadDateCast(ConfigurationValue cv, boolean b) { warn_bad_date_cast = b; } // // '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; } @Config(advanced = true) @Mapping({ "compiler", "warn-bad-es3-type-method" }) public void setCompilerWarnBadEs3TypeMethod(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_bad_es3_type_method) addRemovedConfigurationOptionProblem(cv); } // // '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; } @Config(advanced = true) @Mapping({ "compiler", "warn-bad-es3-type-prop" }) public void setCompilerWarnBadEs3TypeProp(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_bad_es3_type_prop) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-bad-nan-comparison' option // private boolean warn_bad_nan_comparison = true; public boolean warn_bad_nan_comparison() { return warn_bad_nan_comparison; } @Config(advanced = true) @Mapping({ "compiler", "warn-bad-nan-comparison" }) public void setCompilerWarnBadNanComparison(ConfigurationValue cv, boolean b) { warn_bad_nan_comparison = b; } // // 'compiler.warn-bad-null-assignment' option // private boolean warn_bad_null_assignment = true; public boolean warn_bad_null_assignment() { return warn_bad_null_assignment; } @Config(advanced = true) @Mapping({ "compiler", "warn-bad-null-assignment" }) public void setCompilerWarnBadNullAssignment(ConfigurationValue cv, boolean b) { warn_bad_null_assignment = b; } // // 'compiler.warn-bad-null-comparison' option // private boolean warn_bad_null_comparison = true; public boolean warn_bad_null_comparison() { return warn_bad_null_comparison; } @Config(advanced = true) @Mapping({ "compiler", "warn-bad-null-comparison" }) public void setCompilerWarnBadNullComparison(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_bad_null_comparison) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-bad-undefined-comparison' option // private boolean warn_bad_undefined_comparison = true; public boolean warn_bad_undefined_comparison() { return warn_bad_undefined_comparison; } @Config(advanced = true) @Mapping({ "compiler", "warn-bad-undefined-comparison" }) public void setCompilerWarnBadUndefinedComparison(ConfigurationValue cv, boolean b) { warn_bad_undefined_comparison = b; } // // '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; } @Config(advanced = true) @Mapping({ "compiler", "warn-boolean-constructor-with-no-args" }) public void setCompilerWarnBooleanConstructorWithNoArgs(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_boolean_constructor_with_no_args) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-changes-in-resolve' option // private boolean warn_changes_in_resolve = false; public boolean warn_changes_in_resolve() { return warn_changes_in_resolve; } @Config(advanced = true) @Mapping({ "compiler", "warn-changes-in-resolve" }) public void setCompilerWarnChangesInResolve(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_changes_in_resolve) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-class-is-sealed' option // private boolean warn_class_is_sealed = true; public boolean warn_class_is_sealed() { return warn_class_is_sealed; } @Config(advanced = true) @Mapping({ "compiler", "warn-class-is-sealed" }) public void setCompilerWarnClassIsSealed(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_class_is_sealed) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-const-not-initialized' option // private boolean warn_const_not_initialized = true; public boolean warn_const_not_initialized() { return warn_const_not_initialized; } @Config(advanced = true) @Mapping({ "compiler", "warn-const-not-initialized" }) public void setCompilerWarnConstNotInitialized(ConfigurationValue cv, boolean b) { warn_const_not_initialized = b; } // // 'compiler.warn-constructor-returns-value' option // private boolean warn_constructor_returns_value = false; public boolean warn_constructor_returns_value() { return warn_constructor_returns_value; } @Config(advanced = true) @Mapping({ "compiler", "warn-constructor-returns-value" }) public void setCompilerWarnConstructorReturnsValue(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_constructor_returns_value) addRemovedConfigurationOptionProblem(cv); } // // '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; } @Config(advanced = true) @Mapping({ "compiler", "warn-deprecated-event-handler-error" }) public void setCompilerWarnDeprecatedEventHandlerError(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_deprecated_event_handler_error) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-deprecated-function-error' option // private boolean warn_deprecated_function_error = true; public boolean warn_deprecated_function_error() { return warn_deprecated_function_error; } @Config(advanced = true) @Mapping({ "compiler", "warn-deprecated-function-error" }) public void setCompilerWarnDeprecatedFunctionError(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_deprecated_function_error) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-deprecated-property-error' option // private boolean warn_deprecated_property_error = true; public boolean warn_deprecated_property_error() { return warn_deprecated_property_error; } @Config(advanced = true) @Mapping({ "compiler", "warn-deprecated-property-error" }) public void setCompilerWarnDeprecatedPropertyError(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_deprecated_property_error) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-duplicate-argument-names' option // private boolean warn_duplicate_argument_names = true; public boolean warn_duplicate_argument_names() { return warn_duplicate_argument_names; } @Config(advanced = true) @Mapping({ "compiler", "warn-duplicate-argument-names" }) public void setCompilerWarnDuplicateArgumentNames(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_duplicate_argument_names) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-duplicate-variable-def' option // private boolean warn_duplicate_variable_def = true; public boolean warn_duplicate_variable_def() { return warn_duplicate_variable_def; } @Config(advanced = true) @Mapping({ "compiler", "warn-duplicate-variable-def" }) public void csetCompilerWarnDuplicateVariableDef(ConfigurationValue cv, boolean b) { warn_duplicate_variable_def = b; } // // '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; } @Config(advanced = true) @Mapping({ "compiler", "warn-for-var-in-changes" }) public void setCompilerWarnForVarInChanges(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_for_var_in_changes) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-import-hides-class' option // private boolean warn_import_hides_class = true; public boolean warn_import_hides_class() { return warn_import_hides_class; } @Config(advanced = true) @Mapping({ "compiler", "warn-import-hides-class" }) public void setCompilerWarnImportHidesClass(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_import_hides_class) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-instance-of-changes' option // private boolean warn_instance_of_changes = true; public boolean warn_instance_of_changes() { return warn_instance_of_changes; } @Config(advanced = true) @Mapping({ "compiler", "warn-instance-of-changes" }) public void setCompilerWarnInstanceOfChanges(ConfigurationValue cv, boolean b) { warn_instance_of_changes = b; } // // 'compiler.warn-internal-error' option // private boolean warn_internal_error = true; public boolean warn_internal_error() { return warn_internal_error; } @Config(advanced = true) @Mapping({ "compiler", "warn-internal-error" }) public void setCompilerWarnInternalError(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_internal_error) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-level-not-supported' option // private boolean warn_level_not_supported = true; public boolean warn_level_not_supported() { return warn_level_not_supported; } @Config(advanced = true) @Mapping({ "compiler", "warn-level-not-supported" }) public void setCompilerWarnLevelNotSupported(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_level_not_supported) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-missing-namespace-decl' option // private boolean warn_missing_namespace_decl = true; public boolean warn_missing_namespace_decl() { return warn_missing_namespace_decl; } @Config(advanced = true) @Mapping({ "compiler", "warn-missing-namespace-decl" }) public void setCompilerWarnMissingNamespaceDecl(ConfigurationValue cv, boolean b) { warn_missing_namespace_decl = b; } // // 'compiler.warn-negative-uint-literal' option // private boolean warn_negative_uint_literal = true; public boolean warn_negative_uint_literal() { return warn_negative_uint_literal; } @Config(advanced = true) @Mapping({ "compiler", "warn-negative-uint-literal" }) public void setCompilerWarnNegativeUintLiteral(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_negative_uint_literal) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-no-constructor' option // private boolean warn_no_constructor = false; public boolean warn_no_constructor() { return warn_no_constructor; } @Config(advanced = true) @Mapping({ "compiler", "warn-no-constructor" }) public void setCompilerWarnNoConstructor(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_no_constructor) addRemovedConfigurationOptionProblem(cv); } // // '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; } @Config(advanced = true) @Mapping({ "compiler", "warn-no-explicit-super-call-in-constructor" }) public void setCompilerWarnNoExplicitSuperCallInConstructor(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_no_explicit_super_call_in_constructor) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-no-type-decl' option // private boolean warn_no_type_decl = true; public boolean warn_no_type_decl() { return warn_no_type_decl; } @Config(advanced = true) @Mapping({ "compiler", "warn-no-type-decl" }) public void setCompilerWarnNoTypeDecl(ConfigurationValue cv, boolean b) { warn_no_type_decl = b; } // // '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; } @Config(advanced = true) @Mapping({ "compiler", "warn-number-from-string-changes" }) public void setCompilerWarnNumberFromStringChanges(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_number_from_string_changes) addRemovedConfigurationOptionProblem(cv); } // // '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; } @Config(advanced = true) @Mapping({ "compiler", "warn-scoping-change-in-this" }) public void setCompilerWarnScopingChangeInThis(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_scoping_change_in_this) addRemovedConfigurationOptionProblem(cv); } // // '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; } @Config(advanced = true) @Mapping({ "compiler", "warn-slow-text-field-addition" }) public void setCompilerWarnSlowTextFieldAddition(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_slow_text_field_addition) addRemovedConfigurationOptionProblem(cv); } // // 'compiler.warn-unlikely-function-value' option // private boolean warn_unlikely_function_value = true; public boolean warn_unlikely_function_value() { return warn_unlikely_function_value; } @Config(advanced = true) @Mapping({ "compiler", "warn-unlikely-function-value" }) public void setCompilerWarnUnlikelyFunctionValue(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_unlikely_function_value) addRemovedConfigurationOptionProblem(cv); } // // '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; } @Config(advanced = true) @Mapping({ "compiler", "warn-xml-class-has-changed" }) public void setCompilerWarnXmlClassHasChanged(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != warn_xml_class_has_changed) addRemovedConfigurationOptionProblem(cv); } // // compiler.generate-abstract-syntax-tree // private boolean generateAbstractSyntaxTree = true; @Config(hidden = true) @Mapping({ "compiler", "generate-abstract-syntax-tree" }) public void setCompilerGenerateAbstractSyntaxTree(ConfigurationValue cv, boolean b) { generateAbstractSyntaxTree = b; } public boolean getCompilerGenerateAbstractSyntaxTree() { return generateAbstractSyntaxTree; } // // '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 getCompilerIsolateStyles() { return isolateStyles && (getCompilerCompatibilityVersion() >= MXML_VERSION_4_0); } @Config(advanced = true) @Mapping({ "compiler", "isolate-styles" }) @FlexOnly public void setCompilerIsolateStyles(ConfigurationValue cv, boolean isolateStyles) { this.isolateStyles = isolateStyles; } // // 'compiler.compress' option (default is true) // private boolean useCompression = true; @Config @Mapping({ "compiler", "compress" }) public void setCompress(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; } // ATTENTION: Please set default values in DefaultsConfigurator. private static final String LOCALE_TOKEN = "{locale}"; private static final String TARGET_PLAYER_MAJOR_VERSION_TOKEN = "{targetPlayerMajorVersion}"; private static final String TARGET_PLAYER_MINOR_VERSION_TOKEN = "{targetPlayerMinorVersion}"; private static final String TARGET_PLAYER_MAJOR_VERSION_TOKEN_REGEX_ESCAPED = Pattern .quote(TARGET_PLAYER_MAJOR_VERSION_TOKEN); private static final String TARGET_PLAYER_MINOR_VERSION_TOKEN_REGEX_ESCAPED = Pattern .quote(TARGET_PLAYER_MINOR_VERSION_TOKEN); // 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}"; public static final String STRICT = "compiler.strict"; public static final String AS3 = "compiler.as3"; public static final String ES = "compiler.es"; public ImmutableList<String> expandTokens(final Iterable<String> pathElements, final Iterable<String> locales, final ConfigurationValue configurationValue) { return expandTokens(pathElements, locales, configurationValue, false); } /** * All path-tokens get expanded from this method, as of now, {locale} and * {targetPlayerMajorVersion} Replaces instances of * "{targetPlayerMajorVersion}" and "{targetPlayerMinorVersion}" with * configured value. Expands the {locale} token in a list of path elements * for the source-path or library-path. 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: * * <pre> * -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 * </pre> * * @param pathElements A list of unprocessed paths from configuration * values. * @param locales A set of locales. * @param configurationValue Context. * @param returnMissingFiles controls whether or not files that do not * exist are included in the list of expanded files. Pass true to include * files that do not exist, false otherwise. * @return A list of normalized and resolved file paths. * @throws CannotOpen */ protected ImmutableList<String> expandTokens(final Iterable<String> pathElements, final Iterable<String> locales, final ConfigurationValue configurationValue, final boolean returnMissingFiles) { assert pathElements != null : "Expected path list."; assert locales != null : "Expected locales."; assert configurationValue != null : "Expected ConfigurationValue as a context."; String targetPlayerMajorVersion = String.valueOf(getTargetPlayerMajorVersion()); String targetPlayerMinorVersion = String.valueOf(getTargetPlayerMinorVersion()); // Expand target player and locale tokens. final ImmutableList.Builder<String> resolvedPaths = new ImmutableList.Builder<String>(); for (String pathElement : pathElements) { pathElement = expandRuntimeTokens(pathElement); String playerExpandedPath = pathElement .replaceAll(TARGET_PLAYER_MAJOR_VERSION_TOKEN_REGEX_ESCAPED, targetPlayerMajorVersion) .replaceAll(TARGET_PLAYER_MINOR_VERSION_TOKEN_REGEX_ESCAPED, targetPlayerMinorVersion); try { if (playerExpandedPath.contains(LOCALE_TOKEN)) { for (final String locale : locales) { final String expandedPath = playerExpandedPath.replace(LOCALE_TOKEN, locale); String resolvedPath = resolvePathStrict(expandedPath, configurationValue); resolvedPaths.add(resolvedPath); //Add this to the locale dependent sources map localeDependentSources.put(resolvedPath, locale); } } else { String resolvedPath = resolvePathStrict(playerExpandedPath, configurationValue, returnMissingFiles); resolvedPaths.add(resolvedPath); } } catch (CannotOpen e) { // Making an exception here and catching this fatal error. // This is an exception because library paths come thru this // code path and we don't want to throw all of the libraries // out because one of the paths is bad. We want to load as // many libraries as we can an report the ones we couldn't load. configurationProblems.add(new ConfigurationProblem(e)); } } return resolvedPaths.build(); } /** * 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 pathElement) { // 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; pathElement = pathElement.replace(PLAYERGLOBAL_HOME_TOKEN, playerglobalHome); pathElement = pathElement.replace(AIR_HOME_TOKEN, airHome); return pathElement; } /** * 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; } private Map<String, String> localeDependentSources = new HashMap<String, String>(); /** * Returns a map that stores locale dependent files. For each item in this * map, key is the path of the resource and value id the locale it belongs * to. */ public Map<String, String> getLocaleDependentSources() { return localeDependentSources; } /** * * @param path A path to resolve. * @param cv Configuration context. * @return A single normalized resolved file. If the path could be expanded * into more than one path, then use {@link resolvePathsStrict} * @throws CannotOpen */ private String resolvePathStrict(final String path, final ConfigurationValue cv) throws CannotOpen { return resolvePathStrict(path, cv, false); } /** * Resolve a single path. This is a more strict version of * {@link #resolvePaths()} in that it throws {@link CannotOpen} exception * when a file path element can't be resolved. * * @param path A path to resolve. * @param cv Configuration context. * @param returnMissingFiles Determines if the CannotOpen exception is thrown * if a file does not exist. Pass true to disable exceptions and return * files that do not exist. Pass false to throw exceptions. * @return A single normalized resolved file. If the path could be expanded * into more than one path, then use {@link resolvePathsStrict}. * @throws CannotOpen error * @see #resolvePaths(ImmutableList, ConfigurationValue) */ private String resolvePathStrict(final String path, final ConfigurationValue cv, final boolean returnMissingFiles) throws CannotOpen { ImmutableList<String> singletonPath = ImmutableList.of(path); ImmutableList<String> results = resolvePathsStrict(singletonPath, cv, returnMissingFiles); return results.get(0); } /** * Resolve a list of paths. This is a more strict version of * {@link #resolvePaths()} in that it throws {@link CannotOpen} exception * when a file path element can't be resolved. * * @param paths A list of paths to resolve. * @param cv Configuration context. * @return A list of normalized resolved file paths. * @throws CannotOpen error * @see #resolvePaths(ImmutableList, ConfigurationValue) */ private ImmutableList<String> resolvePathsStrict(final ImmutableList<String> paths, final ConfigurationValue cv) throws CannotOpen { return resolvePathsStrict(paths, cv, false); } /** * Resolve a list of paths. This is a more strict version of * {@link #resolvePaths()} in that it throws {@link CannotOpen} exception * when a file path element can't be resolved. * * @param paths A list of paths to resolve. * @param cv Configuration context. * @param returnMissingFiles Determines if the CannotOpen exception is thrown * if a file does not exist. Pass true to disable exceptions and return * files that do not exist. Pass false to throw exceptions. * @return A list of normalized resolved file paths. * @throws CannotOpen error * @see #resolvePaths(ImmutableList, ConfigurationValue) */ private ImmutableList<String> resolvePathsStrict(final ImmutableList<String> paths, final ConfigurationValue cv, final boolean returnMissingFiles) throws CannotOpen { assert paths != null : "Expected paths"; assert cv != null : "Require ConfigurationValue as context."; final ImmutableList.Builder<String> resolvedPathsBuilder = new ImmutableList.Builder<String>(); for (String processedPath : paths) { if (cv.getContext() != null) { boolean isAbsolute = new File(processedPath).isAbsolute(); if (!isAbsolute) processedPath = new File(cv.getContext(), processedPath).getAbsolutePath(); } final File fileSpec = pathResolver.resolve(processedPath); if (!returnMissingFiles && !fileSpec.exists()) { throw new CannotOpen(FilenameNormalization.normalize(processedPath), cv.getVar(), cv.getSource(), cv.getLine()); } resolvedPathsBuilder.add(fileSpec.getAbsolutePath()); } return resolvedPathsBuilder.build(); } ////////////////////////////////////////////////////////////////////////// // compiler.extensions.* ////////////////////////////////////////////////////////////////////////// // // 'compiler.extensions.extension' option // /** * Configures a list of many extensions mapped to a single Extension URI. <extension> * <extension>something-extension.jar</extension> <parameters>version=1.1,content=1.2</parameters> </extension> * * @param cv The configuration value context. * @param pathlist A List of values for the Extension element, with the first item expected to be the uri and the * remaining are extension paths. * @throws CannotOpen When no arg is provided or when the jar does not exist. */ @Config(allowMultiple = true, removed = true) @Mapping({ "compiler", "extensions", "extension" }) @Arguments({ "extension", "parameters" }) @InfiniteArguments public void setExtension(ConfigurationValue cv, String[] pathlist) throws CannotOpen { } ////////////////////////////////////////////////////////////////////////// // compiler.fonts.* ////////////////////////////////////////////////////////////////////////// @Config @Mapping({ "compiler", "fonts", "advanced-anti-aliasing" }) @FlexOnly public void setCompilerFontsAdvancedAntiAliasing(ConfigurationValue cv, boolean val) { // intentionally do nothing here as feature removed, but don't annotate as removed // as to not generate warnings for flex-config's which still set this options } @Config(allowMultiple = true, advanced = true) @Mapping({ "compiler", "fonts", "languages", "language-range" }) @Arguments({ "lang", "range" }) @FlexOnly public void setCompilerFontsLanguagesLanguageRange(ConfigurationValue cv, String lang, String range) { // intentionally do nothing here as feature removed, but don't annotate as removed // as to not generate warnings for flex-config's which still set this options } @Config @Mapping({ "compiler", "fonts", "local-fonts-snapshot" }) @FlexOnly public void setCompilerFontsLocalFontsSnapshot(ConfigurationValue cv, String localFontsSnapshotPath) throws CannotOpen { // intentionally do nothing here as feature removed, but don't annotate as removed // as to not generate warnings for flex-config's which still set this options } @Config @Mapping({ "compiler", "fonts", "local-font-paths" }) @Arguments(Arguments.PATH_ELEMENT) @InfiniteArguments @FlexOnly public void setCompilerFontsLocalFontPaths(ConfigurationValue cv, List<String> list) throws CannotOpen { // intentionally do nothing here as feature removed, but don't annotate as removed // as to not generate warnings for flex-config's which still set this options } @Config(advanced = true) @Mapping({ "compiler", "fonts", "managers" }) @Arguments("manager-class") @InfiniteArguments @FlexOnly public void setCompilerFontsManagers(ConfigurationValue cv, List<String> list) { // intentionally do nothing here as feature removed, but don't annotate as removed // as to not generate warnings for flex-config's which still set this options } @Config @Mapping({ "compiler", "fonts", "max-cached-fonts" }) @FlexOnly public void setCompilerFontsMaxCachedFonts(ConfigurationValue cv, String val) { // intentionally do nothing here as feature removed, but don't annotate as removed // as to not generate warnings for flex-config's which still set this options } @Config @Mapping({ "compiler", "fonts", "max-glyphs-per-face" }) @FlexOnly public void setCompilerFontsMaxGlyphsPerFace(ConfigurationValue cv, String val) { // intentionally do nothing here as feature removed, but don't annotate as removed // as to not generate warnings for flex-config's which still set this options } ////////////////////////////////////////////////////////////////////////// // compiler.namespaces ////////////////////////////////////////////////////////////////////////// private List<MXMLNamespaceMapping> manifestMappings; public List<MXMLNamespaceMapping> getCompilerNamespacesManifestMappings() { return manifestMappings; } /** * Configures a list of many manifests mapped to a single namespace URI. * <namespace> <uri>library:adobe/flex/something</uri> * <manifest>something-manifest.xml</manifest> * <manifest>something-else-manifest.xml</manifest> ... </namespace> * * @param cfgval The configuration value context. * @param args A List of values for the namespace element, with the first * item expected to be the uri and the remaining are manifest paths. */ @Config(allowMultiple = true) @Mapping({ "compiler", "namespaces", "namespace" }) @Arguments({ "uri", "manifest" }) @InfiniteArguments @FlexOnly public void setCompilerNamespacesNamespace(ConfigurationValue cfgval, List<String> args) throws ConfigurationException { if (args == null) throw new ConfigurationException.CannotOpen(null, cfgval.getVar(), cfgval.getSource(), cfgval.getLine()); // allow -compiler.namespaces.namespace= which means don't add // anything, which matches the behavior of things like -compiler.library-path // which don't throw an error in this case either. if (args.isEmpty()) return; if (args.size() < 2) throw new ConfigurationException.NamespaceMissingManifest("namespace", cfgval.getSource(), cfgval.getLine()); if (args.size() % 2 != 0) throw new ConfigurationException.IncorrectArgumentCount(args.size() + 1, args.size(), cfgval.getVar(), cfgval.getSource(), cfgval.getLine()); if (manifestMappings == null) manifestMappings = new ArrayList<MXMLNamespaceMapping>(); for (int i = 0; i < args.size() - 1; i += 2) { final String uri = args.get(i); final String manifestFile = args.get(i + 1); final String path = resolvePathStrict(manifestFile, cfgval); manifestMappings.add(new MXMLNamespaceMapping(uri, path)); } } /////////////////////////////////////////////////////////////////////////// // metadata.* /////////////////////////////////////////////////////////////////////////// // // 'metadata.contributor' option // private final Set<String> contributors = new TreeSet<String>(); @Config(allowMultiple = true) @Mapping({ "metadata", "contributor" }) @Arguments("name") public void setMetadataContributor(ConfigurationValue cv, String name) { contributors.add(name); } // // 'metadata.creator' option // private final Set<String> creators = new TreeSet<String>(); @Config(allowMultiple = true) @Mapping({ "metadata", "creator" }) @Arguments("name") public void setMetadataCreator(ConfigurationValue cv, String name) { creators.add(name); } // // 'metadata.date' option // public String date = null; @Config @Mapping({ "metadata", "date" }) @Arguments("text") public void setMetadataDate(ConfigurationValue cv, String text) { date = text; } // // 'metadata.description' option // private final Map<String, String> localizedDescriptions = new LinkedHashMap<String, String>(); @Config @Mapping({ "metadata", "description" }) @Arguments("text") public void setMetadataDescription(ConfigurationValue cv, String text) { localizedDescriptions.put("x-default", text); } // // 'metadata.language' option // public final Set<String> langs = new TreeSet<String>(); @Config(allowMultiple = true) @Mapping({ "metadata", "language" }) @Arguments("code") public void setMetadataLanguage(ConfigurationValue cv, String code) { langs.add(code); } // // 'metadata.localized-description' option // @Config(allowMultiple = true) @Mapping({ "metadata", "localized-description" }) @Arguments({ "text", "lang" }) public void setMetadataLocalizedDescription(ConfigurationValue cv, String text, String lang) { localizedDescriptions.put(lang, text); } // // 'metadata.localized-title' option // @Config(allowMultiple = true) @Mapping({ "metadata", "localized-title" }) @Arguments({ "title", "lang" }) public void setMetadataLocalizedTitle(ConfigurationValue cv, String title, String lang) { localizedTitles.put(lang, title); } // // 'metadata.publisher' option // private final Set<String> publishers = new TreeSet<String>(); @Config(allowMultiple = true) @Mapping({ "metadata", "publisher" }) @Arguments("name") public void setMetadataPublisher(ConfigurationValue cv, String name) { publishers.add(name); } // // 'metadata.title' option // private final Map<String, String> localizedTitles = new LinkedHashMap<String, String>(); @Config @Mapping({ "metadata", "title" }) @Arguments("text") public void setMetadataTitle(ConfigurationValue cv, String title) { localizedTitles.put("x-default", title); } ////////////////////////////////////////////////////////////////////////// // runtime-shared-library-settings ////////////////////////////////////////////////////////////////////////// // // 'force-rsl' option // private Set<String> forceRsls; /** * Get the array of SWCs that should have their RSLs loaded, even if the * compiler detects no classes being used from the SWC. * * @return Array of SWCs that should have their RSLs loaded. */ public Set<String> getForceRsls() { if (forceRsls == null) { return Collections.emptySet(); } return forceRsls; } @Config(advanced = true, allowMultiple = true) @Mapping({ "runtime-shared-library-settings", "force-rsls" }) @SoftPrerequisites({ "runtime-shared-library-path" }) @Arguments(Arguments.PATH_ELEMENT) @InfiniteArguments @FlexOnly public void setForceRsls(ConfigurationValue cfgval, String[] args) throws ConfigurationException { if (forceRsls == null) { forceRsls = new HashSet<String>(); } // Add swc to the forceRsls set. for (String arg : args) { // path-element parameter (swc) // verify path exists and the swc has an // existing -rslp option specified. String swcPath = resolvePathStrict(arg, cfgval); // verify the swc is used in an the RSL configuration. if (!doesSwcHaveRSLInfo(swcPath)) { throw new ConfigurationException.SwcDoesNotHaveRslData(swcPath, cfgval.getVar(), cfgval.getSource(), cfgval.getLine()); } forceRsls.add(swcPath); } } // // 'application-domain' option // /* * Key: swc file path; Value: application domain target */ private HashMap<String, ApplicationDomainTarget> applicationDomains; /** * Get the application domain an RSL should be loaded into. The default is * the current application domain but the user can override this setting. * @param swcPath The full path of the swc file. * * @return The application domain the RSL should be loaded into. If the * swc is not found, then 'default' is returned. */ public ApplicationDomainTarget getApplicationDomain(String swcPath) { if (applicationDomains == null || swcPath == null) { return ApplicationDomainTarget.DEFAULT; } for (Map.Entry<String, ApplicationDomainTarget> entry : applicationDomains.entrySet()) { if (entry.getKey().equals(swcPath)) { return entry.getValue(); } } return ApplicationDomainTarget.DEFAULT; } @Config(advanced = true, allowMultiple = true) @SoftPrerequisites({ "runtime-shared-library-path" }) @Mapping({ "runtime-shared-library-settings", "application-domain" }) @Arguments({ "path-element", "application-domain-target" }) @InfiniteArguments @FlexOnly // TODO: need to create an argument name generator for the args. public void setApplicationDomain(ConfigurationValue cfgval, String[] args) throws ConfigurationException { // ignore the force option if we are static linking if (getStaticLinkRsl()) return; if (applicationDomains == null) { applicationDomains = new HashMap<String, ApplicationDomainTarget>(); } // Add swc and application domain target to the map. // The args are: swc file path, application domain type, ... for (int i = 0; i < args.length; i++) { String arg = args[i++]; // path-element parameter (swc) // verify path exists and the swc has an // existing -rslp option specified. String swcPath = resolvePathStrict(arg, cfgval); // verify the swc is used in an the RSL configuration. if (!doesSwcHaveRSLInfo(swcPath)) { throw new ConfigurationException.SwcDoesNotHaveRslData(swcPath, cfgval.getVar(), cfgval.getSource(), cfgval.getLine()); } // Verify the application domain target is valid. arg = args[i]; ApplicationDomainTarget adTarget = getApplicationDomainTarget(arg); if (adTarget == null) { // throw a configuration exception that the application domain // type is incorrect. throw new ConfigurationException.BadApplicationDomainValue(swcPath, arg, cfgval.getVar(), cfgval.getSource(), cfgval.getLine()); } applicationDomains.put(swcPath, adTarget); } } /** * Test if the specified parameter is a valid application domain type. If * it is then return the corresponding enum. * * @param arg String value representing an ApplicationDomainTarget. * @return An ApplicationDomainTarget enum if the parameter is a valid * application domain target, null otherwise. */ private ApplicationDomainTarget getApplicationDomainTarget(String arg) { for (ApplicationDomainTarget appDomain : ApplicationDomainTarget.values()) { if (appDomain.getApplicationDomainValue().equals(arg)) return appDomain; } return null; } /** * Check if the SWC has any RSL info associated with it. * * @param swcPath * @return true if the swc has RSL info, false otherwise. */ private boolean doesSwcHaveRSLInfo(String swcPath) { if (swcPath == null) return false; List<RuntimeSharedLibraryPathInfo> rslInfoList = getRslPathInfo(); for (RuntimeSharedLibraryPathInfo rslInfo : rslInfoList) { if (swcPath.equals(rslInfo.getSWCFile().getPath())) return true; } return false; } ////////////////////////////////////////////////////////////////////////// // compiler.mxml ////////////////////////////////////////////////////////////////////////// // // 'compiler.mxml.compatibility-version' option // public static final int MXML_VERSION_4_6 = 0x04060000; public static final int MXML_VERSION_4_5 = 0x04050000; public static final int MXML_VERSION_4_0 = 0x04000000; public static final int MXML_VERSION_3_0 = 0x03000000; public static final int MXML_VERSION_2_0_1 = 0x02000001; public static final int MXML_VERSION_2_0 = 0x02000000; public static final int MXML_CURRENT_VERSION = MXML_VERSION_4_6; public static final int MXML_EARLIEST_MAJOR_VERSION = 3; public static final int MXML_LATEST_MAJOR_VERSION = 4; public static final int MXML_LATEST_MINOR_VERSION = 6; private int mxml_major = MXML_LATEST_MAJOR_VERSION; private int mxml_minor = MXML_LATEST_MINOR_VERSION; private int mxml_revision; private int mxmlMinMajor = MXML_EARLIEST_MAJOR_VERSION; private int mxmlMinMinor; private int mxmlMinRevision; public int getCompilerMxmlMajorCompatibilityVersion() { return mxml_major; } public int getCompilerMxmlMinorCompatibilityVersion() { return mxml_minor; } public int getCompilerMxmlRevisionCompatibilityVersion() { return mxml_revision; } /* * Unlike the framework's FlexVersion.compatibilityVersionString, this * returns null rather than a string like "3.0.0" for the current version. * But if a -compatibility-version was specified, this string will always be * of the form N.N.N. For example, if -compatibility-version=2, this string * is "2.0.0", not "2". */ public String getCompilerMxmlCompatibilityVersionString() { return (mxml_major == 0 && mxml_minor == 0 && mxml_revision == 0) ? null : mxml_major + "." + mxml_minor + "." + mxml_revision; } /* * This returns an int that can be compared with version constants such as * MxmlConfiguration.VERSION_3_0. */ public int getCompilerMxmlCompatibilityVersion() { int version = (mxml_major << 24) + (mxml_minor << 16) + mxml_revision; return version != 0 ? version : MXML_CURRENT_VERSION; } @Config @Mapping({ "compiler", "mxml", "compatibility-version" }) @Arguments("version") @FlexOnly public void setCompilerMxmlCompatibilityVersion(ConfigurationValue cv, String version) throws ConfigurationException { if (version == null) { return; } String[] results = version.split("\\."); if (results.length == 0) { throw new ConfigurationException.BadVersion(version, "compatibility-version"); } // Set minor and revision numbers to zero in case only a major number // was specified. this.mxml_minor = 0; this.mxml_revision = 0; for (int i = 0; i < results.length; i++) { int versionNum = 0; try { versionNum = Integer.parseInt(results[i]); } catch (NumberFormatException e) { throw new ConfigurationException.BadVersion(version, "compatibility-version"); } if (i == 0) { if (versionNum >= MXML_EARLIEST_MAJOR_VERSION && versionNum <= MXML_LATEST_MAJOR_VERSION) { this.mxml_major = versionNum; } else { throw new ConfigurationException.BadVersion(version, "compatibility-version"); } } else { if (versionNum >= 0) { if (i == 1) { this.mxml_minor = versionNum; } else { this.mxml_revision = versionNum; } } else { throw new ConfigurationException.BadVersion(version, "compatibility-version"); } } } } /* * Minimum supported SDK version for this library. This string will always * be of the form N.N.N. For example, if -minimum-supported-version=2, this * string is "2.0.0", not "2". */ public String getCompilerMxmlMinimumSupportedVersionString() { return (mxmlMinMajor == 0 && mxmlMinMinor == 0 && mxmlMinRevision == 0) ? null : mxmlMinMajor + "." + mxmlMinMinor + "." + mxmlMinRevision; } /* * This returns an int that can be compared with version constants such as * MxmlConfiguration.VERSION_3_0. */ public int getCompilerMxmlMinimumSupportedVersion() { int version = (mxmlMinMajor << 24) + (mxmlMinMinor << 16) + mxmlMinRevision; return version != 0 ? version : (MXML_EARLIEST_MAJOR_VERSION << 24); } public void setCompilerMxmlMinimumSupportedVersion(int version) { mxmlMinMajor = version >> 24 & 0xFF; mxmlMinMinor = version >> 16 & 0xFF; mxmlMinRevision = version & 0xFF; } @Config @Mapping({ "compiler", "mxml", "minimum-supported-version" }) @FlexOnly public void setCompilerMxmlMinimumSupportedVersion(ConfigurationValue cv, String version) throws ConfigurationException { if (version == null) { return; } String[] results = version.split("\\."); if (results.length == 0) { throw new ConfigurationException.BadVersion(version, "minimum-supported-version"); } for (int i = 0; i < results.length; i++) { int versionNum = 0; try { versionNum = Integer.parseInt(results[i]); } catch (NumberFormatException e) { throw new ConfigurationException.BadVersion(version, "minimum-supported-version"); } if (i == 0) { if (versionNum >= MXML_EARLIEST_MAJOR_VERSION && versionNum <= MXML_LATEST_MAJOR_VERSION) { this.mxmlMinMajor = versionNum; } else { throw new ConfigurationException.BadVersion(version, "minimum-supported-version"); } } else { if (versionNum >= 0) { if (i == 1) { mxmlMinMinor = versionNum; } else { mxmlMinRevision = versionNum; } } else { throw new ConfigurationException.BadVersion(version, "minimum-supported-version"); } } } isMinimumSupportedVersionConfigured = true; } private boolean isMinimumSupportedVersionConfigured = false; public boolean isCompilerMxmlMinimumSupportedVersionConfigured() { return isMinimumSupportedVersionConfigured; } // // '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; } @Config() @Mapping({ "compiler", "mobile" }) public void setMobile(ConfigurationValue cv, boolean b) { mobile = b; } //////////////////////////////////////////////////////////////////////////// // licenses.* //////////////////////////////////////////////////////////////////////////// // // 'license' option // @Config(allowMultiple = true, displayed = false, removed = true) @Mapping({ "licenses", "license" }) @Arguments({ "product", "serial-number" }) public void setLicensesLicense(ConfigurationValue cfgval, String product, String serialNumber) throws ConfigurationException { } //////////////////////////////////////////////////////////////////////////// // frames.* //////////////////////////////////////////////////////////////////////////// private List<FrameInfo> frameList = new LinkedList<FrameInfo>(); public List<FrameInfo> getFrameList() { return frameList; } @Config(advanced = true, allowMultiple = true) @Mapping({ "frames", "frame" }) @Arguments({ "label", "classname" }) @InfiniteArguments public void setFramesFrame(ConfigurationValue cv, List<String> args) throws ConfigurationException { // "args" are [label, qname, qname, qname, ...] final FrameInfo info = new FrameInfo(); if (args.size() < 2) throw new ConfigurationException.BadFrameParameters(cv.getVar(), cv.getSource(), cv.getLine()); for (final String next : args) { if (info.getLabel() == null) { info.setLabel(next); } else { info.getFrameClasses().add(next); } } frameList.add(info); } // // -as3 // private boolean as3 = true; @Config(advanced = true) @Mapping({ "compiler", "as3" }) @DeprecatedConfig public void setAS3(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != as3) addRemovedConfigurationOptionProblem(cv); } // // -es // private boolean es = false; @Config(advanced = true) @Mapping({ "compiler", "es" }) @DeprecatedConfig public void setES(ConfigurationValue cv, boolean b) { // This option is set in flex-config.xml so only warn // if the user sets a non-default value. if (b != es) addRemovedConfigurationOptionProblem(cv); } //////////////////////////////////////////////////////////////////////////// // Compc Options //////////////////////////////////////////////////////////////////////////// // // compute-digest=true|false // /** * Writes a digest to the catalog.xml of a library. Use this when the * library will be used as a cross-domain RSL or when you want to enforce * the versioning of RSLs. The default value is true. */ @Config(compcOnly = true, removed = true) @Mapping("compute-digest") public void setComputeDigest(ConfigurationValue cv, boolean value) { } /** * directory=false|true */ private boolean outputSwcAsDirectory = false; /** * Outputs the SWC file in an open directory format rather than a SWC file. * You use this option with the output option to specify a destination * directory, as the following example shows: * * <pre> * compc -directory=true -output=destination_directory * </pre> */ @Config(compcOnly = true) @Mapping("directory") public void setOutputSwcAsDirectory(ConfigurationValue cv, boolean value) { outputSwcAsDirectory = value; } /** * @return True if the compiler will build the SWC file in an open directory * format rather than a SWC file. */ public boolean getOutputSwcAsDirectory() { return outputSwcAsDirectory; } /** * include-classes class [...] */ private final List<String> includeClasses = new ArrayList<String>(); /** * Specifies classes to include in the SWC file. You provide the class name * (for example, MyClass) rather than the file name (for example, * MyClass.as) to the file for this option. As a result, all classes * specified with this option must be in the compiler's source path. You * specify this by using the source-path compiler option. * <p> * You can use packaged and unpackaged classes. To use components in * namespaces, use the include-namespaces option. * <p> * If the components are in packages, ensure that you use dot-notation * rather than slashes to separate package levels. * <p> * This is the default option for the component compiler. */ @Config(compcOnly = true, allowMultiple = true) @Arguments(Arguments.CLASS) @Mapping("include-classes") public void setIncludeClasses(ConfigurationValue cv, List<String> values) { includeClasses.addAll(values); } /** * @return A list of class names to be included in the target. */ public List<String> getIncludeClasses() { return includeClasses; } /** * include-file name path [...] */ public final Map<String, String> includeFilesNamePath = new LinkedHashMap<String, String>(); /** * Adds the file to the SWC file. This option does not embed files inside * the library.swf file. This is useful for adding graphics files, where you * want to add non-compiled files that can be referenced in a style sheet or * embedded as assets in MXML files. * <p> * If you add a stylesheet that references compiled resources such as * programmatic skins, use the include-stylesheet option. * <p> * If you use the [Embed] syntax to add a resource to your application, you * are not required to use this option to also link it into the SWC file. */ @Config(compcOnly = true, allowMultiple = true) @Mapping("include-file") @Arguments({ "name", "path" }) public void setIncludeFiles(ConfigurationValue cv, List<String> values) throws IncorrectArgumentCount, CannotOpen, RedundantFile { // Expect name-path pairs in the arguments. final int size = values.size(); if (size % 2 != 0) throw new IncorrectArgumentCount(size + 1, size, cv.getVar(), cv.getSource(), cv.getLine()); for (int nameIndex = 0; nameIndex < size - 1; nameIndex += 2) { final String name = values.get(nameIndex); final String path = resolvePathStrict(values.get(nameIndex + 1), cv); if (includeFilesNamePath.containsKey(name)) { throw new ConfigurationException.RedundantFile(name, cv.getVar(), cv.getSource(), cv.getLine()); } includeFilesNamePath.put(name, path); } } /** * @return A map of included files. The keys are file entry names; The * values are file paths. */ public Map<String, String> getIncludeFiles() { return includeFilesNamePath; } /** * include-lookup-only=false|true */ private boolean includeLookupOnly = false; /** * If true, only manifest entries with lookupOnly=true are included in the * SWC catalog. */ @Config(compcOnly = true, advanced = true) @Mapping("include-lookup-only") @FlexOnly public void setIncludeLookupOnly(ConfigurationValue cv, boolean value) { includeLookupOnly = value; } /** * @return If true, only manifest entries with lookupOnly=true are included * in the SWC catalog. */ public boolean getIncludeLookupOnly() { return includeLookupOnly; } /** * include-namespaces uri [...] */ private final List<String> includeNamespaces = new ArrayList<String>(); /** * Specifies namespace-style components in the SWC file. You specify a list * of URIs to include in the SWC file. The uri argument must already be * defined with the namespace option. * <p> * To use components in packages, use the include-classes option. */ @Config(compcOnly = true, allowMultiple = true) @Mapping("include-namespaces") @Arguments({ "uri" }) @FlexOnly public void setIncludeNamespaces(ConfigurationValue cv, List<String> values) { includeNamespaces.addAll(values); } /** * @return A list of URIs to include in the SWC file. */ public List<String> getIncludeNamespaces() { return includeNamespaces; } /** * include-sources path-element */ private final List<String> includeSources = new ArrayList<String>(); /** * Specifies classes or directories to add to the SWC file. When specifying * classes, you specify the path to the class file (for example, MyClass.as) * rather than the class name itself (for example, MyClass). This lets you * add classes to the SWC file that are not in the source path. In general, * though, use the include-classes option, which lets you add classes that * are in the source path. * <p> * If you specify a directory, this option includes all files with an MXML * or AS extension, and ignores all other files. * <p> * If you use this option to include MXML components that are in a * non-default package, you must include the source folder in the source * path. */ @Config(compcOnly = true, allowMultiple = true) @Mapping("include-sources") @Arguments(Arguments.PATH_ELEMENT) public void setIncludeSources(ConfigurationValue cv, List<String> values) throws NotAFile { fillListWithResolvedPaths(values, includeSources, cv); } /** * @return Normalized file paths of the included source files. */ public List<String> getIncludeSources() { return includeSources; } /** * Clear the {@code target} list and add resolved file paths from * {@code source} list. * * @param source Source list with un-resolved file paths. * @param target Target list. * @param cv Context. * @throws CannotOpen */ private void fillListWithResolvedPaths(final List<String> source, final List<String> target, final ConfigurationValue cv) throws NotAFile { target.clear(); for (final String path : source) { String resolvedPath; try { resolvedPath = resolvePathStrict(path, cv); target.add(resolvedPath); } catch (CannotOpen e) { throw new ConfigurationException.NotAFile(path, cv.getVar(), cv.getSource(), cv.getLine()); } } } /** * include-stylesheet namepath [...] */ private final List<String> includeStyleSheets = new ArrayList<String>(); /** * Specifies stylesheets to add to the SWC file. This option compiles * classes that are referenced by the stylesheet before including the * stylesheet in the SWC file. * <p> * You do not need to use this option for all stylesheets; only stylesheets * that reference assets that need to be compiled such as programmatic skins * or other class files. If your stylesheet does not reference compiled * assets, you can use the include-file option. * <p> * This option does not compile the stylesheet into a SWF file before * including it in the SWC file. You compile a CSS file into a SWF file when * you want to load it at run time. */ @Config(compcOnly = true, allowMultiple = true) @Mapping("include-stylesheet") @Arguments({ "name", "path" }) @FlexOnly public void setIncludeStyleSheets(ConfigurationValue cv, List<String> values) throws NotAFile { fillListWithResolvedPaths(values, includeStyleSheets, cv); } /** * @return A list of the normalized file path of stylesheets to add to the * SWC file. */ public List<String> getIncludeStyleSheets() { return includeStyleSheets; } private File dependencyGraphOutput; /** * Specifies a file name that a graphml version of the dependency graph * should be written to. * */ @Config(advanced = true) @Mapping("dependency-graph") @Arguments("filename") public void setDependencyGraphOutput(ConfigurationValue cv, String fileName) { dependencyGraphOutput = new File(getOutputPath(cv, fileName)); } /** * Gets the location the graphml version of the dependency graph should be * written to, null if no dependecy graph should be written. * * @return The location the dependency graph should be written to. */ public File getDependencyGraphOutput() { return dependencyGraphOutput; } // // 'output' option // private String output; public String getOutput() { return output; } @Config @Arguments("filename") public void setOutput(ConfigurationValue val, String output) throws ConfigurationException { this.output = getOutputPath(val, output); } // // 'dump-config-file' option from ToolsConfiguration // private String dumpConfigFile = null; /** * @return filename of the configuration dump */ public String getDumpConfig() { return dumpConfigFile; } @Config(advanced = true, displayed = false) @Arguments("filename") @Mapping("dump-config") public void setDumpConfig(ConfigurationValue cv, String filename) { dumpConfigFile = getOutputPath(cv, filename); } // // 'warnings' option from ToolsConfiguration // private boolean warnings = true; public boolean getWarnings() { return warnings; } @Config @Mapping("warnings") public void setWarnings(ConfigurationValue cv, boolean b) { warnings = b; } // // 'error-problems' // private Collection<Class<ICompilerProblem>> errorClasses; /** * Get the collection of user specified problem classes that should be * treated as errors. * * @return list of problem classes that should be treated as errors. */ public Collection<Class<ICompilerProblem>> getErrorProblems() { return errorClasses != null ? errorClasses : Collections.<Class<ICompilerProblem>>emptyList(); } @Config(allowMultiple = true) @Arguments(Arguments.CLASS) @InfiniteArguments public void setErrorProblems(ConfigurationValue cv, List<String> classNames) throws ConfigurationException { if (errorClasses == null) errorClasses = new HashSet<Class<ICompilerProblem>>(); // Convert string to a class and save. for (String className : classNames) { Class<ICompilerProblem> resolvedClass = resolveProblemClassName(className); if (resolvedClass == null) { throw new ConfigurationException.CompilerProblemClassNotFound(className, cv.getVar(), cv.getSource(), cv.getLine()); } errorClasses.add(resolvedClass); } } // // 'warning-problems' // private Collection<Class<ICompilerProblem>> warningClasses; /** * Get the collection of user specified problem classes that should be * treated as warnings. * * @return list of problem classes that should be treated as warnings. */ public Collection<Class<ICompilerProblem>> getWarningProblems() { return warningClasses != null ? warningClasses : Collections.<Class<ICompilerProblem>>emptyList(); } @Config(allowMultiple = true) @Arguments(Arguments.CLASS) @InfiniteArguments public void setWarningProblems(ConfigurationValue cv, List<String> classNames) throws ConfigurationException { if (warningClasses == null) warningClasses = new HashSet<Class<ICompilerProblem>>(); // Convert string to a class and save. for (String className : classNames) { Class<ICompilerProblem> resolvedClass = resolveProblemClassName(className); if (resolvedClass == null) { throw new ConfigurationException.CompilerProblemClassNotFound(className, cv.getVar(), cv.getSource(), cv.getLine()); } warningClasses.add(resolvedClass); } } // // 'ignore-problems' // private Collection<Class<ICompilerProblem>> ignoreClasses; /** * Get the collection of user specified problem classes that should be * ignored. * * @return list of problem classes that should be ignored. */ public Collection<Class<ICompilerProblem>> getIgnoreProblems() { return ignoreClasses != null ? ignoreClasses : Collections.<Class<ICompilerProblem>>emptyList(); } @Config(allowMultiple = true) @Arguments(Arguments.CLASS) @InfiniteArguments public void setIgnoreProblems(ConfigurationValue cv, List<String> classNames) throws ConfigurationException { if (ignoreClasses == null) ignoreClasses = new HashSet<Class<ICompilerProblem>>(); // Convert string to a class and save. for (String className : classNames) { Class<ICompilerProblem> resolvedClass = resolveProblemClassName(className); if (resolvedClass == null) { throw new ConfigurationException.CompilerProblemClassNotFound(className, cv.getVar(), cv.getSource(), cv.getLine()); } ignoreClasses.add(resolvedClass); } } // // 'legacy-message-format' // private boolean legacyMessageFormat = true; public boolean useLegacyMessageFormat() { return legacyMessageFormat; } @Config(hidden = true) public void setLegacyMessageFormat(ConfigurationValue cv, boolean value) throws ConfigurationException { legacyMessageFormat = value; } // // 'create-target-with-errors' // private boolean createTargetWithErrors = false; public boolean getCreateTargetWithErrors() { return createTargetWithErrors; } @Config(hidden = true) public void setCreateTargetWithErrors(ConfigurationValue cv, boolean value) throws ConfigurationException { createTargetWithErrors = value; } // // 'flex' // private boolean isFlex = false; public boolean isFlex() { return isFlex; } /** * Option to enable or prevent various Flex compiler behaviors. This is * currently used to enable/disable the generation of a root class for * library swfs and generation of Flex specific code for application swfs. */ @Config(hidden = true) public void setFlex(ConfigurationValue cv, boolean value) throws ConfigurationException { isFlex = value; } /** * Resolve a problem class name to a Java Class. * * @param className May be fully qualified. If the class name is not fully * qualified, it is assumed to live in the "org.apache.flex.compiler.problems" package. * * @return A class corresponding to the className or null if the class name was not * found. */ @SuppressWarnings("unchecked") private Class<ICompilerProblem> resolveProblemClassName(String className) { if (className == null) return null; Class<?> resolvedClass = null; try { resolvedClass = Class.forName(className); } catch (ClassNotFoundException e) { return null; } if (ICompilerProblem.class.isAssignableFrom(resolvedClass)) return (Class<ICompilerProblem>) resolvedClass; else return null; } // // 'file-specs' option // private List<String> fileSpecs = new ArrayList<String>(); /** * Get target file path. Target file is the last file in the * {@link #getFileSpecs()}. */ public String getTargetFile() { if (fileSpecs.isEmpty()) return null; else return Iterables.getLast(fileSpecs); } /** * @return Path of the target's parent directory. */ public String getTargetFileDirectory() { final String targetFile = getTargetFile(); if (targetFile == null) return null; final String normalizedTargetFile = FilenameNormalization.normalize(targetFile); return FilenameUtils.getFullPathNoEndSeparator(normalizedTargetFile); } /** * This has been added so that unit tests can change the target file. * It isn't normally called when running the command line compiler. */ public void setTargetFile(String mainFile) { fileSpecs.clear(); fileSpecs.add(mainFile); } /** * @return A list of filespecs. It's the default variable for command line. */ public List<String> getFileSpecs() { return fileSpecs; } @Config(allowMultiple = true, hidden = true) @Arguments(Arguments.PATH_ELEMENT) @InfiniteArguments @SoftPrerequisites("flex") public void setFileSpecs(ConfigurationValue cv, List<String> args) throws ConfigurationException { this.fileSpecs.addAll(args); checkForMxmlFiles(args); } private void checkForMxmlFiles(List<String> paths) { // If there are mxml or css files then we are compiling a flex // application so enable "flex". for (String path : paths) { if (path.endsWith(".mxml") || path.endsWith(".css")) isFlex = true; } } // // 'help' option from CommandLineConfiguration // /** * dummy, just a trigger for help text */ @Config(displayed = false, greedy = true) @Arguments("keyword") @InfiniteArguments public void setHelp(ConfigurationValue cv, String[] keywords) { } // // 'load-config' option from CommandLineConfiguration // private String configFile = null; /** * @return Normalized path to a Flex configuration file. */ public String getLoadConfig() { return configFile; } /** * Since {@link ConfigurationBuffer} loads the "load-config" files, the * value of this configuration option isn't intersting to the rest part of * the compiler. */ @Config(allowMultiple = true) @Arguments("filename") public void setLoadConfig(ConfigurationValue cv, String filename) throws ConfigurationException { configFile = resolvePathStrict(filename, cv); } // // 'version' option from CommandLineConfiguration // /** * Dummy option. Just a trigger for version info. */ @Config public void setVersion(ConfigurationValue cv, boolean value) { } // // 'verbose' option from CommandLineConfiguration // private boolean verbose = false; public boolean isVerbose() { return verbose; } @Config(hidden = true) public void setVerbose(ConfigurationValue cfgval, boolean b) { verbose = b; } // // 'dump-ast' option from CommandLineConfiguration // private boolean dumpAst; public boolean isDumpAst() { return dumpAst; } @Config(hidden = true) public void setDumpAst(ConfigurationValue cfgval, boolean b) { dumpAst = b; } // // 'enable-inlining' option from CommandLineConfiguration // private boolean enableInlining = false; /** * @return true if function inlining has been enabled. */ public boolean isInliningEnabled() { return enableInlining; } /** * Enable or disable function inlining. * * @param cfgval The configuration value context. * @param b true to enable inlining, false otherwise. */ @Config(hidden = true) @Mapping({ "compiler", "inline" }) public void setEnableInlining(ConfigurationValue cfgval, boolean b) { enableInlining = b; } // // 'remove-dead-code' option from CommandLineConfiguration // private boolean removeDeadCode = false; /** * @return true if dead code removal has been enabled. */ public boolean getRemoveDeadCode() { return this.removeDeadCode; } /** * Enable or disable dead code removal. * @param cfgval the configuration value context. * @param b true to enable dead code removal, * false to disable. */ @Config(advanced = true) @Mapping({ "compiler", "remove-dead-code" }) public void setRemoveDeadCode(ConfigurationValue cfgval, boolean b) { this.removeDeadCode = b; } // // Validation methods from ToolsConfiguration // void validateDumpConfig(ConfigurationBuffer configurationBuffer) throws ConfigurationException { if (dumpConfigFile != null) { final String text = FileConfigurator.formatBuffer(configurationBuffer, "flex-config", LocalizationManager.get(), "flex2.configuration"); try { final Writer writer = new FileWriter(dumpConfigFile); IOUtils.write(text, writer); IOUtils.closeQuietly(writer); } catch (IOException e) { throw new ConfigurationException.IOError(dumpConfigFile); } } } /** * Collection of fatal and non-fatal configuration problems. */ private Collection<ICompilerProblem> configurationProblems = new ArrayList<ICompilerProblem>(); /** * Get the configuration problems. This should be called after the configuration * has been processed. * * @return a collection of fatal and non-fatal configuration problems. */ public Collection<ICompilerProblem> getConfigurationProblems() { return configurationProblems; } private boolean warnOnFlexOnlyOptionUsage = false; /** * @return True if warnings are generated when "Flex only" options are used, * false otherwise. */ public boolean getWarnOnFlexOnlyOptionUsage() { return warnOnFlexOnlyOptionUsage; } /** * Controls if the compiler warns when "Flex only" configuration options * are used in the compiler. * * @param value True to enable warnings, false to disable warnings. The * default is to not warn. */ public void setWarnOnFlexOnlyOptionUsage(boolean value) { this.warnOnFlexOnlyOptionUsage = value; } private void processDeprecatedAndRemovedOptions(ConfigurationBuffer configurationBuffer) { for (final String var : configurationBuffer.getVars()) { ConfigurationInfo info = configurationBuffer.getInfo(var); List<ConfigurationValue> values = configurationBuffer.getVar(var); if (values != null) { for (final ConfigurationValue cv : values) { if (info.isRemoved()) { //addRemovedConfigurationOptionProblem(cv); } else if (info.isDeprecated() && configurationBuffer.getVar(var) != null) { String replacement = info.getDeprecatedReplacement(); String since = info.getDeprecatedSince(); DeprecatedConfigurationOptionProblem problem = new DeprecatedConfigurationOptionProblem(var, replacement, since, cv.getSource(), cv.getLine()); configurationProblems.add(problem); } else if (warnOnFlexOnlyOptionUsage && info.isFlexOnly()) { FlexOnlyConfigurationOptionNotSupported problem = new FlexOnlyConfigurationOptionNotSupported( var, cv.getSource(), cv.getLine()); configurationProblems.add(problem); } } } } } /** * Add a RemovedConfigurationOptionProblem to the list of configuration * problems. * * @param cv */ private void addRemovedConfigurationOptionProblem(ConfigurationValue cv) { RemovedConfigurationOptionProblem problem = new RemovedConfigurationOptionProblem(cv.getVar(), cv.getSource(), cv.getLine()); configurationProblems.add(problem); } }