jdl_grammar.hpp

Go to the documentation of this file.

//  This file is part of jdl_parser.
//
//  jdl_parser 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 3 of the License, or
//  (at your option) any later version.
//
//  jdl_parser 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 jdl_parser.  If not, see <http://www.gnu.org/licenses/>.

// Copyright Simone Pellegrini 2007-2008; e-mail: motonacciu@gmail.com

#ifndef JDL_GRAMMAR_HPP_
#define JDL_GRAMMAR_HPP_

#include "defs.hpp"

#define BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE
#define BOOST_SPIRIT_ASSERT_EXCEPTION 
//#define BOOST_SPIRIT_GRAMMAR_STARTRULE_TYPE_LIMIT 4

//#define DEBUG
#ifdef DEBUG
        #define BOOST_SPIRIT_DEBUG
#endif

#include <boost/spirit/core.hpp>
#include <boost/spirit/attribute.hpp>
#include <boost/spirit/actor/push_back_actor.hpp>
#include <boost/spirit/error_handling/exceptions.hpp>
#include <boost/spirit/utility/confix.hpp>
//#include <boost/spirit/utility/grammar_def.hpp> 

#include <jdl_parser/tree.hpp>
#include <jdl_parser/utils.hpp>

using namespace boost::spirit;

namespace jdl{
//
//  Parser errors
//
enum Errors{
        attribute_expected,
        expr_expected,
        attrname_expected,
        semicolon_expected,
        colon_expected,
        right_quad_par_expected,
        right_round_par_expected,
        right_graph_par_expected,
        question_mark_expected,
        left_round_par_expected
};
            
assertion<Errors> expect_attribute(attribute_expected);
assertion<Errors> expect_expr(expr_expected);
assertion<Errors> expect_attrname(expect_attrname);
assertion<Errors> expect_semicolon(semicolon_expected);
assertion<Errors> expect_colon(colon_expected);
assertion<Errors> expect_right_quad_par(right_quad_par_expected);
assertion<Errors> expect_right_round_par(right_round_par_expected);
assertion<Errors> expect_right_graph_par(right_graph_par_expected);
assertion<Errors> expect_question_mark(question_mark_expected);
assertion<Errors> expect_left_round_par(left_round_par_expected);

guard<Errors> expr_guard;
//
//  Semantic actions
//

void create(attribute_definition_node &node, parser_stack<boost::shared_ptr<component> >& stack);

void create(conditional_expr& node, parser_stack<boost::shared_ptr<component> >& stack);

void create(binary_expr_node& node, parser_stack<boost::shared_ptr<component> >& stack);

void create(bracket_node& node, parser_stack<boost::shared_ptr<component> >& stack);

void create(dot_node& node, parser_stack<boost::shared_ptr<component> >& stack);

void create(term_node& node, parser_stack<boost::shared_ptr<component> >& stack);

void create(list_node& node, parser_stack<boost::shared_ptr<component> >& stack);

void create(func_call_node& node, parser_stack<boost::shared_ptr<component> >& stack);

void create(unary_expr_node& node, parser_stack<boost::shared_ptr<component> >& stack);

template <typename node_type>
struct push
{
    push(parser_stack<boost::shared_ptr<component> >& node_stack)
    :  _node_stack(node_stack) {}

    void operator()(char const*, char const*) const
    {
#ifdef DEBUG
        Logger::getInstance().debug().out << "Pushing new NODE into stack: " << typeid(node_type).name() << endl;
#endif
                boost::shared_ptr<node_type> node(new node_type());
                create(*node, _node_stack);
                _node_stack.push(node);
#ifdef DEBUG
                _node_stack.print(cout);
#endif
    }
    parser_stack<boost::shared_ptr<component> >& _node_stack;
};

template <typename node_type>
struct push_leaf
{
    push_leaf(parser_stack<boost::shared_ptr<component> >& node_stack)
    :  _node_stack(node_stack) {}

    void operator()(char const* begin, char const* end) const
    {
#ifdef DEBUG
        Logger::getInstance().debug().out << "Pushing new LEAF into stack: " << typeid(node_type).name() << endl;
#endif  
        boost::shared_ptr<component> node(new node_type(begin,end));
                _node_stack.push(node);
#ifdef DEBUG
                _node_stack.print(cout);
#endif
    }
    parser_stack<boost::shared_ptr<component> >& _node_stack;
};

void create_activation_record(parser_stack<boost::shared_ptr<component> >& node_stack);
    
struct new_ar
{
    new_ar(parser_stack<boost::shared_ptr<component> >& node_stack)
    :  _node_stack(node_stack) {}
 
