| /* |
| * Copyright 2008 Google Inc. |
| * |
| * Licensed 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 com.google.gwt.dev; |
| |
| import com.google.gwt.core.ext.TreeLogger; |
| import com.google.gwt.core.ext.UnableToCompleteException; |
| import com.google.gwt.core.ext.linker.ArtifactSet; |
| import com.google.gwt.dev.CompileTaskRunner.CompileTask; |
| import com.google.gwt.dev.cfg.BindingProperty; |
| import com.google.gwt.dev.cfg.ConfigurationProperty; |
| import com.google.gwt.dev.cfg.ModuleDef; |
| import com.google.gwt.dev.cfg.ModuleDefLoader; |
| import com.google.gwt.dev.cfg.PropertyPermutations; |
| import com.google.gwt.dev.cfg.Rules; |
| import com.google.gwt.dev.cfg.StaticPropertyOracle; |
| import com.google.gwt.dev.javac.CompilationState; |
| import com.google.gwt.dev.javac.CompilationUnit; |
| import com.google.gwt.dev.javac.StandardGeneratorContext; |
| import com.google.gwt.dev.jdt.RebindOracle; |
| import com.google.gwt.dev.jdt.RebindPermutationOracle; |
| import com.google.gwt.dev.jjs.AbstractCompiler; |
| import com.google.gwt.dev.jjs.JJSOptions; |
| import com.google.gwt.dev.jjs.JJSOptionsImpl; |
| import com.google.gwt.dev.jjs.JavaScriptCompiler; |
| import com.google.gwt.dev.jjs.JsOutputOption; |
| import com.google.gwt.dev.jjs.UnifiedAst; |
| import com.google.gwt.dev.shell.CheckForUpdates; |
| import com.google.gwt.dev.shell.StandardRebindOracle; |
| import com.google.gwt.dev.shell.CheckForUpdates.UpdateResult; |
| import com.google.gwt.dev.util.Memory; |
| import com.google.gwt.dev.util.PerfLogger; |
| import com.google.gwt.dev.util.Util; |
| import com.google.gwt.dev.util.arg.ArgHandlerCompileReport; |
| import com.google.gwt.dev.util.arg.ArgHandlerDisableAggressiveOptimization; |
| import com.google.gwt.dev.util.arg.ArgHandlerDisableCastChecking; |
| import com.google.gwt.dev.util.arg.ArgHandlerDisableClassMetadata; |
| import com.google.gwt.dev.util.arg.ArgHandlerDisableRunAsync; |
| import com.google.gwt.dev.util.arg.ArgHandlerDisableUpdateCheck; |
| import com.google.gwt.dev.util.arg.ArgHandlerDraftCompile; |
| import com.google.gwt.dev.util.arg.ArgHandlerDumpSignatures; |
| import com.google.gwt.dev.util.arg.ArgHandlerEnableAssertions; |
| import com.google.gwt.dev.util.arg.ArgHandlerGenDir; |
| import com.google.gwt.dev.util.arg.ArgHandlerMaxPermsPerPrecompile; |
| import com.google.gwt.dev.util.arg.ArgHandlerScriptStyle; |
| import com.google.gwt.dev.util.arg.ArgHandlerSoyc; |
| import com.google.gwt.dev.util.arg.ArgHandlerSoycDetailed; |
| import com.google.gwt.dev.util.arg.ArgHandlerValidateOnlyFlag; |
| import com.google.gwt.dev.util.arg.OptionDisableUpdateCheck; |
| import com.google.gwt.dev.util.arg.OptionDumpSignatures; |
| import com.google.gwt.dev.util.arg.OptionGenDir; |
| import com.google.gwt.dev.util.arg.OptionMaxPermsPerPrecompile; |
| import com.google.gwt.dev.util.arg.OptionValidateOnly; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.Set; |
| import java.util.SortedMap; |
| import java.util.SortedSet; |
| import java.util.TreeMap; |
| import java.util.concurrent.FutureTask; |
| import java.util.jar.JarOutputStream; |
| import java.util.zip.ZipEntry; |
| |
| /** |
| * Performs the first phase of compilation, generating the set of permutations |
| * to compile, and a ready-to-compile AST. |
| */ |
| public class Precompile { |
| |
| /** |
| * The set of options for the precompiler. |
| */ |
| public interface PrecompileOptions extends JJSOptions, CompileTaskOptions, |
| OptionGenDir, OptionValidateOnly, OptionDisableUpdateCheck, |
| OptionDumpSignatures, OptionMaxPermsPerPrecompile { |
| } |
| |
| static class ArgProcessor extends CompileArgProcessor { |
| public ArgProcessor(PrecompileOptions options) { |
| super(options); |
| registerHandler(new ArgHandlerGenDir(options)); |
| registerHandler(new ArgHandlerScriptStyle(options)); |
| registerHandler(new ArgHandlerEnableAssertions(options)); |
| registerHandler(new ArgHandlerDisableAggressiveOptimization(options)); |
| registerHandler(new ArgHandlerDisableClassMetadata(options)); |
| registerHandler(new ArgHandlerDisableCastChecking(options)); |
| registerHandler(new ArgHandlerValidateOnlyFlag(options)); |
| registerHandler(new ArgHandlerDisableRunAsync(options)); |
| registerHandler(new ArgHandlerDraftCompile(options)); |
| registerHandler(new ArgHandlerDisableUpdateCheck(options)); |
| registerHandler(new ArgHandlerDumpSignatures(options)); |
| registerHandler(new ArgHandlerMaxPermsPerPrecompile(options)); |
| registerHandler(new ArgHandlerCompileReport(options)); |
| registerHandler(new ArgHandlerSoyc(options)); |
| registerHandler(new ArgHandlerSoycDetailed(options)); |
| } |
| |
| @Override |
| protected String getName() { |
| return Precompile.class.getName(); |
| } |
| } |
| |
| static class PrecompileOptionsImpl extends CompileTaskOptionsImpl implements |
| PrecompileOptions { |
| private boolean disableUpdateCheck; |
| private File dumpFile; |
| private File genDir; |
| private final JJSOptionsImpl jjsOptions = new JJSOptionsImpl(); |
| private int maxPermsPerPrecompile; |
| private boolean validateOnly; |
| |
| public PrecompileOptionsImpl() { |
| } |
| |
| public PrecompileOptionsImpl(PrecompileOptions other) { |
| copyFrom(other); |
| } |
| |
| public void copyFrom(PrecompileOptions other) { |
| super.copyFrom(other); |
| |
| jjsOptions.copyFrom(other); |
| |
| setDisableUpdateCheck(other.isUpdateCheckDisabled()); |
| setDumpSignatureFile(other.getDumpSignatureFile()); |
| setGenDir(other.getGenDir()); |
| setMaxPermsPerPrecompile(other.getMaxPermsPerPrecompile()); |
| setValidateOnly(other.isValidateOnly()); |
| } |
| |
| public File getDumpSignatureFile() { |
| return dumpFile; |
| } |
| |
| public File getGenDir() { |
| return genDir; |
| } |
| |
| public int getMaxPermsPerPrecompile() { |
| return maxPermsPerPrecompile; |
| } |
| |
| public JsOutputOption getOutput() { |
| return jjsOptions.getOutput(); |
| } |
| |
| public boolean isAggressivelyOptimize() { |
| return jjsOptions.isAggressivelyOptimize(); |
| } |
| |
| public boolean isCastCheckingDisabled() { |
| return jjsOptions.isCastCheckingDisabled(); |
| } |
| |
| public boolean isClassMetadataDisabled() { |
| return jjsOptions.isClassMetadataDisabled(); |
| } |
| |
| public boolean isDraftCompile() { |
| return jjsOptions.isDraftCompile(); |
| } |
| |
| public boolean isEnableAssertions() { |
| return jjsOptions.isEnableAssertions(); |
| } |
| |
| public boolean isOptimizePrecompile() { |
| return jjsOptions.isOptimizePrecompile(); |
| } |
| |
| public boolean isRunAsyncEnabled() { |
| return jjsOptions.isRunAsyncEnabled(); |
| } |
| |
| public boolean isSoycEnabled() { |
| return jjsOptions.isSoycEnabled(); |
| } |
| |
| public boolean isSoycExtra() { |
| return jjsOptions.isSoycExtra(); |
| } |
| |
| public boolean isUpdateCheckDisabled() { |
| return disableUpdateCheck; |
| } |
| |
| public boolean isValidateOnly() { |
| return validateOnly; |
| } |
| |
| public void setAggressivelyOptimize(boolean aggressivelyOptimize) { |
| jjsOptions.setAggressivelyOptimize(aggressivelyOptimize); |
| } |
| |
| public void setCastCheckingDisabled(boolean disabled) { |
| jjsOptions.setCastCheckingDisabled(disabled); |
| } |
| |
| public void setClassMetadataDisabled(boolean disabled) { |
| jjsOptions.setClassMetadataDisabled(disabled); |
| } |
| |
| public void setDisableUpdateCheck(boolean disabled) { |
| disableUpdateCheck = disabled; |
| } |
| |
| public void setDraftCompile(boolean draft) { |
| jjsOptions.setDraftCompile(draft); |
| } |
| |
| public void setDumpSignatureFile(File dumpFile) { |
| this.dumpFile = dumpFile; |
| } |
| |
| public void setEnableAssertions(boolean enableAssertions) { |
| jjsOptions.setEnableAssertions(enableAssertions); |
| } |
| |
| public void setGenDir(File genDir) { |
| this.genDir = genDir; |
| } |
| |
| public void setMaxPermsPerPrecompile(int maxPermsPerPrecompile) { |
| this.maxPermsPerPrecompile = maxPermsPerPrecompile; |
| } |
| |
| public void setOptimizePrecompile(boolean optimize) { |
| jjsOptions.setOptimizePrecompile(optimize); |
| } |
| |
| public void setOutput(JsOutputOption output) { |
| jjsOptions.setOutput(output); |
| } |
| |
| public void setRunAsyncEnabled(boolean enabled) { |
| jjsOptions.setRunAsyncEnabled(enabled); |
| } |
| |
| public void setSoycEnabled(boolean enabled) { |
| jjsOptions.setSoycEnabled(enabled); |
| } |
| |
| public void setSoycExtra(boolean soycExtra) { |
| jjsOptions.setSoycExtra(soycExtra); |
| } |
| |
| public void setValidateOnly(boolean validateOnly) { |
| this.validateOnly = validateOnly; |
| } |
| } |
| |
| private static class DistillerRebindPermutationOracle implements |
| RebindPermutationOracle { |
| |
| private CompilationState compilationState; |
| private StandardGeneratorContext generatorContext; |
| private final Permutation[] permutations; |
| private final StaticPropertyOracle[] propertyOracles; |
| private final RebindOracle[] rebindOracles; |
| |
| public DistillerRebindPermutationOracle(ModuleDef module, |
| CompilationState compilationState, ArtifactSet generatorArtifacts, |
| PropertyPermutations perms, File genDir, File generatorResourcesDir) { |
| this.compilationState = compilationState; |
| permutations = new Permutation[perms.size()]; |
| propertyOracles = new StaticPropertyOracle[perms.size()]; |
| rebindOracles = new RebindOracle[perms.size()]; |
| generatorContext = new StandardGeneratorContext(compilationState, module, |
| genDir, generatorResourcesDir, generatorArtifacts); |
| BindingProperty[] orderedProps = perms.getOrderedProperties(); |
| SortedSet<ConfigurationProperty> configPropSet = module.getProperties().getConfigurationProperties(); |
| ConfigurationProperty[] configProps = configPropSet.toArray(new ConfigurationProperty[configPropSet.size()]); |
| Rules rules = module.getRules(); |
| for (int i = 0; i < rebindOracles.length; ++i) { |
| String[] orderedPropValues = perms.getOrderedPropertyValues(i); |
| propertyOracles[i] = new StaticPropertyOracle(orderedProps, |
| orderedPropValues, configProps); |
| rebindOracles[i] = new StandardRebindOracle(propertyOracles[i], rules, |
| generatorContext); |
| permutations[i] = new Permutation(i, propertyOracles[i]); |
| } |
| } |
| |
| public void clear() { |
| generatorContext.clear(); |
| compilationState = null; |
| generatorContext = null; |
| } |
| |
| public String[] getAllPossibleRebindAnswers(TreeLogger logger, |
| String requestTypeName) throws UnableToCompleteException { |
| |
| String msg = "Computing all possible rebind results for '" |
| + requestTypeName + "'"; |
| logger = logger.branch(TreeLogger.DEBUG, msg, null); |
| |
| Set<String> answers = new HashSet<String>(); |
| |
| for (int i = 0; i < getPermuationCount(); ++i) { |
| String resultTypeName = rebindOracles[i].rebind(logger, requestTypeName); |
| answers.add(resultTypeName); |
| // Record the correct answer into each permutation. |
| permutations[i].putRebindAnswer(requestTypeName, resultTypeName); |
| } |
| return Util.toArray(String.class, answers); |
| } |
| |
| public CompilationState getCompilationState() { |
| return compilationState; |
| } |
| |
| public StandardGeneratorContext getGeneratorContext() { |
| return generatorContext; |
| } |
| |
| public int getPermuationCount() { |
| return rebindOracles.length; |
| } |
| |
| public Permutation[] getPermutations() { |
| return permutations; |
| } |
| |
| public StaticPropertyOracle getPropertyOracle(int permNumber) { |
| return propertyOracles[permNumber]; |
| } |
| |
| public RebindOracle getRebindOracle(int permNumber) { |
| return rebindOracles[permNumber]; |
| } |
| } |
| |
| /** |
| * The file name for the result of Precompile. |
| */ |
| public static final String PRECOMPILE_FILENAME = "precompilation.ser"; |
| |
| static final String PERM_COUNT_FILENAME = "permCount.txt"; |
| |
| /** |
| * Performs a command-line precompile. |
| */ |
| public static void main(String[] args) { |
| Memory.initialize(); |
| if (System.getProperty("gwt.jjs.dumpAst") != null) { |
| System.out.println("Will dump AST to: " |
| + System.getProperty("gwt.jjs.dumpAst")); |
| } |
| |
| /* |
| * NOTE: main always exits with a call to System.exit to terminate any |
| * non-daemon threads that were started in Generators. Typically, this is to |
| * shutdown AWT related threads, since the contract for their termination is |
| * still implementation-dependent. |
| */ |
| final PrecompileOptions options = new PrecompileOptionsImpl(); |
| if (new ArgProcessor(options).processArgs(args)) { |
| CompileTask task = new CompileTask() { |
| public boolean run(TreeLogger logger) throws UnableToCompleteException { |
| FutureTask<UpdateResult> updater = null; |
| if (!options.isUpdateCheckDisabled()) { |
| updater = CheckForUpdates.checkForUpdatesInBackgroundThread(logger, |
| CheckForUpdates.ONE_DAY); |
| } |
| boolean success = new Precompile(options).run(logger); |
| if (success) { |
| CheckForUpdates.logUpdateAvailable(logger, updater); |
| } |
| return success; |
| } |
| }; |
| if (CompileTaskRunner.runWithAppropriateLogger(options, task)) { |
| // Exit w/ success code. |
| System.exit(0); |
| } |
| } |
| // Exit w/ non-success code. |
| System.exit(1); |
| } |
| |
| /** |
| * Precompiles the given module. |
| * |
| * @param logger a logger to use |
| * @param jjsOptions a set of compiler options |
| * @param module the module to compile |
| * @param genDir optional directory to dump generated source, may be |
| * <code>null</code> |
| * @param generatorResourcesDir required directory to dump generator resources |
| * @return the precompilation |
| */ |
| public static Precompilation precompile(TreeLogger logger, |
| JJSOptions jjsOptions, ModuleDef module, File genDir, |
| File generatorResourcesDir, File dumpSignatureFile) { |
| PropertyPermutations allPermutations = new PropertyPermutations( |
| module.getProperties()); |
| return precompile(logger, jjsOptions, module, 0, allPermutations, genDir, |
| generatorResourcesDir, dumpSignatureFile); |
| } |
| |
| /** |
| * Validates the given module can be compiled. |
| * |
| * @param logger a logger to use |
| * @param jjsOptions a set of compiler options |
| * @param module the module to compile |
| * @param genDir optional directory to dump generated source, may be |
| * <code>null</code> |
| * @param generatorResourcesDir required directory to dump generator resources |
| */ |
| public static boolean validate(TreeLogger logger, JJSOptions jjsOptions, |
| ModuleDef module, File genDir, File generatorResourcesDir, |
| File dumpSignatureFile) { |
| try { |
| CompilationState compilationState = module.getCompilationState(logger); |
| if (dumpSignatureFile != null) { |
| // Dump early to avoid generated types. |
| SignatureDumper.dumpSignatures(logger, |
| compilationState.getTypeOracle(), dumpSignatureFile); |
| } |
| |
| String[] declEntryPts = module.getEntryPointTypeNames(); |
| String[] additionalRootTypes = null; |
| if (declEntryPts.length == 0) { |
| // No declared entry points, just validate all visible classes. |
| Collection<CompilationUnit> compilationUnits = compilationState.getCompilationUnits(); |
| additionalRootTypes = new String[compilationUnits.size()]; |
| int i = 0; |
| for (CompilationUnit unit : compilationUnits) { |
| additionalRootTypes[i++] = unit.getTypeName(); |
| } |
| } |
| |
| ArtifactSet generatorArtifacts = new ArtifactSet(); |
| DistillerRebindPermutationOracle rpo = new DistillerRebindPermutationOracle( |
| module, compilationState, generatorArtifacts, |
| new PropertyPermutations(module.getProperties()), genDir, |
| generatorResourcesDir); |
| // Allow GC later. |
| compilationState = null; |
| if (dumpSignatureFile != null) { |
| // Dump early to avoid generated types. |
| SignatureDumper.dumpSignatures(logger, |
| compilationState.getTypeOracle(), dumpSignatureFile); |
| } |
| // Never optimize on a validation run. |
| jjsOptions.setOptimizePrecompile(false); |
| getCompiler(module).precompile(logger, module, rpo, declEntryPts, |
| additionalRootTypes, jjsOptions, true); |
| return true; |
| } catch (UnableToCompleteException e) { |
| // Already logged. |
| return false; |
| } |
| } |
| |
| private static AbstractCompiler getCompiler(ModuleDef module) { |
| ConfigurationProperty compilerClassProp = module.getProperties().createConfiguration( |
| "x.compiler.class", false); |
| String compilerClassName = compilerClassProp.getValue(); |
| if (compilerClassName == null || compilerClassName.length() == 0) { |
| return new JavaScriptCompiler(); |
| } |
| Throwable caught; |
| try { |
| Class<?> compilerClass = Class.forName(compilerClassName); |
| return (AbstractCompiler) compilerClass.newInstance(); |
| } catch (ClassNotFoundException e) { |
| caught = e; |
| } catch (InstantiationException e) { |
| caught = e; |
| } catch (IllegalAccessException e) { |
| caught = e; |
| } |
| throw new RuntimeException("Unable to instantiate compiler class '" |
| + compilerClassName + "'", caught); |
| } |
| |
| private static Precompilation precompile(TreeLogger logger, |
| JJSOptions jjsOptions, ModuleDef module, int permutationBase, |
| PropertyPermutations allPermutations, File genDir, |
| File generatorResourcesDir, File dumpSignatureFile) { |
| |
| try { |
| CompilationState compilationState = module.getCompilationState(logger); |
| if (dumpSignatureFile != null) { |
| // Dump early to avoid generated types. |
| SignatureDumper.dumpSignatures(logger, |
| compilationState.getTypeOracle(), dumpSignatureFile); |
| } |
| |
| String[] declEntryPts = module.getEntryPointTypeNames(); |
| if (declEntryPts.length == 0) { |
| logger.log(TreeLogger.ERROR, "Module has no entry points defined", null); |
| throw new UnableToCompleteException(); |
| } |
| |
| ArtifactSet generatedArtifacts = new ArtifactSet(); |
| DistillerRebindPermutationOracle rpo = new DistillerRebindPermutationOracle( |
| module, compilationState, generatedArtifacts, allPermutations, |
| genDir, generatorResourcesDir); |
| // Allow GC later. |
| compilationState = null; |
| PerfLogger.start("Precompile"); |
| UnifiedAst unifiedAst = getCompiler(module).precompile(logger, |
| module, rpo, declEntryPts, null, jjsOptions, |
| rpo.getPermuationCount() == 1); |
| PerfLogger.end(); |
| |
| // Merge all identical permutations together. |
| Permutation[] permutations = rpo.getPermutations(); |
| // Sort the permutations by an ordered key to ensure determinism. |
| SortedMap<String, Permutation> merged = new TreeMap<String, Permutation>(); |
| SortedSet<String> liveRebindRequests = unifiedAst.getRebindRequests(); |
| for (Permutation permutation : permutations) { |
| // Construct a key from the stringified map of live rebind answers. |
| SortedMap<String, String> rebindAnswers = new TreeMap<String, String>( |
| permutation.getRebindAnswers()); |
| rebindAnswers.keySet().retainAll(liveRebindRequests); |
| String key = rebindAnswers.toString(); |
| if (merged.containsKey(key)) { |
| Permutation existing = merged.get(key); |
| existing.mergeFrom(permutation, liveRebindRequests); |
| } else { |
| merged.put(key, permutation); |
| } |
| } |
| return new Precompilation(unifiedAst, merged.values(), permutationBase, |
| generatedArtifacts); |
| } catch (UnableToCompleteException e) { |
| // We intentionally don't pass in the exception here since the real |
| // cause has been logged. |
| return null; |
| } |
| } |
| |
| private final PrecompileOptionsImpl options; |
| |
| public Precompile(PrecompileOptions options) { |
| this.options = new PrecompileOptionsImpl(options); |
| } |
| |
| public boolean run(TreeLogger logger) throws UnableToCompleteException { |
| // Avoid early optimizations since permutation compiles will run separately. |
| options.setOptimizePrecompile(false); |
| |
| for (String moduleName : options.getModuleNames()) { |
| File compilerWorkDir = options.getCompilerWorkDir(moduleName); |
| Util.recursiveDelete(compilerWorkDir, true); |
| // No need to check mkdirs result because an IOException will occur anyway |
| compilerWorkDir.mkdirs(); |
| |
| JarOutputStream precompilationJar; |
| try { |
| precompilationJar = new JarOutputStream(new FileOutputStream(new File( |
| compilerWorkDir, PRECOMPILE_FILENAME))); |
| } catch (IOException e) { |
| logger.log(TreeLogger.ERROR, "Could not create " + PRECOMPILE_FILENAME, |
| e); |
| return false; |
| } |
| |
| ModuleDef module = ModuleDefLoader.loadFromClassPath(logger, moduleName); |
| |
| // TODO: All JDT checks now before even building TypeOracle? |
| module.getCompilationState(logger); |
| |
| if (options.isValidateOnly()) { |
| TreeLogger branch = logger.branch(TreeLogger.INFO, |
| "Validating compilation " + module.getName()); |
| if (!validate(branch, options, module, options.getGenDir(), |
| compilerWorkDir, options.getDumpSignatureFile())) { |
| branch.log(TreeLogger.ERROR, "Validation failed"); |
| return false; |
| } |
| branch.log(TreeLogger.INFO, "Validation succeeded"); |
| } else { |
| TreeLogger branch = logger.branch(TreeLogger.INFO, |
| "Precompiling module " + module.getName()); |
| PropertyPermutations allPermutations = new PropertyPermutations( |
| module.getProperties()); |
| int potentialPermutations = allPermutations.size(); |
| int permutationsPerIteration = options.getMaxPermsPerPrecompile(); |
| |
| if (permutationsPerIteration <= 0) { |
| permutationsPerIteration = potentialPermutations; |
| } |
| /* |
| * The potential number of permutations to precompile >= the actual |
| * number of permutations that end up being precompiled, because some of |
| * the permutations might collapse due to identical rebind results. So |
| * we have to track these two counts and ids separately. |
| */ |
| int actualPermutations = 0; |
| for (int potentialFirstPerm = 0; potentialFirstPerm < potentialPermutations; potentialFirstPerm += permutationsPerIteration) { |
| int numPermsToPrecompile = Math.min(potentialPermutations |
| - potentialFirstPerm, permutationsPerIteration); |
| |
| // Select only the range of property permutations that we want |
| PropertyPermutations localPermutations = new PropertyPermutations( |
| allPermutations, potentialFirstPerm, numPermsToPrecompile); |
| |
| Precompilation precompilation = precompile(branch, options, module, |
| actualPermutations, localPermutations, options.getGenDir(), |
| compilerWorkDir, options.getDumpSignatureFile()); |
| if (precompilation == null) { |
| branch.log(TreeLogger.ERROR, "Precompilation failed"); |
| return false; |
| } |
| int actualNumPermsPrecompiled = precompilation.getPermutations().length; |
| String precompilationFilename = PrecompilationFile.fileNameForPermutations( |
| actualPermutations, actualNumPermsPrecompiled); |
| try { |
| precompilationJar.putNextEntry(new ZipEntry(precompilationFilename)); |
| Util.writeObjectToStream(precompilationJar, precompilation); |
| } catch (IOException e) { |
| branch.log(TreeLogger.ERROR, |
| "Failed to write a precompilation result", e); |
| return false; |
| } |
| |
| actualPermutations += actualNumPermsPrecompiled; |
| branch.log(TreeLogger.DEBUG, "Compiled " + actualNumPermsPrecompiled |
| + " permutations starting from " + potentialFirstPerm); |
| } |
| |
| try { |
| precompilationJar.close(); |
| } catch (IOException e) { |
| branch.log(TreeLogger.ERROR, "Failed to finalize " |
| + PRECOMPILE_FILENAME, e); |
| return false; |
| } |
| |
| Util.writeStringAsFile(branch, new File(compilerWorkDir, |
| PERM_COUNT_FILENAME), String.valueOf(actualPermutations)); |
| branch.log(TreeLogger.INFO, |
| "Precompilation succeeded, number of permutations: " |
| + actualPermutations); |
| } |
| } |
| return true; |
| } |
| } |
