UnitGrammar.h

Go to the documentation of this file.

#ifndef _utl_UnitGrammar_h
#define _utl_UnitGrammar_h

#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>
#include <utl/SymbolTable.h>

#include <boost/version.hpp>
#if BOOST_VERSION >= 103800
#  define BOOST_SPIRIT_USE_OLD_NAMESPACE
#  include <boost/spirit/include/classic.hpp>
#  include <boost/spirit/include/phoenix1_binders.hpp>
#  include <boost/spirit/include/phoenix1_functions.hpp>
#else
#  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 <cmath>

namespace utl {

  // Raise X to power of Y template
  struct PowerToImpl {
    template<typename T1, typename T2>
    struct result { typedef double type; };

    template<typename T1, typename T2>
    T1 operator()(T1& t1, T2& t2) const
    { return std::pow(t1, t2); }
  };


  // Create it as a constant Phoenix Function
  const phoenix::function<PowerToImpl> power = PowerToImpl();


  // Unit Grammar Structure
  struct UnitGrammar : public boost::spirit::grammar<UnitGrammar> {
    
    UnitGrammar(double& result, const utl::SymbolTable& symbols)
      : fSymbols(&symbols), fResult(&result) { }

#warning remove this! replace by singleton logic
    UnitGrammar(double& result, const utl::SymbolTable& symbols, utl::SymbolTable& ) :
      fSymbols(&symbols),
      fResult(&result)
    {
      const std::string err = "Cannot initialize UnitGrammar with variables!";
      ERROR(err);
      throw XMLParseException(err);
    }
      
    //double GetResult() const { return fResult; }

    struct SValueClosure : public boost::spirit::closure<SValueClosure, double> {
      member1 value;
    };

    struct SAssignmentClosure : public boost::spirit::closure<SAssignmentClosure, std::string, double> {
      member1 name;
      member2 value;
    };

    struct SStringClosure : public boost::spirit::closure<SStringClosure, std::string> {
      member1 name;
    };

    template<typename ScannerT>
    struct definition {
      definition(UnitGrammar const& self)
      {
        group
          = '('
          >> expression[group.value = phoenix::arg1]
          >> ')'
        ;

        identifier
          = boost::spirit::lexeme_d[(boost::spirit::alpha_p | '_')
          >> *(boost::spirit::alnum_p | '_')][
            identifier.name = phoenix::construct_<std::string>(phoenix::arg1, phoenix::arg2)
          ]
        ;

        statement
          = expression[phoenix::bind(&UnitGrammar::SaveResult)(self, phoenix::arg1)]
          >> (boost::spirit::end_p | ';')
        ;

        literal
          = boost::spirit::longest_d[boost::spirit::int_p[literal.value = phoenix::arg1]
          | boost::spirit::real_p[literal.value = phoenix::arg1]]
        ;

        factor
          = literal[factor.value = phoenix::arg1]
          | group[factor.value = phoenix::arg1]
          | identifier[factor.value = phoenix::bind(&UnitGrammar::Lookup)(self, phoenix::arg1)]
        ;

        term
          = factor[term.value = phoenix::arg1] >>
          *(
            ('^' >> factor[term.value = power(term.value, phoenix::arg1)])
          )
        ;

        expression
          = term[expression.value = phoenix::arg1] >>
          *(
            ('*' >> term[expression.value *= phoenix::arg1])
            | ('/' >> term[expression.value /= phoenix::arg1])
          )
        ;

      }

      boost::spirit::rule<ScannerT> const& start() const { return statement; }
      boost::spirit::rule<ScannerT> statement;
      boost::spirit::rule<ScannerT, SStringClosure::context_t> identifier;
      boost::spirit::rule<ScannerT, SValueClosure::context_t> expression, factor, group, literal, term;
    };

    void SaveResult(const double val) const { *fResult = val; }

    double
    Lookup(const std::string& symbol)
      const
    {
      const SymbolTable::const_iterator it = fSymbols->find(symbol);
      if (it != fSymbols->end()) {
        return it->second;
      }
      // issue exception
      std::string err = 
        "The symbol '" + symbol + "' "
        "is not defined during the evaluaion with the UnitGrammer\n";
      ERROR(err);
      throw XMLParseException(err);
      return 1;
    }

  private:
    const SymbolTable* fSymbols;
    mutable double* fResult;
  };

}


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


namespace utl {  
  typedef ExpressionParser<UnitGrammar, AugerUnits> AugerUnitParser;
}


#endif