Clover coverage report - Ant Coverage
Coverage timestamp: Tue Apr 8 2003 20:43:55 EST
file stats: LOC: 2,053   Methods: 125
NCLOC: 1,119   Classes: 12
 
 Source file Conditionals Statements Methods TOTAL
Javadoc.java 0% 0% 0% 0%
 1   
 /*
 2   
  * The Apache Software License, Version 1.1
 3   
  *
 4   
  * Copyright (c) 2000-2003 The Apache Software Foundation.  All rights
 5   
  * reserved.
 6   
  *
 7   
  * Redistribution and use in source and binary forms, with or without
 8   
  * modification, are permitted provided that the following conditions
 9   
  * are met:
 10   
  *
 11   
  * 1. Redistributions of source code must retain the above copyright
 12   
  *    notice, this list of conditions and the following disclaimer.
 13   
  *
 14   
  * 2. Redistributions in binary form must reproduce the above copyright
 15   
  *    notice, this list of conditions and the following disclaimer in
 16   
  *    the documentation and/or other materials provided with the
 17   
  *    distribution.
 18   
  *
 19   
  * 3. The end-user documentation included with the redistribution, if
 20   
  *    any, must include the following acknowlegement:
 21   
  *       "This product includes software developed by the
 22   
  *        Apache Software Foundation (http://www.apache.org/)."
 23   
  *    Alternately, this acknowlegement may appear in the software itself,
 24   
  *    if and wherever such third-party acknowlegements normally appear.
 25   
  *
 26   
  * 4. The names "Ant" and "Apache Software
 27   
  *    Foundation" must not be used to endorse or promote products derived
 28   
  *    from this software without prior written permission. For written
 29   
  *    permission, please contact apache@apache.org.
 30   
  *
 31   
  * 5. Products derived from this software may not be called "Apache"
 32   
  *    nor may "Apache" appear in their names without prior written
 33   
  *    permission of the Apache Group.
 34   
  *
 35   
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 36   
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 37   
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 38   
  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 39   
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 40   
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 41   
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 42   
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 43   
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 44   
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 45   
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 46   
  * SUCH DAMAGE.
 47   
  * ====================================================================
 48   
  *
 49   
  * This software consists of voluntary contributions made by many
 50   
  * individuals on behalf of the Apache Software Foundation.  For more
 51   
  * information on the Apache Software Foundation, please see
 52   
  * <http://www.apache.org/>.
 53   
  */
 54   
 package org.apache.tools.ant.taskdefs;
 55   
 
 56   
 import java.io.File;
 57   
 import java.io.FileWriter;
 58   
 import java.io.FilenameFilter;
 59   
 import java.io.IOException;
 60   
 import java.io.PrintWriter;
 61   
 import java.io.BufferedReader;
 62   
 import java.io.FileReader;
 63   
 import java.net.MalformedURLException;
 64   
 import java.net.URL;
 65   
 import java.util.Enumeration;
 66   
 import java.util.Locale;
 67   
 import java.util.StringTokenizer;
 68   
 import java.util.Vector;
 69   
 import org.apache.tools.ant.BuildException;
 70   
 import org.apache.tools.ant.DirectoryScanner;
 71   
 import org.apache.tools.ant.Project;
 72   
 import org.apache.tools.ant.ProjectComponent;
 73   
 import org.apache.tools.ant.Task;
 74   
 import org.apache.tools.ant.types.Commandline;
 75   
 import org.apache.tools.ant.types.DirSet;
 76   
 import org.apache.tools.ant.types.EnumeratedAttribute;
 77   
 import org.apache.tools.ant.types.FileSet;
 78   
 import org.apache.tools.ant.types.Path;
 79   
 import org.apache.tools.ant.types.PatternSet;
 80   
 import org.apache.tools.ant.types.Reference;
 81   
 import org.apache.tools.ant.util.FileUtils;
 82   
 import org.apache.tools.ant.util.JavaEnvUtils;
 83   
 
 84   
 /**
 85   
  * Generates Javadoc documentation for a collection
 86   
  * of source code.
 87   
  *
 88   
  * <P>Current known limitations are:
 89   
  *
 90   
  * <P><UL>
 91   
  *    <LI>patterns must be of the form "xxx.*", every other pattern doesn't
 92   
  *        work.
 93   
  *    <LI>there is no control on arguments sanity since they are left
 94   
  *        to the javadoc implementation.
 95   
  *    <LI>argument J in javadoc1 is not supported (what is that for anyway?)
 96   
  * </UL>
 97   
  *
 98   
  * <P>If no <CODE>doclet</CODE> is set, then the <CODE>version</CODE> and
 99   
  * <CODE>author</CODE> are by default <CODE>"yes"</CODE>.
 100   
  *
 101   
  * <P>Note: This task is run on another VM because the Javadoc code calls
 102   
  * <CODE>System.exit()</CODE> which would break Ant functionality.
 103   
  *
 104   
  * @author Jon S. Stevens <a href="mailto:jon@clearink.com">jon@clearink.com</a>
 105   
  * @author Stefano Mazzocchi
 106   
  *         <a href="mailto:stefano@apache.org">stefano@apache.org</a>
 107   
  * @author Patrick Chanezon
 108   
  *         <a href="mailto:chanezon@netscape.com">chanezon@netscape.com</a>
 109   
  * @author Ernst de Haan <a href="mailto:ernst@jollem.com">ernst@jollem.com</a>
 110   
  * @author Stefan Bodewig
 111   
  *
 112   
  * @since Ant 1.1
 113   
  *
 114   
  * @ant.task category="java"
 115   
  */
 116   
 public class Javadoc extends Task {
 117   
     /**
 118   
      * Inner class used to manage doclet parameters.
 119   
      */
 120   
     public class DocletParam {
 121   
         /** The parameter name */
 122   
         private String name;
 123   
 
 124   
         /** The parameter value */
 125   
         private String value;
 126   
 
 127   
         /**
 128   
          * Set the name of the parameter.
 129   
          *
 130   
          * @param name the name of the doclet parameter
 131   
          */
 132  0
         public void setName(String name) {
 133  0
             this.name = name;
 134   
         }
 135   
 
 136   
         /**
 137   
          * Get the parameter name.
 138   
          *
 139   
          * @return the parameter's name.
 140   
          */
 141  0
         public String getName() {
 142  0
             return name;
 143   
         }
 144   
 
 145   
         /**
 146   
          * Set the parameter value.
 147   
          *
 148   
          * Note that only string values are supported. No resolution of file
 149   
          * paths is performed.
 150   
          *
 151   
          * @param value the parameter value.
 152   
          */
 153  0
         public void setValue(String value) {
 154  0
             this.value = value;
 155   
         }
 156   
 
 157   
         /**
 158   
          * Get the parameter value.
 159   
          *
 160   
          * @return the parameter value.
 161   
          */
 162  0
         public String getValue() {
 163  0
             return value;
 164   
         }
 165   
     }
 166   
 
 167   
     /**
 168   
      * A project aware class used for Javadoc extensions which take a name
 169   
      * and a path such as doclet and taglet arguments.
 170   
      *
 171   
      * @author Conor MacNeill
 172   
      */
 173   
     public static class ExtensionInfo extends ProjectComponent {
 174   
         /** The name of the extension */
 175   
         private String name;
 176   
 
 177   
         /** The optional path to use to load the extension */
 178   
         private Path path;
 179   
 
 180   
         /**
 181   
          * Set the name of the extension
 182   
          *
 183   
          * @param name the extension's name.
 184   
          */
 185  0
         public void setName(String name) {
 186  0
             this.name = name;
 187   
         }
 188   
 
 189   
         /**
 190   
          * Get the name of the extension.
 191   
          *
 192   
          * @return the extension's name.
 193   
          */
 194  0
         public String getName() {
 195  0
             return name;
 196   
         }
 197   
 
 198   
         /**
 199   
          * Set the path to use when loading the component.
 200   
          *
 201   
          * @param path a Path instance containing the classpath to use.
 202   
          */
 203  0
         public void setPath(Path path) {
 204  0
             if (this.path == null) {
 205  0
                 this.path = path;
 206   
             } else {
 207  0
                 this.path.append(path);
 208   
             }
 209   
         }
 210   
 
 211   
         /**
 212   
          * Get the extension's path.
 213   
          *
 214   
          * @return the path to be used to load the extension.
 215   
          * May be <code>null</code>
 216   
          */
 217  0
         public Path getPath() {
 218  0
             return path;
 219   
         }
 220   
 
 221   
         /**
 222   
          * Create an empty nested path to be configured by Ant with the
 223   
          * classpath for the extension.
 224   
          *
 225   
          * @return a new Path instance to be configured.
 226   
          */
 227  0
         public Path createPath() {
 228  0
             if (path == null) {
 229  0
                 path = new Path(getProject());
 230   
             }
 231  0
             return path.createPath();
 232   
         }
 233   
 
 234   
         /**
 235   
          * Adds a reference to a CLASSPATH defined elsewhere.
 236   
          *
 237   
          * @param r the reference containing the path.
 238   
          */
 239  0
         public void setPathRef(Reference r) {
 240  0
             createPath().setRefid(r);
 241   
         }
 242   
     }
 243   
 
 244   
     /**
 245   
      * This class stores info about doclets.
 246   
      *
 247   
      * @author Conor MacNeill
 248   
      */
 249   
     public class DocletInfo extends ExtensionInfo {
 250   
 
 251   
         /** Collection of doclet parameters. */
 252   
         private Vector params = new Vector();
 253   
 
 254   
         /**
 255   
          * Create a doclet parameter to be configured by Ant.
 256   
          *
 257   
          * @return a new DocletParam instance to be configured.
 258   
          */
 259  0
         public DocletParam createParam() {
 260  0
             DocletParam param = new DocletParam();
 261  0
             params.addElement(param);
 262   
 
 263  0
             return param;
 264   
         }
 265   
 
 266   
         /**
 267   
          * Get the doclet's parameters.
 268   
          *
 269   
          * @return an Enumeration of DocletParam instances.
 270   
          */
 271  0
         public Enumeration getParams() {
 272  0
             return params.elements();
 273   
         }
 274   
     }
 275   
 
 276   
     /**
 277   
      * Used to track info about the packages to be javadoc'd
 278   
      */
 279   
     public static class PackageName {
 280   
         /** The package name */
 281   
         private String name;
 282   
 
 283   
         /**
 284   
          * Set the name of the package
 285   
          *
 286   
          * @param name the package name.
 287   
          */
 288  0
         public void setName(String name) {
 289  0
             this.name = name.trim();
 290   
         }
 291   
 
 292   
         /**
 293   
          * Get the package name.
 294   
          *
 295   
          * @return the package's name.
 296   
          */
 297  0
         public String getName() {
 298  0
             return name;
 299   
         }
 300   
 
 301   
         /**
 302   
          * @see java.lang.Object#toString
 303   
          */
 304  0
         public String toString() {
 305  0
             return getName();
 306   
         }
 307   
     }
 308   
 
 309   
     /**
 310   
      * This class is used to manage the source files to be processed.
 311   
      */
 312   
     public static class SourceFile {
 313   
         /** The source file */
 314   
         private File file;
 315   
 
 316  0
         public SourceFile() {}
 317  0
         public SourceFile(File file) {
 318  0
             this.file = file;
 319   
         }
 320   
 
 321   
         /**
 322   
          * Set the source file.
 323   
          *
 324   
          * @param file the source file.
 325   
          */
 326  0
         public void setFile(File file) {
 327  0
             this.file = file;
 328   
         }
 329   
 
 330   
         /**
 331   
          * Get the source file.
 332   
          *
 333   
          * @return the source file.
 334   
          */
 335  0
         public File getFile() {
 336  0
             return file;
 337   
         }
 338   
     }
 339   
 
 340   
     /**
 341   
      * An HTML element in the javadoc.
 342   
      *
 343   
      * This class is used for those javadoc elements which contain HTML such as
 344   
      * footers, headers, etc.
 345   
      */
 346   
     public static class Html {
 347   
         /** The text for the element */
 348   
         private StringBuffer text = new StringBuffer();
 349   
 
 350   
         /**
 351   
          * Add text to the element.
 352   
          *
 353   
          * @param t the text to be added.
 354   
          */
 355  0
         public void addText(String t) {
 356  0
             text.append(t);
 357   
         }
 358   
 
 359   
         /**
 360   
          * Get the current text for the element.
 361   
          *
 362   
          * @return the current text.
 363   
          */
 364  0
         public String getText() {
 365  0
             return text.substring(0);
 366   
         }
 367   
     }
 368   
 
 369   
     /**
 370   
      * EnumeratedAttribute implementation supporting the javadoc scoping
 371   
      * values.
 372   
      */
 373   
     public static class AccessType extends EnumeratedAttribute {
 374   
         /**
 375   
          * @see EnumeratedAttribute#getValues().
 376   
          */
 377  0
         public String[] getValues() {
 378   
             // Protected first so if any GUI tool offers a default
 379   
             // based on enum #0, it will be right.
 380  0
             return new String[] {"protected", "public", "package", "private"};
 381   
         }
 382   
     }
 383   
 
 384   
     /** The command line built to execute Javadoc. */
 385   
     private Commandline cmd = new Commandline();
 386   
 
 387   
     /** Flag which indicates if javadoc from JDK 1.1 is to be used. */
 388   
     private static boolean javadoc1 =
 389   
         JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_1);
 390   
 
 391   
     /** Flag which indicates if javadoc from JDK 1.4 is available */
 392   
     private static boolean javadoc4 =
 393   
         (!JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_1) &&
 394   
          !JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_2) &&
 395   
          !JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_3));
 396   
 
 397   
     /**
 398   
      * Utility method to add an argument to the command line conditionally
 399   
      * based on the given flag.
 400   
      *
 401   
      * @param b the flag which controls if the argument is added.
 402   
      * @param arg the argument value.
 403   
      */
 404  0
     private void addArgIf(boolean b, String arg) {
 405  0
         if (b) {
 406  0
             cmd.createArgument().setValue(arg);
 407   
         }
 408   
     }
 409   
 
 410   
     /**
 411   
      * Utility method to add a non JDK1.1 javadoc argument.
 412   
      *
 413   
      * @param key the argument name.
 414   
      * @param value the argument value.
 415   
      */
 416  0
     private void add12ArgIfNotEmpty(String key, String value) {
 417  0
         if (!javadoc1) {
 418  0
             if (value != null && value.length() != 0) {
 419  0
                 cmd.createArgument().setValue(key);
 420  0
                 cmd.createArgument().setValue(value);
 421   
             } else {
 422  0
                 log("Warning: Leaving out empty argument '" + key + "'",
 423   
                     Project.MSG_WARN);
 424   
             }
 425   
         }
 426   
     }
 427   
 
 428   
     /**
 429   
      * Utility method to add a non-JDK1.1 argument to the command line
 430   
      * conditionally based on the given flag.
 431   
      *
 432   
      * @param b the flag which controls if the argument is added.
 433   
      * @param arg the argument value.
 434   
      */
 435  0
     private void add12ArgIf(boolean b, String arg) {
 436  0
         if (!javadoc1 && b) {
 437  0
             cmd.createArgument().setValue(arg);
 438   
         }
 439   
     }
 440   
 
 441   
     /**
 442   
      * Flag which indicates if the task should fail if there is a
 443   
      * javadoc error.
 444   
      */
 445   
     private boolean failOnError = false;
 446   
     private Path sourcePath = null;
 447   
     private File destDir = null;
 448   
     private Vector sourceFiles = new Vector();
 449   
     private Vector packageNames = new Vector(5);
 450   
     private Vector excludePackageNames = new Vector(1);
 451   
     private boolean author = true;
 452   
     private boolean version = true;
 453   
     private DocletInfo doclet = null;
 454   
     private Path classpath = null;
 455   
     private Path bootclasspath = null;
 456   
     private String group = null;
 457   
     private String packageList = null;
 458   
     private Vector links = new Vector(2);
 459   
     private Vector groups = new Vector(2);
 460   
     private Vector tags = new Vector(5);
 461   
     private boolean useDefaultExcludes = true;
 462   
     private Html doctitle = null;
 463   
     private Html header = null;
 464   
     private Html footer = null;
 465   
     private Html bottom = null;
 466   
     private boolean useExternalFile = false;
 467   
     private FileUtils fileUtils = FileUtils.newFileUtils();
 468   
     private String source = null;
 469   
 
 470   
     private Vector fileSets = new Vector();
 471   
     private Vector packageSets = new Vector();
 472   
 
 473   
     /**
 474   
      * Work around command line length limit by using an external file
 475   
      * for the sourcefiles.
 476   
      *
 477   
      * @param b true if an external file is to be used.
 478   
      */
 479  0
     public void setUseExternalFile(boolean b) {
 480  0
         if (!javadoc1) {
 481  0
             useExternalFile = b;
 482   
         }
 483   
     }
 484   
 
 485   
     /**
 486   
      * Sets whether default exclusions should be used or not.
 487   
      *
 488   
      * @param useDefaultExcludes "true"|"on"|"yes" when default exclusions
 489   
      *                           should be used, "false"|"off"|"no" when they
 490   
      *                           shouldn't be used.
 491   
      */
 492  0
     public void setDefaultexcludes(boolean useDefaultExcludes) {
 493  0
         this.useDefaultExcludes = useDefaultExcludes;
 494   
     }
 495   
 
 496   
     /**
 497   
      * Set the maximum memory to be used by the javadoc process
 498   
      *
 499   
      * @param max a string indicating the maximum memory according to the
 500   
      *        JVM conventions (e.g. 128m is 128 Megabytes)
 501   
      */
 502  0
     public void setMaxmemory(String max){
 503  0
         if (javadoc1) {
 504  0
             cmd.createArgument().setValue("-J-mx" + max);
 505   
         } else {
 506  0
             cmd.createArgument().setValue("-J-Xmx" + max);
 507   
         }
 508   
     }
 509   
 
 510   
     /**
 511   
      * Set an additional parameter on the command line
 512   
      *
 513   
      * @param add the additional command line parameter for the javadoc task.
 514   
      */
 515  0
     public void setAdditionalparam(String add){
 516  0
         cmd.createArgument().setLine(add);
 517   
     }
 518   
 
 519   
     /**
 520   
      * Specify where to find source file
 521   
      *
 522   
      * @param src a Path instance containing the various source directories.
 523   
      */
 524  0
     public void setSourcepath(Path src) {
 525  0
         if (sourcePath == null) {
 526  0
             sourcePath = src;
 527   
         } else {
 528  0
             sourcePath.append(src);
 529   
         }
 530   
     }
 531   
 
 532   
     /**
 533   
      * Create a path to be configured with the locations of the source
 534   
      * files.
 535   
      *
 536   
      * @return a new Path instance to be configured by the Ant core.
 537   
      */
 538  0
     public Path createSourcepath() {
 539  0
         if (sourcePath == null) {
 540  0
             sourcePath = new Path(getProject());
 541   
         }
 542  0
         return sourcePath.createPath();
 543   
     }
 544   
 
 545   
     /**
 546   
      * Adds a reference to a CLASSPATH defined elsewhere.
 547   
      *
 548   
      * @param r the reference containing the source path definition.
 549   
      */
 550  0
     public void setSourcepathRef(Reference r) {
 551  0
         createSourcepath().setRefid(r);
 552   
     }
 553   
 
 554   
     /**
 555   
      * Set the directory where the Javadoc output will be generated.
 556   
      *
 557   
      * @param dir the destination directory.
 558   
      */
 559  0
     public void setDestdir(File dir) {
 560  0
         destDir = dir;
 561  0
         cmd.createArgument().setValue("-d");
 562  0
         cmd.createArgument().setFile(destDir);
 563   
     }
 564   
 
 565   
     /**
 566   
      * Set the list of source files to process.
 567   
      *
 568   
      * @param src a comma separated list of source files.
 569   
      */
 570  0
     public void setSourcefiles(String src) {
 571  0
         StringTokenizer tok = new StringTokenizer(src, ",");
 572  0
         while (tok.hasMoreTokens()) {
 573  0
             String f = tok.nextToken();
 574  0
             SourceFile sf = new SourceFile();
 575  0
             sf.setFile(getProject().resolveFile(f.trim()));
 576  0
             addSource(sf);
 577   
         }
 578   
     }
 579   
 
 580   
     /**
 581   
      * Add a single source file.
 582   
      *
 583   
      * @param sf the source file to be processed.
 584   
      */
 585  0
     public void addSource(SourceFile sf) {
 586  0
         sourceFiles.addElement(sf);
 587   
     }
 588   
 
 589   
     /**
 590   
      * Set the package names to be processed.
 591   
      *
 592   
      * @param packages a comma separated list of packages specs
 593   
      *        (may be wildcarded).
 594   
      *
 595   
      * @see #addPackage for wildcard information.
 596   
      */
 597  0
     public void setPackagenames(String packages) {
 598  0
         StringTokenizer tok = new StringTokenizer(packages, ",");
 599  0
         while (tok.hasMoreTokens()) {
 600  0
             String p = tok.nextToken();
 601  0
             PackageName pn = new PackageName();
 602  0
             pn.setName(p);
 603  0
             addPackage(pn);
 604   
         }
 605   
     }
 606   
 
 607   
     /**
 608   
      * Add a single package to be processed.
 609   
      *
 610   
      * If the package name ends with &quot;.*&quot; the Javadoc task
 611   
      * will find and process all subpackages.
 612   
      *
 613   
      * @param pn the package name, possibly wildcarded.
 614   
      */
 615  0
     public void addPackage(PackageName pn) {
 616  0
         packageNames.addElement(pn);
 617   
     }
 618   
 
 619   
     /**
 620   
      * Set the list of packages to be excluded.
 621   
      *
 622   
      * @param packages a comma separated list of packages to be excluded.
 623   
      *        This may not include wildcards.
 624   
      */
 625  0
     public void setExcludePackageNames(String packages) {
 626  0
         StringTokenizer tok = new StringTokenizer(packages, ",");
 627  0
         while (tok.hasMoreTokens()) {
 628  0
             String p = tok.nextToken();
 629  0
             PackageName pn = new PackageName();
 630  0
             pn.setName(p);
 631  0
             addExcludePackage(pn);
 632   
         }
 633   
     }
 634   
 
 635   
     /**
 636   
      * Add a package to be excluded from the javadoc run.
 637   
      *
 638   
      * @param pn the name of the package (wildcards are not permitted).
 639   
      */
 640  0
     public void addExcludePackage(PackageName pn) {
 641  0
         excludePackageNames.addElement(pn);
 642   
     }
 643   
 
 644   
     /**
 645   
      * Specify the file containing the overview to be included in the generated
 646   
      * documentation.
 647   
      *
 648   
      * @param f the file containing the overview.
 649   
      */
 650  0
     public void setOverview(File f) {
 651  0
         if (!javadoc1) {
 652  0
             cmd.createArgument().setValue("-overview");
 653  0
             cmd.createArgument().setFile(f);
 654   
         }
 655   
     }
 656   
 
 657   
     /**
 658   
      * Indicate whether only public classes and members are to be included in
 659   
      * the scope processed
 660   
      *
 661   
      * @param b true if scope is to be public.
 662   
      */
 663  0
     public void setPublic(boolean b) {
 664  0
         addArgIf(b, "-public");
 665   
     }
 666   
 
 667   
     /**
 668   
      * Indicate whether only protected and public classes and members are to
 669   
      * be included in the scope processed
 670   
      *
 671   
      * @param b true if scope is to be protected.
 672   
      */
 673  0
     public void setProtected(boolean b) {
 674  0
         addArgIf(b, "-protected");
 675   
     }
 676   
 
 677   
     /**
 678   
      * Indicate whether only package, protected and public classes and
 679   
      * members are to be included in the scope processed
 680   
      *
 681   
      * @param b true if scope is to be package level.
 682   
      */
 683  0
     public void setPackage(boolean b) {
 684  0
         addArgIf(b, "-package");
 685   
     }
 686   
 
 687   
     /**
 688   
      * Indicate whether all classes and
 689   
      * members are to be included in the scope processed
 690   
      *
 691   
      * @param b true if scope is to be private level.
 692   
      */
 693  0
     public void setPrivate(boolean b) {
 694  0
         addArgIf(b, "-private");
 695   
     }
 696   
 
 697   
     /**
 698   
      * Set the scope to be processed. This is an alternative to the
 699   
      * use of the setPublic, setPrivate, etc methods. It gives better build
 700   
      * file control over what scope is processed.
 701   
      *
 702   
      * @param at the scope to be processed.
 703   
      */
 704  0
     public void setAccess(AccessType at) {
 705  0
         cmd.createArgument().setValue("-" + at.getValue());
 706   
     }
 707   
 
 708   
     /**
 709   
      * Set the class that starts the doclet used in generating the
 710   
      * documentation.
 711   
      *
 712   
      * @param docletName the name of the doclet class.
 713   
      */
 714  0
     public void setDoclet(String docletName) {
 715  0
         if (doclet == null) {
 716  0
             doclet = new DocletInfo();
 717  0
             doclet.setProject(getProject());
 718   
         }
 719  0
         doclet.setName(docletName);
 720   
     }
 721   
 
 722   
     /**
 723   
      * Set the classpath used to find the doclet class.
 724   
      *
 725   
      * @param docletPath the doclet classpath.
 726   
      */
 727  0
     public void setDocletPath(Path docletPath) {
 728  0
         if (doclet == null) {
 729  0
             doclet = new DocletInfo();
 730  0
             doclet.setProject(getProject());
 731   
         }
 732  0
         doclet.setPath(docletPath);
 733   
     }
 734   
 
 735   
     /**
 736   
      * Set the classpath used to find the doclet class by reference.
 737   
      *
 738   
      * @param r the reference to the Path instance to use as the doclet
 739   
      *        classpath.
 740   
      */
 741  0
     public void setDocletPathRef(Reference r) {
 742  0
         if (doclet == null) {
 743  0
             doclet = new DocletInfo();
 744  0
             doclet.setProject(getProject());
 745   
         }
 746  0
         doclet.createPath().setRefid(r);
 747   
     }
 748   
 
 749   
     /**
 750   
      * Create a doclet to be used in the documentation generation.
 751   
      *
 752   
      * @return a new DocletInfo instance to be configured.
 753   
      */
 754  0
     public DocletInfo createDoclet() {
 755  0
         doclet = new DocletInfo();
 756  0
         return doclet;
 757   
     }
 758   
 
 759   
     /**
 760   
      * Add a taglet
 761   
      *
 762   
      * @param tagletInfo information about the taglet.
 763   
      */
 764  0
     public void addTaglet(ExtensionInfo tagletInfo) {
 765  0
         tags.addElement(tagletInfo);
 766   
     }
 767   
 
 768   
     /**
 769   
      * Indicate whether Javadoc should produce old style (JDK 1.1)
 770   
      * documentation.
 771   
      *
 772   
      * This is not supported by JDK 1.1 and has been phased out in JDK 1.4
 773   
      *
 774   
      * @param b if true attempt to generate old style documentation.
 775   
      */
 776  0
     public void setOld(boolean b) {
 777  0
         if (b) {
 778  0
             if (javadoc1) {
 779  0
                 log("Javadoc 1.1 doesn't support the -1.1 switch",
 780   
                     Project.MSG_WARN);
 781  0
             } else if (javadoc4) {
 782  0
                 log("Javadoc 1.4 doesn't support the -1.1 switch anymore",
 783   
                     Project.MSG_WARN);
 784   
             } else {
 785  0
                 cmd.createArgument().setValue("-1.1");
 786   
             }
 787   
         }
 788   
     }
 789   
 
 790   
     /**
 791   
      * Set the classpath to be used for this javadoc run.
 792   
      *
 793   
      * @param path an Ant Path object containing the compilation
 794   
      *        classpath.
 795   
      */
 796  0
     public void setClasspath(Path path) {
 797  0
         if (classpath == null) {
 798  0
             classpath = path;
 799   
         } else {
 800  0
             classpath.append(path);
 801   
         }
 802   
     }
 803   
 
 804   
     /**
 805   
      * Create a Path to be configured with the classpath to use
 806   
      *
 807   
      * @return a new Path instance to be configured with the classpath.
 808   
      */
 809  0
     public Path createClasspath() {
 810  0
         if (classpath == null) {
 811  0
             classpath = new Path(getProject());
 812   
         }
 813  0
         return classpath.createPath();
 814   
     }
 815   
 
 816   
     /**
 817   
      * Adds a reference to a CLASSPATH defined elsewhere.
 818   
      *
 819   
      * @param r the reference to an instance defining the classpath.
 820   
      */
 821  0
     public void setClasspathRef(Reference r) {
 822  0
         createClasspath().setRefid(r);
 823   
     }
 824   
 
 825   
     /**
 826   
      * Set the boot classpath to use.
 827   
      *
 828   
      * @param path the boot classpath.
 829   
      */
 830  0
     public void setBootclasspath(Path path) {
 831  0
         if (bootclasspath == null) {
 832  0
             bootclasspath = path;
 833   
         } else {
 834  0
             bootclasspath.append(path);
 835   
         }
 836   
     }
 837   
 
 838   
     /**
 839   
      * Create a Path to be configured with the boot classpath
 840   
      *
 841   
      * @return a new Path instance to be configured with the boot classpath.
 842   
      */
 843  0
     public Path createBootclasspath() {
 844  0
         if (bootclasspath == null) {
 845  0
             bootclasspath = new Path(getProject());
 846   
         }
 847  0
         return bootclasspath.createPath();
 848   
     }
 849   
 
 850   
     /**
 851   
      * Adds a reference to a CLASSPATH defined elsewhere.
 852   
      *
 853   
      * @param r the reference to an instance defining the bootclasspath.
 854   
      */
 855  0
     public void setBootClasspathRef(Reference r) {
 856  0
         createBootclasspath().setRefid(r);
 857   
     }
 858   
 
 859   
     /**
 860   
      * Set the location of the extensions directories.
 861   
      *
 862   
      * @param path the string version of the path.
 863   
      * @deprecated Use the {@link #setExtdirs(Path)} version.
 864   
      */
 865  0
     public void setExtdirs(String path) {
 866  0
         if (!javadoc1) {
 867  0
             cmd.createArgument().setValue("-extdirs");
 868  0
             cmd.createArgument().setValue(path);
 869   
         }
 870   
     }
 871   
 
 872   
     /**
 873   
      * Set the location of the extensions directories.
 874   
      *
 875   
      * @param path a path containing the extension directories.
 876   
      */
 877  0
     public void setExtdirs(Path path) {
 878  0
         if (!javadoc1) {
 879  0
             cmd.createArgument().setValue("-extdirs");
 880  0
             cmd.createArgument().setPath(path);
 881   
         }
 882   
     }
 883   
 
 884   
     /**
 885   
      * Run javadoc in verbose mode
 886   
      *
 887   
      * @param b true if operation is to be verbose.
 888   
      */
 889  0
     public void setVerbose(boolean b) {
 890  0
         add12ArgIf(b, "-verbose");
 891   
     }
 892   
 
 893   
     /**
 894   
      * Set the local to use in documentation generation.
 895   
      *
 896   
      * @param locale the locale to use.
 897   
      */
 898  0
     public void setLocale(String locale) {
 899  0
         if (!javadoc1) {
 900   
             // createArgument(true) is necessary to make sure, -locale
 901   
             // is the first argument (required in 1.3+).
 902  0
             cmd.createArgument(true).setValue(locale);
 903  0
             cmd.createArgument(true).setValue("-locale");
 904   
         }
 905   
     }
 906   
 
 907   
     /**
 908   
      * Set the encoding name of the source files,
 909   
      *
 910   
      * @param enc the name of the encoding for the source files.
 911   
      */
 912  0
     public void setEncoding(String enc) {
 913  0
         cmd.createArgument().setValue("-encoding");
 914  0
         cmd.createArgument().setValue(enc);
 915   
     }
 916   
 
 917   
     /**
 918   
      * Include the version tag in the generated documentation.
 919   
      *
 920   
      * @param b true if the version tag should be included.
 921   
      */
 922  0
     public void setVersion(boolean b) {
 923  0
         this.version = b;
 924   
     }
 925   
 
 926   
     /**
 927   
      * Generate the &quot;use&quot page for each package.
 928   
      *
 929   
      * @param b true if the use page should be generated.
 930   
      */
 931  0
     public void setUse(boolean b) {
 932  0
         add12ArgIf(b, "-use");
 933   
     }
 934   
 
 935   
 
 936   
     /**
 937   
      * Include the author tag in the generated documentation.
 938   
      *
 939   
      * @param b true if the author tag should be included.
 940   
      */
 941  0
     public void setAuthor(boolean b) {
 942  0
         author = b;
 943   
     }
 944   
 
 945   
     /**
 946   
      * Generate a split index
 947   
      *
 948   
      * @param b true if the index should be split into a file per letter.
 949   
      */
 950  0
     public void setSplitindex(boolean b) {
 951  0
         add12ArgIf(b, "-splitindex");
 952   
     }
 953   
 
 954   
     /**
 955   
      * Set the title to be placed in the HTML &lt;title&gt; tag of the
 956   
      * generated documentation.
 957   
      *
 958   
      * @param title the window title to use.
 959   
      */
 960  0
     public void setWindowtitle(String title) {
 961  0
         add12ArgIfNotEmpty("-windowtitle", title);
 962   
     }
 963   
 
 964   
     /**
 965   
      * Set the title of the generated overview page.
 966   
      *
 967   
      * @param doctitle the Document title.
 968   
      */
 969  0
     public void setDoctitle(String doctitle) {
 970  0
         Html h = new Html();
 971  0
         h.addText(doctitle);
 972  0
         addDoctitle(h);
 973   
     }
 974   
 
 975   
     /**
 976   
      * Add a document title to use for the overview page.
 977   
      *
 978   
      * @param text the HTML element containing the document title.
 979   
      */
 980  0
     public void addDoctitle(Html text) {
 981  0
         if (!javadoc1) {
 982  0
             doctitle = text;
 983   
         }
 984   
     }
 985   
 
 986   
     /**
 987   
      * Set the header text to be placed at the top of each output file.
 988   
      *
 989   
      * @param header the header text
 990   
      */
 991  0
     public void setHeader(String header) {
 992  0
         Html h = new Html();
 993  0
         h.addText(header);
 994  0
         addHeader(h);
 995   
     }
 996   
 
 997   
     /**
 998   
      * Set the header text to be placed at the top of each output file.
 999   
      *
 1000   
      * @param text the header text
 1001   
      */
 1002  0
     public void addHeader(Html text) {
 1003  0
         if (!javadoc1) {
 1004  0
             header = text;
 1005   
         }
 1006   
     }
 1007   
 
 1008   
     /**
 1009   
      * Set the footer text to be placed at the bottom of each output file.
 1010   
      *
 1011   
      * @param footer the footer text.
 1012   
      */
 1013  0
     public void setFooter(String footer) {
 1014  0
         Html h = new Html();
 1015  0
         h.addText(footer);
 1016  0
         addFooter(h);
 1017   
     }
 1018   
 
 1019   
     /**
 1020   
      * Set the footer text to be placed at the bottom of each output file.
 1021   
      *
 1022   
      * @param text the footer text.
 1023   
      */
 1024  0
     public void addFooter(Html text) {
 1025  0
         if (!javadoc1) {
 1026  0
             footer = text;
 1027   
         }
 1028   
     }
 1029   
 
 1030   
     /**
 1031   
      * Set the text to be placed at the bottom of each output file.
 1032   
      *
 1033   
      * @param bottom the bottom text.
 1034   
      */
 1035  0
     public void setBottom(String bottom) {
 1036  0
         Html h = new Html();
 1037  0
         h.addText(bottom);
 1038  0
         addBottom(h);
 1039   
     }
 1040   
 
 1041   
     /**
 1042   
      * Set the text to be placed at the bottom of each output file.
 1043   
      *
 1044   
      * @param text the bottom text.
 1045   
      */
 1046  0
     public void addBottom(Html text) {
 1047  0
         if (!javadoc1) {
 1048  0
             bottom = text;
 1049   
         }
 1050   
     }
 1051   
 
 1052   
     /**
 1053   
      * Link to docs at "url" using package list at "url2"
 1054   
      * - separate the URLs by using a space character.
 1055   
      */
 1056  0
     public void setLinkoffline(String src) {
 1057  0
         if (!javadoc1) {
 1058  0
             LinkArgument le = createLink();
 1059  0
             le.setOffline(true);
 1060  0
             String linkOfflineError = "The linkoffline attribute must include"
 1061   
                 + " a URL and a package-list file location separated by a"
 1062   
                 + " space";
 1063  0
             if (src.trim().length() == 0) {
 1064  0
                 throw new BuildException(linkOfflineError);
 1065   
             }
 1066  0
             StringTokenizer tok = new StringTokenizer(src, " ", false);
 1067  0
             le.setHref(tok.nextToken());
 1068   
 
 1069  0
             if (!tok.hasMoreTokens()) {
 1070  0
                 throw new BuildException(linkOfflineError);
 1071   
             }
 1072  0
             le.setPackagelistLoc(getProject().resolveFile(tok.nextToken()));
 1073   
         }
 1074   
     }
 1075   
 
 1076   
     /**
 1077   
      * Group specified packages together in overview page.
 1078   
      */
 1079  0
     public void setGroup(String src) {
 1080  0
         group = src;
 1081   
     }
 1082   
 
 1083   
     /**
 1084   
      * Create links to javadoc output at the given URL.
 1085   
      */
 1086  0
     public void setLink(String src) {
 1087  0
         if (!javadoc1) {
 1088  0
             createLink().setHref(src);
 1089   
         }
 1090   
     }
 1091   
 
 1092   
     /**
 1093   
      * If true, do not include @deprecated information.
 1094   
      */
 1095  0
     public void setNodeprecated(boolean b) {
 1096  0
         addArgIf(b, "-nodeprecated");
 1097   
     }
 1098   
 
 1099   
     /**
 1100   
      * If true, do not generate deprecated list.
 1101   
      */
 1102  0
     public void setNodeprecatedlist(boolean b) {
 1103  0
         add12ArgIf(b, "-nodeprecatedlist");
 1104   
     }
 1105   
 
 1106   
     /**
 1107   
      * If true, do not generate class hierarchy.
 1108   
      */
 1109  0
     public void setNotree(boolean b) {
 1110  0
         addArgIf(b, "-notree");
 1111   
     }
 1112   
 
 1113   
     /**
 1114   
      * If true, do not generate index.
 1115   
      */
 1116  0
     public void setNoindex(boolean b) {
 1117  0
         addArgIf(b, "-noindex");
 1118   
     }
 1119   
 
 1120   
     /**
 1121   
      * If true, do not generate help link
 1122   
      */
 1123  0
     public void setNohelp(boolean b) {
 1124  0
         add12ArgIf(b, "-nohelp");
 1125   
     }
 1126   
 
 1127   
     /**
 1128   
      * If true, do not generate navigation bar.
 1129   
      */
 1130  0
     public void setNonavbar(boolean b) {
 1131  0
         add12ArgIf(b, "-nonavbar");
 1132   
     }
 1133   
 
 1134   
     /**
 1135   
      * If true, generate warning about @serial tag.
 1136   
      */
 1137  0
     public void setSerialwarn(boolean b) {
 1138  0
         add12ArgIf(b, "-serialwarn");
 1139   
     }
 1140   
 
 1141   
     /**
 1142   
      * Specifies the CSS stylesheet file to use.
 1143   
      */
 1144  0
     public void setStylesheetfile(File f) {
 1145  0
         if (!javadoc1) {
 1146  0
             cmd.createArgument().setValue("-stylesheetfile");
 1147  0
             cmd.createArgument().setFile(f);
 1148   
         }
 1149   
     }
 1150   
 
 1151   
     /**
 1152   
      * Specifies the HTML help file to use.
 1153   
      */
 1154  0
     public void setHelpfile(File f) {
 1155  0
         if (!javadoc1) {
 1156  0
             cmd.createArgument().setValue("-helpfile");
 1157  0
             cmd.createArgument().setFile(f);
 1158   
         }
 1159   
     }
 1160   
 
 1161   
     /**
 1162   
      * Output file encoding name.
 1163   
      */
 1164  0
     public void setDocencoding(String enc) {
 1165  0
         cmd.createArgument().setValue("-docencoding");
 1166  0
         cmd.createArgument().setValue(enc);
 1167   
     }
 1168   
 
 1169   
     /**
 1170   
      * The name of a file containing the packages to process.
 1171   
      */
 1172  0
     public void setPackageList(String src) {
 1173  0
         if (!javadoc1) {
 1174  0
             packageList = src;
 1175   
         }
 1176   
     }
 1177   
 
 1178   
     /**
 1179   
      * Create link to javadoc output at the given URL.
 1180   
      */
 1181  0
     public LinkArgument createLink() {
 1182  0
         LinkArgument la = new LinkArgument();
 1183  0
         links.addElement(la);
 1184  0
         return la;
 1185   
     }
 1186   
 
 1187   
     public class LinkArgument {
 1188   
         private String href;
 1189   
         private boolean offline = false;
 1190   
         private File packagelistLoc;
 1191   
 
 1192  0
         public LinkArgument() {
 1193   
         }
 1194   
 
 1195  0
         public void setHref(String hr) {
 1196  0
             href = hr;
 1197   
         }
 1198   
 
 1199  0
         public String getHref() {
 1200  0
             return href;
 1201   
         }
 1202   
 
 1203  0
         public void setPackagelistLoc(File src) {
 1204  0
             packagelistLoc = src;
 1205   
         }
 1206   
 
 1207  0
         public File getPackagelistLoc() {
 1208  0
             return packagelistLoc;
 1209   
         }
 1210   
 
 1211  0
         public void setOffline(boolean offline) {
 1212  0
             this.offline = offline;
 1213   
         }
 1214   
 
 1215  0
         public boolean isLinkOffline() {
 1216  0
             return offline;
 1217   
         }
 1218   
     }
 1219   
 
 1220   
     /**
 1221   
      * Creates and adds a -tag argument. This is used to specify
 1222   
      * custom tags. This argument is only available for JavaDoc 1.4,
 1223   
      * and will generate a verbose message (and then be ignored)
 1224   
      * when run on Java versions below 1.4.
 1225   
      */
 1226  0
     public TagArgument createTag() {
 1227  0
         if (!javadoc4) {
 1228  0
             log ("-tag option not supported on JavaDoc < 1.4",
 1229   
                  Project.MSG_VERBOSE);
 1230   
         }
 1231  0
         TagArgument ta = new TagArgument();
 1232  0
         tags.addElement (ta);
 1233  0
         return ta;
 1234   
     }
 1235   
 
 1236   
     /**
 1237   
      * Scope element verbose names. (Defined here as fields
 1238   
      * cannot be static in inner classes.) The first letter
 1239   
      * from each element is used to build up the scope string.
 1240   
      */
 1241   
     static final String[] SCOPE_ELEMENTS = {
 1242   
         "overview", "packages", "types", "constructors",
 1243   
         "methods", "fields"
 1244   
     };
 1245   
 
 1246   
     /**
 1247   
      * Class representing a -tag argument.
 1248   
      */
 1249   
     public class TagArgument extends FileSet {
 1250   
         /** Name of the tag. */
 1251   
         private String name = null;
 1252   
         /** Description of the tag to place in the JavaDocs. */
 1253   
         private String description = null;
 1254   
         /** Whether or not the tag is enabled. */
 1255   
         private boolean enabled = true;
 1256   
         /**
 1257   
          * Scope string of the tag. This will form the middle
 1258   
          * argument of the -tag parameter when the tag is enabled
 1259   
          * (with an X prepended for and is parsed from human-readable form.
 1260   
          */
 1261   
         private String scope = "a";
 1262   
 
 1263   
         /** Sole constructor. */
 1264  0
         public TagArgument () {
 1265   
         }
 1266   
 
 1267   
         /**
 1268   
          * Sets the name of the tag.
 1269   
          *
 1270   
          * @param name The name of the tag.
 1271   
          *             Must not be <code>null</code> or empty.
 1272   
          */
 1273  0
         public void setName (String name) {
 1274  0
             this.name = name;
 1275   
         }
 1276   
 
 1277   
         /**
 1278   
          * Sets the description of the tag. This is what appears in
 1279   
          * the JavaDoc.
 1280   
          *
 1281   
          * @param description The description of the tag.
 1282   
          *                    Must not be <code>null</code> or empty.
 1283   
          */
 1284  0
         public void setDescription (String description) {
 1285  0
             this.description = description;
 1286   
         }
 1287   
 
 1288   
         /**
 1289   
          * Sets the scope of the tag. This is in comma-separated
 1290   
          * form, with each element being one of "all" (the default),
 1291   
          * "overview", "packages", "types", "constructors", "methods",
 1292   
          * "fields". The elements are treated in a case-insensitive
 1293   
          * manner.
 1294   
          *
 1295   
          * @param verboseScope The scope of the tag.
 1296   
          *                     Must not be <code>null</code>,
 1297   
          *                     should not be empty.
 1298   
          *
 1299   
          * @exception BuildException if all is specified along with
 1300   
          * other elements, if any elements are repeated, if no
 1301   
          * elements are specified, or if any unrecognised elements are
 1302   
          * specified.
 1303   
          */
 1304  0
         public void setScope (String verboseScope) throws BuildException {
 1305  0
             verboseScope = verboseScope.toLowerCase(Locale.US);
 1306   
 
 1307  0
             boolean[] elements = new boolean[SCOPE_ELEMENTS.length];
 1308   
 
 1309  0
             boolean gotAll = false;
 1310  0
             boolean gotNotAll = false;
 1311   
 
 1312   
             // Go through the tokens one at a time, updating the
 1313   
             // elements array and issuing warnings where appropriate.
 1314  0
             StringTokenizer tok = new StringTokenizer (verboseScope, ",");
 1315  0
             while (tok.hasMoreTokens()) {
 1316  0
                 String next = tok.nextToken().trim();
 1317  0
                 if (next.equals("all")) {
 1318  0
                     if (gotAll) {
 1319  0
                         getProject().log ("Repeated tag scope element: all",
 1320   
                                           Project.MSG_VERBOSE);
 1321   
                     }
 1322  0
                     gotAll = true;
 1323   
                 } else {
 1324  0
                     int i;
 1325  0
                     for (i = 0; i < SCOPE_ELEMENTS.length; i++) {
 1326  0
                         if (next.equals (SCOPE_ELEMENTS[i]))
 1327  0
                             break;
 1328   
                     }
 1329  0
                     if (i == SCOPE_ELEMENTS.length) {
 1330  0
                         throw new BuildException ("Unrecognised scope element: "
 1331   
                                                   + next);
 1332   
                     } else {
 1333  0
                         if (elements[i]) {
 1334  0
                             getProject().log ("Repeated tag scope element: "
 1335   
                                               + next, Project.MSG_VERBOSE);
 1336   
                         }
 1337  0
                         elements[i] = true;
 1338  0
                         gotNotAll = true;
 1339   
                     }
 1340   
                 }
 1341   
             }
 1342   
 
 1343  0
             if (gotNotAll && gotAll) {
 1344  0
                 throw new BuildException ("Mixture of \"all\" and other scope "
 1345   
                                           + "elements in tag parameter.");
 1346   
             }
 1347  0
             if (!gotNotAll && !gotAll) {
 1348  0
                 throw new BuildException ("No scope elements specified in tag "
 1349   
                                           + "parameter.");
 1350   
             }
 1351  0
             if (gotAll) {
 1352  0
                 this.scope = "a";
 1353   
             } else {
 1354  0
                 StringBuffer buff = new StringBuffer (elements.length);
 1355  0
                 for (int i = 0; i < elements.length; i++) {
 1356  0
                     if (elements[i]) {
 1357  0
                         buff.append (SCOPE_ELEMENTS[i].charAt(0));
 1358   
                     }
 1359   
                 }
 1360  0
                 this.scope = buff.toString();
 1361   
             }
 1362   
         }
 1363   
 
 1364   
         /**
 1365   
          * Sets whether or not the tag is enabled.
 1366   
          *
 1367   
          * @param enabled Whether or not this tag is enabled.
 1368   
          */
 1369  0
         public void setEnabled (boolean enabled) {
 1370  0
             this.enabled = enabled;
 1371   
         }
 1372   
 
 1373   
         /**
 1374   
          * Returns the -tag parameter this argument represented.
 1375   
          *
 1376   
          * @exception BuildException if either the name or description
 1377   
          *                           is <code>null</code> or empty.
 1378   
          */
 1379  0
         public String getParameter () throws BuildException {
 1380  0
             if (name == null || name.equals("")) {
 1381  0
                 throw new BuildException ("No name specified for custom tag.");
 1382   
             }
 1383  0
             if (description == null || description.equals("")){
 1384  0
                 throw new BuildException
 1385   
                     ("No description specified for custom tag " + name);
 1386   
             }
 1387   
 
 1388  0
             return name + ":" + (enabled ? "" : "X")
 1389   
                 + scope + ":" + description;
 1390   
         }
 1391   
     }
 1392   
 
 1393   
     /**
 1394   
      * Separates packages on the overview page into whatever
 1395   
      * groups you specify, one group per table.
 1396   
      */
 1397  0
     public GroupArgument createGroup() {
 1398  0
         GroupArgument ga = new GroupArgument();
 1399  0
         groups.addElement(ga);
 1400  0
         return ga;
 1401   
     }
 1402   
 
 1403   
     public class GroupArgument {
 1404   
         private Html title;
 1405   
         private Vector packages = new Vector(3);
 1406   
 
 1407  0
         public GroupArgument() {
 1408   
         }
 1409   
 
 1410  0
         public void setTitle(String src) {
 1411  0
             Html h = new Html();
 1412  0
             h.addText(src);
 1413  0
             addTitle(h);
 1414   
         }
 1415  0
         public void addTitle(Html text) {
 1416  0
             title = text;
 1417   
         }
 1418   
 
 1419  0
         public String getTitle() {
 1420  0
             return title != null ? title.getText() : null;
 1421   
         }
 1422   
 
 1423  0
         public void setPackages(String src) {
 1424  0
             StringTokenizer tok = new StringTokenizer(src, ",");
 1425  0
             while (tok.hasMoreTokens()) {
 1426  0
                 String p = tok.nextToken();
 1427  0
                 PackageName pn = new PackageName();
 1428  0
                 pn.setName(p);
 1429  0
                 addPackage(pn);
 1430   
             }
 1431   
         }
 1432  0
         public void addPackage(PackageName pn) {
 1433  0
             packages.addElement(pn);
 1434   
         }
 1435   
 
 1436  0
         public String getPackages() {
 1437  0
             StringBuffer p = new StringBuffer();
 1438  0
             for (int i = 0; i < packages.size(); i++) {
 1439  0
                 if (i > 0) {
 1440  0
                     p.append(":");
 1441   
                 }
 1442  0
                 p.append(packages.elementAt(i).toString());
 1443   
             }
 1444  0
             return p.toString();
 1445   
         }
 1446   
     }
 1447   
 
 1448   
     /**
 1449   
      * Charset for cross-platform viewing of generated documentation.
 1450   
      */
 1451  0
     public void setCharset(String src) {
 1452  0
         this.add12ArgIfNotEmpty("-charset", src);
 1453   
     }
 1454   
 
 1455   
     /**
 1456   
      * Should the build process fail if javadoc fails (as indicated by
 1457   
      * a non zero return code)?
 1458   
      *
 1459   
      * <p>Default is false.</p>
 1460   
      */
 1461  0
     public void setFailonerror(boolean b) {
 1462  0
         failOnError = b;
 1463   
     }
 1464   
 
 1465   
     /**
 1466   
      * Enables the -source switch, will be ignored if javadoc is not
 1467   
      * the 1.4 version.
 1468   
      *
 1469   
      * @since Ant 1.5
 1470   
      */
 1471  0
     public void setSource(String source) {
 1472  0
         if (!javadoc4) {
 1473  0
             log ("-source option not supported on JavaDoc < 1.4",
 1474   
                  Project.MSG_VERBOSE);
 1475   
         }
 1476  0
         this.source = source;
 1477   
     }
 1478   
 
 1479   
     /**
 1480   
      * Adds a packageset.
 1481   
      *
 1482   
      * <p>All included directories will be translated into package
 1483   
      * names be converting the directory separator into dots.</p>
 1484   
      *
 1485   
      * @since 1.5
 1486   
      */
 1487  0
     public void addPackageset(DirSet packageSet) {
 1488  0
         packageSets.addElement(packageSet);
 1489   
     }
 1490   
 
 1491   
     /**
 1492   
      * Adds a fileset.
 1493   
      *
 1494   
      * <p>All included files will be added as sourcefiles.  The task
 1495   
      * will automatically add
 1496   
      * <code>includes=&quot;**&#47;*.java&quot;</code> to the
 1497   
      * fileset.</p>
 1498   
      *
 1499   
      * @since 1.5
 1500   
      */
 1501  0
     public void addFileset(FileSet fs) {
 1502  0
         fileSets.addElement(fs);
 1503   
     }
 1504   
 
 1505  0
     public void execute() throws BuildException {
 1506  0
         if ("javadoc2".equals(getTaskType())) {
 1507  0
             log("!! javadoc2 is deprecated. Use javadoc instead. !!");
 1508   
         }
 1509   
 
 1510  0
         Vector packagesToDoc = new Vector();
 1511  0
         Path sourceDirs = new Path(getProject());
 1512   
 
 1513  0
         if (packageList != null && sourcePath == null) {
 1514  0
             String msg = "sourcePath attribute must be set when "
 1515   
                 + "specifying packagelist.";
 1516  0
             throw new BuildException(msg);
 1517   
         }
 1518   
 
 1519  0
         if (sourcePath != null) {
 1520  0
             sourceDirs.addExisting(sourcePath);
 1521   
         }
 1522   
 
 1523  0
         parsePackages(packagesToDoc, sourceDirs);
 1524   
 
 1525  0
         if (packagesToDoc.size() != 0 && sourceDirs.size() == 0) {
 1526  0
             String msg = "sourcePath attribute must be set when "
 1527   
                 + "specifying package names.";
 1528  0
             throw new BuildException(msg);
 1529   
         }
 1530   
 
 1531  0
         Vector sourceFilesToDoc = (Vector) sourceFiles.clone();
 1532  0
         addFileSets(sourceFilesToDoc);
 1533   
 
 1534  0
         if (packageList == null && packagesToDoc.size() == 0
 1535   
             && sourceFilesToDoc.size() == 0) {
 1536  0
             throw new BuildException("No source files and no packages have "
 1537   
                                      + "been specified.");
 1538   
         }
 1539   
 
 1540  0
         log("Generating Javadoc", Project.MSG_INFO);
 1541   
 
 1542  0
         Commandline toExecute = (Commandline) cmd.clone();
 1543  0
         toExecute.setExecutable(JavaEnvUtils.getJdkExecutable("javadoc"));
 1544   
 
 1545   
         // ------------------------------------------ general javadoc arguments
 1546  0
         if (doctitle != null) {
 1547  0
             toExecute.createArgument().setValue("-doctitle");
 1548  0
             toExecute.createArgument().setValue(expand(doctitle.getText()));
 1549   
         }
 1550  0
         if (header != null) {
 1551  0
             toExecute.createArgument().setValue("-header");
 1552  0
             toExecute.createArgument().setValue(expand(header.getText()));
 1553   
         }
 1554  0
         if (footer != null) {
 1555  0
             toExecute.createArgument().setValue("-footer");
 1556  0
             toExecute.createArgument().setValue(expand(footer.getText()));
 1557   
         }
 1558  0
         if (bottom != null) {
 1559  0
             toExecute.createArgument().setValue("-bottom");
 1560  0
             toExecute.createArgument().setValue(expand(bottom.getText()));
 1561   
         }
 1562   
 
 1563  0
         if (classpath == null) {
 1564  0
             classpath = (new Path(getProject())).concatSystemClasspath("last");
 1565   
         } else {
 1566  0
             classpath = classpath.concatSystemClasspath("ignore");
 1567   
         }
 1568   
 
 1569  0
         if (!javadoc1) {
 1570  0
             if (classpath.size() > 0) {
 1571  0
                 toExecute.createArgument().setValue("-classpath");
 1572  0
                 toExecute.createArgument().setPath(classpath);
 1573   
             }
 1574  0
             if (sourceDirs.size() > 0) {
 1575  0
                 toExecute.createArgument().setValue("-sourcepath");
 1576  0
                 toExecute.createArgument().setPath(sourceDirs);
 1577   
             }
 1578   
         } else {
 1579  0
             sourceDirs.append(classpath);
 1580  0
             if (sourceDirs.size() > 0) {
 1581  0
                 toExecute.createArgument().setValue("-classpath");
 1582  0
                 toExecute.createArgument().setPath(sourceDirs);
 1583   
             }
 1584   
         }
 1585   
 
 1586  0
         if (version && doclet == null) {
 1587  0
             toExecute.createArgument().setValue("-version");
 1588   
         }
 1589  0
         if (author && doclet == null) {
 1590  0
             toExecute.createArgument().setValue("-author");
 1591   
         }
 1592   
 
 1593  0
         if (javadoc1 || doclet == null) {
 1594  0
             if (destDir == null) {
 1595  0
                 String msg = "destDir attribute must be set!";
 1596  0
                 throw new BuildException(msg);
 1597   
             }
 1598   
         }
 1599   
 
 1600   
         // ---------------------------- javadoc2 arguments for default doclet
 1601   
 
 1602  0
         if (!javadoc1) {
 1603  0
             if (doclet != null) {
 1604  0
                 if (doclet.getName() == null) {
 1605  0
                     throw new BuildException("The doclet name must be "
 1606   
                                              + "specified.", getLocation());
 1607   
                 } else {
 1608  0
                     toExecute.createArgument().setValue("-doclet");
 1609  0
                     toExecute.createArgument().setValue(doclet.getName());
 1610  0
                     if (doclet.getPath() != null) {
 1611  0
                         Path docletPath
 1612   
                             = doclet.getPath().concatSystemClasspath("ignore");
 1613  0
                         if (docletPath.size() != 0) {
 1614  0
                             toExecute.createArgument().setValue("-docletpath");
 1615  0
                             toExecute.createArgument().setPath(docletPath);
 1616   
                         }
 1617   
                     }
 1618  0
                     for (Enumeration e = doclet.getParams();
 1619  0
                          e.hasMoreElements();) {
 1620  0
                         DocletParam param = (DocletParam) e.nextElement();
 1621  0
                         if (param.getName() == null) {
 1622  0
                             throw new BuildException("Doclet parameters must "
 1623   
                                                      + "have a name");
 1624   
                         }
 1625   
 
 1626  0
                         toExecute.createArgument().setValue(param.getName());
 1627  0
                         if (param.getValue() != null) {
 1628  0
                             toExecute.createArgument()
 1629   
                                 .setValue(param.getValue());
 1630   
                         }
 1631   
                     }
 1632   
                 }
 1633   
             }
 1634  0
             if (bootclasspath != null && bootclasspath.size() > 0) {
 1635  0
                 toExecute.createArgument().setValue("-bootclasspath");
 1636  0
                 toExecute.createArgument().setPath(bootclasspath);
 1637   
             }
 1638   
 
 1639   
             // add the links arguments
 1640  0
             if (links.size() != 0) {
 1641  0
                 for (Enumeration e = links.elements(); e.hasMoreElements();) {
 1642  0
                     LinkArgument la = (LinkArgument) e.nextElement();
 1643   
 
 1644  0
                     if (la.getHref() == null || la.getHref().length() == 0) {
 1645  0
                         log("No href was given for the link - skipping",
 1646   
                             Project.MSG_VERBOSE);
 1647  0
                         continue;
 1648   
                     } else {
 1649   
                         // is the href a valid URL
 1650  0
                         try {
 1651  0
                             URL base = new URL("file://.");
 1652  0
                             new URL(base, la.getHref());
 1653   
                         } catch (MalformedURLException mue) {
 1654   
                             // ok - just skip
 1655  0
                             log("Link href \"" + la.getHref()
 1656   
                                 + "\" is not a valid url - skipping link",
 1657   
                                 Project.MSG_WARN);
 1658  0
                             continue;
 1659   
                         }
 1660   
                     }
 1661   
 
 1662  0
                     if (la.isLinkOffline()) {
 1663  0
                         File packageListLocation = la.getPackagelistLoc();
 1664  0
                         if (packageListLocation == null) {
 1665  0
                             throw new BuildException("The package list "
 1666   
                                                      + " location for link " + la.getHref()
 1667   
                                                      + " must be provided because the link is "
 1668   
                                                      + "offline");
 1669   
                         }
 1670  0
                         File packageListFile =
 1671   
                             new File(packageListLocation, "package-list");
 1672  0
                         if (packageListFile.exists()) {
 1673  0
                             try {
 1674  0
                                 String packageListURL =
 1675   
                                     fileUtils.getFileURL(packageListLocation)
 1676   
                                     .toExternalForm();
 1677  0
                                 toExecute.createArgument()
 1678   
                                     .setValue("-linkoffline");
 1679  0
                                 toExecute.createArgument()
 1680   
                                     .setValue(la.getHref());
 1681  0
                                 toExecute.createArgument()
 1682   
                                     .setValue(packageListURL);
 1683   
                             } catch (MalformedURLException ex) {
 1684  0
                                 log("Warning: Package list location was "
 1685   
                                     + "invalid " + packageListLocation,
 1686   
                                     Project.MSG_WARN);
 1687   
                             }
 1688   
                         } else {
 1689  0
                             log("Warning: No package list was found at "
 1690   
                                 + packageListLocation, Project.MSG_VERBOSE);
 1691   
                         }
 1692   
                     } else {
 1693  0
                         toExecute.createArgument().setValue("-link");
 1694  0
                         toExecute.createArgument().setValue(la.getHref());
 1695   
                     }
 1696   
                 }
 1697   
             }
 1698   
 
 1699   
             // add the single group arguments
 1700   
             // Javadoc 1.2 rules:
 1701   
             //   Multiple -group args allowed.
 1702   
             //   Each arg includes 3 strings: -group [name] [packagelist].
 1703   
             //   Elements in [packagelist] are colon-delimited.
 1704   
             //   An element in [packagelist] may end with the * wildcard.
 1705   
 
 1706   
             // Ant javadoc task rules for group attribute:
 1707   
             //   Args are comma-delimited.
 1708   
             //   Each arg is 2 space-delimited strings.
 1709   
             //   E.g., group="XSLT_Packages org.apache.xalan.xslt*,
 1710   
             //                XPath_Packages org.apache.xalan.xpath*"
 1711  0
             if (group != null) {
 1712  0
                 StringTokenizer tok = new StringTokenizer(group, ",", false);
 1713  0
                 while (tok.hasMoreTokens()) {
 1714  0
                     String grp = tok.nextToken().trim();
 1715  0
                     int space = grp.indexOf(" ");
 1716  0
                     if (space > 0){
 1717  0
                         String name = grp.substring(0, space);
 1718  0
                         String pkgList = grp.substring(space + 1);
 1719  0
                         toExecute.createArgument().setValue("-group");
 1720  0
                         toExecute.createArgument().setValue(name);
 1721  0
                         toExecute.createArgument().setValue(pkgList);
 1722   
                     }
 1723   
                 }
 1724   
             }
 1725   
 
 1726   
             // add the group arguments
 1727  0
             if (groups.size() != 0) {
 1728  0
                 for (Enumeration e = groups.elements(); e.hasMoreElements();) {
 1729  0
                     GroupArgument ga = (GroupArgument) e.nextElement();
 1730  0
                     String title = ga.getTitle();
 1731  0
                     String packages = ga.getPackages();
 1732  0
                     if (title == null || packages == null) {
 1733  0
                         throw new BuildException("The title and packages must "
 1734   
                                                  + "be specified for group "
 1735   
                                                  + "elements.");
 1736   
                     }
 1737  0
                     toExecute.createArgument().setValue("-group");
 1738  0
                     toExecute.createArgument().setValue(expand(title));
 1739  0
                     toExecute.createArgument().setValue(packages);
 1740   
                 }
 1741   
             }
 1742   
 
 1743   
             // JavaDoc 1.4 parameters
 1744  0
             if (javadoc4) {
 1745  0
                 for (Enumeration e = tags.elements(); e.hasMoreElements();) {
 1746  0
                     Object element = e.nextElement();
 1747  0
                     if (element instanceof TagArgument) {
 1748  0
                         TagArgument ta = (TagArgument) element;
 1749  0
                         File tagDir = ta.getDir(getProject());
 1750  0
                         if (tagDir == null ) {
 1751   
                             // The tag element is not used as a fileset,
 1752   
                             // but specifies the tag directly.
 1753  0
                             toExecute.createArgument().setValue ("-tag");
 1754  0
                             toExecute.createArgument().setValue (ta.getParameter());
 1755   
                         } else {
 1756   
                             // The tag element is used as a fileset. Parse all the files and
 1757   
                             // create -tag arguments.
 1758  0
                             DirectoryScanner tagDefScanner = ta.getDirectoryScanner(getProject());
 1759  0
                             String[] files = tagDefScanner.getIncludedFiles();
 1760  0
                             for (int i = 0; i < files.length; i++) {
 1761  0
                                 File tagDefFile = new File( tagDir, files[i] );
 1762  0
                                 try {
 1763  0
                                     BufferedReader in = new BufferedReader( new FileReader(tagDefFile) );
 1764  0
                                     String line = null;
 1765  0
                                     while( (line = in.readLine()) != null ) {
 1766  0
                                         toExecute.createArgument().setValue ("-tag");
 1767  0
                                         toExecute.createArgument().setValue (line);
 1768   
                                     }
 1769  0
                                     in.close();
 1770   
                                 } catch( IOException ioe ) {
 1771  0
                                     throw new BuildException( "Couldn't read tag file from " + tagDefFile.getAbsolutePath(), ioe );
 1772   
                                 }
 1773   
                             }
 1774   
                         }
 1775   
                     } else {
 1776  0
                         ExtensionInfo tagletInfo = (ExtensionInfo) element;
 1777  0
                         toExecute.createArgument().setValue("-taglet");
 1778  0
                         toExecute.createArgument().setValue(tagletInfo
 1779   
                                                             .getName());
 1780  0
                         if (tagletInfo.getPath() != null) {
 1781  0
                             Path tagletPath = tagletInfo.getPath()
 1782   
                                 .concatSystemClasspath("ignore");
 1783  0
                             if (tagletPath.size() != 0) {
 1784  0
                                 toExecute.createArgument()
 1785   
                                     .setValue("-tagletpath");
 1786  0
                                 toExecute.createArgument().setPath(tagletPath);
 1787   
                             }
 1788   
                         }
 1789   
                     }
 1790   
                 }
 1791   
 
 1792  0
                 if (source != null) {
 1793  0
                     toExecute.createArgument().setValue("-source");
 1794  0
                     toExecute.createArgument().setValue(source);
 1795   
                 }
 1796   
             }
 1797   
 
 1798   
         }
 1799   
 
 1800  0
         File tmpList = null;
 1801  0
         PrintWriter srcListWriter = null;
 1802  0
         try {
 1803   
 
 1804   
             /**
 1805   
              * Write sourcefiles and package names to a temporary file
 1806   
              * if requested.
 1807   
              */
 1808  0
             if (useExternalFile) {
 1809  0
                 if (tmpList == null) {
 1810  0
                     tmpList = fileUtils.createTempFile("javadoc", "", null);
 1811  0
                     toExecute.createArgument()
 1812   
                         .setValue("@" + tmpList.getAbsolutePath());
 1813   
                 }
 1814  0
                 srcListWriter = new PrintWriter(
 1815   
                                                 new FileWriter(tmpList.getAbsolutePath(),
 1816   
                                                                true));
 1817   
             }
 1818   
 
 1819  0
             Enumeration enum = packagesToDoc.elements();
 1820  0
             while (enum.hasMoreElements()) {
 1821  0
                 String packageName = (String) enum.nextElement();
 1822  0
                 if (useExternalFile) {
 1823  0
                     srcListWriter.println(packageName);
 1824   
                 } else {
 1825  0
                     toExecute.createArgument().setValue(packageName);
 1826   
                 }
 1827   
             }
 1828   
 
 1829  0
             enum = sourceFilesToDoc.elements();
 1830  0
             while (enum.hasMoreElements()) {
 1831  0
                 SourceFile sf = (SourceFile) enum.nextElement();
 1832  0
                 String sourceFileName = sf.getFile().getAbsolutePath();
 1833  0
                 if (useExternalFile) {
 1834  0
                     srcListWriter.println(sourceFileName);
 1835   
                 } else {
 1836  0
                     toExecute.createArgument().setValue(sourceFileName);
 1837   
                 }
 1838   
             }
 1839   
 
 1840   
         } catch (IOException e) {
 1841  0
             tmpList.delete();
 1842  0
             throw new BuildException("Error creating temporary file",
 1843   
                                      e, getLocation());
 1844   
         } finally {
 1845  0
             if (srcListWriter != null) {
 1846  0
                 srcListWriter.close();
 1847   
             }
 1848   
         }
 1849   
 
 1850  0
         if (packageList != null) {
 1851  0
             toExecute.createArgument().setValue("@" + packageList);
 1852   
         }
 1853  0
         log(toExecute.describeCommand(), Project.MSG_VERBOSE);
 1854   
 
 1855  0
         log("Javadoc execution", Project.MSG_INFO);
 1856   
 
 1857  0
         JavadocOutputStream out = new JavadocOutputStream(Project.MSG_INFO);
 1858  0
         JavadocOutputStream err = new JavadocOutputStream(Project.MSG_WARN);
 1859  0
         Execute exe = new Execute(new PumpStreamHandler(out, err));
 1860  0
         exe.setAntRun(getProject());
 1861   
 
 1862   
         /*
 1863   
          * No reason to change the working directory as all filenames and
 1864   
          * path components have been resolved already.
 1865   
          *
 1866   
          * Avoid problems with command line length in some environments.
 1867   
          */
 1868  0
         exe.setWorkingDirectory(null);
 1869  0
         try {
 1870  0
             exe.setCommandline(toExecute.getCommandline());
 1871  0
             int ret = exe.execute();
 1872  0
             if (ret != 0 && failOnError) {
 1873  0
                 throw new BuildException("Javadoc returned " + ret, getLocation());
 1874   
             }
 1875   
         } catch (IOException e) {
 1876  0
             throw new BuildException("Javadoc failed: " + e, e, getLocation());
 1877   
         } finally {
 1878  0
             if (tmpList != null) {
 1879  0
                 tmpList.delete();
 1880  0
                 tmpList = null;
 1881   
             }
 1882   
 
 1883  0
             out.logFlush();
 1884  0
             err.logFlush();
 1885  0
             try {
 1886  0
                 out.close();
 1887  0
                 err.close();
 1888   
             } catch (IOException e) {}
 1889   
         }
 1890   
     }
 1891   
 
 1892   
     /**
 1893   
      * Add the files matched by the nested filesets to the Vector as
 1894   
      * SourceFile instances.
 1895   
      *
 1896   
      * @since 1.5
 1897   
      */
 1898  0
     private void addFileSets(Vector sf) {
 1899  0
         Enumeration enum = fileSets.elements();
 1900  0
         while (enum.hasMoreElements()) {
 1901  0
             FileSet fs = (FileSet) enum.nextElement();
 1902  0
             if (!fs.hasPatterns() && !fs.hasSelectors()) {
 1903  0
                 fs = (FileSet) fs.clone();
 1904  0
                 fs.createInclude().setName("**/*.java");
 1905   
             }
 1906  0
             File baseDir = fs.getDir(getProject());
 1907  0
             DirectoryScanner ds = fs.getDirectoryScanner(getProject());
 1908  0
             String[] files = ds.getIncludedFiles();
 1909  0
             for (int i = 0; i < files.length; i++) {
 1910  0
                 sf.addElement(new SourceFile(new File(baseDir, files[i])));
 1911   
             }
 1912   
         }
 1913   
     }
 1914   
 
 1915   
     /**
 1916   
      * Add the directories matched by the nested dirsets to the Vector
 1917   
      * and the base directories of the dirsets to the Path.  It also
 1918   
      * handles the packages and excludepackages attributes and
 1919   
      * elements.
 1920   
      *
 1921   
      * @since 1.5
 1922   
      */
 1923  0
     private void parsePackages(Vector pn, Path sp) {
 1924  0
         Vector addedPackages = new Vector();
 1925  0
         Vector dirSets = (Vector) packageSets.clone();
 1926   
 
 1927   
         // for each sourcePath entry, add a directoryset with includes
 1928   
         // taken from packagenames attribute and nested package
 1929   
         // elements and excludes taken from excludepackages attribute
 1930   
         // and nested excludepackage elements
 1931  0
         if (sourcePath != null && packageNames.size() > 0) {
 1932  0
             PatternSet ps = new PatternSet();
 1933  0
             Enumeration enum = packageNames.elements();
 1934  0
             while (enum.hasMoreElements()) {
 1935  0
                 PackageName p = (PackageName) enum.nextElement();
 1936  0
                 String pkg = p.getName().replace('.', '/');
 1937  0
                 if (pkg.endsWith("*")) {
 1938  0
                     pkg += "*";
 1939   
                 }
 1940  0
                 ps.createInclude().setName(pkg);
 1941   
             }
 1942   
 
 1943  0
             enum = excludePackageNames.elements();
 1944  0
             while (enum.hasMoreElements()) {
 1945  0
                 PackageName p = (PackageName) enum.nextElement();
 1946  0
                 String pkg = p.getName().replace('.', '/');
 1947  0
                 if (pkg.endsWith("*")) {
 1948  0
                     pkg += "*";
 1949   
                 }
 1950  0
                 ps.createExclude().setName(pkg);
 1951   
             }
 1952   
 
 1953   
 
 1954  0
             String[] pathElements = sourcePath.list();
 1955  0
             for (int i = 0; i < pathElements.length; i++) {
 1956  0
                 DirSet ds = new DirSet();
 1957  0
                 ds.setDefaultexcludes(useDefaultExcludes);
 1958  0
                 ds.setDir(new File(pathElements[i]));
 1959  0
                 ds.createPatternSet().addConfiguredPatternset(ps);
 1960  0
                 dirSets.addElement(ds);
 1961   
             }
 1962   
         }
 1963   
 
 1964  0
         Enumeration enum = dirSets.elements();
 1965  0
         while (enum.hasMoreElements()) {
 1966  0
             DirSet ds = (DirSet) enum.nextElement();
 1967  0
             File baseDir = ds.getDir(getProject());
 1968  0
             log("scanning " + baseDir + " for packages.", Project.MSG_DEBUG);
 1969  0
             DirectoryScanner dsc = ds.getDirectoryScanner(getProject());
 1970  0
             String[] dirs = dsc.getIncludedDirectories();
 1971  0
             boolean containsPackages = false;
 1972  0
             for (int i = 0; i < dirs.length; i++) {
 1973   
                 // are there any java files in this directory?
 1974  0
                 File pd = new File(baseDir, dirs[i]);
 1975  0
                 String[] files = pd.list(new FilenameFilter () {
 1976  0
                         public boolean accept(File dir1, String name) {
 1977  0
                             if (name.endsWith(".java")) {
 1978  0
                                 return true;
 1979   
                             }
 1980  0
                             return false;        // ignore dirs
 1981   
                         }
 1982   
                     });
 1983   
 
 1984  0
                 if (files.length > 0) {
 1985  0
                     containsPackages = true;
 1986  0
                     String packageName =
 1987   
                         dirs[i].replace(File.separatorChar, '.');
 1988  0
                     if (!addedPackages.contains(packageName)) {
 1989  0
                         addedPackages.addElement(packageName);
 1990  0
                         pn.addElement(packageName);
 1991   
                     }
 1992   
                 }
 1993   
             }
 1994  0
             if (containsPackages) {
 1995   
                 // We don't need to care for duplicates here,
 1996   
                 // Path.list does it for us.
 1997  0
                 sp.createPathElement().setLocation(baseDir);
 1998   
             } else {
 1999  0
                 log(baseDir + " doesn\'t contain any packages, dropping it.",
 2000   
                     Project.MSG_VERBOSE);
 2001   
             }
 2002   
         }
 2003   
     }
 2004   
 
 2005   
     private class JavadocOutputStream extends LogOutputStream {
 2006  0
         JavadocOutputStream(int level) {
 2007  0
             super(Javadoc.this, level);
 2008   
         }
 2009   
 
 2010   
         //
 2011   
         // Override the logging of output in order to filter out Generating
 2012   
         // messages.  Generating messages are set to a priority of VERBOSE
 2013   
         // unless they appear after what could be an informational message.
 2014   
         //
 2015   
         private String queuedLine = null;
 2016  0
         protected void processLine(String line, int messageLevel) {
 2017  0
             if (messageLevel == Project.MSG_INFO
 2018   
                 && line.startsWith("Generating ")) {
 2019  0
                 if (queuedLine != null) {
 2020  0
                     super.processLine(queuedLine, Project.MSG_VERBOSE);
 2021   
                 }
 2022  0
                 queuedLine = line;
 2023   
             } else {
 2024  0
                 if (queuedLine != null) {
 2025  0
                     if (line.startsWith("Building ")) {
 2026  0
                         super.processLine(queuedLine, Project.MSG_VERBOSE);
 2027   
                     } else {
 2028  0
                         super.processLine(queuedLine, Project.MSG_INFO);
 2029   
                     }
 2030  0
                     queuedLine = null;
 2031   
                 }
 2032  0
                 super.processLine(line, messageLevel);
 2033   
             }
 2034   
         }
 2035   
 
 2036   
 
 2037  0
         protected void logFlush() {
 2038  0
             if (queuedLine != null) {
 2039  0
                 super.processLine(queuedLine, Project.MSG_VERBOSE);
 2040  0
                 queuedLine = null;
 2041   
             }
 2042   
         }
 2043   
     }
 2044   
 
 2045   
     /**
 2046   
      * Convenience method to expand properties.
 2047   
      */
 2048  0
     protected String expand(String content) {
 2049  0
         return getProject().replaceProperties(content);
 2050   
     }
 2051   
 
 2052   
 }
 2053