mirror of
https://github.com/ziglang/zig.git
synced 2025-12-08 07:13:08 +00:00
156ab87500
See: * https://discourse.llvm.org/t/rfc-freezing-c-03-headers-in-libc/77319 * https://discourse.llvm.org/t/rfc-project-hand-in-hand-llvm-libc-libc-code-sharing/77701 We're dropping support for C++03 for Zig due to the first change; it would be insane to ship 1018 duplicate header files just for this outdated use case. As a result of the second change, I had to bring in a subset of the headers from llvm-libc since libc++ now depends on these. Hopefully we can continue to get away with not copying the entirety of llvm-libc.
370 lines
11 KiB
C++
Vendored
370 lines
11 KiB
C++
Vendored
//===----------------------------------------------------------------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include <__assert>
|
|
#include <__config>
|
|
#include <__system_error/throw_system_error.h>
|
|
#include <__verbose_abort>
|
|
#include <cerrno>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <optional>
|
|
#include <string.h>
|
|
#include <string>
|
|
#include <system_error>
|
|
|
|
#include "include/config_elast.h"
|
|
|
|
#if defined(_LIBCPP_WIN32API)
|
|
# include <windows.h>
|
|
# include <winerror.h>
|
|
#endif
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
#if defined(_LIBCPP_WIN32API)
|
|
|
|
namespace {
|
|
std::optional<errc> __win_err_to_errc(int err) {
|
|
switch (err) {
|
|
case ERROR_ACCESS_DENIED:
|
|
return errc::permission_denied;
|
|
case ERROR_ALREADY_EXISTS:
|
|
return errc::file_exists;
|
|
case ERROR_BAD_NETPATH:
|
|
return errc::no_such_file_or_directory;
|
|
case ERROR_BAD_PATHNAME:
|
|
return errc::no_such_file_or_directory;
|
|
case ERROR_BAD_UNIT:
|
|
return errc::no_such_device;
|
|
case ERROR_BROKEN_PIPE:
|
|
return errc::broken_pipe;
|
|
case ERROR_BUFFER_OVERFLOW:
|
|
return errc::filename_too_long;
|
|
case ERROR_BUSY:
|
|
return errc::device_or_resource_busy;
|
|
case ERROR_BUSY_DRIVE:
|
|
return errc::device_or_resource_busy;
|
|
case ERROR_CANNOT_MAKE:
|
|
return errc::permission_denied;
|
|
case ERROR_CANTOPEN:
|
|
return errc::io_error;
|
|
case ERROR_CANTREAD:
|
|
return errc::io_error;
|
|
case ERROR_CANTWRITE:
|
|
return errc::io_error;
|
|
case ERROR_CURRENT_DIRECTORY:
|
|
return errc::permission_denied;
|
|
case ERROR_DEV_NOT_EXIST:
|
|
return errc::no_such_device;
|
|
case ERROR_DEVICE_IN_USE:
|
|
return errc::device_or_resource_busy;
|
|
case ERROR_DIR_NOT_EMPTY:
|
|
return errc::directory_not_empty;
|
|
case ERROR_DIRECTORY:
|
|
return errc::invalid_argument;
|
|
case ERROR_DISK_FULL:
|
|
return errc::no_space_on_device;
|
|
case ERROR_FILE_EXISTS:
|
|
return errc::file_exists;
|
|
case ERROR_FILE_NOT_FOUND:
|
|
return errc::no_such_file_or_directory;
|
|
case ERROR_HANDLE_DISK_FULL:
|
|
return errc::no_space_on_device;
|
|
case ERROR_INVALID_ACCESS:
|
|
return errc::permission_denied;
|
|
case ERROR_INVALID_DRIVE:
|
|
return errc::no_such_device;
|
|
case ERROR_INVALID_FUNCTION:
|
|
return errc::function_not_supported;
|
|
case ERROR_INVALID_HANDLE:
|
|
return errc::invalid_argument;
|
|
case ERROR_INVALID_NAME:
|
|
return errc::no_such_file_or_directory;
|
|
case ERROR_INVALID_PARAMETER:
|
|
return errc::invalid_argument;
|
|
case ERROR_LOCK_VIOLATION:
|
|
return errc::no_lock_available;
|
|
case ERROR_LOCKED:
|
|
return errc::no_lock_available;
|
|
case ERROR_NEGATIVE_SEEK:
|
|
return errc::invalid_argument;
|
|
case ERROR_NOACCESS:
|
|
return errc::permission_denied;
|
|
case ERROR_NOT_ENOUGH_MEMORY:
|
|
return errc::not_enough_memory;
|
|
case ERROR_NOT_READY:
|
|
return errc::resource_unavailable_try_again;
|
|
case ERROR_NOT_SAME_DEVICE:
|
|
return errc::cross_device_link;
|
|
case ERROR_NOT_SUPPORTED:
|
|
return errc::not_supported;
|
|
case ERROR_OPEN_FAILED:
|
|
return errc::io_error;
|
|
case ERROR_OPEN_FILES:
|
|
return errc::device_or_resource_busy;
|
|
case ERROR_OPERATION_ABORTED:
|
|
return errc::operation_canceled;
|
|
case ERROR_OUTOFMEMORY:
|
|
return errc::not_enough_memory;
|
|
case ERROR_PATH_NOT_FOUND:
|
|
return errc::no_such_file_or_directory;
|
|
case ERROR_READ_FAULT:
|
|
return errc::io_error;
|
|
case ERROR_REPARSE_TAG_INVALID:
|
|
return errc::invalid_argument;
|
|
case ERROR_RETRY:
|
|
return errc::resource_unavailable_try_again;
|
|
case ERROR_SEEK:
|
|
return errc::io_error;
|
|
case ERROR_SHARING_VIOLATION:
|
|
return errc::permission_denied;
|
|
case ERROR_TOO_MANY_OPEN_FILES:
|
|
return errc::too_many_files_open;
|
|
case ERROR_WRITE_FAULT:
|
|
return errc::io_error;
|
|
case ERROR_WRITE_PROTECT:
|
|
return errc::permission_denied;
|
|
default:
|
|
return {};
|
|
}
|
|
}
|
|
} // namespace
|
|
#endif
|
|
|
|
namespace {
|
|
#if _LIBCPP_HAS_THREADS
|
|
|
|
// GLIBC also uses 1024 as the maximum buffer size internally.
|
|
constexpr size_t strerror_buff_size = 1024;
|
|
|
|
string do_strerror_r(int ev);
|
|
|
|
# if defined(_LIBCPP_MSVCRT_LIKE)
|
|
string do_strerror_r(int ev) {
|
|
char buffer[strerror_buff_size];
|
|
if (::strerror_s(buffer, strerror_buff_size, ev) == 0)
|
|
return string(buffer);
|
|
std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
|
|
return string(buffer);
|
|
}
|
|
# else
|
|
|
|
// Only one of the two following functions will be used, depending on
|
|
// the return type of strerror_r:
|
|
|
|
// For the GNU variant, a char* return value:
|
|
__attribute__((unused)) const char* handle_strerror_r_return(char* strerror_return, char* buffer) {
|
|
// GNU always returns a string pointer in its return value. The
|
|
// string might point to either the input buffer, or a static
|
|
// buffer, but we don't care which.
|
|
return strerror_return;
|
|
}
|
|
|
|
// For the POSIX variant: an int return value.
|
|
__attribute__((unused)) const char* handle_strerror_r_return(int strerror_return, char* buffer) {
|
|
// The POSIX variant either:
|
|
// - fills in the provided buffer and returns 0
|
|
// - returns a positive error value, or
|
|
// - returns -1 and fills in errno with an error value.
|
|
if (strerror_return == 0)
|
|
return buffer;
|
|
|
|
// Only handle EINVAL. Other errors abort.
|
|
int new_errno = strerror_return == -1 ? errno : strerror_return;
|
|
if (new_errno == EINVAL)
|
|
return "";
|
|
|
|
_LIBCPP_ASSERT_INTERNAL(new_errno == ERANGE, "unexpected error from ::strerror_r");
|
|
// FIXME maybe? 'strerror_buff_size' is likely to exceed the
|
|
// maximum error size so ERANGE shouldn't be returned.
|
|
std::abort();
|
|
}
|
|
|
|
// This function handles both GNU and POSIX variants, dispatching to
|
|
// one of the two above functions.
|
|
string do_strerror_r(int ev) {
|
|
char buffer[strerror_buff_size];
|
|
// Preserve errno around the call. (The C++ standard requires that
|
|
// system_error functions not modify errno).
|
|
const int old_errno = errno;
|
|
const char* error_message = handle_strerror_r_return(::strerror_r(ev, buffer, strerror_buff_size), buffer);
|
|
// If we didn't get any message, print one now.
|
|
if (!error_message[0]) {
|
|
std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
|
|
error_message = buffer;
|
|
}
|
|
errno = old_errno;
|
|
return string(error_message);
|
|
}
|
|
# endif
|
|
|
|
#endif // _LIBCPP_HAS_THREADS
|
|
|
|
string make_error_str(const error_code& ec, string what_arg) {
|
|
if (ec) {
|
|
if (!what_arg.empty()) {
|
|
what_arg += ": ";
|
|
}
|
|
what_arg += ec.message();
|
|
}
|
|
return what_arg;
|
|
}
|
|
|
|
string make_error_str(const error_code& ec) {
|
|
if (ec) {
|
|
return ec.message();
|
|
}
|
|
return string();
|
|
}
|
|
} // namespace
|
|
|
|
string __do_message::message(int ev) const {
|
|
#if !_LIBCPP_HAS_THREADS
|
|
return string(::strerror(ev));
|
|
#else
|
|
return do_strerror_r(ev);
|
|
#endif
|
|
}
|
|
|
|
class _LIBCPP_HIDDEN __generic_error_category : public __do_message {
|
|
public:
|
|
virtual const char* name() const noexcept;
|
|
virtual string message(int ev) const;
|
|
};
|
|
|
|
const char* __generic_error_category::name() const noexcept { return "generic"; }
|
|
|
|
string __generic_error_category::message(int ev) const {
|
|
#ifdef _LIBCPP_ELAST
|
|
if (ev > _LIBCPP_ELAST)
|
|
return string("unspecified generic_category error");
|
|
#endif // _LIBCPP_ELAST
|
|
return __do_message::message(ev);
|
|
}
|
|
|
|
const error_category& generic_category() noexcept {
|
|
union AvoidDestroyingGenericCategory {
|
|
__generic_error_category generic_error_category;
|
|
constexpr explicit AvoidDestroyingGenericCategory() : generic_error_category() {}
|
|
~AvoidDestroyingGenericCategory() {}
|
|
};
|
|
constinit static AvoidDestroyingGenericCategory helper;
|
|
return helper.generic_error_category;
|
|
}
|
|
|
|
class _LIBCPP_HIDDEN __system_error_category : public __do_message {
|
|
public:
|
|
virtual const char* name() const noexcept;
|
|
virtual string message(int ev) const;
|
|
virtual error_condition default_error_condition(int ev) const noexcept;
|
|
};
|
|
|
|
const char* __system_error_category::name() const noexcept { return "system"; }
|
|
|
|
string __system_error_category::message(int ev) const {
|
|
#ifdef _LIBCPP_WIN32API
|
|
std::string result;
|
|
char* str = nullptr;
|
|
unsigned long num_chars = ::FormatMessageA(
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
nullptr,
|
|
ev,
|
|
0,
|
|
reinterpret_cast<char*>(&str),
|
|
0,
|
|
nullptr);
|
|
auto is_whitespace = [](char ch) { return ch == '\n' || ch == '\r' || ch == ' '; };
|
|
while (num_chars > 0 && is_whitespace(str[num_chars - 1]))
|
|
--num_chars;
|
|
|
|
if (num_chars)
|
|
result = std::string(str, num_chars);
|
|
else
|
|
result = "Unknown error";
|
|
|
|
LocalFree(str);
|
|
return result;
|
|
#else
|
|
# ifdef _LIBCPP_ELAST
|
|
if (ev > _LIBCPP_ELAST)
|
|
return string("unspecified system_category error");
|
|
# endif // _LIBCPP_ELAST
|
|
return __do_message::message(ev);
|
|
#endif
|
|
}
|
|
|
|
error_condition __system_error_category::default_error_condition(int ev) const noexcept {
|
|
#ifdef _LIBCPP_WIN32API
|
|
// Remap windows error codes to generic error codes if possible.
|
|
if (ev == 0)
|
|
return error_condition(0, generic_category());
|
|
if (auto maybe_errc = __win_err_to_errc(ev))
|
|
return error_condition(static_cast<int>(*maybe_errc), generic_category());
|
|
return error_condition(ev, system_category());
|
|
#else
|
|
# ifdef _LIBCPP_ELAST
|
|
if (ev > _LIBCPP_ELAST)
|
|
return error_condition(ev, system_category());
|
|
# endif // _LIBCPP_ELAST
|
|
return error_condition(ev, generic_category());
|
|
#endif
|
|
}
|
|
|
|
const error_category& system_category() noexcept {
|
|
union AvoidDestroyingSystemCategory {
|
|
__system_error_category system_error_category;
|
|
constexpr explicit AvoidDestroyingSystemCategory() : system_error_category() {}
|
|
~AvoidDestroyingSystemCategory() {}
|
|
};
|
|
constinit static AvoidDestroyingSystemCategory helper;
|
|
return helper.system_error_category;
|
|
}
|
|
|
|
// error_condition
|
|
|
|
string error_condition::message() const { return __cat_->message(__val_); }
|
|
|
|
// error_code
|
|
|
|
string error_code::message() const { return __cat_->message(__val_); }
|
|
|
|
// system_error
|
|
|
|
system_error::system_error(error_code ec, const string& what_arg)
|
|
: runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
|
|
|
|
system_error::system_error(error_code ec, const char* what_arg)
|
|
: runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
|
|
|
|
system_error::system_error(error_code ec) : runtime_error(make_error_str(ec)), __ec_(ec) {}
|
|
|
|
system_error::system_error(int ev, const error_category& ecat, const string& what_arg)
|
|
: runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
|
|
|
|
system_error::system_error(int ev, const error_category& ecat, const char* what_arg)
|
|
: runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
|
|
|
|
system_error::system_error(int ev, const error_category& ecat)
|
|
: runtime_error(make_error_str(error_code(ev, ecat))), __ec_(error_code(ev, ecat)) {}
|
|
|
|
system_error::~system_error() noexcept {}
|
|
|
|
void __throw_system_error(int ev, const char* what_arg) {
|
|
#if _LIBCPP_HAS_EXCEPTIONS
|
|
std::__throw_system_error(error_code(ev, generic_category()), what_arg);
|
|
#else
|
|
// The above could also handle the no-exception case, but for size, avoid referencing system_category() unnecessarily.
|
|
_LIBCPP_VERBOSE_ABORT(
|
|
"system_error was thrown in -fno-exceptions mode with error %i and message \"%s\"", ev, what_arg);
|
|
#endif
|
|
}
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|