Grammars.h

Go to the documentation of this file.

// ============================================================================
#ifndef GAUDIKERNEL_GRAMMARS_H
#define GAUDIKERNEL_GRAMMARS_H 1
#ifdef __GNUC__
#warning \
  The headers GaudiKernel/Grammars.h and GaudiKernel/Parsers.icpp are deprecated \
  and will be removed from the next release of Gaudi. You should migrate your \
  code the new pasers based on Boost.Spirit 2.
#endif
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <cctype>
// ============================================================================
// Boost.Spirit
// ============================================================================
#include <boost/version.hpp>
#if BOOST_VERSION >= 103800
// FIXME: Move to the new boost::spirit::classic namespace
#if !defined(BOOST_SPIRIT_USE_OLD_NAMESPACE)
#define BOOST_SPIRIT_USE_OLD_NAMESPACE
#endif
#include <boost/spirit/include/classic.hpp>
#include <boost/spirit/include/phoenix1.hpp>
#else
#include <boost/spirit.hpp>
#include <boost/spirit/phoenix.hpp>
#endif
#include <boost/bind.hpp>

// ============================================================================
// ============================================================================
namespace Gaudi
{
  namespace Parsers
  {
    // ========================================================================
    using namespace boost::spirit ;
    // ========================================================================
    using namespace phoenix ;
    // ========================================================================
   template <typename T>
    struct ClosureGrammar : public boost::spirit::closure < ClosureGrammar<T>,T >
    {
      typedef  boost::spirit::closure<ClosureGrammar, T> closure;
      typename closure::member1 val;
    };
    // ========================================================================
    template <typename T1,typename T2>
    struct AttributesClosureGrammar
      : public boost::spirit::closure<AttributesClosureGrammar<T1,T2>,T1,T2>
    {
      typedef boost::spirit::closure<AttributesClosureGrammar, T1,T2> closure;
      typename closure::member1 val;
      typename closure::member2 attrs;
    };
    // ========================================================================
    class BoolGrammar : public grammar
    <
      BoolGrammar,
      ClosureGrammar<bool>::context_t
    >
    {
    public:
      typedef bool ResultT;
    public:
      template <typename ScannerT>
      struct definition
      {
        definition( BoolGrammar const &self)
        {
          boolean_literal
            = true_literal[self.val = true] | false_literal[self.val = false];
          true_literal
            = str_p("true" ) | str_p("True" ) | str_p("TRUE" ) | str_p("1");
          false_literal
            = str_p("false") | str_p("False") | str_p("FALSE") | str_p("0");
        }
        rule<ScannerT> const& start() const
        { return boolean_literal;}
        rule<ScannerT> boolean_literal,true_literal,false_literal;
      };
    };
    // ========================================================================
    template<typename RT=char>
    class CharGrammar : public grammar
    <
      CharGrammar<RT> , typename ClosureGrammar<RT>::context_t
    >
    {
    public:
      typedef RT ResultT;
    public:
      template <typename ScannerT>
      struct definition
      {
        definition( CharGrammar<RT> const &self)
        {
          char_literal
            = int_parser<RT>()[self.val=arg1]
            | ('\''
               >> ( str_p("\\'")[self.val='\'']
                    | (anychar_p[self.val=arg1]-'\'') )>>'\'');
        }
        rule<ScannerT> const& start() const
        { return char_literal; }
        rule<ScannerT> char_literal;
      };
    };
    // ========================================================================
    template<typename RT=int>
    class IntGrammar : public grammar
    <
      IntGrammar<RT>,
      typename ClosureGrammar<RT>::context_t
    >
    {
    public:
      typedef RT ResultT;
    public:
      template <typename ScannerT>
      struct definition
      {
        definition( IntGrammar<RT> const &self)
        {
          int_literal = lexeme_d[int_parser<RT>()[self.val=arg1]
            >> !(ch_p('u') | ch_p('U') | ch_p('l') | ch_p('L'))];
        }
        rule<ScannerT> const& start() const { return int_literal; }
        rule<ScannerT> int_literal;
      };
    };
    // ========================================================================
    template<typename RT=double>
    class RealGrammar : public grammar
    <
      RealGrammar<RT>,typename ClosureGrammar<RT>::context_t
    >
    {
    public:
      typedef RT ResultT;
    public:
      template <typename ScannerT>
      struct definition
      {
        definition( RealGrammar const &self)
        {
          real_literal
            = lexeme_d[real_parser<RT,
            real_parser_policies<RT> >()[self.val = arg1]
            >> !(ch_p('f') | ch_p('F') | ch_p('l') | ch_p('L'))];
        }
        rule<ScannerT> const& start() const
        { return real_literal; }
        rule<ScannerT> real_literal;
      };
    };
    // ========================================================================
    class StringGrammar : public grammar
    <
      StringGrammar, ClosureGrammar<std::string>::context_t
    >
    {
    public:
      typedef std::string ResultT;
      void matchString() const
      {
        for ( std::string::iterator cur=this->val().begin();
              cur!=this->val().end();cur++)
        { if(std::isspace(*cur) ) { *cur = ' '; } }
      }
    public:
        template <typename ScannerT>
        struct definition
        {
          definition( StringGrammar const &self )
          {
            string_literal = (lexeme_d
              [
               ('"' >> (*( str_p("\\\"")
                           |
                           (anychar_p-'"') ))
                [self.val = construct_<std::string>
                 (arg1,arg2)] >>
                '"')
               |
               ('\'' >> (*( str_p("\\'")
                            |
                            (anychar_p-'\'') ))
                [self.val = construct_<std::string>
                 (arg1,arg2)]>>
                '\'')])[boost::bind(&StringGrammar::matchString,&self)];
          }
          rule<ScannerT> const& start() const { return string_literal; }
          rule<ScannerT> string_literal;
        };
      };
    // ========================================================================
    class SkipperGrammar : public grammar<SkipperGrammar>
    {
    public:
      SkipperGrammar ( const bool skipnewline = true )
        : m_skipnewline(skipnewline){}
    public:
      bool skipnewline() const{return m_skipnewline;}
    public:
      template <typename ScannerT>
      struct definition
      {
        definition( SkipperGrammar const& self)
        {
          if ( self.skipnewline() )
          {
            skip
              =   space_p
              |   comment_p("//")     // C++ comment
              |   comment_p("/*", "*/")     // C comment
              ;
          }
          else
          {
            skip
              =   (space_p-eol_p)
              |   comment_p("//")     // C++ comment
              |   comment_p("/*", "*/")     // C comment
              ;
          }
        }
        rule<ScannerT>  skip;
        rule<ScannerT> const& start() const { return skip; }
      };
    private:
      bool m_skipnewline;
    };
    // ========================================================================
    template <typename KeyGrammarT, typename ValueGrammarT>
    class PairGrammar : public grammar
    <
      PairGrammar<KeyGrammarT,ValueGrammarT>,
      typename ClosureGrammar<
      std::pair<typename KeyGrammarT::ResultT,
                typename ValueGrammarT::ResultT> >::context_t
    >
    {
    public:
      typedef typename KeyGrammarT::ResultT KeyT;
      typedef typename ValueGrammarT::ResultT ValueT;
      typedef std::pair<KeyT,ValueT> ResultT;
    public:
      PairGrammar ( const std::string&  delim = "," )
        : m_delim(delim) {}
    public:
      void matchFirst  ( const KeyT&   first  ) const { this->val().first = first; }
      void matchSecond ( const ValueT& second ) const { this->val().second = second; }
    public:
      template <typename ScannerT>
      struct definition
      {
        definition( PairGrammar const &self)
        {
          para
            = (
               str_p("(")
               >> (grkey[boost::bind(&PairGrammar::matchFirst,&self,_1)])
               >> self.delim().c_str()
               >> (grvalue[boost::bind(&PairGrammar::matchSecond,&self,_1)])
               >> str_p(")")
               ) ;
        }
        rule<ScannerT> const& start() const { return para; }
        rule<ScannerT> para;
        KeyGrammarT grkey;
        ValueGrammarT grvalue;
      };
    public:
      const std::string& delim() const { return m_delim ; }
      void setDelim ( const std::string& delim ) { m_delim = delim;}
    private:
      std::string m_delim;
    };
    // ========================================================================
    template <typename GrammarT>
    class VectorGrammar : public grammar
    <
      VectorGrammar<GrammarT> ,
      typename ClosureGrammar<std::vector<typename GrammarT::ResultT> >::context_t
    >
    {
    public:
      typedef typename GrammarT::ResultT ValueT;
      typedef std::vector<ValueT> ResultT;
      typedef VectorGrammar<GrammarT> SelfT;
    public:
      void matchItem(const ValueT& value) const { this->val().push_back(value); }
    public:
      template <typename ScannerT>
      struct definition
      {
        definition(SelfT const &self)
        {
          inner =
            !(gr[boost::bind(&VectorGrammar::matchItem,&self,_1)]
              >> *(','>>gr[boost::bind(&VectorGrammar::matchItem,&self,_1)]));
          vec =
            '[' >> inner >> ']' |  // a'la python list
            '(' >> inner >> ')' |  // a'la python tuple
            '{' >> inner >> '}' ;  // like obsolete list from opts-grammar
        }
        rule<ScannerT> const& start() const { return vec; }
        rule<ScannerT> vec,inner;
        GrammarT gr;
      };
    };
    // ========================================================================
    template <typename KeyGrammarT, typename ValueGrammarT>
    class MapGrammar : public grammar
    <
      MapGrammar<KeyGrammarT,ValueGrammarT>,
      typename AttributesClosureGrammar
      < std::map<typename KeyGrammarT::ResultT,
                 typename ValueGrammarT::ResultT>,
        std::pair<typename KeyGrammarT::ResultT,
                  typename ValueGrammarT::ResultT> >::context_t
    >
    {
    public:
      typedef typename KeyGrammarT::ResultT KeyT;
      typedef typename ValueGrammarT::ResultT ValueT;
      typedef std::map<KeyT,ValueT> ResultT;
    public:
      void matchItem  () const
      {
        //this->val().insert(this->attrs());
        this->val()[this->attrs().first] = this->attrs().second ;
      }
      void matchFirst ( const KeyT&   value ) const {  this->attrs().first = value ; }
      void matchSecond( const ValueT& value ) const { this->attrs().second = value ; }
    public:
      template <typename ScannerT>
      struct definition
      {
        definition( MapGrammar const &self)
        {
          vec
            = ('{'>> inner_list >> '}') | ('['>>inner_list>>']');
          inner_list
            =
            !( inner[boost::bind(&MapGrammar::matchItem,&self)]
               >> *( ch_p(',') >>
                     inner[boost::bind(&MapGrammar::matchItem,&self)] )
               );
          inner
            =
            grKey[boost ::bind(&MapGrammar::matchFirst,&self,_1)]
              >> ( ch_p('=') | ch_p(':'))
              >> grValue[boost::bind(&MapGrammar::matchSecond,&self,_1)] ;
        }
        KeyGrammarT grKey;
        ValueGrammarT grValue;
        rule<ScannerT> const& start() const { return vec; }
        rule<ScannerT> vec,inner, inner_list ;
      };
    };
    // ========================================================================
  } // end of namespace Gaudi::Parsers
} // end of namespace Gaudi
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIKERNEL_GRAMMARS_H
// ============================================================================