| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| package flex2.tools.oem.internal; |
| |
| import java.io.BufferedInputStream; |
| import java.io.ByteArrayInputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.RandomAccessFile; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import flash.localization.LocalizationManager; |
| import flash.localization.ResourceBundleLocalizer; |
| import flash.util.FileUtils; |
| import flash.util.Trace; |
| import flex2.compiler.CompilerAPI; |
| import flex2.compiler.CompilationUnit; |
| import flex2.compiler.CompilerSwcContext; |
| import flex2.compiler.Source; |
| import flex2.compiler.common.CompilerConfiguration; |
| import flex2.compiler.common.DefaultsConfigurator; |
| import flex2.compiler.config.CommandLineConfigurator; |
| import flex2.compiler.config.ConfigurationBuffer; |
| import flex2.compiler.config.ConfigurationException; |
| import flex2.compiler.config.FileConfigurator; |
| import flex2.compiler.config.SystemPropertyConfigurator; |
| import flex2.compiler.io.FileUtil; |
| import flex2.compiler.io.VirtualFile; |
| import flex2.compiler.swc.Swc; |
| import flex2.compiler.swc.SwcScript; |
| import flex2.compiler.util.CompilerControl; |
| import flex2.compiler.util.MimeMappings; |
| import flex2.compiler.util.QName; |
| import flex2.compiler.util.ThreadLocalToolkit; |
| import flex2.tools.CommandLineConfiguration; |
| import flex2.tools.CompcConfiguration; |
| import flex2.tools.Mxmlc; |
| import flex2.tools.ToolsConfiguration; |
| import flex2.tools.oem.*; |
| |
| /** |
| * A collection of utility methods used by classes in flex2.tools.oem. |
| * |
| * @version 2.0.1 |
| * @author Clement Wong |
| */ |
| public class OEMUtil |
| { |
| /** |
| * |
| */ |
| public static final LocalizationManager setupLocalizationManager() |
| { |
| LocalizationManager l10n = ThreadLocalToolkit.getLocalizationManager(); |
| |
| if (l10n == null) |
| { |
| // set up for localizing messages |
| l10n = new LocalizationManager(); |
| l10n.addLocalizer(new ResourceBundleLocalizer()); |
| ThreadLocalToolkit.setLocalizationManager(l10n); |
| } |
| |
| return l10n; |
| } |
| |
| /** |
| * |
| * @param logger |
| * @param mimeMappings |
| */ |
| public static final void init(Logger logger, |
| MimeMappings mimeMappings, |
| ProgressMeter meter, |
| PathResolver resolver, |
| CompilerControl cc) |
| { |
| CompilerAPI.useAS3(); |
| CompilerAPI.usePathResolver(resolver != null ? new OEMPathResolver(resolver) : null); |
| setupLocalizationManager(); |
| ThreadLocalToolkit.setLogger(new OEMLogAdapter(logger)); |
| ThreadLocalToolkit.setMimeMappings(mimeMappings); |
| ThreadLocalToolkit.setProgressMeter(meter); |
| ThreadLocalToolkit.setCompilerControl(cc); |
| } |
| |
| /** |
| * |
| * |
| */ |
| public static final void clean() |
| { |
| CompilerAPI.removePathResolver(); |
| ThreadLocalToolkit.setLogger(null); |
| ThreadLocalToolkit.setLocalizationManager(null); |
| ThreadLocalToolkit.setMimeMappings(null); |
| ThreadLocalToolkit.setProgressMeter(null); |
| ThreadLocalToolkit.setCompilerControl(null); |
| ThreadLocalToolkit.setCompatibilityVersion(null); |
| } |
| |
| /** |
| * |
| * @param in |
| * @return |
| * @throws IOException |
| */ |
| public static final String load(InputStream in, String cacheName) throws IOException |
| { |
| // grab the data and put it in a temp file... |
| File temp = null; |
| if (cacheName == null) |
| { |
| temp = FileUtil.createTempFile(in); |
| temp.deleteOnExit(); |
| } |
| else |
| { |
| temp = FileUtil.openFile(cacheName); |
| FileUtil.writeBinaryFile(temp, in); |
| } |
| return FileUtil.getCanonicalPath(temp); |
| } |
| |
| /** |
| * |
| * @param out |
| * @param cacheName |
| * @param data |
| * @return |
| * @throws IOException |
| */ |
| public static final long save(OutputStream out, String cacheName, ApplicationData data) throws IOException |
| { |
| if (cacheName == null) |
| { |
| // this will create a temp file and populate cacheName. |
| cacheName = load(new ByteArrayInputStream(new byte[0]), null); |
| } |
| |
| // only save when there is something for us to save (i.e. data != null) |
| if (cacheName != null && data != null) |
| { |
| // delete the existing cache file |
| File dead = FileUtil.openFile(cacheName); |
| if (dead != null && dead.exists()) |
| { |
| dead.delete(); |
| } |
| |
| RandomAccessFile cacheFile = null; |
| try |
| { |
| cacheFile = new RandomAccessFile(cacheName, "rw"); |
| CompilerAPI.persistCompilationUnits(data.configuration, data.fileSpec, data.sourceList, |
| data.sourcePath, data.resources, data.bundlePath, |
| data.sources, data.units, data.checksum, |
| data.cmdChecksum, data.linkChecksum, data.swcChecksum, |
| data.swcDefSignatureChecksums, data.swcFileChecksums, |
| "", cacheFile); |
| } |
| finally |
| { |
| if (cacheFile != null) { try { cacheFile.close(); } catch (IOException ex) {} } |
| } |
| |
| // write the data to the specified output stream |
| InputStream in = null; |
| try |
| { |
| in = new BufferedInputStream(new FileInputStream(cacheName)); |
| FileUtil.streamOutput(in, out); |
| } |
| finally |
| { |
| if (in != null) { try { in.close(); } catch (IOException ex) {} } |
| } |
| |
| return new File(cacheName).length(); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| /** |
| * |
| * @param args |
| * @param logger |
| * @param mimeMappings |
| * @return |
| */ |
| public static final OEMConfiguration getApplicationConfiguration(String[] args, boolean keepLinkReport, |
| boolean keepSizeReport, Logger logger, PathResolver resolver, |
| MimeMappings mimeMappings) |
| { |
| return getApplicationConfiguration(args, keepLinkReport, keepSizeReport, logger, resolver, mimeMappings, true); |
| } |
| |
| /** |
| * |
| * @param args |
| * @param logger |
| * @param mimeMappings |
| * @param processDefaults |
| * @return |
| */ |
| public static final OEMConfiguration getApplicationConfiguration(String[] args, boolean keepLinkReport, boolean keepSizeReport, |
| Logger logger, PathResolver resolver, MimeMappings mimeMappings, |
| boolean processDefaults) |
| { |
| if (!processDefaults) |
| { |
| return new OEMConfiguration(null, null); |
| } |
| |
| // expect args to have --file-specs because we need it to find app-specific-config.xml. |
| OEMUtil.init(logger, mimeMappings, null, resolver, null); |
| |
| try |
| { |
| ConfigurationBuffer cfgbuf = new ConfigurationBuffer(ApplicationCompilerConfiguration.class, |
| ApplicationCompilerConfiguration.getAliases()); |
| cfgbuf.setDefaultVar(Mxmlc.FILE_SPECS); |
| DefaultsConfigurator.loadDefaults(cfgbuf); |
| Object obj = Mxmlc.processConfiguration(ThreadLocalToolkit.getLocalizationManager(), |
| "oem", |
| args, |
| cfgbuf, |
| ApplicationCompilerConfiguration.class, |
| Mxmlc.FILE_SPECS); |
| |
| ApplicationCompilerConfiguration configuration = (ApplicationCompilerConfiguration) obj; |
| configuration.keepLinkReport(keepLinkReport); |
| configuration.keepSizeReport(keepSizeReport); |
| |
| return new OEMConfiguration(cfgbuf, configuration); |
| } |
| catch (ConfigurationException ex) |
| { |
| Mxmlc.processConfigurationException(ex, "oem"); |
| return null; |
| } |
| catch (IOException ex) |
| { |
| ThreadLocalToolkit.logError(ex.getMessage()); |
| return null; |
| } |
| catch (RuntimeException ex) |
| { |
| Class c; |
| try |
| { |
| c = Class.forName("flex.messaging.config.ConfigurationException"); |
| if (c.isInstance(ex)) |
| { |
| ThreadLocalToolkit.logError(ex.getMessage()); |
| } |
| } |
| catch (ClassNotFoundException ex2) |
| { |
| |
| } |
| return null; |
| } |
| } |
| |
| /** |
| * |
| * @param args |
| * @param logger |
| * @param mimeMappings |
| * @return |
| */ |
| public static final OEMConfiguration getLibraryConfiguration(String[] args, boolean keepLinkReport, |
| boolean keepSizeReport, Logger logger, PathResolver resolver, |
| MimeMappings mimeMappings) |
| { |
| return getLibraryConfiguration(args, keepLinkReport, keepSizeReport, logger, resolver, mimeMappings, true); |
| } |
| |
| /** |
| * |
| * @param args |
| * @param logger |
| * @param mimeMappings |
| * @param processDefaults |
| * @return |
| */ |
| public static final OEMConfiguration getLibraryConfiguration(String[] args, boolean keepLinkReport, |
| boolean keepSizeReport, Logger logger, |
| PathResolver resolver, MimeMappings mimeMappings, |
| boolean processDefaults) |
| { |
| if (!processDefaults) |
| { |
| return new OEMConfiguration(null, null); |
| } |
| |
| // expect no SWC inputs in args. |
| OEMUtil.init(logger, mimeMappings, null, resolver, null); |
| |
| try |
| { |
| ConfigurationBuffer cfgbuf = new ConfigurationBuffer(LibraryCompilerConfiguration.class, |
| LibraryCompilerConfiguration.getAliases()); |
| DefaultsConfigurator.loadOEMCompcDefaults( cfgbuf ); |
| Object obj = Mxmlc.processConfiguration(ThreadLocalToolkit.getLocalizationManager(), |
| "oem", |
| args, |
| cfgbuf, |
| LibraryCompilerConfiguration.class, |
| null); |
| |
| LibraryCompilerConfiguration configuration = (LibraryCompilerConfiguration) obj; |
| configuration.keepLinkReport(keepLinkReport); |
| configuration.keepSizeReport(keepSizeReport); |
| |
| return new OEMConfiguration(cfgbuf, configuration); |
| } |
| catch (ConfigurationException ex) |
| { |
| Mxmlc.processConfigurationException(ex, "oem"); |
| return null; |
| } |
| catch (IOException ex) |
| { |
| ThreadLocalToolkit.logError(ex.getMessage()); |
| return null; |
| } |
| catch (RuntimeException ex) |
| { |
| Class c; |
| try |
| { |
| c = Class.forName("flex.messaging.config.ConfigurationException"); |
| if (c.isInstance(ex)) |
| { |
| ThreadLocalToolkit.logError(ex.getMessage()); |
| } |
| } |
| catch (ClassNotFoundException ex2) |
| { |
| |
| } |
| return null; |
| } |
| } |
| |
| /** |
| * |
| * @param args |
| * @param logger |
| * @param mimeMappings |
| * @return |
| */ |
| public static final OEMConfiguration getLinkerConfiguration(String[] args, boolean keepLinkReport, boolean keepSizeReport, |
| Logger logger, MimeMappings mimeMappings, |
| PathResolver resolver, |
| flex2.compiler.common.Configuration c, |
| Set newLinkerOptions, Set<String> includes, Set<String> excludes) |
| { |
| OEMUtil.init(logger, mimeMappings, null, resolver, null); |
| |
| try |
| { |
| ConfigurationBuffer cfgbuf = new ConfigurationBuffer(LinkerConfiguration.class, |
| LinkerConfiguration.getAliases()); |
| |
| DefaultsConfigurator.loadDefaults(cfgbuf); |
| Object obj = Mxmlc.processConfiguration(ThreadLocalToolkit.getLocalizationManager(), |
| "oem", |
| args, |
| cfgbuf, |
| LinkerConfiguration.class, |
| null); |
| |
| LinkerConfiguration configuration = (LinkerConfiguration) obj; |
| configuration.setOriginalConfiguration(c, newLinkerOptions, includes, excludes); |
| configuration.keepLinkReport(keepLinkReport); |
| configuration.keepSizeReport(keepSizeReport); |
| |
| return new OEMConfiguration(cfgbuf, configuration); |
| } |
| catch (ConfigurationException ex) |
| { |
| Mxmlc.processConfigurationException(ex, "oem"); |
| return null; |
| } |
| catch (IOException ex) |
| { |
| ThreadLocalToolkit.logError(ex.getMessage()); |
| return null; |
| } |
| catch (RuntimeException ex) |
| { |
| Class cls; |
| try |
| { |
| cls = Class.forName("flex.messaging.config.ConfigurationException"); |
| if (cls.isInstance(ex)) |
| { |
| ThreadLocalToolkit.logError(ex.getMessage()); |
| } |
| } |
| catch (ClassNotFoundException ex2) |
| { |
| |
| } |
| return null; |
| } |
| } |
| |
| public static final ConfigurationBuffer getCommandLineConfigurationBuffer(Logger logger, PathResolver resolver, String[] args) |
| { |
| ConfigurationBuffer cfgbuf = null; |
| |
| try |
| { |
| OEMUtil.init(logger, null, null, resolver, null); |
| |
| cfgbuf = new ConfigurationBuffer(CommandLineConfiguration.class, CommandLineConfiguration.getAliases()); |
| SystemPropertyConfigurator.load( cfgbuf, "flex" ); |
| CommandLineConfigurator.parse( cfgbuf, null, args); |
| } |
| catch (ConfigurationException ex) |
| { |
| ThreadLocalToolkit.log(ex); |
| cfgbuf = null; |
| } |
| |
| return cfgbuf; |
| } |
| |
| public static final ConfigurationBuffer getCompcConfigurationBuffer(Logger logger, PathResolver resolver, String[] args) |
| { |
| ConfigurationBuffer cfgbuf = null; |
| |
| try |
| { |
| OEMUtil.init(logger, null, null, resolver, null); |
| |
| cfgbuf = new ConfigurationBuffer(CompcConfiguration.class, CompcConfiguration.getAliases()); |
| SystemPropertyConfigurator.load( cfgbuf, "flex" ); |
| CommandLineConfigurator.parse( cfgbuf, null, args); |
| } |
| catch (ConfigurationException ex) |
| { |
| ThreadLocalToolkit.log(ex); |
| cfgbuf = null; |
| } |
| |
| return cfgbuf; |
| } |
| |
| public static String[] trim(String[] args, ConfigurationBuffer cfgbuf, Set excludes) |
| { |
| List<Object[]> positions = cfgbuf.getPositions(); |
| List<Object> newArgs = new ArrayList<Object>(); |
| for (int i = 0, length = positions.size(); i < length; i++) |
| { |
| Object[] a = positions.get(i); |
| String var = (String) a[0]; |
| int iStart = ((Integer) a[1]).intValue(), iEnd = ((Integer) a[2]).intValue(); |
| if (!excludes.contains(var)) |
| { |
| for (int j = iStart; j < iEnd; j++) |
| { |
| newArgs.add(args[j]); |
| } |
| } |
| } |
| args = new String[newArgs.size()]; |
| newArgs.toArray(args); |
| return args; |
| } |
| |
| public static final Logger getLogger(Logger logger, List<Message> messages) |
| { |
| return new BuilderLogger(logger == null ? new OEMConsole() : logger, messages); |
| } |
| |
| public static final String formatConfigurationBuffer(ConfigurationBuffer cfgbuf) |
| { |
| return FileConfigurator.formatBuffer(cfgbuf, "flex-config", |
| OEMUtil.setupLocalizationManager(), "flex2.configuration"); |
| } |
| |
| /** |
| * |
| * @param configuration |
| * @return |
| */ |
| public static final Map getLicenseMap(ToolsConfiguration configuration) |
| { |
| return configuration.getLicensesConfiguration().getLicenseMap(); |
| } |
| |
| public static final void setGeneratedDirectory(CompilerConfiguration compilerConfig, File output) |
| { |
| if (compilerConfig.keepGeneratedActionScript()) |
| { |
| File canonical = FileUtils.canonicalFile( output ); |
| |
| if (canonical != null) |
| output = canonical; |
| |
| String parent = output.getParent(); |
| |
| String generated = null; |
| if (parent == null) |
| { |
| generated = new File( "generated" ).getAbsolutePath(); |
| } |
| else |
| { |
| generated = FileUtils.addPathComponents( parent, "generated", File.separatorChar ); |
| } |
| compilerConfig.setGeneratedDirectory( generated ); |
| new File( generated ).mkdirs(); |
| } |
| } |
| |
| /** |
| * Save the compiler units signature checksums to ApplicationData. |
| * These will be used by the next compilation to determine if we |
| * can do an incremental compiler or if a full recompilation is required. |
| * |
| * @param units - compilation units, may be null |
| * @param data - application data, may not be null |
| */ |
| public static void saveSignatureChecksums(List units, ApplicationData data, |
| flex2.compiler.common.Configuration config) |
| { |
| if (!config.isSwcChecksumEnabled()) |
| { |
| data.swcDefSignatureChecksums = null; |
| return; |
| } |
| |
| if (units != null) |
| { |
| data.swcDefSignatureChecksums = new HashMap<QName, Long>(); |
| for (Iterator iter = units.iterator(); iter.hasNext();) |
| { |
| CompilationUnit unit = (CompilationUnit)iter.next(); |
| Source source = unit == null ? null : unit.getSource(); |
| if (source != null && source.isSwcScriptOwner() && !source.isInternal()) |
| { |
| addSignatureChecksumToData(data, unit); |
| } |
| } |
| } |
| } |
| |
| /** |
| * @param swcContext context, may not be null |
| * @param data - application data, may not be null |
| */ |
| public static void saveSwcFileChecksums(CompilerSwcContext swcContext, ApplicationData data, |
| flex2.compiler.common.Configuration config) |
| { |
| if (!config.isSwcChecksumEnabled()) |
| { |
| data.swcFileChecksums = null; |
| return; |
| } |
| |
| data.swcFileChecksums = new HashMap<String, Long>(); |
| for (Iterator iter = swcContext.getFiles().entrySet().iterator(); iter.hasNext();) |
| { |
| Map.Entry entry = (Map.Entry)iter.next(); |
| String filename = (String)entry.getKey(); |
| VirtualFile file = (VirtualFile)entry.getValue(); |
| data.swcFileChecksums.put(filename, new Long(file.getLastModified())); |
| } |
| |
| for (VirtualFile themeStyleSheet : swcContext.getThemeStyleSheets()) |
| { |
| data.swcFileChecksums.put(themeStyleSheet.getName(), |
| new Long(themeStyleSheet.getLastModified())); |
| } |
| } |
| |
| /** |
| * Loop thru the saved signature checksums in the application data and compare them with |
| * the signature checksums in the swc context. |
| * |
| * @param data application data from a previous compile. May not be null. |
| * @param swcContext swc context |
| * @return true if all the signature checksums in application data match the checksums |
| * in the swc context. |
| */ |
| public static boolean isRecompilationNeeded(ApplicationData data, |
| CompilerSwcContext swcContext, |
| OEMConfiguration config) |
| { |
| int checksum = OEMUtil.calculateChecksum(data, swcContext, config); |
| |
| // if the checksum from last time and the current checksum do not match, |
| // then we need to recompile. |
| if (checksum != data.checksum) |
| { |
| if (Trace.swcChecksum) |
| { |
| Trace.trace("isRecompilationNeeded: calculated checksum differs from last checksum, recompile"); |
| } |
| data.checksum = checksum; |
| return true; |
| } |
| |
| // if we got here and swc checksums are disabled, then |
| // the checksums are equal and a recompilation is not needed. |
| // Otherwise continue on and compare the swc checksums. |
| if (!config.configuration.isSwcChecksumEnabled()) |
| { |
| if (Trace.swcChecksum) |
| { |
| Trace.trace("isRecompilationNeeded: checksums equal, swc-checksum disabled, incremental compile"); |
| } |
| return false; |
| } |
| |
| Map signatureChecksums = data.swcDefSignatureChecksums; |
| if (signatureChecksums == null) |
| { |
| if (Trace.swcChecksum) |
| { |
| Trace.trace("isRecompilationNeeded: checksums equal, signatureChecksums is null, incremental compile"); |
| } |
| } |
| else |
| { |
| for (Iterator iter = signatureChecksums.entrySet().iterator(); iter.hasNext();) |
| { |
| Map.Entry entry = (Map.Entry)iter.next(); |
| |
| // lookup definition in swc context |
| QName qName = (QName) entry.getKey(); |
| Long dataSignatureChecksum = (Long)entry.getValue(); |
| Long swcSignatureChecksum = swcContext.getChecksum(qName); |
| if (swcSignatureChecksum == null && qName != null) |
| { |
| Source source = swcContext.getSource(qName.getNamespace(), qName.getLocalPart()); |
| if (source != null) |
| { |
| swcSignatureChecksum = new Long(source.getLastModified()); |
| } |
| } |
| if (Trace.swcChecksum) |
| { |
| if (dataSignatureChecksum == null) |
| { |
| throw new IllegalStateException("dataSignatureChecksum should never be null"); |
| } |
| } |
| |
| if (dataSignatureChecksum != null && swcSignatureChecksum == null) |
| { |
| if (Trace.swcChecksum) |
| { |
| Trace.trace("isRecompilationNeeded: signature checksums not equal, recompile"); |
| Trace.trace("compare " + entry.getKey()); |
| Trace.trace("data = " + dataSignatureChecksum); |
| Trace.trace("swc = " + swcSignatureChecksum); |
| } |
| return true; |
| } |
| |
| if (dataSignatureChecksum != null) |
| { |
| if (dataSignatureChecksum.longValue() != swcSignatureChecksum.longValue()) |
| { |
| if (Trace.swcChecksum) |
| { |
| Trace.trace("isRecompilationNeeded: signature checksums not equal, recompile"); |
| Trace.trace("compare " + entry.getKey()); |
| Trace.trace("data = " + dataSignatureChecksum); |
| Trace.trace("swc = " + swcSignatureChecksum); |
| } |
| return true; |
| } |
| } |
| else { |
| // dataSignatureChecksum should never be null, but if it is then recompile. |
| return true; |
| } |
| } |
| } |
| |
| boolean result = !areSwcFileChecksumsEqual(data, swcContext); |
| |
| if (Trace.swcChecksum) |
| { |
| Trace.trace("isRecompilationNeeded: " + (result ? "recompile" : "incremental compile")); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Calculate the data checksum. |
| * |
| * @param data application data from a previous compile. If a recompilation is |
| * needed, data.checksum is updated with the new checksum. May not be null. |
| * @param swcContext swc context |
| * @return true if all the signature checksums in application data match the checksums |
| * in the swc context. |
| */ |
| public static int calculateChecksum(ApplicationData data, |
| CompilerSwcContext swcContext, |
| OEMConfiguration config) |
| { |
| int checksum = config.cfgbuf.checksum_ts(); |
| |
| // if swc checksums are disabled or there are no checksums to compare, then |
| // include the swc timestamp as part of the checksum. |
| if (!config.configuration.isSwcChecksumEnabled() || |
| data.swcDefSignatureChecksums == null || |
| data.swcDefSignatureChecksums.size() == 0) |
| { |
| checksum += swcContext.checksum(); |
| } |
| |
| return checksum; |
| } |
| |
| /** |
| * Add all top level definitions to ApplicationData |
| * @param swcDefSignatureChecksums |
| * @param unit |
| * @param signatureChecksum |
| */ |
| private static void addSignatureChecksumToData(ApplicationData data, CompilationUnit unit) |
| { |
| Long signatureChecksum = unit.getSignatureChecksum(); |
| if (signatureChecksum == null) |
| { |
| SwcScript script = (SwcScript) unit.getSource().getOwner(); |
| signatureChecksum = new Long(script.getLastModified()); |
| } |
| |
| if (data.swcDefSignatureChecksums != null) |
| { |
| for (Iterator iter = unit.topLevelDefinitions.iterator(); iter.hasNext();) |
| { |
| QName qname = (QName) iter.next(); |
| data.swcDefSignatureChecksums.put(qname, signatureChecksum); |
| } |
| } |
| } |
| |
| |
| /** |
| * Test if the files in the compiler swc context have changed since the last compile. |
| * |
| * @param data - application data, may not be null |
| * @param swcContext context, may not be null |
| * @return true it the swc files compiled with last time are the same as this time. |
| */ |
| private static boolean areSwcFileChecksumsEqual(ApplicationData data, |
| CompilerSwcContext swcContext) |
| { |
| if (data.swcFileChecksums == null) |
| { |
| if (Trace.swcChecksum) |
| { |
| Trace.trace("areSwcFileChecksumsEqual: no file checksum map, not equal"); |
| } |
| |
| return false; |
| } |
| |
| Map swcFiles = swcContext.getFiles(); |
| |
| for (VirtualFile themeStyleSheet : swcContext.getThemeStyleSheets()) |
| { |
| swcFiles.put(themeStyleSheet.getName(), themeStyleSheet); |
| } |
| |
| Set dataSet = data.swcFileChecksums.entrySet(); |
| |
| if (swcFiles.size() < dataSet.size()) |
| { |
| if (Trace.swcChecksum) |
| { |
| Trace.trace("areSwcFileChecksumsEqual: less files than before, not equal"); |
| } |
| |
| return false; |
| } |
| |
| for (Iterator iter = dataSet.iterator(); iter.hasNext();) |
| { |
| Map.Entry entry = (Map.Entry)iter.next(); |
| String filename = (String)entry.getKey(); |
| |
| // When we are reusing cached SWC's, the catalog.xml and |
| // library.swf are updated each time we save the |
| // SwcDynamicArchive, but we don't want to reload the SWC |
| // from disk, because all the compilation units |
| // represented by catalog.xml should be cached. If any of |
| // the cached CompilationUnit's becomes out of data, |
| // CompilerAPI.validateCompilationUnits() will handle |
| // removing the cached CompilationUnit, which will cause |
| // it to be reloaded from disk. |
| if (!filename.equals(Swc.CATALOG_XML) && |
| !filename.equals(Swc.LIBRARY_SWF)) |
| { |
| Long dataFileLastModified = (Long)entry.getValue(); |
| Long swcFileLastModified = null; |
| VirtualFile swcFile = (VirtualFile)swcFiles.get(filename); |
| if (swcFile != null) |
| { |
| swcFileLastModified = new Long(swcFile.getLastModified()); |
| } |
| |
| if (!dataFileLastModified.equals(swcFileLastModified)) |
| { |
| if (Trace.swcChecksum) |
| { |
| Trace.trace("areSwcFileChecksumsEqual: not equal"); |
| Trace.trace("filename = " + filename); |
| Trace.trace("last modified1 = " + dataFileLastModified); |
| Trace.trace("last modified2 = " + swcFileLastModified); |
| } |
| return false; |
| } |
| } |
| } |
| |
| if (Trace.swcChecksum) |
| { |
| Trace.trace("areSwcFileChecksumsEqual: equal"); |
| } |
| |
| return true; |
| } |
| } |
