modules/compiler/src/java/flex2/tools/Compc.java - flex-sdk - Git at Google

 /*
  *
  *  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;

 import flex2.compiler.*;
 import flex2.compiler.common.CompilerConfiguration;
 import flex2.compiler.common.DefaultsConfigurator;
 import flex2.compiler.config.ConfigurationBuffer;
 import flex2.compiler.config.ConfigurationException;
 import flex2.compiler.extensions.ExtensionManager;
 import flex2.compiler.extensions.ICompcExtension;
 import flex2.compiler.i18n.I18nUtils;
 import flex2.compiler.io.FileUtil;
 import flex2.compiler.io.VirtualFile;
 import flex2.compiler.swc.*;
 import flex2.compiler.util.*;
 import flex2.linker.LinkerException;
 import flash.localization.LocalizationManager;
 import flash.localization.XLRLocalizer;
 import flash.localization.ResourceBundleLocalizer;
 import flash.util.Trace;
 import org.apache.flex.tools.FlexTool;

 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.util.*;

 /**
  * Entry-point for compc, the command-line tool for compiling components.
  *
  * @author Brian Deitte
  */
 public class Compc extends Tool implements FlexTool
 {
     @Override
     public String getName() {
         return FLEX_TOOL_COMPC;
     }

     @Override
     public int execute(String[] args) {
         compc(args);
         return ThreadLocalToolkit.errorCount();
     }

     public static void main(String[] args)
     {
         compc(args);
         System.exit(ThreadLocalToolkit.errorCount());
     }

     public static void compc(String[] args)
     {
         CompilerAPI.useAS3();

         Benchmark benchmark = null;
         ConfigurationBuffer cfgbuf = new ConfigurationBuffer(CompcConfiguration.class, CompcConfiguration.getAliases());

         // Do not set this.  The include-classes should be included in the configuration buffer checksum so changes
         // to the class list can be detected during incremental builds.
         //cfgbuf.setDefaultVar("include-classes");

         try
         {
             // setup the path resolver
             CompilerAPI.usePathResolver();

             // set up for localizing messages
             LocalizationManager l10n = new LocalizationManager();
             l10n.addLocalizer( new XLRLocalizer() );
             l10n.addLocalizer( new ResourceBundleLocalizer() );
             ThreadLocalToolkit.setLocalizationManager( l10n );

             // setup a console-based logger...
             CompilerAPI.useConsoleLogger();

             // process configuration
             DefaultsConfigurator.loadCompcDefaults( cfgbuf );
             CompcConfiguration configuration = (CompcConfiguration) Mxmlc.processConfiguration(
                 l10n, "compc", args, cfgbuf, CompcConfiguration.class, "include-classes");

             benchmark = compc( cfgbuf,  configuration );

             Set<ICompcExtension> extensions = ExtensionManager.getCompcExtensions( configuration.getCompilerConfiguration().getExtensionsConfiguration().getExtensionMappings() );
             for ( ICompcExtension extension : extensions )
             {
                 if(ThreadLocalToolkit.errorCount() == 0) {
                     extension.run( (CompcConfiguration) configuration.clone() );
                 }
             }
         }
         catch (ConfigurationException ex)
         {
             displayStartMessage();
             Mxmlc.processConfigurationException(ex, "compc");
         }
         catch (CompilerException ex)
         {
             assert ThreadLocalToolkit.errorCount() > 0;
         }
         catch (LinkerException ex)
         {
             assert ThreadLocalToolkit.errorCount() > 0;
         }
         catch (SwcException ex)
         {
             assert ThreadLocalToolkit.errorCount() > 0;
         }
         catch (Throwable t) // IOException, Throwable
         {
             ThreadLocalToolkit.logError(t.getMessage());
             if (Trace.error)
             {
                 t.printStackTrace();
             }
         }
         finally
         {
             if (benchmark != null)
             {
                 if ((ThreadLocalToolkit.errorCount() == 0) &&
                     benchmark.hasStarted(Benchmark.POSTCOMPILE))
                 {
                     benchmark.stopTime(Benchmark.POSTCOMPILE, false);
                 }
                 benchmark.totalTime();
                 benchmark.peakMemoryUsage(true);
             }

             CompilerAPI.removePathResolver();
         }

     }

     public static Benchmark compc( ConfigurationBuffer cfgbuf, CompcConfiguration configuration )
         throws Exception, ConfigurationException, CompilerException
     {
         LocalizationManager l10n = ThreadLocalToolkit.getLocalizationManager();
         CompilerAPI.useConsoleLogger(true, true, configuration.getWarnings(), true);

         Benchmark benchmark = null;
         if (configuration.benchmark())
         {
             benchmark = CompilerAPI.runBenchmark();
             benchmark.startTime(Benchmark.PRECOMPILE);
         }
         else
         {
             CompilerAPI.disableBenchmark();
         }

         CompilerAPI.setupHeadless(configuration);

         String[] sourceMimeTypes = WebTierAPI.getSourcePathMimeTypes();
         CompilerConfiguration compilerConfig = configuration.getCompilerConfiguration();

         // create a SourcePath...
         SourcePath sourcePath = new SourcePath(sourceMimeTypes, compilerConfig.allowSourcePathOverlap());
         sourcePath.addPathElements( compilerConfig.getSourcePath() );

         List<VirtualFile>[] array = CompilerAPI.getVirtualFileList(configuration.getIncludeSources(),
                                                                    configuration.getStylesheets().values(),
                                                                    new HashSet<String>(Arrays.asList(sourceMimeTypes)),
                                                                    sourcePath.getPaths());

         // note: if Configuration is ever shared with other parts of the system, then this part will need
         // to change, since we're setting a compc-specific setting below
         compilerConfig.setMetadataExport(true);

         // create a FileSpec... can reuse based on appPath, debug settings, etc...
         FileSpec fileSpec = new FileSpec(array[0], WebTierAPI.getFileSpecMimeTypes(), false);

         // create a SourceList...
         SourceList sourceList = new SourceList(array[1], compilerConfig.getSourcePath(), null,
                                                WebTierAPI.getSourceListMimeTypes(), false);

         ResourceContainer resources = new ResourceContainer();
         ResourceBundlePath bundlePath = new ResourceBundlePath(configuration.getCompilerConfiguration(), null);

         Map<String, Source> classes = new HashMap<String, Source>();
         NameMappings mappings = CompilerAPI.getNameMappings(configuration);
         List<SwcComponent> nsComponents = SwcAPI.setupNamespaceComponents(configuration, mappings, sourcePath,
                                                                           sourceList, classes);
         SwcAPI.setupClasses(configuration, sourcePath, sourceList, classes);

         if (benchmark != null)
         {
             benchmark.benchmark(l10n.getLocalizedTextString(new Mxmlc.InitialSetup()));
         }

         // load SWCs
         CompilerSwcContext swcContext = new CompilerSwcContext();
         SwcCache cache = new SwcCache();

         // lazy read should only be set by mxmlc/compc
         cache.setLazyRead(true);
         // for compc the theme and include-libraries values have been purposely not passed in below.
         // This is done because the theme attribute doesn't make sense and the include-libraries value
         // actually causes issues when the default value is used with external libraries.
         // FIXME: why don't we just get rid of these values from the configurator for compc?  That's a problem
         // for include-libraries at least, since this value appears in flex-config.xml
         swcContext.load( compilerConfig.getLibraryPath(),
                          compilerConfig.getExternalLibraryPath(),
                          null,
                          compilerConfig.getIncludeLibraries(),
                          mappings,
                          I18nUtils.getTranslationFormat(compilerConfig),
                          cache );
         configuration.addExterns( swcContext.getExterns() );
         configuration.addIncludes( swcContext.getIncludes() );
         configuration.addFiles( swcContext.getIncludeFiles() );

         // Allow -include-classes to override the -external-library-path.
         configuration.removeExterns( configuration.getClasses() );

         // 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 (configuration.getIncludeInheritanceDependenciesOnly())
             configuration.addIncludes(configuration.getClasses());

         // The output file.
         File swcFile = new File(configuration.getOutput());

         // Checksums to figure out if incremental compile can be done.
         String incrementalFileName = null;
         SwcChecksums swcChecksums = null;

         // Should we attempt to build incrementally using the incremental file?
         boolean recompile = true;

         // If incremental compilation is enabled and the output file exists,
         // use the persisted store to figure out if a compile/link is necessary.
         // link without a compile is not supported without changes to the
         // persistantStore since units for Sources of type isSwcScriptOwner()
         // aren't stored/restored properly. units contains null entries for those
         // type of Source.  To force a rebuild, with -incremental specified, delete the
         // incremental file.
         if (configuration.getCompilerConfiguration().getIncremental())
         {
             swcChecksums = new SwcChecksums(swcContext, cfgbuf, configuration);

             // If incremental compilation is enabled, read the cached
             // compilation units...  Do not include the checksum in the file name so that
             // cache files don't pile up as the configuration changes.  There needs
             // to be a 1-to-1 mapping between the swc file and the cache file.
             incrementalFileName = configuration.getOutput() + ".cache";

             // If the output file doesn't exist don't bother loading the
             // cache since a recompile is needed.
             if (swcFile.exists())
             {
                 RandomAccessFile incrementalFile = null;
                 try
                 {
                     incrementalFile = new RandomAccessFile(incrementalFileName, "r");

                     // For loadCompilationUnits, loadedChecksums[1] must match
                     // the cached value else IOException is thrown.
                     int[] loadedChecksums = swcChecksums.copy();

                     CompilerAPI.loadCompilationUnits(configuration, fileSpec, sourceList,
                                                      sourcePath, resources, bundlePath,
                                                      null /* sources */, null /* units */,
                                                      loadedChecksums,
                                                      swcChecksums.getSwcDefSignatureChecksums(),
                                                      swcChecksums.getSwcFileChecksums(),
                                                      swcChecksums.getArchiveFileChecksums(),
                                                      incrementalFile, incrementalFileName,
                                                      null /* font manager */);

                     if (!swcChecksums.isRecompilationNeeded(loadedChecksums) && !swcChecksums.isRelinkNeeded(loadedChecksums))
                     {
                         recompile = false;
                     }
                 }
                 catch (FileNotFoundException ex)
                 {
                     ThreadLocalToolkit.logDebug(ex.getLocalizedMessage());
                 }
                 catch (IOException ex)
                 {
                     ThreadLocalToolkit.logInfo(ex.getLocalizedMessage());
                 }
                 finally
                 {
                     if (incrementalFile != null)
                     {
                         try
                         {
                             incrementalFile.close();
                         }
                         catch (IOException ex)
                         {
                         }
                         // If the load failed, or recompilation is needed, reset
                         // all the variables to their original state.
                         if (recompile)
                         {
                             fileSpec = new FileSpec(array[0], WebTierAPI.getFileSpecMimeTypes(), false);

                             sourceList = new SourceList(array[1], compilerConfig.getSourcePath(), null, WebTierAPI.getSourceListMimeTypes(), false);

                             sourcePath = new SourcePath(sourceMimeTypes, compilerConfig.allowSourcePathOverlap());
                             sourcePath.addPathElements(compilerConfig.getSourcePath());

                             resources = new ResourceContainer();
                             bundlePath = new ResourceBundlePath(configuration.getCompilerConfiguration(), null);

                             classes = new HashMap<String, Source>();
                             nsComponents = SwcAPI.setupNamespaceComponents(configuration, mappings, sourcePath, sourceList, classes);
                             SwcAPI.setupClasses(configuration, sourcePath, sourceList, classes);
                         }
                     }
                 }
             }
         }

         // Validate CompilationUnits in FileSpec and SourcePath.  If
         // count > 0 something changed.
         int count = CompilerAPI.validateCompilationUnits(
                                                          fileSpec, sourceList, sourcePath, bundlePath, resources,
                                                          swcContext,
                                                          null    /* perCompileData */,
                                                          configuration);

         // This isn't really incremental since any change requires a total
         // recompile, relink and re-export, but it shouldn't update the output
         // file if there are no changes to it's dependencies.
         if (recompile || count > 0 || !swcFile.exists())
         {
             // Get standard bundle of compilers, transcoders.
             Transcoder[] transcoders = WebTierAPI.getTranscoders( configuration );
             SubCompiler[] compilers = WebTierAPI.getCompilers(compilerConfig, mappings, transcoders);

             ArrayList<Source> sources = new ArrayList<Source>();
             Map<String, VirtualFile> rbFiles = new HashMap<String, VirtualFile>();

             if (benchmark != null)
             {
                 benchmark.stopTime(Benchmark.PRECOMPILE, false);
             }

             List<CompilationUnit> units =
                 CompilerAPI.compile(fileSpec, sourceList, classes.values(), sourcePath, resources, bundlePath,
                                     swcContext, mappings, configuration, compilers,
                                     new CompcPreLink(rbFiles, configuration.getIncludeResourceBundles(), false),
                                     configuration.getLicensesConfiguration().getLicenseMap(), sources);

             if (benchmark != null)
             {
                 benchmark.startTime(Benchmark.POSTCOMPILE);
             }

             // Link the swc and then export it.
             SwcAPI.exportSwc(configuration, units, nsComponents, cache, rbFiles);

             // If there were no errors and the swc exists then it was exported successfully.
             if (ThreadLocalToolkit.errorCount() == 0 && swcFile.isFile())
             {
                 ThreadLocalToolkit.log(new OutputMessage(FileUtil.getCanonicalPath(swcFile), Long.toString(swcFile.length())));
             }

             // If incremental compilation is enabled, save the compilation units.
             if (configuration.getCompilerConfiguration().getIncremental())
             {
                 // Make sure the checksums are all current.
                 swcChecksums.saveChecksums(units);

                 // These are files which don't necessarily have dependencies on them
                 // so the compiler won't figure out if they've been modified.
                 Map<String, VirtualFile> archiveFiles = new TreeMap<String, VirtualFile>();
                 if (configuration.getCSSArchiveFiles() != null) archiveFiles.putAll(configuration.getCSSArchiveFiles());
                 if (configuration.getL10NArchiveFiles() != null) archiveFiles.putAll(configuration.getL10NArchiveFiles());
                 if (configuration.getFiles() != null) archiveFiles.putAll(configuration.getFiles());
                 if (configuration.getStylesheets() != null) archiveFiles.putAll(configuration.getStylesheets());
                 swcChecksums.saveArchiveFilesChecksums(archiveFiles);

                 RandomAccessFile incrementalFile = null;
                 try
                 {
                     incrementalFile = new RandomAccessFile(incrementalFileName, "rw");

                     // In case we're reusing the file, clear it.
                     incrementalFile.setLength(0);

                     CompilerAPI.persistCompilationUnits(
                                                         configuration, fileSpec, sourceList, sourcePath, resources, bundlePath,
                                                         null, /* sources */
                                                         null, /* units */
                                                         swcChecksums.getChecksums(),
                                                         swcChecksums.getSwcDefSignatureChecksums(),
                                                         swcChecksums.getSwcFileChecksums(),
                                                         swcChecksums.getArchiveFileChecksums(),
                                                         "", incrementalFile);
                 }
                 catch (IOException ex)
                 {
                     ThreadLocalToolkit.logInfo(ex.getLocalizedMessage());

                     // Get rid of the cache file since the write failed.
                     new File(incrementalFileName).deleteOnExit();
                 }
                 finally
                 {
                     if (incrementalFile != null)
                     {
                         try
                         {
                             incrementalFile.close();
                         }
                         catch (IOException ex)
                         {
                         }
                     }
                 }
             }
         }
         else
         {
             if (benchmark != null)
             {
                 benchmark.stopTime(Benchmark.PRECOMPILE, false);
                 benchmark.startTime(Benchmark.POSTCOMPILE);
             }

             // swc is already up-to-date so no need to compile/link or rewrite file
             ThreadLocalToolkit.log(new NoUpdateMessage(FileUtil.getCanonicalPath(swcFile)));

         }

         return benchmark;
     }

     public static final void displayStartMessage()
     {
         LocalizationManager l10n = ThreadLocalToolkit.getLocalizationManager();

         ThreadLocalToolkit.logInfo(l10n.getLocalizedTextString(new StartMessage(VersionInfo.buildMessage())));
     }

     public static class StartMessage extends CompilerMessage.CompilerInfo
     {
         private static final long serialVersionUID = -3698237096980702681L;

         public StartMessage(String buildMessage)
         {
             super();
             this.buildMessage = buildMessage;
         }

         public final String buildMessage;
     }

     public static class OutputMessage extends CompilerMessage.CompilerInfo
     {
         private static final long serialVersionUID = 8747873783743625156L;

         public String name;
         public String length;

         public OutputMessage(String name, String length)
         {
             this.name = name;
             this.length = length;
         }
     }

     public static class NoUpdateMessage extends CompilerMessage.CompilerInfo
     {
         private static final long serialVersionUID = -3432746769116961891L;

         public String name;

         public NoUpdateMessage(String name)
         {
             this.name = name;
         }
     }
 }
	/*
	*
	* 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;

	import flex2.compiler.*;
	import flex2.compiler.common.CompilerConfiguration;
	import flex2.compiler.common.DefaultsConfigurator;
	import flex2.compiler.config.ConfigurationBuffer;
	import flex2.compiler.config.ConfigurationException;
	import flex2.compiler.extensions.ExtensionManager;
	import flex2.compiler.extensions.ICompcExtension;
	import flex2.compiler.i18n.I18nUtils;
	import flex2.compiler.io.FileUtil;
	import flex2.compiler.io.VirtualFile;
	import flex2.compiler.swc.*;
	import flex2.compiler.util.*;
	import flex2.linker.LinkerException;
	import flash.localization.LocalizationManager;
	import flash.localization.XLRLocalizer;
	import flash.localization.ResourceBundleLocalizer;
	import flash.util.Trace;
	import org.apache.flex.tools.FlexTool;

	import java.io.File;
	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.io.RandomAccessFile;
	import java.util.*;

	/**
	* Entry-point for compc, the command-line tool for compiling components.
	*
	* @author Brian Deitte
	*/
	public class Compc extends Tool implements FlexTool
	{
	@Override
	public String getName() {
	return FLEX_TOOL_COMPC;
	}

	@Override
	public int execute(String[] args) {
	compc(args);
	return ThreadLocalToolkit.errorCount();
	}

	public static void main(String[] args)
	{
	compc(args);
	System.exit(ThreadLocalToolkit.errorCount());
	}

	public static void compc(String[] args)
	{
	CompilerAPI.useAS3();

	Benchmark benchmark = null;
	ConfigurationBuffer cfgbuf = new ConfigurationBuffer(CompcConfiguration.class, CompcConfiguration.getAliases());

	// Do not set this. The include-classes should be included in the configuration buffer checksum so changes
	// to the class list can be detected during incremental builds.
	//cfgbuf.setDefaultVar("include-classes");

	try
	{
	// setup the path resolver
	CompilerAPI.usePathResolver();

	// set up for localizing messages
	LocalizationManager l10n = new LocalizationManager();
	l10n.addLocalizer( new XLRLocalizer() );
	l10n.addLocalizer( new ResourceBundleLocalizer() );
	ThreadLocalToolkit.setLocalizationManager( l10n );

	// setup a console-based logger...
	CompilerAPI.useConsoleLogger();

	// process configuration
	DefaultsConfigurator.loadCompcDefaults( cfgbuf );
	CompcConfiguration configuration = (CompcConfiguration) Mxmlc.processConfiguration(
	l10n, "compc", args, cfgbuf, CompcConfiguration.class, "include-classes");

	benchmark = compc( cfgbuf, configuration );

	Set<ICompcExtension> extensions = ExtensionManager.getCompcExtensions( configuration.getCompilerConfiguration().getExtensionsConfiguration().getExtensionMappings() );
	for ( ICompcExtension extension : extensions )
	{
	if(ThreadLocalToolkit.errorCount() == 0) {
	extension.run( (CompcConfiguration) configuration.clone() );
	}
	}
	}
	catch (ConfigurationException ex)
	{
	displayStartMessage();
	Mxmlc.processConfigurationException(ex, "compc");
	}
	catch (CompilerException ex)
	{
	assert ThreadLocalToolkit.errorCount() > 0;
	}
	catch (LinkerException ex)
	{
	assert ThreadLocalToolkit.errorCount() > 0;
	}
	catch (SwcException ex)
	{
	assert ThreadLocalToolkit.errorCount() > 0;
	}
	catch (Throwable t) // IOException, Throwable
	{
	ThreadLocalToolkit.logError(t.getMessage());
	if (Trace.error)
	{
	t.printStackTrace();
	}
	}
	finally
	{
	if (benchmark != null)
	{
	if ((ThreadLocalToolkit.errorCount() == 0) &&
	benchmark.hasStarted(Benchmark.POSTCOMPILE))
	{
	benchmark.stopTime(Benchmark.POSTCOMPILE, false);
	}
	benchmark.totalTime();
	benchmark.peakMemoryUsage(true);
	}

	CompilerAPI.removePathResolver();
	}

	}

	public static Benchmark compc( ConfigurationBuffer cfgbuf, CompcConfiguration configuration )
	throws Exception, ConfigurationException, CompilerException
	{
	LocalizationManager l10n = ThreadLocalToolkit.getLocalizationManager();
	CompilerAPI.useConsoleLogger(true, true, configuration.getWarnings(), true);

	Benchmark benchmark = null;
	if (configuration.benchmark())
	{
	benchmark = CompilerAPI.runBenchmark();
	benchmark.startTime(Benchmark.PRECOMPILE);
	}
	else
	{
	CompilerAPI.disableBenchmark();
	}

	CompilerAPI.setupHeadless(configuration);

	String[] sourceMimeTypes = WebTierAPI.getSourcePathMimeTypes();
	CompilerConfiguration compilerConfig = configuration.getCompilerConfiguration();

	// create a SourcePath...
	SourcePath sourcePath = new SourcePath(sourceMimeTypes, compilerConfig.allowSourcePathOverlap());
	sourcePath.addPathElements( compilerConfig.getSourcePath() );

	List<VirtualFile>[] array = CompilerAPI.getVirtualFileList(configuration.getIncludeSources(),
	configuration.getStylesheets().values(),
	new HashSet<String>(Arrays.asList(sourceMimeTypes)),
	sourcePath.getPaths());

	// note: if Configuration is ever shared with other parts of the system, then this part will need
	// to change, since we're setting a compc-specific setting below
	compilerConfig.setMetadataExport(true);

	// create a FileSpec... can reuse based on appPath, debug settings, etc...
	FileSpec fileSpec = new FileSpec(array[0], WebTierAPI.getFileSpecMimeTypes(), false);

	// create a SourceList...
	SourceList sourceList = new SourceList(array[1], compilerConfig.getSourcePath(), null,
	WebTierAPI.getSourceListMimeTypes(), false);

	ResourceContainer resources = new ResourceContainer();
	ResourceBundlePath bundlePath = new ResourceBundlePath(configuration.getCompilerConfiguration(), null);

	Map<String, Source> classes = new HashMap<String, Source>();
	NameMappings mappings = CompilerAPI.getNameMappings(configuration);
	List<SwcComponent> nsComponents = SwcAPI.setupNamespaceComponents(configuration, mappings, sourcePath,
	sourceList, classes);
	SwcAPI.setupClasses(configuration, sourcePath, sourceList, classes);

	if (benchmark != null)
	{
	benchmark.benchmark(l10n.getLocalizedTextString(new Mxmlc.InitialSetup()));
	}

	// load SWCs
	CompilerSwcContext swcContext = new CompilerSwcContext();
	SwcCache cache = new SwcCache();

	// lazy read should only be set by mxmlc/compc
	cache.setLazyRead(true);
	// for compc the theme and include-libraries values have been purposely not passed in below.
	// This is done because the theme attribute doesn't make sense and the include-libraries value
	// actually causes issues when the default value is used with external libraries.
	// FIXME: why don't we just get rid of these values from the configurator for compc? That's a problem
	// for include-libraries at least, since this value appears in flex-config.xml
	swcContext.load( compilerConfig.getLibraryPath(),
	compilerConfig.getExternalLibraryPath(),
	null,
	compilerConfig.getIncludeLibraries(),
	mappings,
	I18nUtils.getTranslationFormat(compilerConfig),
	cache );
	configuration.addExterns( swcContext.getExterns() );
	configuration.addIncludes( swcContext.getIncludes() );
	configuration.addFiles( swcContext.getIncludeFiles() );

	// Allow -include-classes to override the -external-library-path.
	configuration.removeExterns( configuration.getClasses() );

	// 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 (configuration.getIncludeInheritanceDependenciesOnly())
	configuration.addIncludes(configuration.getClasses());

	// The output file.
	File swcFile = new File(configuration.getOutput());

	// Checksums to figure out if incremental compile can be done.
	String incrementalFileName = null;
	SwcChecksums swcChecksums = null;

	// Should we attempt to build incrementally using the incremental file?
	boolean recompile = true;

	// If incremental compilation is enabled and the output file exists,
	// use the persisted store to figure out if a compile/link is necessary.
	// link without a compile is not supported without changes to the
	// persistantStore since units for Sources of type isSwcScriptOwner()
	// aren't stored/restored properly. units contains null entries for those
	// type of Source. To force a rebuild, with -incremental specified, delete the
	// incremental file.
	if (configuration.getCompilerConfiguration().getIncremental())
	{
	swcChecksums = new SwcChecksums(swcContext, cfgbuf, configuration);

	// If incremental compilation is enabled, read the cached
	// compilation units... Do not include the checksum in the file name so that
	// cache files don't pile up as the configuration changes. There needs
	// to be a 1-to-1 mapping between the swc file and the cache file.
	incrementalFileName = configuration.getOutput() + ".cache";

	// If the output file doesn't exist don't bother loading the
	// cache since a recompile is needed.
	if (swcFile.exists())
	{
	RandomAccessFile incrementalFile = null;
	try
	{
	incrementalFile = new RandomAccessFile(incrementalFileName, "r");

	// For loadCompilationUnits, loadedChecksums[1] must match
	// the cached value else IOException is thrown.
	int[] loadedChecksums = swcChecksums.copy();

	CompilerAPI.loadCompilationUnits(configuration, fileSpec, sourceList,
	sourcePath, resources, bundlePath,
	null /* sources /, null / units */,
	loadedChecksums,
	swcChecksums.getSwcDefSignatureChecksums(),
	swcChecksums.getSwcFileChecksums(),
	swcChecksums.getArchiveFileChecksums(),
	incrementalFile, incrementalFileName,
	null /* font manager */);

	if (!swcChecksums.isRecompilationNeeded(loadedChecksums) && !swcChecksums.isRelinkNeeded(loadedChecksums))
	{
	recompile = false;
	}
	}
	catch (FileNotFoundException ex)
	{
	ThreadLocalToolkit.logDebug(ex.getLocalizedMessage());
	}
	catch (IOException ex)
	{
	ThreadLocalToolkit.logInfo(ex.getLocalizedMessage());
	}
	finally
	{
	if (incrementalFile != null)
	{
	try
	{
	incrementalFile.close();
	}
	catch (IOException ex)
	{
	}
	// If the load failed, or recompilation is needed, reset
	// all the variables to their original state.
	if (recompile)
	{
	fileSpec = new FileSpec(array[0], WebTierAPI.getFileSpecMimeTypes(), false);

	sourceList = new SourceList(array[1], compilerConfig.getSourcePath(), null, WebTierAPI.getSourceListMimeTypes(), false);

	sourcePath = new SourcePath(sourceMimeTypes, compilerConfig.allowSourcePathOverlap());
	sourcePath.addPathElements(compilerConfig.getSourcePath());

	resources = new ResourceContainer();
	bundlePath = new ResourceBundlePath(configuration.getCompilerConfiguration(), null);

	classes = new HashMap<String, Source>();
	nsComponents = SwcAPI.setupNamespaceComponents(configuration, mappings, sourcePath, sourceList, classes);
	SwcAPI.setupClasses(configuration, sourcePath, sourceList, classes);
	}
	}
	}
	}
	}

	// Validate CompilationUnits in FileSpec and SourcePath. If
	// count > 0 something changed.
	int count = CompilerAPI.validateCompilationUnits(
	fileSpec, sourceList, sourcePath, bundlePath, resources,
	swcContext,
	null /* perCompileData */,
	configuration);

	// This isn't really incremental since any change requires a total
	// recompile, relink and re-export, but it shouldn't update the output
	// file if there are no changes to it's dependencies.
	if (recompile \|\| count > 0 \|\| !swcFile.exists())
	{
	// Get standard bundle of compilers, transcoders.
	Transcoder[] transcoders = WebTierAPI.getTranscoders( configuration );
	SubCompiler[] compilers = WebTierAPI.getCompilers(compilerConfig, mappings, transcoders);

	ArrayList<Source> sources = new ArrayList<Source>();
	Map<String, VirtualFile> rbFiles = new HashMap<String, VirtualFile>();

	if (benchmark != null)
	{
	benchmark.stopTime(Benchmark.PRECOMPILE, false);
	}

	List<CompilationUnit> units =
	CompilerAPI.compile(fileSpec, sourceList, classes.values(), sourcePath, resources, bundlePath,
	swcContext, mappings, configuration, compilers,
	new CompcPreLink(rbFiles, configuration.getIncludeResourceBundles(), false),
	configuration.getLicensesConfiguration().getLicenseMap(), sources);

	if (benchmark != null)
	{
	benchmark.startTime(Benchmark.POSTCOMPILE);
	}

	// Link the swc and then export it.
	SwcAPI.exportSwc(configuration, units, nsComponents, cache, rbFiles);

	// If there were no errors and the swc exists then it was exported successfully.
	if (ThreadLocalToolkit.errorCount() == 0 && swcFile.isFile())
	{
	ThreadLocalToolkit.log(new OutputMessage(FileUtil.getCanonicalPath(swcFile), Long.toString(swcFile.length())));
	}

	// If incremental compilation is enabled, save the compilation units.
	if (configuration.getCompilerConfiguration().getIncremental())
	{
	// Make sure the checksums are all current.
	swcChecksums.saveChecksums(units);

	// These are files which don't necessarily have dependencies on them
	// so the compiler won't figure out if they've been modified.
	Map<String, VirtualFile> archiveFiles = new TreeMap<String, VirtualFile>();
	if (configuration.getCSSArchiveFiles() != null) archiveFiles.putAll(configuration.getCSSArchiveFiles());
	if (configuration.getL10NArchiveFiles() != null) archiveFiles.putAll(configuration.getL10NArchiveFiles());
	if (configuration.getFiles() != null) archiveFiles.putAll(configuration.getFiles());
	if (configuration.getStylesheets() != null) archiveFiles.putAll(configuration.getStylesheets());
	swcChecksums.saveArchiveFilesChecksums(archiveFiles);

	RandomAccessFile incrementalFile = null;
	try
	{
	incrementalFile = new RandomAccessFile(incrementalFileName, "rw");

	// In case we're reusing the file, clear it.
	incrementalFile.setLength(0);

	CompilerAPI.persistCompilationUnits(
	configuration, fileSpec, sourceList, sourcePath, resources, bundlePath,
	null, /* sources */
	null, /* units */
	swcChecksums.getChecksums(),
	swcChecksums.getSwcDefSignatureChecksums(),
	swcChecksums.getSwcFileChecksums(),
	swcChecksums.getArchiveFileChecksums(),
	"", incrementalFile);
	}
	catch (IOException ex)
	{
	ThreadLocalToolkit.logInfo(ex.getLocalizedMessage());

	// Get rid of the cache file since the write failed.
	new File(incrementalFileName).deleteOnExit();
	}
	finally
	{
	if (incrementalFile != null)
	{
	try
	{
	incrementalFile.close();
	}
	catch (IOException ex)
	{
	}
	}
	}
	}
	}
	else
	{
	if (benchmark != null)
	{
	benchmark.stopTime(Benchmark.PRECOMPILE, false);
	benchmark.startTime(Benchmark.POSTCOMPILE);
	}

	// swc is already up-to-date so no need to compile/link or rewrite file
	ThreadLocalToolkit.log(new NoUpdateMessage(FileUtil.getCanonicalPath(swcFile)));

	}

	return benchmark;
	}

	public static final void displayStartMessage()
	{
	LocalizationManager l10n = ThreadLocalToolkit.getLocalizationManager();

	ThreadLocalToolkit.logInfo(l10n.getLocalizedTextString(new StartMessage(VersionInfo.buildMessage())));
	}

	public static class StartMessage extends CompilerMessage.CompilerInfo
	{
	private static final long serialVersionUID = -3698237096980702681L;

	public StartMessage(String buildMessage)
	{
	super();
	this.buildMessage = buildMessage;
	}

	public final String buildMessage;
	}

	public static class OutputMessage extends CompilerMessage.CompilerInfo
	{
	private static final long serialVersionUID = 8747873783743625156L;

	public String name;
	public String length;

	public OutputMessage(String name, String length)
	{
	this.name = name;
	this.length = length;
	}
	}

	public static class NoUpdateMessage extends CompilerMessage.CompilerInfo
	{
	private static final long serialVersionUID = -3432746769116961891L;

	public String name;

	public NoUpdateMessage(String name)
	{
	this.name = name;
	}
	}
	}