libcxx initial import
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@103490 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/strstream b/include/strstream
new file mode 100644
index 0000000..50f639f
--- /dev/null
+++ b/include/strstream
@@ -0,0 +1,332 @@
+// -*- C++ -*-
+//===--------------------------- strstream --------------------------------===//
+//
+// ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊThe LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_STRSTREAM
+#define _LIBCPP_STRSTREAM
+
+/*
+ strstream synopsis
+
+class strstreambuf
+ : public basic_streambuf<char>
+{
+public:
+ explicit strstreambuf(streamsize alsize_arg = 0);
+ strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
+ strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0);
+ strstreambuf(const char* gnext_arg, streamsize n);
+
+ strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = 0);
+ strstreambuf(const signed char* gnext_arg, streamsize n);
+ strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = 0);
+ strstreambuf(const unsigned char* gnext_arg, streamsize n);
+
+ strstreambuf(strstreambuf&& rhs);
+ strstreambuf& operator=(strstreambuf&& rhs);
+
+ virtual ~strstreambuf();
+
+ void swap(strstreambuf& rhs);
+
+ void freeze(bool freezefl = true);
+ char* str();
+ int pcount() const;
+
+protected:
+ virtual int_type overflow (int_type c = EOF);
+ virtual int_type pbackfail(int_type c = EOF);
+ virtual int_type underflow();
+ virtual pos_type seekoff(off_type off, ios_base::seekdir way,
+ ios_base::openmode which = ios_base::in | ios_base::out);
+ virtual pos_type seekpos(pos_type sp,
+ ios_base::openmode which = ios_base::in | ios_base::out);
+ virtual streambuf* setbuf(char* s, streamsize n);
+
+private:
+ typedef T1 strstate; // exposition only
+ static const strstate allocated; // exposition only
+ static const strstate constant; // exposition only
+ static const strstate dynamic; // exposition only
+ static const strstate frozen; // exposition only
+ strstate strmode; // exposition only
+ streamsize alsize; // exposition only
+ void* (*palloc)(size_t); // exposition only
+ void (*pfree)(void*); // exposition only
+};
+
+class istrstream
+ : public basic_istream<char>
+{
+public:
+ explicit istrstream(const char* s);
+ explicit istrstream(char* s);
+ istrstream(const char* s, streamsize n);
+ istrstream(char* s, streamsize n);
+
+ virtual ~istrstream();
+
+ strstreambuf* rdbuf() const;
+ char *str();
+
+private:
+ strstreambuf sb; // exposition only
+};
+
+class ostrstream
+ : public basic_ostream<char>
+{
+public:
+ ostrstream();
+ ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out);
+
+ virtual ~ostrstream();
+
+ strstreambuf* rdbuf() const;
+ void freeze(bool freezefl = true);
+ char* str();
+ int pcount() const;
+
+private:
+ strstreambuf sb; // exposition only
+};
+
+class strstream
+ : public basic_iostream<char>
+{
+public:
+ // Types
+ typedef char char_type;
+ typedef char_traits<char>::int_type int_type;
+ typedef char_traits<char>::pos_type pos_type;
+ typedef char_traits<char>::off_type off_type;
+
+ // constructors/destructor
+ strstream();
+ strstream(char* s, int n, ios_base::openmode mode = ios_base::in | ios_base::out);
+
+ virtual ~strstream();
+
+ // Members:
+ strstreambuf* rdbuf() const;
+ void freeze(bool freezefl = true);
+ int pcount() const;
+ char* str();
+
+private:
+ strstreambuf sb; // exposition only
+};
+
+} // std
+
+*/
+
+#include <__config>
+#include <ostream>
+#include <istream>
+
+#pragma GCC system_header
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class strstreambuf
+ : public streambuf
+{
+public:
+ explicit strstreambuf(streamsize __alsize = 0);
+ strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
+ strstreambuf(char* __gnext, streamsize __n, char* __pbeg = 0);
+ strstreambuf(const char* __gnext, streamsize __n);
+
+ strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = 0);
+ strstreambuf(const signed char* __gnext, streamsize __n);
+ strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = 0);
+ strstreambuf(const unsigned char* __gnext, streamsize __n);
+
+#ifdef _LIBCPP_MOVE
+ strstreambuf(strstreambuf&& __rhs);
+ strstreambuf& operator=(strstreambuf&& __rhs);
+#endif
+
+ virtual ~strstreambuf();
+
+ void swap(strstreambuf& __rhs);
+
+ void freeze(bool __freezefl = true);
+ char* str();
+ int pcount() const;
+
+protected:
+ virtual int_type overflow (int_type __c = EOF);
+ virtual int_type pbackfail(int_type __c = EOF);
+ virtual int_type underflow();
+ virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
+ ios_base::openmode __which = ios_base::in | ios_base::out);
+ virtual pos_type seekpos(pos_type __sp,
+ ios_base::openmode __which = ios_base::in | ios_base::out);
+
+private:
+ typedef unsigned __mode_type;
+ static const __mode_type __allocated = 0x01;
+ static const __mode_type __constant = 0x02;
+ static const __mode_type __dynamic = 0x04;
+ static const __mode_type __frozen = 0x08;
+ static const streamsize __default_alsize = 4096;
+
+ __mode_type __strmode_;
+ streamsize __alsize_;
+ void* (*__palloc_)(size_t);
+ void (*__pfree_)(void*);
+
+ void __init(char* __gnext, streamsize __n, char* __pbeg);
+};
+
+class istrstream
+ : public istream
+{
+public:
+ explicit istrstream(const char* __s)
+ : istream(&__sb_), __sb_(__s, 0) {}
+ explicit istrstream(char* __s)
+ : istream(&__sb_), __sb_(__s, 0) {}
+ istrstream(const char* __s, streamsize __n)
+ : istream(&__sb_), __sb_(__s, __n) {}
+ istrstream(char* __s, streamsize __n)
+ : istream(&__sb_), __sb_(__s, __n) {}
+
+#ifdef _LIBCPP_MOVE
+ istrstream(istrstream&& __rhs)
+ : istream(_STD::move(__rhs)),
+ __sb_(_STD::move(__rhs.__sb_))
+ {
+ istream::set_rdbuf(&__sb_);
+ }
+
+ istrstream& operator=(istrstream&& __rhs)
+ {
+ istream::operator=(_STD::move(__rhs));
+ __sb_ = _STD::move(__rhs.__sb_);
+ return *this;
+ }
+#endif
+
+ virtual ~istrstream();
+
+ void swap(istrstream& __rhs)
+ {
+ istream::swap(__rhs);
+ __sb_.swap(__rhs.__sb_);
+ }
+
+ strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
+ char *str() {return __sb_.str();}
+
+private:
+ strstreambuf __sb_;
+};
+
+class ostrstream
+ : public ostream
+{
+public:
+ ostrstream()
+ : ostream(&__sb_) {}
+ ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
+ : ostream(&__sb_),
+ __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
+ {}
+
+#ifdef _LIBCPP_MOVE
+ ostrstream(ostrstream&& __rhs)
+ : ostream(_STD::move(__rhs)),
+ __sb_(_STD::move(__rhs.__sb_))
+ {
+ ostream::set_rdbuf(&__sb_);
+ }
+
+ ostrstream& operator=(ostrstream&& __rhs)
+ {
+ ostream::operator=(_STD::move(__rhs));
+ __sb_ = _STD::move(__rhs.__sb_);
+ return *this;
+ }
+#endif
+
+ virtual ~ostrstream();
+
+ void swap(ostrstream& __rhs)
+ {
+ ostream::swap(__rhs);
+ __sb_.swap(__rhs.__sb_);
+ }
+
+ strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
+ void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
+ char* str() {return __sb_.str();}
+ int pcount() const {return __sb_.pcount();}
+
+private:
+ strstreambuf __sb_; // exposition only
+};
+
+class strstream
+ : public iostream
+{
+public:
+ // Types
+ typedef char char_type;
+ typedef char_traits<char>::int_type int_type;
+ typedef char_traits<char>::pos_type pos_type;
+ typedef char_traits<char>::off_type off_type;
+
+ // constructors/destructor
+ strstream()
+ : iostream(&__sb_) {}
+ strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
+ : iostream(&__sb_),
+ __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
+ {}
+
+#ifdef _LIBCPP_MOVE
+ strstream(strstream&& __rhs)
+ : iostream(_STD::move(__rhs)),
+ __sb_(_STD::move(__rhs.__sb_))
+ {
+ iostream::set_rdbuf(&__sb_);
+ }
+
+ strstream& operator=(strstream&& __rhs)
+ {
+ iostream::operator=(_STD::move(__rhs));
+ __sb_ = _STD::move(__rhs.__sb_);
+ return *this;
+ }
+#endif
+
+ virtual ~strstream();
+
+ void swap(strstream& __rhs)
+ {
+ iostream::swap(__rhs);
+ __sb_.swap(__rhs.__sb_);
+ }
+
+ // Members:
+ strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
+ void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
+ int pcount() const {return __sb_.pcount();}
+ char* str() {return __sb_.str();}
+
+private:
+ strstreambuf __sb_; // exposition only
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STRSTREAM