ParserGrammar.h

Go to the documentation of this file.

// $Id: ParserGrammar.h,v 1.10 2007/10/02 09:42:59 marcocle Exp $
// ============================================================================
#ifndef JOBOPTIONSSVC_PARSERGRAMMAR_H
#define JOBOPTIONSSVC_PARSERGRAMMAR_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <string>
#include <vector>
// ============================================================================
// Boost
// ============================================================================
#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>
#else
#include <boost/spirit.hpp>
#endif
#include <boost/bind.hpp>
#include <boost/tuple/tuple.hpp>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/Grammars.h"
#include "GaudiKernel/ToStream.h"
// ============================================================================
// Local
// ============================================================================
#include "ParserUtils.h"
#include "ParserActions.h"
// ============================================================================
namespace Gaudi
{
  namespace Parsers
  {
    // ========================================================================
    using namespace boost::spirit ;
    using namespace phoenix;
    // ========================================================================
    typedef boost::spirit::position_iterator<std::string::const_iterator>
    IteratorT;
    // ========================================================================
    class IdentifierGrammar : public grammar
    <
      IdentifierGrammar, ClosureGrammar<std::string>::context_t
    >
    {
    public:
      typedef std::string ResultT;
    public:
      template <typename ScannerT>
      struct definition
      {
        definition( IdentifierGrammar const &self )
        {
          //-----------------------------------------------------------------
          // KEYWORDS
          //-----------------------------------------------------------------
          keywords =
            "#include" ,
            "#units"   ,
            "#ifdef"   ,
            "#ifndef"  ,
            "#endif"   ,
            "#else"    ,
            "WIN32"    ;
          identifier
            = (lexeme_d[ (alpha_p >> *(alnum_p | '_'))
                         - (keywords >>
                            (anychar_p - (alnum_p | '_')))])
            [self.val = construct_<std::string>(arg1,arg2)];
        }
        symbols<> keywords;
        rule<ScannerT> const& start() const
        { return identifier; }
        rule<ScannerT> identifier;
      };
    };
    // ========================================================================
    class PropertyGrammar: public grammar
        <
                PropertyGrammar,
                ClosureGrammar<std::vector<std::string> >::context_t
        >
    {
        public:
          typedef std::vector<std::string> ResultT;
        public:
              template <typename ScannerT>
              struct definition
              {
                definition(PropertyGrammar const &self )
                {
                                ns = (ident >> *("::">>ident))[ns.val = construct_<std::string>(arg1,arg2)]>>".";
                                property = +(ns[PushBack(self.val)]) >> ident[PushBack(self.val)];

                }
                IdentifierGrammar ident;
                rule<ScannerT> const& start() const
                { return property; }
                rule<ScannerT,ClosureGrammar<std::string>::context_t>  ns;
                rule<ScannerT> property;
              };
    };
    // ========================================================================
    class RealUnitsGrammar : public boost::spirit::grammar
    < RealUnitsGrammar,AttributesClosureGrammar<std::string,
                             boost::tuple<IteratorT, long double> >::context_t >
    {
    public:
      typedef long double ResultT;
      RealUnitsGrammar():m_parser(NULL){}
    public:
      template <typename ScannerT>
      struct definition
      {
        definition(RealUnitsGrammar const &self)
        {
          real_literal
            = (
               longest_d[grInt[boost::bind(&RealUnitsGrammar::matchReal,&self,_1)]
                |grReal[boost::bind(&RealUnitsGrammar::matchReal,&self,_1)]]
               >> eps_p[boost::bind(&RealUnitsGrammar::matchPosition,&self,_2)]
               >>!(!ch_p('*')
               >>grUnit
               [boost::bind(&RealUnitsGrammar::matchUnit,&self,_1)]
               )) [boost::bind(&RealUnitsGrammar::matchRealUnits,&self)];
        }
        RealGrammar<long double> grReal;
        IntGrammar<int> grInt;
        IdentifierGrammar grUnit;
        boost::spirit::rule<ScannerT> const& start() const
        { return real_literal; }
        boost::spirit::rule<ScannerT> real_literal;
      };
      // Action when we recognize real with unit
      void matchRealUnits() const
      {
        val() = Gaudi::Utils::toString ( attrs().get<1>() );
      }

      // Action when we recognize real (without unit)
      void matchReal(ResultT value) const
      { attrs().get<1>()=value; }

      // Action for saving position
      void matchPosition(IteratorT value) const
      { attrs().get<0>()=value; }

      // Action when we recognize unit
      void matchUnit(const std::string& unit) const
      {
        if (NULL == m_parser) return;
        file_position fpos = attrs().get<0>().get_position();
        Position pos(fpos.file,fpos.line,fpos.column);

        attrs().get<1>() *= m_parser->matchUnit(unit,pos);
      }

      void setParser(Parser* parser){m_parser = parser;}
    private:
      Parser* m_parser;
    };
    // ========================================================================
    class UnitsFileGrammar : public boost::spirit::grammar
    <
      UnitsFileGrammar, AttributesClosureGrammar<IteratorT,
                             boost::tuple<std::string,double> >::context_t >
    {
    public:
      UnitsFileGrammar(Parser* parser)
        : m_parser(parser) {}
    public:
      void matchUnit() const
      {
        file_position fpos = val().get_position();
        m_parser->matchUnitEntry
          (attrs().get<0>(),attrs().get<1>(),
           Position(fpos.file,fpos.line,fpos.column));
        attrs().get<1>() = 1;
      }
      void matchLeftReal(double real) const
      { attrs().get<1>() = real; }

      void matchLeftUnit(std::string newunit) const
      { attrs().get<0>() = newunit; }

      void matchRight(std::string value) const
      { attrs().get<1>() =
          boost::lexical_cast<double>(value)/attrs().get<1>(); }
    public:
      template <typename ScannerT>
      struct definition
      {
        definition(UnitsFileGrammar const &self)
        {
          boost::tuples::get<1>(self.attrs()) = 1;
          grUnit.setParser(self.parser());
          units_file = *(unit[boost::bind(&UnitsFileGrammar::matchUnit,&self)]);
          unit =
            (real_p[boost::bind(&UnitsFileGrammar::matchLeftReal,&self,_1)]
             >> eps_p)[self.val=arg1] >> !ch_p('*')
             >>grNewUnit[boost::bind(&UnitsFileGrammar::matchLeftUnit,&self,_1)]
             >>"=">>grUnit[boost::bind(&UnitsFileGrammar::matchRight,&self,_1)];
        }
        RealUnitsGrammar grUnit;
        IdentifierGrammar grNewUnit;
        boost::spirit::rule<ScannerT> const& start() const
        { return units_file;}
        boost::spirit::rule<ScannerT> units_file,unit;
      };
    public:
      Parser* parser() const{ return m_parser;}
    private:
      Parser* m_parser;
    };
    // ========================================================================
    typedef AttributesClosureGrammar
    <boost::tuple<std::string,std::vector<std::string> > ,
     boost::tuple<int> > ValueClosureT;
    // ========================================================================
    class ValueGrammar : public boost::spirit::grammar
    <ValueGrammar, ValueClosureT::context_t>
    {
    public:
      ValueGrammar() : m_parser(NULL){}
    public:
      void matchBrace(bool isopen) const
      {
        if ( isopen ){ attrs().get<0>()++; }
        else         { attrs().get<0>()--; }
      }
      void matchVectorValue(std::string value) const
      { if(attrs().get<0>()==1){val().get<1>().push_back(value); } }

      void matchValue(std::string value) const{ val().get<0>() = value; }

      Parser* parser() const { return m_parser;}

      void setParser(Parser* parser){ m_parser = parser; }

    public:

      template <typename ScannerT>
      struct definition
      {
        definition(ValueGrammar const &self)
        {
          realunits_grammar.setParser(self.parser());
          //-----------------------------------------------------------------
          // OPERATORS
          //-----------------------------------------------------------------
          chlit<>     O_DOT('.');
          chlit<>     O_COMMA(',');
          value_rule = value[boost::bind(&ValueGrammar::matchValue,&self,_1)];
          value =
            vectorvalue[value.val=arg1]
            | vector_type[value.val="["+arg1+"]"]
            | property_link[value.val=arg1]
            ;
          // ------------------------------------------------------------------
          vectorvalue_list
            = !(
                value[vectorvalue_list.val=arg1][boost::bind(&ValueGrammar::matchVectorValue,&self,_1)]
                >> *(',' >>value[vectorvalue_list.val+=","+arg1][boost::bind(&ValueGrammar::matchVectorValue,&self,_1)])
                );
          // ------------------------------------------------------------------
          vector_type =
            (
             ch_p('{')[boost::bind(&ValueGrammar::matchBrace,&self,true)]
             >> vectorvalue_list
             [vector_type.val=arg1]
             >> ch_p('}')[boost::bind(&ValueGrammar::matchBrace,&self,false)]
             )
            |
            (ch_p('[') [boost::bind(&ValueGrammar::matchBrace,&self,true)]
             >> vectorvalue_list
             [vector_type.val=arg1]
             >> ch_p(']')[boost::bind(&ValueGrammar::matchBrace,&self,false)]
             );
          // ------------------------------------------------------------------
          vectorvalue =
            listvalue[vectorvalue.val=arg1]
            | longest_d[
                        literalvalue[vectorvalue.val=arg1]
                        | mapvalue[vectorvalue.val=arg1]
            ];
          // ------------------------------------------------------------------
          listvalue = '(' >> vectorvalue[listvalue.val="("+arg1]
                          >> *(O_COMMA[listvalue.val+=","]
                          >> vectorvalue[listvalue.val+=arg1]) >>ch_p(')')[listvalue.val+=")"];
          // ------------------------------------------------------------------
          mapvalue = literalvalue[mapvalue.val=arg1]
            >> (ch_p('=')[mapvalue.val+="="] | ch_p(':')[mapvalue.val+=":"])
            >> value[mapvalue.val+=arg1]
            ;
          // ------------------------------------------------------------------
          literalvalue =
            realunits_grammar[literalvalue.val = arg1]
            |
            boolean_grammar[AssignBoolToString(literalvalue.val)]
            |
            string_grammar[literalvalue.val = std::string("\"")+arg1+std::string("\"")];
          // ------------------------------------------------------------------
          property_link = ('@'>>property_grammar)
            [property_link.val=construct_<std::string>(arg1,arg2)];
          // ------------------------------------------------------------------
        }
        PropertyGrammar   property_grammar;
        StringGrammar     string_grammar;
        BoolGrammar       boolean_grammar;
        IntGrammar<long>  int_grammar;
        RealUnitsGrammar  realunits_grammar;

        boost::spirit::rule<ScannerT> value_rule;
        boost::spirit::rule
        <ScannerT,ClosureGrammar<std::string>::context_t> value,literalvalue,
          vectorvalue,listvalue,mapvalue,vectorvalue_list, vector_type,
          property_link;
        boost::spirit::rule<ScannerT> const& start() const { return value_rule; }
      };
      // ============================================================================
    private:
      Parser* m_parser;
    };
    // ========================================================================
    typedef AttributesClosureGrammar
    <IteratorT,boost::tuple<bool,std::string,std::vector<std::string> > > ParserClosureT;
    // ========================================================================
    class ParserGrammar :
      public grammar<ParserGrammar, ParserClosureT::context_t> {
    public:
      ParserGrammar(Parser* parser){m_parser=parser;}
      virtual ~ParserGrammar() {}

      Parser* parser() const {return m_parser;}

      void matchInclude(const std::string& fileName) const{
        if(!doActions()) return;
        file_position fpos = this->val().get_position();
        Position pos(fpos.file,fpos.line,fpos.column);
        m_parser->matchInclude(fileName,pos);
      }
      void matchUnits(const std::string& fileName) const{
        if(!doActions()) return;
        file_position fpos = this->val().get_position();
        Position pos(fpos.file,fpos.line,fpos.column);
        m_parser->matchUnits(fileName,pos);
      }
      void matchAssign(std::vector<std::string> params) const{
        if(!doActions()) return;

        // position where statement appears
        file_position fpos = val().get_position();
        Position pos(fpos.file,fpos.line,fpos.column);

        // get value representation. It's two modes string and vector of strings
        std::string value = attrs().get<1>();
        std::vector<std::string> vectorValues = attrs().get<2>();

        // check if value is vector
        bool isVector = false;
        if(vectorValues.size()>0 || value=="[]"){
          isVector = true;
        }else{
          vectorValues.push_back(value);
        }

        // extract object, option name and sign
        std::string objectName;
        std::string delim;
        std::vector< std::string >::const_iterator cur;
        for ( cur  = params.begin();
              *(cur+1) != "#"; cur++ ){
          objectName += delim + *cur;
          delim = ".";
        }

        std::string optionName = *cur;
        std::string sign = *(cur+2);

        Parser::Sign oper;
        if(sign == "+="){
          oper = Parser::S_PLUSASSIGN;
        }else if(sign == "-="){
          oper = Parser::S_MINUSASSIGN;
        }else{
          oper = Parser::S_ASSIGN;
        }

        m_parser->matchAssign
          (objectName, optionName, oper,
           vectorValues,pos,isVector);
        vectorValues.clear();
      }
      // ======================================================================
      void matchPlatform(const std::string& directive) const{
        bool iswin = Gaudi::Parsers::Utils::isWin();
        if(directive=="endif" || (directive=="ifdef" && iswin)
          || (directive=="ifndef" && !iswin)){
          attrs().get<0>() = true;
        } else {
          attrs().get<0>() = !attrs().get<0>();
        }
      }
      // ======================================================================
      void matchPrint(bool on) const{
        file_position fpos = this->val().get_position();
        Position pos(fpos.file,fpos.line,fpos.column);
        m_parser->setIsPrint(on,pos);
      }
      // ======================================================================
      void matchPrintOptions(bool on) const{
        file_position fpos = this->val().get_position();
        Position pos(fpos.file,fpos.line,fpos.column);
        m_parser->setIsPrintOptions(on,pos);
      }
      // ======================================================================
      void matchValue(boost::tuple<std::string,std::vector<std::string> > value) const{
        if(!doActions()) return;
        attrs().get<1>() = value.get<0>();
        attrs().get<2>() = value.get<1>();
      }
      // ======================================================================
      bool doActions() const{ return  attrs().get<0>();}
      // ======================================================================
      template <typename ScannerT>
      struct definition {

        definition(ParserGrammar const &self) {
          value_grammar.setParser(self.parser());
          boost::tuples::get<0>(self.attrs()) = true;
          // ------------------------------------------------------------------
          // OPERATORS
          // ------------------------------------------------------------------
          chlit<>     O_SEMI(';');
          chlit<>     O_DOT('.');

          strlit<>    O_ASSIGN("=");
          strlit<>    O_PLUSASSIGN("+=");
          strlit<>    O_MINUSASSIGN("-=");

          // ------------------------------------------------------------------
          // TOKENS
          // ------------------------------------------------------------------
                                        strlit<> T_SHELL("#!");
          strlit<> T_IFDEF("#ifdef");
          strlit<> T_IFNDEF("#ifndef");
          strlit<> T_ELSE("#else");
          strlit<> T_ENDIF("#endif");
          strlit<> T_WIN32("WIN32");
          strlit<> T_INCLUDE("#include");
          strlit<> T_UNITS("#units");
          strlit<> T_PRAGMA("#pragma");
          strlit<> T_PRINTOPTIONS("#printOptions");
          // ------------------------------------------------------------------
          job_options_file =
            !shell_statement >> *(platform_statement | platform_dependency);
          // ------------------------------------------------------------------
                                        shell_statement = comment_p(T_SHELL);
          // ------------------------------------------------------------------
                            platform_statement = assertable_statement | pragma_statement;
          // ------------------------------------------------------------------
          assertable_statement =
            include_statement
            [boost::bind(&ParserGrammar::matchInclude,&self,_1)]
            | units_statement
            [boost::bind(&ParserGrammar::matchUnits,&self,_1)]
            | assign_statement
            [boost::bind(&ParserGrammar::matchAssign,&self,_1)];
          // ------------------------------------------------------------------
          assertion_statement =
            T_IFDEF
            [boost::bind(&ParserGrammar::matchPlatform,&self,"ifdef")]
            |
            T_IFNDEF
            [boost::bind(&ParserGrammar::matchPlatform,&self,"ifndef")];
          // ------------------------------------------------------------------
          platform_dependency =
            assertion_statement
              >> T_WIN32
              >> *platform_statement
              >> !(
                   T_ELSE[boost::bind(&ParserGrammar::matchPlatform,&self,"else")]
                   >> *platform_statement
                   )
              >> T_ENDIF
            [boost::bind(&ParserGrammar::matchPlatform,&self,"endif")];
          // ------------------------------------------------------------------
          include_statement =
            T_INCLUDE
              >> (string_grammar[include_statement.val=arg1]>>eps_p)
            [self.val=arg1];
          // ------------------------------------------------------------------
          units_statement =
            T_UNITS
              >> (string_grammar[units_statement.val=arg1]>>eps_p)
            [self.val=arg1];;
          // ------------------------------------------------------------------
          pragma_statement = pragma | printopt_statement;
          // ------------------------------------------------------------------
          pragma = (T_PRAGMA>>eps_p)[self.val=arg1] >> str_p("print")
                            >> ((str_p("on") | str_p("ON"))
                                [boost::bind(&ParserGrammar::matchPrint,&self,true)]
                                | (str_p("off") | str_p("OFF"))
                                [boost::bind(&ParserGrammar::matchPrint,&self,false)]) ;
          // ------------------------------------------------------------------
          printopt_statement = ((T_PRINTOPTIONS>>eps_p)[self.val = arg1] >>
            !as_lower_d["full"])
            [boost::bind(&ParserGrammar::matchPrintOptions,&self,true)];
          // ------------------------------------------------------------------
          assign_statement =
                  property_grammar[assign_statement.val=arg1]
              >> eps_p[PushBack(assign_statement.val,"#")]
              >> (
                  O_ASSIGN[PushBack(assign_statement.val,"=")]
                  |O_PLUSASSIGN[PushBack(assign_statement.val,"+=")]
                  |O_MINUSASSIGN[PushBack(assign_statement.val,"-=")]
                  )
              >>  value_grammar[boost::bind(&ParserGrammar::matchValue,&self,_1)]
              >> O_SEMI;
          // ------------------------------------------------------------------
        }
        // --------------------------------------------------------------------
        PropertyGrammar property_grammar;
        IdentifierGrammar identifier_grammar;
        StringGrammar string_grammar;
        ValueGrammar value_grammar;
        // --------------------------------------------------------------------
        rule<ScannerT,ClosureGrammar<std::string>::context_t>  include_statement,
          units_statement;

        rule<ScannerT,ClosureGrammar<std::vector<std::string> >::context_t> assign_statement;

        rule<ScannerT>
        job_options_file,
                                        shell_statement,
          platform_statement,
          assertable_statement,
          assertion_statement,
          platform_dependency,
          pragma_statement,
          pragma,
          printopt_statement;
        // --------------------------------------------------------------------
        rule<ScannerT> const& start() const {
          return job_options_file;
        }
        // --------------------------------------------------------------------
      };
      // ======================================================================
    private:
      Parser* m_parser;
    };
  } // end of namespace Parsers
} // end of namespace Gaudi
// ============================================================================
// The END
// ============================================================================
#endif // JOBOPTIONSSVC_PARSERGRAMMAR_H
// ============================================================================