actions.hpp

C++的一个好库。。。现在很流行

        space(std::ostream& out)
        : out(out) {}

        template <typename Iterator>
        void operator()(Iterator first, Iterator last) const
        {
            if (out)
            {
                while (first != last)
                    detail::print_space(*first++, out);
            }
        }

        template <typename Char>
        void operator()(Char ch) const
        {
            if (out)
            {
                detail::print_space(ch, out);
            }
        }

        std::ostream& out;
    };

    struct code_action
    {
        // Does the actual syntax highlighing of code

        code_action(std::ostream& out,
                    std::string const & source_mode,
                    symbols<std::string> const& macro)
        : out(out)
        , source_mode(source_mode)
        , cpp_p(out, macro, do_macro_action(out))
        , python_p(out, macro, do_macro_action(out))
        {
        }

        template <typename Iterator>
        void operator()(Iterator first, Iterator last) const
        {
            if (out)
            {
                // preprocess the code section to remove the initial indentation
                std::string program(first, last);
                detail::unindent(program);
                
                out << "<programlisting>\n"
                    << "<literal>\n";

                // print the code with syntax coloring
                if (source_mode == "c++")
                {
                    parse(program.begin(), program.end(), cpp_p);
                }
                else if (source_mode == "python")
                {
                    parse(program.begin(), program.end(), python_p);
                }
                
                out << "</literal>\n"
                    << "</programlisting>\n";
            }
        }

        std::ostream& out;
        std::string const& source_mode;
        
        cpp_highlight<
            span
          , space
          , symbols<std::string>
          , do_macro_action
          , unexpected_char
          , std::ostream>
        cpp_p;
        
        python_highlight<
            span
          , space
          , symbols<std::string>
          , do_macro_action
          , unexpected_char
          , std::ostream>
        python_p;
    };

    struct inline_code_action
    {
        // Does the actual syntax highlighing of code inlined in text

        inline_code_action(std::ostream& out,
                           std::string const& source_mode,
                           symbols<std::string> const& macro)
        : out(out)
        , source_mode(source_mode)
        , cpp_p(out, macro, do_macro_action(out))
        , python_p(out, macro, do_macro_action(out))
        {}

        template <typename Iterator>
        void operator()(Iterator first, Iterator last) const
        {
            if (out)
            {
                out << "<code>";

                // print the code with syntax coloring
                if (source_mode == "c++")
                {
                    parse(first, last, cpp_p);
                }
                else if (source_mode == "python")
                {
                    parse(first, last, python_p);
                }
                
                out << "</code>";
            }
        }

        std::ostream& out;
        std::string const& source_mode;
        
        cpp_highlight<
            span
          , space
          , symbols<std::string>
          , do_macro_action
          , unexpected_char
          , std::ostream>
        cpp_p;
        
        python_highlight<
            span
          , space
          , symbols<std::string>
          , do_macro_action
          , unexpected_char
          , std::ostream>
        python_p;
    };

    namespace
    {
        // Some markups

        const char* paragraph_pre   = "<para>\n";
        const char* paragraph_post  = "</para>\n";
        const char* h1_pre          = "<bridgehead renderas=\"sect1\">";
        const char* h1_post         = "</bridgehead>";
        const char* h2_pre          = "<bridgehead renderas=\"sect2\">";
        const char* h2_post         = "</bridgehead>";
        const char* h3_pre          = "<bridgehead renderas=\"sect3\">";
        const char* h3_post         = "</bridgehead>";
        const char* h4_pre          = "<bridgehead renderas=\"sect4\">";
        const char* h4_post         = "</bridgehead>";
        const char* h5_pre          = "<bridgehead renderas=\"sect5\">";
        const char* h5_post         = "</bridgehead>";
        const char* h6_pre          = "<bridgehead renderas=\"sect6\">";
        const char* h6_post         = "</bridgehead>";
        const char* hr_             = "<para/>";

        const char* blurb_pre =
            "<informaltable frame=\"all\">\n"
            "<?dbhtml table-width=\"74%\" ?>\n"
            "<tgroup cols=\"1\">\n"
            "<tbody>\n"
            "<row>\n"
            "<entry role=\"blurb\">\n"
            ;

        const char* blurb_post =
            "</entry>\n"
            "</row>\n"
            "</tbody>\n"
            "</tgroup>\n"
            "</informaltable>\n"
            ;

        const char* blockquote_pre      = "<blockquote><para>";
        const char* blockquote_post     = "</para></blockquote>";
        const char* preformatted_pre    = "<programlisting><literal>";
        const char* preformatted_post   = "</literal></programlisting>";
        const char* list_item_pre       = "<listitem>\n";
        const char* list_item_post      = "\n</listitem>";
        const char* bold_pre_           = "<emphasis role=\"bold\">";
        const char* bold_post_          = "</emphasis>";
        const char* italic_pre_         = "<emphasis>";
        const char* italic_post_        = "</emphasis>";
        const char* underline_pre_      = "<emphasis role=\"underline\">";
        const char* underline_post_     = "</emphasis>";
        const char* teletype_pre_       = "<literal>";
        const char* teletype_post_      = "</literal>";
        const char* break_mark          = "<sbr/>\n";
        const char* url_pre_            = "<ulink url=\"";
        const char* url_post_           = "</ulink>";
        const char* link_pre_           = "<link linkend=\"";
        const char* link_post_          = "</link>";
        const char* start_varlistentry_ = "<varlistentry>";
        const char* end_varlistentry_   = "</varlistentry>\n";
        const char* start_varlistterm_  = "<term>";
        const char* end_varlistterm_    = "</term>";
        const char* start_varlistitem_  = "<listitem>";
        const char* end_varlistitem_    = "</listitem>";
        const char* start_header_       = "<thead>";
        const char* end_header_         = "</thead>\n";
        const char* start_row_          = "<row>";
        const char* end_row_            = "</row>\n";
        const char* start_cell_         = "<entry>";
        const char* end_cell_           = "</entry>";
        const char* funcref_pre_        = "<functionname alt=\"";
        const char* funcref_post_       = "</functionname>";
        const char* classref_pre_       = "<classname alt=\"";
        const char* classref_post_      = "</classname>";
        const char* memberref_pre_      = "<methodname alt=\"";
        const char* memberref_post_     = "</methodname>";
        const char* enumref_pre_        = "<enumname alt=\"";
        const char* enumref_post_       = "</enumname>";
        const char* headerref_pre_      = "<headername alt=\"";
        const char* headerref_post_     = "</headername>";
    }

    struct raw_char_action
    {
        // Prints a single raw (unprocessed) char.
        // Allows '<', '>'... etc.

        raw_char_action(std::ostream& phrase)
        : phrase(phrase) {}

        template <typename Char>
        void operator()(Char const& ch) const
        {
            phrase << ch;
        }

        template <typename Iterator>
        void operator()(Iterator const& first, Iterator const& /*last*/) const
        {
            phrase << *first;
        }

        std::ostream& phrase;
    };

    struct plain_char_action
    {
        // Prints a single plain char.
        // Converts '<' to "&lt;"... etc See utils.hpp

        plain_char_action(std::ostream& phrase)
        : phrase(phrase) {}

        template <typename Char>
        void operator()(Char const& ch) const
        {
            detail::print_char(ch, phrase);
        }

        template <typename Iterator>
        void operator()(Iterator const& first, Iterator const& /*last*/) const
        {
            detail::print_char(*first, phrase);
        }

        std::ostream& phrase;
    };

    struct image_action
    {
        // Handles inline images

        image_action(std::ostream& phrase)
        : phrase(phrase) {}

        template <typename Iterator>
        void operator()(Iterator first, Iterator last) const
        {
            phrase << "<inlinemediaobject><imageobject><imagedata fileref=\"";
            while (first != last)
                detail::print_char(*first++, phrase);
            phrase << "\"></imagedata></imageobject></inlinemediaobject>";
        }

        std::ostream& phrase;
    };

    struct markup_action
    {
        // A generic markup action

        markup_action(std::ostream& phrase, std::string const& str)
        : phrase(phrase), str(str) {}

        template <typename T>
        void operator()(T const&) const
        {
            phrase << str;
        }

        template <typename T>
        void operator()(T const&, T const&) const
        {
            phrase << str;
        }

        std::ostream& phrase;
        std::string str;
    };

    template <typename Actions>
    struct indentifier_action
    {
        // Handles macro identifiers

        indentifier_action(Actions& actions)
        : actions(actions) {}

        template <typename Iterator>
        void operator()(Iterator const& first, Iterator const& last) const
        {
            actions.macro_id.assign(first, last);
            actions.phrase_save = actions.phrase.str();
            actions.phrase.str(std::string());
        }

        Actions& actions;
    };

    template <typename Actions>
    struct macro_def_action
    {
        // Handles macro definitions

        macro_def_action(Actions& actions)
        : actions(actions) {}

        template <typename Iterator>
        void operator()(Iterator const& first, Iterator const& last) const
        {
            actions.macro.add(
                actions.macro_id.begin()
              , actions.macro_id.end()
              , actions.phrase.str());
            actions.phrase.str(actions.phrase_save);
        }

        Actions& actions;
    };

    struct link_action
    {
        // Handles links (URL, XML refentry, function, class, member)

        link_action(std::ostream& phrase, char const* tag)