1 // Compatibility symbols for previous versions, C++0x bits -*- C++ -*- 2 3 // Copyright (C) 2009-2017 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 // gcc-4.4.0 48 // <mutex> exported std::lock_error 49 #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) 50 class lock_error : public exception 51 { 52 public: 53 virtual const char* 54 _GLIBCXX_CONST what() const throw(); 55 }; 56 57 const char* what() const58 lock_error::what() const throw() 59 { return "std::lock_error"; } 60 #endif 61 62 // We need these due to the symbols exported since GLIBCXX_3.4.10. 63 // See libstdc++/41662 for details. 64 65 #ifndef _GLIBCXX_LONG_DOUBLE_COMPAT_IMPL 66 template<> 67 struct hash<string> 68 { 69 size_t operator()(string) const; 70 }; 71 72 size_t operator ()(string __s) const73 hash<string>::operator()(string __s) const 74 { return _Hash_impl::hash(__s.data(), __s.length()); } 75 76 template<> 77 struct hash<const string&> 78 { 79 size_t operator()(const string&) const; 80 }; 81 82 size_t operator ()(const string & __s) const83 hash<const string&>::operator()(const string& __s) const 84 { return _Hash_impl::hash(__s.data(), __s.length()); } 85 86 #ifdef _GLIBCXX_USE_WCHAR_T 87 template<> 88 struct hash<wstring> 89 { 90 size_t operator()(wstring) const; 91 }; 92 93 size_t operator ()(wstring __s) const94 hash<wstring>::operator()(wstring __s) const 95 { return _Hash_impl::hash(__s.data(), __s.length() * sizeof(wchar_t)); } 96 97 template<> 98 struct hash<const wstring&> 99 { 100 size_t operator()(const wstring&) const; 101 }; 102 103 size_t operator ()(const wstring & __s) const104 hash<const wstring&>::operator()(const wstring& __s) const 105 { return _Hash_impl::hash(__s.data(), __s.length() * sizeof(wchar_t)); } 106 #endif 107 #endif 108 109 template<> 110 struct hash<error_code> 111 { 112 size_t operator()(error_code) const; 113 }; 114 115 size_t operator ()(error_code __e) const116 hash<error_code>::operator()(error_code __e) const 117 { 118 const size_t __tmp = std::_Hash_impl::hash(__e._M_value); 119 return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp); 120 } 121 122 // gcc-4.7.0 123 // <chrono> changes is_monotonic to is_steady. 124 namespace chrono 125 { 126 struct system_clock 127 { 128 static constexpr bool is_monotonic = false; 129 }; 130 constexpr bool system_clock::is_monotonic; 131 } // namespace chrono 132 133 _GLIBCXX_BEGIN_NAMESPACE_VERSION 134 // gcc-5 replaces this with _V2::error_category 135 class error_category 136 { 137 public: 138 error_category() noexcept; 139 140 virtual ~error_category(); 141 142 error_category(const error_category&) = delete; 143 error_category& operator=(const error_category&) = delete; 144 145 virtual const char* 146 name() const noexcept = 0; 147 148 virtual string 149 message(int) const = 0; 150 151 virtual error_condition 152 default_error_condition(int __i) const noexcept; 153 154 virtual bool 155 equivalent(int __i, const error_condition& __cond) const noexcept; 156 157 virtual bool 158 equivalent(const error_code& __code, int __i) const noexcept; 159 160 bool operator <(const error_category & __other) const161 operator<(const error_category& __other) const noexcept 162 { return less<const error_category*>()(this, &__other); } 163 164 bool operator ==(const error_category & __other) const165 operator==(const error_category& __other) const noexcept 166 { return this == &__other; } 167 168 bool operator !=(const error_category & __other) const169 operator!=(const error_category& __other) const noexcept 170 { return this != &__other; } 171 }; 172 _GLIBCXX_END_NAMESPACE_VERSION 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* namestd::__anon0d63118c0111::generic_error_category187 name() const noexcept 188 { return "generic"; } 189 190 virtual string messagestd::__anon0d63118c0111::generic_error_category191 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* namestd::__anon0d63118c0111::system_error_category202 name() const noexcept 203 { return "system"; } 204 205 virtual string messagestd::__anon0d63118c0111::system_error_category206 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 _GLIBCXX_BEGIN_NAMESPACE_VERSION 219 const error_category& system_category()220 system_category() noexcept { return system_category_instance; } 221 222 const error_category& generic_category()223 generic_category() noexcept { return generic_category_instance; } 224 225 namespace _V2 226 { 227 _GLIBCXX_CONST const error_categoryxx& system_category() noexcept; 228 _GLIBCXX_CONST const error_categoryxx& generic_category() noexcept; 229 } 230 _GLIBCXX_END_NAMESPACE_VERSION 231 232 error_condition default_error_condition(int __i) const233 error_category::default_error_condition(int __i) const noexcept 234 { 235 if (*this == system_category()) 236 return error_condition(__i, _V2::system_category()); 237 return error_condition(__i, _V2::generic_category()); 238 } 239 240 bool equivalent(int __i,const error_condition & __cond) const241 error_category::equivalent(int __i, 242 const error_condition& __cond) const noexcept 243 { return default_error_condition(__i) == __cond; } 244 245 bool equivalent(const error_code & __code,int __i) const246 error_category::equivalent(const error_code& __code, int __i) const noexcept 247 { 248 if (*this == system_category() 249 && __code.category() == _V2::system_category()) 250 return __code.value() == __i; 251 if (*this == generic_category() 252 && __code.category() == _V2::generic_category()) 253 return __code.value() == __i; 254 return false; 255 } 256 257 } 258 #endif 259