1 // Locale support -*- C++ -*- 2 3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 4 // 2006, 2007, 2008, 2009, 2010, 2011 5 // Free Software Foundation, Inc. 6 // 7 // This file is part of the GNU ISO C++ Library. This library is free 8 // software; you can redistribute it and/or modify it under the 9 // terms of the GNU General Public License as published by the 10 // Free Software Foundation; either version 3, or (at your option) 11 // any later version. 12 13 // This library is distributed in the hope that it will be useful, 14 // but WITHOUT ANY WARRANTY; without even the implied warranty of 15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 // GNU General Public License for more details. 17 18 // Under Section 7 of GPL version 3, you are granted additional 19 // permissions described in the GCC Runtime Library Exception, version 20 // 3.1, as published by the Free Software Foundation. 21 22 // You should have received a copy of the GNU General Public License and 23 // a copy of the GCC Runtime Library Exception along with this program; 24 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 25 // <http://www.gnu.org/licenses/>. 26 27 /** @file bits/locale_facets.h 28 * This is an internal header file, included by other library headers. 29 * Do not attempt to use it directly. @headername{locale} 30 */ 31 32 // 33 // ISO C++ 14882: 22.1 Locales 34 // 35 36 #ifndef _LOCALE_FACETS_H 37 #define _LOCALE_FACETS_H 1 38 39 #pragma GCC system_header 40 41 #include <cwctype> // For wctype_t 42 #include <cctype> 43 #include <bits/ctype_base.h> 44 #include <iosfwd> 45 #include <bits/ios_base.h> // For ios_base, ios_base::iostate 46 #include <streambuf> 47 #include <bits/cpp_type_traits.h> 48 #include <ext/type_traits.h> 49 #include <ext/numeric_traits.h> 50 #include <bits/streambuf_iterator.h> 51 52 namespace std _GLIBCXX_VISIBILITY(default) 53 { 54 _GLIBCXX_BEGIN_NAMESPACE_VERSION 55 56 // NB: Don't instantiate required wchar_t facets if no wchar_t support. 57 #ifdef _GLIBCXX_USE_WCHAR_T 58 # define _GLIBCXX_NUM_FACETS 28 59 #else 60 # define _GLIBCXX_NUM_FACETS 14 61 #endif 62 63 // Convert string to numeric value of type _Tp and store results. 64 // NB: This is specialized for all required types, there is no 65 // generic definition. 66 template<typename _Tp> 67 void 68 __convert_to_v(const char*, _Tp&, ios_base::iostate&, 69 const __c_locale&) throw(); 70 71 // Explicit specializations for required types. 72 template<> 73 void 74 __convert_to_v(const char*, float&, ios_base::iostate&, 75 const __c_locale&) throw(); 76 77 template<> 78 void 79 __convert_to_v(const char*, double&, ios_base::iostate&, 80 const __c_locale&) throw(); 81 82 template<> 83 void 84 __convert_to_v(const char*, long double&, ios_base::iostate&, 85 const __c_locale&) throw(); 86 87 // NB: __pad is a struct, rather than a function, so it can be 88 // partially-specialized. 89 template<typename _CharT, typename _Traits> 90 struct __pad 91 { 92 static void 93 _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, 94 const _CharT* __olds, streamsize __newlen, streamsize __oldlen); 95 }; 96 97 // Used by both numeric and monetary facets. 98 // Inserts "group separator" characters into an array of characters. 99 // It's recursive, one iteration per group. It moves the characters 100 // in the buffer this way: "xxxx12345" -> "12,345xxx". Call this 101 // only with __gsize != 0. 102 template<typename _CharT> 103 _CharT* 104 __add_grouping(_CharT* __s, _CharT __sep, 105 const char* __gbeg, size_t __gsize, 106 const _CharT* __first, const _CharT* __last); 107 108 // This template permits specializing facet output code for 109 // ostreambuf_iterator. For ostreambuf_iterator, sputn is 110 // significantly more efficient than incrementing iterators. 111 template<typename _CharT> 112 inline 113 ostreambuf_iterator<_CharT> 114 __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) 115 { 116 __s._M_put(__ws, __len); 117 return __s; 118 } 119 120 // This is the unspecialized form of the template. 121 template<typename _CharT, typename _OutIter> 122 inline 123 _OutIter 124 __write(_OutIter __s, const _CharT* __ws, int __len) 125 { 126 for (int __j = 0; __j < __len; __j++, ++__s) 127 *__s = __ws[__j]; 128 return __s; 129 } 130 131 132 // 22.2.1.1 Template class ctype 133 // Include host and configuration specific ctype enums for ctype_base. 134 135 /** 136 * @brief Common base for ctype facet 137 * 138 * This template class provides implementations of the public functions 139 * that forward to the protected virtual functions. 140 * 141 * This template also provides abstract stubs for the protected virtual 142 * functions. 143 */ 144 template<typename _CharT> 145 class __ctype_abstract_base : public locale::facet, public ctype_base 146 { 147 public: 148 // Types: 149 /// Typedef for the template parameter 150 typedef _CharT char_type; 151 152 /** 153 * @brief Test char_type classification. 154 * 155 * This function finds a mask M for @a c and compares it to mask @a m. 156 * It does so by returning the value of ctype<char_type>::do_is(). 157 * 158 * @param c The char_type to compare the mask of. 159 * @param m The mask to compare against. 160 * @return (M & m) != 0. 161 */ 162 bool 163 is(mask __m, char_type __c) const 164 { return this->do_is(__m, __c); } 165 166 /** 167 * @brief Return a mask array. 168 * 169 * This function finds the mask for each char_type in the range [lo,hi) 170 * and successively writes it to vec. vec must have as many elements 171 * as the char array. It does so by returning the value of 172 * ctype<char_type>::do_is(). 173 * 174 * @param lo Pointer to start of range. 175 * @param hi Pointer to end of range. 176 * @param vec Pointer to an array of mask storage. 177 * @return @a hi. 178 */ 179 const char_type* 180 is(const char_type *__lo, const char_type *__hi, mask *__vec) const 181 { return this->do_is(__lo, __hi, __vec); } 182 183 /** 184 * @brief Find char_type matching a mask 185 * 186 * This function searches for and returns the first char_type c in 187 * [lo,hi) for which is(m,c) is true. It does so by returning 188 * ctype<char_type>::do_scan_is(). 189 * 190 * @param m The mask to compare against. 191 * @param lo Pointer to start of range. 192 * @param hi Pointer to end of range. 193 * @return Pointer to matching char_type if found, else @a hi. 194 */ 195 const char_type* 196 scan_is(mask __m, const char_type* __lo, const char_type* __hi) const 197 { return this->do_scan_is(__m, __lo, __hi); } 198 199 /** 200 * @brief Find char_type not matching a mask 201 * 202 * This function searches for and returns the first char_type c in 203 * [lo,hi) for which is(m,c) is false. It does so by returning 204 * ctype<char_type>::do_scan_not(). 205 * 206 * @param m The mask to compare against. 207 * @param lo Pointer to first char in range. 208 * @param hi Pointer to end of range. 209 * @return Pointer to non-matching char if found, else @a hi. 210 */ 211 const char_type* 212 scan_not(mask __m, const char_type* __lo, const char_type* __hi) const 213 { return this->do_scan_not(__m, __lo, __hi); } 214 215 /** 216 * @brief Convert to uppercase. 217 * 218 * This function converts the argument to uppercase if possible. 219 * If not possible (for example, '2'), returns the argument. It does 220 * so by returning ctype<char_type>::do_toupper(). 221 * 222 * @param c The char_type to convert. 223 * @return The uppercase char_type if convertible, else @a c. 224 */ 225 char_type 226 toupper(char_type __c) const 227 { return this->do_toupper(__c); } 228 229 /** 230 * @brief Convert array to uppercase. 231 * 232 * This function converts each char_type in the range [lo,hi) to 233 * uppercase if possible. Other elements remain untouched. It does so 234 * by returning ctype<char_type>:: do_toupper(lo, hi). 235 * 236 * @param lo Pointer to start of range. 237 * @param hi Pointer to end of range. 238 * @return @a hi. 239 */ 240 const char_type* 241 toupper(char_type *__lo, const char_type* __hi) const 242 { return this->do_toupper(__lo, __hi); } 243 244 /** 245 * @brief Convert to lowercase. 246 * 247 * This function converts the argument to lowercase if possible. If 248 * not possible (for example, '2'), returns the argument. It does so 249 * by returning ctype<char_type>::do_tolower(c). 250 * 251 * @param c The char_type to convert. 252 * @return The lowercase char_type if convertible, else @a c. 253 */ 254 char_type 255 tolower(char_type __c) const 256 { return this->do_tolower(__c); } 257 258 /** 259 * @brief Convert array to lowercase. 260 * 261 * This function converts each char_type in the range [lo,hi) to 262 * lowercase if possible. Other elements remain untouched. It does so 263 * by returning ctype<char_type>:: do_tolower(lo, hi). 264 * 265 * @param lo Pointer to start of range. 266 * @param hi Pointer to end of range. 267 * @return @a hi. 268 */ 269 const char_type* 270 tolower(char_type* __lo, const char_type* __hi) const 271 { return this->do_tolower(__lo, __hi); } 272 273 /** 274 * @brief Widen char to char_type 275 * 276 * This function converts the char argument to char_type using the 277 * simplest reasonable transformation. It does so by returning 278 * ctype<char_type>::do_widen(c). 279 * 280 * Note: this is not what you want for codepage conversions. See 281 * codecvt for that. 282 * 283 * @param c The char to convert. 284 * @return The converted char_type. 285 */ 286 char_type 287 widen(char __c) const 288 { return this->do_widen(__c); } 289 290 /** 291 * @brief Widen array to char_type 292 * 293 * This function converts each char in the input to char_type using the 294 * simplest reasonable transformation. It does so by returning 295 * ctype<char_type>::do_widen(c). 296 * 297 * Note: this is not what you want for codepage conversions. See 298 * codecvt for that. 299 * 300 * @param lo Pointer to start of range. 301 * @param hi Pointer to end of range. 302 * @param to Pointer to the destination array. 303 * @return @a hi. 304 */ 305 const char* 306 widen(const char* __lo, const char* __hi, char_type* __to) const 307 { return this->do_widen(__lo, __hi, __to); } 308 309 /** 310 * @brief Narrow char_type to char 311 * 312 * This function converts the char_type to char using the simplest 313 * reasonable transformation. If the conversion fails, dfault is 314 * returned instead. It does so by returning 315 * ctype<char_type>::do_narrow(c). 316 * 317 * Note: this is not what you want for codepage conversions. See 318 * codecvt for that. 319 * 320 * @param c The char_type to convert. 321 * @param dfault Char to return if conversion fails. 322 * @return The converted char. 323 */ 324 char 325 narrow(char_type __c, char __dfault) const 326 { return this->do_narrow(__c, __dfault); } 327 328 /** 329 * @brief Narrow array to char array 330 * 331 * This function converts each char_type in the input to char using the 332 * simplest reasonable transformation and writes the results to the 333 * destination array. For any char_type in the input that cannot be 334 * converted, @a dfault is used instead. It does so by returning 335 * ctype<char_type>::do_narrow(lo, hi, dfault, to). 336 * 337 * Note: this is not what you want for codepage conversions. See 338 * codecvt for that. 339 * 340 * @param lo Pointer to start of range. 341 * @param hi Pointer to end of range. 342 * @param dfault Char to use if conversion fails. 343 * @param to Pointer to the destination array. 344 * @return @a hi. 345 */ 346 const char_type* 347 narrow(const char_type* __lo, const char_type* __hi, 348 char __dfault, char *__to) const 349 { return this->do_narrow(__lo, __hi, __dfault, __to); } 350 351 protected: 352 explicit 353 __ctype_abstract_base(size_t __refs = 0): facet(__refs) { } 354 355 virtual 356 ~__ctype_abstract_base() { } 357 358 /** 359 * @brief Test char_type classification. 360 * 361 * This function finds a mask M for @a c and compares it to mask @a m. 362 * 363 * do_is() is a hook for a derived facet to change the behavior of 364 * classifying. do_is() must always return the same result for the 365 * same input. 366 * 367 * @param c The char_type to find the mask of. 368 * @param m The mask to compare against. 369 * @return (M & m) != 0. 370 */ 371 virtual bool 372 do_is(mask __m, char_type __c) const = 0; 373 374 /** 375 * @brief Return a mask array. 376 * 377 * This function finds the mask for each char_type in the range [lo,hi) 378 * and successively writes it to vec. vec must have as many elements 379 * as the input. 380 * 381 * do_is() is a hook for a derived facet to change the behavior of 382 * classifying. do_is() must always return the same result for the 383 * same input. 384 * 385 * @param lo Pointer to start of range. 386 * @param hi Pointer to end of range. 387 * @param vec Pointer to an array of mask storage. 388 * @return @a hi. 389 */ 390 virtual const char_type* 391 do_is(const char_type* __lo, const char_type* __hi, 392 mask* __vec) const = 0; 393 394 /** 395 * @brief Find char_type matching mask 396 * 397 * This function searches for and returns the first char_type c in 398 * [lo,hi) for which is(m,c) is true. 399 * 400 * do_scan_is() is a hook for a derived facet to change the behavior of 401 * match searching. do_is() must always return the same result for the 402 * same input. 403 * 404 * @param m The mask to compare against. 405 * @param lo Pointer to start of range. 406 * @param hi Pointer to end of range. 407 * @return Pointer to a matching char_type if found, else @a hi. 408 */ 409 virtual const char_type* 410 do_scan_is(mask __m, const char_type* __lo, 411 const char_type* __hi) const = 0; 412 413 /** 414 * @brief Find char_type not matching mask 415 * 416 * This function searches for and returns a pointer to the first 417 * char_type c of [lo,hi) for which is(m,c) is false. 418 * 419 * do_scan_is() is a hook for a derived facet to change the behavior of 420 * match searching. do_is() must always return the same result for the 421 * same input. 422 * 423 * @param m The mask to compare against. 424 * @param lo Pointer to start of range. 425 * @param hi Pointer to end of range. 426 * @return Pointer to a non-matching char_type if found, else @a hi. 427 */ 428 virtual const char_type* 429 do_scan_not(mask __m, const char_type* __lo, 430 const char_type* __hi) const = 0; 431 432 /** 433 * @brief Convert to uppercase. 434 * 435 * This virtual function converts the char_type argument to uppercase 436 * if possible. If not possible (for example, '2'), returns the 437 * argument. 438 * 439 * do_toupper() is a hook for a derived facet to change the behavior of 440 * uppercasing. do_toupper() must always return the same result for 441 * the same input. 442 * 443 * @param c The char_type to convert. 444 * @return The uppercase char_type if convertible, else @a c. 445 */ 446 virtual char_type 447 do_toupper(char_type) const = 0; 448 449 /** 450 * @brief Convert array to uppercase. 451 * 452 * This virtual function converts each char_type in the range [lo,hi) 453 * to uppercase if possible. Other elements remain untouched. 454 * 455 * do_toupper() is a hook for a derived facet to change the behavior of 456 * uppercasing. do_toupper() must always return the same result for 457 * the same input. 458 * 459 * @param lo Pointer to start of range. 460 * @param hi Pointer to end of range. 461 * @return @a hi. 462 */ 463 virtual const char_type* 464 do_toupper(char_type* __lo, const char_type* __hi) const = 0; 465 466 /** 467 * @brief Convert to lowercase. 468 * 469 * This virtual function converts the argument to lowercase if 470 * possible. If not possible (for example, '2'), returns the argument. 471 * 472 * do_tolower() is a hook for a derived facet to change the behavior of 473 * lowercasing. do_tolower() must always return the same result for 474 * the same input. 475 * 476 * @param c The char_type to convert. 477 * @return The lowercase char_type if convertible, else @a c. 478 */ 479 virtual char_type 480 do_tolower(char_type) const = 0; 481 482 /** 483 * @brief Convert array to lowercase. 484 * 485 * This virtual function converts each char_type in the range [lo,hi) 486 * to lowercase if possible. Other elements remain untouched. 487 * 488 * do_tolower() is a hook for a derived facet to change the behavior of 489 * lowercasing. do_tolower() must always return the same result for 490 * the same input. 491 * 492 * @param lo Pointer to start of range. 493 * @param hi Pointer to end of range. 494 * @return @a hi. 495 */ 496 virtual const char_type* 497 do_tolower(char_type* __lo, const char_type* __hi) const = 0; 498 499 /** 500 * @brief Widen char 501 * 502 * This virtual function converts the char to char_type using the 503 * simplest reasonable transformation. 504 * 505 * do_widen() is a hook for a derived facet to change the behavior of 506 * widening. do_widen() must always return the same result for the 507 * same input. 508 * 509 * Note: this is not what you want for codepage conversions. See 510 * codecvt for that. 511 * 512 * @param c The char to convert. 513 * @return The converted char_type 514 */ 515 virtual char_type 516 do_widen(char) const = 0; 517 518 /** 519 * @brief Widen char array 520 * 521 * This function converts each char in the input to char_type using the 522 * simplest reasonable transformation. 523 * 524 * do_widen() is a hook for a derived facet to change the behavior of 525 * widening. do_widen() must always return the same result for the 526 * same input. 527 * 528 * Note: this is not what you want for codepage conversions. See 529 * codecvt for that. 530 * 531 * @param lo Pointer to start range. 532 * @param hi Pointer to end of range. 533 * @param to Pointer to the destination array. 534 * @return @a hi. 535 */ 536 virtual const char* 537 do_widen(const char* __lo, const char* __hi, 538 char_type* __dest) const = 0; 539 540 /** 541 * @brief Narrow char_type to char 542 * 543 * This virtual function converts the argument to char using the 544 * simplest reasonable transformation. If the conversion fails, dfault 545 * is returned instead. 546 * 547 * do_narrow() is a hook for a derived facet to change the behavior of 548 * narrowing. do_narrow() must always return the same result for the 549 * same input. 550 * 551 * Note: this is not what you want for codepage conversions. See 552 * codecvt for that. 553 * 554 * @param c The char_type to convert. 555 * @param dfault Char to return if conversion fails. 556 * @return The converted char. 557 */ 558 virtual char 559 do_narrow(char_type, char __dfault) const = 0; 560 561 /** 562 * @brief Narrow char_type array to char 563 * 564 * This virtual function converts each char_type in the range [lo,hi) to 565 * char using the simplest reasonable transformation and writes the 566 * results to the destination array. For any element in the input that 567 * cannot be converted, @a dfault is used instead. 568 * 569 * do_narrow() is a hook for a derived facet to change the behavior of 570 * narrowing. do_narrow() must always return the same result for the 571 * same input. 572 * 573 * Note: this is not what you want for codepage conversions. See 574 * codecvt for that. 575 * 576 * @param lo Pointer to start of range. 577 * @param hi Pointer to end of range. 578 * @param dfault Char to use if conversion fails. 579 * @param to Pointer to the destination array. 580 * @return @a hi. 581 */ 582 virtual const char_type* 583 do_narrow(const char_type* __lo, const char_type* __hi, 584 char __dfault, char* __dest) const = 0; 585 }; 586 587 /** 588 * @brief Primary class template ctype facet. 589 * @ingroup locales 590 * 591 * This template class defines classification and conversion functions for 592 * character sets. It wraps cctype functionality. Ctype gets used by 593 * streams for many I/O operations. 594 * 595 * This template provides the protected virtual functions the developer 596 * will have to replace in a derived class or specialization to make a 597 * working facet. The public functions that access them are defined in 598 * __ctype_abstract_base, to allow for implementation flexibility. See 599 * ctype<wchar_t> for an example. The functions are documented in 600 * __ctype_abstract_base. 601 * 602 * Note: implementations are provided for all the protected virtual 603 * functions, but will likely not be useful. 604 */ 605 template<typename _CharT> 606 class ctype : public __ctype_abstract_base<_CharT> 607 { 608 public: 609 // Types: 610 typedef _CharT char_type; 611 typedef typename __ctype_abstract_base<_CharT>::mask mask; 612 613 /// The facet id for ctype<char_type> 614 static locale::id id; 615 616 explicit 617 ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { } 618 619 protected: 620 virtual 621 ~ctype(); 622 623 virtual bool 624 do_is(mask __m, char_type __c) const; 625 626 virtual const char_type* 627 do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; 628 629 virtual const char_type* 630 do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; 631 632 virtual const char_type* 633 do_scan_not(mask __m, const char_type* __lo, 634 const char_type* __hi) const; 635 636 virtual char_type 637 do_toupper(char_type __c) const; 638 639 virtual const char_type* 640 do_toupper(char_type* __lo, const char_type* __hi) const; 641 642 virtual char_type 643 do_tolower(char_type __c) const; 644 645 virtual const char_type* 646 do_tolower(char_type* __lo, const char_type* __hi) const; 647 648 virtual char_type 649 do_widen(char __c) const; 650 651 virtual const char* 652 do_widen(const char* __lo, const char* __hi, char_type* __dest) const; 653 654 virtual char 655 do_narrow(char_type, char __dfault) const; 656 657 virtual const char_type* 658 do_narrow(const char_type* __lo, const char_type* __hi, 659 char __dfault, char* __dest) const; 660 }; 661 662 template<typename _CharT> 663 locale::id ctype<_CharT>::id; 664 665 /** 666 * @brief The ctype<char> specialization. 667 * @ingroup locales 668 * 669 * This class defines classification and conversion functions for 670 * the char type. It gets used by char streams for many I/O 671 * operations. The char specialization provides a number of 672 * optimizations as well. 673 */ 674 template<> 675 class ctype<char> : public locale::facet, public ctype_base 676 { 677 public: 678 // Types: 679 /// Typedef for the template parameter char. 680 typedef char char_type; 681 682 protected: 683 // Data Members: 684 __c_locale _M_c_locale_ctype; 685 bool _M_del; 686 __to_type _M_toupper; 687 __to_type _M_tolower; 688 const mask* _M_table; 689 mutable char _M_widen_ok; 690 mutable char _M_widen[1 + static_cast<unsigned char>(-1)]; 691 mutable char _M_narrow[1 + static_cast<unsigned char>(-1)]; 692 mutable char _M_narrow_ok; // 0 uninitialized, 1 init, 693 // 2 memcpy can't be used 694 695 public: 696 /// The facet id for ctype<char> 697 static locale::id id; 698 /// The size of the mask table. It is SCHAR_MAX + 1. 699 static const size_t table_size = 1 + static_cast<unsigned char>(-1); 700 701 /** 702 * @brief Constructor performs initialization. 703 * 704 * This is the constructor provided by the standard. 705 * 706 * @param table If non-zero, table is used as the per-char mask. 707 * Else classic_table() is used. 708 * @param del If true, passes ownership of table to this facet. 709 * @param refs Passed to the base facet class. 710 */ 711 explicit 712 ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); 713 714 /** 715 * @brief Constructor performs static initialization. 716 * 717 * This constructor is used to construct the initial C locale facet. 718 * 719 * @param cloc Handle to C locale data. 720 * @param table If non-zero, table is used as the per-char mask. 721 * @param del If true, passes ownership of table to this facet. 722 * @param refs Passed to the base facet class. 723 */ 724 explicit 725 ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, 726 size_t __refs = 0); 727 728 /** 729 * @brief Test char classification. 730 * 731 * This function compares the mask table[c] to @a m. 732 * 733 * @param c The char to compare the mask of. 734 * @param m The mask to compare against. 735 * @return True if m & table[c] is true, false otherwise. 736 */ 737 inline bool 738 is(mask __m, char __c) const; 739 740 /** 741 * @brief Return a mask array. 742 * 743 * This function finds the mask for each char in the range [lo, hi) and 744 * successively writes it to vec. vec must have as many elements as 745 * the char array. 746 * 747 * @param lo Pointer to start of range. 748 * @param hi Pointer to end of range. 749 * @param vec Pointer to an array of mask storage. 750 * @return @a hi. 751 */ 752 inline const char* 753 is(const char* __lo, const char* __hi, mask* __vec) const; 754 755 /** 756 * @brief Find char matching a mask 757 * 758 * This function searches for and returns the first char in [lo,hi) for 759 * which is(m,char) is true. 760 * 761 * @param m The mask to compare against. 762 * @param lo Pointer to start of range. 763 * @param hi Pointer to end of range. 764 * @return Pointer to a matching char if found, else @a hi. 765 */ 766 inline const char* 767 scan_is(mask __m, const char* __lo, const char* __hi) const; 768 769 /** 770 * @brief Find char not matching a mask 771 * 772 * This function searches for and returns a pointer to the first char 773 * in [lo,hi) for which is(m,char) is false. 774 * 775 * @param m The mask to compare against. 776 * @param lo Pointer to start of range. 777 * @param hi Pointer to end of range. 778 * @return Pointer to a non-matching char if found, else @a hi. 779 */ 780 inline const char* 781 scan_not(mask __m, const char* __lo, const char* __hi) const; 782 783 /** 784 * @brief Convert to uppercase. 785 * 786 * This function converts the char argument to uppercase if possible. 787 * If not possible (for example, '2'), returns the argument. 788 * 789 * toupper() acts as if it returns ctype<char>::do_toupper(c). 790 * do_toupper() must always return the same result for the same input. 791 * 792 * @param c The char to convert. 793 * @return The uppercase char if convertible, else @a c. 794 */ 795 char_type 796 toupper(char_type __c) const 797 { return this->do_toupper(__c); } 798 799 /** 800 * @brief Convert array to uppercase. 801 * 802 * This function converts each char in the range [lo,hi) to uppercase 803 * if possible. Other chars remain untouched. 804 * 805 * toupper() acts as if it returns ctype<char>:: do_toupper(lo, hi). 806 * do_toupper() must always return the same result for the same input. 807 * 808 * @param lo Pointer to first char in range. 809 * @param hi Pointer to end of range. 810 * @return @a hi. 811 */ 812 const char_type* 813 toupper(char_type *__lo, const char_type* __hi) const 814 { return this->do_toupper(__lo, __hi); } 815 816 /** 817 * @brief Convert to lowercase. 818 * 819 * This function converts the char argument to lowercase if possible. 820 * If not possible (for example, '2'), returns the argument. 821 * 822 * tolower() acts as if it returns ctype<char>::do_tolower(c). 823 * do_tolower() must always return the same result for the same input. 824 * 825 * @param c The char to convert. 826 * @return The lowercase char if convertible, else @a c. 827 */ 828 char_type 829 tolower(char_type __c) const 830 { return this->do_tolower(__c); } 831 832 /** 833 * @brief Convert array to lowercase. 834 * 835 * This function converts each char in the range [lo,hi) to lowercase 836 * if possible. Other chars remain untouched. 837 * 838 * tolower() acts as if it returns ctype<char>:: do_tolower(lo, hi). 839 * do_tolower() must always return the same result for the same input. 840 * 841 * @param lo Pointer to first char in range. 842 * @param hi Pointer to end of range. 843 * @return @a hi. 844 */ 845 const char_type* 846 tolower(char_type* __lo, const char_type* __hi) const 847 { return this->do_tolower(__lo, __hi); } 848 849 /** 850 * @brief Widen char 851 * 852 * This function converts the char to char_type using the simplest 853 * reasonable transformation. For an underived ctype<char> facet, the 854 * argument will be returned unchanged. 855 * 856 * This function works as if it returns ctype<char>::do_widen(c). 857 * do_widen() must always return the same result for the same input. 858 * 859 * Note: this is not what you want for codepage conversions. See 860 * codecvt for that. 861 * 862 * @param c The char to convert. 863 * @return The converted character. 864 */ 865 char_type 866 widen(char __c) const 867 { 868 if (_M_widen_ok) 869 return _M_widen[static_cast<unsigned char>(__c)]; 870 this->_M_widen_init(); 871 return this->do_widen(__c); 872 } 873 874 /** 875 * @brief Widen char array 876 * 877 * This function converts each char in the input to char using the 878 * simplest reasonable transformation. For an underived ctype<char> 879 * facet, the argument will be copied unchanged. 880 * 881 * This function works as if it returns ctype<char>::do_widen(c). 882 * do_widen() must always return the same result for the same input. 883 * 884 * Note: this is not what you want for codepage conversions. See 885 * codecvt for that. 886 * 887 * @param lo Pointer to first char in range. 888 * @param hi Pointer to end of range. 889 * @param to Pointer to the destination array. 890 * @return @a hi. 891 */ 892 const char* 893 widen(const char* __lo, const char* __hi, char_type* __to) const 894 { 895 if (_M_widen_ok == 1) 896 { 897 __builtin_memcpy(__to, __lo, __hi - __lo); 898 return __hi; 899 } 900 if (!_M_widen_ok) 901 _M_widen_init(); 902 return this->do_widen(__lo, __hi, __to); 903 } 904 905 /** 906 * @brief Narrow char 907 * 908 * This function converts the char to char using the simplest 909 * reasonable transformation. If the conversion fails, dfault is 910 * returned instead. For an underived ctype<char> facet, @a c 911 * will be returned unchanged. 912 * 913 * This function works as if it returns ctype<char>::do_narrow(c). 914 * do_narrow() must always return the same result for the same input. 915 * 916 * Note: this is not what you want for codepage conversions. See 917 * codecvt for that. 918 * 919 * @param c The char to convert. 920 * @param dfault Char to return if conversion fails. 921 * @return The converted character. 922 */ 923 char 924 narrow(char_type __c, char __dfault) const 925 { 926 if (_M_narrow[static_cast<unsigned char>(__c)]) 927 return _M_narrow[static_cast<unsigned char>(__c)]; 928 const char __t = do_narrow(__c, __dfault); 929 if (__t != __dfault) 930 _M_narrow[static_cast<unsigned char>(__c)] = __t; 931 return __t; 932 } 933 934 /** 935 * @brief Narrow char array 936 * 937 * This function converts each char in the input to char using the 938 * simplest reasonable transformation and writes the results to the 939 * destination array. For any char in the input that cannot be 940 * converted, @a dfault is used instead. For an underived ctype<char> 941 * facet, the argument will be copied unchanged. 942 * 943 * This function works as if it returns ctype<char>::do_narrow(lo, hi, 944 * dfault, to). do_narrow() must always return the same result for the 945 * same input. 946 * 947 * Note: this is not what you want for codepage conversions. See 948 * codecvt for that. 949 * 950 * @param lo Pointer to start of range. 951 * @param hi Pointer to end of range. 952 * @param dfault Char to use if conversion fails. 953 * @param to Pointer to the destination array. 954 * @return @a hi. 955 */ 956 const char_type* 957 narrow(const char_type* __lo, const char_type* __hi, 958 char __dfault, char *__to) const 959 { 960 if (__builtin_expect(_M_narrow_ok == 1, true)) 961 { 962 __builtin_memcpy(__to, __lo, __hi - __lo); 963 return __hi; 964 } 965 if (!_M_narrow_ok) 966 _M_narrow_init(); 967 return this->do_narrow(__lo, __hi, __dfault, __to); 968 } 969 970 // _GLIBCXX_RESOLVE_LIB_DEFECTS 971 // DR 695. ctype<char>::classic_table() not accessible. 972 /// Returns a pointer to the mask table provided to the constructor, or 973 /// the default from classic_table() if none was provided. 974 const mask* 975 table() const throw() 976 { return _M_table; } 977 978 /// Returns a pointer to the C locale mask table. 979 static const mask* 980 classic_table() throw(); 981 protected: 982 983 /** 984 * @brief Destructor. 985 * 986 * This function deletes table() if @a del was true in the 987 * constructor. 988 */ 989 virtual 990 ~ctype(); 991 992 /** 993 * @brief Convert to uppercase. 994 * 995 * This virtual function converts the char argument to uppercase if 996 * possible. If not possible (for example, '2'), returns the argument. 997 * 998 * do_toupper() is a hook for a derived facet to change the behavior of 999 * uppercasing. do_toupper() must always return the same result for 1000 * the same input. 1001 * 1002 * @param c The char to convert. 1003 * @return The uppercase char if convertible, else @a c. 1004 */ 1005 virtual char_type 1006 do_toupper(char_type) const; 1007 1008 /** 1009 * @brief Convert array to uppercase. 1010 * 1011 * This virtual function converts each char in the range [lo,hi) to 1012 * uppercase if possible. Other chars remain untouched. 1013 * 1014 * do_toupper() is a hook for a derived facet to change the behavior of 1015 * uppercasing. do_toupper() must always return the same result for 1016 * the same input. 1017 * 1018 * @param lo Pointer to start of range. 1019 * @param hi Pointer to end of range. 1020 * @return @a hi. 1021 */ 1022 virtual const char_type* 1023 do_toupper(char_type* __lo, const char_type* __hi) const; 1024 1025 /** 1026 * @brief Convert to lowercase. 1027 * 1028 * This virtual function converts the char argument to lowercase if 1029 * possible. If not possible (for example, '2'), returns the argument. 1030 * 1031 * do_tolower() is a hook for a derived facet to change the behavior of 1032 * lowercasing. do_tolower() must always return the same result for 1033 * the same input. 1034 * 1035 * @param c The char to convert. 1036 * @return The lowercase char if convertible, else @a c. 1037 */ 1038 virtual char_type 1039 do_tolower(char_type) const; 1040 1041 /** 1042 * @brief Convert array to lowercase. 1043 * 1044 * This virtual function converts each char in the range [lo,hi) to 1045 * lowercase if possible. Other chars remain untouched. 1046 * 1047 * do_tolower() is a hook for a derived facet to change the behavior of 1048 * lowercasing. do_tolower() must always return the same result for 1049 * the same input. 1050 * 1051 * @param lo Pointer to first char in range. 1052 * @param hi Pointer to end of range. 1053 * @return @a hi. 1054 */ 1055 virtual const char_type* 1056 do_tolower(char_type* __lo, const char_type* __hi) const; 1057 1058 /** 1059 * @brief Widen char 1060 * 1061 * This virtual function converts the char to char using the simplest 1062 * reasonable transformation. For an underived ctype<char> facet, the 1063 * argument will be returned unchanged. 1064 * 1065 * do_widen() is a hook for a derived facet to change the behavior of 1066 * widening. do_widen() must always return the same result for the 1067 * same input. 1068 * 1069 * Note: this is not what you want for codepage conversions. See 1070 * codecvt for that. 1071 * 1072 * @param c The char to convert. 1073 * @return The converted character. 1074 */ 1075 virtual char_type 1076 do_widen(char __c) const 1077 { return __c; } 1078 1079 /** 1080 * @brief Widen char array 1081 * 1082 * This function converts each char in the range [lo,hi) to char using 1083 * the simplest reasonable transformation. For an underived 1084 * ctype<char> facet, the argument will be copied unchanged. 1085 * 1086 * do_widen() is a hook for a derived facet to change the behavior of 1087 * widening. do_widen() must always return the same result for the 1088 * same input. 1089 * 1090 * Note: this is not what you want for codepage conversions. See 1091 * codecvt for that. 1092 * 1093 * @param lo Pointer to start of range. 1094 * @param hi Pointer to end of range. 1095 * @param to Pointer to the destination array. 1096 * @return @a hi. 1097 */ 1098 virtual const char* 1099 do_widen(const char* __lo, const char* __hi, char_type* __dest) const 1100 { 1101 __builtin_memcpy(__dest, __lo, __hi - __lo); 1102 return __hi; 1103 } 1104 1105 /** 1106 * @brief Narrow char 1107 * 1108 * This virtual function converts the char to char using the simplest 1109 * reasonable transformation. If the conversion fails, dfault is 1110 * returned instead. For an underived ctype<char> facet, @a c will be 1111 * returned unchanged. 1112 * 1113 * do_narrow() is a hook for a derived facet to change the behavior of 1114 * narrowing. do_narrow() must always return the same result for the 1115 * same input. 1116 * 1117 * Note: this is not what you want for codepage conversions. See 1118 * codecvt for that. 1119 * 1120 * @param c The char to convert. 1121 * @param dfault Char to return if conversion fails. 1122 * @return The converted char. 1123 */ 1124 virtual char 1125 do_narrow(char_type __c, char) const 1126 { return __c; } 1127 1128 /** 1129 * @brief Narrow char array to char array 1130 * 1131 * This virtual function converts each char in the range [lo,hi) to 1132 * char using the simplest reasonable transformation and writes the 1133 * results to the destination array. For any char in the input that 1134 * cannot be converted, @a dfault is used instead. For an underived 1135 * ctype<char> facet, the argument will be copied unchanged. 1136 * 1137 * do_narrow() is a hook for a derived facet to change the behavior of 1138 * narrowing. do_narrow() must always return the same result for the 1139 * same input. 1140 * 1141 * Note: this is not what you want for codepage conversions. See 1142 * codecvt for that. 1143 * 1144 * @param lo Pointer to start of range. 1145 * @param hi Pointer to end of range. 1146 * @param dfault Char to use if conversion fails. 1147 * @param to Pointer to the destination array. 1148 * @return @a hi. 1149 */ 1150 virtual const char_type* 1151 do_narrow(const char_type* __lo, const char_type* __hi, 1152 char, char* __dest) const 1153 { 1154 __builtin_memcpy(__dest, __lo, __hi - __lo); 1155 return __hi; 1156 } 1157 1158 private: 1159 void _M_narrow_init() const; 1160 void _M_widen_init() const; 1161 }; 1162 1163 #ifdef _GLIBCXX_USE_WCHAR_T 1164 /** 1165 * @brief The ctype<wchar_t> specialization. 1166 * @ingroup locales 1167 * 1168 * This class defines classification and conversion functions for the 1169 * wchar_t type. It gets used by wchar_t streams for many I/O operations. 1170 * The wchar_t specialization provides a number of optimizations as well. 1171 * 1172 * ctype<wchar_t> inherits its public methods from 1173 * __ctype_abstract_base<wchar_t>. 1174 */ 1175 template<> 1176 class ctype<wchar_t> : public __ctype_abstract_base<wchar_t> 1177 { 1178 public: 1179 // Types: 1180 /// Typedef for the template parameter wchar_t. 1181 typedef wchar_t char_type; 1182 typedef wctype_t __wmask_type; 1183 1184 protected: 1185 __c_locale _M_c_locale_ctype; 1186 1187 // Pre-computed narrowed and widened chars. 1188 bool _M_narrow_ok; 1189 char _M_narrow[128]; 1190 wint_t _M_widen[1 + static_cast<unsigned char>(-1)]; 1191 1192 // Pre-computed elements for do_is. 1193 mask _M_bit[16]; 1194 __wmask_type _M_wmask[16]; 1195 1196 public: 1197 // Data Members: 1198 /// The facet id for ctype<wchar_t> 1199 static locale::id id; 1200 1201 /** 1202 * @brief Constructor performs initialization. 1203 * 1204 * This is the constructor provided by the standard. 1205 * 1206 * @param refs Passed to the base facet class. 1207 */ 1208 explicit 1209 ctype(size_t __refs = 0); 1210 1211 /** 1212 * @brief Constructor performs static initialization. 1213 * 1214 * This constructor is used to construct the initial C locale facet. 1215 * 1216 * @param cloc Handle to C locale data. 1217 * @param refs Passed to the base facet class. 1218 */ 1219 explicit 1220 ctype(__c_locale __cloc, size_t __refs = 0); 1221 1222 protected: 1223 __wmask_type 1224 _M_convert_to_wmask(const mask __m) const throw(); 1225 1226 /// Destructor 1227 virtual 1228 ~ctype(); 1229 1230 /** 1231 * @brief Test wchar_t classification. 1232 * 1233 * This function finds a mask M for @a c and compares it to mask @a m. 1234 * 1235 * do_is() is a hook for a derived facet to change the behavior of 1236 * classifying. do_is() must always return the same result for the 1237 * same input. 1238 * 1239 * @param c The wchar_t to find the mask of. 1240 * @param m The mask to compare against. 1241 * @return (M & m) != 0. 1242 */ 1243 virtual bool 1244 do_is(mask __m, char_type __c) const; 1245 1246 /** 1247 * @brief Return a mask array. 1248 * 1249 * This function finds the mask for each wchar_t in the range [lo,hi) 1250 * and successively writes it to vec. vec must have as many elements 1251 * as the input. 1252 * 1253 * do_is() is a hook for a derived facet to change the behavior of 1254 * classifying. do_is() must always return the same result for the 1255 * same input. 1256 * 1257 * @param lo Pointer to start of range. 1258 * @param hi Pointer to end of range. 1259 * @param vec Pointer to an array of mask storage. 1260 * @return @a hi. 1261 */ 1262 virtual const char_type* 1263 do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; 1264 1265 /** 1266 * @brief Find wchar_t matching mask 1267 * 1268 * This function searches for and returns the first wchar_t c in 1269 * [lo,hi) for which is(m,c) is true. 1270 * 1271 * do_scan_is() is a hook for a derived facet to change the behavior of 1272 * match searching. do_is() must always return the same result for the 1273 * same input. 1274 * 1275 * @param m The mask to compare against. 1276 * @param lo Pointer to start of range. 1277 * @param hi Pointer to end of range. 1278 * @return Pointer to a matching wchar_t if found, else @a hi. 1279 */ 1280 virtual const char_type* 1281 do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; 1282 1283 /** 1284 * @brief Find wchar_t not matching mask 1285 * 1286 * This function searches for and returns a pointer to the first 1287 * wchar_t c of [lo,hi) for which is(m,c) is false. 1288 * 1289 * do_scan_is() is a hook for a derived facet to change the behavior of 1290 * match searching. do_is() must always return the same result for the 1291 * same input. 1292 * 1293 * @param m The mask to compare against. 1294 * @param lo Pointer to start of range. 1295 * @param hi Pointer to end of range. 1296 * @return Pointer to a non-matching wchar_t if found, else @a hi. 1297 */ 1298 virtual const char_type* 1299 do_scan_not(mask __m, const char_type* __lo, 1300 const char_type* __hi) const; 1301 1302 /** 1303 * @brief Convert to uppercase. 1304 * 1305 * This virtual function converts the wchar_t argument to uppercase if 1306 * possible. If not possible (for example, '2'), returns the argument. 1307 * 1308 * do_toupper() is a hook for a derived facet to change the behavior of 1309 * uppercasing. do_toupper() must always return the same result for 1310 * the same input. 1311 * 1312 * @param c The wchar_t to convert. 1313 * @return The uppercase wchar_t if convertible, else @a c. 1314 */ 1315 virtual char_type 1316 do_toupper(char_type) const; 1317 1318 /** 1319 * @brief Convert array to uppercase. 1320 * 1321 * This virtual function converts each wchar_t in the range [lo,hi) to 1322 * uppercase if possible. Other elements remain untouched. 1323 * 1324 * do_toupper() is a hook for a derived facet to change the behavior of 1325 * uppercasing. do_toupper() must always return the same result for 1326 * the same input. 1327 * 1328 * @param lo Pointer to start of range. 1329 * @param hi Pointer to end of range. 1330 * @return @a hi. 1331 */ 1332 virtual const char_type* 1333 do_toupper(char_type* __lo, const char_type* __hi) const; 1334 1335 /** 1336 * @brief Convert to lowercase. 1337 * 1338 * This virtual function converts the argument to lowercase if 1339 * possible. If not possible (for example, '2'), returns the argument. 1340 * 1341 * do_tolower() is a hook for a derived facet to change the behavior of 1342 * lowercasing. do_tolower() must always return the same result for 1343 * the same input. 1344 * 1345 * @param c The wchar_t to convert. 1346 * @return The lowercase wchar_t if convertible, else @a c. 1347 */ 1348 virtual char_type 1349 do_tolower(char_type) const; 1350 1351 /** 1352 * @brief Convert array to lowercase. 1353 * 1354 * This virtual function converts each wchar_t in the range [lo,hi) to 1355 * lowercase if possible. Other elements remain untouched. 1356 * 1357 * do_tolower() is a hook for a derived facet to change the behavior of 1358 * lowercasing. do_tolower() must always return the same result for 1359 * the same input. 1360 * 1361 * @param lo Pointer to start of range. 1362 * @param hi Pointer to end of range. 1363 * @return @a hi. 1364 */ 1365 virtual const char_type* 1366 do_tolower(char_type* __lo, const char_type* __hi) const; 1367 1368 /** 1369 * @brief Widen char to wchar_t 1370 * 1371 * This virtual function converts the char to wchar_t using the 1372 * simplest reasonable transformation. For an underived ctype<wchar_t> 1373 * facet, the argument will be cast to wchar_t. 1374 * 1375 * do_widen() is a hook for a derived facet to change the behavior of 1376 * widening. do_widen() must always return the same result for the 1377 * same input. 1378 * 1379 * Note: this is not what you want for codepage conversions. See 1380 * codecvt for that. 1381 * 1382 * @param c The char to convert. 1383 * @return The converted wchar_t. 1384 */ 1385 virtual char_type 1386 do_widen(char) const; 1387 1388 /** 1389 * @brief Widen char array to wchar_t array 1390 * 1391 * This function converts each char in the input to wchar_t using the 1392 * simplest reasonable transformation. For an underived ctype<wchar_t> 1393 * facet, the argument will be copied, casting each element to wchar_t. 1394 * 1395 * do_widen() is a hook for a derived facet to change the behavior of 1396 * widening. do_widen() must always return the same result for the 1397 * same input. 1398 * 1399 * Note: this is not what you want for codepage conversions. See 1400 * codecvt for that. 1401 * 1402 * @param lo Pointer to start range. 1403 * @param hi Pointer to end of range. 1404 * @param to Pointer to the destination array. 1405 * @return @a hi. 1406 */ 1407 virtual const char* 1408 do_widen(const char* __lo, const char* __hi, char_type* __dest) const; 1409 1410 /** 1411 * @brief Narrow wchar_t to char 1412 * 1413 * This virtual function converts the argument to char using 1414 * the simplest reasonable transformation. If the conversion 1415 * fails, dfault is returned instead. For an underived 1416 * ctype<wchar_t> facet, @a c will be cast to char and 1417 * returned. 1418 * 1419 * do_narrow() is a hook for a derived facet to change the 1420 * behavior of narrowing. do_narrow() must always return the 1421 * same result for the same input. 1422 * 1423 * Note: this is not what you want for codepage conversions. See 1424 * codecvt for that. 1425 * 1426 * @param c The wchar_t to convert. 1427 * @param dfault Char to return if conversion fails. 1428 * @return The converted char. 1429 */ 1430 virtual char 1431 do_narrow(char_type, char __dfault) const; 1432 1433 /** 1434 * @brief Narrow wchar_t array to char array 1435 * 1436 * This virtual function converts each wchar_t in the range [lo,hi) to 1437 * char using the simplest reasonable transformation and writes the 1438 * results to the destination array. For any wchar_t in the input that 1439 * cannot be converted, @a dfault is used instead. For an underived 1440 * ctype<wchar_t> facet, the argument will be copied, casting each 1441 * element to char. 1442 * 1443 * do_narrow() is a hook for a derived facet to change the behavior of 1444 * narrowing. do_narrow() must always return the same result for the 1445 * same input. 1446 * 1447 * Note: this is not what you want for codepage conversions. See 1448 * codecvt for that. 1449 * 1450 * @param lo Pointer to start of range. 1451 * @param hi Pointer to end of range. 1452 * @param dfault Char to use if conversion fails. 1453 * @param to Pointer to the destination array. 1454 * @return @a hi. 1455 */ 1456 virtual const char_type* 1457 do_narrow(const char_type* __lo, const char_type* __hi, 1458 char __dfault, char* __dest) const; 1459 1460 // For use at construction time only. 1461 void 1462 _M_initialize_ctype() throw(); 1463 }; 1464 #endif //_GLIBCXX_USE_WCHAR_T 1465 1466 /// class ctype_byname [22.2.1.2]. 1467 template<typename _CharT> 1468 class ctype_byname : public ctype<_CharT> 1469 { 1470 public: 1471 typedef typename ctype<_CharT>::mask mask; 1472 1473 explicit 1474 ctype_byname(const char* __s, size_t __refs = 0); 1475 1476 protected: 1477 virtual 1478 ~ctype_byname() { }; 1479 }; 1480 1481 /// 22.2.1.4 Class ctype_byname specializations. 1482 template<> 1483 class ctype_byname<char> : public ctype<char> 1484 { 1485 public: 1486 explicit 1487 ctype_byname(const char* __s, size_t __refs = 0); 1488 1489 protected: 1490 virtual 1491 ~ctype_byname(); 1492 }; 1493 1494 #ifdef _GLIBCXX_USE_WCHAR_T 1495 template<> 1496 class ctype_byname<wchar_t> : public ctype<wchar_t> 1497 { 1498 public: 1499 explicit 1500 ctype_byname(const char* __s, size_t __refs = 0); 1501 1502 protected: 1503 virtual 1504 ~ctype_byname(); 1505 }; 1506 #endif 1507 1508 _GLIBCXX_END_NAMESPACE_VERSION 1509 } // namespace 1510 1511 // Include host and configuration specific ctype inlines. 1512 #include <bits/ctype_inline.h> 1513 1514 namespace std _GLIBCXX_VISIBILITY(default) 1515 { 1516 _GLIBCXX_BEGIN_NAMESPACE_VERSION 1517 1518 // 22.2.2 The numeric category. 1519 class __num_base 1520 { 1521 public: 1522 // NB: Code depends on the order of _S_atoms_out elements. 1523 // Below are the indices into _S_atoms_out. 1524 enum 1525 { 1526 _S_ominus, 1527 _S_oplus, 1528 _S_ox, 1529 _S_oX, 1530 _S_odigits, 1531 _S_odigits_end = _S_odigits + 16, 1532 _S_oudigits = _S_odigits_end, 1533 _S_oudigits_end = _S_oudigits + 16, 1534 _S_oe = _S_odigits + 14, // For scientific notation, 'e' 1535 _S_oE = _S_oudigits + 14, // For scientific notation, 'E' 1536 _S_oend = _S_oudigits_end 1537 }; 1538 1539 // A list of valid numeric literals for output. This array 1540 // contains chars that will be passed through the current locale's 1541 // ctype<_CharT>.widen() and then used to render numbers. 1542 // For the standard "C" locale, this is 1543 // "-+xX0123456789abcdef0123456789ABCDEF". 1544 static const char* _S_atoms_out; 1545 1546 // String literal of acceptable (narrow) input, for num_get. 1547 // "-+xX0123456789abcdefABCDEF" 1548 static const char* _S_atoms_in; 1549 1550 enum 1551 { 1552 _S_iminus, 1553 _S_iplus, 1554 _S_ix, 1555 _S_iX, 1556 _S_izero, 1557 _S_ie = _S_izero + 14, 1558 _S_iE = _S_izero + 20, 1559 _S_iend = 26 1560 }; 1561 1562 // num_put 1563 // Construct and return valid scanf format for floating point types. 1564 static void 1565 _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw(); 1566 }; 1567 1568 template<typename _CharT> 1569 struct __numpunct_cache : public locale::facet 1570 { 1571 const char* _M_grouping; 1572 size_t _M_grouping_size; 1573 bool _M_use_grouping; 1574 const _CharT* _M_truename; 1575 size_t _M_truename_size; 1576 const _CharT* _M_falsename; 1577 size_t _M_falsename_size; 1578 _CharT _M_decimal_point; 1579 _CharT _M_thousands_sep; 1580 1581 // A list of valid numeric literals for output: in the standard 1582 // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF". 1583 // This array contains the chars after having been passed 1584 // through the current locale's ctype<_CharT>.widen(). 1585 _CharT _M_atoms_out[__num_base::_S_oend]; 1586 1587 // A list of valid numeric literals for input: in the standard 1588 // "C" locale, this is "-+xX0123456789abcdefABCDEF" 1589 // This array contains the chars after having been passed 1590 // through the current locale's ctype<_CharT>.widen(). 1591 _CharT _M_atoms_in[__num_base::_S_iend]; 1592 1593 bool _M_allocated; 1594 1595 __numpunct_cache(size_t __refs = 0) 1596 : facet(__refs), _M_grouping(0), _M_grouping_size(0), 1597 _M_use_grouping(false), 1598 _M_truename(0), _M_truename_size(0), _M_falsename(0), 1599 _M_falsename_size(0), _M_decimal_point(_CharT()), 1600 _M_thousands_sep(_CharT()), _M_allocated(false) 1601 { } 1602 1603 ~__numpunct_cache(); 1604 1605 void 1606 _M_cache(const locale& __loc); 1607 1608 private: 1609 __numpunct_cache& 1610 operator=(const __numpunct_cache&); 1611 1612 explicit 1613 __numpunct_cache(const __numpunct_cache&); 1614 }; 1615 1616 template<typename _CharT> 1617 __numpunct_cache<_CharT>::~__numpunct_cache() 1618 { 1619 if (_M_allocated) 1620 { 1621 delete [] _M_grouping; 1622 delete [] _M_truename; 1623 delete [] _M_falsename; 1624 } 1625 } 1626 1627 /** 1628 * @brief Primary class template numpunct. 1629 * @ingroup locales 1630 * 1631 * This facet stores several pieces of information related to printing and 1632 * scanning numbers, such as the decimal point character. It takes a 1633 * template parameter specifying the char type. The numpunct facet is 1634 * used by streams for many I/O operations involving numbers. 1635 * 1636 * The numpunct template uses protected virtual functions to provide the 1637 * actual results. The public accessors forward the call to the virtual 1638 * functions. These virtual functions are hooks for developers to 1639 * implement the behavior they require from a numpunct facet. 1640 */ 1641 template<typename _CharT> 1642 class numpunct : public locale::facet 1643 { 1644 public: 1645 // Types: 1646 //@{ 1647 /// Public typedefs 1648 typedef _CharT char_type; 1649 typedef basic_string<_CharT> string_type; 1650 //@} 1651 typedef __numpunct_cache<_CharT> __cache_type; 1652 1653 protected: 1654 __cache_type* _M_data; 1655 1656 public: 1657 /// Numpunct facet id. 1658 static locale::id id; 1659 1660 /** 1661 * @brief Numpunct constructor. 1662 * 1663 * @param refs Refcount to pass to the base class. 1664 */ 1665 explicit 1666 numpunct(size_t __refs = 0) 1667 : facet(__refs), _M_data(0) 1668 { _M_initialize_numpunct(); } 1669 1670 /** 1671 * @brief Internal constructor. Not for general use. 1672 * 1673 * This is a constructor for use by the library itself to set up the 1674 * predefined locale facets. 1675 * 1676 * @param cache __numpunct_cache object. 1677 * @param refs Refcount to pass to the base class. 1678 */ 1679 explicit 1680 numpunct(__cache_type* __cache, size_t __refs = 0) 1681 : facet(__refs), _M_data(__cache) 1682 { _M_initialize_numpunct(); } 1683 1684 /** 1685 * @brief Internal constructor. Not for general use. 1686 * 1687 * This is a constructor for use by the library itself to set up new 1688 * locales. 1689 * 1690 * @param cloc The C locale. 1691 * @param refs Refcount to pass to the base class. 1692 */ 1693 explicit 1694 numpunct(__c_locale __cloc, size_t __refs = 0) 1695 : facet(__refs), _M_data(0) 1696 { _M_initialize_numpunct(__cloc); } 1697 1698 /** 1699 * @brief Return decimal point character. 1700 * 1701 * This function returns a char_type to use as a decimal point. It 1702 * does so by returning returning 1703 * numpunct<char_type>::do_decimal_point(). 1704 * 1705 * @return @a char_type representing a decimal point. 1706 */ 1707 char_type 1708 decimal_point() const 1709 { return this->do_decimal_point(); } 1710 1711 /** 1712 * @brief Return thousands separator character. 1713 * 1714 * This function returns a char_type to use as a thousands 1715 * separator. It does so by returning returning 1716 * numpunct<char_type>::do_thousands_sep(). 1717 * 1718 * @return char_type representing a thousands separator. 1719 */ 1720 char_type 1721 thousands_sep() const 1722 { return this->do_thousands_sep(); } 1723 1724 /** 1725 * @brief Return grouping specification. 1726 * 1727 * This function returns a string representing groupings for the 1728 * integer part of a number. Groupings indicate where thousands 1729 * separators should be inserted in the integer part of a number. 1730 * 1731 * Each char in the return string is interpret as an integer 1732 * rather than a character. These numbers represent the number 1733 * of digits in a group. The first char in the string 1734 * represents the number of digits in the least significant 1735 * group. If a char is negative, it indicates an unlimited 1736 * number of digits for the group. If more chars from the 1737 * string are required to group a number, the last char is used 1738 * repeatedly. 1739 * 1740 * For example, if the grouping() returns "\003\002" and is 1741 * applied to the number 123456789, this corresponds to 1742 * 12,34,56,789. Note that if the string was "32", this would 1743 * put more than 50 digits into the least significant group if 1744 * the character set is ASCII. 1745 * 1746 * The string is returned by calling 1747 * numpunct<char_type>::do_grouping(). 1748 * 1749 * @return string representing grouping specification. 1750 */ 1751 string 1752 grouping() const 1753 { return this->do_grouping(); } 1754 1755 /** 1756 * @brief Return string representation of bool true. 1757 * 1758 * This function returns a string_type containing the text 1759 * representation for true bool variables. It does so by calling 1760 * numpunct<char_type>::do_truename(). 1761 * 1762 * @return string_type representing printed form of true. 1763 */ 1764 string_type 1765 truename() const 1766 { return this->do_truename(); } 1767 1768 /** 1769 * @brief Return string representation of bool false. 1770 * 1771 * This function returns a string_type containing the text 1772 * representation for false bool variables. It does so by calling 1773 * numpunct<char_type>::do_falsename(). 1774 * 1775 * @return string_type representing printed form of false. 1776 */ 1777 string_type 1778 falsename() const 1779 { return this->do_falsename(); } 1780 1781 protected: 1782 /// Destructor. 1783 virtual 1784 ~numpunct(); 1785 1786 /** 1787 * @brief Return decimal point character. 1788 * 1789 * Returns a char_type to use as a decimal point. This function is a 1790 * hook for derived classes to change the value returned. 1791 * 1792 * @return @a char_type representing a decimal point. 1793 */ 1794 virtual char_type 1795 do_decimal_point() const 1796 { return _M_data->_M_decimal_point; } 1797 1798 /** 1799 * @brief Return thousands separator character. 1800 * 1801 * Returns a char_type to use as a thousands separator. This function 1802 * is a hook for derived classes to change the value returned. 1803 * 1804 * @return @a char_type representing a thousands separator. 1805 */ 1806 virtual char_type 1807 do_thousands_sep() const 1808 { return _M_data->_M_thousands_sep; } 1809 1810 /** 1811 * @brief Return grouping specification. 1812 * 1813 * Returns a string representing groupings for the integer part of a 1814 * number. This function is a hook for derived classes to change the 1815 * value returned. @see grouping() for details. 1816 * 1817 * @return String representing grouping specification. 1818 */ 1819 virtual string 1820 do_grouping() const 1821 { return _M_data->_M_grouping; } 1822 1823 /** 1824 * @brief Return string representation of bool true. 1825 * 1826 * Returns a string_type containing the text representation for true 1827 * bool variables. This function is a hook for derived classes to 1828 * change the value returned. 1829 * 1830 * @return string_type representing printed form of true. 1831 */ 1832 virtual string_type 1833 do_truename() const 1834 { return _M_data->_M_truename; } 1835 1836 /** 1837 * @brief Return string representation of bool false. 1838 * 1839 * Returns a string_type containing the text representation for false 1840 * bool variables. This function is a hook for derived classes to 1841 * change the value returned. 1842 * 1843 * @return string_type representing printed form of false. 1844 */ 1845 virtual string_type 1846 do_falsename() const 1847 { return _M_data->_M_falsename; } 1848 1849 // For use at construction time only. 1850 void 1851 _M_initialize_numpunct(__c_locale __cloc = 0); 1852 }; 1853 1854 template<typename _CharT> 1855 locale::id numpunct<_CharT>::id; 1856 1857 template<> 1858 numpunct<char>::~numpunct(); 1859 1860 template<> 1861 void 1862 numpunct<char>::_M_initialize_numpunct(__c_locale __cloc); 1863 1864 #ifdef _GLIBCXX_USE_WCHAR_T 1865 template<> 1866 numpunct<wchar_t>::~numpunct(); 1867 1868 template<> 1869 void 1870 numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc); 1871 #endif 1872 1873 /// class numpunct_byname [22.2.3.2]. 1874 template<typename _CharT> 1875 class numpunct_byname : public numpunct<_CharT> 1876 { 1877 public: 1878 typedef _CharT char_type; 1879 typedef basic_string<_CharT> string_type; 1880 1881 explicit 1882 numpunct_byname(const char* __s, size_t __refs = 0) 1883 : numpunct<_CharT>(__refs) 1884 { 1885 if (__builtin_strcmp(__s, "C") != 0 1886 && __builtin_strcmp(__s, "POSIX") != 0) 1887 { 1888 __c_locale __tmp; 1889 this->_S_create_c_locale(__tmp, __s); 1890 this->_M_initialize_numpunct(__tmp); 1891 this->_S_destroy_c_locale(__tmp); 1892 } 1893 } 1894 1895 protected: 1896 virtual 1897 ~numpunct_byname() { } 1898 }; 1899 1900 _GLIBCXX_BEGIN_NAMESPACE_LDBL 1901 1902 /** 1903 * @brief Primary class template num_get. 1904 * @ingroup locales 1905 * 1906 * This facet encapsulates the code to parse and return a number 1907 * from a string. It is used by the istream numeric extraction 1908 * operators. 1909 * 1910 * The num_get template uses protected virtual functions to provide the 1911 * actual results. The public accessors forward the call to the virtual 1912 * functions. These virtual functions are hooks for developers to 1913 * implement the behavior they require from the num_get facet. 1914 */ 1915 template<typename _CharT, typename _InIter> 1916 class num_get : public locale::facet 1917 { 1918 public: 1919 // Types: 1920 //@{ 1921 /// Public typedefs 1922 typedef _CharT char_type; 1923 typedef _InIter iter_type; 1924 //@} 1925 1926 /// Numpunct facet id. 1927 static locale::id id; 1928 1929 /** 1930 * @brief Constructor performs initialization. 1931 * 1932 * This is the constructor provided by the standard. 1933 * 1934 * @param refs Passed to the base facet class. 1935 */ 1936 explicit 1937 num_get(size_t __refs = 0) : facet(__refs) { } 1938 1939 /** 1940 * @brief Numeric parsing. 1941 * 1942 * Parses the input stream into the bool @a v. It does so by calling 1943 * num_get::do_get(). 1944 * 1945 * If ios_base::boolalpha is set, attempts to read 1946 * ctype<CharT>::truename() or ctype<CharT>::falsename(). Sets 1947 * @a v to true or false if successful. Sets err to 1948 * ios_base::failbit if reading the string fails. Sets err to 1949 * ios_base::eofbit if the stream is emptied. 1950 * 1951 * If ios_base::boolalpha is not set, proceeds as with reading a long, 1952 * except if the value is 1, sets @a v to true, if the value is 0, sets 1953 * @a v to false, and otherwise set err to ios_base::failbit. 1954 * 1955 * @param in Start of input stream. 1956 * @param end End of input stream. 1957 * @param io Source of locale and flags. 1958 * @param err Error flags to set. 1959 * @param v Value to format and insert. 1960 * @return Iterator after reading. 1961 */ 1962 iter_type 1963 get(iter_type __in, iter_type __end, ios_base& __io, 1964 ios_base::iostate& __err, bool& __v) const 1965 { return this->do_get(__in, __end, __io, __err, __v); } 1966 1967 //@{ 1968 /** 1969 * @brief Numeric parsing. 1970 * 1971 * Parses the input stream into the integral variable @a v. It does so 1972 * by calling num_get::do_get(). 1973 * 1974 * Parsing is affected by the flag settings in @a io. 1975 * 1976 * The basic parse is affected by the value of io.flags() & 1977 * ios_base::basefield. If equal to ios_base::oct, parses like the 1978 * scanf %o specifier. Else if equal to ios_base::hex, parses like %X 1979 * specifier. Else if basefield equal to 0, parses like the %i 1980 * specifier. Otherwise, parses like %d for signed and %u for unsigned 1981 * types. The matching type length modifier is also used. 1982 * 1983 * Digit grouping is interpreted according to numpunct::grouping() and 1984 * numpunct::thousands_sep(). If the pattern of digit groups isn't 1985 * consistent, sets err to ios_base::failbit. 1986 * 1987 * If parsing the string yields a valid value for @a v, @a v is set. 1988 * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. 1989 * Sets err to ios_base::eofbit if the stream is emptied. 1990 * 1991 * @param in Start of input stream. 1992 * @param end End of input stream. 1993 * @param io Source of locale and flags. 1994 * @param err Error flags to set. 1995 * @param v Value to format and insert. 1996 * @return Iterator after reading. 1997 */ 1998 iter_type 1999 get(iter_type __in, iter_type __end, ios_base& __io, 2000 ios_base::iostate& __err, long& __v) const 2001 { return this->do_get(__in, __end, __io, __err, __v); } 2002 2003 iter_type 2004 get(iter_type __in, iter_type __end, ios_base& __io, 2005 ios_base::iostate& __err, unsigned short& __v) const 2006 { return this->do_get(__in, __end, __io, __err, __v); } 2007 2008 iter_type 2009 get(iter_type __in, iter_type __end, ios_base& __io, 2010 ios_base::iostate& __err, unsigned int& __v) const 2011 { return this->do_get(__in, __end, __io, __err, __v); } 2012 2013 iter_type 2014 get(iter_type __in, iter_type __end, ios_base& __io, 2015 ios_base::iostate& __err, unsigned long& __v) const 2016 { return this->do_get(__in, __end, __io, __err, __v); } 2017 2018 #ifdef _GLIBCXX_USE_LONG_LONG 2019 iter_type 2020 get(iter_type __in, iter_type __end, ios_base& __io, 2021 ios_base::iostate& __err, long long& __v) const 2022 { return this->do_get(__in, __end, __io, __err, __v); } 2023 2024 iter_type 2025 get(iter_type __in, iter_type __end, ios_base& __io, 2026 ios_base::iostate& __err, unsigned long long& __v) const 2027 { return this->do_get(__in, __end, __io, __err, __v); } 2028 #endif 2029 //@} 2030 2031 //@{ 2032 /** 2033 * @brief Numeric parsing. 2034 * 2035 * Parses the input stream into the integral variable @a v. It does so 2036 * by calling num_get::do_get(). 2037 * 2038 * The input characters are parsed like the scanf %g specifier. The 2039 * matching type length modifier is also used. 2040 * 2041 * The decimal point character used is numpunct::decimal_point(). 2042 * Digit grouping is interpreted according to numpunct::grouping() and 2043 * numpunct::thousands_sep(). If the pattern of digit groups isn't 2044 * consistent, sets err to ios_base::failbit. 2045 * 2046 * If parsing the string yields a valid value for @a v, @a v is set. 2047 * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. 2048 * Sets err to ios_base::eofbit if the stream is emptied. 2049 * 2050 * @param in Start of input stream. 2051 * @param end End of input stream. 2052 * @param io Source of locale and flags. 2053 * @param err Error flags to set. 2054 * @param v Value to format and insert. 2055 * @return Iterator after reading. 2056 */ 2057 iter_type 2058 get(iter_type __in, iter_type __end, ios_base& __io, 2059 ios_base::iostate& __err, float& __v) const 2060 { return this->do_get(__in, __end, __io, __err, __v); } 2061 2062 iter_type 2063 get(iter_type __in, iter_type __end, ios_base& __io, 2064 ios_base::iostate& __err, double& __v) const 2065 { return this->do_get(__in, __end, __io, __err, __v); } 2066 2067 iter_type 2068 get(iter_type __in, iter_type __end, ios_base& __io, 2069 ios_base::iostate& __err, long double& __v) const 2070 { return this->do_get(__in, __end, __io, __err, __v); } 2071 //@} 2072 2073 /** 2074 * @brief Numeric parsing. 2075 * 2076 * Parses the input stream into the pointer variable @a v. It does so 2077 * by calling num_get::do_get(). 2078 * 2079 * The input characters are parsed like the scanf %p specifier. 2080 * 2081 * Digit grouping is interpreted according to numpunct::grouping() and 2082 * numpunct::thousands_sep(). If the pattern of digit groups isn't 2083 * consistent, sets err to ios_base::failbit. 2084 * 2085 * Note that the digit grouping effect for pointers is a bit ambiguous 2086 * in the standard and shouldn't be relied on. See DR 344. 2087 * 2088 * If parsing the string yields a valid value for @a v, @a v is set. 2089 * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. 2090 * Sets err to ios_base::eofbit if the stream is emptied. 2091 * 2092 * @param in Start of input stream. 2093 * @param end End of input stream. 2094 * @param io Source of locale and flags. 2095 * @param err Error flags to set. 2096 * @param v Value to format and insert. 2097 * @return Iterator after reading. 2098 */ 2099 iter_type 2100 get(iter_type __in, iter_type __end, ios_base& __io, 2101 ios_base::iostate& __err, void*& __v) const 2102 { return this->do_get(__in, __end, __io, __err, __v); } 2103 2104 protected: 2105 /// Destructor. 2106 virtual ~num_get() { } 2107 2108 iter_type 2109 _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&, 2110 string&) const; 2111 2112 template<typename _ValueT> 2113 iter_type 2114 _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, 2115 _ValueT&) const; 2116 2117 template<typename _CharT2> 2118 typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type 2119 _M_find(const _CharT2*, size_t __len, _CharT2 __c) const 2120 { 2121 int __ret = -1; 2122 if (__len <= 10) 2123 { 2124 if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len)) 2125 __ret = __c - _CharT2('0'); 2126 } 2127 else 2128 { 2129 if (__c >= _CharT2('0') && __c <= _CharT2('9')) 2130 __ret = __c - _CharT2('0'); 2131 else if (__c >= _CharT2('a') && __c <= _CharT2('f')) 2132 __ret = 10 + (__c - _CharT2('a')); 2133 else if (__c >= _CharT2('A') && __c <= _CharT2('F')) 2134 __ret = 10 + (__c - _CharT2('A')); 2135 } 2136 return __ret; 2137 } 2138 2139 template<typename _CharT2> 2140 typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value, 2141 int>::__type 2142 _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const 2143 { 2144 int __ret = -1; 2145 const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c); 2146 if (__q) 2147 { 2148 __ret = __q - __zero; 2149 if (__ret > 15) 2150 __ret -= 6; 2151 } 2152 return __ret; 2153 } 2154 2155 //@{ 2156 /** 2157 * @brief Numeric parsing. 2158 * 2159 * Parses the input stream into the variable @a v. This function is a 2160 * hook for derived classes to change the value returned. @see get() 2161 * for more details. 2162 * 2163 * @param in Start of input stream. 2164 * @param end End of input stream. 2165 * @param io Source of locale and flags. 2166 * @param err Error flags to set. 2167 * @param v Value to format and insert. 2168 * @return Iterator after reading. 2169 */ 2170 virtual iter_type 2171 do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const; 2172 2173 virtual iter_type 2174 do_get(iter_type __beg, iter_type __end, ios_base& __io, 2175 ios_base::iostate& __err, long& __v) const 2176 { return _M_extract_int(__beg, __end, __io, __err, __v); } 2177 2178 virtual iter_type 2179 do_get(iter_type __beg, iter_type __end, ios_base& __io, 2180 ios_base::iostate& __err, unsigned short& __v) const 2181 { return _M_extract_int(__beg, __end, __io, __err, __v); } 2182 2183 virtual iter_type 2184 do_get(iter_type __beg, iter_type __end, ios_base& __io, 2185 ios_base::iostate& __err, unsigned int& __v) const 2186 { return _M_extract_int(__beg, __end, __io, __err, __v); } 2187 2188 virtual iter_type 2189 do_get(iter_type __beg, iter_type __end, ios_base& __io, 2190 ios_base::iostate& __err, unsigned long& __v) const 2191 { return _M_extract_int(__beg, __end, __io, __err, __v); } 2192 2193 #ifdef _GLIBCXX_USE_LONG_LONG 2194 virtual iter_type 2195 do_get(iter_type __beg, iter_type __end, ios_base& __io, 2196 ios_base::iostate& __err, long long& __v) const 2197 { return _M_extract_int(__beg, __end, __io, __err, __v); } 2198 2199 virtual iter_type 2200 do_get(iter_type __beg, iter_type __end, ios_base& __io, 2201 ios_base::iostate& __err, unsigned long long& __v) const 2202 { return _M_extract_int(__beg, __end, __io, __err, __v); } 2203 #endif 2204 2205 virtual iter_type 2206 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 2207 float&) const; 2208 2209 virtual iter_type 2210 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 2211 double&) const; 2212 2213 // XXX GLIBCXX_ABI Deprecated 2214 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 2215 virtual iter_type 2216 __do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 2217 double&) const; 2218 #else 2219 virtual iter_type 2220 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 2221 long double&) const; 2222 #endif 2223 2224 virtual iter_type 2225 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 2226 void*&) const; 2227 2228 // XXX GLIBCXX_ABI Deprecated 2229 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 2230 virtual iter_type 2231 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 2232 long double&) const; 2233 #endif 2234 //@} 2235 }; 2236 2237 template<typename _CharT, typename _InIter> 2238 locale::id num_get<_CharT, _InIter>::id; 2239 2240 2241 /** 2242 * @brief Primary class template num_put. 2243 * @ingroup locales 2244 * 2245 * This facet encapsulates the code to convert a number to a string. It is 2246 * used by the ostream numeric insertion operators. 2247 * 2248 * The num_put template uses protected virtual functions to provide the 2249 * actual results. The public accessors forward the call to the virtual 2250 * functions. These virtual functions are hooks for developers to 2251 * implement the behavior they require from the num_put facet. 2252 */ 2253 template<typename _CharT, typename _OutIter> 2254 class num_put : public locale::facet 2255 { 2256 public: 2257 // Types: 2258 //@{ 2259 /// Public typedefs 2260 typedef _CharT char_type; 2261 typedef _OutIter iter_type; 2262 //@} 2263 2264 /// Numpunct facet id. 2265 static locale::id id; 2266 2267 /** 2268 * @brief Constructor performs initialization. 2269 * 2270 * This is the constructor provided by the standard. 2271 * 2272 * @param refs Passed to the base facet class. 2273 */ 2274 explicit 2275 num_put(size_t __refs = 0) : facet(__refs) { } 2276 2277 /** 2278 * @brief Numeric formatting. 2279 * 2280 * Formats the boolean @a v and inserts it into a stream. It does so 2281 * by calling num_put::do_put(). 2282 * 2283 * If ios_base::boolalpha is set, writes ctype<CharT>::truename() or 2284 * ctype<CharT>::falsename(). Otherwise formats @a v as an int. 2285 * 2286 * @param s Stream to write to. 2287 * @param io Source of locale and flags. 2288 * @param fill Char_type to use for filling. 2289 * @param v Value to format and insert. 2290 * @return Iterator after writing. 2291 */ 2292 iter_type 2293 put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const 2294 { return this->do_put(__s, __f, __fill, __v); } 2295 2296 //@{ 2297 /** 2298 * @brief Numeric formatting. 2299 * 2300 * Formats the integral value @a v and inserts it into a 2301 * stream. It does so by calling num_put::do_put(). 2302 * 2303 * Formatting is affected by the flag settings in @a io. 2304 * 2305 * The basic format is affected by the value of io.flags() & 2306 * ios_base::basefield. If equal to ios_base::oct, formats like the 2307 * printf %o specifier. Else if equal to ios_base::hex, formats like 2308 * %x or %X with ios_base::uppercase unset or set respectively. 2309 * Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu 2310 * for unsigned values. Note that if both oct and hex are set, neither 2311 * will take effect. 2312 * 2313 * If ios_base::showpos is set, '+' is output before positive values. 2314 * If ios_base::showbase is set, '0' precedes octal values (except 0) 2315 * and '0[xX]' precedes hex values. 2316 * 2317 * Thousands separators are inserted according to numpunct::grouping() 2318 * and numpunct::thousands_sep(). The decimal point character used is 2319 * numpunct::decimal_point(). 2320 * 2321 * If io.width() is non-zero, enough @a fill characters are inserted to 2322 * make the result at least that wide. If 2323 * (io.flags() & ios_base::adjustfield) == ios_base::left, result is 2324 * padded at the end. If ios_base::internal, then padding occurs 2325 * immediately after either a '+' or '-' or after '0x' or '0X'. 2326 * Otherwise, padding occurs at the beginning. 2327 * 2328 * @param s Stream to write to. 2329 * @param io Source of locale and flags. 2330 * @param fill Char_type to use for filling. 2331 * @param v Value to format and insert. 2332 * @return Iterator after writing. 2333 */ 2334 iter_type 2335 put(iter_type __s, ios_base& __f, char_type __fill, long __v) const 2336 { return this->do_put(__s, __f, __fill, __v); } 2337 2338 iter_type 2339 put(iter_type __s, ios_base& __f, char_type __fill, 2340 unsigned long __v) const 2341 { return this->do_put(__s, __f, __fill, __v); } 2342 2343 #ifdef _GLIBCXX_USE_LONG_LONG 2344 iter_type 2345 put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const 2346 { return this->do_put(__s, __f, __fill, __v); } 2347 2348 iter_type 2349 put(iter_type __s, ios_base& __f, char_type __fill, 2350 unsigned long long __v) const 2351 { return this->do_put(__s, __f, __fill, __v); } 2352 #endif 2353 //@} 2354 2355 //@{ 2356 /** 2357 * @brief Numeric formatting. 2358 * 2359 * Formats the floating point value @a v and inserts it into a stream. 2360 * It does so by calling num_put::do_put(). 2361 * 2362 * Formatting is affected by the flag settings in @a io. 2363 * 2364 * The basic format is affected by the value of io.flags() & 2365 * ios_base::floatfield. If equal to ios_base::fixed, formats like the 2366 * printf %f specifier. Else if equal to ios_base::scientific, formats 2367 * like %e or %E with ios_base::uppercase unset or set respectively. 2368 * Otherwise, formats like %g or %G depending on uppercase. Note that 2369 * if both fixed and scientific are set, the effect will also be like 2370 * %g or %G. 2371 * 2372 * The output precision is given by io.precision(). This precision is 2373 * capped at numeric_limits::digits10 + 2 (different for double and 2374 * long double). The default precision is 6. 2375 * 2376 * If ios_base::showpos is set, '+' is output before positive values. 2377 * If ios_base::showpoint is set, a decimal point will always be 2378 * output. 2379 * 2380 * Thousands separators are inserted according to numpunct::grouping() 2381 * and numpunct::thousands_sep(). The decimal point character used is 2382 * numpunct::decimal_point(). 2383 * 2384 * If io.width() is non-zero, enough @a fill characters are inserted to 2385 * make the result at least that wide. If 2386 * (io.flags() & ios_base::adjustfield) == ios_base::left, result is 2387 * padded at the end. If ios_base::internal, then padding occurs 2388 * immediately after either a '+' or '-' or after '0x' or '0X'. 2389 * Otherwise, padding occurs at the beginning. 2390 * 2391 * @param s Stream to write to. 2392 * @param io Source of locale and flags. 2393 * @param fill Char_type to use for filling. 2394 * @param v Value to format and insert. 2395 * @return Iterator after writing. 2396 */ 2397 iter_type 2398 put(iter_type __s, ios_base& __f, char_type __fill, double __v) const 2399 { return this->do_put(__s, __f, __fill, __v); } 2400 2401 iter_type 2402 put(iter_type __s, ios_base& __f, char_type __fill, 2403 long double __v) const 2404 { return this->do_put(__s, __f, __fill, __v); } 2405 //@} 2406 2407 /** 2408 * @brief Numeric formatting. 2409 * 2410 * Formats the pointer value @a v and inserts it into a stream. It 2411 * does so by calling num_put::do_put(). 2412 * 2413 * This function formats @a v as an unsigned long with ios_base::hex 2414 * and ios_base::showbase set. 2415 * 2416 * @param s Stream to write to. 2417 * @param io Source of locale and flags. 2418 * @param fill Char_type to use for filling. 2419 * @param v Value to format and insert. 2420 * @return Iterator after writing. 2421 */ 2422 iter_type 2423 put(iter_type __s, ios_base& __f, char_type __fill, 2424 const void* __v) const 2425 { return this->do_put(__s, __f, __fill, __v); } 2426 2427 protected: 2428 template<typename _ValueT> 2429 iter_type 2430 _M_insert_float(iter_type, ios_base& __io, char_type __fill, 2431 char __mod, _ValueT __v) const; 2432 2433 void 2434 _M_group_float(const char* __grouping, size_t __grouping_size, 2435 char_type __sep, const char_type* __p, char_type* __new, 2436 char_type* __cs, int& __len) const; 2437 2438 template<typename _ValueT> 2439 iter_type 2440 _M_insert_int(iter_type, ios_base& __io, char_type __fill, 2441 _ValueT __v) const; 2442 2443 void 2444 _M_group_int(const char* __grouping, size_t __grouping_size, 2445 char_type __sep, ios_base& __io, char_type* __new, 2446 char_type* __cs, int& __len) const; 2447 2448 void 2449 _M_pad(char_type __fill, streamsize __w, ios_base& __io, 2450 char_type* __new, const char_type* __cs, int& __len) const; 2451 2452 /// Destructor. 2453 virtual 2454 ~num_put() { }; 2455 2456 //@{ 2457 /** 2458 * @brief Numeric formatting. 2459 * 2460 * These functions do the work of formatting numeric values and 2461 * inserting them into a stream. This function is a hook for derived 2462 * classes to change the value returned. 2463 * 2464 * @param s Stream to write to. 2465 * @param io Source of locale and flags. 2466 * @param fill Char_type to use for filling. 2467 * @param v Value to format and insert. 2468 * @return Iterator after writing. 2469 */ 2470 virtual iter_type 2471 do_put(iter_type, ios_base&, char_type __fill, bool __v) const; 2472 2473 virtual iter_type 2474 do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const 2475 { return _M_insert_int(__s, __io, __fill, __v); } 2476 2477 virtual iter_type 2478 do_put(iter_type __s, ios_base& __io, char_type __fill, 2479 unsigned long __v) const 2480 { return _M_insert_int(__s, __io, __fill, __v); } 2481 2482 #ifdef _GLIBCXX_USE_LONG_LONG 2483 virtual iter_type 2484 do_put(iter_type __s, ios_base& __io, char_type __fill, 2485 long long __v) const 2486 { return _M_insert_int(__s, __io, __fill, __v); } 2487 2488 virtual iter_type 2489 do_put(iter_type __s, ios_base& __io, char_type __fill, 2490 unsigned long long __v) const 2491 { return _M_insert_int(__s, __io, __fill, __v); } 2492 #endif 2493 2494 virtual iter_type 2495 do_put(iter_type, ios_base&, char_type __fill, double __v) const; 2496 2497 // XXX GLIBCXX_ABI Deprecated 2498 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 2499 virtual iter_type 2500 __do_put(iter_type, ios_base&, char_type __fill, double __v) const; 2501 #else 2502 virtual iter_type 2503 do_put(iter_type, ios_base&, char_type __fill, long double __v) const; 2504 #endif 2505 2506 virtual iter_type 2507 do_put(iter_type, ios_base&, char_type __fill, const void* __v) const; 2508 2509 // XXX GLIBCXX_ABI Deprecated 2510 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 2511 virtual iter_type 2512 do_put(iter_type, ios_base&, char_type __fill, long double __v) const; 2513 #endif 2514 //@} 2515 }; 2516 2517 template <typename _CharT, typename _OutIter> 2518 locale::id num_put<_CharT, _OutIter>::id; 2519 2520 _GLIBCXX_END_NAMESPACE_LDBL 2521 2522 // Subclause convenience interfaces, inlines. 2523 // NB: These are inline because, when used in a loop, some compilers 2524 // can hoist the body out of the loop; then it's just as fast as the 2525 // C is*() function. 2526 2527 /// Convenience interface to ctype.is(ctype_base::space, __c). 2528 template<typename _CharT> 2529 inline bool 2530 isspace(_CharT __c, const locale& __loc) 2531 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); } 2532 2533 /// Convenience interface to ctype.is(ctype_base::print, __c). 2534 template<typename _CharT> 2535 inline bool 2536 isprint(_CharT __c, const locale& __loc) 2537 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); } 2538 2539 /// Convenience interface to ctype.is(ctype_base::cntrl, __c). 2540 template<typename _CharT> 2541 inline bool 2542 iscntrl(_CharT __c, const locale& __loc) 2543 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); } 2544 2545 /// Convenience interface to ctype.is(ctype_base::upper, __c). 2546 template<typename _CharT> 2547 inline bool 2548 isupper(_CharT __c, const locale& __loc) 2549 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); } 2550 2551 /// Convenience interface to ctype.is(ctype_base::lower, __c). 2552 template<typename _CharT> 2553 inline bool 2554 islower(_CharT __c, const locale& __loc) 2555 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); } 2556 2557 /// Convenience interface to ctype.is(ctype_base::alpha, __c). 2558 template<typename _CharT> 2559 inline bool 2560 isalpha(_CharT __c, const locale& __loc) 2561 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); } 2562 2563 /// Convenience interface to ctype.is(ctype_base::digit, __c). 2564 template<typename _CharT> 2565 inline bool 2566 isdigit(_CharT __c, const locale& __loc) 2567 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); } 2568 2569 /// Convenience interface to ctype.is(ctype_base::punct, __c). 2570 template<typename _CharT> 2571 inline bool 2572 ispunct(_CharT __c, const locale& __loc) 2573 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); } 2574 2575 /// Convenience interface to ctype.is(ctype_base::xdigit, __c). 2576 template<typename _CharT> 2577 inline bool 2578 isxdigit(_CharT __c, const locale& __loc) 2579 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); } 2580 2581 /// Convenience interface to ctype.is(ctype_base::alnum, __c). 2582 template<typename _CharT> 2583 inline bool 2584 isalnum(_CharT __c, const locale& __loc) 2585 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); } 2586 2587 /// Convenience interface to ctype.is(ctype_base::graph, __c). 2588 template<typename _CharT> 2589 inline bool 2590 isgraph(_CharT __c, const locale& __loc) 2591 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); } 2592 2593 /// Convenience interface to ctype.toupper(__c). 2594 template<typename _CharT> 2595 inline _CharT 2596 toupper(_CharT __c, const locale& __loc) 2597 { return use_facet<ctype<_CharT> >(__loc).toupper(__c); } 2598 2599 /// Convenience interface to ctype.tolower(__c). 2600 template<typename _CharT> 2601 inline _CharT 2602 tolower(_CharT __c, const locale& __loc) 2603 { return use_facet<ctype<_CharT> >(__loc).tolower(__c); } 2604 2605 _GLIBCXX_END_NAMESPACE_VERSION 2606 } // namespace 2607 2608 # include <bits/locale_facets.tcc> 2609 2610 #endif 2611