本家「@IT」にはない内容をエンジニアライフで技術紹介するコラム。広く議論する場になることを目指します。

第027回_条件付字句解析器3_IgnoreLexer_IgnoreWordTokenizer

»
今回は、IGNORE_WORDの字句解析器を検討します。

Ignoreを字句解析するIgnoreLexerの検討と実装

Ignroeの構文を確認した上で検討に入ります。

構文の確認
 [65] Ignore ::= Char* − (Char* ('<![' | ']]>') Char*)
つまり、
 IGNORE_WORD ::= "<!["と"]]>" を含まないCharの文字列
# 紙面の都合上、仕様については実装のコメントで説明します。

実装

public class IgnoreLexer extends MapSwitchLexer
{
    private class IgnoreTokenMaker implements Functor
    {
        public IgnoreTokenMaker()
        {
        }
        
        @Override
        public Token tokenize(StringBuilder str, int pos)
        {
            m_tokenBuilder.initStart();
            return new IgnoreWordToken();
        }
    }
    
    private static final IgnoreLexer m_instance = new IgnoreLexer();

    private IgnoreLexer()
    {
        //記号   UniCode         処理
        //----------------------------------------------------------------------------------------
        //Char   #x0001-#x003B   初期化して、IgnoreWordTokenizer
        //"<"    #x003C          今の文字は確定せず、次の文字へ移動する。
        //                         IgnoreWordTokenizer2
        //Char   #x003D-#x005C   初期化して、IgnoreWordTokenizer
        //"]"    #x005D          今の文字は確定せず、次の文字へ移動する。
        //                         IgnoreWordTokenizer2
        //Char   #x005E-#xD7FF   初期化して、IgnoreWordTokenizer
        //Char   #xE000-#xFFFD   初期化して、IgnoreWordTokenizer
        //その他     -----       空のIgnoreWordTokenを作成する
        //EOF                    空のIgnoreWordTokenを作成する

        Init_MovePos      ignoreWordTokenizer
                           = new Init_MovePos(new IgnoreWordTokenizer());
        MovePos           ignoreWordTokenizer2
                           = new MovePos(new IgnoreWordTokenizer2());
        MovePos           ignoreWordTokenizer3
                           = new MovePos(new IgnoreWordTokenizer3());
        IgnoreTokenMaker  ignoreTokenMaker
                           = new IgnoreTokenMaker();
        
        m_map.put('\u0001', '\u003B',       ignoreWordTokenizer);
        m_map.put('\u003C',                 ignoreWordTokenizer2);
        //005Cはスラッシュ
        m_map.put('\u003D', '\u005C\u005C', ignoreWordTokenizer);
        m_map.put('\u005D',                 ignoreWordTokenizer3);
        m_map.put('\u005E', '\uD7FF',       ignoreWordTokenizer);
        m_map.put('\uE000', '\uFFFD',       ignoreWordTokenizer);
        m_map.setOutOfRange(ignoreTokenMaker);
        m_map.setEofFunctor(ignoreTokenMaker);
    }

    public static IgnoreLexer getInstance()
    {
        return m_instance;
    }
}

IgnoreWordTokenizerの実装

# 紙面の都合上、仕様については実装のコメントで説明します。

public class IgnoreWordTokenizer extends MultipleMapsSwitchTokenizer
{
    protected class IgnoreWordTokenMaker implements Functor
    {
        public IgnoreWordTokenMaker()
        {
        }
        
        @Override
        public Token tokenize(StringBuilder str, int pos)
        {
            return new IgnoreWordToken();
        }
    }
    
    protected final IgnoreWordTokenMaker m_iwtm;

    public IgnoreWordTokenizer()
    {
        m_iwtm = new IgnoreWordTokenMaker();
        
        // Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
        // Char   ::= [#x1-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] 
        makeMap_A();
        makeMap_B();
        makeMap_C();
        makeMap_D();
        makeMap_E();
    }

