class Pic16f84Simulator {
        //-------------------------------------------
        /// プロパティの定義
        //-------------------------------------------
        /// <summary> プログラムカウンタ</summary>
        public int Pc { get; private set; }
 
        /// <summary> ワーキングレジスタ</summary>
        public int Wreg{ get; private set; }
 
        /// <summary> プログラムメモリ</summary>
        public int[] ProgMem { get; private set; }
 
        /// <summary> ファイルレジスタ</summary>
        public int[] FileReg { get; private set; }
 
        /// <summary> CPUサイクル</summary>
        public long CpuCycle { get; private set; }
 
        public Pic16f84Simulator() {
            ProgMem = new int[1024];
            FileReg = new int[256];
        }

        //*********************************************************************
        /// <summary>　プログラムメモリの読み込みを行う
        /// </summary>
        //*********************************************************************
        public void loadProgram( int[] inProgMem ) {
            Array.Copy( inProgMem, this.ProgMem, inProgMem.Length );
        }

        //*********************************************************************
        /// <summary>　ステップ実行を行う
        /// </summary>
        //*********************************************************************
        public void step() {
            OpeInfo opeInfo;
 
            //-------------------------------
            // 命令のフェッチ
            //-------------------------------
            int opeCode = ProgMem[ Pc ];
            Pc++;
 
            //-------------------------------
            // フェッチされた命令のデコード
            //-------------------------------
            opeInfo = decode( opeCode );
 
            //-------------------------------
            // 命令の実行
            //-------------------------------
            execute( opeInfo );
 
            CpuCycle++;
 
 
            // デバッグ出力
            Console.WriteLine( "命令内容 :" + Pic16f84.toNimonic( opeCode, false ) );
            Console.WriteLine( "   cycle={0}: Pc={1}, Wreg={2}" + Environment.NewLine, CpuCycle, Pc, Wreg );
        }

        //*********************************************************************
        /// <summary>指定された機械語命令を解析する
        /// </summary>
        /// <param name="mCode">機械語命令</param>
        /// <returns>           解析結果</returns>
        //*********************************************************************
        private OpeInfo decode( int mCode ) {
            OpeInfo opeInfo = new OpeInfo();
 
 
            // GOTO  :  0010 1kkk kkkk kkkk
            if ( ( mCode & 0xF800 ) == 0x2800 ) {
                opeInfo.OpeCode = OPCODE.GOTO;
                opeInfo.Literal = getLiteral11( mCode );
                return opeInfo;
            }
 
            // ADDLW :  0011 111x kkkk kkkk
            if ( ( mCode & 0xFE00 ) == 0x3E00 ) {
                opeInfo.OpeCode = OPCODE.ADDLW;
                opeInfo.Literal = getLiteral8( mCode );
                return opeInfo;
            }
 
            opeInfo.OpeCode = OPCODE.UNKNOWN;
            return opeInfo;
        }

        //***************************************************************************
        /// <summary>デコード後の命令情報
        /// </summary>
        //***************************************************************************
        class OpeInfo {
            public OPCODE   OpeCode{ get; set; }
            public int      DestReg{ get; set; }
            public int      FileReg{ get; set; }
            public int      BitAddr{ get; set; }
            public int      Literal{ get; set; }
 
            public OpeInfo() {
                OpeCode = OPCODE.UNKNOWN;
            }
        }
 
        //***************************************************************************
        /// <summary>命令コード一覧
        /// </summary>
        //***************************************************************************
        enum OPCODE {
            GOTO,
            ADDLW,
            UNKNOWN,
        };

        //***************************************************************************
        /// <summary>   機械語命令の実行を行う
        /// </summary>
        /// <param name="opeInfo"></param>
        //***************************************************************************
        private void execute( OpeInfo opeInfo ) {
            switch ( opeInfo.OpeCode ) {
                case OPCODE.ADDLW:
                    Wreg += opeInfo.Literal;
                    break;
                case OPCODE.GOTO:
                    Pc    = opeInfo.Literal;
                    break;
 
                default:
                    break;
            }
        }

