1 // Iostreams base classes -*- C++ -*- 2 3 // Copyright (C) 2014-2022 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 // 26 // ISO C++ 14882:2011: 27.5.3.1.1 Class ios_base::failure 27 // 28 29 #define _GLIBCXX_USE_CXX11_ABI 1 30 #include <ios> 31 #include <bits/functexcept.h> 32 #include <cxxabi.h> 33 34 #ifdef _GLIBCXX_USE_NLS 35 # include <libintl.h> 36 # define _(msgid) gettext (msgid) 37 #else 38 # define _(msgid) (msgid) 39 #endif 40 41 #if ! _GLIBCXX_USE_DUAL_ABI 42 # error This file should not be compiled for this configuration. 43 #endif 44 45 #if __has_cpp_attribute(clang::require_constant_initialization) 46 # define __constinit [[clang::require_constant_initialization]] 47 #endif 48 49 namespace 50 { 51 struct io_error_category final : std::error_category 52 { 53 const char* 54 name() const noexcept final 55 { return "iostream"; } 56 57 _GLIBCXX_DEFAULT_ABI_TAG 58 std::string 59 message(int __ec) const final 60 { 61 std::string __msg; 62 switch (std::io_errc(__ec)) 63 { 64 case std::io_errc::stream: 65 __msg = "iostream error"; 66 break; 67 default: 68 __msg = "Unknown error"; 69 break; 70 } 71 return __msg; 72 } 73 }; 74 75 struct constant_init 76 { 77 union { 78 unsigned char unused; 79 io_error_category cat; 80 }; 81 constexpr constant_init() : cat() { } 82 ~constant_init() { /* do nothing, union member is not destroyed */ } 83 }; 84 85 __constinit constant_init io_category_instance{}; 86 } // namespace 87 88 namespace std _GLIBCXX_VISIBILITY(default) 89 { 90 _GLIBCXX_BEGIN_NAMESPACE_VERSION 91 92 const error_category& 93 iostream_category() noexcept 94 { return io_category_instance.cat; } 95 96 ios_base::failure::failure(const string& __str) 97 : system_error(io_errc::stream, __str) { } 98 99 ios_base::failure::failure(const string& __str, const error_code& __ec) 100 : system_error(__ec, __str) { } 101 102 ios_base::failure::failure(const char* __str, const error_code& __ec) 103 : system_error(__ec, __str) { } 104 105 ios_base::failure::~failure() 106 { } 107 108 const char* 109 ios_base::failure::what() const throw() 110 { return runtime_error::what(); } 111 112 #if __cpp_rtti 113 // These functions are defined in src/c++98/ios_failure.cc 114 extern void __construct_ios_failure(void*, const char*); 115 extern void __destroy_ios_failure(void*); 116 extern bool __is_ios_failure_handler(const __cxxabiv1::__class_type_info*); 117 118 // The type thrown to report errors during stream buffer operations. 119 // In addition to the ios::failure[abi:cxx11] base class it also has a 120 // member of the gcc4-compatible ios::failure type (in an opaque buffer). 121 struct __ios_failure : std::ios::failure 122 { 123 __ios_failure(const char* s) : failure(s) 124 { __construct_ios_failure(buf, runtime_error::what()); } 125 126 __ios_failure(const char* s, const error_code& e) : failure(s, e) 127 { __construct_ios_failure(buf, runtime_error::what()); } 128 129 ~__ios_failure() 130 { __destroy_ios_failure(buf); } 131 132 // Use std::runtime_error as a proxy for the gcc4-compatible ios::failure 133 // (which can't be declared here because _GLIBCXX_USE_CXX11_ABI == 1). 134 // There are assertions in src/c++98/ios_failure.cc to ensure the size 135 // and alignment assumptions are valid. 136 alignas(runtime_error) unsigned char buf[sizeof(runtime_error)]; 137 }; 138 139 // Custom type info for __ios_failure. 140 class __iosfail_type_info : __cxxabiv1::__si_class_type_info 141 { 142 ~__iosfail_type_info(); 143 144 bool 145 __do_upcast (const __class_type_info *dst_type, 146 void **obj_ptr) const override; 147 }; 148 149 __iosfail_type_info::~__iosfail_type_info() = default; 150 151 // This function gets called to see if an exception of type 152 // __ios_failure can be upcast to the type in a catch handler. 153 bool 154 __iosfail_type_info::__do_upcast(const __class_type_info *dst_type, 155 void **obj_ptr) const 156 { 157 // If the handler is for the gcc4-compatible ios::failure type then 158 // catch the object stored in __ios_failure::buf instead of 159 // the __ios_failure exception object itself. 160 if (__is_ios_failure_handler(dst_type)) 161 { 162 *obj_ptr = static_cast<__ios_failure*>(*obj_ptr)->buf; 163 return true; 164 } 165 // Otherwise proceed as normal to see if the handler matches. 166 return __class_type_info::__do_upcast(dst_type, obj_ptr); 167 } 168 #else // ! __cpp_rtti 169 using __ios_failure = ios::failure; 170 #endif 171 172 void 173 __throw_ios_failure(const char* __s __attribute__((unused))) 174 { _GLIBCXX_THROW_OR_ABORT(__ios_failure(_(__s))); } 175 176 void 177 __throw_ios_failure(const char* str __attribute__((unused)), 178 int err __attribute__((unused))) 179 { 180 _GLIBCXX_THROW_OR_ABORT(__ios_failure(_(str), 181 err ? error_code(err, generic_category()) : io_errc::stream)); 182 } 183 184 _GLIBCXX_END_NAMESPACE_VERSION 185 } // namespace 186