Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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