1 // Iostreams base classes -*- C++ -*- 2 3 // Copyright (C) 2014-2020 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 namespace 46 { 47 struct io_error_category : std::error_category 48 { 49 virtual const char* name__anon52abe9e20111::io_error_category50 name() const noexcept 51 { return "iostream"; } 52 53 _GLIBCXX_DEFAULT_ABI_TAG message__anon52abe9e20111::io_error_category54 virtual std::string message(int __ec) const 55 { 56 std::string __msg; 57 switch (std::io_errc(__ec)) 58 { 59 case std::io_errc::stream: 60 __msg = "iostream error"; 61 break; 62 default: 63 __msg = "Unknown error"; 64 break; 65 } 66 return __msg; 67 } 68 }; 69 70 const io_error_category& __io_category_instance()71 __io_category_instance() noexcept 72 { 73 static const io_error_category __ec{}; 74 return __ec; 75 } 76 77 } // namespace 78 79 namespace std _GLIBCXX_VISIBILITY(default) 80 { 81 _GLIBCXX_BEGIN_NAMESPACE_VERSION 82 83 const error_category& iostream_category()84 iostream_category() noexcept 85 { return __io_category_instance(); } 86 failure(const string & __str)87 ios_base::failure::failure(const string& __str) 88 : system_error(io_errc::stream, __str) { } 89 failure(const string & __str,const error_code & __ec)90 ios_base::failure::failure(const string& __str, const error_code& __ec) 91 : system_error(__ec, __str) { } 92 failure(const char * __str,const error_code & __ec)93 ios_base::failure::failure(const char* __str, const error_code& __ec) 94 : system_error(__ec, __str) { } 95 ~failure()96 ios_base::failure::~failure() 97 { } 98 99 const char* what() const100 ios_base::failure::what() const throw() 101 { return runtime_error::what(); } 102 103 #if __cpp_rtti 104 // These functions are defined in src/c++98/ios_failure.cc 105 extern void __construct_ios_failure(void*, const char*); 106 extern void __destroy_ios_failure(void*); 107 extern bool __is_ios_failure_handler(const __cxxabiv1::__class_type_info*); 108 109 // The type thrown to report errors during stream buffer operations. 110 // In addition to the ios::failure[abi:cxx11] base class it also has a 111 // member of the gcc4-compatible ios::failure type (in an opaque buffer). 112 struct __ios_failure : std::ios::failure 113 { __ios_failurestd::__ios_failure114 __ios_failure(const char* s) : failure(s) 115 { __construct_ios_failure(buf, runtime_error::what()); } 116 __ios_failurestd::__ios_failure117 __ios_failure(const char* s, const error_code& e) : failure(s, e) 118 { __construct_ios_failure(buf, runtime_error::what()); } 119 ~__ios_failurestd::__ios_failure120 ~__ios_failure() 121 { __destroy_ios_failure(buf); } 122 123 // Use std::runtime_error as a proxy for the gcc4-compatible ios::failure 124 // (which can't be declared here because _GLIBCXX_USE_CXX11_ABI == 1). 125 // There are assertions in src/c++98/ios_failure.cc to ensure the size 126 // and alignment assumptions are valid. 127 alignas(runtime_error) unsigned char buf[sizeof(runtime_error)]; 128 }; 129 130 // Custom type info for __ios_failure. 131 class __iosfail_type_info : __cxxabiv1::__si_class_type_info 132 { 133 ~__iosfail_type_info(); 134 135 bool 136 __do_upcast (const __class_type_info *dst_type, 137 void **obj_ptr) const override; 138 }; 139 140 __iosfail_type_info::~__iosfail_type_info() = default; 141 142 // This function gets called to see if an exception of type 143 // __ios_failure can be upcast to the type in a catch handler. 144 bool __do_upcast(const __class_type_info * dst_type,void ** obj_ptr) const145 __iosfail_type_info::__do_upcast(const __class_type_info *dst_type, 146 void **obj_ptr) const 147 { 148 // If the handler is for the gcc4-compatible ios::failure type then 149 // catch the object stored in __ios_failure::buf instead of 150 // the __ios_failure exception object itself. 151 if (__is_ios_failure_handler(dst_type)) 152 { 153 *obj_ptr = static_cast<__ios_failure*>(*obj_ptr)->buf; 154 return true; 155 } 156 // Otherwise proceed as normal to see if the handler matches. 157 return __class_type_info::__do_upcast(dst_type, obj_ptr); 158 } 159 #else // ! __cpp_rtti 160 using __ios_failure = ios::failure; 161 #endif 162 163 void __throw_ios_failure(const char * __s)164 __throw_ios_failure(const char* __s __attribute__((unused))) 165 { _GLIBCXX_THROW_OR_ABORT(__ios_failure(_(__s))); } 166 167 void __throw_ios_failure(const char * str,int err)168 __throw_ios_failure(const char* str __attribute__((unused)), 169 int err __attribute__((unused))) 170 { 171 _GLIBCXX_THROW_OR_ABORT(__ios_failure(_(str), 172 err ? error_code(err, generic_category()) : io_errc::stream)); 173 } 174 175 _GLIBCXX_END_NAMESPACE_VERSION 176 } // namespace 177