зеркало из https://github.com/microsoft/STL.git
682 строки
26 KiB
C++
682 строки
26 KiB
C++
// system_error standard header
|
|
|
|
// Copyright (c) Microsoft Corporation.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
|
#pragma once
|
|
#ifndef _SYSTEM_ERROR_
|
|
#define _SYSTEM_ERROR_
|
|
#include <yvals.h>
|
|
#if _STL_COMPILER_PREPROCESSOR
|
|
#include <__msvc_system_error_abi.hpp>
|
|
#include <cerrno>
|
|
#include <cstdlib>
|
|
#include <stdexcept>
|
|
#include <xcall_once.h>
|
|
#include <xerrc.h>
|
|
#ifndef _M_CEE_PURE
|
|
#include <atomic>
|
|
#endif // _M_CEE_PURE
|
|
|
|
#if _HAS_CXX20
|
|
#include <compare>
|
|
#endif // _HAS_CXX20
|
|
|
|
#pragma pack(push, _CRT_PACKING)
|
|
#pragma warning(push, _STL_WARNING_LEVEL)
|
|
#pragma warning(disable : _STL_DISABLED_WARNINGS)
|
|
_STL_DISABLE_CLANG_WARNINGS
|
|
#pragma push_macro("new")
|
|
#undef new
|
|
|
|
_STD_BEGIN
|
|
// ENUM CLASS io_errc
|
|
enum class io_errc { // error codes for ios_base::failure
|
|
stream = 1
|
|
};
|
|
|
|
// STRUCT TEMPLATE is_error_code_enum
|
|
template <class _Enum>
|
|
struct is_error_code_enum : false_type {};
|
|
|
|
template <>
|
|
struct is_error_code_enum<io_errc> : true_type {};
|
|
|
|
template <class _Ty>
|
|
_INLINE_VAR constexpr bool is_error_code_enum_v = is_error_code_enum<_Ty>::value;
|
|
|
|
// STRUCT TEMPLATE is_error_condition_enum
|
|
template <class _Enum>
|
|
struct is_error_condition_enum : false_type {};
|
|
|
|
template <>
|
|
struct is_error_condition_enum<errc> : true_type {};
|
|
|
|
template <class _Ty>
|
|
_INLINE_VAR constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Ty>::value;
|
|
|
|
class error_code;
|
|
class error_condition;
|
|
_NODISCARD error_code make_error_code(errc) noexcept;
|
|
_NODISCARD error_code make_error_code(io_errc) noexcept;
|
|
_NODISCARD error_condition make_error_condition(errc) noexcept;
|
|
_NODISCARD error_condition make_error_condition(io_errc) noexcept;
|
|
|
|
// CLASS error_category
|
|
class error_category;
|
|
|
|
_NODISCARD const error_category& generic_category() noexcept;
|
|
_NODISCARD const error_category& iostream_category() noexcept;
|
|
_NODISCARD const error_category& system_category() noexcept;
|
|
|
|
class __declspec(novtable) error_category { // categorize an error
|
|
public:
|
|
/* constexpr */ error_category() noexcept { // TRANSITION, ABI
|
|
_Addr = reinterpret_cast<uintptr_t>(this);
|
|
}
|
|
|
|
#ifdef __cpp_constexpr_dynamic_alloc
|
|
constexpr
|
|
#endif
|
|
virtual ~error_category() noexcept = default;
|
|
|
|
_NODISCARD virtual const char* name() const noexcept = 0;
|
|
|
|
_NODISCARD virtual string message(int _Errval) const = 0;
|
|
|
|
_NODISCARD virtual error_condition default_error_condition(int _Errval) const noexcept;
|
|
|
|
_NODISCARD virtual bool equivalent(int _Errval, const error_condition& _Cond) const noexcept;
|
|
|
|
_NODISCARD virtual bool equivalent(const error_code& _Code, int _Errval) const noexcept;
|
|
|
|
_NODISCARD bool operator==(const error_category& _Right) const noexcept {
|
|
return _Addr == _Right._Addr;
|
|
}
|
|
|
|
#if !_HAS_CXX20
|
|
_NODISCARD bool operator!=(const error_category& _Right) const noexcept {
|
|
return !(*this == _Right);
|
|
}
|
|
#endif // !_HAS_CXX20
|
|
|
|
// TRANSITION, GH-489
|
|
#ifdef __cpp_lib_concepts
|
|
_NODISCARD strong_ordering operator<=>(const error_category& _Right) const noexcept {
|
|
return compare_three_way{}(_Addr, _Right._Addr);
|
|
}
|
|
#else // ^^^ defined(__cpp_lib_concepts) / !defined(__cpp_lib_concepts) vvv
|
|
_NODISCARD bool operator<(const error_category& _Right) const noexcept {
|
|
return _Addr < _Right._Addr;
|
|
}
|
|
#endif // ^^^ !defined(__cpp_lib_concepts) ^^^
|
|
|
|
error_category(const error_category&) = delete;
|
|
error_category& operator=(const error_category&) = delete;
|
|
|
|
protected:
|
|
uintptr_t _Addr;
|
|
|
|
constexpr explicit error_category(const uintptr_t _Addr_) noexcept : _Addr(_Addr_) {}
|
|
|
|
enum : uintptr_t { // symbolic addresses for Standard error_category objects
|
|
_Future_addr = 1,
|
|
_Generic_addr = 3,
|
|
_Iostream_addr = 5,
|
|
_System_addr = 7
|
|
};
|
|
};
|
|
|
|
#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
|
|
_NODISCARD inline bool _System_error_equal(const error_code&, const error_condition&) noexcept;
|
|
#endif // _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
|
|
|
|
// CLASS error_code
|
|
class error_code { // store an implementation-specific error code and category
|
|
public:
|
|
error_code() noexcept : _Myval(0), _Mycat(&_STD system_category()) {} // construct non-error
|
|
|
|
error_code(int _Val, const error_category& _Cat) noexcept : _Myval(_Val), _Mycat(&_Cat) {}
|
|
|
|
template <class _Enum, enable_if_t<is_error_code_enum_v<_Enum>, int> = 0>
|
|
error_code(_Enum _Errcode) noexcept : _Myval(0), _Mycat(nullptr) {
|
|
*this = make_error_code(_Errcode); // using ADL
|
|
}
|
|
|
|
void assign(int _Val, const error_category& _Cat) noexcept {
|
|
_Myval = _Val;
|
|
_Mycat = &_Cat;
|
|
}
|
|
|
|
template <class _Enum, enable_if_t<is_error_code_enum_v<_Enum>, int> = 0>
|
|
error_code& operator=(_Enum _Errcode) noexcept {
|
|
*this = make_error_code(_Errcode); // using ADL
|
|
return *this;
|
|
}
|
|
|
|
void clear() noexcept {
|
|
_Myval = 0;
|
|
_Mycat = &_STD system_category();
|
|
}
|
|
|
|
_NODISCARD int value() const noexcept {
|
|
return _Myval;
|
|
}
|
|
|
|
_NODISCARD const error_category& category() const noexcept {
|
|
return *_Mycat;
|
|
}
|
|
|
|
_NODISCARD error_condition default_error_condition() const noexcept;
|
|
|
|
_NODISCARD string message() const {
|
|
return category().message(value());
|
|
}
|
|
|
|
explicit operator bool() const noexcept {
|
|
return value() != 0;
|
|
}
|
|
|
|
#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
|
|
_NODISCARD friend bool operator==(const error_code& _Left, const error_code& _Right) noexcept {
|
|
return _Left.category() == _Right.category() && _Left.value() == _Right.value();
|
|
}
|
|
|
|
_NODISCARD friend bool operator==(const error_code& _Left, const error_condition& _Right) noexcept {
|
|
return _System_error_equal(_Left, _Right);
|
|
}
|
|
|
|
// TRANSITION, GH-489
|
|
#ifdef __cpp_lib_concepts
|
|
_NODISCARD friend strong_ordering operator<=>(const error_code& _Left, const error_code& _Right) noexcept {
|
|
if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
|
|
return _Result;
|
|
}
|
|
return _Left.value() <=> _Right.value();
|
|
}
|
|
#else // ^^^ defined(__cpp_lib_concepts) / !defined(__cpp_lib_concepts) vvv
|
|
_NODISCARD friend bool operator<(const error_code& _Left, const error_code& _Right) noexcept {
|
|
return _Left.category() < _Right.category()
|
|
|| (_Left.category() == _Right.category() && _Left.value() < _Right.value());
|
|
}
|
|
#endif // ^^^ !defined(__cpp_lib_concepts) ^^^
|
|
#if !_HAS_CXX20
|
|
_NODISCARD friend bool operator==(const error_condition& _Left, const error_code& _Right) noexcept {
|
|
return _System_error_equal(_Right, _Left);
|
|
}
|
|
|
|
_NODISCARD friend bool operator!=(const error_code& _Left, const error_code& _Right) noexcept {
|
|
return !(_Left == _Right);
|
|
}
|
|
|
|
_NODISCARD friend bool operator!=(const error_code& _Left, const error_condition& _Right) noexcept {
|
|
return !_System_error_equal(_Left, _Right);
|
|
}
|
|
|
|
_NODISCARD friend bool operator!=(const error_condition& _Left, const error_code& _Right) noexcept {
|
|
return !_System_error_equal(_Right, _Left);
|
|
}
|
|
#endif // !_HAS_CXX20
|
|
#endif // _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
|
|
|
|
private:
|
|
int _Myval; // the stored error number
|
|
const error_category* _Mycat; // pointer to error category
|
|
};
|
|
|
|
// CLASS error_condition
|
|
class error_condition { // store an abstract error code and category
|
|
public:
|
|
error_condition() noexcept : _Myval(0), _Mycat(&_STD generic_category()) {} // construct non-error
|
|
|
|
error_condition(int _Val, const error_category& _Cat) noexcept : _Myval(_Val), _Mycat(&_Cat) {}
|
|
|
|
template <class _Enum, enable_if_t<is_error_condition_enum_v<_Enum>, int> = 0>
|
|
error_condition(_Enum _Errcode) noexcept : _Myval(0), _Mycat(nullptr) {
|
|
*this = make_error_condition(_Errcode); // using ADL
|
|
}
|
|
|
|
void assign(int _Val, const error_category& _Cat) noexcept {
|
|
_Myval = _Val;
|
|
_Mycat = &_Cat;
|
|
}
|
|
|
|
template <class _Enum, enable_if_t<is_error_condition_enum_v<_Enum>, int> = 0>
|
|
error_condition& operator=(_Enum _Errcode) noexcept {
|
|
*this = make_error_condition(_Errcode); // using ADL
|
|
return *this;
|
|
}
|
|
|
|
void clear() noexcept {
|
|
_Myval = 0;
|
|
_Mycat = &_STD generic_category();
|
|
}
|
|
|
|
_NODISCARD int value() const noexcept {
|
|
return _Myval;
|
|
}
|
|
|
|
_NODISCARD const error_category& category() const noexcept {
|
|
return *_Mycat;
|
|
}
|
|
|
|
_NODISCARD string message() const {
|
|
return category().message(value());
|
|
}
|
|
|
|
explicit operator bool() const noexcept {
|
|
return value() != 0;
|
|
}
|
|
|
|
#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
|
|
_NODISCARD friend bool operator==(const error_condition& _Left, const error_condition& _Right) noexcept {
|
|
return _Left.category() == _Right.category() && _Left.value() == _Right.value();
|
|
}
|
|
|
|
// TRANSITION, GH-489
|
|
#ifdef __cpp_lib_concepts
|
|
_NODISCARD friend strong_ordering operator<=>(
|
|
const error_condition& _Left, const error_condition& _Right) noexcept {
|
|
if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
|
|
return _Result;
|
|
}
|
|
return _Left.value() <=> _Right.value();
|
|
}
|
|
#else // ^^^ defined(__cpp_lib_concepts) / !defined(__cpp_lib_concepts) vvv
|
|
_NODISCARD friend bool operator<(const error_condition& _Left, const error_condition& _Right) noexcept {
|
|
return _Left.category() < _Right.category()
|
|
|| (_Left.category() == _Right.category() && _Left.value() < _Right.value());
|
|
}
|
|
#endif // ^^^ !defined(__cpp_lib_concepts) ^^^
|
|
#if !_HAS_CXX20
|
|
_NODISCARD friend bool operator!=(const error_condition& _Left, const error_condition& _Right) noexcept {
|
|
return !(_Left == _Right);
|
|
}
|
|
#endif // !_HAS_CXX20
|
|
|
|
// We grant friendship to the operators from error_code here to allow is_error_code_enum_v but not
|
|
// is_error_condition_enum_v enums to be compared directly with error_condition; for example:
|
|
// io_errc::stream == make_error_condition(errc::out_of_memory)
|
|
friend bool operator==(const error_code& _Left, const error_condition& _Right) noexcept;
|
|
#if !_HAS_CXX20
|
|
friend bool operator==(const error_condition& _Left, const error_code& _Right) noexcept;
|
|
friend bool operator!=(const error_code& _Left, const error_condition& _Right) noexcept;
|
|
friend bool operator!=(const error_condition& _Left, const error_code& _Right) noexcept;
|
|
#endif // !_HAS_CXX20
|
|
#endif // _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
|
|
|
|
private:
|
|
int _Myval; // the stored error number
|
|
const error_category* _Mycat; // pointer to error category
|
|
};
|
|
|
|
#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
|
|
_NODISCARD inline bool _System_error_equal(const error_code& _Left, const error_condition& _Right) noexcept {
|
|
return _Left.category().equivalent(_Left.value(), _Right) || _Right.category().equivalent(_Left, _Right.value());
|
|
}
|
|
#else // ^^^ _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS // !_STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS vvv
|
|
_NODISCARD inline bool operator==(const error_code& _Left, const error_code& _Right) noexcept {
|
|
return _Left.category() == _Right.category() && _Left.value() == _Right.value();
|
|
}
|
|
|
|
_NODISCARD inline bool operator==(const error_code& _Left, const error_condition& _Right) noexcept {
|
|
return _Left.category().equivalent(_Left.value(), _Right) || _Right.category().equivalent(_Left, _Right.value());
|
|
}
|
|
|
|
_NODISCARD inline bool operator==(const error_condition& _Left, const error_condition& _Right) noexcept {
|
|
return _Left.category() == _Right.category() && _Left.value() == _Right.value();
|
|
}
|
|
|
|
// TRANSITION, GH-489
|
|
#ifdef __cpp_lib_concepts
|
|
_NODISCARD inline strong_ordering operator<=>(const error_code& _Left, const error_code& _Right) noexcept {
|
|
if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
|
|
return _Result;
|
|
}
|
|
return _Left.value() <=> _Right.value();
|
|
}
|
|
|
|
_NODISCARD inline strong_ordering operator<=>(const error_condition& _Left, const error_condition& _Right) noexcept {
|
|
if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
|
|
return _Result;
|
|
}
|
|
return _Left.value() <=> _Right.value();
|
|
}
|
|
#else // ^^^ defined(__cpp_lib_concepts) / !defined(__cpp_lib_concepts) vvv
|
|
_NODISCARD inline bool operator<(const error_code& _Left, const error_code& _Right) noexcept {
|
|
return _Left.category() < _Right.category()
|
|
|| (_Left.category() == _Right.category() && _Left.value() < _Right.value());
|
|
}
|
|
|
|
_NODISCARD inline bool operator<(const error_condition& _Left, const error_condition& _Right) noexcept {
|
|
return _Left.category() < _Right.category()
|
|
|| (_Left.category() == _Right.category() && _Left.value() < _Right.value());
|
|
}
|
|
#endif // ^^^ !defined(__cpp_lib_concepts) ^^^
|
|
|
|
#if !_HAS_CXX20
|
|
_NODISCARD inline bool operator==(const error_condition& _Left, const error_code& _Right) noexcept {
|
|
return _Right.category().equivalent(_Right.value(), _Left) || _Left.category().equivalent(_Right, _Left.value());
|
|
}
|
|
|
|
_NODISCARD inline bool operator!=(const error_code& _Left, const error_code& _Right) noexcept {
|
|
return !(_Left == _Right);
|
|
}
|
|
|
|
_NODISCARD inline bool operator!=(const error_code& _Left, const error_condition& _Right) noexcept {
|
|
return !(_Left == _Right);
|
|
}
|
|
|
|
_NODISCARD inline bool operator!=(const error_condition& _Left, const error_code& _Right) noexcept {
|
|
return !(_Left == _Right);
|
|
}
|
|
|
|
_NODISCARD inline bool operator!=(const error_condition& _Left, const error_condition& _Right) noexcept {
|
|
return !(_Left == _Right);
|
|
}
|
|
#endif // !_HAS_CXX20
|
|
#endif // _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
|
|
|
|
// VIRTUALS FOR error_category
|
|
_NODISCARD inline error_condition error_category::default_error_condition(int _Errval) const noexcept {
|
|
// make error_condition for error code
|
|
return error_condition(_Errval, *this);
|
|
}
|
|
|
|
_NODISCARD inline bool error_category::equivalent(int _Errval, const error_condition& _Cond) const noexcept {
|
|
return default_error_condition(_Errval) == _Cond;
|
|
}
|
|
|
|
_NODISCARD inline bool error_category::equivalent(const error_code& _Code, int _Errval) const noexcept {
|
|
return *this == _Code.category() && _Code.value() == _Errval;
|
|
}
|
|
|
|
// MEMBER FUNCTIONS for error_code
|
|
_NODISCARD inline error_condition error_code::default_error_condition() const noexcept {
|
|
// make error_condition for error code
|
|
return category().default_error_condition(value());
|
|
}
|
|
|
|
// FUNCTION make_error_code
|
|
_NODISCARD inline error_code make_error_code(errc _Errno) noexcept {
|
|
return error_code(static_cast<int>(_Errno), _STD generic_category());
|
|
}
|
|
|
|
_NODISCARD inline error_code make_error_code(io_errc _Errno) noexcept {
|
|
return error_code(static_cast<int>(_Errno), _STD iostream_category());
|
|
}
|
|
|
|
// FUNCTION make_error_condition
|
|
_NODISCARD inline error_condition make_error_condition(errc _Errno) noexcept {
|
|
return error_condition(static_cast<int>(_Errno), _STD generic_category());
|
|
}
|
|
|
|
_NODISCARD inline error_condition make_error_condition(io_errc _Errno) noexcept {
|
|
return error_condition(static_cast<int>(_Errno), _STD iostream_category());
|
|
}
|
|
|
|
// STRUCT TEMPLATE SPECIALIZATION hash
|
|
template <>
|
|
struct hash<error_code> {
|
|
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef error_code _ARGUMENT_TYPE_NAME;
|
|
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef size_t _RESULT_TYPE_NAME;
|
|
|
|
_NODISCARD size_t operator()(const error_code& _Keyval) const noexcept {
|
|
return hash<int>{}(_Keyval.value());
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct hash<error_condition> {
|
|
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef error_condition _ARGUMENT_TYPE_NAME;
|
|
_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef size_t _RESULT_TYPE_NAME;
|
|
|
|
_NODISCARD size_t operator()(const error_condition& _Keyval) const noexcept {
|
|
return hash<int>{}(_Keyval.value());
|
|
}
|
|
};
|
|
|
|
// CLASS system_error
|
|
class _System_error : public runtime_error { // base of all system-error exceptions
|
|
private:
|
|
static string _Makestr(error_code _Errcode, string _Message) { // compose error message
|
|
if (!_Message.empty()) {
|
|
_Message.append(": ");
|
|
}
|
|
|
|
_Message.append(_Errcode.message());
|
|
return _Message;
|
|
}
|
|
|
|
protected:
|
|
_System_error(error_code _Errcode, const string& _Message)
|
|
: runtime_error(_Makestr(_Errcode, _Message)), _Mycode(_Errcode) {}
|
|
|
|
error_code _Mycode; // the stored error code
|
|
};
|
|
|
|
class system_error : public _System_error { // base of all system-error exceptions
|
|
private:
|
|
using _Mybase = _System_error;
|
|
|
|
public:
|
|
system_error(error_code _Errcode) : _Mybase(_Errcode, "") {}
|
|
|
|
system_error(error_code _Errcode, const string& _Message) : _Mybase(_Errcode, _Message) {}
|
|
|
|
system_error(error_code _Errcode, const char* _Message) : _Mybase(_Errcode, _Message) {}
|
|
|
|
system_error(int _Errval, const error_category& _Errcat) : _Mybase(error_code(_Errval, _Errcat), "") {}
|
|
|
|
system_error(int _Errval, const error_category& _Errcat, const string& _Message)
|
|
: _Mybase(error_code(_Errval, _Errcat), _Message) {}
|
|
|
|
system_error(int _Errval, const error_category& _Errcat, const char* _Message)
|
|
: _Mybase(error_code(_Errval, _Errcat), _Message) {}
|
|
|
|
_NODISCARD const error_code& code() const noexcept {
|
|
return _Mycode;
|
|
}
|
|
|
|
#if !_HAS_EXCEPTIONS
|
|
protected:
|
|
virtual void _Doraise() const override { // perform class-specific exception handling
|
|
_RAISE(*this);
|
|
}
|
|
#endif // !_HAS_EXCEPTIONS
|
|
};
|
|
|
|
[[noreturn]] inline void _Throw_system_error(const errc _Errno) {
|
|
_THROW(system_error{_STD make_error_code(_Errno)});
|
|
}
|
|
|
|
_CRTIMP2_PURE const char* __CLRCALL_PURE_OR_CDECL _Syserror_map(int);
|
|
_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Winerror_map(int);
|
|
|
|
struct _System_error_message {
|
|
char* _Str;
|
|
size_t _Length;
|
|
|
|
explicit _System_error_message(const unsigned long _Ec) noexcept
|
|
: _Str(nullptr), _Length(_CSTD __std_system_error_allocate_message(_Ec, &_Str)) {}
|
|
|
|
_System_error_message(const _System_error_message&) = delete;
|
|
_System_error_message& operator=(const _System_error_message&) = delete;
|
|
|
|
~_System_error_message() {
|
|
_CSTD __std_system_error_deallocate_message(_Str);
|
|
}
|
|
};
|
|
|
|
class _Generic_error_category : public error_category { // categorize a generic error
|
|
public:
|
|
constexpr _Generic_error_category() noexcept : error_category(_Generic_addr) {}
|
|
|
|
_NODISCARD virtual const char* name() const noexcept override {
|
|
return "generic";
|
|
}
|
|
|
|
_NODISCARD virtual string message(int _Errcode) const override {
|
|
return _Syserror_map(_Errcode);
|
|
}
|
|
};
|
|
|
|
class _Iostream_error_category2 : public error_category { // categorize an iostream error
|
|
public:
|
|
constexpr _Iostream_error_category2() noexcept : error_category(_Iostream_addr) {}
|
|
|
|
_NODISCARD virtual const char* name() const noexcept override {
|
|
return "iostream";
|
|
}
|
|
|
|
_NODISCARD virtual string message(int _Errcode) const override {
|
|
if (_Errcode == static_cast<int>(io_errc::stream)) {
|
|
static constexpr char _Iostream_error[] = "iostream stream error";
|
|
constexpr size_t _Iostream_error_length = sizeof(_Iostream_error) - 1; // TRANSITION, DevCom-906503
|
|
return string(_Iostream_error, _Iostream_error_length);
|
|
} else {
|
|
return _Syserror_map(_Errcode);
|
|
}
|
|
}
|
|
};
|
|
|
|
class _System_error_category : public error_category { // categorize an operating system error
|
|
public:
|
|
constexpr _System_error_category() noexcept : error_category(_System_addr) {}
|
|
|
|
_NODISCARD virtual const char* name() const noexcept override {
|
|
return "system";
|
|
}
|
|
|
|
_NODISCARD virtual string message(int _Errcode) const override {
|
|
const _System_error_message _Msg(static_cast<unsigned long>(_Errcode));
|
|
if (_Msg._Length == 0) {
|
|
static constexpr char _Unknown_error[] = "unknown error";
|
|
constexpr size_t _Unknown_error_length = sizeof(_Unknown_error) - 1; // TRANSITION, DevCom-906503
|
|
return string(_Unknown_error, _Unknown_error_length);
|
|
} else {
|
|
return string(_Msg._Str, _Msg._Length);
|
|
}
|
|
}
|
|
|
|
_NODISCARD virtual error_condition default_error_condition(int _Errval) const noexcept override {
|
|
// make error_condition for error code (generic if possible)
|
|
const int _Posv = _Winerror_map(_Errval);
|
|
if (_Posv == 0) {
|
|
return error_condition(_Errval, _STD system_category());
|
|
} else {
|
|
return error_condition(_Posv, _STD generic_category());
|
|
}
|
|
}
|
|
};
|
|
|
|
// _Immortalize_memcpy_image is used to provide a nonstandard guarantee.
|
|
// Specifically, we want the error category objects returned from things like std::system_category() to always
|
|
// be available, even during DLL unload (otherwise, <system_error> would be a huge regression vs. legacy error codes).
|
|
// Moreover, we need to be very conservative in the runtime support we request. Thus, we have these constraints:
|
|
//
|
|
// * can't use magic statics in standard modes, because that would inject a .TLS section into all binaries using
|
|
// <system_error> and would likely put borderline programs over the TLS slot count limit, and would destroy the
|
|
// variable during DLL unload
|
|
// * can't declare the error_category as an ordinary constexpr variable for most compilers, because error_category
|
|
// has a virtual destructor (TRANSITION, __cpp_constexpr_dynamic_alloc)
|
|
// * can't declare the error_category as an ordinary non-constexpr variable even with a constexpr constructor, because
|
|
// the compiler will emit code to destroy it which invalidates its use in these DLL shutdown scenarios
|
|
//
|
|
// As a result, we use a workaround: We create an atomic<uintptr_t> array to store the error_category instance, test
|
|
// if the first atomic is nonzero (acquire), and if so, we know we have formed the instance and can return a
|
|
// reinterpreted pointer to that storage. If the first atomic is zero, we write all except the first atomic (relaxed),
|
|
// then write the first one as a store-release. (The non-first values are transferred to other threads in the
|
|
// release sequence).
|
|
//
|
|
// Acknowledged undefined and implementation-defined behavior happening here:
|
|
// * There is a data race when filling in the values other than the first atomic; this is OK on all hardware we target
|
|
// because the racing threads are all writing identical values that never change afterwards.
|
|
// * We are reaching into the layout of atomic<uintptr_t>[N] and assuming we can reinterpret that as some other type.
|
|
// * We are assuming that virtual functions are implemented with a vfptr located as the first member of an object.
|
|
// (there are probably others)
|
|
//
|
|
// Inspecting the resulting assembly of any callers of _Immortalize_memcpy_image is recommended.
|
|
//
|
|
|
|
#if defined(_M_CEE_PURE)
|
|
// /clr:pure doesn't ever do constant initialization, so rely on the CLR and magic statics
|
|
template <class _Ty>
|
|
_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
|
|
/* MAGIC */ static _Immortalizer_impl<_Ty> _Static;
|
|
return _Static._Storage;
|
|
}
|
|
#elif defined(__cpp_constexpr_dynamic_alloc)
|
|
template <class _Ty>
|
|
_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
|
|
static constexpr _Ty _Static;
|
|
return _Static;
|
|
}
|
|
#elif defined(__clang__)
|
|
template <class _Ty>
|
|
_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
|
|
[[clang::require_constant_initialization]] static _Ty _Static;
|
|
return _Static;
|
|
}
|
|
#elif !defined(_M_CEE) // TRANSITION, VSO-1153256
|
|
template <class _Ty>
|
|
struct _Constexpr_immortalize_impl {
|
|
union {
|
|
_Ty _Storage;
|
|
};
|
|
|
|
constexpr _Constexpr_immortalize_impl() noexcept : _Storage{} {}
|
|
|
|
_Constexpr_immortalize_impl(const _Constexpr_immortalize_impl&) = delete;
|
|
_Constexpr_immortalize_impl& operator=(const _Constexpr_immortalize_impl&) = delete;
|
|
|
|
[[msvc::noop_dtor]] ~_Constexpr_immortalize_impl() {
|
|
// do nothing, allowing _Ty to be used during shutdown
|
|
}
|
|
};
|
|
|
|
template <class _Ty>
|
|
_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
|
|
static _Constexpr_immortalize_impl<_Ty> _Static;
|
|
return _Static._Storage;
|
|
}
|
|
#else // ^^^ no workaround / workaround vvv
|
|
template <class _Ty>
|
|
_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
|
|
// return reference to a memcpy'd default-initialized _Ty
|
|
// pre: A default-initialized _Ty sets the first pointer-sized field to nonzero
|
|
constexpr size_t _Pointer_count = sizeof(_Ty) / sizeof(uintptr_t);
|
|
static atomic<uintptr_t> _Storage[_Pointer_count];
|
|
static_assert(sizeof(_Storage) == sizeof(_Ty), "Bad storage size");
|
|
static_assert(alignof(decltype(_Storage)) >= alignof(_Ty), "Bad alignment assumptions");
|
|
if (_Storage[0].load(memory_order_acquire) != 0) {
|
|
return reinterpret_cast<_Ty&>(_Storage);
|
|
}
|
|
|
|
const _Ty _Target;
|
|
const auto _Target_iter = reinterpret_cast<const uintptr_t*>(_STD addressof(_Target));
|
|
_CSTD memcpy(_Storage + 1, _Target_iter + 1, sizeof(_Ty) - sizeof(uintptr_t));
|
|
_Storage[0].store(_Target_iter[0], memory_order_release);
|
|
return reinterpret_cast<_Ty&>(_Storage);
|
|
}
|
|
#endif // choose immortalize strategy
|
|
|
|
_NODISCARD inline const error_category& generic_category() noexcept {
|
|
return _Immortalize_memcpy_image<_Generic_error_category>();
|
|
}
|
|
|
|
_NODISCARD inline const error_category& iostream_category() noexcept {
|
|
return _Immortalize_memcpy_image<_Iostream_error_category2>();
|
|
}
|
|
|
|
_NODISCARD inline const error_category& system_category() noexcept {
|
|
return _Immortalize_memcpy_image<_System_error_category>();
|
|
}
|
|
_STD_END
|
|
#pragma pop_macro("new")
|
|
_STL_RESTORE_CLANG_WARNINGS
|
|
#pragma warning(pop)
|
|
#pragma pack(pop)
|
|
#endif // _STL_COMPILER_PREPROCESSOR
|
|
#endif // _SYSTEM_ERROR_
|