translation_unit_parser.h

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

            HANNIBAL_REGISTER_RULE(cv_qualifier_seq);
            cv_qualifier_seq
                =   cv_qualifier >> !cv_qualifier_seq
                ;

            HANNIBAL_REGISTER_RULE(cv_qualifier);
            cv_qualifier
                =   ch_p(T_CONST) 
                |   ch_p(T_VOLATILE)
                ;

            HANNIBAL_REGISTER_RULE(enum_specifier);
            enum_specifier 
                =   enum_keyword >> !ch_p(T_IDENTIFIER) 
                    >> ch_p(T_LEFTBRACE) >> !enumerator_list >> ch_p(T_RIGHTBRACE)
                ;

            HANNIBAL_REGISTER_RULE(enum_keyword);
            enum_keyword
                =   ch_p(T_ENUM)
                ;

            HANNIBAL_REGISTER_RULE(enumerator_list);
            enumerator_list
                =   enumerator_definition % ch_p(T_COMMA) 
                    >> !ch_p(T_COMMA) 
                    // TODO find out if this last COMMA_T is an MS-"extension"?
                    // it seems not to be in the grammar but MSVC 7.0 accepts it.
                ;

            HANNIBAL_REGISTER_RULE(enumerator_definition);
            enumerator_definition
                = enumerator >> !(ch_p(T_ASSIGN) >> constant_expression)
                ;

            HANNIBAL_REGISTER_RULE(enumerator);
            enumerator
                =   ch_p(T_IDENTIFIER)
                ;


            HANNIBAL_REGISTER_RULE(simple_type_specifier);
            simple_type_specifier
                =   !ch_p(T_COLON_COLON) >> !nested_name_specifier 
                    >>  ch_p(T_TEMPLATE) >> template_id
                |   +simple_type_name
                |  !ch_p(T_COLON_COLON) >> !nested_name_specifier >> type_name
                ;

            HANNIBAL_REGISTER_RULE(class_head);
            class_head // DH changed the order because otherwise it would always parse the (!IDENTIFIER) part.
                =  !access_specifier >> *odd_language_extension 
                    >>  class_key >> *odd_language_extension 
                    >>  (   
                            !nested_name_specifier >> template_id
                        |   nested_name_specifier >> ch_p(T_IDENTIFIER)
                        |   !ch_p(T_IDENTIFIER)
                        )
                    >> !base_clause
                ;

            HANNIBAL_REGISTER_RULE(type_name);
            type_name
                =   class_name
                |   enum_name
                |   typedef_name
                ;

            HANNIBAL_REGISTER_RULE(elaborated_type_specifier);
            elaborated_type_specifier
                =   class_key >> *odd_language_extension 
                    >>  !ch_p(T_COLON_COLON) 
                    >>  !nested_name_specifier 
                    >>  ( 
                            !ch_p(T_TEMPLATE) >> template_id 
                        |   ch_p(T_IDENTIFIER)
                        )
                |   ch_p(T_ENUM) >> !ch_p(T_COLON_COLON)
                    >> !nested_name_specifier 
                    >>  ch_p(T_IDENTIFIER)
                |   ch_p(T_TYPENAME) 
                    >> !ch_p(T_COLON_COLON) 
                    >>  nested_name_specifier 
                    >>  (
                            !ch_p(T_TEMPLATE) >> template_id 
                        |   ch_p(T_IDENTIFIER)
                        )
                ;

            HANNIBAL_REGISTER_RULE(template_argument_list);
            template_argument_list 
                =   template_argument % ch_p(T_COMMA)
                ;

            HANNIBAL_REGISTER_RULE(template_argument);
            template_argument
                =   longest_d
                    [
                        type_id
                    |   ta_assignment_expression
                    |   template_name
                    ]
                ;

            HANNIBAL_REGISTER_RULE(class_key);
            class_key
                =   class_keywords
                ;

            HANNIBAL_REGISTER_RULE(class_keywords);
            class_keywords 
                =   ch_p(T_CLASS)
                |   ch_p(T_STRUCT)
                |   ch_p(T_UNION)
                ;

            HANNIBAL_REGISTER_RULE(nested_name_specifier);
            nested_name_specifier
                =   class_or_namespace_name >> ch_p(T_COLON_COLON) 
                    >>  ch_p(T_TEMPLATE) >> nested_name_specifier
                |   class_or_namespace_name >> ch_p(T_COLON_COLON) 
                    >> !nested_name_specifier
                ;

            HANNIBAL_REGISTER_RULE(class_or_namespace_name);
            class_or_namespace_name
                =   class_name 
                |   namespace_name
                ;

            HANNIBAL_REGISTER_RULE(class_name);
            class_name 
                =   template_id
                |   ch_p(T_IDENTIFIER)
                ;

            HANNIBAL_REGISTER_RULE(enum_name);
            enum_name
                =   ch_p(T_IDENTIFIER)
                ;

            HANNIBAL_REGISTER_RULE(typedef_name);
            typedef_name
                =   ch_p(T_IDENTIFIER)
                ;

            HANNIBAL_REGISTER_RULE(namespace_name);
            namespace_name    // TODO
                =   ch_p(T_IDENTIFIER)
                ;

            HANNIBAL_REGISTER_RULE(template_id);
            template_id 
                =   template_name 
                    >> ch_p(T_LESS) >> template_argument_list >> ch_p(T_GREATER)
                ;

            //
            //  This is kind of a HACK. We want to prevent the decl_specifier_seq 
            //  from eating the whole declaration, including the ch_p(T_IDENTIFIER). 
            //  Therefore in the sequence, we only allow one 'unknown' word 
            //  (the type_specifier), the rest of the decl_specifier sequence 
            //  must consist of known keywords or constructs (the 
            //  no_type_decl_specifier).
            //  This means that a declaration like:
            //     MYDLL_EXPORT int f(); 
            //  will not be accepted unless the MYDLL_EXPORT is properly 
            //  expanded by the preprocessor first.
            //     
            //  This should not cause any problems normally, it just means that 
            //  this rule is not very robust in the case where not all symbols 
            //  are known.
            //
            HANNIBAL_REGISTER_RULE(decl_specifier_seq);
            decl_specifier_seq
                =  *no_type_decl_specifier >> type_specifier >> *no_type_decl_specifier
                ;

            //  The following rule is more according to the standard grammar
            //  decl_specifier_seq // adapted
            //     =   decl_specifier >> decl_specifier_seq
            //    |   (decl_specifier - (declarator_id >> parameters_or_array_spec )) 
            //     ;

            HANNIBAL_REGISTER_RULE( storage_class_specifier);
            storage_class_specifier
                =   ch_p(T_AUTO)
                |   ch_p(T_REGISTER)
                |   ch_p(T_STATIC)
                |   ch_p(T_EXTERN)
                |   ch_p(T_MUTABLE)
                ;

            HANNIBAL_REGISTER_RULE( function_specifier);
            function_specifier
                =   ch_p(T_INLINE)
                |   ch_p(T_VIRTUAL)
                |   ch_p(T_EXPLICIT)
                ;

            HANNIBAL_REGISTER_RULE(class_specifier);
            class_specifier
                =   class_head 
                    >> ch_p(T_LEFTBRACE) >> !member_specification >> ch_p(T_RIGHTBRACE)
                ;

            HANNIBAL_REGISTER_RULE(member_specification);
            member_specification
                =  +(   access_specifier >> ch_p(T_COLON)
                    |   member_declaration HANNIBAL_TRACE_ACTION("member declaration")
                    )
                ;

      //    member_specification
      //     = access_specifier >> COLON_T >> !member_specification
      //     | member_declaration >> !member_specification
      //     ;

            HANNIBAL_REGISTER_RULE(member_declaration);
            member_declaration
                =   using_declaration
                |   template_declaration
                |  !decl_specifier_seq >> !member_declarator_list 
                    >> ch_p(T_SEMICOLON)
                |   function_definition >> 
                   !ch_p(T_SEMICOLON)
                |   qualified_id 
                    >> ch_p(T_SEMICOLON)
                ;

            HANNIBAL_REGISTER_RULE(member_declarator_list);
            member_declarator_list
                =   member_declarator % ch_p(T_COMMA)
                ;

            HANNIBAL_REGISTER_RULE(member_declarator);
            member_declarator
                =  !ch_p(T_IDENTIFIER) >> ch_p(T_COLON) >> constant_expression
                |   declarator >> !(pure_specifier | constant_initializer)
                ;

            HANNIBAL_REGISTER_RULE(pure_specifier);
            pure_specifier
                =   ch_p(T_ASSIGN) >> ch_p(T_INTLIT)
                ;

            HANNIBAL_REGISTER_RULE(constant_initializer);
            constant_initializer
                =   ch_p(T_ASSIGN) >> constant_expression
                ;

            HANNIBAL_REGISTER_RULE(access_specifier);
            access_specifier 
                =   ch_p(T_PUBLIC)
                |   ch_p(T_PROTECTED)
                |   ch_p(T_PRIVATE)
                ;

            HANNIBAL_REGISTER_RULE(base_clause);
            base_clause
                =   ch_p(T_COLON) >> base_specifier_list
                ;

            HANNIBAL_REGISTER_RULE(base_specifier_list);
            base_specifier_list
                =   base_specifier % ch_p(T_COMMA)
                ;

            HANNIBAL_REGISTER_RULE(base_specifier);
            base_specifier
                =   ch_p(T_VIRTUAL) >> !access_specifier >> !ch_p(T_COLON_COLON) 
                    >> !nested_name_specifier >> class_name
                |   access_specifier >> !ch_p(T_VIRTUAL) >> !ch_p(T_COLON_COLON)
                    >> !nested_name_specifier >> class_name
                |  !ch_p(T_COLON_COLON) >> !nested_name_specifier >> class_name
                ;

            HANNIBAL_REGISTER_RULE(extension_type_decorator);
            extension_type_decorator
                =   ch_p(T_MSEXT_CDECL) 
                |   ch_p(T_MSEXT_DECLSPEC)
                |   ch_p(T_MSEXT_BASED)
                |   ch_p(T_MSEXT_FASTCALL) 
                |   ch_p(T_MSEXT_INLINE)
                ;

            HANNIBAL_REGISTER_RULE(simple_type_name);
            simple_type_name
                =   ch_p(T_CHAR)
                |   ch_p(T_WCHART)
                |   ch_p(T_BOOL)
                |   ch_p(T_SHORT)
                |   ch_p(T_INT)
                |   ch_p(T_LONG) 
                |   ch_p(T_UNSIGNED)
                |   ch_p(T_SIGNED)
                |   ch_p(T_FLOAT)
                |   ch_p(T_DOUBLE)
                |   ch_p(T_VOID)
                |   ch_p(T_MSEXT_INT64)
                |   ch_p(T_MSEXT_INT8)
                |   ch_p(T_MSEXT_INT16)
                |   ch_p(T_MSEXT_INT32)
                ;
        }

        rule_type const& start() const { return translation_unit; }

        //  Helper function wrapping pattern_p
        static inline boost::wave::util::pattern_and< boost::wave::token_id>  
        pp (boost::wave::token_id id)
        {
            using namespace boost::wave;
            return util::pattern_p(id, MainTokenMask);
        }
    };
  
#if HANNIBAL_DUMP_PARSE_TREE != 0
private:
    template<typename Rule>
    void declare_rule(Rule const& rule, std::string const& rule_name) const
    {
        if (rule_map_ptr)
            (*rule_map_ptr)[rule.id()] = rule_name;
    }
    rule_map_type *rule_map_ptr;
#endif 
};

#undef HANNIBAL_REGISTER_RULE
#undef HANNIBAL_TRACE_TRANSLATION_UNIT_GRAMMAR

#endif // HANNIBAL_TRANSLATION_UNIT_GRAMMAR_H_INCLUDED