        //***************************************************************************
        /// <summary> BCF,BSF, BTFSC命令などで指定されるbit位置情報を返す
        ///           ビット位置情報はOPCODE<9-7>で指定される。
        /// </summary>
        /// <returns></returns>
        //***************************************************************************
        static private int getOperandBit( int mCode ) {
            int bitOffset = ( mCode & 0x0380 ) >> 7;
            return bitOffset;
        }
 
        //***************************************************************************
        /// <summary> 命令実行結果の格納先(W or F)を返す
        /// </summary>
        /// <returns></returns>
        //***************************************************************************
        static private int getDestination( int mCode ) {
            int dest = ( mCode & 0x0080 ) >> 7;
            return dest;
        }
 
        //***************************************************************************
        /// <summary> ADDWF, MOVF命令などで指定される処理対象レジスタの情報を返す
        ///           レジスタの場所情報はOPCODE<6-0>で指定される。
        /// </summary>
        /// <returns></returns>
        //***************************************************************************
        static private int getOperandRegister( int mCode ) {
            int regAddress = ( mCode & 0x007F );
            return regAddress;
        }
 
 
        //***************************************************************************
        /// <summary> 11桁のリテラル値を返す
        ///           リテラル値の場所はOPCODE<10-0>
        /// </summary>
        /// <param name="mCode"></param>
        /// <returns></returns>
        //***************************************************************************
        static private int getLiteral11( int mCode ) {
            int literal = ( mCode & 0x07FF );
            return literal;
        }
 
        //***************************************************************************
        /// <summary> 8桁のリテラル値を返す
        ///           リテラル値の場所はOPCODE<7-0>
        /// </summary>
        /// <param name="mCode"></param>
        /// <returns></returns>
        //***************************************************************************
        static private int getLiteral8( int mCode ) {
            int literal = ( mCode & 0x00FF );
            return literal;
        }

    LIST    P=16F84
    INCLUDE P16F84A.INC
 
    ORG 0
    ADDLW       D'08'
MAIN
    ADDLW       D'01'
    GOTO        MAIN
 
