1// Copyright (c) 2001-2012 Hartmut Kaiser
2//
3// Distributed under the Boost Software License, Version 1.0. (See accompanying
4// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5
6#if !defined(BOOST_SPIRIT_KARMA_INT_FEB_23_2007_0840PM)
7#define BOOST_SPIRIT_KARMA_INT_FEB_23_2007_0840PM
8
9#if defined(_MSC_VER)
10#pragma once
11#endif
12
13#include <boost/limits.hpp>
14#include <boost/config.hpp>
15#include <boost/mpl/bool.hpp>
16#include <boost/utility/enable_if.hpp>
17
18#include <boost/spirit/home/support/common_terminals.hpp>
19#include <boost/spirit/home/support/string_traits.hpp>
20#include <boost/spirit/home/support/numeric_traits.hpp>
21#include <boost/spirit/home/support/info.hpp>
22#include <boost/spirit/home/support/char_class.hpp>
23#include <boost/spirit/home/support/container.hpp>
24#include <boost/spirit/home/support/detail/get_encoding.hpp>
25#include <boost/spirit/home/support/detail/is_spirit_tag.hpp>
26#include <boost/spirit/home/karma/meta_compiler.hpp>
27#include <boost/spirit/home/karma/delimit_out.hpp>
28#include <boost/spirit/home/karma/auxiliary/lazy.hpp>
29#include <boost/spirit/home/karma/detail/get_casetag.hpp>
30#include <boost/spirit/home/karma/detail/extract_from.hpp>
31#include <boost/spirit/home/karma/detail/enable_lit.hpp>
32#include <boost/spirit/home/karma/domain.hpp>
33#include <boost/spirit/home/karma/numeric/detail/numeric_utils.hpp>
34#include <boost/fusion/include/at.hpp>
35#include <boost/fusion/include/value_at.hpp>
36#include <boost/fusion/include/vector.hpp>
37
38///////////////////////////////////////////////////////////////////////////////
39namespace boost { namespace spirit
40{
41 namespace tag
42 {
43 template <typename T, unsigned Radix, bool force_sign>
44 struct int_generator
45 {
46 BOOST_SPIRIT_IS_TAG()
47 };
48 }
49
50 namespace karma
51 {
52 ///////////////////////////////////////////////////////////////////////
53 // This one is the class that the user can instantiate directly in
54 // order to create a customized int generator
55 template <typename T = int, unsigned Radix = 10, bool force_sign = false>
56 struct int_generator
57 : spirit::terminal<tag::int_generator<T, Radix, force_sign> >
58 {};
59 }
60
61 ///////////////////////////////////////////////////////////////////////////
62 // Enablers
63 ///////////////////////////////////////////////////////////////////////////
64 template <>
65 struct use_terminal<karma::domain, tag::short_> // enables short_
66 : mpl::true_ {};
67
68 template <>
69 struct use_terminal<karma::domain, tag::int_> // enables int_
70 : mpl::true_ {};
71
72 template <>
73 struct use_terminal<karma::domain, tag::long_> // enables long_
74 : mpl::true_ {};
75
76#ifdef BOOST_HAS_LONG_LONG
77 template <>
78 struct use_terminal<karma::domain, tag::long_long> // enables long_long
79 : mpl::true_ {};
80#endif
81
82 ///////////////////////////////////////////////////////////////////////////
83 template <>
84 struct use_terminal<karma::domain, short> // enables lit(short(0))
85 : mpl::true_ {};
86
87 template <>
88 struct use_terminal<karma::domain, int> // enables lit(0)
89 : mpl::true_ {};
90
91 template <>
92 struct use_terminal<karma::domain, long> // enables lit(0L)
93 : mpl::true_ {};
94
95#ifdef BOOST_HAS_LONG_LONG
96 template <>
97 struct use_terminal<karma::domain, boost::long_long_type> // enables lit(0LL)
98 : mpl::true_ {};
99#endif
100
101 ///////////////////////////////////////////////////////////////////////////
102 template <typename A0>
103 struct use_terminal<karma::domain // enables short_(...)
104 , terminal_ex<tag::short_, fusion::vector1<A0> >
105 > : mpl::true_ {};
106
107 template <typename A0>
108 struct use_terminal<karma::domain // enables int_(...)
109 , terminal_ex<tag::int_, fusion::vector1<A0> >
110 > : mpl::true_ {};
111
112 template <typename A0>
113 struct use_terminal<karma::domain // enables long_(...)
114 , terminal_ex<tag::long_, fusion::vector1<A0> >
115 > : mpl::true_ {};
116
117#ifdef BOOST_HAS_LONG_LONG
118 template <typename A0>
119 struct use_terminal<karma::domain // enables long_long(...)
120 , terminal_ex<tag::long_long, fusion::vector1<A0> >
121 > : mpl::true_ {};
122#endif
123
124 ///////////////////////////////////////////////////////////////////////////
125 template <> // enables *lazy* short_(...)
126 struct use_lazy_terminal<karma::domain, tag::short_, 1>
127 : mpl::true_ {};
128
129 template <> // enables *lazy* int_(...)
130 struct use_lazy_terminal<karma::domain, tag::int_, 1>
131 : mpl::true_ {};
132
133 template <> // enables *lazy* long_(...)
134 struct use_lazy_terminal<karma::domain, tag::long_, 1>
135 : mpl::true_ {};
136
137#ifdef BOOST_HAS_LONG_LONG
138 template <> // enables *lazy* long_long(...)
139 struct use_lazy_terminal<karma::domain, tag::long_long, 1>
140 : mpl::true_ {};
141#endif
142
143 ///////////////////////////////////////////////////////////////////////////
144 // enables any custom int_generator
145 template <typename T, unsigned Radix, bool force_sign>
146 struct use_terminal<karma::domain, tag::int_generator<T, Radix, force_sign> >
147 : mpl::true_ {};
148
149 // enables any custom int_generator(...)
150 template <typename T, unsigned Radix, bool force_sign, typename A0>
151 struct use_terminal<karma::domain
152 , terminal_ex<tag::int_generator<T, Radix, force_sign>
153 , fusion::vector1<A0> >
154 > : mpl::true_ {};
155
156 // enables *lazy* custom int_generator
157 template <typename T, unsigned Radix, bool force_sign>
158 struct use_lazy_terminal<
159 karma::domain
160 , tag::int_generator<T, Radix, force_sign>
161 , 1 // arity
162 > : mpl::true_ {};
163
164 // enables lit(int)
165 template <typename A0>
166 struct use_terminal<karma::domain
167 , terminal_ex<tag::lit, fusion::vector1<A0> >
168 , typename enable_if<traits::is_int<A0> >::type>
169 : mpl::true_ {};
170}}
171
172///////////////////////////////////////////////////////////////////////////////
173namespace boost { namespace spirit { namespace karma
174{
175#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
176 using spirit::short_;
177 using spirit::int_;
178 using spirit::long_;
179#ifdef BOOST_HAS_LONG_LONG
180 using spirit::long_long;
181#endif
182 using spirit::lit; // lit(1) is equivalent to 1
183#endif
184
185 using spirit::short_type;
186 using spirit::int_type;
187 using spirit::long_type;
188#ifdef BOOST_HAS_LONG_LONG
189 using spirit::long_long_type;
190#endif
191
192 using spirit::lit_type;
193
194 ///////////////////////////////////////////////////////////////////////////
195 // This specialization is used for int generators not having a direct
196 // initializer: int_, long_ etc. These generators must be used in
197 // conjunction with an Attribute.
198 ///////////////////////////////////////////////////////////////////////////
199 template <
200 typename T, typename CharEncoding, typename Tag, unsigned Radix
201 , bool force_sign>
202 struct any_int_generator
203 : primitive_generator<any_int_generator<T, CharEncoding, Tag, Radix
204 , force_sign> >
205 {
206 private:
207 template <typename OutputIterator, typename Attribute>
208 static bool insert_int(OutputIterator& sink, Attribute const& attr)
209 {
210 return sign_inserter::call(sink, traits::test_zero(attr)
211 , traits::test_negative(attr), force_sign) &&
212 int_inserter<Radix, CharEncoding, Tag>::call(sink
213 , traits::get_absolute_value(attr));
214 }
215
216 public:
217 template <typename Context, typename Unused>
218 struct attribute
219 {
220 typedef T type;
221 };
222
223 // check template Attribute 'Radix' for validity
224 BOOST_SPIRIT_ASSERT_MSG(
225 Radix == 2 || Radix == 8 || Radix == 10 || Radix == 16,
226 not_supported_radix, ());
227
228 BOOST_SPIRIT_ASSERT_MSG(std::numeric_limits<T>::is_signed,
229 signed_unsigned_mismatch, ());
230
231 // int has a Attribute attached
232 template <typename OutputIterator, typename Context, typename Delimiter
233 , typename Attribute>
234 static bool
235 generate(OutputIterator& sink, Context& context, Delimiter const& d
236 , Attribute const& attr)
237 {
238 if (!traits::has_optional_value(attr))
239 return false; // fail if it's an uninitialized optional
240
241 return insert_int(sink, traits::extract_from<T>(attr, context)) &&
242 delimit_out(sink, d); // always do post-delimiting
243 }
244
245 // this int has no Attribute attached, it needs to have been
246 // initialized from a direct literal
247 template <typename OutputIterator, typename Context, typename Delimiter>
248 static bool
249 generate(OutputIterator&, Context&, Delimiter const&, unused_type)
250 {
251 // It is not possible (doesn't make sense) to use numeric generators
252 // without providing any attribute, as the generator doesn't 'know'
253 // what to output. The following assertion fires if this situation
254 // is detected in your code.
255 BOOST_SPIRIT_ASSERT_FAIL(OutputIterator, int_not_usable_without_attribute, ());
256 return false;
257 }
258
259 template <typename Context>
260 static info what(Context const& /*context*/)
261 {
262 return info("integer");
263 }
264 };
265
266 ///////////////////////////////////////////////////////////////////////////
267 // This specialization is used for int generators having a direct
268 // initializer: int_(10), long_(20) etc.
269 ///////////////////////////////////////////////////////////////////////////
270 template <
271 typename T, typename CharEncoding, typename Tag, unsigned Radix
272 , bool force_sign, bool no_attribute>
273 struct literal_int_generator
274 : primitive_generator<literal_int_generator<T, CharEncoding, Tag, Radix
275 , force_sign, no_attribute> >
276 {
277 private:
278 template <typename OutputIterator, typename Attribute>
279 static bool insert_int(OutputIterator& sink, Attribute const& attr)
280 {
281 return sign_inserter::call(sink, traits::test_zero(attr)
282 , traits::test_negative(attr), force_sign) &&
283 int_inserter<Radix, CharEncoding, Tag>::call(sink
284 , traits::get_absolute_value(attr));
285 }
286
287 public:
288 template <typename Context, typename Unused = unused_type>
289 struct attribute
290 : mpl::if_c<no_attribute, unused_type, T>
291 {};
292
293 literal_int_generator(typename add_const<T>::type n)
294 : n_(n) {}
295
296 // check template Attribute 'Radix' for validity
297 BOOST_SPIRIT_ASSERT_MSG(
298 Radix == 2 || Radix == 8 || Radix == 10 || Radix == 16,
299 not_supported_radix, ());
300
301 BOOST_SPIRIT_ASSERT_MSG(std::numeric_limits<T>::is_signed,
302 signed_unsigned_mismatch, ());
303
304 // A int_(1) which additionally has an associated attribute emits
305 // its immediate literal only if it matches the attribute, otherwise
306 // it fails.
307 template <typename OutputIterator, typename Context, typename Delimiter
308 , typename Attribute>
309 bool generate(OutputIterator& sink, Context& context
310 , Delimiter const& d, Attribute const& attr) const
311 {
312 typedef typename attribute<Context>::type attribute_type;
313 if (!traits::has_optional_value(attr) ||
314 n_ != traits::extract_from<attribute_type>(attr, context))
315 {
316 return false;
317 }
318 return insert_int(sink, n_) && delimit_out(sink, d);
319 }
320
321 // A int_(1) without any associated attribute just emits its
322 // immediate literal
323 template <typename OutputIterator, typename Context, typename Delimiter>
324 bool generate(OutputIterator& sink, Context&, Delimiter const& d
325 , unused_type) const
326 {
327 return insert_int(sink, n_) && delimit_out(sink, d);
328 }
329
330 template <typename Context>
331 static info what(Context const& /*context*/)
332 {
333 return info("integer");
334 }
335
336 T n_;
337 };
338
339 ///////////////////////////////////////////////////////////////////////////
340 // Generator generators: make_xxx function (objects)
341 ///////////////////////////////////////////////////////////////////////////
342 namespace detail
343 {
344 template <typename T, typename Modifiers, unsigned Radix = 10
345 , bool force_sign = false>
346 struct make_int
347 {
348 static bool const lower =
349 has_modifier<Modifiers, tag::char_code_base<tag::lower> >::value;
350 static bool const upper =
351 has_modifier<Modifiers, tag::char_code_base<tag::upper> >::value;
352
353 typedef any_int_generator<
354 T
355 , typename spirit::detail::get_encoding_with_case<
356 Modifiers, unused_type, lower || upper>::type
357 , typename detail::get_casetag<Modifiers, lower || upper>::type
358 , Radix
359 , force_sign
360 > result_type;
361
362 result_type operator()(unused_type, unused_type) const
363 {
364 return result_type();
365 }
366 };
367 }
368
369 ///////////////////////////////////////////////////////////////////////////
370 template <typename Modifiers>
371 struct make_primitive<tag::short_, Modifiers>
372 : detail::make_int<short, Modifiers> {};
373
374 template <typename Modifiers>
375 struct make_primitive<tag::int_, Modifiers>
376 : detail::make_int<int, Modifiers> {};
377
378 template <typename Modifiers>
379 struct make_primitive<tag::long_, Modifiers>
380 : detail::make_int<long, Modifiers> {};
381
382#ifdef BOOST_HAS_LONG_LONG
383 template <typename Modifiers>
384 struct make_primitive<tag::long_long, Modifiers>
385 : detail::make_int<boost::long_long_type, Modifiers> {};
386#endif
387
388 template <typename T, unsigned Radix, bool force_sign, typename Modifiers>
389 struct make_primitive<tag::int_generator<T, Radix, force_sign>, Modifiers>
390 : detail::make_int<typename remove_const<T>::type
391 , Modifiers, Radix, force_sign> {};
392
393 ///////////////////////////////////////////////////////////////////////////
394 namespace detail
395 {
396 template <typename T, typename Modifiers, unsigned Radix = 10
397 , bool force_sign = false>
398 struct make_int_direct
399 {
400 static bool const lower =
401 has_modifier<Modifiers, tag::char_code_base<tag::lower> >::value;
402 static bool const upper =
403 has_modifier<Modifiers, tag::char_code_base<tag::upper> >::value;
404
405 typedef literal_int_generator<
406 T
407 , typename spirit::detail::get_encoding_with_case<
408 Modifiers, unused_type, lower || upper>::type
409 , typename detail::get_casetag<Modifiers, lower || upper>::type
410 , Radix, force_sign, false
411 > result_type;
412
413 template <typename Terminal>
414 result_type operator()(Terminal const& term, unused_type) const
415 {
416 return result_type(fusion::at_c<0>(term.args));
417 }
418 };
419 }
420
421 ///////////////////////////////////////////////////////////////////////////
422 template <typename Modifiers, typename A0>
423 struct make_primitive<
424 terminal_ex<tag::short_, fusion::vector1<A0> >, Modifiers>
425 : detail::make_int_direct<short, Modifiers> {};
426
427 template <typename Modifiers, typename A0>
428 struct make_primitive<
429 terminal_ex<tag::int_, fusion::vector1<A0> >, Modifiers>
430 : detail::make_int_direct<int, Modifiers> {};
431
432 template <typename Modifiers, typename A0>
433 struct make_primitive<
434 terminal_ex<tag::long_, fusion::vector1<A0> >, Modifiers>
435 : detail::make_int_direct<long, Modifiers> {};
436
437#ifdef BOOST_HAS_LONG_LONG
438 template <typename Modifiers, typename A0>
439 struct make_primitive<
440 terminal_ex<tag::long_long, fusion::vector1<A0> >, Modifiers>
441 : detail::make_int_direct<boost::long_long_type, Modifiers> {};
442#endif
443
444 template <typename T, unsigned Radix, bool force_sign, typename A0
445 , typename Modifiers>
446 struct make_primitive<
447 terminal_ex<tag::int_generator<T, Radix, force_sign>
448 , fusion::vector1<A0> >, Modifiers>
449 : detail::make_int_direct<typename remove_const<T>::type
450 , Modifiers, Radix, force_sign> {};
451
452 ///////////////////////////////////////////////////////////////////////////
453 namespace detail
454 {
455 template <typename T, typename Modifiers>
456 struct basic_int_literal
457 {
458 static bool const lower =
459 has_modifier<Modifiers, tag::char_code_base<tag::lower> >::value;
460 static bool const upper =
461 has_modifier<Modifiers, tag::char_code_base<tag::upper> >::value;
462
463 typedef literal_int_generator<
464 T
465 , typename spirit::detail::get_encoding_with_case<
466 Modifiers, unused_type, lower || upper>::type
467 , typename detail::get_casetag<Modifiers, lower || upper>::type
468 , 10, false, true
469 > result_type;
470
471 template <typename T_>
472 result_type operator()(T_ i, unused_type) const
473 {
474 return result_type(i);
475 }
476 };
477 }
478
479 template <typename Modifiers>
480 struct make_primitive<short, Modifiers>
481 : detail::basic_int_literal<short, Modifiers> {};
482
483 template <typename Modifiers>
484 struct make_primitive<int, Modifiers>
485 : detail::basic_int_literal<int, Modifiers> {};
486
487 template <typename Modifiers>
488 struct make_primitive<long, Modifiers>
489 : detail::basic_int_literal<long, Modifiers> {};
490
491#ifdef BOOST_HAS_LONG_LONG
492 template <typename Modifiers>
493 struct make_primitive<boost::long_long_type, Modifiers>
494 : detail::basic_int_literal<boost::long_long_type, Modifiers> {};
495#endif
496
497 // lit(int)
498 template <typename Modifiers, typename A0>
499 struct make_primitive<
500 terminal_ex<tag::lit, fusion::vector1<A0> >
501 , Modifiers
502 , typename enable_if<traits::is_int<A0> >::type>
503 {
504 static bool const lower =
505 has_modifier<Modifiers, tag::char_code_base<tag::lower> >::value;
506 static bool const upper =
507 has_modifier<Modifiers, tag::char_code_base<tag::upper> >::value;
508
509 typedef literal_int_generator<
510 typename remove_const<A0>::type
511 , typename spirit::detail::get_encoding_with_case<
512 Modifiers, unused_type, lower || upper>::type
513 , typename detail::get_casetag<Modifiers, lower || upper>::type
514 , 10, false, true
515 > result_type;
516
517 template <typename Terminal>
518 result_type operator()(Terminal const& term, unused_type) const
519 {
520 return result_type(fusion::at_c<0>(term.args));
521 }
522 };
523}}}
524
525#endif
526

source code of boost/libs/spirit/include/boost/spirit/home/karma/numeric/int.hpp