/Src/Dependencies/Boost/boost/spirit/home/karma/numeric/int.hpp
C++ Header | 525 lines | 401 code | 73 blank | 51 comment | 27 complexity | 83006643336db164c42bafd676fcb98f MD5 | raw file
1// Copyright (c) 2001-2011 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_MSG(false, 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