Bug 1760649: Rearrge to Maven 2 Standard Directory Layout

git-svn-id: file:///home/sven/projects/JOGL/temp/ant-contrib/svn/ant-contrib-code/cpptasks/trunk@121 32d7a393-a5a9-423c-abd3-5d954feb1f2f

1 files changed, 0 insertions, 1410 deletions

diff --git a/src/net/sf/antcontrib/cpptasks/CCTask.java b/src/net/sf/antcontrib/cpptasks/CCTask.java
deleted file mode 100644
index beeed89..0000000
--- a/src/net/sf/antcontrib/cpptasks/CCTask.java
+++ /dev/null
@@ -1,1410 +0,0 @@
-/*
- * 
- * 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.*;
-
-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.ide.ProjectDef;
-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 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 and link task.
- * 
- * <p>
- * This task can compile various source languages and produce executables,
- * shared libraries (aka DLL's) and static libraries. Compiler adaptors are
- * currently available for several C/C++ compilers, FORTRAN, MIDL and Windows
- * Resource files.
- * </p>
- * 
- * 
- * <p>
- * Copyright (c) 2001-2006, 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 Ant's classpath by placing in Ant's lib directory,
- * adding to CLASSPATH environment variable or using the -lib command line option.</li>
- * <li>Add type and task definitions in build file:
- * <ul><li>Ant 1.6 or later: add xmlns:cpptasks="antlib:org.sf.net.antcontrib.cpptasks" to &lt;project&gt; element.</li>
- * <li>Ant 1.5 or later: Add &lt;taskdef resource="cpptasks.tasks"/&gt; and &lt;typedef
- * resource="cpptasks.types"/&gt; to body of &lt;project&gt; element.</li></ul></li>
- * <li>Add &lt;cc/&gt;, &lt;compiler/&gt; and &lt;linker/&gt 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 static 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 class ProjectFileCollector implements FileVisitor {
-        private final List files;
-        /**
-         * Creates a new ProjectFileCollector.
-         * @param files vector for collected files.
-         */
-        public ProjectFileCollector(List files) {
-            this.files = files;
-        }
-        /**
-         * Called for each file to be considered for collection.
-         * @param parentDir parent directory
-         * @param filename filename within directory
-         */
-        public void visit(File parentDir, String filename)  {
-            files.add(new File(parentDir, filename));
-        }
-    }
-    
-    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 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 linker definitions. */
-    private Vector _linkers = new Vector();
-    /** The object directory. */
-    private File _objDir;
-    /** The output file. */
-    private File _outfile;
-    /** The linker definitions. */
-    private final Vector targetPlatforms = new Vector();
-    /** The distributer definitions. */
-    private Vector distributers = new Vector();
-    private final Vector versionInfos = new Vector();
-    private final Vector projects = new Vector();
-    private boolean projectsOnly = false;
-
-    
-    /**
-     * If true, stop build on compile failure.
-     */
-    protected boolean failOnError = true;
-    
-    /**
-     * Content that appears in <cc>and also in <compiler>are maintained by a
-     * captive CompilerDef instance
-     */
-    private final CompilerDef compilerDef = new CompilerDef();
-    /** The OS390 dataset to build to object to */
-    private String dataset;
-    /**
-     * 
-     * Depth of dependency checking
-     * 
-     * Values < 0 indicate full dependency checking Values >= 0 indicate
-     * partial dependency checking and for superficial compilation checks. Will
-     * throw BuildException before attempting link
-     */
-    private int dependencyDepth = -1;
-    /**
-     * Content that appears in <cc>and also in <linker>are maintained by a
-     * captive CompilerDef instance
-     */
-    private final LinkerDef linkerDef = new LinkerDef();
-    /**
-     * contains the subsystem, output type and
-     *  
-     */
-    private final LinkType linkType = new LinkType();
-    /**
-     * The property name which will be set with the physical filename of the
-     * file that is generated by the linker
-     */
-    private String outputFileProperty;
-    /**
-     * if relentless = true, compilations should attempt to compile as many
-     * files as possible before throwing a BuildException
-     */
-    private boolean relentless;
-    public CCTask() {
-    }
-    /**
-     * 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);
-    }
-    /**
-     * 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);
-    }
-    /**
-     * Specifies the generation of IDE project file.  Experimental.
-     * @param projectDef project file generation specification
-     */
-    public void addProject(final ProjectDef projectDef) {
-        if (projectDef == null) {
-            throw new NullPointerException("projectDef");
-        }
-        projects.addElement(projectDef);
-    }
-    public void setProjectsOnly(final boolean value) {
-    	projectsOnly = value;
-    }
-    /**
-     * 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, VersionInfo versionInfo) {
-        //
-        //    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, versionInfo);
-                    if (linkerConfig != null) {
-                        //
-                        //   create collectors for object files
-                        //      and system libraries
-                        objCollector = new ObjectFileCollector(selectedLinker,
-                                objectFiles);
-                        sysLibraryCollector = new SystemLibraryCollector(
-                                selectedLinker, sysLibraries);
-                        //
-                        //    if the <linker> has embedded <fileset>'s
-                        //       (such as linker specific libraries)
-                        //       add them as object files.
-                        //
-                        if (currentLinkerDef.hasFileSets()) {
-                            currentLinkerDef.visitFiles(objCollector);
-                        }
-                        //
-                        //    user libraries are just a specialized form
-                        //       of an object fileset
-                        selectedLinkerDef.visitUserLibraries(selectedLinker,
-                                objCollector);
-                    }
-                    break;
-                }
-            }
-        }
-        if (linkerConfig == null) {
-            linkerConfig = linkerDef.createConfiguration(this, linkType, null, targetPlatform, versionInfo);
-            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");
-        }
-        TargetHistoryTable objHistory = new TargetHistoryTable(this, _objDir);
-
-        //
-        //   get the first active version info
-        //
-        VersionInfo versionInfo = null;
-        Enumeration versionEnum = versionInfos.elements();
-        while (versionEnum.hasMoreElements()) {
-        	versionInfo = (VersionInfo) versionEnum.nextElement();
-        	versionInfo = versionInfo.merge();
-        	if (versionInfo.isActive()) {
-        		break;
-        	} else {
-        		versionInfo = null;
-        	}
-        }
-        
-        
-        //
-        //  determine the eventual linker configuration
-        //      (may be null) and collect any explicit
-        //          object files or libraries
-        Vector objectFiles = new Vector();
-        Vector sysObjectFiles = new Vector();
-        LinkerConfiguration linkerConfig = collectExplicitObjectFiles(
-                objectFiles, sysObjectFiles, versionInfo);
-        
-        
-        //
-        //   Assemble hashtable of all files
-        //       that we know how to compile (keyed by output file name)
-        //
-        Hashtable targets = getTargets(linkerConfig, objectFiles, versionInfo, _outfile);
-        TargetInfo linkTarget = null;
-        //
-        //   if output file is not specified,
-        //      then skip link step
-        //
-        if (_outfile != null) {
-            linkTarget = getLinkTarget(linkerConfig, objectFiles,
-                    sysObjectFiles, targets, versionInfo);
-        }
-        
-        if (projects.size() > 0) {
-        	ArrayList files = new ArrayList();
-        	ProjectFileCollector matcher = new ProjectFileCollector(files);
-            for (int i = 0; i < _compilers.size(); i++) {
-                CompilerDef currentCompilerDef = (CompilerDef) _compilers
-                        .elementAt(i);
-                if (currentCompilerDef.isActive()) {
-                    if (currentCompilerDef.hasFileSets()) {
-                        currentCompilerDef.visitFiles(matcher);
-                    }
-                }
-            }
-            compilerDef.visitFiles(matcher);
-        	
-        	
-        	Enumeration iter = projects.elements();
-        	while (iter.hasMoreElements()) {
-        		ProjectDef projectDef = (ProjectDef) iter.nextElement();
-        		if (projectDef.isActive()) {
-        			projectDef.execute(this, files, targets, linkTarget);
-        		}
-        	}
-        }
-        if (projectsOnly) return;
-      
-        
-        
-        //
-        //     mark targets that don't have a history record or
-        //        whose source last modification time is not
-        //        the same as the history to be rebuilt
-        //
-        objHistory.markForRebuild(targets);
-        CCTaskProgressMonitor monitor = new CCTaskProgressMonitor(objHistory, versionInfo);
-        //
-        //      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, VersionInfo versionInfo) {
-        //
-        //  walk the compile phase targets and
-        //     add those sources that have already been
-        //     assigned to the linker or
-        //     our output files the linker knows how to consume
-        //     files the linker knows how to consume
-        //
-        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());
-            }
-        }
-        File[] objectFileArray = new File[objectFiles.size()];
-        objectFiles.copyInto(objectFileArray);
-        File[] sysObjectFileArray = new File[sysObjectFiles.size()];
-        sysObjectFiles.copyInto(sysObjectFileArray);
-        String baseName = _outfile.getName();
-        String[] fullNames = linkerConfig.getOutputFileNames(baseName, versionInfo);
-        File outputFile = new File(_outfile.getParent(), fullNames[0]);
-        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 <cc>and nested <compiler>elements. The TargetInfo's contain the
-     * appropriate compiler configurations for their possible compilation
-     *  
-     */
-    private Hashtable getTargets(LinkerConfiguration linkerConfig,
-            Vector objectFiles, VersionInfo versionInfo, File outputFile) {
-        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, versionInfo);
-                //
-                //   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, versionInfo);
-     
-                        matcher.visit(new File(prototype.getParent()),
-                                prototype.getName());
-                        //
-                        //   only the configuration that uses the
-                        //      precompiled header gets added to the bidding list
-                        biddingProcessors.addElement(configs[1]);
-                        localConfigs = new ProcessorConfiguration[2];
-                        localConfigs[0] = configs[1];
-                        localConfigs[1] = config;
-                    }
-                }
-                //
-                //   if the compiler has a fileset
-                //       then allow it to add its files
-                //       to the set of potential targets
-                if (currentCompilerDef.hasFileSets()) {
-                    TargetMatcher matcher = new TargetMatcher(this, _objDir,
-                            localConfigs, linkerConfig, objectFiles, targets,
-							versionInfo);
-                    currentCompilerDef.visitFiles(matcher);
-                }
-                biddingProcessors.addElement(config);
-            }
-        }
-        //
-        //    add fallback compiler at the end
-        //
-        ProcessorConfiguration config = compilerDef.createConfiguration(this,
-                linkType, null, targetPlatform, versionInfo);
-        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, versionInfo);
-        compilerDef.visitFiles(matcher);
-        
-        if (outputFile != null && versionInfo != null) {
-        	boolean isDebug = linkerConfig.isDebug();
-    		try {
-    			linkerConfig.getLinker().addVersionFiles(versionInfo, linkType,
-    				outputFile,
-					isDebug,
-    				_objDir, matcher);
-    		} catch(IOException ex) {
-    			throw new BuildException(ex);
-    		}
-        }
-        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);
-    }
-    /**
-     * 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);     
-    }
-    
-    /**
-     * Gets debug state.
-     * @return true if building for debugging
-     */
-    public boolean getDebug() {
-    	return compilerDef.getDebug(null, 0);
-    }
-    
-    /**
-     * 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);
-    }
-    /**
-     * 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>
-     * <tr>
-     * <td>uic</td>
-     * <td>Qt user interface compiler (creates .h, .cpp and moc_*.cpp files).</td>
-     * </tr>
-     * <tr>
-     * <td>moc</td>
-     * <td>Qt meta-object compiler</td>
-     * </tr>
-     * <tr>
-     * <td>xpidl</td>
-     * <td>Mozilla xpidl compiler (creates .h and .xpt files).</td>
-     * </tr>
-     * <tr>
-     * <td>wcl</td>
-     * <td>OpenWatcom C/C++ compiler</td>
-     * </tr>
-     * <tr>
-     * <td>wfl</td>
-     * <td>OpenWatcom FORTRAN compiler</td>
-     * </tr>
-     * </table>
-     *  
-     */
-    public void setName(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);
-    }
-    /**
-     * 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);
-    }
-    
-    /**
-     * Gets output type.
-     * @return output type
-     */
-    public String getOuttype() {
-    	return linkType.getOutputType();
-    }
-    
-    /**
-     * Sets the project.
-     */
-    public void setProject(Project project) {
-        super.setProject(project);
-        compilerDef.setProject(project);
-        linkerDef.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);
-    }
-    /**
-     * 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);
-    }
-    
-    /**
-     * Gets subsystem name.
-     * @return Subsystem name
-     */
-    public String getSubsystem() {
-    	return linkType.getSubsystem();
-    }
-    
-    /**
-     * Enumerated attribute with the values "none", "severe", "default",
-     * "production", "diagnostic", and "failtask".
-     */
-    public void setWarnings(WarningLevelEnum 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 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);
-    }
-    
-    /**
-     * Adds desriptive version information to be included in the
-     * generated file.  The first active version info block will
-     * be used.
-     */
-    public void addConfiguredVersioninfo(VersionInfo newVersionInfo) {
-        newVersionInfo.setProject(this.getProject());
-        versionInfos.addElement(newVersionInfo);
-    }
-    
-}