translation_unit_parser.h

来自「Boost provides free peer-reviewed portab」· C头文件 代码 · 共 1,346 行 · 第 1/4 页

            throw_expression
                =   ch_p(T_THROW) >> !assignment_expression
                ;

            HANNIBAL_REGISTER_RULE( ta_throw_expression);
            ta_throw_expression
                =   ch_p(T_THROW) >> !ta_assignment_expression
                ;

            HANNIBAL_REGISTER_RULE( conditional_expression);
            conditional_expression
                =   logical_or_expression 
                    >> !(   
                                ch_p(T_QUESTION_MARK) 
                            >>  expression 
                            >>  ch_p(T_COLON) 
                            >>  assignment_expression
                        )
                ;

            HANNIBAL_REGISTER_RULE( ta_conditional_expression);
            ta_conditional_expression
                =   ta_logical_or_expression 
                    >> !(   
                                ch_p(T_QUESTION_MARK) 
                            >>  ta_expression 
                            >>  ch_p(T_COLON) 
                            >>  ta_assignment_expression
                        )
                ;
            
            HANNIBAL_REGISTER_RULE( expression);
            expression
                =   assignment_expression % ch_p(T_COMMA);
                                
            HANNIBAL_REGISTER_RULE( ta_expression);
            ta_expression
                =   ta_assignment_expression % ch_p(T_COMMA);

            HANNIBAL_REGISTER_RULE( assignment_operator);
            assignment_operator
                =   pp(T_ASSIGN)         
                |   pp(T_ANDASSIGN)
                |   pp(T_ORASSIGN)         
                |   pp(T_XORASSIGN) 
                |   pp(T_DIVIDEASSIGN)     
                |   pp(T_MINUSASSIGN) 
                |   pp(T_PERCENTASSIGN)    
                |   pp(T_PLUSASSIGN)
                |   pp(T_SHIFTLEFTASSIGN)  
                |   pp(T_SHIFTRIGHTASSIGN) 
                |   pp(T_STARASSIGN)
                ;


            // we skip quite a few rules here, since we're not interested in operator precedence 
            // just now.            
            HANNIBAL_REGISTER_RULE( logical_or_expression);
            logical_or_expression
                =   cast_expression % expression_operator
                ;

            HANNIBAL_REGISTER_RULE( ta_logical_or_expression);
            ta_logical_or_expression
                =   cast_expression % ta_expression_operator
                ;
            
            HANNIBAL_REGISTER_RULE( expression_operator );
            expression_operator 
                =   ta_expression_operator | pp(T_GREATER)
                ;
            
            HANNIBAL_REGISTER_RULE( ta_expression_operator );
            ta_expression_operator 
                =   pp(T_OROR) 
                |   pp(T_ANDAND) 
                |   pp(T_OR) 
                |   pp(T_XOR) 
                |   pp(T_AND)
                |   pp(T_NOTEQUAL) 
                |   pp(T_EQUAL) 
                |   pp(T_GREATEREQUAL) 
                |   pp(T_LESSEQUAL)
                |   pp(T_LESS) 
                |   pp(T_SHIFTLEFT) 
                |   pp(T_SHIFTRIGHT)
                |   pp(T_PLUS) 
                |   pp(T_MINUS) 
                |   pp(T_PERCENT) 
                |   pp(T_DIVIDE) 
                |   pp(T_STAR)
                |   pp(T_ARROWSTAR) 
                |   pp(T_DOTSTAR) 
                ;

            HANNIBAL_REGISTER_RULE( cast_expression);
            cast_expression
                =   ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN) 
                    >>  cast_expression
                |   unary_expression
                ;
            
            HANNIBAL_REGISTER_RULE( unary_expression);
            unary_expression
                =     postfix_expression
                |   ch_p(T_PLUSPLUS) >> cast_expression
                |   ch_p(T_MINUSMINUS) >> cast_expression
                |   unary_operator >> cast_expression
                |   ch_p(T_SIZEOF) >> unary_expression
                |   ch_p(T_SIZEOF) 
                    >> ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN)
                |   new_expression
                |   delete_expression
                ;
            
            HANNIBAL_REGISTER_RULE( unary_operator);
            unary_operator 
                =   ch_p(T_STAR) 
                |   pp(T_AND) 
                |   pp(T_PLUS) 
                |   ch_p(T_MINUS) 
                |   ch_p(T_NOT) 
                |   pp(T_COMPL)
                ;

            HANNIBAL_REGISTER_RULE( new_expression);
            new_expression
                =  !ch_p(T_COLON_COLON) >> ch_p(T_NEW) >> !new_placement
                    >>  ( 
                            new_type_id >> !new_initializer
                        |   ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN) >> !new_initializer
                        )
                ;
            
            HANNIBAL_REGISTER_RULE( new_placement);
            new_placement
                =   ch_p(T_LEFTPAREN) >> expression_list >> ch_p(T_RIGHTPAREN)
                ;
            
            HANNIBAL_REGISTER_RULE( new_type_id);
            new_type_id
                =   type_specifier_seq >> !new_declarator
                ;
            
            HANNIBAL_REGISTER_RULE( new_declarator);
            new_declarator
                =   ptr_operator >> !new_declarator
                |   direct_new_declarator
                ;
            
            HANNIBAL_REGISTER_RULE( direct_new_declarator);
            direct_new_declarator
                =  *(   pp(T_LEFTBRACKET) >> expression >> pp(T_RIGHTBRACKET) ) 
                    >>  pp(T_LEFTBRACKET) >> constant_expression >> pp(T_RIGHTBRACKET)
                ;
            
            HANNIBAL_REGISTER_RULE( new_initializer);
            new_initializer
                =   ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN)
                ;
            
            HANNIBAL_REGISTER_RULE( delete_expression);
            delete_expression
                =  !ch_p(T_COLON_COLON) >> ch_p(T_DELETE) >> cast_expression
                |  !ch_p(T_COLON_COLON) >> ch_p(T_DELETE) 
                    >>  pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET) 
                    >>  cast_expression
                ;
            
            HANNIBAL_REGISTER_RULE( postfix_expression);
            postfix_expression
                =   simple_postfix_expression >> *postfix_expression_helper
                ;
            
            HANNIBAL_REGISTER_RULE( simple_postfix_expression);
            simple_postfix_expression
                =   primary_expression
                |   simple_type_specifier 
                    >>  ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN)
                |   ch_p(T_DYNAMICCAST) 
                    >>  ch_p(T_LESS) >> type_id >> ch_p(T_GREATER) 
                    >>  ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN)
                |   ch_p(T_STATICCAST) 
                    >>  ch_p(T_LESS) >> type_id >> ch_p(T_GREATER) 
                    >>  ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN)
                |   ch_p(T_REINTERPRETCAST) 
                    >>  ch_p(T_LESS) >> type_id >> ch_p(T_GREATER) 
                    >>  ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN)
                |   ch_p(T_CONSTCAST) 
                    >>  ch_p(T_LESS) >> type_id >> ch_p(T_GREATER) 
                    >>  ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN)
                |   ch_p(T_TYPEID) 
                    >>  ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN)
                |   ch_p(T_TYPEID)
                    >> ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN)
                ;
            
            HANNIBAL_REGISTER_RULE( postfix_expression_helper );
            postfix_expression_helper 
                =   pp(T_LEFTBRACKET) >> expression >> pp(T_RIGHTBRACKET)
                |   ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN)
                |   ch_p(T_DOT) >> !ch_p(T_TEMPLATE) >> !ch_p(T_COLON_COLON) >> id_expression
                |   ch_p(T_ARROW) >> !ch_p(T_TEMPLATE) >> !ch_p(T_COLON_COLON) >> id_expression
                |   ch_p(T_DOT) >> pseudo_destructor_name
                |   ch_p(T_ARROW) >> pseudo_destructor_name
                |   ch_p(T_PLUSPLUS)
                |   ch_p(T_MINUSMINUS)
                ;
            
            HANNIBAL_REGISTER_RULE( pseudo_destructor_name);
            pseudo_destructor_name
                =  !ch_p(T_COLON_COLON) >> !nested_name_specifier 
                    >>  (   
                            type_name >> ch_p(T_COLON_COLON) >> ch_p(T_COMPL) >> type_name
                        |   ch_p(T_COMPL) >> type_name
                        )
                ;


            HANNIBAL_REGISTER_RULE(constant_expression);
            constant_expression
                =   conditional_expression
                ;

            HANNIBAL_REGISTER_RULE(ctor_initializer);
            ctor_initializer
                =   ch_p(T_COLON) >> mem_initializer_list
                ;

            HANNIBAL_REGISTER_RULE(mem_initializer_list);
            mem_initializer_list
                =   mem_initializer % ch_p(T_COMMA)
                ;

            HANNIBAL_REGISTER_RULE(mem_initializer);
            mem_initializer
                =   mem_initializer_id 
                >>  comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN))
                // TODO: restore after assignment expression has been implemented
                //ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN)
                ;

            HANNIBAL_REGISTER_RULE(mem_initializer_id);
            mem_initializer_id
                =  !ch_p(T_COLON_COLON) >> !nested_name_specifier >> class_name
                |   ch_p(T_IDENTIFIER)
                ;

            //
            // the eps_p is added to allow skipping of trailing whitespace 
            // (post-skip)
            //
            HANNIBAL_REGISTER_RULE(translation_unit);
            translation_unit
                =  !declaration_seq >> end_p; 
                ;

            HANNIBAL_REGISTER_RULE(odd_language_extension);
            odd_language_extension    // read: microsoft extensions
                =   extension_type_decorator 
                >> !comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN))
                ;

            HANNIBAL_REGISTER_RULE(declaration_seq);
            declaration_seq
                =  +declaration HANNIBAL_TRACE_ACTION( "declaration")
                ;

            HANNIBAL_REGISTER_RULE(declaration);
            declaration
                =   template_declaration
                |   explicit_instantiation
                |   explicit_specialization
                |   linkage_specification
                |   namespace_definition
                |   block_declaration
                |   function_definition
                ;

            HANNIBAL_REGISTER_RULE(block_declaration);
            block_declaration
                =   simple_declaration
                |   asm_definition
                |   namespace_alias_definition
                |   using_declaration
                |   using_directive
                ;

            HANNIBAL_REGISTER_RULE(simple_declaration);
            simple_declaration
                =  !decl_specifier_seq >> !init_declarator_list 
                    >>  ch_p(T_SEMICOLON)
                ;

            HANNIBAL_REGISTER_RULE(asm_definition);
            asm_definition
                =   ch_p(T_ASM) 
                    >>  ch_p(T_LEFTPAREN) >> ch_p(T_STRINGLIT) >> ch_p(T_RIGHTPAREN)
                    >>  ch_p(T_SEMICOLON)
                ;

            HANNIBAL_REGISTER_RULE(init_declarator_list);
            init_declarator_list
                =   init_declarator % ch_p(T_COMMA)
                ;

            HANNIBAL_REGISTER_RULE(init_declarator);
            init_declarator
                =   declarator >> !initializer
                ;

            HANNIBAL_REGISTER_RULE(initializer);
            initializer
                =   ch_p(T_ASSIGN) >> initializer_clause
                |   ch_p(T_LEFTPAREN) >> expression_list >> ch_p(T_RIGHTPAREN)
                ;

            HANNIBAL_REGISTER_RULE(initializer_clause);
            initializer_clause
                =   assignment_expression
                |   ch_p(T_LEFTBRACE) >> initializer_list 
                    >> !ch_p(T_COMMA) >> ch_p(T_RIGHTBRACE)
                |   ch_p(T_LEFTBRACE) >> ch_p(T_RIGHTBRACE)
                ;

            HANNIBAL_REGISTER_RULE(initializer_list);
            initializer_list
                =   initializer_clause % ch_p(T_COMMA)
                ;

            HANNIBAL_REGISTER_RULE(expression_list);
            expression_list
                =   assignment_expression % ch_p(T_COMMA)
                ;

            HANNIBAL_REGISTER_RULE(namespace_alias_definition);
            namespace_alias_definition