第011回_構文解析Sample1および2

pulic class AnalyzeSyntax
{
    public static void main(String args[])
    {
        //EBNFデータツリーを作成する
        //Literalトークンの中でかつ1.1とだけマッチングOKとなるノード
        EbnfLimitedLiteralNode node = new EbnfLimitedLiteralNode("1.1");
        
        //Visitorを作成する
        //  コンストラクタ内でトークンリストを作成する
        Sample1Visitor v = new Sample1Visitor();

        //EBNFデータツリーをを巡回する
        node.accept(v);

        //結果を表示する
        System.out.println(v.getResult());
    }
}

public class EbnfLimitedLiteralNode implements EbnfNodeAccepter
{
    private final String m_matchText;

    public EbnfLimitedLiteralNode(String text)
    {
        m_matchText = text;
    }

    public boolean equals(String text)
    {
        return m_matchText.equals(text);
    }

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

public class Sample1Visitor extends EbnfVisitor
{
    private boolean m_result;
    private ArrayList<Token> m_list;

    public Sample1Visitor()
    {
        //字句解析がまだないので、入力トークン列を作成する。
        m_list = new ArrayList<Token>();
        LiteralToken token = new LiteralToken("1.1", 0, 3);
        m_list.add(token);
    }

    public boolean getResult()
    {
        return m_result;
    }


    @Override
    public void visit(EbnfLimitedLiteralNode n)
    {
        Token token = m_list.get(0);
        if(token instanceof LiteralToken)
        {
             LiteralToken ltoken = (LiteralToken)token;
             m_result = n.equals(ltoken.getString());
        }
        else
        {
             m_result = false;
        }
    }
}

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

        //EBNFデータツリーを構築する
        EbnfLimitedWordNode version = new EbnfLimitedWordNode("version");
        EbnfSymbolNode           eq = new EbnfSymbolNode("=");
        EbnfLimitedLiteralNode  num = new EbnfLimitedLiteralNode("1.1");

        EbnfSequenceNode seq = new EbnfSequenceNode();
        seq.addChild(version);
        seq.addChild(eq);
        seq.addChild(num);

        seq.accept(v);

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

public class EbnfSequenceNode implements EbnfNodeAccepter
{
    private ArrayList<EbnfNodeAccepter> m_children;

    public EbnfSequenceNode()
    {
        m_children = new ArrayList<EbnfNodeAccepter>();
    }

    public void addChild(EbnfNodeAccepter child)
    {
        m_children.add(child);
    }

    public ArrayList<EbnfNodeAccepter> getChildren()
    {
        return m_children;
    }

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

public class EbnfLimitedWordNode implements EbnfNodeAcceptor
{
    private final Pattern m_pattern;

    public EbnfLimitedWordNode(String regex)
    {
        m_pattern = Pattern.compile(regex);
    }

    public boolean equals(String text)
    {
        Matcher m = m_pattern.matcher(text);
        return m.matches();
    }

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

public class EbnfSymbolNode implements EbnfNodeAcceptor
{
    private final String m_matchText;

    public EbnfSymbolNode(String text)
    {
        m_matchText = text;
    }

    public boolean equals(String text)
    {
        return m_matchText.equals(text);
    }

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

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

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

    public void visit(EbnfSymbolNode n)
    {
        Token token = m_list.get(m_index);
        if(token instanceof SymbolToken)
        {
            SymbolToken stoken = (SymbolToken)token;
            m_result = n.equals(stoken.getString());
            
            if (m_result)
            {
                m_index++;
            }
            else
            {
                //何もしない
            }
        }
        else
        {
            m_result = false;
        }
    }
    
    public void visit(EbnfLimitedWordNode n)
    {
        Token token =  m_list.get(m_index);
        if(token instanceof WordToken)
        {
            WordToken wtoken = (WordToken)token;
            m_result = n.equals(wtoken.getString());

            if (m_result)
            {
                m_index++;
            }
            else
            {
                //何もしない
            }
        }
        else
        {
            m_result = false;
        }
    }

    public void visit(EbnfSequenceNode n)
    {
        ArrayList<EbnfNodeAccepter> children = n.getChildren();

        for(EbnfNodeAccepter child :children)
        {
            child.accept(this);

            //acceptの結果がOKの場合
            if (m_result)
            {
                //何もしない
            }
            //acceptの結果がNGの場合
            else
            {
                break;
            }
        }
    }

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