robot/include/boost/wave/grammars/cpp_has_include_grammar.hpp

/*=============================================================================
    Boost.Wave: A Standard compliant C++ preprocessor library

    http://www.boost.org/

    Copyright (c) 2020      Jeff Trull
    Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under 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)
=============================================================================*/

#if !defined(BOOST_CPP_HAS_INCLUDE_GRAMMAR_HPP_F48287B2_DC67_40A8_B4A1_800EFBD67869_INCLUDED)
#define BOOST_CPP_HAS_INCLUDE_GRAMMAR_HPP_F48287B2_DC67_40A8_B4A1_800EFBD67869_INCLUDED

#include <boost/wave/wave_config.hpp>

#include <boost/assert.hpp>
#include <boost/spirit/include/classic_core.hpp>
#include <boost/spirit/include/classic_closure.hpp>
#include <boost/spirit/include/classic_assign_actor.hpp>
#include <boost/spirit/include/classic_push_back_actor.hpp>

#include <boost/wave/token_ids.hpp>
#include <boost/wave/util/pattern_parser.hpp>
#include <boost/wave/grammars/cpp_has_include_grammar_gen.hpp>

#if !defined(spirit_append_actor)
#define spirit_append_actor(actor) boost::spirit::classic::push_back_a(actor)
#endif // !has_include(spirit_append_actor)

// this must occur after all of the includes and before any code appears
#ifdef BOOST_HAS_ABI_HEADERS
#include BOOST_ABI_PREFIX
#endif

