Ticket #6460: XpressiveGrammarSample.hpp

#include <boost/xpressive/xpressive.hpp>
#include <boost/xpressive/regex_actions.hpp>

//Class hierarchy into which we would like to parse the data
class testnode
{
public:
        testnode(){};
        testnode(testnode* pChild){m_pChildren.push_back(pChild);};
protected:
        std::vector<testnode*> m_pChildren;
};

class testnodetext : public testnode
{
public:
        testnodetext(std::string sVal){m_sVal=sVal;};
private:
        std::string m_sVal;
};

class testnodeor : public testnode
{
public:
        testnodeor(testnode* pL,testnode* pR){m_pChildren.push_back(pL);m_pChildren.push_back(pR);}
};

class testnodeand : public testnode
{
public:
        testnodeand(testnode* pL,testnode* pR){m_pChildren.push_back(pL);m_pChildren.push_back(pR);}
};

class testnodenot : public testnode
{
public:
        testnodenot(testnode* pNot){m_pChildren.push_back(pNot);};
};



//Boiler plate base class that does most of the 'work' creating the parse tree
//This is somewhat 'equivalent' to the grammar class of spirit
//We can re-use this base for every pointer based grammar we would like to create
template <typename TBase> class XpressiveGrammarBase
{
public:
protected:
        //Functions to allow us to create new nodes as needed
        template<typename Tmk> struct mknode_impl
        {
                mknode_impl(std::deque<TBase*>* paStack): m_paStack(paStack){};
                typedef void result_type;
                void operator()() const
                {
                        m_paStack->push_back(new Tmk());
                }
                template<typename Value1> void operator()(Value1 const &val1) const
                {
                        m_paStack->push_back(new Tmk(val1));
                }
                template<typename Value1,typename Value2> void operator()(Value1 const &val1,Value2 const &val2) const
                {
                        m_paStack->push_back(new Tmk(val1,val2));
                }
                std::deque<TBase*>* m_paStack;
        };
        template<typename Tmk> typename boost::xpressive::detail::make_function::impl<mknode_impl<Tmk> const>::result_type const mknode_()
        {
                return boost::xpressive::detail::make_function::impl<mknode_impl<Tmk> const>()((mknode_impl<Tmk>(&m_aStack)));
        }
        template<typename Tmk, typename A0> typename boost::xpressive::detail::make_function::impl<mknode_impl<Tmk> const, A0 const &>::result_type const mknode_(A0 const &a0)
        {
                return boost::xpressive::detail::make_function::impl<mknode_impl<Tmk> const, A0 const &>()((mknode_impl<Tmk>(&m_aStack)), a0);
        }
        template<typename Tmk, typename A0, typename A1> typename boost::xpressive::detail::make_function::impl<mknode_impl<Tmk> const, A0 const &, A1 const &>::result_type const mknode_(A0 const &a0,A1 const &a1)
        {
                return boost::xpressive::detail::make_function::impl<mknode_impl<Tmk> const, A0 const &, A1 const &>()((mknode_impl<Tmk>(&m_aStack)), a0, a1);
        }
        //Function to retrieve previously created child nodes (so that we can create composite nodes etc.)
        struct getnode_impl
        {
                getnode_impl(std::deque<TBase*>* paStack): m_paStack(paStack){};
                typedef TBase* result_type;
                TBase* operator()() const
                {
                        TBase* pRet = m_paStack->front();
                        m_paStack->pop_front();
                        return pRet;
                }
                std::deque<TBase*>* m_paStack;
        };
        typename boost::xpressive::detail::make_function::impl<getnode_impl const>::result_type const getnode_()
        {
                return boost::xpressive::detail::make_function::impl<getnode_impl const>()((getnode_impl(&m_aStack)));
        }
private:
        std::deque<TBase*> m_aStack;
};


//Example of an actual grammar
class testgrammar: public XpressiveGrammarBase<testnode>
{
public:
        testgrammar(std::string sSearch,testnode*& pRoot)
        {
                using namespace boost::xpressive;

                rulestart               =       bos >> by_ref(rulenode) >> eos
                                                        [ref(pRoot)=getnode_()];;

                rulenode                =       (by_ref(ruletextnode)|by_ref(rulenotnode)|by_ref(ruleandnode)|by_ref(ruleornode));

                ruletextnode    =       (s1 = +(~(set='!','&','|')))
                                                        [mknode_<testnodetext>(s1)];

                rulenotnode             =       '!' >> by_ref(rulenode)
                                                        [mknode_<testnodenot>(getnode_())];

                ruleandnode             =       (by_ref(ruletextnode)|by_ref(rulenotnode)|by_ref(ruleornode)) >> '&' >> by_ref(rulenode)
                                                        [mknode_<testnodeand>(getnode_(),getnode_())];

                ruleornode              =       (by_ref(ruletextnode)|by_ref(rulenotnode)) >> '|' >> by_ref(rulenode)
                                                        [mknode_<testnodeor>(getnode_(),getnode_())];

                regex_search(sSearch,rulestart);
        }
protected:
private:
        boost::xpressive::sregex rulestart, rulenode, rulenotnode, ruleornode, ruleandnode, ruletextnode;
};

int main(int argc, char *argv[])
{
        std::string sTest = "abcd|!xyz|qwerty";
        testnode* pRoot=NULL;
        testgrammar grammar(sTest,pRoot);
        if(pRoot)
        {
                //Success
                //->testnodeor
                //      -> testnodetext ("abcd")
                //      ->testnodeor
                //              ->testnodenot
                //                      ->testnodetext("xyz")
                //              ->testnodetext ("qwerty")
        }
        else
        {
                //Failed
        }
        return 0;
}