1. package org.jr.text;

  2. 

  3. /**

  4.  * Copyright: Copyright (c) 2002-2004

  5.  * Company: JavaResearch(http://www.javaresearch.org)

  6.  * 最后更新日期:2004年11月30日

  7.  * @author Cherami

  8.  */

  9. 

  10. import java.io.*;

  11. import java.util.*;

  12. import org.jr.util.*;

  13. 

  14. /**

  15.  * 将java源代码转换为HTML格式并且可以设置风格的工具类。

  16.  * 这个类应该是一个可以反复使用的类，不需生成太多的类实例。

  17.  * 用完以后重新设置其他的风格就可以继续使用。

  18.  * 一般情况下构造完一个实例后要设置需要的参数，否则虽然对代码进行了处理，但是没有任何效果。

  19.  * 当然也可以启用默认模式。

  20.  * @since  0.5

  21.  */

  22. 

  23. public class JavaToHTML {

  24.   public static final int NONTYPE = -1;

  25.   public static final int WORD = 0;

  26.   public static final int QUOTE = 1;

  27.   public static final int LINE_COMMENT = 2;

  28.   public static final int COMMENT = 3;

  29.   protected static final TreeSet defaultReservedWords = TreeSetUtil.

  30.       ArrayToTreeSet(StringUtil.split("abstract,break,byte,boolean,catch,case,class,char,continue,default,double,do,else,extends,false,final,float,for,finally,if,import,implements,int,interface,instanceof,long,length,native,new,null,package,private,protected,public,final,return,switch,synchronized,short,static,super,try,true,this,throw,throws,threadsafe,transient,void,volatile,while"));

  31.   protected static final TreeSet defaultClassNames = ClassUtil.getAllClassname();

  32.   protected static final HTMLStyle defaultReservedWordsStyle = new HTMLStyle(

  33.       "<b><font color='#0000ff'>",

  34.       "</font></b>");

  35.   protected static final HTMLStyle defaultCommentStyle = new HTMLStyle(

  36.       "<i><font color='#339900'>", "</font></i>");

  37.   protected static final HTMLStyle defaultClassNameStyle = new HTMLStyle(

  38.       "<font color='#ff0000'>", "</font>");

  39.   protected static final HTMLStyle defaultQuoteStyle = new HTMLStyle(

  40.       "<font color='#ff33ff'>", "</font>");

  41.   protected TreeSet reservedWords;

  42.   protected TreeSet classNames;

  43.   protected HTMLStyle reservedWordsStyle;

  44.   protected HTMLStyle commentStyle;

  45.   protected HTMLStyle classNameStyle;

  46.   protected HTMLStyle quoteStyle;

  47.   protected int currentType = NONTYPE;

  48.   protected boolean showLineNumber = true;

  49. 

  50.   protected String currentLine;

  51.   protected int currentIndex;

  52.   protected ArrayList importedClasses=new ArrayList();

  53.   protected boolean writePre=true;

  54. 

  55.   private final static int HEAD = 0;

  56.   private final static int LINE = 1;

  57.   private final static int END = 2;

  58. 

  59.   private static String LINE_SEPARATOR=Constants.LINE_SEPARATOR;

  60.   /**

  61.    * 构造一个JavaToHTML。

  62.    * @since  0.5

  63.    */

  64.   public JavaToHTML() {

  65.     reservedWords = new TreeSet();

  66.     classNames = new TreeSet();

  67.     reservedWordsStyle = new HTMLStyle();

  68.     commentStyle = new HTMLStyle();

  69.     classNameStyle = new HTMLStyle();

  70.     quoteStyle = new HTMLStyle();

  71.   }

  72. 

  73.   /**

  74.    * 根据指定的参数构造一个JavaToHTML。

  75.    * @param useDefault 是否使用缺省设置

  76.    * @since  0.5

  77.    */

  78.   public JavaToHTML(boolean useDefault) {

  79.     if (useDefault == true) {

  80.       useDefaultSet();

  81.     }

  82.     else {

  83.       reservedWords = new TreeSet();

  84.       classNames = new TreeSet();

  85.       reservedWordsStyle = new HTMLStyle();

  86.       commentStyle = new HTMLStyle();

  87.       classNameStyle = new HTMLStyle();

  88.       quoteStyle = new HTMLStyle();

  89.     }

  90.   }

  91. 

  92.   /**

  93.    * 设置使用转换器的缺省设置。

  94.    * @since  0.5

  95.    */

  96.   public void useDefaultSet() {

  97.     reservedWords = defaultReservedWords;

  98.     classNames = defaultClassNames;

  99.     reservedWordsStyle = defaultReservedWordsStyle;

  100.     commentStyle = defaultCommentStyle;

  101.     classNameStyle = defaultClassNameStyle;

  102.     quoteStyle = defaultQuoteStyle;

  103.   }

  104. 

  105.   /**

  106.    * 设置是否显示行号。

  107.    * @param lineNumberVisible 是否显示行号，true的时候显示行号

  108.    * @since  0.5

  109.    */

  110.   public void setLineNumberVisible(boolean lineNumberVisible) {

  111.     showLineNumber = lineNumberVisible;

  112.   }

  113. 

  114.   /**

  115.    * 设置保留字。

  116.    * @param reservedWords 保留字

  117.    * @since  0.5

  118.    */

  119.   public void setReservedWords(TreeSet reservedWords) {

  120.     this.reservedWords = reservedWords;

  121.   }

  122. 

  123.   /**

  124.    * 设置已知类的类名。

  125.    * @param classNames 已知类的类名

  126.    * @since  0.5

  127.    */

  128.   public void setClassNames(TreeSet classNames) {

  129.     this.classNames = classNames;

  130.   }

  131. 

  132.   /**

  133.    * 设置保留字的风格。

  134.    * @param reservedWordsStyle 保留字的风格

  135.    * @since  0.5

  136.    */

  137.   public void setReservedWordsStyle(HTMLStyle reservedWordsStyle) {

  138.     this.reservedWordsStyle = reservedWordsStyle;

  139.   }

  140. 

  141.   /**

  142.    * 设置注释的风格。

  143.    * @param commentStyle 注释的风格

  144.    * @since  0.5

  145.    */

  146.   public void setCommentStyle(HTMLStyle commentStyle) {

  147.     this.commentStyle = commentStyle;

  148.   }

  149. 

  150.   /**

  151.    * 设置已知类名的风格。

  152.    * @param classNameStyle 已知类名的风格

  153.    * @since  0.5

  154.    */

  155.   public void setClassNameStyle(HTMLStyle classNameStyle) {

  156.     this.classNameStyle = classNameStyle;

  157.   }

  158. 

  159.   /**

  160.    * 设置字符串的风格。

  161.    * @param quoteStyle 字符串的风格

  162.    * @since  0.5

  163.    */

  164.   public void setQuoteStyle(HTMLStyle quoteStyle) {

  165.     this.quoteStyle = quoteStyle;

  166.   }

  167.   

  168.   

  169. 

  170.   /**

  171.    * 设置是否将代码的输出用<PRE>标签包含起来。

  172.    * @param writePre true则用<PRE>标签包含

  173.    */

  174.   public void setWritePre(boolean writePre) {

  175.     this.writePre = writePre;

  176.   }

  177.   /**

  178.    * 将HTML标签的'<'和'>'转换为对应的转义文本"<"和">"。

  179.    * @param source 原始文本

  180.    * @return 转换后的结果

  181.    * @since  0.5

  182.    */

  183.   public static String escapeHTMLtag(String source) {

  184.     String result = source.replaceAll("<", "<");

  185.     result = result.replaceAll(">", ">");

  186.     return result;

  187.   }

  188. 

  189.   /**

  190.    * 将单词转换为具有风格的结果。

  191.    * 在0.6版中，根据java2html项目的要求提高此方法的访问权限为protected便于子类覆盖。

  192.    * @param word 原始的单词

  193.    * @return 转换后的结果

  194.    * @since  0.5

  195.    */

  196.   protected String convertWord(String word) {

  197.     if (reservedWords.contains(word)) {

  198.       return reservedWordsStyle.getBegin() + word + reservedWordsStyle.getEnd();

  199.     }

  200.     else if (classNames.contains(word)) {

  201.       return classNameStyle.getBegin() + word + classNameStyle.getEnd();

  202.     }

  203.     else {

  204.       return word;

  205.     }

  206.   }

  207. 

  208.   /**

  209.    * 将一行内容转换为具有风格的内容。

  210.    * @param line 一行文本

  211.    * @return 转换后的结果

  212.    */

  213.   private String convertLine(String line) {

  214.     if (line.length() == 0) {

  215.       return "";

  216.     }

  217.     addImportedContent(line);

  218.     currentLine=line;

  219.     StringBuffer lineBuffer = new StringBuffer(line.length() * 2);

  220.     StringBuffer wordBuffer = new StringBuffer();

  221.     int start = 0;

  222.     int end = line.length() - 1;

  223.     char[] contents = line.toCharArray();

  224.     //循环判断一行中的最后一个字符前的字符状况

  225.     for (int i = start; i < end; i++) {

  226.       //如果没有当前类型

  227.       if (currentType == NONTYPE) {

  228.         //如果是合法的java字符开始标识符则将类型设置为单词类型并将当前字符添加到单词缓冲区

  229.         if (Character.isJavaIdentifierStart(contents[i])) {

  230.           currentType = WORD;

  231.           wordBuffer.append(contents[i]);

  232.           continue;

  233.         }

  234.         //如果是可能的注释开始

  235.         else if (contents[i] == '/') {

  236.           char nextChar = contents[i + 1];

  237.           switch (nextChar) {

  238.             //如果下一个字符是'*'则表明是多行注释，将类型设置为多行字符并添加对应的字体颜色及字符

  239.             case '*':

  240.               currentType = COMMENT;

  241.               lineBuffer.append(commentStyle.getBegin());

  242.               lineBuffer.append(contents[i]);

  243.               continue;

  244.               //如果下一个字符是'/'则表明是单行注释，添加对应的字体颜色并直接取字符串的剩余内容

  245.             case '/':

  246.               lineBuffer.append(commentStyle.getBegin());

  247.               lineBuffer.append(line.substring(i));

  248.               lineBuffer.append(commentStyle.getEnd());

  249.               return lineBuffer.toString();

  250.               //不是注释的开始则直接添加内容

  251.             default:

  252.               lineBuffer.append(contents[i]);

  253.               continue;

  254.           }

  255.         }

  256.         //如果是双引号

  257.         else if (contents[i] == '\"') {

  258.           //如果是最开始的位置或者其前一个字符不是'\'则表明是一个引用的开始，设置类型并添加对应的字体颜色及字符

  259.           if (i == 0 || contents[i - 1] != '\\') {

  260.             currentType = QUOTE;

  261.             lineBuffer.append(quoteStyle.getBegin());

  262.             lineBuffer.append(contents[i]);

  263.             continue;

  264.           }

  265.           //否则不是引用的内容，添加内容

  266.           else {

  267.             lineBuffer.append(contents[i]);

  268.             continue;

  269.           }

  270.         }

  271.         //如果不是以上情况则表明是其他的杂项内容，不进行处理，将字符添加到缓冲区

  272.         else {

  273.           lineBuffer.append(contents[i]);

  274.           continue;

  275.         }

  276.       }

  277.       //如果当前类型是单词

  278.       else if (currentType == WORD) {

  279.         //如果是一个java标识符的合法部分表明单词没有结束，将当前字符添加到单词缓冲区

  280.         if (Character.isJavaIdentifierPart(contents[i])) {

  281.           wordBuffer.append(contents[i]);

  282.           continue;

  283.         }

  284.         //否则表明单词结束，将单词缓冲区的内容进行转换并添加到缓冲区并继续判断后面部分的语法成分

  285.         else {

  286.           currentIndex=i-wordBuffer.length();

  287.           lineBuffer.append(convertWord(wordBuffer.toString()));

  288.           wordBuffer = new StringBuffer();

  289.           //如果是可能的注释开始

  290.           if (contents[i] == '/') {

  291.             char nextChar = contents[i + 1];

  292.             switch (nextChar) {

  293.               //如果下一个字符是'*'则表明是多行注释，将类型设置为多行字符并添加对应的字体颜色及字符

  294.               case '*':

  295.                 currentType = COMMENT;

  296.                 lineBuffer.append(commentStyle.getBegin());

  297.                 lineBuffer.append(contents[i]);

  298.                 continue;

  299.                 //如果下一个字符是'/'则表明是单行注释，添加对应的字体颜色并直接取字符串的剩余内容

  300.               case '/':

  301.                 lineBuffer.append(commentStyle.getBegin());

  302.                 lineBuffer.append(line.substring(i));

  303.                 lineBuffer.append(commentStyle.getEnd());

  304.                 currentType = NONTYPE;

  305.                 return lineBuffer.toString();

  306.             }

  307.           }

  308.           //如果是双引号则表明是一个引用的开始，设置类型并添加对应的字体颜色及字符

  309.           else if (contents[i] == '\"') {

  310.             currentType = QUOTE;

  311.             lineBuffer.append(quoteStyle.getBegin());

  312.             lineBuffer.append(contents[i]);

  313.             continue;

  314.           }

  315.           //如果不是以上情况则表明是其他的杂项内容，不进行处理，将字符添加到缓冲区

  316.           else {

  317.             currentType = NONTYPE;

  318.             lineBuffer.append(contents[i]);

  319.             continue;

  320.           }

  321.         }

  322.       }

  323.       //如果当前类型是引用

  324.       else if (currentType == QUOTE) {

  325.         //如果当前字符不是引号或者如果是引号但是他的前一个字符是'\'则表明是引用的内容，添加内容

  326.         if (contents[i] != '\"' || contents[i - 1] == '\\') {

  327.           lineBuffer.append(contents[i]);

  328.           continue;

  329.         }

  330.         //否则表明是引用的结束，添加内容并结束字体设置

  331.         else {

  332.           lineBuffer.append(contents[i]);

  333.           lineBuffer.append(quoteStyle.getEnd());

  334.           currentType = NONTYPE;

  335.           continue;

  336.         }

  337.       }

  338.       //如果当前类型是多行注释

  339.       else if (currentType == COMMENT) {

  340.         //如果是第一个字符则表明是多行注释的继续的一行，添加字体设置

  341.         if (i == 0) {

  342.           lineBuffer.append(commentStyle.getBegin());

  343.         }

  344.         //如果当前字符是'/'并且他的前一个字符是'*'则表明是注释的结束，添加内容并结束字体设置

  345.         if (contents[i] == '/' && i != 0 && contents[i - 1] == '*') {

  346.           lineBuffer.append(contents[i]);

  347.           lineBuffer.append(commentStyle.getEnd());

  348.           currentType = NONTYPE;

  349.           continue;

  350.         }

  351.         //否则表明不是注释的结束，添加内容

  352.         else {

  353.           lineBuffer.append(contents[i]);

  354.           continue;

  355.         }

  356.       }

  357.     }

  358.     //对最后一个字符进行处理并结束本行的转换

  359.     char endChar = contents[end];

  360.     //如果是没有任何类型，最后一个字符不能构成任何特殊类，直接添加内容

  361.     if (currentType == NONTYPE) {

  362.       lineBuffer.append(endChar);

  363.       return lineBuffer.toString();

  364.     }

  365.     //如果是单词

  366.     else if (currentType == WORD) {

  367.       //如果最后一个字符是标识符的一部分，添加内容并结束风格设置

  368.       if (Character.isJavaIdentifierPart(endChar)) {

  369.         wordBuffer.append(endChar);

  370.         currentIndex=line.length()-wordBuffer.length();

  371.         lineBuffer.append(convertWord(wordBuffer.toString()));

  372.         wordBuffer = new StringBuffer();

  373.       }

  374.       //否则表明单词已经结束，转换单词后作为普通内容添加。

  375.       else {

  376.         currentIndex=line.length()-wordBuffer.length()-1;//XXXXXX

  377.         lineBuffer.append(convertWord(wordBuffer.toString()));

  378.         wordBuffer = new StringBuffer();

  379.         lineBuffer.append(endChar);

  380.       }

  381.       currentType = NONTYPE;

  382.       return lineBuffer.toString();

  383.     }

  384.     //如果是引用，由于字符串不能跨行，因此结束字符串引用不会有问题。

  385.     else if (currentType == QUOTE) {

  386.       lineBuffer.append(endChar);

  387.       lineBuffer.append(quoteStyle.getEnd());

  388.       currentType = NONTYPE;

  389.       return lineBuffer.toString();

  390.     }

  391.     else {

  392.       //如果最后一个字符是'/'并且他的前一个字符是'*'则表明是注释的结束，添加内容并结束字体设置

  393.       if (endChar == '/' && contents[end - 1] == '*') {

  394.         lineBuffer.append(endChar);

  395.         lineBuffer.append(commentStyle.getEnd());

  396.         currentType = NONTYPE;

  397.       }

  398.       //否则表明不是注释的结束，添加内容

  399.       else {

  400.         lineBuffer.append(endChar);

  401.         lineBuffer.append(commentStyle.getEnd());

  402.       }

  403.       return lineBuffer.toString();

  404.     }

  405. 

  406.   }

  407.   

  408.   public static void setLineSeparater(String lineSeparator) {

  409.     LINE_SEPARATOR=lineSeparator;

  410.   }

  411. 

  412.   /**

  413.    * 将指定的缓冲阅读器中的内容读出进行转换并将转换后的结果写入记录器。

  414.    * 之所以需要缓冲阅读器是因为在内部是以行为单位进行处理的。

  415.    * @param reader 阅读器

  416.    * @param writer 记录器

  417.    * @since  0.5

  418.    */

  419.   public void convert(BufferedReader reader, Writer writer) {

  420.     try {

  421.       importedClasses.removeAll(importedClasses);

  422.       if (writePre) {

  423.         writer.write("<pre>");

  424.       }

  425.       writeLineNumber(writer, HEAD);

  426.       String line = reader.readLine();

  427.       while (line != null) {

  428.         writeLineNumber(writer, LINE);

  429.         writer.write(convertLine(escapeHTMLtag(line)));

  430.         writer.write(LINE_SEPARATOR);

  431.         line = reader.readLine();

  432.       }

  433.       writeLineNumber(writer, END);

  434.       if (writePre) {

  435.         writer.write("</pre>");

  436.       }

  437.     }

  438.     catch (IOException e) {

  439. 

  440.     }

  441.   }

  442. 

  443.   /**

  444.    * 记录器写入行号控制部分。

  445.    * @param writer 记录器

  446.    * @param type 行号控制类型

  447.    * @throws IOException

  448.    */

  449.   private void writeLineNumber(Writer writer, int type) throws IOException {

  450.     if (showLineNumber == true) {

  451.       switch (type) {

  452.         case HEAD:

  453.           writer.write("<ol>");

  454.           break;

  455.         case LINE:

  456.           writer.write("<li>");

  457.           break;

  458.         case END:

  459.           writer.write("</ol>");

  460.           break;

  461.       }

  462.     }

  463.   }

  464. 

  465.   private void addImportedContent(String line) {

  466.     if (line.length() == 0) {

  467.       return;

  468.     }

  469.     line=line.trim();

  470.     if (line.startsWith("import ")) {

  471.       StringBuffer buffer=new StringBuffer();

  472.       boolean hasStart=false;

  473.       for (int i="import ".length();i<line.length();i++) {

  474.         char c=line.charAt(i);

  475.         if (hasStart==false) {

  476.           if (Character.isJavaIdentifierStart(c)) {

  477.             buffer.append(c);

  478.             hasStart=true;

  479.           } else {

  480.             continue;

  481.           }

  482.         } else {

  483.           if (Character.isJavaIdentifierPart(c)||c=='.') {

  484.             buffer.append(c);

  485.           } else {

  486.             break;

  487.           }

  488.         }

  489.       }

  490.       if (hasStart) {

  491.         importedClasses.add(buffer.toString().replace('.','/'));

  492.       }

  493.     }

  494. 

  495.   }

  496. }