translation_unit_parser.h

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

                =   ch_p(T_NAMESPACE) >> ch_p(T_IDENTIFIER) >> ch_p(T_ASSIGN)
                    >>  qualified_namespace_specifier 
                    >>  ch_p(T_SEMICOLON)
                ;

            HANNIBAL_REGISTER_RULE(qualified_namespace_specifier);
            qualified_namespace_specifier
                =  !ch_p(T_COLON_COLON) >> !nested_name_specifier 
                    >>  namespace_name
                ;

            HANNIBAL_REGISTER_RULE(explicit_instantiation);
            explicit_instantiation
                =   template_declaration
                ;

            HANNIBAL_REGISTER_RULE(template_declaration);
            template_declaration
                =  !ch_p(T_EXPORT) >> ch_p(T_TEMPLATE)
                    >>  ch_p(T_LESS) >> template_parameter_list >> ch_p(T_GREATER)
                    >>  declaration
                ;

            HANNIBAL_REGISTER_RULE(template_parameter_list);
            template_parameter_list
                =   template_parameter % ch_p(T_COMMA)
                ;

            HANNIBAL_REGISTER_RULE(template_parameter);
            template_parameter
                =   type_parameter
                |   parameter_declaration
                ;

            HANNIBAL_REGISTER_RULE(type_parameter);
            type_parameter
                =   ch_p(T_CLASS) >> !ch_p(T_IDENTIFIER) 
                    >> !(ch_p(T_ASSIGN) >> type_id)
                |   ch_p(T_TYPENAME) >> !ch_p(T_IDENTIFIER) 
                    >> !(ch_p(T_ASSIGN) >> type_id)
                |   ch_p(T_TEMPLATE) 
                    >>  ch_p(T_LESS) >> template_parameter_list >> ch_p(T_GREATER) 
                    >>  ch_p(T_CLASS) >> !ch_p(T_IDENTIFIER) 
                    >> !(ch_p(T_ASSIGN) >> template_name)
                ;

            HANNIBAL_REGISTER_RULE(template_name);
            template_name
                =   ch_p(T_IDENTIFIER)
                ;

            HANNIBAL_REGISTER_RULE(using_declaration);
            using_declaration     // optimize?
                =   ch_p(T_USING) >> !ch_p(T_TYPENAME) >> !ch_p(T_COLON_COLON) 
                    >>  nested_name_specifier >> unqualified_id 
                    >>  ch_p(T_SEMICOLON)
                |   ch_p(T_USING) >> ch_p(T_COLON_COLON) >> unqualified_id 
                    >>  ch_p(T_SEMICOLON)
                ;

            HANNIBAL_REGISTER_RULE(using_directive);
            using_directive
                =   ch_p(T_USING) >> ch_p(T_NAMESPACE) >> !ch_p(T_COLON_COLON) 
                    >> !nested_name_specifier >> namespace_name 
                    >>  ch_p(T_SEMICOLON)
                ;

            HANNIBAL_REGISTER_RULE(explicit_specialization);
            explicit_specialization
                =   ch_p(T_TEMPLATE) >> ch_p(T_LESS) >> ch_p(T_GREATER) 
                    >>  declaration
                ;

            HANNIBAL_REGISTER_RULE(linkage_specification);
            linkage_specification
                =   ch_p(T_EXTERN) >> ch_p(T_STRINGLIT) 
                    >>  (   ch_p(T_LEFTBRACE) >> !declaration_seq >> ch_p(T_RIGHTBRACE)
                        |   declaration
                        )
                ;

            HANNIBAL_REGISTER_RULE(namespace_definition);
            namespace_definition
                =   named_namespace_definition
                |   unnamed_namespace_definition    // TODO: optimize?
                ;

            HANNIBAL_REGISTER_RULE(named_namespace_definition);
            named_namespace_definition
                =   original_namespace_definition
           //   |   extension_namespace_definition // optimization: extension namespace is syntactically identical
                ;

            HANNIBAL_REGISTER_RULE(original_namespace_definition);
            original_namespace_definition
                =   ch_p(T_NAMESPACE) >> ch_p(T_IDENTIFIER)
                    >>  ch_p(T_LEFTBRACE) >> namespace_body >> ch_p(T_RIGHTBRACE)
                ;

            HANNIBAL_REGISTER_RULE(extension_namespace_definition);
            extension_namespace_definition
                =   ch_p(T_NAMESPACE) >> original_namespace_name 
                    >>  ch_p(T_LEFTBRACE) >> namespace_body >> ch_p(T_RIGHTBRACE)
                ;

            HANNIBAL_REGISTER_RULE(original_namespace_name);
            original_namespace_name
                =   ch_p(T_IDENTIFIER)
                ;

            HANNIBAL_REGISTER_RULE(unnamed_namespace_definition);
            unnamed_namespace_definition
                =   ch_p(T_NAMESPACE) 
                    >>  ch_p(T_LEFTBRACE) >> namespace_body >> ch_p(T_RIGHTBRACE)
                ;

            HANNIBAL_REGISTER_RULE(namespace_body);
            namespace_body
                =  !declaration_seq
                ;

            HANNIBAL_REGISTER_RULE(function_definition);
            function_definition
                =   function_definition_helper 
                    >> !ctor_initializer >> !function_body  // removed semicolons
                |   decl_specifier_seq >> declarator >> function_try_block
                |   declarator >> function_try_block
                ;

            HANNIBAL_REGISTER_RULE(function_definition_helper);
            function_definition_helper
                =   decl_specifier_seq >> declarator
                |  +no_type_decl_specifier >> declarator
                |   declarator
                ;

            HANNIBAL_REGISTER_RULE(function_try_block);
            function_try_block
                =   ch_p(T_TRY) 
                    >> !ctor_initializer >> function_body >> handler_seq
                ;

            HANNIBAL_REGISTER_RULE(handler_seq);
            handler_seq
                =  +handler
                ;

            HANNIBAL_REGISTER_RULE(handler);
            handler // TODO
                =   ch_p(T_CATCH) 
                    >>  comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN)) 
                    >>  compound_statement
                ;

            HANNIBAL_REGISTER_RULE(declarator);
            declarator
                =  *(   ptr_operator 
                    |   odd_language_extension
                    ) 
                    >> direct_declarator
                ;

            HANNIBAL_REGISTER_RULE(direct_declarator);
            direct_declarator
                =   (   declarator_id
                    |   ch_p(T_LEFTPAREN) >> declarator >> ch_p(T_RIGHTPAREN)
                    )  
                    >> *parameters_or_array_spec
                ;

            HANNIBAL_REGISTER_RULE(parameters_or_array_spec);
            parameters_or_array_spec
                =   ch_p(T_LEFTPAREN) >> parameter_declaration_clause >> ch_p(T_RIGHTPAREN)
                    >> !cv_qualifier_seq >> !exception_specification
                |   pp(T_LEFTBRACKET) >> !constant_expression >> pp(T_RIGHTBRACKET)
                ;

            HANNIBAL_REGISTER_RULE(exception_specification);
            exception_specification     // TODO
                =   ch_p(T_THROW) 
                    >>  comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN))
                ;

            HANNIBAL_REGISTER_RULE(abstract_declarator);
            abstract_declarator
                =  +(   ptr_operator 
                    |   odd_language_extension
                    ) 
                    >> !direct_abstract_declarator
                |   direct_abstract_declarator
                ;

            HANNIBAL_REGISTER_RULE(direct_abstract_declarator);
            direct_abstract_declarator
                =   ch_p(T_LEFTPAREN) >> abstract_declarator >> ch_p(T_RIGHTPAREN)
                    >> *direct_abstract_declarator_helper
                ;

            HANNIBAL_REGISTER_RULE(direct_abstract_declarator_helper);
            direct_abstract_declarator_helper
                =   ch_p(T_LEFTPAREN) >> parameter_declaration_clause >> ch_p(T_RIGHTPAREN)
                    >> !cv_qualifier_seq >> !exception_specification
                |   pp(T_LEFTBRACKET) >> !constant_expression >> pp(T_RIGHTBRACKET)
                ;

            HANNIBAL_REGISTER_RULE(parameter_declaration_clause);
            parameter_declaration_clause
                =   parameter_declaration_list >> ch_p(T_COMMA) 
                    >> ch_p(T_ELLIPSIS)
                |  !parameter_declaration_list >> !ch_p(T_ELLIPSIS)
                ;

            HANNIBAL_REGISTER_RULE(parameter_declaration_list);
            parameter_declaration_list
                =   parameter_declaration % ch_p(T_COMMA)
                ;


            HANNIBAL_REGISTER_RULE(parameter_declaration);
            parameter_declaration
                =   decl_specifier_seq 
                    >> !(declarator | abstract_declarator) 
                    >> !(ch_p(T_ASSIGN) >> assignment_expression)
                ;

            HANNIBAL_REGISTER_RULE(declarator_id);
            declarator_id
                =  !ch_p(T_COLON_COLON)
                    >> (   id_expression
                        |  !nested_name_specifier >> type_name
                        )
                ;

            HANNIBAL_REGISTER_RULE(id_expression);
            id_expression
                =   qualified_id
                |   unqualified_id
                ;

            HANNIBAL_REGISTER_RULE(qualified_id);
            qualified_id
                =   nested_name_specifier >> !ch_p(T_TEMPLATE) >> unqualified_id
                ;

            HANNIBAL_REGISTER_RULE(unqualified_id);
            unqualified_id
                =   operator_function_id
                |   conversion_function_id 
                |   ch_p(T_COMPL) >> class_name
                |   template_id
                |   ch_p(T_IDENTIFIER)
                ;

            HANNIBAL_REGISTER_RULE(operator_function_id);
            operator_function_id
                =   ch_p(T_OPERATOR) >> operator_sym // this is called 'operator' in the std grammar
                ;
                
            HANNIBAL_REGISTER_RULE(operator_sym);
            operator_sym 
                =   ch_p(T_DELETE) >> !(pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET))
                |   ch_p(T_NEW) >> !(pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET))
                |   pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET)
                |   ch_p(T_LEFTPAREN) >> ch_p(T_RIGHTPAREN)
                |   pattern_p(OperatorTokenType, TokenTypeMask)
                ;

            HANNIBAL_REGISTER_RULE(conversion_function_id);  
            conversion_function_id
                =   ch_p(T_OPERATOR) >> conversion_type_id
                ;

            HANNIBAL_REGISTER_RULE( conversion_type_id);
            conversion_type_id
                =   type_specifier_seq >> !conversion_declarator
                ;

            HANNIBAL_REGISTER_RULE(type_id);
            type_id
                =   type_specifier_seq >> !abstract_declarator
                ;


            HANNIBAL_REGISTER_RULE(conversion_declarator);
            conversion_declarator
                = ptr_operator >> !conversion_declarator
                ;

            HANNIBAL_REGISTER_RULE(function_body);
            function_body
                = compound_statement
                ;

            HANNIBAL_REGISTER_RULE(compound_statement);
            compound_statement
                =   comment_nest_p(ch_p(T_LEFTBRACE), ch_p(T_RIGHTBRACE))
                ;   // TODO later


            HANNIBAL_REGISTER_RULE(ptr_operator);
            ptr_operator
                =   ch_p(T_STAR) >> !cv_qualifier_seq
                |   ch_p(T_AND)
                |  !ch_p(T_COLON_COLON) >> nested_name_specifier 
                    >> ch_p(T_STAR) >> !cv_qualifier_seq
                ;


            HANNIBAL_REGISTER_RULE(decl_specifier);
            decl_specifier
                =   no_type_decl_specifier
                |   type_specifier
                ;

            HANNIBAL_REGISTER_RULE(no_type_decl_specifier);
            no_type_decl_specifier 
                =   storage_class_specifier
                |   function_specifier
                |   ch_p(T_FRIEND)
                |   ch_p(T_TYPEDEF)
                |   cv_qualifier
                |   odd_language_extension
                ;

            HANNIBAL_REGISTER_RULE(type_specifier_seq);
            type_specifier_seq
                =  +type_specifier
                ;

            HANNIBAL_REGISTER_RULE(type_specifier);
            type_specifier
                =   enum_specifier
                |   class_specifier
                |   elaborated_type_specifier
                |   simple_type_specifier
                |   cv_qualifier
                ;