    void operator()(char const c) const
    {
                create_activation_record(_node_stack);
    }
    
    void operator()(char const* begin, char const* end) const
    {
                create_activation_record(_node_stack);
    }

    parser_stack<boost::shared_ptr<component> >& _node_stack;
};

void reduce_stack(parser_stack<boost::shared_ptr<component> >& node_stack);
    
struct reduce
{
    reduce(parser_stack<boost::shared_ptr<component> >& node_stack)
    :  _node_stack(node_stack) {}

    void operator()(char const c) const
    {
                reduce_stack(_node_stack);
    }
    
    void operator()(char const* begin, char const* end) const
    {
        reduce_stack(_node_stack);
    }
    
    parser_stack<boost::shared_ptr<component> >& _node_stack;
};

void discard_activation_record(parser_stack<boost::shared_ptr<component> >& node_stack);

struct discard
{
    discard(parser_stack<boost::shared_ptr<component> >& node_stack)
    :  _node_stack(node_stack) {}

    void operator()(char const c) const
    {
#ifdef DEBUG
                Logger::getInstance().debug().out << "Discarding activation record." << endl;
#endif
                discard_activation_record(_node_stack);
    }
    
    void operator()(char const* begin, char const* end) const
    {
#ifdef DEBUG
        Logger::getInstance().debug().out << "Discarding activation record." << endl;
#endif
        discard_activation_record(_node_stack);
    }

    parser_stack<boost::shared_ptr<component> >& _node_stack;
};

//
//  Guard reaction
//
struct discard_ar
{
        discard_ar(parser_stack<boost::shared_ptr<component> >& node_stack)
    :  _node_stack(node_stack) {}
    
    template <typename ScannerT, typename ErrorT>
    error_status<>
    operator()(ScannerT const& /*scan*/, ErrorT const& error) const
    {
#ifdef DEBUG
                cout << "Discarding activation record." << endl;
#endif
        if(error.descriptor == question_mark_expected || 
                error.descriptor == left_round_par_expected){
                        discard_activation_record(_node_stack);
                        _node_stack.new_ar();
#ifdef DEBUG
                _node_stack.print(cout);
#endif
                return error_status<>(error_status<>::fail);
        }else{
#ifdef BOOST_SPIRIT_DEBUG
                cout << "Rethrowing error!" << endl;
                cout << "Error type: " << error.descriptor << endl;
#endif
                return error_status<>(error_status<>::rethrow);
        }
    }
    parser_stack<boost::shared_ptr<component> >& _node_stack;
};

//
//  JDL grammar
//
struct jdl_grammar : public grammar<jdl_grammar>
{       
        jdl_grammar(parser_stack<boost::shared_ptr<component> >& stack): node_stack(stack){}
        
    template <typename ScannerT>
    struct definition
    {
        
