/* -------------------------------------------------------------------------- */
/*                                                                            */
/*                           DOCUMENTATION TOOL                               */
/*                                                                            */
/*                              Frans Coenen                                  */
/*                                                                            */
/*                        Wednesday 19 September 2007                         */
/*            Revisised: Tuesday 16 October 2007, Mondat 1 Junr 2008          */
/*                                                                            */
/*                      Department of Computer Science                        */
/*                        The University of Liverpool                         */
/*                                                                            */
/* -------------------------------------------------------------------------- */

/** Transglobal express KTP documentation tool to document asp files. */

/* NOTES:
1. Everything gets converted to lower case for comparison purposes although 
   this is not apparent from the output (whivh uses the original source).
2. Sting s=null; s=s+s; produces s = "nullnull"!
3. currentLine is a class variable used to temporerily hold line numbers, thus
   should usualy be reset to 0 when starting a new process. */

import java.io.*;
import java.util.*;
import javax.swing.*;

class ASPdoc extends JFrame {
    // INPUT/OUTPUT FILE FIELDS
    /** Array of file names to be checked. */
    private String[] fileNames = null;
    /** Alternative array of file paths. */
    private File[] filePaths   = null;
    /** Current input file name (used for error messaging. */
    private String filename;
    /** Instance of BufferedReader class */
    private BufferedReader fileInput = null;
    /** Output data file name. */
    private File outputFileName = null ;
    /** Instance of PrintWriter class for file output. */
    private PrintWriter fileOutput = null;

    // DATA STRUCTURES
    /** String array in which c urrent code is stored for processing. */
    private String[] codeFile = null;
    /** Array of link labels. */
    private LinkStruct[] links = null;
    /** Array of ASP structures. */
    private ASPstruct[] aspFrags = null;
    /** Array of .asp function structures. */
    private ASPfunctionStruct[] aspFunctions = null;
    /** Array of script structures. */
    private ScriptStruct[] scriptFrags = null;
    /** Array of script function structures. */
    private ScriptFunctionStruct[] scriptFunctions = null;

    // FLAGS
    /** Output links flag. */
    private boolean outputLinksFlag = true;
    /** Output asp blocks flag. */
    private boolean outputASPblocksFlag = true;
    /** Output asp functions flag. */
    private boolean outputASPfuncsFlag = true;
    /** Output script blocks flag. */
    private boolean outputScriptBlocksFlag = true;
    /** Output script functions flag. */
    private boolean outputScriptFuncsFlag = true;
    
    // OTHER FIELDS
    /** The current line number used foe refficiency purposes (Reset for each
    new documentation process). */
    private int currentLine = 0;
    /** The title inbetween the title tags in the ciurrentbinput file. */
    private String title = null;
    /** The start comment if any. */
    private String startComment = null;
    /** Text Area if using GUI interface. */
    private JTextArea textArea = null;

    /* --------------------------------------------------- */
    /*                                                     */
    /*                    CONSTRUCTORS                     */
    /*                                                     */
    /* --------------------------------------------------- */

    /** Defualt constructor used with GUI. */

    public ASPdoc() {
        }

    /** One argumenmt constructor.
    @param tFile the file containing the list of field and method names to be
    checked. */

    public ASPdoc(String[] fNames) {
        fileNames = fNames;
        }

    /* ---------------------------------------------------------------- */
    /*                                                                  */
    /*                           S T A R T                              */
    /*                                                                  */
    /* ---------------------------------------------------------------- */

    /** Starts the documentation process, choosing btween a list of sting file
    names or paths. */

    public void startDocumentation() {
        if (fileNames!=null) startDocumentation1();
        else if (filePaths!=null) startDocumentation2();
        else output("ERROR: no files specified");
        }

    /** Starts documentation process where file list is in the form of a list
    of strings. */

    private void startDocumentation1() {
        // Read files
        for (int fIndex=0;fIndex<fileNames.length;fIndex++) {
            // First makesure fields are set to default status
            resetFields();
            // Read file, get size, ctrate storage, load
//System.out.println("File = " + fileNames[fIndex]);
            filename  = fileNames[fIndex];
            int size  = getNumberOfLines(fileNames[fIndex]);
            codeFile = new String[size];
            readInputFile(fileNames[fIndex]);
            // Documenmt the file
            processFile();
            // Output the result
            output(filename,fIndex);
            // End (and start on next file!)
            output("Completed " + filename);
            closeInputFile();
            }
        }

    /** Starts documentation process where file list is in the form of a list
    of paths of type <TT>FILE</TT>. */

    private void startDocumentation2() {
        // Read files
        for (int fIndex=0;fIndex<filePaths.length;fIndex++) {
            // Reset fields to default status
            resetFields();
            // Read file, get size, ctrate storage, load
//System.out.println("File = " + filePaths[fIndex]);
            filename  = filePaths[fIndex].toString();
            int pos = filename.lastIndexOf('/');		// Linux, MacOS
            if (pos<0) pos = filename.lastIndexOf('\\');	// Windows
            if (pos>=0) filename = filename.substring(pos+1);
//System.out.println("filename = " + filename);
            int size  = getNumberOfLines(filePaths[fIndex]);
//System.out.println("size = " + size);
            codeFile = new String[size];
            readInputFile(filePaths[fIndex]);
            // Documenmt the file
            processFile();
            // Output
            output(filename,fIndex);
            // End (and start on next file!)
            output("Completed " + filename);
            closeInputFile();
            }
        }

    /** Processes the current input file. <P>This is the heart of the process. */

    private void processFile() {
        // Get title, if any,  inbetween '<TITLE>' and '</TITLE>' tags if
        // available.
        int pos = findTitle();

        // If title found have .html file, thus find opening comment on line
        // imediately after <BODY> tag if available. Otherwise .asp file in
        // which case opening comment on second line. NOTR: Opening comments
        // are included by creator of the WWW site.
        pos = findComment(pos);
//System.out.println("processFile 0: currentLine = " + currentLine);

        // Seasrch entire file looking for links (<A HREF = "....)
        findLinks(pos);

        // Look for ASP blocks/fragments, between '<%' and '%>' tags, and .asp
        // functions within .asp fragments. Then, if found idebtify .asp
        // functions. (1) count blocks and create storage, (2) process blocks,
        // (3) count functions and create storage, (4) process functions
        countASPfrags(pos);
        if (aspFrags!=null) {
            findASPfrags(pos);
            countASPfunctions();
            if (aspFunctions!=null) idASPfunctions();
            }
//System.out.println("processFile 6: currentLine = " + currentLine);
        collectASPblockComments();   // Uses currentLine field
//System.out.println("processFile 7: currentLine = " + currentLine);
        currentLine = 0;              // Reset.

        // Look for SCRIPT fragments, between <SCRIPT and /SCRIPT> tags
        countScriptFrags(pos);
        if (scriptFrags!=null) {
            findScriptFrags(pos);
            countScriptFunctions();
            if (scriptFunctions!=null) idScriptFunctions();
            }
        }

    /* --------------------------------------------------------------------- */
    /*                                                                       */
    /*              T I T L E   A N D   S T A R T   C O M M E N T            */
    /*                                                                       */
    /* --------------------------------------------------------------------- */


    /** Find title text loacted between '<TITLE>' and '</TITLE>' tags if any.
    @return position in current line where title was found or zero otherwise. */

    private int findTitle() {
        int pos = 0;

        // Find <TITLE> tag
        int pos1 = findStartTag("title",0);

        // If not negative found title tag, thus find closing tag </TITLE>
        if (pos1>=0) {
            int line = currentLine;
            int pos2 = findEndTag("/title",pos1+1);
            // Found end tag, get title (the enclosed string between the tags)
            if (pos2>=0) {
                title = getString(line,pos1+1,currentLine,pos2);
                pos = pos2;
                }
            // Otherwise error
            else output("ERROR " + filename + ": no closing </title> tag!");
            }
        else {
            pos = 0;
            currentLine = 0;
            }

        // Return
        return(pos);
        }

    /** Finds opening explanatory comment if available; this will be located
    immediately after the '<BODY>' tag if HTML document or on second line (line
    number 1, first line is 0) if not .asp document, ot first line otherwise.
    <P>Note that comment can go over several lines.
    @return position in current line from where search is to continue.  */

    private int findComment(int pos) {
        // If title found have .html file, thus find comment on line imediately
        // after <BODY> tag if available.
        if (title!=null) {
            int tempLineCounter = currentLine;
            int tempPos = findCommentAfterBodyTag(pos);
            if (tempPos>=0) pos=tempPos;
            else currentLine = tempLineCounter;
            }
        // Otherwise .asp file in which case opening comment on second line
        else if (codeFile[0].indexOf("<%")>=0) {
            currentLine=1;
            findHTMLcomment(0);
            currentLine = 0;
            }
        // Else html comment
        else {
            currentLine=0;
            findHTMLcomment(0);
            currentLine = 0;
            }

        // Return
        return(pos);
        }

    /** Attemots to find an HTML syle comment (<! ... >) located immediately
    after body start tag or starting after line 0 iks .asp page or on line 0
    otherrwise; this is where any programmer comments should have been placed.
    Note that although there may be a title tag later in the code this may be
    followed by a body tag (and subsequent comment), in which case return to
    top of code and look for comments here.
    @param pos the location in the current line from where the search is to
    start.
    @return the current position in the line where the comment ends or -1. */

    private int findCommentAfterBodyTag(int pos) {
        // Find <BODY> tag
        pos = findStartTag("body",pos);

        // If found proceed, otherwise error
        if (pos>=0) pos = findHTMLcomment(pos);
        // No body tag therefore look back at top of code.
        else if (codeFile[0].indexOf("<%")>=0) {
            currentLine=1;
            pos = findHTMLcomment(0);
            currentLine = 0;
            if (pos<0) pos =-1;
            }
        // Else html comment
        else {
            currentLine=0;
            pos = findHTMLcomment(0);
            currentLine = 0;
            if (pos<0) pos =-1;
            }

        // Return
        return(pos);
        }

    /** Finds an HTML stylew comment (<! ... >) commencing search from
    currentLine in code.
    @param pos the location in the current line from where the search is to
    start.
    @retutn location of end of comment or -1 if no comment found. */

