← Back to branch summary

~ubuntu-branches/ubuntu/warty/aqsis/warty

« back to all changes in this revision

Viewing changes to boost/boost/spirit/core/meta/impl/parser_traits.ipp

  • Committer: Bazaar Package Importer
  • Author(s): LaMont Jones
  • Date: 2004-08-24 07:25:04 UTC
  • Revision ID: james.westby@ubuntu.com-20040824072504-zf993vnevvisdsvb
Tags: upstream-0.9.1
Import upstream version 0.9.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/boost/spirit/core/meta/impl/parser_traits.ipp
 
1
/*=============================================================================
 
2
    Spirit v1.6.1
 
3
    Copyright (c) 2002-2003 Joel de Guzman
 
4
    Copyright (c) 2002-2003 Hartmut Kaiser
 
5
    Copyright (c) 2003 Martin Wille
 
6
    http://spirit.sourceforge.net/
 
7
 
 
8
    Permission to copy, use, modify, sell and distribute this software is
 
9
    granted provided this copyright notice appears in all copies. This
 
10
    software is provided "as is" without express or implied warranty, and
 
11
    with no claim as to its suitability for any purpose.
 
12
=============================================================================*/
 
13
#if !defined(BOOST_SPIRIT_PARSER_TRAITS_IPP)
 
14
#define BOOST_SPIRIT_PARSER_TRAITS_IPP
 
15
 
 
16
#include "boost/spirit/core/composite/operators.hpp"
 
17
 
 
18
///////////////////////////////////////////////////////////////////////////////
 
