1// -*- C++ -*- 2//===--------------------------- strstream --------------------------------===// 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_STRSTREAM 12#define _LIBCPP_STRSTREAM 13 14/* 15 strstream synopsis 16 17class strstreambuf 18 : public basic_streambuf<char> 19{ 20public: 21 explicit strstreambuf(streamsize alsize_arg = 0); 22 strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*)); 23 strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0); 24 strstreambuf(const char* gnext_arg, streamsize n); 25 26 strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = 0); 27 strstreambuf(const signed char* gnext_arg, streamsize n); 28 strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = 0); 29 strstreambuf(const unsigned char* gnext_arg, streamsize n); 30 31 strstreambuf(strstreambuf&& rhs); 32 strstreambuf& operator=(strstreambuf&& rhs); 33 34 virtual ~strstreambuf(); 35 36 void swap(strstreambuf& rhs); 37 38 void freeze(bool freezefl = true); 39 char* str(); 40 int pcount() const; 41 42protected: 43 virtual int_type overflow (int_type c = EOF); 44 virtual int_type pbackfail(int_type c = EOF); 45 virtual int_type underflow(); 46 virtual pos_type seekoff(off_type off, ios_base::seekdir way, 47 ios_base::openmode which = ios_base::in | ios_base::out); 48 virtual pos_type seekpos(pos_type sp, 49 ios_base::openmode which = ios_base::in | ios_base::out); 50 virtual streambuf* setbuf(char* s, streamsize n); 51 52private: 53 typedef T1 strstate; // exposition only 54 static const strstate allocated; // exposition only 55 static const strstate constant; // exposition only 56 static const strstate dynamic; // exposition only 57 static const strstate frozen; // exposition only 58 strstate strmode; // exposition only 59 streamsize alsize; // exposition only 60 void* (*palloc)(size_t); // exposition only 61 void (*pfree)(void*); // exposition only 62}; 63 64class istrstream 65 : public basic_istream<char> 66{ 67public: 68 explicit istrstream(const char* s); 69 explicit istrstream(char* s); 70 istrstream(const char* s, streamsize n); 71 istrstream(char* s, streamsize n); 72 73 virtual ~istrstream(); 74 75 strstreambuf* rdbuf() const; 76 char *str(); 77 78private: 79 strstreambuf sb; // exposition only 80}; 81 82class ostrstream 83 : public basic_ostream<char> 84{ 85public: 86 ostrstream(); 87 ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out); 88 89 virtual ~ostrstream(); 90 91 strstreambuf* rdbuf() const; 92 void freeze(bool freezefl = true); 93 char* str(); 94 int pcount() const; 95 96private: 97 strstreambuf sb; // exposition only 98}; 99 100class strstream 101 : public basic_iostream<char> 102{ 103public: 104 // Types 105 typedef char char_type; 106 typedef char_traits<char>::int_type int_type; 107 typedef char_traits<char>::pos_type pos_type; 108 typedef char_traits<char>::off_type off_type; 109 110 // constructors/destructor 111 strstream(); 112 strstream(char* s, int n, ios_base::openmode mode = ios_base::in | ios_base::out); 113 114 virtual ~strstream(); 115 116 // Members: 117 strstreambuf* rdbuf() const; 118 void freeze(bool freezefl = true); 119 int pcount() const; 120 char* str(); 121 122private: 123 strstreambuf sb; // exposition only 124}; 125 126} // std 127 128*/ 129 130#include <__config> 131#include <ostream> 132#include <istream> 133 134#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 135#pragma GCC system_header 136#endif 137 138_LIBCPP_BEGIN_NAMESPACE_STD 139 140class _LIBCPP_TYPE_VIS strstreambuf 141 : public streambuf 142{ 143public: 144 explicit strstreambuf(streamsize __alsize = 0); 145 strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*)); 146 strstreambuf(char* __gnext, streamsize __n, char* __pbeg = 0); 147 strstreambuf(const char* __gnext, streamsize __n); 148 149 strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = 0); 150 strstreambuf(const signed char* __gnext, streamsize __n); 151 strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = 0); 152 strstreambuf(const unsigned char* __gnext, streamsize __n); 153 154#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 155 _LIBCPP_INLINE_VISIBILITY 156 strstreambuf(strstreambuf&& __rhs); 157 _LIBCPP_INLINE_VISIBILITY 158 strstreambuf& operator=(strstreambuf&& __rhs); 159#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 160 161 virtual ~strstreambuf(); 162 163 void swap(strstreambuf& __rhs); 164 165 void freeze(bool __freezefl = true); 166 char* str(); 167 int pcount() const; 168 169protected: 170 virtual int_type overflow (int_type __c = EOF); 171 virtual int_type pbackfail(int_type __c = EOF); 172 virtual int_type underflow(); 173 virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, 174 ios_base::openmode __which = ios_base::in | ios_base::out); 175 virtual pos_type seekpos(pos_type __sp, 176 ios_base::openmode __which = ios_base::in | ios_base::out); 177 178private: 179 typedef unsigned __mode_type; 180 static const __mode_type __allocated = 0x01; 181 static const __mode_type __constant = 0x02; 182 static const __mode_type __dynamic = 0x04; 183 static const __mode_type __frozen = 0x08; 184 static const streamsize __default_alsize = 4096; 185 186 __mode_type __strmode_; 187 streamsize __alsize_; 188 void* (*__palloc_)(size_t); 189 void (*__pfree_)(void*); 190 191 void __init(char* __gnext, streamsize __n, char* __pbeg); 192}; 193 194#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 195 196inline _LIBCPP_INLINE_VISIBILITY 197strstreambuf::strstreambuf(strstreambuf&& __rhs) 198 : streambuf(__rhs), 199 __strmode_(__rhs.__strmode_), 200 __alsize_(__rhs.__alsize_), 201 __palloc_(__rhs.__palloc_), 202 __pfree_(__rhs.__pfree_) 203{ 204 __rhs.setg(nullptr, nullptr, nullptr); 205 __rhs.setp(nullptr, nullptr); 206} 207 208inline _LIBCPP_INLINE_VISIBILITY 209strstreambuf& 210strstreambuf::operator=(strstreambuf&& __rhs) 211{ 212 if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0) 213 { 214 if (__pfree_) 215 __pfree_(eback()); 216 else 217 delete [] eback(); 218 } 219 streambuf::operator=(__rhs); 220 __strmode_ = __rhs.__strmode_; 221 __alsize_ = __rhs.__alsize_; 222 __palloc_ = __rhs.__palloc_; 223 __pfree_ = __rhs.__pfree_; 224 __rhs.setg(nullptr, nullptr, nullptr); 225 __rhs.setp(nullptr, nullptr); 226 return *this; 227} 228 229#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 230 231class _LIBCPP_TYPE_VIS istrstream 232 : public istream 233{ 234public: 235 _LIBCPP_INLINE_VISIBILITY 236 explicit istrstream(const char* __s) 237 : istream(&__sb_), __sb_(__s, 0) {} 238 _LIBCPP_INLINE_VISIBILITY 239 explicit istrstream(char* __s) 240 : istream(&__sb_), __sb_(__s, 0) {} 241 _LIBCPP_INLINE_VISIBILITY 242 istrstream(const char* __s, streamsize __n) 243 : istream(&__sb_), __sb_(__s, __n) {} 244 _LIBCPP_INLINE_VISIBILITY 245 istrstream(char* __s, streamsize __n) 246 : istream(&__sb_), __sb_(__s, __n) {} 247 248#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 249 _LIBCPP_INLINE_VISIBILITY 250 istrstream(istrstream&& __rhs) 251 : istream(_VSTD::move(__rhs)), 252 __sb_(_VSTD::move(__rhs.__sb_)) 253 { 254 istream::set_rdbuf(&__sb_); 255 } 256 257 _LIBCPP_INLINE_VISIBILITY 258 istrstream& operator=(istrstream&& __rhs) 259 { 260 istream::operator=(_VSTD::move(__rhs)); 261 __sb_ = _VSTD::move(__rhs.__sb_); 262 return *this; 263 } 264#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 265 266 virtual ~istrstream(); 267 268 _LIBCPP_INLINE_VISIBILITY 269 void swap(istrstream& __rhs) 270 { 271 istream::swap(__rhs); 272 __sb_.swap(__rhs.__sb_); 273 } 274 275 _LIBCPP_INLINE_VISIBILITY 276 strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);} 277 _LIBCPP_INLINE_VISIBILITY 278 char *str() {return __sb_.str();} 279 280private: 281 strstreambuf __sb_; 282}; 283 284class _LIBCPP_TYPE_VIS ostrstream 285 : public ostream 286{ 287public: 288 _LIBCPP_INLINE_VISIBILITY 289 ostrstream() 290 : ostream(&__sb_) {} 291 _LIBCPP_INLINE_VISIBILITY 292 ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out) 293 : ostream(&__sb_), 294 __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0)) 295 {} 296 297#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 298 _LIBCPP_INLINE_VISIBILITY 299 ostrstream(ostrstream&& __rhs) 300 : ostream(_VSTD::move(__rhs)), 301 __sb_(_VSTD::move(__rhs.__sb_)) 302 { 303 ostream::set_rdbuf(&__sb_); 304 } 305 306 _LIBCPP_INLINE_VISIBILITY 307 ostrstream& operator=(ostrstream&& __rhs) 308 { 309 ostream::operator=(_VSTD::move(__rhs)); 310 __sb_ = _VSTD::move(__rhs.__sb_); 311 return *this; 312 } 313#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 314 315 virtual ~ostrstream(); 316 317 _LIBCPP_INLINE_VISIBILITY 318 void swap(ostrstream& __rhs) 319 { 320 ostream::swap(__rhs); 321 __sb_.swap(__rhs.__sb_); 322 } 323 324 _LIBCPP_INLINE_VISIBILITY 325 strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);} 326 _LIBCPP_INLINE_VISIBILITY 327 void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);} 328 _LIBCPP_INLINE_VISIBILITY 329 char* str() {return __sb_.str();} 330 _LIBCPP_INLINE_VISIBILITY 331 int pcount() const {return __sb_.pcount();} 332 333private: 334 strstreambuf __sb_; // exposition only 335}; 336 337class _LIBCPP_TYPE_VIS strstream 338 : public iostream 339{ 340public: 341 // Types 342 typedef char char_type; 343 typedef char_traits<char>::int_type int_type; 344 typedef char_traits<char>::pos_type pos_type; 345 typedef char_traits<char>::off_type off_type; 346 347 // constructors/destructor 348 _LIBCPP_INLINE_VISIBILITY 349 strstream() 350 : iostream(&__sb_) {} 351 _LIBCPP_INLINE_VISIBILITY 352 strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out) 353 : iostream(&__sb_), 354 __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0)) 355 {} 356 357#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 358 _LIBCPP_INLINE_VISIBILITY 359 strstream(strstream&& __rhs) 360 : iostream(_VSTD::move(__rhs)), 361 __sb_(_VSTD::move(__rhs.__sb_)) 362 { 363 iostream::set_rdbuf(&__sb_); 364 } 365 366 _LIBCPP_INLINE_VISIBILITY 367 strstream& operator=(strstream&& __rhs) 368 { 369 iostream::operator=(_VSTD::move(__rhs)); 370 __sb_ = _VSTD::move(__rhs.__sb_); 371 return *this; 372 } 373#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 374 375 virtual ~strstream(); 376 377 _LIBCPP_INLINE_VISIBILITY 378 void swap(strstream& __rhs) 379 { 380 iostream::swap(__rhs); 381 __sb_.swap(__rhs.__sb_); 382 } 383 384 // Members: 385 _LIBCPP_INLINE_VISIBILITY 386 strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);} 387 _LIBCPP_INLINE_VISIBILITY 388 void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);} 389 _LIBCPP_INLINE_VISIBILITY 390 int pcount() const {return __sb_.pcount();} 391 _LIBCPP_INLINE_VISIBILITY 392 char* str() {return __sb_.str();} 393 394private: 395 strstreambuf __sb_; // exposition only 396}; 397 398_LIBCPP_END_NAMESPACE_STD 399 400#endif // _LIBCPP_STRSTREAM 401