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