| /* | |
| * | |
| * Copyright 2001-2005 The Ant-Contrib project | |
| * | |
| * 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 net.sf.antcontrib.cpptasks; | |
| import java.io.File; | |
| import java.io.IOException; | |
| import java.util.Enumeration; | |
| import java.util.Hashtable; | |
| import java.util.Iterator; | |
| import java.util.Vector; | |
| import net.sf.antcontrib.cpptasks.compiler.AslcompilerConfiguration; | |
| import net.sf.antcontrib.cpptasks.compiler.AssemblerConfiguration; | |
| import net.sf.antcontrib.cpptasks.compiler.CompilerConfiguration; | |
| import net.sf.antcontrib.cpptasks.compiler.LinkType; | |
| import net.sf.antcontrib.cpptasks.compiler.Linker; | |
| import net.sf.antcontrib.cpptasks.compiler.LinkerConfiguration; | |
| import net.sf.antcontrib.cpptasks.compiler.Processor; | |
| import net.sf.antcontrib.cpptasks.compiler.ProcessorConfiguration; | |
| import net.sf.antcontrib.cpptasks.types.AslcompilerArgument; | |
| import net.sf.antcontrib.cpptasks.types.AssemblerArgument; | |
| import net.sf.antcontrib.cpptasks.types.CompilerArgument; | |
| import net.sf.antcontrib.cpptasks.types.ConditionalFileSet; | |
| import net.sf.antcontrib.cpptasks.types.DefineSet; | |
| import net.sf.antcontrib.cpptasks.types.IncludePath; | |
| import net.sf.antcontrib.cpptasks.types.LibrarySet; | |
| import net.sf.antcontrib.cpptasks.types.LinkerArgument; | |
| import net.sf.antcontrib.cpptasks.types.SystemIncludePath; | |
| import net.sf.antcontrib.cpptasks.types.SystemLibrarySet; | |
| import net.sf.antcontrib.cpptasks.userdefine.UserDefineCompiler; | |
| import net.sf.antcontrib.cpptasks.userdefine.UserDefineDef; | |
| import net.sf.antcontrib.cpptasks.VersionInfo; | |
| 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; | |
| /** | |
| * Compile, link, assembler and asl compile 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. Assembler adaptors are currently available for MASM and GAS. | |
| * And aslcompiler support to ASL and IASL command. | |
| * </p> | |
| * | |
| * | |
| * <p> | |
| * Copyright (c) 2001-2005, The Ant-Contrib project. | |
| * </p> | |
| * | |
| * <p> | |
| * Licensed under the Apache Software License 2.0, | |
| * http://www.apache.org/licenses/LICENSE-2.0. | |
| * </p> | |
| * | |
| * <p> | |
| * For use with Apache Ant 1.5 or later. This software is not a product of the | |
| * of the Apache Software Foundation and no endorsement is implied. | |
| * </p> | |
| * | |
| * <p> | |
| * THIS SOFTWARE IS PROVIDED 'AS-IS', See | |
| * http://www.apache.org/licenses/LICENSE-2.0 for additional disclaimers. | |
| * </p> | |
| * | |
| * To use: | |
| * <ol> | |
| * <li>Place cpptasks.jar into the lib directory of Ant 1.5 or later.</li> | |
| * <li>Add <taskdef resource="cpptasks.tasks"/> and <typedef | |
| * resource="cpptasks.types"/> to build.xml.</li> | |
| * <li>Add <cc/>, <compiler/> <linker/> <assembler/> | |
| * and <aslcompiler/> elements to project.</li> | |
| * <li>Set path and environment variables to be able to run compiler from | |
| * command line.</li> | |
| * <li>Build project.</li> | |
| * </ol> | |
| * | |
| * @author Adam Murdoch | |
| * @author Curt Arnold | |
| */ | |
| public class CCTask extends Task { | |
| private class SystemLibraryCollector implements FileVisitor { | |
| private Hashtable libraries; | |
| private Linker linker; | |
| public SystemLibraryCollector (Linker linker, Hashtable libraries) { | |
| this.linker = linker; | |
| this.libraries = libraries; | |
| } | |
| public void visit(File basedir, String filename) { | |
| if (linker.bid(filename) > 0) { | |
| File libfile = new File(basedir, filename); | |
| String key = linker.getLibraryKey(libfile); | |
| 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 Hashtable getTargetsToBuildByConfiguration(Hashtable targets) { | |
| Hashtable targetsByConfig = new Hashtable(); | |
| Enumeration targetEnum = targets.elements(); | |
| while (targetEnum.hasMoreElements()) { | |
| TargetInfo target = (TargetInfo) targetEnum.nextElement(); | |
| if (target.getRebuild()) { | |
| Vector targetsForSameConfig = (Vector) targetsByConfig | |
| .get(target.getConfiguration()); | |
| if (targetsForSameConfig != null) { | |
| targetsForSameConfig.addElement(target); | |
| } else { | |
| targetsForSameConfig = new Vector(); | |
| targetsForSameConfig.addElement(target); | |
| targetsByConfig.put(target.getConfiguration(), | |
| targetsForSameConfig); | |
| } | |
| } | |
| } | |
| return targetsByConfig; | |
| } | |
| /** The userdefine definitions. */ | |
| private Vector _userdefines = new Vector(); | |
| /** The compiler definitions. */ | |
| private Vector _compilers = new Vector(); | |
| /** The output file type. */ | |
| // private LinkType _linkType = LinkType.EXECUTABLE; | |
| /** The library sets. */ | |
| private Vector _libsets = new Vector(); | |
| /** The aslcompiler definitions. */ | |
| private Vector _aslcompiler = new Vector(); | |
| /** The assembler definitions. */ | |
| private Vector _assemblers = new Vector(); | |
| /** The linker definitions. */ | |
| private Vector _linkers = new Vector(); | |
| /** The object directory. */ | |
| private File _objDir; | |
| /** The output file. */ | |
| private File _outfile; | |
| private boolean userdefine = false; | |
| private String arch; | |
| private String os; | |
| private String vendor; | |
| /** the flag for assembler */ | |
| private boolean assembler = true; | |
| /** the flag for aslcompiler */ | |
| private boolean aslcompiler = true; | |
| /** The linker definitions. */ | |
| private final Vector targetPlatforms = new Vector(); | |
| /** The distributer definitions. */ | |
| private Vector distributers = new Vector(); | |
| /** | |
| * 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(); | |
| /** | |
| * Content that appears in <cc>and also in <aslcompiler>are maintained by a | |
| * captive AslcompilerDef instance | |
| */ | |
| private final AslcompilerDef aslcompilerDef = new AslcompilerDef(); | |
| /** 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 <assembler>are maintained by a | |
| * captive AssemblerDef instance | |
| */ | |
| private final AssemblerDef assemblerDef = new AssemblerDef(); | |
| /** | |
| * 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; | |
| public CCTask () { | |
| } | |
| public void addConfiguredCommand(UserDefineDef userdefineDef) { | |
| if (userdefineDef == null) { | |
| throw new NullPointerException("UserDefineDef"); | |
| } | |
| userdefineDef.setProject(getProject()); | |
| _userdefines.addElement(userdefineDef); | |
| } | |
| /** | |
| * Adds a asl compiler definition or reference. | |
| * | |
| * @param Aslcompiler | |
| * aslcompiler | |
| * @throws NullPointerException | |
| * if aslcompiler is null | |
| */ | |
| public void addConfiguredAslcompiler(AslcompilerDef aslcompier) { | |
| if (aslcompier == null) { | |
| throw new NullPointerException("aslcompier"); | |
| } | |
| aslcompier.setProject(getProject()); | |
| _aslcompiler.addElement(aslcompier); | |
| } | |
| /** | |
| * Adds a asl command-line arg. Argument will be inherited by all nested | |
| * aslcompiler elements that do not have inherit="false". | |
| * | |
| */ | |
| public void addConfiguredAslcompilerArg(AslcompilerArgument arg) { | |
| aslcompilerDef.addConfiguredAslcompilerArg(arg); | |
| } | |
| /** | |
| * Adds a assembler definition or reference. | |
| * | |
| * @param assembler | |
| * assemblera | |
| * @throws NullPointerException | |
| * if assembler is null | |
| */ | |
| public void addConfiguredAssembler(AssemblerDef assembler) { | |
| if (assembler == null) { | |
| throw new NullPointerException("assembler"); | |
| } | |
| assembler.setProject(getProject()); | |
| _assemblers.addElement(assembler); | |
| } | |
| /** | |
| * Adds a assembler command-line arg. Argument will be inherited by all | |
| * nested assembler elements that do not have inherit="false". | |
| * | |
| */ | |
| public void addConfiguredAssemblerArg(AssemblerArgument arg) { | |
| assemblerDef.addConfiguredAssemblerArg(arg); | |
| } | |
| /** | |
| * Adds a compiler definition or reference. | |
| * | |
| * @param compiler | |
| * compiler | |
| * @throws NullPointerException | |
| * if compiler is null | |
| */ | |
| public void addConfiguredCompiler(CompilerDef compiler) { | |
| if (compiler == null) { | |
| throw new NullPointerException("compiler"); | |
| } | |
| compiler.setProject(getProject()); | |
| _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(CompilerArgument arg) { | |
| 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(DefineSet defs) { | |
| compilerDef.addConfiguredDefineset(defs); | |
| } | |
| /** | |
| * 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(LinkerDef linker) { | |
| if (linker == null) { | |
| throw new NullPointerException("linker"); | |
| } | |
| linker.setProject(getProject()); | |
| _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(LinkerArgument arg) { | |
| linkerDef.addConfiguredLinkerArg(arg); | |
| } | |
| /** | |
| * Add an environment variable to the launched process. | |
| */ | |
| public void addEnv(Environment.Variable var) { | |
| compilerDef.addEnv(var); | |
| linkerDef.addEnv(var); | |
| assemblerDef.addEnv(var); | |
| aslcompilerDef.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(ConditionalFileSet srcSet) { | |
| 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(LibrarySet libset) { | |
| if (libset == null) { | |
| throw new NullPointerException("libset"); | |
| } | |
| linkerDef.addLibset(libset); | |
| } | |
| /** | |
| * 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(SystemLibrarySet libset) { | |
| if (libset == null) { | |
| throw new NullPointerException("libset"); | |
| } | |
| 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 | |
| * | |
| * @returns total number of targets to be rebuilt | |
| * | |
| */ | |
| protected int checkForChangedIncludeFiles(Hashtable targets) { | |
| int potentialTargets = 0; | |
| int definiteTargets = 0; | |
| Enumeration targetEnum = targets.elements(); | |
| while (targetEnum.hasMoreElements()) { | |
| TargetInfo target = (TargetInfo) targetEnum.nextElement(); | |
| 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."); | |
| DependencyTable dependencyTable = new DependencyTable(_objDir); | |
| try { | |
| dependencyTable.load(); | |
| } catch (Exception ex) { | |
| log("Problem reading dependencies.xml: " + ex.toString()); | |
| } | |
| targetEnum = targets.elements(); | |
| while (targetEnum.hasMoreElements()) { | |
| TargetInfo target = (TargetInfo) targetEnum.nextElement(); | |
| if (!target.getRebuild()) { | |
| if (dependencyTable.needsRebuild(this, target, | |
| dependencyDepth)) { | |
| target.mustRebuild(); | |
| } | |
| } | |
| } | |
| dependencyTable.commit(this); | |
| } | |
| // | |
| // count files being rebuilt now | |
| // | |
| int currentTargets = 0; | |
| targetEnum = targets.elements(); | |
| while (targetEnum.hasMoreElements()) { | |
| TargetInfo target = (TargetInfo) targetEnum.nextElement(); | |
| 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( | |
| Vector objectFiles, Vector sysObjectFiles) { | |
| // | |
| // find the first eligible linker | |
| // | |
| // | |
| ProcessorConfiguration linkerConfig = null; | |
| LinkerDef selectedLinkerDef = null; | |
| Linker selectedLinker = null; | |
| Hashtable sysLibraries = new Hashtable(); | |
| TargetDef targetPlatform = getTargetPlatform(); | |
| FileVisitor objCollector = null; | |
| FileVisitor sysLibraryCollector = null; | |
| for (int i = 0; i < _linkers.size(); i++) { | |
| LinkerDef currentLinkerDef = (LinkerDef) _linkers.elementAt(i); | |
| if (currentLinkerDef.isActive()) { | |
| selectedLinkerDef = currentLinkerDef; | |
| selectedLinker = currentLinkerDef.getProcessor().getLinker( | |
| linkType); | |
| // | |
| // skip the linker if it doesn't know how to | |
| // produce the specified link type | |
| if (selectedLinker != null) { | |
| linkerConfig = currentLinkerDef.createConfiguration(this, | |
| linkType, linkerDef, targetPlatform); | |
| 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 = linkerDef.createConfiguration(this, linkType, null, | |
| targetPlatform); | |
| selectedLinker = (Linker) linkerDef.getProcessor().getLinker( | |
| 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()) { | |
| linkerDef.visitUserLibraries(selectedLinker, objCollector); | |
| 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 | |
| // | |
| Enumeration 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 compilerDef.createIncludePath(); | |
| } | |
| /** | |
| * Specifies precompilation prototype file and exclusions. Inherited by all | |
| * compilers that do not have inherit="false". | |
| * | |
| */ | |
| public PrecompileDef createPrecompile() throws BuildException { | |
| return 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 compilerDef.createSysIncludePath(); | |
| } | |
| /** | |
| * Executes the task. Compiles the given files. | |
| * | |
| * @throws BuildException | |
| * if someting goes wrong with the build | |
| */ | |
| public void execute() throws BuildException { | |
| // | |
| // if link type allowed objdir to be defaulted | |
| // provide it from outfile | |
| if (_objDir == null) { | |
| if (_outfile != null) { | |
| _objDir = new File(_outfile.getParent()); | |
| } else { | |
| _objDir = new File("."); | |
| } | |
| } | |
| // | |
| // if the object directory does not exist | |
| // | |
| if (!_objDir.exists()) { | |
| throw new BuildException("Object directory does not exist"); | |
| } | |
| // | |
| // if userdefine is true, then run all user defined command | |
| // | |
| if (userdefine) { | |
| Iterator iter = _userdefines.iterator(); | |
| while( iter.hasNext()) { | |
| UserDefineDef userdefineDef = (UserDefineDef)iter.next(); | |
| UserDefineCompiler userdefineCompiler = new UserDefineCompiler(this, userdefineDef); | |
| userdefineCompiler.command(this, userdefineDef); | |
| } | |
| return ; | |
| } | |
| TargetHistoryTable objHistory = new TargetHistoryTable(this, _objDir); | |
| // | |
| // determine the eventual linker configuration | |
| // (may be null) and collect any explicit | |
| // object files or libraries | |
| Vector objectFiles = new Vector(); | |
| Vector sysObjectFiles = new Vector(); | |
| LinkerConfiguration linkerConfig = collectExplicitObjectFiles( | |
| objectFiles, sysObjectFiles); | |
| // | |
| // Assembler hashtable of all files | |
| // that we know how to compile (keyed by output file name) | |
| // | |
| Hashtable targets = getTargets(linkerConfig, objectFiles); | |
| Hashtable acpiTarget = new Hashtable(); | |
| if (aslcompiler) { | |
| acpiTarget = getAcpiTargets(linkerConfig, new Vector()); | |
| } | |
| Hashtable assemblerTarget = new Hashtable(); | |
| if (assembler) { | |
| assemblerTarget = getAssemblerTargets(linkerConfig, objectFiles); | |
| } | |
| TargetInfo linkTarget = null; | |
| // | |
| // if output file is not specified, | |
| // then skip link step | |
| // | |
| if (_outfile != null) { | |
| linkTarget = getLinkTarget(linkerConfig, objectFiles, | |
| sysObjectFiles, targets, assemblerTarget); | |
| } | |
| // | |
| // If specify the aslcompiler, then call asl compiler | |
| // | |
| if (aslcompiler) { | |
| BuildException acpiException = null; | |
| Hashtable targetsByConfig = getTargetsToBuildByConfiguration(acpiTarget); | |
| Enumeration acpiTargetEnum = targetsByConfig.elements(); | |
| Vector[] targetVectors = new Vector[targetsByConfig.size()]; | |
| int index = 0; | |
| while (acpiTargetEnum.hasMoreElements()) { | |
| Vector targetsForConfig = (Vector) acpiTargetEnum.nextElement(); | |
| targetVectors[index++] = targetsForConfig; | |
| } | |
| for (int i = 0; i < targetVectors.length; i++) { | |
| // | |
| // get the targets for this configuration | |
| // | |
| Vector targetsForConfig = targetVectors[i]; | |
| // | |
| // get the configuration from the first entry | |
| // | |
| AslcompilerConfiguration config = (AslcompilerConfiguration) ((TargetInfo) targetsForConfig | |
| .elementAt(0)).getConfiguration(); | |
| // | |
| // prepare the list of source files | |
| // | |
| 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.aslcompiler(this, _objDir, sourceFiles); | |
| log(sourceFiles.length | |
| + " total ACPI source files to be compiled."); | |
| } catch (BuildException ex) { | |
| if (acpiException == null) { | |
| acpiException = ex; | |
| } | |
| if (!relentless) | |
| break; | |
| } | |
| } | |
| } | |
| // | |
| // If specify the assembler, then call assembler | |
| // | |
| if (assembler) { | |
| BuildException assemblerException = null; | |
| Hashtable targetsByConfig = getTargetsToBuildByConfiguration(assemblerTarget); | |
| Enumeration assembleTargetEnum = targetsByConfig.elements(); | |
| Vector[] targetVectors = new Vector[targetsByConfig.size()]; | |
| int index = 0; | |
| while (assembleTargetEnum.hasMoreElements()) { | |
| Vector targetsForConfig = (Vector) assembleTargetEnum | |
| .nextElement(); | |
| targetVectors[index++] = targetsForConfig; | |
| } | |
| for (int i = 0; i < targetVectors.length; i++) { | |
| // | |
| // get the targets for this configuration | |
| // | |
| Vector targetsForConfig = targetVectors[i]; | |
| // | |
| // get the configuration from the first entry | |
| // | |
| AssemblerConfiguration config = (AssemblerConfiguration) ((TargetInfo) targetsForConfig | |
| .elementAt(0)).getConfiguration(); | |
| // | |
| // prepare the list of source files | |
| // | |
| 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.assembler(this, _objDir, sourceFiles); | |
| log(sourceFiles.length + " total files to be assembled."); | |
| } catch (BuildException ex) { | |
| if (assemblerException == null) { | |
| assemblerException = ex; | |
| } | |
| if (!relentless) | |
| break; | |
| } | |
| } | |
| // | |
| // if we threw a assembler exception and | |
| // didn't throw it at the time because | |
| // we were relentless then | |
| // save the history and | |
| // throw the exception | |
| // | |
| if (assemblerException != null) { | |
| if (failOnError) { | |
| throw assemblerException; | |
| } else { | |
| log(assemblerException.getMessage(), Project.MSG_ERR); | |
| 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); | |
| CCTaskProgressMonitor monitor = new CCTaskProgressMonitor(objHistory); | |
| // | |
| // check for changed include files | |
| // | |
| int rebuildCount = checkForChangedIncludeFiles(targets); | |
| if (rebuildCount > 0) { | |
| BuildException compileException = null; | |
| // | |
| // compile all targets with getRebuild() == true | |
| // | |
| Hashtable targetsByConfig = getTargetsToBuildByConfiguration(targets); | |
| // | |
| // build array containing Vectors with precompiled generation | |
| // steps going first | |
| // | |
| Vector[] targetVectors = new Vector[targetsByConfig.size()]; | |
| int index = 0; | |
| Enumeration targetVectorEnum = targetsByConfig.elements(); | |
| while (targetVectorEnum.hasMoreElements()) { | |
| Vector targetsForConfig = (Vector) targetVectorEnum | |
| .nextElement(); | |
| // | |
| // get the configuration from the first entry | |
| // | |
| CompilerConfiguration config = (CompilerConfiguration) ((TargetInfo) targetsForConfig | |
| .elementAt(0)).getConfiguration(); | |
| if (config.isPrecompileGeneration()) { | |
| targetVectors[index++] = targetsForConfig; | |
| } | |
| } | |
| targetVectorEnum = targetsByConfig.elements(); | |
| while (targetVectorEnum.hasMoreElements()) { | |
| Vector targetsForConfig = (Vector) targetVectorEnum | |
| .nextElement(); | |
| for (int i = 0; i < targetVectors.length; i++) { | |
| if (targetVectors[i] == targetsForConfig) { | |
| break; | |
| } | |
| if (targetVectors[i] == null) { | |
| targetVectors[i] = targetsForConfig; | |
| break; | |
| } | |
| } | |
| } | |
| for (int i = 0; i < targetVectors.length; i++) { | |
| // | |
| // get the targets for this configuration | |
| // | |
| Vector targetsForConfig = targetVectors[i]; | |
| // | |
| // get the configuration from the first entry | |
| // | |
| CompilerConfiguration config = (CompilerConfiguration) ((TargetInfo) targetsForConfig | |
| .elementAt(0)).getConfiguration(); | |
| // | |
| // prepare the list of source files | |
| // | |
| 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; | |
| } | |
| } | |
| // | |
| // save the details of the object file compilation | |
| // settings to disk for dependency analysis | |
| // | |
| try { | |
| objHistory.commit(); | |
| } catch (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 (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 (dependencyDepth >= 0) { | |
| throw new BuildException( | |
| "All files at depth " | |
| + Integer.toString(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) | |
| TargetHistoryTable linkHistory = getLinkHistory(objHistory); | |
| // | |
| // see if it needs to be rebuilt | |
| // | |
| linkHistory.markForRebuild(linkTarget); | |
| // | |
| // if it needs to be rebuilt, rebuild it | |
| // | |
| File output = linkTarget.getOutput(); | |
| if (linkTarget.getRebuild()) { | |
| log("Starting link"); | |
| LinkerConfiguration linkConfig = (LinkerConfiguration) linkTarget | |
| .getConfiguration(); | |
| if (failOnError) { | |
| linkConfig.link(this, linkTarget); | |
| } else { | |
| try { | |
| linkConfig.link(this, linkTarget); | |
| } catch (BuildException ex) { | |
| log(ex.getMessage(), Project.MSG_ERR); | |
| return; | |
| } | |
| } | |
| if (outputFileProperty != null) | |
| getProject().setProperty(outputFileProperty, | |
| output.getAbsolutePath()); | |
| linkHistory.update(linkTarget); | |
| try { | |
| linkHistory.commit(); | |
| } catch (IOException ex) { | |
| log("Error writing link history.xml: " + ex.toString()); | |
| } | |
| } else { | |
| if (outputFileProperty != null) | |
| getProject().setProperty(outputFileProperty, | |
| output.getAbsolutePath()); | |
| } | |
| } | |
| } | |
| /** | |
| * Gets the dataset. | |
| * | |
| * @return Returns a String | |
| */ | |
| public String getDataset() { | |
| return dataset; | |
| } | |
| protected TargetHistoryTable getLinkHistory(TargetHistoryTable objHistory) { | |
| File outputFileDir = new File(_outfile.getParent()); | |
| // | |
| // if the output file is being produced in the link | |
| // directory, then we can use the same history file | |
| // | |
| if (_objDir.equals(outputFileDir)) { | |
| return objHistory; | |
| } | |
| return new TargetHistoryTable(this, outputFileDir); | |
| } | |
| protected TargetInfo getLinkTarget(LinkerConfiguration linkerConfig, | |
| Vector objectFiles, Vector sysObjectFiles, | |
| Hashtable compileTargets, Hashtable assemblerTargets) { | |
| // | |
| // 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 | |
| // | |
| Enumeration compileTargetsEnum = compileTargets.elements(); | |
| while (compileTargetsEnum.hasMoreElements()) { | |
| TargetInfo compileTarget = (TargetInfo) compileTargetsEnum | |
| .nextElement(); | |
| // | |
| // output of compile tasks | |
| // | |
| int bid = linkerConfig.bid(compileTarget.getOutput().toString()); | |
| if (bid > 0) { | |
| objectFiles.addElement(compileTarget.getOutput()); | |
| } | |
| } | |
| // | |
| // walk the assembler 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 | |
| // | |
| Enumeration assembleTargetsEnum = assemblerTargets.elements(); | |
| while (assembleTargetsEnum.hasMoreElements()) { | |
| TargetInfo assemblerTarget = (TargetInfo) assembleTargetsEnum | |
| .nextElement(); | |
| // | |
| // output of assemble tasks | |
| // | |
| int bid = linkerConfig.bid(assemblerTarget.getOutput().toString()); | |
| if (bid > 0) { | |
| objectFiles.addElement(assemblerTarget.getOutput()); | |
| } | |
| } | |
| File[] objectFileArray = new File[objectFiles.size()]; | |
| objectFiles.copyInto(objectFileArray); | |
| File[] sysObjectFileArray = new File[sysObjectFiles.size()]; | |
| sysObjectFiles.copyInto(sysObjectFileArray); | |
| String baseName = _outfile.getName(); | |
| String fullName = linkerConfig.getOutputFileName(baseName); | |
| File outputFile = new File(_outfile.getParent(), fullName); | |
| return new TargetInfo(linkerConfig, objectFileArray, | |
| sysObjectFileArray, outputFile, linkerConfig | |
| .getRebuild()); | |
| } | |
| public File getObjdir() { | |
| return _objDir; | |
| } | |
| public File getOutfile() { | |
| return _outfile; | |
| } | |
| 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 <aslcompiler> elements. The TargetInfo's contain the appropriate ACPI | |
| * configurations for their possible acpi | |
| * | |
| */ | |
| private Hashtable getAcpiTargets(LinkerConfiguration linkerConfig, | |
| Vector objectFiles) { | |
| Hashtable targets = new Hashtable(1000); | |
| TargetDef targetPlatform = getTargetPlatform(); | |
| Vector biddingProcessors = new Vector(_aslcompiler.size()); | |
| for (int i = 0; i < _aslcompiler.size(); i++) { | |
| AslcompilerDef currentAslDef = (AslcompilerDef) _aslcompiler | |
| .elementAt(i); | |
| if (currentAslDef.isActive()) { | |
| ProcessorConfiguration config = currentAslDef | |
| .createConfiguration(this, linkType, | |
| aslcompilerDef, targetPlatform); | |
| // | |
| // if the aslcompiler has a fileset | |
| // then allow it to add its files to | |
| // the set of potential targets | |
| // | |
| ProcessorConfiguration[] localConfigs = new ProcessorConfiguration[] { config }; | |
| if (currentAslDef.hasFileSets()) { | |
| TargetMatcher matcher = new TargetMatcher(this, _objDir, | |
| localConfigs, linkerConfig, objectFiles, | |
| targets); | |
| currentAslDef.visitFiles(matcher); | |
| } | |
| biddingProcessors.addElement(config); | |
| } | |
| } | |
| // | |
| // add fallback compiler at the end | |
| // | |
| ProcessorConfiguration config = aslcompilerDef.createConfiguration( | |
| this, linkType, null, targetPlatform); | |
| biddingProcessors.addElement(config); | |
| ProcessorConfiguration[] bidders = new ProcessorConfiguration[biddingProcessors | |
| .size()]; | |
| biddingProcessors.copyInto(bidders); | |
| TargetMatcher matcher = new TargetMatcher(this, _objDir, bidders, | |
| linkerConfig, objectFiles, targets); | |
| aslcompilerDef.visitFiles(matcher); | |
| return targets; | |
| } | |
| /** | |
| * 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 <assembler> elements. The TargetInfo's contain the appropriate | |
| * assembler configurations for their possible assembly | |
| * | |
| */ | |
| private Hashtable getAssemblerTargets(LinkerConfiguration linkerConfig, | |
| Vector objectFiles) { | |
| Hashtable targets = new Hashtable(1000); | |
| TargetDef targetPlatform = getTargetPlatform(); | |
| Vector biddingProcessors = new Vector(_assemblers.size()); | |
| for (int i = 0; i < _assemblers.size(); i++) { | |
| AssemblerDef currentAssemblerDef = (AssemblerDef) _assemblers | |
| .elementAt(i); | |
| if (currentAssemblerDef.isActive()) { | |
| ProcessorConfiguration config = currentAssemblerDef | |
| .createConfiguration(this, linkType, | |
| assemblerDef, targetPlatform); | |
| // | |
| // if the assembler has a fileset | |
| // then allow it to add its files to | |
| // the set of potential targets | |
| // | |
| ProcessorConfiguration[] localConfigs = new ProcessorConfiguration[] { config }; | |
| if (currentAssemblerDef.hasFileSets()) { | |
| TargetMatcher matcher = new TargetMatcher(this, _objDir, | |
| localConfigs, linkerConfig, objectFiles, | |
| targets); | |
| currentAssemblerDef.visitFiles(matcher); | |
| } | |
| biddingProcessors.addElement(config); | |
| } | |
| } | |
| // | |
| // add fallback assembler at the end | |
| // | |
| ProcessorConfiguration config = assemblerDef.createConfiguration(this, | |
| linkType, null, targetPlatform); | |
| biddingProcessors.addElement(config); | |
| ProcessorConfiguration[] bidders = new ProcessorConfiguration[biddingProcessors | |
| .size()]; | |
| biddingProcessors.copyInto(bidders); | |
| TargetMatcher matcher = new TargetMatcher(this, _objDir, bidders, | |
| linkerConfig, objectFiles, targets); | |
| assemblerDef.visitFiles(matcher); | |
| return targets; | |
| } | |
| /** | |
| * 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 Hashtable getTargets(LinkerConfiguration linkerConfig, | |
| Vector objectFiles) { | |
| Hashtable targets = new Hashtable(1000); | |
| TargetDef targetPlatform = getTargetPlatform(); | |
| // | |
| // find active (specialized) compilers | |
| // | |
| Vector biddingProcessors = new Vector(_compilers.size()); | |
| for (int i = 0; i < _compilers.size(); i++) { | |
| CompilerDef currentCompilerDef = (CompilerDef) _compilers | |
| .elementAt(i); | |
| if (currentCompilerDef.isActive()) { | |
| ProcessorConfiguration config = currentCompilerDef | |
| .createConfiguration(this, linkType, | |
| compilerDef, targetPlatform); | |
| // | |
| // see if this processor had a precompile child element | |
| // | |
| PrecompileDef precompileDef = currentCompilerDef | |
| .getActivePrecompile(compilerDef); | |
| ProcessorConfiguration[] localConfigs = new ProcessorConfiguration[] { config }; | |
| // | |
| // if it does then | |
| // | |
| if (precompileDef != null) { | |
| 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."); | |
| } | |
| String[] exceptFiles = precompileDef.getExceptFiles(); | |
| // | |
| // create a precompile building and precompile using | |
| // variants of the configuration | |
| // or return null if compiler doesn't support | |
| // precompilation | |
| 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) | |
| TargetMatcher matcher = new TargetMatcher( | |
| this, | |
| _objDir, | |
| new ProcessorConfiguration[] { configs[0] }, | |
| linkerConfig, objectFiles, targets); | |
| 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()) { | |
| TargetMatcher matcher = new TargetMatcher(this, _objDir, | |
| localConfigs, linkerConfig, objectFiles, | |
| targets); | |
| currentCompilerDef.visitFiles(matcher); | |
| } | |
| biddingProcessors.addElement(config); | |
| } | |
| } | |
| // | |
| // add fallback compiler at the end | |
| // | |
| ProcessorConfiguration config = compilerDef.createConfiguration(this, | |
| linkType, null, targetPlatform); | |
| biddingProcessors.addElement(config); | |
| ProcessorConfiguration[] bidders = new ProcessorConfiguration[biddingProcessors | |
| .size()]; | |
| biddingProcessors.copyInto(bidders); | |
| // | |
| // bid out the <fileset>'s in the cctask | |
| // | |
| TargetMatcher matcher = new TargetMatcher(this, _objDir, bidders, | |
| linkerConfig, objectFiles, targets); | |
| compilerDef.visitFiles(matcher); | |
| return targets; | |
| } | |
| /** | |
| * 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(String classname) { | |
| compilerDef.setClassname(classname); | |
| linkerDef.setClassname(classname); | |
| assemblerDef.setClassname(classname); | |
| aslcompilerDef.setClassname(classname); | |
| } | |
| /** | |
| * Sets the dataset for OS/390 builds. | |
| * | |
| * @param dataset | |
| * The dataset to set | |
| */ | |
| public void setDataset(String dataset) { | |
| this.dataset = dataset; | |
| } | |
| /** | |
| * Enables or disables generation of debug info. | |
| */ | |
| public void setDebug(boolean debug) { | |
| compilerDef.setDebug(debug); | |
| linkerDef.setDebug(debug); | |
| assemblerDef.setDebug(debug); | |
| aslcompilerDef.setDebug(debug); | |
| } | |
| /** | |
| * 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(int depth) { | |
| dependencyDepth = depth; | |
| } | |
| /** | |
| * Enables generation of exception handling code | |
| */ | |
| public void setExceptions(boolean exceptions) { | |
| compilerDef.setExceptions(exceptions); | |
| } | |
| /** | |
| * Enables run-time type information. | |
| */ | |
| public void setRtti(boolean rtti) { | |
| compilerDef.setRtti(rtti); | |
| } | |
| // public LinkType getLinkType() { | |
| // return linkType; | |
| // } | |
| /** | |
| * Enables or disables incremental linking. | |
| * | |
| * @param incremental | |
| * new state | |
| */ | |
| public void setIncremental(boolean incremental) { | |
| 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(boolean libtool) { | |
| compilerDef.setLibtool(libtool); | |
| linkerDef.setLibtool(libtool); | |
| assemblerDef.setLibtool(libtool); | |
| aslcompilerDef.setLibtool(libtool); | |
| } | |
| /** | |
| * Sets the output file type. Supported values "executable", "shared", and | |
| * "static". Deprecated, specify outtype instead. | |
| * | |
| * @deprecated | |
| */ | |
| public void setLink(OutputTypeEnum outputType) { | |
| linkType.setOutputType(outputType); | |
| } | |
| /** | |
| * Enables or disables generation of multithreaded code | |
| * | |
| * @param multi | |
| * If true, generated code may be multithreaded. | |
| */ | |
| public void setMultithreaded(boolean multi) { | |
| 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> | |
| * </table> | |
| * | |
| */ | |
| public void setName(CompilerEnum name) { | |
| compilerDef.setName(name); | |
| Processor compiler = compilerDef.getProcessor(); | |
| Linker linker = compiler.getLinker(linkType); | |
| linkerDef.setProcessor(linker); | |
| } | |
| /** | |
| * Do not propagate old environment when new environment variables are | |
| * specified. | |
| */ | |
| public void setNewenvironment(boolean newenv) { | |
| compilerDef.setNewenvironment(newenv); | |
| linkerDef.setNewenvironment(newenv); | |
| assemblerDef.setNewenvironment(newenv); | |
| aslcompilerDef.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(File dir) { | |
| if (dir == null) { | |
| throw new NullPointerException("dir"); | |
| } | |
| _objDir = dir; | |
| } | |
| /** | |
| * 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(File outfile) { | |
| // | |
| // if file name was empty, skip link step | |
| // | |
| if (outfile == null || outfile.toString().length() > 0) { | |
| _outfile = outfile; | |
| } | |
| } | |
| /** | |
| * Specifies the name of a property to set with the physical filename that | |
| * is produced by the linker | |
| */ | |
| public void setOutputFileProperty(String outputFileProperty) { | |
| this.outputFileProperty = outputFileProperty; | |
| } | |
| /** | |
| * Sets the output file type. Supported values "executable", "shared", and | |
| * "static". | |
| */ | |
| public void setOuttype(OutputTypeEnum outputType) { | |
| linkType.setOutputType(outputType); | |
| } | |
| /** | |
| * Sets the project. | |
| */ | |
| public void setProject(Project project) { | |
| super.setProject(project); | |
| compilerDef.setProject(project); | |
| linkerDef.setProject(project); | |
| assemblerDef.setProject(project); | |
| aslcompilerDef.setProject(project); | |
| } | |
| /** | |
| * If set to true, all files will be rebuilt. | |
| * | |
| * @paran rebuildAll If true, all files will be rebuilt. If false, up to | |
| * date files will not be rebuilt. | |
| */ | |
| public void setRebuild(boolean rebuildAll) { | |
| compilerDef.setRebuild(rebuildAll); | |
| linkerDef.setRebuild(rebuildAll); | |
| assemblerDef.setRebuild(rebuildAll); | |
| aslcompilerDef.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(boolean relentless) { | |
| this.relentless = relentless; | |
| } | |
| /** | |
| * Sets the type of runtime library, possible values "dynamic", "static". | |
| */ | |
| public void setRuntime(RuntimeType rtlType) { | |
| 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(SubsystemEnum subsystem) { | |
| if (subsystem == null) { | |
| throw new NullPointerException("subsystem"); | |
| } | |
| linkType.setSubsystem(subsystem); | |
| } | |
| /** | |
| * Enumerated attribute with the values "none", "severe", "default", | |
| * "production", "diagnostic", and "failtask". | |
| */ | |
| public void setWarnings(CompilerDef.WarningLevel level) { | |
| compilerDef.setWarnings(level); | |
| } | |
| /** | |
| * 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(boolean fail) { | |
| failOnError = fail; | |
| } | |
| /** | |
| * Gets the failonerror flag. | |
| * | |
| * @return the failonerror flag | |
| */ | |
| public boolean getFailonerror() { | |
| return failOnError; | |
| } | |
| /** | |
| * Adds descriptive version information to be included in the generated | |
| * file. The first active version info block will be used. (Non-functional | |
| * prototype) | |
| */ | |
| public void addConfiguredVersioninfo(VersionInfo info) { | |
| linkerDef.addConfiguredVersioninfo(info); | |
| } | |
| /** | |
| * Adds a target definition or reference (Non-functional prototype). | |
| * | |
| * @param target | |
| * target | |
| * @throws NullPointerException | |
| * if compiler is null | |
| */ | |
| public void addConfiguredTarget(TargetDef target) { | |
| if (target == null) { | |
| throw new NullPointerException("target"); | |
| } | |
| target.setProject(getProject()); | |
| targetPlatforms.addElement(target); | |
| } | |
| /** | |
| * Adds a distributer definition or reference (Non-functional prototype). | |
| * | |
| * @param distributer | |
| * distributer | |
| * @throws NullPointerException | |
| * if compiler is null | |
| */ | |
| public void addConfiguredDistributer(DistributerDef distributer) { | |
| if (distributer == null) { | |
| throw new NullPointerException("distributer"); | |
| } | |
| distributer.setProject(getProject()); | |
| distributers.addElement(distributer); | |
| } | |
| /** | |
| * Sets optimization. | |
| * @param optimization | |
| */ | |
| public void setOptimize(OptimizationEnum optimization) { | |
| compilerDef.setOptimize(optimization); | |
| } | |
| public boolean isAssembler() { | |
| return assembler; | |
| } | |
| public void setAssembler(boolean assembler) { | |
| this.assembler = assembler; | |
| } | |
| public boolean isAslcompiler() { | |
| return aslcompiler; | |
| } | |
| public void setAslcompiler(boolean aslcompiler) { | |
| this.aslcompiler = aslcompiler; | |
| } | |
| public boolean isUserdefine() { | |
| return userdefine; | |
| } | |
| public void setUserdefine(boolean userdefine) { | |
| this.userdefine = userdefine; | |
| } | |
| public String getArch() { | |
| return arch; | |
| } | |
| public void setArch(String arch) { | |
| this.arch = arch; | |
| } | |
| public String getOs() { | |
| return os; | |
| } | |
| public void setOs(String os) { | |
| this.os = os; | |
| } | |
| public String getVendor() { | |
| return vendor; | |
| } | |
| public void setVendor(String vendor) { | |
| this.vendor = vendor; | |
| } | |
| } |