/*
*
* 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;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.net.URI;
import flash.util.Trace;
import flex2.compiler.CompilationUnit;
import flex2.compiler.CompilerAPI;
import flex2.compiler.CompilerException;
import flex2.compiler.CompilerSwcContext;
import flex2.compiler.FileSpec;
import flex2.compiler.ResourceBundlePath;
import flex2.compiler.ResourceContainer;
import flex2.compiler.Source;
import flex2.compiler.SourceList;
import flex2.compiler.SourcePath;
import flex2.compiler.SubCompiler;
import flex2.compiler.SymbolTable;
import flex2.compiler.Transcoder;
import flex2.compiler.common.CompilerConfiguration;
import flex2.compiler.config.ConfigurationException;
import flex2.compiler.extensions.ExtensionManager;
import flex2.compiler.extensions.ILibraryExtension;
import flex2.compiler.i18n.I18nUtils;
import flex2.compiler.io.FileUtil;
import flex2.compiler.io.LocalFile;
import flex2.compiler.io.VirtualFile;
import flex2.compiler.swc.SwcAPI;
import flex2.compiler.swc.SwcArchive;
import flex2.compiler.swc.SwcCache;
import flex2.compiler.swc.SwcComponent;
import flex2.compiler.swc.SwcDirectoryArchive;
import flex2.compiler.swc.SwcLazyReadArchive;
import flex2.compiler.swc.SwcException;
import flex2.compiler.swc.SwcMovie;
import flex2.compiler.util.Benchmark;
import flex2.compiler.util.CompilerControl;
import flex2.compiler.util.MimeMappings;
import flex2.compiler.util.NameFormatter;
import flex2.compiler.util.NameMappings;
import flex2.compiler.util.PerformanceData;
import flex2.compiler.util.QName;
import flex2.compiler.util.ThreadLocalToolkit;
import flex2.linker.LinkerConfiguration;
import flex2.linker.LinkerException;
import flex2.linker.SimpleMovie;
import flex2.tools.CompcPreLink;
import flex2.tools.Mxmlc;
import flex2.tools.ToolsConfiguration;
import flex2.tools.WebTierAPI;
import flex2.tools.oem.internal.LibraryData;
import flex2.tools.oem.internal.OEMConfiguration;
import flex2.tools.oem.internal.OEMReport;
import flex2.tools.oem.internal.OEMUtil;
import macromedia.asc.util.ContextStatics;
/**
* The <code>Library</code> class represents a SWC archive or a RSL. It implements the <code>Builder</code> interface
* which allows for building the library incrementally. The following example defines a SWC archive or RSL:
*
* <pre>
* Library lib = new Library();
* </pre>
*
* You can add components to the <code>Library</code> object in the following ways:
*
* <pre>
* 1. String - Specify a fully-qualified name.
* 2. File - Specify a source file.
* 3. VirtualLocalFile - Specify an in-memory source object.
* 4. URI - Specify a namespace URI.
* </pre>
*
* <p>
* To add resource bundles to the <code>Library</code>, you can use the <code>addResourceBundle()</code> method,
* as the following example shows:
*
* <pre>
* lib.addResourceBundle("mx.controls"));
* </pre>
*
* <p>
* To add archive files to the <code>Library</code>, you can use the <code>addArchiveFile()</code> method, as the following
* example shows:
*
* <pre>
* lib.addArchiveFile("defaults.css", new File("path1/myStyle.css"));
* </pre>
*
* Before you can compile with a <code>Library</code> object, you must configure it. The following
* four methods are the most common methods you use to configure the <code>Library</code> object:
*
* <pre>
* 1. setLogger() - Use this to set a Logger so that the client can be notified of events that occurred during the compilation.
* 2. setConfiguration() - Optional. Use this to specify compiler options.
* 3. setOutput() - Optional. Use this to specify an output file name.
* 4. setDirectory() - Optional. Use this to specify an RSL output directory.
* </pre>
*
* You must implement the <code>flex2.tools.oem.Logger</code> interface and use the implementation as the <code>Logger</code>
* for the compilation. The following is an example <code>Logger</code> implementation:
*
* <pre>
* lib.setLogger(new flex2.tools.oem.Logger()
* {
* public void log(Message message, int errorCode, String source)
* {
* System.out.println(message);
* }
* });
* </pre>
*
* To specify compiler options for the <code>Library</code> object, you
* must get a <code>Configuration</code> object that is populated with default values. Then, you set
* compiler options programmatically using methods of the <code>Configuration</code> class.
*
* <p>
* The <code>setOutput()</code> method lets you specify where the <code>Library</code> object writes
* the output to. If you call the <code>setOutput()</code> method, the <code>build(boolean)</code> method
* writes directly to the specified location; for example:
*
* <pre>
* lib.setOutput(new File("MyLib.swc"));
* lib.build(true);
* </pre>
*
* If you do not call the <code>setOutput()</code> method, you can use the <code>build(OutputStream, boolean)</code>
* method. This requires that you provide a buffered output stream; for example:
*
* <pre>
* lib.build(new BufferedOutputStream(new FileOutputStream("MyLib.swc")), true);
* </pre>
*
* The <code>setDirectory()</code> method lets you output RSLs to the specified directory; for example:
*
* <pre>
* lib.setDirectory(new File("dir1"));
* lib.build(true);
* </pre>
*
* You can save the <code>Library</code> object compilation
* data for reuse. You do this using the <code>save(OutputStream)</code> method. Subsequent compilations can use
* the <code>load(OutputStream)</code> method to get the old data into the <code>Library</code> object; for example:
*
* <pre>
* lib.save(new BufferedOutputStream(new FileOutputStream("MyLib.incr")));
* </pre>
*
* When a cache file (for example, <code>MyLib.incr</code>) from a previous compilation is available before the
* compilation, you can call the <code>load(OutputStream)</code> method before you call the <code>build()</code> method; for example:
*
* <pre>
* lib.load(new BufferedInputStream(FileInputStream("MyLib.incr")));
* lib.build(true);
* </pre>
*
* The <code>build(false)</code> and <code>build(OutputStream, false)</code> methods always rebuild the library.
* The first time you build the <code>Library</code>
* object, the <code>build(true)/build(OutputStream, true)</code> methods do a complete build, which
* is equivalent to the <code>build(false)/build(OutputStream, false)</code> methods, respectively. After you call the
* <code>clean()</code> method, the <code>Library</code> object always does a full build.
*
* <p>
* The <code>clean()</code> method cleans up compilation data in the <code>Library</code> object the output
* file, if the <code>setOutput()</code> method was called.
*
* <p>
* You can use the <code>Library</code> class to build a library from a combination of source
* files in the file system and in-memory, dynamically-generated source objects. You
* must use the <code>addComponent(VirtualLocalFile)</code>, <code>addResourceBundle(VirtualLocalFile)</code>, and
* <code>addArchiveFile(String, VirtualLocalFile)</code> methods to use in-memory objects.
*
* <p>
* The <code>Library</code> class can be part of a <code>Project</code>.
*
* @see flex2.tools.oem.Configuration
* @see flex2.tools.oem.Project
* @version 2.0.1
* @author Clement Wong
*/
public class Library implements Builder, Cloneable
{
static
{
// This "should" trigger the static initialization of Application which locates
// flex-compiler-oem.jar and set application.home correctly.
try
{
// in Java 1.4, simply saying Application.class would load the class
// Java 1.5 is much smarter, and you have to coax the JVM to actually load it
Class.forName("flex2.tools.oem.Application");
}
catch (ClassNotFoundException e)
{
// I guess it didn't work *shrug*
e.printStackTrace();
assert false;
}
}
/**
* Constructor.
*/
public Library()
{
sources = new TreeSet<VirtualFile>(new Comparator<VirtualFile>()
{
public int compare(VirtualFile f0, VirtualFile f1)
{
return f0.getName().compareTo(f1.getName());
}
});
classes = new TreeSet<String>();
namespaces = new TreeSet<URI>();
resourceBundles = new TreeSet<String>();
files = new TreeMap<String, VirtualFile>();
stylesheets = new TreeMap<String, VirtualFile>();
oemConfiguration = null;
logger = null;
output = null;
directory = null;
mimeMappings = new MimeMappings();
meter = null;
resolver = null;
cc = new CompilerControl();
data = null;
cacheName = null;
configurationReport = null;
messages = new ArrayList<Message>();
}
private Set<VirtualFile> sources;
private Set<String> classes, resourceBundles;
private Set<URI> namespaces;
private Map<String, VirtualFile> files, stylesheets;
private OEMConfiguration oemConfiguration;
private Logger logger;
private File output, directory;
private MimeMappings mimeMappings;
private ProgressMeter meter;
protected PathResolver resolver;
private CompilerControl cc;
private ApplicationCache applicationCache;
private LibraryCache libraryCache;
// clean() would null out the following variables
LibraryData data;
private String cacheName, configurationReport;
private List<Message> messages;
private HashMap<String, PerformanceData[]> compilerBenchmarks;
private Benchmark benchmark;
/**
* Adds a class, function, variable, or namespace to this <code>Library</code> object.
*
* This is the equilvalent of the <code>include-classes</code> option of the compc compiler.
*
* @param includeClass A fully-qualified name.
*/
public void addComponent(String includeClass)
{
classes.add(includeClass);
}
/**
* Adds a component to this <code>Library</code> object.
* This is the equilvalent of the <code>include-sources</code> option of the compc compiler.
*
* @param includeSource A source file.
*/
public void addComponent(File includeSource)
{
sources.add(new LocalFile(includeSource));
}
/**
* Adds a component to this <code>Library</code> object.
*
* This is equilvalent to the <code>include-sources</code> option of the compc compiler.
*
* @param includeSource An in-memory source object.
*/
public void addComponent(VirtualLocalFile includeSource)
{
sources.add(includeSource);
}
/**
* Adds a list of components to this <code>Library</code> object.
*
* This is equilvalent to the <code>include-namespaces</code> option of the compc compiler.
*
* @param includeNamespace A namespace URI.
*/
public void addComponent(URI includeNamespace)
{
namespaces.add(includeNamespace);
}
/**
* Removes the specified component from this <code>Library</code> object.
* The name can be a class, a function, a variable, or a namespace.
*
* @param includeClass A fully-qualified name.
*/
public void removeComponent(String includeClass)
{
classes.remove(includeClass);
}
/**
* Removes the specified component from this <code>Library</code> object.
*
* @param includeSource A source file.
*/
public void removeComponent(File includeSource)
{
sources.remove(new LocalFile(includeSource));
}
/**
* Removes the specified component from this <code>Library</code> object.
*
* @param includeSource An in-memory source object.
*/
public void removeComponent(VirtualLocalFile includeSource)
{
sources.remove(includeSource);
}
/**
* Removes the specified list of components from this <code>Library</code> object. The input argument is a namespace URI.
*
* @param includeNamespace A namespace URI.
*/
public void removeComponent(URI includeNamespace)
{
namespaces.remove(includeNamespace);
}
/**
* Removes all the components from this <code>Library</code> object.
*/
public void removeAllComponents()
{
sources.clear();
classes.clear();
namespaces.clear();
}
/**
* Adds a resource bundle to this <code>Library</code> object.
*
* This is equilvalent to the <code>include-resource-bundles</code> option of the compc compiler.
*
* @param resourceBundle A resource bundle name.
*/
public void addResourceBundle(String resourceBundle)
{
resourceBundles.add(resourceBundle);
}
/**
* Removes the specified resource bundle name from this <code>Library</code> object.
*
* @param resourceBundle A resource bundle name.
*/
public void removeResourceBundle(String resourceBundle)
{
resourceBundles.remove(resourceBundle);
}
/**
* Removes all the resource bundles from this <code>Library</code> object.
*
*/
public void removeAllResourceBundles()
{
resourceBundles.clear();
}
/**
* Adds a file to this <code>Library</code> object. This is equilvalent to the <code>include-file</code> option of the compc compiler.
*
* @param name The name in the archive.
* @param file The file to be added.
*/
public void addArchiveFile(String name, File file)
{
files.put(name, new LocalFile(file));
}
/**
* Adds an in-memory source object to this <code>Library</code> object. This is equilvalent to the <code>
* include-file</code> option of the compc compiler.
*
* @param name The name in the archive.
* @param file The in-memory source object to be added.
*/
public void addArchiveFile(String name, VirtualLocalFile file)
{
files.put(name, file);
}
/**
* Removes the specified file from this <code>Library</code> object.
*
* @param name The name in the archive.
*/
public void removeArchiveFile(String name)
{
files.remove(name);
}
/**
* Removes all the archive files from this <code>Library</code> object.
*/
public void removeAllArchiveFiles()
{
files.clear();
}
/**
* Adds a CSS stylesheet to this <code>Library</code> object. This is equilvalent to the <code>include-stylesheet</code> option of the compc compiler.
*
* @param name The name in the archive.
* @param file The file to be added.
* @since 3.0
*/
public void addStyleSheet(String name, File file)
{
stylesheets.put(name, new LocalFile(file));
}
/**
* Adds an in-memory CSS stylesheet object to this <code>Library</code> object. This is equilvalent to the <code>
* include-stylesheet</code> option of the compc compiler.
*
* @param name The name in the archive.
* @param file The in-memory source object to be added.
* @since 3.0
*/
public void addStyleSheet(String name, VirtualLocalFile file)
{
stylesheets.put(name, file);
}
/**
* Removes the specified CSS stylesheet from this <code>Library</code> object.
*
* @param name The name in the archive.
* @since 3.0
*/
public void removeStyleSheet(String name)
{
stylesheets.remove(name);
}
/**
* Removes all the CSS stylesheets from this <code>Library</code> object.
* @since 3.0
*/
public void removeAllStyleSheets()
{
stylesheets.clear();
}
/**
* @inheritDoc
*/
public void setConfiguration(Configuration configuration)
{
oemConfiguration = (OEMConfiguration) configuration;
}
/**
* @inheritDoc
*/
public Configuration getDefaultConfiguration()
{
return getDefaultConfiguration(false);
}
/**
*
* @param processDefaults
* @return
*/
private Configuration getDefaultConfiguration(boolean processDefaults)
{
return OEMUtil.getLibraryConfiguration(constructCommandLine(null), false, false,
OEMUtil.getLogger(logger, messages), resolver,
mimeMappings, processDefaults);
}
/**
* @inheritDoc
*/
public HashMap<String, PerformanceData[]> getCompilerBenchmarks()
{
return compilerBenchmarks;
}
/**
* @inheritDoc
*/
public Benchmark getBenchmark()
{
return benchmark;
}
/**
* @inheritDoc
*/
public Configuration getConfiguration()
{
return oemConfiguration;
}
/**
* @inheritDoc
*/
public void setLogger(Logger logger)
{
this.logger = logger;
}
/**
* @inheritDoc
*/
public Logger getLogger()
{
return logger;
}
/**
* @inheritDoc
*/
public void setSupportedFileExtensions(String mimeType, String[] extensions)
{
mimeMappings.set(mimeType, extensions);
}
/**
* Sets the output destination. This method is necessary if you use the <code>build(boolean)</code> method.
* If you use the <code>build(OutputStream, boolean)</code> method, there is no need to use this method.
*
* @param output An instance of the <code>java.io.File</code> class.
*/
public void setOutput(File output)
{
this.output = output;
}
/**
* Gets the output destination. This method returns <code>null</code> if you did not call the
* <code>setOutput()</code> method.
*
* @return An instance of the <code>java.io.File</code> class, or <code>null</code> if you did not
* call the <code>setOutput()</code> method.
*/
public File getOutput()
{
return output;
}
/**
* Sets the RSL output directory.
*
* @param directory An RSL directory.
*/
public void setDirectory(File directory)
{
this.directory = directory;
}
/**
* Gets the RSL output directory.
*
* @return A <code>java.io.File</code>, or <code>null</code> if you did not call the <code>setDirectory()</code> method.
*/
public File getDirectory()
{
return directory;
}
/**
* @inheritDoc
*/
public void setProgressMeter(ProgressMeter meter)
{
this.meter = meter;
}
/**
* @inheritDoc
*/
public void setPathResolver(PathResolver resolver)
{
this.resolver = resolver;
}
/**
* @inheritDoc
*/
// IMPORTANT: If you make changes here, you probably want to mirror them in Application.build()
public long build(boolean incremental) throws IOException
{
// I know that directory is not referenced anywhere in here...
// if you setDirectory but do not setOutput, then output==null but dirctory!=null
// so this silly looking IF needs to be like this...
if (output != null || directory != null)
{
long size = 0;
//TODO PERFORMANCE: A lot of unnecessary recopying and buffering here
try
{
int result = compile(incremental);
if (result == SKIP || result == LINK || result == OK)
{
size = link(null);
}
return size;
}
finally
{
if ((output != null) && (data != null) && (data.swcCache != null))
{
refreshLastModified();
}
if ((benchmark != null) && benchmark.hasStarted(Benchmark.POSTCOMPILE))
{
benchmark.stopTime(Benchmark.POSTCOMPILE, false);
}
runExtensions();
clean(false /* cleanData */,
false /* cleanCache */,
false /* cleanOutput */,
true /* cleanConfig */,
false /* cleanMessages */,
true /* cleanThreadLocals */);
}
}
else
{
return 0;
}
}
private void runExtensions()
{
if (oemConfiguration != null)
{
Set<ILibraryExtension> extensions = ExtensionManager.getLibraryExtensions( oemConfiguration.getExtensions() );
for ( ILibraryExtension extension : extensions )
{
if (ThreadLocalToolkit.errorCount() == 0)
{
extension.run( this.clone(), oemConfiguration.clone() );
}
}
}
}
/**
* @inheritDoc
*
* Note: If the OutputStream is written to a File,
* refreshLastModified() should be called to update the timestamp
* in the SwcCache. Otherwise, subsequent builds in this Project
* will think the Library has been externally updated and will
* force a reload.
*/
public long build(OutputStream out, boolean incremental) throws IOException
{
try
{
int result = compile(incremental);
if (result == SKIP || result == LINK || result == OK)
{
return link(out);
}
else
{
return 0;
}
}
finally
{
if ((benchmark != null) && benchmark.hasStarted(Benchmark.POSTCOMPILE))
{
benchmark.stopTime(Benchmark.POSTCOMPILE, false);
}
runExtensions();
clean(false /* cleanData */,
false /* cleanCache */,
false /* cleanOutput */,
true /* cleanConfig */,
false /* cleanMessages */,
true /* cleanThreadLocals */);
}
}
/**
* @param fullRecompile if true a full recompile is needed, do not attempted to use cache file.
*
* @return {@link Builder#OK} if this method call resulted in compilation of some/all parts of the application;
* {@link Builder#LINK} if this method call did not compile anything in the application but advise the caller to link again;
* {@link Builder#SKIP} if this method call did not compile anything in the application;
* {@link Builder#FAIL} if this method call encountered errors during compilation.
*/
private int recompile(boolean fullRecompile, Map licenseMap, OEMConfiguration localOEMConfiguration)
{
data = new LibraryData();
data.configuration = localOEMConfiguration.configuration;
data.cacheName = cacheName;
NameMappings mappings = CompilerAPI.getNameMappings(localOEMConfiguration.configuration), copy = mappings.copy();
CompilerConfiguration compilerConfig = localOEMConfiguration.configuration.getCompilerConfiguration();
compilerConfig.setMetadataExport(true);
if (output != null || directory != null)
{
OEMUtil.setGeneratedDirectory(compilerConfig, output != null ? output : directory);
}
Transcoder[] transcoders = WebTierAPI.getTranscoders( localOEMConfiguration.configuration );
SubCompiler[] compilers = WebTierAPI.getCompilers(compilerConfig, mappings, transcoders);
if ((data.fileSet = processSources(compilerConfig)) == null)
{
return FAIL;
}
data.fileSet.addAll(processStylesheets());
if (!setupSourceContainers(localOEMConfiguration.configuration, data.fileSet))
{
return FAIL;
}
// Setup SWC cache
if (libraryCache != null)
{
ContextStatics contextStatics = libraryCache.getContextStatics();
if (contextStatics != null)
{
// Clear out ASC's userDefined, so definitions from a
// previous compilation don't spill over into this one.
contextStatics.userDefined.clear();
data.perCompileData = contextStatics;
data.swcCache = libraryCache.getSwcCache();
}
}
if (data.swcCache == null)
{
data.swcCache = new SwcCache();
}
// load SWCs
CompilerSwcContext swcContext = new CompilerSwcContext(true);
try
{
swcContext.load( compilerConfig.getLibraryPath(),
compilerConfig.getExternalLibraryPath(),
null,
compilerConfig.getIncludeLibraries(),
mappings,
I18nUtils.getTranslationFormat(compilerConfig),
data.swcCache );
}
catch (SwcException ex)
{
if (Trace.error)
{
ex.printStackTrace();
}
return FAIL;
}
// save the generated cache if the caller provided a libraryCache.
if (libraryCache != null)
{
libraryCache.setSwcCache(data.swcCache);
}
data.includes = new HashSet<String>(swcContext.getIncludes());
data.excludes = new HashSet<String>(swcContext.getExterns());
localOEMConfiguration.configuration.addExterns( swcContext.getExterns() );
localOEMConfiguration.configuration.addIncludes( swcContext.getIncludes() );
data.swcArchiveFiles = new HashMap<String, VirtualFile>(swcContext.getIncludeFiles());
// The ToolsConfiguration expects class names in QName format.
Set<String> qNameClasses = new HashSet<String>();
for (String className : classes)
{
qNameClasses.add(NameFormatter.toColon(className));
}
// Allow -include-classes to override the -external-library-path.
localOEMConfiguration.configuration.removeExterns(qNameClasses);
// If we want only inheritance dependencies of -include-classes then
// add the classes to the includes list. When
// -include-inheritance-dependencies-only is turned on the dependency
// walker will ignore all the classes except for the includes.
if (localOEMConfiguration.configuration.getIncludeInheritanceDependenciesOnly())
{
localOEMConfiguration.configuration.addIncludes(qNameClasses);
}
data.cmdChecksum = localOEMConfiguration.cfgbuf.checksum_ts();
data.linkChecksum = localOEMConfiguration.cfgbuf.link_checksum_ts();
data.swcChecksum = swcContext.checksum();
int[] checksums = new int[] { 0, data.cmdChecksum, data.linkChecksum, data.swcChecksum };
boolean clearCache = false;
// C: must do loadCompilationUnits() after checksum calculation...
if (!fullRecompile)
{
if (!loadCompilationUnits(localOEMConfiguration.configuration, data.fileSet, swcContext, checksums))
{
return FAIL;
}
data.checksum = checksums[0];
if (data.units != null &&
data.units.size() > 0 &&
OEMUtil.isRecompilationNeeded(data, swcContext, localOEMConfiguration))
{
if (!setupSourceContainers(localOEMConfiguration.configuration, data.fileSet))
{
return FAIL;
}
clearCache = true;
}
}
else
{
clearCache = true;
}
if (clearCache && (libraryCache != null) && (output != null))
{
String path = FileUtil.getCanonicalPath(output);
libraryCache.getSwcCache().remove(path);
}
// validate CompilationUnits...
int count = CompilerAPI.validateCompilationUnits(data.fileSpec, data.sourceList, data.sourcePath, data.bundlePath,
data.resources, swcContext, data.classes, data.perCompileData,
localOEMConfiguration.configuration);
SymbolTable symbolTable;
if (data.perCompileData != null)
{
symbolTable = new SymbolTable(localOEMConfiguration.configuration, data.perCompileData);
}
else
{
symbolTable = new SymbolTable(localOEMConfiguration.configuration);
data.perCompileData = symbolTable.perCompileData;
if (libraryCache != null)
{
libraryCache.setContextStatics(data.perCompileData);
}
}
Map<String, Source> classes = new TreeMap<String, Source>();
if ((data.nsComponents = processInputs(swcContext, copy, classes)) == null)
{
return FAIL;
}
// Only updated the LibraryData's classes if processInputs()
// is successful.
data.classes = classes;
data.sources = new ArrayList<Source>();
data.units = compile(compilers, swcContext, symbolTable, mappings, licenseMap, data.classes, data.sources);
// need to update the checksum here since doing a compile could add some
// some signature checksums and change it.
data.checksum = OEMUtil.calculateChecksum(data, swcContext, localOEMConfiguration);
boolean forcedToStop = CompilerAPI.forcedToStop();
if (data.units == null || forcedToStop)
{
return FAIL;
}
else
{
return OK;
}
}
/**
* @inheritDoc
*/
public void stop()
{
cc.stop();
}
/**
* @inheritDoc
*/
public void clean()
{
clean(true /* cleanData */,
true /* cleanCache */,
true /* cleanOutput */,
true /* cleanConfig */,
true /* cleanMessages */,
true /* cleanThreadLocals */);
}
/**
* @inheritDoc
*/
public void load(InputStream in) throws IOException
{
cacheName = OEMUtil.load(in, cacheName);
clean(true /* cleanData */,
false /* cleanCache */,
false /* cleanOutput */,
true /* cleanConfig */,
false /* cleanMessages */,
true /* cleanThreadLocals */);
}
/**
* @inheritDoc
*/
public long save(OutputStream out) throws IOException
{
return OEMUtil.save(out, cacheName, data);
}
/**
* @inheritDoc
*/
public Report getReport()
{
OEMUtil.setupLocalizationManager();
return new OEMReport(data == null ? null : data.sources,
data == null ? null : data.movie,
data == null ? null : data.configuration,
data == null ? null : data.sourceList,
configurationReport,
messages, files);
}
/**
*
* @param c
* @return
*/
private String[] constructCommandLine(OEMConfiguration localOEMConfiguration)
{
String[] commandLine = (localOEMConfiguration != null) ? localOEMConfiguration.getCompilerOptions() :
new String[0];
// Translate "classes" into "-include-classes" so the CompcConfiguration can
// properly validate the configuration.
if (classes.size() > 0)
{
StringBuilder buffer = new StringBuilder("-include-classes=");
for (Iterator<String> iter = classes.iterator(); iter.hasNext();)
{
String className = iter.next();
buffer.append(className);
if (iter.hasNext())
{
buffer.append(",");
}
}
String[] newCommandLine = new String[commandLine.length + 1];
System.arraycopy(commandLine, 0, newCommandLine, 0, commandLine.length);
newCommandLine[commandLine.length] = buffer.toString();
return newCommandLine;
}
return commandLine;
}
/**
*
* @param swcContext
* @param mappings
* @param classes
* @return
*/
private Set<SwcComponent> processInputs(CompilerSwcContext swcContext, NameMappings mappings, Map<String, Source> classes)
{
try
{
Set<SwcComponent> nsComponents = processNamespaces(mappings, classes);
if (nsComponents == null)
{
return null;
}
if (!processClasses(classes))
{
return null;
}
for (Map.Entry<String, Source> entry : classes.entrySet())
{
Source source = entry.getValue();
String namespaceURI = source.getRelativePath().replace('/', '.');
String localPart = source.getShortName();
Source swcSource = (swcContext != null) ? swcContext.getSource(namespaceURI, localPart) : null;
// No sense recompiling the same source file again.
if ((swcSource != null) &&
((source.getLastModified() == swcSource.getLastModified()) &&
((source.getCompilationUnit() == null) ||
(!source.getCompilationUnit().hasTypeInfo))))
{
classes.put(entry.getKey(), swcSource);
}
}
return nsComponents;
}
catch (SwcException ex)
{
if (Trace.error)
{
ex.printStackTrace();
}
assert ThreadLocalToolkit.errorCount() > 0;
return null;
}
}
/**
*
* @param classes
* @return
*/
private boolean processClasses(Map<String, Source> classes)
{
try
{
SwcAPI.setupClasses(new ArrayList<String>(this.classes), data.sourcePath, data.sourceList, classes);
return true;
}
catch (CompilerException ex)
{
assert ThreadLocalToolkit.errorCount() > 0;
return false;
}
}
/**
* This must be called before CompilerSwcContext.load().
*
* @param mappings
* @param classes
* @return
*/
private Set<SwcComponent> processNamespaces(NameMappings mappings, Map<String, Source> classes)
{
Set<SwcComponent> nsComponents = null;
try
{
List<SwcComponent> list = SwcAPI.setupNamespaceComponents(toStrings(namespaces), mappings,
data.sourcePath, data.sourceList,
classes);
nsComponents = new TreeSet<SwcComponent>(new Comparator<SwcComponent>()
{
public int compare(SwcComponent c0, SwcComponent c1)
{
return c0.getClassName().compareTo(c1.getClassName());
}
});
nsComponents.addAll(list);
}
catch (ConfigurationException ex)
{
Mxmlc.processConfigurationException(ex, "oem");
}
catch (CompilerException ex)
{
assert ThreadLocalToolkit.errorCount() > 0;
}
return nsComponents;
}
/**
*
* @param set
* @return
*/
private List<String> toStrings(Set<URI> set)
{
List<String> a = new ArrayList<String>(set.size());
for (Iterator<URI> i = set.iterator(); i.hasNext(); )
{
URI uri = i.next();
a.add(uri.toString());
}
return a;
}
/**
* @param configuration
* @param fileList
* @return true, unless a CompilerException occurs.
*/
private boolean setupSourceContainers(flex2.compiler.common.Configuration configuration, Set<VirtualFile> fileSet)
{
CompilerConfiguration compilerConfig = configuration.getCompilerConfiguration();
VirtualFile[] asClasspath = compilerConfig.getSourcePath();
boolean result = false;
try
{
// create a SourcePath...
data.sourcePath = new SourcePath(WebTierAPI.getSourcePathMimeTypes(),
compilerConfig.allowSourcePathOverlap());
data.sourcePath.addPathElements( asClasspath );
List<VirtualFile>[] array = CompilerAPI.getVirtualFileList(fileSet, data.sourcePath.getPaths());
// create a FileSpec...
data.fileSpec = new FileSpec(array[0], WebTierAPI.getFileSpecMimeTypes(), false);
// create a SourceList...
data.sourceList = new SourceList(array[1], asClasspath, null, WebTierAPI.getSourceListMimeTypes(), false);
// create a ResourceContainer...
data.resources = new ResourceContainer();
// create a ResourceBundlePath...
data.bundlePath = new ResourceBundlePath(compilerConfig, null);
// clear these...
if (data.sources != null) data.sources.clear();
if (data.units != null) data.units.clear();
if (data.swcDefSignatureChecksums != null) data.swcDefSignatureChecksums.clear();
if (data.swcFileChecksums != null) data.swcFileChecksums.clear();
result = true;
}
catch (CompilerException ex)
{
assert ThreadLocalToolkit.errorCount() > 0;
}
return result;
}
/**
* Convert the set of sources, which might include directories and
* files with tokens in the name, into a set of resolved
* VirtualFiles.
*
* @return
*/
private Set<VirtualFile> processSources(CompilerConfiguration compilerConfiguration)
{
Set<VirtualFile> fileSet = null;
try
{
// Create a list of LocalFile paths and remove the LocalFiles "sources".
List<String> localPathList = new ArrayList<String>();
for (Iterator<VirtualFile> iterator = sources.iterator(); iterator.hasNext();)
{
VirtualFile virtualFile = iterator.next();
if (virtualFile instanceof LocalFile)
{
localPathList.add(virtualFile.getName());
iterator.remove();
}
}
// Convert the localPathList to an Array
String[] localPathArray = new String[localPathList.size()];
int i = 0;
for (String localPath : localPathList)
{
localPathArray[i++] = localPath;
}
VirtualFile[] virtualFileArray =
compilerConfiguration.expandTokens(localPathArray, compilerConfiguration.getLocales(), null);
// Add the token expanded VirtualFile's back into "sources".
for (VirtualFile virtualFile : virtualFileArray)
{
sources.add(virtualFile);
}
List<VirtualFile> fileList =
CompilerAPI.getVirtualFileList(sources, new HashSet<String>(Arrays.asList(WebTierAPI.getSourcePathMimeTypes())));
fileSet = new TreeSet<VirtualFile>(new Comparator<VirtualFile>()
{
public int compare(VirtualFile f0, VirtualFile f1)
{
return f0.getName().compareTo(f1.getName());
}
});
fileSet.addAll(fileList);
}
catch (ConfigurationException ex)
{
Mxmlc.processConfigurationException(ex, "oem");
assert ThreadLocalToolkit.errorCount() > 0;
}
return fileSet;
}
/**
*
* @return
*/
private Set<VirtualFile> processStylesheets()
{
Set<VirtualFile> fileSet = null;
try
{
List<VirtualFile> fileList = CompilerAPI.getVirtualFileList(new ArrayList<VirtualFile>(stylesheets.values()), new HashSet<String>(Arrays.asList(new String[] { MimeMappings.CSS })));
fileSet = new TreeSet<VirtualFile>(new Comparator<VirtualFile>()
{
public int compare(VirtualFile f0, VirtualFile f1)
{
return f0.getName().compareTo(f1.getName());
}
});
fileSet.addAll(fileList);
}
catch (ConfigurationException ex)
{
assert ThreadLocalToolkit.errorCount() > 0;
}
return fileSet;
}
/**
*
* @param configuration
* @param fileList
* @return
*/
private boolean loadCompilationUnits(ToolsConfiguration configuration, Set fileSet, CompilerSwcContext swcContext, int[] checksums)
{
if (data.cacheName == null) // note: NOT (cacheName == null)
{
return true;
}
RandomAccessFile cacheFile = null;
try
{
cacheFile = new RandomAccessFile(data.cacheName, "r");
CompilerAPI.loadCompilationUnits(configuration, data.fileSpec, data.sourceList,
data.sourcePath, data.resources, data.bundlePath,
data.sources = new ArrayList<Source>(),
data.units = new ArrayList<CompilationUnit>(),
checksums,
data.swcDefSignatureChecksums = new HashMap<QName, Long>(),
data.swcFileChecksums = new HashMap<String, Long>(),
cacheFile, data.cacheName);
/*
for (int i = 0, size = data.sources.size(); i < size; i++)
{
Object obj = data.sources.get(i);
if (obj instanceof String)
{
String name = (String) obj;
Source s = swcContext.getSource(name);
data.sources.set(i, s);
data.units.set(i, s != null ? s.getCompilationUnit() : null);
}
}
*/
}
catch (FileNotFoundException ex)
{
ThreadLocalToolkit.logInfo(ex.getMessage());
// if the cache file is not found, no big deal... return true so that we recompile.
return true;
}
catch (IOException ex)
{
ThreadLocalToolkit.logInfo(ex.getMessage());
if (!setupSourceContainers(configuration, fileSet))
{
return false;
}
}
finally
{
if (cacheFile != null) try { cacheFile.close(); } catch (IOException ex) {}
}
return true;
}
/**
* Compiles the <code>Library</code>. This method does not link the <code>Library</code>.
*
* @param incremental If <code>true</code>, build incrementally; if <code>false</code>, rebuild.
* @return {@link Builder#OK} if this method call resulted in compilation of some/all parts of the application;
* {@link Builder#LINK} if this method call did not compile anything in the application but advise the caller to link again;
* {@link Builder#SKIP} if this method call did not compile anything in the application;
* {@link Builder#FAIL} if this method call encountered errors during compilation.
*/
protected int compile(boolean incremental)
{
try
{
messages.clear();
// if there is no configuration, use the default... but don't populate this.configuration.
OEMConfiguration tempOEMConfiguration;
if (oemConfiguration == null)
{
tempOEMConfiguration = (OEMConfiguration) getDefaultConfiguration(true);
}
else
{
tempOEMConfiguration = OEMUtil.getLibraryConfiguration(constructCommandLine(oemConfiguration),
oemConfiguration.keepLinkReport(),
oemConfiguration.keepSizeReport(),
OEMUtil.getLogger(logger, messages),
resolver, mimeMappings);
}
// if c is null, which indicates problems, this method will return.
if (tempOEMConfiguration == null)
{
clean(false /* cleanData */, false /* cleanCache */, false /* cleanOutput */);
return FAIL;
}
else if (oemConfiguration != null && oemConfiguration.keepConfigurationReport())
{
configurationReport = OEMUtil.formatConfigurationBuffer(tempOEMConfiguration.cfgbuf);
}
if (oemConfiguration != null)
{
oemConfiguration.cfgbuf = tempOEMConfiguration.cfgbuf;
}
if (tempOEMConfiguration.configuration.benchmark())
{
benchmark = CompilerAPI.runBenchmark();
benchmark.setTimeFilter(tempOEMConfiguration.configuration.getBenchmarkTimeFilter());
benchmark.startTime(Benchmark.PRECOMPILE);
}
else
{
CompilerAPI.disableBenchmark();
}
// add archive files to the link checksum
for (Map.Entry<String, VirtualFile>entry : files.entrySet())
{
tempOEMConfiguration.cfgbuf.calculateLinkChecksum(entry.getKey(), entry.getValue().getLastModified());
}
// initialize some ThreadLocal variables...
cc.run();
OEMUtil.init(OEMUtil.getLogger(logger, messages), mimeMappings, meter, resolver, cc);
// if there is any problem getting the licenses, this method will return.
Map licenseMap = OEMUtil.getLicenseMap(tempOEMConfiguration.configuration);
// if there are no SWC inputs, output an error and return -1
VirtualFile[] includeLibs = (tempOEMConfiguration.configuration == null) ? null : tempOEMConfiguration.configuration.getCompilerConfiguration().getIncludeLibraries();
if (sources.size() == 0 && classes.size() == 0 && namespaces.size() == 0 &&
resourceBundles.size() == 0 && files.size() == 0 && stylesheets.size() == 0 &&
(includeLibs == null || includeLibs.length == 0))
{
ThreadLocalToolkit.log(new ConfigurationException.NoSwcInputs( null, null, -1 ));
clean(false /* cleanData */, false /* cleanCache */, false /* cleanOutput */);
return FAIL;
}
// if nothing has been built yet, let's rebuild.
if (data == null || !incremental)
{
String compilationType = (cacheName != null) ? "inactive" : "full";
if (benchmark != null)
{
benchmark.benchmark2("Starting " + compilationType + " compile for " + getOutput(), true);
}
int returnValue = recompile(false, licenseMap, tempOEMConfiguration);
if (benchmark != null)
{
benchmark.benchmark2("Ending " + compilationType + " compile for " + getOutput(), true);
}
clean(returnValue != OK, false, false);
return returnValue;
}
CompilerAPI.setupHeadless(tempOEMConfiguration.configuration);
NameMappings mappings = CompilerAPI.getNameMappings(tempOEMConfiguration.configuration), copy = mappings.copy();
// Clear out ASC's userDefined, so definitions from a
// previous compilation don't spill over into this one.
data.perCompileData.userDefined.clear();
data.sourcePath.clearCache();
data.bundlePath.clearCache();
data.resources.refresh();
CompilerConfiguration compilerConfig = tempOEMConfiguration.configuration.getCompilerConfiguration();
compilerConfig.setMetadataExport(true);
if (output != null || directory != null)
{
OEMUtil.setGeneratedDirectory(compilerConfig, output != null ? output : directory);
}
Transcoder[] transcoders = WebTierAPI.getTranscoders(tempOEMConfiguration.configuration);
SubCompiler[] compilers = WebTierAPI.getCompilers(compilerConfig, mappings, transcoders);
CompilerSwcContext swcContext = new CompilerSwcContext(true);
try
{
swcContext.load( compilerConfig.getLibraryPath(),
compilerConfig.getExternalLibraryPath(),
null,
compilerConfig.getIncludeLibraries(),
mappings,
I18nUtils.getTranslationFormat(compilerConfig),
data.swcCache );
}
catch (SwcException ex)
{
if (Trace.error)
{
ex.printStackTrace();
}
clean(false /* cleanData */, false /* cleanCache */, false /* cleanOutput */);
return FAIL;
}
// save the generated swcCache if the class has a libraryCache.
if (libraryCache != null)
{
libraryCache.setSwcCache(data.swcCache);
}
// If checksum is different, rebuild.
if (OEMUtil.isRecompilationNeeded(data, swcContext, tempOEMConfiguration))
{
if (benchmark != null)
{
benchmark.benchmark2("Starting full compile for " + getOutput(), true);
}
clean(true /* cleanData */,
false /* cleanCache */,
false /* cleanOutput */,
true /* cleanConfig */,
false /* cleanMessages */,
false /* cleanThreadLocals */);
int returnValue = recompile(true, licenseMap, tempOEMConfiguration);
if (benchmark != null)
{
benchmark.benchmark2("Ending full compile for " + getOutput(), true);
}
clean(returnValue != OK, false, false);
return returnValue;
}
// If --include-sources is different, rebuild.
Set<VirtualFile> fileSet = null;
if ((fileSet = processSources(compilerConfig)) == null)
{
clean(false /* cleanData */, false /* cleanCache */, false /* cleanOutput */);
return FAIL;
}
// If --include-stylesheets is different, rebuild.
fileSet.addAll(processStylesheets());
boolean isFileSpecDifferent = isDifferent(data.fileSet, fileSet);
if (isFileSpecDifferent)
{
if (benchmark != null)
{
benchmark.benchmark2("Starting full compile for " + getOutput(), true);
}
clean(true /* cleanData */,
false /* cleanCache */,
false /* cleanOutput */,
true /* cleanConfig */,
false /* cleanMessages */,
false /* cleanThreadLocals */);
int returnValue = recompile(true, licenseMap, tempOEMConfiguration);
if (benchmark != null)
{
benchmark.benchmark2("Ending full compile for " + getOutput(), true);
}
clean(returnValue != OK, false, false);
return returnValue;
}
if (benchmark != null)
{
// We aren't really starting the compile here, but it's
// the earliest that we know that it's going to be an
// active compilation.
benchmark.benchmark2("Starting active compile for " + getOutput(), true);
}
data.includes = new HashSet<String>(swcContext.getIncludes());
data.excludes = new HashSet<String>(swcContext.getExterns());
tempOEMConfiguration.configuration.addExterns( swcContext.getExterns() );
tempOEMConfiguration.configuration.addIncludes( swcContext.getIncludes() );
data.swcArchiveFiles = new HashMap<String, VirtualFile>(swcContext.getIncludeFiles());
// The ToolsConfiguration expects class names in QName format.
Set<String> qNameClasses = new HashSet<String>();
for (String className : classes)
{
qNameClasses.add(NameFormatter.toColon(className));
}
// Allow -include-classes to override the -external-library-path.
tempOEMConfiguration.configuration.removeExterns(qNameClasses);
// If we want only inheritance dependencies of -include-classes then
// add the classes to the includes list. When
// -include-inheritance-dependencies-only is turned on the dependency
// walker will ignore all the classes except for the includes.
if (tempOEMConfiguration.configuration.getIncludeInheritanceDependenciesOnly())
{
tempOEMConfiguration.configuration.addIncludes(qNameClasses);
}
int count = CompilerAPI.validateCompilationUnits(data.fileSpec, data.sourceList, data.sourcePath,
data.bundlePath, data.resources, swcContext,
data.classes, data.perCompileData,
tempOEMConfiguration.configuration);
Map<String, Source> classes = new TreeMap<String, Source>();
Set<SwcComponent> nsComponents = null;
if ((nsComponents = processInputs(swcContext, copy, classes)) == null)
{
clean(false /* cleanData */, false /* cleanCache */, false /* cleanOutput */);
return FAIL;
}
// If the other --include-* are different, build incrementally.
boolean isDifferent = isDifferent(data.classes.keySet(), classes.keySet());
if (count > 0 || isDifferent || isResourceBundleListDifferent() ||
data.swcChecksum != swcContext.checksum())
{
// create a symbol table
SymbolTable symbolTable = new SymbolTable(tempOEMConfiguration.configuration, data.perCompileData);
data.configuration = tempOEMConfiguration.configuration;
data.nsComponents = nsComponents;
data.classes = classes;
data.fileSet = fileSet;
data.linkChecksum = tempOEMConfiguration.cfgbuf.link_checksum_ts();
data.swcChecksum = swcContext.checksum();
// compile
data.sources = new ArrayList<Source>();
data.units = compile(compilers, swcContext, symbolTable, mappings, licenseMap, classes, data.sources);
boolean forcedToStop = CompilerAPI.forcedToStop();
if (data.units == null || forcedToStop)
{
clean(true, false, false);
return FAIL;
}
else
{
if (benchmark != null)
{
benchmark.benchmark2("Ending active compile for " + getOutput(), true);
}
clean(false /* cleanData */, false /* cleanCache */, false /* cleanOutput */);
return OK;
}
}
else
{
if (benchmark != null)
{
benchmark.stopTime(Benchmark.PRECOMPILE, false);
benchmark.startTime(Benchmark.POSTCOMPILE);
}
int retVal = SKIP;
if (data != null)
{
CompilerAPI.displayWarnings(data.units);
if (data.linkChecksum != tempOEMConfiguration.cfgbuf.link_checksum_ts())
{
retVal = LINK;
}
}
else
{
retVal = LINK;
}
data.linkChecksum = tempOEMConfiguration.cfgbuf.link_checksum_ts();
data.swcChecksum = swcContext.checksum();
if (CompilerAPI.forcedToStop()) retVal = FAIL;
if (benchmark != null)
{
benchmark.benchmark2("Ending active compile for " + getOutput(), true);
}
if (retVal == LINK)
{
clean(false /* cleanData */,
false /* cleanCache */,
false /* cleanOutput */,
false /* cleanConfig */,
false /* cleanMessages */,
false /* cleanThreadLocals */);
}
else
{
clean(false /* cleanData */, false /* cleanCache */, false /* cleanOutput */);
}
return retVal;
}
}
finally
{
// clean thread locals
OEMUtil.clean();
}
}
/**
*
* @param compilers
* @param swcContext
* @param symbolTable
* @param licenseMap
* @param classes
*/
private List<CompilationUnit> compile(SubCompiler[] compilers, CompilerSwcContext swcContext,
SymbolTable symbolTable, NameMappings nameMappings, Map licenseMap,
Map<String, Source> classes, List<Source> sources)
{
List<CompilationUnit> units = null;
Map<String, VirtualFile> rbFiles = new HashMap<String, VirtualFile>();
try
{
if (benchmark != null)
{
for (int i = 0; i < compilers.length; i++)
{
compilers[i].initBenchmarks();
}
benchmark.stopTime(Benchmark.PRECOMPILE, false);
}
units = CompilerAPI.compile(data.fileSpec, data.sourceList, classes.values(), data.sourcePath, data.resources,
data.bundlePath, swcContext, symbolTable, nameMappings, data.configuration,
compilers, new CompcPreLink(rbFiles, new ArrayList<String>(resourceBundles), false),
licenseMap, sources);
if (benchmark != null)
{
benchmark.startTime(Benchmark.POSTCOMPILE);
}
if ((benchmark != null) && (ThreadLocalToolkit.getLogger() != null))
{
if (compilerBenchmarks == null)
compilerBenchmarks = new HashMap<String, PerformanceData[]>();
compilerBenchmarks.clear();
flex2.compiler.Logger logger = ThreadLocalToolkit.getLogger();
for (int i = 0; i < compilers.length; i++)
{
SubCompiler compiler = compilers[i];
PerformanceData[] times = compiler.getBenchmarks();
if (times == null)
continue;
compiler.logBenchmarks(logger);
String compilerName = compiler.getName();
compilerBenchmarks.put(compilerName, times);
}
}
}
catch (CompilerException ex)
{
if (Trace.error)
{
ex.printStackTrace();
}
assert ThreadLocalToolkit.errorCount() > 0;
}
catch (SwcException ex)
{
if (Trace.error)
{
ex.printStackTrace();
}
assert ThreadLocalToolkit.errorCount() > 0;
}
catch (Throwable t)
{
if (Trace.error)
{
t.printStackTrace();
}
ThreadLocalToolkit.logError(t.getLocalizedMessage());
}
finally
{
data.sourcePath.clearCache();
data.bundlePath.clearCache();
data.resources.refresh();
data.classes = classes;
data.rbFiles = rbFiles;
Map<String, VirtualFile> m = data.configuration.getCSSArchiveFiles();
if (m != null)
{
data.cssArchiveFiles = new HashMap<String, VirtualFile>(m);
}
m = data.configuration.getL10NArchiveFiles();
if (m != null)
{
data.l10nArchiveFiles = new HashMap<String, VirtualFile>(m);
}
OEMUtil.saveSignatureChecksums(units, data, data.configuration);
OEMUtil.saveSwcFileChecksums(swcContext, data, data.configuration);
// Make sure the swcContext is closed so we don't leave any dangling file handles
swcContext.close();
}
return units;
}
/**
* Links the <code>Library</code>. This method writes the output
* to the output stream specified by the client. You should use a
* buffered output stream for best performance.
*
* <p> This method is protected. In most circumstances, the client
* only needs to call the <code>build()</code> method. Subclasses
* can call this method so that it links and outputs the
* application without recompiling. If the OutputStream is
* subsequently written to a file, subclasses should call
* refreshLastModified().
*
* @param out The <code>OutputStream</code>.
* @return The size of the application, in bytes.
* @throws IOException Thrown when an I/O error occurs during linking.
*/
protected long link(OutputStream out) throws IOException
{
if (data == null || data.units == null)
{
return 0;
}
boolean hasChanged = (oemConfiguration == null) ? false : oemConfiguration.hasChanged();
flex2.compiler.common.Configuration config = null;
if (hasChanged)
{
oemConfiguration = OEMUtil.getLinkerConfiguration(oemConfiguration.getLinkerOptions(),
oemConfiguration.keepLinkReport(),
oemConfiguration.keepSizeReport(),
OEMUtil.getLogger(logger, messages),
mimeMappings, resolver,
data.configuration,
oemConfiguration.newLinkerOptionsAfterCompile,
data.includes, data.excludes);
if (oemConfiguration == null)
{
clean(false /* cleanData */,
false /* cleanCache */,
false /* cleanOutput */,
false /* cleanConfig */,
false /* cleanMessages */,
true /* cleanThreadLocals */);
return 0;
}
config = oemConfiguration.configuration;
}
else
{
config = data.configuration;
}
if (config.benchmark())
{
benchmark = CompilerAPI.runBenchmark();
benchmark.setTimeFilter(config.getBenchmarkTimeFilter());
}
else
{
CompilerAPI.disableBenchmark();
}
try
{
OEMUtil.init(OEMUtil.getLogger(logger, messages), mimeMappings, meter, resolver, cc);
SimpleMovie temp = data.movie;
data.movie = SwcAPI.link(config, data.units);
// link
SwcArchive archive = null;
Map<String, VirtualFile> archiveFiles = new TreeMap<String, VirtualFile>();
if (data.swcArchiveFiles != null) archiveFiles.putAll(data.swcArchiveFiles);
if (data.cssArchiveFiles != null) archiveFiles.putAll(data.cssArchiveFiles);
if (data.l10nArchiveFiles != null) archiveFiles.putAll(data.l10nArchiveFiles);
archiveFiles.putAll(files);
if (directory != null)
{
archive = new SwcDirectoryArchive(FileUtil.getCanonicalPath(directory));
SwcAPI.exportSwc(archive,
archiveFiles,
this.stylesheets,
(LinkerConfiguration) config,
(SwcMovie) data.movie,
new ArrayList<SwcComponent>(data.nsComponents),
data.swcCache,
data.rbFiles);
}
long size = 0;
// TODO PERFORMANCE: A lot of unnecessary recopying and buffering here
ByteArrayOutputStream baos = null;
String path = null;
if (output != null)
{
path = FileUtil.getCanonicalPath(output);
}
// Flex Builder supplies an "out" and an "output", but
// they really only use the "out", so check for that
// first.
if (out != null)
{
baos = new ByteArrayOutputStream();
archive = new SwcLazyReadArchive(baos, path);
}
else if (output != null)
{
archive = new SwcLazyReadArchive(path);
}
SwcAPI.exportSwc(archive,
archiveFiles,
this.stylesheets,
(LinkerConfiguration) config,
(SwcMovie) data.movie,
new ArrayList<SwcComponent>(data.nsComponents),
data.swcCache,
data.rbFiles);
if (out != null)
{
ByteArrayInputStream in = new ByteArrayInputStream(baos.toByteArray());
FileUtil.streamOutput(in, out);
size = baos.size();
}
else if (output != null)
{
size = output.length();
}
if (hasChanged && temp != null)
{
data.movie = temp;
}
return size;
}
catch (LinkerException ex)
{
assert ThreadLocalToolkit.errorCount() > 0;
return 0;
}
catch (SwcException ex)
{
if (Trace.error)
{
ex.printStackTrace();
}
assert ThreadLocalToolkit.errorCount() > 0;
return 0;
}
catch (Throwable t)
{
if (Trace.error)
{
t.printStackTrace();
}
ThreadLocalToolkit.logError(t.getLocalizedMessage());
return 0;
}
finally
{
// clean thread locals
OEMUtil.clean();
}
}
/**
*
* @param cleanData
* @param cleanCache
* @param cleanOutput
*/
private void clean(boolean cleanData, boolean cleanCache, boolean cleanOutput)
{
clean(cleanData,
cleanCache,
cleanOutput,
true /* cleanConfig */,
false /* cleanMessages */,
false /* cleanThreadLocals */);
}
/**
*
* @param cleanData
* @param cleanCache
* @param cleanOutput
* @param cleanConfig
* @param cleanMessages
* @param cleanThreadLocals
*/
private void clean(boolean cleanData, boolean cleanCache, boolean cleanOutput,
boolean cleanConfig, boolean cleanMessages, boolean cleanThreadLocals)
{
if (cleanThreadLocals)
{
OEMUtil.clean();
}
if (oemConfiguration != null && cleanConfig)
{
oemConfiguration.reset();
}
if (cleanData)
{
data = null;
configurationReport = null;
}
if (cleanCache)
{
if (cacheName != null)
{
File dead = FileUtil.openFile(cacheName);
if (dead != null && dead.exists())
{
dead.delete();
}
cacheName = null;
}
}
if (cleanOutput)
{
if (output != null && output.exists())
{
output.delete();
}
}
if (cleanMessages)
{
messages.clear();
}
}
/**
*
* @param s1
* @param s2
* @return
*/
private <T> boolean isDifferent(Collection<T> s1, Collection<T> s2)
{
for (Iterator<T> i = s2.iterator(); i.hasNext(); )
{
if (!s1.contains(i.next()))
{
return true;
}
}
return s1.size() > s2.size();
}
/**
*
* @return
*/
private boolean isResourceBundleListDifferent()
{
int size1 = (data == null || data.rbFiles == null) ? 0 : data.rbFiles.size();
int size2 = resourceBundles == null ? 0 : resourceBundles.size();
return size1 != size2;
}
/**
* Returns the cache of sources in the source list and source
* path. After building this Library object, the cache may be
* saved and used to compile another Application or Library object
* with common sources.
*
* @return The active cache. May be null.
*
* @since 4.5
*/
public ApplicationCache getApplicationCache()
{
return applicationCache;
}
/**
* Sets the cache for sources in the source list and source path.
* After compiling this Library object, the cache may be reused to
* build another Application or Library object with common
* sources.
*
* @param applicationCache A reference to the application cache.
*
* @since 4.5
*/
public void setApplicationCache(ApplicationCache applicationCache)
{
this.applicationCache = applicationCache;
}
// TODO: deprecate getSwcCache() and setSwcCache(), then add
// getLibraryCache() and setLibraryCache().
/**
* Get the cache of swcs in the library path. After building this
* Library object, the cache may be saved and used to compile
* another Library or Application object that uses the same
* library path.
*
* @return The active cache. May be null.
*
* @since 3.0
*/
public LibraryCache getSwcCache()
{
return libraryCache;
}
/**
* Set the cache for swcs in the library path. After compiling an
* Library object, the cache may be reused to build another
* Library or Application object that uses the same library path.
*
* @param swcCache A reference to an allocated swc cache.
*
* @since 3.0
*/
public void setSwcCache(LibraryCache libraryCache)
{
this.libraryCache = libraryCache;
}
public void refreshLastModified()
{
String fileName = FileUtil.getCanonicalPath(output);
File file = new File(fileName);
long lastModified = file.lastModified();
data.swcCache.setLastModified(fileName, lastModified);
}
@Override
public Library clone()
{
Library clone;
try
{
clone = (Library) super.clone();
}
catch ( CloneNotSupportedException e )
{
throw new RuntimeException( e ); //wont happen
}
clone.oemConfiguration = oemConfiguration.clone();
return clone;
}
}