Line data    Source code

       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_PARSER_HPP)
       9             : #define BOOST_SPIRIT_PARSER_HPP
      10             : 
      11             : #include <boost/config.hpp>
      12             : #include <boost/type_traits/remove_reference.hpp>
      13             : #include <boost/spirit/home/classic/namespace.hpp>
      14             : #include <boost/spirit/home/classic/core/scanner/scanner.hpp>
      15             : #include <boost/spirit/home/classic/core/nil.hpp>
      16             : 
      17             : namespace boost { namespace spirit {
      18             : 
      19             : BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
      20             : 
      21             :     template <typename ParserT, typename ActionT>
      22             :     class action; //  forward declaration
      23             : 
      24             :     ///////////////////////////////////////////////////////////////////////////
      25             :     //
      26             :     //  Parser categories
      27             :     //
      28             :     //      Helper template classes to distinguish different types of
      29             :     //      parsers. The following categories are the most generic. More
      30             :     //      specific types may inherit from these. Each parser has a typedef
      31             :     //      parser_category_t that defines its category. By default, if one
      32             :     //      is not specified, it will inherit from the base parser class
      33             :     //      which typedefs its parser_category_t as plain_parser_category.
      34             :     //
      35             :     //          - plain parser has nothing special
      36             :     //          - binary parser has subject a and b (e.g. alternative)
      37             :     //          - unary parser has single subject  (e.g. kleene star)
      38             :     //          - action parser has an attached action parser
      39             :     //
      40             :     ///////////////////////////////////////////////////////////////////////////
      41             :     struct plain_parser_category {};
      42             :     struct binary_parser_category       : plain_parser_category {};
      43             :     struct unary_parser_category        : plain_parser_category {};
      44             :     struct action_parser_category       : unary_parser_category {};
      45             : 
      46             :     ///////////////////////////////////////////////////////////////////////////
      47             :     //
      48             :     //  parser_result metafunction
      49             :     //
      50             :     //      Given a scanner type ScannerT and a parser type ParserT, the
      51             :     //      parser_result metafunction provides the actual result of the
      52             :     //      parser.
      53             :     //
      54             :     //  Usage:
      55             :     //
      56             :     //      typename parser_result<ParserT, ScannerT>::type
      57             :     //
      58             :     ///////////////////////////////////////////////////////////////////////////
      59             :     template <typename ParserT, typename ScannerT>
      60             :     struct parser_result
      61             :     {
      62             :         typedef typename boost::remove_reference<ParserT>::type parser_type;
      63             :         typedef typename parser_type::template result<ScannerT>::type type;
      64             :     };
      65             : 
      66             :     ///////////////////////////////////////////////////////////////////////////
      67             :     //
      68             :     //  parser class
      69             :     //
      70             :     //      This class is a protocol base class for all parsers. This is
      71             :     //      essentially an interface contract. The parser class does not
      72             :     //      really know how to parse anything but instead relies on the
      73             :     //      template parameter DerivedT (which obviously is assumed to be a
      74             :     //      subclass) to do the actual parsing.
      75             :     //
      76             :     //      Concrete sub-classes inheriting from parser must have a
      77             :     //      corresponding member function parse(...) compatible with the
      78             :     //      conceptual Interface:
      79             :     //
      80             :     //          template <typename ScannerT>
      81             :     //          RT parse(ScannerT const& scan) const;
      82             :     //
      83             :     //      where RT is the desired return type of the parser and ScannerT
      84             :     //      scan is the scanner (see scanner.hpp).
      85             :     //
      86             :     //      Concrete sub-classes inheriting from parser in most cases need to
      87             :     //      have a nested meta-function result that returns the result type
      88             :     //      of the parser's parse member function, given a scanner type. The
      89             :     //      meta-function has the form:
      90             :     //
      91             :     //          template <typename ScannerT>
      92             :     //          struct result
      93             :     //          {
      94             :     //              typedef RT type;
      95             :     //          };
      96             :     //
      97             :     //      where RT is the desired return type of the parser. This is
      98             :     //      usually, but not always, dependent on the template parameter
      99             :     //      ScannerT. If a parser does not supply a result metafunction, a
     100             :     //      default is provided by the base parser class.
     101             :     //
     102             :     //      The parser's derived() member function returns a reference to the
     103             :     //      parser as its derived object.
     104             :     //
     105             :     //      An operator[] is provided. The operator returns a semantic action
     106             :     //      handler (see actions.hpp).
     107             :     //
     108             :     //      Each parser has a typedef embed_t. This typedef specifies how a
     109             :     //      parser is embedded in a composite (see composite.hpp). By
     110             :     //      default, if one is not specified, the parser will be embedded by
     111             :     //      value. That is, a copy of the parser is placed as a member
     112             :     //      variable of the composite. Most parsers are embedded by value. In
     113             :     //      certain situations however, this is not desirable or possible.
     114             :     //
     115             :     ///////////////////////////////////////////////////////////////////////////
     116             :     template <typename DerivedT>
     117             :     struct parser
     118             :     {
     119             :         typedef DerivedT                embed_t;
     120             :         typedef DerivedT                derived_t;
     121             :         typedef plain_parser_category   parser_category_t;
     122             : 
     123             :         template <typename ScannerT>
     124             :         struct result
     125             :         {
     126             :             typedef typename match_result<ScannerT, nil_t>::type type;
     127             :         };
     128             : 
     129             :         DerivedT& derived()
     130             :         {
     131             :             return *static_cast<DerivedT*>(this);
     132             :         }
     133             : 
     134           0 :         DerivedT const& derived() const
     135             :         {
     136             :             return *static_cast<DerivedT const*>(this);
     137             :         }
     138             : 
     139             :         template <typename ActionT>
     140             :         action<DerivedT, ActionT>
     141           0 :         operator[](ActionT const& actor) const
     142             :         {
     143           0 :             return action<DerivedT, ActionT>(derived(), actor);
     144             :         }
     145             :     };
     146             : 
     147             :     ///////////////////////////////////////////////////////////////////////////
     148             :     //
     149             :     //  parse_info
     150             :     //
     151             :     //      Results returned by the free parse functions:
     152             :     //
     153             :     //      stop:   points to the final parse position (i.e parsing
     154             :     //              processed the input up to this point).
     155             :     //
     156             :     //      hit:    true if parsing is successful. This may be full:
     157             :     //              the parser consumed all the input, or partial:
     158             :     //              the parser consumed only a portion of the input.
     159             :     //
     160             :     //      full:   true when we have a full hit (i.e the parser
     161             :     //              consumed all the input.
     162             :     //
     163             :     //      length: The number of characters consumed by the parser.
     164             :     //              This is valid only if we have a successful hit
     165             :     //              (either partial or full).
     166             :     //
     167             :     ///////////////////////////////////////////////////////////////////////////
     168             :     template <typename IteratorT = char const*>
     169           0 :     struct parse_info
     170             :     {
     171             :         IteratorT   stop;
     172             :         bool        hit;
     173             :         bool        full;
     174             :         std::size_t length;
     175             : 
     176           0 :         parse_info(
     177             :             IteratorT const& stop_ = IteratorT(),
     178             :             bool hit_ = false,
     179             :             bool full_ = false,
     180             :             std::size_t length_ = 0)
     181             :         : stop(stop_)
     182             :         , hit(hit_)
     183             :         , full(full_)
     184           0 :         , length(length_) {}
     185             : 
     186             :         template <typename ParseInfoT>
     187             :         parse_info(ParseInfoT const& pi)
     188             :         : stop(pi.stop)
     189             :         , hit(pi.hit)
     190             :         , full(pi.full)
     191             :         , length(pi.length) {}
     192             :     };
     193             : 
     194             :     ///////////////////////////////////////////////////////////////////////////
     195             :     //
     196             :     //  Generic parse function
     197             :     //
     198             :     ///////////////////////////////////////////////////////////////////////////
     199             :     template <typename IteratorT, typename DerivedT>
     200             :     parse_info<IteratorT>
     201             :     parse(
     202             :         IteratorT const&        first,
     203             :         IteratorT const&        last,
     204             :         parser<DerivedT> const& p);
     205             : 
     206             :     ///////////////////////////////////////////////////////////////////////////
     207             :     //
     208             :     //  Parse function for null terminated strings
     209             :     //
     210             :     ///////////////////////////////////////////////////////////////////////////
     211             :     template <typename CharT, typename DerivedT>
     212             :     parse_info<CharT const*>
     213             :     parse(
     214             :         CharT const*            str,
     215             :         parser<DerivedT> const& p);
     216             : 
     217             : BOOST_SPIRIT_CLASSIC_NAMESPACE_END
     218             : 
     219             : }} // namespace BOOST_SPIRIT_CLASSIC_NS
     220             : 
     221             : #endif
     222             : 
     223             : #include <boost/spirit/home/classic/core/impl/parser.ipp>