comparison DEPENDENCIES/generic/include/boost/spirit/home/classic/utility/escape_char.hpp @ 16:2665513ce2d3

Add boost headers

+/*=============================================================================
+    Copyright (c) 2001-2003 Daniel Nuffer
+    http://spirit.sourceforge.net/
+
+  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)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_ESCAPE_CHAR_HPP
+#define BOOST_SPIRIT_ESCAPE_CHAR_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+#include <string>
+#include <iterator>
+#include <cctype>
+#include <boost/limits.hpp>
+
+#include <boost/spirit/home/classic/namespace.hpp>
+#include <boost/spirit/home/classic/debug.hpp>
+
+#include <boost/spirit/home/classic/utility/escape_char_fwd.hpp>
+#include <boost/spirit/home/classic/utility/impl/escape_char.ipp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  escape_char_action class
+//
+//      Links an escape char parser with a user defined semantic action.
+//      The semantic action may be a function or a functor. A function
+//      should be compatible with the interface:
+//
+//          void f(CharT ch);
+//
+//      A functor should have a member operator() with a compatible signature
+//      as above. The matching character is passed into the function/functor.
+//      This is the default class that character parsers use when dealing with
+//      the construct:
+//
+//          p[f]
+//
+//      where p is a parser and f is a function or functor.
+//
+///////////////////////////////////////////////////////////////////////////////
+template <
+    typename ParserT, typename ActionT,
+    unsigned long Flags, typename CharT
+>
+struct escape_char_action
+:   public unary<ParserT,
+        parser<escape_char_action<ParserT, ActionT, Flags, CharT> > >
+{
+    typedef escape_char_action
+        <ParserT, ActionT, Flags, CharT>        self_t;
+    typedef action_parser_category              parser_category_t;
+    typedef unary<ParserT, parser<self_t> >     base_t;
+
+    template <typename ScannerT>
+    struct result
+    {
+        typedef typename match_result<ScannerT, CharT>::type type;
+    };
+
+    escape_char_action(ParserT const& p, ActionT const& a)
+    : base_t(p), actor(a) {}
+
+    template <typename ScannerT>
+    typename parser_result<self_t, ScannerT>::type
+    parse(ScannerT const& scan) const
+    {
+        return impl::escape_char_action_parse<Flags, CharT>::
+            parse(scan, *this);
+    }
+
+    ActionT const& predicate() const { return actor; }
+
+private:
+
+    ActionT actor;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  escape_char_parser class
+//
+//      The escape_char_parser helps in conjunction with the escape_char_action
+//      template class (see above) in parsing escaped characters. There are two
+//      different variants of this parser: one for parsing C style escaped
+//      characters and one for parsing LEX style escaped characters.
+//
+//      The C style escaped character parser is generated, when the template
+//      parameter 'Flags' is equal to 'c_escapes' (a constant defined in the
+//      file impl/escape_char.ipp). This parser recognizes all valid C escape
+//      character sequences: '\t', '\b', '\f', '\n', '\r', '\"', '\'', '\\'
+//      and the numeric style escapes '\120' (octal) and '\x2f' (hexadecimal)
+//      and converts these to their character equivalent, for instance the
+//      sequence of a backslash and a 'b' is parsed as the character '\b'.
+//      All other escaped characters are rejected by this parser.
+//
+//      The LEX style escaped character parser is generated, when the template
+//      parameter 'Flags' is equal to 'lex_escapes' (a constant defined in the
+//      file impl/escape_char.ipp). This parser recognizes all the C style
+//      escaped character sequences (as described above) and additionally
+//      does not reject all other escape sequences. All not mentioned escape
+//      sequences are converted by the parser to the plain character, for
+//      instance '\a' will be parsed as 'a'.
+//
+//      All not escaped characters are parsed without modification.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+template <unsigned long Flags, typename CharT>
+struct escape_char_action_parser_gen;
+
+template <unsigned long Flags, typename CharT>
+struct escape_char_parser :
+    public parser<escape_char_parser<Flags, CharT> > {
+
+    // only the values c_escapes and lex_escapes are valid for Flags
+    BOOST_STATIC_ASSERT(Flags == c_escapes || Flags == lex_escapes);
+
+    typedef escape_char_parser<Flags, CharT> self_t;
+    typedef
+        escape_char_action_parser_gen<Flags, CharT>
+        action_parser_generator_t;
+
+    template <typename ScannerT>
+    struct result {
+
+        typedef typename match_result<ScannerT, CharT>::type type;
+    };
+
+    template <typename ActionT>
+    escape_char_action<self_t, ActionT, Flags, CharT>
+    operator[](ActionT const& actor) const
+    {
+        return escape_char_action<self_t, ActionT, Flags, CharT>(*this, actor);
+    }
+
+    template <typename ScannerT>
+    typename parser_result<self_t, ScannerT>::type
+    parse(ScannerT const &scan) const
+    {
+        return impl::escape_char_parse<CharT>::parse(scan, *this);
+    }
+};
+
+template <unsigned long Flags, typename CharT>
+struct escape_char_action_parser_gen {
+
+    template <typename ParserT, typename ActionT>
+    static escape_char_action<ParserT, ActionT, Flags, CharT>
+    generate (ParserT const &p, ActionT const &actor)
+    {
+        typedef
+            escape_char_action<ParserT, ActionT, Flags, CharT>
+            action_parser_t;
+        return action_parser_t(p, actor);
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  predefined escape_char_parser objects
+//
+//      These objects should be used for generating correct escaped character
+//      parsers.
+//
+///////////////////////////////////////////////////////////////////////////////
+const escape_char_parser<lex_escapes> lex_escape_ch_p =
+    escape_char_parser<lex_escapes>();
+
+const escape_char_parser<c_escapes> c_escape_ch_p =
+    escape_char_parser<c_escapes>();
+
+///////////////////////////////////////////////////////////////////////////////
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace BOOST_SPIRIT_CLASSIC_NS
+
+#endif