    private void makeMap_A()
    {
        //
        //表A 前の文字までを確定した状態
        //  記号   UniCode         処理
        //  -----------------------------------------------------
        //  Char   #x0001-#x003B   今の文字を確定する
        //  "<"    #x003C          今の文字を確定させずにBへ
        //  Char   #x003D-#x005C   今の文字を確定する
        //  "]"    #x005D          今の文字を確定させずにDへ
        //  Char   #x005E-#xD7FF   今の文字を確定する
        //  Char   #xE000-#xFFFD   今の文字を確定する
        //  その他 ------          解析したところまでをIGNORE_WORDにする
        //  EOF                    解析したところまでをIGNORE_WORDにする
        //
        //  処理1:今の文字を確定する
        //  処理2:今の文字を確定させずにBへ
        //  処理3:今の文字を確定させずにDへ
        //  処理4:解析したところまでをIGNORE_WORDにする
        //
        
        Update_MovePos  proc1 = new Update_MovePos(this);
        MovePos_MoveMap proc2 = new MovePos_MoveMap(1);
        MovePos_MoveMap proc3 = new MovePos_MoveMap(3);
        //              proc4 m_iwtm
        
        LexicalMap map = new LexicalMap();
        map.put('\u0001','\u003B'      ,proc1);
        map.put('\u003C'               ,proc2);
        map.put('\u003D','\u005C\u005C',proc1);
        map.put('\u005D'               ,proc3);
        map.put('\u005E','\uD7FF'      ,proc1);
        map.put('\uE000','\uFFFD'      ,proc1);
        map.setOutOfRange(m_iwtm);
        map.setEofFunctor(m_iwtm);
        
        m_mapList.add(map);
    }

    private void makeMap_B()
    {
        //表B (1つ前は<で未確定)
        //  記号   UniCode         処理
        //  -----------------------------------------------------
        //  Char   #x0001-#x0020   1つ前と今の文字を確定してA
        //  "!"    #x0021          今の文字を確定させずにC
        //  Char   #x0022-#x003B   1つ前と今の文字を確定してA
        //  "<"    #x003C          1つ前を確定する(Bのまま)
        //  Char   #x003D-#x005C   1つ前と今の文字を確定してA
        //  "]"    #x005D          1つ前を確定して、Dへ
        //  Char   #x005E-#xD7FF   1つ前と今の文字を確定してA
        //  Char   #xE000-#xFFFD   1つ前と今の文字を確定してA
        //  その他 ------          1つ前を確定させて、IGNORE_WORDにする
        //  EOF                    1つ前を確定させて、IGNORE_WORDにする
        //
        //  処理1:1つ前と今の文字を確定してA
        //  処理2:今の文字を確定させずにC
        //  処理3:1つ前を確定する(Bのまま)
        //  処理4:1つ前を確定して、Dへ
        //  処理5:1つ前を確定させて、IGNORE_WORDにする
        //
        
        UpdateRange_MovePos_MoveMap proc1 
                            = new UpdateRange_MovePos_MoveMap(0,1,0);
        MovePos_MoveMap             proc2
                            = new MovePos_MoveMap(2);
        UpdateRange_MovePos         proc3
                            = new UpdateRange_MovePos(this,1,1);
        UpdateRange_MovePos_MoveMap proc4
                            = new UpdateRange_MovePos_MoveMap(3,1,1);
        UpdateRange_MovePos  proc5 = new UpdateRange_MovePos(m_iwtm,1,1);
        
        LexicalMap map = new LexicalMap();
        map.put('\u0001','\u0020'        , proc1);
        map.put('\u0021'                 , proc2);
        map.put('\u0022','\u003B'        , proc1);
        map.put('\u003C'                 , proc3);
        map.put('\u003D','\u005C\u005C' , proc1);
        map.put('\u005D'                 , proc4);
        map.put('\u005E','\uD7FF'        , proc1);
        map.put('\uE000','\uFFFD'       , proc1);
        map.setOutOfRange(proc5);
        map.setEofFunctor(proc5);
        m_mapList.add(map);
    }

