第012回_構文解析Sample3

2.上限がある場合
　2-1.上限値までのforループ
　　2-1-1.countを取得する
　　2-1-2.子ノードを処理する
　　2-1-3.子ノードの処理結果がOKの場合は、OKカウント(okCount)を+1する
　　2-1-4.子ノードの処理結果がNGの場合は
　　　2-1-4-1.count2を取得する
　　　2-1-4-2.count==count2をokFlagに保存する
　　　2-1-4-3.繰り返し処理を中断する

2.上限がある場合
　2-1.上限値までのforループ
　　2-1-1.子ノードを処理する
　　2-1-2.子ノードの処理結果がOKの場合は、OKカウント(okCount)を+1する
　　2-1-3.子ノードの処理結果がNGの場合は
　　　2-1-3-1.繰り返し処理を中断する

pulic class AnalyzeSyntax
{
    public static void main(String args[])
    {
         Sample3Visitor v = new Sample3Visitor();

         //EBNFデータツリーを構築する
         EbnfSequenceNode seq = new EbnfSequenceNode();
         {
             EbnfLimitedWordNode version
                        = new EbnfLimitedWordNode("version");

             EbnfSequenceNode eqSeq = new EbnfSequenceNode();
             {
                 EbnfRepetitionNode rep1 = new EbnfRepetitionNode(0,1);
                 {
                     EbnfWhiteSpaceNode s = new EbnfWhiteSpaceNode();
                     rep1.setChild(s);
                 }

                 EbnfSymbolNode           eq = new EbnfSymbolNode("=");
             
                 EbnfRepetitionNode rep2 = new EbnfRepetitionNode(0,1);
                 {
                     EbnfWhiteSpaceNode s = new EbnfWhiteSpaceNode();
                     rep2.setChild(s);
                 }
                 
                 eqSeq.addChild(rep1);
                 eqSeq.addChild(eq);
                 eqSeq.addChild(rep2);
             }
             
             EbnfLimitedLiteralNode  num
                     = new EbnfLimitedLiteralNode("1.1");

             seq.addChild(version);
             seq.addChild(eqSeq);
             seq.addChild(num);
         }

         seq.accept(v);

         System.out.println(v.getResult());
     }
}

public class EbnfWhiteSpaceNode implements EbnfNodeAcceptor
{
    private static final EbnfWhiteSpaceNode m_instance
　　　　　　　　　　　　　　　 = new EbnfWhiteSpaceNode();

    protected EbnfWhiteSpaceNode()
    {
    }

    public static EbnfWhiteSpaceNode getInstance()
    {
        return m_instance;
    }

    public void accept(EbnfVisitor v)
    {
        v.visit(this);
    }
}

public class EbnfRepetitionNode implements EbnfNodeAcceptor
{
    public static final int ASTER = -1;

    protected EbnfNodeAcceptor m_child;
    private int m_lowerbound;
    private int m_upperbound;

    public EbnfRepetitionNode(int lower, int upper)
    {
        m_child = null;
        m_lowerbound = lower;
        m_upperbound = upper;
    }

    public void setChild(EbnfNodeAcceptor child)
    {
        m_child = child;
    }

    public EbnfNodeAcceptor getChild()
    {
        return m_child;
    }

    public int getUpper()
    {
        return m_upperbound;
    }

    public int getLower()
    {
        return m_lowerbound;
    }

    public void accept(EbnfVisitor v)
    {
        v.visit(this);
    }
}

public class Sample3Visitor extends EbnfVisitor
{
    private boolean m_result;
    private int              m_index;
    private ArrayList<Token> m_list;

    public Sample3Visitor()
    {
        m_result = true;
        
        m_index = 0;
        
        //字句解析で取得したトークン列の構成
        m_list = new ArrayList<Token>();
        WordToken       token1 = new WordToken("version", 0, 7);
        WhiteSpaceToken token2 = new WhiteSpaceToken(7,1);
        SymbolToken     token3 = new SymbolToken("=", 8, 1);
        LiteralToken    token4 = new LiteralToken("1.1", 9, 3);
        m_list.add(token1);
        m_list.add(token2);
        m_list.add(token3);
        m_list.add(token4);
    }

    public void visit(EbnfWhiteSpaceNode n)
    {
        Token token = m_list.get(m_index);
        
        if(token instanceof WhiteSpaceToken)
        {
            m_index++;
            m_result = true;
        }
        else
        {
            m_result = false;
        }
    }

    public void visit(EbnfRepetitionNode n)
    {
        int upper = n.getUpper();
        int lower = n.getLower();
        EbnfNodeAcceptor node = n.getChild();
        int size = children.size();
        int okCount=0;

        boolean okFlag = true;
        
        //上限値がない場合
        if (upper == EbnfRepetitionNode.ASTER)
        {
            //無限ループ処理
            while(true)
            {
                int count = m_index;
                
                //子ノード評価を行う
                node.accept(this);

                //評価結果がOKの場合
                if (m_result)
                {
                    //OKカウントを+1する
                    okCount++;
                }
                //評価結果がNGの場合
                else
                {
                    int count2 = m_index;
                    okFlag = (count == count2);
                    
                    //ループ処理を中断する
                    break;
                }
            }
        }
        //上限値がある場合
        else
        {
            //処理ループ(0～上限値まで)
            for (int i=0; i<upper; i++)
            {
                int count = m_index;

                //子ノード評価を行う
                node.accept(this);

                //評価結果がOKの場合
                if (m_result)
                {
                    //OKカウントを+1する
                    okCount++;
                }
                //評価結果がNGの場合
                else
                {
                    int count2 = m_index;
                    okFlag = (count == count2);
                    
                    //ループ処理を中断する
                    break;
                }
            }
        }

        //OKカウントが下限値より少ない場合
        if(okCount<lower)
        {
            //評価NG
            m_result = false;
        }
        //OKカウントが下限値より多い場合
        else
        {
            //評価OK
            m_result = okFlag;
        }
    }

    public boolean getResult(){割愛}
    public void visit(EbnfLimitedWordNode n){割愛}
    public void visit(EbnfLimitedLiteralNode n){割愛}
    public void visit(EbnfSymbolNode n){割愛}
    public void visit(EbnfSequenceNode n){割愛}
}