| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| package flex2.tools.oem.internal; |
| |
| import java.io.File; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.TreeMap; |
| import java.util.Map.Entry; |
| |
| import macromedia.asc.embedding.ConfigVar; |
| import macromedia.asc.util.ObjectList; |
| import flex2.compiler.common.CompilerConfiguration; |
| import flex2.compiler.common.FontsConfiguration; |
| import flex2.compiler.common.FramesConfiguration; |
| import flex2.compiler.common.NamespacesConfiguration; |
| import flex2.compiler.common.RuntimeSharedLibrarySettingsConfiguration; |
| import flex2.compiler.common.Configuration.RslPathInfo; |
| import flex2.compiler.common.FramesConfiguration.FrameInfo; |
| import flex2.compiler.config.ConfigurationBuffer; |
| import flex2.compiler.io.FileUtil; |
| import flex2.compiler.io.LocalFile; |
| import flex2.compiler.io.VirtualFile; |
| import flex2.tools.LicensesConfiguration; |
| import flex2.tools.ToolsConfiguration; |
| import flex2.tools.oem.Configuration; |
| |
| /** |
| * A ToolsConfiguration wrapper, which provides strongly typed |
| * configuration getters and setters, which internally storing them |
| * loosely typed for later processing. This is part of a complex |
| * scheme to only expose some of the compiler's configurability while |
| * supporting merging with configuration defaults. |
| * |
| * @version 2.0.1 |
| * @author Clement Wong |
| */ |
| public class OEMConfiguration implements Configuration, ConfigurationConstants, Cloneable |
| { |
| /** |
| * Created to enable picking out cross-domain args by type. |
| */ |
| class RslPathList extends ArrayList<String[]> |
| { |
| private static final long serialVersionUID = 0L; |
| } |
| |
| /** |
| * Ditto for conditional compilation |
| */ |
| class CompilerDefinitionList extends ArrayList<String> |
| { |
| private static final long serialVersionUID = 0L; |
| } |
| |
| /** |
| * Ditto for application-domains |
| */ |
| class ApplicationDomainsList extends ArrayList<String[]> |
| { |
| private static final long serialVersionUID = 0L; |
| } |
| |
| OEMConfiguration(ConfigurationBuffer cfgbuf, ToolsConfiguration configuration) |
| { |
| this.cfgbuf = cfgbuf; |
| this.configuration = configuration; |
| |
| args = new LinkedHashMap<String, Object>(); |
| more = new LinkedHashMap<String, Object>(); |
| linker_args = new LinkedHashMap<String, Object>(); |
| linker_more = new LinkedHashMap<String, Object>(); |
| newLinkerOptionsAfterCompile = new HashSet<String>(); |
| |
| if (configuration != null) |
| { |
| populateDefaults(configuration); |
| } |
| |
| defaults = args; |
| args = new LinkedHashMap<String, Object>(); |
| linker_args = new LinkedHashMap<String, Object>(); |
| newLinkerOptionsAfterCompile.clear(); |
| |
| keepLinkReport = false; |
| keepSizeReport = false; |
| keepConfigurationReport = false; |
| |
| tokens = new TreeMap<String, String>(); |
| } |
| |
| public ConfigurationBuffer cfgbuf; |
| public final ToolsConfiguration configuration; |
| |
| private Map<String, Object> args, defaults, more, linker_args, linker_more; |
| private String[] extras; |
| public final Set<String> newLinkerOptionsAfterCompile; |
| private boolean keepLinkReport, keepSizeReport, keepConfigurationReport; |
| |
| private Map<String, String> tokens; |
| |
| /** |
| * |
| * @param c |
| */ |
| void importDefaults(OEMConfiguration c) |
| { |
| args.putAll(c.defaults); |
| } |
| |
| /** |
| * |
| * @return |
| */ |
| public String[] getCompilerOptions() |
| { |
| return getOptions(args, more, true); |
| } |
| |
| /** |
| * |
| * @return |
| */ |
| public String[] getLinkerOptions() |
| { |
| return getOptions(linker_args, linker_more, false); |
| } |
| |
| /** |
| * |
| * @return |
| */ |
| |
| //TEST ME |
| private String[] getOptions(Map<String, Object> args, Map<String, Object> more, boolean processExtras) |
| { |
| ArrayList<String> buffer = new ArrayList<String>(); |
| |
| //TODO this can be optimized to use the entrySet |
| for (Iterator<String> i = tokens.keySet().iterator(); i.hasNext(); ) |
| { |
| String key = i.next(); |
| String value = tokens.get(key); |
| buffer.add("+" + key + "=" + value); |
| } |
| |
| for (Iterator<String> i = args.keySet().iterator(); i.hasNext(); ) |
| { |
| String key = (String) i.next(); |
| Object value = args.get(key); |
| |
| if (value instanceof Boolean) |
| { |
| buffer.add(key + "=" + value); |
| } |
| else if (value instanceof Number) |
| { |
| buffer.add(key); |
| buffer.add(value.toString()); |
| } |
| else if (COMPILER_CONTEXT_ROOT.equals(key) && value instanceof String) |
| { |
| buffer.add(key); |
| buffer.add((String)value); |
| } |
| else if (value instanceof String) |
| { |
| if (!"".equals(value)) |
| { |
| buffer.add(key); |
| buffer.add((String)value); |
| } |
| else |
| { |
| buffer.add(key + "="); |
| } |
| } |
| else if (value instanceof File) |
| { |
| String p = ((File) value).getPath(); |
| if (!"".equals(p)) |
| { |
| buffer.add(key); |
| buffer.add(p); |
| } |
| else |
| { |
| buffer.add(key + "="); |
| } |
| } |
| else if (value instanceof URL) |
| { |
| String u = ((URL) value).toExternalForm(); |
| if (!"".equals(u)) |
| { |
| buffer.add(key); |
| buffer.add(u); |
| } |
| else |
| { |
| buffer.add(key + "="); |
| } |
| } |
| else if (value instanceof java.util.Date) |
| { |
| buffer.add(key); |
| buffer.add(value.toString()); |
| } |
| else if (value instanceof Map) |
| { |
| Map m = (Map) value; |
| for (Iterator j = m.keySet().iterator(); j.hasNext(); ) |
| { |
| String k = (String) j.next(); |
| Object v = m.get(k); |
| |
| if (v instanceof String) |
| { |
| buffer.add(key); |
| buffer.add(k); |
| buffer.add((String)v); |
| } |
| else if (v instanceof File) |
| { |
| buffer.add(key); |
| buffer.add(k); |
| buffer.add(((File) v).getPath()); |
| } |
| else if (v instanceof String[]) |
| { |
| buffer.add(key); |
| buffer.add(k); |
| buffer.add(toCommaSeparatedString((String[]) v)); |
| } |
| else if (v instanceof List) |
| { |
| buffer.add(key); |
| buffer.add(k); |
| Iterator it = ((List)v).iterator(); |
| while (it.hasNext()) |
| { |
| Object next = it.next(); |
| if (next != null) |
| buffer.add(next.toString()); |
| } |
| } |
| else if (v != null) |
| { |
| assert false; |
| } |
| } |
| } |
| else if (value instanceof int[]) |
| { |
| int[] a = (int[]) value; |
| buffer.add(key); |
| buffer.add(String.valueOf(a[0])); |
| buffer.add(String.valueOf(a[1])); |
| } |
| else if (value instanceof String[]) |
| { |
| String[] a = merge((String[]) args.get(key), (String[]) more.get(key)); |
| int length = a == null ? 0 : a.length; |
| if (length > 0) |
| { |
| buffer.add(key); |
| } |
| else |
| { |
| buffer.add(key + "="); |
| } |
| for (int j = 0; j < length; j++) |
| { |
| if (a[j] != null) |
| { |
| buffer.add(a[j]); |
| } |
| } |
| } |
| else if (LOAD_CONFIG.equals(key) && value instanceof File[]) |
| { |
| File[] a = merge((File[]) args.get(key), (File[]) more.get(key)); |
| for (int j = 0, length = a == null ? 0 : a.length; j < length; j++) |
| { |
| if (a[j] != null) |
| { |
| buffer.add(key); |
| buffer.add(a[j].getPath()); |
| } |
| } |
| } |
| else if (value instanceof File[]) |
| { |
| File[] a = merge((File[]) args.get(key), (File[]) more.get(key)); |
| int length = a == null ? 0 : a.length; |
| if (length > 0) |
| { |
| buffer.add(key); |
| } |
| else |
| { |
| buffer.add(key + "="); |
| } |
| for (int j = 0; j < length; j++) |
| { |
| if (a[j] != null) |
| { |
| buffer.add(a[j].getPath()); |
| } |
| } |
| } |
| else if (value instanceof URL[]) |
| { |
| URL[] a = merge((URL[]) args.get(key), (URL[]) more.get(key)); |
| int length = a == null ? 0 : a.length; |
| if (length > 0) |
| { |
| buffer.add(key); |
| } |
| else |
| { |
| buffer.add(key + "="); |
| } |
| for (int j = 0; j < length; j++) |
| { |
| if (a[j] != null) |
| { |
| buffer.add(a[j].toExternalForm()); |
| } |
| } |
| } |
| else if (value instanceof RslPathList) |
| { |
| RslPathList valueList = (RslPathList)value; |
| for (Iterator<String[]> iter = valueList.iterator(); iter.hasNext();) |
| { |
| StringBuilder sb = new StringBuilder(RUNTIME_SHARED_LIBRARY_PATH); |
| sb.append("="); |
| String[] cdArgs = iter.next(); |
| sb.append(cdArgs[0]); |
| for (int j = 1; j < cdArgs.length; j++) |
| { |
| sb.append(","); |
| sb.append(cdArgs[j]); |
| } |
| buffer.add(sb.toString()); |
| } |
| } |
| else if (value instanceof CompilerDefinitionList) |
| { |
| final CompilerDefinitionList defs = (CompilerDefinitionList)value; |
| for (Iterator<String> iter = defs.iterator(); iter.hasNext();) |
| { |
| // String.valueOf will help turn null into "null" |
| String name = String.valueOf(iter.next()); |
| String val = String.valueOf(iter.next()); |
| |
| // handle empty-string values |
| |
| // technically, name should not ever be empty length (value can be), |
| // but we don't want to do error handling, CompilerConfiguration.cfgDefine() |
| // will do it for us later |
| if (name.length() == 0) |
| { |
| name = "\"\""; |
| } |
| |
| if (val.length() == 0) |
| { |
| val = "\"\""; |
| } |
| |
| /* note '+=': defines from all flex-config.xmls will be collected (just '=' would |
| * always ignore all but the most recent definitions), hopefully in a meaningful |
| * order (flex-config, user-config, commandline) since we now allow re-definitions. |
| */ |
| buffer.add(COMPILER_DEFINE + "+=" + name + "," + val); |
| } |
| } |
| else if (value instanceof ApplicationDomainsList) |
| { |
| ApplicationDomainsList valueList = (ApplicationDomainsList)value; |
| |
| if (valueList.size() == 0) |
| buffer.add(key + "="); // we should only ever come here for the first and only key. |
| else |
| buffer.add(key); |
| |
| for (String[] adArgs : valueList) |
| { |
| for (int j = 0; j < adArgs.length; j++) |
| { |
| buffer.add(adArgs[j]); |
| } |
| } |
| } |
| else if (value != null) |
| { |
| assert false; |
| } |
| else |
| { |
| // System.err.println("unprocessed compiler options: " + key + "=" + value); |
| } |
| } |
| |
| for (Iterator<String> i = more.keySet().iterator(); i.hasNext(); ) |
| { |
| String key = (String) i.next(); |
| Object value = more.get(key); |
| |
| if (value instanceof String[]) |
| { |
| if (!args.containsKey(key)) |
| { |
| buffer.add(key + "+=" + toCommaSeparatedString((String[]) value)); |
| } |
| } |
| /* |
| else if (LOAD_CONFIG.equals(key) && value instanceof File[]) |
| { |
| if (!args.containsKey(key)) |
| { |
| File[] a = merge(null, (File[]) more.get(key)); |
| for (int j = 0, length = a == null ? 0 : a.length; j < length; j++) |
| { |
| if (a[j] != null) |
| { |
| buffer.add(key); |
| buffer.add(a[j].getPath()); |
| } |
| } |
| } |
| } |
| */ |
| else if (value instanceof File[]) |
| { |
| if (!args.containsKey(key)) |
| { |
| buffer.add(key + "+=" + toCommaSeparatedString((File[]) value)); |
| } |
| } |
| else if (value instanceof URL[]) |
| { |
| if (!args.containsKey(key)) |
| { |
| buffer.add(key + "+=" + toCommaSeparatedString((URL[]) value)); |
| } |
| } |
| else if (value instanceof Map) |
| { |
| Map m = (Map) value; |
| for (Iterator j = m.keySet().iterator(); j.hasNext(); ) |
| { |
| String k = (String) j.next(); |
| Object v = m.get(k); |
| |
| if (v instanceof List) |
| { |
| Iterator it = ((List)v).iterator(); |
| while (it.hasNext()) |
| { |
| Object next = it.next(); |
| if (next != null) |
| buffer.add(key + "+=" + k + "," + next.toString()); |
| } |
| } |
| else if (v != null) |
| { |
| assert false; |
| } |
| } |
| } |
| else if (value instanceof Map) |
| { |
| Map m = (Map) value; |
| for (Iterator j = m.keySet().iterator(); j.hasNext(); ) |
| { |
| String k = (String) j.next(); |
| Object v = m.get(k); |
| |
| if (v instanceof List) |
| { |
| Iterator it = ((List)v).iterator(); |
| while (it.hasNext()) |
| { |
| Object next = it.next(); |
| if (next != null) |
| buffer.add(key + "+=" + k + "," + next.toString()); |
| } |
| } |
| else if (v != null) |
| { |
| assert false; |
| } |
| } |
| } |
| else if (value != null) |
| { |
| assert false; |
| } |
| else |
| { |
| // System.err.println("unprocessed compiler options: " + key + "=" + value); |
| } |
| } |
| |
| for (int i = 0, length = extras == null ? 0 : extras.length; processExtras && i < length; i++) |
| { |
| if (extras[i] != null) |
| { |
| buffer.add(extras[i]); |
| } |
| } |
| |
| String[] options = new String[buffer.size()]; |
| buffer.toArray(options); |
| |
| return options; |
| } |
| |
| /** |
| * Enables accessibility in the application. |
| * This is equivalent to using <code>mxmlc/compc --compiler.accessible</code>.<p> |
| * By default, this is disabled. |
| * |
| * @param b boolean value |
| */ |
| public void enableAccessibility(boolean b) |
| { |
| args.put(COMPILER_ACCESSIBLE, b ? Boolean.TRUE : Boolean.FALSE); |
| linker_args.put(COMPILER_ACCESSIBLE, b ? Boolean.TRUE : Boolean.FALSE); |
| newLinkerOptionsAfterCompile.add(COMPILER_ACCESSIBLE); |
| } |
| |
| /** |
| * Sets the ActionScript file encoding. The compiler will use this encoding to read |
| * the ActionScript source files. |
| * This is equivalent to using <code>mxmlc/compc --compiler.actionscript-file-encoding</code>.<p> |
| * By default, the encoding is <code>UTF-8</code>. |
| * |
| * @param encoding charactere encoding, e.g. <code>UTF-8</code>, <code>Big5</code> |
| */ |
| public void setActionScriptFileEncoding(String encoding) |
| { |
| args.put(COMPILER_ACTIONSCRIPT_FILE_ENCODING, encoding); |
| } |
| |
| /** |
| * Allows some source path directories to be subdirectories of the other. |
| * This is equivalent to using <code>mxmlc/compc --compiler.allow-source-path-overlap</code>.<p> |
| * By default, this is disabled.<p> |
| * |
| * In some J2EE settings, directory overlapping should be allowed. For example, |
| * |
| * <pre> |
| * wwwroot/MyAppRoot |
| * wwwroot/WEB-INF/flex/source_path1 |
| * </pre> |
| * |
| * @param b boolean value |
| */ |
| public void allowSourcePathOverlap(boolean b) |
| { |
| args.put(COMPILER_ALLOW_SOURCE_PATH_OVERLAP, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Uses the ActionScript 3 class based object model for greater performance and better error reporting. |
| * In the class based object model, most built-in functions are implemented as fixed methods of classes. |
| * This is equivalent to using <code>mxmlc/compc --compiler.as3</code>.<p> |
| * By default, this is enabled. |
| * |
| * @param b boolean value |
| */ |
| public void useActionScript3(boolean b) |
| { |
| args.put(COMPILER_AS3, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Sets the context root path so that the compiler can replace <code>{context.root}</code> tokens for |
| * service channel endpoints. This is equivalent to using the <code>compiler.context-root</code> option |
| * for the mxmlc or compc compilers. |
| * |
| * <p> |
| * By default, this value is undefined. |
| * |
| * @param path An instance of String. |
| */ |
| public void setContextRoot(String path) |
| { |
| args.put(COMPILER_CONTEXT_ROOT, path); |
| } |
| |
| /** |
| * Enables debugging in the application. |
| * This is equivalent to using <code>mxmlc/compc --compiler.debug</code> and <code>--debug-password</code>.<p> |
| * By default, debug is <code>false</code> and the debug password is "". |
| * |
| * @param b boolean value |
| * @param debugPassword a password that is embedded in the application. |
| */ |
| public void enableDebugging(boolean b, String debugPassword) |
| { |
| args.put(COMPILER_DEBUG, b ? Boolean.TRUE : Boolean.FALSE); |
| args.put(DEBUG_PASSWORD, debugPassword); |
| |
| linker_args.put(COMPILER_DEBUG, b ? Boolean.TRUE : Boolean.FALSE); |
| linker_args.put(DEBUG_PASSWORD, debugPassword); |
| |
| newLinkerOptionsAfterCompile.add(COMPILER_DEBUG); |
| newLinkerOptionsAfterCompile.add(DEBUG_PASSWORD); |
| } |
| |
| /** |
| * Sets the location of the default CSS file. |
| * This is equivalent to using <code>mxmlc/compc --compiler.defaults-css-url</code>. |
| * |
| * @param url an instance of <code>java.io.File</code>. |
| */ |
| public void setDefaultCSS(File url) |
| { |
| args.put(COMPILER_DEFAULTS_CSS_URL, url); |
| } |
| |
| /** |
| * Uses the ECMAScript edition 3 prototype based object model to allow dynamic overriding |
| * of prototype properties. In the prototype based object model built-in functions are |
| * implemented as dynamic properties of prototype objects. |
| * This is equivalent to using <code>mxmlc/compc --compiler.es</code>.<p> |
| * By default, this is disabled. |
| * |
| * @param b boolean value |
| */ |
| public void useECMAScript(boolean b) |
| { |
| args.put(COMPILER_ES, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Sets the list of SWC files or directories to compile against but to omit from linking. |
| * This is equivalent to using <code>mxmlc/compc --compiler.external-library-path</code>. |
| * |
| * @param paths <code>File.isDirectory()</code> should return <code>true</code> or <code>File</code> instances should represent SWC files. |
| */ |
| public void setExternalLibraryPath(File[] paths) |
| { |
| args.put(COMPILER_EXTERNAL_LIBRARY_PATH, paths); |
| more.remove(COMPILER_EXTERNAL_LIBRARY_PATH); |
| } |
| |
| /** |
| * Adds to the existing list of SWC files. |
| * |
| * @see #setExternalLibraryPath(File[]) |
| * @param paths <code>File.isDirectory()</code> should return <code>true</code> or <code>File</code> instances should represent SWC files. |
| */ |
| public void addExternalLibraryPath(File[] paths) |
| { |
| addFiles(COMPILER_EXTERNAL_LIBRARY_PATH, paths); |
| } |
| |
| /** |
| * Sets a range to restrict the number of font glyphs embedded into the application. |
| * This is equivalent to using <code>mxmlc/compc --compiler.fonts.languages.language-range</code>. |
| * For example, |
| * |
| * <pre> |
| * setFontLanguageRange("englishRange", "U+0020-U+007E"); |
| * </pre> |
| * |
| * @param language language name |
| * @param range a range of glyphs |
| */ |
| public void setFontLanguageRange(String language, String range) |
| { |
| if (!args.containsKey(COMPILER_FONTS_LANGUAGES_LANGUAGE_RANGE)) |
| { |
| args.put(COMPILER_FONTS_LANGUAGES_LANGUAGE_RANGE, new TreeMap<String, String>()); |
| } |
| |
| // I am ONLY doing this because we set it three lines above |
| @SuppressWarnings("unchecked") |
| Map<String, String> map = (Map<String, String>) args.get(COMPILER_FONTS_LANGUAGES_LANGUAGE_RANGE); |
| map.put(language, range); |
| } |
| |
| /** |
| * Sets the location of the local font snapshot file. The file contains system font data produced by |
| * <code>flex2.tools.FontSnapshot</code>. This is equivalent to using <code>mxmlc/compc --compiler.fonts.local-fonts-snapshot</code>. |
| * |
| * @param file file |
| */ |
| public void setLocalFontSnapshot(File file) |
| { |
| args.put(COMPILER_FONTS_LOCAL_FONTS_SNAPSHOT, file); |
| } |
| |
| /** |
| * Sets the local font file paths to be searched by the compiler. |
| * This is equivalent to using <code>mxmlc/compc --compiler.fonts.local-font-paths</code>. |
| * |
| * @param paths an array of file paths. |
| */ |
| public void setLocalFontPaths(String[] paths) |
| { |
| args.put(COMPILER_FONTS_LOCAL_FONT_PATHS, paths); |
| more.remove(COMPILER_FONTS_LOCAL_FONT_PATHS); |
| } |
| |
| /** |
| * Adds local font paths to the existing local font path list. |
| * |
| * @see #setLocalFontPaths(String[]) |
| * @param paths an array of local font file paths. |
| */ |
| public void addLocalFontPaths(String[] paths) |
| { |
| addStrings(COMPILER_FONTS_LOCAL_FONT_PATHS, paths); |
| } |
| |
| /** |
| * Sets the font managers used by the compiler. |
| * This is equivalent to using <code>mxmlc/compc --compiler.fonts.managers</code>. |
| * |
| * @param classNames an array of Java class names. |
| */ |
| public void setFontManagers(String[] classNames) |
| { |
| args.put(COMPILER_FONTS_MANAGERS, classNames); |
| more.remove(COMPILER_FONTS_MANAGERS); |
| } |
| |
| /** |
| * Adds font managers to the existing font manager list. |
| * |
| * @see #setFontManagers(String[]) |
| * @param classNames an array of Java class names. |
| */ |
| public void addFontManagers(String[] classNames) |
| { |
| addStrings(COMPILER_FONTS_MANAGERS, classNames); |
| } |
| |
| /** |
| * Sets the maximum number of embedded font faces that can be cached. |
| * This is equivalent to using <code>mxmlc/compc --compiler.fonts.max-cached-fonts</code>. |
| * By default, it's 20. |
| * |
| * @param size an integer |
| */ |
| public void setMaximumCachedFonts(int size) |
| { |
| if (size > 0) |
| { |
| args.put(COMPILER_FONTS_MAX_CACHED_FONTS, new Integer(size)); |
| } |
| } |
| |
| /** |
| * Sets the maximum number of character glyph outlines to cache for each font face. |
| * This is equivalent to using <code>mxmlc/compc --compiler.fonts.max-glyphs-per-face</code>. |
| * By default, it's 1000. |
| * |
| * @param size an integer |
| */ |
| public void setMaximumGlyphsPerFace(int size) |
| { |
| if (size > 0) |
| { |
| args.put(COMPILER_FONTS_MAX_GLYPHS_PER_FACE, new Integer(size)); |
| } |
| } |
| |
| /** |
| * Sets the compiler when it runs on a server without a display. |
| * This is equivalent to using <code>mxmlc/compc --compiler.headless-server</code>. |
| * |
| * @param b boolean value |
| */ |
| public void useHeadlessServer(boolean b) |
| { |
| args.put(COMPILER_HEADLESS_SERVER, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Sets the AS3 metadata the compiler should keep in the SWF. |
| * This is equivalent to using <code>mxmlc --compiler.keep-as3-metadata</code>. |
| * |
| * <p> |
| * The default value is <code>{Bindable, Managed, ChangeEvent, NonCommittingChangeEvent, Transient}</code>. |
| * |
| * @param md an array of AS3 metadata names |
| */ |
| public void setActionScriptMetadata(String[] md) |
| { |
| args.put(COMPILER_KEEP_AS3_METADATA, md); |
| more.remove(COMPILER_KEEP_AS3_METADATA); |
| |
| linker_args.put(COMPILER_KEEP_AS3_METADATA, md); |
| linker_more.remove(COMPILER_KEEP_AS3_METADATA); |
| |
| newLinkerOptionsAfterCompile.add(COMPILER_KEEP_AS3_METADATA); |
| } |
| |
| /** |
| * Adds the list of AS3 metadata names to the existing list of AS3 metadata the compiler should |
| * keep in the SWF. |
| * |
| * @param md an array of AS3 metadata names |
| */ |
| public void addActionScriptMetadata(String[] md) |
| { |
| addStrings(COMPILER_KEEP_AS3_METADATA, md); |
| addStrings(linker_more, COMPILER_KEEP_AS3_METADATA, md); |
| |
| newLinkerOptionsAfterCompile.add(COMPILER_KEEP_AS3_METADATA); |
| } |
| |
| /** |
| * Disables the pruning of unused type selectors. |
| * This is equivalent to using <code>mxmlc/compc --compiler.keep-all-type-selectors</code>. |
| * By default, it is set to <code>false</code>. |
| * |
| * @param b boolean value |
| */ |
| public void keepAllTypeSelectors(boolean b) |
| { |
| args.put(COMPILER_KEEP_ALL_TYPE_SELECTORS, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Saves temporary source files generated during MXML compilation. |
| * This is equivalent to using <code>mxmlc/compc --compiler.keep-generated-actionscript</code>. |
| * By default, it is set to <code>false</code>. |
| * |
| * @param b boolean value |
| */ |
| public void keepCompilerGeneratedActionScript(boolean b) |
| { |
| args.put(COMPILER_KEEP_GENERATED_ACTIONSCRIPT, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Instructs the linker to keep a report of the content that is included in the application. |
| * Callers may use <code>Report.writeLinkReport()</code> to retrieve the linker report. |
| * |
| * @param b boolean value |
| */ |
| public void keepLinkReport(boolean b) |
| { |
| keepLinkReport = b; |
| newLinkerOptionsAfterCompile.add(LINK_REPORT); |
| } |
| |
| public boolean keepLinkReport() |
| { |
| return keepLinkReport; |
| } |
| |
| /** |
| * Instructs the linker to keep a SWF size report. |
| * Callers may use <code>Report.writeSizeReport()</code> to retrieve the size report. |
| * |
| * @param b boolean value |
| */ |
| public void keepSizeReport(boolean b) |
| { |
| keepSizeReport = b; |
| newLinkerOptionsAfterCompile.add(SIZE_REPORT); |
| } |
| |
| public boolean keepSizeReport() |
| { |
| return keepSizeReport; |
| } |
| |
| /** |
| * Instructs the compiler to keep a report of the compiler configuration settings. |
| * Callers may use <code>Report.writeConfigurationReport()</code> to retrieve the configuration report. |
| * |
| * @param b boolean value |
| */ |
| public void keepConfigurationReport(boolean b) |
| { |
| keepConfigurationReport = b; |
| } |
| |
| public boolean keepConfigurationReport() |
| { |
| return keepConfigurationReport; |
| } |
| |
| |
| /** |
| * Includes a list of libraries (SWCs) to completely include in the application |
| * This is equivalent to using <code>mxmlc/compc --compiler.include-libraries</code>. |
| * |
| * @param libraries an array of <code>java.io.File</code> (<code>File.isDirectory()</code> should return <code>true</code> or instances must represent SWC files). |
| * @see #setIncludes(String[]) |
| * @see #setExterns(File[]) |
| * @see #setExterns(String[]) |
| * @see #setExternalLibraryPath(File[]) |
| */ |
| public void includeLibraries(File[] libraries) |
| { |
| args.put(COMPILER_INCLUDE_LIBRARIES, libraries); |
| } |
| |
| /** |
| * Sets a list of resource bundles to include in the swf. |
| * This is equivalent to using <code>mxmlc/compc --include-resource-bundle</code>. |
| * |
| * @param bundles an array of <code>java.lang.String</code> |
| */ |
| public void setIncludeResourceBundles(String[] bundles) |
| { |
| args.put(INCLUDE_RESOURCE_BUNDLES, bundles); |
| } |
| |
| /** |
| * Adds a list of resource bundles to the existing list. |
| * |
| * @see #setIncludeResourceBundles(String[]) |
| * @param bundles an array of <code>java.lang.String</code> |
| */ |
| public void addIncludeResourceBundles(String[] bundles) |
| { |
| addStrings(INCLUDE_RESOURCE_BUNDLES, bundles); |
| } |
| |
| /** |
| * Sets a list of SWC files or directories that contain SWC files. |
| * This is equivalent to using <code>mxmlc/compc --compiler.library-path</code>. |
| * |
| * @param paths an array of <code>File</code>. <code>File.isDirectory()</code> should return <code>true</code> or instances must represent SWC files. |
| */ |
| public void setLibraryPath(File[] paths) |
| { |
| args.put(COMPILER_LIBRARY_PATH, paths); |
| more.remove(COMPILER_LIBRARY_PATH); |
| } |
| |
| /** |
| * Adds a list of SWC files or directories to the default library path. |
| * |
| * @param paths an array of <code>File</code>. <code>File.isDirectory()</code> should return <code>true</code> or instances must represent SWC files. |
| * @see #setLibraryPath(File[]) |
| */ |
| public void addLibraryPath(File[] paths) |
| { |
| addFiles(COMPILER_LIBRARY_PATH, paths); |
| } |
| |
| /** |
| * Sets the locales that the compiler would use to replace <code>{locale}</code> tokens that appear in some configuration values. |
| * This is equivalent to using <code>mxmlc/compc --compiler.locale</code>. |
| * For example, |
| * |
| * <pre> |
| * addSourcePath(new File[] { "locale/{locale}" }); |
| * addLocale(new String[] { "en_US" }); |
| * </pre> |
| * |
| * The <code>locale/en_US</code> directory will be added to the source path. |
| * |
| * @param locale String |
| * |
| * @since 3.0 |
| */ |
| public void setLocale(String[] locales) |
| { |
| args.put(COMPILER_LOCALE, locales); |
| } |
| |
| /** |
| * Sets the locale that the compiler would use to replace <code>{locale}</code> tokens that appear in some configuration values. |
| * This is equivalent to using <code>mxmlc/compc --compiler.locale</code> to set a single locale. |
| * For example, |
| * |
| * <pre> |
| * addSourcePath(new File[] { "locale/{locale}" }); |
| * setLocale(Locale.US); |
| * </pre> |
| * |
| * The <code>locale/en_US</code> directory will be added to the source path. |
| * |
| * @param locale java.util.Locale |
| * |
| * @deprecated As of 3.0, use setLocale(String[]) |
| */ |
| public void setLocale(Locale locale) |
| { |
| setLocale(new String[] { locale.toString() }); |
| } |
| |
| /** |
| * Specifies a URI to associate with a manifest of components for use as |
| * MXML elements. This is equivalent to using: |
| * <code>mxmlc/compc --compiler.namespaces.namespace</code>. |
| * |
| * @param namespaceURI a namespace URI |
| * @param manifest a component manifest file (XML) |
| */ |
| public void setComponentManifest(String namespaceURI, File manifest) |
| { |
| List<File> manifests = new ArrayList<File>(2); |
| manifests.add(manifest); |
| setComponentManifests(namespaceURI, manifests); |
| } |
| |
| /** |
| * Specifies a URI to associate with a list of potentially several manifests |
| * which map MXML elements to component implementations. This is equivalent |
| * to using: <code>mxmlc/compc --compiler.namespaces.namespace</code>. |
| * |
| * @param namespaceURI a namespace URI |
| * @param manifests A List of component manifest files (XML) |
| */ |
| public void setComponentManifests(String namespaceURI, List<File> manifests) |
| { |
| if (!more.containsKey(COMPILER_NAMESPACES_NAMESPACE)) |
| { |
| more.put(COMPILER_NAMESPACES_NAMESPACE, new LinkedHashMap<String, List<File>>()); |
| } |
| |
| // I am ONLY doing this because we set it three lines above |
| @SuppressWarnings("unchecked") |
| Map<String, List<File>> map = (Map<String, List<File>>) more.get(COMPILER_NAMESPACES_NAMESPACE); |
| map.put(namespaceURI, manifests); |
| } |
| |
| /** |
| * Enables post-link optimization. This is equivalent to using <code>mxmlc/compc --compiler.optimize</code>. |
| * Application sizes are usually smaller with this option enabled. |
| * By default, it is set to <code>true</code>. |
| * |
| * @param b boolean value |
| */ |
| public void optimize(boolean b) |
| { |
| args.put(COMPILER_OPTIMIZE, b ? Boolean.TRUE : Boolean.FALSE); |
| linker_args.put(COMPILER_OPTIMIZE, b ? Boolean.TRUE : Boolean.FALSE); |
| newLinkerOptionsAfterCompile.add(COMPILER_OPTIMIZE); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void compress(boolean b) |
| { |
| args.put(COMPILER_COMPRESS, b ? Boolean.TRUE : Boolean.FALSE); |
| linker_args.put(COMPILER_COMPRESS, b ? Boolean.TRUE : Boolean.FALSE); |
| newLinkerOptionsAfterCompile.add(COMPILER_COMPRESS); |
| } |
| |
| /** |
| * Sets the location of the FDS service configuration file. |
| * This is equivalent to using <code>mxmlc/compc --compiler.services</code> |
| * @param file file |
| */ |
| public void setServiceConfiguration(File file) |
| { |
| args.put(COMPILER_SERVICES, file); |
| } |
| |
| /** |
| * Runs the ActionScript compiler in a mode that detects legal but potentially incorrect code. |
| * This is equivalent to using <code>mxmlc/compc --compiler.show-actionscript-warnings</code>. |
| * By default, it is set to <code>true</code>. |
| * |
| * @param b boolean value |
| * @see #checkActionScriptWarning(int, boolean) |
| */ |
| public void showActionScriptWarnings(boolean b) |
| { |
| args.put(COMPILER_SHOW_ACTIONSCRIPT_WARNINGS, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Toggles whether warnings generated from data binding code are displayed. |
| * This is equivalent to using <code>mxmlc/compc --compiler.show-binding-warnings</code>. |
| * By default, it is set to <code>true</code>. |
| * |
| * @param b boolean value |
| */ |
| public void showBindingWarnings(boolean b) |
| { |
| args.put(COMPILER_SHOW_BINDING_WARNINGS, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Toggles whether the use of deprecated APIs generates a warning. |
| * This is equivalent to using <code>mxmlc/compc --compiler.show-deprecation-warnings</code>. |
| * By default, it is set to <code>true</code>. |
| * |
| * @param b boolean value |
| */ |
| public void showDeprecationWarnings(boolean b) |
| { |
| args.put(COMPILER_SHOW_DEPRECATION_WARNINGS, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Toggles whether warnings are displayed when an embedded font name shadows |
| * a device font name. |
| * This is equivalent to using <code>mxmlc/compc --compiler.show-shadowed-device-font-warnings</code>. |
| * By default, it is set to <code>true</code>. |
| * |
| * @param b boolean value |
| */ |
| public void showShadowedDeviceFontWarnings(boolean b) |
| { |
| args.put(COMPILER_SHOW_SHADOWED_DEVICE_FONT_WARNINGS, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Toggles whether warnings generated from unused type selectors are displayed. |
| * This is equivalent to using <code>mxmlc/compc --compiler.show-unused-type-selector-warnings</code>. |
| * By default, it is set to <code>true</code>. |
| * |
| * @param b boolean value |
| */ |
| public void showUnusedTypeSelectorWarnings(boolean b) |
| { |
| args.put(COMPILER_SHOW_UNUSED_TYPE_SELECTOR_WARNINGS, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Sets a list of path elements that form the roots of ActionScript class hierarchies. |
| * This is equivalent to using <code>mxmlc/compc --compiler.source-path</code>. |
| * |
| * @param paths an array of <code>java.io.File</code> (<code>File.isDirectory()</code> must return <code>true</code>). |
| */ |
| public void setSourcePath(File[] paths) |
| { |
| args.put(COMPILER_SOURCE_PATH, paths); |
| more.remove(COMPILER_SOURCE_PATH); |
| } |
| |
| /** |
| * Adds a list of path elements to the existing source path list. |
| * |
| * @param paths an array of <code>java.io.File</code> (<code>File.isDirectory()</code> must return <code>true</code>). |
| * @see #setSourcePath(File[]) |
| */ |
| public void addSourcePath(File[] paths) |
| { |
| addFiles(COMPILER_SOURCE_PATH, paths); |
| } |
| |
| /** |
| * Runs the ActionScript compiler in strict error checking mode. |
| * This is equivalent to using <code>mxmlc/compc --compiler.strict</code>. |
| * By default, it is set to <code>true</code>. |
| * |
| * @param b boolean value |
| */ |
| public void enableStrictChecking(boolean b) |
| { |
| args.put(COMPILER_STRICT, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Sets a list of CSS or SWC files to apply as a theme. |
| * This is equivalent to using <code>mxmlc/compc --compiler.theme</code>. |
| * |
| * @param files an array of <code>java.io.File</code> |
| */ |
| public void setTheme(File[] files) |
| { |
| args.put(COMPILER_THEME, files); |
| more.remove(COMPILER_THEME); |
| } |
| |
| /** |
| * Adds a list of CSS or SWC files to the existing list of theme files. |
| * |
| * @param files an array of <code>java.io.File</code> |
| * @see #setTheme(File[]) |
| */ |
| public void addTheme(File[] files) |
| { |
| addFiles(COMPILER_THEME, files); |
| } |
| |
| /** |
| * Determines whether resources bundles are included in the application. |
| * This is equivalent to using <code>mxmlc/compc --compiler.use-resource-bundle-metadata</code>. |
| * By default, it is set to <code>true</code>. |
| * |
| * @param b boolean value |
| */ |
| public void useResourceBundleMetaData(boolean b) |
| { |
| args.put(COMPILER_USE_RESOURCE_BUNDLE_METADATA, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Generates bytecodes that include line numbers. When a run-time error occurs, |
| * the stacktrace shows these line numbers. Enabling this option generates larger SWF files. |
| * This is equivalent to using <code>mxmlc/compc --compiler.verbose-stacktraces</code>. |
| * By default, it is set to <code>false</code>. |
| * |
| * @param b boolean value |
| */ |
| public void enableVerboseStacktraces(boolean b) |
| { |
| args.put(COMPILER_VERBOSE_STACKTRACES, b ? Boolean.TRUE : Boolean.FALSE); |
| linker_args.put(COMPILER_VERBOSE_STACKTRACES, b ? Boolean.TRUE : Boolean.FALSE); |
| newLinkerOptionsAfterCompile.add(COMPILER_VERBOSE_STACKTRACES); |
| } |
| |
| /** |
| * Enables FlashType for embedded fonts, which provides greater clarity for small fonts. |
| * This is equilvalent to using <code>mxmlc/compc --compiler.fonts.flash-type</code>. |
| * By default, it is set to <code>true</code>. |
| * |
| * @param b boolean value |
| */ |
| public void enableFlashType(boolean b) |
| { |
| args.put(COMPILER_FONTS_FLASH_TYPE, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Enables advanced anti-aliasing for embedded fonts, which provides greater clarity for small fonts. |
| * This is equilvalent to using <code>mxmlc/compc --compiler.fonts.advanced-anti-aliasing</code>. |
| * By default, it is set to <code>false</code>. |
| * |
| * @param b boolean value |
| */ |
| public void enableAdvancedAntiAliasing(boolean b) |
| { |
| args.put(COMPILER_FONTS_ADVANCED_ANTI_ALIASING, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Enables the removal of RSLs associated with libraries |
| * that are not used by an application. |
| * This is equivalent to using the |
| * <code>remove-unused-rsls</code> option of the mxmlc compiler. |
| * |
| * <p> |
| * The default value is <code>false</code>. |
| * |
| * @param b Boolean value that enables or disables the removal. |
| * |
| * @since 4.5 |
| */ |
| public void removeUnusedRuntimeSharedLibraryPaths(boolean b) |
| { |
| args.put(REMOVE_UNUSED_RSLS, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| /** |
| * Enables checking of ActionScript warnings. They are: |
| * |
| * <pre> |
| * --compiler.warn-array-tostring-changes |
| * --compiler.warn-assignment-within-conditional |
| * --compiler.warn-bad-array-cast |
| * --compiler.warn-bad-bool-assignment |
| * --compiler.warn-bad-date-cast |
| * --compiler.warn-bad-es3-type-method |
| * --compiler.warn-bad-es3-type-prop |
| * --compiler.warn-bad-nan-comparison |
| * --compiler.warn-bad-null-assignment |
| * --compiler.warn-bad-null-comparison |
| * --compiler.warn-bad-undefined-comparison |
| * --compiler.warn-boolean-constructor-with-no-args |
| * --compiler.warn-changes-in-resolve |
| * --compiler.warn-class-is-sealed |
| * --compiler.warn-const-not-initialized |
| * --compiler.warn-constructor-returns-value |
| * --compiler.warn-deprecated-event-handler-error |
| * --compiler.warn-deprecated-function-error |
| * --compiler.warn-deprecated-property-error |
| * --compiler.warn-duplicate-argument-names |
| * --compiler.warn-duplicate-variable-def |
| * --compiler.warn-for-var-in-changes |
| * --compiler.warn-import-hides-class |
| * --compiler.warn-instance-of-changes |
| * --compiler.warn-internal-error |
| * --compiler.warn-level-not-supported |
| * --compiler.warn-missing-namespace-decl |
| * --compiler.warn-negative-uint-literal |
| * --compiler.warn-no-constructor |
| * --compiler.warn-no-explicit-super-call-in-constructor |
| * --compiler.warn-no-type-decl |
| * --compiler.warn-number-from-string-changes |
| * --compiler.warn-scoping-change-in-this |
| * --compiler.warn-slow-text-field-addition |
| * --compiler.warn-unlikely-function-value |
| * --compiler.warn-xml-class-has-changed |
| * </pre> |
| * |
| * @param warningCode warning code |
| * @param b boolean value |
| * @see #WARN_ARRAY_TOSTRING_CHANGES |
| * @see #WARN_ASSIGNMENT_WITHIN_CONDITIONAL |
| * @see #WARN_BAD_ARRAY_CAST |
| * @see #WARN_BAD_BOOLEAN_ASSIGNMENT |
| * @see #WARN_BAD_DATE_CAST |
| * @see #WARN_BAD_ES3_TYPE_METHOD |
| * @see #WARN_BAD_ES3_TYPE_PROP |
| * @see #WARN_BAD_NAN_COMPARISON |
| * @see #WARN_BAD_NULL_ASSIGNMENT |
| * @see #WARN_BAD_NULL_COMPARISON |
| * @see #WARN_BAD_UNDEFINED_COMPARISON |
| * @see #WARN_BOOLEAN_CONSTRUCTOR_WITH_NO_ARGS |
| * @see #WARN_CHANGES_IN_RESOLVE |
| * @see #WARN_CLASS_IS_SEALED |
| * @see #WARN_CONST_NOT_INITIALIZED |
| * @see #WARN_CONSTRUCTOR_RETURNS_VALUE |
| * @see #WARN_DEPRECATED_EVENT_HANDLER_ERROR |
| * @see #WARN_DEPRECATED_FUNCTION_ERROR |
| * @see #WARN_DEPRECATED_PROPERTY_ERROR |
| * @see #WARN_DUPLICATE_ARGUMENT_NAMES |
| * @see #WARN_DUPLICATE_VARIABLE_DEF |
| * @see #WARN_FOR_VAR_IN_CHANGES |
| * @see #WARN_IMPORT_HIDES_CLASS |
| * @see #WARN_INSTANCEOF_CHANGES |
| * @see #WARN_INTERNAL_ERROR |
| * @see #WARN_LEVEL_NOT_SUPPORTED |
| * @see #WARN_MISSING_NAMESPACE_DECL |
| * @see #WARN_NEGATIVE_UINT_LITERAL |
| * @see #WARN_NO_CONSTRUCTOR |
| * @see #WARN_NO_EXPLICIT_SUPER_CALL_IN_CONSTRUCTOR |
| * @see #WARN_NO_TYPE_DECL |
| * @see #WARN_NUMBER_FROM_STRING_CHANGES |
| * @see #WARN_SCOPING_CHANGE_IN_THIS |
| * @see #WARN_SLOW_TEXTFIELD_ADDITION |
| * @see #WARN_UNLIKELY_FUNCTION_VALUE |
| * @see #WARN_XML_CLASS_HAS_CHANGED |
| */ |
| public void checkActionScriptWarning(int warningCode, boolean b) |
| { |
| String key = null; |
| |
| switch (warningCode) |
| { |
| case WARN_ARRAY_TOSTRING_CHANGES: |
| key = COMPILER_WARN_ARRAY_TOSTRING_CHANGES; |
| break; |
| case WARN_ASSIGNMENT_WITHIN_CONDITIONAL: |
| key = COMPILER_WARN_ASSIGNMENT_WITHIN_CONDITIONAL; |
| break; |
| case WARN_BAD_ARRAY_CAST: |
| key = COMPILER_WARN_BAD_ARRAY_CAST; |
| break; |
| case WARN_BAD_BOOLEAN_ASSIGNMENT: |
| key = COMPILER_WARN_BAD_BOOL_ASSIGNMENT; |
| break; |
| case WARN_BAD_DATE_CAST: |
| key = COMPILER_WARN_BAD_DATE_CAST; |
| break; |
| case WARN_BAD_ES3_TYPE_METHOD: |
| key = COMPILER_WARN_BAD_ES3_TYPE_METHOD; |
| break; |
| case WARN_BAD_ES3_TYPE_PROP: |
| key = COMPILER_WARN_BAD_ES3_TYPE_PROP; |
| break; |
| case WARN_BAD_NAN_COMPARISON: |
| key = COMPILER_WARN_BAD_NAN_COMPARISON; |
| break; |
| case WARN_BAD_NULL_ASSIGNMENT: |
| key = COMPILER_WARN_BAD_NULL_ASSIGNMENT; |
| break; |
| case WARN_BAD_NULL_COMPARISON: |
| key = COMPILER_WARN_BAD_NULL_COMPARISON; |
| break; |
| case WARN_BAD_UNDEFINED_COMPARISON: |
| key = COMPILER_WARN_BAD_UNDEFINED_COMPARISON; |
| break; |
| case WARN_BOOLEAN_CONSTRUCTOR_WITH_NO_ARGS: |
| key = COMPILER_WARN_BOOLEAN_CONSTRUCTOR_WITH_NO_ARGS; |
| break; |
| case WARN_CHANGES_IN_RESOLVE: |
| key = COMPILER_WARN_CHANGES_IN_RESOLVE; |
| break; |
| case WARN_CLASS_IS_SEALED: |
| key = COMPILER_WARN_CLASS_IS_SEALED; |
| break; |
| case WARN_CONST_NOT_INITIALIZED: |
| key = COMPILER_WARN_CONST_NOT_INITIALIZED; |
| break; |
| case WARN_CONSTRUCTOR_RETURNS_VALUE: |
| key = COMPILER_WARN_CONSTRUCTOR_RETURNS_VALUE; |
| break; |
| case WARN_DEPRECATED_EVENT_HANDLER_ERROR: |
| key = COMPILER_WARN_DEPRECATED_EVENT_HANDLER_ERROR; |
| break; |
| case WARN_DEPRECATED_FUNCTION_ERROR: |
| key = COMPILER_WARN_DEPRECATED_FUNCTION_ERROR; |
| break; |
| case WARN_DEPRECATED_PROPERTY_ERROR: |
| key = COMPILER_WARN_DEPRECATED_PROPERTY_ERROR; |
| break; |
| case WARN_DUPLICATE_ARGUMENT_NAMES: |
| key = COMPILER_WARN_DUPLICATE_ARGUMENT_NAMES; |
| break; |
| case WARN_DUPLICATE_VARIABLE_DEF: |
| key = COMPILER_WARN_DUPLICATE_VARIABLE_DEF; |
| break; |
| case WARN_FOR_VAR_IN_CHANGES: |
| key = COMPILER_WARN_FOR_VAR_IN_CHANGES; |
| break; |
| case WARN_IMPORT_HIDES_CLASS: |
| key = COMPILER_WARN_IMPORT_HIDES_CLASS; |
| break; |
| case WARN_INSTANCEOF_CHANGES: |
| key = COMPILER_WARN_INSTANCE_OF_CHANGES; |
| break; |
| case WARN_INTERNAL_ERROR: |
| key = COMPILER_WARN_INTERNAL_ERROR; |
| break; |
| case WARN_LEVEL_NOT_SUPPORTED: |
| key = COMPILER_WARN_LEVEL_NOT_SUPPORTED; |
| break; |
| case WARN_MISSING_NAMESPACE_DECL: |
| key = COMPILER_WARN_MISSING_NAMESPACE_DECL; |
| break; |
| case WARN_NEGATIVE_UINT_LITERAL: |
| key = COMPILER_WARN_NEGATIVE_UINT_LITERAL; |
| break; |
| case WARN_NO_CONSTRUCTOR: |
| key = COMPILER_WARN_NO_CONSTRUCTOR; |
| break; |
| case WARN_NO_EXPLICIT_SUPER_CALL_IN_CONSTRUCTOR: |
| key = COMPILER_WARN_NO_EXPLICIT_SUPER_CALL_IN_CONSTRUCTOR; |
| break; |
| case WARN_NO_TYPE_DECL: |
| key = COMPILER_WARN_NO_TYPE_DECL; |
| break; |
| case WARN_NUMBER_FROM_STRING_CHANGES: |
| key = COMPILER_WARN_NUMBER_FROM_STRING_CHANGES; |
| break; |
| case WARN_SCOPING_CHANGE_IN_THIS: |
| key = COMPILER_WARN_SCOPING_CHANGE_IN_THIS; |
| break; |
| case WARN_SLOW_TEXTFIELD_ADDITION: |
| key = COMPILER_WARN_SLOW_TEXT_FIELD_ADDITION; |
| break; |
| case WARN_UNLIKELY_FUNCTION_VALUE: |
| key = COMPILER_WARN_UNLIKELY_FUNCTION_VALUE; |
| break; |
| case WARN_XML_CLASS_HAS_CHANGED: |
| key = COMPILER_WARN_XML_CLASS_HAS_CHANGED; |
| break; |
| } |
| |
| if (key != null) |
| { |
| args.put(key, b ? Boolean.TRUE : Boolean.FALSE); |
| } |
| } |
| |
| /** |
| * Sets the default background color (may be overridden by the application code). |
| * This is equivalent to using <code>mxmlc/compc --default-background-color</code>. |
| * The default value is <code>0x869CA7</code>. |
| * |
| * @param color RGB value |
| */ |
| public void setDefaultBackgroundColor(int color) |
| { |
| args.put(DEFAULT_BACKGROUND_COLOR, new Integer(color)); |
| linker_args.put(DEFAULT_BACKGROUND_COLOR, new Integer(color)); |
| newLinkerOptionsAfterCompile.add(DEFAULT_BACKGROUND_COLOR); |
| } |
| |
| /** |
| * Sets the default frame rate to be used in the application. |
| * This is equivalent to using <code>mxmlc/compc --default-frame-rate</code>. |
| * The default value is <code>24</code>. |
| * |
| * @param rate frames per second |
| */ |
| public void setDefaultFrameRate(int rate) |
| { |
| args.put(DEFAULT_FRAME_RATE, new Integer(rate)); |
| linker_args.put(DEFAULT_FRAME_RATE, new Integer(rate)); |
| newLinkerOptionsAfterCompile.add(DEFAULT_FRAME_RATE); |
| } |
| |
| /** |
| * Sets the default script execution limits (may be overridden by root attributes). |
| * This is equivalent to using <code>mxmlc/compc --default-script-limits</code>. |
| * The default maximum recursion depth is <code>1000</code>. |
| * The default maximum execution time is <code>60</code>. |
| * |
| * @param maxRecursionDepth recursion depth |
| * @param maxExecutionTime execution time in seconds. |
| */ |
| public void setDefaultScriptLimits(int maxRecursionDepth, int maxExecutionTime) |
| { |
| args.put(DEFAULT_SCRIPT_LIMITS, new int[] { maxRecursionDepth, maxExecutionTime }); |
| linker_args.put(DEFAULT_SCRIPT_LIMITS, new int[] { maxRecursionDepth, maxExecutionTime }); |
| newLinkerOptionsAfterCompile.add(DEFAULT_SCRIPT_LIMITS); |
| } |
| |
| /** |
| * Sets the default window size. |
| * This is equivalent to using <code>mxmlc/compc --default-size</code>. |
| * The default width is <code>500</code>. |
| * The default height is <code>375</code>. |
| * |
| * @param width width in pixels |
| * @param height height in pixels |
| */ |
| public void setDefaultSize(int width, int height) |
| { |
| args.put(DEFAULT_SIZE, new int[] { width, height }); |
| linker_args.put(DEFAULT_SIZE, new int[] { width, height }); |
| newLinkerOptionsAfterCompile.add(DEFAULT_SIZE); |
| } |
| |
| /** |
| * Sets a list of definitions to omit from linking when building an application. |
| * This is equivalent to using <code>mxmlc/compc --externs</code>. |
| * |
| * @param definitions An array of definitions (e.g. classes, functions, variables, namespaces, etc.) |
| */ |
| public void setExterns(String[] definitions) |
| { |
| args.put(EXTERNS, definitions); |
| more.remove(EXTERNS); |
| linker_args.put(EXTERNS, definitions); |
| linker_more.remove(EXTERNS); |
| newLinkerOptionsAfterCompile.add(EXTERNS); |
| } |
| |
| /** |
| * Adds a list of definitions to the existing list of definitions. |
| * |
| * @see #setExterns(File[]) |
| * @see #setExterns(String[]) |
| * @param definitions an array of definitions (e.g. classes, functions, variables, namespaces, etc.) |
| */ |
| public void addExterns(String[] definitions) |
| { |
| addStrings(EXTERNS, definitions); |
| addStrings(linker_more, EXTERNS, definitions); |
| newLinkerOptionsAfterCompile.add(EXTERNS); |
| } |
| |
| /** |
| * Loads a file containing configuration options. The file format follows the format of <code>flex-config.xml</code>. |
| * This is equivalent to using <code>mxmlc/compc --load-config</code>. |
| * |
| * @param file an instance of <code>java.io.File</code> |
| */ |
| public void setConfiguration(File file) |
| { |
| args.put(LOAD_CONFIG, new File[] {file}); |
| more.remove(LOAD_CONFIG); |
| } |
| |
| /** |
| * Adds a file to the existing list of configuration files. |
| * |
| * @see #setConfiguration(File) |
| * @param file a configuration file |
| */ |
| public void addConfiguration(File file) |
| { |
| addFiles(LOAD_CONFIG, new File[] {file}); |
| } |
| |
| /** |
| * Sets the configuration parameters. The input should be valid <code>mxmlc/compc</code> command-line arguments.<p> |
| * |
| * @param args <code>mxmlc/compc</code> command-line arguments |
| */ |
| public void setConfiguration(String[] args) |
| { |
| extras = args; |
| } |
| |
| /** |
| * Sets a list of definitions to omit from linking when building an application. |
| * This is equivalent to using <code>mxmlc/compc --load-externs</code>. |
| * This option is similar to <code>setExterns(String[])</code>. The following is an example of |
| * the file format: |
| * |
| * <pre> |
| * <script> |
| * <!-- use 'dep', 'pre' or 'dep' to specify a definition to be omitted from linking. --> |
| * <def id="mx.skins:ProgrammaticSkin"/> |
| * <pre id="mx.core:IFlexDisplayObject"/> |
| * <dep id="String"/> |
| * </script> |
| * </pre> |
| * |
| * @param files an array of <code>java.io.File</code> |
| */ |
| public void setExterns(File[] files) |
| { |
| args.put(LOAD_EXTERNS, files); |
| more.remove(LOAD_EXTERNS); |
| linker_args.put(LOAD_EXTERNS, files); |
| linker_more.remove(LOAD_EXTERNS); |
| newLinkerOptionsAfterCompile.add(LOAD_EXTERNS); |
| } |
| |
| /** |
| * Adds a list of files to the existing list of definitions to be omitted from linking. |
| * |
| * @see #setExterns(File[]) |
| * @see #setExterns(String[]) |
| * @param files an array of <code>java.io.File</code>. |
| */ |
| public void addExterns(File[] files) |
| { |
| addFiles(LOAD_EXTERNS, files); |
| addFiles(linker_more, LOAD_EXTERNS, files); |
| newLinkerOptionsAfterCompile.add(LOAD_EXTERNS); |
| } |
| |
| /** |
| * Sets a SWF frame label with a sequence of classnames that will be linked onto the frame. |
| * This is equivalent to using <code>mxmlc/compc --frames.frame</code>. |
| * |
| * @param label A string |
| * @param classNames an array of class names |
| */ |
| public void setFrameLabel(String label, String[] classNames) |
| { |
| if (!args.containsKey(FRAMES_FRAME)) |
| { |
| args.put(FRAMES_FRAME, new TreeMap<String, String[]>()); |
| } |
| |
| // I am ONLY doing this because we set it three lines above |
| @SuppressWarnings("unchecked") |
| Map<String, String[]> map = (Map<String, String[]>) args.get(FRAMES_FRAME); |
| map.put(label, classNames); |
| |
| if (!linker_args.containsKey(FRAMES_FRAME)) |
| { |
| linker_args.put(FRAMES_FRAME, new TreeMap()); |
| } |
| |
| // I am ONLY doing this because we set it three lines above |
| @SuppressWarnings("unchecked") |
| Map<String, String[]> map2 = (Map<String, String[]>) linker_args.get(FRAMES_FRAME); |
| map2.put(label, classNames); |
| |
| newLinkerOptionsAfterCompile.add(FRAMES_FRAME); |
| } |
| |
| /** |
| * Sets a list of definitions to always link in when building an application. |
| * This is equivalent to using <code>mxmlc/compc --includes</code>. |
| * |
| * @param definitions an array of definitions (e.g. classes, functions, variables, namespaces, etc). |
| */ |
| public void setIncludes(String[] definitions) |
| { |
| args.put(INCLUDES, definitions); |
| more.remove(INCLUDES); |
| linker_args.put(INCLUDES, definitions); |
| linker_more.remove(INCLUDES); |
| newLinkerOptionsAfterCompile.add(INCLUDES); |
| } |
| |
| /** |
| * Adds a list of definitions to the existing list of definitions. |
| * |
| * @see #setIncludes(String[]) |
| * @param definitions an array of definitions (e.g. classes, functions, variables, namespaces, etc.) |
| */ |
| public void addIncludes(String[] definitions) |
| { |
| addStrings(INCLUDES, definitions); |
| addStrings(linker_more, INCLUDES, definitions); |
| newLinkerOptionsAfterCompile.add(INCLUDES); |
| } |
| |
| /** |
| * Specifies the licenses that the compiler has to validate before compiling. |
| * This is equivalent to using <code>mxmlc/compc --licenses.license</code> |
| * |
| * @param productName a string |
| * @param serialNumber a serial number |
| */ |
| public void setLicense(String productName, String serialNumber) |
| { |
| if (!args.containsKey(LICENSES_LICENSE)) |
| { |
| args.put(LICENSES_LICENSE, new TreeMap<String, String>()); |
| } |
| |
| // I am ONLY doing this because we set it three lines above |
| @SuppressWarnings("unchecked") |
| Map<String, String> map = (Map<String, String>) args.get(LICENSES_LICENSE); |
| map.put(productName, serialNumber); |
| } |
| |
| /** |
| * Sets the metadata section of the application SWF. This option is equivalent to using the following <code>mxmlc/compc</code> |
| * command-line options: |
| * |
| * <pre> |
| * --metadata.contributor |
| * --metadata.creator |
| * --metadata.date |
| * --metadata.description |
| * --metadata.language |
| * --metadata.localized-description |
| * --metadata.localized-title |
| * --metadata.publisher |
| * --metadata.title |
| * </pre> |
| * |
| * The valid fields and types of value are specified below: |
| * |
| * <pre> |
| * CONTRIBUTOR java.lang.String |
| * CREATOR java.lang.String |
| * DATE java.util.Date |
| * DESCRIPTION java.util.Map<String, String> |
| * TITLE java.util.Map<String, String> |
| * LANGUAGE java.lang.String |
| * PUBLISHER java.lang.String |
| * </pre> |
| * |
| * For example, |
| * |
| * <pre> |
| * Map titles = new HashMap(); |
| * titles.put("EN", "Adobe Flex 2 Application"); |
| * |
| * Map descriptions = new HashMap(); |
| * descriptions.put("EN", "http://www.adobe.com/products/flex"); |
| * |
| * setSWFMetaData(Configuration.LANGUAGE, "EN"); |
| * setSWFMetaData(Configuration.TITLE, titles); |
| * setSWFMetaData(Configuration.DESCRIPTION, descriptions); |
| * </pre> |
| * |
| * @param field CONTRIBUTOR, CREATOR, DATE, DESCRIPTION, TITLE, LANGUAGE, PUBLISHER |
| * @param value String, Date or Map |
| * @see #CONTRIBUTOR |
| * @see #CREATOR |
| * @see #DATE |
| * @see #DESCRIPTION |
| * @see #TITLE |
| * @see #LANGUAGE |
| * @see #PUBLISHER |
| */ |
| public void setSWFMetaData(int field, Object value) |
| { |
| switch (field) |
| { |
| case CONTRIBUTOR: |
| args.put(METADATA_CONTRIBUTOR, value); |
| break; |
| case CREATOR: |
| args.put(METADATA_CREATOR, value); |
| break; |
| case DATE: |
| args.put(METADATA_DATE, value); |
| break; |
| case DESCRIPTION: |
| args.put(METADATA_LOCALIZED_DESCRIPTION, value); |
| break; |
| case TITLE: |
| args.put(METADATA_LOCALIZED_TITLE, value); |
| break; |
| case LANGUAGE: |
| args.put(METADATA_LANGUAGE, value); |
| break; |
| case PUBLISHER: |
| args.put(METADATA_PUBLISHER, value); |
| break; |
| } |
| |
| switch (field) |
| { |
| case CONTRIBUTOR: |
| linker_args.put(METADATA_CONTRIBUTOR, value); |
| break; |
| case CREATOR: |
| linker_args.put(METADATA_CREATOR, value); |
| break; |
| case DATE: |
| linker_args.put(METADATA_DATE, value); |
| break; |
| case DESCRIPTION: |
| linker_args.put(METADATA_LOCALIZED_DESCRIPTION, value); |
| break; |
| case TITLE: |
| linker_args.put(METADATA_LOCALIZED_TITLE, value); |
| break; |
| case LANGUAGE: |
| linker_args.put(METADATA_LANGUAGE, value); |
| break; |
| case PUBLISHER: |
| linker_args.put(METADATA_PUBLISHER, value); |
| break; |
| } |
| |
| newLinkerOptionsAfterCompile.add(METADATA_CONTRIBUTOR); |
| newLinkerOptionsAfterCompile.add(METADATA_CREATOR); |
| newLinkerOptionsAfterCompile.add(METADATA_DATE); |
| newLinkerOptionsAfterCompile.add(METADATA_LOCALIZED_DESCRIPTION); |
| newLinkerOptionsAfterCompile.add(METADATA_LOCALIZED_TITLE); |
| newLinkerOptionsAfterCompile.add(METADATA_LANGUAGE); |
| newLinkerOptionsAfterCompile.add(METADATA_PUBLISHER); |
| |
| args.remove(RAW_METADATA); |
| linker_args.remove(RAW_METADATA); |
| newLinkerOptionsAfterCompile.remove(RAW_METADATA); |
| } |
| |
| /** |
| * Sets the path to the Flash Player executable when building a projector. For example, |
| * |
| * <pre> |
| * setProjector(new File("C:/.../SAFlashPlayer.exe")) {} |
| * </pre> |
| * |
| * This is equivalent to using <code>mxmlc/compc --projector</code>. |
| * |
| * @param file the Flash Player executable. |
| */ |
| public void setProjector(File file) |
| { |
| args.put(PROJECTOR, file); |
| } |
| |
| /** |
| * Sets the metadata section of the application SWF. |
| * This is equivalent to using <code>mxmlc/compc --raw-metadata</code>. |
| * This option overrides everything set by the <code>setSWFMetaData</code> method. |
| * |
| * @see #setSWFMetaData(int, Object) |
| * @param xml a well-formed XML fragment |
| */ |
| public void setSWFMetaData(String xml) |
| { |
| args.put(RAW_METADATA, xml); |
| linker_args.put(RAW_METADATA, xml); |
| |
| args.remove(METADATA_CONTRIBUTOR); |
| args.remove(METADATA_CREATOR); |
| args.remove(METADATA_DATE); |
| args.remove(METADATA_LOCALIZED_DESCRIPTION); |
| args.remove(METADATA_LOCALIZED_TITLE); |
| args.remove(METADATA_LANGUAGE); |
| args.remove(METADATA_PUBLISHER); |
| |
| linker_args.remove(METADATA_CONTRIBUTOR); |
| linker_args.remove(METADATA_CREATOR); |
| linker_args.remove(METADATA_DATE); |
| linker_args.remove(METADATA_LOCALIZED_DESCRIPTION); |
| linker_args.remove(METADATA_LOCALIZED_TITLE); |
| linker_args.remove(METADATA_LANGUAGE); |
| linker_args.remove(METADATA_PUBLISHER); |
| |
| newLinkerOptionsAfterCompile.remove(METADATA_CONTRIBUTOR); |
| newLinkerOptionsAfterCompile.remove(METADATA_CREATOR); |
| newLinkerOptionsAfterCompile.remove(METADATA_DATE); |
| newLinkerOptionsAfterCompile.remove(METADATA_LOCALIZED_DESCRIPTION); |
| newLinkerOptionsAfterCompile.remove(METADATA_LOCALIZED_TITLE); |
| newLinkerOptionsAfterCompile.remove(METADATA_LANGUAGE); |
| newLinkerOptionsAfterCompile.remove(METADATA_PUBLISHER); |
| } |
| |
| /** |
| * Sets a list of runtime shared library URLs to be loaded before the application starts. |
| * This is equivalent to using <code>mxmlc/compc --runtime-shared-libraries</code>. |
| * |
| * @param libraries an array of <code>java.lang.String</code>. |
| */ |
| public void setRuntimeSharedLibraries(String[] libraries) |
| { |
| args.put(RUNTIME_SHARED_LIBRARIES, libraries); |
| more.remove(RUNTIME_SHARED_LIBRARIES); |
| } |
| |
| /** |
| * Adds a list of runtime shared library URLs to the existing list. |
| * |
| * @see #setRuntimeSharedLibraries(String[]) |
| * @param libraries an array of <code>java.lang.String</code> |
| */ |
| public void addRuntimeSharedLibraries(String[] libraries) |
| { |
| addStrings(RUNTIME_SHARED_LIBRARIES, libraries); |
| } |
| |
| /** |
| * Toggles whether the application SWF is flagged for access to network resources. |
| * This is equivalent to using <code>mxmlc/compc --use-network</code>. |
| * By default, it is set to <code>true</code>. |
| * |
| * @param b boolean value |
| */ |
| public void useNetwork(boolean b) |
| { |
| args.put(USE_NETWORK, b ? Boolean.TRUE : Boolean.FALSE); |
| linker_args.put(USE_NETWORK, b ? Boolean.TRUE : Boolean.FALSE); |
| newLinkerOptionsAfterCompile.add(USE_NETWORK); |
| } |
| |
| /** |
| * Defines a token. mxmlc and compc support token substitutions. For example, |
| * |
| * <pre> |
| * mxmlc +flexlib=path1 +foo=bar --var=${foo} |
| * </pre> |
| * |
| * <code>var=bar</code> after the substitution of <code>${foo}</code>. |
| * |
| * @param name |
| * @param value |
| */ |
| public void setToken(String name, String value) |
| { |
| tokens.put(name, value); |
| } |
| |
| /** |
| * |
| * @param key |
| * @param files |
| */ |
| private void addFiles(String key, File[] files) |
| { |
| addFiles(more, key, files); |
| } |
| |
| /** |
| * |
| * @param more |
| * @param key |
| * @param files |
| */ |
| private void addFiles(Map<String, Object> more, String key, File[] files) |
| { |
| File[] existing = null; |
| |
| if (more.containsKey(key)) |
| { |
| existing = (File[]) more.get(key); |
| } |
| |
| if (existing != null) |
| { |
| int length1 = existing.length, length2 = files == null ? 0 : files.length; |
| |
| File[] newPaths = new File[length1 + length2]; |
| System.arraycopy(existing, 0, newPaths, 0, length1); |
| System.arraycopy(files, 0, newPaths, length1, length2); |
| |
| files = newPaths; |
| } |
| |
| more.put(key, files); |
| } |
| |
| /** |
| * |
| * @param a1 |
| * @param a2 |
| * @return |
| */ |
| private String[] merge(String[] a1, String[] a2) |
| { |
| int l1 = a1 == null ? 0 : a1.length; |
| int l2 = a2 == null ? 0 : a2.length; |
| |
| String[] a3 = new String[l1 + l2]; |
| if (a1 != null) |
| { |
| System.arraycopy(a1, 0, a3, 0, l1); |
| } |
| if (a2 != null) |
| { |
| System.arraycopy(a2, 0, a3, l1, l2); |
| } |
| |
| return a3; |
| } |
| |
| /** |
| * |
| * @param a1 |
| * @param a2 |
| * @return |
| */ |
| private File[] merge(File[] a1, File[] a2) |
| { |
| int l1 = a1 == null ? 0 : a1.length; |
| int l2 = a2 == null ? 0 : a2.length; |
| |
| File[] a3 = new File[l1 + l2]; |
| if (a1 != null) |
| { |
| System.arraycopy(a1, 0, a3, 0, l1); |
| } |
| if (a2 != null) |
| { |
| System.arraycopy(a2, 0, a3, l1, l2); |
| } |
| |
| return a3; |
| } |
| |
| /** |
| * |
| * @param a1 |
| * @param a2 |
| * @return |
| */ |
| private URL[] merge(URL[] a1, URL[] a2) |
| { |
| int l1 = a1 == null ? 0 : a1.length; |
| int l2 = a2 == null ? 0 : a2.length; |
| |
| URL[] a3 = new URL[l1 + l2]; |
| if (a1 != null) |
| { |
| System.arraycopy(a1, 0, a3, 0, l1); |
| } |
| if (a2 != null) |
| { |
| System.arraycopy(a2, 0, a3, l1, l2); |
| } |
| |
| return a3; |
| } |
| |
| |
| /** |
| * |
| * @param key |
| * @param strings |
| */ |
| private void addStrings(String key, String[] strings) |
| { |
| addStrings(more, key, strings); |
| } |
| |
| /** |
| * |
| * @param more |
| * @param key |
| * @param strings |
| */ |
| private void addStrings(Map<String, Object> more, String key, String[] strings) |
| { |
| String[] existing = null; |
| |
| if (more.containsKey(key)) |
| { |
| existing = (String[]) more.get(key); |
| } |
| |
| if (existing != null) |
| { |
| int length1 = existing.length, length2 = strings == null ? 0 : strings.length; |
| |
| String[] newStrings = new String[length1 + length2]; |
| System.arraycopy(existing, 0, newStrings, 0, length1); |
| System.arraycopy(strings, 0, newStrings, length1, length2); |
| |
| strings = newStrings; |
| } |
| |
| more.put(key, strings); |
| } |
| |
| /** |
| * |
| * @param key |
| * @param urls |
| private void addURLs(String key, URL[] urls) |
| { |
| URL[] existing = null; |
| |
| if (more.containsKey(key)) |
| { |
| existing = (URL[]) more.get(key); |
| } |
| |
| if (existing != null) |
| { |
| int length1 = existing.length, length2 = urls == null ? 0 : urls.length; |
| |
| URL[] newURLs = new URL[length1 + length2]; |
| System.arraycopy(existing, 0, newURLs, 0, length1); |
| System.arraycopy(urls, 0, newURLs, length1, length2); |
| |
| urls = newURLs; |
| } |
| |
| more.put(key, urls); |
| } |
| */ |
| |
| /** |
| * |
| */ |
| public String toString() |
| { |
| String[] args = getCompilerOptions(); |
| StringBuilder b = new StringBuilder(); |
| for (int i = 0; i < args.length; i++) |
| { |
| b.append(args[i]); |
| b.append(' '); |
| } |
| return b.toString(); |
| } |
| |
| /** |
| * |
| * @param f |
| * @return |
| */ |
| private File toFile(VirtualFile f) |
| { |
| return (f instanceof LocalFile) ? new File(f.getName()) : null; |
| } |
| |
| /** |
| * |
| * @param f |
| * @return |
| */ |
| @SuppressWarnings({ "unused", "deprecation" }) |
| private URL toURL(VirtualFile f) |
| { |
| try |
| { |
| return (f instanceof LocalFile) ? new File(f.getName()).toURL() : null; |
| } |
| catch (MalformedURLException ex) |
| { |
| return null; |
| } |
| } |
| |
| /** |
| * |
| * @param p |
| * @return |
| private File toFile(String p) |
| { |
| return (p != null) ? new File(p) : null; |
| } |
| */ |
| |
| /** |
| * |
| * @param files |
| * @return |
| */ |
| private File[] toFiles(VirtualFile[] files) |
| { |
| File[] newFiles = new File[files == null ? 0 : files.length]; |
| for (int i = 0, length = newFiles.length; i < length; i++) |
| { |
| newFiles[i] = toFile(files[i]); |
| } |
| |
| return newFiles; |
| } |
| |
| /** |
| * |
| * @param list |
| * @return |
| */ |
| private String[] toStrings(List list) |
| { |
| String[] strings = new String[list == null ? 0 : list.size()]; |
| for (int i = 0, length = strings.length; i < length; i++) |
| { |
| strings[i] = (String) list.get(i); |
| } |
| return strings; |
| } |
| |
| /** |
| * |
| * @param list |
| * @return |
| private URL[] toURLs(List list) |
| { |
| URL[] urls = new URL[list == null ? 0 : list.size()]; |
| for (int i = 0, length = urls.length; i < length; i++) |
| { |
| try |
| { |
| urls[i] = new URL((String) list.get(i)); |
| } |
| catch (MalformedURLException ex) |
| { |
| urls[i] = null; |
| } |
| } |
| return urls; |
| } |
| */ |
| |
| /** |
| * |
| * @param set |
| * @return |
| */ |
| private String[] toStrings(Set set) |
| { |
| String[] strings = new String[set == null ? 0 : set.size()]; |
| if (set != null) |
| { |
| int k = 0; |
| for (Iterator i = set.iterator(); i.hasNext(); k++) |
| { |
| strings[k] = (String) i.next(); |
| } |
| } |
| return strings; |
| } |
| |
| /** |
| * |
| * @param num |
| * @return |
| */ |
| private int toInteger(String num) |
| { |
| try |
| { |
| return Integer.parseInt(num); |
| } |
| catch (NumberFormatException ex) |
| { |
| return -1; |
| } |
| } |
| |
| private String toCommaSeparatedString(String[] strings) |
| { |
| StringBuilder b = new StringBuilder(); |
| for (int i = 0, length = strings == null ? 0 : strings.length; i < length; i++) |
| { |
| b.append(strings[i]); |
| if (i < length - 1) |
| { |
| b.append(','); |
| } |
| } |
| return b.toString(); |
| } |
| |
| private String toCommaSeparatedString(File[] files) |
| { |
| StringBuilder b = new StringBuilder(); |
| for (int i = 0, length = files == null ? 0 : files.length; i < length; i++) |
| { |
| b.append(files[i].getPath()); |
| if (i < length - 1) |
| { |
| b.append(','); |
| } |
| } |
| return b.toString(); |
| } |
| |
| private String toCommaSeparatedString(URL[] urls) |
| { |
| StringBuilder b = new StringBuilder(); |
| for (int i = 0, length = urls == null ? 0 : urls.length; i < length; i++) |
| { |
| b.append(urls[i].toExternalForm()); |
| if (i < length - 1) |
| { |
| b.append(','); |
| } |
| } |
| return b.toString(); |
| } |
| |
| /** |
| * |
| * @param c |
| */ |
| private void populateDefaults(ToolsConfiguration c) |
| { |
| setDefaultBackgroundColor(c.backgroundColor()); |
| setDefaultFrameRate(c.getFrameRate()); |
| setDefaultScriptLimits(c.getScriptRecursionLimit(), c.getScriptTimeLimit()); |
| setDefaultSize(c.defaultWidth(), c.defaultHeight()); |
| setExterns(toStrings(c.getExterns())); |
| setIncludes(toStrings(c.getIncludes())); |
| setTargetPlayer(c.getTargetPlayerMajorVersion(), c.getTargetPlayerMinorVersion(), |
| c.getTargetPlayerRevision()); |
| enableDigestVerification(c.getVerifyDigests()); |
| removeUnusedRuntimeSharedLibraryPaths(c.getRemoveUnusedRsls()); |
| |
| List<RslPathInfo> rslList = c.getRslPathInfo(); |
| boolean first = true; |
| for (Iterator<RslPathInfo> iter = rslList.iterator(); iter.hasNext();) { |
| RslPathInfo info = (RslPathInfo)iter.next(); |
| String[] rslUrls = info.getRslUrls().toArray(new String[0]); |
| String[] policyUrls = info.getPolicyFileUrls().toArray(new String[0]); |
| if (first) { |
| setRuntimeSharedLibraryPath(info.getSwcPath(), |
| rslUrls, |
| policyUrls); |
| first = false; |
| } |
| else { |
| addRuntimeSharedLibraryPath(info.getSwcPath(), |
| rslUrls, |
| policyUrls); |
| } |
| } |
| |
| // TODO |
| // setSWFMetaData(); |
| // setProjector(); |
| |
| setSWFMetaData(c.getMetadata()); |
| setRuntimeSharedLibraries(toStrings(c.getRuntimeSharedLibraries())); |
| useNetwork(c.useNetwork()); |
| |
| // useMobileFramework(); |
| |
| populateDefaults(c.getCompilerConfiguration()); |
| populateDefaults(c.getFramesConfiguration()); |
| populateDefaults(c.getLicensesConfiguration()); |
| populateDefaults(c.getRuntimeSharedLibrarySettingsConfiguration()); |
| } |
| |
| /** |
| * |
| * @param cc |
| */ |
| private void populateDefaults(CompilerConfiguration cc) |
| { |
| enableAccessibility(cc.accessible()); |
| setActionScriptMetadata(cc.getKeepAs3Metadata()); |
| setActionScriptFileEncoding(cc.getActionscriptFileEncoding()); |
| allowSourcePathOverlap(cc.allowSourcePathOverlap()); |
| useActionScript3(cc.dialect() == CompilerConfiguration.AS3Dialect); |
| setContextRoot(cc.getContextRoot()); |
| enableDebugging(cc.debug(), configuration.debugPassword()); |
| |
| if (cc.getDefaultsCssUrl() != null) |
| { |
| setDefaultCSS(FileUtil.openFile(cc.getDefaultsCssUrl().getName())); |
| } |
| |
| useECMAScript(cc.dialect() == CompilerConfiguration.ESDialect); |
| setExternalLibraryPath(toFiles(cc.getExternalLibraryPath())); |
| useHeadlessServer(cc.headlessServer()); |
| keepAllTypeSelectors(cc.keepAllTypeSelectors()); |
| keepCompilerGeneratedActionScript(cc.keepGeneratedActionScript()); |
| includeLibraries(toFiles(cc.getIncludeLibraries())); |
| setLibraryPath(toFiles(cc.getLibraryPath())); |
| setLocale(cc.getLocales()); |
| optimize(cc.optimize()); |
| setServiceConfiguration(toFile(cc.getServices())); |
| showActionScriptWarnings(cc.warnings()); |
| showBindingWarnings(cc.showBindingWarnings()); |
| showDeprecationWarnings(cc.showDeprecationWarnings()); |
| showShadowedDeviceFontWarnings(cc.showShadowedDeviceFontWarnings()); |
| showUnusedTypeSelectorWarnings(cc.showUnusedTypeSelectorWarnings()); |
| setSourcePath(cc.getUnexpandedSourcePath()); |
| enableStrictChecking(cc.strict()); |
| setTheme(toFiles(cc.getThemeFiles())); |
| useResourceBundleMetaData(cc.useResourceBundleMetadata()); |
| enableVerboseStacktraces(cc.debug()); |
| setDefineDirective(cc.getDefine()); |
| setCompatibilityVersion(cc.getMxmlConfiguration().getMajorCompatibilityVersion(), |
| cc.getMxmlConfiguration().getMinorCompatibilityVersion(), |
| cc.getMxmlConfiguration().getRevisionCompatibilityVersion()); |
| |
| checkActionScriptWarning(WARN_ARRAY_TOSTRING_CHANGES, cc.warn_array_tostring_changes()); |
| checkActionScriptWarning(WARN_ASSIGNMENT_WITHIN_CONDITIONAL, cc.warn_assignment_within_conditional()); |
| checkActionScriptWarning(WARN_BAD_ARRAY_CAST, cc.warn_bad_array_cast()); |
| checkActionScriptWarning(WARN_BAD_BOOLEAN_ASSIGNMENT, cc.warn_bad_bool_assignment()); |
| checkActionScriptWarning(WARN_BAD_DATE_CAST, cc.warn_bad_date_cast()); |
| checkActionScriptWarning(WARN_BAD_ES3_TYPE_METHOD, cc.warn_bad_es3_type_method()); |
| checkActionScriptWarning(WARN_BAD_ES3_TYPE_PROP, cc.warn_bad_es3_type_prop()); |
| checkActionScriptWarning(WARN_BAD_NAN_COMPARISON, cc.warn_bad_nan_comparison()); |
| checkActionScriptWarning(WARN_BAD_NULL_ASSIGNMENT, cc.warn_bad_null_assignment()); |
| checkActionScriptWarning(WARN_BAD_NULL_COMPARISON, cc.warn_bad_null_comparison()); |
| checkActionScriptWarning(WARN_BAD_UNDEFINED_COMPARISON, cc.warn_bad_undefined_comparison()); |
| checkActionScriptWarning(WARN_BOOLEAN_CONSTRUCTOR_WITH_NO_ARGS, cc.warn_boolean_constructor_with_no_args()); |
| checkActionScriptWarning(WARN_CHANGES_IN_RESOLVE, cc.warn_changes_in_resolve()); |
| checkActionScriptWarning(WARN_CLASS_IS_SEALED, cc.warn_class_is_sealed()); |
| checkActionScriptWarning(WARN_CONST_NOT_INITIALIZED, cc.warn_const_not_initialized()); |
| checkActionScriptWarning(WARN_CONSTRUCTOR_RETURNS_VALUE, cc.warn_constructor_returns_value()); |
| checkActionScriptWarning(WARN_DEPRECATED_EVENT_HANDLER_ERROR, cc.warn_deprecated_event_handler_error()); |
| checkActionScriptWarning(WARN_DEPRECATED_FUNCTION_ERROR, cc.warn_deprecated_function_error()); |
| checkActionScriptWarning(WARN_DEPRECATED_PROPERTY_ERROR, cc.warn_deprecated_property_error()); |
| checkActionScriptWarning(WARN_DUPLICATE_ARGUMENT_NAMES, cc.warn_duplicate_argument_names()); |
| checkActionScriptWarning(WARN_DUPLICATE_VARIABLE_DEF, cc.warn_duplicate_variable_def()); |
| checkActionScriptWarning(WARN_FOR_VAR_IN_CHANGES, cc.warn_for_var_in_changes()); |
| checkActionScriptWarning(WARN_IMPORT_HIDES_CLASS, cc.warn_import_hides_class()); |
| checkActionScriptWarning(WARN_INSTANCEOF_CHANGES, cc.warn_instance_of_changes()); |
| checkActionScriptWarning(WARN_INTERNAL_ERROR, cc.warn_internal_error()); |
| checkActionScriptWarning(WARN_LEVEL_NOT_SUPPORTED, cc.warn_level_not_supported()); |
| checkActionScriptWarning(WARN_MISSING_NAMESPACE_DECL, cc.warn_missing_namespace_decl()); |
| checkActionScriptWarning(WARN_NEGATIVE_UINT_LITERAL, cc.warn_negative_uint_literal()); |
| checkActionScriptWarning(WARN_NO_CONSTRUCTOR, cc.warn_no_constructor()); |
| checkActionScriptWarning(WARN_NO_EXPLICIT_SUPER_CALL_IN_CONSTRUCTOR, cc.warn_no_explicit_super_call_in_constructor()); |
| checkActionScriptWarning(WARN_NO_TYPE_DECL, cc.warn_no_type_decl()); |
| checkActionScriptWarning(WARN_NUMBER_FROM_STRING_CHANGES, cc.warn_number_from_string_changes()); |
| checkActionScriptWarning(WARN_SCOPING_CHANGE_IN_THIS, cc.warn_scoping_change_in_this()); |
| checkActionScriptWarning(WARN_SLOW_TEXTFIELD_ADDITION, cc.warn_slow_text_field_addition()); |
| checkActionScriptWarning(WARN_UNLIKELY_FUNCTION_VALUE, cc.warn_unlikely_function_value()); |
| checkActionScriptWarning(WARN_XML_CLASS_HAS_CHANGED, cc.warn_xml_class_has_changed()); |
| |
| populateDefaults(cc.getFontsConfiguration()); |
| populateDefaults(cc.getNamespacesConfiguration()); |
| } |
| |
| /** |
| * |
| * @param fc |
| */ |
| private void populateDefaults(FontsConfiguration fc) |
| { |
| FontsConfiguration.Languages lc = fc.getLanguagesConfiguration(); |
| |
| for (Iterator i = lc.keySet().iterator(); i.hasNext(); ) |
| { |
| String key = (String) i.next(); |
| setFontLanguageRange(key, lc.getProperty(key)); |
| } |
| setLocalFontSnapshot(toFile(fc.getLocalFontsSnapshot())); |
| setLocalFontPaths(toStrings(fc.getLocalFontPaths())); |
| setFontManagers(toStrings(fc.getManagers())); |
| setMaximumCachedFonts(toInteger(fc.getMaxCachedFonts())); |
| setMaximumGlyphsPerFace(toInteger(fc.getMaxGlyphsPerFace())); |
| enableAdvancedAntiAliasing(fc.getFlashType()); |
| } |
| |
| /** |
| * |
| * @param nc |
| */ |
| private void populateDefaults(NamespacesConfiguration nc) |
| { |
| Map<String, List<VirtualFile>> manifestMappings = nc.getManifestMappings(); |
| |
| if (manifestMappings != null) |
| { |
| Iterator<Entry<String, List<VirtualFile>>> iterator = manifestMappings.entrySet().iterator(); |
| while (iterator.hasNext()) |
| { |
| Entry<String, List<VirtualFile>> entry = iterator.next(); |
| String uri = entry.getKey(); |
| List<VirtualFile> virtualFiles = entry.getValue(); |
| List<File> files = new ArrayList<File>(virtualFiles.size()); |
| |
| Iterator<VirtualFile> vi = virtualFiles.iterator(); |
| while (vi.hasNext()) |
| { |
| files.add(toFile(vi.next())); |
| } |
| setComponentManifests(uri, files); |
| } |
| } |
| } |
| |
| /** |
| * |
| * @param frc |
| */ |
| private void populateDefaults(FramesConfiguration frc) |
| { |
| List frList = frc.getFrameList(); |
| |
| for (int i = 0, length = frList == null ? 0 : frList.size(); i < length; i++) |
| { |
| FrameInfo info = (FrameInfo) frList.get(i); |
| setFrameLabel(info.label, toStrings(info.frameClasses)); |
| } |
| } |
| |
| /** |
| * |
| * @param lic |
| */ |
| private void populateDefaults(LicensesConfiguration lic) |
| { |
| Map licenseMap = lic.getLicenseMap(); |
| |
| if (licenseMap != null) |
| { |
| for (Iterator i = licenseMap.keySet().iterator(); i.hasNext(); ) |
| { |
| String name = (String) i.next(); |
| setLicense(name, (String) licenseMap.get(name)); |
| } |
| } |
| } |
| |
| /** |
| * |
| * @param configuration - runtime shared library settings. |
| */ |
| private void populateDefaults(RuntimeSharedLibrarySettingsConfiguration configuration) |
| { |
| setForceRuntimeSharedLibraryPaths(toFiles(configuration.getForceRsls())); |
| |
| Map<VirtualFile, String>adMap = configuration.getApplicationDomains(); |
| boolean first = true; |
| |
| for (Map.Entry<VirtualFile, String>entry : adMap.entrySet()) |
| { |
| File file = toFile(entry.getKey()); |
| if (first) |
| { |
| setApplicationDomainForRuntimeSharedLibraryPath( |
| file, |
| entry.getValue()); |
| first = false; |
| } |
| else |
| { |
| addApplicationDomainForRuntimeSharedLibraryPath( |
| file, |
| entry.getValue()); |
| } |
| } |
| |
| } |
| |
| public boolean hasChanged() |
| { |
| return newLinkerOptionsAfterCompile.size() > 0; |
| } |
| |
| public void reset() |
| { |
| newLinkerOptionsAfterCompile.clear(); |
| } |
| |
| public void setTargetPlayer(int major, int minor, int revision) |
| { |
| args.put(TARGET_PLAYER, major + "." + minor + "." + revision); |
| } |
| |
| public void setCompatibilityVersion(int major, int minor, int revision) |
| { |
| if (!(major == 0 && minor == 0 && revision == 0)) |
| { |
| args.put(COMPILER_MXML_COMPATIBILITY, major + "." + minor + "." + revision); |
| } |
| } |
| |
| private String[] createCrossDomainArray(String swc, String[] rslUrls, String[] policyFileUrls) |
| { |
| if (swc == null || rslUrls == null || policyFileUrls == null) |
| { |
| throw new NullPointerException(); |
| } |
| |
| if (rslUrls.length != policyFileUrls.length) |
| { |
| throw new IllegalArgumentException(); |
| } |
| |
| List<String> rslList = new ArrayList<String>(); |
| |
| rslList.add(swc); |
| |
| int argCount = rslUrls.length; |
| for (int i = 0; i < argCount; i++) |
| { |
| rslList.add(rslUrls[i]); |
| rslList.add(policyFileUrls[i]); |
| } |
| |
| return rslList.toArray(new String[0]); |
| } |
| |
| |
| public void enableDigestComputation(boolean compute) |
| { |
| args.put(COMPILER_COMPUTE_DIGEST, compute ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| |
| public void addRuntimeSharedLibraryPath(String swc, String[] rslUrls, String[] policyFileUrls) |
| { |
| String[] rslArray = createCrossDomainArray(swc, rslUrls, policyFileUrls); |
| |
| RslPathList value = (RslPathList) args.get(RUNTIME_SHARED_LIBRARY_PATH); |
| if (value == null) |
| { |
| value = new RslPathList(); |
| args.put(RUNTIME_SHARED_LIBRARY_PATH, value); |
| } |
| |
| value.add(rslArray); |
| } |
| |
| public void setRuntimeSharedLibraryPath(String swc, String[] rslUrls, String[] policyFileUrls) |
| { |
| String[] rslArray = createCrossDomainArray(swc, rslUrls, policyFileUrls); |
| |
| RslPathList list = new RslPathList(); |
| list.add(rslArray); |
| |
| args.put(RUNTIME_SHARED_LIBRARY_PATH, list); |
| } |
| |
| public void enableDigestVerification(boolean verify) |
| { |
| args.put(VERIFY_DIGESTS, verify ? Boolean.TRUE : Boolean.FALSE); |
| } |
| |
| public void addDefineDirective(String name, String value) |
| { |
| // error checking on the values themsevles will be handled later, |
| // in CompilerConfiguration.cfgDefine() |
| CompilerDefinitionList defs = (CompilerDefinitionList) args.get(COMPILER_DEFINE); |
| if (defs == null) |
| { |
| defs = new CompilerDefinitionList(); |
| args.put(COMPILER_DEFINE, defs); |
| } |
| |
| defs.add(name); |
| defs.add(value); |
| } |
| |
| public void setDefineDirective(String[] names, String[] values) |
| { |
| if ((names == null) || (values == null) || (names.length != values.length)) |
| { |
| args.remove(COMPILER_DEFINE); |
| } |
| else |
| { |
| final CompilerDefinitionList defs = new CompilerDefinitionList(); |
| args.put(COMPILER_DEFINE, defs); |
| |
| for(int i = 0; i < values.length; i++) |
| { |
| defs.add(names[i]); |
| defs.add(values[i]); |
| } |
| } |
| } |
| |
| /** |
| * hacky non-API helper method for populateDefaults |
| */ |
| private void setDefineDirective(ObjectList<ConfigVar> configVars) |
| { |
| if (configVars != null) |
| { |
| final CompilerDefinitionList defs = new CompilerDefinitionList(); |
| args.put(COMPILER_DEFINE, defs); |
| for(ConfigVar var : configVars) |
| { |
| // by this point, error checking should already have been |
| // performed on the ConfigVars |
| assert (var != null && |
| var.ns != null && |
| var.name != null && |
| var.value != null && |
| var.ns.length() > 0 && |
| var.name.length() > 0 && |
| var.value.length() > 0); |
| |
| defs.add(var.ns + "::" + var.name); |
| defs.add(var.value); |
| } |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| public Map<String, List<String>> getExtensions() { |
| if( !args.containsKey( COMPILER_EXTENSIONS ) ) { |
| args.put( COMPILER_EXTENSIONS, new LinkedHashMap<String, List<String>>() ); |
| } |
| return (Map<String, List<String>>) args.get( COMPILER_EXTENSIONS ); |
| } |
| |
| public void addExtensionLibraries( File extension, List<String> parameter ) |
| { |
| getExtensions().put( extension.getAbsolutePath(), parameter ); |
| } |
| |
| public void setExtensionLibraries( Map<File, List<String>> extensions) |
| { |
| getExtensions().clear(); |
| Set<File> keys = extensions.keySet(); |
| for ( File key : keys ) |
| { |
| addExtensionLibraries( key, extensions.get( key ) ); |
| } |
| } |
| |
| @Override |
| public OEMConfiguration clone() |
| { |
| OEMConfiguration cloneConfig; |
| try |
| { |
| cloneConfig = (OEMConfiguration) super.clone(); |
| } |
| catch ( CloneNotSupportedException e ) |
| { |
| throw new RuntimeException(e);//wont happen |
| } |
| cloneConfig.args = new LinkedHashMap<String, Object>(args); |
| cloneConfig.defaults = new LinkedHashMap<String, Object>(defaults); |
| cloneConfig.more = new LinkedHashMap<String, Object>(more); |
| cloneConfig.linker_args = new LinkedHashMap<String, Object>(linker_args); |
| cloneConfig.linker_more = new LinkedHashMap<String, Object>(linker_more); |
| return cloneConfig; |
| } |
| |
| public void addForceRuntimeSharedLibraryPaths(File[] paths) |
| { |
| if (paths == null) |
| throw new NullPointerException("paths may not be null"); |
| |
| addFiles(RUNTIME_SHARED_LIBRARY_SETTINGS_FORCE_RSLS, paths); |
| } |
| |
| public void setForceRuntimeSharedLibraryPaths(File[] paths) |
| { |
| if (paths == null) |
| throw new NullPointerException("paths may not be null"); |
| |
| args.put(RUNTIME_SHARED_LIBRARY_SETTINGS_FORCE_RSLS, paths); |
| more.remove(RUNTIME_SHARED_LIBRARY_SETTINGS_FORCE_RSLS); |
| } |
| |
| public void addApplicationDomainForRuntimeSharedLibraryPath(File path, String applicationDomainTarget) |
| { |
| validateApplicationDomainArguments(path, applicationDomainTarget); |
| |
| ApplicationDomainsList value = (ApplicationDomainsList) args.get(RUNTIME_SHARED_LIBRARY_SETTINGS_APPLICATION_DOMAIN); |
| if (value == null) |
| { |
| value = new ApplicationDomainsList(); |
| args.put(RUNTIME_SHARED_LIBRARY_SETTINGS_APPLICATION_DOMAIN, value); |
| } |
| |
| value.add(new String[]{path.getPath(), applicationDomainTarget}); |
| } |
| |
| public void setApplicationDomainForRuntimeSharedLibraryPath(File path, String applicationDomainTarget) |
| { |
| ApplicationDomainsList list = new ApplicationDomainsList(); |
| if (path == null) |
| { |
| args.put(RUNTIME_SHARED_LIBRARY_SETTINGS_APPLICATION_DOMAIN, list); |
| return; |
| } |
| |
| validateApplicationDomainArguments(path, applicationDomainTarget); |
| |
| list.add(new String[]{path.getPath(), applicationDomainTarget}); |
| |
| args.put(RUNTIME_SHARED_LIBRARY_SETTINGS_APPLICATION_DOMAIN, list); |
| } |
| |
| /** |
| * Validate the arguments to the application domain methods. |
| * Throw exceptions if the arguments do not pass the tests. |
| */ |
| private void validateApplicationDomainArguments(File path, String applicationDomainTarget) |
| { |
| if (path == null) |
| throw new NullPointerException("paths may not be null"); |
| |
| if (applicationDomainTarget == null) |
| throw new NullPointerException("applicationDomains may not be null"); |
| } |
| |
| } |