    private int findHTMLcomment(int pos) {
        // Ignore empty lines (+1 becuse current line is where '<BODY>' tag
        // was found (if appropriate).
        currentLine = findNextNonMTline(currentLine);
//System.out.println("codeFile[currentLine] = " +  codeFile[currentLine]);
        // Find open comment on discovered first non MT line
        int startPos = codeFile[currentLine].indexOf("<!");
//System.out.println("Find '<!', startPos = " + startPos);
        // Test
        if (startPos>=0) {
            // Found comment
            int startLine = currentLine;
            int endPos = findChar('>',startPos+2);
            startComment = getString(startLine,startPos+2,currentLine,endPos);
//System.out.println("startComment = " + startComment);
            return(endPos);
            }

        // Otherwise no comment
        else return(-1);
        }

    /* ---------------------------------------------------------------- */
    /*                                                                  */
    /*                           L I N K S                              */
    /*                                                                  */
    /* ---------------------------------------------------------------- */

    /** Identifies links (URLs) in given input file.
    @param pos position in line indicated by tempLineCounter from where
    searching is to commence.
    @param tempLineCounter line input file form where search should begin. */

    private void findLinks(int pos) {
        int tempLineCounter = currentLine;

        // Count links
        int numLinks = countLinks(0,pos);
//System.out.println("numLinks = " + numLinks);

        // If links found define links structure
        if (numLinks>0) {
            links = new LinkStruct[numLinks];
            for(int i=0;i<links.length;i++) links[i] = new LinkStruct();
            // Get details
            currentLine = tempLineCounter;
            findLink(pos,0);
            }

        // End
        currentLine = tempLineCounter;
        }

    /** Count '<A * HREF * >'tags and dimension links array.
    @counter the '< * HREF * >' tags encountered so far.
    @param pos the location in the current line from where the search is to
    start.	*/

    private int countLinks(int counter, int pos) {
        // Search for '<A'
        int startPos = findString("<a",pos);

        // If found go on to find closing '>'
        if (startPos>=0) {
             int startLine = currentLine;
             int endPos    = findChar('>',startPos+1);
             // If found get string between '<' and '>' and test contents.
             if (endPos>=0) {
                 String s = getString(startLine,startPos+2,currentLine,endPos);
                 String tempS = s.toLowerCase().trim();
                 int i = tempS.indexOf("href");
//System.out.println("tempS = " + tempS);
                 if (i==0) return(countLinks(counter+1,endPos+1));
                 else return(countLinks(counter,endPos+1));
                 }
             // No end pos essentially an error in the input file
             else return(counter);
             }
        // No open '<' tag operator found
        else return(counter);
        }

    /** Find links ('<A * HREF * = label *>' tags).
    @param pos the location in the current line from where the search is to
    start.
    @param index the current index in to the links array.  */

    private void findLink(int pos, int index) {
        // Search for '<A'
        int startPos = findString("<a",pos);

        // If found '<' go on to find closing '>'
        if (startPos>=0) {
            int startLine = currentLine;
            int[] end     = findEndOfTag(startLine,startPos+1);
            int endPos    = end[1];
            // If found '>' get contents and check that includes 'HREF'.
            if (endPos>=0) {
                 int endLine   = end[0];
                 String s = getString(startLine,startPos+2,endLine,endPos);
                 String tempS = s.toLowerCase().trim();
                 int i = tempS.indexOf("href");
//System.out.println("tempS = " + tempS);
                 if (i==0) {
                    String label = checkForSpecialChars(getValue(s));
                    // Check for no reference label
                    if (label.length()==0) label=null;
                    // Set and increment index
                    links[index].setLineNumber(currentLine);
                    links[index].setLinkLabel(label);
                    index=index+1;
                    }
                findLink(endPos+1,index);
                }
            else output("ERROR " + filename + ": No '>' paired " +
                                       "with '<' on line " + startLine + "!");
            }
        }

    /** Finds the closing '>' matching an opening '<'.
    @param startLine the line number in the code file where the '<' is located
    @return two element array reprresenting the end line number and end
    position in that line.	*/

    private int[] findEndOfTag(int startLine, int startPos) {
        int[] end = {-1,-1};
        int   n   = 1;

        for (int i=startLine;i<codeFile.length;i++) {
            String s = codeFile[i];
            for (int j=startPos;j<s.length();j++) {
                char c = s.charAt(j);
//System.out.println("c = " + c + ", n = " + n);
                if (c=='<') {
                    n++;
//System.out.println("c = " + c + "' n = " + n);
                    }
                if (c=='>') {
                    n--;
//System.out.println("c = " + c + "' n = " + n);
                    }
                // Test
                if (n==0) {
                	end[0] = i;
                	end[1] = j;
                	return(end);
                    }
                }
            startPos=0;
            }

        // End
        return(end);
        }

    /* ---------------------------------------------------------------- */
    /*                                                                  */
    /*                    A S P   F R A G M E N T S                     */
    /*                                                                  */
    /* ---------------------------------------------------------------- */

    /* Set of methods for: (i) identifying and (ii) documenting, ASP blocks
    (fragmnets). ASP blocks begin with a <% and end with a %>. An asp block can
    contain zero, one or many ASP functions. Details about the location of ASP
    blocjs is stored in a data structure of the type ASPstruct called aspFrags.
    This holds the details of the start and end positions of ASP fragments
    (blocks). */

    /** Counts .ASP fragments indicated by a '<%'.
    @param pos the location in the current line from where the search is to
    start (yhis is simply an efficiency measure).	 */

    private void countASPfrags(int pos) {
        int tempCurrentLine = currentLine;

        // Loop through file count number of blocks.
        int counter = countASPfrags(0,pos);
//System.out.println("Number of .asp fragments = " + counter);

        // If .asp fragment(s) found dimension .asp array
        if (counter>0) {
            aspFrags = new ASPstruct[counter];
            for(int i=0;i<counter;i++) aspFrags[i] = new ASPstruct();
            }

        // End
        currentLine = tempCurrentLine;
        }

    /**  Recursive process to count number of '<%' tags (opening tag for an ASP
    code block).
    @param counter number of '<%' tags sofar.
    @param pos the location in the current line from where the search is to
    start.
    @return the updated counter. */

    private int countASPfrags(int counter, int pos) {
        int startPos = findChar('<',pos);

        // If found check for subsequent '%'
        if (startPos>=0) {
            if (codeFile[currentLine].charAt(startPos+1)=='%')
                                   return(countASPfrags(counter+1,startPos+2));
            else return(countASPfrags(counter,startPos+1));
            }

        // Otherwise return
        return(counter);
        }

    /** Finds .asp fragments within the current file, once the ASPstruct data
    structure has been domensionsed, and causes start and end line numbers to
    be recorded.
    @param pos the location in the current line from where the search is to
    start.  */

    private void findASPfrags(int pos) {
        int tempCurrentLine = currentLine;

        // Search
        int startIndex = 0;
        findASPfragStart(pos,startIndex);

        // End
        currentLine = tempCurrentLine;
        }

    /** Finds start of .asp fragment indicated by a '<%' and records that start
    line number and position.
    @param pos the location in the current line from where the search is to
    start.
    @param index the current index into the links array.  */

    private void findASPfragStart(int pos, int index) {
        int startPos = findChar('<',pos);

        // If found check for subsequent '%'
        if (startPos>=0) {
            if (codeFile[currentLine].charAt(startPos+1)=='%') {
                // Found start of ASP fragment (block)
//System.out.println("currentLine = " + currentLine + ", startPoss = " + startPos);
                int startLine = currentLine;
                aspFrags[index].setStartLineNum(startLine,startPos);
                // Find end
                findASPfragEnd(startPos,startLine,index);
                }
            else findASPfragStart(startPos+1,index);
            }

        // Otherwise no more .asp fragments to find
        else return;
        }

    /** Finds end of .ASP fragment indicated by a '%>', and records the end
    line number and position.
    @param pos the location in the current line from where the search is to
    start.
    @param startLine the line in the code filke where the .asp fragment starts.
    @param index the current index into the links array.  */

    private void findASPfragEnd(int startPos, int startLine, int index) {
        int endPos = findChar('>',startPos+1);

        // If found check fpr preceding '%'
        if (endPos>=0) {
//System.out.println("charAt(" + endPos + "-1) = " +
//codeFile[currentLine].charAt(endPos-1));
            if (codeFile[currentLine].charAt(endPos-1)=='%') {
                // Found end ASP fargment
                aspFrags[index].setEndLineNum(currentLine,endPos);
                // Find next .asp fragment
                findASPfragStart(endPos+1,index+1);
                }
            else findASPfragEnd(endPos+1,startLine,index);
            }
        // Otherwise no closing tag found
        else output("ERROR " + filename + ": No closing '%>' " +
                             " found for .asp fragement starting on line " +
                               (aspFrags[index].getStartLineNum()+1) + "!");
        }

    /** Collect ASP block commnets located between start and end of ASP block
    but excluding functions. <P>Does this by processing ASPstruct data
    structure. The varibale j is the index into the aspFunctions structure,
    we do not want to include comments with function blocks. */

    private void collectASPblockComments() {
        // Loop through identified .asp fragments in ASPstruct data structure
        int j=0;   // aspFunction array index
        for (int i=0;i<aspFrags.length;i++) {
            int blockLN  = aspFrags[i].getStartLineNum();
            int blockEnd = aspFrags[i].getEndLineNum();
            // If there are no asp functions in the ASP block, or no more
            // functions, record comments.
            if ((aspFunctions== null) || (j>=aspFunctions.length)) {
                // Search for commnets between blockLN and blockEnd
                String s = findASPcomments(blockLN,blockEnd);
                aspFrags[i].setNote(s);
//System.out.println("blockLN = " + blockLN + ", blockEnd = " + blockEnd + "\n" + s);
               }
           else j=collectASPblockComments(aspFrags[i],blockLN,blockEnd,j);
           }
        }

    /** Collects ASP block comments for given block where functions are
    included.
    @param linkref The reference to the current ASP block.
    @param blockLN The current block line number starting with the block start
    line number.
    @param blockEnd The block end line number.
    @param j The current index into the ASP function structure.
    @return The updated index sofar into the ASP function structure. */

