ExpressionParser.h

Go to the documentation of this file.

#ifndef _utl_ExpressionParser_h_
#define _utl_ExpressionParser_h_

#include <utl/SymbolTable.h>

#include <utl/ExpressionParser.h>
#include <utl/AugerUnits.h>
#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>

// #define BOOST_SPIRIT_DEBUG

#include <boost/version.hpp>
#if BOOST_VERSION >= 103800
#  define BOOST_SPIRIT_USE_OLD_NAMESPACE
#  include <boost/spirit/include/classic_parser.hpp>
#  include <boost/spirit/include/classic.hpp>
#  include <boost/spirit/include/phoenix1_binders.hpp>
#  include <boost/spirit/include/phoenix1_functions.hpp>
#else
#  include <boost/spirit/core/parser.hpp>
#  include <boost/spirit.hpp>
#  include <boost/spirit/phoenix/binders.hpp>
#  include <boost/spirit/phoenix/primitives.hpp>
#  include <boost/spirit/phoenix/functions.hpp>
#endif

#include <string>
#include <map>
#include <iostream>
#include <iomanip>
#include <sstream>


namespace utl {

  template<class Grammar, class Symbols>
  class ExpressionParser {

  public:
    ExpressionParser() = default;
    ExpressionParser(utl::SymbolTable& variables) : fVariables(variables) { }

    double
    Evaluate(const std::string& expression_in)
      const
    {
      double result = 0;
      std::string expression = expression_in;  // todo: non-const really needed ???
      std::string::iterator firstChar = expression.begin();
      const std::string::iterator lastChar = expression.end();
      boost::spirit::parse_info<std::string::iterator> info;
      do {
        info =
          boost::spirit::parse(
            firstChar, lastChar,
            (fVariables.empty() ?
              Grammar(result, Symbols::GetSymbolMap()) :
              Grammar(result, Symbols::GetSymbolMap(), fVariables)),
            boost::spirit::space_p
          );
        if (!info.hit) {  // not successful parsing
          std::ostringstream err;
          const int errPosition = info.stop - firstChar;
          const char errChar = expression[errPosition];
          if (errChar == '-' || errChar == '+')
            err << "Bad symbol";
          if (errChar == '(' || errChar == ')')
            err << "Bad bracket";
          else
            err << "Parsing error";
          err << " at location " << errPosition << " \'" << errChar << "\'";
          ERROR(err);
          throw XMLParseException(err.str());
          firstChar = info.stop;  // next start point
        } else if (!info.full) {  // ok, but no full match
          const std::string err = "Parsing incomplete";
          ERROR(err);
          throw XMLParseException(err);
        }
      } while(!info.full && info.hit);    // full match and parsing is ok
      return result;
    }

    SymbolTable& GetVariables() { return fVariables; }
    const SymbolTable& GetVariables() const { return fVariables; }
    int GetNVariables() const { return fVariables.size(); }

    bool HasVariable(const std::string& name) const { return fVariables.count(name); }
    void SetVariable(const std::string& name, const double& v) { fVariables[name] = v; }
    double GetVariable(const std::string& name) const { return fVariables.find(name)->second; }

  private:
    mutable utl::SymbolTable fVariables;

  };

}


#endif