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