/Src/Dependencies/Boost/boost/spirit/home/classic/core/primitives/primitives.hpp
C++ Header | 654 lines | 411 code | 115 blank | 128 comment | 13 complexity | 61cf4e39f2be99f7144b58848fab49cc MD5 | raw file
1/*============================================================================= 2 Copyright (c) 1998-2003 Joel de Guzman 3 Copyright (c) 2003 Martin Wille 4 http://spirit.sourceforge.net/ 5 6 Distributed under the Boost Software License, Version 1.0. (See accompanying 7 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 8=============================================================================*/ 9#if !defined(BOOST_SPIRIT_PRIMITIVES_HPP) 10#define BOOST_SPIRIT_PRIMITIVES_HPP 11 12#include <boost/ref.hpp> 13#include <boost/spirit/home/classic/namespace.hpp> 14#include <boost/spirit/home/classic/core/assert.hpp> 15#include <boost/spirit/home/classic/core/parser.hpp> 16#include <boost/spirit/home/classic/core/composite/impl/directives.ipp> 17#include <boost/spirit/home/classic/core/primitives/impl/primitives.ipp> 18 19#ifdef BOOST_MSVC 20#pragma warning (push) 21#pragma warning(disable : 4512) 22#endif 23 24namespace boost { namespace spirit { 25 26BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN 27 28 /////////////////////////////////////////////////////////////////////////// 29 // 30 // char_parser class 31 // 32 /////////////////////////////////////////////////////////////////////////// 33 template <typename DerivedT> 34 struct char_parser : public parser<DerivedT> 35 { 36 typedef DerivedT self_t; 37 template <typename ScannerT> 38 struct result 39 { 40 typedef typename match_result< 41 ScannerT, 42 typename ScannerT::value_t 43 >::type type; 44 }; 45 46 template <typename ScannerT> 47 typename parser_result<self_t, ScannerT>::type 48 parse(ScannerT const& scan) const 49 { 50 typedef typename parser_result<self_t, ScannerT>::type result_t; 51 typedef typename ScannerT::value_t value_t; 52 typedef typename ScannerT::iterator_t iterator_t; 53 54 if (!scan.at_end()) 55 { 56 value_t ch = *scan; 57 if (this->derived().test(ch)) 58 { 59 iterator_t save(scan.first); 60 ++scan.first; 61 return scan.create_match(1, ch, save, scan.first); 62 } 63 } 64 return scan.no_match(); 65 } 66 }; 67 68 /////////////////////////////////////////////////////////////////////////// 69 // 70 // negation of char_parsers 71 // 72 /////////////////////////////////////////////////////////////////////////// 73 template <typename PositiveT> 74 struct negated_char_parser 75 : public char_parser<negated_char_parser<PositiveT> > 76 { 77 typedef negated_char_parser<PositiveT> self_t; 78 typedef PositiveT positive_t; 79 80 negated_char_parser(positive_t const& p) 81 : positive(p.derived()) {} 82 83 template <typename T> 84 bool test(T ch) const 85 { 86 return !positive.test(ch); 87 } 88 89 positive_t const positive; 90 }; 91 92 template <typename ParserT> 93 inline negated_char_parser<ParserT> 94 operator~(char_parser<ParserT> const& p) 95 { 96 return negated_char_parser<ParserT>(p.derived()); 97 } 98 99 template <typename ParserT> 100 inline ParserT 101 operator~(negated_char_parser<ParserT> const& n) 102 { 103 return n.positive; 104 } 105 106 /////////////////////////////////////////////////////////////////////////// 107 // 108 // chlit class 109 // 110 /////////////////////////////////////////////////////////////////////////// 111 template <typename CharT = char> 112 struct chlit : public char_parser<chlit<CharT> > 113 { 114 chlit(CharT ch_) 115 : ch(ch_) {} 116 117 template <typename T> 118 bool test(T ch_) const 119 { 120 return ch_ == ch; 121 } 122 123 CharT ch; 124 }; 125 126 template <typename CharT> 127 inline chlit<CharT> 128 ch_p(CharT ch) 129 { 130 return chlit<CharT>(ch); 131 } 132 133 // This should take care of ch_p("a") "bugs" 134 template <typename CharT, std::size_t N> 135 inline chlit<CharT> 136 ch_p(CharT const (& str)[N]) 137 { 138 // ch_p's argument should be a single character or a null-terminated 139 // string with a single character 140 BOOST_STATIC_ASSERT(N < 3); 141 return chlit<CharT>(str[0]); 142 } 143 144 /////////////////////////////////////////////////////////////////////////// 145 // 146 // range class 147 // 148 /////////////////////////////////////////////////////////////////////////// 149 template <typename CharT = char> 150 struct range : public char_parser<range<CharT> > 151 { 152 range(CharT first_, CharT last_) 153 : first(first_), last(last_) 154 { 155 BOOST_SPIRIT_ASSERT(!(last < first)); 156 } 157 158 template <typename T> 159 bool test(T ch) const 160 { 161 return !(CharT(ch) < first) && !(last < CharT(ch)); 162 } 163 164 CharT first; 165 CharT last; 166 }; 167 168 template <typename CharT> 169 inline range<CharT> 170 range_p(CharT first, CharT last) 171 { 172 return range<CharT>(first, last); 173 } 174 175 /////////////////////////////////////////////////////////////////////////// 176 // 177 // chseq class 178 // 179 /////////////////////////////////////////////////////////////////////////// 180 template <typename IteratorT = char const*> 181 class chseq : public parser<chseq<IteratorT> > 182 { 183 public: 184 185 typedef chseq<IteratorT> self_t; 186 187 chseq(IteratorT first_, IteratorT last_) 188 : first(first_), last(last_) {} 189 190 chseq(IteratorT first_) 191 : first(first_), last(impl::get_last(first_)) {} 192 193 template <typename ScannerT> 194 typename parser_result<self_t, ScannerT>::type 195 parse(ScannerT const& scan) const 196 { 197 typedef typename boost::unwrap_reference<IteratorT>::type striter_t; 198 typedef typename parser_result<self_t, ScannerT>::type result_t; 199 return impl::string_parser_parse<result_t>( 200 striter_t(first), 201 striter_t(last), 202 scan); 203 } 204 205 private: 206 207 IteratorT first; 208 IteratorT last; 209 }; 210 211 template <typename CharT> 212 inline chseq<CharT const*> 213 chseq_p(CharT const* str) 214 { 215 return chseq<CharT const*>(str); 216 } 217 218 template <typename IteratorT> 219 inline chseq<IteratorT> 220 chseq_p(IteratorT first, IteratorT last) 221 { 222 return chseq<IteratorT>(first, last); 223 } 224 225 /////////////////////////////////////////////////////////////////////////// 226 // 227 // strlit class 228 // 229 /////////////////////////////////////////////////////////////////////////// 230 template <typename IteratorT = char const*> 231 class strlit : public parser<strlit<IteratorT> > 232 { 233 public: 234 235 typedef strlit<IteratorT> self_t; 236 237 strlit(IteratorT first, IteratorT last) 238 : seq(first, last) {} 239 240 strlit(IteratorT first) 241 : seq(first) {} 242 243 template <typename ScannerT> 244 typename parser_result<self_t, ScannerT>::type 245 parse(ScannerT const& scan) const 246 { 247 typedef typename parser_result<self_t, ScannerT>::type result_t; 248 return impl::contiguous_parser_parse<result_t> 249 (seq, scan, scan); 250 } 251 252 private: 253 254 chseq<IteratorT> seq; 255 }; 256 257 template <typename CharT> 258 inline strlit<CharT const*> 259 str_p(CharT const* str) 260 { 261 return strlit<CharT const*>(str); 262 } 263 264 template <typename CharT> 265 inline strlit<CharT *> 266 str_p(CharT * str) 267 { 268 return strlit<CharT *>(str); 269 } 270 271 template <typename IteratorT> 272 inline strlit<IteratorT> 273 str_p(IteratorT first, IteratorT last) 274 { 275 return strlit<IteratorT>(first, last); 276 } 277 278 // This should take care of str_p('a') "bugs" 279 template <typename CharT> 280 inline chlit<CharT> 281 str_p(CharT ch) 282 { 283 return chlit<CharT>(ch); 284 } 285 286 /////////////////////////////////////////////////////////////////////////// 287 // 288 // nothing_parser class 289 // 290 /////////////////////////////////////////////////////////////////////////// 291 struct nothing_parser : public parser<nothing_parser> 292 { 293 typedef nothing_parser self_t; 294 295 nothing_parser() {} 296 297 template <typename ScannerT> 298 typename parser_result<self_t, ScannerT>::type 299 parse(ScannerT const& scan) const 300 { 301 return scan.no_match(); 302 } 303 }; 304 305 nothing_parser const nothing_p = nothing_parser(); 306 307 /////////////////////////////////////////////////////////////////////////// 308 // 309 // anychar_parser class 310 // 311 /////////////////////////////////////////////////////////////////////////// 312 struct anychar_parser : public char_parser<anychar_parser> 313 { 314 typedef anychar_parser self_t; 315 316 anychar_parser() {} 317 318 template <typename CharT> 319 bool test(CharT) const 320 { 321 return true; 322 } 323 }; 324 325 anychar_parser const anychar_p = anychar_parser(); 326 327 inline nothing_parser 328 operator~(anychar_parser) 329 { 330 return nothing_p; 331 } 332 333 /////////////////////////////////////////////////////////////////////////// 334 // 335 // alnum_parser class 336 // 337 /////////////////////////////////////////////////////////////////////////// 338 struct alnum_parser : public char_parser<alnum_parser> 339 { 340 typedef alnum_parser self_t; 341 342 alnum_parser() {} 343 344 template <typename CharT> 345 bool test(CharT ch) const 346 { 347 return impl::isalnum_(ch); 348 } 349 }; 350 351 alnum_parser const alnum_p = alnum_parser(); 352 353 /////////////////////////////////////////////////////////////////////////// 354 // 355 // alpha_parser class 356 // 357 /////////////////////////////////////////////////////////////////////////// 358 struct alpha_parser : public char_parser<alpha_parser> 359 { 360 typedef alpha_parser self_t; 361 362 alpha_parser() {} 363 364 template <typename CharT> 365 bool test(CharT ch) const 366 { 367 return impl::isalpha_(ch); 368 } 369 }; 370 371 alpha_parser const alpha_p = alpha_parser(); 372 373 /////////////////////////////////////////////////////////////////////////// 374 // 375 // cntrl_parser class 376 // 377 /////////////////////////////////////////////////////////////////////////// 378 struct cntrl_parser : public char_parser<cntrl_parser> 379 { 380 typedef cntrl_parser self_t; 381 382 cntrl_parser() {} 383 384 template <typename CharT> 385 bool test(CharT ch) const 386 { 387 return impl::iscntrl_(ch); 388 } 389 }; 390 391 cntrl_parser const cntrl_p = cntrl_parser(); 392 393 /////////////////////////////////////////////////////////////////////////// 394 // 395 // digit_parser class 396 // 397 /////////////////////////////////////////////////////////////////////////// 398 struct digit_parser : public char_parser<digit_parser> 399 { 400 typedef digit_parser self_t; 401 402 digit_parser() {} 403 404 template <typename CharT> 405 bool test(CharT ch) const 406 { 407 return impl::isdigit_(ch); 408 } 409 }; 410 411 digit_parser const digit_p = digit_parser(); 412 413 /////////////////////////////////////////////////////////////////////////// 414 // 415 // graph_parser class 416 // 417 /////////////////////////////////////////////////////////////////////////// 418 struct graph_parser : public char_parser<graph_parser> 419 { 420 typedef graph_parser self_t; 421 422 graph_parser() {} 423 424 template <typename CharT> 425 bool test(CharT ch) const 426 { 427 return impl::isgraph_(ch); 428 } 429 }; 430 431 graph_parser const graph_p = graph_parser(); 432 433 /////////////////////////////////////////////////////////////////////////// 434 // 435 // lower_parser class 436 // 437 /////////////////////////////////////////////////////////////////////////// 438 struct lower_parser : public char_parser<lower_parser> 439 { 440 typedef lower_parser self_t; 441 442 lower_parser() {} 443 444 template <typename CharT> 445 bool test(CharT ch) const 446 { 447 return impl::islower_(ch); 448 } 449 }; 450 451 lower_parser const lower_p = lower_parser(); 452 453 /////////////////////////////////////////////////////////////////////////// 454 // 455 // print_parser class 456 // 457 /////////////////////////////////////////////////////////////////////////// 458 struct print_parser : public char_parser<print_parser> 459 { 460 typedef print_parser self_t; 461 462 print_parser() {} 463 464 template <typename CharT> 465 bool test(CharT ch) const 466 { 467 return impl::isprint_(ch); 468 } 469 }; 470 471 print_parser const print_p = print_parser(); 472 473 /////////////////////////////////////////////////////////////////////////// 474 // 475 // punct_parser class 476 // 477 /////////////////////////////////////////////////////////////////////////// 478 struct punct_parser : public char_parser<punct_parser> 479 { 480 typedef punct_parser self_t; 481 482 punct_parser() {} 483 484 template <typename CharT> 485 bool test(CharT ch) const 486 { 487 return impl::ispunct_(ch); 488 } 489 }; 490 491 punct_parser const punct_p = punct_parser(); 492 493 /////////////////////////////////////////////////////////////////////////// 494 // 495 // blank_parser class 496 // 497 /////////////////////////////////////////////////////////////////////////// 498 struct blank_parser : public char_parser<blank_parser> 499 { 500 typedef blank_parser self_t; 501 502 blank_parser() {} 503 504 template <typename CharT> 505 bool test(CharT ch) const 506 { 507 return impl::isblank_(ch); 508 } 509 }; 510 511 blank_parser const blank_p = blank_parser(); 512 513 /////////////////////////////////////////////////////////////////////////// 514 // 515 // space_parser class 516 // 517 /////////////////////////////////////////////////////////////////////////// 518 struct space_parser : public char_parser<space_parser> 519 { 520 typedef space_parser self_t; 521 522 space_parser() {} 523 524 template <typename CharT> 525 bool test(CharT ch) const 526 { 527 return impl::isspace_(ch); 528 } 529 }; 530 531 space_parser const space_p = space_parser(); 532 533 /////////////////////////////////////////////////////////////////////////// 534 // 535 // upper_parser class 536 // 537 /////////////////////////////////////////////////////////////////////////// 538 struct upper_parser : public char_parser<upper_parser> 539 { 540 typedef upper_parser self_t; 541 542 upper_parser() {} 543 544 template <typename CharT> 545 bool test(CharT ch) const 546 { 547 return impl::isupper_(ch); 548 } 549 }; 550 551 upper_parser const upper_p = upper_parser(); 552 553 /////////////////////////////////////////////////////////////////////////// 554 // 555 // xdigit_parser class 556 // 557 /////////////////////////////////////////////////////////////////////////// 558 struct xdigit_parser : public char_parser<xdigit_parser> 559 { 560 typedef xdigit_parser self_t; 561 562 xdigit_parser() {} 563 564 template <typename CharT> 565 bool test(CharT ch) const 566 { 567 return impl::isxdigit_(ch); 568 } 569 }; 570 571 xdigit_parser const xdigit_p = xdigit_parser(); 572 573 /////////////////////////////////////////////////////////////////////////// 574 // 575 // eol_parser class (contributed by Martin Wille) 576 // 577 /////////////////////////////////////////////////////////////////////////// 578 struct eol_parser : public parser<eol_parser> 579 { 580 typedef eol_parser self_t; 581 582 eol_parser() {} 583 584 template <typename ScannerT> 585 typename parser_result<self_t, ScannerT>::type 586 parse(ScannerT const& scan) const 587 { 588 typename ScannerT::iterator_t save = scan.first; 589 std::size_t len = 0; 590 591 if (!scan.at_end() && *scan == '\r') // CR 592 { 593 ++scan.first; 594 ++len; 595 } 596 597 // Don't call skipper here 598 if (scan.first != scan.last && *scan == '\n') // LF 599 { 600 ++scan.first; 601 ++len; 602 } 603 604 if (len) 605 return scan.create_match(len, nil_t(), save, scan.first); 606 return scan.no_match(); 607 } 608 }; 609 610 eol_parser const eol_p = eol_parser(); 611 612 /////////////////////////////////////////////////////////////////////////// 613 // 614 // end_parser class (suggested by Markus Schoepflin) 615 // 616 /////////////////////////////////////////////////////////////////////////// 617 struct end_parser : public parser<end_parser> 618 { 619 typedef end_parser self_t; 620 621 end_parser() {} 622 623 template <typename ScannerT> 624 typename parser_result<self_t, ScannerT>::type 625 parse(ScannerT const& scan) const 626 { 627 if (scan.at_end()) 628 return scan.empty_match(); 629 return scan.no_match(); 630 } 631 }; 632 633 end_parser const end_p = end_parser(); 634 635 /////////////////////////////////////////////////////////////////////////// 636 // 637 // the pizza_p parser :-) 638 // 639 /////////////////////////////////////////////////////////////////////////// 640 inline strlit<char const*> const 641 pizza_p(char const* your_favorite_pizza) 642 { 643 return your_favorite_pizza; 644 } 645 646BOOST_SPIRIT_CLASSIC_NAMESPACE_END 647 648}} // namespace BOOST_SPIRIT_CLASSIC_NS 649 650#ifdef BOOST_MSVC 651#pragma warning (pop) 652#endif 653 654#endif