    private int collectASPblockComments(ASPstruct linkRef, int blockLN,
                                                          int blockEnd, int j) {
        String s = null;
        // Get start of first function
        int funcStart = aspFunctions[j].getStartLineNum();

        // Process block missing out ASP functions
        while (funcStart<blockEnd) {
            // Search for commnets between blockLN and funcStart-1
//System.out.println("collectASPblockComments, blockLN = " + blockLN +
//", funcStart = " + funcStart + "\ns = " + s);
            // If-else so that we do not get a "nullnull" string!
            if (s==null) s = findASPcomments(blockLN,funcStart);
            else s = s + findASPcomments(blockLN,funcStart);
//System.out.println("s = " + s);
            // Hve processed to start of function, update blockLN variable to
            // end of function, end of function may be end of block.
            blockLN = 1+ aspFunctions[j].getEndLineNum();
            if (blockLN>=blockEnd) break;
            // Get details of next ASP function; increment j index, if no more
            // functions then process rest of comments without checking for
            // functions, otherwise continue processing.
            j++;
            if (j>=aspFunctions.length) {
                if (s==null) s = findASPcomments(blockLN,blockEnd);
                else s = s + findASPcomments(blockLN,blockEnd);
                break;
                }
            else funcStart = aspFunctions[j].getStartLineNum();
            }

        // Update ASP structure
        linkRef.setNote(s);

        // End
        return(j);
        }

    /** Finds ASP comments between given start line and end line.
    @param startLine the given start line.
    @param endLine the given end line.
    @return the discovered comments or 'null' if none found. */

    private String findASPcomments(int start, int end) {
//System.out.println("findASPcomments: start = " + start + ", end = " + end);
        String s = null;

        for (int i=start;i<=end;i++) {
            // Find comment start
            currentLine=i;
            int startPos  = findString2("<!--",end);
            int startLine = currentLine;
            // Find comment end
            int endPos = findString2("<--",end);
            // Get comment
            if ((startPos>=0) && (endPos>=0)) {
                if (s==null) getString(startLine,startPos+4,currentLine,endPos);
                else s = s + getString(startLine,startPos+4,currentLine,endPos);
                }
            // Repear
            i= currentLine;
            }

        // Return
        return(s);
        }

    /* ---------------------------------------------------------------- */
    /*                                                                  */
    /*                    A S P   F U N C T I O N S                     */
    /*                                                                  */
    /* ---------------------------------------------------------------- */

    /* Series of methods to identify ASP functions. */

    /** Commences identification of functions contained with .asp fragments;
    identified by processing identified fragments. */

    private void countASPfunctions() {
        int tempCurrentLine = currentLine;
        int counter = 0;

        // Loop through identified .asp fragments
        for (int i=0;i<aspFrags.length;i++) {
            counter = countFunctions(counter,aspFrags[i].getStartLineNum(),
                     aspFrags[i].getStartPos(),aspFrags[i].getEndLineNum(),
                                                  aspFrags[i].getEndPos());
            }

        // Define and populate asp functions array
//System.out.println("Size = " + counter);
        if (counter>0) {
            aspFunctions = new ASPfunctionStruct[counter];
            for (int i=0;i<aspFunctions.length;i++)
                                aspFunctions[i] = new ASPfunctionStruct();
            }

        // End
        currentLine = tempCurrentLine;
        }

    /** Count functions in current fragment that are in the form 'function name
    (args) ... end function'; there may be several. <P>Assumption is that a
    functions starts at the beginning of a line. Remeber that any
    "exit function" statements should be ignored. Method may also called by
    count script functions method.
    @param counter the asp function count sofar.
    @param startLine the line in the source code where the current .asp
    fragment starts.
    @param startPos the location in the line in the source code where the
    current .asp fragment starts.
    @param endLine the line in the source code where the current .asp
    fragment endss.
    @param endPos the location in the line in the source code where the
    current .asp fragment ends.
    @return the updated count.   */

    private int countFunctions(int counter, int startLine, int startPos,
                                                  int endLine, int endPos) {
        boolean lookingForEnd = false;

        // Check first line in current .asp block
        String s = codeFile[startLine].substring(startPos+2);
        s = s.toLowerCase();
        if (s.indexOf("function")==0) {
//System.out.println("countFunctions/5");
//System.out.println("Function currentLine = " + startLine);
            counter++;
            lookingForEnd = true;
            }

        // Check middle
        for (int i=startLine+1;i<endLine;i++) {
//System.out.print(" " + i);
            s = codeFile[i].toLowerCase();
            if (lookingForEnd) {
                String[] searchS = {"end","function"};
                if (findStringSequence(searchS,s)) {
                    lookingForEnd=false;
//System.out.println("Function currentLine (End) = " + i);
                    }
                }
            else {
                if (s.indexOf("function")>=0) {
//System.out.println("countFunctions/5");
//System.out.println("Function currentLine (start) = " + i);
                    counter++;
                    lookingForEnd=true;
                    }
                }
            }

        // End, last line can only have an "end function" so ignore
        return(counter);
        }

    /** Commences process of dentifing details of functions contained in .asp
    fragments. */

    private void idASPfunctions() {
        int tempCurrentLine = currentLine;
        int index = 0;

        // Loop through identified .asp fragments
        for (int i=0;i<aspFrags.length;i++) {
            index = idASPfunctions(index,aspFrags[i].getStartLineNum(),
                     aspFrags[i].getStartPos(),aspFrags[i].getEndLineNum(),
                                                  aspFrags[i].getEndPos());
            }

        // End
        currentLine = tempCurrentLine;
        }

    /** Identifies functions in current .asp fragment.
    @param index the function array index sofar.
    @param startLine the line in the source code where the current .asp
    fragment starts.
    @param startPos the location in the line in the source code where the
    current .asp fragment starts.
    @param endLine the line in the source code where the current .asp
    fragment endss.
    @param endPos the location in the line in the source code where the
    current .asp fragment ends.
    @rerurn the updates index.   */

    private int idASPfunctions(int index, int startLine, int startPos,
                                                  int endLine, int endPos) {
        boolean lookingForEnd = false;

        // Check first line, can only have the start of a asp function
        String s = codeFile[startLine].substring(startPos+2);
        if (checkForFunction(lookingForEnd,s,startLine,index))
                                                        lookingForEnd = true;

        // Check middle
        for (int i=startLine+1;i<endLine;i++) {
//System.out.print(" " + i);
            s = codeFile[i];
            if (checkForFunction(lookingForEnd,s,i,index)) {
                if (lookingForEnd) {
                    index++;
                    lookingForEnd = false;
                    }
                else lookingForEnd = true;
                }
            }

        // Check last line (can only be looking for end)
        s = codeFile[endLine].substring(0,endPos);
        if (checkForFunction(lookingForEnd,s,endLine,index)) index++;

        // End
        return(index);
        }

    /** Checks if given string contains keyword 'function'.
    &param lookingForEnd booldean varibale set to true if looking for end of
    function and false otherwise.
    @param s the given string.
    @param startLine the line in the source code where the current .asp
    fragment starts.
    @param index the current index into the functions array.
    @return true if found, false otherwise. */

    private boolean checkForFunction(boolean lookingForEnd, String s,
                                                 int startLine, int index) {
        boolean found = false;

        // Convert to all lower case
        s = s.toLowerCase();

        // If looking for end of 'function' look for 'end' keyword first and
        // then 'function' keyword. If found retirn'true', otherwise 'false'.
        if (lookingForEnd) {
            String[] searchS = {"end","function"};
            if (findStringSequence(searchS,s)) {
                aspFunctions[index].setEndLineNum(startLine);
                found = true;
//System.out.println("endLine = " + startLine);
                }
            }
        // Otherwise search for keyword 'function', if found get details and
        // return true, otherwise return false
        else {
            int pos = s.indexOf("function");
            if ((pos>=0)  && (!isCommentedOut(startLine-1))) {
//System.out.println("checkForFunction/4");
//System.out.println("lookingForEnd = " + lookingForEnd + ", s = " + s +
//", startLine = " + startLine + ", index = " + index);
//System.out.println("startLine = " + startLine);
                if (isCommentedOut(startLine-1))
                                 aspFunctions[index].setCommentedOutFlag(true);
                getASPfunctionDetails(index,startLine,pos+8);
                found = true;
                }
            }

        // If no 'function' or 'end' keyword found return default
        return(found);
        }

    /** Searches for end of asp function in given line.
    @param s the given string.
    @return trure if found 'end function, false otherwise.       */

    private boolean findEndASPfunction(String s) {
        int pos = s.indexOf("end");

        // Check if end found
        if (pos>=0) {
            // Get rest of line
            s = s.substring(pos+3).trim();
            if (s.indexOf("function")==0) return(true);
            }

        // Default return
        return(false);
        }

    /** Gets asp functions details assuming name is on same line as function
    keyword.
    @param index the current function array index.
    @param startLine the line in the source code where the current .asp
    fragment starts.
    @param startPos the location in the line in the source code where the
    current .asp fragment starts. */

    private void getASPfunctionDetails(int index, int startLine, int startPos) {
        // Set start of function line number in structure.
        aspFunctions[index].setStartLineNum(startLine);

        // Try and find '(' on current line
        currentLine = startLine;
//System.out.println("currentLine = " + currentLine + ", startPos = " + startPos +
//", line = " + codeFile[currentLine] + ",index = " + index);
        int pos = findChar('(',startPos);
//System.out.println("pos = " + pos);
        // Get string
        if (pos>=0) {
            String s = getString(startLine,startPos,currentLine,pos);
            s = s.trim();
//System.out.println("Label = '" + s + "'");
            aspFunctions[index].setLabel(s);
            // Get arguments
            aspFunctions[index].setArguments(getArguments(startLine,pos+1));
            // Now get preceding note
            s = codeFile[startLine-1];
            pos = s.indexOf('\'');
            if (pos>=0) {
                s = s.substring(pos+1);
                aspFunctions[index].setNote(s);
                }
            }
        // Error
        else output("ERROR " + filename + ": No function name " +
                       "found for function starting on line " + (startLine+1));
        }

    /* ---------------------------------------------------------------- */
    /*                                                                  */
    /*                 S C R I P T   F R A G M E N T S                  */
    /*                                                                  */
    /* ---------------------------------------------------------------- */

    /** Count 'script' fragments indicated by a '<SCRIPT' (lower or upper case).
    @param pos the location in the current line from where the search is to
    start.	 */

