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; import java.io.File; import java.io.FileFilter; import java.io.IOException; import java.util.ArrayList; import java.util.Comparator; import java.util.Enumeration; import java.util.HashMap; import java.util.Hashtable; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.TreeMap; import java.util.Vector; import org.apache.tools.ant.BuildException; import org.apache.tools.ant.Project; import org.apache.tools.ant.Task; import org.apache.tools.ant.types.Environment; import org.apache.commons.io.FilenameUtils; import com.github.maven_nar.cpptasks.compiler.CompilerConfiguration; import com.github.maven_nar.cpptasks.compiler.LinkType; import com.github.maven_nar.cpptasks.compiler.Linker; import com.github.maven_nar.cpptasks.compiler.LinkerConfiguration; import com.github.maven_nar.cpptasks.compiler.Processor; import com.github.maven_nar.cpptasks.compiler.ProcessorConfiguration; import com.github.maven_nar.cpptasks.compiler.AbstractCompiler; import com.github.maven_nar.cpptasks.compiler.CommandLineCompilerConfiguration; import com.github.maven_nar.cpptasks.ide.ProjectDef; import com.github.maven_nar.cpptasks.types.CompilerArgument; import com.github.maven_nar.cpptasks.types.ConditionalFileSet; import com.github.maven_nar.cpptasks.types.DefineSet; import com.github.maven_nar.cpptasks.types.IncludePath; import com.github.maven_nar.cpptasks.types.LibrarySet; import com.github.maven_nar.cpptasks.types.LinkerArgument; import com.github.maven_nar.cpptasks.types.SystemIncludePath; import com.github.maven_nar.cpptasks.types.SystemLibrarySet; /** * Compile and link task. * * <p> * This task can compile various source languages and produce executables, * shared libraries (aka DLL's) and static libraries. Compiler adaptors are * currently available for several C/C++ compilers, FORTRAN, MIDL and Windows * Resource files. * </p> * * @author Adam Murdoch * @author Curt Arnold */ public class CCTask extends Task { // BEGINFREEHEP class Core extends Thread { private final CCTask task; private final CompilerConfiguration config; private final File objDir; private final List<String> sourceFiles; private final boolean relentless; private final CCTaskProgressMonitor monitor; private Exception compileException; Core(final CCTask task, final int coreNo, final CompilerConfiguration config, final File objDir, final List<String> set, final boolean relentless, final CCTaskProgressMonitor monitor) { super("Core " + coreNo); this.task = task; this.config = config; this.objDir = objDir; this.sourceFiles = set; this.relentless = relentless; this.monitor = monitor; } public Exception getException() { return this.compileException; } @Override public void run() { super.run(); try { String[] sources = new String[this.sourceFiles.size()]; sources = this.sourceFiles.toArray(sources); this.config.compile(this.task, this.objDir, sources, this.relentless, this.monitor); } catch (final Exception ex) { if (this.compileException == null) { this.compileException = ex; } } } } // BEGINFREEHEP class Progress extends Thread { private boolean stop = false; private final File objDir; private final int rebuildCount; public Progress(final File objDir, final int rebuildCount) { this.objDir = objDir; this.rebuildCount = rebuildCount; } public void exit() { this.stop = true; } @Override public void run() { if (this.rebuildCount < 10) { return; } try { final FileFilter updatedFiles = new FileFilter() { private final long startTime = System.currentTimeMillis(); @Override public boolean accept(final File file) { return file.lastModified() > this.startTime && !file.getName().endsWith(".xml"); } }; while (!this.stop) { System.err.print("\r" + this.objDir.listFiles(updatedFiles).length + " / " + this.rebuildCount + " files compiled..."); System.err.print("\r"); System.err.flush(); if (!this.stop) { Thread.sleep(5000); } } } catch (final InterruptedException e) { } System.err.print("\r "); System.err.print("\r"); System.err.flush(); log(Integer.toString(this.rebuildCount) + " files were compiled."); } } private static class ProjectFileCollector implements FileVisitor { private final List<File> files; /** * Creates a new ProjectFileCollector. * * @param files * vector for collected files. */ public ProjectFileCollector(final List<File> files) { this.files = files; } /** * Called for each file to be considered for collection. * * @param parentDir * parent directory * @param filename * filename within directory */ @Override public void visit(final File parentDir, final String filename) { this.files.add(new File(parentDir, filename)); } } private static class SystemLibraryCollector implements FileVisitor { private final Hashtable<String, File> libraries; private final Linker linker; public SystemLibraryCollector(final Linker linker, final Hashtable<String, File> libraries) { this.linker = linker; this.libraries = libraries; } @Override public void visit(final File basedir, final String filename) { if (this.linker.bid(filename) > 0) { final File libfile = new File(basedir, filename); final String key = this.linker.getLibraryKey(libfile); this.libraries.put(key, libfile); } } } private static final ProcessorConfiguration[] EMPTY_CONFIG_ARRAY = new ProcessorConfiguration[0]; /** * Builds a Hashtable to targets needing to be rebuilt keyed by compiler * configuration */ public static Map<CompilerConfiguration, Vector<TargetInfo>> getTargetsToBuildByConfiguration( final Map<String, TargetInfo> targets) { final Map<CompilerConfiguration, Vector<TargetInfo>> targetsByConfig = new HashMap<>(); for (final TargetInfo target : targets.values()) { if (target.getRebuild()) { // FIXME: Types do not match between the key of targetsByConfig and the return value of target.getConfiguration Vector<TargetInfo> targetsForSameConfig = targetsByConfig.get(target.getConfiguration()); if (targetsForSameConfig != null) { targetsForSameConfig.addElement(target); } else { targetsForSameConfig = new Vector<>(); targetsForSameConfig.addElement(target); targetsByConfig.put((CompilerConfiguration) target.getConfiguration(), targetsForSameConfig); } } } return targetsByConfig; } // FREEHEP private int maxCores = 0; private boolean ordered = false; /** The compiler definitions. */ private final Vector<CompilerDef> _compilers = new Vector<>(); /** The output file type. */ // private LinkType _linkType = LinkType.EXECUTABLE; /** The library sets. */ private final Vector _libsets = new Vector(); /** The linker definitions. */ private final Vector<LinkerDef> _linkers = new Vector<>(); /** The object directory. */ private File _objDir; /** The output file. */ private File _outfile; /** The linker definitions. */ private final Vector<TargetDef> targetPlatforms = new Vector<>(); /** The distributer definitions. */ private final Vector<DistributerDef> distributers = new Vector<>(); private final Vector<VersionInfo> versionInfos = new Vector<>(); private final Vector<ProjectDef> projects = new Vector<>(); private boolean projectsOnly = false; private boolean decorateLinkerOptions = true; /** * If true, stop build on compile failure. */ protected boolean failOnError = true; /** * Content that appears in <cc>and also in <compiler>are maintained by a * captive CompilerDef instance */ private final CompilerDef compilerDef = new CompilerDef(); /** The OS390 dataset to build to object to */ private String dataset; /** * * Depth of dependency checking * * Values < 0 indicate full dependency checking Values >= 0 indicate * partial dependency checking and for superficial compilation checks. Will * throw BuildException before attempting link */ private int dependencyDepth = -1; /** * Content that appears in <cc>and also in <linker>are maintained by a * captive CompilerDef instance */ private final LinkerDef linkerDef = new LinkerDef(); /** * contains the subsystem, output type and * */ private final LinkType linkType = new LinkType(); /** * The property name which will be set with the physical filename of the * file that is generated by the linker */ private String outputFileProperty; /** * if relentless = true, compilations should attempt to compile as many * files as possible before throwing a BuildException */ private boolean relentless; /** * At which log-level do we log command-lines in the build? */ private int commandLogLevel = Project.MSG_VERBOSE; public CCTask() { } /** * Adds a compiler definition or reference. * * @param compiler * compiler * @throws NullPointerException * if compiler is null */ public void addConfiguredCompiler(final CompilerDef compiler) { if (compiler == null) { throw new NullPointerException("compiler"); } compiler.setProject(getProject()); this._compilers.addElement(compiler); } /** * Adds a compiler command-line arg. Argument will be inherited by all * nested compiler elements that do not have inherit="false". * */ public void addConfiguredCompilerArg(final CompilerArgument arg) { this.compilerDef.addConfiguredCompilerArg(arg); } /** * Adds a defineset. Will be inherited by all compiler elements that do not * have inherit="false". * * @param defs * Define set */ public void addConfiguredDefineset(final DefineSet defs) { this.compilerDef.addConfiguredDefineset(defs); } /** * Adds a distributer definition or reference (Non-functional prototype). * * @param distributer * distributer * @throws NullPointerException * if compiler is null */ public void addConfiguredDistributer(final DistributerDef distributer) { if (distributer == null) { throw new NullPointerException("distributer"); } distributer.setProject(getProject()); this.distributers.addElement(distributer); } /** * Adds a linker definition. The first linker that is not disqualified by * its "if" and "unless" attributes will perform the link. If no child * linker element is active, the linker implied by the cc elements name or * classname attribute will be used. * * @param linker * linker * @throws NullPointerException * if linker is null */ public void addConfiguredLinker(final LinkerDef linker) { if (linker == null) { throw new NullPointerException("linker"); } linker.setProject(getProject()); this._linkers.addElement(linker); } /** * Adds a linker command-line arg. Argument will be inherited by all nested * linker elements that do not have inherit="false". */ public void addConfiguredLinkerArg(final LinkerArgument arg) { this.linkerDef.addConfiguredLinkerArg(arg); } /** * Adds a target definition or reference (Non-functional prototype). * * @param target * target * @throws NullPointerException * if compiler is null */ public void addConfiguredTarget(final TargetDef target) { if (target == null) { throw new NullPointerException("target"); } target.setProject(getProject()); this.targetPlatforms.addElement(target); } /** * Adds desriptive version information to be included in the * generated file. The first active version info block will * be used. */ public void addConfiguredVersioninfo(final VersionInfo newVersionInfo) { newVersionInfo.setProject(this.getProject()); this.versionInfos.addElement(newVersionInfo); } /** * Add an environment variable to the launched process. */ public void addEnv(final Environment.Variable var) { this.compilerDef.addEnv(var); for (int i = 0; i < this._compilers.size(); i++) { final CompilerDef currentCompilerDef = this._compilers.elementAt(i); currentCompilerDef.addEnv(var); } this.linkerDef.addEnv(var); } /** * Adds a source file set. * * Files in these filesets will be auctioned to the available compiler * configurations, with the default compiler implied by the cc element * bidding last. If no compiler is interested in the file, it will be * passed to the linker. * * To have a file be processed by a particular compiler configuration, add * a fileset to the corresponding compiler element. */ public void addFileset(final ConditionalFileSet srcSet) { this.compilerDef.addFileset(srcSet); } /** * Adds a library set. * * Library sets will be inherited by all linker elements that do not have * inherit="false". * * @param libset * library set * @throws NullPointerException * if libset is null. */ public void addLibset(final LibrarySet libset) { if (libset == null) { throw new NullPointerException("libset"); } this.linkerDef.addLibset(libset); } /** * Specifies the generation of IDE project file. Experimental. * * @param projectDef * project file generation specification */ public void addProject(final ProjectDef projectDef) { if (projectDef == null) { throw new NullPointerException("projectDef"); } this.projects.addElement(projectDef); } /** * Adds a system library set. Timestamps and locations of system library * sets are not used in dependency analysis. * * Essential libraries (such as C Runtime libraries) should not be * specified since the task will attempt to identify the correct libraries * based on the multithread, debug and runtime attributes. * * System library sets will be inherited by all linker elements that do not * have inherit="false". * * @param libset * library set * @throws NullPointerException * if libset is null. */ public void addSyslibset(final SystemLibrarySet libset) { if (libset == null) { throw new NullPointerException("libset"); } this.linkerDef.addSyslibset(libset); } /** * Checks all targets that are not forced to be rebuilt or are missing * object files to be checked for modified include files * * @return total number of targets to be rebuilt * */ protected int checkForChangedIncludeFiles(final Map<String, TargetInfo> targets) { int potentialTargets = 0; int definiteTargets = 0; Iterator<TargetInfo> targetEnum = targets.values().iterator(); while (targetEnum.hasNext()) { final TargetInfo target = targetEnum.next(); if (!target.getRebuild()) { potentialTargets++; } else { definiteTargets++; } } // // If there were remaining targets that // might be out of date // if (potentialTargets > 0) { log("Starting dependency analysis for " + Integer.toString(potentialTargets) + " files."); final DependencyTable dependencyTable = new DependencyTable(this._objDir); try { dependencyTable.load(); } catch (final Exception ex) { log("Problem reading dependencies.xml: " + ex.toString()); } targetEnum = targets.values().iterator(); while (targetEnum.hasNext()) { final TargetInfo target = targetEnum.next(); if (!target.getRebuild() && dependencyTable.needsRebuild(this, target, this.dependencyDepth)) { target.mustRebuild(); } } dependencyTable.commit(this); } // // count files being rebuilt now // int currentTargets = 0; targetEnum = targets.values().iterator(); while (targetEnum.hasNext()) { final TargetInfo target = targetEnum.next(); if (target.getRebuild()) { currentTargets++; } } if (potentialTargets > 0) { log(Integer.toString(potentialTargets - currentTargets + definiteTargets) + " files are up to date."); log(Integer.toString(currentTargets - definiteTargets) + " files to be recompiled from dependency analysis."); } log(Integer.toString(currentTargets) + " total files to be compiled."); return currentTargets; } protected LinkerConfiguration collectExplicitObjectFiles(final Vector<File> objectFiles, final Vector<File> sysObjectFiles, final VersionInfo versionInfo) { // // find the first eligible linker // // ProcessorConfiguration linkerConfig = null; LinkerDef selectedLinkerDef = null; Linker selectedLinker = null; final Hashtable<String, File> sysLibraries = new Hashtable<>(); final TargetDef targetPlatform = getTargetPlatform(); FileVisitor objCollector = null; FileVisitor sysLibraryCollector = null; for (int i = 0; i < this._linkers.size(); i++) { final LinkerDef currentLinkerDef = this._linkers.elementAt(i); if (currentLinkerDef.isActive()) { selectedLinkerDef = currentLinkerDef; selectedLinker = currentLinkerDef.getProcessor().getLinker(this.linkType); // // skip the linker if it doesn't know how to // produce the specified link type if (selectedLinker != null) { linkerConfig = currentLinkerDef.createConfiguration(this, this.linkType, this.linkerDef, targetPlatform, versionInfo); if (linkerConfig != null) { // // create collectors for object files // and system libraries objCollector = new ObjectFileCollector(selectedLinker, objectFiles); sysLibraryCollector = new SystemLibraryCollector(selectedLinker, sysLibraries); // // if the <linker> has embedded <fileset>'s // (such as linker specific libraries) // add them as object files. // if (currentLinkerDef.hasFileSets()) { currentLinkerDef.visitFiles(objCollector); } // // user libraries are just a specialized form // of an object fileset selectedLinkerDef.visitUserLibraries(selectedLinker, objCollector); } break; } } } if (linkerConfig == null) { linkerConfig = this.linkerDef.createConfiguration(this, this.linkType, null, targetPlatform, versionInfo); selectedLinker = this.linkerDef.getProcessor().getLinker(this.linkType); objCollector = new ObjectFileCollector(selectedLinker, objectFiles); sysLibraryCollector = new SystemLibraryCollector(selectedLinker, sysLibraries); } // // unless there was a <linker> element that // explicitly did not inherit files from // containing <cc> element if (selectedLinkerDef == null || selectedLinkerDef.getInherit()) { this.linkerDef.visitUserLibraries(selectedLinker, objCollector); this.linkerDef.visitSystemLibraries(selectedLinker, sysLibraryCollector); } // // if there was a <syslibset> in a nested <linker> // evaluate it last so it takes priority over // identically named libs from <cc> element // if (selectedLinkerDef != null) { // // add any system libraries to the hashtable // done in reverse order so the earliest // on the classpath takes priority selectedLinkerDef.visitSystemLibraries(selectedLinker, sysLibraryCollector); } // // copy over any system libraries to the // object files vector // final Enumeration<File> sysLibEnum = sysLibraries.elements(); while (sysLibEnum.hasMoreElements()) { sysObjectFiles.addElement(sysLibEnum.nextElement()); } return (LinkerConfiguration) linkerConfig; } /** * Adds an include path. * * Include paths will be inherited by nested compiler elements that do not * have inherit="false". */ public IncludePath createIncludePath() { return this.compilerDef.createIncludePath(); } /** * Specifies precompilation prototype file and exclusions. Inherited by all * compilers that do not have inherit="false". * */ public PrecompileDef createPrecompile() throws BuildException { return this.compilerDef.createPrecompile(); } /** * Adds a system include path. Locations and timestamps of files located * using the system include paths are not used in dependency analysis. * * * Standard include locations should not be specified. The compiler * adapters should recognized the settings from the appropriate environment * variables or configuration files. * * System include paths will be inherited by nested compiler elements that * do not have inherit="false". */ public SystemIncludePath createSysIncludePath() { return this.compilerDef.createSysIncludePath(); } // ENDFREEHEP /** * Executes the task. Compiles the given files. * * @throws BuildException * if someting goes wrong with the build */ @Override public void execute() throws BuildException { // // if link type allowed objdir to be defaulted // provide it from outfile if (this._objDir == null) { if (this._outfile != null) { this._objDir = new File(this._outfile.getParent()); } else { this._objDir = new File("."); } } // // if the object directory does not exist // if (!this._objDir.exists()) { throw new BuildException("Object directory does not exist"); } final TargetHistoryTable objHistory = new TargetHistoryTable(this, this._objDir); // // get the first active version info // VersionInfo versionInfo = null; final Enumeration<VersionInfo> versionEnum = this.versionInfos.elements(); while (versionEnum.hasMoreElements()) { versionInfo = versionEnum.nextElement(); versionInfo = versionInfo.merge(); if (versionInfo.isActive()) { break; } else { versionInfo = null; } } // // determine the eventual linker configuration // (may be null) and collect any explicit // object files or libraries final Vector<File> objectFiles = new Vector<>(); final Vector<File> sysObjectFiles = new Vector<>(); final LinkerConfiguration linkerConfig = collectExplicitObjectFiles(objectFiles, sysObjectFiles, versionInfo); // // Assemble hashtable of all files // that we know how to compile (keyed by output file name) // final Map<String, TargetInfo> targets = getTargets(linkerConfig, objectFiles, versionInfo, this._outfile); TargetInfo linkTarget = null; // // if output file is not specified, // then skip link step // if (this._outfile != null) { linkTarget = getLinkTarget(linkerConfig, objectFiles, sysObjectFiles, targets, versionInfo); } if (this.projects.size() > 0) { final List<File> files = new ArrayList<>(); final ProjectFileCollector matcher = new ProjectFileCollector(files); for (int i = 0; i < this._compilers.size(); i++) { final CompilerDef currentCompilerDef = this._compilers.elementAt(i); if (currentCompilerDef.isActive() && currentCompilerDef.hasFileSets()) { currentCompilerDef.visitFiles(matcher); } } this.compilerDef.visitFiles(matcher); final Enumeration<ProjectDef> iter = this.projects.elements(); while (iter.hasMoreElements()) { final ProjectDef projectDef = iter.nextElement(); if (projectDef.isActive()) { projectDef.execute(this, files, targets, linkTarget); } } } if (this.projectsOnly) { return; } // // mark targets that don't have a history record or // whose source last modification time is not // the same as the history to be rebuilt // objHistory.markForRebuild(targets); final CCTaskProgressMonitor monitor = new CCTaskProgressMonitor(objHistory, versionInfo); // // check for changed include files // final int rebuildCount = checkForChangedIncludeFiles(targets); if (rebuildCount > 0) { BuildException compileException = null; // // compile all targets with getRebuild() == true // final Map<CompilerConfiguration, Vector<TargetInfo>> targetsByConfig = getTargetsToBuildByConfiguration( targets); // // build array containing Vectors with precompiled generation // steps going first // final ArrayList<Vector<TargetInfo>> targetVectorsPreComp = new ArrayList<>(); final ArrayList<Vector<TargetInfo>> targetVectors = new ArrayList<>(); int index = 0; for (final Map.Entry<CompilerConfiguration, Vector<TargetInfo>> targetsForConfig : targetsByConfig .entrySet()) { // // get the configuration from the first entry // final CompilerConfiguration config = targetsForConfig.getKey(); if (config.isPrecompileGeneration()) { targetVectorsPreComp.add(targetsForConfig.getValue()); } else { targetVectors.add(targetsForConfig.getValue()); } } // BEGINFREEHEP final Progress progress = new Progress(getObjdir(), rebuildCount); progress.start(); // ENDFREEHEP compileException = runTargetPool(monitor, compileException, targetVectorsPreComp); if (compileException == null || this.relentless) compileException = runTargetPool(monitor, compileException, targetVectors); // BEGINFREEHEP progress.exit(); try { progress.join(); } catch (final InterruptedException ex) { } // ENDFREEHEP // // save the details of the object file compilation // settings to disk for dependency analysis // try { objHistory.commit(); } catch (final IOException ex) { this.log("Error writing history.xml: " + ex.toString()); } // // if we threw a compile exception and // didn't throw it at the time because // we were relentless then // save the history and // throw the exception // if (compileException != null) { if (this.failOnError) { throw compileException; } else { log(compileException.getMessage(), Project.MSG_ERR); return; } } } // // if the dependency tree was not fully // evaluated, then throw an exception // since we really didn't do what we // should have done // // if (this.dependencyDepth >= 0) { throw new BuildException("All files at depth " + Integer.toString(this.dependencyDepth) + " from changes successfully compiled.\n" + "Remove or change dependencyDepth to -1 to perform full compilation."); } // // if no link target then // commit the history for the object files // and leave the task if (linkTarget != null) { // // get the history for the link target (may be the same // as the object history) final TargetHistoryTable linkHistory = getLinkHistory(objHistory); // // see if it needs to be rebuilt // linkHistory.markForRebuild(linkTarget); // // if it needs to be rebuilt, rebuild it // final File output = linkTarget.getOutput(); if (linkTarget.getRebuild()) { final LinkerConfiguration linkConfig = (LinkerConfiguration) linkTarget.getConfiguration(); // BEGINFREEHEP log("Linking..."); log("Starting link {" + linkConfig.getIdentifier() + "}"); // ENDFREEHEP if (this.failOnError) { linkConfig.link(this, linkTarget); } else { try { linkConfig.link(this, linkTarget); } catch (final BuildException ex) { log(ex.getMessage(), Project.MSG_ERR); return; } } if (this.outputFileProperty != null) { getProject().setProperty(this.outputFileProperty, output.getAbsolutePath()); } linkHistory.update(linkTarget); try { linkHistory.commit(); } catch (final IOException ex) { log("Error writing link history.xml: " + ex.toString()); } } else { if (this.outputFileProperty != null) { getProject().setProperty(this.outputFileProperty, output.getAbsolutePath()); } } } } private BuildException runTargetPool(final CCTaskProgressMonitor monitor, BuildException compileException, final ArrayList<Vector<TargetInfo>> targetVectors) { int index; for (final Vector<TargetInfo> targetsForConfig : targetVectors) { // // get the configuration from the first entry // final CompilerConfiguration config = (CompilerConfiguration) targetsForConfig.elementAt(0) .getConfiguration(); // // prepare the list of source files // // BEGINFREEHEP int noOfCores = Runtime.getRuntime().availableProcessors(); log("Found " + noOfCores + " processors available"); if (this.maxCores > 0) { noOfCores = Math.min(this.maxCores, noOfCores); log("Limited processors to " + noOfCores); } final int noOfFiles = targetsForConfig.size(); if (noOfFiles < noOfCores) { noOfCores = noOfFiles; log("Limited used processors to " + noOfCores); } if (this.ordered) { noOfCores = 1; log("Limited processors to 1 due to ordering of source files"); } final List<String>[] sourceFiles = new List[noOfCores]; for (int j = 0; j < sourceFiles.length; j++) { sourceFiles[j] = new ArrayList<>(noOfFiles / sourceFiles.length); } final Enumeration<TargetInfo> targetsEnum = targetsForConfig.elements(); index = 0; while (targetsEnum.hasMoreElements()) { final TargetInfo targetInfo = targetsEnum.nextElement(); sourceFiles[index++].add(targetInfo.getSources()[0].toString()); index %= sourceFiles.length; } // setup cores/cpus final Core[] cores = new Core[noOfCores]; for (int j = 0; j < cores.length; j++) { cores[j] = new Core(this, j, config, this._objDir, sourceFiles[j], this.relentless, monitor); log("\nStarting Core " + j + " with " + sourceFiles[j].size() + " source files..."); } // starting cores for (final Core core : cores) { core.start(); } // checking cores boolean alive = false; try { do { alive = false; for (int j = 0; j < cores.length; j++) { if (cores[j] != null) { if (cores[j].isAlive()) { alive = true; } else { final Exception exception = cores[j].getException(); if (exception != null) { if (compileException == null && exception instanceof BuildException) { compileException = (BuildException) exception; } else { log(cores[j].getName() + " " + exception + " ", Project.MSG_ERR); } if (!this.relentless) { cores[j] = null; alive = false; break; } } cores[j] = null; } } } if (alive) { // wait for a maximum of 5 seconds or #files*2 seconds. Thread.sleep(Math.min(5000, sourceFiles[0].size() * 2000)); } } while (alive); } catch (final InterruptedException e) { break; } // killing leftovers for (final Core core : cores) { if (core != null) { core.interrupt(); log(core.getName() + " interrupted "); } } if (!this.relentless && compileException != null) { break; } // ENDFREEHEP /* * OLD CODE * String[] sourceFiles = new String[targetsForConfig.size()]; * Enumeration targetsEnum = targetsForConfig.elements(); * index = 0; * while (targetsEnum.hasMoreElements()) { * TargetInfo targetInfo = ((TargetInfo) targetsEnum * .nextElement()); * sourceFiles[index++] = targetInfo.getSources()[0] * .toString(); * } * try { * config.compile(this, _objDir, sourceFiles, relentless, * monitor); * } catch (BuildException ex) { * if (compileException == null) { * compileException = ex; * } * if (!relentless) * break; * } */ } return compileException; } // ENDFREEHEP /** * Get the commandLogLevel * * @return The current commandLogLevel */ public int getCommandLogLevel() { return this.commandLogLevel; } /** * Gets the dataset. * * @return Returns a String */ public String getDataset() { return this.dataset; } /** * Gets debug state. * * @return true if building for debugging */ public boolean getDebug() { return this.compilerDef.getDebug(null, 0); } /** * Gets the failonerror flag. * * @return the failonerror flag */ public boolean getFailonerror() { return this.failOnError; } protected TargetHistoryTable getLinkHistory(final TargetHistoryTable objHistory) { final File outputFileDir = new File(this._outfile.getParent()); // // if the output file is being produced in the link // directory, then we can use the same history file // if (this._objDir.equals(outputFileDir)) { return objHistory; } return new TargetHistoryTable(this, outputFileDir); } protected TargetInfo getLinkTarget(final LinkerConfiguration linkerConfig, final Vector<File> objectFiles, final Vector<File> sysObjectFiles, final Map<String, TargetInfo> compileTargets, final VersionInfo versionInfo) { // // walk the compile phase targets and // add those sources that have already been // assigned to the linker or // our output files the linker knows how to consume // files the linker knows how to consume // for (final TargetInfo compileTarget : compileTargets.values()) { // // output of compile tasks // final int bid = linkerConfig.bid(compileTarget.getOutput().toString()); if (bid > 0) { objectFiles.addElement(compileTarget.getOutput()); } } final File[] objectFileArray = new File[objectFiles.size()]; objectFiles.copyInto(objectFileArray); final File[] sysObjectFileArray = new File[sysObjectFiles.size()]; sysObjectFiles.copyInto(sysObjectFileArray); final String baseName = this._outfile.getName(); final String[] fullNames = linkerConfig.getOutputFileNames(baseName, versionInfo); final File outputFile = new File(this._outfile.getParent(), fullNames[0]); return new TargetInfo(linkerConfig, objectFileArray, sysObjectFileArray, outputFile, linkerConfig.getRebuild()); } public int getMaxCores() { return this.maxCores; } public File getObjdir() { return this._objDir; } public File getOutfile() { return this._outfile; } /** * Gets output type. * * @return output type */ public String getOuttype() { return this.linkType.getOutputType(); } /** * Gets subsystem name. * * @return Subsystem name */ public String getSubsystem() { return this.linkType.getSubsystem(); } public TargetDef getTargetPlatform() { return null; } /** * This method collects a Hashtable, keyed by output file name, of * TargetInfo's for every source file that is specified in the filesets of * the <cc>and nested <compiler>elements. The TargetInfo's contain the * appropriate compiler configurations for their possible compilation * */ private Map<String, TargetInfo> getTargets(final LinkerConfiguration linkerConfig, final Vector<File> objectFiles, final VersionInfo versionInfo, final File outputFile) { // FREEHEP final List<String> order = new ArrayList<>(); final Map<String, TargetInfo> targets = new TreeMap<>(new Comparator<String>() { // Order according to "order" List followed by alphabetical order @Override public int compare(String f0, String f1) { if (order.isEmpty()) { return f0.compareTo(f1); } // Trimming the path and trailing file extension to allow for order // comparison String compf0 = FilenameUtils.getBaseName(f0); String compf1 = FilenameUtils.getBaseName(f1); // remove the hash // TODO: well we hope it's a hash compf0 = FilenameUtils.removeExtension(compf0); compf1 = FilenameUtils.removeExtension(compf1); // order according to list or alphabetical final int i0 = order.indexOf(compf0); final int i1 = order.indexOf(compf1); if (i0 < 0 && i1 < 0) { // none in list // compare original values return f0.compareTo(f1); } else { // make sure we use only one core CCTask.this.ordered = true; if (i0 > 0 && i1 > 0) { // both in list return i0 == i1 ? 0 : i0 < i1 ? -1 : +1; } else if (i1 < 0) { // i0 in list return -1; } else { // i1 in list return +1; } } } }); final TargetDef targetPlatform = getTargetPlatform(); // BEGINFREEHEP // a little trick here, the inner function needs the list to be final, // so that the map order doesn't change after we start adding items, // populate with all the ordered items from each compiler type order.clear(); for (int i = 0; i < this._compilers.size(); i++) { final CompilerDef currentCompilerDef = this._compilers.elementAt(i); if (currentCompilerDef.isActive()) { final List<String> compilerFileOrder = currentCompilerDef.getOrder(); if (compilerFileOrder != null) { order.addAll(compilerFileOrder); } } } // ENDFREEHEP // // find active (specialized) compilers // final Vector<ProcessorConfiguration> biddingProcessors = new Vector<>(this._compilers.size()); for (int i = 0; i < this._compilers.size(); i++) { final CompilerDef currentCompilerDef = this._compilers.elementAt(i); if (currentCompilerDef.isActive()) { final ProcessorConfiguration config = currentCompilerDef.createConfiguration(this, this.linkType, this.compilerDef, targetPlatform, versionInfo); // // see if this processor had a precompile child element // final PrecompileDef precompileDef = currentCompilerDef.getActivePrecompile(this.compilerDef); CommandLineCompilerConfiguration commandLineConfig = (CommandLineCompilerConfiguration) config; AbstractCompiler compiler = (AbstractCompiler) commandLineConfig.getCompiler(); compiler.setWorkDir(currentCompilerDef.getWorkDir()); ProcessorConfiguration[] localConfigs = new ProcessorConfiguration[] { config }; // // if it does then // if (precompileDef != null) { final File prototype = precompileDef.getPrototype(); // // will throw exceptions if prototype doesn't exist, etc // if (!prototype.exists()) { throw new BuildException("prototype (" + prototype.toString() + ") does not exist."); } if (prototype.isDirectory()) { throw new BuildException("prototype (" + prototype.toString() + ") is a directory."); } final String[] exceptFiles = precompileDef.getExceptFiles(); // // create a precompile building and precompile using // variants of the configuration // or return null if compiler doesn't support // precompilation final CompilerConfiguration[] configs = ((CompilerConfiguration) config) .createPrecompileConfigurations(prototype, exceptFiles); if (configs != null && configs.length == 2) { // // visit the precompiled file to add it into the // targets list (just like any other file if // compiler doesn't support precompilation) final TargetMatcher matcher = new TargetMatcher(this, this._objDir, new ProcessorConfiguration[] { configs[0] }, linkerConfig, objectFiles, targets, versionInfo); matcher.visit(new File(prototype.getParent()), prototype.getName()); // // only the configuration that uses the // precompiled header gets added to the bidding list biddingProcessors.addElement(configs[1]); localConfigs = new ProcessorConfiguration[2]; localConfigs[0] = configs[1]; localConfigs[1] = config; } } // // if the compiler has a fileset // then allow it to add its files // to the set of potential targets if (currentCompilerDef.hasFileSets()) { final TargetMatcher matcher = new TargetMatcher(this, this._objDir, localConfigs, linkerConfig, objectFiles, targets, versionInfo); currentCompilerDef.visitFiles(matcher); } biddingProcessors.addElement(config); } } // // add fallback compiler at the end // if (this._compilers.size() == 0) { final ProcessorConfiguration config = this.compilerDef.createConfiguration(this, this.linkType, null, targetPlatform, versionInfo); biddingProcessors.addElement(config); final ProcessorConfiguration[] bidders = new ProcessorConfiguration[biddingProcessors.size()]; biddingProcessors.copyInto(bidders); // // bid out the <fileset>'s in the cctask // final TargetMatcher matcher = new TargetMatcher(this, this._objDir, bidders, linkerConfig, objectFiles, targets, versionInfo); this.compilerDef.visitFiles(matcher); if (outputFile != null && versionInfo != null) { final boolean isDebug = linkerConfig.isDebug(); try { linkerConfig.getLinker().addVersionFiles(versionInfo, this.linkType, outputFile, isDebug, this._objDir, matcher); } catch (final IOException ex) { throw new BuildException(ex); } } } return targets; } public boolean isDecorateLinkerOptions() { return this.decorateLinkerOptions; } /** * Sets the default compiler adapter. Use the "name" attribute when the * compiler is a supported compiler. * * @param classname * fully qualified classname which implements CompilerAdapter */ public void setClassname(final String classname) { this.compilerDef.setClassname(classname); this.linkerDef.setClassname(classname); } /** * Set commandLogLevel * * ( CUtil.runCommand() will honor this... ) * * @param commandLogLevel * The log-level for command-logs, default is MSG_VERBOSE. */ public void setCommandLogLevel(final int commandLogLevel) { this.commandLogLevel = commandLogLevel; } /** * Sets the dataset for OS/390 builds. * * @param dataset * The dataset to set */ public void setDataset(final String dataset) { this.dataset = dataset; } /** * Enables or disables generation of debug info. */ public void setDebug(final boolean debug) { this.compilerDef.setDebug(debug); this.linkerDef.setDebug(debug); } public void setDecorateLinkerOptions(final boolean decorateLinkerOptions) { this.decorateLinkerOptions = decorateLinkerOptions; } /** * Deprecated. * * Controls the depth of the dependency evaluation. Used to do a quick * check of changes before a full build. * * Any negative value which will perform full dependency checking. Positive * values will truncate dependency checking. A value of 0 will cause only * those files that changed to be recompiled, a value of 1 which cause * files that changed or that explicitly include a file that changed to be * recompiled. * * Any non-negative value will cause a BuildException to be thrown before * attempting a link or completing the task. * */ public void setDependencyDepth(final int depth) { this.dependencyDepth = depth; } /** * Enables generation of exception handling code */ public void setExceptions(final boolean exceptions) { this.compilerDef.setExceptions(exceptions); } /** * Indicates whether the build will continue * even if there are compilation errors; defaults to true. * * @param fail * if true halt the build on failure */ public void setFailonerror(final boolean fail) { this.failOnError = fail; } // public LinkType getLinkType() { // return linkType; // } /** * Enables or disables incremental linking. * * @param incremental * new state */ public void setIncremental(final boolean incremental) { this.linkerDef.setIncremental(incremental); } /** * Set use of libtool. * * If set to true, the "libtool " will be prepended to the command line for * compatible processors * * @param libtool * If true, use libtool. */ public void setLibtool(final boolean libtool) { this.compilerDef.setLibtool(libtool); this.linkerDef.setLibtool(libtool); } /** * Sets the output file type. Supported values "executable", "shared", and * "static". Deprecated, specify outtype instead. * * @deprecated */ @Deprecated public void setLink(final OutputTypeEnum outputType) { this.linkType.setOutputType(outputType); } // BEGINFREEHEP public void setLinkCPP(final boolean linkCPP) { this.linkType.setLinkCPP(linkCPP); } public void setLinkFortran(final boolean linkFortran) { this.linkType.setLinkFortran(linkFortran); } public void setLinkFortranMain(final boolean linkFortranMain) { this.linkType.setLinkFortranMain(linkFortranMain); } // ENDFREEHEP // BEGINFREEHEP public void setMaxCores(final int maxCores) { this.maxCores = maxCores; } /** * Enables or disables generation of multithreaded code * * @param multi * If true, generated code may be multithreaded. */ public void setMultithreaded(final boolean multi) { this.compilerDef.setMultithreaded(multi); } // // keep near duplicate comment at CompilerDef.setName in sync // /** * Sets type of the default compiler and linker. * * <table width="100%" border="1"> * <thead>Supported compilers </thead> * <tr> * <td>gcc (default)</td> * <td>GCC C++ compiler</td> * </tr> * <tr> * <td>g++</td> * <td>GCC C++ compiler</td> * </tr> * <tr> * <td>c++</td> * <td>GCC C++ compiler</td> * </tr> * <tr> * <td>g77</td> * <td>GNU FORTRAN compiler</td> * </tr> * <tr> * <td>msvc</td> * <td>Microsoft Visual C++</td> * </tr> * <tr> * <td>bcc</td> * <td>Borland C++ Compiler</td> * </tr> * <tr> * <td>msrc</td> * <td>Microsoft Resource Compiler</td> * </tr> * <tr> * <td>brc</td> * <td>Borland Resource Compiler</td> * </tr> * <tr> * <td>df</td> * <td>Compaq Visual Fortran Compiler</td> * </tr> * <tr> * <td>midl</td> * <td>Microsoft MIDL Compiler</td> * </tr> * <tr> * <td>icl</td> * <td>Intel C++ compiler for Windows (IA-32)</td> * </tr> * <tr> * <td>ecl</td> * <td>Intel C++ compiler for Windows (IA-64)</td> * </tr> * <tr> * <td>icc</td> * <td>Intel C++ compiler for Linux (IA-32)</td> * </tr> * <tr> * <td>ecc</td> * <td>Intel C++ compiler for Linux (IA-64)</td> * </tr> * <tr> * <td>CC</td> * <td>Sun ONE C++ compiler</td> * </tr> * <tr> * <td>aCC</td> * <td>HP aC++ C++ Compiler</td> * </tr> * <tr> * <td>os390</td> * <td>OS390 C Compiler</td> * </tr> * <tr> * <td>os400</td> * <td>Icc Compiler</td> * </tr> * <tr> * <td>sunc89</td> * <td>Sun C89 C Compiler</td> * </tr> * <tr> * <td>xlC</td> * <td>VisualAge C Compiler</td> * </tr> * <tr> * <td>uic</td> * <td>Qt user interface compiler (creates .h, .cpp and moc_*.cpp files).</td> * </tr> * <tr> * <td>moc</td> * <td>Qt meta-object compiler</td> * </tr> * <tr> * <td>xpidl</td> * <td>Mozilla xpidl compiler (creates .h and .xpt files).</td> * </tr> * <tr> * <td>wcl</td> * <td>OpenWatcom C/C++ compiler</td> * </tr> * <tr> * <td>wfl</td> * <td>OpenWatcom FORTRAN compiler</td> * </tr> * </table> * */ public void setName(final CompilerEnum name) { this.compilerDef.setName(name); final Processor compiler = this.compilerDef.getProcessor(); final Linker linker = compiler.getLinker(this.linkType); this.linkerDef.setProcessor(linker); } /** * Do not propagate old environment when new environment variables are * specified. */ public void setNewenvironment(final boolean newenv) { this.compilerDef.setNewenvironment(newenv); for (int i = 0; i < this._compilers.size(); i++) { final CompilerDef currentCompilerDef = this._compilers.elementAt(i); currentCompilerDef.setNewenvironment(newenv); } this.linkerDef.setNewenvironment(newenv); } /** * Sets the destination directory for object files. * * Generally this should be a property expression that evaluates to * distinct debug and release object file directories. * * @param dir * object directory */ public void setObjdir(final File dir) { if (dir == null) { throw new NullPointerException("dir"); } this._objDir = dir; } /** * Sets optimization. * * @param optimization */ public void setOptimize(final OptimizationEnum optimization) { this.compilerDef.setOptimize(optimization); } /** * Sets the output file name. If not specified, the task will only compile * files and not attempt to link. If an extension is not specified, the * task may use a system appropriate extension and prefix, for example, * outfile="example" may result in "libexample.so" being created. * * @param outfile * output file name */ public void setOutfile(final File outfile) { // // if file name was empty, skip link step // if (outfile == null || outfile.toString().length() > 0) { this._outfile = outfile; } } /** * Specifies the name of a property to set with the physical filename that * is produced by the linker */ public void setOutputFileProperty(final String outputFileProperty) { this.outputFileProperty = outputFileProperty; } /** * Sets the output file type. Supported values "executable", "shared", and * "static". */ public void setOuttype(final OutputTypeEnum outputType) { this.linkType.setOutputType(outputType); } // ENDFREEHEP /** * Sets the project. */ @Override public void setProject(final Project project) { super.setProject(project); this.compilerDef.setProject(project); this.linkerDef.setProject(project); } public void setProjectsOnly(final boolean value) { this.projectsOnly = value; } /** * If set to true, all files will be rebuilt. * * @param rebuildAll * If true, all files will be rebuilt. If false, up to * date files will not be rebuilt. */ public void setRebuild(final boolean rebuildAll) { this.compilerDef.setRebuild(rebuildAll); this.linkerDef.setRebuild(rebuildAll); } /** * If set to true, compilation errors will not stop the task until all * files have been attempted. * * @param relentless * If true, don't stop on the first compilation error * */ public void setRelentless(final boolean relentless) { this.relentless = relentless; } /** * Enables run-time type information. */ public void setRtti(final boolean rtti) { this.compilerDef.setRtti(rtti); } /** * Sets the type of runtime library, possible values "dynamic", "static". */ public void setRuntime(final RuntimeType rtlType) { this.linkType.setStaticRuntime(rtlType.getIndex() == 1); } /** * Sets the nature of the subsystem under which that the program will * execute. * * <table width="100%" border="1"> * <thead>Supported subsystems </thead> * <tr> * <td>gui</td> * <td>Graphical User Interface</td> * </tr> * <tr> * <td>console</td> * <td>Command Line Console</td> * </tr> * <tr> * <td>other</td> * <td>Other</td> * </tr> * </table> * * @param subsystem * subsystem * @throws NullPointerException * if subsystem is null */ public void setSubsystem(final SubsystemEnum subsystem) { if (subsystem == null) { throw new NullPointerException("subsystem"); } this.linkType.setSubsystem(subsystem); } /** * Enumerated attribute with the values "none", "severe", "default", * "production", "diagnostic", and "aserror". */ public void setWarnings(final WarningLevelEnum level) { this.compilerDef.setWarnings(level); } }