add subtree-ish sources for 12.0.3

[ceph.git] / ceph / src / boost / tools / quickbook / src / code_snippet.cpp

/*=============================================================================
    Copyright (c) 2006 Joel de Guzman
    http://spirit.sourceforge.net/

    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/

#include <boost/spirit/include/classic_core.hpp>
#include <boost/spirit/include/classic_actor.hpp>
#include <boost/spirit/include/classic_confix.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>
#include "block_tags.hpp"
#include "template_stack.hpp"
#include "actions.hpp"
#include "state.hpp"
#include "values.hpp"
#include "files.hpp"
#include "native_text.hpp"

namespace quickbook
{
    namespace cl = boost::spirit::classic;

    struct code_snippet_actions
    {
        code_snippet_actions(std::vector<template_symbol>& storage,
                                file_ptr source_file,
                                char const* source_type)
            : last_code_pos(source_file->source().begin())
            , in_code(false)
            , snippet_stack()
            , storage(storage)
            , source_file(source_file)
            , source_type(source_type)
            , error_count(0)
        {
            source_file->is_code_snippets = true;
            content.start(source_file);
        }

        void mark(string_iterator first, string_iterator last);
        void pass_thru(string_iterator first, string_iterator last);
        void escaped_comment(string_iterator first, string_iterator last);
        void start_snippet(string_iterator first, string_iterator last);
        void start_snippet_impl(std::string const&, string_iterator);
        void end_snippet(string_iterator first, string_iterator last);
        void end_snippet_impl(string_iterator);
        void end_file(string_iterator, string_iterator);
        
        void append_code(string_iterator first, string_iterator last);
        void close_code();

        struct snippet_data
        {
            snippet_data(std::string const& id)
                : id(id)
                , start_code(false)
            {}
            
            std::string id;
            bool start_code;
            string_iterator source_pos;
            mapped_file_builder::pos start_pos;
            boost::shared_ptr<snippet_data> next;
        };
        
        void push_snippet_data(std::string const& id,
                string_iterator pos)
        {
            boost::shared_ptr<snippet_data> new_snippet(new snippet_data(id));
            new_snippet->next = snippet_stack;
            snippet_stack = new_snippet;
            snippet_stack->start_code = in_code;
            snippet_stack->source_pos = pos;
            snippet_stack->start_pos = content.get_pos();
        }

        boost::shared_ptr<snippet_data> pop_snippet_data()
        {
            boost::shared_ptr<snippet_data> snippet(snippet_stack);
            snippet_stack = snippet->next;
            snippet->next.reset();
            return snippet;
        }

        mapped_file_builder content;
        boost::string_ref::const_iterator mark_begin, mark_end;
        boost::string_ref::const_iterator last_code_pos;
        bool in_code;
        boost::shared_ptr<snippet_data> snippet_stack;
        std::vector<template_symbol>& storage;
        file_ptr source_file;
        char const* const source_type;
        int error_count;
    };

    struct python_code_snippet_grammar
        : cl::grammar<python_code_snippet_grammar>
    {
        typedef code_snippet_actions actions_type;
  
        python_code_snippet_grammar(actions_type & actions)
            : actions(actions)
        {}

        template <typename Scanner>
        struct definition
        {
            typedef code_snippet_actions actions_type;
            
            definition(python_code_snippet_grammar const& self)
            {

                actions_type& actions = self.actions;
            
                start_ = (*code_elements)           [boost::bind(&actions_type::end_file, &actions, _1, _2)]
                    ;

                identifier =
                    (cl::alpha_p | '_') >> *(cl::alnum_p | '_')
                    ;

                code_elements =
                        start_snippet               [boost::bind(&actions_type::start_snippet, &actions, _1, _2)]
                    |   end_snippet                 [boost::bind(&actions_type::end_snippet, &actions, _1, _2)]
                    |   escaped_comment             [boost::bind(&actions_type::escaped_comment, &actions, _1, _2)]
                    |   pass_thru_comment           [boost::bind(&actions_type::pass_thru, &actions, _1, _2)]
                    |   ignore                      [boost::bind(&actions_type::append_code, &actions, _1, _2)]
                    |   cl::anychar_p
                    ;

                start_snippet =
                        *cl::blank_p
                    >>  !(cl::eol_p >> *cl::blank_p)
                    >>  "#["
                    >>  *cl::blank_p
                    >>  identifier                  [boost::bind(&actions_type::mark, &actions, _1, _2)]
                    >>  *(cl::anychar_p - cl::eol_p)
                    ;

                end_snippet =
                        *cl::blank_p
                    >>  !(cl::eol_p >> *cl::blank_p)
                    >>  "#]"
                    >>  *(cl::anychar_p - cl::eol_p)
                    ;

                ignore
                    =   cl::confix_p(
                            *cl::blank_p >> "#<-",
                            *cl::anychar_p,
                            "#->" >> *cl::blank_p >> (cl::eol_p | cl::end_p)
                        )
                    |   cl::confix_p(
                            "\"\"\"<-\"\"\"",
                            *cl::anychar_p,
                            "\"\"\"->\"\"\""
                        )
                    |   cl::confix_p(
                            "\"\"\"<-",
                            *cl::anychar_p,
                            "->\"\"\""
                        )
                    ;

                escaped_comment =
                        cl::confix_p(
                            *cl::space_p >> "#`",
                            (*cl::anychar_p)        [boost::bind(&actions_type::mark, &actions, _1, _2)],
                            (cl::eol_p | cl::end_p)
                        )
                    |   cl::confix_p(
                            *cl::space_p >> "\"\"\"`",
                            (*cl::anychar_p)        [boost::bind(&actions_type::mark, &actions, _1, _2)],
                            "\"\"\""
                        )
                    ;

                // Note: Unlike escaped_comment and ignore, this doesn't
                // swallow preceeding whitespace.
                pass_thru_comment
                    =   "#=" >> (cl::eps_p - '=')
                    >>  (   *(cl::anychar_p - cl::eol_p)
                        >>  (cl::eol_p | cl::end_p)
                        )                           [boost::bind(&actions_type::mark, &actions, _1, _2)]
                    |   cl::confix_p(
                            "\"\"\"=" >> (cl::eps_p - '='),
                            (*cl::anychar_p)        [boost::bind(&actions_type::mark, &actions, _1, _2)],
                            "\"\"\""
                        )
                    ;
            }

            cl::rule<Scanner>
                start_, identifier, code_elements, start_snippet, end_snippet,
                escaped_comment, pass_thru_comment, ignore;

            cl::rule<Scanner> const&
            start() const { return start_; }
        };

        actions_type& actions;
    };  

    struct cpp_code_snippet_grammar
        : cl::grammar<cpp_code_snippet_grammar>
    {
        typedef code_snippet_actions actions_type;
  
        cpp_code_snippet_grammar(actions_type & actions)
            : actions(actions)
        {}

        template <typename Scanner>
        struct definition
        {
            definition(cpp_code_snippet_grammar const& self)
            {
                actions_type& actions = self.actions;
            
                start_ = (*code_elements)           [boost::bind(&actions_type::end_file, &actions, _1, _2)]
                    ;

                identifier =
                    (cl::alpha_p | '_') >> *(cl::alnum_p | '_')
                    ;

                code_elements =
                        start_snippet               [boost::bind(&actions_type::start_snippet, &actions, _1, _2)]
                    |   end_snippet                 [boost::bind(&actions_type::end_snippet, &actions, _1, _2)]
                    |   escaped_comment             [boost::bind(&actions_type::escaped_comment, &actions, _1, _2)]
                    |   ignore                      [boost::bind(&actions_type::append_code, &actions, _1, _2)]
                    |   pass_thru_comment           [boost::bind(&actions_type::pass_thru, &actions, _1, _2)]
                    |   cl::anychar_p
                    ;

                start_snippet =
                            *cl::blank_p
                        >>  !(cl::eol_p >> *cl::blank_p)
                        >>  "//["
                        >>  *cl::blank_p
                        >>  identifier              [boost::bind(&actions_type::mark, &actions, _1, _2)]
                        >>  *(cl::anychar_p - cl::eol_p)
                    |
                            *cl::blank_p
                        >>  cl::eol_p
                        >>  *cl::blank_p
                        >>  "/*["
                        >>  *cl::space_p
                        >>  identifier              [boost::bind(&actions_type::mark, &actions, _1, _2)]
                        >>  *cl::space_p
                        >>  "*/"
                        >>  *cl::blank_p
                        >>  cl::eps_p(cl::eol_p)
                    |
                            "/*["
                        >>  *cl::space_p
                        >>  identifier              [boost::bind(&actions_type::mark, &actions, _1, _2)]
                        >>  *cl::space_p
                        >>  "*/"
                    ;

                end_snippet =
                            *cl::blank_p
                        >>  !(cl::eol_p >> *cl::blank_p)
                        >>  "//]"
                        >>  *(cl::anychar_p - cl::eol_p)
                    |
                            *cl::blank_p
                        >>  cl::eol_p
                        >>  *cl::blank_p
                        >>  "/*]*/"
                        >>  *cl::blank_p
                        >>  cl::eps_p(cl::eol_p)
                    |
                            "/*[*/"
                    ;

                ignore
                    =   cl::confix_p(
                            *cl::blank_p >> "//<-",
                            *cl::anychar_p,
                            "//->"
                        )
                    >>  *cl::blank_p
                    >>  cl::eol_p
                    |   cl::confix_p(
                            "/*<-*/",
                            *cl::anychar_p,
                            "/*->*/"
                        )
                    |   cl::confix_p(
                            "/*<-",
                            *cl::anychar_p,
                            "->*/"
                        )
                    ;

                escaped_comment
                    =   cl::confix_p(
                            *cl::space_p >> "//`",
                            (*cl::anychar_p)        [boost::bind(&actions_type::mark, &actions, _1, _2)],
                            (cl::eol_p | cl::end_p)
                        )
                    |   cl::confix_p(
                            *cl::space_p >> "/*`",
                            (*cl::anychar_p)        [boost::bind(&actions_type::mark, &actions, _1, _2)],
                            "*/"
                        )
                    ;

                // Note: Unlike escaped_comment and ignore, this doesn't
                // swallow preceeding whitespace.
                pass_thru_comment
                    =   "//=" >> (cl::eps_p - '=')
                    >>  (   *(cl::anychar_p - cl::eol_p)
                        >>  (cl::eol_p | cl::end_p)
                        )                           [boost::bind(&actions_type::mark, &actions, _1, _2)]
                    |   cl::confix_p(
                            "/*=" >> (cl::eps_p - '='),
                            (*cl::anychar_p)        [boost::bind(&actions_type::mark, &actions, _1, _2)],
                            "*/"
                        )
                    ;
            }

            cl::rule<Scanner>
            start_, identifier, code_elements, start_snippet, end_snippet,
                escaped_comment, pass_thru_comment, ignore;

            cl::rule<Scanner> const&
            start() const { return start_; }
        };

        actions_type& actions;
    };

    int load_snippets(
        fs::path const& filename
      , std::vector<template_symbol>& storage   // snippets are stored in a
                                                // vector of template_symbols
      , std::string const& extension
      , value::tag_type load_type)
    {
        assert(load_type == block_tags::include ||
            load_type == block_tags::import);

        bool is_python = extension == ".py";
        code_snippet_actions a(storage, load(filename, qbk_version_n), is_python ? "[python]" : "[c++]");

        string_iterator first(a.source_file->source().begin());
        string_iterator last(a.source_file->source().end());

        cl::parse_info<string_iterator> info;

        if(is_python) {
            info = boost::spirit::classic::parse(first, last, python_code_snippet_grammar(a));
        }
        else {
            info = boost::spirit::classic::parse(first, last, cpp_code_snippet_grammar(a));
        }

        assert(info.full);
        return a.error_count;
    }

    void code_snippet_actions::append_code(string_iterator first, string_iterator last)
    {
        assert(last_code_pos <= first);

        if(snippet_stack) {
            if (last_code_pos != first) {
                if (!in_code)
                {
                    content.add_at_pos("\n\n", last_code_pos);
                    content.add_at_pos(source_type, last_code_pos);
                    content.add_at_pos("```\n", last_code_pos);

                    in_code = true;
                }

                content.add(boost::string_ref(last_code_pos, first - last_code_pos));
            }
        }
        
        last_code_pos = last;
    }
    
    void code_snippet_actions::close_code()
    {
        if (!snippet_stack) return;
    
        if (in_code)
        {
            content.add_at_pos("\n```\n\n", last_code_pos);
            in_code = false;
        }
    }

    void code_snippet_actions::mark(string_iterator first, string_iterator last)
    {
        mark_begin = first;
        mark_end = last;
    }

    void code_snippet_actions::pass_thru(string_iterator first, string_iterator last)
    {
        if(!snippet_stack) return;
        append_code(first, last);

        if (!in_code)
        {
            content.add_at_pos("\n\n", first);
            content.add_at_pos(source_type, first);
            content.add_at_pos("```\n", first);
            in_code = true;
        }

        content.add(boost::string_ref(mark_begin, mark_end - mark_begin));
    }

    void code_snippet_actions::escaped_comment(string_iterator first, string_iterator last)
    {
        append_code(first, last);
        close_code();

        if (mark_begin != mark_end)
        {
            if (!snippet_stack)
            {
                start_snippet_impl("!", first);
            }
    
            snippet_data& snippet = *snippet_stack;

            content.add_at_pos("\n", mark_begin);
            content.unindent_and_add(boost::string_ref(mark_begin, mark_end - mark_begin));

            if (snippet.id == "!")
            {
                end_snippet_impl(last);
            }
        }
    }

    void code_snippet_actions::start_snippet(string_iterator first, string_iterator last)
    {
        append_code(first, last);
        start_snippet_impl(std::string(mark_begin, mark_end), first);
    }

    void code_snippet_actions::end_snippet(string_iterator first, string_iterator last)
    {
        append_code(first, last);

        if(!snippet_stack) {
            if (qbk_version_n >= 106u) {
                detail::outerr(source_file, first)
                    << "Mismatched end snippet."
                    << std::endl;
                ++error_count;
            }
            else {
                detail::outwarn(source_file, first)
                    << "Mismatched end snippet."
                    << std::endl;
            }
            return;
        }

        end_snippet_impl(first);
    }
    
    void code_snippet_actions::end_file(string_iterator, string_iterator pos)
    {
        append_code(pos, pos);
        close_code();

        while (snippet_stack) {
            if (qbk_version_n >= 106u) {
                detail::outerr(source_file->path)
                    << "Unclosed snippet '"
                    << snippet_stack->id
                    << "'"
                    << std::endl;
                ++error_count;
            }
            else {
                detail::outwarn(source_file->path)
                    << "Unclosed snippet '"
                    << snippet_stack->id
                    << "'"
                    << std::endl;
            }
            
            end_snippet_impl(pos);
        }
    }

    void code_snippet_actions::start_snippet_impl(std::string const& id,
            string_iterator position)
    {
        push_snippet_data(id, position);
    }

    void code_snippet_actions::end_snippet_impl(string_iterator position)
    {
        assert(snippet_stack);

        boost::shared_ptr<snippet_data> snippet = pop_snippet_data();

        mapped_file_builder f;
        f.start(source_file);
        if (snippet->start_code) {
            f.add_at_pos("\n\n", snippet->source_pos);
            f.add_at_pos(source_type, snippet->source_pos);
            f.add_at_pos("```\n", snippet->source_pos);
        }
        f.add(content, snippet->start_pos, content.get_pos());
        if (in_code) {
            f.add_at_pos("\n```\n\n", position);
        }

        std::vector<std::string> params;

        file_ptr body = f.release();

        storage.push_back(template_symbol(snippet->id, params,
            qbk_value(body, body->source().begin(), body->source().end(),
                template_tags::snippet)));
    }
}