]>
Commit | Line | Data |
---|---|---|
1 | // Compatibility symbols for previous versions, C++0x bits -*- C++ -*- | |
2 | ||
3 | // Copyright (C) 2009-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 | #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.value()); | |
121 | return std::_Hash_impl::__hash_combine(&__e.category(), __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 |