    private void countScriptFrags(int pos) {
        int tempCurrentLine = currentLine;

        // Loop through file
        int counter = countScriptFrags(0,pos);

        // Dimension data structure
//System.out.println("Number of script fragments = " + counter);
        if (counter>0) {
            scriptFrags = new ScriptStruct[counter];
            for (int i=0;i<counter;i++) scriptFrags[i] = new ScriptStruct();
            }

        // End
        currentLine = tempCurrentLine;
        }

    /**  Recursive process to count number of '<SCRIPT' tags. <P>
    Fraqgment is assumed to start at the beginning of a line.
    @param counter number of '<SCRIPT' tags sofar.
    @param pos the location in the current line from where the search is to
    start.
    @return the updated counter. */

    private int countScriptFrags(int counter, int pos) {
//System.out.println("Look for script, currentLine = " + currentLine);
        int startPos = findString("<script",pos);
//System.out.println("startPos = " + startPos);

        // If found check for subsequent '<SCRIPT' (Repeat). Otherwise return.
        if (startPos==0) return(countScriptFrags(counter+1,startPos+6));
        else return(counter);     // Base case for the recursion
        }

    /** Finds script fragments.
    @param pos the location in the current line from where the search is to
    start.  */

    private void findScriptFrags(int pos) {
        int tempCurrentLine = currentLine;

        // Search
        int startIndex = 0;
        findScriptFragStart(pos,startIndex);

        // End
        currentLine = tempCurrentLine;
        }

    /** Finds start of script fragment indicated by a '<SCRIPT ...'. <P>
    Fraqgment is assumed to start at the beginning of a line.
    @param pos the location in the current line from where the search is to
    start.
    @param index the current index into the links array.  */

    private void findScriptFragStart(int pos, int index) {
//System.out.println("findScriptFragStart: pos = " + pos + ", index = " +
//index + ", currentLine = " + currentLine);
        int startPos = findString("<script",pos);
//System.out.println("findScriptFragStart: startPos = " + startPos + ", currentLine = " + currentLine);
        // Check if found
        if (startPos==0) {
            // Found start of script fragment (block)
            int startLine = currentLine;
            int endPos    = findChar('>',startPos+1);
            // If found '>' get contents and check that includes 'type'.
            if (endPos>=0) {
                 String s = getString(startLine,startPos+7,currentLine,endPos);
                 String tempS = s.toLowerCase().trim();
                 int i1 = tempS.indexOf("type");
                 int i2 = tempS.indexOf("language");
//System.out.println("tempS = " + tempS + ", i1 = " + i1 + ", i2 = " +i2);
                 // If found update structure
                 scriptFrags[index].setStartLineNum(startLine,endPos);
                 if (i1==0) scriptFrags[index].setScriptType(getValue(s));
                 if (i2==0) scriptFrags[index].setScriptLanguage(getValue(s));
                findScriptFragEnd(endPos+1,index);
                }
            else output("ERROR " + filename + ": No '>' paired " +
                             "with '<SCRIPT' on line " + (startLine+1) + "!");
            }
        }

    /** Finds end of script fragment indicated by a '</SCRIPT>'.
    @param pos the location in the current line from where the search is to
    start.
    @param index the current index into the links array.  */

    private void findScriptFragEnd(int pos, int index) {
        int endPos = findString("</script>",pos);

        // If found cupdate structure abd repeate
        if (endPos>=0) {
//System.out.println("findScriptFragEnd: endPos = " + endPos + ", currentLine = " + currentLine);
            scriptFrags[index].setEndLineNum(currentLine,endPos);
            findScriptFragStart(endPos+1,index+1);
            }
        // Otherwise no closing tag found
        else output("ERROR " + filename + ": No closing " +
        	        "'</SCRIPT>' found for script block starting on line " +
                               (aspFrags[index].getStartLineNum()+1) + "!");
        }

    /* ---------------------------------------------------------------------- */
    /*                                                                        */
    /*              C O U N T   S C R I P T   F U N C T I O N S               */
    /*                                                                        */
    /* ---------------------------------------------------------------------- */

    /* Java script function name() { }
       VBScript function name     end function. */

    /** Commences process of counting the number of functions in identified
    scripts and dimensioning the script functions afrray. <P>Functions may be
    VBScript of JavaScript functions. */

    private void countScriptFunctions() {
        int tempCurrentLine = currentLine;
        int counter = 0;

        // Loop through identified script fragments
        for (int i=0;i<scriptFrags.length;i++) {
            // Get script type
            int startLine   = scriptFrags[i].getStartLineNum();
            int startPos    = scriptFrags[i].getStartPos();
            int endLine     = scriptFrags[i].getEndLineNum();
            int endPos      = scriptFrags[i].getEndPos();
            // Check type, e.g. "text/Javascript"
            String type     = scriptFrags[i].getScriptType();
            type            = type.toLowerCase();
            String language = scriptFrags[i].getScriptLanguage();
            language        = language.toLowerCase();
//System.out.println("type = '" + type + "'");
            if (type.equals("text/javascript") ||
                                               language.equals("javascript")) {
                counter = countFunctionsJS(counter,startLine,endLine);
                }
            // otherwise check language, if VBScript then 'function name ...
            // end function' format.
            else if (language.equals("vbscript")) {
                counter = countFunctions(counter,startLine,startPos,
                                                               endLine,endPos);
                }
            else output("ERROR " + filename + ": Unrecognised" +
                              " type or language in script starting on line " +
                                          (startLine+1) + "; type = '" + type +
                                          "', language = '" + language + "'.");
            }

        // Define and populate script functions array
//System.out.println("Num scrtipt functions = " + counter);
        if (counter>0) {
            scriptFunctions = new ScriptFunctionStruct[counter];
            for (int i=0;i<scriptFunctions.length;i++)
                                scriptFunctions[i] = new ScriptFunctionStruct();
            }
        }

    /* ------------ JAVA SCRIPT ------- */

    /** Counts functions in 'function name (arguments) {}' JavaScript format.
    @param counter the asp function count sofar.
    @param startLine the line in the source code where the current .asp
    fragment starts.
    @param endLine the line in the source code where the current .asp
    fragment endss.
    @rerurn the updated count.   */

    private int countFunctionsJS(int counter, int startLine, int endLine) {
        for (int i=startLine;i<endLine;i++) {
            StringTokenizer data = new StringTokenizer(codeFile[i]);
            int numberOfTokens   = data.countTokens();
            if (numberOfTokens>1) {
                String s = data.nextToken().toLowerCase();
                if (s.equals("function")) {
//System.out.println("countFunctionsJS/2");
                    counter++;
                    }
                }
            }

        // End
        return(counter);
        }

    /* ---------------------------------------------------------------------- */
    /*                                                                        */
    /*                    S C R I P T   F U N C T I O N S                     */
    /*                                                                        */
    /* ---------------------------------------------------------------------- */

    /** Commences process of identifing details of functions contained in
    script fragments according to whether theyb are JavaScript or VBScript
    functions. */

    private void idScriptFunctions() {
        int tempCurrentLine = currentLine;
        int index = 0;

        // Loop through identified script fragments
        for (int i=0;i<scriptFrags.length;i++) {
            // Get script type
            int startLine = scriptFrags[i].getStartLineNum();
            int endLine   = scriptFrags[i].getEndLineNum();
            String type     = scriptFrags[i].getScriptType();
            type            = type.toLowerCase();
            String language = scriptFrags[i].getScriptLanguage();
            language        = language.toLowerCase();
            // Java script
            if (type.equals("text/javascript")) index =
                           idScriptFunctionsJS(index,type,startLine,endLine);
            else if (language.equals("javascript")) index =
                       idScriptFunctionsJS(index,language,startLine,endLine);
            // VBScript.
            else if (language.equals("vbscript")) index =
                        idScriptFunctionsVB(index,language,startLine,endLine);
            // Defaulr error
            else output("ERROR " + filename + ": Unrecognised" +
                           " type or language in script starting on line " +
                                       (startLine+1) + "; type = '" + type +
                                       "', language = '" + language + "'.");
            }

        // End
        currentLine = tempCurrentLine;
        }

    /* ---------- JAVA SCRIPT ---------- */

    /** Identify Java Script functions details. (Function name ... End
    Function') in current script fragment.
    @param index the function array index sofar.
    @param type language the 'langage' label, e.g. VBScript.
    @param startLine the line in the source code where the current script
    fragment starts.
    @param endLine the line in the source code where the current .asp
    fragment endss.
    @return the updates index.   */

    private int idScriptFunctionsJS(int index, String type,
                                             int startLine, int endLine) {
        // Loop
        for (int i=startLine;i<endLine;i++) {
             int pos = codeFile[i].indexOf("function");
             if (pos==0) {
//System.out.println("idScriptFunctionsJS/4");
                 if (isCommentedOut(i-1))
                            scriptFunctions[index].setCommentedOutFlag(true);
                 getScriptFunctionDetailsJS(index,type,i,pos+8);
             	 index++;
             	 }
             }

        // End
        return(index);
        }

    /** Gets Java Script script functions details ('function name (argumnents)
    { } ').
    @param index the current function array index.
    @param type the 'type' label, e.g. Java Script.
    @param startLine the line in the source code where the current Java Script
    function starts.
    @param startPos the location in the line in the source code where the
    current .asp fragment starts.*/

    private void getScriptFunctionDetailsJS(int index, String type,
                                             int startLine, int startPos) {
        // Set start of function line number in structure.
        scriptFunctions[index].setStartLineNum(startLine);

        // Try and find '(' starting on current line,this marks end of function
        // name
        currentLine = startLine;
//System.out.println("currentLine = " + currentLine + ", startPos = " + startPos +
//", line = " + codeFile[currentLine] + ",index = " + index);
        int pos = findChar('(',startPos);
//System.out.println("pos = " + pos);
        // If found '(' marking end of function name get name string
        if (pos>=0) {
            String s = getString(startLine,startPos,currentLine,pos);
            s = s.trim();
//System.out.println("Label = '" + s + "'");
            scriptFunctions[index].setLabel(s);
            scriptFunctions[index].setTypeOrLang(type);
            scriptFunctions[index].setArguments(getArguments(startLine,pos+1));
            // Find end line
            int end = findEndOfFunction(startLine);
            scriptFunctions[index].setEndLineNum(end);
            // Now get preceding note
            findPrecedingCommentJS(startLine-1,index);
            }
        // Error
        else output("ERROR " + filename + ": No function name " +
                       "found for function starting on line " + (startLine+1));
        }

