Quartett!的文本提取程序

诶，之前写了这个程序却没有发出来，结果自己差点找不到了。幸好在笔记本的某个不起眼的角落里又见到了它啊 T T

这个程序用于从*.tkn脚本文件中提取“文本”（text=之后的项）。对应的ScriptInserter那时没写……

提取出来的文本像这样：
[quote]135
<FONT size=22 face='G'><TYPE interval=100% speed=700 style='Wave'>心配だな～
167
<TYPE interval=60>お兄ちゃん<BR>...<TYPE interval=55>ほんとに大丈夫なの？
170
<FONT size=16><TYPE interval=60>今日のクリスマス・ミサには...<BR>毎年..たくさんの人が来るんだよ[/quote]

一行原始行号，一行文本。行号是用于校验用的。

ScriptExtractor.cs

// ScriptExtracter.cs, 2008/01/13
// by RednaxelaFX

/*
 * Copyright (c) 2008 著作权由RednaxelaFX所有。著作权人保留一切权利。
 * 
 * 这份授权条款，在使用者符合以下三条件的情形下，授予使用者使用及再散播本
 * 软件包装原始码及二进位可执行形式的权利，无论此包装是否经改作皆然：
 * 
 * * 对于本软件源代码的再散播，必须保留上述的版权宣告、此三条件表列，以
 *   及下述的免责声明。
 * * 对于本套件二进位可执行形式的再散播，必须连带以文件以及／或者其他附
 *   于散播包装中的媒介方式，重制上述之版权宣告、此三条件表列，以及下述
 *   的免责声明。
 * * 未获事前取得书面许可，不得使用RednaxelaFX之名称，
 *   来为本软件之衍生物做任何表示支持、认可或推广、促销之行为。
 * 
 * 免责声明：本软件是由RednaxelaFX以现状（"as is"）提供，
 * 本软件包装不负任何明示或默示之担保责任，包括但不限于就适售性以及特定目
 * 的的适用性为默示性担保。RednaxelaFX无论任何条件、
 * 无论成因或任何责任主义、无论此责任为因合约关系、无过失责任主义或因非违
 * 约之侵权（包括过失或其他原因等）而起，对于任何因使用本软件包装所产生的
 * 任何直接性、间接性、偶发性、特殊性、惩罚性或任何结果的损害（包括但不限
 * 于替代商品或劳务之购用、使用损失、资料损失、利益损失、业务中断等等），
 * 不负任何责任，即在该种使用已获事前告知可能会造成此类损害的情形下亦然。
 */

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace FFDSystemAnalysis
{
    enum TokenType
    {
        Decimal = 0x080,
        Identifier = 0x081,
        Hexadecimal = 0x082,
        String = 0x083,
        Operator = 0x085
    }

    enum OutputState
    {
    	Searching,
    	FoundText,
    	FoundEqual
    }

    sealed class ScriptExtractor
    {
        private static readonly byte[ ] SIGNATURE = {
		    ( byte )0x54, ( byte )0x4F, ( byte )0x4B, ( byte )0x45,
		    ( byte )0x4E, ( byte )0x53, ( byte )0x45, ( byte )0x54,
		    ( byte )0x64, ( byte )0x0,  ( byte )0x0,  ( byte )0x0
        };

        static void Main( string[ ] args ) {
            if ( !args[ 0 ].EndsWith( ".tkn" ) ) return;
            if ( !File.Exists( args[ 0 ] ) ) return;

            string infile = args[ 0 ];
            string outfile = Path.GetFileNameWithoutExtension( infile ) + ".txt";

            Encoding utf16le = new UnicodeEncoding( false, true );
            Encoding jis = Encoding.GetEncoding( 932 );

            using ( BinaryReader reader = new BinaryReader( File.OpenRead( infile ), jis ) ) {
                using ( BinaryWriter writer = new BinaryWriter( File.Create( outfile ), utf16le ) ) {
                    byte[ ] sig = reader.ReadBytes( SIGNATURE.Length );
                    if ( !Equals( sig, SIGNATURE ) ) {
                        Console.WriteLine( "Wrong signature" );
                        return;
                    }

                    // write UTF-16LE BOM
                    writer.Write( ( ushort ) 0xFEFF );

                    // process each token
                    int lineNum = 1;
                    TokenType tokenType = TokenType.Operator;
                    OutputState state = OutputState.Searching;
                    int tokenCount = reader.ReadInt32( );
                    for ( int tokenNum = 0; tokenNum < tokenCount; ++tokenNum ) {
                        // get line numbers
                        lineNum = reader.ReadInt32( );

                        // get token tokenType
                        tokenType = ( TokenType ) ( reader.ReadByte( ) & 0x0FF );

                        // get token value
                        string tokenString = ReadCString( reader );

                        switch ( tokenType ) {

                        case TokenType.Identifier:
                            if ( tokenString.Equals("text") ) {
                            	state = OutputState.FoundText;
                            } else {
                            	state = OutputState.Searching;
                            }
                            break;

                        case TokenType.String:
                            if (OutputState.FoundEqual == state)
                            {
                            	writer.Write( utf16le.GetBytes( lineNum.ToString( ) ) );
                            	writer.Write( utf16le.GetBytes( Environment.NewLine ) );
                            	writer.Write( utf16le.GetBytes( tokenString ) );
                            	writer.Write( utf16le.GetBytes( Environment.NewLine ) );
                            	state = OutputState.Searching;
                            }
                            break;

                        case TokenType.Operator:
                            if ((OutputState.FoundText == state)
                                && tokenString.Equals("=")) {
                            	state = OutputState.FoundEqual;
                            } else {
                            	state = OutputState.Searching;
                            }
                            break;

                        case TokenType.Decimal:
                        case TokenType.Hexadecimal:
                            // do nothing
                            break;

                        default:
                            Console.WriteLine( "Unexpected token type {0} at 0x{1}.",
                                tokenType.ToString( "X" ),
                                reader.BaseStream.Position.ToString( "X" ) );
                            return;
                        } // switch tokenType
                    } // for
                }
            }
        }

        static bool Equals( byte[ ] a, byte[ ] b ) {
            int len = a.Length;
            if ( len != b.Length ) return false;
            for ( int i = 0; i < len; i++ ) {
                if ( a[ i ] != b[ i ] ) return false;
            }
            return true;
        }

        static string ReadCString( BinaryReader reader ) {
            StringBuilder builder = new StringBuilder( );
            char c = '\0';

            while ( ( c = reader.ReadChar( ) ) != '\0' ) {
                builder.Append( c );
            }

            return builder.ToString( );
        }
    }
}