/*
* 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.ModuleDef;
import com.google.gwt.dev.cfg.ModuleDefLoader;
import com.google.gwt.dev.jjs.JJSOptions;
import com.google.gwt.dev.jjs.PermutationResult;
import com.google.gwt.dev.shell.CheckForUpdates;
import com.google.gwt.dev.shell.CheckForUpdates.UpdateResult;
import com.google.gwt.dev.util.FileBackedObject;
import com.google.gwt.dev.util.Util;
import com.google.gwt.dev.util.arg.ArgHandlerLocalWorkers;
import com.google.gwt.dev.util.arg.ArgHandlerOutDir;
import com.google.gwt.dev.util.arg.ArgHandlerWorkDirOptional;
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 com.google.gwt.util.tools.ToolBase;
import com.google.gwt.util.tools.Utility;
import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.FutureTask;
/**
* The main executable entry point for the GWT Java to JavaScript compiler.
*
* @deprecated Use {@link Compiler} instead
*/
@Deprecated
public class GWTCompiler {
static final class ArgProcessor extends PrecompileTaskArgProcessor {
public ArgProcessor(LegacyCompilerOptions options) {
super(options);
registerHandler(new ArgHandlerOutDir(options));
// Override the ArgHandlerWorkDirRequired in the super class.
registerHandler(new ArgHandlerWorkDirOptional(options));
registerHandler(new ArgHandlerLocalWorkers(options));
}
@Override
protected String getName() {
return GWTCompiler.class.getName();
}
}
/**
* Simple implementation of {@link LegacyCompilerOptions}.
*/
public static class GWTCompilerOptionsImpl extends PrecompileTaskOptionsImpl
implements LegacyCompilerOptions {
private int localWorkers;
private File outDir;
public GWTCompilerOptionsImpl() {
}
public GWTCompilerOptionsImpl(LegacyCompilerOptions other) {
copyFrom(other);
}
public void copyFrom(LegacyCompilerOptions other) {
super.copyFrom(other);
setLocalWorkers(other.getLocalWorkers());
setOutDir(other.getOutDir());
}
@Override
public int getLocalWorkers() {
return localWorkers;
}
@Override
public File getOutDir() {
return outDir;
}
@Override
public void setLocalWorkers(int localWorkers) {
this.localWorkers = localWorkers;
}
@Override
public void setOutDir(File outDir) {
this.outDir = outDir;
}
}
public static void main(String[] args) {
ToolBase.legacyWarn(GWTCompiler.class, Compiler.class);
SpeedTracerLogger.init();
Event compileEvent = SpeedTracerLogger.start(CompilerEventType.COMPILE);
/*
* 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 LegacyCompilerOptions options = new GWTCompilerOptionsImpl();
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 GWTCompiler(options).run(logger);
if (success) {
CheckForUpdates.logUpdateAvailable(logger, updater);
}
return success;
}
};
if (CompileTaskRunner.runWithAppropriateLogger(options, task)) {
// Exit w/ success code.
success = true;
}
}
compileEvent.end();
// Exit w/ non-success code.
System.exit(success ? 0 : 1);
}
private final GWTCompilerOptionsImpl options;
public GWTCompiler(LegacyCompilerOptions options) {
this.options = new GWTCompilerOptionsImpl(options);
}
/**
* Compiles the set of modules specified in the options.
*/
public boolean run(TreeLogger logger) throws UnableToCompleteException {
ModuleDef[] modules = new ModuleDef[options.getModuleNames().size()];
int i = 0;
for (String moduleName : options.getModuleNames()) {
modules[i++] = ModuleDefLoader.loadFromClassPath(logger, moduleName, true);
}
return run(logger, modules);
}
/**
* Compiles a specific set of modules.
*/
public boolean run(TreeLogger logger, ModuleDef... modules)
throws UnableToCompleteException {
Event compileEvent = SpeedTracerLogger.start(CompilerEventType.COMPILE);
boolean tempWorkDir = false;
try {
if (options.getWorkDir() == null) {
options.setWorkDir(Utility.makeTemporaryDirectory(null, "gwtc"));
tempWorkDir = true;
}
for (ModuleDef module : modules) {
String moduleName = module.getName();
if (options.isValidateOnly()) {
if (!Precompile.validate(logger, options, module, options.getGenDir())) {
return false;
}
} else {
long compileStart = System.currentTimeMillis();
logger = logger.branch(TreeLogger.INFO, "Compiling module "
+ moduleName);
// Optimize early since permutation compiles will run in process.
options.setOptimizePrecompile(true);
Precompilation precompilation = Precompile.precompile(logger,
options, module, options.getGenDir());
if (precompilation == null) {
return false;
}
Permutation[] allPerms = precompilation.getPermutations();
List<FileBackedObject<PermutationResult>> resultFiles = CompilePerms.makeResultFiles(
options.getCompilerWorkDir(moduleName), allPerms);
CompilePerms.compile(logger, precompilation, allPerms,
options.getLocalWorkers(), resultFiles);
ArtifactSet generatedArtifacts = precompilation.getGeneratedArtifacts();
JJSOptions precompileOptions = precompilation.getUnifiedAst().getOptions();
precompilation = null; // No longer needed, so save the memory
Link.legacyLink(logger.branch(TreeLogger.TRACE, "Linking into "
+ options.getOutDir().getPath()), module, generatedArtifacts,
allPerms, resultFiles, options.getOutDir(), precompileOptions);
long compileDone = System.currentTimeMillis();
long delta = compileDone - compileStart;
if (logger.isLoggable(TreeLogger.INFO)) {
logger.log(TreeLogger.INFO, "Compilation succeeded -- "
+ String.format("%.3f", delta / 1000d) + "s");
}
}
}
} catch (IOException e) {
logger.log(TreeLogger.ERROR, "Unable to create compiler work directory",
e);
return false;
} finally {
compileEvent.end();
if (tempWorkDir) {
Util.recursiveDelete(options.getWorkDir(), false);
}
}
return true;
}
}