    END

:020000040000FA
:06000000083E013E01284C
:04000600003400348E
:00000001FF

 
命令内容 :ADDLW 0x8
   cycle=1: Pc=1, Wreg=8
 
命令内容 :ADDLW 0x1
   cycle=2: Pc=2, Wreg=9
 
命令内容 :GOTO 0x1
   cycle=3: Pc=1, Wreg=9
 
命令内容 :ADDLW 0x1
   cycle=4: Pc=2, Wreg=10
 
命令内容 :GOTO 0x1
   cycle=5: Pc=1, Wreg=10
 
命令内容 :ADDLW 0x1
   cycle=6: Pc=2, Wreg=11
 
命令内容 :GOTO 0x1
   cycle=7: Pc=1, Wreg=11
 
命令内容 :ADDLW 0x1
   cycle=8: Pc=2, Wreg=12
 
命令内容 :GOTO 0x1
   cycle=9: Pc=1, Wreg=12
 
命令内容 :ADDLW 0x1
   cycle=10: Pc=2, Wreg=13

using System;
 
class Pic16f84 {
    //***************************************************************************
    /// <summary>   指定された機械語の命令をアセンブリのニーモニックに変換する
    ///             PIC16F84は命令長が13bitなので、13bit分のみチェックする
    /// </summary>
    /// <param name="inMachineCode">    機械語命令</param>
    /// <param name="isLittleEndian">   リトルエンディアンか(通常はfalse)</param>
    /// <returns>   ニーモニック文字列</returns>
    //***************************************************************************
    public static string toNimonic( string inMachineCode, bool isLittleEndian = false ) {
        int mCode;
        if ( isLittleEndian ) {
            mCode = Convert.ToInt16( inMachineCode.Substring(2,2) + inMachineCode.Substring(0,2), 16 );
        } else {
            mCode = Convert.ToInt16( inMachineCode, 16 );
        }
 
        if ( mCode == 0x3FFF ) {
            return "";
        }
 
        // RETURN:  0000 0000 0000 1000
        if ( mCode == 0x0008 ) {
            return "RETURN";
        }
 
        // RETFIE:  0000 0000 0000 1001
        if ( mCode == 0x0009 ) {
            return "RETFIE";
        }
 
        // SLEEP :  0000 0000 0110 0011
        if ( mCode == 0x0063 ) {
            return "SLEEP";
        }
 
        // CLRWDT:  0000 0000 0110 0100
        if ( mCode == 0x0064 ) {
            return "CLRWDT";
        }
 
        // TODO:仕様書を要確認
        // NOP   :  0000 0000 0xx0 0000
        if ( mCode == 0x0000 ) {
            return "NOP";
        }
 
        // MOVWF :  0000 0000 1fff ffff
        if ( ( mCode & 0xFF80 ) == 0x0080 ) {
            return "MOVWF " + getOperandRegister( mCode );
        }
 
 
        // CLRW  :  0000 0001 0xxx xxxx
        if ( ( mCode & 0xFF80 ) == 0x0100 ) {
            return "CLRW";
        }
 
        // CLRF  :  0000 0001 1fff ffff
        if ( ( mCode & 0xFF80 ) == 0x0180 ) {
            return "CLRF " + getOperandRegister( mCode );
        }
 
        // SUBWF :  0000 0010 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0200 ) {
            return "SUBWF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // DECF  :  0000 0011 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0300 ) {
            return "DECF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // IORWF :  0000 0100 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0400 ) {
            return "IORWF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // ANDWF :  0000 0101 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0500 ) {
            return "ANDWF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // XORWF :  0000 0110 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0600 ) {
            return "XORWF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // ADDWF :  0000 0111 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0700 ) {
            return "ADDWF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // MOVF  :  0000 1000 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0800 ) {
            return "MOVF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // COMF  :  0000 1001 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0900 ) {
            return "COMF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // INCF  :  0000 1010 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0A00 ) {
            return "INCF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // DECFSZ:  0000 1011 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0B00 ) {
            return "DECFSZ " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // RRF   :  0000 1100 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0C00 ) {
            return "RRF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // RLF   :  0000 1101 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0D00 ) {
            return "RLF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // SWAPF :  0000 1110 dfff ffff
        if ( ( mCode & 0xFF00 ) == 0x0E00 ) {
            return "SWAPF " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // INCFSZ:  0000 1111 dfff ffff
            if ( ( mCode & 0xFF00 ) == 0x0F00 ) {
            return "INCFSZ " + getOperandRegister( mCode ) + ", " + getDestination( mCode );
        }
 
        // BCF   :  0001 00bb bfff ffff
        if ( ( mCode & 0xFC00 ) == 0x1000 ) {
            return "BCF " + getOperandRegister( mCode ) + ", " + getOperandBit( mCode );
        }
 
        // BSF   :  0001 01bb bfff ffff
        if ( ( mCode & 0xFC00 ) == 0x1400 ) {
            return "BSF " + getOperandRegister( mCode ) + ", " + getOperandBit( mCode );
        }
 
        // BTFSC :  0001 10bb bfff ffff
        if ( ( mCode & 0xFC00 ) == 0x1800 ) {
            return "BTFSC " + getOperandRegister( mCode ) + ", " + getOperandBit( mCode );
        }
 
        // BTFSS :  0001 11bb bfff ffff
        if ( ( mCode & 0xFC00 ) == 0x1C00 ) {
            return "BTFSS " + getOperandRegister( mCode ) + ", " + getOperandBit( mCode );
        }
 
        // CALL  :  0010 0kkk kkkk kkkk
        if ( ( mCode & 0xF800 ) == 0x2000 ) {
            return "CALL " + getLiteral11( mCode );
        }
 
        // GOTO  :  0010 1kkk kkkk kkkk
        if ( ( mCode & 0xF800 ) == 0x2800 ) {
            return "GOTO " + getLiteral11( mCode );
        }
 
        // MOVLW :  0011 00xx kkkk kkkk
        if ( ( mCode & 0xFC00 ) == 0x3000 ) {
            return "MOVLW " + getLiteral8( mCode );
        }
 
        // RETLW :  0011 01xx kkkk kkkk
        if ( ( mCode & 0xFC00 ) == 0x3400 ) {
            return "RETLW " + getLiteral8( mCode );
        }
 
        // IORLW :  0011 1000 kkkk kkkk
        if ( ( mCode & 0xFF00 ) == 0x3800 ) {
            return "IORLW " + getLiteral8( mCode );
        }
 
        // ANDLW :  0011 1001 kkkk kkkk
        if ( ( mCode & 0xFF00 ) == 0x3900 ) {
            return "ANDLW " + getLiteral8( mCode );
        }
 
        // XORLW :  0011 1010 kkkk kkkk
        if ( ( mCode & 0xFF00 ) == 0x3A00 ) {
            return "XORLW " + getLiteral8( mCode );
        }
 
        // SUBLW :  0011 110x kkkk kkkk
        if ( ( mCode & 0xFE00 ) == 0x3C00 ) {
            return "SUBLW " + getLiteral8( mCode );
        }
 
        // ADDLW :  0011 111x kkkk kkkk
        if ( ( mCode & 0xFE00 ) == 0x3E00 ) {
            return "ADDLW " + getLiteral8( mCode );
        }
 
        // 不明
        return "???";
    }
 
 
    //***************************************************************************
    /// <summary> BCF,BSF, BTFSC命令などで指定されるbit位置情報を返す
    ///           ビット位置情報はOPCODE<9-7>で指定される。
    /// </summary>
    /// <returns></returns>
    //***************************************************************************
    static private string getOperandBit( int mCode ) {
        int bitOffset = ( mCode & 0x0380 ) >> 7;
        return "0x" + bitOffset.ToString( "x" );
    }
 
    //***************************************************************************
    /// <summary> 命令実行結果の格納先(W or F)を返す
    /// </summary>
    /// <returns></returns>
    //***************************************************************************
    static private string getDestination( int mCode ) {
        int data = ( mCode & 0x0080 ) >> 7;
        if ( data == 0 ) {
            return "W";
        } else {
            return "F";
        }       
    }
 
    //***************************************************************************
    /// <summary> ADDWF, MOVF命令などで指定される処理対象レジスタの情報を返す
    ///           レジスタの場所情報はOPCODE<6-0>で指定される。
    /// </summary>
    /// <returns></returns>
    //***************************************************************************
    static private string getOperandRegister( int mCode ) {
        int regAddress = ( mCode & 0x007F );
        return "0x" + regAddress.ToString( "x" );
    }
 
 
    //***************************************************************************
    /// <summary> 11桁のリテラル値を返す
    ///           リテラル値の場所はOPCODE<10-0>
    /// </summary>
    /// <param name="mCode"></param>
    /// <returns></returns>
    //***************************************************************************
    static private string getLiteral11( int mCode ) {
        int regAddress = ( mCode & 0x07FF );
        return "0x" + regAddress.ToString( "x" );
    }
 
    //***************************************************************************
    /// <summary> 8桁のリテラル値を返す
    ///           リテラル値の場所はOPCODE<7-0>
    /// </summary>
    /// <param name="mCode"></param>
    /// <returns></returns>
    //***************************************************************************
    static private string getLiteral8( int mCode ) {
        int regAddress = ( mCode & 0x00FF );
        return "0x" + regAddress.ToString( "x" );
    }
}

//------------------------------------
// hexファイルを元に,逆アセンブルを行う
//------------------------------------
textBox1.Text = "";
textBox1.AppendText( "LIST    P=16F84"     + Environment.NewLine );
textBox1.AppendText( "INCLUDE P16F84A.INC" + Environment.NewLine );
textBox1.AppendText( "ORG " + startAddr + Environment.NewLine );
bool needOrgFlg = false;
 
int dispLine = 1;
for ( int curAddr = startAddr; curAddr < endAddr; curAddr+=2 ) {
    string mWord1 = parser.getValue( curAddr );
    string mWord2 = parser.getValue( curAddr+1 );
    string mWord  = mWord1 + mWord2;
    string mnemonic = Pic16f84.toNimonic( mWord, true );
 
    //------------------------------
    // .asmファイル用のコードを出力
    //------------------------------
    if ( mnemonic.Length <= 0 ) {
        needOrgFlg = true;
    } else {
        if ( needOrgFlg ) {
            textBox1.AppendText( Environment.NewLine );
            textBox1.AppendText( "ORG " + ( curAddr /2 ) + Environment.NewLine );
        }
        needOrgFlg = false;
        textBox1.AppendText( mnemonic + Environment.NewLine );
    }
}

//------------------------------------
// hexファイルを元に,逆アセンブルを行う
//------------------------------------
txtDisAsmWithAddr.Text = "";
txtDisAsmWithAddr.AppendText( " Line  Address  Opcode               Disassembly              " + Environment.NewLine );
 
 
int dispLine = 1;
for ( int curAddr = startAddr; curAddr < endAddr; curAddr+=2 ) {
    string mWord1 = parser.getValue( curAddr );
    string mWord2 = parser.getValue( curAddr+1 );
    string mWord  = mWord1 + mWord2;
    string mnemonic = Pic16f84.toNimonic( mWord, true );
 
    //---------------------------
    // MPLAB互換のダンプを出力
    //---------------------------
    txtDisAsmWithAddr.AppendText( String.Format( "{0,6}", dispLine.ToString() ) +
                          "   " +
                          ( curAddr / 2  ).ToString( "X3" ) +           /* addrはbyteでは無くword(16bit)なので2で割る */
                          "     " +
                          mWord2 + mWord1 +
                          "  " +
                          mnemonic + Environment.NewLine );
    dispLine++;
}

using System;
using System.Collections.Generic;
 
public class HexFileParser {
    /// <summary> hexファイル情報</summary>
    class HexFileData {
        public int    Offset  { get; set; } // オフセット   0～65536
        public int    Length  { get; set; } // データ長     0～255
        public string RecType { get; set; } // レコード種別 2byte
                                            // 00   データレコード
                                            // 01   ファイル終了レコード
                                            // 02   拡張セグメントアドレスレコード
                                            // 03   スタートセグメントアドレスレコード
                                            // 04   拡張リニアアドレスレコード
                                            // 05   スタートリニアアドレスレコード
        public string Data    { get; set; }
    }
 
