mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-16 01:06:32 +00:00
4090910a69
There were some remaining headers that were not guarded with _LIBCPP_HAS_LOCALIZATION, leading to errors when trying to use modules on platforms that don't support localization (since all the headers get pulled in when building the 'std' module). This patch brings these headers in line with what we do for every other header that depends on localization. This patch also requires including <picolibc.h> from <__configuration/platform.h> in order to define _NEWLIB_VERSION. In the long term, we should use a better approach for doing that, such as defining a macro in the __config_site header.
364 lines
12 KiB
C++
364 lines
12 KiB
C++
// -*- C++ -*-
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP_STRSTREAM
|
|
#define _LIBCPP_STRSTREAM
|
|
|
|
/*
|
|
strstream synopsis
|
|
|
|
class strstreambuf // Removed in C++26
|
|
: public basic_streambuf<char>
|
|
{
|
|
public:
|
|
explicit strstreambuf(streamsize alsize_arg = 0); // before C++20
|
|
strstreambuf() : strstreambuf(0) {} // C++20
|
|
explicit strstreambuf(streamsize alsize_arg); // C++20
|
|
|
|
strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
|
|
strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = nullptr);
|
|
strstreambuf(const char* gnext_arg, streamsize n);
|
|
|
|
strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = nullptr);
|
|
strstreambuf(const signed char* gnext_arg, streamsize n);
|
|
strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = nullptr);
|
|
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 // Removed in C++26
|
|
: 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 // Removed in C++26
|
|
: 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 // Removed in C++26
|
|
: 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
|
|
|
|
*/
|
|
|
|
#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
|
|
# include <__cxx03/strstream>
|
|
#else
|
|
# include <__config>
|
|
|
|
# if _LIBCPP_HAS_LOCALIZATION
|
|
|
|
# include <__ostream/basic_ostream.h>
|
|
# include <istream>
|
|
# include <streambuf>
|
|
# include <version>
|
|
|
|
# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
# pragma GCC system_header
|
|
# endif
|
|
|
|
# if _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) || defined(_LIBCPP_BUILDING_LIBRARY)
|
|
|
|
_LIBCPP_PUSH_MACROS
|
|
# include <__undef_macros>
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstreambuf : public streambuf {
|
|
public:
|
|
# ifndef _LIBCPP_CXX03_LANG
|
|
_LIBCPP_HIDE_FROM_ABI strstreambuf() : strstreambuf(0) {}
|
|
explicit strstreambuf(streamsize __alsize);
|
|
# else
|
|
explicit strstreambuf(streamsize __alsize = 0);
|
|
# endif
|
|
strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
|
|
strstreambuf(char* __gnext, streamsize __n, char* __pbeg = nullptr);
|
|
strstreambuf(const char* __gnext, streamsize __n);
|
|
|
|
strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = nullptr);
|
|
strstreambuf(const signed char* __gnext, streamsize __n);
|
|
strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = nullptr);
|
|
strstreambuf(const unsigned char* __gnext, streamsize __n);
|
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
|
_LIBCPP_HIDE_FROM_ABI strstreambuf(strstreambuf&& __rhs);
|
|
_LIBCPP_HIDE_FROM_ABI strstreambuf& operator=(strstreambuf&& __rhs);
|
|
# endif // _LIBCPP_CXX03_LANG
|
|
|
|
~strstreambuf() override;
|
|
|
|
void swap(strstreambuf& __rhs);
|
|
|
|
void freeze(bool __freezefl = true);
|
|
char* str();
|
|
int pcount() const;
|
|
|
|
protected:
|
|
int_type overflow(int_type __c = EOF) override;
|
|
int_type pbackfail(int_type __c = EOF) override;
|
|
int_type underflow() override;
|
|
pos_type
|
|
seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out) override;
|
|
pos_type seekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out) override;
|
|
|
|
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);
|
|
};
|
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI strstreambuf::strstreambuf(strstreambuf&& __rhs)
|
|
: streambuf(__rhs),
|
|
__strmode_(__rhs.__strmode_),
|
|
__alsize_(__rhs.__alsize_),
|
|
__palloc_(__rhs.__palloc_),
|
|
__pfree_(__rhs.__pfree_) {
|
|
__rhs.setg(nullptr, nullptr, nullptr);
|
|
__rhs.setp(nullptr, nullptr);
|
|
}
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI strstreambuf& strstreambuf::operator=(strstreambuf&& __rhs) {
|
|
if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0) {
|
|
if (__pfree_)
|
|
__pfree_(eback());
|
|
else
|
|
delete[] eback();
|
|
}
|
|
streambuf::operator=(__rhs);
|
|
__strmode_ = __rhs.__strmode_;
|
|
__alsize_ = __rhs.__alsize_;
|
|
__palloc_ = __rhs.__palloc_;
|
|
__pfree_ = __rhs.__pfree_;
|
|
__rhs.setg(nullptr, nullptr, nullptr);
|
|
__rhs.setp(nullptr, nullptr);
|
|
return *this;
|
|
}
|
|
|
|
# endif // _LIBCPP_CXX03_LANG
|
|
|
|
class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI istrstream : public istream {
|
|
public:
|
|
_LIBCPP_HIDE_FROM_ABI explicit istrstream(const char* __s) : istream(&__sb_), __sb_(__s, 0) {}
|
|
_LIBCPP_HIDE_FROM_ABI explicit istrstream(char* __s) : istream(&__sb_), __sb_(__s, 0) {}
|
|
_LIBCPP_HIDE_FROM_ABI istrstream(const char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}
|
|
_LIBCPP_HIDE_FROM_ABI istrstream(char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}
|
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
|
_LIBCPP_HIDE_FROM_ABI istrstream(istrstream&& __rhs) // extension
|
|
: istream(std::move(static_cast<istream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
|
|
istream::set_rdbuf(&__sb_);
|
|
}
|
|
|
|
_LIBCPP_HIDE_FROM_ABI istrstream& operator=(istrstream&& __rhs) {
|
|
__sb_ = std::move(__rhs.__sb_);
|
|
istream::operator=(std::move(__rhs));
|
|
return *this;
|
|
}
|
|
# endif // _LIBCPP_CXX03_LANG
|
|
|
|
~istrstream() override;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void swap(istrstream& __rhs) {
|
|
istream::swap(__rhs);
|
|
__sb_.swap(__rhs.__sb_);
|
|
}
|
|
|
|
_LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
|
|
_LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
|
|
|
|
private:
|
|
strstreambuf __sb_;
|
|
};
|
|
|
|
class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI ostrstream : public ostream {
|
|
public:
|
|
_LIBCPP_HIDE_FROM_ABI ostrstream() : ostream(&__sb_) {}
|
|
_LIBCPP_HIDE_FROM_ABI ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
|
|
: ostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}
|
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
|
_LIBCPP_HIDE_FROM_ABI ostrstream(ostrstream&& __rhs) // extension
|
|
: ostream(std::move(static_cast<ostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
|
|
ostream::set_rdbuf(&__sb_);
|
|
}
|
|
|
|
_LIBCPP_HIDE_FROM_ABI ostrstream& operator=(ostrstream&& __rhs) {
|
|
__sb_ = std::move(__rhs.__sb_);
|
|
ostream::operator=(std::move(__rhs));
|
|
return *this;
|
|
}
|
|
# endif // _LIBCPP_CXX03_LANG
|
|
|
|
~ostrstream() override;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void swap(ostrstream& __rhs) {
|
|
ostream::swap(__rhs);
|
|
__sb_.swap(__rhs.__sb_);
|
|
}
|
|
|
|
_LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
|
|
_LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
|
|
_LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
|
|
_LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
|
|
|
|
private:
|
|
strstreambuf __sb_; // exposition only
|
|
};
|
|
|
|
class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI 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
|
|
_LIBCPP_HIDE_FROM_ABI strstream() : iostream(&__sb_) {}
|
|
_LIBCPP_HIDE_FROM_ABI strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
|
|
: iostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}
|
|
|
|
# ifndef _LIBCPP_CXX03_LANG
|
|
_LIBCPP_HIDE_FROM_ABI strstream(strstream&& __rhs) // extension
|
|
: iostream(std::move(static_cast<iostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
|
|
iostream::set_rdbuf(&__sb_);
|
|
}
|
|
|
|
_LIBCPP_HIDE_FROM_ABI strstream& operator=(strstream&& __rhs) {
|
|
__sb_ = std::move(__rhs.__sb_);
|
|
iostream::operator=(std::move(__rhs));
|
|
return *this;
|
|
}
|
|
# endif // _LIBCPP_CXX03_LANG
|
|
|
|
~strstream() override;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI void swap(strstream& __rhs) {
|
|
iostream::swap(__rhs);
|
|
__sb_.swap(__rhs.__sb_);
|
|
}
|
|
|
|
// Members:
|
|
_LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
|
|
_LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
|
|
_LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
|
|
_LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
|
|
|
|
private:
|
|
strstreambuf __sb_; // exposition only
|
|
};
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
_LIBCPP_POP_MACROS
|
|
|
|
# endif // _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) ||
|
|
// defined(_LIBCPP_BUILDING_LIBRARY)
|
|
|
|
# endif // _LIBCPP_HAS_LOCALIZATION
|
|
|
|
#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
|
|
|
|
#endif // _LIBCPP_STRSTREAM
|