1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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_SPIRIT_CHAR_PARSER_APR_16_2006_0906AM)
#define BOOST_SPIRIT_CHAR_PARSER_APR_16_2006_0906AM
#if defined(_MSC_VER)
#pragma once
#endif
#include <boost/spirit/home/qi/domain.hpp>
#include <boost/spirit/home/qi/parser.hpp>
#include <boost/spirit/home/qi/detail/assign_to.hpp>
#include <boost/spirit/home/qi/meta_compiler.hpp>
#include <boost/spirit/home/qi/skip_over.hpp>
#include <boost/spirit/home/support/unused.hpp>
#include <boost/spirit/home/support/info.hpp>
namespace boost { namespace spirit
{
///////////////////////////////////////////////////////////////////////////
// Enablers
///////////////////////////////////////////////////////////////////////////
template <>
struct use_operator<qi::domain, proto::tag::complement> // enables ~
: mpl::true_ {};
}}
namespace boost { namespace spirit { namespace traits // classification
{
namespace detail
{
BOOST_MPL_HAS_XXX_TRAIT_DEF(char_parser_id)
}
template <typename T>
struct is_char_parser : detail::has_char_parser_id<T> {};
}}}
namespace boost { namespace spirit { namespace qi
{
///////////////////////////////////////////////////////////////////////////
// The base char_parser
///////////////////////////////////////////////////////////////////////////
template <typename Derived, typename Char, typename Attr = Char>
struct char_parser : primitive_parser<Derived>
{
typedef Char char_type;
struct char_parser_id;
// if Attr is unused_type, Derived must supply its own attribute
// metafunction
template <typename Context, typename Iterator>
struct attribute
{
typedef Attr type;
};
template <typename Iterator, typename Context, typename Skipper, typename Attribute>
bool parse(Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper, Attribute& attr_) const
{
qi::skip_over(first, last, skipper);
if (first != last && this->derived().test(*first, context))
{
spirit::traits::assign_to(*first, attr_);
++first;
return true;
}
return false;
}
// Requirement: p.test(ch, context) -> bool
//
// ch: character being parsed
// context: enclosing rule context
};
///////////////////////////////////////////////////////////////////////////
// negated_char_parser handles ~cp expressions (cp is a char_parser)
///////////////////////////////////////////////////////////////////////////
template <typename Positive>
struct negated_char_parser :
char_parser<negated_char_parser<Positive>, typename Positive::char_type>
{
negated_char_parser(Positive const& positive_)
: positive(positive_) {}
template <typename CharParam, typename Context>
bool test(CharParam ch, Context& context) const
{
return !positive.test(ch, context);
}
template <typename Context>
info what(Context& context) const
{
return info("not", positive.what(context));
}
Positive positive;
};
///////////////////////////////////////////////////////////////////////////
// Parser generators: make_xxx function (objects)
///////////////////////////////////////////////////////////////////////////
namespace detail
{
template <typename Positive>
struct make_negated_char_parser
{
typedef negated_char_parser<Positive> result_type;
result_type operator()(Positive const& positive) const
{
return result_type(positive);
}
};
template <typename Positive>
struct make_negated_char_parser<negated_char_parser<Positive> >
{
typedef Positive result_type;
result_type operator()(negated_char_parser<Positive> const& ncp) const
{
return ncp.positive;
}
};
}
template <typename Elements, typename Modifiers>
struct make_composite<proto::tag::complement, Elements, Modifiers>
{
typedef typename
fusion::result_of::value_at_c<Elements, 0>::type
subject;
BOOST_SPIRIT_ASSERT_MSG((
traits::is_char_parser<subject>::value
), subject_is_not_negatable, (subject));
typedef typename
detail::make_negated_char_parser<subject>::result_type
result_type;
result_type operator()(Elements const& elements, unused_type) const
{
return detail::make_negated_char_parser<subject>()(
fusion::at_c<0>(elements));
}
};
}}}
#endif
|
