http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/install.html
----------------------------------------------------------------------
diff --git a/manual/install.html b/manual/install.html
index f6699ce..abff025 100644
--- a/manual/install.html
+++ b/manual/install.html
@@ -38,10 +38,10 @@ details.</li>
 <li>Set environmental variables: <code>JAVA_HOME</code> to your Java 
environment, <code>ANT_HOME</code> to the directory
 you uncompressed Ant to, and add <samp>${ANT_HOME}/bin</samp> (Unix) or 
<samp>%ANT_HOME%/bin</samp> (Windows) to
 your <code>PATH</code>. See <a href="#setup">Setup</a> for details.</li>
-<li>Optionally, from the <code>ANT_HOME</code> directory run <code>ant -f 
fetch.xml -Ddest=system</code> to get the
+<li>Optionally, from the <code>ANT_HOME</code> directory run <kbd>ant -f 
fetch.xml -Ddest=system</kbd> to get the
 library dependencies of most of the Ant tasks that require them. If you don't 
do this, many of the dependent Ant tasks
 will not be available. See <a href="#optionalTasks">Optional Tasks</a> for 
details and other options for
-the <code>-Ddest</code> parameter.</li>
+the <kbd>-Ddest</kbd> parameter.</li>
 <li>Optionally, add any desired Antlibs. See <a 
href="https://ant.apache.org/antlibs/proper.html"; target="_top">Ant
 Libraries</a> for a list.</li>
 </ol>
@@ -325,7 +325,7 @@ security restrictions on the classes which may be loaded by 
an extension.
 
 <h3 id="checkInstallation">Check Installation</h3>
 <p>
-You can check the basic installation with opening a new shell and typing 
<code>ant</code>. You should get a message like
+You can check the basic installation with opening a new shell and typing 
<kbd>ant</kbd>. You should get a message like
 this
 </p>
 <pre>
@@ -333,8 +333,8 @@ Buildfile: build.xml does not exist!
 Build failed
 </pre>
 <p>
-So Ant works. This message is there because you need to write a buildfile for 
your project. With a <code>ant
--version</code> you should get an output like
+So Ant works. This message is there because you need to write a buildfile for 
your project. With a <kbd>ant
+-version</kbd> you should get an output like
 </p>
 <pre>
 Apache Ant(TM) version 1.9.2 compiled on July 8 2013
@@ -351,7 +351,7 @@ If this does not work, ensure your environment variables 
are set right. E.g., on
 <code>ANT_HOME</code> is used by the launcher script for finding the 
libraries. <code>JAVA_HOME</code> is used by the
 launcher for finding the JDK/JRE to use. (JDK is recommended as some tasks 
require the Java tools.) If not set, the
 launcher tries to find one via the <code>%PATH%</code> environment variable. 
<code>PATH</code> is set for user
-convenience. With that set you can just start <code>ant</code> instead of 
always
+convenience. With that set you can just start <kbd>ant</kbd> instead of always
 typing <samp>the/complete/path/to/your/ant/installation/bin/ant</samp>.
 </p>
 
@@ -381,7 +381,7 @@ Ant. All JAR files added to this directory are available to 
command-line Ant.
 
 <li>
 <p>
-On the command line with a <code>-lib</code> parameter. This lets you add new 
JAR files on a case-by-case basis.
+On the command line with a <kbd>-lib</kbd> parameter. This lets you add new 
JAR files on a case-by-case basis.
 </p>
 </li>
 
@@ -417,7 +417,7 @@ the optional Ant tasks need.
 To do so, change to the <code>ANT_HOME</code> directory and execute the 
command:
 </p>
 
-<pre>ant -f fetch.xml -Ddest=<em>[option]</em></pre>
+<pre class="input">ant -f fetch.xml -Ddest=<em>[option]</em></pre>
 
 <p>
 where option is one of the following, as described above:
@@ -471,14 +471,14 @@ space in a directory. This will break Ant, and it is not 
needed.</li>
 Ant's ability to quote the string. Again, this is not needed for the correct 
operation of the <code>CLASSPATH</code>
 environment variable, even if a DOS directory is to be added to the path.</li>
 
-<li>You can stop Ant using the <code>CLASSPATH</code> environment variable by 
setting the <code>-noclasspath</code>
+<li>You can stop Ant using the <code>CLASSPATH</code> environment variable by 
setting the <kbd>-noclasspath</kbd>
 option on the command line. This is an easy way to test for classpath-related 
problems.</li>
 </ol>
 
 <p>
 The usual symptom of <code>CLASSPATH</code> problems is that Ant will not run 
with some error about not being able to
 find <code>org.apache.tools.ant.launch.Launcher</code>, or, if you have got 
the quotes/backslashes wrong, some very
-weird Java startup error. To see if this is the case, run <code>ant 
-noclasspath</code> or unset
+weird Java startup error. To see if this is the case, run <kbd>ant 
-noclasspath</kbd> or unset
 the <code>CLASSPATH</code> environment variable.
 </p>
 
@@ -510,7 +510,7 @@ this.
 <li><strong>With Java 5 or above</strong><br/>
 <p>
 When you run Ant on Java 5 or above, you could try to use the automatic proxy 
setup mechanism
-with <code>-autoproxy</code>.
+with <kbd>-autoproxy</kbd>.
 </p>
 </li>
 
@@ -525,15 +525,15 @@ laptop, you have to change these settings as you roam. To 
set <code>ANT_OPTS</co
 <p>
 For csh/tcsh:
 </p>
-<pre>setenv ANT_OPTS "-Dhttp.proxyHost=proxy -Dhttp.proxyPort=8080"</pre>
+<pre class="input">setenv ANT_OPTS "-Dhttp.proxyHost=proxy 
-Dhttp.proxyPort=8080"</pre>
 <p>
 For bash:
 </p>
-<pre>export ANT_OPTS="-Dhttp.proxyHost=proxy -Dhttp.proxyPort=8080"</pre>
+<pre class="input">export ANT_OPTS="-Dhttp.proxyHost=proxy 
-Dhttp.proxyPort=8080"</pre>
 <p>
 For Windows, set the environment variable in the appropriate dialog box and 
open a new console or, by hand
 </p>
-<pre>set ANT_OPTS = -Dhttp.proxyHost=proxy -Dhttp.proxyPort=8080</pre>
+<pre class="input">set ANT_OPTS = -Dhttp.proxyHost=proxy 
-Dhttp.proxyPort=8080</pre>
 </blockquote>
 </li>
 
@@ -554,7 +554,7 @@ do not work, because those are <em>Ant properties</em> 
being set, not JVM option
 up the command line:
 </p>
 
-<pre>ant -Dhttp.proxyHost=proxy -Dhttp.proxyPort=81</pre>
+<pre class="input">ant -Dhttp.proxyHost=proxy -Dhttp.proxyPort=81</pre>
 
 <p>
 All it does is set up two Ant properties.
@@ -569,19 +569,19 @@ have to spend much time configuring the JVM properties 
until they are happy.
 <h3 id="windows">Windows and OS/2</h3>
 <p>Assume Ant is installed in <samp>c:\ant\</samp>. The following sets up the
 environment:</p>
-<pre>set ANT_HOME=c:\ant
+<pre class="input">set ANT_HOME=c:\ant
 set JAVA_HOME=c:\jdk1.7.0_51
 set PATH=%PATH%;%ANT_HOME%\bin</pre>
 
 <h3 id="bash">Linux/Unix (bash)</h3>
 <p>Assume Ant is installed in <samp>/usr/local/ant</samp>. The following sets 
up
 the environment:</p>
-<pre>export ANT_HOME=/usr/local/ant
+<pre class="input">export ANT_HOME=/usr/local/ant
 export JAVA_HOME=/usr/local/jdk1.7.0_51
 export PATH=${PATH}:${ANT_HOME}/bin</pre>
 
 <h3 id="tcshcsh">Linux/Unix (csh)</h3>
-<pre>setenv ANT_HOME /usr/local/ant
+<pre class="input">setenv ANT_HOME /usr/local/ant
 setenv JAVA_HOME /usr/local/jdk/jdk1.7.0_51
 set path=( $path $ANT_HOME/bin )</pre>
 
@@ -592,7 +592,7 @@ Having a symbolic link set up to point to the JVM/JDK 
version makes updates more
 <p>
 The <a href="http://www.jpackage.org"; target="_top">JPackage project</a> 
distributes an RPM version of Ant. With this
 version, it is not necessary to set <code>JAVA_HOME</code> or 
<code>ANT_HOME</code> environment variables and the RPM
-installer will correctly place the Ant executable on your path.
+installer will correctly place the <kbd>ant</kbd> executable on your path.
 </p>
 <p>
 <strong>Note</strong>: <em>Since Ant 1.7.0</em>, if the <code>ANT_HOME</code> 
environment variable is set, the JPackage
@@ -626,7 +626,7 @@ above.</li>
 
 Finally, if for some reason you are running on a system with both the JPackage 
and Apache versions of Ant available, if
 you should want to run the Apache version (which will have to be specified 
with an absolute file name, not found on the
-path), you should use Ant's <code>--noconfig</code> command-line switch to 
avoid JPackage's classpath mechanism.
+path), you should use Ant's <kbd>--noconfig</kbd> command-line switch to avoid 
JPackage's classpath mechanism.
 
 <h3 id="advanced">Advanced</h3>
 
@@ -665,8 +665,8 @@ installed. See <a href="#installing">Installing Ant</a> for 
examples on how to d
 </p>
 
 <p>
-<strong>Note</strong>: The bootstrap process of Ant requires a greedy compiler 
like OpenJDK or Oracle's javac. It does
-not work with gcj or kjc.
+<strong>Note</strong>: The bootstrap process of Ant requires a greedy compiler 
like OpenJDK or
+Oracle's <kbd>javac</kbd>. It does not work with <kbd>gcj</kbd> or 
<kbd>kjc</kbd>.
 </p>
 
 <p>
@@ -693,8 +693,8 @@ from <a href="https://junit.org/"; 
target="_top">JUnit.org</a>) if you are using
 Your are now ready to build Ant:
 </p>
 <blockquote>
-  <p><code>build 
-Ddist.dir=&lt;<i>directory-to-contain-Ant-distribution</i>&gt; 
dist</code>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Windows</em>)</p>
-  <p><code>sh build.sh 
-Ddist.dir=&lt;<i>directory-to-contain-Ant-distribution</i>&gt; 
dist</code>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Unix</em>)</p>
+  <p><kbd>build 
-Ddist.dir=&lt;<i>directory-to-contain-Ant-distribution</i>&gt; 
dist</kbd>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Windows</em>)</p>
+  <p><kbd>sh build.sh 
-Ddist.dir=&lt;<i>directory-to-contain-Ant-distribution</i>&gt; 
dist</kbd>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Unix</em>)</p>
 </blockquote>
 
 <p>
@@ -719,21 +719,21 @@ directory.</li>
 <p>
 On most occasions you will not need to explicitly bootstrap Ant since the 
build scripts do that for you. However, if the
 build file you are using makes use of features not yet compiled into the 
bootstrapped Ant, you will need to manually
-bootstrap. Run <code>bootstrap.bat</code> (Windows) or 
<code>bootstrap.sh</code> (UNIX) to build a new bootstrap version
+bootstrap. Run <kbd>bootstrap.bat</kbd> (Windows) or <kbd>bootstrap.sh</kbd> 
(UNIX) to build a new bootstrap version
 of Ant.
 </p>
 
 If you wish to install the build into the current <code>ANT_HOME</code>
 directory, you can use:
 <blockquote>
