ceph/src/boost/libs/spirit/include/boost/spirit/home/classic/core/non_terminal/rule.hpp

   1 /*=============================================================================
   2     Copyright (c) 1998-2003 Joel de Guzman
   3     http://spirit.sourceforge.net/
   4
   5   Distributed under the Boost Software License, Version 1.0. (See accompanying
   6   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   7 =============================================================================*/
   8 #if !defined(BOOST_SPIRIT_RULE_HPP)
   9 #define BOOST_SPIRIT_RULE_HPP
  10
  11 #include <boost/static_assert.hpp>
  12
  13 ///////////////////////////////////////////////////////////////////////////////
  14 //
  15 //  Spirit predefined maximum number of simultaneously usable different
  16 //  scanner types.
  17 //
  18 //  This limit defines the maximum number of possible different scanner
  19 //  types for which a specific rule<> may be used. If this isn't defined, a
  20 //  rule<> may be used with one scanner type only (multiple scanner support
  21 //  is disabled).
  22 //
  23 ///////////////////////////////////////////////////////////////////////////////
  24 #if !defined(BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT)
  25 #  define BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT 1
  26 #endif
  27
  28 //  Ensure a meaningful maximum number of simultaneously usable scanner types
  29 BOOST_STATIC_ASSERT(BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 0);
  30
  31 #include <boost/scoped_ptr.hpp>
  32 #include <boost/spirit/home/classic/namespace.hpp>
  33 #include <boost/spirit/home/classic/core/non_terminal/impl/rule.ipp>
  34
  35 #if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1
  36 #  include <boost/preprocessor/enum_params.hpp>
  37 #endif
  38
  39 ///////////////////////////////////////////////////////////////////////////////
  40 namespace boost { namespace spirit {
  41
  42 BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
  43
  44 #if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1
  45
  46     ///////////////////////////////////////////////////////////////////////////
  47     //
  48     //  scanner_list (a fake scanner)
  49     //
  50     //      Typically, rules are tied to a specific scanner type and
  51     //      a particular rule cannot be used with anything else. Sometimes
  52     //      there's a need for rules that can accept more than one scanner
  53     //      type. The scanner_list<S0, ...SN> can be used as a template
  54     //      parameter to the rule class to specify up to the number of
  55     //      scanner types defined by the BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT
  56     //      constant. Example:
  57     //
  58     //          rule<scanner_list<ScannerT0, ScannerT1> > r;
  59     //
  60     //      *** This feature is available only to compilers that support
  61     //      partial template specialization. ***
  62     //
  63     ///////////////////////////////////////////////////////////////////////////
  64     template <
  65         BOOST_PP_ENUM_PARAMS(
  66             BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT,
  67             typename ScannerT
  68         )
  69     >
  70     struct scanner_list : scanner_base {};
  71
  72 #endif
  73
  74     ///////////////////////////////////////////////////////////////////////////
  75     //
  76     //  rule class
  77     //
  78     //      The rule is a polymorphic parser that acts as a named place-
  79     //      holder capturing the behavior of an EBNF expression assigned to
  80     //      it.
  81     //
  82     //      The rule is a template class parameterized by:
  83     //
  84     //          1) scanner (scanner_t, see scanner.hpp),
  85     //          2) the rule's context (context_t, see parser_context.hpp)
  86     //          3) an arbitrary tag (tag_t, see parser_id.hpp) that allows
  87     //             a rule to be tagged for identification.
  88     //
  89     //      These template parameters may be specified in any order. The
  90     //      scanner will default to scanner<> when it is not specified.
  91     //      The context will default to parser_context when not specified.
  92     //      The tag will default to parser_address_tag when not specified.
  93     //
  94     //      The definition of the rule (its right hand side, RHS) held by
  95     //      the rule through a scoped_ptr. When a rule is seen in the RHS
  96     //      of an assignment or copy construction EBNF expression, the rule
  97     //      is held by the LHS rule by reference.
  98     //
  99     ///////////////////////////////////////////////////////////////////////////
 100     template <
 101         typename T0 = nil_t
 102       , typename T1 = nil_t
 103       , typename T2 = nil_t
 104     >
 105     class rule
 106         : public impl::rule_base<
 107             rule<T0, T1, T2>
 108           , rule<T0, T1, T2> const&
 109           , T0, T1, T2>
 110     {
 111     public:
 112
 113         typedef rule<T0, T1, T2> self_t;
 114         typedef impl::rule_base<
 115             self_t
 116           , self_t const&
 117           , T0, T1, T2>
 118         base_t;
 119
 120         typedef typename base_t::scanner_t scanner_t;
 121         typedef typename base_t::attr_t attr_t;
 122         typedef impl::abstract_parser<scanner_t, attr_t> abstract_parser_t;
 123
 124         rule() : ptr() {}
 125         ~rule() {}
 126
 127         rule(rule const& r)
 128         : ptr(new impl::concrete_parser<rule, scanner_t, attr_t>(r)) {}
 129
 130         template <typename ParserT>
 131         rule(ParserT const& p)
 132         : ptr(new impl::concrete_parser<ParserT, scanner_t, attr_t>(p)) {}
 133
 134         template <typename ParserT>
 135         rule& operator=(ParserT const& p)
 136         {
 137             ptr.reset(new impl::concrete_parser<ParserT, scanner_t, attr_t>(p));
 138             return *this;
 139         }
 140
 141         rule& operator=(rule const& r)
 142         {
 143             ptr.reset(new impl::concrete_parser<rule, scanner_t, attr_t>(r));
 144             return *this;
 145         }
 146
 147         rule<T0, T1, T2>
 148         copy() const
 149         {
 150             return rule<T0, T1, T2>(ptr.get() ? ptr->clone() : 0);
 151         }
 152
 153     private:
 154         friend class impl::rule_base_access;
 155
 156         abstract_parser_t*
 157         get() const
 158         {
 159             return ptr.get();
 160         }
 161
 162         rule(abstract_parser_t* ptr_)
 163         : ptr(ptr_) {}
 164
 165         rule(abstract_parser_t const* ptr_)
 166         : ptr(ptr_) {}
 167
 168         scoped_ptr<abstract_parser_t> ptr;
 169     };
 170
 171 BOOST_SPIRIT_CLASSIC_NAMESPACE_END
 172
 173 }} // namespace BOOST_SPIRIT_CLASSIC_NS
 174
 175 #endif