    /// <summary> 開始アドレス</summary>
    public int StartAddr { get{ return startAddr; } }
 
    /// <summary> 終了アドレス</summary>
    public int EndAddr   { get{ return endAddr;   } }
 
    // 解析エラー情報を取得する
 
    public List<string>ParseErrorInfo { get{ return parseErrorInfo;} }
 
    public string DefaultValue { get; set; }
 
    /// <summary>開始アドレス</summary>
    private int startAddr;
    /// <summary>終了アドレス</summary>
    private int endAddr;
 
    /// <summary> Hexファイル情報リスト(元ファイル１行で１データ)</summary>
    private List<HexFileData> hexFileList = new List<HexFileData>();
 
 
    /// <summary>解析エラー情報</summary>
    private List<string> parseErrorInfo = new List<string>();
 
 
    //*********************************************************************
    /// <summary> コンストラクタ
    /// </summary>
    //*********************************************************************
    public HexFileParser() {
        DefaultValue = "00";
 
        clearParseInfo();
    }
 
 
    //*********************************************************************
    /// <summary>   解析情報をクリアする
    /// </summary>
    //*********************************************************************
    public void clearParseInfo() {
        startAddr    = 0xFFFF;
        endAddr      = 0x0000;
        parseErrorInfo.Clear();
        hexFileList.Clear();
    }
 
