ExpressionGrammar.hpp

// <ExpressionGrammar.hpp> -*- C++ -*-
 
#define BOOST_SPIRIT_USE_PHOENIX_V3 0
 
#pragma once
 
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
 
#include "sparta/statistics/Expression.hpp"
#include "sparta/simulation/TreeNode.hpp"
 
#include <string>
 
// Alias deep boost namespaces
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
 
 
namespace sparta {
    namespace statistics {
        namespace expression {
 
            namespace grammar {
 
 
class ExpressionGrammar :
    public qi::grammar<std::string::const_iterator,
                       Expression(),
                       ascii::space_type>
{
    struct constants_
        : qi::symbols<typename std::iterator_traits<std::string::const_iterator>::value_type,
                      Expression>
    {
        constants_();
 
    }; // struct constants_
 
    struct builtin_vars_
        : qi::symbols<typename std::iterator_traits<std::string::const_iterator>::value_type,
                      std::function<Expression(void)>>
    {
        builtin_vars_(sparta::TreeNode* n,
                      std::vector<const TreeNode*>& used);
 
    }; // struct builtin_vars_
 
    struct variable_ : qi::grammar<std::string::const_iterator,
                                   Expression(),
                                   ascii::space_type>
    {
        variable_(sparta::TreeNode* n,
                  std::vector<const TreeNode*>& used,
                  const StatisticPairs & report_si);
 
        qi::rule<std::string::const_iterator,
                 Expression(),
                 ascii::space_type> start;
        qi::rule<std::string::const_iterator,
                 std::string(),
                 ascii::space_type> str;
    }; // struct variable_
 
    struct ufunc_
        : qi::symbols<typename std::iterator_traits<std::string::const_iterator>::value_type,
                      std::function<Expression(Expression&)>>
    {
        typedef double(*fptr_dd_t)(double);
 
        typedef bool(*fptr_bd_t)(long double);
 
        ufunc_(std::vector<const TreeNode*>& already_used);
 
    }; // ufunc_
 
    struct bfunc_
        : qi::symbols<typename std::iterator_traits<std::string::const_iterator>::value_type,
                      std::function<Expression(Expression&, Expression&)>>
    {
        typedef double(*fptr_ddd_t)(double, double);
 
        typedef const double&(*fptr_drdrdrt)(const double&, const double&);
 
        bfunc_(const std::vector<const TreeNode*>& already_used);
 
    }; // bfunc_
 
    struct tfunc_
        : qi::symbols<typename std::iterator_traits<std::string::const_iterator>::value_type,
                      std::function<Expression(Expression&, Expression&, Expression&)>>
    {
        typedef double(*fptr_dddd_t)(double, double, double);
 
        typedef const double&(*fptr_drdrdrdrt)(const double&, const double&, const double&);
 
        tfunc_(const std::vector<const TreeNode*>& already_used);
 
    }; // tfunc_
 
 
    // Sub-Parsers
 
    struct constants_ constants;
    struct builtin_vars_ builtin_vars;
    struct ufunc_ ufunc;
    struct bfunc_ bfunc;
    struct tfunc_ tfunc;
    struct variable_ var;
 
 
    // Configuration
 
    sparta::TreeNode* const root_;
 
    std::vector<const TreeNode*> already_used_;
 
 
    // Rules
 
    typedef qi::rule<std::string::const_iterator,
                     Expression(),
                     ascii::space_type> ExpressionRule;
 
    ExpressionRule expression,
                   term,
                   factor,
                   primary;
 
public:
 
    ExpressionGrammar(sparta::TreeNode* root,
                      std::vector<const TreeNode*>& already_used,
                      const StatisticPairs &report_si);
 
 
}; // struct grammar
 
            } // namespace grammar
        } // namespace expression
    } // namespace statistics
} // namespace sparta