Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // Compatibility symbols for previous versions -*- C++ -*-
  2.  
  3. // Copyright (C) 2005-2015 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
  562.