libstdc++-v3/src/c++98/compatibility.cc

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