/*
*
* 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;
}
}