    /** Gets the Java Sc ript comment associated with an identified function.
    @param startLine the line number for the code line immediately before the
    identified function.
    @pram index the function array index sofar. */

    private void  findPrecedingCommentJS(int startLine, int index) {
	    // Skip empty line
	    int endLine = findNextNonMTlineBack(startLine);

	    // Check for end comment
	    int endPos = codeFile[endLine].lastIndexOf("*/");

	    // If found find start comment
	    if (endPos<0) return;
	    int i        = endLine;
	    int startPos = 0;
	    for (;i>=0;i--) {
	        startPos = codeFile[i].indexOf("/*");
	        if (startPos>=0) break;
	        }

	    // Get comment string
	    String s = getString(i,startPos+2,endLine,endPos);
	    s = s.trim();
	    scriptFunctions[index].setNote(s);
	    }

    /** Finds the end of a function when dealing with java script.
    @param startLine the line number in the code file where the function of
    interest starts.
    @return the end line number.	*/

    private int findEndOfFunction(int startLine) {
        boolean notStart = false;
        int n = 0;

        for (int i=startLine;i<codeFile.length;i++) {
            String s = codeFile[i];
            for (int j=0;j<s.length();j++) {
                char c = s.charAt(j);
//System.out.println("c = " + c + ", n = " + n);
                if (c=='{') {
                    n++;
                    notStart = true;	// Found first {
//System.out.println("c = " + c + "' n = " + n);
                    }
                if (c=='}') {
                    n--;
//System.out.println("c = " + c + "' n = " + n);
                    }
                // Test
                if (n==0 && notStart) return(i);
                }
            }

        // Default error
        output("ERROR " + filename + ": no end of function " +
        	                  "starting on line " + (startLine+1) + "found!");
        return(startLine);
        }

    /* ----------- VB ------------ */

    /** Gets VBScript script functions details in current script. <P> Foramt
    may be: (i) 'Fuction name ... End Function', or (ii) 'function name(args)
    ... End Function'
    current script fragment.
    @param index the function array index sofar.
    @param type language the 'langage' label, e.g. VBScript.
    @param startLine the line in the source code where the current script
    fragment starts.
    @param endLine the line in the source code where the current .asp
    fragment endss.
    @return the updates index.   */

    private int idScriptFunctionsVB(int index, String typeLang, int startLine,
                                                                int endLine) {
        boolean lookingForEnd = false;
        String[] endFunction  = {"end","function"};

        // Loop
        for (int i=startLine;i<endLine;i++) {
            // Looking for function end
            if (lookingForEnd) {
                if (findStringSequence(endFunction,codeFile[i])) {
                    scriptFunctions[index].setEndLineNum(i);
                    lookingForEnd=false;
                    index++;
                    }
                }
            // Looking for next function
            else {
                String s = codeFile[i].toLowerCase();
                int pos =  s.indexOf("function");
//System.out.println("codeFile[i] = " + codeFile[i] + ", pos = " + pos);
                if (pos==0) {
                    if (isCommentedOut(i-1))
                              scriptFunctions[index].setCommentedOutFlag(true);
//System.out.println("idScriptFunctionsVB/4");
//System.out.println("i = " + i);
                    scriptFunctions[index].setStartLineNum(i);
                    scriptFunctions[index].setTypeOrLang(typeLang);
                    // Get label, may have arguments
                    int endPos = codeFile[i].indexOf('(',pos+8);
                    if (endPos>=0) {
                        s = codeFile[i].substring(pos+8,endPos);
                        s = s.trim();
                        scriptFunctions[index].setLabel(s);
                        scriptFunctions[index].setArguments(getArguments(i,
                                                                endPos+1));
                        }
                    // Otherwise no argumnets
                    else {
                        s = codeFile[i].substring(pos+8);
                        StringTokenizer data = new StringTokenizer(s);
                        int numberOfTokens   = data.countTokens();
                        if (numberOfTokens>0)
                        scriptFunctions[index].setLabel(data.nextToken());
                        }
                    // Find Comment
                    findPrecedingCommentVB(i-1,index);
                    // Reset
                    lookingForEnd=true;
                    }
                }
            }

        // End
        return(index);
        }

    /** Gets the VB script comment associated with an identified function.
    @param line the line number for the code line immediately before the
    identified function.
    @pram index the function array index sofar. */

    private void  findPrecedingCommentVB(int line, int index) {
	    // Skip empty line
	    int endLine = findNextNonMTlineBack(line);
//System.out.println("line = " + line + "' codeFile[endLine] = " + codeFile[endLine]);

	    // Process lines in reverse until no ''' found
	    int startLine=endLine-1;
	    for(;startLine>=0;startLine--) {
//System.out.println("codeFile[startLine] = " + codeFile[startLine] +
//", codeFile[startLine].length() = " + codeFile[startLine].length());
	        if (codeFile[startLine].length()==0) break;
	        if (codeFile[startLine].charAt(0)!='\'') break;
	        }

	    // Get comment
	    String comment = codeFile[startLine+1].substring(1);
	    comment = comment.trim();
	    for (int i = startLine+2;i<=endLine;i++) {
//System.out.println("i = " + i + ", endLine = " + endLine + ", codeFile[i] = " + codeFile[i]);
	          String s = codeFile[i].substring(1);
	          comment = comment+" "+s.trim();
	          }

	    // Set
	    scriptFunctions[index].setNote(comment);
	    }

	/** Gets function arguments if any. <P>Argumdemts are assumed tlo be
	contained bwtween '(' and ')' characters and seperated by a ','
	characters.
	@param startLine the line number in the code file where the opening '('
	has been found.
	@param startPos the position in the "startLined" immediately after the
	opening '('.
    @return list of arguments, or "null" if there are not any. */

	private String[] getArguments(int startLine, int startPos) {
	    // Count arguments
	    int size = countArguments(startLine,startPos);
	    if (size==0) return(null);
	    String[] arguments = new String[size];

	    // Find closing ')' character
	    currentLine = startLine;
	    int endPos = findChar(')',startPos);

	    // Find arguments
	    int index=0;
	    if (endPos>=0) {
	        int endLine = currentLine;
	        String s = getString(startLine,startPos,endLine,endPos);
//System.out.println("s = " + s);
	        // look for ',' characters
	        int i=0;
	        while (true) {
	            int pos = s.indexOf(',',i);
//System.out.println("startpos = " + startPos + ", comma pos = " + pos);
	            if (pos<0) {
	                String arg = s.substring(i,s.length());
	                arg = arg.trim();
	                if (arg.length()>0)
//System.out.println("END '" + arg + "', length = " + arg.length());
                    arguments[index]=arg;
	                break;
	                }
	            String arg = s.substring(i,pos-1);
	            arg = arg.trim();
                arguments[index] = arg;
//System.out.println("'" + arg + "'");
                i=pos+1;
	            }
	        }
	    // Otherwise something has gone wrong but error message already output
	    // during counting

	    // End
	    return(arguments);
	    }

	/** Counts number of arguments associated with identified function.
	@param startLine the line number in the code file where the opening '('
	has been found.
	@param startPos the position in the "startLined" immediately after the
	opening '('.
	@return the number of arguments in the function, or "null". */

	private int countArguments(int startLine, int startPos) {
	    int counter=0;

	    // Find closing ')' character
	    currentLine = startLine;
	    int endPos = findChar(')',startPos);

	    // Find arguments
	    if (endPos>=0) {
	        int endLine = currentLine;
	        String s = getString(startLine,startPos,endLine,endPos);
	        // look for ',' characters
	        int i=0;
	        while (true) {
	            int pos = s.indexOf(',',i);
	            if (pos<0) {
	                String arg = s.substring(i,s.length());
	                arg = arg.trim();
	                if (arg.length()>0) counter++;
	                break;
	                }
	            counter++;
                i=pos+1;
	            }
	        }
	    // Otherwise something has gone wrong
	    else output("ERROR " + filename + ": no closing ')' " +
        	       "characyter found for function on  " + (startLine+1) + "!");

	    // Return
	    return(counter);
	    }

	/* ------ UTILITIES ------ */
	
	/** Determines if function is commented out. <P>A function is commented out 
    if it is preceeded by a <! and there ius no ac companying > before the start 
    of the function. */
    
    private boolean isCommentedOut(int startLine) {
//System.out.println("startLine = " + startLine);
        for (int i=startLine;i>=0;i--) {
            int n = isCommentedOut(codeFile[i]);
            if (n==1) return(true);
            if (n==-1) return(false);
            }
            
        // End
        return(false);
        }
    
    /* Checks given line for an open comment processing it in reverse.
    @param s the given string/line.
    @return 1 if open comment found, -1 if close comment found, 0 if neither. */

    private int isCommentedOut(String s) {
//System.out.println("s = " + s);
        for(int i=s.length()-1;i>=0;i--) {
            if (s.charAt(i)=='>') return(-1);
            if ((s.charAt(i)=='!') && (i>0) && (s.charAt(i-1)=='<')) return(1);
            }

        // Default
        return(0);
        }

    /* ------------------------------------- */
    /*                                       */
    /*         STRING MANIPUILATION          */
    /*                                       */
    /* ------------------------------------- */

    /** Find specified string, e.g. '<A' in code file starting search from
    current line and given position.
    @param searchS the search string.
    @param pos the position on the current line from where the search should
    start.
    @return position of tag or -1 if not found (the line number is held in the
    <TT>currentLine</TT> filed. */

    private int findString(String searchS, int pos) {
        // Check for end of file, if found return -1
        if (currentLine>=codeFile.length) return(-1);

        // Check first line (convert to lower case).
        String s = codeFile[currentLine].substring(pos);
        int startPos = s.toLowerCase().indexOf(searchS);
        // If found return start pos, otherwise increment line
        if (startPos>=0) return(startPos);
        else currentLine++;

        // Continue search
        for (;currentLine<codeFile.length;currentLine++) {
             startPos = codeFile[currentLine].toLowerCase().indexOf(searchS);
             if (startPos>=0) break;
             }

        // End
        return(startPos);
        }

    /** Find specified string, e.g. '<!--' in code file starting search from
    current line and ending on giben end line.
    @param searchS the search string.
    @param endLine line on which search should end.
    @return position of tag or -1 if not found (the line number is held in the
    <TT>currentLine</TT> filed. */

