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