/*
*
* 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 flash.localization.LocalizationManager;
import flex2.compiler.common.Configuration;
import flex2.compiler.common.ConfigurationPathResolver;
import flex2.compiler.common.PathResolver;
import flex2.compiler.config.*;
import flex2.compiler.io.VirtualFile;
import flex2.compiler.util.CompilerMessage;
import flex2.compiler.util.ThreadLocalToolkit;
import org.apache.flex.compiler.clients.MXMLC;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
import java.util.Map.Entry;
/**
* A command line tool for compiling Flex applications. Despite the
* name, in addition to .mxml files, this tool can be used to compile
* other file formats, like .as and .css.
*/
public final class Mxmlc extends Tool {
static private String l10nConfigPrefix = "flex2.configuration";
public static final String FILE_SPECS = "file-specs";
/**
* The entry-point for Mxmlc.
* Note that if you change anything in this method, make sure to check Compc, Shell, and
* the server's CompileFilter to see if the same change needs to be made there. You
* should also inform the Zorn team of the change.
*
* @param args
*/
public static void main(String[] args) throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
System.exit(mxmlcNoExit(args));
}
public static int mxmlcNoExit(String[] args) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
COMPILER = MXMLC.class;
JS_COMPILER = MxmlJSC.class;
return compile(args);
}
public static void mxmlc(String[] args) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
COMPILER = MXMLC.class;
JS_COMPILER = MxmlJSC.class;
compile(args);
}
public static Configuration processConfiguration(LocalizationManager lmgr, String program, String[] args,
ConfigurationBuffer cfgbuf, Class<? extends Configuration> cls, String defaultVar)
throws ConfigurationException, IOException {
return processConfiguration(lmgr, program, args, cfgbuf, cls, defaultVar, true);
}
public static Configuration processConfiguration(LocalizationManager lmgr, String program, String[] args,
ConfigurationBuffer cfgbuf, Class<? extends Configuration> cls, String defaultVar,
boolean ignoreUnknownItems)
throws IOException {
ToolsConfiguration toolsConfiguration = null;
try {
SystemPropertyConfigurator.load(cfgbuf, "flex");
// Parse the command line a first time, to peak at stuff like
// "flexlib" and "load-config". The first parse is thrown
// away after that and we intentionally parse a second time
// below. See note below.
CommandLineConfigurator.parse(cfgbuf, defaultVar, args);
String flexlib = cfgbuf.getToken("flexlib");
if (flexlib == null) {
String appHome = System.getProperty("application.home");
if (appHome == null) {
appHome = ".";
} else {
appHome += File.separator + "frameworks"; // FIXME - need to eliminate this from the compiler
}
cfgbuf.setToken("flexlib", appHome);
}
// Framework Type
// halo, gumbo, interop...
String framework = cfgbuf.getToken("framework");
if (framework == null) {
cfgbuf.setToken("framework", "halo");
}
String configname = cfgbuf.getToken("configname");
if (configname == null) {
cfgbuf.setToken("configname", "flex");
}
String buildNumber = cfgbuf.getToken("build.number");
if (buildNumber == null) {
if ("".equals(VersionInfo.getBuild())) {
buildNumber = "workspace";
} else {
buildNumber = VersionInfo.getBuild();
}
cfgbuf.setToken("build.number", buildNumber);
}
// We need to intercept "help" options because we want to try to correctly
// interpret them even when the rest of the configuration is totally screwed up.
if (cfgbuf.getVar("version") != null) {
System.out.println(VersionInfo.buildMessage());
System.exit(0);
}
processHelp(cfgbuf, program, defaultVar, lmgr, args);
// at this point, we should have enough to know both
// flexlib and the config file.
ConfigurationPathResolver configResolver = new ConfigurationPathResolver();
List<ConfigurationValue> configs = cfgbuf.peekConfigurationVar("load-config");
if (configs != null) {
for (ConfigurationValue cv : configs) {
for (String path : cv.getArgs()) {
VirtualFile configFile = ConfigurationPathResolver.getVirtualFile(path, configResolver, cv);
cfgbuf.calculateChecksum(configFile);
InputStream in = configFile.getInputStream();
if (in != null) {
FileConfigurator.load(cfgbuf, new BufferedInputStream(in), configFile.getName(),
configFile.getParent(), "flex-config", ignoreUnknownItems);
} else {
throw new ConfigurationException.ConfigurationIOError(path, cv.getVar(), cv.getSource(), cv.getLine());
}
}
}
}
PathResolver resolver = ThreadLocalToolkit.getPathResolver();
// Load project file, if any...
List fileValues = cfgbuf.getVar(FILE_SPECS);
if ((fileValues != null) && (fileValues.size() > 0)) {
ConfigurationValue cv = (ConfigurationValue) fileValues.get(fileValues.size() - 1);
if (cv.getArgs().size() > 0) {
String val = cv.getArgs().get(cv.getArgs().size() - 1);
int index = val.lastIndexOf('.');
if (index != -1) {
String project = val.substring(0, index) + "-config.xml";
VirtualFile projectFile = resolver.resolve(configResolver, project);
if (projectFile != null) {
cfgbuf.calculateChecksum(projectFile);
InputStream in = projectFile.getInputStream();
if (in != null) {
FileConfigurator.load(cfgbuf, new BufferedInputStream(in),
projectFile.getName(), projectFile.getParent(), "flex-config",
ignoreUnknownItems);
}
}
}
}
}
// The command line needs to take precedence over all defaults and config files.
// This is a bit gross, but by simply re-merging the command line back on top,
// we will get the behavior we want.
cfgbuf.clearSourceVars(CommandLineConfigurator.source);
CommandLineConfigurator.parse(cfgbuf, defaultVar, args);
toolsConfiguration = null;
try {
toolsConfiguration = (ToolsConfiguration) cls.newInstance();
toolsConfiguration.setConfigPathResolver(configResolver);
} catch (Exception e) {
LocalizationManager l10n = ThreadLocalToolkit.getLocalizationManager();
throw new ConfigurationException(l10n.getLocalizedTextString(new CouldNotInstantiate(toolsConfiguration)));
}
cfgbuf.commit(toolsConfiguration);
// enterprise service config file has other config file dependencies. add them here...
calculateServicesChecksum(toolsConfiguration, cfgbuf);
toolsConfiguration.validate(cfgbuf);
// consolidate license keys...
VirtualFile licenseFile = toolsConfiguration.getLicenseFile();
if (licenseFile != null) {
Map<String, String> fileLicenses = Tool.getLicenseMapFromFile(licenseFile.getName());
Map<String, String> cmdLicenses = toolsConfiguration.getLicensesConfiguration().getLicenseMap();
if (cmdLicenses == null) {
toolsConfiguration.getLicensesConfiguration().setLicenseMap(fileLicenses);
} else if (fileLicenses != null) {
fileLicenses.putAll(cmdLicenses);
toolsConfiguration.getLicensesConfiguration().setLicenseMap(fileLicenses);
}
}
} catch (ConfigurationException e) {
e.printStackTrace();
}
return toolsConfiguration;
}
static void processHelp(ConfigurationBuffer cfgbuf, String program, String defaultVar, LocalizationManager lmgr, String[] args) {
if (cfgbuf.getVar("help") != null) {
Set<String> keywords = new HashSet<String>();
List vals = cfgbuf.getVar("help");
for (Iterator it = vals.iterator(); it.hasNext(); ) {
ConfigurationValue val = (ConfigurationValue) it.next();
for (Object element : val.getArgs()) {
String keyword = (String) element;
while (keyword.startsWith("-"))
keyword = keyword.substring(1);
keywords.add(keyword);
}
}
if (keywords.size() == 0) {
keywords.add("help");
}
ThreadLocalToolkit.logInfo(getStartMessage(program));
System.out.println();
System.out.println(CommandLineConfigurator.usage(program, defaultVar, cfgbuf, keywords, lmgr, l10nConfigPrefix));
System.exit(0);
}
if (args.length == 0 && ("mxmlc".equals(program) || "compc".equals(program))) {
ThreadLocalToolkit.logInfo(getStartMessage(program));
System.err.println(CommandLineConfigurator.brief(program, defaultVar, lmgr, l10nConfigPrefix));
System.exit(1);
}
}
private static void calculateServicesChecksum(Configuration config, ConfigurationBuffer cfgbuf) {
Map<String, Long> services = null;
if (config.getCompilerConfiguration().getServicesDependencies() != null) {
services = config.getCompilerConfiguration().getServicesDependencies().getConfigPaths();
}
if (services != null) {
for (Entry<String, Long> entry : services.entrySet()) {
cfgbuf.calculateChecksum(entry.getKey(), entry.getValue());
}
}
}
public static void processConfigurationException(ConfigurationException ex, String program) {
ThreadLocalToolkit.log(ex);
if (ex.source == null || ex.source.equals("command line")) {
Map<String, String> p = new HashMap<String, String>();
p.put("program", program);
String help = ThreadLocalToolkit.getLocalizationManager().getLocalizedTextString("flex2.compiler.CommandLineHelp", p);
if (help != null) {
// "Use '" + program + " -help' for information about using the command line.");
System.err.println(help);
}
}
}
private static String getStartMessage(String program) {
LocalizationManager l10n = ThreadLocalToolkit.getLocalizationManager();
return l10n.getLocalizedTextString(new StartMessage(program, VersionInfo.buildMessage()));
}
public static class CouldNotInstantiate extends CompilerMessage.CompilerInfo {
private static final long serialVersionUID = -8970190710117830662L;
public CouldNotInstantiate(Configuration config) {
super();
this.config = config;
}
public final Configuration config;
}
public static class StartMessage extends CompilerMessage.CompilerInfo {
private static final long serialVersionUID = 4807822711658875257L;
public StartMessage(String program, String buildMessage) {
super();
this.program = program;
this.buildMessage = buildMessage;
}
public final String program, buildMessage;
}
public static class OutputMessage extends CompilerMessage.CompilerInfo {
private static final long serialVersionUID = -4859993585489031839L;
public String name;
public String length;
public OutputMessage(String name, String length) {
this.name = name;
this.length = length;
}
}
}