    private int findString2(String searchS, int endLine) {
        // Check for end of file
        if (currentLine>=codeFile.length) return(-1);

        // Check first line
        String s = codeFile[currentLine].substring(0);
        int startPos = s.toLowerCase().indexOf(searchS);
        // If found return start pos, otherwise increment line
        if (startPos>=0) return(startPos);
        else currentLine++;

        // Continue search
        for (;currentLine<=endLine;currentLine++) {
             startPos = codeFile[currentLine].toLowerCase().indexOf(searchS);
             if (startPos>=0) break;
             }

        // End
        return(startPos);
        }

    /** Find a specific start tag, e.g.'<TITLE>,<BODY>, etc., in the document
    and return the position of the end '>' closising operator, or -1 if not
    found.
    @param searchS the tag label (bit between the '<'and '>' operators.
    @param pos the position on the current line from where the search should
    start.
    @return position of the closing '>' operator or -1 if tag not found. */

    private int findStartTag(String searchS, int pos) {
        // Find opening '<'
        int startPos = findChar('<',pos);

        // If found go on to find closing '>'
        if (startPos>=0) {
             int startLine = currentLine;
             int endPos = findChar('>',startPos+1);
             // If found get the tag and test against desired tag, first
             // convert gto lower case and then remove white space from each
             // end if necessary
             if (endPos>=0) {
                 String s = getString(startLine,startPos+1,currentLine,endPos);
//System.out.println("s = " + s);
                 s = s.toLowerCase();
                 s = s.trim();
                 if (s.equalsIgnoreCase(searchS)) return(endPos);
                 else return(findStartTag(searchS,endPos));
                 }
             }

        // Defualt error return
        return(-1);
        }

    /** find a specific end tag in the document and return the position of the
    end '<' opening operator, or -1 if not foond.
    @param searchS the tag label (bit between the '<'and '>' operators).
    @param pos the position on the current line from where the search should
    start.
    @return position of the opening '<' operator or -1 if tag not found. */

    private int findEndTag(String searchS, int pos) {
        // Find opening '<'
        int startPos = findChar('<',pos);

        // If found go on to find closing '>'
        if (startPos>=0) {
             int startLine = currentLine;
             int endPos = findChar('>',startPos+1);
             // If found get the tag and test against desired tag.
             if (endPos>=0) {
                 String s = getString(startLine,startPos+1,currentLine,endPos);
                 s = s.toLowerCase();
                 s = s.trim();
                 if (s.equalsIgnoreCase(searchS)) return(startPos);
                 else return(findEndTag(searchS,endPos));
                 }
             }

        // Defualt error return
        return(-1);
        }

    /** Gets string located beween indicated locations in code file.
    @param startLine the line number where the search should start from.
    @param startPos the location in the strat line where the search should
    start from.
    @param endLine the line number at which the search should end.
    @param endPos the location in the end line where the search should end.   */

    private String getString(int startLine,int startPos, int endLine,
                                                                  int endPos) {
        String s;
//System.out.println("startLine = " + startLine + ", startPos = " + startPos +
//", endLine = " + endLine + ", endPos = " + endPos);
        // String on one line
        if (startLine==endLine) s = codeFile[startLine].substring(startPos,
                                                                       endPos);

        // Otherwise process
        else {
            s = codeFile[startLine].substring(startPos);
            for (int i=startLine+1;i<endLine;i++) {
                s = s+codeFile[i]+" ";
                }
            s = s + codeFile[endLine].substring(0,endPos);
            }

        // Return
        return(s);
        }

    /** Find given character in code File starting search fron given position
    in the line number indicated by the currentLine field.
    @param c the charcter we rae looking for.
    @param the location in the current line from where the serch should begin.
    @return the position in the line where the charcter is found. */

    private int findChar(char c, int startPos) {
//if (c=='<') System.out.println("c = '" + c + "', startPos = " + startPos +
//", currentLine = " + currentLine + ", codeFile.length = " + codeFile.length);
        // Check for end of input file
        if (currentLine>=codeFile.length) return(-1);

        // Get char on current line starting seatch from value contained in
        // startPos
        int pos=findChar(c,codeFile[currentLine],startPos);
//if (c=='<') {
//System.out.println("line = " + codeFile[currentLine] + ", startPos = " + startPos);
//System.out.println("First line pos = " + pos);
//}
        // If not found continue with next lines (if any)
        if (pos<0) {
            currentLine++;
            // Loop through rest lof file if not found
            for (;currentLine<codeFile.length;currentLine++) {
                pos = findChar(c,codeFile[currentLine]);
                if (pos>=0) break;
                }
            }

        // Return
        return(pos);
        }

    /** Find given character in given string.
    @param c the charcter we rae looking for.
    @param s the straing to be searched.
    @return the position of the character in the string or -1 if not found.  */

    private int findChar(char c, String s) {
        for (int i=0;i<s.length();i++) if (s.charAt(i)==c) return(i);

        // Failed
        return(-1);
        }

    /** Find given character in given string starting search from given
    position.
    @param c the charcter we rae looking for.
    @param s the straing to be searched.
    @param pos the position in the string from where the search is to start.
    @return the position of the character in the string or -1 if not found.  */

    private int findChar(char c, String s, int pos) {
        for (int i=pos;i<s.length();i++) if (s.charAt(i)==c) return(i);

        // Failed
        return(-1);
        }

    /** Steps through input file from given line until a non-empty line is
    found.
    @param n the line number from where the serach is to start.\
    @return the line number where a non emty line is found or -1 if not
    found. */

    private int findNextNonMTline(int n) {
        boolean found = false;

        // Loop
        int i=n;
        for (;i<codeFile.length;i++) {
            // Tokenize
            StringTokenizer data = new StringTokenizer(codeFile[i]);
            int numberOfTokens   = data.countTokens();
            if (numberOfTokens>0) {
                found = true;
                break;
                }
            }

        // End
        if (found) return(i);
        else return(-1);
        }

    /** Steps backwards through input file from given line until a non-empty
    line is found.
    @param n the line number from where the serach is to start.
    @return the line number where a non emty line is found or the given line
    if not found. */

    private int findNextNonMTlineBack(int n) {
        boolean found = false;

        // Loop
        int i=n;
        for (;i<codeFile.length;i--) {
            // Tokenize
            StringTokenizer data = new StringTokenizer(codeFile[i]);
            int numberOfTokens   = data.countTokens();
            if (numberOfTokens>0) {
                found = true;
                break;
                }
            }

        // End
        if (found) return(i);
        else return(n);
        }

    /** Attempts to find the given word sequence (case sensative) in the given
    string.
    @param searchStr the sequence of words (strings) being looked for in the
    given string.
    @param s the given string.
    @return true if found and false otherwise. */

    private boolean findStringSequence(String[] searchStr, String s) {
        boolean found = false;
//System.out.println("searchStr[0] = " + searchStr[0] + ", s = " + s);
        // Tokenize
        StringTokenizer data = new StringTokenizer(s);
        int numberOfTokens   = data.countTokens();

        // Find first element in search string
        int i=0;
        for (;i<numberOfTokens;i++) {
            String s1 = data.nextToken().toLowerCase();
            if (searchStr[0].equals(s1)) {
                found=true;
                break;
                }
            }

        // If found check for rest of search string
        if (found) {
            if (numberOfTokens<searchStr.length) found=false;
            else {
                for (int j=1;j<searchStr.length;j++) {
                    String s1 = data.nextToken().toLowerCase();
//System.out.println("s1 = " + s1 + ", searchStr = " + searchStr[j]);
                    if (!s1.equals(searchStr[j])) {
                        found=false;
                        break;
                        }
                    else found = true;
                    }
                }
            }

        // End
        return(found);
        }

    /** Try to extract value between start and end quote in the given string.
    <P<Typical example were this might be done is to find the link associated
    with a HREF tag or an argument to a scripot tag. First attempt assumes
    it is contained in between quotes, second attempt assumes it is betweem '='
    and ending '>', otherwise default label.
    @param s the imput string containing HREF tag
    @return the idebtified label or a defualt label.  */

    private String getValue(String s) {
        boolean noQuotes=true;
        String label = "No label!";
//System.out.println("getValue: s = " + s);
        // Get start quote
        int startPos = s.indexOf('"');
//System.out.println("startPos = " + startPos);

        // If found start quote search for end quote
        if (startPos>=0) {
            // find second quote
            int endPos = s.lastIndexOf('"');
//System.out.println("endPos = " + endPos);
            // If found extract label.
            if (endPos>=0) {
                label    = s.substring(startPos+1,endPos);
                noQuotes = false;
//System.out.println("label = " + label);
                }
            }

        // If not found bad HTMl, but try and identify label anyway
        if (noQuotes) {
            startPos = s.indexOf('=');
            if (startPos>=0) {
                label = s.substring(startPos+1);
                s = s.trim();
                }
            }

       // Return
       return(label);
       }

    /** Checks in the given string for less than and greater thans and replaces
    with "&lt;" and "&gt;" sequences.
    @param s the given string.
    @return the new string. 	*/

    private String checkForSpecialChars(String s) {
        s = s.replaceAll("<","&lt;");
        s = s.replaceAll(">","&gt;");

        // End
        return(s);
        }

    /* ------------------------------------------------------- */
    /*                                                         */
    /*                  FILE HANDLING UTILITIES                */
    /*                                                         */
    /* ------------------------------------------------------- */

    /** Gets the number of lines in the indicated input file.
    @param fNmae the name of the input file.
    @return the bumber of lines.		*/

    private int getNumberOfLines(String fName) {
        // Open the file
	    openInputFile(fName);

        // Get number of lines and return
        return(getNumberOfLines());
        }

    /** Gets the number of lines in the indicated input file path.
    @param fNmae the name of the input file.
    @return the bumber of lines.		*/

    private int getNumberOfLines(File fName) {
        // Open the file
	    openInputFile(fName);

        // Get number of lines and return
        return(getNumberOfLines());
        }

    /** Continues process of getting the number of lines in the input file.
    @return the bumber of lines. */

    private int getNumberOfLines() {
        int counter=0;

        // Loop through file
        try {
	        String line;
	        while (true) {
                line = fileInput.readLine();
	            if (line==null) break;
	            else counter++;
	            }
            }
        catch(NullPointerException e) {
	        closeInputFile();
            }
	    catch(IOException e) {
	        closeInputFile();
	        }

        // Return
        return(counter);
        }