    //*********************************************************************
    /// <summary> 指定された行のデータを解析する
    /// </summary>
    /// <param name="lineNo">行番号(エラー出力用)</param>
    /// <param name="inData">hexファイル行データ</param>
    //*********************************************************************
    public void parseLine( int lineNo, string inData ) {
        string startMark;       // 1byte    スタートマーク(":"固定)
        string byteCount;       // 2byte    データ長
        string offsetAddress;   // 4byte    データオフセット(開始位置)
        string recType;         // 2byte    レコード種別 00:データ
        string data;            // variable データ
        string checkSum;        // 2byte    チェックサム
 
        //--------------------
        // レコード長チェック
        //--------------------
        if ( inData.Length < 11 ) {
            parseErrorInfo.Add( "行:" + lineNo + " レコード長が不正です" );
            return;
        }
 
        //------------------------------------
        // 入力レコードを、フィールド分割する
        //------------------------------------
        startMark     = inData.Substring( 0, 1 );
        byteCount     = inData.Substring( 1, 2 );
        offsetAddress = inData.Substring( 3, 4 );
        recType       = inData.Substring( 7, 2 );
        data          = inData.Substring( 9, inData.Length - 11 );
        checkSum      = inData.Substring( inData.Length - 2 );
 
        //--------------------
        // データチェック
        //--------------------
 
        // スタートマーク
        if ( !startMark.Equals( ":" ) ) {
            parseErrorInfo.Add( "行:" + lineNo + " スタートマークが':'では有りません[data=" + startMark + "]" );
            return;
        }
 
        // バイト数
        if ( !isHexaDecimal( byteCount ) ) {
            parseErrorInfo.Add( "行:" + lineNo + " バイトカウントが16進文字列では有りません[data=" + byteCount + "]" );
            return;
        }
 
        // オフセット
        if ( !isHexaDecimal( offsetAddress ) ) {
            parseErrorInfo.Add( "行:" + lineNo + " オフセットアドレスが16進文字列では有りません[data=" + offsetAddress + "]" );
            return;
        }
 
        // レコード種別
        if ( !isHexaDecimal( recType ) ) {
            parseErrorInfo.Add( "行:" + lineNo + " レコード種別が16進文字列では有りません[data=" + recType + "]" );
            return;
        }
        if ( !recType.Equals( "00" ) && !recType.Equals( "01" ) && !recType.Equals( "02" ) &&
             !recType.Equals( "03" ) && !recType.Equals( "04" ) && !recType.Equals( "05" ) ) {
            parseErrorInfo.Add( "行:" + lineNo + " レコード種別が00～05以外の値です[data=" + recType + "]" );
            return;
        }
 
        // データ
        if ( !isHexaDecimal( data ) ) {
            parseErrorInfo.Add( "行:" + lineNo + " データが16進文字列では有りません[data=" + data + "]" );
            return;
        }
 
        // チェックサム
        if ( !isHexaDecimal( checkSum ) ) {
            parseErrorInfo.Add( "行:" + lineNo + " チェックサムが16進文字列では有りません[data=" + checkSum + "]" );
            return;
        }
 
        //------------------------------
        // チェックサムの整合性チェック
        //------------------------------
 
        // スタートマークの次の位置(2byte目)～チェックサムの手前までを合算する
        uint calcValue = 0;
        for ( int loop = 1; loop < inData.Length - 2; loop +=2 ) {
            string curValue = inData.Substring( loop, 2 );
            calcValue += (uint)Convert.ToInt32( curValue, 16 );
        }
        calcValue = (~calcValue) + 1; // 2の補数を取る
        calcValue &= 0x000000FF;      // 下位16ビット分だけを抽出
        if ( Convert.ToInt32( checkSum, 16 ) != calcValue ) {
            parseErrorInfo.Add( "行:" + lineNo + " チェックサムが一致しません[calc=" + calcValue.ToString() + ", data=" + checkSum + "]" );
            return;
        }
 
        // 解析した値を覚える
        int start = Convert.ToInt32( offsetAddress, 16 );
        int len   = Convert.ToInt32( byteCount, 16 );
        storeValue( start, len, recType, data );
 
    }
 
 
    //*********************************************************************
    /// <summary> 指定されたアドレスの値を取得する
    /// </summary>
    /// <param name="address">  取得対象アドレス</param>
    /// <returns>               メモリ値</returns>
    //*********************************************************************
    public string getValue( int address ) {
        // 指定されたアドレスに対する定義を探す
        HexFileData targetData = null;
        foreach ( HexFileData curData in hexFileList ) {
            if ( curData.Offset <= address && curData.Offset + curData.Length > address ) {
                targetData = curData;
                break;
            }
        }
 
        // 指定されたアドレスの定義がない場合は、デフォルト値を返す
        if ( targetData == null ) {
            int wordLen = DefaultValue.Length / 2;  // １ワードの長さを求める
            int wordPos = address % wordLen;        // 要求されたアドレスが、ワード中のどこにあたるかかのoffsetを求める
 
            return DefaultValue.Substring( wordPos * 2, 2 );
        }
 
        // 定義がある場合は、ファイルの内容を返す
        int pos = address - targetData.Offset;
        return targetData.Data.Substring( pos*2, 2 );
    }
 
 
    //*********************************************************************
    /// <summary>解析した文字列を保存する
    /// </summary>
    /// 
    /// <param name="recType">      レコード種別</param>
    /// <param name="data">         データ(空文字列の可能性もあり</param>
    //*********************************************************************
    private void storeValue( int start, int len, string recType, string data ) {
        // データレコード以外は保存しない
        if ( !recType.Equals( "00") ) {
             return;
        }
 
        //-------------------------------------------------------
        // このデータによって開始･終了アドレスが変わるかチェック
        //-------------------------------------------------------
        if ( start < startAddr ) {
            startAddr = start;
        }
        if ( start + len > endAddr ) {
            endAddr = start + len;
        }
 
        //-------------------------------------------------------
        // 追加すべきデータをセット
        //-------------------------------------------------------
        HexFileData hexFileData = new HexFileData();
        hexFileData.Offset  = start;
        hexFileData.Length  = len;
        hexFileData.RecType = recType;
        hexFileData.Data    = data;
 
        //-------------------------------------------------------
        // 一覧に追加
        //-------------------------------------------------------
        hexFileList.Add( hexFileData );
    }
 
