1 // -*- C++ -*- 2 //===--------------------------- iomanip ----------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef _LIBCPP_IOMANIP 12 #define _LIBCPP_IOMANIP 13 14 /* 15 iomanip synopsis 16 17 namespace std { 18 19 // types T1, T2, ... are unspecified implementation types 20 T1 resetiosflags(ios_base::fmtflags mask); 21 T2 setiosflags (ios_base::fmtflags mask); 22 T3 setbase(int base); 23 template<charT> T4 setfill(charT c); 24 T5 setprecision(int n); 25 T6 setw(int n); 26 template <class moneyT> T7 get_money(moneyT& mon, bool intl = false); 27 template <class charT, class moneyT> T8 put_money(const moneyT& mon, bool intl = false); 28 template <class charT> T9 get_time(struct tm* tmb, const charT* fmt); 29 template <class charT> T10 put_time(const struct tm* tmb, const charT* fmt); 30 31 template <class charT> 32 T11 quoted(const charT* s, charT delim=charT('"'), charT escape=charT('\\')); // C++14 33 34 template <class charT, class traits, class Allocator> 35 T12 quoted(const basic_string<charT, traits, Allocator>& s, 36 charT delim=charT('"'), charT escape=charT('\\')); // C++14 37 38 template <class charT, class traits, class Allocator> 39 T13 quoted(basic_string<charT, traits, Allocator>& s, 40 charT delim=charT('"'), charT escape=charT('\\')); // C++14 41 42 } // std 43 44 */ 45 46 #include <__config> 47 #include <istream> 48 49 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 50 #pragma GCC system_header 51 #endif 52 53 _LIBCPP_BEGIN_NAMESPACE_STD 54 55 // resetiosflags 56 57 class __iom_t1 58 { 59 ios_base::fmtflags __mask_; 60 public: 61 _LIBCPP_INLINE_VISIBILITY 62 explicit __iom_t1(ios_base::fmtflags __m) : __mask_(__m) {} 63 64 template <class _CharT, class _Traits> 65 friend 66 _LIBCPP_INLINE_VISIBILITY 67 basic_istream<_CharT, _Traits>& 68 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t1& __x) 69 { 70 __is.unsetf(__x.__mask_); 71 return __is; 72 } 73 74 template <class _CharT, class _Traits> 75 friend 76 _LIBCPP_INLINE_VISIBILITY 77 basic_ostream<_CharT, _Traits>& 78 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t1& __x) 79 { 80 __os.unsetf(__x.__mask_); 81 return __os; 82 } 83 }; 84 85 inline _LIBCPP_INLINE_VISIBILITY 86 __iom_t1 87 resetiosflags(ios_base::fmtflags __mask) 88 { 89 return __iom_t1(__mask); 90 } 91 92 // setiosflags 93 94 class __iom_t2 95 { 96 ios_base::fmtflags __mask_; 97 public: 98 _LIBCPP_INLINE_VISIBILITY 99 explicit __iom_t2(ios_base::fmtflags __m) : __mask_(__m) {} 100 101 template <class _CharT, class _Traits> 102 friend 103 _LIBCPP_INLINE_VISIBILITY 104 basic_istream<_CharT, _Traits>& 105 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t2& __x) 106 { 107 __is.setf(__x.__mask_); 108 return __is; 109 } 110 111 template <class _CharT, class _Traits> 112 friend 113 _LIBCPP_INLINE_VISIBILITY 114 basic_ostream<_CharT, _Traits>& 115 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t2& __x) 116 { 117 __os.setf(__x.__mask_); 118 return __os; 119 } 120 }; 121 122 inline _LIBCPP_INLINE_VISIBILITY 123 __iom_t2 124 setiosflags(ios_base::fmtflags __mask) 125 { 126 return __iom_t2(__mask); 127 } 128 129 // setbase 130 131 class __iom_t3 132 { 133 int __base_; 134 public: 135 _LIBCPP_INLINE_VISIBILITY 136 explicit __iom_t3(int __b) : __base_(__b) {} 137 138 template <class _CharT, class _Traits> 139 friend 140 _LIBCPP_INLINE_VISIBILITY 141 basic_istream<_CharT, _Traits>& 142 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t3& __x) 143 { 144 __is.setf(__x.__base_ == 8 ? ios_base::oct : 145 __x.__base_ == 10 ? ios_base::dec : 146 __x.__base_ == 16 ? ios_base::hex : 147 ios_base::fmtflags(0), ios_base::basefield); 148 return __is; 149 } 150 151 template <class _CharT, class _Traits> 152 friend 153 _LIBCPP_INLINE_VISIBILITY 154 basic_ostream<_CharT, _Traits>& 155 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t3& __x) 156 { 157 __os.setf(__x.__base_ == 8 ? ios_base::oct : 158 __x.__base_ == 10 ? ios_base::dec : 159 __x.__base_ == 16 ? ios_base::hex : 160 ios_base::fmtflags(0), ios_base::basefield); 161 return __os; 162 } 163 }; 164 165 inline _LIBCPP_INLINE_VISIBILITY 166 __iom_t3 167 setbase(int __base) 168 { 169 return __iom_t3(__base); 170 } 171 172 // setfill 173 174 template<class _CharT> 175 class __iom_t4 176 { 177 _CharT __fill_; 178 public: 179 _LIBCPP_INLINE_VISIBILITY 180 explicit __iom_t4(_CharT __c) : __fill_(__c) {} 181 182 template <class _Traits> 183 friend 184 _LIBCPP_INLINE_VISIBILITY 185 basic_ostream<_CharT, _Traits>& 186 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t4& __x) 187 { 188 __os.fill(__x.__fill_); 189 return __os; 190 } 191 }; 192 193 template<class _CharT> 194 inline _LIBCPP_INLINE_VISIBILITY 195 __iom_t4<_CharT> 196 setfill(_CharT __c) 197 { 198 return __iom_t4<_CharT>(__c); 199 } 200 201 // setprecision 202 203 class __iom_t5 204 { 205 int __n_; 206 public: 207 _LIBCPP_INLINE_VISIBILITY 208 explicit __iom_t5(int __n) : __n_(__n) {} 209 210 template <class _CharT, class _Traits> 211 friend 212 _LIBCPP_INLINE_VISIBILITY 213 basic_istream<_CharT, _Traits>& 214 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t5& __x) 215 { 216 __is.precision(__x.__n_); 217 return __is; 218 } 219 220 template <class _CharT, class _Traits> 221 friend 222 _LIBCPP_INLINE_VISIBILITY 223 basic_ostream<_CharT, _Traits>& 224 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t5& __x) 225 { 226 __os.precision(__x.__n_); 227 return __os; 228 } 229 }; 230 231 inline _LIBCPP_INLINE_VISIBILITY 232 __iom_t5 233 setprecision(int __n) 234 { 235 return __iom_t5(__n); 236 } 237 238 // setw 239 240 class __iom_t6 241 { 242 int __n_; 243 public: 244 _LIBCPP_INLINE_VISIBILITY 245 explicit __iom_t6(int __n) : __n_(__n) {} 246 247 template <class _CharT, class _Traits> 248 friend 249 _LIBCPP_INLINE_VISIBILITY 250 basic_istream<_CharT, _Traits>& 251 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t6& __x) 252 { 253 __is.width(__x.__n_); 254 return __is; 255 } 256 257 template <class _CharT, class _Traits> 258 friend 259 _LIBCPP_INLINE_VISIBILITY 260 basic_ostream<_CharT, _Traits>& 261 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t6& __x) 262 { 263 __os.width(__x.__n_); 264 return __os; 265 } 266 }; 267 268 inline _LIBCPP_INLINE_VISIBILITY 269 __iom_t6 270 setw(int __n) 271 { 272 return __iom_t6(__n); 273 } 274 275 // get_money 276 277 template <class _MoneyT> class __iom_t7; 278 279 template <class _CharT, class _Traits, class _MoneyT> 280 basic_istream<_CharT, _Traits>& 281 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x); 282 283 template <class _MoneyT> 284 class __iom_t7 285 { 286 _MoneyT& __mon_; 287 bool __intl_; 288 public: 289 _LIBCPP_INLINE_VISIBILITY 290 __iom_t7(_MoneyT& __mon, bool __intl) 291 : __mon_(__mon), __intl_(__intl) {} 292 293 template <class _CharT, class _Traits, class _Mp> 294 friend 295 basic_istream<_CharT, _Traits>& 296 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_Mp>& __x); 297 }; 298 299 template <class _CharT, class _Traits, class _MoneyT> 300 basic_istream<_CharT, _Traits>& 301 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x) 302 { 303 #ifndef _LIBCPP_NO_EXCEPTIONS 304 try 305 { 306 #endif // _LIBCPP_NO_EXCEPTIONS 307 typename basic_istream<_CharT, _Traits>::sentry __s(__is); 308 if (__s) 309 { 310 typedef istreambuf_iterator<_CharT, _Traits> _Ip; 311 typedef money_get<_CharT, _Ip> _Fp; 312 ios_base::iostate __err = ios_base::goodbit; 313 const _Fp& __mf = use_facet<_Fp>(__is.getloc()); 314 __mf.get(_Ip(__is), _Ip(), __x.__intl_, __is, __err, __x.__mon_); 315 __is.setstate(__err); 316 } 317 #ifndef _LIBCPP_NO_EXCEPTIONS 318 } 319 catch (...) 320 { 321 __is.__set_badbit_and_consider_rethrow(); 322 } 323 #endif // _LIBCPP_NO_EXCEPTIONS 324 return __is; 325 } 326 327 template <class _MoneyT> 328 inline _LIBCPP_INLINE_VISIBILITY 329 __iom_t7<_MoneyT> 330 get_money(_MoneyT& __mon, bool __intl = false) 331 { 332 return __iom_t7<_MoneyT>(__mon, __intl); 333 } 334 335 // put_money 336 337 template <class _MoneyT> class __iom_t8; 338 339 template <class _CharT, class _Traits, class _MoneyT> 340 basic_ostream<_CharT, _Traits>& 341 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x); 342 343 template <class _MoneyT> 344 class __iom_t8 345 { 346 const _MoneyT& __mon_; 347 bool __intl_; 348 public: 349 _LIBCPP_INLINE_VISIBILITY 350 __iom_t8(const _MoneyT& __mon, bool __intl) 351 : __mon_(__mon), __intl_(__intl) {} 352 353 template <class _CharT, class _Traits, class _Mp> 354 friend 355 basic_ostream<_CharT, _Traits>& 356 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_Mp>& __x); 357 }; 358 359 template <class _CharT, class _Traits, class _MoneyT> 360 basic_ostream<_CharT, _Traits>& 361 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x) 362 { 363 #ifndef _LIBCPP_NO_EXCEPTIONS 364 try 365 { 366 #endif // _LIBCPP_NO_EXCEPTIONS 367 typename basic_ostream<_CharT, _Traits>::sentry __s(__os); 368 if (__s) 369 { 370 typedef ostreambuf_iterator<_CharT, _Traits> _Op; 371 typedef money_put<_CharT, _Op> _Fp; 372 const _Fp& __mf = use_facet<_Fp>(__os.getloc()); 373 if (__mf.put(_Op(__os), __x.__intl_, __os, __os.fill(), __x.__mon_).failed()) 374 __os.setstate(ios_base::badbit); 375 } 376 #ifndef _LIBCPP_NO_EXCEPTIONS 377 } 378 catch (...) 379 { 380 __os.__set_badbit_and_consider_rethrow(); 381 } 382 #endif // _LIBCPP_NO_EXCEPTIONS 383 return __os; 384 } 385 386 template <class _MoneyT> 387 inline _LIBCPP_INLINE_VISIBILITY 388 __iom_t8<_MoneyT> 389 put_money(const _MoneyT& __mon, bool __intl = false) 390 { 391 return __iom_t8<_MoneyT>(__mon, __intl); 392 } 393 394 // get_time 395 396 template <class _CharT> class __iom_t9; 397 398 template <class _CharT, class _Traits> 399 basic_istream<_CharT, _Traits>& 400 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x); 401 402 template <class _CharT> 403 class __iom_t9 404 { 405 tm* __tm_; 406 const _CharT* __fmt_; 407 public: 408 _LIBCPP_INLINE_VISIBILITY 409 __iom_t9(tm* __tm, const _CharT* __fmt) 410 : __tm_(__tm), __fmt_(__fmt) {} 411 412 template <class _Cp, class _Traits> 413 friend 414 basic_istream<_Cp, _Traits>& 415 operator>>(basic_istream<_Cp, _Traits>& __is, const __iom_t9<_Cp>& __x); 416 }; 417 418 template <class _CharT, class _Traits> 419 basic_istream<_CharT, _Traits>& 420 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x) 421 { 422 #ifndef _LIBCPP_NO_EXCEPTIONS 423 try 424 { 425 #endif // _LIBCPP_NO_EXCEPTIONS 426 typename basic_istream<_CharT, _Traits>::sentry __s(__is); 427 if (__s) 428 { 429 typedef istreambuf_iterator<_CharT, _Traits> _Ip; 430 typedef time_get<_CharT, _Ip> _Fp; 431 ios_base::iostate __err = ios_base::goodbit; 432 const _Fp& __tf = use_facet<_Fp>(__is.getloc()); 433 __tf.get(_Ip(__is), _Ip(), __is, __err, __x.__tm_, 434 __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_)); 435 __is.setstate(__err); 436 } 437 #ifndef _LIBCPP_NO_EXCEPTIONS 438 } 439 catch (...) 440 { 441 __is.__set_badbit_and_consider_rethrow(); 442 } 443 #endif // _LIBCPP_NO_EXCEPTIONS 444 return __is; 445 } 446 447 template <class _CharT> 448 inline _LIBCPP_INLINE_VISIBILITY 449 __iom_t9<_CharT> 450 get_time(tm* __tm, const _CharT* __fmt) 451 { 452 return __iom_t9<_CharT>(__tm, __fmt); 453 } 454 455 // put_time 456 457 template <class _CharT> class __iom_t10; 458 459 template <class _CharT, class _Traits> 460 basic_ostream<_CharT, _Traits>& 461 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x); 462 463 template <class _CharT> 464 class __iom_t10 465 { 466 const tm* __tm_; 467 const _CharT* __fmt_; 468 public: 469 _LIBCPP_INLINE_VISIBILITY 470 __iom_t10(const tm* __tm, const _CharT* __fmt) 471 : __tm_(__tm), __fmt_(__fmt) {} 472 473 template <class _Cp, class _Traits> 474 friend 475 basic_ostream<_Cp, _Traits>& 476 operator<<(basic_ostream<_Cp, _Traits>& __os, const __iom_t10<_Cp>& __x); 477 }; 478 479 template <class _CharT, class _Traits> 480 basic_ostream<_CharT, _Traits>& 481 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x) 482 { 483 #ifndef _LIBCPP_NO_EXCEPTIONS 484 try 485 { 486 #endif // _LIBCPP_NO_EXCEPTIONS 487 typename basic_ostream<_CharT, _Traits>::sentry __s(__os); 488 if (__s) 489 { 490 typedef ostreambuf_iterator<_CharT, _Traits> _Op; 491 typedef time_put<_CharT, _Op> _Fp; 492 const _Fp& __tf = use_facet<_Fp>(__os.getloc()); 493 if (__tf.put(_Op(__os), __os, __os.fill(), __x.__tm_, 494 __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_)).failed()) 495 __os.setstate(ios_base::badbit); 496 } 497 #ifndef _LIBCPP_NO_EXCEPTIONS 498 } 499 catch (...) 500 { 501 __os.__set_badbit_and_consider_rethrow(); 502 } 503 #endif // _LIBCPP_NO_EXCEPTIONS 504 return __os; 505 } 506 507 template <class _CharT> 508 inline _LIBCPP_INLINE_VISIBILITY 509 __iom_t10<_CharT> 510 put_time(const tm* __tm, const _CharT* __fmt) 511 { 512 return __iom_t10<_CharT>(__tm, __fmt); 513 } 514 515 #if _LIBCPP_STD_VER > 11 516 517 template <class _CharT, class _Traits, class _ForwardIterator> 518 std::basic_ostream<_CharT, _Traits> & 519 __quoted_output ( basic_ostream<_CharT, _Traits> &__os, 520 _ForwardIterator __first, _ForwardIterator __last, _CharT __delim, _CharT __escape ) 521 { 522 _VSTD::basic_string<_CharT, _Traits> __str; 523 __str.push_back(__delim); 524 for ( ; __first != __last; ++ __first ) 525 { 526 if (_Traits::eq (*__first, __escape) || _Traits::eq (*__first, __delim)) 527 __str.push_back(__escape); 528 __str.push_back(*__first); 529 } 530 __str.push_back(__delim); 531 return __put_character_sequence(__os, __str.data(), __str.size()); 532 } 533 534 template <class _CharT, class _Traits, class _String> 535 basic_istream<_CharT, _Traits> & 536 __quoted_input ( basic_istream<_CharT, _Traits> &__is, _String & __string, _CharT __delim, _CharT __escape ) 537 { 538 __string.clear (); 539 _CharT __c; 540 __is >> __c; 541 if ( __is.fail ()) 542 return __is; 543 544 if (!_Traits::eq (__c, __delim)) // no delimiter, read the whole string 545 { 546 __is.unget (); 547 __is >> __string; 548 return __is; 549 } 550 551 __save_flags<_CharT, _Traits> sf(__is); 552 noskipws (__is); 553 while (true) 554 { 555 __is >> __c; 556 if ( __is.fail ()) 557 break; 558 if (_Traits::eq (__c, __escape)) 559 { 560 __is >> __c; 561 if ( __is.fail ()) 562 break; 563 } 564 else if (_Traits::eq (__c, __delim)) 565 break; 566 __string.push_back ( __c ); 567 } 568 return __is; 569 } 570 571 572 template <class _CharT, class _Iter, class _Traits=char_traits<_CharT>> 573 struct __quoted_output_proxy 574 { 575 _Iter __first; 576 _Iter __last; 577 _CharT __delim; 578 _CharT __escape; 579 580 __quoted_output_proxy(_Iter __f, _Iter __l, _CharT __d, _CharT __e) 581 : __first(__f), __last(__l), __delim(__d), __escape(__e) {} 582 // This would be a nice place for a string_ref 583 }; 584 585 template <class _CharT, class _Traits, class _Iter> 586 basic_ostream<_CharT, _Traits>& operator<<( 587 basic_ostream<_CharT, _Traits>& __os, 588 const __quoted_output_proxy<_CharT, _Iter, _Traits> & __proxy) 589 { 590 return __quoted_output (__os, __proxy.__first, __proxy.__last, __proxy.__delim, __proxy.__escape); 591 } 592 593 template <class _CharT, class _Traits, class _Allocator> 594 struct __quoted_proxy 595 { 596 basic_string<_CharT, _Traits, _Allocator> &__string; 597 _CharT __delim; 598 _CharT __escape; 599 600 __quoted_proxy(basic_string<_CharT, _Traits, _Allocator> &__s, _CharT __d, _CharT __e) 601 : __string(__s), __delim(__d), __escape(__e) {} 602 }; 603 604 template <class _CharT, class _Traits, class _Allocator> 605 _LIBCPP_INLINE_VISIBILITY 606 basic_ostream<_CharT, _Traits>& operator<<( 607 basic_ostream<_CharT, _Traits>& __os, 608 const __quoted_proxy<_CharT, _Traits, _Allocator> & __proxy) 609 { 610 return __quoted_output (__os, __proxy.__string.cbegin (), __proxy.__string.cend (), __proxy.__delim, __proxy.__escape); 611 } 612 613 // extractor for non-const basic_string& proxies 614 template <class _CharT, class _Traits, class _Allocator> 615 _LIBCPP_INLINE_VISIBILITY 616 basic_istream<_CharT, _Traits>& operator>>( 617 basic_istream<_CharT, _Traits>& __is, 618 const __quoted_proxy<_CharT, _Traits, _Allocator> & __proxy) 619 { 620 return __quoted_input ( __is, __proxy.__string, __proxy.__delim, __proxy.__escape ); 621 } 622 623 624 template <class _CharT> 625 _LIBCPP_INLINE_VISIBILITY 626 __quoted_output_proxy<_CharT, const _CharT *> 627 quoted ( const _CharT *__s, _CharT __delim = _CharT('"'), _CharT __escape =_CharT('\\')) 628 { 629 const _CharT *__end = __s; 630 while ( *__end ) ++__end; 631 return __quoted_output_proxy<_CharT, const _CharT *> ( __s, __end, __delim, __escape ); 632 } 633 634 template <class _CharT, class _Traits, class _Allocator> 635 _LIBCPP_INLINE_VISIBILITY 636 __quoted_output_proxy<_CharT, typename basic_string <_CharT, _Traits, _Allocator>::const_iterator> 637 quoted ( const basic_string <_CharT, _Traits, _Allocator> &__s, _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\')) 638 { 639 return __quoted_output_proxy<_CharT, 640 typename basic_string <_CharT, _Traits, _Allocator>::const_iterator> 641 ( __s.cbegin(), __s.cend (), __delim, __escape ); 642 } 643 644 template <class _CharT, class _Traits, class _Allocator> 645 __quoted_proxy<_CharT, _Traits, _Allocator> 646 quoted ( basic_string <_CharT, _Traits, _Allocator> &__s, _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\')) 647 { 648 return __quoted_proxy<_CharT, _Traits, _Allocator>( __s, __delim, __escape ); 649 } 650 #endif 651 652 _LIBCPP_END_NAMESPACE_STD 653 654 #endif // _LIBCPP_IOMANIP 655