    /** Read given file and store in codeFile.
    @param fNmae the name of the input file. */

    private void readInputFile(String fName) {
        // Open the file
	    openInputFile(fName);

	    // Read
	    readInputFile();
	    }

    /** Read given file (indicated by file path) and store in codeFile.
    @param fNmae the name of the input file path. */

    private void readInputFile(File fName) {
        // Open the file
	    openInputFile(fName);

	    // Read
	    readInputFile();
	    }

    /** Continues process of reading input filde. */

    private void readInputFile() {
        // Loop through file
        try {
	        String line;
	        for (int i=0;i<codeFile.length;i++) {
                codeFile[i]=fileInput.readLine();
                }
            }
        catch(NullPointerException e) {
	        closeInputFile();
            }
	    catch(IOException e) {
	        closeInputFile();
	        }
        }

    /** Opens input file using fileName (instance field).
    @param nameOfFile the filename of the file to be opened. */

    protected void openInputFile(String nameOfFile) {
	    try {
	        // Open file
	        FileReader file = new FileReader(nameOfFile);
	        fileInput = new BufferedReader(file);
	        }
	    catch(IOException ioException) {
	        JOptionPane.showMessageDialog(null,"Error Opening File \"" +
	    		               nameOfFile + "\"","FILE INPUT ERROR",
			                         JOptionPane.ERROR_MESSAGE);
	        System.exit(1);
	        }
	    }

    /** Opens input file using filePath (instance field).
    @param nameOfFile the file path of the file to be opened. */

    protected void openInputFile(File nameOfFile) {
	    try {
	        // Open file
	        FileReader file = new FileReader(nameOfFile);
	        fileInput = new BufferedReader(file);
	        }
	    catch(IOException ioException) {
	        JOptionPane.showMessageDialog(null,"Error Opening File \"" +
	    		               nameOfFile + "\"","FILE INPUT ERROR",
			                         JOptionPane.ERROR_MESSAGE);
	        System.exit(1);
	        }
	    }

    /** Closes input file. */

    private void closeInputFile() {
        if (fileInput != null) {
	        try {
	    	    fileInput.close();
		        }
	        catch (IOException ioException) {
	            JOptionPane.showMessageDialog(this,"Error Opening File",
			             "Error 4: ",JOptionPane.ERROR_MESSAGE);
	            }
	        }
	    }

    /* ---------------------------- */
    /*                              */
    /*         SET METHODS          */
    /*                              */
    /* ---------------------------- */

    /** sets the list of file paths field by copying the given list.
    @param fPaths the given list of file p;aths.	*/

    public void setFilePaths(File[] fPaths) {
        filePaths = new File[fPaths.length];

        // Loop
        for (int i=0;i<fPaths.length;i++) filePaths[i] = fPaths[i];
        }

    /** Sets text area field.
    @param tArea the given instanvce of the clas JTecxtArea. */

    public void setTextArea(JTextArea tArea) {
        textArea = tArea;
        }

    /** Sets output links flag to the given value.
    @param v the given boolean value. */

    public void setOutputLinksFlag(boolean v) {
        outputLinksFlag = v;
        }

    /** Sets output ASP blocks flag to the given value.
    @param v the given boolean value. */
    
    public void setOutputASPblocksFlag(boolean v) {
        outputASPblocksFlag = v;
        }
        
    /** Sets output ASP functions flag to the given value. 
    @param v the given boolean value. */
    
    public void setOutputASPfuncsFlag(boolean v) {
        outputASPfuncsFlag = v;
        }
        
    /** Sets output Script blocks flag to the given value. 
    @param v the given boolean value. */
    
    public void setOutputScriptBlocksFlag(boolean v) {
        outputScriptBlocksFlag =  v;
        }
        
    /** Sets output Script functions flag to the given value. 
    @param v the given boolean value. */
    
    public void setOutputScriptFuncsFlag(boolean v) {
         outputScriptFuncsFlag =  v;
        }
        
    /* -------------------------- */
    /*                            */
    /*         UTILITIES          */
    /*                            */
    /* -------------------------- */

    /** Reset fields */

    private void resetFields() {
         // Input output fields.
         fileInput      = null;
         outputFileName = null;
         fileOutput     = null;

         // Data structures
         codeFile        = null;
         links           = null;
         aspFrags        = null;
         aspFunctions    = null;
         scriptFrags     = null;
         scriptFunctions = null;

         // Other fields
         currentLine  = 0;
         title        = null;
         startComment = null;
         }

    /* ------------------------------------- */
    /*                                       */
    /*            OUTPUT METHODS             */
    /*                                       */
    /* ------------------------------------- */
    
    /** Outputs message to text area or terminal window.
    @param s the given message. */
    
    private void output(String s) {
        if (textArea!=null) textArea.append(s + "\n");
        else System.out.println(s);
        }
        
    /** Commences process of saving the generated ARM data to file by preparing
    the output file ready for writing.
    @param fileName the name of the input file that has been processed.
    @param index the index of the current input file in the file array.  */

    private void output(String fileName, int index) {
        // Open output file
	    if (openOutputFile(fileName)) {
	        outputToFile(fileName,index);
            // End by closing file
	        fileOutput.close();
            }
        }

    /** Opens the output file for the generated ARM data set.
    @param fileName the name of the input file that has been processed.
    @return true if file succesfully opened, and false otherwise. */

    private boolean openOutputFile(String fileName) {
        String outputFileName = getOutputFileName(fileName);

        // Proceed
	    try {
	        fileOutput = new PrintWriter(new FileWriter(outputFileName));
	        return(true);
	        }
	    catch(IOException ioException) {
	        JOptionPane.showMessageDialog(this,"Error opening File",
			                     "Error",JOptionPane.ERROR_MESSAGE);
      	    return(false);
	        }
	    }

    /** Generates name of output file from input file name.
    @param fileName the name of the input file that has been processed.
    @return the name of the output file. */

    private String getOutputFileName(String fileName) {
        String outputFileName = null;
        
        // Remolve post fix
        int pos = findChar('.',fileName);
        if (pos>=0) outputFileName = fileName.substring(0,pos);
        else outputFileName = fileName;

        // Return
        return(outputFileName + "Doc.html");
        }

    /** Generates name of output file from input file path.
    @param fileName the name of the input file that has been processed.
    @return the name of the output file. */

    private String getOutputFileName(File filePath) {
        String outputFileName = null;
        String filename       = filePath.toString();
        
        // Remove path
        int pos = filename.lastIndexOf('/');			// Linux, MacOS
        if (pos<0) pos = filename.lastIndexOf('\\');	// Windows
        if (pos>=0) filename = filename.substring(pos+1);
        
        // Remolve post fix
        pos = findChar('.',filename);
        if (pos>=0) outputFileName = filename.substring(0,pos);
        else outputFileName = filename;
//System.out.println("filename = " + filename + ", outputFileName = " +  outputFileName);

        // Return
        return(outputFileName + "Doc.html");
        }

    /** Starts output.
    @param fileNmae the name of the file being documented.
    @param index the index of the current input file in the file array. */

    private void outputToFile(String fileName, int index) {
        outputTitle(fileName,index);
        
        //  Set heading countrer 
        int counter=1;
        
        // Links
        if (outputLinksFlag) {
            outputLinks(counter);
            counter++;
            }
            
        // ASP blocks 
        if (outputASPblocksFlag) {
            outputASPfrags(counter);
            counter++;
            }
            
        // ASP functions
        if (outputASPfuncsFlag) {
            outputASPfunctions(counter);
            counter++;
            }
            
        // Script blocks 
        if (outputScriptBlocksFlag) {
            outputScriptFrags(counter);
            counter++;
            }
            
        // Script functions 
        if (outputScriptFuncsFlag) {
            outputScriptFunctions(counter);
            counter++;
            }
            
        // End
        outputEnd();
        }

    /** Outputs HTMLheader.
    @param fileNmae the name of the file being documented. */

    private void outputHeader(String fileName) {
        fileOutput.println("<HTML>\n<HEAD>\n<TITLE>" + fileName +
                    " Documentation </TITLE>\n</HEAD>\n<BODY BGCOLOR=#CCFFF>");
        }

    /** Outputs title of documentation WWW page.
    @param fileNmae the name of the file being documented.
    @param index the index of the current input file in the file array.	 */
        
    private void outputTitle(String fileName, int index) {
        // Start box
        fileOutput.println("<CENTER><TABLE BORDER = 0 cellpadding = 10 " +
        	"WIDTH=\"100%\">\n<TR><TD BGCOLOR = 990000>");
        fileOutput.println("<CENTER><TABLE BORDER = 0 cellpadding = 10 " +
        	"WIDTH=\"90%\">\n<TR BGCOLOR = 33CCFF><TD>\n");
        
        // Start heading box
        fileOutput.println("<CENTER><TABLE><TR>\n<TD><CENTER>\n<H1>\"" + fileName +
                                                      "\" DOCUMENTATION</H1>");

        // Add title if anu (from '<TITEL>' tag
        if (title!=null) fileOutput.println("<H1>(" + title + ")</H1>");
        fileOutput.println("</CENTER></TD>\n</TABLE></CENTER>\n");
        
        // End box
        fileOutput.println("</TD></TABLE></CENTER>\n</TD></TABLE></CENTER>\n");

        // Add links to associated pages.
        outputText(index);

        // Add start comments if any and end
        if (startComment!=null) fileOutput.println("<P>" + startComment +
                                                               "</P>\n");
        fileOutput.println("<BR><HR><BR>");
        }

    /** Output associated links.
    @param index the index of the current input file in the file array.*/

    private void outputText(int index) {
        // Check for only one file
        if (fileNames!=null && fileNames.length==1) return;
        if (filePaths!=null && filePaths.length==1) return;

        // Start
        fileOutput.print("<P>");
        
        if (fileNames!=null) outputText1(index);
        else if (filePaths!=null) outputText2(index);
        else output("ERROR: Both file names and file paths lists are emty!");
        
        // End
        fileOutput.println(".</P>\n");
        }
        
    /** Continues process of outpoutting text (file names).
    @param index the index of the current input file in the file array. */
    
