maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libcxx/include/fstream

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1775 lines
54 KiB
Plaintext
Raw Normal View History

libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
// -*- C++ -*-
//===------------------------- fstream ------------------------------------===//
//
Update more file headers across all of the LLVM projects in the monorepo to reflect the new license. These used slightly different spellings that defeated my regular expressions. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351648
2019-01-19 18:56:40 +08:00
// 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
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_FSTREAM
#define _LIBCPP_FSTREAM
/*
fstream synopsis
template <class charT, class traits = char_traits<charT> >
class basic_filebuf
: public basic_streambuf<charT, traits>
{
public:
typedef charT char_type;
typedef traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
// 27.9.1.2 Constructors/destructor:
basic_filebuf();
basic_filebuf(basic_filebuf&& rhs);
virtual ~basic_filebuf();
// 27.9.1.3 Assign/swap:
basic_filebuf& operator=(basic_filebuf&& rhs);
void swap(basic_filebuf& rhs);
// 27.9.1.4 Members:
bool is_open() const;
basic_filebuf* open(const char* s, ios_base::openmode mode);
basic_filebuf* open(const string& s, ios_base::openmode mode);
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
basic_filebuf* open(const filesystem::path& p, ios_base::openmode mode); // C++17
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf* close();
protected:
// 27.9.1.5 Overridden virtual functions:
virtual streamsize showmanyc();
virtual int_type underflow();
virtual int_type uflow();
virtual int_type pbackfail(int_type c = traits_type::eof());
virtual int_type overflow (int_type c = traits_type::eof());
virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* s, streamsize n);
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 int sync();
virtual void imbue(const locale& loc);
};
template <class charT, class traits>
void
swap(basic_filebuf<charT, traits>& x, basic_filebuf<charT, traits>& y);
typedef basic_filebuf<char> filebuf;
typedef basic_filebuf<wchar_t> wfilebuf;
template <class charT, class traits = char_traits<charT> >
class basic_ifstream
: public basic_istream<charT,traits>
{
public:
typedef charT char_type;
typedef traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
basic_ifstream();
explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in);
explicit basic_ifstream(const string& s, ios_base::openmode mode = ios_base::in);
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
explicit basic_ifstream(const filesystem::path& p,
ios_base::openmode mode = ios_base::in); // C++17
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ifstream(basic_ifstream&& rhs);
basic_ifstream& operator=(basic_ifstream&& rhs);
void swap(basic_ifstream& rhs);
basic_filebuf<char_type, traits_type>* rdbuf() const;
bool is_open() const;
void open(const char* s, ios_base::openmode mode = ios_base::in);
void open(const string& s, ios_base::openmode mode = ios_base::in);
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
void open(const filesystem::path& s, ios_base::openmode mode = ios_base::in); // C++17
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void close();
};
template <class charT, class traits>
void
swap(basic_ifstream<charT, traits>& x, basic_ifstream<charT, traits>& y);
typedef basic_ifstream<char> ifstream;
typedef basic_ifstream<wchar_t> wifstream;
template <class charT, class traits = char_traits<charT> >
class basic_ofstream
: public basic_ostream<charT,traits>
{
public:
typedef charT char_type;
typedef traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
basic_ofstream();
explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out);
explicit basic_ofstream(const string& s, ios_base::openmode mode = ios_base::out);
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
explicit basic_ofstream(const filesystem::path& p,
ios_base::openmode mode = ios_base::out); // C++17
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ofstream(basic_ofstream&& rhs);
basic_ofstream& operator=(basic_ofstream&& rhs);
void swap(basic_ofstream& rhs);
basic_filebuf<char_type, traits_type>* rdbuf() const;
bool is_open() const;
void open(const char* s, ios_base::openmode mode = ios_base::out);
void open(const string& s, ios_base::openmode mode = ios_base::out);
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
void open(const filesystem::path& p,
ios_base::openmode mode = ios_base::out); // C++17
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void close();
};
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
template <class charT, class traits>
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void
swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y);
typedef basic_ofstream<char> ofstream;
typedef basic_ofstream<wchar_t> wofstream;
template <class charT, class traits=char_traits<charT> >
class basic_fstream
: public basic_iostream<charT,traits>
{
public:
typedef charT char_type;
typedef traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
basic_fstream();
explicit basic_fstream(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out);
explicit basic_fstream(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out);
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
explicit basic_fstream(const filesystem::path& p,
ios_base::openmode mode = ios_base::in|ios_base::out); C++17
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_fstream(basic_fstream&& rhs);
basic_fstream& operator=(basic_fstream&& rhs);
void swap(basic_fstream& rhs);
basic_filebuf<char_type, traits_type>* rdbuf() const;
bool is_open() const;
void open(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out);
void open(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out);
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
void open(const filesystem::path& s,
ios_base::openmode mode = ios_base::in|ios_base::out); // C++17
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void close();
};
template <class charT, class traits>
void swap(basic_fstream<charT, traits>& x, basic_fstream<charT, traits>& y);
typedef basic_fstream<char> fstream;
typedef basic_fstream<wchar_t> wfstream;
} // std
*/
#include <__config>
[libc++] Rework the whole availability markup implementation Currently, vendor-specific availability markup is enabled by default. This means that even when building against trunk libc++, the headers will by default prevent you from using some features that were not released in the dylib on your target platform. This is a source of frustration since people building libc++ from sources are usually not trying to use some vendor's released dylib. For that reason, I've been thinking for a long time that availability annotations should be off by default, which is the primary change that this commit enables. In addition, it reworks the implementation to make it easier for new vendors to add availability annotations for their platform, and it refreshes the documentation to reflect the current state of the codebase. Finally, a CMake configuration option is added to control whether availability annotations should be turned on for the flavor of libc++ being created. The intent is for vendors like Apple to turn it on, and for the upstream libc++ to leave it off (the default). Differential Revision: https://reviews.llvm.org/D90843
2020-11-05 04:01:25 +08:00
#include <__availability>
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
#include <ostream>
#include <istream>
#include <__locale>
#include <cstdio>
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
#include <cstdlib>
[libc++] Make LIBCXX_ENABLE_FILESYSTEM fully consistent Previously, LIBCXX_ENABLE_FILESYSTEM controlled only whether the filesystem support was compiled into libc++'s library. This commit promotes the setting to a first-class option like LIBCXX_ENABLE_LOCALIZATION, where the whole library is aware of the setting and features that depend on <filesystem> won't be provided at all. The test suite is also properly annotated such that tests that depend on <filesystem> are disabled when the library doesn't support it. This is an alternative to https://llvm.org/D94824, but also an improvement along the lines of LIBCXX_ENABLE_LOCALIZATION that I had been wanting to make for a while. Differential Revision: https://reviews.llvm.org/D94921
2021-01-19 01:18:18 +08:00
#if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
# include <filesystem>
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
Windows support by Ruben Van Boxem. llvm-svn: 142235
2011-10-18 04:05:10 +08:00
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
#pragma GCC system_header
Windows support by Ruben Van Boxem. llvm-svn: 142235
2011-10-18 04:05:10 +08:00
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
[Libc++] Use #pragma push_macro/pop_macro to better handle min/max on Windows Summary: This patch improves how libc++ handles min/max macros within the headers. Previously libc++ would undef them and emit a warning. This patch changes libc++ to use `#pragma push_macro` to save the macro before undefining it, and `#pragma pop_macro` to restore the macros and the end of the header. Reviewers: mclow.lists, bcraig, compnerd, EricWF Reviewed By: EricWF Subscribers: cfe-commits, krytarowski Differential Revision: https://reviews.llvm.org/D33080 llvm-svn: 304357
2017-06-01 06:07:49 +08:00
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _CharT, class _Traits>
[NFC] Rename _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS The name _LIBCPP_TYPE_VIS_ONLY is no longer accurate because both _LIBCPP_TYPE_VIS and _LIBCPP_TYPE_VIS_ONLY expand to __attribute__((__type_visibility__)) with Clang. The only remaining difference is that _LIBCPP_TYPE_VIS_ONLY can be applied to templates whereas _LIBCPP_TYPE_VIS cannot (due to dllimport/dllexport not being allowed on templates). This patch renames _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS. llvm-svn: 291035
2017-01-05 07:56:00 +08:00
class _LIBCPP_TEMPLATE_VIS basic_filebuf
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
: public basic_streambuf<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef typename traits_type::state_type state_type;
// 27.9.1.2 Constructors/destructor:
basic_filebuf();
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#ifndef _LIBCPP_CXX03_LANG
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf(basic_filebuf&& __rhs);
#endif
virtual ~basic_filebuf();
// 27.9.1.3 Assign/swap:
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#ifndef _LIBCPP_CXX03_LANG
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf& operator=(basic_filebuf&& __rhs);
#endif
void swap(basic_filebuf& __rhs);
// 27.9.1.4 Members:
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
bool is_open() const;
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf* open(const char* __s, ios_base::openmode __mode);
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode);
#endif
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf* open(const string& __s, ios_base::openmode __mode);
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
[libc++] Make LIBCXX_ENABLE_FILESYSTEM fully consistent Previously, LIBCXX_ENABLE_FILESYSTEM controlled only whether the filesystem support was compiled into libc++'s library. This commit promotes the setting to a first-class option like LIBCXX_ENABLE_LOCALIZATION, where the whole library is aware of the setting and features that depend on <filesystem> won't be provided at all. The test suite is also properly annotated such that tests that depend on <filesystem> are disabled when the library doesn't support it. This is an alternative to https://llvm.org/D94824, but also an improvement along the lines of LIBCXX_ENABLE_LOCALIZATION that I had been wanting to make for a while. Differential Revision: https://reviews.llvm.org/D94921
2021-01-19 01:18:18 +08:00
#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
[libc++] Mark <filesystem> tests as failing when the dylib doesn't support filesystem This fixes CI for back-deployment testers on platforms that don't have <filesystem> support in the dylib. This is effectively half of https://reviews.llvm.org/D59224. The other half requires fixes in Clang. llvm-svn: 356558
2019-03-20 22:34:00 +08:00
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
basic_filebuf* open(const _VSTD_FS::path& __p, ios_base::openmode __mode) {
return open(__p.c_str(), __mode);
}
#endif
[libc++] Instantiate additional <iostream> members in the dylib This commit adds new explicit instantiations for some classes in <iostream> in the library. This is done after noticing that many programs that use streams end up containing weak definitions of these classes, which has a negative impact on both code size and load times (due to the need to resolve weak symbols at load time). Note that we are just adding the additional explicit instantiations for the `char` specializations, since the `wchar_t` specializations are not used as often, and as a result there wouldn't be a clear benefit. This change is not an ABI break, since we are just adding additional symbols. Differential Revision: https://reviews.llvm.org/D90677
2020-10-21 23:11:45 +08:00
inline _LIBCPP_INLINE_VISIBILITY
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
basic_filebuf* __open(int __fd, ios_base::openmode __mode);
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf* close();
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
_LIBCPP_INLINE_VISIBILITY
inline static const char*
__make_mdstring(ios_base::openmode __mode) _NOEXCEPT;
protected:
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
// 27.9.1.5 Overridden virtual functions:
virtual int_type underflow();
virtual int_type pbackfail(int_type __c = traits_type::eof());
virtual int_type overflow (int_type __c = traits_type::eof());
virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n);
virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __wch = ios_base::in | ios_base::out);
virtual pos_type seekpos(pos_type __sp,
ios_base::openmode __wch = ios_base::in | ios_base::out);
virtual int sync();
virtual void imbue(const locale& __loc);
private:
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
char* __extbuf_;
const char* __extbufnext_;
const char* __extbufend_;
char __extbuf_min_[8];
size_t __ebs_;
char_type* __intbuf_;
size_t __ibs_;
FILE* __file_;
const codecvt<char_type, char, state_type>* __cv_;
state_type __st_;
state_type __st_last_;
ios_base::openmode __om_;
ios_base::openmode __cm_;
bool __owns_eb_;
bool __owns_ib_;
bool __always_noconv_;
bool __read_mode();
void __write_mode();
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
};
template <class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>::basic_filebuf()
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
: __extbuf_(nullptr),
__extbufnext_(nullptr),
__extbufend_(nullptr),
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__ebs_(0),
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__intbuf_(nullptr),
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__ibs_(0),
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__file_(nullptr),
basic_filebuf needs to delay obtaining a codecvt facet from the global locale to give the client a chance to imbue the proper locale. Fixes http://llvm.org/bugs/show_bug.cgi?id=13663. llvm-svn: 162567
2012-08-25 00:52:47 +08:00
__cv_(nullptr),
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__st_(),
Hyeon-Bin Jeong: 1. sync() should reset it’s external buffer pointers. Remaining characters should be discarded once sync() called. If don’t, garbage characters can be inserted to the front of external buffer in underflow(). Because underflow() copies remaining characters in external buffer to it’s front. This results wrong characters insertion when seekpos() or seekoff() is called. this line should be inserted in sync() just before return: __extbufnext_ = __extbufend_ = __extbuf_; 2. sync() should use length() rather than out() to calculate offset. Reversing iterators and calling out() to calculate offset from behind is working fine in stateless character encoding. However, in stateful encoding, escape sequences could differ in length. As a result, out() could return wrong length. For example, if we have internal buffer converted from this external sequence: (capital letters mean escape sequence) … a a a a B b b b b out() produces this sequence. b b b b A a a a a Because out() inserts escape sequence A rather than B, result sequence doesn't match to external sequence. A and B could have different lengths, result offset could be wrong value too. length() method in codecvt is right for calculating offset, but it counts offset from the beginning of buffer. So it requires another state member variable to hold state before conversion. Fixes http://llvm.org/bugs/show_bug.cgi?id=13667 llvm-svn: 162601
2012-08-25 05:20:56 +08:00
__st_last_(),
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__om_(0),
__cm_(0),
__owns_eb_(false),
__owns_ib_(false),
basic_filebuf needs to delay obtaining a codecvt facet from the global locale to give the client a chance to imbue the proper locale. Fixes http://llvm.org/bugs/show_bug.cgi?id=13663. llvm-svn: 162567
2012-08-25 00:52:47 +08:00
__always_noconv_(false)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
{
basic_filebuf needs to delay obtaining a codecvt facet from the global locale to give the client a chance to imbue the proper locale. Fixes http://llvm.org/bugs/show_bug.cgi?id=13663. llvm-svn: 162567
2012-08-25 00:52:47 +08:00
if (has_facet<codecvt<char_type, char, state_type> >(this->getloc()))
{
__cv_ = &use_facet<codecvt<char_type, char, state_type> >(this->getloc());
__always_noconv_ = __cv_->always_noconv();
}
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
setbuf(nullptr, 4096);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#ifndef _LIBCPP_CXX03_LANG
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
: basic_streambuf<_CharT, _Traits>(__rhs)
{
if (__rhs.__extbuf_ == __rhs.__extbuf_min_)
{
__extbuf_ = __extbuf_min_;
__extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_);
__extbufend_ = __extbuf_ + (__rhs.__extbufend_ - __rhs.__extbuf_);
}
else
{
__extbuf_ = __rhs.__extbuf_;
__extbufnext_ = __rhs.__extbufnext_;
__extbufend_ = __rhs.__extbufend_;
}
__ebs_ = __rhs.__ebs_;
__intbuf_ = __rhs.__intbuf_;
__ibs_ = __rhs.__ibs_;
__file_ = __rhs.__file_;
__cv_ = __rhs.__cv_;
__st_ = __rhs.__st_;
Hyeon-Bin Jeong: 1. sync() should reset it’s external buffer pointers. Remaining characters should be discarded once sync() called. If don’t, garbage characters can be inserted to the front of external buffer in underflow(). Because underflow() copies remaining characters in external buffer to it’s front. This results wrong characters insertion when seekpos() or seekoff() is called. this line should be inserted in sync() just before return: __extbufnext_ = __extbufend_ = __extbuf_; 2. sync() should use length() rather than out() to calculate offset. Reversing iterators and calling out() to calculate offset from behind is working fine in stateless character encoding. However, in stateful encoding, escape sequences could differ in length. As a result, out() could return wrong length. For example, if we have internal buffer converted from this external sequence: (capital letters mean escape sequence) … a a a a B b b b b out() produces this sequence. b b b b A a a a a Because out() inserts escape sequence A rather than B, result sequence doesn't match to external sequence. A and B could have different lengths, result offset could be wrong value too. length() method in codecvt is right for calculating offset, but it counts offset from the beginning of buffer. So it requires another state member variable to hold state before conversion. Fixes http://llvm.org/bugs/show_bug.cgi?id=13667 llvm-svn: 162601
2012-08-25 05:20:56 +08:00
__st_last_ = __rhs.__st_last_;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__om_ = __rhs.__om_;
__cm_ = __rhs.__cm_;
__owns_eb_ = __rhs.__owns_eb_;
__owns_ib_ = __rhs.__owns_ib_;
__always_noconv_ = __rhs.__always_noconv_;
if (__rhs.pbase())
{
if (__rhs.pbase() == __rhs.__intbuf_)
this->setp(__intbuf_, __intbuf_ + (__rhs. epptr() - __rhs.pbase()));
else
this->setp((char_type*)__extbuf_,
(char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase()));
Make pbump (internally) handle sizes bigger than MAX_INT. Fixes PR#33725 - thanks to Jonathan Wakely for the report llvm-svn: 313031
2017-09-12 23:00:43 +08:00
this->__pbump(__rhs. pptr() - __rhs.pbase());
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
else if (__rhs.eback())
{
if (__rhs.eback() == __rhs.__intbuf_)
this->setg(__intbuf_, __intbuf_ + (__rhs.gptr() - __rhs.eback()),
__intbuf_ + (__rhs.egptr() - __rhs.eback()));
else
this->setg((char_type*)__extbuf_,
(char_type*)__extbuf_ + (__rhs.gptr() - __rhs.eback()),
(char_type*)__extbuf_ + (__rhs.egptr() - __rhs.eback()));
}
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__rhs.__extbuf_ = nullptr;
__rhs.__extbufnext_ = nullptr;
__rhs.__extbufend_ = nullptr;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__rhs.__ebs_ = 0;
__rhs.__intbuf_ = 0;
__rhs.__ibs_ = 0;
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__rhs.__file_ = nullptr;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__rhs.__st_ = state_type();
Hyeon-Bin Jeong: 1. sync() should reset it’s external buffer pointers. Remaining characters should be discarded once sync() called. If don’t, garbage characters can be inserted to the front of external buffer in underflow(). Because underflow() copies remaining characters in external buffer to it’s front. This results wrong characters insertion when seekpos() or seekoff() is called. this line should be inserted in sync() just before return: __extbufnext_ = __extbufend_ = __extbuf_; 2. sync() should use length() rather than out() to calculate offset. Reversing iterators and calling out() to calculate offset from behind is working fine in stateless character encoding. However, in stateful encoding, escape sequences could differ in length. As a result, out() could return wrong length. For example, if we have internal buffer converted from this external sequence: (capital letters mean escape sequence) … a a a a B b b b b out() produces this sequence. b b b b A a a a a Because out() inserts escape sequence A rather than B, result sequence doesn't match to external sequence. A and B could have different lengths, result offset could be wrong value too. length() method in codecvt is right for calculating offset, but it counts offset from the beginning of buffer. So it requires another state member variable to hold state before conversion. Fixes http://llvm.org/bugs/show_bug.cgi?id=13667 llvm-svn: 162601
2012-08-25 05:20:56 +08:00
__rhs.__st_last_ = state_type();
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__rhs.__om_ = 0;
__rhs.__cm_ = 0;
__rhs.__owns_eb_ = false;
__rhs.__owns_ib_ = false;
__rhs.setg(0, 0, 0);
__rhs.setp(0, 0);
}
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf<_CharT, _Traits>&
basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs)
{
close();
swap(__rhs);
Don't neglect to "return *this". llvm-svn: 165860
2012-10-13 10:03:45 +08:00
return *this;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#endif // _LIBCPP_CXX03_LANG
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>::~basic_filebuf()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
close();
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
}
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (__owns_eb_)
delete [] __extbuf_;
if (__owns_ib_)
delete [] __intbuf_;
}
template <class _CharT, class _Traits>
void
basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs)
{
basic_streambuf<char_type, traits_type>::swap(__rhs);
if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
_VSTD::swap(__extbuf_, __rhs.__extbuf_);
_VSTD::swap(__extbufnext_, __rhs.__extbufnext_);
_VSTD::swap(__extbufend_, __rhs.__extbufend_);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
else
{
ptrdiff_t __ln = __extbufnext_ - __extbuf_;
ptrdiff_t __le = __extbufend_ - __extbuf_;
ptrdiff_t __rn = __rhs.__extbufnext_ - __rhs.__extbuf_;
ptrdiff_t __re = __rhs.__extbufend_ - __rhs.__extbuf_;
if (__extbuf_ == __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_)
{
__extbuf_ = __rhs.__extbuf_;
__rhs.__extbuf_ = __rhs.__extbuf_min_;
}
else if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ == __rhs.__extbuf_min_)
{
__rhs.__extbuf_ = __extbuf_;
__extbuf_ = __extbuf_min_;
}
__extbufnext_ = __extbuf_ + __rn;
__extbufend_ = __extbuf_ + __re;
__rhs.__extbufnext_ = __rhs.__extbuf_ + __ln;
__rhs.__extbufend_ = __rhs.__extbuf_ + __le;
}
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
_VSTD::swap(__ebs_, __rhs.__ebs_);
_VSTD::swap(__intbuf_, __rhs.__intbuf_);
_VSTD::swap(__ibs_, __rhs.__ibs_);
_VSTD::swap(__file_, __rhs.__file_);
_VSTD::swap(__cv_, __rhs.__cv_);
_VSTD::swap(__st_, __rhs.__st_);
Hyeon-Bin Jeong: 1. sync() should reset it’s external buffer pointers. Remaining characters should be discarded once sync() called. If don’t, garbage characters can be inserted to the front of external buffer in underflow(). Because underflow() copies remaining characters in external buffer to it’s front. This results wrong characters insertion when seekpos() or seekoff() is called. this line should be inserted in sync() just before return: __extbufnext_ = __extbufend_ = __extbuf_; 2. sync() should use length() rather than out() to calculate offset. Reversing iterators and calling out() to calculate offset from behind is working fine in stateless character encoding. However, in stateful encoding, escape sequences could differ in length. As a result, out() could return wrong length. For example, if we have internal buffer converted from this external sequence: (capital letters mean escape sequence) … a a a a B b b b b out() produces this sequence. b b b b A a a a a Because out() inserts escape sequence A rather than B, result sequence doesn't match to external sequence. A and B could have different lengths, result offset could be wrong value too. length() method in codecvt is right for calculating offset, but it counts offset from the beginning of buffer. So it requires another state member variable to hold state before conversion. Fixes http://llvm.org/bugs/show_bug.cgi?id=13667 llvm-svn: 162601
2012-08-25 05:20:56 +08:00
_VSTD::swap(__st_last_, __rhs.__st_last_);
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
_VSTD::swap(__om_, __rhs.__om_);
_VSTD::swap(__cm_, __rhs.__cm_);
_VSTD::swap(__owns_eb_, __rhs.__owns_eb_);
_VSTD::swap(__owns_ib_, __rhs.__owns_ib_);
_VSTD::swap(__always_noconv_, __rhs.__always_noconv_);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (this->eback() == (char_type*)__rhs.__extbuf_min_)
{
ptrdiff_t __n = this->gptr() - this->eback();
ptrdiff_t __e = this->egptr() - this->eback();
this->setg((char_type*)__extbuf_min_,
(char_type*)__extbuf_min_ + __n,
(char_type*)__extbuf_min_ + __e);
}
else if (this->pbase() == (char_type*)__rhs.__extbuf_min_)
{
ptrdiff_t __n = this->pptr() - this->pbase();
ptrdiff_t __e = this->epptr() - this->pbase();
this->setp((char_type*)__extbuf_min_,
(char_type*)__extbuf_min_ + __e);
Make pbump (internally) handle sizes bigger than MAX_INT. Fixes PR#33725 - thanks to Jonathan Wakely for the report llvm-svn: 313031
2017-09-12 23:00:43 +08:00
this->__pbump(__n);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
if (__rhs.eback() == (char_type*)__extbuf_min_)
{
ptrdiff_t __n = __rhs.gptr() - __rhs.eback();
ptrdiff_t __e = __rhs.egptr() - __rhs.eback();
__rhs.setg((char_type*)__rhs.__extbuf_min_,
(char_type*)__rhs.__extbuf_min_ + __n,
(char_type*)__rhs.__extbuf_min_ + __e);
}
else if (__rhs.pbase() == (char_type*)__extbuf_min_)
{
ptrdiff_t __n = __rhs.pptr() - __rhs.pbase();
ptrdiff_t __e = __rhs.epptr() - __rhs.pbase();
__rhs.setp((char_type*)__rhs.__extbuf_min_,
(char_type*)__rhs.__extbuf_min_ + __e);
Make pbump (internally) handle sizes bigger than MAX_INT. Fixes PR#33725 - thanks to Jonathan Wakely for the report llvm-svn: 313031
2017-09-12 23:00:43 +08:00
__rhs.__pbump(__n);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
}
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y)
{
__x.swap(__y);
}
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
bool
basic_filebuf<_CharT, _Traits>::is_open() const
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
return __file_ != nullptr;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
template <class _CharT, class _Traits>
const char* basic_filebuf<_CharT, _Traits>::__make_mdstring(
ios_base::openmode __mode) _NOEXCEPT {
switch (__mode & ~ios_base::ate) {
case ios_base::out:
case ios_base::out | ios_base::trunc:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "w" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
case ios_base::out | ios_base::app:
case ios_base::app:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "a" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
case ios_base::in:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "r" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
case ios_base::in | ios_base::out:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "r+" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
case ios_base::in | ios_base::out | ios_base::trunc:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "w+" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
case ios_base::in | ios_base::out | ios_base::app:
case ios_base::in | ios_base::app:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "a+" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
case ios_base::out | ios_base::binary:
case ios_base::out | ios_base::trunc | ios_base::binary:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "wb" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
case ios_base::out | ios_base::app | ios_base::binary:
case ios_base::app | ios_base::binary:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "ab" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
case ios_base::in | ios_base::binary:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "rb" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
case ios_base::in | ios_base::out | ios_base::binary:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "r+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "w+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
case ios_base::in | ios_base::out | ios_base::app | ios_base::binary:
case ios_base::in | ios_base::app | ios_base::binary:
Open fstream files in O_CLOEXEC mode when possible. Reviewers: EricWF, mclow.lists, ldionne Reviewed By: ldionne Subscribers: smeenai, dexonsmith, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D59839 llvm-svn: 372027
2019-09-17 03:26:41 +08:00
return "a+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
default:
return nullptr;
}
_LIBCPP_UNREACHABLE();
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>*
basic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
basic_filebuf<_CharT, _Traits>* __rt = nullptr;
if (__file_ == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
{
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
if (const char* __mdstr = __make_mdstring(__mode)) {
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__rt = this;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
__file_ = fopen(__s, __mdstr);
if (__file_) {
__om_ = __mode;
if (__mode & ios_base::ate) {
if (fseek(__file_, 0, SEEK_END)) {
fclose(__file_);
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__file_ = nullptr;
__rt = nullptr;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
}
} else
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__rt = nullptr;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
}
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
return __rt;
}
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
template <class _CharT, class _Traits>
[libc++] Instantiate additional <iostream> members in the dylib This commit adds new explicit instantiations for some classes in <iostream> in the library. This is done after noticing that many programs that use streams end up containing weak definitions of these classes, which has a negative impact on both code size and load times (due to the need to resolve weak symbols at load time). Note that we are just adding the additional explicit instantiations for the `char` specializations, since the `wchar_t` specializations are not used as often, and as a result there wouldn't be a clear benefit. This change is not an ABI break, since we are just adding additional symbols. Differential Revision: https://reviews.llvm.org/D90677
2020-10-21 23:11:45 +08:00
inline _LIBCPP_INLINE_VISIBILITY
basic_filebuf<_CharT, _Traits>*
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
basic_filebuf<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) {
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
basic_filebuf<_CharT, _Traits>* __rt = nullptr;
if (__file_ == nullptr) {
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
if (const char* __mdstr = __make_mdstring(__mode)) {
__rt = this;
__file_ = fdopen(__fd, __mdstr);
if (__file_) {
__om_ = __mode;
if (__mode & ios_base::ate) {
if (fseek(__file_, 0, SEEK_END)) {
fclose(__file_);
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__file_ = nullptr;
__rt = nullptr;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
}
}
} else
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__rt = nullptr;
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
}
}
return __rt;
}
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
// This is basically the same as the char* overload except that it uses _wfopen
// and long mode strings.
template <class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>*
basic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
basic_filebuf<_CharT, _Traits>* __rt = nullptr;
if (__file_ == nullptr)
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
{
__rt = this;
const wchar_t* __mdstr;
switch (__mode & ~ios_base::ate)
{
case ios_base::out:
case ios_base::out | ios_base::trunc:
__mdstr = L"w";
break;
case ios_base::out | ios_base::app:
case ios_base::app:
__mdstr = L"a";
break;
case ios_base::in:
__mdstr = L"r";
break;
case ios_base::in | ios_base::out:
__mdstr = L"r+";
break;
case ios_base::in | ios_base::out | ios_base::trunc:
__mdstr = L"w+";
break;
case ios_base::in | ios_base::out | ios_base::app:
case ios_base::in | ios_base::app:
__mdstr = L"a+";
break;
case ios_base::out | ios_base::binary:
case ios_base::out | ios_base::trunc | ios_base::binary:
__mdstr = L"wb";
break;
case ios_base::out | ios_base::app | ios_base::binary:
case ios_base::app | ios_base::binary:
__mdstr = L"ab";
break;
case ios_base::in | ios_base::binary:
__mdstr = L"rb";
break;
case ios_base::in | ios_base::out | ios_base::binary:
__mdstr = L"r+b";
break;
case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
__mdstr = L"w+b";
break;
case ios_base::in | ios_base::out | ios_base::app | ios_base::binary:
case ios_base::in | ios_base::app | ios_base::binary:
__mdstr = L"a+b";
break;
default:
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__rt = nullptr;
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
break;
}
if (__rt)
{
__file_ = _wfopen(__s, __mdstr);
if (__file_)
{
__om_ = __mode;
if (__mode & ios_base::ate)
{
if (fseek(__file_, 0, SEEK_END))
{
fclose(__file_);
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__file_ = nullptr;
__rt = nullptr;
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
}
}
}
else
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__rt = nullptr;
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
}
}
return __rt;
}
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf<_CharT, _Traits>*
basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
{
return open(__s.c_str(), __mode);
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>*
basic_filebuf<_CharT, _Traits>::close()
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
basic_filebuf<_CharT, _Traits>* __rt = nullptr;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (__file_)
{
__rt = this;
unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose);
Fix http://llvm.org/bugs/show_bug.cgi?id=11752 llvm-svn: 148069
2012-01-13 07:37:51 +08:00
if (sync())
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__rt = nullptr;
[libc++] Set __file_ to 0 in basic_filebuf::close() even if fclose fails This issue was detected by ASan in one of our tests. This test manually invokes basic_filebuf::cloe(). fclose(__h.release() returned a non-zero exit status, so __file_ wasn't set to 0. Later when basic_filebuf destructor ran, we would enter the if (__file_) block again leading to heap-use-after-free error. The POSIX specification for fclose says that independently of the return value, fclose closes the underlying file descriptor and any further access (including another call to fclose()) to the stream results in undefined behavior. This is exactly what happened in our test case. To avoid this issue, we have to always set __file_ to 0 independently of the fclose return value. Differential Revision: https://reviews.llvm.org/D64979 llvm-svn: 366730
2019-07-23 03:54:34 +08:00
if (fclose(__h.release()))
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__rt = nullptr;
__file_ = nullptr;
Set the buffer of an fstream to empty when the underlying file is closed. This 'fixes' PR#38052 - std::fstream still good after closing and updating content. llvm-svn: 350603
2019-01-08 10:48:45 +08:00
setbuf(0, 0);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
return __rt;
}
template <class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::int_type
basic_filebuf<_CharT, _Traits>::underflow()
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__file_ == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
return traits_type::eof();
bool __initial = __read_mode();
char_type __1buf;
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (this->gptr() == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
this->setg(&__1buf, &__1buf+1, &__1buf+1);
const size_t __unget_sz = __initial ? 0 : min<size_t>((this->egptr() - this->eback()) / 2, 4);
int_type __c = traits_type::eof();
if (this->gptr() == this->egptr())
{
[libc++] ADL-proof by adding _VSTD:: qualifications to memmove etc. Generally these calls aren't vulnerable to ADL because they involve only primitive types. The ones in <list> and <vector> drag in namespace std but that's OK; the ones in <fstream> and <strstream> are vulnerable iff `CharT` is an enum type, which seems far-fetched. But absolutely zero of them *need* ADL to happen; so in my opinion they should all be consistently qualified, just like calls to any other (non-user-customizable) functions in namespace std. Also: Include <cstring> and <cwchar> in <__string>. We seemed to be getting lucky that <memory> included <iterator> included <iosfwd> included <wchar.h>. That gave us the global-namespace `wmemmove`, but not `_VSTD::wmemmove`. This is now fixed. I didn't touch these headers: <ext/__hash> uses strlen, safely <support/ibm/locale_mgmt_aix.h> uses memcpy, safely <string.h> uses memchr and strchr, safely <wchar.h> uses wcschr, safely <__bsd_locale_fallbacks.h> uses wcsnrtombs, safely Differential Revision: https://reviews.llvm.org/D93061
2020-12-08 10:50:15 +08:00
_VSTD::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (__always_noconv_)
{
size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz);
__nmemb = fread(this->eback() + __unget_sz, 1, __nmemb, __file_);
if (__nmemb != 0)
{
this->setg(this->eback(),
this->eback() + __unget_sz,
this->eback() + __unget_sz + __nmemb);
Missing traits::to_int_type in fstream llvm-svn: 124727
2011-02-03 01:37:16 +08:00
__c = traits_type::to_int_type(*this->gptr());
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
}
else
{
Don't call memmove when there's nothing to move. Fixes PR#27978. llvm-svn: 271794
2016-06-05 00:16:59 +08:00
_LIBCPP_ASSERT ( !(__extbufnext_ == NULL && (__extbufend_ != __extbufnext_)), "underflow moving from NULL" );
if (__extbufend_ != __extbufnext_)
[libc++] ADL-proof by adding _VSTD:: qualifications to memmove etc. Generally these calls aren't vulnerable to ADL because they involve only primitive types. The ones in <list> and <vector> drag in namespace std but that's OK; the ones in <fstream> and <strstream> are vulnerable iff `CharT` is an enum type, which seems far-fetched. But absolutely zero of them *need* ADL to happen; so in my opinion they should all be consistently qualified, just like calls to any other (non-user-customizable) functions in namespace std. Also: Include <cstring> and <cwchar> in <__string>. We seemed to be getting lucky that <memory> included <iterator> included <iosfwd> included <wchar.h>. That gave us the global-namespace `wmemmove`, but not `_VSTD::wmemmove`. This is now fixed. I didn't touch these headers: <ext/__hash> uses strlen, safely <support/ibm/locale_mgmt_aix.h> uses memcpy, safely <string.h> uses memchr and strchr, safely <wchar.h> uses wcschr, safely <__bsd_locale_fallbacks.h> uses wcsnrtombs, safely Differential Revision: https://reviews.llvm.org/D93061
2020-12-08 10:50:15 +08:00
_VSTD::memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
__extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
Fix basic_filebuf's internal buffer is shrinking when using with some codecvt. http://llvm.org/bugs/show_bug.cgi?id=13602 llvm-svn: 162585
2012-08-25 04:37:00 +08:00
size_t __nmemb = _VSTD::min(static_cast<size_t>(__ibs_ - __unget_sz),
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
static_cast<size_t>(__extbufend_ - __extbufnext_));
codecvt_base::result __r;
Hyeon-Bin Jeong: 1. sync() should reset it’s external buffer pointers. Remaining characters should be discarded once sync() called. If don’t, garbage characters can be inserted to the front of external buffer in underflow(). Because underflow() copies remaining characters in external buffer to it’s front. This results wrong characters insertion when seekpos() or seekoff() is called. this line should be inserted in sync() just before return: __extbufnext_ = __extbufend_ = __extbuf_; 2. sync() should use length() rather than out() to calculate offset. Reversing iterators and calling out() to calculate offset from behind is working fine in stateless character encoding. However, in stateful encoding, escape sequences could differ in length. As a result, out() could return wrong length. For example, if we have internal buffer converted from this external sequence: (capital letters mean escape sequence) … a a a a B b b b b out() produces this sequence. b b b b A a a a a Because out() inserts escape sequence A rather than B, result sequence doesn't match to external sequence. A and B could have different lengths, result offset could be wrong value too. length() method in codecvt is right for calculating offset, but it counts offset from the beginning of buffer. So it requires another state member variable to hold state before conversion. Fixes http://llvm.org/bugs/show_bug.cgi?id=13667 llvm-svn: 162601
2012-08-25 05:20:56 +08:00
__st_last_ = __st_;
Add some const_casts in places where we were implicitly casting away constness. No functional change, but now they're explicit llvm-svn: 305410
2017-06-15 04:00:36 +08:00
size_t __nr = fread((void*) const_cast<char *>(__extbufnext_), 1, __nmemb, __file_);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (__nr != 0)
{
basic_filebuf needs to delay obtaining a codecvt facet from the global locale to give the client a chance to imbue the proper locale. Fixes http://llvm.org/bugs/show_bug.cgi?id=13663. llvm-svn: 162567
2012-08-25 00:52:47 +08:00
if (!__cv_)
Add an _LIBCPP_NORETURN inline function named __throw_XXX for each exception type we define. They either construct and throw the exception, or abort() (if exceptions are disabled). Use these functions everywhere instead of assert()ing when exceptions are disabled. WARNING: This is a behavior change - but only with exceptions disabled. Reviewed as: https://reviews.llvm.org/D23855. llvm-svn: 279744
2016-08-25 23:09:01 +08:00
__throw_bad_cast();
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__extbufend_ = __extbufnext_ + __nr;
char_type* __inext;
__r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_,
this->eback() + __unget_sz,
Fix basic_filebuf's internal buffer is shrinking when using with some codecvt. http://llvm.org/bugs/show_bug.cgi?id=13602 llvm-svn: 162585
2012-08-25 04:37:00 +08:00
this->eback() + __ibs_, __inext);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (__r == codecvt_base::noconv)
{
[libc++] Mark <filesystem> tests as failing when the dylib doesn't support filesystem This fixes CI for back-deployment testers on platforms that don't have <filesystem> support in the dylib. This is effectively half of https://reviews.llvm.org/D59224. The other half requires fixes in Clang. llvm-svn: 356558
2019-03-20 22:34:00 +08:00
this->setg((char_type*)__extbuf_, (char_type*)__extbuf_,
Add some const_casts in places where we were implicitly casting away constness. No functional change, but now they're explicit llvm-svn: 305410
2017-06-15 04:00:36 +08:00
(char_type*)const_cast<char *>(__extbufend_));
Missing traits::to_int_type in fstream llvm-svn: 124727
2011-02-03 01:37:16 +08:00
__c = traits_type::to_int_type(*this->gptr());
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
else if (__inext != this->eback() + __unget_sz)
{
this->setg(this->eback(), this->eback() + __unget_sz, __inext);
Missing traits::to_int_type in fstream llvm-svn: 124727
2011-02-03 01:37:16 +08:00
__c = traits_type::to_int_type(*this->gptr());
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
}
}
}
else
Missing traits::to_int_type in fstream llvm-svn: 124727
2011-02-03 01:37:16 +08:00
__c = traits_type::to_int_type(*this->gptr());
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (this->eback() == &__1buf)
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
this->setg(nullptr, nullptr, nullptr);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
return __c;
}
template <class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::int_type
basic_filebuf<_CharT, _Traits>::pbackfail(int_type __c)
{
if (__file_ && this->eback() < this->gptr())
{
if (traits_type::eq_int_type(__c, traits_type::eof()))
{
this->gbump(-1);
return traits_type::not_eof(__c);
}
if ((__om_ & ios_base::out) ||
traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))
{
this->gbump(-1);
*this->gptr() = traits_type::to_char_type(__c);
return __c;
}
}
return traits_type::eof();
}
template <class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::int_type
basic_filebuf<_CharT, _Traits>::overflow(int_type __c)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__file_ == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
return traits_type::eof();
__write_mode();
char_type __1buf;
char_type* __pb_save = this->pbase();
char_type* __epb_save = this->epptr();
if (!traits_type::eq_int_type(__c, traits_type::eof()))
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (this->pptr() == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
this->setp(&__1buf, &__1buf+1);
*this->pptr() = traits_type::to_char_type(__c);
this->pbump(1);
}
if (this->pptr() != this->pbase())
{
if (__always_noconv_)
{
size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
if (fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb)
return traits_type::eof();
}
else
{
char* __extbe = __extbuf_;
codecvt_base::result __r;
do
{
basic_filebuf needs to delay obtaining a codecvt facet from the global locale to give the client a chance to imbue the proper locale. Fixes http://llvm.org/bugs/show_bug.cgi?id=13663. llvm-svn: 162567
2012-08-25 00:52:47 +08:00
if (!__cv_)
Add an _LIBCPP_NORETURN inline function named __throw_XXX for each exception type we define. They either construct and throw the exception, or abort() (if exceptions are disabled). Use these functions everywhere instead of assert()ing when exceptions are disabled. WARNING: This is a behavior change - but only with exceptions disabled. Reviewed as: https://reviews.llvm.org/D23855. llvm-svn: 279744
2016-08-25 23:09:01 +08:00
__throw_bad_cast();
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
const char_type* __e;
__r = __cv_->out(__st_, this->pbase(), this->pptr(), __e,
__extbuf_, __extbuf_ + __ebs_, __extbe);
if (__e == this->pbase())
return traits_type::eof();
if (__r == codecvt_base::noconv)
{
size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
if (fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb)
return traits_type::eof();
}
else if (__r == codecvt_base::ok || __r == codecvt_base::partial)
{
size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_);
if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb)
return traits_type::eof();
if (__r == codecvt_base::partial)
{
Add some const_casts in places where we were implicitly casting away constness. No functional change, but now they're explicit llvm-svn: 305410
2017-06-15 04:00:36 +08:00
this->setp(const_cast<char_type*>(__e), this->pptr());
Make pbump (internally) handle sizes bigger than MAX_INT. Fixes PR#33725 - thanks to Jonathan Wakely for the report llvm-svn: 313031
2017-09-12 23:00:43 +08:00
this->__pbump(this->epptr() - this->pbase());
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
}
else
return traits_type::eof();
} while (__r == codecvt_base::partial);
}
this->setp(__pb_save, __epb_save);
}
return traits_type::not_eof(__c);
}
template <class _CharT, class _Traits>
basic_streambuf<_CharT, _Traits>*
basic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
this->setg(nullptr, nullptr, nullptr);
this->setp(nullptr, nullptr);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (__owns_eb_)
delete [] __extbuf_;
if (__owns_ib_)
delete [] __intbuf_;
__ebs_ = __n;
if (__ebs_ > sizeof(__extbuf_min_))
{
if (__always_noconv_ && __s)
{
__extbuf_ = (char*)__s;
__owns_eb_ = false;
}
else
{
__extbuf_ = new char[__ebs_];
__owns_eb_ = true;
}
}
else
{
__extbuf_ = __extbuf_min_;
__ebs_ = sizeof(__extbuf_min_);
__owns_eb_ = false;
}
if (!__always_noconv_)
{
__ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_));
if (__s && __ibs_ >= sizeof(__extbuf_min_))
{
__intbuf_ = __s;
__owns_ib_ = false;
}
else
{
__intbuf_ = new char_type[__ibs_];
__owns_ib_ = true;
}
}
else
{
__ibs_ = 0;
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__intbuf_ = nullptr;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__owns_ib_ = false;
}
return this;
}
template <class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::pos_type
basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode)
{
basic_filebuf needs to delay obtaining a codecvt facet from the global locale to give the client a chance to imbue the proper locale. Fixes http://llvm.org/bugs/show_bug.cgi?id=13663. llvm-svn: 162567
2012-08-25 00:52:47 +08:00
if (!__cv_)
Add an _LIBCPP_NORETURN inline function named __throw_XXX for each exception type we define. They either construct and throw the exception, or abort() (if exceptions are disabled). Use these functions everywhere instead of assert()ing when exceptions are disabled. WARNING: This is a behavior change - but only with exceptions disabled. Reviewed as: https://reviews.llvm.org/D23855. llvm-svn: 279744
2016-08-25 23:09:01 +08:00
__throw_bad_cast();
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
int __width = __cv_->encoding();
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__file_ == nullptr || (__width <= 0 && __off != 0) || sync())
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
return pos_type(off_type(-1));
// __width > 0 || __off == 0
int __whence;
switch (__way)
{
case ios_base::beg:
__whence = SEEK_SET;
break;
case ios_base::cur:
__whence = SEEK_CUR;
break;
case ios_base::end:
__whence = SEEK_END;
break;
default:
return pos_type(off_type(-1));
}
[libc++] Add configuration define for off_t functions Create this define in __config and use it elsewhere, instead of checking the operating system/library defines in other files. The aim is to reduce the usage of _WIN32 outside __config. No functional change. Differential Revision: https://reviews.llvm.org/D25741 llvm-svn: 285582
2016-10-31 23:09:10 +08:00
#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
Reference: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20130325/077133.html llvm-svn: 178581
2013-04-03 06:14:51 +08:00
if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence))
return pos_type(off_type(-1));
pos_type __r = ftell(__file_);
#else
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (fseeko(__file_, __width > 0 ? __width * __off : 0, __whence))
return pos_type(off_type(-1));
pos_type __r = ftello(__file_);
Reference: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20130325/077133.html llvm-svn: 178581
2013-04-03 06:14:51 +08:00
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__r.state(__st_);
return __r;
}
template <class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::pos_type
Tests for basic posix regex templated on wchar_t llvm-svn: 108435
2010-07-16 02:18:07 +08:00
basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__file_ == nullptr || sync())
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
return pos_type(off_type(-1));
[libc++] Add configuration define for off_t functions Create this define in __config and use it elsewhere, instead of checking the operating system/library defines in other files. The aim is to reduce the usage of _WIN32 outside __config. No functional change. Differential Revision: https://reviews.llvm.org/D25741 llvm-svn: 285582
2016-10-31 23:09:10 +08:00
#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
Reference: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20130325/077133.html llvm-svn: 178581
2013-04-03 06:14:51 +08:00
if (fseek(__file_, __sp, SEEK_SET))
return pos_type(off_type(-1));
#else
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (fseeko(__file_, __sp, SEEK_SET))
return pos_type(off_type(-1));
Reference: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20130325/077133.html llvm-svn: 178581
2013-04-03 06:14:51 +08:00
#endif
Hyeon-Bin Jeong: 1. sync() should reset it’s external buffer pointers. Remaining characters should be discarded once sync() called. If don’t, garbage characters can be inserted to the front of external buffer in underflow(). Because underflow() copies remaining characters in external buffer to it’s front. This results wrong characters insertion when seekpos() or seekoff() is called. this line should be inserted in sync() just before return: __extbufnext_ = __extbufend_ = __extbuf_; 2. sync() should use length() rather than out() to calculate offset. Reversing iterators and calling out() to calculate offset from behind is working fine in stateless character encoding. However, in stateful encoding, escape sequences could differ in length. As a result, out() could return wrong length. For example, if we have internal buffer converted from this external sequence: (capital letters mean escape sequence) … a a a a B b b b b out() produces this sequence. b b b b A a a a a Because out() inserts escape sequence A rather than B, result sequence doesn't match to external sequence. A and B could have different lengths, result offset could be wrong value too. length() method in codecvt is right for calculating offset, but it counts offset from the beginning of buffer. So it requires another state member variable to hold state before conversion. Fixes http://llvm.org/bugs/show_bug.cgi?id=13667 llvm-svn: 162601
2012-08-25 05:20:56 +08:00
__st_ = __sp.state();
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
return __sp;
}
template <class _CharT, class _Traits>
int
basic_filebuf<_CharT, _Traits>::sync()
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__file_ == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
return 0;
basic_filebuf needs to delay obtaining a codecvt facet from the global locale to give the client a chance to imbue the proper locale. Fixes http://llvm.org/bugs/show_bug.cgi?id=13663. llvm-svn: 162567
2012-08-25 00:52:47 +08:00
if (!__cv_)
Add an _LIBCPP_NORETURN inline function named __throw_XXX for each exception type we define. They either construct and throw the exception, or abort() (if exceptions are disabled). Use these functions everywhere instead of assert()ing when exceptions are disabled. WARNING: This is a behavior change - but only with exceptions disabled. Reviewed as: https://reviews.llvm.org/D23855. llvm-svn: 279744
2016-08-25 23:09:01 +08:00
__throw_bad_cast();
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (__cm_ & ios_base::out)
{
if (this->pptr() != this->pbase())
if (overflow() == traits_type::eof())
return -1;
codecvt_base::result __r;
do
{
char* __extbe;
__r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe);
size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_);
if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb)
return -1;
} while (__r == codecvt_base::partial);
if (__r == codecvt_base::error)
return -1;
if (fflush(__file_))
return -1;
}
else if (__cm_ & ios_base::in)
{
off_type __c;
Hyeon-Bin Jeong: 1. sync() should reset it’s external buffer pointers. Remaining characters should be discarded once sync() called. If don’t, garbage characters can be inserted to the front of external buffer in underflow(). Because underflow() copies remaining characters in external buffer to it’s front. This results wrong characters insertion when seekpos() or seekoff() is called. this line should be inserted in sync() just before return: __extbufnext_ = __extbufend_ = __extbuf_; 2. sync() should use length() rather than out() to calculate offset. Reversing iterators and calling out() to calculate offset from behind is working fine in stateless character encoding. However, in stateful encoding, escape sequences could differ in length. As a result, out() could return wrong length. For example, if we have internal buffer converted from this external sequence: (capital letters mean escape sequence) … a a a a B b b b b out() produces this sequence. b b b b A a a a a Because out() inserts escape sequence A rather than B, result sequence doesn't match to external sequence. A and B could have different lengths, result offset could be wrong value too. length() method in codecvt is right for calculating offset, but it counts offset from the beginning of buffer. So it requires another state member variable to hold state before conversion. Fixes http://llvm.org/bugs/show_bug.cgi?id=13667 llvm-svn: 162601
2012-08-25 05:20:56 +08:00
state_type __state = __st_last_;
bool __update_st = false;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (__always_noconv_)
__c = this->egptr() - this->gptr();
else
{
int __width = __cv_->encoding();
__c = __extbufend_ - __extbufnext_;
if (__width > 0)
__c += __width * (this->egptr() - this->gptr());
else
{
if (this->gptr() != this->egptr())
{
Hyeon-Bin Jeong: 1. sync() should reset it’s external buffer pointers. Remaining characters should be discarded once sync() called. If don’t, garbage characters can be inserted to the front of external buffer in underflow(). Because underflow() copies remaining characters in external buffer to it’s front. This results wrong characters insertion when seekpos() or seekoff() is called. this line should be inserted in sync() just before return: __extbufnext_ = __extbufend_ = __extbuf_; 2. sync() should use length() rather than out() to calculate offset. Reversing iterators and calling out() to calculate offset from behind is working fine in stateless character encoding. However, in stateful encoding, escape sequences could differ in length. As a result, out() could return wrong length. For example, if we have internal buffer converted from this external sequence: (capital letters mean escape sequence) … a a a a B b b b b out() produces this sequence. b b b b A a a a a Because out() inserts escape sequence A rather than B, result sequence doesn't match to external sequence. A and B could have different lengths, result offset could be wrong value too. length() method in codecvt is right for calculating offset, but it counts offset from the beginning of buffer. So it requires another state member variable to hold state before conversion. Fixes http://llvm.org/bugs/show_bug.cgi?id=13667 llvm-svn: 162601
2012-08-25 05:20:56 +08:00
const int __off = __cv_->length(__state, __extbuf_,
__extbufnext_,
this->gptr() - this->eback());
__c += __extbufnext_ - __extbuf_ - __off;
__update_st = true;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
}
}
}
[libc++] Add configuration define for off_t functions Create this define in __config and use it elsewhere, instead of checking the operating system/library defines in other files. The aim is to reduce the usage of _WIN32 outside __config. No functional change. Differential Revision: https://reviews.llvm.org/D25741 llvm-svn: 285582
2016-10-31 23:09:10 +08:00
#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
Reference: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20130325/077133.html llvm-svn: 178581
2013-04-03 06:14:51 +08:00
if (fseek(__file_, -__c, SEEK_CUR))
return -1;
#else
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (fseeko(__file_, -__c, SEEK_CUR))
return -1;
Reference: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20130325/077133.html llvm-svn: 178581
2013-04-03 06:14:51 +08:00
#endif
Hyeon-Bin Jeong: 1. sync() should reset it’s external buffer pointers. Remaining characters should be discarded once sync() called. If don’t, garbage characters can be inserted to the front of external buffer in underflow(). Because underflow() copies remaining characters in external buffer to it’s front. This results wrong characters insertion when seekpos() or seekoff() is called. this line should be inserted in sync() just before return: __extbufnext_ = __extbufend_ = __extbuf_; 2. sync() should use length() rather than out() to calculate offset. Reversing iterators and calling out() to calculate offset from behind is working fine in stateless character encoding. However, in stateful encoding, escape sequences could differ in length. As a result, out() could return wrong length. For example, if we have internal buffer converted from this external sequence: (capital letters mean escape sequence) … a a a a B b b b b out() produces this sequence. b b b b A a a a a Because out() inserts escape sequence A rather than B, result sequence doesn't match to external sequence. A and B could have different lengths, result offset could be wrong value too. length() method in codecvt is right for calculating offset, but it counts offset from the beginning of buffer. So it requires another state member variable to hold state before conversion. Fixes http://llvm.org/bugs/show_bug.cgi?id=13667 llvm-svn: 162601
2012-08-25 05:20:56 +08:00
if (__update_st)
__st_ = __state;
__extbufnext_ = __extbufend_ = __extbuf_;
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
this->setg(nullptr, nullptr, nullptr);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__cm_ = 0;
}
return 0;
}
template <class _CharT, class _Traits>
void
basic_filebuf<_CharT, _Traits>::imbue(const locale& __loc)
{
sync();
__cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
bool __old_anc = __always_noconv_;
__always_noconv_ = __cv_->always_noconv();
if (__old_anc != __always_noconv_)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
this->setg(nullptr, nullptr, nullptr);
this->setp(nullptr, nullptr);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
// invariant, char_type is char, else we couldn't get here
if (__always_noconv_) // need to dump __intbuf_
{
if (__owns_eb_)
delete [] __extbuf_;
__owns_eb_ = __owns_ib_;
__ebs_ = __ibs_;
__extbuf_ = (char*)__intbuf_;
__ibs_ = 0;
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
__intbuf_ = nullptr;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__owns_ib_ = false;
}
else // need to obtain an __intbuf_.
{ // If __extbuf_ is user-supplied, use it, else new __intbuf_
if (!__owns_eb_ && __extbuf_ != __extbuf_min_)
{
__ibs_ = __ebs_;
__intbuf_ = (char_type*)__extbuf_;
__owns_ib_ = false;
__extbuf_ = new char[__ebs_];
__owns_eb_ = true;
}
else
{
__ibs_ = __ebs_;
__intbuf_ = new char_type[__ibs_];
__owns_ib_ = true;
}
}
}
}
template <class _CharT, class _Traits>
bool
basic_filebuf<_CharT, _Traits>::__read_mode()
{
if (!(__cm_ & ios_base::in))
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
this->setp(nullptr, nullptr);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (__always_noconv_)
this->setg((char_type*)__extbuf_,
(char_type*)__extbuf_ + __ebs_,
(char_type*)__extbuf_ + __ebs_);
else
this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_);
__cm_ = ios_base::in;
return true;
}
return false;
}
template <class _CharT, class _Traits>
void
basic_filebuf<_CharT, _Traits>::__write_mode()
{
if (!(__cm_ & ios_base::out))
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
this->setg(nullptr, nullptr, nullptr);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
if (__ebs_ > sizeof(__extbuf_min_))
{
if (__always_noconv_)
this->setp((char_type*)__extbuf_,
(char_type*)__extbuf_ + (__ebs_ - 1));
else
this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1));
}
else
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
this->setp(nullptr, nullptr);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
__cm_ = ios_base::out;
}
}
// basic_ifstream
template <class _CharT, class _Traits>
[NFC] Rename _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS The name _LIBCPP_TYPE_VIS_ONLY is no longer accurate because both _LIBCPP_TYPE_VIS and _LIBCPP_TYPE_VIS_ONLY expand to __attribute__((__type_visibility__)) with Clang. The only remaining difference is that _LIBCPP_TYPE_VIS_ONLY can be applied to templates whereas _LIBCPP_TYPE_VIS cannot (due to dllimport/dllexport not being allowed on templates). This patch renames _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS. llvm-svn: 291035
2017-01-05 07:56:00 +08:00
class _LIBCPP_TEMPLATE_VIS basic_ifstream
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
: public basic_istream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ifstream();
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in);
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
_LIBCPP_INLINE_VISIBILITY
explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
#endif
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);
[libc++] Make LIBCXX_ENABLE_FILESYSTEM fully consistent Previously, LIBCXX_ENABLE_FILESYSTEM controlled only whether the filesystem support was compiled into libc++'s library. This commit promotes the setting to a first-class option like LIBCXX_ENABLE_LOCALIZATION, where the whole library is aware of the setting and features that depend on <filesystem> won't be provided at all. The test suite is also properly annotated such that tests that depend on <filesystem> are disabled when the library doesn't support it. This is an alternative to https://llvm.org/D94824, but also an improvement along the lines of LIBCXX_ENABLE_LOCALIZATION that I had been wanting to make for a while. Differential Revision: https://reviews.llvm.org/D94921
2021-01-19 01:18:18 +08:00
#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
[libc++] Mark <filesystem> tests as failing when the dylib doesn't support filesystem This fixes CI for back-deployment testers on platforms that don't have <filesystem> support in the dylib. This is effectively half of https://reviews.llvm.org/D59224. The other half requires fixes in Clang. llvm-svn: 356558
2019-03-20 22:34:00 +08:00
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
explicit basic_ifstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in)
: basic_ifstream(__p.c_str(), __mode) {}
#endif // _LIBCPP_STD_VER >= 17
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#ifndef _LIBCPP_CXX03_LANG
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ifstream(basic_ifstream&& __rhs);
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ifstream& operator=(basic_ifstream&& __rhs);
#endif
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void swap(basic_ifstream& __rhs);
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf<char_type, traits_type>* rdbuf() const;
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
bool is_open() const;
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void open(const char* __s, ios_base::openmode __mode = ios_base::in);
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void open(const string& __s, ios_base::openmode __mode = ios_base::in);
[libc++] Make LIBCXX_ENABLE_FILESYSTEM fully consistent Previously, LIBCXX_ENABLE_FILESYSTEM controlled only whether the filesystem support was compiled into libc++'s library. This commit promotes the setting to a first-class option like LIBCXX_ENABLE_LOCALIZATION, where the whole library is aware of the setting and features that depend on <filesystem> won't be provided at all. The test suite is also properly annotated such that tests that depend on <filesystem> are disabled when the library doesn't support it. This is an alternative to https://llvm.org/D94824, but also an improvement along the lines of LIBCXX_ENABLE_LOCALIZATION that I had been wanting to make for a while. Differential Revision: https://reviews.llvm.org/D94921
2021-01-19 01:18:18 +08:00
#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
[libc++] Mark <filesystem> tests as failing when the dylib doesn't support filesystem This fixes CI for back-deployment testers on platforms that don't have <filesystem> support in the dylib. This is effectively half of https://reviews.llvm.org/D59224. The other half requires fixes in Clang. llvm-svn: 356558
2019-03-20 22:34:00 +08:00
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
void open(const filesystem::path& __p,
ios_base::openmode __mode = ios_base::in) {
return open(__p.c_str(), __mode);
}
#endif // _LIBCPP_STD_VER >= 17
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
_LIBCPP_INLINE_VISIBILITY
void __open(int __fd, ios_base::openmode __mode);
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void close();
private:
basic_filebuf<char_type, traits_type> __sb_;
};
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ifstream<_CharT, _Traits>::basic_ifstream()
: basic_istream<char_type, traits_type>(&__sb_)
{
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode)
: basic_istream<char_type, traits_type>(&__sb_)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
this->setstate(ios_base::failbit);
}
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
template <class _CharT, class _Traits>
inline
basic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode)
: basic_istream<char_type, traits_type>(&__sb_)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
this->setstate(ios_base::failbit);
}
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode)
: basic_istream<char_type, traits_type>(&__sb_)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
this->setstate(ios_base::failbit);
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#ifndef _LIBCPP_CXX03_LANG
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs)
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
: basic_istream<char_type, traits_type>(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
{
this->set_rdbuf(&__sb_);
}
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ifstream<_CharT, _Traits>&
basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
return *this;
}
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#endif // _LIBCPP_CXX03_LANG
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void
basic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs)
{
basic_istream<char_type, traits_type>::swap(__rhs);
__sb_.swap(__rhs.__sb_);
}
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y)
{
__x.swap(__y);
}
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf<_CharT, _Traits>*
basic_ifstream<_CharT, _Traits>::rdbuf() const
{
return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
}
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
bool
basic_ifstream<_CharT, _Traits>::is_open() const
{
return __sb_.is_open();
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
void
basic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
{
if (__sb_.open(__s, __mode | ios_base::in))
this->clear();
else
this->setstate(ios_base::failbit);
}
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
template <class _CharT, class _Traits>
void
basic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
{
if (__sb_.open(__s, __mode | ios_base::in))
this->clear();
else
this->setstate(ios_base::failbit);
}
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
void
basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
{
if (__sb_.open(__s, __mode | ios_base::in))
this->clear();
else
this->setstate(ios_base::failbit);
}
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
template <class _CharT, class _Traits>
void basic_ifstream<_CharT, _Traits>::__open(int __fd,
ios_base::openmode __mode) {
if (__sb_.__open(__fd, __mode | ios_base::in))
this->clear();
else
this->setstate(ios_base::failbit);
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void
basic_ifstream<_CharT, _Traits>::close()
{
if (__sb_.close() == 0)
this->setstate(ios_base::failbit);
}
// basic_ofstream
template <class _CharT, class _Traits>
[NFC] Rename _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS The name _LIBCPP_TYPE_VIS_ONLY is no longer accurate because both _LIBCPP_TYPE_VIS and _LIBCPP_TYPE_VIS_ONLY expand to __attribute__((__type_visibility__)) with Clang. The only remaining difference is that _LIBCPP_TYPE_VIS_ONLY can be applied to templates whereas _LIBCPP_TYPE_VIS cannot (due to dllimport/dllexport not being allowed on templates). This patch renames _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS. llvm-svn: 291035
2017-01-05 07:56:00 +08:00
class _LIBCPP_TEMPLATE_VIS basic_ofstream
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
: public basic_ostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ofstream();
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out);
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
_LIBCPP_INLINE_VISIBILITY
explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
#endif
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
[libc++] Make LIBCXX_ENABLE_FILESYSTEM fully consistent Previously, LIBCXX_ENABLE_FILESYSTEM controlled only whether the filesystem support was compiled into libc++'s library. This commit promotes the setting to a first-class option like LIBCXX_ENABLE_LOCALIZATION, where the whole library is aware of the setting and features that depend on <filesystem> won't be provided at all. The test suite is also properly annotated such that tests that depend on <filesystem> are disabled when the library doesn't support it. This is an alternative to https://llvm.org/D94824, but also an improvement along the lines of LIBCXX_ENABLE_LOCALIZATION that I had been wanting to make for a while. Differential Revision: https://reviews.llvm.org/D94921
2021-01-19 01:18:18 +08:00
#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
[libc++] Mark <filesystem> tests as failing when the dylib doesn't support filesystem This fixes CI for back-deployment testers on platforms that don't have <filesystem> support in the dylib. This is effectively half of https://reviews.llvm.org/D59224. The other half requires fixes in Clang. llvm-svn: 356558
2019-03-20 22:34:00 +08:00
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
explicit basic_ofstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out)
: basic_ofstream(__p.c_str(), __mode) {}
#endif // _LIBCPP_STD_VER >= 17
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#ifndef _LIBCPP_CXX03_LANG
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ofstream(basic_ofstream&& __rhs);
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ofstream& operator=(basic_ofstream&& __rhs);
#endif
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void swap(basic_ofstream& __rhs);
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf<char_type, traits_type>* rdbuf() const;
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
bool is_open() const;
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void open(const char* __s, ios_base::openmode __mode = ios_base::out);
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void open(const string& __s, ios_base::openmode __mode = ios_base::out);
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
[libc++] Make LIBCXX_ENABLE_FILESYSTEM fully consistent Previously, LIBCXX_ENABLE_FILESYSTEM controlled only whether the filesystem support was compiled into libc++'s library. This commit promotes the setting to a first-class option like LIBCXX_ENABLE_LOCALIZATION, where the whole library is aware of the setting and features that depend on <filesystem> won't be provided at all. The test suite is also properly annotated such that tests that depend on <filesystem> are disabled when the library doesn't support it. This is an alternative to https://llvm.org/D94824, but also an improvement along the lines of LIBCXX_ENABLE_LOCALIZATION that I had been wanting to make for a while. Differential Revision: https://reviews.llvm.org/D94921
2021-01-19 01:18:18 +08:00
#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
[libc++] Mark <filesystem> tests as failing when the dylib doesn't support filesystem This fixes CI for back-deployment testers on platforms that don't have <filesystem> support in the dylib. This is effectively half of https://reviews.llvm.org/D59224. The other half requires fixes in Clang. llvm-svn: 356558
2019-03-20 22:34:00 +08:00
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out)
{ return open(__p.c_str(), __mode); }
#endif // _LIBCPP_STD_VER >= 17
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
_LIBCPP_INLINE_VISIBILITY
void __open(int __fd, ios_base::openmode __mode);
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void close();
private:
basic_filebuf<char_type, traits_type> __sb_;
};
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ofstream<_CharT, _Traits>::basic_ofstream()
: basic_ostream<char_type, traits_type>(&__sb_)
{
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode)
: basic_ostream<char_type, traits_type>(&__sb_)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
this->setstate(ios_base::failbit);
}
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
template <class _CharT, class _Traits>
inline
basic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode)
: basic_ostream<char_type, traits_type>(&__sb_)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
this->setstate(ios_base::failbit);
}
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode)
: basic_ostream<char_type, traits_type>(&__sb_)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
this->setstate(ios_base::failbit);
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#ifndef _LIBCPP_CXX03_LANG
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs)
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
: basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
{
this->set_rdbuf(&__sb_);
}
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_ofstream<_CharT, _Traits>&
basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
return *this;
}
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#endif // _LIBCPP_CXX03_LANG
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void
basic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs)
{
basic_ostream<char_type, traits_type>::swap(__rhs);
__sb_.swap(__rhs.__sb_);
}
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y)
{
__x.swap(__y);
}
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf<_CharT, _Traits>*
basic_ofstream<_CharT, _Traits>::rdbuf() const
{
return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
}
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
bool
basic_ofstream<_CharT, _Traits>::is_open() const
{
return __sb_.is_open();
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
void
basic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
{
if (__sb_.open(__s, __mode | ios_base::out))
this->clear();
else
this->setstate(ios_base::failbit);
}
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
template <class _CharT, class _Traits>
void
basic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
{
if (__sb_.open(__s, __mode | ios_base::out))
this->clear();
else
this->setstate(ios_base::failbit);
}
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
void
basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
{
if (__sb_.open(__s, __mode | ios_base::out))
this->clear();
else
this->setstate(ios_base::failbit);
}
Implement a better copy_file. This patch improves both the performance, and the safety of the copy_file implementation. The performance improvements are achieved by using sendfile on Linux and copyfile on OS X when available. The TOCTOU hardening is achieved by opening the source and destination files and then using fstat to check their attributes to see if we can copy them. Unfortunately for the destination file, there is no way to open it without accidentally creating it, so we first have to use stat to determine if it exists, and if we should copy to it. Then, once we're sure we should try to copy, we open the dest file and ensure it names the same entity we previously stat'ed. llvm-svn: 337649
2018-07-22 10:00:53 +08:00
template <class _CharT, class _Traits>
void basic_ofstream<_CharT, _Traits>::__open(int __fd,
ios_base::openmode __mode) {
if (__sb_.__open(__fd, __mode | ios_base::out))
this->clear();
else
this->setstate(ios_base::failbit);
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void
basic_ofstream<_CharT, _Traits>::close()
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__sb_.close() == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
this->setstate(ios_base::failbit);
}
// basic_fstream
template <class _CharT, class _Traits>
[NFC] Rename _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS The name _LIBCPP_TYPE_VIS_ONLY is no longer accurate because both _LIBCPP_TYPE_VIS and _LIBCPP_TYPE_VIS_ONLY expand to __attribute__((__type_visibility__)) with Clang. The only remaining difference is that _LIBCPP_TYPE_VIS_ONLY can be applied to templates whereas _LIBCPP_TYPE_VIS cannot (due to dllimport/dllexport not being allowed on templates). This patch renames _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS. llvm-svn: 291035
2017-01-05 07:56:00 +08:00
class _LIBCPP_TEMPLATE_VIS basic_fstream
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
: public basic_iostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_fstream();
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
_LIBCPP_INLINE_VISIBILITY
explicit basic_fstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
#endif
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
[libc++] Make LIBCXX_ENABLE_FILESYSTEM fully consistent Previously, LIBCXX_ENABLE_FILESYSTEM controlled only whether the filesystem support was compiled into libc++'s library. This commit promotes the setting to a first-class option like LIBCXX_ENABLE_LOCALIZATION, where the whole library is aware of the setting and features that depend on <filesystem> won't be provided at all. The test suite is also properly annotated such that tests that depend on <filesystem> are disabled when the library doesn't support it. This is an alternative to https://llvm.org/D94824, but also an improvement along the lines of LIBCXX_ENABLE_LOCALIZATION that I had been wanting to make for a while. Differential Revision: https://reviews.llvm.org/D94921
2021-01-19 01:18:18 +08:00
#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
[libc++] Mark <filesystem> tests as failing when the dylib doesn't support filesystem This fixes CI for back-deployment testers on platforms that don't have <filesystem> support in the dylib. This is effectively half of https://reviews.llvm.org/D59224. The other half requires fixes in Clang. llvm-svn: 356558
2019-03-20 22:34:00 +08:00
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
explicit basic_fstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in | ios_base::out)
: basic_fstream(__p.c_str(), __mode) {}
#endif // _LIBCPP_STD_VER >= 17
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#ifndef _LIBCPP_CXX03_LANG
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_fstream(basic_fstream&& __rhs);
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_fstream& operator=(basic_fstream&& __rhs);
#endif
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void swap(basic_fstream& __rhs);
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf<char_type, traits_type>* rdbuf() const;
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
bool is_open() const;
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
[libc++] Make LIBCXX_ENABLE_FILESYSTEM fully consistent Previously, LIBCXX_ENABLE_FILESYSTEM controlled only whether the filesystem support was compiled into libc++'s library. This commit promotes the setting to a first-class option like LIBCXX_ENABLE_LOCALIZATION, where the whole library is aware of the setting and features that depend on <filesystem> won't be provided at all. The test suite is also properly annotated such that tests that depend on <filesystem> are disabled when the library doesn't support it. This is an alternative to https://llvm.org/D94824, but also an improvement along the lines of LIBCXX_ENABLE_LOCALIZATION that I had been wanting to make for a while. Differential Revision: https://reviews.llvm.org/D94921
2021-01-19 01:18:18 +08:00
#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
[libc++] Mark <filesystem> tests as failing when the dylib doesn't support filesystem This fixes CI for back-deployment testers on platforms that don't have <filesystem> support in the dylib. This is effectively half of https://reviews.llvm.org/D59224. The other half requires fixes in Clang. llvm-svn: 356558
2019-03-20 22:34:00 +08:00
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
Implement <filesystem> This patch implements the <filesystem> header and uses that to provide <experimental/filesystem>. Unlike other standard headers, the symbols needed for <filesystem> have not yet been placed in libc++.so. Instead they live in the new libc++fs.a library. Users of filesystem are required to link this library. (Also note that libc++experimental no longer contains the definition of <experimental/filesystem>, which now requires linking libc++fs). The reason for keeping <filesystem> out of the dylib for now is that it's still somewhat experimental, and the possibility of requiring an ABI breaking change is very real. In the future the symbols will likely be moved into the dylib, or the dylib will be made to link libc++fs automagically). Note that moving the symbols out of libc++experimental may break user builds until they update to -lc++fs. This should be OK, because the experimental library provides no stability guarantees. However, I plan on looking into ways we can force libc++experimental to automagically link libc++fs. In order to use a single implementation and set of tests for <filesystem>, it has been placed in a special `__fs` namespace. This namespace is inline in C++17 onward, but not before that. As such implementation is available in C++11 onward, but no filesystem namespace is present "directly", and as such name conflicts shouldn't occur in C++11 or C++14. llvm-svn: 338093
2018-07-27 11:07:09 +08:00
void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in|ios_base::out)
{ return open(__p.c_str(), __mode); }
#endif // _LIBCPP_STD_VER >= 17
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
_LIBCPP_INLINE_VISIBILITY
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void close();
private:
basic_filebuf<char_type, traits_type> __sb_;
};
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_fstream<_CharT, _Traits>::basic_fstream()
: basic_iostream<char_type, traits_type>(&__sb_)
{
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode)
: basic_iostream<char_type, traits_type>(&__sb_)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__sb_.open(__s, __mode) == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
this->setstate(ios_base::failbit);
}
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
template <class _CharT, class _Traits>
inline
basic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode)
: basic_iostream<char_type, traits_type>(&__sb_)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__sb_.open(__s, __mode) == nullptr)
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
this->setstate(ios_base::failbit);
}
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode)
: basic_iostream<char_type, traits_type>(&__sb_)
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__sb_.open(__s, __mode) == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
this->setstate(ios_base::failbit);
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#ifndef _LIBCPP_CXX03_LANG
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs)
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
: basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
{
this->set_rdbuf(&__sb_);
}
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_fstream<_CharT, _Traits>&
basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
return *this;
}
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in the input.output library llvm-svn: 300626
2017-04-19 07:38:41 +08:00
#endif // _LIBCPP_CXX03_LANG
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void
basic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs)
{
basic_iostream<char_type, traits_type>::swap(__rhs);
__sb_.swap(__rhs.__sb_);
}
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y)
{
__x.swap(__y);
}
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
basic_filebuf<_CharT, _Traits>*
basic_fstream<_CharT, _Traits>::rdbuf() const
{
return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
}
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
bool
basic_fstream<_CharT, _Traits>::is_open() const
{
return __sb_.is_open();
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
void
basic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
{
if (__sb_.open(__s, __mode))
this->clear();
else
this->setstate(ios_base::failbit);
}
libcxx: Provide overloads for basic_filebuf::open() et al that take wchar_t* filenames on Windows. This is an MSVC standard library extension. It seems like a reasonable enough extension to me because wchar_t* is the native format for filenames on that platform. Differential Revision: https://reviews.llvm.org/D42225 llvm-svn: 323170
2018-01-23 10:07:27 +08:00
#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
template <class _CharT, class _Traits>
void
basic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
{
if (__sb_.open(__s, __mode))
this->clear();
else
this->setstate(ios_base::failbit);
}
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
void
basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
{
if (__sb_.open(__s, __mode))
this->clear();
else
this->setstate(ios_base::failbit);
}
Add option to disable access to the global filesystem namespace. Systems like FreeBSD's Capsicum and Nuxi CloudABI apply the concept of capability-based security on the way processes can interact with the filesystem API. It is no longer possible to interact with the VFS through calls like open(), unlink(), rename(), etc. Instead, processes are only allowed to interact with files and directories to which they have been granted access. The *at() functions can be used for this purpose. This change adds a new config switch called _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE. If set, all functionality that requires the global filesystem namespace will be disabled. More concretely: - fstream's open() function will be removed. - cstdio will no longer pull in fopen(), rename(), etc. - The test suite's get_temp_file_name() will be removed. This will cause all tests that use the global filesystem namespace to break, but will at least make all the other tests run (as get_temp_file_name will not build anyway). It is important to mention that this change will make fstream rather useless on those systems for now. Still, I'd rather not have fstream disabled entirely, as it is of course possible to come up with an extension for fstream that would allow access to local filesystem namespaces (e.g., by adding an openat() member function). Differential revision: http://reviews.llvm.org/D8194 Reviewed by: jroelofs (thanks!) llvm-svn: 232049
2015-03-12 23:44:39 +08:00
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class _CharT, class _Traits>
Cleanup: move visibility/linkage attributes to the first declaration. http://reviews.llvm.org/D15404 llvm-svn: 267093
2016-04-22 09:04:55 +08:00
inline
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
void
basic_fstream<_CharT, _Traits>::close()
{
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-25 01:53:53 +08:00
if (__sb_.close() == nullptr)
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
this->setstate(ios_base::failbit);
}
[libc++] Instantiate additional <iostream> members in the dylib This commit adds new explicit instantiations for some classes in <iostream> in the library. This is done after noticing that many programs that use streams end up containing weak definitions of these classes, which has a negative impact on both code size and load times (due to the need to resolve weak symbols at load time). Note that we are just adding the additional explicit instantiations for the `char` specializations, since the `wchar_t` specializations are not used as often, and as a result there wouldn't be a clear benefit. This change is not an ABI break, since we are just adding additional symbols. Differential Revision: https://reviews.llvm.org/D90677
2020-10-21 23:11:45 +08:00
#if defined(_LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1)
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ifstream<char>)
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ofstream<char>)
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_filebuf<char>)
#endif
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
_LIBCPP_END_NAMESPACE_STD
[Libc++] Use #pragma push_macro/pop_macro to better handle min/max on Windows Summary: This patch improves how libc++ handles min/max macros within the headers. Previously libc++ would undef them and emit a warning. This patch changes libc++ to use `#pragma push_macro` to save the macro before undefining it, and `#pragma pop_macro` to restore the macros and the end of the header. Reviewers: mclow.lists, bcraig, compnerd, EricWF Reviewed By: EricWF Subscribers: cfe-commits, krytarowski Differential Revision: https://reviews.llvm.org/D33080 llvm-svn: 304357
2017-06-01 06:07:49 +08:00
_LIBCPP_POP_MACROS
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
#endif // _LIBCPP_FSTREAM