OLD | NEW |
| (Empty) |
1 // Compatibility symbols for previous versions -*- C++ -*- | |
2 | |
3 // Copyright (C) 2005, 2006, 2007, 2008, 2009 | |
4 // Free Software Foundation, Inc. | |
5 // | |
6 // This file is part of the GNU ISO C++ Library. This library is free | |
7 // software; you can redistribute it and/or modify it under the | |
8 // terms of the GNU General Public License as published by the | |
9 // Free Software Foundation; either version 3, or (at your option) | |
10 // any later version. | |
11 | |
12 // This library is distributed in the hope that it will be useful, | |
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 // GNU General Public License for more details. | |
16 | |
17 // Under Section 7 of GPL version 3, you are granted additional | |
18 // permissions described in the GCC Runtime Library Exception, version | |
19 // 3.1, as published by the Free Software Foundation. | |
20 | |
21 // You should have received a copy of the GNU General Public License and | |
22 // a copy of the GCC Runtime Library Exception along with this program; | |
23 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
24 // <http://www.gnu.org/licenses/>. | |
25 | |
26 #include <bits/c++config.h> | |
27 | |
28 #if defined(_GLIBCXX_SYMVER_GNU) && defined(PIC) \ | |
29 && defined(_GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE) | |
30 #define istreambuf_iterator istreambuf_iteratorXX | |
31 #define basic_fstream basic_fstreamXX | |
32 #define basic_ifstream basic_ifstreamXX | |
33 #define basic_ofstream basic_ofstreamXX | |
34 #define _M_copy(a, b, c) _M_copyXX(a, b, c) | |
35 #define _M_move(a, b, c) _M_moveXX(a, b, c) | |
36 #define _M_assign(a, b, c) _M_assignXX(a, b, c) | |
37 #define _M_disjunct(a) _M_disjunctXX(a) | |
38 #define _M_check_length(a, b, c) _M_check_lengthXX(a, b, c) | |
39 #define _M_set_length_and_sharable(a) _M_set_length_and_sharableXX(a) | |
40 #define ignore ignoreXX | |
41 #define eq eqXX | |
42 #define _List_node_base _List_node_baseXX | |
43 #endif | |
44 | |
45 #include <string> | |
46 #include <istream> | |
47 #include <fstream> | |
48 #include <sstream> | |
49 #include <cmath> | |
50 #include <ext/numeric_traits.h> | |
51 | |
52 _GLIBCXX_BEGIN_NAMESPACE(std) | |
53 | |
54 // std::istream ignore explicit specializations. | |
55 template<> | |
56 basic_istream<char>& | |
57 basic_istream<char>:: | |
58 ignore(streamsize __n) | |
59 { | |
60 if (__n == 1) | |
61 return ignore(); | |
62 | |
63 _M_gcount = 0; | |
64 sentry __cerb(*this, true); | |
65 if (__cerb && __n > 0) | |
66 { | |
67 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
68 __try | |
69 { | |
70 const int_type __eof = traits_type::eof(); | |
71 __streambuf_type* __sb = this->rdbuf(); | |
72 int_type __c = __sb->sgetc(); | |
73 | |
74 // See comment in istream.tcc. | |
75 bool __large_ignore = false; | |
76 while (true) | |
77 { | |
78 while (_M_gcount < __n | |
79 && !traits_type::eq_int_type(__c, __eof)) | |
80 { | |
81 streamsize __size = std::min(streamsize(__sb->egptr() | |
82 - __sb->gptr()), | |
83 streamsize(__n - _M_gcount)); | |
84 if (__size > 1) | |
85 { | |
86 __sb->gbump(__size); | |
87 _M_gcount += __size; | |
88 __c = __sb->sgetc(); | |
89 } | |
90 else | |
91 { | |
92 ++_M_gcount; | |
93 __c = __sb->snextc(); | |
94 } | |
95 } | |
96 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max | |
97 && !traits_type::eq_int_type(__c, __eof)) | |
98 { | |
99 _M_gcount = | |
100 __gnu_cxx::__numeric_traits<streamsize>::__min; | |
101 __large_ignore = true; | |
102 } | |
103 else | |
104 break; | |
105 } | |
106 | |
107 if (__large_ignore) | |
108 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max; | |
109 | |
110 if (traits_type::eq_int_type(__c, __eof)) | |
111 __err |= ios_base::eofbit; | |
112 } | |
113 __catch(__cxxabiv1::__forced_unwind&) | |
114 { | |
115 this->_M_setstate(ios_base::badbit); | |
116 __throw_exception_again; | |
117 } | |
118 __catch(...) | |
119 { this->_M_setstate(ios_base::badbit); } | |
120 if (__err) | |
121 this->setstate(__err); | |
122 } | |
123 return *this; | |
124 } | |
125 | |
126 #ifdef _GLIBCXX_USE_WCHAR_T | |
127 template<> | |
128 basic_istream<wchar_t>& | |
129 basic_istream<wchar_t>:: | |
130 ignore(streamsize __n) | |
131 { | |
132 if (__n == 1) | |
133 return ignore(); | |
134 | |
135 _M_gcount = 0; | |
136 sentry __cerb(*this, true); | |
137 if (__cerb && __n > 0) | |
138 { | |
139 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
140 __try | |
141 { | |
142 const int_type __eof = traits_type::eof(); | |
143 __streambuf_type* __sb = this->rdbuf(); | |
144 int_type __c = __sb->sgetc(); | |
145 | |
146 bool __large_ignore = false; | |
147 while (true) | |
148 { | |
149 while (_M_gcount < __n | |
150 && !traits_type::eq_int_type(__c, __eof)) | |
151 { | |
152 streamsize __size = std::min(streamsize(__sb->egptr() | |
153 - __sb->gptr()), | |
154 streamsize(__n - _M_gcount)); | |
155 if (__size > 1) | |
156 { | |
157 __sb->gbump(__size); | |
158 _M_gcount += __size; | |
159 __c = __sb->sgetc(); | |
160 } | |
161 else | |
162 { | |
163 ++_M_gcount; | |
164 __c = __sb->snextc(); | |
165 } | |
166 } | |
167 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max | |
168 && !traits_type::eq_int_type(__c, __eof)) | |
169 { | |
170 _M_gcount = | |
171 __gnu_cxx::__numeric_traits<streamsize>::__min; | |
172 __large_ignore = true; | |
173 } | |
174 else | |
175 break; | |
176 } | |
177 | |
178 if (__large_ignore) | |
179 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max; | |
180 | |
181 if (traits_type::eq_int_type(__c, __eof)) | |
182 __err |= ios_base::eofbit; | |
183 } | |
184 __catch(__cxxabiv1::__forced_unwind&) | |
185 { | |
186 this->_M_setstate(ios_base::badbit); | |
187 __throw_exception_again; | |
188 } | |
189 __catch(...) | |
190 { this->_M_setstate(ios_base::badbit); } | |
191 if (__err) | |
192 this->setstate(__err); | |
193 } | |
194 return *this; | |
195 } | |
196 #endif | |
197 | |
198 _GLIBCXX_END_NAMESPACE | |
199 | |
200 | |
201 // NB: These symbols renames should go into the shared library only, | |
202 // and only those shared libraries that support versioning. | |
203 #if defined(_GLIBCXX_SYMVER_GNU) && defined(PIC) \ | |
204 && defined(_GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE) | |
205 | |
206 /* gcc-3.4.4 | |
207 _ZNSt19istreambuf_iteratorIcSt11char_traitsIcEEppEv | |
208 _ZNSt19istreambuf_iteratorIwSt11char_traitsIwEEppEv | |
209 */ | |
210 | |
211 _GLIBCXX_BEGIN_NAMESPACE(std) | |
212 | |
213 template | |
214 istreambuf_iterator<char>& | |
215 istreambuf_iterator<char>::operator++(); | |
216 | |
217 #ifdef _GLIBCXX_USE_WCHAR_T | |
218 template | |
219 istreambuf_iterator<wchar_t>& | |
220 istreambuf_iterator<wchar_t>::operator++(); | |
221 #endif | |
222 | |
223 _GLIBCXX_END_NAMESPACE | |
224 | |
225 | |
226 /* gcc-4.0.0 | |
227 _ZNSs4_Rep26_M_set_length_and_sharableEj | |
228 _ZNSs7_M_copyEPcPKcj | |
229 _ZNSs7_M_moveEPcPKcj | |
230 _ZNSs9_M_assignEPcjc | |
231 _ZNKSs11_M_disjunctEPKc | |
232 _ZNKSs15_M_check_lengthEjjPKc | |
233 _ZNSbIwSt11char_traitsIwESaIwEE4_Rep26_M_set_length_and_sharableEj | |
234 _ZNSbIwSt11char_traitsIwESaIwEE7_M_copyEPwPKwj | |
235 _ZNSbIwSt11char_traitsIwESaIwEE7_M_moveEPwPKwj | |
236 _ZNSbIwSt11char_traitsIwESaIwEE9_M_assignEPwjw | |
237 _ZNKSbIwSt11char_traitsIwESaIwEE11_M_disjunctEPKw | |
238 _ZNKSbIwSt11char_traitsIwESaIwEE15_M_check_lengthEjjPKc | |
239 | |
240 _ZNKSt13basic_fstreamIcSt11char_traitsIcEE7is_openEv | |
241 _ZNKSt13basic_fstreamIwSt11char_traitsIwEE7is_openEv | |
242 _ZNKSt14basic_ifstreamIcSt11char_traitsIcEE7is_openEv | |
243 _ZNKSt14basic_ifstreamIwSt11char_traitsIwEE7is_openEv | |
244 _ZNKSt14basic_ofstreamIcSt11char_traitsIcEE7is_openEv | |
245 _ZNKSt14basic_ofstreamIwSt11char_traitsIwEE7is_openEv | |
246 | |
247 _ZNSi6ignoreEi | |
248 _ZNSi6ignoreEv | |
249 _ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreEi | |
250 _ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreEv | |
251 | |
252 _ZNSt11char_traitsIcE2eqERKcS2_ | |
253 _ZNSt11char_traitsIwE2eqERKwS2_ | |
254 */ | |
255 _GLIBCXX_BEGIN_NAMESPACE(std) | |
256 | |
257 // std::char_traits is explicitly specialized | |
258 bool (* __p1)(const char&, const char&) = &char_traits<char>::eq; | |
259 | |
260 // std::string | |
261 template | |
262 void | |
263 basic_string<char>::_M_copy(char*, const char*, size_t); | |
264 | |
265 template | |
266 void | |
267 basic_string<char>::_M_move(char*, const char*, size_t); | |
268 | |
269 template | |
270 void | |
271 basic_string<char>::_M_assign(char*, size_t, char); | |
272 | |
273 template | |
274 bool | |
275 basic_string<char>::_M_disjunct(const char*) const; | |
276 | |
277 template | |
278 void | |
279 basic_string<char>::_M_check_length(size_t, size_t, const char*) const; | |
280 | |
281 template | |
282 void | |
283 basic_string<char>::_Rep::_M_set_length_and_sharable(size_t); | |
284 | |
285 | |
286 // std::istream | |
287 template | |
288 basic_istream<char>& | |
289 basic_istream<char>::ignore(); | |
290 | |
291 template | |
292 bool | |
293 basic_fstream<char>::is_open() const; | |
294 | |
295 template | |
296 bool | |
297 basic_ifstream<char>::is_open() const; | |
298 | |
299 template | |
300 bool | |
301 basic_ofstream<char>::is_open() const; | |
302 | |
303 #ifdef _GLIBCXX_USE_WCHAR_T | |
304 bool (* __p2)(const wchar_t&, const wchar_t&) = &char_traits<wchar_t>::eq; | |
305 | |
306 // std::wstring | |
307 template | |
308 void | |
309 basic_string<wchar_t>::_M_copy(wchar_t*, const wchar_t*, size_t); | |
310 | |
311 template | |
312 void | |
313 basic_string<wchar_t>::_M_move(wchar_t*, const wchar_t*, size_t); | |
314 | |
315 template | |
316 void | |
317 basic_string<wchar_t>::_M_assign(wchar_t*, size_t, wchar_t); | |
318 | |
319 template | |
320 bool | |
321 basic_string<wchar_t>::_M_disjunct(const wchar_t*) const; | |
322 | |
323 template | |
324 void | |
325 basic_string<wchar_t>::_M_check_length(size_t, size_t, | |
326 const char*) const; | |
327 | |
328 template | |
329 void | |
330 basic_string<wchar_t>::_Rep::_M_set_length_and_sharable(size_t); | |
331 | |
332 template | |
333 basic_istream<wchar_t>& | |
334 basic_istream<wchar_t>::ignore(); | |
335 | |
336 template | |
337 bool | |
338 basic_fstream<wchar_t>::is_open() const; | |
339 | |
340 template | |
341 bool | |
342 basic_ifstream<wchar_t>::is_open() const; | |
343 | |
344 template | |
345 bool | |
346 basic_ofstream<wchar_t>::is_open() const; | |
347 #endif | |
348 | |
349 _GLIBCXX_END_NAMESPACE | |
350 | |
351 // The rename syntax for default exported names is | |
352 // asm (".symver name1,exportedname@GLIBCXX_3.4") | |
353 // asm (".symver name2,exportedname@@GLIBCXX_3.4.5") | |
354 // In the future, GLIBCXX_ABI > 6 should remove all uses of | |
355 // _GLIBCXX_*_SYMVER macros in this file. | |
356 | |
357 #define _GLIBCXX_3_4_SYMVER(XXname, name) \ | |
358 extern "C" void \ | |
359 _X##name() \ | |
360 __attribute__ ((alias(#XXname))); \ | |
361 asm (".symver " "_X" #name "," #name "@GLIBCXX_3.4"); | |
362 | |
363 #define _GLIBCXX_3_4_5_SYMVER(XXname, name) \ | |
364 extern "C" void \ | |
365 _Y##name() \ | |
366 __attribute__ ((alias(#XXname))); \ | |
367 asm (".symver " "_Y" #name "," #name "@@GLIBCXX_3.4.5"); | |
368 | |
369 #define _GLIBCXX_ASM_SYMVER(cur, old, version) \ | |
370 asm (".symver " #cur "," #old "@@" #version); | |
371 | |
372 #define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_SYMVER | |
373 #include <bits/compatibility.h> | |
374 #undef _GLIBCXX_APPLY_SYMVER | |
375 | |
376 #define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_5_SYMVER | |
377 #include <bits/compatibility.h> | |
378 #undef _GLIBCXX_APPLY_SYMVER | |
379 | |
380 | |
381 /* gcc-3.4.0 | |
382 _ZN10__gnu_norm15_List_node_base4hookEPS0_; | |
383 _ZN10__gnu_norm15_List_node_base4swapERS0_S1_; | |
384 _ZN10__gnu_norm15_List_node_base6unhookEv; | |
385 _ZN10__gnu_norm15_List_node_base7reverseEv; | |
386 _ZN10__gnu_norm15_List_node_base8transferEPS0_S1_; | |
387 */ | |
388 #include "list.cc" | |
389 _GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX4hookEPS_, \ | |
390 _ZN10__gnu_norm15_List_node_base4hookEPS0_, \ | |
391 GLIBCXX_3.4) | |
392 | |
393 _GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX4swapERS_S0_, \ | |
394 _ZN10__gnu_norm15_List_node_base4swapERS0_S1_, \ | |
395 GLIBCXX_3.4) | |
396 | |
397 _GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX6unhookEv, \ | |
398 _ZN10__gnu_norm15_List_node_base6unhookEv, \ | |
399 GLIBCXX_3.4) | |
400 | |
401 _GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX7reverseEv, \ | |
402 _ZN10__gnu_norm15_List_node_base7reverseEv, \ | |
403 GLIBCXX_3.4) | |
404 | |
405 _GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX8transferEPS_S0_, \ | |
406 _ZN10__gnu_norm15_List_node_base8transferEPS0_S1_, \ | |
407 GLIBCXX_3.4) | |
408 #undef _List_node_base | |
409 | |
410 // gcc-4.1.0 | |
411 // Long double versions of "C" math functions. | |
412 #if defined (_GLIBCXX_LONG_DOUBLE_COMPAT) \ | |
413 || (defined (__hppa__) && defined (__linux__)) | |
414 | |
415 #define _GLIBCXX_MATHL_WRAPPER(name, argdecl, args, ver) \ | |
416 extern "C" double \ | |
417 __ ## name ## l_wrapper argdecl \ | |
418 { \ | |
419 return name args; \ | |
420 } \ | |
421 asm (".symver __" #name "l_wrapper, " #name "l@" #ver) | |
422 | |
423 #define _GLIBCXX_MATHL_WRAPPER1(name, ver) \ | |
424 _GLIBCXX_MATHL_WRAPPER (name, (double x), (x), ver) | |
425 | |
426 #define _GLIBCXX_MATHL_WRAPPER2(name, ver) \ | |
427 _GLIBCXX_MATHL_WRAPPER (name, (double x, double y), (x, y), ver) | |
428 | |
429 #ifdef _GLIBCXX_HAVE_ACOSL | |
430 _GLIBCXX_MATHL_WRAPPER1 (acos, GLIBCXX_3.4.3); | |
431 #endif | |
432 #ifdef _GLIBCXX_HAVE_ASINL | |
433 _GLIBCXX_MATHL_WRAPPER1 (asin, GLIBCXX_3.4.3); | |
434 #endif | |
435 #ifdef _GLIBCXX_HAVE_ATAN2L | |
436 _GLIBCXX_MATHL_WRAPPER2 (atan2, GLIBCXX_3.4); | |
437 #endif | |
438 #ifdef _GLIBCXX_HAVE_ATANL | |
439 _GLIBCXX_MATHL_WRAPPER1 (atan, GLIBCXX_3.4.3); | |
440 #endif | |
441 #ifdef _GLIBCXX_HAVE_CEILL | |
442 _GLIBCXX_MATHL_WRAPPER1 (ceil, GLIBCXX_3.4.3); | |
443 #endif | |
444 #ifdef _GLIBCXX_HAVE_COSHL | |
445 _GLIBCXX_MATHL_WRAPPER1 (cosh, GLIBCXX_3.4); | |
446 #endif | |
447 #ifdef _GLIBCXX_HAVE_COSL | |
448 _GLIBCXX_MATHL_WRAPPER1 (cos, GLIBCXX_3.4); | |
449 #endif | |
450 #ifdef _GLIBCXX_HAVE_EXPL | |
451 _GLIBCXX_MATHL_WRAPPER1 (exp, GLIBCXX_3.4); | |
452 #endif | |
453 #ifdef _GLIBCXX_HAVE_FLOORL | |
454 _GLIBCXX_MATHL_WRAPPER1 (floor, GLIBCXX_3.4.3); | |
455 #endif | |
456 #ifdef _GLIBCXX_HAVE_FMODL | |
457 _GLIBCXX_MATHL_WRAPPER2 (fmod, GLIBCXX_3.4.3); | |
458 #endif | |
459 #ifdef _GLIBCXX_HAVE_FREXPL | |
460 _GLIBCXX_MATHL_WRAPPER (frexp, (double x, int *y), (x, y), GLIBCXX_3.4.3); | |
461 #endif | |
462 #ifdef _GLIBCXX_HAVE_HYPOTL | |
463 _GLIBCXX_MATHL_WRAPPER2 (hypot, GLIBCXX_3.4); | |
464 #endif | |
465 #ifdef _GLIBCXX_HAVE_LDEXPL | |
466 _GLIBCXX_MATHL_WRAPPER (ldexp, (double x, int y), (x, y), GLIBCXX_3.4.3); | |
467 #endif | |
468 #ifdef _GLIBCXX_HAVE_LOG10L | |
469 _GLIBCXX_MATHL_WRAPPER1 (log10, GLIBCXX_3.4); | |
470 #endif | |
471 #ifdef _GLIBCXX_HAVE_LOGL | |
472 _GLIBCXX_MATHL_WRAPPER1 (log, GLIBCXX_3.4); | |
473 #endif | |
474 #ifdef _GLIBCXX_HAVE_MODFL | |
475 _GLIBCXX_MATHL_WRAPPER (modf, (double x, double *y), (x, y), GLIBCXX_3.4.3); | |
476 #endif | |
477 #ifdef _GLIBCXX_HAVE_POWL | |
478 _GLIBCXX_MATHL_WRAPPER2 (pow, GLIBCXX_3.4); | |
479 #endif | |
480 #ifdef _GLIBCXX_HAVE_SINHL | |
481 _GLIBCXX_MATHL_WRAPPER1 (sinh, GLIBCXX_3.4); | |
482 #endif | |
483 #ifdef _GLIBCXX_HAVE_SINL | |
484 _GLIBCXX_MATHL_WRAPPER1 (sin, GLIBCXX_3.4); | |
485 #endif | |
486 #ifdef _GLIBCXX_HAVE_SQRTL | |
487 _GLIBCXX_MATHL_WRAPPER1 (sqrt, GLIBCXX_3.4); | |
488 #endif | |
489 #ifdef _GLIBCXX_HAVE_TANHL | |
490 _GLIBCXX_MATHL_WRAPPER1 (tanh, GLIBCXX_3.4); | |
491 #endif | |
492 #ifdef _GLIBCXX_HAVE_TANL | |
493 _GLIBCXX_MATHL_WRAPPER1 (tan, GLIBCXX_3.4); | |
494 #endif | |
495 #endif // _GLIBCXX_LONG_DOUBLE_COMPAT | |
496 | |
497 #endif | |
498 | |
499 #ifdef _GLIBCXX_LONG_DOUBLE_COMPAT | |
500 extern void *_ZTVN10__cxxabiv123__fundamental_type_infoE[]; | |
501 extern void *_ZTVN10__cxxabiv119__pointer_type_infoE[]; | |
502 extern __attribute__((used, weak)) const char _ZTSe[2] = "e"; | |
503 extern __attribute__((used, weak)) const char _ZTSPe[3] = "Pe"; | |
504 extern __attribute__((used, weak)) const char _ZTSPKe[4] = "PKe"; | |
505 extern __attribute__((used, weak)) const void *_ZTIe[2] | |
506 = { (void *) &_ZTVN10__cxxabiv123__fundamental_type_infoE[2], | |
507 (void *) _ZTSe }; | |
508 extern __attribute__((used, weak)) const void *_ZTIPe[4] | |
509 = { (void *) &_ZTVN10__cxxabiv119__pointer_type_infoE[2], | |
510 (void *) _ZTSPe, (void *) 0L, (void *) _ZTIe }; | |
511 extern __attribute__((used, weak)) const void *_ZTIPKe[4] | |
512 = { (void *) &_ZTVN10__cxxabiv119__pointer_type_infoE[2], | |
513 (void *) _ZTSPKe, (void *) 1L, (void *) _ZTIe }; | |
514 #endif // _GLIBCXX_LONG_DOUBLE_COMPAT | |
515 | |
516 | |
517 | |
518 #ifdef _GLIBCXX_SYMVER_DARWIN | |
519 #if (defined(__ppc__) || defined(__ppc64__)) && defined(PIC) | |
520 /* __eprintf shouldn't have been made visible from libstdc++, or | |
521 anywhere, but on Mac OS X 10.4 it was defined in | |
522 libstdc++.6.0.3.dylib; so on that platform we have to keep defining | |
523 it to keep binary compatibility. We can't just put the libgcc | |
524 version in the export list, because that doesn't work; once a | |
525 symbol is marked as hidden, it stays that way. */ | |
526 | |
527 #include <cstdio> | |
528 #include <cstdlib> | |
529 | |
530 using namespace std; | |
531 | |
532 extern "C" void | |
533 __eprintf(const char *string, const char *expression, | |
534 unsigned int line, const char *filename) | |
535 { | |
536 fprintf(stderr, string, expression, line, filename); | |
537 fflush(stderr); | |
538 abort(); | |
539 } | |
540 #endif | |
541 #endif | |
OLD | NEW |