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

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