    private void outputText1(int index) {
        // Before current file
        int counter=0;
        for (int i=0;i<index;i++) {
            String outputFileName = getOutputFileName(fileNames[i]);   
            if (counter>0) fileOutput.println(",");
            fileOutput.print("<A HREF = \"" + outputFileName + "\">" +
                                                   outputFileName + "</A>");
            counter++;
            }

        // After current file
        for (int i=index+1;i<fileNames.length;i++) {
            String outputFileName = getOutputFileName(fileNames[i]);
            if (counter>0) fileOutput.println(",");
            fileOutput.print("<A HREF = \"" + outputFileName + "\">" +
                                                   outputFileName + "</A>");
            counter++;
            }
        }
        
    /** Continues process of outpoutting text (file pathss).
    @param index the index of the current input file in the file array. */
    
    private void outputText2(int index) {
        // Before current file
        int counter=0;
        for (int i=0;i<index;i++) {
            String outputFileName = getOutputFileName(filePaths[i]);   
            if (counter>0) fileOutput.println(",");
            fileOutput.print("<A HREF = \"" + outputFileName + "\">" +
                                                   outputFileName + "</A>");
            counter++;
            }

        // After current file
        for (int i=index+1;i<filePaths.length;i++) {
            String outputFileName = getOutputFileName(filePaths[i]);
            if (counter>0) fileOutput.println(",");
            fileOutput.print("<A HREF = \"" + outputFileName + "\">" +
                                                   outputFileName + "</A>");
            counter++;
            }
        }

    /** Outputs link set. */

    private void outputLinks(int counter) {
        // Start section
        fileOutput.println("<TABLE BORDER-=0 WIDTH=\"100%\" CELLPADDING=5 " +
            	"BGCOLOR=\"990000\">\n<TR><TD><H2><font color = \"white\">" +
        	           "<H2>" + counter + ". LINKS</H2></font></H2></TD>\n" +
                                                           "</TABLE><BR>\n");

        // Check for no links
        if (links==null) {
            fileOutput.println("<P>No links found.</P>\n" +
            		                               "<BR><HR><BR>\n");
            return;
            }
            
        // Start table
        fileOutput.println("<CENTER>\n<TABLE BORDER=\"2\" CELLPADDING=5 " +		
        								              "BGCOLOR = FFFFCC>");
        fileOutput.println("<TR BGCOLOR = 99CCCC><TH>Line Number</TH>" +
        					                              "<TH>Link</TH>");

        // Loop
        for(int i=0;i<links.length;i++) {
            fileOutput.println(links[i]);
            }

        // End table
        fileOutput.println("</TABLE>\n</CENTER>\n<BR><HR><BR>\n");
        }

    /** Outputs ASP code fragment/nloch details in a three column format. */

    private void outputASPfrags(int counter) {
        // Start section
        fileOutput.println("<TABLE BORDER-=0 WIDTH=\"100%\" CELLPADDING=5 " +
        	    "BGCOLOR=\"990000\">\n<TR><TD><H2><font color = \"white\">" +
        	 "<H2>" + counter + ". ASP CODE BLOCKS</H2></font></H2></TD>\n" +
        	                                               "</TABLE><BR>\n");
        
        // Check for no.asp fragments
        if (aspFrags==null) {
            fileOutput.println("<P>No .asp fragmemnts found.</P>\n" +
            		                               "<BR><HR><BR>\n");
            return;
            }
        
        // Calculate lines per columm
        int linesPerCol = aspFrags.length/3;
        double tempN    = ((double) aspFrags.length/3.0) - linesPerCol;
        int leftOver    = (int) (tempN*10);
//System.out.println("linesPerCol = "  + linesPerCol + ", leftOver " + leftOver);

        // Start table pallet for column output
        fileOutput.println("<CENTER>\n<TABLE BORDER=\"0\"");
        fileOutput.println("<TR>");

        // Start column output
        int index=0;
        for (int i=1;i<4;i++) {
            fileOutput.println("<TD>");
            index = outputASPfrags(index,linesPerCol,i,leftOver);
            fileOutput.println("</TD>");
            }

        // End table
        fileOutput.println("</TABLE>\n</CENTER>\n<BR><HR><BR>\n");
        }
        

    /** Output a column of .asp block details. Uses a test value (3 or 6) for
    the left over quantity to be compared with to determine if an extra line
    needs to be addeed to the column where the number of fragments is not
    exactly divisible by three.
    @param index the current index into the sap fragmentarray.
    @param linesPerColumn the number of ;ines to output.
    @param colNum the current cilumn number: 1, 2 or 3.
    @param leftOver the left over quantity; 3 = first column only, 6 = first
    two columns.
    @retutn the new index. */

    private int outputASPfrags(int index, int linesPerColumn, int colNum,
                                                                int leftOver) {
        // Output header
        if (linesPerColumn>0) outputASPtableHeadings();
        else {
            if (leftOver==3 && colNum==1) outputASPtableHeadings();
            else if (leftOver==6 && colNum<3) outputASPtableHeadings();
            else return(index);
            }

        // Output main body of colunm
        for (int i=0;i<linesPerColumn;i++) {
            fileOutput.println(aspFrags[index]);
            index++;
            }

        // Output left over
        if (leftOver==3) {
            if (colNum==1) {
                fileOutput.println(aspFrags[index]); index++;
                }
            else fileOutput.println("<TR><TD><PRE> </PRE></TD>" +
                                 "<TD><PRE> </PRE></TD><TD><PRE> </PRE></TD>");
            }
        else if (leftOver==6) {
            if (colNum<3) {
                fileOutput.println(aspFrags[index]); index++;
                }
            else fileOutput.println("<TR><TD><PRE> </PRE></TD>" +
                                 "<TD><PRE> </PRE></TD><TD><PRE> </PRE></TD>");
            }

        // End and return
        fileOutput.println("</TABLE>\n</CENTER>\n");
        return(index);
        }

    /** Outputs .asp table heading. */

    private void outputASPtableHeadings() {
        fileOutput.println("<CENTER>\n<TABLE BORDER=\"2\" CELLPADDING=5 " +		
        								              "BGCOLOR = FFFFCC>");
        fileOutput.println("<TR BGCOLOR = 99CCCC><TH>Start line</TH>" +
                                  "<TH>End line</TH><TH>Description</TH>");
        }

    /** Output .asp functions. */

    private void outputASPfunctions(int counter) {
        // Start section
        fileOutput.println("<TABLE BORDER-=0 WIDTH=\"100%\" CELLPADDING=5 " +
        	    "BGCOLOR=\"990000\">\n<TR><TD><H2><font color = \"white\">" +
        	   "<H2>" + counter + ". ASP FUNCTIONS</H2></font></H2></TD>\n" + 
        	                                               "</TABLE><BR>\n");

        // If no functions comment and retutn
        if (aspFunctions==null){
            fileOutput.println("<P>No .asp functions found.</P>\n" +
            		                               "<BR><HR><BR>\n");
            return;
            }
            
        // Start table
        fileOutput.println("<CENTER>\n<TABLE BORDER=\"2\" CELLPADDING=5 " +		
        								              "BGCOLOR = FFFFCC>");
        fileOutput.println("<TR BGCOLOR = 99CCCC><TH>Start line</TH>" +
                    "<TH>End line</TH><TH>Name</TH><TH>Description</TH>");

        // Loop
        for(int i=0;i<aspFunctions.length;i++) 
                                          fileOutput.println(aspFunctions[i]);

        // End table
        fileOutput.println("</TABLE>\n</CENTER>\n<BR><HR><BR>\n");
        }
        
    /** Outputs script code fragment/bloch details in a three column format. */

    private void outputScriptFrags(int counter) {
        // Start section
        fileOutput.println("<TABLE BORDER-=0 WIDTH=\"100%\" CELLPADDING=5 " +
             	"BGCOLOR=\"990000\">\n<TR><TD><H2><font color = \"white\">" +
        	   "<H2>" + counter + ". SCRIPT BLOCKS</H2></font></H2></TD>\n" +
        	                                               "</TABLE><BR>\n");
        
        // Check for no.asp fragments
        if (scriptFrags==null) {
            fileOutput.println("<P>No script blocks found.</P>\n" +
            		                               "<BR><HR><BR>\n");
            return;
            }
        
        
        // Start table
        fileOutput.println("<CENTER>\n<TABLE BORDER=\"2\" CELLPADDING=5 " +		
        								              "BGCOLOR = FFFFCC>");
        fileOutput.println("<TR BGCOLOR = 99CCCC><TH>Start line</TH>" +
                        "<TH>End line</TH><TH>Type</TH><TH>Language</TH>");

        // Loop
        for(int i=0;i<scriptFrags.length;i++) {
            fileOutput.println(scriptFrags[i]);
            }

        // End table
        fileOutput.println("</TABLE>\n</CENTER>\n<BR><HR><BR>\n");
        }

    /** Output script functions. */

    private void outputScriptFunctions(int counter) {
        // Start section
        fileOutput.println("<TABLE BORDER-=0 WIDTH=\"100%\" CELLPADDING=5 " +
        	    "BGCOLOR=\"990000\">\n<TR><TD><H2><font color = \"white\">" +
        	"<H2>" + counter + ". SCRIPT FUNCTIONS</H2></font></H2></TD>\n" +
        	                                               "</TABLE><BR>\n");

        // If no functions comment and retutn
        if (scriptFunctions==null){
            fileOutput.println("<P>No script fragmemnts found.</P>\n" +
            		                               "<BR><HR><BR>\n");
            return;
            }
            
        // Start table
        fileOutput.println("<CENTER>\n<TABLE BORDER=\"2\" CELLPADDING=5 " +		
        								              "BGCOLOR = FFFFCC>");
        fileOutput.println("<TR BGCOLOR = 99CCCC><TH>Start line</TH>" +
                             "<TH>End line</TH><TH>Type or Language</TH>" + 
                                     "<TH>Name</TH><TH>Description</TH>");

        // Loop
        for(int i=0;i<scriptFunctions.length;i++) 
                                        fileOutput.println(scriptFunctions[i]);

        // End table
        fileOutput.println("</TABLE>\n</CENTER>\n<BR><HR><BR>\n");
        }
        
    /** Outputs end. */

    private void outputEnd() {
        fileOutput.println("<P>Produced by documentation generator code " +
                    "developed as part of the Transglobal KTP project " +
                    "(October 2007).</P>");
        fileOutput.println("</BODY>\n</HEAD>");
        }
    }