    private void makeMap_C()
    {
        //表C (2つ前は<で未確定、1つ前は!で未確定)
        //  記号        UniCode         処理
        //  -----------------------------------------------------
        //  Char   #x0001-#x003B   2つ前,1つ前,今の文字を確定させてA
        //  "<"    #x003C          2つ前、1つ前を確定してBへ
        //  Char   #x003D-#x005A   2つ前,1つ前,今の文字を確定させてA
        //  "["    #x005B          <![を含まずにIGNORE_WORDにする
        //  Char   #x005C          2つ前,1つ前,今の文字を確定させてA
        //  "]"    #x005D          2つ前、1つ前を確定して、Dへ
        //  Char   #x005E-#xD7FF   2つ前,1つ前,今の文字を確定させてA
        //  Char   #xE000-#xFFFD   2つ前,1つ前,今の文字を確定させてA
        //  その他 ------          2つ前,1つ前を確定させて
        //                               IGNORE_WORDにする
        //  EOF                    2つ前、1つ前を確定させて
        //                               IGNORE_WORDにする
        //
        //  処理1:2つ前,1つ前,今の文字を確定させてA
        //  処理2:2つ前、1つ前を確定してBへ
        //  処理3:<![を含まずにIGNORE_WORDにする
        //  処理4:2つ前、1つ前を確定して、Dへ
        //  処理5:2つ前,1つ前を確定させてIGNORE_WORDにする
        //
        UpdateRange_MovePos_MoveMap
                  proc1 = new UpdateRange_MovePos_MoveMap(0,2,0);
        UpdateRange_MovePos_MoveMap
                  proc2 = new UpdateRange_MovePos_MoveMap(1,2,1);
        //                          proc3 = m_iwtm
        UpdateRange_MovePos_MoveMap
                  proc4 = new UpdateRange_MovePos_MoveMap(3,2,1);
        UpdateRange_MovePos
                  proc5 = new UpdateRange_MovePos(m_iwtm,2,1);

        LexicalMap map = new LexicalMap();
        map.put('\u0001','\u003B'        , proc1);
        map.put('\u003C'                 , proc2);
        map.put('\u003D','\u005A'        , proc1);
        map.put('\u005B'                 , m_iwtm);
        map.put('\u005C\u005C'           , proc1);
        map.put('\u005D'                 , proc4);
        map.put('\u005E','\uD7FF'        , proc1);
        map.put('\uE000','\uFFFD'        , proc1);
        map.setOutOfRange(proc5);
        map.setEofFunctor(proc5);
        m_mapList.add(map);
    }

    private void makeMap_D()
    {
        //表D (1つ前は]で未確定)
        //  記号   UniCode         処理
        //  -----------------------------------------------------
        //  Char   #x0001-#x003B   1つ前と今の文字を確定させてA
        //  "<"    #x003C          1つ前を確定してBへ
        //  Char   #x003D-#x005C   1つ前と今の文字を確定させてA
        //  "]"    #x005D          今の文字を確定させずにE
        //  Char   #x005E-#xD7FF   1つ前と今の文字を確定させてA
        //  Char   #xE000-#xFFFD   1つ前と今の文字を確定させてA
        //  その他 ------          1つ前を確定させて、IGNORE_WORDにする 
        //  EOF                    1つ前を確定させて、IGNORE_WORDにする
        //
        //  処理1:1つ前と今の文字を確定してA
        //  処理2:1つ前を確定してBへ
        //  処理3:今の文字を確定させずにE
        //  処理4:1つ前を確定させて、IGNORE_WORDにする 

        UpdateRange_MovePos_MoveMap
               proc1 = new UpdateRange_MovePos_MoveMap(0,1,0);
        UpdateRange_MovePos_MoveMap
               proc2 = new UpdateRange_MovePos_MoveMap(1,1,1);
        MovePos_MoveMap
               proc3 = new MovePos_MoveMap(4);
        UpdateRange_MovePos
               proc4 = new UpdateRange_MovePos(m_iwtm,1,1);
        
        LexicalMap map = new LexicalMap();
        map.put('\u0001','\u003B'        , proc1);
        map.put('\u003C'                 , proc2);
        map.put('\u003D','\u005C\u005C' , proc1);
        map.put('\u005D'                 , proc3);
        map.put('\u005E','\uD7FF'        , proc1);
        map.put('\uE000','\uFFFD'       , proc1);
        map.setOutOfRange(proc4);
        map.setEofFunctor(proc4);
        m_mapList.add(map);
    }

