compatibility.cc
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_, \ 381 GLIBCXX_3.4) 382 383 _GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX4swapERS_S0_, \ 384 _ZN10__gnu_norm15_List_node_base4swapERS0_S1_, \ 385 GLIBCXX_3.4) 386 387 _GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX6unhookEv, \ 388 _ZN10__gnu_norm15_List_node_base6unhookEv, \ 389 GLIBCXX_3.4) 390 391 _GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX7reverseEv, \ 392 _ZN10__gnu_norm15_List_node_base7reverseEv, \ 393 GLIBCXX_3.4) 394 395 _GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX8transferEPS_S0_, \ 396 _ZN10__gnu_norm15_List_node_base8transferEPS0_S1_, \ 397 GLIBCXX_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) \ 403 extern "C" double \ 404 __ ## name ## l_wrapper argdecl \ 405 { \ 406 return name args; \ 407 } \ 408 asm (".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 487 extern void *_ZTVN10__cxxabiv123__fundamental_type_infoE[]; 488 extern void *_ZTVN10__cxxabiv119__pointer_type_infoE[]; 489 extern __attribute__((used, weak)) const char _ZTSe[2] = "e"; 490 extern __attribute__((used, weak)) const char _ZTSPe[3] = "Pe"; 491 extern __attribute__((used, weak)) const char _ZTSPKe[4] = "PKe"; 492 extern __attribute__((used, weak)) const void *_ZTIe[2] 493 = { (void *) &_ZTVN10__cxxabiv123__fundamental_type_infoE[2], 494 (void *) _ZTSe }; 495 extern __attribute__((used, weak)) const void *_ZTIPe[4] 496 = { (void *) &_ZTVN10__cxxabiv119__pointer_type_infoE[2], 497 (void *) _ZTSPe, (void *) 0L, (void *) _ZTIe }; 498 extern __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 517 using namespace std; 518 519 extern "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