/*
* Copyright 2010 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.impl.StandardLinkerContext;
import com.google.gwt.dev.CompileTaskRunner.CompileTask;
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.shell.CheckForUpdates;
import com.google.gwt.dev.shell.CheckForUpdates.UpdateResult;
import com.google.gwt.dev.util.Memory;
import com.google.gwt.dev.util.Util;
import com.google.gwt.dev.util.arg.ArgHandlerPerm;
import com.google.gwt.dev.util.arg.OptionPerm;
import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;
import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event;
import java.io.File;
import java.util.List;
import java.util.concurrent.FutureTask;
/**
* Creates a ready-to-compile AST for a single permutation.
*
* Also collapses similar permutations and builds them together.
*/
public class PrecompileOnePerm {
/**
* The set of options for the precompiler.
*/
public interface PrecompileOnePermOptions extends
PrecompileTaskOptions, OptionPerm {
}
static class ArgProcessor extends PrecompileTaskArgProcessor {
public ArgProcessor(PrecompileOnePermOptions options) {
super(options);
registerHandler(new ArgHandlerPerm(options));
}
@Override
protected String getName() {
return PrecompileOnePerm.class.getName();
}
}
@SuppressWarnings("serial")
static class PrecompileOnePermOptionsImpl extends
PrecompileTaskOptionsImpl implements PrecompileOnePermOptions {
int permToCompile = -1;
public PrecompileOnePermOptionsImpl() {
}
public PrecompileOnePermOptionsImpl(PrecompileOnePermOptions other) {
copyFrom(other);
}
public void copyFrom(PrecompileOnePermOptions other) {
super.copyFrom(other);
setPermToCompile(other.getPermToCompile());
}
@Override
public int getPermToCompile() {
return permToCompile;
}
@Override
public void setPermToCompile(int permToCompile) {
this.permToCompile = permToCompile;
}
}
/**
* Performs a command-line precompile.
*/
public static void main(String[] args) {
Memory.initialize();
SpeedTracerLogger.init();
Event precompileEvent = SpeedTracerLogger.start(CompilerEventType.PRECOMPILE);
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 PrecompileOnePermOptions options = new PrecompileOnePermOptionsImpl();
boolean success = false;
if (new ArgProcessor(options).processArgs(args)) {
CompileTask task = new CompileTask() {
@Override
public boolean run(TreeLogger logger) throws UnableToCompleteException {
FutureTask<UpdateResult> updater = null;
if (!options.isUpdateCheckDisabled()) {
updater = CheckForUpdates.checkForUpdatesInBackgroundThread(logger,
CheckForUpdates.ONE_DAY);
}
boolean success = new PrecompileOnePerm(options).run(logger);
if (success) {
CheckForUpdates.logUpdateAvailable(logger, updater);
}
return success;
}
};
if (CompileTaskRunner.runWithAppropriateLogger(options, task)) {
// Exit w/ success code.
success = true;
}
}
precompileEvent.end();
System.exit(success ? 0 : 1);
}
/**
* Returns a filename for the serialized AST when precompile is performed
* separately on a per-permutation basis.
*/
static String getPrecompileFilename(int permutationBase) {
return Precompile.PRECOMPILE_FILENAME_PREFIX + "-" + permutationBase
+ Precompile.PRECOMPILE_FILENAME_SUFFIX;
}
private static boolean validateOptions(TreeLogger logger, PrecompileOnePermOptions options) {
// Fatal Errors
if (options.getModuleNames().size() != 1) {
logger.log(TreeLogger.ERROR, "Expected a single module name.");
return false;
}
if (options.getPermToCompile() < 0) {
logger.log(TreeLogger.ERROR,
"Expected argument -perm to specify the permutation to compile.");
return false;
}
// Warnings
if (!options.isEnabledGeneratingOnShards()) {
logger.log(TreeLogger.WARN,
"-XdisableGeneratingOnShards has no effect in PrecompileOnePerm");
}
if (options.getMaxPermsPerPrecompile() != -1) {
logger.log(TreeLogger.WARN,
"-XmaxPermsPerPrecompile has no effect in PrecompileOnePerm");
}
return true;
}
private final PrecompileOnePermOptionsImpl options;
private CompilerContext compilerContext;
private final CompilerContext.Builder compilerContextBuilder = new CompilerContext.Builder();
public PrecompileOnePerm(PrecompileOnePermOptions options) {
this.options = new PrecompileOnePermOptionsImpl(options);
compilerContext = compilerContextBuilder.options(options).build();
}
public boolean run(TreeLogger logger) throws UnableToCompleteException {
if (!validateOptions(logger, options)) {
return false;
}
// Avoid early optimizations since permutation compiles will run separately.
options.setOptimizePrecompile(false);
List<String> moduleNames = options.getModuleNames();
int permToRun = options.getPermToCompile();
String moduleName = moduleNames.get(0);
File compilerWorkDir = options.getCompilerWorkDir(moduleName);
ModuleDef module = ModuleDefLoader.loadFromClassPath(logger, compilerContext, moduleName);
compilerContext = compilerContextBuilder.module(module).build();
StandardLinkerContext linkerContext = new StandardLinkerContext(
TreeLogger.NULL, module, compilerContext.getPublicResourceOracle(), options.getOutput());
if (!linkerContext.allLinkersAreShardable()) {
logger.log(TreeLogger.ERROR,
"This compilation mode requires all linkers to be shardable.");
return false;
}
PrecompileTaskOptions optionsFileData = AnalyzeModule.readAnalyzeModuleOptionsFile(
logger, compilerWorkDir);
if (optionsFileData == null) {
logger.log(TreeLogger.ERROR, "Couldn't find "
+ AnalyzeModule.OPTIONS_FILENAME + " in " + compilerWorkDir);
return false;
}
logger.log(TreeLogger.INFO, "Precompiling only specified permutations");
if (options.isValidateOnly()) {
TreeLogger branch = logger.branch(TreeLogger.INFO,
"Validating compilation " + module.getName());
if (!Precompile.validate(branch, compilerContext)) {
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());
if (!precompilePermutation(logger, compilerWorkDir, module, branch,
permToRun)) {
branch.log(TreeLogger.ERROR, "Precompile failed");
return false;
}
}
return true;
}
private boolean precompilePermutation(TreeLogger logger,
File compilerWorkDir, ModuleDef module, TreeLogger branch, int permId)
throws UnableToCompleteException {
// Only precompile specified permutations
List<PropertyPermutations> collapsedPermutations =
Precompile.getCollapsedPermutations(module);
PropertyPermutations onePerm = collapsedPermutations.get(permId);
Precompilation precompilation = Precompile.precompile(branch, compilerContext, permId, onePerm);
if (precompilation == null) {
branch.log(TreeLogger.ERROR, "Precompilation failed");
return false;
}
// TODO: precompile should do this after we get the parameter passing refactored.
if (!options.shouldSaveSource()) {
precompilation.removeSourceArtifacts(logger);
}
File precompilationFile = new File(compilerWorkDir,
getPrecompileFilename(permId));
Util.writeObjectAsFile(logger, precompilationFile, precompilation);
if (branch.isLoggable(TreeLogger.INFO)) {
branch.log(TreeLogger.INFO, "Precompilation succeeded for permutation "
+ permId);
}
return true;
}
}