    private void makeMap_E()
    {
        //表E (2つ前は]で未確定、1つ前は]で未確定)
        //  記号   UniCode         処理
        //  -----------------------------------------------------
        //  Char   #x0001-#x003B   2つ前,1つ前,今の文字を確定させてA
        //  "<"    #x003C          2つ前、1つ前を確定してBへ
        //  Char   #x003D          2つ前,1つ前,今の文字を確定させてA
        //  ">"    #x003E          ]]>を含まずにIGNORE_WORDにする
        //  Char   #x003F-#x005C   2つ前,1つ前,今の文字を確定させてA       
        //  "]"    #x005D          2つ前を確定する
        //  Char   #x005E-#xD7FF   2つ前,1つ前,今の文字を確定させてA       
        //  Char   #xE000-#xFFFD   2つ前,1つ前,今の文字を確定させてA
        //  その他 ------          2つ前,1つ前を確定させてIGNORE_WORDにする        
        //  EOF                    2つ前,1つ前を確定させてIGNORE_WORDにする
        //
        //  処理1:2つ前,1つ前,今の文字を確定させてA
        //  処理2:2つ前、1つ前を確定してBへ
        //  処理3:]]>を含まずにIGNORE_WORDにする
        //  処理4:2つ前を確定する
        //  処理5:2つ前,1つ前を確定させてIGNORE_WORDにする

        UpdateRange_MovePos_MoveMap
                 proc1 = new UpdateRange_MovePos_MoveMap(0,2,0);
        UpdateRange_MovePos_MoveMap
                 proc2 = new UpdateRange_MovePos_MoveMap(1,2,1);
        //                          proc3 = m_iwtm
        UpdateRange_MovePos
                 proc4 = new UpdateRange_MovePos(this, 2,2);
        UpdateRange_MovePos
                 proc5 = new UpdateRange_MovePos(m_iwtm,2,1);

        LexicalMap map = new LexicalMap();
        map.put('\u0001','\u003B'        , proc1);
        map.put('\u003C'                 , proc2);
        map.put('\u003D'                , proc1);
        map.put('\u003E'                , m_iwtm);
        map.put('\u003F','\u005C\u005C' , proc1);
        map.put('\u005D'                , proc4);
        map.put('\u005E','\uD7FF'        , proc1);
        map.put('\uE000','\uFFFD'       , proc1);
        map.setOutOfRange(proc5);
        map.setEofFunctor(proc5);
        m_mapList.add(map);
    }
}

IgnoreWordTokenizer2の実装

# 紙面の都合上、仕様については実装のコメントで説明します。

public class IgnoreWordTokenizer2 extends IgnoreWordTokenizer
{
    private class Init_IgnoreWordTokenMaker implements Functor
    {
        public Init_IgnoreWordTokenMaker()
        {
        }
        
        @Override
        public Token tokenize(StringBuilder str, int pos)
        {
            m_tokenBuilder.initStart();
            return new IgnoreWordToken();
        }
    }
    
    private final Init_IgnoreWordTokenMaker m_eiwtm;

    public IgnoreWordTokenizer2()
    {
        super();
        
        m_index = 5; //表Fからスタートする
        
        m_eiwtm = new Init_IgnoreWordTokenMaker();
        
        // Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
        // Char   ::= [#x1-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
        makeMap_F();//5
        makeMap_G();//6
    }

    private void makeMap_F()
    {
        //表F (tokenBuilder.initStartしていない、1文字前が<で未確定)
        //  記号   UniCode         処理
        //  -----------------------------------------------------
        //  Char   #x0001-#x0020   初期化、1つ前と今の文字を確定してA
        //  "!"    #x0021          今の文字を確定させずにG
        //  Char   #x0022-#x003B   初期化、1つ前と今の文字を確定してA
        //  "<"    #x003C          初期化、1つ前を確定するB
        //  Char   #x003D-#x005C   初期化、1つ前と今の文字を確定してA
        //  "]"    #x005D          初期化、1つ前を確定して、Dへ
        //  Char   #x005E-#xD7FF   初期化、1つ前と今の文字を確定してA
        //  Char   #xE000-#xFFFD   初期化、1つ前と今の文字を確定してA
        //  その他 ------          初期化、1つ前を確定させて
        //                           IGNORE_WORDにする
        //  EOF                    初期化、1つ前を確定させて
        //                           IGNORE_WORDにする
        //
        //  処理1:初期化、1つ前と今の文字を確定してA
        //  処理2:今の文字を確定させずにG
        //  処理3:初期化、1つ前を確定するB
        //  処理4:初期化、1つ前を確定して、Dへ
        //  処理5:初期化、1つ前を確定させて、IGNORE_WORDにする
        //
        InitUpdateRange_MovePos_MoveMap
                    proc1 = new InitUpdateRange_MovePos_MoveMap(0,1,0);
        MovePos_MoveMap                 proc2 = new MovePos_MoveMap(6);
        InitUpdateRange_MovePos
                    proc3 = new InitUpdateRange_MovePos(this,1,1);
        InitUpdateRange_MovePos_MoveMap
                    proc4 = new InitUpdateRange_MovePos_MoveMap(3,1,1);
        InitUpdateRange_MovePos
                    proc5 = new InitUpdateRange_MovePos(m_iwtm,1,1);
        
        LexicalMap map = new LexicalMap();
        map.put('\u0001','\u0020'        , proc1);
        map.put('\u0021'                 , proc2);
        map.put('\u0022','\u003B'        , proc1);
        map.put('\u003C'                 , proc3);
        map.put('\u003D','\u005C\u005C' , proc1);
        map.put('\u005D'                 , proc4);
        map.put('\u005E','\uD7FF'        , proc1);
        map.put('\uE000','\uFFFD'       , proc1);
        map.setOutOfRange(proc5);
        map.setEofFunctor(proc5);
        m_mapList.add(map);
    }