///////////////////////////////////////////////////////////////////////////////
namespace boost {
namespace wave {
namespace grammars {

///////////////////////////////////////////////////////////////////////////////
//  define, whether the rule's should generate some debug output
#define TRACE_CPP_HAS_INCLUDE_GRAMMAR \
    bool(BOOST_SPIRIT_DEBUG_FLAGS_CPP & BOOST_SPIRIT_DEBUG_FLAGS_HAS_INCLUDE_GRAMMAR) \
    /**/

template <typename ContainerT>
struct has_include_grammar :
    public boost::spirit::classic::grammar<has_include_grammar<ContainerT> >
{
    has_include_grammar(ContainerT &tokens_seq_,
                        bool &is_quoted_filename_,
                        bool &is_system_)
    :   tokens_seq(tokens_seq_), is_quoted_filename(is_quoted_filename_),
        is_system(is_system_), true_(true)
    {
        BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME(*this, "has_include_grammar",
            TRACE_CPP_HAS_INCLUDE_GRAMMAR);
        is_quoted_filename = false;
        is_system = false;
    }

    template <typename ScannerT>
    struct definition
    {
        typedef boost::spirit::classic::rule<ScannerT> rule_t;

        rule_t has_include_op;
        rule_t system_include;
        rule_t nonsystem_include;

        rule_t nonparen;
        rule_t parenthesized_exp;
        rule_t computed_include;

        definition(has_include_grammar const & self)
        {
            using namespace boost::spirit::classic;
            using namespace boost::wave;
            using namespace boost::wave::util;

            has_include_op
                =   ch_p(T_IDENTIFIER) >>     // token contains '__has_include'
                    ch_p(T_LEFTPAREN)  >>
                    (system_include | nonsystem_include | computed_include) >>
                    ch_p(T_RIGHTPAREN)
                ;

            system_include
                = ch_p(T_LESS)
                [
                    spirit_append_actor(self.tokens_seq)
                ]
                >> * (~ch_p(T_GREATER))
                [
                    spirit_append_actor(self.tokens_seq)
                ]
                >> ch_p(T_GREATER)
                [
                    spirit_append_actor(self.tokens_seq)
                ][
                    assign_a(self.is_quoted_filename, self.true_)
                ][
                    assign_a(self.is_system, self.true_)
                ]
                ;

            nonsystem_include = ch_p(T_STRINGLIT)
                [
                    spirit_append_actor(self.tokens_seq)
                ][
                    assign_a(self.is_quoted_filename, self.true_)
                ]
                ;

            // an action to store a sequence of parsed tokens
            auto append_seq = [&](typename ScannerT::iterator_t first,
                                  typename ScannerT::iterator_t last) {
                for (;first != last;++first) {
                    self.tokens_seq.push_back(*first);
                };
            };

            // if neither of the above match we take everything between
            // the parentheses and evaluate it ("computed include")
            // supported expressions are "implementation defined" per the gcc manual
            // we've tried to be fairly generous in Wave
            // here we accept any set of non-whitespace characters with
            // properly nested parentheses:
            nonparen = (anychar_p - ch_p(T_LEFTPAREN) - ch_p(T_RIGHTPAREN)) [ append_seq ] ;

            parenthesized_exp =
                        ch_p(T_LEFTPAREN)[ spirit_append_actor(self.tokens_seq) ] >>
                        computed_include >>
                        ch_p(T_RIGHTPAREN)[ spirit_append_actor(self.tokens_seq) ] ;
            computed_include = * (nonparen | parenthesized_exp) ;


            BOOST_SPIRIT_DEBUG_TRACE_RULE(has_include_op, TRACE_CPP_HAS_INCLUDE_GRAMMAR);
            BOOST_SPIRIT_DEBUG_TRACE_RULE(system_include, TRACE_CPP_HAS_INCLUDE_GRAMMAR);
            BOOST_SPIRIT_DEBUG_TRACE_RULE(nonsystem_include, TRACE_CPP_HAS_INCLUDE_GRAMMAR);
            BOOST_SPIRIT_DEBUG_TRACE_RULE(computed_include, TRACE_CPP_HAS_INCLUDE_GRAMMAR);
            BOOST_SPIRIT_DEBUG_TRACE_RULE(parenthesized_exp, TRACE_CPP_HAS_INCLUDE_GRAMMAR);
            BOOST_SPIRIT_DEBUG_TRACE_RULE(nonparen, TRACE_CPP_HAS_INCLUDE_GRAMMAR);
        }

        // start rule of this grammar
        rule_t const& start() const
        { return has_include_op; }
    };

    ContainerT &tokens_seq;
    bool &is_quoted_filename;
    bool &is_system;
    const bool true_;  // Spirit Classic actors operate on references, not values
};

///////////////////////////////////////////////////////////////////////////////
#undef TRACE_CPP_HAS_INCLUDE_GRAMMAR

///////////////////////////////////////////////////////////////////////////////
//
//  The following parse function is has_include here, to allow the separation of
//  the compilation of the has_include_grammar from the function
//  using it.
//
///////////////////////////////////////////////////////////////////////////////

#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0
#define BOOST_WAVE_HAS_INCLUDE_GRAMMAR_GEN_INLINE
#else
#define BOOST_WAVE_HAS_INCLUDE_GRAMMAR_GEN_INLINE inline
#endif

//  The parse_operator_define function is instantiated manually twice to
//  simplify the explicit specialization of this template. This way the user
//  has only to specify one template parameter (the lexer type) to correctly
//  formulate the required explicit specialization.
//  This results in no code overhead, because otherwise the function would be
//  generated by the compiler twice anyway.

template <typename LexIteratorT>
BOOST_WAVE_HAS_INCLUDE_GRAMMAR_GEN_INLINE
boost::spirit::classic::parse_info<
    typename has_include_grammar_gen<LexIteratorT>::iterator1_type
>
has_include_grammar_gen<LexIteratorT>::parse_operator_has_include (
    iterator1_type const &first, iterator1_type const &last,
    token_sequence_type &tokens,
    bool &is_quoted_filename, bool &is_system)
{
    using namespace boost::spirit::classic;
    using namespace boost::wave;

    has_include_grammar<token_sequence_type>
        g(tokens, is_quoted_filename, is_system);
    return boost::spirit::classic::parse (
        first, last, g, ch_p(T_SPACE) | ch_p(T_CCOMMENT));
}

template <typename LexIteratorT>
BOOST_WAVE_HAS_INCLUDE_GRAMMAR_GEN_INLINE
boost::spirit::classic::parse_info<
    typename has_include_grammar_gen<LexIteratorT>::iterator2_type
>
has_include_grammar_gen<LexIteratorT>::parse_operator_has_include (
    iterator2_type const &first, iterator2_type const &last,
    token_sequence_type &found_qualified_name,
    bool &is_quoted_filename, bool &is_system)
{
    using namespace boost::spirit::classic;
    using namespace boost::wave;

    has_include_grammar<token_sequence_type>
        g(found_qualified_name, is_quoted_filename, is_system);
    return boost::spirit::classic::parse (
        first, last, g, ch_p(T_SPACE) | ch_p(T_CCOMMENT));
}

#undef BOOST_WAVE_HAS_INCLUDE_GRAMMAR_GEN_INLINE

///////////////////////////////////////////////////////////////////////////////
}   // namespace grammars
}   // namespace wave
}   // namespace boost

// the suffix header occurs after all of the code
#ifdef BOOST_HAS_ABI_HEADERS
#include BOOST_ABI_SUFFIX
#endif

#endif // !defined(BOOST_CPP_HAS_INCLUDE_GRAMMAR_HPP_F48287B2_DC67_40A8_B4A1_800EFBD67869_INCLUDED)