Tools/Source/Cpptasks/net/sf/antcontrib/cpptasks/LinkerDef.java

   1 /*
   2  *
   3  * Copyright 2002-2004 The Ant-Contrib project
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  */
  17 package net.sf.antcontrib.cpptasks;
  18 import java.io.File;
  19 import java.util.Enumeration;
  20 import java.util.Vector;
  21
  22 import net.sf.antcontrib.cpptasks.compiler.CommandLineLinker;
  23 import net.sf.antcontrib.cpptasks.compiler.LinkType;
  24 import net.sf.antcontrib.cpptasks.compiler.Linker;
  25 import net.sf.antcontrib.cpptasks.compiler.Processor;
  26 import net.sf.antcontrib.cpptasks.compiler.ProcessorConfiguration;
  27 import net.sf.antcontrib.cpptasks.gcc.GccLinker;
  28 import net.sf.antcontrib.cpptasks.types.FlexLong;
  29 import net.sf.antcontrib.cpptasks.types.LibrarySet;
  30 import net.sf.antcontrib.cpptasks.types.LinkerArgument;
  31 import net.sf.antcontrib.cpptasks.types.SystemLibrarySet;
  32
  33 import org.apache.tools.ant.BuildException;
  34 import org.apache.tools.ant.Project;
  35 import org.apache.tools.ant.types.FlexInteger;
  36 /**
  37  * A linker definition. linker elements may be placed either as children of a
  38  * cc element or the project element. A linker element with an id attribute may
  39  * be referenced by linker elements with refid or extends attributes.
  40  *
  41  * @author Adam Murdoch
  42  * @author Curt Arnold
  43  */
  44 public class LinkerDef extends ProcessorDef {
  45     private long base;
  46     private String entry;
  47     private Boolean fixed;
  48     private Boolean incremental;
  49     private final Vector librarySets = new Vector();
  50     private Boolean map;
  51     private int stack;
  52     private final Vector sysLibrarySets = new Vector();
  53     private final Vector versionInfos = new Vector();
  54     private Boolean defaultflag = new Boolean(true);
  55     /**
  56      * Default constructor
  57      *
  58      * @see java.lang.Object#Object()
  59      */
  60     public LinkerDef() {
  61         base = -1;
  62         stack = -1;
  63     }
  64     private void addActiveLibrarySet(Project project, Vector libsets,
  65             Vector srcSets) {
  66         Enumeration srcenum = srcSets.elements();
  67         while (srcenum.hasMoreElements()) {
  68             LibrarySet set = (LibrarySet) srcenum.nextElement();
  69             if (set.isActive(project)) {
  70                 libsets.addElement(set);
  71             }
  72         }
  73     }
  74     private void addActiveSystemLibrarySets(Project project, Vector libsets) {
  75         addActiveLibrarySet(project, libsets, sysLibrarySets);
  76     }
  77     private void addActiveUserLibrarySets(Project project, Vector libsets) {
  78         addActiveLibrarySet(project, libsets, librarySets);
  79     }
  80     /**
  81      * Adds a linker command-line arg.
  82      */
  83     public void addConfiguredLinkerArg(LinkerArgument arg) {
  84         addConfiguredProcessorArg(arg);
  85     }
  86     /**
  87      * Adds a compiler command-line arg.
  88      */
  89     public void addConfiguredLinkerParam(LinkerParam param) {
  90         if (isReference()) {
  91             throw noChildrenAllowed();
  92         }
  93         addConfiguredProcessorParam(param);
  94     }
  95     /**
  96      * Adds a system library set.
  97      */
  98     public void addLibset(LibrarySet libset) {
  99         if (isReference()) {
 100             throw super.noChildrenAllowed();
 101         }
 102         if (libset == null) {
 103             throw new NullPointerException("libset");
 104         }
 105         librarySets.addElement(libset);
 106     }
 107     /**
 108      * Adds a system library set.
 109      */
 110     public void addSyslibset(SystemLibrarySet libset) {
 111         if (isReference()) {
 112             throw super.noChildrenAllowed();
 113         }
 114         if (libset == null) {
 115             throw new NullPointerException("libset");
 116         }
 117         sysLibrarySets.addElement(libset);
 118     }
 119
 120     /**
 121      * Adds desriptive version information to be included in the
 122      * generated file.  The first active version info block will
 123      * be used.
 124      */
 125     public void addConfiguredVersioninfo(VersionInfo newVersionInfo) {
 126         if (isReference()) {
 127             throw noChildrenAllowed();
 128         }
 129         newVersionInfo.setProject(this.getProject());
 130         versionInfos.addElement(newVersionInfo);
 131     }
 132
 133     public ProcessorConfiguration createConfiguration(CCTask task,
 134             LinkType linkType, ProcessorDef baseDef, TargetDef targetPlatform) {
 135         //
 136         //    must combine some local context (the linkType)
 137         //       with the referenced element
 138         //
 139         //    get a pointer to the definition (either local or referenced)
 140         ProcessorDef thisDef = this;
 141         if (isReference()) {
 142             thisDef = ((ProcessorDef) getCheckedRef(ProcessorDef.class,
 143                     "ProcessorDef"));
 144         }
 145         //
 146         //    find the appropriate processor (combines local linkType
 147         //       with possibly remote linker name)
 148         Processor proc = getProcessor();
 149         proc = proc.getLinker(linkType);
 150         ProcessorDef[] defaultProviders = getDefaultProviders(baseDef);
 151         return proc.createConfiguration(task, linkType, defaultProviders,
 152                 thisDef, targetPlatform);
 153     }
 154     public void execute() throws org.apache.tools.ant.BuildException {
 155         throw new org.apache.tools.ant.BuildException(
 156                 "Not an actual task, but looks like one for documentation purposes");
 157     }
 158     /**
 159      * Returns an array of active library sets for this linker definition.
 160      */
 161     public LibrarySet[] getActiveLibrarySets(LinkerDef[] defaultProviders,
 162             int index) {
 163         if (isReference()) {
 164             return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
 165                     .getActiveUserLibrarySets(defaultProviders, index);
 166         }
 167         Project p = getProject();
 168         Vector libsets = new Vector();
 169         for (int i = index; i < defaultProviders.length; i++) {
 170             defaultProviders[i].addActiveUserLibrarySets(p, libsets);
 171             defaultProviders[i].addActiveSystemLibrarySets(p, libsets);
 172         }
 173         addActiveUserLibrarySets(p, libsets);
 174         addActiveSystemLibrarySets(p, libsets);
 175         LibrarySet[] sets = new LibrarySet[libsets.size()];
 176         libsets.copyInto(sets);
 177         return sets;
 178     }
 179     /**
 180      * Returns an array of active library sets for this linker definition.
 181      */
 182     public LibrarySet[] getActiveSystemLibrarySets(
 183             LinkerDef[] defaultProviders, int index) {
 184         if (isReference()) {
 185             return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
 186                     .getActiveUserLibrarySets(defaultProviders, index);
 187         }
 188         Project p = getProject();
 189         Vector libsets = new Vector();
 190         for (int i = index; i < defaultProviders.length; i++) {
 191             defaultProviders[i].addActiveSystemLibrarySets(p, libsets);
 192         }
 193         addActiveSystemLibrarySets(p, libsets);
 194         LibrarySet[] sets = new LibrarySet[libsets.size()];
 195         libsets.copyInto(sets);
 196         return sets;
 197     }
 198     /**
 199      * Returns an array of active library sets for this linker definition.
 200      */
 201     public LibrarySet[] getActiveUserLibrarySets(LinkerDef[] defaultProviders,
 202             int index) {
 203         if (isReference()) {
 204             return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
 205                     .getActiveUserLibrarySets(defaultProviders, index);
 206         }
 207         Project p = getProject();
 208         Vector libsets = new Vector();
 209         for (int i = index; i < defaultProviders.length; i++) {
 210             defaultProviders[i].addActiveUserLibrarySets(p, libsets);
 211         }
 212         addActiveUserLibrarySets(p, libsets);
 213         LibrarySet[] sets = new LibrarySet[libsets.size()];
 214         libsets.copyInto(sets);
 215         return sets;
 216     }
 217     public long getBase(LinkerDef[] defaultProviders, int index) {
 218         if (isReference()) {
 219             return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
 220                     .getBase(defaultProviders, index);
 221         }
 222         if (base <= 0) {
 223             if (defaultProviders != null && index < defaultProviders.length) {
 224                 return defaultProviders[index].getBase(defaultProviders,
 225                         index + 1);
 226             }
 227         }
 228         return base;
 229     }
 230     public Boolean getFixed(LinkerDef[] defaultProviders, int index) {
 231         if (isReference()) {
 232             return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
 233                     .getFixed(defaultProviders, index);
 234         }
 235         if (fixed == null) {
 236             if (defaultProviders != null && index < defaultProviders.length) {
 237                 return defaultProviders[index].getFixed(defaultProviders,
 238                         index + 1);
 239             }
 240         }
 241         return fixed;
 242     }
 243     public boolean getIncremental(LinkerDef[] defaultProviders, int index) {
 244         if (isReference()) {
 245             return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
 246                     .getIncremental(defaultProviders, index);
 247         }
 248         if (incremental != null) {
 249             return incremental.booleanValue();
 250         }
 251         if (defaultProviders != null && index < defaultProviders.length) {
 252             return defaultProviders[index].getIncremental(defaultProviders, index + 1);
 253         }
 254         return false;
 255     }
 256     public boolean getMap(LinkerDef[] defaultProviders, int index) {
 257         if (isReference()) {
 258             return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
 259                     .getMap(defaultProviders, index);
 260         }
 261         if (map != null) {
 262             return map.booleanValue();
 263         }
 264         if (defaultProviders != null && index < defaultProviders.length) {
 265             return defaultProviders[index].getMap(defaultProviders, index + 1);
 266         }
 267         return false;
 268     }
 269     public final Boolean getDefaultflag(LinkerDef[] defaultProviders, int index) {
 270         if (isReference()) {
 271             return ((LinkerDef) getCheckedRef(LinkerDef.class,
 272                   "LinkerDef")).getDefaultflag(defaultProviders, index);
 273         }
 274         return defaultflag;
 275     }
 276     public String getEntry(LinkerDef[] defaultProviders, int index) {
 277         if (isReference()) {
 278             return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
 279                     .getEntry(defaultProviders, index);
 280         }
 281         if (entry != null) {
 282             return entry;
 283         }
 284         if (defaultProviders != null && index < defaultProviders.length) {
 285             return defaultProviders[index].getEntry(defaultProviders, index + 1);
 286         }
 287         return null;
 288     }
 289
 290     public Processor getProcessor() {
 291         Linker linker = (Linker) super.getProcessor();
 292         if (linker == null) {
 293             linker = GccLinker.getInstance();
 294         }
 295         if (getLibtool() && linker instanceof CommandLineLinker) {
 296             CommandLineLinker cmdLineLinker = (CommandLineLinker) linker;
 297             linker = cmdLineLinker.getLibtoolLinker();
 298         }
 299         return linker;
 300     }
 301     public int getStack(LinkerDef[] defaultProviders, int index) {
 302         if (isReference()) {
 303             return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
 304                     .getStack(defaultProviders, index);
 305         }
 306         if (stack < 0) {
 307             if (defaultProviders != null && index < defaultProviders.length) {
 308                 return defaultProviders[index].getStack(defaultProviders,
 309                         index + 1);
 310             }
 311         }
 312         return stack;
 313     }
 314     /**
 315      * Sets the base address. May be specified in either decimal or hex.
 316      *
 317      * @param base
 318      *            base address
 319      *
 320      */
 321     public void setBase(FlexLong base) {
 322         if (isReference()) {
 323             throw tooManyAttributes();
 324         }
 325         this.base = base.longValue();
 326     }
 327     /**
 328      * Sets the starting address.
 329      *
 330      * @param name
 331      *            function name
 332      */
 333     public void setEntry(String entry) {
 334         if (isReference()) {
 335             throw tooManyAttributes();
 336         }
 337         this.entry = entry;
 338     }
 339     /**
 340      * If true, marks the file to be loaded only at its preferred address.
 341      */
 342     public void setFixed(boolean fixed) {
 343         if (isReference()) {
 344             throw tooManyAttributes();
 345         }
 346         this.fixed = booleanValueOf(fixed);
 347     }
 348     /**
 349      * If true, allows incremental linking.
 350      *
 351      */
 352     public void setIncremental(boolean incremental) {
 353         if (isReference()) {
 354             throw tooManyAttributes();
 355         }
 356         this.incremental = booleanValueOf(incremental);
 357     }
 358     /**
 359      * If set to true, a map file will be produced.
 360      */
 361     public void setMap(boolean map) {
 362         if (isReference()) {
 363             throw tooManyAttributes();
 364         }
 365         this.map = booleanValueOf(map);
 366     }
 367     /**
 368      * Sets linker type.
 369      *
 370      *
 371      * <table width="100%" border="1"> <thead>Supported linkers </thead>
 372      * <tr>
 373      * <td>gcc</td>
 374      * <td>Gcc Linker</td>
 375      * </tr>
 376      * <tr>
 377      * <td>g++</td>
 378      * <td>G++ Linker</td>
 379      * </tr>
 380      * <tr>
 381      * <td>ld</td>
 382      * <td>Ld Linker</td>
 383      * </tr>
 384      * <tr>
 385      * <td>ar</td>
 386      * <td>Gcc Librarian</td>
 387      * </tr>
 388      * <tr>
 389      * <td>msvc</td>
 390      * <td>Microsoft Linker</td>
 391      * </tr>
 392      * <tr>
 393      * <td>bcc</td>
 394      * <td>Borland Linker</td>
 395      * </tr>
 396      * <tr>
 397      * <td>df</td>
 398      * <td>Compaq Visual Fortran Linker</td>
 399      * </tr>
 400      * <tr>
 401      * <td>icl</td>
 402      * <td>Intel Linker for Windows (IA-32)</td>
 403      * </tr>
 404      * <tr>
 405      * <td>ecl</td>
 406      * <td>Intel Linker for Windows (IA-64)</td>
 407      * </tr>
 408      * <tr>
 409      * <td>icc</td>
 410      * <td>Intel Linker for Linux (IA-32)</td>
 411      * </tr>
 412      * <tr>
 413      * <td>ecc</td>
 414      * <td>Intel Linker for Linux (IA-64)</td>
 415      * </tr>
 416      * <tr>
 417      * <td>CC</td>
 418      * <td>Sun ONE Linker</td>
 419      * </tr>
 420      * <tr>
 421      * <td>aCC</td>
 422      * <td>HP aC++ Linker</td>
 423      * </tr>
 424      * <tr>
 425      * <td>os390</td>
 426      * <td>OS390 Linker</td>
 427      * </tr>
 428      * <tr>
 429      * <td>os390batch</td>
 430      * <td>OS390 Linker</td>
 431      * </tr>
 432      * <tr>
 433      * <td>os400</td>
 434      * <td>IccLinker</td>
 435      * </tr>
 436      * <tr>
 437      * <td>sunc89</td>
 438      * <td>C89 Linker</td>
 439      * </tr>
 440      * <tr>
 441      * <td>xlC</td>
 442      * <td>VisualAge Linker</td>
 443      * </tr>
 444      * </table>
 445      *
 446      */
 447     public void setName(LinkerEnum name) throws BuildException {
 448         if (isReference()) {
 449             throw tooManyAttributes();
 450         }
 451         Linker linker = name.getLinker();
 452         super.setProcessor(linker);
 453     }
 454     protected void setProcessor(Processor proc) throws BuildException {
 455         Linker linker = null;
 456         if (proc instanceof Linker) {
 457             linker = (Linker) proc;
 458         } else {
 459             LinkType linkType = new LinkType();
 460             linker = proc.getLinker(linkType);
 461         }
 462         super.setProcessor(linker);
 463     }
 464     /**
 465      * Sets stack size in bytes.
 466      */
 467     public void setStack(FlexInteger stack) {
 468         if (isReference()) {
 469             throw tooManyAttributes();
 470         }
 471         this.stack = stack.intValue();
 472     }
 473     public void visitSystemLibraries(Linker linker, FileVisitor libraryVisitor) {
 474         Project p = getProject();
 475         if (p == null) {
 476             throw new java.lang.IllegalStateException("project must be set");
 477         }
 478         if (isReference()) {
 479             LinkerDef master = ((LinkerDef) getCheckedRef(LinkerDef.class,
 480                     "Linker"));
 481             master.visitSystemLibraries(linker, libraryVisitor);
 482         } else {
 483             //
 484             //   if this linker extends another,
 485             //      visit its libraries first
 486             //
 487             LinkerDef extendsDef = (LinkerDef) getExtends();
 488             if (extendsDef != null) {
 489                 extendsDef.visitSystemLibraries(linker, libraryVisitor);
 490             }
 491             if (sysLibrarySets.size() > 0) {
 492                 File[] libpath = linker.getLibraryPath();
 493                 for (int i = 0; i < sysLibrarySets.size(); i++) {
 494                     LibrarySet set = (LibrarySet) sysLibrarySets.elementAt(i);
 495                     if (set.isActive(p)) {
 496                         set.visitLibraries(p, linker, libpath,
 497                                 libraryVisitor);
 498                     }
 499                 }
 500             }
 501         }
 502     }
 503     public void visitUserLibraries(Linker linker, FileVisitor libraryVisitor) {
 504         Project p = getProject();
 505         if (p == null) {
 506             throw new java.lang.IllegalStateException("project must be set");
 507         }
 508         if (isReference()) {
 509             LinkerDef master = ((LinkerDef) getCheckedRef(LinkerDef.class,
 510                     "Linker"));
 511             master.visitUserLibraries(linker, libraryVisitor);
 512         } else {
 513             //
 514             //   if this linker extends another,
 515             //      visit its libraries first
 516             //
 517             LinkerDef extendsDef = (LinkerDef) getExtends();
 518             if (extendsDef != null) {
 519                 extendsDef.visitUserLibraries(linker, libraryVisitor);
 520             }
 521             //
 522             //   visit the user libraries
 523             //
 524             if (librarySets.size() > 0) {
 525                 File[] libpath = linker.getLibraryPath();
 526                 for (int i = 0; i < librarySets.size(); i++) {
 527                     LibrarySet set = (LibrarySet) librarySets.elementAt(i);
 528                     if (set.isActive(p)) {
 529                         set.visitLibraries(p, linker, libpath,
 530                                 libraryVisitor);
 531                     }
 532                 }
 533             }
 534         }
 535     }
 536     /**
 537      * Enables or disables default flags.
 538      *
 539      * @param defaultflag
 540      *            if true, default flags will add to command line.
 541      *
 542      */
 543     public void setDefaultflag(boolean defaultflag) {
 544         if (isReference()) {
 545             throw tooManyAttributes();
 546         }
 547         this.defaultflag = booleanValueOf(defaultflag);
 548     }
 549 }