-  <p><code>build install</code>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Windows</em>)</p>
-  <p><code>sh build.sh 
install</code>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Unix</em>)</p>
+  <p><kbd>build install</kbd>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Windows</em>)</p>
+  <p><kbd>sh build.sh install</kbd>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Unix</em>)</p>
 </blockquote>
 
 You can avoid the lengthy Javadoc step, if desired, with:
 <blockquote>
-  <p><code>build 
install-lite</code>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Windows</em>)</p>
-  <p><code>sh build.sh 
install-lite</code>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Unix</em>)</p>
+  <p><kbd>build 
install-lite</kbd>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Windows</em>)</p>
+  <p><kbd>sh build.sh 
install-lite</kbd>&nbsp;&nbsp;&nbsp;&nbsp;(<em>Unix</em>)</p>
 </blockquote>
 This will only install the <samp>bin</samp> and <samp>lib</samp> directories.
 
@@ -749,7 +749,7 @@ different user than the one who installed Ant initially). 
In this case you can s
 property <code>chmod.fail</code> to false when starting the build like in
 </p>
 
-<pre>sh build.sh install -Dchmod.fail=false</pre>
+<pre class="input">sh build.sh install -Dchmod.fail=false</pre>
 
 <p>
 and any error to change permission will not result in a build failure.
@@ -936,7 +936,7 @@ these tasks available. Please refer to the <a 
href="#optionalTasks">Installing A
 <h3 id="diagnostics">Diagnostics</h3>
 
 <p>
-Ant has a built in diagnostics feature. If you run <code>ant 
-diagnostics</code>, Ant will look at its internal state
+Ant has a built in diagnostics feature. If you run <kbd>ant 
-diagnostics</kbd>, Ant will look at its internal state
 and print it out. This code will check and print the following things.
 </p>
 
@@ -965,7 +965,7 @@ get confused.</li>
 </ul>
 
 <p>
-Running <code>ant -diagnostics</code> is a good way to check that Ant is 
installed. It is also a first step towards
+Running <kbd>ant -diagnostics</kbd> is a good way to check that Ant is 
installed. It is also a first step towards
 self-diagnosis of any problem. Any configuration problem reported to the user 
mailing list will probably result ins
 someone asking you to run the command and show the results, so save time by 
using it yourself.
 </p>

http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/javacprops.html
----------------------------------------------------------------------
diff --git a/manual/javacprops.html b/manual/javacprops.html
index 5593f22..dc3e22b 100644
--- a/manual/javacprops.html
+++ b/manual/javacprops.html
@@ -26,7 +26,7 @@
 
 <p>The <var>source</var> and <var>target</var> attributes
 of <code>&lt;javac&gt;</code> don't have any default values for
-historical reasons.  Since the underlying <code>javac</code>
+historical reasons.  Since the underlying <kbd>javac</kbd>
 compiler defaults depends on the JDK you use, you may encounter
 build files that don't explicitly set those attributes and that will
 no longer compile using a newer JDK.  If you cannot change the build

http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/listeners.html
----------------------------------------------------------------------
diff --git a/manual/listeners.html b/manual/listeners.html
index 7677b81..346e205 100644
--- a/manual/listeners.html
+++ b/manual/listeners.html
@@ -45,7 +45,7 @@ loggers.</p>
 </ul>
 
 <p>These are used internally for various recording and housekeeping 
operations, however new
-listeners may registered on the command line through the 
<code>-listener</code> argument.</p>
+listeners may registered on the command line through the <kbd>-listener</kbd> 
argument.</p>
 
 <h3 id="Loggers">Loggers</h3>
 
@@ -53,8 +53,8 @@ listeners may registered on the command line through the 
<code>-listener</code>
 
 <ul>
   <li>Receives a handle to the standard output and error print streams and 
therefore can log
-    information to the console or the <code>-logfile</code> specified 
file.</li>
-  <li>Logging level (<code>-quiet</code>, <code>-verbose</code>, 
<code>-debug</code>) aware</li>
+    information to the console or the <kbd>-logfile</kbd> specified file.</li>
+  <li>Logging level (<kbd>-quiet</kbd>, <kbd>-verbose</kbd>, 
<kbd>-debug</kbd>) aware</li>
   <li>Emacs-mode aware</li>
 </ul>
 
@@ -68,7 +68,7 @@ listeners may registered on the command line through the 
<code>-listener</code>
   </tr>
   <tr>
     <td><code><a 
href="#DefaultLogger">org.apache.tools.ant.DefaultLogger</a></code></td>
-    <td>The logger used implicitly unless overridden with the 
<code>-logger</code> command-line
+    <td>The logger used implicitly unless overridden with the 
<kbd>-logger</kbd> command-line
       switch.</td>
     <td>BuildLogger</td>
   </tr>
@@ -127,12 +127,12 @@ listeners may registered on the command line through the 
<code>-listener</code>
 <h3 id="DefaultLogger">DefaultLogger</h3>
 <p>Simply run Ant normally, or:</p>
 
-<pre>ant -logger org.apache.tools.ant.DefaultLogger</pre>
+<pre class="input">ant -logger org.apache.tools.ant.DefaultLogger</pre>
 
 <h3 id="NoBannerLogger">NoBannerLogger</h3>
 <p>Removes output of empty target output.</p>
 
-<pre>ant -logger org.apache.tools.ant.NoBannerLogger</pre>
+<pre class="input">ant -logger org.apache.tools.ant.NoBannerLogger</pre>
 
 <h3 id="MailLogger">MailLogger</h3>
 <p>The MailLogger captures all output logged through DefaultLogger (standard 
Ant output) and will
@@ -266,7 +266,7 @@ failure messages individually.</p>
   </tr>
 </table>
 
-<pre>ant -logger org.apache.tools.ant.listener.MailLogger</pre>
+<pre class="input">ant -logger org.apache.tools.ant.listener.MailLogger</pre>
 
 <h3 id="AnsiColorLogger">AnsiColorLogger</h3>
 
@@ -275,13 +275,13 @@ code escape sequences to it.  It is just an extension of 
<a href="#DefaultLogger
 and hence provides all features that DefaultLogger does.</p>
 <p>AnsiColorLogger differentiates the output by assigning different colors 
depending upon the type
 of the message.</p>
-<p>If used with the <code>-logfile</code> option, the output file will contain 
all the necessary
+<p>If used with the <kbd>-logfile</kbd> option, the output file will contain 
all the necessary
 escape codes to display the text in colorized mode when displayed in the 
console using applications
 like <code>cat</code>, <code>more</code>, etc.</p>
-<p>This is designed to work on terminals that support ANSI color codes.  It 
works on XTerm, ETerm, Win9x Console (with
-ANSI.SYS loaded.), etc.</p>
+<p>This is designed to work on terminals that support ANSI color codes.  It 
works on XTerm, ETerm,
+Win9x Console (with <code>ANSI.SYS</code> loaded.), etc.</p>
 <p><strong>Note</strong>: It doesn't work on WinNT and successors, even when
-a <code>COMMAND.COM</code> console loaded with ANSI.SYS is used.</p>
+a <code>COMMAND.COM</code> console loaded with <code>ANSI.SYS<</code> is 
used.</p>
 <p>If the user wishes to override the default colors with custom ones, a file 
containing zero or
 more of the custom color key-value pairs must be created.  The recognized keys 
and their default
 values are shown below:</p>
@@ -294,11 +294,11 @@ AnsiColorLogger.DEBUG_COLOR=2;34</pre>
 <p>Each key takes as value a color combination defined as 
<q>Attribute;Foreground;Background</q>.
 In the above example, background value has not been used.</p>
 <p>This file must be specified as the value of a system variable
-named <code>ant.logger.defaults</code> and passed as an argument using the 
<code>-D</code> option to
-the <code>java</code> command that invokes the Ant application. An easy way to 
achieve this is to
-add <code>-Dant.logger.defaults=</code><samp>/path/to/your/file</samp> to the 
<code>ANT_OPTS</code>
-environment variable. Ant's launching script recognizes this flag and will 
pass it to
-the <code>java</code> command appropriately.</p>
+named <code>ant.logger.defaults</code> and passed as an argument using the 
<kbd>-D</kbd> option to
+the <kbd>java</kbd> command that invokes the Ant application. An easy way to 
achieve this is to
+add <kbd>-Dant.logger.defaults=</kbd><samp 
class="input">/path/to/your/file</samp> to
+the <code>ANT_OPTS</code> environment variable. Ant's launching script 
recognizes this flag and will
+pass it to the <kbd>java</kbd> command appropriately.</p>
 <p>Format:</p>
 <pre>
 AnsiColorLogger.*=Attribute;Foreground;Background
@@ -332,7 +332,7 @@ Background is one of the following:
 46 &rarr; Cyan
 47 &rarr; White</pre>
 
-<pre>ant -logger org.apache.tools.ant.listener.AnsiColorLogger</pre>
+<pre class="input">ant -logger 
org.apache.tools.ant.listener.AnsiColorLogger</pre>
 
 <h3 id="Log4jListener">Log4jListener</h3>
 <p><em><u>Deprecated</u></em>: Apache Log4j (1) is not developed any more. 
Last release is 1.2.17
@@ -340,8 +340,8 @@ from 26 May 2012 and contains vulnerability issues.</p>
 <p>Passes build events to Log4j, using the full classname's of the generator 
of each build event as
 the category:</p>
 <ul>
-  <li>build started / build 
finished&mdash;<code>org.apache.tools.ant.Project</code></li>
-  <li>target started / target 
finished&mdash;<code>org.apache.tools.ant.Target</code></li>
+  <li>build started / build finished&mdash;<code 
class="code">org.apache.tools.ant.Project</code></li>
+  <li>target started / target finished&mdash;<code 
class="code">org.apache.tools.ant.Target</code></li>
   <li>task started / task finished&mdash;the fully qualified classname of the 
task</li>
   <li>message logged&mdash;the classname of one of the above, so if a task 
logs a message, its
     classname is the category used, and so on.</li>
@@ -350,13 +350,13 @@ the category:</p>
 on whether the build failed during that stage. Message events are logged 
according to their Ant
 logging level, mapping directly to a corresponding Log4j level.</p>
 
-<pre>ant -listener org.apache.tools.ant.listener.Log4jListener</pre>
+<pre class="input">ant -listener 
org.apache.tools.ant.listener.Log4jListener</pre>
 
 <p>To use Log4j you will need the Log4j JAR file and a 
<samp>log4j.properties</samp> configuration
 file.  Both should be placed somewhere in your Ant classpath. If the 
<samp>log4j.properties</samp>
-is in your project root folder you can add this with <code>-lib</code> 
option:</p>
+is in your project root folder you can add this with <kbd>-lib</kbd> 
option:</p>
 
-<pre>ant -listener org.apache.tools.ant.listener.Log4jListener -lib .</pre>
+<pre class="input">ant -listener org.apache.tools.ant.listener.Log4jListener 
-lib .</pre>
 
 <p>If, for example, you wanted to capture the same information output to the 
console by the
 DefaultLogger and send it to a file named <samp>build.log</samp>, you could 
use the following
@@ -387,7 +387,7 @@ want to use the Log4j 2.x runtime.  For using the bridge 
with Ant you have to ad
   <li><samp>log4j-core-${log4j.version}.jar</samp></li>
   <li><samp>log4j2.xml</samp></li>
 </ul>