19
namespace boost { namespace spirit {
 
20
 
 
21
namespace impl
 
22
{
 
23
 
 
24
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
25
 
 
26
    ///////////////////////////////////////////////////////////////////////////
 
27
    //
 
28
    //  from spirit 1.1 (copyright (c) 2001 Bruce Florman)
 
29
    //  various workarounds to support compile time decisions without partial
 
30
    //  template specialization whether a given type is an instance of a
 
31
    //  concrete parser type.
 
32
    //
 
33
    ///////////////////////////////////////////////////////////////////////////
 
34
 
 
35
    ///////////////////////////////////////////////////////////////////////////
 
36
    template <typename T>
 
37
    struct parser_type_traits
 
38
    {
 
39
    //  Determine at compile time (without partial specialization)
 
40
    //  whether a given type is an instance of the alternative<A,B>
 
41
 
 
42
        static T t();
 
43
 
 
44
        typedef struct { char dummy[1]; }   size1_t;
 
45
        typedef struct { char dummy[2]; }   size2_t;
 
46
        typedef struct { char dummy[3]; }   size3_t;
 
47
        typedef struct { char dummy[4]; }   size4_t;
 
48
        typedef struct { char dummy[5]; }   size5_t;
 
49
        typedef struct { char dummy[6]; }   size6_t;
 
50
        typedef struct { char dummy[7]; }   size7_t;
 
51
        typedef struct { char dummy[8]; }   size8_t;
 
52
        typedef struct { char dummy[9]; }   size9_t;
 
53
        typedef struct { char dummy[10]; }  size10_t;
 
54
 
 
55
    // the following functions need no implementation
 
56
        template <typename A, typename B>
 
57
        static size1_t test_(alternative<A, B> const&);
 
58
        template <typename A, typename B>
 
59
        static size2_t test_(sequence<A, B> const&);
 
60
        template <typename A, typename B>
 
61
        static size3_t test_(sequential_or<A, B> const&);
 
62
        template <typename A, typename B>
 
63
        static size4_t test_(intersection<A, B> const&);
 
64
        template <typename A, typename B>
 
65
        static size5_t test_(difference<A, B> const&);
 
66
        template <typename A, typename B>
 
67
        static size6_t test_(exclusive_or<A, B> const&);
 
68
        template <typename S>
 
69
        static size7_t test_(optional<S> const&);
 
70
        template <typename S>
 
71
        static size8_t test_(kleene_star<S> const&);
 
72
        template <typename S>
 
73
        static size9_t test_(positive<S> const&);
 
74
 
 
75
        static size10_t test_(...);
 
76
 
 
77
        BOOST_STATIC_CONSTANT(bool,
 
78
            is_alternative = (sizeof(size1_t) == sizeof(test_(t()))) );
 
79
        BOOST_STATIC_CONSTANT(bool,
 
80
            is_sequence = (sizeof(size2_t) == sizeof(test_(t()))) );
 
81
        BOOST_STATIC_CONSTANT(bool,
 
82
            is_sequential_or = (sizeof(size3_t) == sizeof(test_(t()))) );
 
83
        BOOST_STATIC_CONSTANT(bool,
 
84
            is_intersection = (sizeof(size4_t) == sizeof(test_(t()))) );
 
85
        BOOST_STATIC_CONSTANT(bool,
 
86
            is_difference = (sizeof(size5_t) == sizeof(test_(t()))) );
 
87
        BOOST_STATIC_CONSTANT(bool,
 
88
            is_exclusive_or = (sizeof(size6_t) == sizeof(test_(t()))) );
 
89
        BOOST_STATIC_CONSTANT(bool,
 
90
            is_optional = (sizeof(size7_t) == sizeof(test_(t()))) );
 
91
        BOOST_STATIC_CONSTANT(bool,
 
92
            is_kleene_star = (sizeof(size8_t) == sizeof(test_(t()))) );
 
93
        BOOST_STATIC_CONSTANT(bool,
 
94
            is_positive = (sizeof(size9_t) == sizeof(test_(t()))) );
 
95
    };
 
96
 
 
97
#else
 
98
 
 
99
    ///////////////////////////////////////////////////////////////////////////
 
100
    struct parser_type_traits_base {
 
101
 
 
102
        BOOST_STATIC_CONSTANT(bool, is_alternative = false);
 
103
        BOOST_STATIC_CONSTANT(bool, is_sequence = false);
 
104
        BOOST_STATIC_CONSTANT(bool, is_sequential_or = false);
 
105
        BOOST_STATIC_CONSTANT(bool, is_intersection = false);
 
106
        BOOST_STATIC_CONSTANT(bool, is_difference = false);
 
107
        BOOST_STATIC_CONSTANT(bool, is_exclusive_or = false);
 
108
        BOOST_STATIC_CONSTANT(bool, is_optional = false);
 
109
        BOOST_STATIC_CONSTANT(bool, is_kleene_star = false);
 
110
        BOOST_STATIC_CONSTANT(bool, is_positive = false);
 
111
    };
 
112
 
 
113
    template <typename ParserT>
 
114
    struct parser_type_traits : public parser_type_traits_base {
 
115
 
 
116
    //  no definition here, fallback for all not explicitly mentioned parser
 
117
    //  types
 
118
    };
 
119
 
 
120
    template <typename A, typename B>
 
121
    struct parser_type_traits<alternative<A, B> >
 
122
    :   public parser_type_traits_base {
 
123
 
 
124
        BOOST_STATIC_CONSTANT(bool, is_alternative = true);
 
125
    };
 
126
 
 
127
    template <typename A, typename B>
 
128
    struct parser_type_traits<sequence<A, B> >
 
129
    :   public parser_type_traits_base {
 
130
 
 
131
        BOOST_STATIC_CONSTANT(bool, is_sequence = true);
 
132
    };
 
133
 
 
134
    template <typename A, typename B>
 
135
    struct parser_type_traits<sequential_or<A, B> >
 
136
    :   public parser_type_traits_base {
 
137
 
 
138
        BOOST_STATIC_CONSTANT(bool, is_sequential_or = true);
 
139
    };
 
140
 
 
141
    template <typename A, typename B>
 
142
    struct parser_type_traits<intersection<A, B> >
 
143
    :   public parser_type_traits_base {
 
144
 
 
145
        BOOST_STATIC_CONSTANT(bool, is_intersection = true);
 
146
    };
 
147
 
 
148
    template <typename A, typename B>
 
149
    struct parser_type_traits<difference<A, B> >
 
150
    :   public parser_type_traits_base {
 
151
 
 
152
        BOOST_STATIC_CONSTANT(bool, is_difference = true);
 
153
    };
 
154
 
 
155
    template <typename A, typename B>
 
156
    struct parser_type_traits<exclusive_or<A, B> >
 
157
    :   public parser_type_traits_base {
 
158
 
 
159
        BOOST_STATIC_CONSTANT(bool, is_exclusive_or = true);
 
160
    };
 
161
 
 
162
    template <typename S>
 
163
    struct parser_type_traits<optional<S> >
 
164
    :   public parser_type_traits_base {
 
165
 
 
166
        BOOST_STATIC_CONSTANT(bool, is_optional = true);
 
167
    };
 
168
 
 
169
    template <typename S>
 
170
    struct parser_type_traits<kleene_star<S> >
 
171
    :   public parser_type_traits_base {
 
172
 
 
173
        BOOST_STATIC_CONSTANT(bool, is_kleene_star = true);
 
174
    };
 
175
 
 
176
    template <typename S>
 
177
    struct parser_type_traits<positive<S> >
 
178
    :   public parser_type_traits_base {
 
179
 
 
180
        BOOST_STATIC_CONSTANT(bool, is_positive = true);
 
181
    };
 
182
 
 
183
#endif // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
184
}   // namespace impl
 
185
 
 
186
///////////////////////////////////////////////////////////////////////////////
 
187
}} // namespace boost::spirit
 
188
 
 
189
#endif // !defined(BOOST_SPIRIT_PARSER_TRAITS_IPP)