1276630Skib// Compatibility symbols for previous versions -*- C++ -*-
2276630Skib
3276630Skib// Copyright (C) 2005-2020 Free Software Foundation, Inc.
4276630Skib//
5276630Skib// This file is part of the GNU ISO C++ Library.  This library is free
6276630Skib// software; you can redistribute it and/or modify it under the
7276630Skib// terms of the GNU General Public License as published by the
8276630Skib// Free Software Foundation; either version 3, or (at your option)
9276630Skib// any later version.
10276630Skib
11276630Skib// This library is distributed in the hope that it will be useful,
12276630Skib// but WITHOUT ANY WARRANTY; without even the implied warranty of
13276630Skib// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14276630Skib// GNU General Public License for more details.
15276630Skib
16276630Skib// Under Section 7 of GPL version 3, you are granted additional
17276630Skib// permissions described in the GCC Runtime Library Exception, version
18276630Skib// 3.1, as published by the Free Software Foundation.
19276630Skib
20276630Skib// You should have received a copy of the GNU General Public License and
21276630Skib// a copy of the GCC Runtime Library Exception along with this program;
22276630Skib// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23276630Skib// <http://www.gnu.org/licenses/>.
24276630Skib
25276630Skib#define _GLIBCXX_USE_CXX11_ABI 0
26276630Skib#include <bits/c++config.h>
27276630Skib
28276630Skib#if defined(_GLIBCXX_SYMVER_GNU) && defined(_GLIBCXX_SHARED) \
29276630Skib    && defined(_GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE)\
30276630Skib    && defined(_GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT)
31276630Skib#define istreambuf_iterator istreambuf_iteratorXX
32276630Skib#define basic_fstream basic_fstreamXX
33276630Skib#define basic_ifstream basic_ifstreamXX
34276630Skib#define basic_ofstream basic_ofstreamXX
35276630Skib#define _M_copy(a, b, c) _M_copyXX(a, b, c)
36276630Skib#define _M_move(a, b, c) _M_moveXX(a, b, c)
37276630Skib#define _M_assign(a, b, c) _M_assignXX(a, b, c)
38276630Skib#define _M_disjunct(a) _M_disjunctXX(a)
39276630Skib#define _M_check_length(a, b, c) _M_check_lengthXX(a, b, c)
40276630Skib#define _M_set_length_and_sharable(a) _M_set_length_and_sharableXX(a)
41276630Skib#define ignore ignoreXX
42276630Skib#define eq eqXX
43276630Skib#define _List_node_base _List_node_baseXX
44276630Skib#endif
45276630Skib
46276630Skib#include <string>
47276630Skib#include <istream>
48276630Skib#include <fstream>
49276630Skib#include <sstream>
50276630Skib#include <cmath>
51#include <ext/numeric_traits.h>
52
53namespace 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
216namespace 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 */
263namespace 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#ifdef _GLIBCXX_COMPAT_
369#define _GLIBCXX_3_4_SYMVER(XXname, name) \
370   extern "C" void \
371   _X##name(...) \
372   __attribute__ ((alias(#XXname))); \
373   asm (".symver " "_X" #name "," #name "@GLIBCXX_3.4");
374
375#define _GLIBCXX_3_4_5_SYMVER(XXname, name) \
376   extern "C" void \
377   _Y##name(...) \
378   __attribute__ ((alias(#XXname))); \
379   asm (".symver " "_Y" #name  "," #name "@@GLIBCXX_3.4.5");
380
381#define _GLIBCXX_ASM_SYMVER(cur, old, version) \
382   asm (".symver " #cur "," #old "@@" #version);
383#else
384#define _GLIBCXX_3_4_SYMVER(XXname, name)
385#define _GLIBCXX_3_4_5_SYMVER(XXname, name)
386#define _GLIBCXX_ASM_SYMVER(cur, old, version)
387#endif
388
389#define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_SYMVER
390#include <abi/compatibility.h>
391#undef _GLIBCXX_APPLY_SYMVER
392
393#define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_5_SYMVER
394#include <abi/compatibility.h>
395#undef _GLIBCXX_APPLY_SYMVER
396
397
398/* gcc-3.4.0
399_ZN10__gnu_norm15_List_node_base4hookEPS0_;
400_ZN10__gnu_norm15_List_node_base4swapERS0_S1_;
401_ZN10__gnu_norm15_List_node_base6unhookEv;
402_ZN10__gnu_norm15_List_node_base7reverseEv;
403_ZN10__gnu_norm15_List_node_base8transferEPS0_S1_;
404*/
405#include "list.cc"
406_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX7_M_hookEPS0_, \
407_ZN10__gnu_norm15_List_node_base4hookEPS0_, \
408GLIBCXX_3.4)
409
410_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX4swapERS0_S1_, \
411_ZN10__gnu_norm15_List_node_base4swapERS0_S1_, \
412GLIBCXX_3.4)
413
414_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX9_M_unhookEv, \
415_ZN10__gnu_norm15_List_node_base6unhookEv, \
416GLIBCXX_3.4)
417
418_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX10_M_reverseEv, \
419_ZN10__gnu_norm15_List_node_base7reverseEv, \
420GLIBCXX_3.4)
421
422_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX11_M_transferEPS0_S1_, \
423_ZN10__gnu_norm15_List_node_base8transferEPS0_S1_, \
424GLIBCXX_3.4)
425#undef _List_node_base
426
427// gcc-4.1.0
428// Long double versions of "C" math functions.
429#if defined (_GLIBCXX_LONG_DOUBLE_COMPAT) \
430    || (defined (__arm__) && defined (__linux__) && defined (__ARM_EABI__)) \
431    || (defined (__hppa__) && defined (__linux__)) \
432    || (defined (__m68k__) && defined (__mcoldfire__) && defined (__linux__)) \
433    || (defined (__mips__) && defined (_ABIO32) && defined (__linux__)) \
434    || (defined (__sh__) && defined (__linux__) && __SIZEOF_SIZE_T__ == 4) \
435
436#define _GLIBCXX_MATHL_WRAPPER(name, argdecl, args, ver) \
437extern "C" double						\
438__ ## name ## l_wrapper argdecl					\
439{								\
440  return name args;						\
441}								\
442asm (".symver __" #name "l_wrapper, " #name "l@" #ver)
443
444#define _GLIBCXX_MATHL_WRAPPER1(name, ver) \
445  _GLIBCXX_MATHL_WRAPPER (name, (double x), (x), ver)
446
447#define _GLIBCXX_MATHL_WRAPPER2(name, ver) \
448  _GLIBCXX_MATHL_WRAPPER (name, (double x, double y), (x, y), ver)
449
450#ifdef _GLIBCXX_HAVE_ACOSL
451_GLIBCXX_MATHL_WRAPPER1 (acos, GLIBCXX_3.4.3);
452#endif
453#ifdef _GLIBCXX_HAVE_ASINL
454_GLIBCXX_MATHL_WRAPPER1 (asin, GLIBCXX_3.4.3);
455#endif
456#ifdef _GLIBCXX_HAVE_ATAN2L
457_GLIBCXX_MATHL_WRAPPER2 (atan2, GLIBCXX_3.4);
458#endif
459#ifdef _GLIBCXX_HAVE_ATANL
460_GLIBCXX_MATHL_WRAPPER1 (atan, GLIBCXX_3.4.3);
461#endif
462#ifdef _GLIBCXX_HAVE_CEILL
463_GLIBCXX_MATHL_WRAPPER1 (ceil, GLIBCXX_3.4.3);
464#endif
465#ifdef _GLIBCXX_HAVE_COSHL
466_GLIBCXX_MATHL_WRAPPER1 (cosh, GLIBCXX_3.4);
467#endif
468#ifdef _GLIBCXX_HAVE_COSL
469_GLIBCXX_MATHL_WRAPPER1 (cos, GLIBCXX_3.4);
470#endif
471#ifdef _GLIBCXX_HAVE_EXPL
472_GLIBCXX_MATHL_WRAPPER1 (exp, GLIBCXX_3.4);
473#endif
474#ifdef _GLIBCXX_HAVE_FLOORL
475_GLIBCXX_MATHL_WRAPPER1 (floor, GLIBCXX_3.4.3);
476#endif
477#ifdef _GLIBCXX_HAVE_FMODL
478_GLIBCXX_MATHL_WRAPPER2 (fmod, GLIBCXX_3.4.3);
479#endif
480#ifdef _GLIBCXX_HAVE_FREXPL
481_GLIBCXX_MATHL_WRAPPER (frexp, (double x, int *y), (x, y), GLIBCXX_3.4.3);
482#endif
483#ifdef _GLIBCXX_HAVE_HYPOTL
484_GLIBCXX_MATHL_WRAPPER2 (hypot, GLIBCXX_3.4);
485#endif
486#ifdef _GLIBCXX_HAVE_LDEXPL
487_GLIBCXX_MATHL_WRAPPER (ldexp, (double x, int y), (x, y), GLIBCXX_3.4.3);
488#endif
489#ifdef _GLIBCXX_HAVE_LOG10L
490_GLIBCXX_MATHL_WRAPPER1 (log10, GLIBCXX_3.4);
491#endif
492#ifdef _GLIBCXX_HAVE_LOGL
493_GLIBCXX_MATHL_WRAPPER1 (log, GLIBCXX_3.4);
494#endif
495#ifdef _GLIBCXX_HAVE_MODFL
496_GLIBCXX_MATHL_WRAPPER (modf, (double x, double *y), (x, y), GLIBCXX_3.4.3);
497#endif
498#ifdef _GLIBCXX_HAVE_POWL
499_GLIBCXX_MATHL_WRAPPER2 (pow, GLIBCXX_3.4);
500#endif
501#ifdef _GLIBCXX_HAVE_SINHL
502_GLIBCXX_MATHL_WRAPPER1 (sinh, GLIBCXX_3.4);
503#endif
504#ifdef _GLIBCXX_HAVE_SINL
505_GLIBCXX_MATHL_WRAPPER1 (sin, GLIBCXX_3.4);
506#endif
507#ifdef _GLIBCXX_HAVE_SQRTL
508_GLIBCXX_MATHL_WRAPPER1 (sqrt, GLIBCXX_3.4);
509#endif
510#ifdef _GLIBCXX_HAVE_TANHL
511_GLIBCXX_MATHL_WRAPPER1 (tanh, GLIBCXX_3.4);
512#endif
513#ifdef _GLIBCXX_HAVE_TANL
514_GLIBCXX_MATHL_WRAPPER1 (tan, GLIBCXX_3.4);
515#endif
516#endif // _GLIBCXX_LONG_DOUBLE_COMPAT
517
518#endif
519
520#ifdef _GLIBCXX_LONG_DOUBLE_COMPAT
521extern void *_ZTVN10__cxxabiv123__fundamental_type_infoE[];
522extern void *_ZTVN10__cxxabiv119__pointer_type_infoE[];
523extern __attribute__((used, weak)) const char _ZTSe[2] = "e";
524extern __attribute__((used, weak)) const char _ZTSPe[3] = "Pe";
525extern __attribute__((used, weak)) const char _ZTSPKe[4] = "PKe";
526extern __attribute__((used, weak)) const void * const _ZTIe[2]
527  = { reinterpret_cast<const void *>
528      (&_ZTVN10__cxxabiv123__fundamental_type_infoE[2]),
529      reinterpret_cast<const void *>(_ZTSe) };
530extern __attribute__((used, weak)) const void * const _ZTIPe[4]
531  = { reinterpret_cast<const void *>
532      (&_ZTVN10__cxxabiv119__pointer_type_infoE[2]),
533      reinterpret_cast<const void *>(_ZTSPe),
534      reinterpret_cast<const void *>(0L),
535      reinterpret_cast<const void *>(_ZTIe) };
536extern __attribute__((used, weak)) const void * const _ZTIPKe[4]
537  = { reinterpret_cast<const void *>
538      (&_ZTVN10__cxxabiv119__pointer_type_infoE[2]),
539      reinterpret_cast<const void *>(_ZTSPKe),
540      reinterpret_cast<const void *>(1L),
541      reinterpret_cast<const void *>(_ZTIe) };
542#endif // _GLIBCXX_LONG_DOUBLE_COMPAT
543
544#ifdef _GLIBCXX_SYMVER_DARWIN
545#if (defined(__ppc__) || defined(__ppc64__)) && defined(_GLIBCXX_SHARED)
546/* __eprintf shouldn't have been made visible from libstdc++, or
547   anywhere, but on Mac OS X 10.4 it was defined in
548   libstdc++.6.0.3.dylib; so on that platform we have to keep defining
549   it to keep binary compatibility.  We can't just put the libgcc
550   version in the export list, because that doesn't work; once a
551   symbol is marked as hidden, it stays that way.  */
552
553#include <cstdio>
554#include <cstdlib>
555
556using namespace std;
557
558extern "C" void
559__eprintf(const char *string, const char *expression,
560	  unsigned int line, const char *filename)
561{
562  fprintf(stderr, string, expression, line, filename);
563  fflush(stderr);
564  abort();
565}
566#endif
567#endif
568