-<p>to your classpath, e.g. via the <code>-lib</code> option.  (For using the 
bridge, Ant
+<p>to your classpath, e.g. via the <kbd>-lib</kbd> option.  (For using the 
bridge, Ant
 1.9.10/1.10.2 or higher is required.)  Translating the 1.x properties file 
into the 2.x XML syntax
 would result in</p>
 <pre>
@@ -414,7 +414,7 @@ would result in</p>
 <h3 id="XmlLogger">XmlLogger</h3>
 <p>Writes all build information out to an XML file named <samp>log.xml</samp>, 
or the value of
 the <code>XmlLogger.file</code> property if present, when used as a listener. 
When used as a logger,
-it writes all output to either the console or to the value of 
<code>-logfile</code>. Whether used as
+it writes all output to either the console or to the value of 
<kbd>-logfile</kbd>. Whether used as
 a listener or logger, the output is not generated until the build is complete, 
as it buffers the
 information in order to provide timing information for task, targets, and the 
project.</p>
 <p>By default the XML file creates a reference to an XSLT file 
<samp>log.xsl</samp> in the current
@@ -423,16 +423,16 @@ property <code>ant.XmlLogger.stylesheet.uri</code> to 
provide a URI to a style s
 relative or absolute file path, or an HTTP URL. If you set the property to the 
empty
 string, <q></q>, no XSLT transform is declared at all.</p>
 
-<pre>ant -listener org.apache.tools.ant.XmlLogger
+<pre class="input">ant -listener org.apache.tools.ant.XmlLogger
 ant -logger org.apache.tools.ant.XmlLogger -verbose -logfile 
build_log.xml</pre>
 
 <h3 id="TimestampedLogger">TimestampedLogger</h3>
 <p>Acts like the default logger, except that the final success/failure message 
also includes the
 time that the build completed. For example:</p>
-<pre>BUILD SUCCESSFUL - at 16/08/05 16:24</pre>
+<pre class="output">BUILD SUCCESSFUL - at 16/08/05 16:24</pre>
 <p>To use this listener, use the command:</p>
 
-<pre>ant  -logger org.apache.tools.ant.listener.TimestampedLogger</pre>
+<pre class="input">ant -logger 
org.apache.tools.ant.listener.TimestampedLogger</pre>
 
 <h3 id="BigProjectLogger">BigProjectLogger</h3>
 <p>This logger is designed to make examining the logs of a big build easier, 
especially those run
@@ -447,7 +447,7 @@ under continuous integration tools. It</p>
 <p>This is useful when using <code>&lt;subant&gt;</code> to build a large 
project from many smaller
 projects&mdash;the output shows which particular project is building. Here is 
an example in which
 "clean" is being called on all a number of child projects, only some of which 
perform work:</p>
-<pre>
+<pre class="output">
 ======================================================================
 Entering project "xunit"
 In /home/ant/components/xunit
@@ -474,13 +474,13 @@ Exiting project "junit"
 testing many child components, the messages are reduced to becoming clear 
delimiters of where
 different projects are in charge&mdash;or, more importantly, which project is 
failing.</p>
 <p>To use this listener, use the command:</p>
-<pre>ant -logger org.apache.tools.ant.listener.BigProjectLogger</pre>
+<pre class="input">ant -logger 
org.apache.tools.ant.listener.BigProjectLogger</pre>
 
 <h3 id="SimpleBigProjectLogger">SimpleBigProjectLogger</h3>
 <p><em>Since Ant 1.8.1</em></p>
 <p>Like <code>BigProjectLogger</code>, project-qualified target names are 
printed, useful for big
 builds with subprojects. Otherwise it is as quiet as 
<code>NoBannerLogger</code>:</p>
-<pre>
+<pre class="output">
 Buildfile: /sources/myapp/build.xml
 
 myapp-lib.compile:
@@ -500,7 +500,7 @@ Building jar: /sources/myapp/build/myapp.jar
 BUILD SUCCESSFUL
 Total time: 1 second</pre>
 <p>To use this listener, use the command:</p>
-<pre>ant -logger org.apache.tools.ant.listener.SimpleBigProjectLogger</pre>
+<pre class="input">ant -logger 
org.apache.tools.ant.listener.SimpleBigProjectLogger</pre>
 
 <h3 id="ProfileLogger">ProfileLogger</h3>
 <!-- This is the 'since' as described in the Loggers JavaDoc -->
@@ -522,9 +522,9 @@ Having that buildfile
         &lt;echo&gt;another-echo-task&lt;/echo&gt;
     &lt;/target&gt;
 &lt;/project&gt;</pre>
-<p>and executing with <code>ant -logger 
org.apache.tools.ant.listener.ProfileLogger
-anotherTarget</code> gives that output (with other timestamps and duration of 
course ;-):</p>
-<pre>
+<p>and executing with <kbd>ant -logger 
org.apache.tools.ant.listener.ProfileLogger
+anotherTarget</kbd> gives that output (with other timestamps and duration of 
course ;-):</p>
+<pre class="output">
 Buildfile: ...\build.xml
 
 Target aTarget: started Thu Jan 22 09:01:00 CET 2009
@@ -562,23 +562,23 @@ Total time: 2 seconds</pre>
 <ul>
   <li>
     A listener or logger should not write to standard output or error in
-    the <code>messageLogged()</code> method; Ant captures these internally and 
it will trigger an
-    infinite loop.
+    the <code class="code">messageLogged()</code> method; Ant captures these 
internally and it will
+    trigger an infinite loop.
   </li>
   <li>
     Logging is synchronous; all listeners and loggers are called one after the 
other, with the build
     blocking until the output is processed. Slow logging means a slow build.
   </li>
-  <li>When a build is started, and <code>BuildListener.buildStarted(BuildEvent 
event)</code> is
-    called, the project is not fully functional. The build has started, yes, 
and
-    the <code>event.getProject()</code> method call returns the Project 
instance, but that project
-    is initialized with JVM and Ant properties, nor has it parsed the build 
file yet. You cannot
-    call <code>Project.getProperty()</code> for property lookup, or
-    <code>Project.getName()</code> to get the project name (it will return 
null).
+  <li>When a build is started, and <code 
class="code">BuildListener.buildStarted(BuildEvent
+    event)</code> is called, the project is not fully functional. The build 
has started, yes, and
+    the <code class="code">event.getProject()</code> method call returns the 
Project instance, but
+    that project is initialized with JVM and Ant properties, nor has it parsed 
the build file
+    yet. You cannot call <code class="code">Project.getProperty()</code> for 
property lookup, or
+    <code class="code">Project.getName()</code> to get the project name (it 
will return null).
   </li>
   <li>
-    Classes that implement <code>org.apache.tools.ant.SubBuildListener</code> 
receive notifications
-    when child projects start and stop.
+    Classes that implement <code 
class="code">org.apache.tools.ant.SubBuildListener</code> receive
+    notifications when child projects start and stop.
   </li>
 </ul>
 

http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/platform.html
----------------------------------------------------------------------
diff --git a/manual/platform.html b/manual/platform.html
index f1ee98f..c9a89b0 100644
--- a/manual/platform.html
+++ b/manual/platform.html
@@ -46,7 +46,7 @@ or <code>&lt;apply&gt;</code> the real tar program.</li>
 to build up a list of files. Unexpected things can happen.</li>
 <li>Linux on IA-64: apparently you need a larger heap than the default one 
(64M) to compile big
 projects. If you get out of heap errors, either increase the heap or use a
-forking <code>javac</code>. Better yet, use jikes for extra compilation 
speed.</li>
+forking <code>javac</code>. Better yet, use <code>jikes</code> for extra 
compilation speed.</li>
 </ul>
 
 <h2>Microsoft Windows</h2>
@@ -87,7 +87,7 @@ Ant is trying to run, it is not on the path.
 <p>
 There are reports of problems with Windows Vista security bringing up dialog 
boxes asking if the
 user wants to run an untrusted executable during an Ant run, such as when the 
&lt;signjar&gt; task
-runs the <code>jarsigner.exe</code> program. This is beyond Ant's control, and 
stems from the OS
+runs the <kbd>jarsigner.exe</kbd> program. This is beyond Ant's control, and 
stems from the OS
 trying to provide some illusion of security by being reluctant to run unsigned 
native executables.
 The latest Java versions appear to resolve this problem by having signed 
binaries.
 </p>
@@ -102,7 +102,7 @@ and JRE tools under Windows or cygwin. Relative path names 
such as <samp>src/org
 are supported, but Java tools do not understand <samp>/cygdrive/c</samp> to 
mean <samp>c:\</samp>.
 </p>
 <p>
-The utility <code>cygpath</code> (used industrially in the <code>ant</code> 
script to support
+The utility <kbd>cygpath</kbd> (used industrially in the <kbd>ant</kbd> script 
to support
 cygwin) can convert cygwin path names to Windows.  You can use the 
<code>&lt;exec&gt;</code> task in
 Ant to convert cygwin paths to Windows path, for instance like that:
 </p>
@@ -139,7 +139,7 @@ or <samp>dist\bin</samp>).
   <li><code>CLASSPATH</code>&mdash;put <samp>ant.jar</samp> and any other 
needed jars on the system
     classpath.</li>
   <li><code>ANT_OPTS</code>&mdash;On NetWare, <code>ANT_OPTS</code> needs to 
include a parameter of
-    the form, <code>-envCWD=<i>ANT_HOME</i></code>, with 
<code><i>ANT_HOME</i></code> being the
+    the form, <kbd>-envCWD=<i>ANT_HOME</i></kbd>, with 
<kbd><i>ANT_HOME</i></kbd> being the
     fully expanded location of Ant, <strong>not</strong> an environment 
variable.  This is due to
     the fact that the NetWare System Console has no notion of a current 
working directory.</li>
 </ul>

http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/projecthelper.html
----------------------------------------------------------------------
diff --git a/manual/projecthelper.html b/manual/projecthelper.html
index 4c2523e..057f07c 100644
--- a/manual/projecthelper.html
+++ b/manual/projecthelper.html
@@ -28,122 +28,114 @@
 <h2 id="definition">What is a ProjectHelper?</h2>
 
 <p>
-The <code>ProjectHelper</code> in Apache Ant is responsible for parsing the 
build file
-and creating Java instances representing the build workflow. It also signals 
which
-kind of file it can parse, and which file name it expects as default input 
file.
+The <code class="code">ProjectHelper</code> in Apache Ant is responsible for 
parsing the build file
+and creating Java instances representing the build workflow. It also signals 
which kind of file it
+can parse, and which file name it expects as default input file.
 </p>
 
 <p>
-Ant's default <code>ProjectHelper</code>
-(<code>org.apache.tools.ant.helper.ProjectHelper2</code>) parses the
-usual <code>build.xml</code> files. And if no build file is specified on the 
command
-line, it will expect to find a file named <code>build.xml</code>.
+Ant's default <code class="code">ProjectHelper</code>
+(<code class="code">org.apache.tools.ant.helper.ProjectHelper2</code>) parses 
the
+usual <code>build.xml</code> files. And if no build file is specified on the 
command line, it will
+expect to find a file named <code>build.xml</code>.
 </p>
 
 <p>
-The immediate benefit of a such abstraction it that it is possible to make Ant
-understand other kind of descriptive languages than XML. Some experiments have 
been
-done around a pure Java frontend, and a Groovy one too (ask the dev mailing 
list for
-further info about these).
+The immediate benefit of a such abstraction it that it is possible to make Ant 
understand other kind
+of descriptive languages than XML. Some experiments have been done around a 
pure Java frontend, and
+a Groovy one too (ask the dev mailing list for further info about these).
 </p>
 
 <p>
-<em>Since Ant 1.8.2</em>, the <a href="Tasks/import.html">import</a> task will 
also
-try to use the proper helper to parse the imported file. So it is possible to 
write
-different build files in different languages and have them import each other.
+<em>Since Ant 1.8.2</em>, the <a href="Tasks/import.html">import</a> task will 
also try to use the
+proper helper to parse the imported file. So it is possible to write different 
build files in
+different languages and have them import each other.
 </p>
 
 <h2 id="repository">How is Ant is selecting the proper ProjectHelper</h2>
 
 <p>
-Ant knows about several implementations of <code>ProjectHelper</code> and has 
to
-decide which to use for each build file.
+Ant knows about several implementations of <code 
class="code">ProjectHelper</code> and has to decide
+which to use for each build file.
 </p>
 
 <p>
-At startup Ant lists the all implementations found and keeps them in the same 
order
-they've been found in an internal 'repository':
+At startup Ant lists the all implementations found and keeps them in the same 
order they've been
+found in an internal 'repository':
 </p>
 <ul>
-  <li>the first to be searched for is the one declared by the system property
-    <code>org.apache.tools.ant.ProjectHelper</code> (see
-    <a href="running.html#sysprops">Java System Properties</a>);</li>
-  <li>then it searches with its class loader for a <code>ProjectHelper</code>
-    service declarations in the <samp>META-INF</samp>: it searches in the 
classpath for a
-    file <samp>META-INF/services/org.apache.tools.ant.ProjectHelper</samp>.
-    This file will just contain the fully qualified name of the
-    implementation of <code>ProjectHelper</code> to instantiate;</li>
-  <li>it will also search with the system class loader for
-    <code>ProjectHelper</code> service declarations in the 
<samp>META-INF</samp>;</li>
-  <li>last but not least it will add its default <code>ProjectHelper</code>
-    that can parse classical <samp>build.xml</samp> files.</li>
+  <li>the first to be searched for is the one declared by the system
+    property <code class="code">org.apache.tools.ant.ProjectHelper</code>
+    (see <a href="running.html#sysprops">Java System Properties</a>);</li>
+  <li>then it searches with its class loader for a <code>ProjectHelper</code> 
service declarations
+    in the <samp>META-INF</samp>: it searches in the classpath for a
+    file <samp>META-INF/services/org.apache.tools.ant.ProjectHelper</samp>.  
This file will just
+    contain the fully qualified name of the implementation
+    of <code class="code">ProjectHelper</code> to instantiate;</li>
+  <li>it will also search with the system class loader for <code 
class="code">ProjectHelper</code>
+    service declarations in the <samp>META-INF</samp>;</li>
+  <li>last but not least it will add its default <code 
class="code">ProjectHelper</code> that can
+    parse classical <samp>build.xml</samp> files.</li>
 </ul>
 <p>
-In case of an error while trying to instantiate a <code>ProjectHelper</code>, 
Ant will
+In case of an error while trying to instantiate a <code 
class="code">ProjectHelper</code>, Ant will
 log an error but won't stop.  If you want further debugging info about
-the <code>ProjectHelper</code> internal 'repository', use the 
<strong>system</strong>
-property <code>ant.project-helper-repo.debug</code> and set it to 
<code>true</code>;
-the full stack trace will then also be printed.
+the <code class="code">ProjectHelper</code> internal 'repository', use the 
<strong>system</strong>
+property <code>ant.project-helper-repo.debug</code> and set it to <q>true</q>; 
the full stack trace
+will then also be printed.
 </p>
 
 <p>
-When Ant is expected to parse a file, it will ask the 
<code>ProjectHelper</code>
-repository to find an implementation that will be able to parse the input
-file. Actually it will just iterate over the ordered list and the first 
implementation
-that returns <code>true</code> to <code>supportsBuildFile(File 
buildFile)</code> will
-be selected.
+When Ant is expected to parse a file, it will ask the <code 
class="code">ProjectHelper</code>
+repository to find an implementation that will be able to parse the input 
file. Actually it will
+just iterate over the ordered list and the first implementation that returns 
<q>true</q>
+to <code class="code">supportsBuildFile(File buildFile)</code> will be 
selected.
 </p>
 
 <p>
-When Ant is started and no input file has been specified, it will search for a 
default
-input file. It will iterate over list of <code>ProjectHelper</code>s and will 
select
-the first one that expects a default file that actually exist.
+When Ant is started and no input file has been specified, it will search for a 
default input
+file. It will iterate over list of <code class="code">ProjectHelper</code>s 
and will select the
+first one that expects a default file that actually exist.
 </p>
 
 <h2 id="writing">Writing your own ProjectHelper</h2>
 
 <p>
-The class <code>org.apache.tools.ant.ProjectHelper</code> is the API expected 
to be
-implemented. So write your own <code>ProjectHelper</code> by extending that 
abstract
-class. You are then expected to implement at least the function 
<code>parse(Project
-project, Object source)</code>. Note also that your implementation will be
-instantiated by Ant, and it is expecting a default constructor with no 
arguments.
+The class <code class="code">org.apache.tools.ant.ProjectHelper</code> is the 
API expected to be
+implemented. So write your own <code class="code">ProjectHelper</code> by 
extending that abstract
+class. You are then expected to implement at least the function <code 
class="code">parse(Project
+project, Object source)</code>. Note also that your implementation will be 
instantiated by Ant, and
+it is expecting a default constructor with no arguments.
 </p>
 
 <p>
-There are some functions that will help you define what your helper is capable 
of and
-what is is expecting:
+There are some functions that will help you define what your helper is capable 
of and what is is
+expecting:
 </p>
 <ul>
-  <li><code>getDefaultBuildFile()</code>: defines which file name is expected 
if
-    none provided</li>
-  <li><code>supportsBuildFile(File buildFile)</code>: defines if your parser
-    can parse the input file</li>
-  <li><code>canParseAntlibDescriptor(URL url)</code>: whether your
-    implementation is capable of parsing a given Antlib
-    descriptor.  The base class returns <code>false</code></li>
-  <li><code>parseAntlibDescriptor(Project containingProject, URL
-    source)</code>: invoked to actually parse the Antlib
-    descriptor if your implementation returned <code>true</code>
-    for the previous method.</li>
+  <li><code class="code">getDefaultBuildFile()</code>: defines which file name 
is expected if none
+    provided</li>
+  <li><code class="code">supportsBuildFile(File buildFile)</code>: defines if 
your parser can parse
+    the input file</li>
+  <li><code class="code">canParseAntlibDescriptor(URL url)</code>: whether 
your implementation is
+    capable of parsing a given Antlib descriptor.  The base class returns 
<q>false</q></li>
+  <li><code class="code">parseAntlibDescriptor(Project containingProject, URL 
source)</code>:
+    invoked to actually parse the Antlib descriptor if your implementation 
returned <q>true</q> for
+    the previous method.</li>
 </ul>
 
 <p>
-Now that you have your implementation ready, you have to declare it to Ant. 
Three
-solutions here:
+Now that you have your implementation ready, you have to declare it to Ant. 
Three solutions here:
 </p>
 <ul>
-  <li>use the system property <code>org.apache.tools.ant.ProjectHelper</code>
-    (see also the <a href="running.html#sysprops">Java System 
Properties</a>);</li>
+  <li>use the system property <code 
class="code">org.apache.tools.ant.ProjectHelper</code> (see also
+    the <a href="running.html#sysprops">Java System Properties</a>);</li>
   <li>use the service file in <samp>META-INF</samp>: in the jar you will build 
with your
-    implementation, add a file
-    <samp>META-INF/services/org.apache.tools.ant.ProjectHelper</samp>.
-    And then in this file just put the fully qualified name of your
-    implementation</li>
-  <li>use the <a href="Tasks/projecthelper.html">projecthelper</a> task 
(<em>since
-    Ant 1.8.2</em>) which will install dynamically a helper in the internal 
helper
-    'repository'. Then your helper can be used on the next call to the
-    <a href="Tasks/import.html">import</a> task.</li>
+    implementation, add a file 
<samp>META-INF/services/org.apache.tools.ant.ProjectHelper</samp>.
+    And then in this file just put the fully qualified name of your 
implementation</li>
+  <li>use the <a href="Tasks/projecthelper.html">projecthelper</a> task 
(<em>since Ant 1.8.2</em>)
+    which will install dynamically a helper in the internal helper 
'repository'. Then your helper
+    can be used on the next call to the <a href="Tasks/import.html">import</a> 
task.</li>
 </ul>
 
 </body>

http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/properties.html
----------------------------------------------------------------------
diff --git a/manual/properties.html b/manual/properties.html
index 224d9a3..8dc459e 100644
--- a/manual/properties.html
+++ b/manual/properties.html
@@ -106,16 +106,18 @@
   <h1 id="propertyHelper">PropertyHelpers</h1>
 
   <p>Ant's property handling is accomplished by an instance
-    of <code>org.apache.tools.ant.PropertyHelper</code> associated with the 
current Project.  You
-    can learn more about this class by examining Ant's Java API. In Ant 1.8 
the PropertyHelper class
-    was much reworked and now itself employs a number of helper classes 
(actually instances of
-    the <code>org.apache.tools.ant.PropertyHelper$Delegate</code> marker 
interface) to take care of
-    discrete tasks such as property setting, retrieval, parsing, etc. This 
makes Ant's property
-    handling highly extensible; also of interest is the
+    of <code class="code">org.apache.tools.ant.PropertyHelper</code> 
associated with the current
+    Project.  You can learn more about this class by examining Ant's Java API. 
In Ant 1.8 the
+    <code class="code">PropertyHelper</code> class was much reworked and now 
itself employs a number
+    of helper classes (actually instances of
+    the <code class="code">org.apache.tools.ant.PropertyHelper$Delegate</code> 
marker interface) to
+    take care of discrete tasks such as property setting, retrieval, parsing, 
etc. This makes Ant's
+    property handling highly extensible; also of interest is the
     new <a href="Tasks/propertyhelper.html">propertyhelper</a> task used to 
manipulate the
     PropertyHelper and its delegates from the context of the Ant buildfile.</p>
 
-  <p>There are three sub-interfaces of <code>Delegate</code> that may be 
useful to implement.</p>
+  <p>There are three sub-interfaces of <code class="code">Delegate</code> that 
may be useful to
+  implement.</p>
 
   <ul>
     <li><code>org.apache.tools.ant.property.PropertyExpander</code> is 
responsible for finding the
@@ -126,36 +128,36 @@
         syntax&mdash;or allow nested property expansions since the default 
implementation doesn't
         balance braces
         (see <a 
href="https://git-wip-us.apache.org/repos/asf?p=ant-antlibs-props.git;a=blob;f=src/main/org/apache/ant/props/NestedPropertyExpander.java;hb=HEAD";
-        target="_top"><code>NestedPropertyExpander</code> in the 
<samp>props</samp> Antlib</a> for
+        target="_top"><code class="code">NestedPropertyExpander</code> in the 
<samp>props</samp> Antlib</a> for
         an example).</p>
     </li>
 
-    <li><code>org.apache.tools.ant.PropertyHelper$PropertyEvaluator</code> is 
used to
+    <li><code 
class="code">org.apache.tools.ant.PropertyHelper$PropertyEvaluator</code> is 
used to
       expand <samp>${some-string}</samp> into an <code>Object</code>.
 
       <p>This is the interface you'd implement if you want to provide your own 
storage independent
         of Ant's project instance&mdash;the interface represents the reading 
end.  An example for
-        this would be 
<code>org.apache.tools.ant.property.LocalProperties</code> which implements
-        storage for <a href="Tasks/local.html">local properties</a>.</p>
+        this would be <code 
class="code">org.apache.tools.ant.property.LocalProperties</code> which
+        implements storage for <a href="Tasks/local.html">local 
properties</a>.</p>
 
       <p>Another reason to implement this interface is if you wanted to 
provide your own "property
         protocol" like expanding <code>toString:foo</code> by looking up the 
project
-        reference <samp>foo</samp> and invoking <code>toString()</code> on it 
(which is already
-        implemented in Ant, see below).</p>
+        reference <samp>foo</samp> and invoking <code 
class="code">toString()</code> on it (which is
+        already implemented in Ant, see below).</p>
     </li>
 
-    <li><code>org.apache.tools.ant.PropertyHelper$PropertySetter</code> is 
responsible for setting
-      properties.
+    <li><code 
class="code">org.apache.tools.ant.PropertyHelper$PropertySetter</code> is 
responsible
+      for setting properties.
 
       <p>This is the interface you'd implement if you want to provide your own 
storage independent
         of Ant's project instance&mdash;the interface represents the reading 
end.  An example for
-        this would be 
<code>org.apache.tools.ant.property.LocalProperties</code> which implements
-        storage for <a href="Tasks/local.html">local properties</a>.</p>
+        this would be <code 
class="code">org.apache.tools.ant.property.LocalProperties</code> which
+        implements storage for <a href="Tasks/local.html">local 
properties</a>.</p>
     </li>
 
   </ul>
 
-  <p>The default <code>PropertyExpander</code> looks similar to:</p>
+  <p>The default <code class="code">PropertyExpander</code> looks similar 
to:</p>
 
 <pre>
 public class DefaultExpander implements PropertyExpander {
@@ -176,8 +178,9 @@ public class DefaultExpander implements PropertyExpander {
 }</pre>
 
   <p>The logic that replaces <samp>${toString:<i>some-id</i>}</samp> with the 
stringified
-    representation of the object with <var>id</var> <samp>some-id</samp> 
inside the current build is
-    contained in a PropertyEvaluator similar to the following code:</p>
+    representation of the object with <var>id</var> 
<samp><i>some-id</i></samp> inside the current
+    build is contained in a <code class="code">PropertyEvaluator</code> 
similar to the following
+    code:</p>
 
 <pre>
 public class ToStringEvaluator implements PropertyHelper.PropertyEvaluator {
@@ -234,10 +237,10 @@ public class ToStringEvaluator implements 
PropertyHelper.PropertyEvaluator {
 
   <p>This means you can't use easily expand properties whose names are given 
by properties, but
     there are <a 
href="https://ant.apache.org/faq.html#propertyvalue-as-name-for-property";
-    target="_top">some workarounds</a> for older versions of Ant.  With Ant 
1.8.0 and
-    the <a href="https://ant.apache.org/antlib/props/"; target="_top">the props 
Antlib</a> you can
-    configure Ant to use the <code>NestedPropertyExpander</code> defined there 
if you need such a
-    feature.</p>
+    target="_top">some workarounds</a> for older versions of Ant. <em>Since 
Ant 1.8.0</em> using
+    the <a href="https://ant.apache.org/antlibs/props/"; target="_top">props 
Antlib</a> you can
+    configure Ant to use the <code class="code">NestedPropertyExpander</code> 
defined there if you
+    need such a feature.</p>
 
   <h2>Expanding a "Property Name"</h2>
 
@@ -253,9 +256,9 @@ public class ToStringEvaluator implements 
PropertyHelper.PropertyEvaluator {
 
   <p>Any Ant type which has been declared with a reference can also its string 
value extracted by
     using the <samp>${toString:}</samp> operation, with the name of the 
reference listed after
-    the <code>toString:</code> text.  The <code>toString()</code> method of 
the Java class instance
-    that is referenced is invoked&mdash;all built in types strive to produce 
useful and relevant
-    output in such an instance.</p>
+    the <code>toString:</code> text.  The <code class="code">toString()</code> 
method of the Java
+    class instance that is referenced is invoked&mdash;all built in types 
strive to produce useful
+    and relevant output in such an instance.</p>
 
   <p>For example, here is how to get a listing of the files in a fileset,<p>
 
@@ -272,12 +275,13 @@ public class ToStringEvaluator implements 
PropertyHelper.PropertyEvaluator {
     the <samp>${ant.refid:}</samp> operation, with the name of the reference 
listed after
     the <code>ant.refid:</code> text.  The difference between this operation
     and <a href="#toString"><samp>${toString:}</samp></a> is that 
<samp>${ant.refid:}</samp> will
-    expand to the referenced object itself.  In most circumstances the 
<code>toString</code> method
-    will be invoked anyway, for example if the <samp>${ant.refid:}</samp> is 
surrounded by other
-    text.</p>
+    expand to the referenced object itself.  In most circumstances
+    the <code class="code">toString()</code> method will be invoked anyway, 
for example if
+    the <samp>${ant.refid:}</samp> is surrounded by other text.</p>
 
   <p>This syntax is most useful when using a task with attribute setters that 
accept objects other
-    than String.  For example, if the setter accepts a Resource object as 
in</p>
+    than <code class="code">String</code>.  For example, if the setter accepts
+    a <code class="code">Resource</code> object as in</p>
 
   <pre>public void setAttr(Resource r) { ... }</pre>
 
@@ -327,7 +331,7 @@ public class ToStringEvaluator implements 
PropertyHelper.PropertyEvaluator {
 &lt;/target>
 &lt;target name="lots-of-stuff" 
depends="use-file,other-unconditional-stuff"/&gt;</pre>
   <p>
-    Now <code>ant -Dfile.exists=false lots-of-stuff</code> will run 
<q>other-unconditional-stuff</q>
+    Now <kbd>ant -Dfile.exists=false lots-of-stuff</kbd> will run 
<q>other-unconditional-stuff</q>
     but not <q>use-file</q>, as you might expect, and you can disable the 
condition from another
     script too:
   </p>

http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/proxy.html
----------------------------------------------------------------------
diff --git a/manual/proxy.html b/manual/proxy.html
index 4071503..72ed136 100644
--- a/manual/proxy.html
+++ b/manual/proxy.html
@@ -60,7 +60,7 @@
 <h3>Java 5+ proxy support</h3>
 <p><em>Since Ant 1.7</em></p>
 <p>
-  When Ant starts up, if the <code>-autoproxy</code> command is
+  When Ant starts up, if the <kbd>-autoproxy</kbd> command is
   supplied, Ant sets the <code>java.net.useSystemProxies</code> system
   property. This tells a Java 5+ runtime to use the current set of
   property settings of the host environment. Other JVMs, such as
@@ -78,7 +78,7 @@
   like Oracle JDBC drivers or pure Java SVN clients.
 </p>
 <p>
-  To make the <code>-autoproxy</code> option the default, add it to
+  To make the <kbd>-autoproxy</kbd> option the default, add it to
   the environment variable <code>ANT_ARGS</code>, which contains a
   list of arguments to pass to Ant on every command line run.
 </p>
@@ -130,7 +130,7 @@
 <h3>Manual JVM options</h3>
 <p>
   Any JVM can have its proxy options explicitly configured by passing
-  the appropriate <code>-D</code> system property options to the
+  the appropriate <kbd>-D</kbd> system property options to the
   runtime.  Ant can be configured through all its shell scripts via
   the <code>ANT_OPTS</code> environment variable, which is a list of
   options to supply to Ant's JVM:
@@ -260,7 +260,7 @@ For csh/tcsh:
   There are four ways to set up proxies in Ant.
 </p>
 <ol>
-  <li>With Ant 1.7 and Java 5+ using the <code>-autoproxy</code> 
parameter.</li>
+  <li>With Ant 1.7 and Java 5+ using the <kbd>-autoproxy</kbd> parameter.</li>
   <li>Via JVM system properties&mdash;set these in the <code>ANT_ARGS</code> 
environment variable.</li>
   <li>Via the <code>&lt;setproxy&gt;</code> task.</li>
   <li>Custom ProxySelector implementations</li>
@@ -275,7 +275,7 @@ For csh/tcsh:
   for Java code to adapt to them. However, given the fact that it
   currently does break some builds, it will be some time before Ant
   enables the automatic proxy feature by default. Until then, you have
-  to enable the <code>-autoproxy</code> option or use one of the
+  to enable the <kbd>-autoproxy</kbd> option or use one of the
   alternate mechanisms to configure the JVM.
 </p>
 

http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/running.html
----------------------------------------------------------------------
diff --git a/manual/running.html b/manual/running.html
index e9d0ef2..84daea7 100644
--- a/manual/running.html
+++ b/manual/running.html
@@ -29,32 +29,32 @@
 
 <p>If you've installed Apache Ant as described in
 the <a href="install.html">Installing Ant</a> section, running Ant
-from the command-line is simple: just type <code>ant</code>.</p>
+from the command-line is simple: just type <kbd>ant</kbd>.</p>
 
 <p>When no arguments are specified, Ant looks for
 a <samp>build.xml</samp> file in the current directory and, if found,
 uses that file as the build file and runs the target specified in
 the <var>default</var> attribute of the <code>&lt;project&gt;</code>
 tag.  To make Ant use a build file other than <samp>build.xml</samp>,
-use the command-line option <code>-buildfile <em>file</em></code>,
-where <em>file</em> is the name of the build file you want to use (or
+use the command-line option <kbd>-buildfile <i>file</i></kbd>,
+where <code><i>file</i></code> is the name of the build file you want to use 
(or
 a directory containing a <samp>build.xml</samp> file).</p>
 
-<p>If you use the <code>-find [<em>file</em>]</code> option, Ant will
+<p>If you use the <kbd>-find [<i>file</i>]</kbd> option, Ant will
 search for a build file first in the current directory, then in the
 parent directory, and so on, until either a build file is found or the
 root of the filesystem has been reached. By default, it will look for
 a build file called <samp>build.xml</samp>. To have it search for a
 build file other than <samp>build.xml</samp>, specify a file
 argument. <strong>Note</strong>: If you include any other flags or
-arguments on the command line after the <code>-find</code> flag, you
-must include the file argument for the <code>-find</code> flag, even
+arguments on the command line after the <kbd>-find</kbd> flag, you
+must include the file argument for the <kbd>-find</kbd> flag, even
 if the name of the build file you want to find
 is <samp>build.xml</samp>.</p>
 
 <p>You can also set <a href="using.html#properties">properties</a> on
 the command line.  This can be done with
-the <code>-D<i>property</i>=<i>value</i></code> option,
+the <kbd>-D<i>property</i>=<i>value</i></kbd> option,
 where <em>property</em> is the name of the property,
 and <em>value</em> is the value for that property. If you specify a
 property that is also set in the build file (see
@@ -62,19 +62,19 @@ the <a href="Tasks/property.html">property</a> task), the 
value
 specified on the command line will override the value specified in the
 build file.  Defining properties on the command line can also be used
 to pass in the value of environment variables; just
-pass <code>-DMYVAR=%MYVAR%</code> (Windows)
-or <code>-DMYVAR=$MYVAR</code> (Unix) to Ant. You can then access
+pass <kbd>-DMYVAR=%MYVAR%</kbd> (Windows)
+or <kbd>-DMYVAR=$MYVAR</kbd> (Unix) to Ant. You can then access
 these variables inside your build file as <code>${MYVAR}</code>.  You
 can also access environment variables using
 the <a href="Tasks/property.html">property</a>
 task's <var>environment</var> attribute.</p>
 
 <p>Options that affect the amount of logging output by Ant
-are: <code>-quiet</code>, which instructs Ant to print less
-information to the console; <code>-verbose</code>, which causes Ant to
-print additional information to the console; <code>-debug</code>,
+are: <kbd>-quiet</kbd>, which instructs Ant to print less
+information to the console; <kbd>-verbose</kbd>, which causes Ant to
+print additional information to the console; <kbd>-debug</kbd>,
 which causes Ant to print considerably more additional information;
-and <code>-silent</code> which makes Ant print nothing but task output
+and <kbd>-silent</kbd> which makes Ant print nothing but task output
 and build failures (useful to capture Ant output by scripts).</p>
 
 <p>It is also possible to specify one or more targets that should be
@@ -83,16 +83,16 @@ the <var>default</var> attribute of
 the <a href="using.html#projects"><code>project</code></a> tag is
 used.</p>
 
-<p>The <code>-projecthelp</code> option prints out a list of the build
+<p>The <kbd>-projecthelp</kbd> option prints out a list of the build
 file's targets. Targets that include a <var>description</var>
 attribute are listed as &quot;Main targets&quot;, those without
 a <var>description</var> are listed as &quot;Other targets&quot;, then
 the &quot;Default&quot; target is listed ("Other targets" are only
 displayed if there are no main targets, or if Ant is invoked
-in <code>-verbose</code> or <code>-debug</code> mode).</p>
+in <kbd>-verbose</kbd> or <kbd>-debug</kbd> mode).</p>
 
 <h3 id="options">Command-line Options Summary</h3>
-<pre>ant [options] [target [target2 [target3] ...]]
+<pre class="output">ant [options] [target [target2 [target3] ...]]
 Options:
   -help, -h              print this message and exit
   -projecthelp, -p       print project help information and exit
@@ -128,10 +128,10 @@ Options:
   -autoproxy             Java 5+ : use the OS proxies
   -main &lt;class&gt;          override Ant's normal entry point
 </pre>
-<p>For more information about <code>-logger</code> and
-<code>-listener</code> see
+<p>For more information about <kbd>-logger</kbd> and
+<kbd>-listener</kbd> see
 <a href="listeners.html">Loggers &amp; Listeners</a>.
-<p>For more information about <code>-inputhandler</code> see
+<p>For more information about <kbd>-inputhandler</kbd> see
 <a href="inputhandler.html">InputHandler</a>.
 <p>Easiest way of changing the exit-behaviour is subclassing the original main 
class:</p>
 <pre>
@@ -141,7 +141,7 @@ public class CustomExitCode extends 
org.apache.tools.ant.Main {
     }
 }
 </pre>
-<p>and starting Ant with access (<code>-lib <i>path-to-class</i></code>) to 
this class.</p>
+<p>and starting Ant with access (<kbd>-lib <i>path-to-class</i></kbd>) to this 
class.</p>
 
 <h3 id="libs">Library Directories</h3>
 
@@ -160,22 +160,22 @@ installation to be locked down which will please system
 administrators.</p>
 
 <p>Additional directories to be searched may be added by using
-the <code>-lib</code> option.  The <code>-lib</code> option specifies
+the <kbd>-lib</kbd> option.  The <kbd>-lib</kbd> option specifies
 a search path. Any jars or classes in the directories of the path will
 be added to Ant's classloader. The order in which jars are added to
 the classpath is as follows:</p>
 
 <ul>
-  <li><code>-lib</code> jars in the order specified by the <code>-lib</code> 
options on the command line</li>
-  <li>jars from <samp>${user.home}/.ant/lib</samp> (unless 
<code>-nouserlib</code> is set)</li>
+  <li>jars in the order specified by the <kbd>-lib</kbd> options on the 
command line</li>
+  <li>jars from <samp>${user.home}/.ant/lib</samp> (unless 
<kbd>-nouserlib</kbd> is set)</li>
   <li>jars from <samp>ANT_HOME/lib</samp></li>
 </ul>
 
 <p>Note that the <code>CLASSPATH</code> environment variable is passed
-to Ant using a <code>-lib</code> option. Ant itself is started with a
+to Ant using a <kbd>-lib</kbd> option. Ant itself is started with a
 very minimalistic classpath.  Ant should work perfectly well with an
 empty <code>CLASSPATH</code> environment variable, something the
-the <code>-noclasspath</code> option actually enforces. We get many
+the <kbd>-noclasspath</kbd> option actually enforces. We get many
 more support calls related to classpath problems (especially quoting
 problems) than we like.</p>
 
@@ -188,30 +188,30 @@ your JVM documentation for more details.</p>
 
 <h3>Examples</h3>
 
-<pre>ant</pre>
+<pre class="input">ant</pre>
 <p>runs Ant using the <samp>build.xml</samp> file in the current
 directory, on the default target.</p>
 
-<pre>ant -buildfile test.xml</pre>
+<pre class="input">ant -buildfile test.xml</pre>
 <p>runs Ant using the <samp>test.xml</samp> file in the current
 directory, on the default target.</p>
 
-<pre>ant -buildfile test.xml dist</pre>
+<pre class="input">ant -buildfile test.xml dist</pre>
 <p>runs Ant using the <samp>test.xml</samp> file in the current
 directory, on the target called <samp>dist</samp>.</p>
 
-<pre>ant -buildfile test.xml -Dbuild=build/classes dist</pre>
+<pre class="input">ant -buildfile test.xml -Dbuild=build/classes dist</pre>
 <p>runs Ant using the <samp>test.xml</samp> file in the current
 directory, on the target called <samp>dist</samp>, setting
 the <code>build</code> property to the
-value <samp>build/classes</samp>.</p>
+value <q>build/classes</q>.</p>
 
-<pre>ant -lib /home/ant/extras</pre>
+<pre class="input">ant -lib /home/ant/extras</pre>
 <p>runs Ant picking up additional task and support jars from
 the <samp>/home/ant/extras</samp> location</p>
 
-<pre>ant -lib one.jar;another.jar</pre>
-<pre>ant -lib one.jar -lib another.jar</pre>
+<pre class="input">ant -lib one.jar;another.jar</pre>
+<pre class="input">ant -lib one.jar -lib another.jar</pre>
 <p>adds two jars to Ants classpath.</p>
 
 <h3 id="files">Files</h3>
@@ -238,8 +238,8 @@ section for examples.</p>
 
   <li><code>ANT_ARGS</code>&mdash;Ant command-line arguments. For example,
   set <code>ANT_ARGS</code> to point to a different logger, include a
-  listener, and to include the <code>-find</code> flag.<br/>
-  <strong>Note</strong>: If you include <code>-find</code>
+  listener, and to include the <kbd>-find</kbd> flag.<br/>
+  <strong>Note</strong>: If you include <kbd>-find</kbd>
   in <code>ANT_ARGS</code>, you should include the name of the build file
   to find, even if the file is called <samp>build.xml</samp>.</li>
 </ul>
@@ -248,7 +248,7 @@ section for examples.</p>
 <p>Some of Ant's core classes can be configured via system properties.</p>
 <p>Here is the result of a search through the codebase. Because system
 properties are available via Project instance, I searched for them with a</p>
-<pre>grep -r -n "getPropert" * &gt; ..\grep.txt</pre>
+<pre class="input">grep -r -n "getPropert" * &gt; ..\grep.txt</pre>
 <p>command. After that I filtered out the often-used but
   not-so-important values (most of them read-only
   values): <code>path.separator</code>, <code>ant.home</code>, 
<code>basedir</code>, <code>user.dir</code>, <code>os.name</code>, 
<code>line.separator</code>, <code>java.home</code>, <code>java.version</code>, 
<code>java.version</code>, <code>user.home</code>, 
<code>java.class.path</code><br/>
@@ -358,34 +358,34 @@ properties are available via Project instance, I searched 
for them with a</p>
   <td><code>build.compiler.emacs</code></td>
   <td>boolean (default <q>false</q>)</td>
   <td>Enable emacs-compatible error messages;
-  see <a href="Tasks/javac.html">javac</a> "Jikes Notes".
+  see <a href="Tasks/javac.html#jikes">javac</a> "Jikes Notes".
   </td>
 </tr>
 <tr>
   <td><code>build.compiler.fulldepend</code></td>
   <td>boolean (default false)</td>
   <td>Enable full dependency checking;
-  see <a href="Tasks/javac.html">javac</a> "Jikes Notes".
+  see <a href="Tasks/javac.html#jikes">javac</a> "Jikes Notes".
   </td>
 </tr>
 <tr>
   <td><code>build.compiler.jvc.extensions</code></td>
   <td><em><u>Deprecated</u></em></td>
   <td>Enable Microsoft extensions of their Java compiler;
-    see <a href="Tasks/javac.html">javac</a> "Jvc Notes".
+    see <a href="Tasks/javac.html#jvc">javac</a> "Jvc Notes".
   </td>
 </tr>
 <tr>
   <td><code>build.compiler.pedantic</code></td>
   <td>boolean (default <q>false</q>)</td>
   <td>Enable pedantic warnings;
-  see <a href="Tasks/javac.html">javac</a> "Jikes Notes".
+  see <a href="Tasks/javac.html#jikes">javac</a> "Jikes Notes".
   </td>
 </tr>
 <tr>
   <td><code>build.compiler.warnings</code></td>
   <td><em><u>Deprecated</u></em></td>
-  <td>See <a href="Tasks/javac.html">javac</a> "Jikes Notes"</td>
+  <td>See <a href="Tasks/javac.html#jikes">javac</a> "Jikes Notes"</td>
 </tr>
 <tr>
   <td><code>build.rmic</code></td>
@@ -508,15 +508,15 @@ that command being available in the Windows path.
 <h2 id="os2">OS/2 Users</h2>
 <p>
 The OS/2 launch script was developed to perform complex tasks. It has
-two parts: <code>ant.cmd</code> which calls Ant
-and <code>antenv.cmd</code> which sets the environment for Ant.  Most
-often you will just call <code>ant.cmd</code> using the same command
+two parts: <kbd>ant.cmd</kbd> which calls Ant
+and <kbd>antenv.cmd</kbd> which sets the environment for Ant.  Most
+often you will just call <kbd>ant.cmd</kbd> using the same command
 line options as described above. The behaviour can be modified by a
 number of ways explained below.
 </p>
 
 <p>
-Script <code>ant.cmd</code> first verifies whether the Ant environment
+Script <kbd>ant.cmd</kbd> first verifies whether the Ant environment
 is set correctly. The requirements are:
 </p>
 <ol>
@@ -527,36 +527,36 @@ is set correctly. The requirements are:
 </ol>
 
 <p>
-If any of these conditions is violated, script <code>antenv.cmd</code>
+If any of these conditions is violated, script <kbd>antenv.cmd</kbd>
 is called. This script first invokes configuration scripts if there
-exist: the system-wide configuration <code>antconf.cmd</code> from
+exist: the system-wide configuration <kbd>antconf.cmd</kbd> from
 the <samp>%ETC%</samp> directory and then the user
-configuration <code>antrc.cmd</code> from the <samp>%HOME%</samp>
+configuration <kbd>antrc.cmd</kbd> from the <samp>%HOME%</samp>
 directory. At this moment both <code>JAVA_HOME</code>
 and <code>ANT_HOME</code> must be defined
-because <code>antenv.cmd</code> now adds <samp>classes.zip</samp>
+because <kbd>antenv.cmd</kbd> now adds <samp>classes.zip</samp>
 or <samp>tools.jar</samp> (depending on version of JVM) and everything
 from <samp>%ANT_HOME%\lib</samp> except <samp>ant-*.jar</samp>
-to <code>CLASSPATH</code>. Finally <code>ant.cmd</code> calls
-per-directory configuration <code>antrc.cmd</code>. All settings made
-by <code>ant.cmd</code> are local and are undone when the script
-ends. The settings made by <code>antenv.cmd</code> are persistent
+to <code>CLASSPATH</code>. Finally <kbd>ant.cmd</kbd> calls
+per-directory configuration <kbd>antrc.cmd</kbd>. All settings made
+by <kbd>ant.cmd</kbd> are local and are undone when the script
+ends. The settings made by <kbd>antenv.cmd</kbd> are persistent
 during the lifetime of the shell (of course unless called
-automatically from <code>ant.cmd</code>). It is thus possible to
-call <code>antenv.cmd</code> manually and modify some settings before
-calling <code>ant.cmd</code>.
+automatically from <kbd>ant.cmd</kbd>). It is thus possible to
+call <kbd>antenv.cmd</kbd> manually and modify some settings before
+calling <kbd>ant.cmd</kbd>.
 </p>
 
 <p>
-Scripts <code>envset.cmd</code> and <code>runrc.cmd</code> perform
+Scripts <kbd>envset.cmd</kbd> and <kbd>runrc.cmd</kbd> perform
 auxiliary tasks. All scripts have some documentation inside.
 </p>
 
 <h2 id="background">Running Ant as a background process on Unix(-like) 
systems</h2>
 
 <p>
-If you start Ant as a background process (like in <code>ant
-&amp;</code>) and the build process creates another process, Ant will
+If you start Ant as a background process (like in <kbd>ant
+&amp;</kbd>) and the build process creates another process, Ant will
 immediately try to read from standard input, which in turn will most
 likely suspend the process.  In order to avoid this, you must redirect
 Ant's standard input or explicitly provide input to each spawned
@@ -576,13 +576,13 @@ If you have installed Ant in the do-it-yourself way, Ant 
can be
 started from one of two entry points:
 </p>
 
-<pre>java -Dant.home=c:\ant org.apache.tools.ant.Main [options] [target]</pre>
-<pre>java -Dant.home=c:\ant org.apache.tools.ant.launch.Launcher [options] 
[target]</pre>
+<pre class="input">java -Dant.home=c:\ant org.apache.tools.ant.Main [options] 
[target]</pre>
+<pre class="input">java -Dant.home=c:\ant org.apache.tools.ant.launch.Launcher 
[options] [target]</pre>
 
 <p>
 The first method runs Ant's traditional entry point. The second method
 uses the Ant Launcher introduced in Ant 1.6. The former method does
-not support the <code>-lib</code> option and all required classes are
+not support the <kbd>-lib</kbd> option and all required classes are
 loaded from the <code>CLASSPATH</code>. You must ensure that all
 required jars are available. At a minimum the <code>CLASSPATH</code>
 should include:
@@ -596,7 +596,7 @@ should include:
 
 <p>
 The latter method supports
-the <code>-lib</code>, <code>-nouserlib</code>, <code>-noclasspath</code>
+the <kbd>-lib</kbd>, <kbd>-nouserlib</kbd>, <kbd>-noclasspath</kbd>
 options and will load jars from the
 specified <code>ANT_HOME</code>. You should start the latter with the
 most minimal classpath possible, generally just

http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/stylesheets/style.css
----------------------------------------------------------------------
diff --git a/manual/stylesheets/style.css b/manual/stylesheets/style.css
index 37ad35e..9b35645 100644
--- a/manual/stylesheets/style.css
+++ b/manual/stylesheets/style.css
@@ -80,7 +80,7 @@ q.no-break {
     hyphens: none;
 }
 
-code, samp {
+code, samp, kbd {
     white-space: nowrap;
     hyphens: none;
     font-size: 1.125rem;
@@ -114,10 +114,29 @@ pre var, code var {
    background: #efefef;
 }
 
+/* highlight console input */
+.input, kbd {
+   color: white;
+   background: darkseagreen;
+   overflow: hidden;
+   text-overflow: ellipsis;
+}
+
 /* highlight console output */
 .output {
    color: white;
    background: #837A67;
+   overflow: hidden;
+   text-overflow: ellipsis;
+}
+
+/* a workaround for invisible
+   (white on white) overflows */
+pre.input:hover, pre.output:hover {
+    margin-right: 0;
+    margin-left: 0;
+    overflow: scroll;
+    text-overflow: initial;
 }
 
 td {

http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/targets.html
----------------------------------------------------------------------
diff --git a/manual/targets.html b/manual/targets.html
index ba239ff..a3f2471 100644
--- a/manual/targets.html
+++ b/manual/targets.html
@@ -121,9 +121,9 @@
 
   <p>The optional <var>description</var> attribute can be used to
     provide a one-line description of this target, which is printed by
-    the <code>-projecthelp</code> command-line option. Targets without
+    the <kbd>-projecthelp</kbd> command-line option. Targets without
     such a description are deemed internal and will not be listed,
-    unless either the <code>-verbose</code> or <code>-debug</code>
+    unless either the <kbd>-verbose</kbd> or <kbd>-debug</kbd>
     option is used.</p>
 
   <p>It is a good practice to place
@@ -241,7 +241,7 @@
 
   <p>Unlike targets they don't contain any tasks, their main purpose
     is to collect targets that contribute to the desired state in
-    their depends list.</p>
+    their <var>depends</var> list.</p>
 
   <p>Targets can add themselves to an
     extension-point's <var>depends</var> list via

http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/tasksoverview.html
----------------------------------------------------------------------
diff --git a/manual/tasksoverview.html b/manual/tasksoverview.html
index 8eb702e..7e69b51 100644
--- a/manual/tasksoverview.html
+++ b/manual/tasksoverview.html
@@ -107,14 +107,14 @@ documentation.</p>
 
   <tr>
     <td><a href="Tasks/rpm.html">Rpm</a></td>
-    <td><p>Invokes the <code>rpm</code> executable to build a Linux
+    <td><p>Invokes the <kbd>rpm</kbd> executable to build a Linux
      installation file. This task currently only works on Linux or
      other Unix platforms with RPM support.</p></td>
   </tr>
 
   <tr>
     <td><a href="Tasks/signjar.html">SignJar</a></td>
-    <td><p>Signs a jar or zip file with the <code>javasign</code>
+    <td><p>Signs a jar or zip file with the <kbd>javasign</kbd>
      command-line tool.</p></td>
   </tr>
 
@@ -227,7 +227,7 @@ documentation.</p>
 
   <tr>
     <td><a href="Tasks/rmic.html">Rmic</a></td>
-    <td><p>Runs the <code>rmic</code> compiler on the specified 
file(s).</p></td>
+    <td><p>Runs the <kbd>rmic</kbd> compiler on the specified file(s).</p></td>
   </tr>
 
   <tr>
@@ -270,7 +270,7 @@ documentation.</p>
 
   <tr>
     <td><a href="Tasks/javadoc.html">Javadoc</a></td>
-    <td><p>Generates code documentation using the <code>javadoc</code>
+    <td><p>Generates code documentation using the <kbd>javadoc</kbd>
      tool. <em>The <code>Javadoc2</code> task is <u>deprecated</u>; use
      the <code>Javadoc</code> task instead.</em></p></td>
   </tr>
@@ -417,7 +417,7 @@ documentation.</p>
     <td><p>Changes the permissions of a file or all files inside the
      specified directories. Currently, it has effect only under Unix.
      The permissions are also UNIX style, like the arguments for the
-    <code>chmod</code> command.</p></td>
+     <kbd>chmod</kbd> command.</p></td>
   </tr>
 
   <tr>
@@ -662,8 +662,9 @@ documentation.</p>
 
   <tr>
     <td><a href="Tasks/fail.html">Fail</a></td>
-    <td><p>Exits the current build by throwing a BuildException,
-     optionally printing additional information.</p></td>
+    <td><p>Exits the current build by throwing
+     a <code>BuildException</code>, optionally printing additional
+     information.</p></td>
   </tr>
 
   <tr>
@@ -1018,9 +1019,9 @@ documentation.</p>
 
   <tr>
     <td><a href="Tasks/cvspass.html">CVSPass</a></td>
-    <td><p>Adds entries to a .cvspass file. Adding entries to this
-     file has the same affect as a <code>cvs login</code>
-     command.</p></td>
+    <td><p>Adds entries to a <samp>.cvspass</samp> file. Adding
+     entries to this file has the same affect as a <kbd>cvs
+     login</kbd> command.</p></td>
   </tr>
 
   <tr>
@@ -1033,26 +1034,26 @@ documentation.</p>
 
   <tr>
     <td><a href="Tasks/clearcase.html">ClearCase</a></td>
-    <td><p>Tasks to perform the ClearCase cleartool <em>checkin</em>,
-     <em>checkout</em>, <em>uncheckout</em>, <em>update</em>,
-     <em>lock</em>, <em>unlock</em>, <em>mklbtype</em>, <em>rmtype</em>,
-     <em>mklabel</em>, <em>mkattr</em>, <em>mkdir</em>, <em>mkelem</em>,
-     and <em>mkbl</em> commands.</p></td>
+    <td><p>Tasks to perform the ClearCase <kbd>cleartool checkin</kbd>,
+     <kbd>checkout</kbd>, <kbd>uncheckout</kbd>, <kbd>update</kbd>,
+     <kbd>lock</kbd>, <kbd>unlock</kbd>, <kbd>mklbtype</kbd>, 
<kbd>rmtype</kbd>,
+     <kbd>mklabel</kbd>, <kbd>mkattr</kbd>, <kbd>mkdir</kbd>, 
<kbd>mkelem</kbd>,
+     and <kbd>mkbl</kbd> commands.</p></td>
   </tr>
 
   <tr>
     <td><a href="Tasks/ccm.html">Continuus/Synergy</a></td>
-    <td><p>Tasks to perform the Continuus <em>ccmcheckin</em>,
-     <em>ccmcheckout</em>, <em>ccmcheckintask</em>, <em>ccmreconfigure</em>,
-     and <em>ccmcreateTask</em> commands.</p></td>
+    <td><p>Tasks to perform the Continuus <kbd>ccm checkin</kbd>,
+     <kbd>checkout</kbd>, <kbd>reconfigure</kbd>, <em>ccmcheckintask</em>,
+     and <em>ccmcreatetask</em> commands.</p></td>
   </tr>
 
   <tr>
     <td><a href="Tasks/vss.html">Microsoft Visual SourceSafe</a></td>
-    <td><p>Tasks to perform the Visual SourceSafe <em>vssget</em>,
-     <em>vsslabel</em>, <em>vsshistory</em>, <em>vsscheckin</em>,
-     <em>vsscheckout</em>, <em>vssadd</em>, <em>vsscp</em>,
-     and <em>vsscreate</em> commands.</p></td>
+    <td><p>Tasks to perform the Visual SourceSafe <kbd>ss get</kbd>,
+     <kbd>label</kbd>, <kbd>history</kbd>, <kbd>checkin</kbd>,
+     <kbd>checkout</kbd>, <kbd>add</kbd>, <kbd>cp</kbd>,
+     and <kbd>create</kbd> commands.</p></td>
   </tr>
 
   <tr>
@@ -1063,8 +1064,8 @@ documentation.</p>
 
   <tr>
     <td><a href="Tasks/sos.html">SourceOffSite</a></td>
-    <td><p>Tasks to perform the SourceOffSite <em>sosget</em>, 
<em>soslabel</em>,
-     <em>soscheckin</em>, and <em>soscheckout</em> commands.</p></td>
+    <td><p>Tasks to perform the SourceOffSite <kbd>sos get</kbd>, 
<kbd>label</kbd>,
+     <kbd>checkin</kbd>, and <kbd>checkout</kbd> commands.</p></td>
   </tr>
 </table>
 

http://git-wip-us.apache.org/repos/asf/ant/blob/14dfef58/manual/tutorial-HelloWorldWithAnt.html
----------------------------------------------------------------------
diff --git a/manual/tutorial-HelloWorldWithAnt.html 
b/manual/tutorial-HelloWorldWithAnt.html
index 784b142..41d6404 100644
--- a/manual/tutorial-HelloWorldWithAnt.html
+++ b/manual/tutorial-HelloWorldWithAnt.html
@@ -43,12 +43,12 @@ individual steps: <samp>classes</samp> for our compiled 
files and <samp>jar</sam
 <p>We have to create only the <samp>src</samp> directory. (Because I am 
working on Windows, here is the Windows
 syntax&mdash;translate to your shell):</p>
 
-<pre class="code">md src</pre>
+<pre class="input">md src</pre>
 
 <p>The following simple Java class just prints a fixed message out to STDOUT, 
so just write this code
 into <samp>src\oata\HelloWorld.java</samp>.</p>
 
-<pre class="code">
+<pre>
 package oata;
 
 public class HelloWorld {
@@ -58,7 +58,7 @@ public class HelloWorld {
 }</pre>
 
 <p>Now just try to compile and run that:</p>
-<pre class="code">
+<pre class="input">
 md build\classes
 javac -sourcepath src -d build\classes src\oata\HelloWorld.java
 java -cp build\classes oata.HelloWorld</pre>
@@ -67,14 +67,14 @@ which will result in
 
 <p>Creating a jar-file is not very difficult. But creating a 
<em>startable</em> jar-file needs more steps: create a
 manifest-file containing the start class, creating the target directory and 
archiving the files.</p>
-<pre class="code">
+<pre class="input">
 echo Main-Class: oata.HelloWorld&gt;myManifest
 md build\jar
 jar cfm build\jar\HelloWorld.jar myManifest -C build\classes .
 java -jar build\jar\HelloWorld.jar</pre>
 
-<p><strong>Note</strong>: Do not have blanks around the &gt;-sign in the 
<code>echo
-Main-Class</code> instruction because it would falsify it!</p>
+<p><strong>Note</strong>: Do not have blanks around the &gt;-sign in the 
<kbd>echo Main-Class</kbd> instruction because
+it would falsify it!</p>
 
 <h2 id="four-steps">Four steps to a running application</h2>
 <p>After finishing the java-only step we have to think about our build 
process. We <em>have</em> to compile our code,
@@ -85,7 +85,7 @@ startable jar file would be nice ... And it's a good practise 
to have a <q>clean
 generated stuff. Many failures could be solved just by a "clean build".</p>
 
 <p>By default Ant uses <samp>build.xml</samp> as the name for a buildfile, so 
our <samp>.\build.xml</samp> would be:</p>
-<pre class="code">
+<pre>
 &lt;project&gt;
 
     &lt;target name="clean"&gt;
@@ -113,12 +113,12 @@ generated stuff. Many failures could be solved just by a 
"clean build".</p>
 &lt;/project&gt;</pre>
 
 <p>Now you can compile, package and run the application via</p>
-<pre class="code">
+<pre class="input">
 ant compile
 ant jar
 ant run</pre>
 <p>Or shorter with</p>
-<pre class="code">ant compile jar run</pre>
+<pre class="input">ant compile jar run</pre>
 
 <p>While having a look at the buildfile, we will see some similar steps 
between Ant and the Java-only commands:</p>
 <table>
@@ -127,7 +127,7 @@ ant run</pre>
   <th>Ant</th>
 </tr>
 <tr>
-  <td><pre class="code">
+  <td><pre class="input">
 md build\classes
 javac
     -sourcepath src
@@ -144,7 +144,7 @@ jar cfm
 
 
 java -jar build\jar\HelloWorld.jar</pre></td>
-  <td><pre class="code">
+  <td><pre>
 &lt;mkdir dir="build/classes"/&gt;
 &lt;javac
     srcdir="src"
@@ -171,7 +171,7 @@ steps.</p>
 <p>The first and second point would be addressed with <em>properties</em>, the 
third with a special property&mdash;an
 attribute of the <code>&lt;project&gt;</code> tag and the fourth problem can 
be solved using dependencies.</p>
 
-<pre class="code">
+<pre>
 &lt;project name="HelloWorld" basedir="." default="main"&gt;
 
     &lt;property name="src.dir"     value="src"/&gt;
@@ -212,7 +212,7 @@ attribute of the <code>&lt;project&gt;</code> tag and the 
fourth problem can be
 
 &lt;/project&gt;</pre>
 
-<p>Now it's easier, just do a <code>ant</code> and you will get</p>
+<p>Now it's easier, just do a <kbd>ant</kbd> and you will get</p>
 <pre class="output">
 Buildfile: build.xml
 
@@ -252,7 +252,7 @@ this library could be accessed during compilation and 
run.</p>
 the <a href="https://logging.apache.org/log4j/1.2/manual.html"; 
target="_top">Short Manual [2]</a>. First we have to
 modify the java source to use the logging framework:</p>
 
-<pre class="code">
+<pre>
 package oata;
 
 <b>import org.apache.log4j.Logger;</b>
@@ -269,13 +269,13 @@ public class HelloWorld {
 
 <p>Most of the modifications are "framework overhead" which has to be done 
once. The blue line is our "old System-out"
 statement.</p>
-<p>Don't try to run <code>ant</code>&mdash;you will only get lot of compiler 
errors. Log4J is not on the classpath so we
+<p>Don't try to run <kbd>ant</kbd>&mdash;you will only get lot of compiler 
errors. Log4J is not on the classpath so we
 have to do a little work here. But do not change the <code>CLASSPATH</code> 
environment variable! This is only for this
 project and maybe you would break other environments (this is one of the most 
famous mistakes when working with Ant). We
 introduce Log4J (or to be more precise: all libraries (jar-files) which are 
somewhere under <samp>.\lib</samp>) into our
 buildfile:</p>
 
-<pre class="code">
+<pre>
 &lt;project name="HelloWorld" basedir="." default="main"&gt;
     ...
     <b>&lt;property name="lib.dir"     value="lib"/&gt;</b>
@@ -304,9 +304,9 @@ buildfile:</p>
 
 &lt;/project&gt;</pre>
 
-<p>In this example we start our application not via its Main-Class 
manifest-attribute, because we could not provide a
-jarname <em>and</em> a classpath. So add our class in the red line to the 
already defined path and start as
-usual. Running <code>ant</code> would give (after the usual compile stuff):</p>
+<p>In this example we start our application not via its 
<code>Main-Class</code> manifest-attribute, because we could not
+provide a jarname <em>and</em> a classpath. So add our class in the red line 
to the already defined path and start as
+usual. Running <kbd>ant</kbd> would give (after the usual compile stuff):</p>
 
 <pre class="output">[java] 0 [main] INFO oata.HelloWorld  - Hello World</pre>
 
@@ -324,14 +324,14 @@ usual. Running <code>ant</code> would give (after the 
usual compile stuff):</p>
 
 <h2 id="config-files">Configuration files</h2>
 <p>Why we have used Log4J? "It's highly configurable"? No&mdash;all is 
hardcoded! But that is not the fault of
-Log4J&mdash;it's ours. We had coded 
<code>BasicConfigurator.configure();</code> which implies a simple, but 
hardcoded
-configuration. More comfortable would be using a property file. In the Java 
source file, delete
-the <code>BasicConfiguration</code> line from the <code>main()</code> method 
(and the
-related <code>import</code>-statement). Log4J will search then for a 
configuration as described in it's manual. Then
+Log4J&mdash;it's ours. We had coded <code 
class="code">BasicConfigurator.configure();</code> which implies a simple, but
+hardcoded configuration. More comfortable would be using a property file. In 
the Java source file, delete
+the <code class="code">BasicConfiguration</code> line from the <code 
class="code">main()</code> method (and the
+related <code>import</code> statement). Log4J will search then for a 
configuration as described in it's manual. Then
 create a new file <samp>src/log4j.properties</samp>. That's the default name 
for Log4J's configuration and using that
 name would make life easier&mdash;not only the framework knows what is inside, 
you too!</p>
 
-<pre class="code">
+<pre>
 log4j.rootLogger=DEBUG, <b>stdout</b>
 
 log4j.appender.<b>stdout</b>=org.apache.log4j.ConsoleAppender
@@ -341,11 +341,11 @@ 
log4j.appender.<b>stdout</b>.layout.ConversionPattern=<span style="color:blue"><
 </pre>
 
 <p>This configuration creates an output channel (<q>Appender</q>) to console 
named as <code>stdout</code> which prints
-the message (<q>%m</q>) followed by a line feed (<q>%n</q>)&mdash;same as the 
earlier <code>System.out.println()</code>
-:-) Oooh kay&mdash;but we haven't finished yet. We should deliver the 
configuration file, too. So we change the
-buildfile:</p>
+the message (<q>%m</q>) followed by a line feed (<q>%n</q>)&mdash;same as the
+earlier <code class="code">System.out.println()</code> :-) Oooh kay&mdash;but 
we haven't finished yet. We should deliver
+the configuration file, too. So we change the buildfile:</p>
 
-<pre class="code">
+<pre>
     ...
     &lt;target name="compile"&gt;
         &lt;mkdir dir="${classes.dir}"/&gt;
@@ -363,7 +363,7 @@ start the application from that directory and these files 
will included into the
 <p>In this step we will introduce the usage of the JUnit [3] test framework in 
combination with Ant. Because Ant has a
 built-in JUnit 4.12 you could start directly using it. Write a test class in 
<samp>src\HelloWorldTest.java</samp>:</p>
 
-<pre class="code">
+<pre>
 import org.junit.Test;
 
 public class HelloWorldTest {
@@ -383,7 +383,7 @@ public class HelloWorldTest {
 information see the JUnit documentation [3] and the manual of <a 
href="Tasks/junit.html">junit</a> task.  Now we add a
 junit instruction to our buildfile:</p>
 
-<pre class="code">
+<pre>
     ...
 
     &lt;path <b>id="application"</b> 
location="${jar.dir}/${ant.project.name}.jar"/&gt;
@@ -418,7 +418,7 @@ How much tests failed? Some errors? <var>printsummary</var> 
lets us know.  The c
 To run tests the <code>batchtest</code> here is used, so you could easily add 
more test classes in the future just by
 naming them <code>*Test.java</code>.  This is a common naming scheme.</p>
 
-<p>After a <code>ant junit</code> you'll get:</p>
+<p>After a <kbd>ant junit</kbd> you'll get:</p>
 
 <pre class="output">
 ...
@@ -433,7 +433,7 @@ BUILD SUCCESSFUL
 <p>We can also produce a report. Something that you (and other) could read 
after closing the shell ....  There are two
 steps: 1. let <code>&lt;junit&gt;</code> log the information and 2. convert 
these to something readable (browsable).<p>
 
-<pre class="code">
+<pre>
     ...
     <b>&lt;property name="report.dir"  
value="${build.dir}/junitreport"/&gt;</b>
     ...

Reply via email to