    private void makeMap_G()
    {
        //表G (tokenBuilder.initStartしていない、
        //      2文字前が<、1文字前が!で未確定)
        //  記号   UniCode         処理
        //  -----------------------------------------------------
        //  Char   #x0001-#x003B   初期化、2つ前,1つ前
        //                           今の文字を確定させてA
        //  "<"    #x003C          初期化、2つ前、1つ前を確定してBへ
        //  Char   #x003D-#x005A   初期化、2つ前,1つ前
        //                           今の文字を確定させてA
        //  "["    #x005B          初期化、<![を含まずにIGNORE_WORDにする
        //  Char   #x005C          初期化、2つ前,1つ前
        //                           今の文字を確定させてA
        //  "]"    #x005D          初期化、2つ前、1つ前を確定して、Dへ
        //  Char   #x005E-#xD7FF   初期化、2つ前,1つ前
        //                           今の文字を確定させてA
        //  Char   #xE000-#xFFFD   初期化、2つ前,1つ前
        //                           今の文字を確定させてA
        //  その他 ------          初期化、2つ前,1つ前を確定させて
        //                           IGNORE_WORDにする
        //  EOF                    初期化、2つ前、1つ前を確定させて
        //                           IGNORE_WORDにする
        //
        //  処理1:初期化、2つ前,1つ前,今の文字を確定させてA
        //  処理2:初期化、2つ前、1つ前を確定してBへ
        //  処理3:初期化、<![を含まずにIGNORE_WORDにする
        //  処理4:初期化、2つ前、1つ前を確定して、Dへ
        //  処理5:初期化、2つ前,1つ前を確定させてIGNORE_WORDにする
        //
        InitUpdateRange_MovePos_MoveMap
                    proc1 = new InitUpdateRange_MovePos_MoveMap(0,2,0);
        InitUpdateRange_MovePos_MoveMap
                    proc2 = new InitUpdateRange_MovePos_MoveMap(1,2,1);
        //                              proc3 = m_eiwtm
        InitUpdateRange_MovePos_MoveMap
                    proc4 = new InitUpdateRange_MovePos_MoveMap(3,2,1);
        InitUpdateRange_MovePos
                    proc5 = new InitUpdateRange_MovePos(m_iwtm,2,1);

        LexicalMap map = new LexicalMap();
        map.put('\u0001','\u003B'        , proc1);
        map.put('\u003C'                 , proc2);
        map.put('\u003D','\u005A'       , proc1);
        map.put('\u005B'                 , m_eiwtm);
        map.put('\u005C\u005C'          , proc1);
        map.put('\u005D'                 , proc4);
        map.put('\u005E','\uD7FF'        , proc1);
        map.put('\uE000','\uFFFD'       , proc1);
        map.setOutOfRange(proc5);
        map.setEofFunctor(proc5);
        m_mapList.add(map);
    }
}

IgnoreWordTokenizer3の実装

# 紙面の都合上、仕様については実装のコメントで説明します。

public class IgnoreWordTokenizer3 extends IgnoreWordTokenizer
{
    private class Init_IgnoreWordTokenMaker implements Functor
    {
        public Init_IgnoreWordTokenMaker()
        {
        }
        
        @Override
        public Token tokenize(StringBuilder str, int pos)
        {
            m_tokenBuilder.initStart();
            return new IgnoreWordToken();
        }
    }
    
    private final Init_IgnoreWordTokenMaker m_eiwtm;
    
    public IgnoreWordTokenizer3()
    {
        super();
        
        m_index = 5; //状態Fからスタートする
        
        m_eiwtm = new Init_IgnoreWordTokenMaker();
        
        makeMap_F();//5
        makeMap_G();//6
    }

