package org.apache.maven.jxr;

 /*

  * CodeViewer.java

  * CoolServlets.com

  * March 2000

  *

  * Copyright (C) 2000 CoolServlets.com

  *

  * Redistribution and use in source and binary forms, with or without

  * modification, are permitted provided that the following conditions are met:

  * 1) Redistributions of source code must retain the above copyright notice,

  *   this list of conditions and the following disclaimer.

  * 2) Redistributions in binary form must reproduce the above copyright notice,

  *   this list of conditions and the following disclaimer in the documentation

  *   and/or other materials provided with the distribution.

  * 3) Neither the name CoolServlets.com nor the names of its contributors may be

  *   used to endorse or promote products derived from this software without

  *   specific prior written permission.

  *

  * THIS SOFTWARE IS PROVIDED BY COOLSERVLETS.COM AND CONTRIBUTORS ``AS IS'' AND

  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

  * DISCLAIMED. IN NO EVENT SHALL COOLSERVLETS.COM OR CONTRIBUTORS BE LIABLE FOR

  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  */

 import org.apache.maven.jxr.pacman.ClassType;

 import org.apache.maven.jxr.pacman.FileManager;

 import org.apache.maven.jxr.pacman.ImportType;

 import org.apache.maven.jxr.pacman.JavaFile;

 import org.apache.maven.jxr.pacman.PackageManager;

 import org.apache.maven.jxr.pacman.PackageType;

 import org.apache.maven.jxr.util.SimpleWordTokenizer;

 import org.apache.maven.jxr.util.StringEntry;

 import org.codehaus.plexus.util.StringUtils;

 import java.io.BufferedReader;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileOutputStream;

 import java.io.FileReader;

 import java.io.FileWriter;

 import java.io.IOException;

 import java.io.InputStreamReader;

 import java.io.ObjectInputStream;

 import java.io.ObjectOutputStream;

 import java.io.OutputStreamWriter;

 import java.io.PrintWriter;

 import java.io.Reader;

 import java.io.Serializable;

 import java.io.Writer;

 import java.util.Hashtable;

 import java.util.Locale;

 import java.util.Vector;

 /**

  * Syntax highlights java by turning it into html. A codeviewer object is

  * created and then keeps state as lines are passed in. Each line passed in as

  * java test, is returned as syntax highlighted html text. Users of the class

  * can set how the java code will be highlighted with setter methods. Only valid

  * java lines should be passed in since the object maintains state and may not

  * handle illegal code gracefully. The actual system is implemented as a series

  * of filters that deal with specific portions of the java code. The filters are

  * as follows: <pre>

  *  htmlFilter

  *     |__

  *        multiLineCommentFilter -> uriFilter

  *           |___

  *              inlineCommentFilter

  *                 |___

  *                    stringFilter

  *                       |___

  *                          keywordFilter

  *                             |___

  *                                uriFilter

  *                                   |___

  *                                      jxrFilter

  *                                         |___

  *                                            importFilter

  * </pre>

  */

 public class JavaCodeTransform

     implements Serializable

 {

     // ----------------------------------------------------------------------

     // public fields

     // ----------------------------------------------------------------------

     /**

      * show line numbers

      */

     public static final boolean LINE_NUMBERS = true;

     /**

      * start comment delimeter

      */

     public static final String COMMENT_START = "<em class=\"jxr_comment\">";

     /**

      * end comment delimeter

      */

     public static final String COMMENT_END = "</em>";

     /**

      * start javadoc comment delimeter

      */

     public static final String JAVADOC_COMMENT_START = "<em class=\"jxr_javadoccomment\">";

     /**

      * end javadoc comment delimeter

      */

     public static final String JAVADOC_COMMENT_END = "</em>";

     /**

      * start String delimeter

      */

     public static final String STRING_START = "<span class=\"jxr_string\">";

     /**

      * end String delimeter

      */

     public static final String STRING_END = "</span>";

     /**

      * start reserved word delimeter

      */

     public static final String RESERVED_WORD_START = "<strong class=\"jxr_keyword\">";

     /**

      * end reserved word delimeter

      */

     public static final String RESERVED_WORD_END = "</strong>";

     /**

      * stylesheet file name

      */

     public static final String STYLESHEET_FILENAME = "stylesheet.css";

     /**

      * Description of the Field

      */

     public static final String[] VALID_URI_SCHEMES = {"http://", "mailto:"};

     /**

      * Specify the only characters that are allowed in a URI besides alpha and

      * numeric characters. Refer RFC2396 - http://www.ietf.org/rfc/rfc2396.txt

      */

     public static final char[] VALID_URI_CHARS = {'?', '+', '%', '&', ':', '/', '.', '@', '_', ';', '=', '$', ',', '-',

         '!', '~', '*', '\'', '(', ')'};

     // ----------------------------------------------------------------------

     // private fields

     // ----------------------------------------------------------------------

     /**

      * HashTable containing java reserved words

      */

     private Hashtable reservedWords = new Hashtable();

     /**

      * flag set to true when a multi line comment is started

      */

     private boolean inMultiLineComment = false;

     /**

      * flag set to true when a javadoc comment is started

      */

     private boolean inJavadocComment = false;

     /**

      * Set the filename that is currently being processed.

      */

     private String currentFilename = null;

     /**

      * The current CVS revision of the currently transformed documnt

      */

     private String revision = null;

     /**

      * The currently being transformed source file

      */

     private String sourcefile = null;

     /**

      * The currently being written destfile

      */

     private String destfile = null;

     /**

      * The virtual source directory that is being read from: src/java

      */

     private String sourcedir = null;

     /**

      * The input encoding

      */

     private String inputEncoding = null;

     /**

      * The output encoding

      */

     private String outputEncoding = null;

     /**

      * The wanted locale

      */

     private Locale locale = null;

     /**

      * Relative path to javadocs, suitable for hyperlinking

      */

     private String javadocLinkDir;

     /**

      * Package Manager for this project.

      */

     private PackageManager packageManager;

     /**

      * current file manager

      */

     private FileManager fileManager;

     // ----------------------------------------------------------------------

     // constructor

     // ----------------------------------------------------------------------

     /**

      * Constructor for the JavaCodeTransform object

      *

      * @param packageManager PackageManager for this project

      */

     public JavaCodeTransform( PackageManager packageManager )

     {

         this.packageManager = packageManager;

         loadHash();

         this.fileManager = packageManager.getFileManager();

     }

     // ----------------------------------------------------------------------

     // public methods

     // ----------------------------------------------------------------------

     /**

      * Now different method of seeing if at end of input stream, closes inputs

      * stream at end.

      *

      * @param line String

      * @return filtered line of code

      */

     public final String syntaxHighlight( String line )

     {

         return htmlFilter( line );

     }

     /**

      * Gets the header attribute of the JavaCodeTransform object

      *

      * @return String

      */

     public String getHeader()

     {

         StringBuffer buffer = new StringBuffer();

         String outputEncoding = this.outputEncoding;

         if ( outputEncoding == null )

         {

             outputEncoding = "ISO-8859-1";

         }

         // header

         buffer

             .append(

                 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n" )

             .append( "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"" ).append( locale )

             .append( "\" lang=\"" ).append( locale ).append( "\">\n" ).append( "<head>\n" )

             .append( "<meta http-equiv=\"content-type\" content=\"text/html; charset=" ).append( outputEncoding )

             .append( "\" />\n" );

         // title ("classname xref")

         buffer.append( "<title>" );

         try

         {

             JavaFile javaFile = fileManager.getFile( this.getCurrentFilename() );

             // Use the name of the file instead of the class to handle inner classes properly

             if ( javaFile.getClassType() != null && javaFile.getClassType().getFilename() != null )

             {

                 buffer.append( javaFile.getClassType().getFilename() );

             }

             else

             {

                 buffer.append( this.getCurrentFilename() );

             }

             buffer.append( " " );

         }

         catch ( IOException e )

         {

             e.printStackTrace();

         }

         finally

         {

             buffer.append( "xref</title>\n" );

         }

         // stylesheet link

         buffer.append( "<link type=\"text/css\" rel=\"stylesheet\" href=\"" ).append( this.getPackageRoot() )

             .append( STYLESHEET_FILENAME ).append( "\" />\n" );

         buffer.append( "</head>\n" ).append( "<body>\n" ).append( this.getFileOverview() );

         // start code section

         buffer.append( "<pre>\n" );

         return buffer.toString();

     }

     /**

      * Gets the footer attribute of the JavaCodeTransform object

      *

      * @return String

      */

     public final String getFooter()

     {

         return "</pre>\n" + "<hr/>" + "<div id=\"footer\">" + JXR.NOTICE + "</div>" + "</body>\n" + "</html>\n";

     }

     /**

      * This is the public method for doing all transforms of code.

      *

      * @param sourceReader Reader

      * @param destWriter Writer

      * @param locale String

      * @param inputEncoding String

      * @param outputEncoding String

      * @param javadocLinkDir String

      * @param revision String

      * @param showHeader boolean

      * @param showFooter boolean

      * @throws IOException

      */

     public final void transform( Reader sourceReader, Writer destWriter, Locale locale, String inputEncoding,

                                  String outputEncoding, String javadocLinkDir, String revision, boolean showHeader,

                                  boolean showFooter )

         throws IOException

     {

         this.locale = locale;

         this.inputEncoding = inputEncoding;

         this.outputEncoding = outputEncoding;

         this.javadocLinkDir = javadocLinkDir;

         this.revision = revision;

         BufferedReader in = new BufferedReader( sourceReader );

         PrintWriter out = new PrintWriter( destWriter );

         String line = "";

         if ( showHeader )

         {

             out.println( getHeader() );

         }

         int linenumber = 1;

         while ( ( line = in.readLine() ) != null )

         {

             if ( LINE_NUMBERS )

             {

                 out.print( "<a name=\"" + linenumber + "\" " + "href=\"#" + linenumber + "\">" + linenumber

                     + "</a>" + getLineWidth( linenumber ) );

             }

             out.println( this.syntaxHighlight( line ) );

             ++linenumber;

         }

         if ( showFooter )

         {

             out.println( getFooter() );

         }

         out.flush();

     }

     /**

      * This is the public method for doing all transforms of code.

      *

      * @param sourcefile String

      * @param destfile String

      * @param locale String

      * @param inputEncoding String

      * @param outputEncoding String

      * @param javadocLinkDir String

      * @param revision String

      * @throws IOException

      */

     public final void transform( String sourcefile, String destfile, Locale locale, String inputEncoding,

                                  String outputEncoding, String javadocLinkDir, String revision )

         throws IOException

     {

         this.setCurrentFilename( sourcefile );

         this.sourcefile = sourcefile;

         this.destfile = destfile;

         //make sure that the parent directories exist...

         new File( new File( destfile ).getParent() ).mkdirs();

         Reader fr = null;

         Writer fw = null;

         try

         {

             if ( inputEncoding != null )

             {

                 fr = new InputStreamReader( new FileInputStream( sourcefile ), inputEncoding );

             }

             else

             {

                 fr = new FileReader( sourcefile );

             }

             if ( outputEncoding != null )

             {

                 fw = new OutputStreamWriter( new FileOutputStream( destfile ), outputEncoding );

             }

             else

             {

                 fw = new FileWriter( destfile );

             }

             transform( fr, fw, locale, inputEncoding, outputEncoding, javadocLinkDir, revision, true, true );

         }

         catch ( RuntimeException e )

         {

             System.out.println( "Unable to processPath " + sourcefile + " => " + destfile );

             throw e;

         }

         finally

         {

             if ( fr != null )

             {

                 try

                 {

                     fr.close();

                 }

                 catch ( Exception ex )

                 {

                     ex.printStackTrace();

                 }

             }

             if ( fw != null )

             {

                 try

                 {

                     fw.close();

                 }

                 catch ( Exception ex )

                 {

                     ex.printStackTrace();

                 }

             }

         }

     }

     /**

      * Get the current filename

      *

      * @return String

      */

     public final String getCurrentFilename()

     {

         return this.currentFilename;

     }

     /**

      * Set the current filename

      *

      * @param filename String

      */

     public final void setCurrentFilename( String filename )

     {

         this.currentFilename = filename;

     }

     /**

      * From the current file, determine the package root based on the current

      * path.

      *

      * @return String

      */

     public final String getPackageRoot()

     {

         StringBuffer buff = new StringBuffer();

         JavaFile jf = null;

         try

         {

             jf = fileManager.getFile( this.getCurrentFilename() );

         }

         catch ( IOException e )

         {

             e.printStackTrace();

             return null;

         }

         String current = jf.getPackageType().getName();

         int count = this.getPackageCount( current );

         for ( int i = 0; i < count; ++i )

         {

             buff.append( "../" );

         }

         return buff.toString();

     }

     /**

      * Given a line of text, search for URIs and make href's out of them

      *

      * @param line String

      * @return String

      */

     public final String uriFilter( String line )

     {

         for ( int i = 0; i < VALID_URI_SCHEMES.length; ++i )

         {

             String scheme = VALID_URI_SCHEMES[i];

             int index = line.indexOf( scheme );

             if ( index != -1 )

             {

                 int start = index;

                 int end = -1;

                 for ( int j = start; j < line.length(); ++j )

                 {

                     char current = line.charAt( j );

                     if ( !Character.isLetterOrDigit( current ) && isInvalidURICharacter( current ) )

                     {

                         end = j;

                         break;

                     }

                     end = j;

                 }

                 //now you should have the full URI so you can replace this

                 //in the current buffer

                 if ( end != -1 )

                 {

                     String uri = line.substring( start, end );

                     line = StringUtils.replace( line, uri,

                                                 "<a href=\"" + uri + "\" target=\"alexandria_uri\">" + uri + "</a>" );

                 }

             }

         }

         //if we are in a multiline comment we should not call JXR here.

         if ( !inMultiLineComment && !inJavadocComment )

         {

             return jxrFilter( line );

         }

         return line;

     }

     /**

      * The current revision of the CVS module

      *

      * @return String

      */

     public final String getRevision()

     {

         return this.revision;

     }

     /**

      * The current source file being read

      *

      * @return source file name

      */

     public final String getSourcefile()

     {

         return this.sourcefile;

     }

     /**

      * The current dest file being written

      *

      * @return destination file name

      */

     public final String getDestfile()

     {

         return this.destfile;

     }

     /**

      * The current source directory being read from.

      *

      * @return source directory

      */

     public final String getSourceDirectory()

     {

         return this.sourcedir;

     }

     /**

      * Cross Reference the given line with JXR returning the new content.

      *

      * @param line String

      * @param packageName String

      * @param classType ClassType

      * @return String

      */

     public final String xrLine( String line, String packageName, ClassType classType )

     {

         StringBuffer buff = new StringBuffer( line );

         String link = null;

         String find = null;

         String href = null;

         if ( classType != null )

         {

             href = this.getHREF( packageName, classType );

             find = classType.getName();

         }

         else

         {

             href = this.getHREF( packageName );

             find = packageName;

         }

         //build out what the link would be.

         link = "<a href=\"" + href + "\">" + find + "</a>";

         //use the SimpleWordTokenizer to find all entries

         //that match word.  Then replace these with the link

         //now replace the word in the buffer with the link

         String replace = link;

         StringEntry[] tokens = SimpleWordTokenizer.tokenize( buff.toString(), find );

         for ( int l = 0; l < tokens.length; ++l )

         {

             int start = tokens[l].getIndex();

             int end = tokens[l].getIndex() + find.length();

             buff.replace( start, end, replace );

         }

         return buff.toString();

     }

     /**

      * Highlight the package in this line.

      *

      * @param line input line

      * @param packageName package name

      * @return input line with linked package

      */

     public final String xrLine( String line, String packageName )

     {

         String href = this.getHREF( packageName );

         String find = packageName;

         //build out what the link would be.

         String link = "<a href=\"" + href + "\">" + find + "</a>";

         return StringUtils.replace( line, find, link );

     }

     // ----------------------------------------------------------------------

     // private methods

     // ----------------------------------------------------------------------

     /**

      * Filter html tags into more benign text.

      *

      * @param line String

      * @return html encoded line

      */

     private final String htmlFilter( String line )

     {

         if ( line == null || line.equals( "" ) )

         {

             return "";

         }

         line = replace( line, "&", "&" );

         line = replace( line, "<", "&lt;" );

         line = replace( line, ">", ">" );

         line = replace( line, "\\\\", "\\" );

         line = replace( line, "\\\"", "\\"" );

         line = replace( line, "'\"'", "'"'" );

         return multiLineCommentFilter( line );

     }

     /**

      * Filter out multiLine comments. State is kept with a private boolean variable.

      *

      * @param line String

      * @return String

      */

     private final String multiLineCommentFilter( String line )

     {

         if ( line == null || line.equals( "" ) )

         {

             return "";

         }

         StringBuffer buf = new StringBuffer();

         int index;

         //First, check for the end of a java comment.

         if ( inJavadocComment && ( index = line.indexOf( "*/" ) ) > -1 && !isInsideString( line, index ) )

         {

             inJavadocComment = false;

             buf.append( JAVADOC_COMMENT_START );

             buf.append( line.substring( 0, index ) );

             buf.append( "*/" ).append( JAVADOC_COMMENT_END );

             if ( line.length() > index + 2 )

             {

                 buf.append( inlineCommentFilter( line.substring( index + 2 ) ) );

             }

             return uriFilter( buf.toString() );

         }

         //Second, check for the end of a multi-line comment.

         if ( inMultiLineComment && ( index = line.indexOf( "*/" ) ) > -1 && !isInsideString( line, index ) )

         {

             inMultiLineComment = false;

             buf.append( COMMENT_START );

             buf.append( line.substring( 0, index ) );

             buf.append( "*/" ).append( COMMENT_END );

             if ( line.length() > index + 2 )

             {

                 buf.append( inlineCommentFilter( line.substring( index + 2 ) ) );

             }

             return uriFilter( buf.toString() );

         }

         //If there was no end detected and we're currently in a multi-line

         //comment, we don't want to do anymore work, so return line.

         else if ( inMultiLineComment )

         {

             StringBuffer buffer = new StringBuffer( line );

             buffer.insert( 0, COMMENT_START );

             buffer.append( COMMENT_END );

             return uriFilter( buffer.toString() );

         }

         else if ( inJavadocComment )

         {

             StringBuffer buffer = new StringBuffer( line );

             buffer.insert( 0, JAVADOC_COMMENT_START );

             buffer.append( JAVADOC_COMMENT_END );

             return uriFilter( buffer.toString() );

         }

         //We're not currently in a Javadoc comment, so check to see if the start

         //of a multi-line Javadoc comment is in this line.

         else if ( ( index = line.indexOf( "/**" ) ) > -1 && !isInsideString( line, index ) )

         {

             inJavadocComment = true;

             //Return result of other filters + everything after the start

             //of the multiline comment. We need to pass the through the

             //to the multiLineComment filter again in case the comment ends

             //on the same line.

             buf.append( inlineCommentFilter( line.substring( 0, index ) ) );

             buf.append( JAVADOC_COMMENT_START ).append( "/**" );

             buf.append( JAVADOC_COMMENT_END );

             buf.append( multiLineCommentFilter( line.substring( index + 3 ) ) );

             return uriFilter( buf.toString() );

         }

         //We're not currently in a comment, so check to see if the start

         //of a multi-line comment is in this line.

         else if ( ( index = line.indexOf( "/*" ) ) > -1 && !isInsideString( line, index ) )

         {

             inMultiLineComment = true;

             //Return result of other filters + everything after the start

             //of the multiline comment. We need to pass the through the

             //to the multiLineComment filter again in case the comment ends

             //on the same line.

             buf.append( inlineCommentFilter( line.substring( 0, index ) ) );

             buf.append( COMMENT_START ).append( "/*" );

             buf.append( multiLineCommentFilter( line.substring( index + 2 ) ) );

             buf.append( COMMENT_END );

             return uriFilter( buf.toString() );

         }

         //Otherwise, no useful multi-line comment information was found so

         //pass the line down to the next filter for processesing.

         else

         {

             return inlineCommentFilter( line );

         }

     }

     /**

      * Filter inline comments from a line and formats them properly. One problem

      * we'll have to solve here: comments contained in a string should be

      * ignored... this is also true of the multiline comments. So, we could

      * either ignore the problem, or implement a function called something like

      * isInsideString(line, index) where index points to some point in the line

      * that we need to check... started doing this function below.

      *

      * @param line String

      * @return String

      */

     private final String inlineCommentFilter( String line )

     {

         if ( line == null || line.equals( "" ) )

         {

             return "";

         }

         StringBuffer buf = new StringBuffer();

         int index;

         if ( ( index = line.indexOf( "//" ) ) > -1 && !isInsideString( line, index ) )

         {

             buf.append( stringFilter( line.substring( 0, index ) ) );

             buf.append( COMMENT_START );

             buf.append( line.substring( index ) );

             buf.append( COMMENT_END );

         }

         else

         {

             buf.append( stringFilter( line ) );

         }

         return buf.toString();

     }

     /**

      * Filters strings from a line of text and formats them properly.

      *

      * @param line String

      * @return String

      */

     private final String stringFilter( String line )

     {

         if ( line == null || line.equals( "" ) )

         {

             return "";

         }

         StringBuffer buf = new StringBuffer();

         if ( line.indexOf( "\"" ) <= -1 )

         {

             return keywordFilter( line );

         }

         int start = 0;

         int startStringIndex = -1;

         int endStringIndex = -1;

         int tempIndex;

         //Keep moving through String characters until we want to stop...

         while ( ( tempIndex = line.indexOf( "\"" ) ) > -1 )

         {

             //We found the beginning of a string

             if ( startStringIndex == -1 )

             {

                 startStringIndex = 0;

                 buf.append( stringFilter( line.substring( start, tempIndex ) ) );

                 buf.append( STRING_START ).append( "\"" );

                 line = line.substring( tempIndex + 1 );

             }

             //Must be at the end

             else

             {

                 startStringIndex = -1;

                 endStringIndex = tempIndex;

                 buf.append( line.substring( 0, endStringIndex + 1 ) );

                 buf.append( STRING_END );

                 line = line.substring( endStringIndex + 1 );

             }

         }

         buf.append( keywordFilter( line ) );

         return buf.toString();

     }

     /**

      * Filters keywords from a line of text and formats them properly.

      *

      * @param line String

      * @return String

      */

     private final String keywordFilter( String line )

     {

         final String CLASS_KEYWORD = "class";

         if ( line == null || line.equals( "" ) )

         {

             return "";

         }

         StringBuffer buf = new StringBuffer();

         Hashtable usedReservedWords = new Hashtable();

         int i = 0;

         char ch;

         StringBuffer temp = new StringBuffer();

         while ( i < line.length() )

         {

             temp.setLength( 0 );

             ch = line.charAt( i );

             while ( i < line.length() && ( ( ch >= 65 && ch <= 90 ) || ( ch >= 97 && ch <= 122 ) ) )

             {

                 temp.append( ch );

                 i++;

                 if ( i < line.length() )

                 {

                     ch = line.charAt( i );

                 }

             }

             String tempString = temp.toString();

             // Special handling of css style class definitions

             if ( CLASS_KEYWORD.equals( tempString ) && ch == '=' )

             {

                 i++;

             }

             else if ( reservedWords.containsKey( tempString ) )

             {

                 StringBuffer newLine = new StringBuffer( line.substring( 0, i - tempString.length() ) );

                 newLine.append( RESERVED_WORD_START );

                 newLine.append( tempString );

                 newLine.append( RESERVED_WORD_END );

                 newLine.append( line.substring( i ) );

                 line = newLine.toString();

                 i += ( RESERVED_WORD_START.length() + RESERVED_WORD_END.length() );

             }

             else

             {

                 i++;

             }

         }

         buf.append( line );

         return uriFilter( buf.toString() );

     }

     /**

      * Replace... I made it use a stringBuffer... hope it still works :)

      *

      * @param line String

      * @param oldString String

      * @param newString String

      * @return String

      */

     private final String replace( String line, String oldString, String newString )

     {

         int i = 0;

         while ( ( i = line.indexOf( oldString, i ) ) >= 0 )

         {

             line = ( new StringBuffer().append( line.substring( 0, i ) ).append( newString ).append(

                 line.substring( i + oldString.length() ) ) ).toString();

             i += newString.length();

         }

         return line;

     }

     /**

      * Checks to see if some position in a line is between String start and

      * ending characters. Not yet used in code or fully working :)

      *

      * @param line String

      * @param position int

      * @return boolean

      */

     private final boolean isInsideString( String line, int position )

     {

         if ( line.indexOf( "\"" ) < 0 )

         {

             return false;

         }

         int index;

         String left = line.substring( 0, position );

         String right = line.substring( position );

         int leftCount = 0;

         int rightCount = 0;

         while ( ( index = left.indexOf( "\"" ) ) > -1 )

         {

             leftCount++;

             left = left.substring( index + 1 );

         }

         while ( ( index = right.indexOf( "\"" ) ) > -1 )

         {

             rightCount++;

             right = right.substring( index + 1 );

         }

         return ( rightCount % 2 != 0 && leftCount % 2 != 0 );

     }

     /**

      * Description of the Method

      */

     private final void loadHash()

     {

         reservedWords.put( "abstract", "abstract" );

         reservedWords.put( "do", "do" );

         reservedWords.put( "inner", "inner" );

         reservedWords.put( "public", "public" );

         reservedWords.put( "var", "var" );

         reservedWords.put( "boolean", "boolean" );

         reservedWords.put( "continue", "continue" );

         reservedWords.put( "int", "int" );

         reservedWords.put( "return", "return" );

         reservedWords.put( "void", "void" );

         reservedWords.put( "break", "break" );

         reservedWords.put( "else", "else" );

         reservedWords.put( "interface", "interface" );

         reservedWords.put( "short", "short" );

         reservedWords.put( "volatile", "volatile" );

         reservedWords.put( "byvalue", "byvalue" );

         reservedWords.put( "extends", "extends" );

         reservedWords.put( "long", "long" );

         reservedWords.put( "static", "static" );

         reservedWords.put( "while", "while" );

         reservedWords.put( "case", "case" );

         reservedWords.put( "final", "final" );

         reservedWords.put( "native", "native" );

         reservedWords.put( "super", "super" );

         reservedWords.put( "transient", "transient" );

         reservedWords.put( "cast", "cast" );

         reservedWords.put( "float", "float" );

         reservedWords.put( "new", "new" );

         reservedWords.put( "rest", "rest" );

         reservedWords.put( "catch", "catch" );

         reservedWords.put( "for", "for" );

         reservedWords.put( "null", "null" );

         reservedWords.put( "synchronized", "synchronized" );

         reservedWords.put( "char", "char" );

         reservedWords.put( "finally", "finally" );

         reservedWords.put( "operator", "operator" );

         reservedWords.put( "this", "this" );

         reservedWords.put( "class", "class" );

         reservedWords.put( "generic", "generic" );

         reservedWords.put( "outer", "outer" );

         reservedWords.put( "switch", "switch" );

         reservedWords.put( "const", "const" );

         reservedWords.put( "goto", "goto" );

         reservedWords.put( "package", "package" );

         reservedWords.put( "throw", "throw" );

         reservedWords.put( "double", "double" );

         reservedWords.put( "if", "if" );

         reservedWords.put( "private", "private" );

         reservedWords.put( "true", "true" );

         reservedWords.put( "default", "default" );

         reservedWords.put( "import", "import" );

         reservedWords.put( "protected", "protected" );

         reservedWords.put( "try", "try" );

         reservedWords.put( "throws", "throws" );

     }

     /**

      * Description of the Method

      *

      * @param oos ObjectOutputStream

      * @throws IOException

      */

     final void writeObject( ObjectOutputStream oos )

         throws IOException

     {

         oos.defaultWriteObject();

     }

     /**

      * Description of the Method

      *

      * @param ois ObjectInputStream

      * @throws ClassNotFoundException

      * @throws IOException

      */

     final void readObject( ObjectInputStream ois )

         throws ClassNotFoundException, IOException

     {

         ois.defaultReadObject();

     }

     /**

      * Get an overview header for this file.

      *

      * @return String

      */

     private final String getFileOverview()

     {

         StringBuffer overview = new StringBuffer();

         // only add the header if javadocs are present

         if ( javadocLinkDir != null )

         {

             overview.append( "<div id=\"overview\">" );

             //get the URI to get Javadoc info.

             StringBuffer javadocURI = new StringBuffer().append( javadocLinkDir );

             try

             {

                 JavaFile jf = fileManager.getFile( this.getCurrentFilename() );

                 javadocURI.append( StringUtils.replace( jf.getPackageType().getName(), ".", "/" ) );

                 javadocURI.append( "/" );

                 // Use the name of the file instead of the class to handle inner classes properly

                 if ( jf.getClassType() != null && jf.getClassType().getFilename() != null )

                 {

                     javadocURI.append( jf.getClassType().getFilename() );

                 }

                 else

                 {

                     return "";

                 }

                 javadocURI.append( ".html" );

             }

             catch ( IOException e )

             {

                 e.printStackTrace();

             }

             String javadocHREF = "<a href=\"" + javadocURI + "\">View Javadoc</a>";

             //get the generation time...

             overview.append( javadocHREF );

             overview.append( "</div>" );

         }

         return overview.toString();

     }

     /**

      * Handles line width which may need to change depending on which line

      * number you are on.

      *

      * @param linenumber int

      * @return String

      */

     private final String getLineWidth( int linenumber )

     {

         if ( linenumber < 10 )

         {

             return "   ";

         }

         else if ( linenumber < 100 )

         {

             return "  ";

         }

         else

         {

             return " ";

         }

     }

     /**

      * Handles finding classes based on the current filename and then makes

      * HREFs for you to link to them with.

      *

      * @param line String

      * @return String

      */

     private final String jxrFilter( String line )

     {

         JavaFile jf = null;

         try

         {

             //if the current file isn't set then just return

             if ( this.getCurrentFilename() == null )

             {

                 return line;

             }

             jf = fileManager.getFile( this.getCurrentFilename() );

         }

         catch ( IOException e )

         {

             e.printStackTrace();

             return line;

         }

         Vector v = new Vector();

         //get the imported packages

         ImportType[] imports = jf.getImportTypes();

         for ( int j = 0; j < imports.length; ++j )

         {

             v.addElement( imports[j].getPackage() );

         }

         //add the current package.

         v.addElement( jf.getPackageType().getName() );

         String[] packages = new String[v.size()];

         v.copyInto( packages );

         StringEntry[] words = SimpleWordTokenizer.tokenize( line );

         //go through each word and then match them to the correct class if necessary.

         for ( int i = 0; i < words.length; ++i )

         {

             //each word

             StringEntry word = words[i];

             for ( int j = 0; j < packages.length; ++j )

             {

                 //get the package from teh PackageManager because this will hold

                 //the version with the classes also.

                 PackageType currentImport = packageManager.getPackageType( packages[j] );

                 //the package here might in fact be null because it wasn't parsed out

                 //this might be something that is either not included or os part

                 //of another package and wasn't parsed out.

                 if ( currentImport == null )

                 {

                     continue;

                 }

                 //see if the current word is within the package

                 //at this point the word could be a fully qualified package name

                 //(FQPN) or an imported package name.

                 String wordName = word.toString();

                 if ( wordName.indexOf( "." ) != -1 )

                 {

                     //if there is a "." in the string then we have to assume

                     //it is a package.

                     String fqpn_package = null;

                     String fqpn_class = null;

                     fqpn_package = wordName.substring( 0, wordName.lastIndexOf( "." ) );

                     fqpn_class = wordName.substring( wordName.lastIndexOf( "." ) + 1, wordName.length() );

                     //note. since this is a reference to a full package then

                     //it doesn't have to be explicitly imported so this information

                     //is useless.  Instead just see if it was parsed out.

                     PackageType pt = packageManager.getPackageType( fqpn_package );

                     if ( pt != null )

                     {

                         ClassType ct = pt.getClassType( fqpn_class );

                         if ( ct != null )

                         {

                             //OK.  the user specified a full package to be imported

                             //that is in the package manager so it is time to

                             //link to it.

                             line = xrLine( line, pt.getName(), ct );

                         }

                     }

                     if ( fqpn_package.equals( currentImport.getName() )

                         && currentImport.getClassType( fqpn_class ) != null )

                     {

                         //then the package we are currently in is the one specified in the string

                         //and the import class is correct.

                         line = xrLine( line, packages[j], currentImport.getClassType( fqpn_class ) );

                     }

                 }

                 else if ( currentImport.getClassType( wordName ) != null )

                 {

                     line = xrLine( line, packages[j], currentImport.getClassType( wordName ) );

                 }

             }

         }

         return importFilter( line );

     }

     /**

      * Given the current package, get an HREF to the package and class given

      *

      * @param dest String

      * @param jc ClassType

      * @return String

      */

     private final String getHREF( String dest, ClassType jc )

     {

         StringBuffer href = new StringBuffer();

         //find out how to go back to the root

         href.append( this.getPackageRoot() );

         //now find out how to get to the dest package

         dest = StringUtils.replace( dest, ".*", "" );

         dest = StringUtils.replace( dest, ".", "/" );

         href.append( dest );

         // Now append filename.html

         if ( jc != null )

         {

             href.append( "/" );

             href.append( jc.getFilename() );

             href.append( ".html" );

         }

         return href.toString();

     }

     /**

      * Based on the destination package, get the HREF.

      *

      * @param dest String

      * @return String

      */

     private final String getHREF( String dest )

     {

         return getHREF( dest, null );

     }

     /**

      * <p>Given the name of a package... get the number of

      * subdirectories/subpackages there would be. </p>

      * <p>EX: org.apache.maven == 3 </p>

      *

      * @param packageName String

      * @return int

      */

     private final int getPackageCount( String packageName )

     {

         if ( packageName == null )

         {

             return 0;

         }

         int count = 0;

         int index = 0;

         while ( true )

         {

             index = packageName.indexOf( ".", index );

             if ( index == -1 )

             {

                 break;

             }

             ++index;

             ++count;