        definition(jdl_grammar const& self)
        {   
                /* 
                 * def_list := (attribute_definition ';' | comment)+
             *                     | record_expression ';'?
             */
                def_list =
                        // Attribute definition list
                ( +( attribute_definition >> 
                         expect_semicolon(ch_p(';')[new_ar(self.node_stack)]) 
                         | comment 
                   )
                )[discard(self.node_stack)][push<term_node>(self.node_stack)]
                // A record '[', ']' delimited attribute definition list.
                | record_expression >> !ch_p(';')
                ;
            
            comment = 
                comment_p("//") 
                |       comment_p("#")
                ;
            
            /* 
             * expression := simple_expression '?' expression ':' expression
             *                     | simple_expression
             */
            expression =
                expr_guard( (simple_expression >>  
                                expect_question_mark(ch_p('?')[new_ar(self.node_stack)]) >> 
                                expect_expr(expression)[reduce(self.node_stack)] >>             
                                expect_colon(ch_p(':')[new_ar(self.node_stack)]) >>             
                                expect_expr(expression)[reduce(self.node_stack)])[push<conditional_expr>(self.node_stack)])[discard_ar(self.node_stack)]        
                |       simple_expression
                ;
            
            /* 
             * simple_expression := term1 ( ('||' | '&&') term1 )*
             */
                        simple_expression = 
                                term1 >> 
                                        *( (level1_op[push_leaf<string_node>(self.node_stack)][new_ar(self.node_stack)] >> 
                                            term1[reduce(self.node_stack)])[push<binary_expr_node>(self.node_stack)] 
                                         )
                                ;
                                
                        /* 
                         * term1 := term2 ( ('|' | '&' | '^') term2 )*
             */
                        term1 = 
                                term2 >> 
                                        *( (level2_op[push_leaf<string_node>(self.node_stack)][new_ar(self.node_stack)] >> 
                                            term2[reduce(self.node_stack)])[push<binary_expr_node>(self.node_stack)] 
                                         )
                                ;       
                        
                        /* 
                         * term2 := term3 ( ('==' | '!=' | 'is' | 'isnt'
                         *                                      | '<' | '>' | '<=' | '>=') term3 )*
             */
                        term2 = 
                                term3 >> 
                                        *( (level3_op[push_leaf<string_node>(self.node_stack)][new_ar(self.node_stack)] >> 
                                            term3[reduce(self.node_stack)])[push<binary_expr_node>(self.node_stack)] 
                                         )
                                ;                               
                        
                        /* 
                         * term3 := term4 ( ('<<' | '>>' | '>>>') term4 )*
             */
                        term3 = 
                                term4 >> 
                                        *( (level4_op[push_leaf<string_node>(self.node_stack)][new_ar(self.node_stack)] >> 
                                            term4[reduce(self.node_stack)])[push<binary_expr_node>(self.node_stack)] 
                                         )
                                ;       
                        
                        /* 
                         * term4 := term5 ( ('+' | '-') term5 )*
             */
                        term4 = 
                                term5 >> 
                                        *( (level5_op[push_leaf<string_node>(self.node_stack)][new_ar(self.node_stack)] >> 
                                            term5[reduce(self.node_stack)])[push<binary_expr_node>(self.node_stack)] 
                                         )
                                ;       
                        
                        /* 
                         * term5 := factlor ( ('*' | '/' | '%') factor )*
             */ 
                        term5 = 
                                factor >> 
                                        *( (level6_op[push_leaf<string_node>(self.node_stack)][new_ar(self.node_stack)] >> 
                                            factor[reduce(self.node_stack)])[push<binary_expr_node>(self.node_stack)] 
                                         )
                                ;       
                        
                        /* 
                         * factor := ('+' | '-' | '~' |  '!') suffix_expr
                         *                       | suffix_expr
             */         
                        factor =
                                (unary_op[push_leaf<string_node>(self.node_stack)][new_ar(self.node_stack)] >> 
                                 suffix_expr[reduce(self.node_stack)])[push<unary_expr_node>(self.node_stack)]
                |       suffix_expr 
                ;
              
            level1_op = 
                lexeme_d[
                                        longest_d[chseq_p("||") | "&&"]]
                                        ;
                        
                        level2_op = 
                                lexeme_d[
                                        longest_d[chseq_p("|") | '&' | '^'] ] - "&&" - "||"
                                        ;
                                        
                        level3_op =
                                lexeme_d[
                                        longest_d[chseq_p("==") | "!=" | "is" | "isnt"
                                        | '<' | '>' | "<=" | ">="]] - "<<" - ">>" - ">>>"
                                        ;
                        
                        level4_op =
                                lexeme_d[
                                        longest_d[chseq_p("<<") | ">>" | ">>>"]]
                                        ;
                                        
                        level5_op = 
                                lexeme_d[
                                        longest_d[chseq_p("+") | '-']]
                                        ;
                        
                        level6_op =
                                lexeme_d[
                                        longest_d[chseq_p("*") | '/' | '%']]
                                        ;
               
            unary_op = 
                lexeme_d[ch_p('+') | '-' | '~' |  '!' ]
                ;
            
            /* 
             * suffix_expr := atom ('.' attribute_name | '[' expression ']')*
             */
                suffix_expr = 
                                (atom >> 
                                        *( (ch_p('.')[new_ar(self.node_stack)] >> 
                                                expect_attrname(attribute_name))[reduce(self.node_stack)][push<dot_node>(self.node_stack)]
                                        | 
                                        (ch_p('[')[new_ar(self.node_stack)] >> 
                                                expect_expr(expression) >> expect_right_quad_par(ch_p(']')))[reduce(self.node_stack)][push<bracket_node>(self.node_stack)] )
                                )       
                                ;
            
            /* 
             * atom := '(' expression ')'
             *           |  list_expression
             *       |  record_expression
             *       |  function_call
             *       |  literal
             *       |  attribute_name
             *       |  keywords
             */
            atom = 
                                        ( '(' >> expect_expr(expression) >> expect_right_round_par(ch_p(')')) )
                                        | list_expression[push<list_node>(self.node_stack)]
                                        | record_expression
                                        | function_call[push<func_call_node>(self.node_stack)]
                                        | literal               
                                        | attribute_name        
                                        | keywords
                                ;
                        
                        keywords = 
                                lexeme_d[(chseq_p("error") | "false" | "true" | "undefined" | "parent")[push_leaf<string_node>(self.node_stack)]]
                                ; 
                        
                        /* 
                         * list_expression := '{' ( '}' | list_expr_list )
             */
                        list_expression = 
                                ch_p('{')[new_ar(self.node_stack)] >> 
                                        (ch_p('}')[discard(self.node_stack)]
                                        | list_expr_list)
                                ;
                        
                        /* 
                         * list_expr_list := expression ( (',' list_expr_list) | '}' )
             */
                        list_expr_list = 
                                expect_expr(expression)[reduce(self.node_stack)] >>
                                        (ch_p(',')[new_ar(self.node_stack)] >> list_expr_list
                                        | expect_right_graph_par(ch_p('}')) )
                                ;
                        
                        /* 
                         * record_expression := '[' ( ']' | attribute_def_list )
             */
                        record_expression = 
                                (ch_p('[')[new_ar(self.node_stack)] >>  
                                        attribute_def_list
                                        |       ch_p(']'))[push<term_node>(self.node_stack)]
                                ;
                        
                        /* 
                         * attribute_def_list := comment (']' | attribute_def_list )
                         *                                         | attribute_definition ( ( ';'? comment* ']' ) | ';' attribute_def_list )
             */
                        attribute_def_list =
                                (comment >> (ch_p(']') | attribute_def_list))
                                |       expect_attribute(attribute_definition) >> 
                                        ( !ch_p(';') >> *comment >> ch_p(']') 
                                        | expect_semicolon(ch_p(';'))[new_ar(self.node_stack)] >> attribute_def_list)
                                ;
                        
                        /* 
                         * attribute_definition := attribute_name '=' expression
             */
                        attribute_definition =
                                (attribute_name >> 
                                        ch_p('=')[new_ar(self.node_stack)] >> 
                                        expect_expr(expression)[reduce(self.node_stack)])[push<attribute_definition_node>(self.node_stack)]
                                ;
                        
                        /* 
                         * function_call := unquoted_name '(' ( expression ( ',' expression )* )? ')'
             */
                        function_call = 
                                expr_guard(unquoted_name[push_leaf<string_node>(self.node_stack)] >> 
                                (       expect_left_round_par(ch_p('('))[new_ar(self.node_stack)] >> 
                                        !( expect_expr(expression) >> 
                                                *( (ch_p(',')[new_ar(self.node_stack)] >> expect_expr(expression) )[reduce(self.node_stack)]) 
                                        ) >> expect_right_round_par(ch_p(')'))
                                )[push<term_node>(self.node_stack)][reduce(self.node_stack)])[discard_ar(self.node_stack)]
                                ;
            
            /* 
             * attribute_name := unquoted_name | quoted_name
             */
            attribute_name = 
                                (unquoted_name 
                                |       quoted_name)[push_leaf<string_node>(self.node_stack)]
                                ;
                        
                        /* 
                         * literal := integer_literal | floating_point_literal | string_literal+
             */
                        literal =
                                floating_point_literal[push_leaf<float_node>(self.node_stack)]
                                |       integer_literal[push_leaf<int_node>(self.node_stack)]
                                |       /*+(*/ string_literal /*)*/
                                ;
                        
                        /* 
                         * floating_point_literal := uint_p+ '.' uint_p* exponent?
                         *                                                 | '.' uint_p+ exponent?
                         *                                                 | uint_p+ exponent
                         */
                floating_point_literal = 
                                +uint_p >> '.' >> *uint_p >>  !exponent
                                | '.' >> +uint_p  >> !exponent
                                | +uint_p >> exponent
                                ;
                                
                        /* 
                         * exponent := ('e' | 'E') ('+' | '-')? uint_p+
                         */
                        exponent = 
                                lexeme_d[( ch_p('e') | 'E' ) >> !( ch_p('+') | '-' ) >> +uint_p ]
                                ;

                        nonzero_digit = 
                                range_p('1','9')
                                ;
                                
                integer_literal = 
                                nonzero_digit >> *uint_p
                                | lexeme_d[ ('0' >> *oct_p) ]
                                | lexeme_d[ ('0' >> ( ch_p('x') |  'X' ) >> +hex_p) ]
                                ;

                        string_literal = 
                                ch_p('\"') >> ( *( non_quote | '\'' ) )[push_leaf<string_literal_node>(self.node_stack)] >> '\"'
                                ;
                                
                escaped_char = 
                                lexeme_d[ch_p('n') | 't' | 'b' | 'r' | 'f' | '\\'  | '\"' | '\'']
                                ;

                non_quote =
                                ('\\' >> escaped_char
                                |       lexeme_d['\\' >> oct_p >> !oct_p]
                                |       lexeme_d['\\' >> range_p('0','3') >> oct_p >> oct_p]
                                |       ~ch_p('\"'))
                                ;
                
                quoted_name = 
                                ch_p('\'') >> (+( non_quote | '\"' )) >> '\''
                                ;

                unquoted_name =
                                (lexeme_d[( alpha_p | '_' ) >> *(  alpha_p  | uint_p  | '_' )]) 
                                - "error" - "true" - "false" - "undefined" - "parent"
                                ;
            
                        BOOST_SPIRIT_DEBUG_NODE(attribute_definition);
                        BOOST_SPIRIT_DEBUG_NODE(attribute_def_list);
                        BOOST_SPIRIT_DEBUG_NODE(function_call);
                        BOOST_SPIRIT_DEBUG_NODE(list_expression);
                        BOOST_SPIRIT_DEBUG_NODE(atom);
                        BOOST_SPIRIT_DEBUG_NODE(suffix_expr);
                        BOOST_SPIRIT_DEBUG_NODE(unary_op);
            BOOST_SPIRIT_DEBUG_NODE(factor);
            BOOST_SPIRIT_DEBUG_NODE(binary_op);
            BOOST_SPIRIT_DEBUG_NODE(simple_expression);
            BOOST_SPIRIT_DEBUG_NODE(expression);
            BOOST_SPIRIT_DEBUG_NODE(record_expression);
            BOOST_SPIRIT_DEBUG_NODE(comment);
            BOOST_SPIRIT_DEBUG_NODE(def_list);
            BOOST_SPIRIT_DEBUG_NODE(escaped_char);
                        BOOST_SPIRIT_DEBUG_NODE(string_literal);
                        BOOST_SPIRIT_DEBUG_NODE(letter);
                        BOOST_SPIRIT_DEBUG_NODE(exponent);
                        BOOST_SPIRIT_DEBUG_NODE(floating_point_literal);
                        BOOST_SPIRIT_DEBUG_NODE(integer_literal);
                        BOOST_SPIRIT_DEBUG_NODE(non_quote);
                        BOOST_SPIRIT_DEBUG_NODE(quoted_name);
                        BOOST_SPIRIT_DEBUG_NODE(unquoted_name);
                        BOOST_SPIRIT_DEBUG_NODE(literal);
            BOOST_SPIRIT_DEBUG_NODE(term1); 
            BOOST_SPIRIT_DEBUG_NODE(term2); 
            BOOST_SPIRIT_DEBUG_NODE(term3); 
            BOOST_SPIRIT_DEBUG_NODE(term4); 
            BOOST_SPIRIT_DEBUG_NODE(term5); 
            BOOST_SPIRIT_DEBUG_NODE(level1_op); 
            BOOST_SPIRIT_DEBUG_NODE(level2_op);
            BOOST_SPIRIT_DEBUG_NODE(level3_op);
            BOOST_SPIRIT_DEBUG_NODE(level4_op);
            BOOST_SPIRIT_DEBUG_NODE(level5_op);
            BOOST_SPIRIT_DEBUG_NODE(level6_op);     
            BOOST_SPIRIT_DEBUG_NODE(attribute_name); 
        }

        rule<ScannerT> def_list, expression, simple_expression, binary_op, factor, 
                atom, unary_op, suffix_expr, list_expr_list, list_expression,
                record_expression, attribute_definition, function_call, 
                attribute_def_list, comment, term, level1_op, level2_op, level3_op,
                level4_op, level5_op, level6_op, term1, term2, term3, term4, term5,
                keywords;
        
        rule<ScannerT>  attribute_name, literal, unquoted_name, 
                quoted_name, integer_literal, floating_point_literal, exponent, 
                string_literal, letter, escaped_char, non_quote, nonzero_digit;
                                        
        rule<ScannerT> const&
        start() const { return def_list; }
        
    };
    
        parser_stack<boost::shared_ptr<component> > &node_stack;
};

}
#endif /*JDL_GRAMMAR_HPP_*/

---