Java tutorial
/* * #%L * Native ARchive plugin for Maven * %% * Copyright (C) 2002 - 2014 NAR Maven Plugin developers. * %% * 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. * #L% */ package com.github.maven_nar.cpptasks.compiler; import java.io.File; import java.io.IOException; import java.util.Collections; import java.util.Enumeration; import java.util.Vector; import java.util.ArrayList; import org.apache.tools.ant.BuildException; import org.apache.tools.ant.types.Environment; import org.apache.commons.io.FilenameUtils; import com.github.maven_nar.cpptasks.CCTask; import com.github.maven_nar.cpptasks.CUtil; import com.github.maven_nar.cpptasks.CompilerDef; import com.github.maven_nar.cpptasks.OptimizationEnum; import com.github.maven_nar.cpptasks.ProcessorDef; import com.github.maven_nar.cpptasks.ProcessorParam; import com.github.maven_nar.cpptasks.TargetDef; import com.github.maven_nar.cpptasks.VersionInfo; import com.github.maven_nar.cpptasks.types.CommandLineArgument; import com.github.maven_nar.cpptasks.types.UndefineArgument; import com.google.common.collect.ObjectArrays; import org.apache.tools.ant.util.FileUtils; /** * An abstract Compiler implementation which uses an external program to * perform the compile. * * @author Adam Murdoch */ public abstract class CommandLineCompiler extends AbstractCompiler { /** Command used when invoking ccache */ private static final String CCACHE_CMD = "ccache"; private String command; private String prefix; private final Environment env; private String identifier; private final String identifierArg; private final boolean libtool; private final CommandLineCompiler libtoolCompiler; private final boolean newEnvironment; protected CommandLineCompiler(final String command, final String identifierArg, final String[] sourceExtensions, final String[] headerExtensions, final String outputSuffix, final boolean libtool, final CommandLineCompiler libtoolCompiler, final boolean newEnvironment, final Environment env) { super(sourceExtensions, headerExtensions, outputSuffix); this.command = command; if (libtool && libtoolCompiler != null) { throw new java.lang.IllegalArgumentException("libtoolCompiler should be null when libtool is true"); } this.libtool = libtool; this.libtoolCompiler = libtoolCompiler; this.identifierArg = identifierArg; this.newEnvironment = newEnvironment; this.env = env; } abstract protected void addImpliedArgs(Vector<String> args, boolean debug, boolean multithreaded, boolean exceptions, LinkType linkType, Boolean rtti, OptimizationEnum optimization); /** * Adds command-line arguments for include directories. * * If relativeArgs is not null will add corresponding relative paths * include switches to that vector (for use in building a configuration * identifier that is consistent between machines). * * @param baseDirPath * Base directory path. * @param includeDirs * Array of include directory paths * @param args * Vector of command line arguments used to execute the task * @param relativeArgs * Vector of command line arguments used to build the * configuration identifier */ protected void addIncludes(final String baseDirPath, final File[] includeDirs, final Vector<String> args, final Vector<String> relativeArgs, final StringBuffer includePathId, final boolean isSystem) { for (final File includeDir : includeDirs) { args.addElement(getIncludeDirSwitch(includeDir.getAbsolutePath(), isSystem)); if (relativeArgs != null) { final String relative = CUtil.getRelativePath(baseDirPath, includeDir); relativeArgs.addElement(getIncludeDirSwitch(relative, isSystem)); if (includePathId != null) { if (includePathId.length() == 0) { includePathId.append("/I"); } else { includePathId.append(" /I"); } includePathId.append(relative); } } } } abstract protected void addWarningSwitch(Vector<String> args, int warnings); protected void buildDefineArguments(final CompilerDef[] defs, final Vector<String> args) { // // assume that we aren't inheriting defines from containing <cc> // UndefineArgument[] merged = defs[0].getActiveDefines(); for (int i = 1; i < defs.length; i++) { // // if we are inheriting, merge the specific defines with the // containing defines merged = UndefineArgument.merge(defs[i].getActiveDefines(), merged); } final StringBuffer buf = new StringBuffer(30); for (final UndefineArgument current : merged) { buf.setLength(0); if (current.isDefine()) { getDefineSwitch(buf, current.getName(), current.getValue()); } else { getUndefineSwitch(buf, current.getName()); } args.addElement(buf.toString()); } } @Override public String[] getOutputFileNames(final String inputFile, final VersionInfo versionInfo) { // // if a recognized input file // if (bid(inputFile) > 1) { final String baseName = getBaseOutputName(inputFile); final File standardisedFile = new File(inputFile); try { return new String[] { baseName + FilenameUtils.EXTENSION_SEPARATOR + Integer.toHexString(standardisedFile.getCanonicalPath().hashCode()) + getOutputSuffix() }; } catch (IOException e) { throw new BuildException("Source file not found", e); } } return new String[0]; } /** * Compiles a source file. * */ public void compile(final CCTask task, final File outputDir, final String[] sourceFiles, String[] args, final String[] endArgs, final boolean relentless, final CommandLineCompilerConfiguration config, final ProgressMonitor monitor) throws BuildException { BuildException exc = null; // // determine length of executable name and args // String command = getCommandWithPath(config); if (config.isUseCcache()) { // Replace the command with "ccache" and push the old compiler // command into the args. final String compilerCommand = command; command = CCACHE_CMD; args = ObjectArrays.concat(compilerCommand, args); } int baseLength = command.length() + args.length + endArgs.length; if (this.libtool) { baseLength += 8; } for (final String arg : args) { baseLength += arg.length(); } for (final String endArg : endArgs) { baseLength += endArg.length(); } if (baseLength > getMaximumCommandLength()) { throw new BuildException("Command line is over maximum length without specifying source file"); } // // typically either 1 or Integer.MAX_VALUE // final int maxInputFilesPerCommand = getMaximumInputFilesPerCommand(); final int argumentCountPerInputFile = getArgumentCountPerInputFile(); for (int sourceIndex = 0; sourceIndex < sourceFiles.length;) { int cmdLength = baseLength; int firstFileNextExec; for (firstFileNextExec = sourceIndex; firstFileNextExec < sourceFiles.length && firstFileNextExec - sourceIndex < maxInputFilesPerCommand; firstFileNextExec++) { cmdLength += getTotalArgumentLengthForInputFile(outputDir, sourceFiles[firstFileNextExec]); if (cmdLength >= getMaximumCommandLength()) { break; } } if (firstFileNextExec == sourceIndex) { throw new BuildException("Extremely long file name, can't fit on command line"); } ArrayList<String> commandlinePrefix = new ArrayList<>(); if (this.libtool) { commandlinePrefix.add("libtool"); } commandlinePrefix.add(command); Collections.addAll(commandlinePrefix, args); int retval = 0; for (int j = sourceIndex; j < firstFileNextExec; j++) { ArrayList<String> commandlineSuffix = new ArrayList<>(); for (int k = 0; k < argumentCountPerInputFile; k++) { commandlineSuffix.add(getInputFileArgument(outputDir, sourceFiles[j], k)); } Collections.addAll(commandlineSuffix, endArgs); ArrayList<String> commandline = new ArrayList<>(commandlinePrefix); commandline.addAll(commandlineSuffix); final int ret = runCommand(task, workDir, commandline.toArray(new String[commandline.size()])); if (ret != 0) { retval = ret; } } if (monitor != null) { final String[] fileNames = new String[firstFileNextExec - sourceIndex]; System.arraycopy(sourceFiles, sourceIndex + 0, fileNames, 0, fileNames.length); monitor.progress(fileNames); } // // if the process returned a failure code and // we aren't holding an exception from an earlier // interation if (retval != 0 && exc == null) { // // construct the exception // exc = new BuildException(getCommandWithPath(config) + " failed with return code " + retval, task.getLocation()); // // and throw it now unless we are relentless // if (!relentless) { throw exc; } } sourceIndex = firstFileNextExec; } // // if the compiler returned a failure value earlier // then throw an exception if (exc != null) { throw exc; } } @Override protected CompilerConfiguration createConfiguration(final CCTask task, final LinkType linkType, final ProcessorDef[] baseDefs, final CompilerDef specificDef, final TargetDef targetPlatform, final VersionInfo versionInfo) { this.prefix = specificDef.getCompilerPrefix(); this.objDir = task.getObjdir(); final Vector<String> args = new Vector<>(); final CompilerDef[] defaultProviders = new CompilerDef[baseDefs.length + 1]; for (int i = 0; i < baseDefs.length; i++) { defaultProviders[i + 1] = (CompilerDef) baseDefs[i]; } defaultProviders[0] = specificDef; final Vector<CommandLineArgument> cmdArgs = new Vector<>(); // // add command line arguments inherited from <cc> element // any "extends" and finally the specific CompilerDef CommandLineArgument[] commandArgs; for (int i = defaultProviders.length - 1; i >= 0; i--) { commandArgs = defaultProviders[i].getActiveProcessorArgs(); for (final CommandLineArgument commandArg : commandArgs) { if (commandArg.getLocation() == 0) { String arg = commandArg.getValue(); if (isWindows() && arg.matches(".*[ \"].*")) { // Work around inconsistent quoting by Ant arg = "\"" + arg.replaceAll("[\\\\\"]", "\\\\$0") + "\""; } args.addElement(arg); } else { cmdArgs.addElement(commandArg); } } } final Vector<ProcessorParam> params = new Vector<>(); // // add command line arguments inherited from <cc> element // any "extends" and finally the specific CompilerDef ProcessorParam[] paramArray; for (int i = defaultProviders.length - 1; i >= 0; i--) { paramArray = defaultProviders[i].getActiveProcessorParams(); Collections.addAll(params, paramArray); } paramArray = params.toArray(new ProcessorParam[params.size()]); if (specificDef.isClearDefaultOptions() == false) { final boolean multithreaded = specificDef.getMultithreaded(defaultProviders, 1); final boolean debug = specificDef.getDebug(baseDefs, 0); final boolean exceptions = specificDef.getExceptions(defaultProviders, 1); final Boolean rtti = specificDef.getRtti(defaultProviders, 1); final OptimizationEnum optimization = specificDef.getOptimization(defaultProviders, 1); this.addImpliedArgs(args, debug, multithreaded, exceptions, linkType, rtti, optimization); } // // add all appropriate defines and undefines // buildDefineArguments(defaultProviders, args); final int warnings = specificDef.getWarnings(defaultProviders, 0); addWarningSwitch(args, warnings); Enumeration<CommandLineArgument> argEnum = cmdArgs.elements(); int endCount = 0; while (argEnum.hasMoreElements()) { final CommandLineArgument arg = argEnum.nextElement(); switch (arg.getLocation()) { case 1: args.addElement(arg.getValue()); break; case 2: endCount++; break; } } final String[] endArgs = new String[endCount]; argEnum = cmdArgs.elements(); int index = 0; while (argEnum.hasMoreElements()) { final CommandLineArgument arg = argEnum.nextElement(); if (arg.getLocation() == 2) { endArgs[index++] = arg.getValue(); } } // // Want to have distinct set of arguments with relative // path names for includes that are used to build // the configuration identifier // final Vector<String> relativeArgs = (Vector) args.clone(); // // add all active include and sysincludes // final StringBuffer includePathIdentifier = new StringBuffer(); final File baseDir = specificDef.getProject().getBaseDir(); String baseDirPath; try { baseDirPath = baseDir.getCanonicalPath(); } catch (final IOException ex) { baseDirPath = baseDir.toString(); } final Vector<String> includePath = new Vector<>(); final Vector<String> sysIncludePath = new Vector<>(); for (int i = defaultProviders.length - 1; i >= 0; i--) { String[] incPath = defaultProviders[i].getActiveIncludePaths(); for (final String element : incPath) { includePath.addElement(element); } incPath = defaultProviders[i].getActiveSysIncludePaths(); for (final String element : incPath) { sysIncludePath.addElement(element); } } final File[] incPath = new File[includePath.size()]; for (int i = 0; i < includePath.size(); i++) { incPath[i] = new File(includePath.elementAt(i)); } final File[] sysIncPath = new File[sysIncludePath.size()]; for (int i = 0; i < sysIncludePath.size(); i++) { sysIncPath[i] = new File(sysIncludePath.elementAt(i)); } addIncludes(baseDirPath, incPath, args, relativeArgs, includePathIdentifier, false); addIncludes(baseDirPath, sysIncPath, args, null, null, true); final StringBuffer buf = new StringBuffer(getIdentifier()); for (int i = 0; i < relativeArgs.size(); i++) { buf.append(' '); buf.append(relativeArgs.elementAt(i)); } for (final String endArg : endArgs) { buf.append(' '); buf.append(endArg); } final String configId = buf.toString(); final String[] argArray = new String[args.size()]; args.copyInto(argArray); final boolean rebuild = specificDef.getRebuild(baseDefs, 0); final File[] envIncludePath = getEnvironmentIncludePath(); final String path = specificDef.getToolPath(); CommandLineCompiler compiler = this; Environment environment = specificDef.getEnv(); if (environment == null) { for (final ProcessorDef baseDef : baseDefs) { environment = baseDef.getEnv(); if (environment != null) { compiler = (CommandLineCompiler) compiler.changeEnvironment(baseDef.isNewEnvironment(), environment); } } } else { compiler = (CommandLineCompiler) compiler.changeEnvironment(specificDef.isNewEnvironment(), environment); } return new CommandLineCompilerConfiguration(compiler, configId, incPath, sysIncPath, envIncludePath, includePathIdentifier.toString(), argArray, paramArray, rebuild, endArgs, path, specificDef.getCcache()); } protected int getArgumentCountPerInputFile() { return 1; } protected final String getCommand() { if (this.prefix != null && (!this.prefix.isEmpty())) { return this.prefix + this.command; } else { return this.command; } } public String getCommandWithPath(final CommandLineCompilerConfiguration config) { if (config.getCommandPath() != null) { final File command = new File(config.getCommandPath(), this.getCommand()); try { return command.getCanonicalPath(); } catch (final IOException e) { e.printStackTrace(); return command.getAbsolutePath(); } } else { return this.getCommand(); } } abstract protected void getDefineSwitch(StringBuffer buffer, String define, String value); protected abstract File[] getEnvironmentIncludePath(); @Override public String getIdentifier() { if (this.identifier == null) { if (this.identifierArg == null) { this.identifier = getIdentifier(new String[] { this.getCommand() }, this.getCommand()); } else { this.identifier = getIdentifier(new String[] { this.getCommand(), this.identifierArg }, this.getCommand()); } } return this.identifier; } abstract protected String getIncludeDirSwitch(String source); /** * Added by Darren Sargent 22Oct2008 Returns the include dir switch value. * Default implementation doesn't treat system includes specially, for * compilers which don't care. * * @param source * the given source value. * @param isSystem * "true" if this is a system include path * * @return the include dir switch value. */ protected String getIncludeDirSwitch(final String source, final boolean isSystem) { return getIncludeDirSwitch(source); } protected String getInputFileArgument(final File outputDir, final String filename, final int index) { // // if there is an embedded space, // must enclose in quotes String relative = ""; String inputFile; try { relative = FileUtils.getRelativePath(workDir, new File(filename)); } catch (Exception ex) { } if (relative.isEmpty()) { inputFile = filename; } else { inputFile = relative; } if (inputFile.indexOf(' ') >= 0) { final String buf = "\"" + inputFile + "\""; return buf; } return inputFile; } protected final boolean getLibtool() { return this.libtool; } /** * Obtains the same compiler, but with libtool set * * Default behavior is to ignore libtool */ public final CommandLineCompiler getLibtoolCompiler() { if (this.libtoolCompiler != null) { return this.libtoolCompiler; } return this; } abstract public int getMaximumCommandLength(); protected int getMaximumInputFilesPerCommand() { return Integer.MAX_VALUE; } /** * Get total command line length due to the input file. * * @param outputDir * File output directory * @param inputFile * String input file * @return int characters added to command line for the input file. */ protected int getTotalArgumentLengthForInputFile(final File outputDir, final String inputFile) { final int argumentCountPerInputFile = getArgumentCountPerInputFile(); int len = 0; for (int k = 0; k < argumentCountPerInputFile; k++) { len += getInputFileArgument(outputDir, inputFile, k).length(); } return len + argumentCountPerInputFile; // argumentCountPerInputFile added for spaces } abstract protected void getUndefineSwitch(StringBuffer buffer, String define); /** * This method is exposed so test classes can overload and test the * arguments without actually spawning the compiler */ protected int runCommand(final CCTask task, final File workingDir, final String[] cmdline) throws BuildException { return CUtil.runCommand(task, workingDir, cmdline, this.newEnvironment, this.env); } protected final void setCommand(final String command) { this.command = command; } }