    //*********************************************************************
    /// <summary>指定された値が16進文字列であるかをチェックする
    ///          (= '0'～'F'のみで構成されているか)
    /// </summary>
    /// 
    /// <param name="inData">   チェック対象データ</param>
    /// <returns>true:16進文字列である, false:16進文字列ではない</returns>
    //*********************************************************************
    private bool isHexaDecimal( string inData ) {
        foreach ( Char data in inData ) {
            if ( ( data >= '0' && data <= '9' ) ||
                 ( data >= 'A' && data <= 'F' ) ) {
                continue;
            }
 
            // "0-9A-F"以外->値がおかしい
            return false;
        }
 
        // チェックOK
        return true;
    }
}

    string fileName ="c:\\test.hex";
    public HexFileParser parser = new HexFileParser();
 
    // デフォルト値の指定(pic16F84Aの場合"0x3FFF"だがlittle endianなのでFF3Fになる)
    parser.DefaultValue = "FF3F"; 
 
    using ( StreamReader reader = new StreamReader( fileName ) ) {
        int lineNo = 0;
        //-------------------------------
        // 全ての行を読み込むまで繰り返し
        //-------------------------------
        while ( true ) { 
            string line = reader.ReadLine();
            if ( line == null ) {
                break;
            }
 
            //-------------------------------------
            // Hexファイルのフォーマット解析を行う
            //-------------------------------------
            parser.parseLine( lineNo, line );
 
            // 解析したデータを画面に表示
            textBox1.AppendText( line + Environment.NewLine );
 
            lineNo++;
        }
    }
 
    //------------------------------------
    // hexファイルを元に,16進ダンプを行う
    //------------------------------------
    txtHexDump.Text = "";
 
    int loopCol = 0;
    int startAddr = parser.StartAddr;
    int endAddr   = parser.EndAddr;
    for ( int curAddr = startAddr; curAddr < endAddr; curAddr++ ) {
        string mCode = parser.getValue( curAddr );
        // 16進ダンプ値を表示
        textBox1.AppendText( mCode + " " );
 
 
        // 16byte単位で改行を入れる
        if ( loopCol++ >= 16 ) {
            loopCol = 0;
            textBox1.AppendText( Environment.NewLine );
        }
    }