PFunctionGrammar.h

Go to the documentation of this file.

/***************************************************************************
 
  PFunctionGrammar.h
 
  Author: Andreas Suter
  e-mail: andreas.suter@psi.ch
 
  Header-only grammar for parsing function entries in msr-file FUNCTION blocks.
  This version uses Boost.Spirit X3 in header-only mode for maximum compatibility.
 
***************************************************************************/
 
/***************************************************************************
 *   Copyright (C) 2007-2026 by Andreas Suter                              *
 *   andreas.suter@psi.ch                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef _PFUNCTIONGRAMMAR_H_
#define _PFUNCTIONGRAMMAR_H_
 
// Check Boost version - require 1.61+ for Spirit X3
#include <boost/version.hpp>
#if BOOST_VERSION < 106100
#  error "Boost version 1.61.0 or higher is required for Spirit X3. Please upgrade Boost."
#endif
 
#include "PFunctionAst.h"
#include <boost/spirit/home/x3.hpp>
 
namespace x3 = boost::spirit::x3;

namespace musrfit { namespace grammar
{
  using x3::int_;
  using x3::double_;
  using x3::lit;
  using x3::lexeme;
  using x3::attr;

  // Symbol tables - using inline to avoid multiple definition errors

  struct additive_op_ : x3::symbols<ast::optoken>
  {
    additive_op_()
    {
      add("+", ast::op_plus)("-", ast::op_minus);
    }
  };
 
  inline additive_op_ additive_op;  

  struct multiplicative_op_ : x3::symbols<ast::optoken>
  {
    multiplicative_op_()
    {
      add("*", ast::op_times)("/", ast::op_divide);
    }
  };
 
  inline multiplicative_op_ multiplicative_op;  

  struct fun_tok_ : x3::symbols<ast::funid>
  {
    fun_tok_()
    {
      add
        ("COS",   ast::fun_cos)
        ("SIN",   ast::fun_sin)
        ("TAN",   ast::fun_tan)
        ("COSH",  ast::fun_cosh)
        ("SINH",  ast::fun_sinh)
        ("TANH",  ast::fun_tanh)
        ("ACOS",  ast::fun_acos)
        ("ASIN",  ast::fun_asin)
        ("ATAN",  ast::fun_atan)
        ("ACOSH", ast::fun_acosh)
        ("ASINH", ast::fun_asinh)
        ("ATANH", ast::fun_atanh)
        ("LOG",   ast::fun_log)
        ("LN",    ast::fun_ln)
        ("EXP",   ast::fun_exp)
        ("SQRT",  ast::fun_sqrt);
    }
  };
 
  inline fun_tok_ fun_tok;  

  struct const_tok_ : x3::symbols<ast::constant::type>
  {
    const_tok_()
    {
      add("PI", ast::constant::pi)("GAMMA_MU", ast::constant::gamma_mu);
    }
  };
 
  inline const_tok_ const_tok;  

  // Grammar Rules - Forward Declarations

  x3::rule<class assignment, ast::assignment> const assignment = "assignment";

  x3::rule<class expression, ast::expression> const expression = "expression";

  x3::rule<class term, ast::expression> const term = "term";

  x3::rule<class factor, ast::operand> const factor = "factor";

  x3::rule<class constant, ast::constant> const constant = "constant";

  x3::rule<class parameter, ast::parameter> const parameter = "parameter";

  x3::rule<class map_ref, ast::map_ref> const map = "map";

  x3::rule<class function_call, ast::function_call> const function = "function";

  x3::rule<class power_call, ast::power_call> const power = "power";

  // Grammar Rule Definitions

  auto const assignment_def =
      lit("FUN") >> int_ >> '=' >> expression;

  auto const expression_def =
      term >> *(additive_op >> term);

  auto const term_def =
      factor >> *(multiplicative_op >> factor);

  auto const factor_def =
      double_
      | constant
      | parameter
      | map
      | function
      | power
      | ('(' >> expression >> ')');

  auto const constant_def =
      (const_tok >> attr(false) >> attr(0))
      | (lit("B")  >> attr(ast::constant::field)  >> attr(false) >> attr(0))
      | (lit("-B") >> attr(ast::constant::field)  >> attr(true)  >> attr(0))
      | (lit("EN")  >> attr(ast::constant::energy) >> attr(false) >> attr(0))
      | (lit("-EN") >> attr(ast::constant::energy) >> attr(true)  >> attr(0))
      | (lit('T')  >> attr(ast::constant::temp) >> attr(false) >> int_)
      | (lit("-T") >> attr(ast::constant::temp) >> attr(true)  >> int_);

  auto const parameter_def =
      (lexeme[lit("-PAR") >> int_] >> attr(true))
      | (lit("PAR") >> int_ >> attr(false));

  auto const map_def =
      (lexeme[lit("-MAP") >> int_] >> attr(true))
      | (lit("MAP") >> int_ >> attr(false));

  auto const function_def =
      fun_tok >> '(' >> expression >> ')';

  auto const power_def =
      lit("POW") >> '(' >> expression >> ',' >> expression >> ')';

  BOOST_SPIRIT_DEFINE(
    assignment,
    expression,
    term,
    factor,
    constant,
    parameter,
    map,
    function,
    power
  )
 
}}

namespace musrfit {
  inline auto const& function_grammar()
  {
    return grammar::assignment;
  }
}
 
#endif // _PFUNCTIONGRAMMAR_H_