    private void makeMap_F()
    {
        //表F (tokenBuilder.initStartしていない、1つ前は]で未確定)
        //  記号   UniCode         処理
        //  -----------------------------------------------------
        //  Char   #x0001-#x003B   初期化、1つ前と今の文字を確定させてA
        //  "<"    #x003C          初期化、1つ前を確定してBへ
        //  Char   #x003D-#x005C   初期化、1つ前と今の文字を確定させてA
        //  "]"    #x005D          今の文字を確定させずにG
        //  Char   #x005E-#xD7FF   初期化、1つ前と今の文字を確定させてA
        //  Char   #xE000-#xFFFD   初期化、1つ前と今の文字を確定させてA
        //  その他 ------          初期化、1つ前を確定させて
        //                           IGNORE_WORDにする
        //  EOF                    初期化、1つ前を確定させて
        //                           IGNORE_WORDにする
        //
        //  処理1:初期化、1つ前と今の文字を確定してA
        //  処理2:初期化、1つ前を確定してBへ
        //  処理3:今の文字を確定させずにG
        //  処理4:初期化、1つ前を確定させて、IGNORE_WORDにする 

        InitUpdateRange_MovePos_MoveMap
              proc1 = new InitUpdateRange_MovePos_MoveMap(0,1,0);
        InitUpdateRange_MovePos_MoveMap
              proc2 = new InitUpdateRange_MovePos_MoveMap(1,1,1);
        MovePos_MoveMap  proc3 = new MovePos_MoveMap(6);
        InitUpdateRange_MovePos
              proc4 = new InitUpdateRange_MovePos(m_iwtm,1,1);
        
        LexicalMap map = new LexicalMap();
        map.put('\u0001','\u003B'        , proc1);
        map.put('\u003C'                 , proc2);
        map.put('\u003D','\u005C\u005C' , proc1);
        map.put('\u005D'                 , proc3);
        map.put('\u005E','\uD7FF'        , proc1);
        map.put('\uE000','\uFFFD'       , proc1);
        map.setOutOfRange(proc4);
        map.setEofFunctor(proc4);
        m_mapList.add(map);
    }

    private void makeMap_G()
    {
        //表G (tokenBuilder.initStartしていない、
        //     2つ前は]で未確定、1つ前は]で未確定)
        //  記号   UniCode         処理
        //  -----------------------------------------------------
        //  Char   #x0001-#x003B   初期化、2つ前,1つ前,
        //                           今の文字を確定させてA
        //  "<"    #x003C          初期化、2つ前、1つ前を確定してBへ
        //  Char   #x003D          初期化、2つ前,1つ前,
        //                           今の文字を確定させてA
        //  ">"    #x003E          ]]>を含まずにIGNORE_WORDにする
        //  Char   #x003F-#x005C   初期化、2つ前,1つ前,
        //                           今の文字を確定させてA       
        //  "]"    #x005D          初期化、2つ前を確定してE
        //  Char   #x005E-#xD7FF   初期化、2つ前,1つ前,
        //                           今の文字を確定させてA       
        //  Char   #xE000-#xFFFD   初期化、2つ前,1つ前,
        //                           今の文字を確定させてA
        //  その他 ------          初期化、2つ前,1つ前を確定させて
        //                           IGNORE_WORDにする        
        //  EOF                    初期化、2つ前,1つ前を確定させて
        //                           IGNORE_WORDにする
        //
        //  処理1:初期化、2つ前,1つ前,今の文字を確定させてA
        //  処理2:初期化、2つ前、1つ前を確定してBへ
        //  処理3:初期化、]]>を含まずにIGNORE_WORDにする
        //  処理4:初期化、2つ前を確定してE
        //  処理5:初期化、2つ前,1つ前を確定させてIGNORE_WORDにする

        InitUpdateRange_MovePos_MoveMap
                  proc1 = new InitUpdateRange_MovePos_MoveMap(0,2,0);
        InitUpdateRange_MovePos_MoveMap
                  proc2 = new InitUpdateRange_MovePos_MoveMap(1,2,1);
        //                              proc3 = m_eiwtm
        InitUpdateRange_MovePos_MoveMap
                  proc4 = new InitUpdateRange_MovePos_MoveMap(4, 2,2);
        InitUpdateRange_MovePos
                  proc5 = new InitUpdateRange_MovePos(m_iwtm,2,1);

        LexicalMap map = new LexicalMap();
        map.put('\u0001','\u003B'        , proc1);
        map.put('\u003C'                 , proc2);
        map.put('\u003D'                , proc1);
        map.put('\u003E'                , m_eiwtm);
        map.put('\u003F','\u005C\u005C' , proc1);
        map.put('\u005D'                , proc4);
        map.put('\u005E','\uD7FF'        , proc1);
        map.put('\uE000','\uFFFD'       , proc1);
        map.setOutOfRange(proc5);
        map.setEofFunctor(proc5);
        m_mapList.add(map);
    }
}
Comment(0)

コメント

コメントを投稿する