サンプル集  >  Java  >  JavaソースをHTML文書に変換
JavaソースをHTML文書に変換
2005/05/08

入力ファイルを全て読み込み出力ファイルに書き込みます。

1行の文字列を検査し、以下のポイントにHTMLタグを挿入します。

行コメント
(//で始まるコメント)
開始 // <SPAN class='comFont'>
終了 改行 </SPAN>
範囲コメント
(/*で始まるコメント)
開始 /* <SPAN class='comFont'>
終了 */ </SPAN>
文字列@
("(ダブルクォート)で始まる文字列)
開始 " <SPAN class='strFont'>
終了 " </SPAN>
文字列A
('(シングルクォート)で始まる文字列)
開始 ' <SPAN class='strFont'>
終了 ' </SPAN>

以下の変換を行います。

  • 「<」を「&lt;」
  • 「>」を「&gt;」

挿入するHTMLタグがオンコーディングになっている為、このままでは使いずらいと思います。。。

改善していきたいですね。

◆環境
OS Windows 2000 Professional
J2SE SDK 1.4.2.05

JSrc2HTML.java
  1: 
  2: 
  3: 
  4: 
  5: 
  6: 
  7: 
  8: 
  9: 
 10: 
 11: 
 12: 
 13: 
 14: 
 15: 
 16: 
 17: 
 18: 
 19: 
 20: 
 21: 
 22: 
 23: 
 24: 
 25: 
 26: 
 27: 
 28: 
 29: 
 30: 
 31: 
 32: 
 33: 
 34: 
 35: 
 36: 
 37: 
 38: 
 39: 
 40: 
 41: 
 42: 
 43: 
 44: 
 45: 
 46: 
 47: 
 48: 
 49: 
 50: 
 51: 
 52: 
 53: 
 54: 
 55: 
 56: 
 57: 
 58: 
 59: 
 60: 
 61: 
 62: 
 63: 
 64: 
 65: 
 66: 
 67: 
 68: 
 69: 
 70: 
 71: 
 72: 
 73: 
 74: 
 75: 
 76: 
 77: 
 78: 
 79: 
 80: 
 81: 
 82: 
 83: 
 84: 
 85: 
 86: 
 87: 
 88: 
 89: 
 90: 
 91: 
 92: 
 93: 
 94: 
 95: 
 96: 
 97: 
 98: 
 99: 
100: 
101: 
102: 
103: 
104: 
105: 
106: 
107: 
108: 
109: 
110: 
111: 
112: 
113: 
114: 
115: 
116: 
117: 
118: 
119: 
120: 
121: 
122: 
123: 
124: 
125: 
126: 
127: 
128: 
129: 
130: 
131: 
132: 
133: 
134: 
135: 
136: 
137: 
138: 
139: 
140: 
141: 
142: 
143: 
144: 
145: 
146: 
147: 
148: 
149: 
150: 
151: 
152: 
153: 
154: 
155: 
156: 
157: 
158: 
159: 
160: 
161: 
162: 
163: 
164: 
165: 
166: 
167: 
168: 
169: 
170: 
171: 
172: 
173: 
174: 
175: 
176: 
177: 
178: 
179: 
180: 
181: 
182: 
183: 
184: 
185: 
186: 
187: 
188: 
189: 
190: 
191: 
192: 
193: 
194: 
195: 
196: 
197: 
198: 
199: 
200: 
201: 
202: 
203: 
204: 
205: 
206: 
207: 
208: 
209: 
210: 
211: 
212: 
213: 
214: 
215: 
216: 
217: 
218: 
219: 
220: 
221: 
222: 
223: 
224: 
225: 
226: 
227: 
228: 
229: 
230: 
231: 
232: 
233: 
234: 
235: 
236: 
237: 
238: 
239: 
240: 
241: 
242: 
243: 
244: 
245: 
246: 
247: 
248: 
249: 
250: 
251: 
252: 
253: 
254: 
255: 
256: 
257: 
258: 
259: 
260: 
261: 
262: 
263: 
264: 
265: 
266: 
267: 
268: 
269: 
270: 
271: 
272: 
273: 
274: 
275: 
276: 
277: 
278: 
279: 
280: 
281: 
282: 
283: 
284: 
285: 
286: 
287: 
288: 
289: 
290: 
291: 
292: 
293: 
294: 
295: 
296: 
297: 
298: 
299: 
300: 
301: 
302: 
303: 
304: 
305: 
306: 
307: 
308: 
309: 
310: 
311: 
312: 
313: 
314: 
315: 
316: 
317: 
318: 
319: 
320: 
321: 
322: 
323: 
324: 
325: 
326: 
327: 
328: 
329: 
330: 
331: 
332: 
333: 
334: 
335: 
336: 
337: 
338: 
339: 
340: 
341: 
342: 
343: 
344: 
345: 
346: 
347: 
348: 
349: 
350: 
351: 
352: 
353: 
354: 
355: 
356: 
357: 
358: 
359: 
360: 
361: 
362: 
363: 
364: 
365: 
366: 
367: 
368: 
369: 
370: 
371: 
372: 
373: 
374: 
375: 
376: 
377: 
378: 
379: 
380: 
381: 
382: 
383: 
384: 
385: 
386: 
387: 
388: 
389: 
390: 
391: 
392: 
393: 
394: 
395: 
396: 
397: 
398: 
399: 
400: 
401: 
402: 
403: 
404: 
405: 
406: 
407: 
408: 
409: 
410: 
411: 
412: 
413: 
414: 
415: 
416: 
417: 
418: 
419: 
420: 
421: 
422: 
423: 
424: 
425: 
426: 
427: 
428: 
429: 
430: 
431: 
432: 
433: 
434: 
435: 
436: 
437: 
438: 
439: 
package ym.file;

import java.io.*;

/**
 * JavaソースをHTML文書に変換。<BR>
 * 2005/05/01 新規作成<BR>
 * @author ymlib.com
 * @version 1.0
 */

public class JSrc2HTML
{
    /**
     * コンストラクタ。<BR>
     * @since 1.0
     */

    public JSrc2HTML()
    {
    }

    /**
     * 入力ファイルを全て読み込み出力ファイルに書き込みます。<BR>
     * <BR>
     * 1行の文字列を検査し、以下のポイントにHTMLタグを挿入し
     * ます。<BR>
     * ・行コメント(//で始まるコメント)開始/終了時<BR>
     * ・範囲コメント(/*で始まるコメント)開始/終了時<BR>
     * ・文字列@("(ダブルクォート)で始まる文字列)開始/終
     * 了時<BR>
     * ・文字列A('(シングルクォート)で始まる文字列)開始/
     * 終了時<BR>
     * <BR>
     * 以下の変換を行います。<BR>
     * 「<」を「&amp;lt;」<BR>
     * 「>」を「&amp;gt;」<BR>
     * @param strInFileName 入力ファイル名
     * @param strOutFileName 出力ファイル名
     * @throws java.io.IOException 入出力例外が発生した場合
     * @since 1.0
     */

    public void chgJSrc2HTML( String strInFileName
                            , String strOutFileName )
        throws IOException
    {
        // 入力ファイル
        File           inf   = null;
        FileReader     infr  = null;
        BufferedReader inbr  = null;

        // 出力ファイル
        File           outf  = null;
        FileWriter     outfw = null;
        BufferedWriter outbw = null;

        Long lFileSize = null;     // 入力ファイルサイズ

        char   cBuf;               // 処理中の1文字
        int    i;                  // カウンタ

        StringBuffer sbNewLine = new StringBuffer();
                           // 編集結果格納

        String strLine   = null;
                           // ファイルから読み込んだ1行

        boolean bSFlg    = false;
                           // 1文字目の「/」を発見したら true
                           // それ以外は false

        boolean bAFlg    = false;
                           // 1文字目の「*」を発見したら true
                           // それ以外は false

        boolean bEcsFlg  = false;
                           // エスケープ文字かどうかを判断する
                           // 1文字目の「\」発見したら true
                           // それ以外は false

        int     bComType = 0;
                           // コメントの種別を設定
                           // 0:コメント中ではない
                           // 1:行コメント
                           // 2:範囲コメント

        int     bStrType = 0;
                           // 文字列の種別を設定
                           // 0:文字列中ではない
                           // 1:「"」による文字列(文字列@)
                           // 2:「'」による文字列(文字列A)

        // 入力ファイルの準備
        inf  = new File( strInFileName );
        infr = new FileReader( inf );
        inbr = new BufferedReader( infr );

        // 出力ファイルの準備
        outf  = new File( strOutFileName );
        outfw = new FileWriter( outf );
        outbw = new BufferedWriter( outfw );

        //=======================================================
        // ファイル全体の処理
        //=======================================================
        while( true )
        {
            // 読み込み開始位置をマーク
            lFileSize = new Long( inf.length() );
            inbr.mark( lFileSize.intValue() + 1 );

            // ファイルから1行読み込む
            strLine = inbr.readLine();

            // 編集結果格納変数を初期化
            sbNewLine.delete( 0, sbNewLine.length() );

            //===================================================
            // 1行の処理
            //===================================================
            for ( i = 0; i < strLine.length(); i++ )
            {
                // 1文字抜き出す
                cBuf = strLine.charAt( i );

                // 1文字の処理
                switch( cBuf )
                {
                  case '<':
                    bSFlg   = false;
                    bAFlg   = false;
                    bEcsFlg = false;
                    sbNewLine.append( "&lt;" );
                    break;
                  case '>':
                    bSFlg   = false;
                    bAFlg   = false;
                    bEcsFlg = false;
                    sbNewLine.append( "&gt;" );
                    break;
                  case '/':
                    if ( bSFlg )
                    {
                        // 2個めの「/」を発見
                        if ( bComType == 1      // 行コメント中
                          || bComType == 2      // 範囲コメント中
                          || bStrType == 1      // 文字列中
                          || bStrType == 2 )    // 文字列中
                        {
                            // コメント中、文字列中なら普通の文字
                            // として扱う
                            bSFlg    = false;
                            bAFlg    = false;
                            bEcsFlg  = false;
                            sbNewLine.append( cBuf );
                        }
                        else
                        {
                            // 行コメント開始
                            bSFlg    = false;
                            bAFlg    = false;
                            bEcsFlg  = false;
                            bComType = 1;       // 行コメント
                            sbNewLine.insert(
                                  sbNewLine.length() - 1
                                , "<SPAN class='comFont'>" );
                            sbNewLine.append( cBuf );
                        }
                    }
                    else if ( bAFlg )
                    {
                        // 「*」に続く「/」を発見
                        if ( bComType == 1        // 行コメント中
                          || bStrType == 1        // 文字列中
                          || bStrType == 2 )      // 文字列中
                        {
                            // コメント中、文字列中なら普通の文字
                            // として扱う
                            bSFlg    = false;
                            bAFlg    = false;
                            bEcsFlg  = false;
                            sbNewLine.append( cBuf );
                        }
                        else if ( bComType == 2 )
                            // 範囲コメント中
                        {
                            // 範囲コメント中なら範囲コメントを
                            // 終了
                            bSFlg    = false;
                            bAFlg    = false;
                            bEcsFlg  = false;
                            bComType = 0;       // コメント終了
                            sbNewLine.append( cBuf );
                            sbNewLine.append( "</SPAN>" );
                        }
                        else
                        {
                            // いきなり「*/」が現れた場合、
                            // 普通の文字として扱う
                            bSFlg    = false;
                            bAFlg    = false;
                            bEcsFlg  = false;
                            sbNewLine.append( cBuf );
                        }
                    }
                    else
                    {
                        // 1個めの「/」を発見
                        bSFlg   = true;
                        bAFlg   = false;
                        bEcsFlg = false;
                        sbNewLine.append( cBuf );
                    }
                    break;
                  case '*':
                    if ( bSFlg )
                    {
                        // 「/」に続く「*」を発見
                        if ( bComType == 1      // 行コメント中
                          || bComType == 2      // 範囲コメント中
                          || bStrType == 1      // 文字列中
                          || bStrType == 2 )    // 文字列中
                        {
                            // コメント中、文字列中なら普通の文字
                            // として扱う
                            bSFlg    = false;
                            bAFlg    = false;
                            bEcsFlg  = false;
                            sbNewLine.append( cBuf );
                        }
                        else
                        {
                            // 範囲コメント開始
                            bSFlg    = false;
                            bAFlg    = false;
                            bEcsFlg  = false;
                            bComType = 2;       // 範囲コメント
                            sbNewLine.insert(
                                  sbNewLine.length() - 1
                                , "<SPAN class='comFont'>" );
                            sbNewLine.append( cBuf );

                        }
                    }
                    else
                    {
                        // 1個めの「*」を発見
                        bSFlg   = false;
                        bAFlg   = true;
                        bEcsFlg = false;
                        sbNewLine.append( cBuf );
                    }
                    break;
                  case '\\':
                    if ( bEcsFlg )
                    {
                        // 2個目のエスケープ文字
                        // エスケープ終了
                        bSFlg   = false;
                        bAFlg   = false;
                        bEcsFlg = false;
                        sbNewLine.append( cBuf );
                    }
                    else
                    {
                        // 1個めの「\」を発見
                        bSFlg   = false;
                        bAFlg   = false;
                        bEcsFlg = true;
                        sbNewLine.append( cBuf );
                    }
                    break;
                  case '\"':
                    if ( bEcsFlg )
                    {
                        // エスケープされていた場合、
                        // 普通の文字として扱う
                        bSFlg   = false;
                        bAFlg   = false;
                        bEcsFlg = false;
                        sbNewLine.append( cBuf );
                    }
                    else if ( bComType == 1    // 行コメント中
                           || bComType == 2    // 範囲コメント中
                           || bStrType == 2 )  // 文字列中
                    {
                        // コメント中、文字列中なら普通の文字
                        // として扱う
                        bSFlg    = false;
                        bAFlg    = false;
                        bEcsFlg  = false;
                        sbNewLine.append( cBuf );
                    }
                    else
                    {
                        if ( bStrType == 1 )
                        {
                            // 文字列の終わり
                            bSFlg    = false;
                            bAFlg    = false;
                            bEcsFlg  = false;
                            bStrType = 0;
                            sbNewLine.append( cBuf );
                            sbNewLine.append( "</SPAN>" );
                        }
                        else
                        {
                            // 文字列の開始
                            bSFlg    = false;
                            bAFlg    = false;
                            bEcsFlg  = false;
                            bStrType = 1;
                            sbNewLine.append(
                                "<SPAN class='strFont'>" );
                            sbNewLine.append( cBuf );
                        }
                    }
                    break;
                  case '\'':
                    if ( bEcsFlg )
                    {
                        // エスケープされていた場合、
                        // 普通の文字として扱う
                        bSFlg   = false;
                        bAFlg   = false;
                        bEcsFlg = false;
                        sbNewLine.append( cBuf );
                    }
                    else if ( bComType == 1    // 行コメント中
                           || bComType == 2    // 範囲コメント中
                           || bStrType == 1 )  // 文字列中
                    {
                        // コメント中、文字列中なら普通の文字
                        // として扱う
                        bSFlg    = false;
                        bAFlg    = false;
                        bEcsFlg  = false;
                        sbNewLine.append( cBuf );
                    }
                    else
                    {
                        if ( bStrType == 2 )
                        {
                            // 文字列の終わり
                            bSFlg    = false;
                            bAFlg    = false;
                            bEcsFlg  = false;
                            bStrType = 0;
                            sbNewLine.append( cBuf );
                            sbNewLine.append( "</SPAN>" );
                        }
                        else
                        {
                            // 文字列の開始
                            bSFlg    = false;
                            bAFlg    = false;
                            bEcsFlg  = false;
                            bStrType = 2;
                            sbNewLine.append(
                                "<SPAN class='strFont'>" );
                            sbNewLine.append( cBuf );
                        }
                    }
                    break;
                  default:
                    bSFlg   = false;
                    bAFlg   = false;
                    bEcsFlg = false;
                    sbNewLine.append( cBuf );
                    break;
                }
            }  // 1行の処理

            // 行コメント中の場合、行が終わったら
            // 終了タグを付加する
            if ( bComType == 1 )
            {
                bComType = 0;       // コメント終了
                sbNewLine.append( "</SPAN>" );
            }

            // 行をまたいだ文字列は終了したものとみなす
            switch( bStrType )
            {
              case 1:
                bStrType = 0;       // 文字列@終了
                sbNewLine.append( "</SPAN>" );
                break;
              case 2:
                bStrType = 0;       // 文字列A終了
                sbNewLine.append( "</SPAN>" );
                break;
              default:
                break;
            }

            // ファイルへ書き込み
            outbw.write( sbNewLine.toString() );

            // ファイルの終端に達しているかチェック
            if ( inbr.ready() )
            {
                // 終端に達していない場合
                outbw.newLine();
            }
            else
            {
                // 終端に達した
                // 終端が「改行⇒EOF」だったのか
                // 「EOFのみ」だったのかを判断する

                // 読み込み開始位置へ戻す
                inbr.reset();

                // 読み込んだ文字数分進める
                inbr.skip( strLine.length() );

                // 1文字読み込む
                if ( inbr.read() != -1 )
                {
                    // 読み込めた場合、
                    // 終端は「改行⇒EOF」と判断
                    outbw.newLine();
                }
                break;
            }

        }  // ファイル全体の処理

        // 入出力ファイルをクローズする
        inbr.close();
        outbw.close();

        System.out.println(
            "入力:[" + strInFileName  + "] "
                      + inf.length()   + "(バイト)" );
        System.out.println(
            "出力:[" + strOutFileName + "] "
                      + outf.length()  + "(バイト)" );
    }
}

JSrc2HTMLTest.java
 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
package ym.test;

import java.io.*;
import ym.file.*;

/**
 * JSrc2HTMLのテスト。<BR>
 * 2005/05/01 新規作成<BR>
 * @author ymlib.com
 * @version 1.0
 */

public class JSrc2HTMLTest
{
    /**
     * main関数<BR>
     * @param args 起動時パラメータ<BR>
     * [0]:入力ファイル名<BR>
     * [1]:出力ファイル名<BR>
     * @since 1.0
     */

    public static void main( String args[] )
    {
        try
        {
            // JSrc2HTMLクラスの生成
            JSrc2HTML jsh = new JSrc2HTML();

            // 変換
            jsh.chgJSrc2HTML( args[0], args[1] );
        }
        catch ( IOException ioe )
        {
            ioe.printStackTrace();
        }
    }
}

◆実行結果
>java ym.test.JSrc2HTMLTest JSrc2HTML.java JSrc2HTML.html
入力:[JSrc2HTML.java]  15886(バイト)
出力:[JSrc2HTML.html]  19757(バイト)

▲ PageTop  ■ Home


Copyright (C) 2012 ymlib.com