1 // Compatibility symbols for previous versions, C++0x bits -*- C++ -*- 2 3 // Copyright (C) 2009-2018 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 #define _GLIBCXX_COMPATIBILITY_CXX0X 26 #define _GLIBCXX_USE_CXX11_ABI 0 27 #define error_category error_categoryxx 28 #define system_category system_categoryxx 29 #define generic_category generic_categoryxx 30 #define _V2 _V2xx 31 #include <string> 32 #include <system_error> 33 #include <cstring> 34 #undef error_category 35 #undef system_category 36 #undef generic_category 37 #undef _V2 38 39 #if __cplusplus < 201103L 40 # error "compatibility-c++0x.cc must be compiled with -std=gnu++0x" 41 #endif 42 43 #ifdef _GLIBCXX_SHARED 44 45 namespace std _GLIBCXX_VISIBILITY(default) 46 { 47 _GLIBCXX_BEGIN_NAMESPACE_VERSION 48 49 // gcc-4.4.0 50 // <mutex> exported std::lock_error 51 #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) 52 class lock_error : public exception 53 { 54 public: 55 virtual const char* 56 _GLIBCXX_CONST what() const throw(); 57 }; 58 59 const char* 60 lock_error::what() const throw() 61 { return "std::lock_error"; } 62 #endif 63 64 // We need these due to the symbols exported since GLIBCXX_3.4.10. 65 // See libstdc++/41662 for details. 66 67 #ifndef _GLIBCXX_LONG_DOUBLE_COMPAT_IMPL 68 template<> 69 struct hash<string> 70 { 71 size_t operator()(string) const; 72 }; 73 74 size_t 75 hash<string>::operator()(string __s) const 76 { return _Hash_impl::hash(__s.data(), __s.length()); } 77 78 template<> 79 struct hash<const string&> 80 { 81 size_t operator()(const string&) const; 82 }; 83 84 size_t 85 hash<const string&>::operator()(const string& __s) const 86 { return _Hash_impl::hash(__s.data(), __s.length()); } 87 88 #ifdef _GLIBCXX_USE_WCHAR_T 89 template<> 90 struct hash<wstring> 91 { 92 size_t operator()(wstring) const; 93 }; 94 95 size_t 96 hash<wstring>::operator()(wstring __s) const 97 { return _Hash_impl::hash(__s.data(), __s.length() * sizeof(wchar_t)); } 98 99 template<> 100 struct hash<const wstring&> 101 { 102 size_t operator()(const wstring&) const; 103 }; 104 105 size_t 106 hash<const wstring&>::operator()(const wstring& __s) const 107 { return _Hash_impl::hash(__s.data(), __s.length() * sizeof(wchar_t)); } 108 #endif 109 #endif 110 111 template<> 112 struct hash<error_code> 113 { 114 size_t operator()(error_code) const; 115 }; 116 117 size_t 118 hash<error_code>::operator()(error_code __e) const 119 { 120 const size_t __tmp = std::_Hash_impl::hash(__e._M_value); 121 return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp); 122 } 123 124 // gcc-4.7.0 125 // <chrono> changes is_monotonic to is_steady. 126 namespace chrono 127 { 128 struct system_clock 129 { 130 static constexpr bool is_monotonic = false; 131 }; 132 constexpr bool system_clock::is_monotonic; 133 } // namespace chrono 134 135 // gcc-5 replaces this with _V2::error_category 136 class error_category 137 { 138 public: 139 error_category() noexcept; 140 141 virtual ~error_category(); 142 143 error_category(const error_category&) = delete; 144 error_category& operator=(const error_category&) = delete; 145 146 virtual const char* 147 name() const noexcept = 0; 148 149 virtual string 150 message(int) const = 0; 151 152 virtual error_condition 153 default_error_condition(int __i) const noexcept; 154 155 virtual bool 156 equivalent(int __i, const error_condition& __cond) const noexcept; 157 158 virtual bool 159 equivalent(const error_code& __code, int __i) const noexcept; 160 161 bool 162 operator<(const error_category& __other) const noexcept 163 { return less<const error_category*>()(this, &__other); } 164 165 bool 166 operator==(const error_category& __other) const noexcept 167 { return this == &__other; } 168 169 bool 170 operator!=(const error_category& __other) const noexcept 171 { return this != &__other; } 172 }; 173 174 // gcc-4.9.0 175 // LWG 2145 changes this constructor to constexpr i.e. inline 176 error_category::error_category() noexcept = default; 177 178 error_category::~error_category() noexcept = default; 179 180 namespace 181 { 182 using std::string; 183 184 struct generic_error_category : public std::error_category 185 { 186 virtual const char* 187 name() const noexcept 188 { return "generic"; } 189 190 virtual string 191 message(int i) const 192 { 193 // XXX locale issues: how does one get or set loc. 194 // _GLIBCXX_HAVE_STRERROR_L, strerror_l(i, cloc) 195 return string(strerror(i)); 196 } 197 }; 198 199 struct system_error_category : public std::error_category 200 { 201 virtual const char* 202 name() const noexcept 203 { return "system"; } 204 205 virtual string 206 message(int i) const 207 { 208 // XXX locale issues: how does one get or set loc. 209 // _GLIBCXX_HAVE_STRERROR_L, strerror_l(i, cloc) 210 return string(strerror(i)); 211 } 212 }; 213 214 const generic_error_category generic_category_instance{}; 215 const system_error_category system_category_instance{}; 216 } 217 218 const error_category& 219 system_category() noexcept { return system_category_instance; } 220 221 const error_category& 222 generic_category() noexcept { return generic_category_instance; } 223 224 namespace _V2 225 { 226 _GLIBCXX_CONST const error_categoryxx& system_category() noexcept; 227 _GLIBCXX_CONST const error_categoryxx& generic_category() noexcept; 228 } 229 230 error_condition 231 error_category::default_error_condition(int __i) const noexcept 232 { 233 if (*this == system_category()) 234 return error_condition(__i, _V2::system_category()); 235 return error_condition(__i, _V2::generic_category()); 236 } 237 238 bool 239 error_category::equivalent(int __i, 240 const error_condition& __cond) const noexcept 241 { return default_error_condition(__i) == __cond; } 242 243 bool 244 error_category::equivalent(const error_code& __code, int __i) const noexcept 245 { 246 if (*this == system_category() 247 && __code.category() == _V2::system_category()) 248 return __code.value() == __i; 249 if (*this == generic_category() 250 && __code.category() == _V2::generic_category()) 251 return __code.value() == __i; 252 return false; 253 } 254 255 _GLIBCXX_END_NAMESPACE_VERSION 256 } 257 #endif 258