Skip to content

R
riscv-gcc-1
Commit 9fab2793 by Benjamin Kosnik
Options

include: New directory. 


2000-10-05  Benjamin Kosnik  <bkoz@cygnus.com>

	* include: New directory.
	* include/backward: New directory.
	* include/bits: New directory.
	* include/ext: New directory.
	* include/std: New directory.
	* include/*/*: Populate.

	* backwards: Move to include/backwards, delete.
	* bits: Move to include/bits, delete.
	* ext: Move to include/ext, delete.
	* std: Move to include/std, delete.

	* src/complex.cc: Adjust include of mathconf.

	* mkc++config (BASE_H): Add include.

	* src/Makefile.am: Support for topleve sources include directory.
	(INCLUDES): Add LIBMATH_INCLUDE.
	* src/Makefile.in: Regenerate.
	* math/Makefile.am (INCLUDES): Append /include.
	* math/Makefile.in: Regenerate.
	* libio/Makefile.am (INCLUDES): Add glibcpp_includedir.
	* libio/Makefile.in: Regenerate.

From-SVN: r36724
parent 725dc051
Showing with 0 additions and 4890 deletions
libstdc++-v3/bits/basic_file.h deleted 100644 → 0
// Wrapper of C-language FILE struct -*- C++ -*-
// Copyright (C) 1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 27.8 File-based streams
//
#ifndef _CPP_BASIC_FILE
#define _CPP_BASIC_FILE 1
#include <bits/c++config.h>
#include <bits/std_ios.h>
namespace std {
// Ulrich is going to make some detailed comment here, explaining
// all this unpleasantness, providing detailed performance analysis
// as to why we have to do all this lame vtable hacking instead of a
// sane, function-based approach. This verbage will provide a clear
// and detailed description of the whole object-layout,
// vtable-swapping, sordid history of this hack.
template<typename _CharT>
struct __basic_file_base: public __c_file_type
{
virtual
~__basic_file_base() { };
virtual int
overflow(int __c = EOF) = 0;
virtual int
underflow() = 0;
virtual int
uflow() = 0;
virtual int
pbackfail(int __c) = 0;
virtual streamsize
xsputn(const _CharT* __s, streamsize __n) = 0;
virtual streamsize
xsgetn(_CharT* __s, streamsize __n) = 0;
virtual streamoff
seekoff(streamoff __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out) = 0;
virtual streamoff
seekpos(streamoff __pos,
ios_base::openmode __mode = ios_base::in | ios_base::out) = 0;
virtual streambuf*
setbuf(_CharT* __b, int __len) = 0;
virtual int
sync() = 0;
virtual int
doallocate() = 0;
virtual streamsize
sys_read(_CharT* __s, streamsize __n) = 0;
virtual streamsize
sys_write(const _CharT* __s, streamsize __n) = 0;
virtual streamoff
sys_seek(streamoff __off, ios_base::seekdir __way) = 0;
virtual int
sys_close() = 0;
virtual int
sys_stat(void* __v) = 0;
virtual int
showmanyc() = 0;
virtual void
imbue(void* __v) = 0;
};
// Some of these member functions are based on libio/filebuf.cc.
// Also note that the order and number of virtual functions has to precisely
// match the order and number in the _IO_jump_t struct defined in libioP.h.
template<typename _CharT>
#if _GLIBCPP_BASIC_FILE_INHERITANCE
class __basic_file: public __basic_file_base<_CharT>
#else
class __basic_file
#endif
{
#if _GLIBCPP_BASIC_FILE_ENCAPSULATION
int _M_fileno;
__c_file_type* _M_cfile;
#endif
__c_wfile_type _M_wfile;
public:
__basic_file(__c_lock* __lock = 0);
void
_M_open_mode(ios_base::openmode __mode, int& __p_mode, int& __rw_mode);
// Eqivalent to the normal fopen function.
__basic_file*
open(const char* __name, ios_base::openmode __mode, int __prot = 0664);
// Used for opening the standard streams, cin, cout, cerr, clog,
// and their wide-stream equivalents. Instead of calling open, it
// just sets __c_file_type->_fileno and the respective _flags bits, and
// returns.
__basic_file*
sys_open(int __fd, ios_base::openmode __mode);
__basic_file*
close();
bool
is_open();
// Needed by ios_base::sync_with_stdio.
int get_fileno(void);
// NB: Must match FILE specific jump table starting here--this
// means all virtual functions starting with the dtor must match,
// slot by slot. For glibc-based dystems, this means the _IO_FILE
// as the FILE struct and _IO_jump_t as the jump table.
virtual
~__basic_file(); // Takes the place of __finish.
virtual int
overflow(int __c = EOF);
virtual int
underflow();
virtual int
uflow();
virtual int
pbackfail(int __c);
// A complex "write" function that sets all of __c_file_type's
// ponters and associated data members correctly and manages it's
// relation to the external byte sequence.
virtual streamsize
xsputn(const _CharT* __s, streamsize __n);
// A complex "read" function that sets all of __c_file_type's
// ponters and associated data members correctly and manages it's
// relation to the external byte sequence.
virtual streamsize
xsgetn(_CharT* __s, streamsize __n);
// A complex "seekoff" function that sets all of __c_file_type's
// ponters and associated data members correctly and manages it's
// relation to the external byte sequence.
virtual streamoff
seekoff(streamoff __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out);
// A complex "seekpos" function that sets all of __c_file_type's
// pointers and associated data members correctly and manages it's
// relation to the external byte sequence.
virtual streamoff
seekpos(streamoff __pos,
ios_base::openmode __mode = ios_base::in | ios_base::out);
virtual streambuf*
setbuf(_CharT* __b, int __len);
virtual int
sync();
virtual int
doallocate();
// A simple read function for the external byte sequence, that
// does no mucking around with or setting of the pointers or flags
// in __c_file_type.
virtual streamsize
sys_read(_CharT* __s, streamsize __n);
// A simple write function for the external byte sequence, that
// does no mucking around with or setting of the pointers or flags
// in __c_file_type.
virtual streamsize
sys_write(const _CharT* __s, streamsize __n);
// A simple seek function for the external byte sequence, that
// does no mucking around with or setting of the pointers or flags
// in __c_file_type.
virtual streamoff
sys_seek(streamoff __off, ios_base::seekdir __way);
virtual int
sys_close();
virtual int
sys_stat(void* __v);
virtual int
showmanyc();
virtual void
imbue(void* __v);
};
// __basic_file<char> specializations
template<>
__basic_file<char>::__basic_file(__c_lock* __lock);
template<>
int
__basic_file<char>::overflow(int __c);
template<>
int
__basic_file<char>::underflow();
template<>
int
__basic_file<char>::uflow();
template<>
int
__basic_file<char>::pbackfail(int __c);
template<>
streamsize
__basic_file<char>::xsputn(const char* __s, streamsize __n);
template<>
streamoff
__basic_file<char>::seekoff(streamoff __off, ios_base::seekdir __way,
ios_base::openmode __mode);
template<>
streamoff
__basic_file<char>::seekpos(streamoff __pos, ios_base::openmode __mode);
template<>
streambuf*
__basic_file<char>::setbuf(char* __b, int __len);
template<>
int
__basic_file<char>::sync();
template<>
int
__basic_file<char>::doallocate();
// __basic_file<wchar_t> specializations
#ifdef _GLIBCPP_USE_WCHAR_T
template<>
__basic_file<wchar_t>::__basic_file(__c_lock* __lock);
template<>
int
__basic_file<wchar_t>::overflow(int __c);
template<>
int
__basic_file<wchar_t>::underflow();
template<>
int
__basic_file<wchar_t>::uflow();
template<>
int
__basic_file<wchar_t>::pbackfail(int __c);
template<>
streamsize
__basic_file<wchar_t>::xsputn(const wchar_t* __s, streamsize __n);
template<>
streamoff
__basic_file<wchar_t>::seekoff(streamoff __off, ios_base::seekdir __way,
ios_base::openmode __mode);
template<>
streamoff
__basic_file<wchar_t>::seekpos(streamoff __pos, ios_base::openmode __mode);
template<>
streambuf*
__basic_file<wchar_t>::setbuf(wchar_t* __b, int __len);
template<>
int
__basic_file<wchar_t>::sync();
template<>
int
__basic_file<wchar_t>::doallocate();
#endif
} // namespace std
#endif /* _CPP_BASIC_FILE */
libstdc++-v3/bits/basic_ios.h deleted 100644 → 0
// Iostreams base classes -*- C++ -*-
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#ifndef _CPP_BITS_BASICIOS_H
#define _CPP_BITS_BASICIOS_H 1
#include <bits/sbuf_iter.h>
namespace std {
// 27.4.5 Template class basic_ios
template<typename _CharT, typename _Traits>
class basic_ios : public ios_base
{
public:
// Types:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
// Non-standard Types:
typedef ctype<_CharT> __ctype_type;
// From ostream
typedef ostreambuf_iterator<_CharT> __ostreambuf_iter;
typedef num_put<_CharT, __ostreambuf_iter> __numput_type;
typedef istreambuf_iterator<_CharT> __istreambuf_iter;
typedef num_get<_CharT, __istreambuf_iter> __numget_type;
// Data members:
private:
basic_ostream<_CharT, _Traits>* _M_tie;
char_type _M_fill;
iostate _M_exception;
protected:
basic_streambuf<_CharT, _Traits>* _M_streambuf;
iostate _M_streambuf_state;
// Cached use_facet<ctype>, which is based on the current locale info.
const __ctype_type* _M_ios_fctype;
// From ostream.
const __numput_type* _M_fnumput;
// From istream.
const __numget_type* _M_fnumget;
public:
inline const __ctype_type*
_M_get_fctype_ios(void)
{ return _M_ios_fctype; }
inline const __numget_type*
_M_get_fnumget(void)
{ return _M_fnumget; }
inline const __numput_type*
_M_get_fnumput(void)
{ return _M_fnumput; }
operator void*() const
{ return this->fail() ? 0 : const_cast<basic_ios*>(this); }
inline bool
operator!() const
{ return this->fail(); }
inline iostate
rdstate() const
{ return _M_streambuf_state; }
inline void
clear(iostate __state = goodbit)
{
if (this->rdbuf())
_M_streambuf_state = __state;
else
_M_streambuf_state = __state | badbit;
if ((this->rdstate() & this->exceptions()))
throw failure("basic_ios::clear(iostate) caused exception");
}
inline void
setstate(iostate __state)
{ this->clear(this->rdstate() | __state); }
inline bool
good() const
{ return this->rdstate() == 0; }
inline bool
eof() const
{ return (this->rdstate() & eofbit) != 0; }
inline bool
fail() const
{ return (this->rdstate() & (badbit | failbit)) != 0; }
inline bool
bad() const
{ return (this->rdstate() & badbit) != 0; }
inline iostate
exceptions() const
{ return _M_exception; }
inline void
exceptions(iostate __except)
{
_M_exception = __except;
this->clear(_M_streambuf_state);
}
// Constructor/destructor:
explicit
basic_ios(basic_streambuf<_CharT, _Traits>* __sb) : ios_base()
{ this->init(__sb); }
virtual
~basic_ios() { }
// Members:
inline basic_ostream<_CharT, _Traits>*
tie() const
{ return _M_tie; }
inline basic_ostream<_CharT, _Traits>*
tie(basic_ostream<_CharT, _Traits>* __tiestr)
{
basic_ostream<_CharT, _Traits>* __old = _M_tie;
_M_tie = __tiestr;
return __old;
}
inline basic_streambuf<_CharT, _Traits>*
rdbuf() const
{ return _M_streambuf; }
basic_streambuf<_CharT, _Traits>*
rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
basic_ios&
copyfmt(const basic_ios& __rhs);
inline char_type
fill() const
{ return _M_fill; }
inline char_type
fill(char_type __ch)
{
char_type __old = _M_fill;
_M_fill = __ch;
return __old;
}
// Locales:
locale
imbue(const locale& __loc);
char
narrow(char_type __c, char __dfault) const;
char_type
widen(char __c) const;
protected:
// 27.4.5.1 basic_ios constructors
basic_ios() : ios_base()
{ }
void
init(basic_streambuf<_CharT, _Traits>* __sb);
};
} // namespace std
#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT
# define export
//#include <bits/basic_ios.tcc>
#endif
#endif /* _CPP_BITS_BASICIOS_H */
libstdc++-v3/bits/basic_ios.tcc deleted 100644 → 0
// basic_ios locale and locale-related member functions -*- C++ -*-
// Copyright (C) 1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#ifndef _CPP_BITS_BASICIOS_TCC
#define _CPP_BITS_BASICIOS_TCC 1
namespace std {
template<typename _CharT, typename _Traits>
basic_streambuf<_CharT, _Traits>*
basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
{
basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
_M_streambuf = __sb;
this->clear();
return __old;
}
template<typename _CharT, typename _Traits>
basic_ios<_CharT, _Traits>&
basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
{
// Per 27.1.1.1, do not call imbue, yet must trash all caches
// associated with imbue()
// Alloc any new word array first, so if it fails we have "rollback".
_Words* __words = (__rhs._M_word_limit <= _S_local_words) ?
_M_word_array : new _Words[__rhs._M_word_limit];
// XXX This is the only reason _Callback_list was defined
// inline. The suspicion is that this increased compilation
// times dramatically for functions that use this member
// function (inserters_extractors, ios_manip_fmtflags). FIX ME,
// clean this stuff up. Callbacks are broken right now, anyway.
// Bump refs before doing callbacks, for safety.
_Callback_list* __cb = __rhs._M_callbacks;
if (__cb)
__cb->_M_add_reference();
_M_call_callbacks(erase_event);
if (_M_words != _M_word_array)
delete [] _M_words;
_M_dispose_callbacks();
_M_callbacks = __cb; // NB: Don't want any added during above.
for (int __i = 0; __i < __rhs._M_word_limit; ++__i)
__words[__i] = __rhs._M_words[__i];
if (_M_words != _M_word_array)
delete [] _M_words;
_M_words = __words;
_M_word_limit = __rhs._M_word_limit;
this->flags(__rhs.flags());
this->width(__rhs.width());
this->precision(__rhs.precision());
this->tie(__rhs.tie());
this->fill(__rhs.fill());
// The next is required to be the last assignment.
this->exceptions(__rhs.exceptions());
_M_call_callbacks(copyfmt_event);
return *this;
}
template<typename _CharT, typename _Traits>
char
basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
{ return _M_ios_fctype->narrow(__c, __dfault); }
template<typename _CharT, typename _Traits>
_CharT
basic_ios<_CharT, _Traits>::widen(char __c) const
{ return _M_ios_fctype->widen(__c); }
// Locales:
template<typename _CharT, typename _Traits>
locale
basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
{
locale __old(this->getloc());
ios_base::imbue(__loc);
_M_ios_fctype = &use_facet<__ctype_type>(__loc);
_M_fnumput = &use_facet<__numput_type>(__loc);
_M_fnumget = &use_facet<__numget_type>(__loc);
if (this->rdbuf() != 0)
this->rdbuf()->pubimbue(__loc);
return __old;
}
template<typename _CharT, typename _Traits>
void
basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
{
// NB: This may be called more than once on the same object.
ios_base::_M_init();
locale __loc = this->getloc();
_M_ios_fctype = &use_facet<__ctype_type>(__loc);
// Should be filled in by ostream and istream, respectively.
_M_fnumput = &use_facet<__numput_type>(__loc);
_M_fnumget = &use_facet<__numget_type>(__loc);
_M_tie = 0;
_M_fill = this->widen(' ');
_M_exception = goodbit;
_M_streambuf = __sb;
iostate __state = __sb ? goodbit : badbit;
_M_streambuf_state = __state;
}
} // namespace std
#endif /* _CPP_BITS_BASICIOS_TCC */
libstdc++-v3/bits/c++config deleted 100644 → 0
// Predefined symbols and macros -*- C++ -*-
// Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#ifndef _CPP_CPPCONFIG
#define _CPP_CPPCONFIG 1
// The current version of the C++ library in compressed ISO date format.
#define __GLIBCPP__ 20000911
// By enabling this, all GNU extensions are enabled.
#define _GNU_SOURCE 1
// By enabling this, all ISO C99, ISO C9X functionality is enabled.
#define _ISOC99_SOURCE 1
// This flag controls the error handling in string, and perhaps other
// bits as time goes on: check out bits/basic_string.h for more
// info. It also helps alleviate the circular dependency between
// string and exception.
# define _GLIBCPP_USE_EXCEPTIONS 1
// This is necessary until Egcs supports separate template
// compilation.
#define _GLIBCPP_NO_TEMPLATE_EXPORT 1
// This is a hack around not having either pre-compiled headers or
// export compilation. If defined, the io, string, and valarray
// headers will include all the necessary bits. If not defined, the
// implementation optimizes the headers for the most commonly-used
// types. For the io library, this means that larger, out-of-line
// member functions are only declared, and definitions are not parsed
// by the compiler, but instead instantiated into the library binary.
//#define _GLIBCPP_FULLY_COMPLIANT_HEADERS 1
// To enable older, ARM-style iostreams and other anachronisms use this.
//#define _GLIBCPP_DEPRICATED 1
// Use corrected code from the committee library group's issues list.
# define _GLIBCPP_RESOLVE_LIB_DEFECTS 1
libstdc++-v3/bits/char_traits.h deleted 100644 → 0
// Character Traits for use by standard string and iostream -*- C++ -*-
// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 21 Strings library
//
#ifndef _CPP_BITS_CHAR_TRAITS_H
#define _CPP_BITS_CHAR_TRAITS_H 1
#include <bits/std_cwchar.h> // For mbstate_t.
#include <bits/std_cstring.h> // For memmove, memset, memchr
#include <bits/fpos.h> // For streamoff, streamsize
namespace std {
// Same as iosfwd
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
// Can't have self-recursive types for streampos.
// 21.1.3.1 char_traits sets size_type to streampos
// 27.4.1
// And here, where streampos is typedefed to fpos<traits::state_type>
typedef fpos<mbstate_t> streampos;
# ifdef _GLIBCPP_USE_WCHAR_T
typedef fpos<mbstate_t> wstreampos;
# endif
#endif
// 21.1.2 Basis for explicit _Traits specialization
// NB: That for any given actual character type this definition is
// probably wrong.
template<class _CharT>
struct char_traits
{
typedef _CharT char_type;
// Unsigned as wint_t in unsigned.
typedef unsigned long int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
static void
assign(char_type& __c1, const char_type& __c2)
{ __c1 = __c2; }
static bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
static bool
lt(const char_type& __c1, const char_type& __c2)
{ return __c1 < __c2; }
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
for (size_t __i = 0; __i < __n; ++__i)
if (!eq(__s1[__i], __s2[__i]))
return lt(__s1[__i], __s2[__i]) ? -1 : 1;
return 0;
}
static size_t
length(const char_type* __s)
{
const char_type* __p = __s;
while (*__p) ++__p;
return (__p - __s);
}
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{
for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
if (*__p == __a) return __p;
return 0;
}
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{ return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); }
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); }
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{
for (char_type* __p = __s; __p < __s + __n; ++__p)
assign(*__p, __a);
return __s;
}
static char_type
to_char_type(const int_type& __c)
{ return char_type(__c); }
static int_type
to_int_type(const char_type& __c) { return int_type(__c); }
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
static state_type
_S_get_state(const pos_type& __pos) { return __pos.state(); }
static int_type
eof() { return static_cast<int_type>(-1); }
static int_type
_S_eos() { return char_type(); }
static int_type
not_eof(const int_type& __c)
{ return eq_int_type(__c, eof()) ? int_type(0) : __c; }
};
// 21.1.4 char_traits specializations
template<>
struct char_traits<char>
{
typedef char char_type;
typedef unsigned int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
static void
assign(char_type& __c1, const char_type& __c2)
{ __c1 = __c2; }
static bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
static bool
lt(const char_type& __c1, const char_type& __c2)
{ return __c1 < __c2; }
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{ return memcmp(__s1, __s2, __n); }
static size_t
length(const char_type* __s)
{ return strlen(__s); }
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{ return static_cast<const char_type*>(memchr(__s, __a, __n)); }
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{ return static_cast<char_type*>(memmove(__s1, __s2, __n)); }
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return static_cast<char_type*>(memset(__s, __a, __n)); }
static char_type
to_char_type(const int_type& __c)
{ return static_cast<char_type>(__c); }
// To keep both the byte 0xff and the eof symbol 0xffffffff
// from ending up as 0xffffffff.
static int_type
to_int_type(const char_type& __c)
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
static state_type
_S_get_state(const pos_type& __pos) { return __pos.state(); }
static int_type
eof() { return static_cast<int_type>(EOF); }
static int_type
_S_eos() { return char_type(); }
static int_type
not_eof(const int_type& __c)
{ return (__c == eof()) ? 0 : __c; }
};
#ifdef _GLIBCPP_USE_WCHAR_T
template<>
struct char_traits<wchar_t>
{
typedef wchar_t char_type;
typedef wint_t int_type;
typedef wstreamoff off_type;
typedef wstreampos pos_type;
typedef mbstate_t state_type;
static void
assign(char_type& __c1, const char_type& __c2)
{ __c1 = __c2; }
static bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; }
static bool
lt(const char_type& __c1, const char_type& __c2)
{ return __c1 < __c2; }
static int
compare(const char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemcmp(__s1, __s2, __n); }
static size_t
length(const char_type* __s)
{ return wcslen(__s); }
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{ return wmemchr(__s, __a, __n); }
static char_type*
move(char_type* __s1, const char_type* __s2, int_type __n)
{ return wmemmove(__s1, __s2, __n); }
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemcpy(__s1, __s2, __n); }
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return wmemset(__s, __a, __n); }
static char_type
to_char_type(const int_type& __c) { return char_type(__c); }
static int_type
to_int_type(const char_type& __c) { return int_type(__c); }
static bool
eq_int_type(const int_type& __c1, const int_type& __c2)
{ return __c1 == __c2; }
static state_type
_S_get_state(const pos_type& __pos) { return __pos.state(); }
static int_type
eof() { return static_cast<int_type>(WEOF); }
static int_type
_S_eos() { return char_type(); }
static int_type
not_eof(const int_type& __c)
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
#endif //_GLIBCPP_USE_WCHAR_T
template<typename _CharT, typename _Traits>
struct _Char_traits_match
{
_CharT _M_c;
_Char_traits_match(_CharT const& __c) : _M_c(__c) { }
bool
operator()(_CharT const& __a) { return _Traits::eq(_M_c,__a); }
};
} // namespace std
#endif /* _CPP_BITS_CHAR_TRAITS_H */
libstdc++-v3/bits/container_concepts.h deleted 100644 → 0
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef __STL_CONTAINER_CONCEPTS_H
#define __STL_CONTAINER_CONCEPTS_H
#include <bits/concept_checks.h>
#ifdef __STL_USE_CONCEPT_CHECKS
// This file covers the following concepts:
// _Container
// _ForwardContainer
// _ReversibleContainer
// _const_ReversibleContainer
// _RandomAccessContainer
//
struct _ERROR_IN_STL_CONTAINER {
/* Container expresssions */
template <class _Container>
static void
__begin_iterator_accessor_requirement_violation(_Container __c) {
__c.begin();
}
template <class _Container>
static void
__const_begin_iterator_accessor_requirement_violation(const _Container& __c) {
__c.begin();
}
template <class _Container>
static void
__end_iterator_accessor_requirement_violation(_Container __c) {
__c.end();
}
template <class _Container>
static void
__const_end_iterator_accessor_requirement_violation(const _Container& __c) {
__c.end();
}
template <class _Container>
static void
__rbegin_iterator_accessor_requirement_violation(_Container __c) {
__c.rbegin();
}
template <class _Container>
static void
__const_rbegin_iterator_accessor_requirement_violation(const _Container& __c) {
__c.rbegin();
}
template <class _Container>
static void
__rend_iterator_accessor_requirement_violation(_Container __c) {
__c.rend();
}
template <class _Container>
static void
__const_rend_iterator_accessor_requirement_violation(const _Container& __c) {
__c.rend();
}
template <class _Container>
static void
__size_function_must_be_const(const _Container& __c) {
__c.size();
}
template <class _Container>
static void
__size_function_requirement_violation(_Container& __c) {
__c.size();
__size_function_must_be_const(__c);
}
template <class _Container>
static void
__max_size_function_must_be_const(const _Container& __c) {
__c.max_size();
}
template <class _Container>
static void
__max_size_function_requirement_violation(_Container& __c) {
__c.max_size();
__max_size_function_must_be_const(__c);
}
template <class _Container>
static void
__empty_function_must_be_const(const _Container& __c) {
__c.empty();
}
template <class _Container>
static void
__empty_function_requirement_violation(_Container& __c) {
__c.empty();
__empty_function_must_be_const(__c);
}
template <class _Container>
static void
__swap_function_requirement_violation(_Container& __c) {
__c.swap(__c);
}
};
__STL_TYPEDEF_REQUIREMENT(iterator);
__STL_TYPEDEF_REQUIREMENT(const_iterator);
/* Containers */
template <class _Container>
struct _Container_concept_specification {
static void
_Container_requirement_violation(_Container __c) {
// Refinement of Assignable
_Assignable_concept_specification<_Container>::_Assignable_requirement_violation(__c);
// Associated Types
__value_type__typedef_requirement_violation<_Container>();
__difference_type__typedef_requirement_violation<_Container>();
__size_type__typedef_requirement_violation<_Container>();
__reference__typedef_requirement_violation<_Container>();
__const_reference__typedef_requirement_violation<_Container>();
__pointer__typedef_requirement_violation<_Container>();
__const_pointer__typedef_requirement_violation<_Container>();
__iterator__typedef_requirement_violation<_Container>();
__const_iterator__typedef_requirement_violation<_Container>();
// Valid Expressions
_ERROR_IN_STL_CONTAINER::__const_begin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__const_end_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__begin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__end_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__size_function_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__max_size_function_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__empty_function_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__swap_function_requirement_violation(__c);
// Requirements on Iterators
typedef typename _Container::iterator iter;
typedef typename _Container::const_iterator const_iter;
_InputIterator_concept_specification<const_iter>::_InputIterator_requirement_violation(const_iter());
_InputIterator_concept_specification<iter>::_InputIterator_requirement_violation(iter());
}
};
template <class _ForwardContainer>
struct _ForwardContainer_concept_specification {
static void
_ForwardContainer_requirement_violation(_ForwardContainer __c) {
// Refinement of Container
_Container_concept_specification<_ForwardContainer>::_Container_requirement_violation(__c);
// Requirements on Iterators
typedef typename _ForwardContainer::iterator iter;
typedef typename _ForwardContainer::const_iterator const_iter;
_ForwardIterator_concept_specification<const_iter>::_ForwardIterator_requirement_violation(const_iter());
_Mutable_ForwardIterator_concept_specification<iter>::_Mutable_ForwardIterator_requirement_violation(iter());
}
};
__STL_TYPEDEF_REQUIREMENT(reverse_iterator);
__STL_TYPEDEF_REQUIREMENT(const_reverse_iterator);
template <class _ReversibleContainer>
struct _ReversibleContainer_concept_specification {
static void
_ReversibleContainer_requirement_violation(_ReversibleContainer __c) {
// Refinement of ForwardContainer
_ForwardContainer_concept_specification<_ReversibleContainer>::_ForwardContainer_requirement_violation(__c);
// Associated types
__reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
__const_reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
// Valid Expressions
_ERROR_IN_STL_CONTAINER::__const_rbegin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__const_rend_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__rbegin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__rend_iterator_accessor_requirement_violation(__c);
// Requirements on Iterators
typedef typename _ReversibleContainer::iterator iter;
typedef typename _ReversibleContainer::const_iterator const_iter;
_BidirectionalIterator_concept_specification<const_iter>::_BidirectionalIterator_requirement_violation(const_iter());
_Mutable_BidirectionalIterator_concept_specification<iter>::_Mutable_BidirectionalIterator_requirement_violation(iter());
}
};
template <class _ReversibleContainer>
struct _const_ReversibleContainer_concept_specification {
static void
_const_ReversibleContainer_requirement_violation(_ReversibleContainer __c) {
// Refinement of Container (JGS, not ForwardContainer)
_Container_concept_specification<_ReversibleContainer>::_Container_requirement_violation(__c);
// Associated types
__reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
__const_reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
// Valid Expressions
_ERROR_IN_STL_CONTAINER::__const_rbegin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__const_rend_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__rbegin_iterator_accessor_requirement_violation(__c);
_ERROR_IN_STL_CONTAINER::__rend_iterator_accessor_requirement_violation(__c);
// Requirements on Iterators
typedef typename _ReversibleContainer::iterator iter;
typedef typename _ReversibleContainer::const_iterator const_iter;
_BidirectionalIterator_concept_specification<const_iter>::_BidirectionalIterator_requirement_violation(const_iter());
}
};
template <class _RandomAccessContainer>
struct _RandomAccessContainer_concept_specification {
static void
_RandomAccessContainer_requirement_violation(_RandomAccessContainer __c) {
// Refinement of ReversibleContainer
_ReversibleContainer_concept_specification<_RandomAccessContainer>::_ReversibleContainer_requirement_violation(__c);
// Valid Expressions
typedef typename _RandomAccessContainer::value_type __T;
typedef typename _RandomAccessContainer::difference_type _Dist;
typedef typename _Mutable_trait<__T>::_Type Type;
typedef Type* _TypePtr;
typedef typename _Mutable_trait<_Dist>::_Type Dist;
_STL_ERROR::__element_access_operator_requirement_violation(__c,
_TypePtr(),
Dist());
// Requirements on Iterators
typedef typename _RandomAccessContainer::iterator iter;
typedef typename _RandomAccessContainer::const_iterator const_iter;
_RandomAccessIterator_concept_specification<const_iter>::_RandomAccessIterator_requirement_violation(const_iter());
_Mutable_RandomAccessIterator_concept_specification<iter>::_Mutable_RandomAccessIterator_requirement_violation(iter());
}
};
#endif /* if __STL_USE_CONCEPT_CHECKS */
#endif /* __STL_CONTAINER_CONCEPTS_H */
libstdc++-v3/bits/cpp_type_traits.h deleted 100644 → 0
// The -*- C++ -*- type traits classes for internal use in libstdc++
// Copyright (C) 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// Written by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
#ifndef _CPP_BITS_CPP_TYPE_TRAITS_H
#define _CPP_BITS_CPP_TYPE_TRAITS_H 1
//
// This file provides some compile-time information about various types.
// These informations were designed, on purpose, to be constant-expressions
// and not types as found in <stl/bits/type_traits.h>. In particular, they
// can be used in control structures and the optimizer hopefully will do
// the obvious thing.
//
// Why integral expressions, and not functions nor types?
// Firstly, these compile-time information entities are used as
// template-arguments so function return values won't work. We
// need compile-time entities. We're left with types and constant
// integral expressions.
// Secondly, from the point of view of ease of use type-based compile-time
// information is -not- *that* convenient. On has to write lots of
// overloaded functions and to hope that the compiler will select the right
// one. As a net effect, the overall structure isn't very clear at first
// glance.
// Thirdly, partial ordering and overload resolution (of template functions)
// is very costly in terms of compiler-resource. It is a Good Thing to
// keep these resource consumption as least as possible.
//
// -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06.
//
namespace std {
template<typename _Tp>
struct __is_void
{
enum
{
_M_type = 0
};
};
template<>
struct __is_void<void>
{
enum
{
_M_type = 1
};
};
//
// Integer types
//
template<typename _Tp>
struct __is_integer
{
enum
{
_M_type = 0
};
};
// Thirteen specializations (yes there are eleven standard integer
// types; 'long long' and 'unsigned long long' are supported as
// extensions)
template<>
struct __is_integer<bool>
{
enum
{
_M_type = 1
};
};
template<>
struct __is_integer<char>
{
enum
{
_M_type = 1
};
};
template<>
struct __is_integer<signed char>
{
enum
{
_M_type = 1
};
};
template<>
struct __is_integer<unsigned char>
{
enum
{
_M_type = 1
};
};
# ifdef _GLIBCPP_USE_WCHAR_T
template<>
struct __is_integer<wchar_t>
{
enum
{
_M_type = 1
};
};
# endif
template<>
struct __is_integer<short>
{
enum
{
_M_type = 1
};
};
template<>
struct __is_integer<unsigned short>
{
enum
{
_M_type = 1
};
};
template<>
struct __is_integer<int>
{
enum
{
_M_type = 1
};
};
template<>
struct __is_integer<unsigned int>
{
enum
{
_M_type = 1
};
};
template<>
struct __is_integer<long>
{
enum
{
_M_type = 1
};
};
template<>
struct __is_integer<unsigned long>
{
enum
{
_M_type = 1
};
};
# ifdef _GLIBCPP_USE_LONG_LONG
template<>
struct __is_integer<long long>
{
enum
{
_M_type = 1
};
};
template<>
struct __is_integer<unsigned long long>
{
enum
{
_M_type = 1
};
};
# endif
//
// Floating point types
//
template<typename _Tp>
struct __is_floating
{
enum
{
_M_type = 0
};
};
// three specializations (float, double and 'long double')
template<>
struct __is_floating<float>
{
enum
{
_M_type = 1
};
};
template<>
struct __is_floating<double>
{
enum
{
_M_type = 1
};
};
template<>
struct __is_floating<long double>
{
enum
{
_M_type = 1
};
};
//
// An arithmetic type is an integer type or a floating point type
//
template<typename _Tp>
struct __is_arithmetic
{
enum
{
_M_type = __is_integer<_Tp>::_M_type || __is_floating<_Tp>::_M_type
};
};
//
// A fundamental type is `void' or and arithmetic type
//
template<typename _Tp>
struct __is_fundamental
{
enum
{
_M_type = __is_void<_Tp>::_M_type || __is_arithmetic<_Tp>::_M_type
};
};
//
// For the immediate use, the following is a good approximation
//
template<typename _Tp>
struct __is_pod
{
enum
{
_M_type = __is_fundamental<_Tp>::_M_type
};
};
} // namespace std
#endif //_CPP_BITS_CPP_TYPE_TRAITS_H
libstdc++-v3/bits/exception_support.h deleted 100644 → 0
// Methods and support infrastructure for exceptions -*- C++ -*-
// Copyright (C) 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 15 Exception handling
//
// This file declares functions whose only purpose is to throw an
// exception. They help break a circularity between <string> and
// <stdexcept>. See src/stdexcept.cc, where these functions are
// defined.
// XXX: These functions serve a similar purpose to those in
// stl/bits/stl_range_errors.h . Eventually the two approaches should
// be merged.
#ifndef _CPP_EXCEPTION_SUPPORT_H
#define _CPP_EXCEPTION_SUPPORT_H 1
namespace std {
#if _GLIBCPP_USE_EXCEPTIONS
// Internal functions for string implementation.
extern void __out_of_range(const char *__str);
extern void __length_error(const char *__str);
# define __OUTOFRANGE(__cond) \
do { if (__cond) __out_of_range(#__cond); } while (0)
# define __LENGTHERROR(__cond) \
do { if (__cond) __length_error(#__cond); } while (0)
#else
# include <bits/std_cassert.h>
# define __OUTOFRANGE(__cond) assert(!(__cond))
# define __LENGTHERROR(__cond) assert(!(__cond))
#endif
} // namespace std
#endif /* _CPP_EXCEPTION_SUPPORT_H */
libstdc++-v3/bits/fpos.h deleted 100644 → 0
// File position object and stream types
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 27 Input/output library
//
#ifndef _CPP_BITS_FPOS_H
#define _CPP_BITS_FPOS_H 1
// Need this here as well as in std_ios because fpos is used in
// char_traits, and char_traits is used by string, which may or may
// not have included the std_ios file.
#include <bits/c++io.h>
namespace std {
// 27.4.1 Types
// 27.4.3 Template class fpos
template<typename _StateT>
class fpos
{
public:
// Types:
typedef _StateT __state_type;
__state_type
state() const { return _M_st; }
void
state(__state_type __st) { _M_st = __st; }
// NB: The standard defines only the implicit copy ctor and the
// previous two members. The rest is a "conforming extension".
fpos(): _M_st(__state_type()), _M_pos(streamoff()) { }
fpos(streamoff __pos, __state_type __st)
: _M_st(__st), _M_pos(__pos) { }
fpos(streamoff __pos)
: _M_st(), _M_pos(__pos) { }
operator streamoff() const { return _M_pos; }
fpos&
operator+=(streamoff __off) { _M_pos += __off; return *this; }
fpos&
operator-=(streamoff __off) { _M_pos -= __off; return *this; }
bool
operator==(const fpos& __pos2) const { return _M_pos == __pos2._M_pos; }
bool
operator!=(const fpos& __pos2) const { return _M_pos != __pos2._M_pos; }
streamoff
_M_position() const { return _M_pos; }
void
_M_position(streamoff __pos) { _M_pos = __pos; }
private:
__state_type _M_st;
streamoff _M_pos;
};
template<typename _State>
inline fpos<_State>
operator+(const fpos<_State>& __pos, streamoff __off)
{
fpos<_State> t(__pos);
return t += __off;
}
template<typename _State>
inline fpos<_State>
operator-(const fpos<_State>& __pos, streamoff __off)
{
fpos<_State> t(__pos);
return t -= __off;
}
template<typename _State>
inline streamoff
operator-(const fpos<_State>& __pos1, const fpos<_State>& __pos2)
{ return __pos1._M_position() - __pos2._M_position(); }
} // namespace std
#endif /* _CPP_BITS_FPOS_H */
libstdc++-v3/bits/generic_shadow.h deleted 100644 → 0
// generic C header shadow file -*- C++ -*-
// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// This file is included by all the standard C <foo.h> headers
// after defining _SHADOW_NAME.
#ifdef _IN_C_LEGACY_ /* sub-included by a C header */
// Get out of the "swamp."
} // Close extern "C"
} // Close namespace _C_legacy::
# undef _IN_C_LEGACY_
# include _SHADOW_NAME
// Dive back into the "swamp."
namespace _C_legacy {
extern "C" {
# define _IN_C_LEGACY_
#else /* not _IN_C_LEGACY_: directly included by user program */
# include _SHADOW_NAME
// Expose global C names, including non-standard ones, but shadow
// some names and types with the std:: C++ version.
using namespace ::_C_legacy::_C_shadow;
#endif /* _IN_C_LEGACY_ */
libstdc++-v3/bits/gslice.h deleted 100644 → 0
// The template and inlines for the -*- C++ -*- gslice class.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
#ifndef _CPP_BITS_GSLICE_H
#define _CPP_BITS_GSLICE_H
namespace std {
class gslice
{
public:
gslice ();
gslice (size_t, const valarray<size_t>&, const valarray<size_t>&);
// XXX: the IS says the copy-ctor and copy-assignment operators are
// synthetized by the compiler but they are just unsuitable
// for a ref-counted semantic
gslice(const gslice&);
~gslice();
// XXX: See the note above.
gslice& operator= (const gslice&);
size_t start () const;
valarray<size_t> size () const;
valarray<size_t> stride () const;
private:
struct _Indexer {
size_t _M_count;
size_t _M_start;
valarray<size_t> _M_size;
valarray<size_t> _M_stride;
valarray<size_t> _M_index;
_Indexer(size_t, const valarray<size_t>&,
const valarray<size_t>&);
void _M_increment_use() { ++_M_count; }
size_t _M_decrement_use() { return --_M_count; }
};
_Indexer* _M_index;
template<typename _Tp> friend class valarray;
};
inline size_t
gslice::start () const
{ return _M_index ? _M_index->_M_start : 0; }
inline valarray<size_t>
gslice::size () const
{ return _M_index ? _M_index->_M_size : valarray<size_t>(); }
inline valarray<size_t>
gslice::stride () const
{ return _M_index ? _M_index->_M_stride : valarray<size_t>(); }
inline gslice::gslice () : _M_index(0) {}
inline
gslice::gslice(size_t __o, const valarray<size_t>& __l,
const valarray<size_t>& __s)
: _M_index(new gslice::_Indexer(__o, __l, __s)) {}
inline
gslice::gslice(const gslice& __g) : _M_index(__g._M_index)
{ if (_M_index) _M_index->_M_increment_use(); }
inline
gslice::~gslice()
{ if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; }
inline gslice&
gslice::operator= (const gslice& __g)
{
if (__g._M_index) __g._M_index->_M_increment_use();
if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index;
_M_index = __g._M_index;
return *this;
}
} // std::
#endif /* _CPP_BITS_GSLICE_H */
// Local Variables:
// mode:c++
// End:
libstdc++-v3/bits/gslice_array.h deleted 100644 → 0
// The template and inlines for the -*- C++ -*- gslice_array class.
// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
#ifndef _CPP_BITS_GSLICE_ARRAY
#define _CPP_BITS_GSLICE_ARRAY 1
namespace std {
template<typename _Tp> class gslice_array
{
public:
typedef _Tp value_type;
void operator= (const valarray<_Tp>&) const;
void operator*= (const valarray<_Tp>&) const;
void operator/= (const valarray<_Tp>&) const;
void operator%= (const valarray<_Tp>&) const;
void operator+= (const valarray<_Tp>&) const;
void operator-= (const valarray<_Tp>&) const;
void operator^= (const valarray<_Tp>&) const;
void operator&= (const valarray<_Tp>&) const;
void operator|= (const valarray<_Tp>&) const;
void operator<<=(const valarray<_Tp>&) const;
void operator>>=(const valarray<_Tp>&) const;
void operator=(const _Tp&);
template<class _Dom>
void operator= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator*= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator/= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator%= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator+= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator-= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator^= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator&= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator|= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator<<= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator>>= (const _Expr<_Dom,_Tp>&) const;
private:
_Array<_Tp> _M_array;
const valarray<size_t>& _M_index;
friend class valarray<_Tp>;
gslice_array (_Array<_Tp>, const valarray<size_t>&);
// this constructor needs to be implemented.
gslice_array (const gslice_array&);
// not implemented
gslice_array();
gslice_array& operator= (const gslice_array&);
};
template<typename _Tp>
inline
gslice_array<_Tp>::gslice_array (_Array<_Tp> __a,
const valarray<size_t>& __i)
: _M_array (__a), _M_index (__i) {}
template<typename _Tp>
inline
gslice_array<_Tp>::gslice_array (const gslice_array<_Tp>& __a)
: _M_array (__a._M_array), _M_index (__a._M_index) {}
template<typename _Tp>
inline void
gslice_array<_Tp>::operator= (const _Tp& __t)
{
__valarray_fill (_M_array, _Array<size_t>(_M_index),
_M_index.size(), __t);
}
template<typename _Tp>
inline void
gslice_array<_Tp>::operator= (const valarray<_Tp>& __v) const
{
__valarray_copy (_Array<_Tp> (__v), __v.size (),
_M_array, _Array<size_t>(_M_index));
}
template<typename _Tp>
template<class E>
inline void
gslice_array<_Tp>::operator= (const _Expr<E, _Tp>& __e) const
{
__valarray_copy (__e, _M_index.size(), _M_array,
_Array<size_t>(_M_index));
}
#undef _DEFINE_VALARRAY_OPERATOR
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
template<typename _Tp> \
inline void \
gslice_array<_Tp>::operator op##= (const valarray<_Tp>& __v) const \
{ \
_Array_augmented_##name (_M_array, _Array<size_t>(_M_index), \
_Array<_Tp> (__v), __v.size ()); \
} \
\
template<typename _Tp> template<class E> \
inline void \
gslice_array<_Tp>::operator op##= (const _Expr<E, _Tp>& __e) const \
{ \
_Array_augmented_##name (_M_array, _Array<size_t>(_M_index), __e, \
_M_index.size()); \
}
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
_DEFINE_VALARRAY_OPERATOR(/, divides)
_DEFINE_VALARRAY_OPERATOR(%, modulus)
_DEFINE_VALARRAY_OPERATOR(+, plus)
_DEFINE_VALARRAY_OPERATOR(-, minus)
_DEFINE_VALARRAY_OPERATOR(^, xor)
_DEFINE_VALARRAY_OPERATOR(&, and)
_DEFINE_VALARRAY_OPERATOR(|, or)
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
#undef _DEFINE_VALARRAY_OPERATOR
} // std::
#endif /* _CPP_BITS_GSLICE_ARRAY */
// Local Variables:
// mode:c++
// End:
libstdc++-v3/bits/indirect_array.h deleted 100644 → 0
// The template and inlines for the -*- C++ -*- indirect_array class.
// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
#ifndef _CPP_BITS_INDIRECT_ARRAY_H
#define _CPP_BITS_INDIRECT_ARRAY_H
namespace std {
template <class _Tp> class indirect_array
{
public:
typedef _Tp value_type;
void operator= (const valarray<_Tp>&) const;
void operator*= (const valarray<_Tp>&) const;
void operator/= (const valarray<_Tp>&) const;
void operator%= (const valarray<_Tp>&) const;
void operator+= (const valarray<_Tp>&) const;
void operator-= (const valarray<_Tp>&) const;
void operator^= (const valarray<_Tp>&) const;
void operator&= (const valarray<_Tp>&) const;
void operator|= (const valarray<_Tp>&) const;
void operator<<= (const valarray<_Tp>&) const;
void operator>>= (const valarray<_Tp>&) const;
void operator= (const _Tp&);
// ~indirect_array();
template<class _Dom>
void operator= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
void operator*= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
void operator/= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
void operator%= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
void operator+= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
void operator-= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
void operator^= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
void operator&= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
void operator|= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
void operator<<= (const _Expr<_Dom, _Tp>&) const;
template<class _Dom>
void operator>>= (const _Expr<_Dom, _Tp>&) const;
private:
indirect_array (const indirect_array&);
indirect_array (_Array<_Tp>, size_t, _Array<size_t>);
friend class valarray<_Tp>;
friend class gslice_array<_Tp>;
const size_t _M_sz;
const _Array<size_t> _M_index;
const _Array<_Tp> _M_array;
// not implemented
indirect_array ();
indirect_array& operator= (const indirect_array&);
};
template<typename _Tp>
inline indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
: _M_sz (__a._M_sz), _M_index (__a._M_index),
_M_array (__a._M_array) {}
template<typename _Tp>
inline
indirect_array<_Tp>::indirect_array (_Array<_Tp> __a, size_t __s,
_Array<size_t> __i)
: _M_sz (__s), _M_index (__i), _M_array (__a) {}
// template<typename _Tp>
// inline indirect_array<_Tp>::~indirect_array() {}
template<typename _Tp>
inline void
indirect_array<_Tp>::operator= (const _Tp& __t)
{ __valarray_fill(_M_array, _M_index, _M_sz, __t); }
template<typename _Tp>
inline void
indirect_array<_Tp>::operator= (const valarray<_Tp>& __v) const
{ __valarray_copy (_Array<_Tp> (__v), _M_sz, _M_array, _M_index); }
template<typename _Tp>
template<class _Dom>
inline void
indirect_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
{ __valarray_copy (__e, _M_sz, _M_array, _M_index); }
#undef _DEFINE_VALARRAY_OPERATOR
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
template<typename _Tp> \
inline void \
indirect_array<_Tp>::operator op##= (const valarray<_Tp>& __v) const \
{ \
_Array_augmented_##name (_M_array, _M_index, _Array<_Tp> (__v), _M_sz); \
} \
\
template<typename _Tp> template<class _Dom> \
inline void \
indirect_array<_Tp>::operator op##= (const _Expr<_Dom,_Tp>& __e) const \
{ \
_Array_augmented_##name (_M_array, _M_index, __e, _M_sz); \
}
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
_DEFINE_VALARRAY_OPERATOR(/, divides)
_DEFINE_VALARRAY_OPERATOR(%, modulus)
_DEFINE_VALARRAY_OPERATOR(+, plus)
_DEFINE_VALARRAY_OPERATOR(-, minus)
_DEFINE_VALARRAY_OPERATOR(^, xor)
_DEFINE_VALARRAY_OPERATOR(&, and)
_DEFINE_VALARRAY_OPERATOR(|, or)
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
#undef _DEFINE_VALARRAY_OPERATOR
} // std::
#endif /* _CPP_BITS_INDIRECT_ARRAY_H */
// Local Variables:
// mode:c++
// End:
libstdc++-v3/bits/mask_array.h deleted 100644 → 0
// The template and inlines for the -*- C++ -*- mask_array class.
// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
#ifndef _CPP_BITS_MASK_ARRAY_H
#define _CPP_BITS_MASK_ARRAY_H 1
namespace std {
template <class _Tp> class mask_array
{
public:
typedef _Tp value_type;
void operator= (const valarray<_Tp>&) const;
void operator*= (const valarray<_Tp>&) const;
void operator/= (const valarray<_Tp>&) const;
void operator%= (const valarray<_Tp>&) const;
void operator+= (const valarray<_Tp>&) const;
void operator-= (const valarray<_Tp>&) const;
void operator^= (const valarray<_Tp>&) const;
void operator&= (const valarray<_Tp>&) const;
void operator|= (const valarray<_Tp>&) const;
void operator<<=(const valarray<_Tp>&) const;
void operator>>=(const valarray<_Tp>&) const;
void operator= (const _Tp&);
// ~mask_array ();
template<class _Dom>
void operator= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator*= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator/= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator%= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator+= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator-= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator^= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator&= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator|= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator<<=(const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator>>=(const _Expr<_Dom,_Tp>&) const;
private:
mask_array (_Array<_Tp>, size_t, _Array<bool>);
friend class valarray<_Tp>;
const size_t _M_sz;
const _Array<bool> _M_mask;
const _Array<_Tp> _M_array;
mask_array (const mask_array&);
// not implemented
mask_array ();
mask_array& operator= (const mask_array&);
};
template<typename _Tp>
inline mask_array<_Tp>::mask_array (const mask_array<_Tp>& a)
: _M_sz (a._M_sz), _M_mask (a._M_mask), _M_array (a._M_array) {}
template<typename _Tp>
inline
mask_array<_Tp>::mask_array (_Array<_Tp> __a, size_t __s, _Array<bool> __m)
: _M_sz (__s), _M_mask (__m), _M_array (__a) {}
// template<typename _Tp>
// inline mask_array<_Tp>::~mask_array () {}
template<typename _Tp>
inline void
mask_array<_Tp>::operator= (const _Tp& __t)
{ __valarray_fill (_M_array, _M_sz, _M_mask, __t); }
template<typename _Tp>
inline void
mask_array<_Tp>::operator= (const valarray<_Tp>& __v) const
{ __valarray_copy (_Array<_Tp> (__v), __v.size (), _M_array, _M_mask); }
template<typename _Tp>
template<class E>
inline void
mask_array<_Tp>::operator= (const _Expr<E, _Tp>& __e) const
{ __valarray_copy (__e, __e.size (), _M_array, _M_mask); }
#undef _DEFINE_VALARRAY_OPERATOR
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
template<typename _Tp> \
inline void \
mask_array<_Tp>::operator op##= (const valarray<_Tp>& __v) const \
{ \
_Array_augmented_##name (_M_array, _M_mask, \
_Array<_Tp> (__v), __v.size ()); \
} \
\
template<typename _Tp> template<class E> \
inline void \
mask_array<_Tp>::operator op##= (const _Expr<E, _Tp>& __e) const \
{ \
_Array_augmented_##name (_M_array, _M_mask, __e, __e.size ()); \
}
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
_DEFINE_VALARRAY_OPERATOR(/, divides)
_DEFINE_VALARRAY_OPERATOR(%, modulus)
_DEFINE_VALARRAY_OPERATOR(+, plus)
_DEFINE_VALARRAY_OPERATOR(-, minus)
_DEFINE_VALARRAY_OPERATOR(^, xor)
_DEFINE_VALARRAY_OPERATOR(&, and)
_DEFINE_VALARRAY_OPERATOR(|, or)
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
#undef _DEFINE_VALARRAY_OPERATOR
} // std::
#endif /* _CPP_BITS_MASK_ARRAY_H */
// Local Variables:
// mode:c++
// End:
libstdc++-v3/bits/sbuf_iter.h deleted 100644 → 0
// Streambuf iterators
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// XXX Should specialize copy, find algorithms for streambuf iterators.
#ifndef _CPP_BITS_SBUF_ITER_H
#define _CPP_BITS_SBUF_ITER_H 1
namespace std
{
template<typename _CharT, typename _Traits>
class ostreambuf_iterator
#if 0 // XXX this is standard:
: public iterator<output_iterator_tag, _CharT, void, void, void>
#else
: public output_iterator
#endif
{
public:
// Types:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
inline
ostreambuf_iterator(ostream_type& __s) throw ()
: _M_sbuf(__s.rdbuf()), _M_failed(false) { }
ostreambuf_iterator(streambuf_type* __s) throw ()
: _M_sbuf(__s), _M_failed(false) { }
ostreambuf_iterator&
operator=(_CharT __c);
ostreambuf_iterator&
operator*() throw()
{ return *this; }
ostreambuf_iterator&
operator++(int) throw()
{ return *this; }
ostreambuf_iterator&
operator++() throw()
{ return *this; }
bool
failed() const throw()
{ return _M_failed; }
private:
streambuf_type* _M_sbuf;
bool _M_failed;
#if 0
template<>
friend char const*
copy(char const* __first, char const* __last,
ostreambuf_iterator<char,char_traits<char> > __to);
template<>
friend wchar_t const*
copy(wchar_t const* __first, wchar_t const* __last,
ostreambuf_iterator<wchar_t,char_traits<wchar_t> > __to);
#endif
};
template<typename _CharT, typename _Traits>
inline ostreambuf_iterator<_CharT, _Traits>&
ostreambuf_iterator<_CharT, _Traits>::operator=(_CharT __c)
{
if (!_M_failed &&
_Traits::eq_int_type(_M_sbuf->sputc(__c),_Traits::eof()))
_M_failed = true;
return *this;
}
#if 0
// Optimized specializations of standard algorithms
// These are specialized only for standard types
// (with no unbound arguments) to avoid creating
// overload problems with user specializations.
template<>
char const*
copy(char const* __first, char const* __last,
ostreambuf_iterator<char,char_traits<char> > __to)
{
if (!__to._M_failed)
__to._M_sbuf->sputn(__first, __last-__first);
return __last;
}
template<>
wchar_t const*
copy(wchar_t const* __first, wchar_t const* __last,
ostreambuf_iterator<whar_t,char_traits<wchar_t> > __to)
{
if (!__to._M_failed)
__to._M_sbuf->sputn(__first, __last-__first);
return __last;
}
#endif
// 24.5.3 Template class istreambuf_iterator
template<class _CharT, class _Traits>
class istreambuf_iterator
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
_CharT*, _CharT&>
{
public:
// Types:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename _Traits::int_type int_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_istream<_CharT, _Traits> istream_type;
// Non-standard Types:
typedef istreambuf_iterator<_CharT, _Traits> __istreambufiter_type;
istreambuf_iterator() throw()
: _M_istreambuf(NULL), _M_c(-2) { }
istreambuf_iterator(istream_type& __s) throw()
: _M_istreambuf(__s.rdbuf()), _M_c(-2) { }
istreambuf_iterator(streambuf_type* __s) throw()
: _M_istreambuf(__s), _M_c(-2) { }
// NB: This should really have an int_type return
// value, so "end of stream" postion can be checked without
// hacking.
char_type
operator*() const
{
// The result of operator*() on an end of stream is undefined.
char_type __ret;
if (_M_istreambuf && _M_c != static_cast<int_type>(-2))
__ret = _M_c;
else if (_M_istreambuf)
__ret = traits_type::to_char_type(_M_istreambuf->sgetc());
else
__ret = static_cast<char_type>(traits_type::eof());
return __ret;
}
__istreambufiter_type&
operator++()
{
if (_M_istreambuf)
_M_istreambuf->sbumpc();
_M_c = -2;
return *this;
}
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
// 14882 says return a proxy object. It should be a const
// proxy object, but since this class is not mandated, it
// should allow this signature:
const __istreambufiter_type
operator++(int)
{
if (_M_istreambuf)
_M_c = _M_istreambuf->sbumpc();
return *this;
}
#endif
bool
equal(const __istreambufiter_type& __b)
{
int_type __eof = traits_type::eof();
bool __thiseof = !_M_istreambuf || _M_istreambuf->sgetc() == __eof;
bool __beof = !__b._M_istreambuf
|| __b._M_istreambuf->sgetc() == __eof;
return (__thiseof && __beof || (!__thiseof && !__beof));
}
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
// 110 istreambuf_iterator::equal not const
// NB: there is also number 111 pending on this function.
bool
equal(const __istreambufiter_type& __b) const
{
int_type __eof = traits_type::eof();
bool __thiseof = !_M_istreambuf || _M_istreambuf->sgetc() == __eof;
bool __beof = !__b._M_istreambuf
|| __b._M_istreambuf->sgetc() == __eof;
return (__thiseof && __beof || (!__thiseof && !__beof));
}
#endif
private:
// 24.5.3 istreambuf_iterator
// p 1
// If the end of stream is reached (streambuf_type::sgetc()
// returns traits_type::eof()), the iterator becomes equal to
// the "end of stream" iterator value.
// NB: This implementation assumes the "end of stream" value
// is EOF, or -1.
streambuf_type* _M_istreambuf;
int_type _M_c;
};
template<typename _CharT, typename _Traits>
inline bool
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
{ return __a.equal(__b); }
template<typename _CharT, typename _Traits>
inline bool
operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
{ return !__a.equal(__b); }
} // std::
#endif /* _CPP_BITS_SBUF_ITER_H */
libstdc++-v3/bits/sequence_concepts.h deleted 100644 → 0
/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef STL_SEQUENCE_CONCEPTS_H
#define STL_SEQUENCE_CONCEPTS_H
#include <bits/container_concepts.h>
#ifdef __STL_USE_CONCEPT_CHECKS
// This file covers the following concepts:
// _Sequence
// _FrontInsertionSequence
// _BackInsertionSequence
struct _ERROR_IN_STL_SEQ {
template <class _XX>
static void
__fill_constructor_requirement_violation(_XX& __s) {
typename _XX::value_type __t = typename _XX::value_type();
typename _XX::difference_type __n = typename _XX::difference_type();
_XX __x(__n, __t);
__sink_unused_warning(__x);
}
template <class _XX>
static void
__fill_default_constructor_requirement_violation(_XX& __s) {
_STL_ERROR::__default_constructor_requirement_violation(*__s.begin());
typename _XX::difference_type __n = typename _XX::difference_type();
_XX __x(__n);
__sink_unused_warning(__x);
}
template <class _XX>
static void
__range_constructor_requirement_violation(_XX& __s) {
_XX __x(__s.begin(), __s.end());
__sink_unused_warning(__x);
}
template <class _XX>
static void
__insert_function_requirement_violation(_XX& __s) {
typename _XX::value_type __t = typename _XX::value_type();
typename _XX::iterator __p = typename _XX::iterator();
__p = __s.insert(__p, __t);
}
template <class _XX>
static void
__fill_insert_function_requirement_violation(_XX& __s) {
typename _XX::value_type __t = typename _XX::value_type();
typename _XX::iterator __p = typename _XX::iterator();
typename _XX::difference_type __n = typename _XX::difference_type();
__s.insert(__p, __n, __t);
}
template <class _XX>
static void
__range_insert_function_requirement_violation(_XX& __s) {
typename _XX::iterator __p = typename _XX::iterator();
typename _XX::iterator __i = typename _XX::iterator();
typename _XX::iterator __j = typename _XX::iterator();
__s.insert(__p, __i, __j);
}
template <class _XX>
static void
__insert_element_function_requirement_violation(_XX& __s) {
typename _XX::value_type __t = typename _XX::value_type();
std::pair<typename _XX::iterator, bool> __r;
__r = __s.insert(__t);
__sink_unused_warning(__r);
}
template <class _XX>
static void
__unconditional_insert_element_function_requirement_violation(_XX& __s) {
typename _XX::value_type __t = typename _XX::value_type();
typename _XX::iterator __p;
__p = __s.insert(__t);
__sink_unused_warning(__p);
}
template <class _XX>
static void
__erase_function_requirement_violation(_XX& __s) {
typename _XX::iterator __p = typename _XX::iterator();
__p = __s.erase(__p);
}
template <class _XX>
static void
__range_erase_function_requirement_violation(_XX& __s) {
typename _XX::iterator __p = typename _XX::iterator();
typename _XX::iterator __q = typename _XX::iterator();
__p = __s.erase(__p, __q);
}
template <class _XX>
static void
__const_front_function_requirement_violation(const _XX& __s) {
typename _XX::const_reference __t = __s.front();
__sink_unused_warning(__t);
}
template <class _XX>
static void
__front_function_requirement_violation(_XX& __s) {
typename _XX::reference __t = __s.front();
__const_front_function_requirement_violation(__s);
__sink_unused_warning(__t);
}
template <class _XX>
static void
__const_back_function_requirement_violation(const _XX& __s) {
typename _XX::const_reference __t = __s.back();
__sink_unused_warning(__t);
}
template <class _XX>
static void
__back_function_requirement_violation(_XX& __s) {
typename _XX::reference __t = __s.back();
__const_back_function_requirement_violation(__s);
__sink_unused_warning(__t);
}
template <class _XX>
static void
__push_front_function_requirement_violation(_XX& __s) {
typename _XX::value_type __t = typename _XX::value_type();
__s.push_front(__t);
}
template <class _XX>
static void
__pop_front_function_requirement_violation(_XX& __s) {
__s.pop_front();
}
template <class _XX>
static void
__push_back_function_requirement_violation(_XX& __s) {
typename _XX::value_type __t = typename _XX::value_type();
__s.push_back(__t);
}
template <class _XX>
static void
__pop_back_function_requirement_violation(_XX& __s) {
__s.pop_back();
}
};
/* Sequence Containers */
template <class _Sequence>
struct _Sequence_concept_specification {
static void
_Sequence_requirement_violation(_Sequence __s) {
// Refinement of ForwardContainer
_ForwardContainer_concept_specification<_Sequence>::_ForwardContainer_requirement_violation(__s);
// Refinement of DefaultConstructible
_DefaultConstructible_concept_specification<_Sequence>::_DefaultConstructible_requirement_violation(__s);
// Valid Expressions
_ERROR_IN_STL_SEQ::__fill_constructor_requirement_violation(__s);
_ERROR_IN_STL_SEQ::__fill_default_constructor_requirement_violation(__s);
_ERROR_IN_STL_SEQ::__range_constructor_requirement_violation(__s);
_ERROR_IN_STL_SEQ::__insert_function_requirement_violation(__s);
_ERROR_IN_STL_SEQ::__fill_insert_function_requirement_violation(__s);
_ERROR_IN_STL_SEQ::__range_insert_function_requirement_violation(__s);
_ERROR_IN_STL_SEQ::__erase_function_requirement_violation(__s);
_ERROR_IN_STL_SEQ::__range_erase_function_requirement_violation(__s);
_ERROR_IN_STL_SEQ::__front_function_requirement_violation(__s);
}
};
template <class _FrontInsertionSequence>
struct _FrontInsertionSequence_concept_specification {
static void
_FrontInsertionSequence_requirement_violation(_FrontInsertionSequence __s) {
// Refinement of Sequence
_Sequence_concept_specification<_FrontInsertionSequence>::_Sequence_requirement_violation(__s);
// Valid Expressions
_ERROR_IN_STL_SEQ::__push_front_function_requirement_violation(__s);
_ERROR_IN_STL_SEQ::__pop_front_function_requirement_violation(__s);
}
};
template <class _BackInsertionSequence>
struct _BackInsertionSequence_concept_specification {
static void
_BackInsertionSequence_requirement_violation(_BackInsertionSequence __s) {
// Refinement of Sequence
_Sequence_concept_specification<_BackInsertionSequence>::_Sequence_requirement_violation(__s);
// Valid Expressions
_ERROR_IN_STL_SEQ::__back_function_requirement_violation(__s);
_ERROR_IN_STL_SEQ::__push_back_function_requirement_violation(__s);
_ERROR_IN_STL_SEQ::__pop_back_function_requirement_violation(__s);
}
};
#endif /* if __STL_USE_CONCEPT_CHECKS */
#endif /* STL_SEQUENCE_CONCEPTS_H */
libstdc++-v3/bits/slice.h deleted 100644 → 0
// The template and inlines for the -*- C++ -*- slice class.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
#ifndef _CPP_BITS_SLICE_H
#define _CPP_BITS_SLICE_H
namespace std {
class slice
{
public:
slice ();
slice (size_t, size_t, size_t);
size_t start () const;
size_t size () const;
size_t stride () const;
private:
size_t _M_off; // offset
size_t _M_sz; // size
size_t _M_st; // stride unit
};
inline slice::slice () {}
inline slice::slice (size_t __o, size_t __d, size_t __s)
: _M_off (__o), _M_sz (__d), _M_st (__s) {}
inline size_t
slice::start () const
{ return _M_off; }
inline size_t
slice::size () const
{ return _M_sz; }
inline size_t
slice::stride () const
{ return _M_st; }
} // std::
#endif /* _CPP_BITS_SLICE_H */
// Local Variables:
// mode:c++
// End:
libstdc++-v3/bits/slice_array.h deleted 100644 → 0
// The template and inlines for the -*- C++ -*- slice_array class.
// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
#ifndef _CPP_BITS_SLICE_ARRAY_H
#define _CPP_BITS_SLICE_ARRAY_H 1
namespace std {
template<typename _Tp>
class slice_array
{
public:
typedef _Tp value_type;
void operator= (const valarray<_Tp>&) const;
void operator*= (const valarray<_Tp>&) const;
void operator/= (const valarray<_Tp>&) const;
void operator%= (const valarray<_Tp>&) const;
void operator+= (const valarray<_Tp>&) const;
void operator-= (const valarray<_Tp>&) const;
void operator^= (const valarray<_Tp>&) const;
void operator&= (const valarray<_Tp>&) const;
void operator|= (const valarray<_Tp>&) const;
void operator<<= (const valarray<_Tp>&) const;
void operator>>= (const valarray<_Tp>&) const;
void operator= (const _Tp &);
// ~slice_array ();
template<class _Dom>
void operator= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator*= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator/= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator%= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator+= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator-= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator^= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator&= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator|= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator<<= (const _Expr<_Dom,_Tp>&) const;
template<class _Dom>
void operator>>= (const _Expr<_Dom,_Tp>&) const;
private:
friend class valarray<_Tp>;
slice_array(_Array<_Tp>, const slice&);
const size_t _M_sz;
const size_t _M_stride;
const _Array<_Tp> _M_array;
// this constructor is implemented since we need to return a value.
slice_array (const slice_array&);
// not implemented
slice_array ();
slice_array& operator= (const slice_array&);
};
template<typename _Tp>
inline slice_array<_Tp>::slice_array (_Array<_Tp> __a, const slice& __s)
: _M_sz (__s.size ()), _M_stride (__s.stride ()),
_M_array (__a.begin () + __s.start ()) {}
template<typename _Tp>
inline slice_array<_Tp>::slice_array(const slice_array<_Tp>& a)
: _M_sz(a._M_sz), _M_stride(a._M_stride), _M_array(a._M_array) {}
// template<typename _Tp>
// inline slice_array<_Tp>::~slice_array () {}
template<typename _Tp>
inline void
slice_array<_Tp>::operator= (const _Tp& __t)
{ __valarray_fill (_M_array, _M_sz, _M_stride, __t); }
template<typename _Tp>
inline void
slice_array<_Tp>::operator= (const valarray<_Tp>& __v) const
{ __valarray_copy (_Array<_Tp> (__v), _M_array, _M_sz, _M_stride); }
template<typename _Tp>
template<class _Dom>
inline void
slice_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
{ __valarray_copy (__e, _M_sz, _M_array, _M_stride); }
#undef _DEFINE_VALARRAY_OPERATOR
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
template<typename _Tp> \
inline void \
slice_array<_Tp>::operator op##= (const valarray<_Tp>& __v) const \
{ \
_Array_augmented_##name (_M_array, _M_sz, _M_stride, _Array<_Tp> (__v));\
} \
\
template<typename _Tp> template<class _Dom> \
inline void \
slice_array<_Tp>::operator op##= (const _Expr<_Dom,_Tp>& __e) const \
{ \
_Array_augmented_##name (_M_array, _M_stride, __e, _M_sz); \
}
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
_DEFINE_VALARRAY_OPERATOR(/, divides)
_DEFINE_VALARRAY_OPERATOR(%, modulus)
_DEFINE_VALARRAY_OPERATOR(+, plus)
_DEFINE_VALARRAY_OPERATOR(-, minus)
_DEFINE_VALARRAY_OPERATOR(^, xor)
_DEFINE_VALARRAY_OPERATOR(&, and)
_DEFINE_VALARRAY_OPERATOR(|, or)
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
#undef _DEFINE_VALARRAY_OPERATOR
} // std::
#endif /* _CPP_BITS_SLICE_ARRAY_H */
// Local Variables:
// mode:c++
// End:
libstdc++-v3/bits/sstream.tcc deleted 100644 → 0
// String based streams -*- C++ -*-
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 27.7 String-based streams
//
#ifndef _CPP_BITS_SSTREAM_TCC
#define _CPP_BITS_SSTREAM_TCC 1
#include <bits/std_sstream.h>
namespace std {
template <class _CharT, class _Traits, class _Alloc>
basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
basic_stringbuf<_CharT, _Traits, _Alloc>::
pbackfail(int_type __c)
{
int_type __ret = traits_type::eof();
bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
bool __testpos = _M_in_cur && _M_in_beg < _M_in_cur;
// Try to put back __c into input sequence in one of three ways.
// Order these tests done in is unspecified by the standard.
if (__testpos)
{
if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])
&& !__testeof)
{
--_M_in_cur;
__ret = __c;
}
else if (!__testeof)
{
--_M_in_cur;
*_M_in_cur = traits_type::to_char_type(__c);
__ret = __c;
}
else if (__testeof)
{
--_M_in_cur;
__ret = traits_type::not_eof(__c);
}
}
return __ret;
}
template <class _CharT, class _Traits, class _Alloc>
basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
basic_stringbuf<_CharT, _Traits, _Alloc>::
overflow(int_type __c)
{
int_type __ret = traits_type::eof();
bool __testeof = traits_type::eq_int_type(__c, __ret);
bool __testwrite = _M_out_cur < _M_buf + _M_buf_size;
bool __testout = _M_mode & ios_base::out;
// Try to append __c into output sequence in one of two ways.
// Order these tests done in is unspecified by the standard.
if (__testout)
{
if (!__testeof)
{
__size_type __len = max(_M_buf_size, _M_buf_size_opt);
__len *= 2;
if (__testwrite)
__ret = this->sputc(__c);
else if (__len <= _M_string.max_size())
{
// Force-allocate, re-sync.
_M_string = this->str();
_M_string.reserve(__len);
_M_buf_size = static_cast<int_type>(__len);
_M_really_sync(_M_in_cur - _M_in_beg,
_M_out_cur - _M_out_beg);
*_M_out_cur = traits_type::to_char_type(__c);
_M_out_cur_move(1);
__ret = __c;
}
}
else
__ret = traits_type::not_eof(__c);
}
return __ret;
}
template <class _CharT, class _Traits, class _Alloc>
basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
basic_stringbuf<_CharT, _Traits, _Alloc>::
seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
{
pos_type __ret = pos_type(off_type(-1));
bool __testin = __mode & ios_base::in && _M_mode & ios_base::in;
bool __testout = __mode & ios_base::out && _M_mode & ios_base::out;
bool __testboth = __testin && __testout && __way != ios_base::cur;
if (_M_buf_size && ((__testin != __testout) || __testboth))
{
char_type* __beg = _M_buf;
char_type* __curi = NULL;
char_type* __curo = NULL;
char_type* __endi = NULL;
char_type* __endo = NULL;
if (__testin)
{
__curi = this->gptr();
__endi = this->egptr();
}
if (__testout)
{
__curo = this->pptr();
__endo = this->epptr();
}
off_type __newoffi = 0;
off_type __newoffo = 0;
if (__way == ios_base::cur)
{
__newoffi = __curi - __beg;
__newoffo = __curo - __beg;
}
else if (__way == ios_base::end)
{
__newoffi = __endi - __beg;
__newoffo = __endo - __beg;
}
if (__testin
&& __newoffi + __off >= 0 && __endi - __beg >= __newoffi + __off)
{
_M_in_cur = __beg + __newoffi + __off;
__ret = pos_type(__newoffi);
}
if (__testout
&& __newoffo + __off >= 0 && __endo - __beg >= __newoffo + __off)
{
_M_out_cur_move(__newoffo + __off - (_M_out_cur - __beg));
__ret = pos_type(__newoffo);
}
}
return __ret;
}
template <class _CharT, class _Traits, class _Alloc>
basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
basic_stringbuf<_CharT, _Traits, _Alloc>::
seekpos(pos_type __sp, ios_base::openmode __mode)
{
pos_type __ret = pos_type(off_type(-1));
off_type __pos = __sp._M_position();
char_type* __beg = NULL;
char_type* __end = NULL;
bool __testin = __mode & ios_base::in && _M_mode & ios_base::in;
bool __testout = __mode & ios_base::out && _M_mode & ios_base::out;
if (__testin)
{
__beg = this->eback();
__end = this->egptr();
}
if (__testout)
{
__beg = this->pbase();
__end = _M_buf + _M_buf_size;
}
if (0 <= __pos && __pos <= __end - __beg)
{
// Need to set both of these if applicable
if (__testin)
_M_in_cur = _M_in_beg + __pos;
if (__testout)
_M_out_cur_move((__pos) - (_M_out_cur - __beg));
__ret = pos_type(off_type(__pos));
}
return __ret;
}
} // namespace std
#endif /* _CPP_BITS_SSTREAM_TCC */
libstdc++-v3/bits/std_algorithm.h deleted 100644 → 0
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _CPP_ALGORITHM
#define _CPP_ALGORITHM 1
#include <bits/stl_algobase.h>
#include <bits/stl_construct.h>
#include <bits/stl_uninitialized.h>
#include <bits/stl_tempbuf.h>
#include <bits/stl_algo.h>
#endif /* _CPP_ALGORITHM */
// Local Variables:
// mode:C++
// End:
libstdc++-v3/bits/std_cassert.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 19.2 Assertions
//
// Note: This is not a conforming implementation.
// No include guards on this header...
# pragma GCC system_header
# include_next <assert.h>
libstdc++-v3/bits/std_cctype.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: <ccytpe>
//
#ifndef _CPP_CCTYPE
#define _CPP_CCTYPE 1
// This keeps isanum, et al from being propagated as macros.
#if __linux__
#define __NO_CTYPE 1
#endif
# pragma GCC system_header
# include_next <ctype.h>
// Sequester the C non-inline implementations in the _C_Swamp::
// namespace, and provide C++ inlines for them in the std:: namespace
// where they belong.
namespace std
{
// NB: If not using namespaces, can't have any of these definitions,
// as they will duplicate what's in the global namespace.
#ifdef toupper
inline int
_S_toupper_helper(int __c) { return toupper(__c); }
# undef toupper
inline int
toupper(int __c) { return _S_toupper_helper(__c); }
#else
inline int
toupper(int __c) { return ::toupper(__c); }
#endif
#ifdef tolower
inline int
_S_tolower_helper(int __c) { return tolower(__c); }
# undef tolower
inline int
tolower(int __c) { return _S_tolower_helper(__c); }
#else
inline int
tolower(int __c) { return ::tolower(__c); }
#endif
#ifdef isspace
inline int
_S_isspace_helper(int __c) { return isspace(__c); }
# undef isspace
inline int
isspace(int __c) { return _S_isspace_helper(__c); }
#else
inline int
isspace(int __c) { return ::isspace(__c); }
#endif
#ifdef isprint
inline int
_S_isprint_helper(int __c) { return isprint(__c); }
# undef isprint
inline int
isprint(int __c) { return _S_isprint_helper(__c); }
#else
inline int
isprint(int __c) { return ::isprint(__c); }
#endif
#ifdef iscntrl
inline int
_S_iscntrl_helper(int __c) { return iscntrl(__c); }
# undef iscntrl
inline int
iscntrl(int __c) { return _S_iscntrl_helper(__c); }
#else
inline int
iscntrl(int __c) { return ::iscntrl(__c); }
#endif
#ifdef isupper
inline int
_S_isupper_helper(int __c) { return isupper(__c); }
# undef isupper
inline int
isupper(int __c) { return _S_isupper_helper(__c); }
#else
inline int
isupper(int __c) { return ::isupper(__c); }
#endif
#ifdef islower
inline int
_S_islower_helper(int __c) { return islower(__c); }
# undef islower
inline int
islower(int __c) { return _S_islower_helper(__c); }
#else
inline int
islower(int __c) { return ::islower(__c); }
#endif
#ifdef isalpha
inline int
_S_isalpha_helper(int __c) { return isalpha(__c); }
# undef isalpha
inline int
isalpha(int __c) { return _S_isalpha_helper(__c); }
#else
inline int
isalpha(int __c) { return ::isalpha(__c); }
#endif
#ifdef isdigit
inline int
_S_isdigit_helper(int __c) { return isdigit(__c); }
# undef isdigit
inline int
isdigit(int __c) { return _S_isdigit_helper(__c); }
#else
inline int
isdigit(int __c) { return ::isdigit(__c); }
#endif
#ifdef ispunct
inline int
_S_ispunct_helper(int __c) { return ispunct(__c); }
# undef ispunct
inline int
ispunct(int __c) { return _S_ispunct_helper(__c); }
#else
inline int
ispunct(int __c) { return ::ispunct(__c); }
#endif
#ifdef isxdigit
inline int
_S_isxdigit_helper(int __c) { return isxdigit(__c); }
# undef isxdigit
inline int
isxdigit(int __c) { return _S_isxdigit_helper(__c); }
#else
inline int
isxdigit(int __c) { return ::isxdigit(__c); }
#endif
#ifdef isalnum
inline int
_S_isalnum_helper(int __c) { return isalnum(__c); }
# undef isalnum
inline int
isalnum(int __c) { return _S_isalnum_helper(__c); }
#else
inline int
isalnum(int __c) { return ::isalnum(__c); }
#endif
#ifdef isgraph
inline int
_S_isgraph_helper(int __c) { return isgraph(__c); }
# undef isgraph
inline int
isgraph(int __c) { return _S_isgraph_helper(__c); }
#else
inline int
isgraph(int __c) { return ::isgraph(__c); }
#endif
} // namespace std
#endif // _CPP_CCTYPE
libstdc++-v3/bits/std_cerrno.h deleted 100644 → 0
// The -*- C++ -*- error number header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 19.3 Error numbers
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CERRNO
#define _CPP_CERRNO 1
# pragma GCC system_header
# include_next <errno.h>
#endif
libstdc++-v3/bits/std_cfloat.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 18.2.2 Implementation properties: C library
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CFLOAT
#define _CPP_CFLOAT 1
# pragma GCC system_header
# include_next <float.h>
#if 0
# ifdef __GLIBC__
// For GNU libc we must also include this one:
# include <fenv.h>
# endif
#endif
#endif
libstdc++-v3/bits/std_climits.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 18.2.2 Implementation properties: C library
//
// Note: This is not a conforming implementation.
#ifndef _CPP_CLIMITS
#define _CPP_CLIMITS 1
# pragma GCC system_header
# include_next <limits.h>
#endif
libstdc++-v3/bits/std_clocale.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 18.2.2 Implementation properties: C library
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CLOCALE
#define _CPP_CLOCALE 1
# pragma GCC system_header
# include_next <locale.h>
#endif
libstdc++-v3/bits/std_csetjmp.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 20.4.6 C library
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CSETJMP
#define _CPP_CSETJMP 1
# pragma GCC system_header
# include_next <setjmp.h>
#endif
libstdc++-v3/bits/std_csignal.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 20.4.6 C library
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CSIGNAL
#define _CPP_CSIGNAL 1
# pragma GCC system_header
# include_next <signal.h>
#endif
libstdc++-v3/bits/std_cstdarg.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 20.4.6 C library
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CSTDARG
#define _CPP_CSTDARG 1
# pragma GCC system_header
# include_next <stdarg.h>
#endif
libstdc++-v3/bits/std_cstddef.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 18.1 Types
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CSTDDEF
#define _CPP_CSTDDEF 1
# pragma GCC system_header
# include_next <stddef.h>
#endif
libstdc++-v3/bits/std_cstdio.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 27.8.2 C Library files
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CSTDIO
#define _CPP_CSTDIO 1
# pragma GCC system_header
# include_next <stdio.h>
#ifndef SEEK_CUR
#define SEEK_CUR 1
#endif
#ifndef SEEK_END
#define SEEK_END 2
#endif
#ifndef SEEK_SET
#define SEEK_SET 4
#endif
#endif
libstdc++-v3/bits/std_cstdlib.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 20.4.6 C library
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CSTDLIB
#define _CPP_CSTDLIB 1
// This keeps isanum, et al from being propagated as macros.
#if __linux__
#define __USE_ISOC9X 1
#endif
# pragma GCC system_header
# include_next <stdlib.h>
#endif // _CPP_CSTDLIB
libstdc++-v3/bits/std_cstring.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 20.4.6 C library
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CSTRING
#define _CPP_CSTRING 1
# if defined __GLIBC__ && __GLIBC__ >= 2
// We must not see the optimized string functions GNU libc defines.
# define __NO_STRING_INLINES
# endif
# pragma GCC system_header
# include_next <string.h>
#endif
libstdc++-v3/bits/std_ctime.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 20.5 Date and time
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CTIME
#define _CPP_CTIME 1
# pragma GCC system_header
# include_next <time.h>
#endif
libstdc++-v3/bits/std_cwchar.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: ???
//
// Note: this is not a conforming implementation.
#ifndef _CPP_CWCHAR
#define _CPP_CWCHAR 1
#include <bits/c++config.h>
#if _GLIBCPP_USE_WCHAR_T
# pragma GCC system_header
# include_next <wchar.h>
#else
# ifdef __cplusplus
extern "C"
{
#endif
typedef struct
{
int __fill[6];
} mbstate_t;
# ifdef __cplusplus
}
# endif
#endif //_GLIBCPP_USE_WCHAR_T
#endif // _CPP_CWCHAR
libstdc++-v3/bits/std_cwctype.h deleted 100644 → 0
// -*- C++ -*- forwarding header.
// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: <cwctype>
//
#ifndef _CPP_CWCTYPE
#define _CPP_CWCTYPE 1
# pragma GCC system_header
# include_next <wctype.h>
// Sequester the C non-inline implementations in the _C_Swamp::
// namespace, and provide C++ inlines for them in the std:: namespace
// where they belong.
namespace std
{
#ifdef towupper
inline wint_t
_S_towupper_helper(wint_t __wc) { return towupper(__wc); }
# undef towupper
inline wint_t
towupper(wint_t __wc) { return _S_towupper_helper(__wc); }
#endif
#ifdef towlower
inline wint_t
_S_towlower_helper(wint_t __wc) { return towlower(__wc); }
# undef towlower
inline wint_t
towlower(wint_t __wc) { return _S_towlower_helper(__wc); }
#endif
#ifdef iswspace
inline int
_S_iswspace_helper(wint_t __wc) { return iswspace(__wc); }
# undef iswspace
inline int
iswspace(wint_t __wc) { return _S_iswspace_helper(__wc); }
#endif
#ifdef iswprint
inline int
_S_iswprint_helper(wint_t __wc) { return iswprint(__wc); }
# undef iswprint
inline int
iswprint(wint_t __wc) { return _S_iswprint_helper(__wc); }
#endif
#ifdef iswcntrl
inline int
_S_iswcntrl_helper(wint_t __wc) { return iswcntrl(__wc); }
# undef iswcntrl
inline int
iswcntrl(wint_t __wc) { return _S_iswcntrl_helper(__wc); }
#endif
#ifdef iswupper
inline int
_S_iswupper_helper(wint_t __wc) { return iswupper(__wc); }
# undef iswupper
inline int
iswupper(wint_t __wc) { return _S_iswupper_helper(__wc); }
#endif
#ifdef iswlower
inline int
_S_iswlower_helper(wint_t __wc) { return iswlower(__wc); }
# undef iswlower
inline int
iswlower(wint_t __wc) { return _S_iswlower_helper(__wc); }
#endif
#ifdef iswalpha
inline int
_S_iswalpha_helper(wint_t __wc) { return iswalpha(__wc); }
# undef iswalpha
inline int
iswalpha(wint_t __wc) { return _S_iswalpha_helper(__wc); }
#endif
#ifdef iswdigit
inline int
_S_iswdigit_helper(wint_t __wc) { return iswdigit(__wc); }
# undef iswdigit
inline int
iswdigit(wint_t __wc) { return _S_iswdigit_helper(__wc); }
#endif
#ifdef iswpunct
inline int
_S_iswpunct_helper(wint_t __wc) { return iswpunct(__wc); }
# undef iswpunct
inline int
iswpunct(wint_t __wc) { return _S_iswpunct_helper(__wc); }
#endif
#ifdef iswxdigit
inline int
_S_iswxdigit_helper (wint_t __wc) { return iswxdigit(__wc); }
# undef iswxdigit
inline int
iswxdigit(wint_t __wc) { return _S_iswxdigit_helper(__wc); }
#endif
#ifdef iswalnum
inline int
_S_iswalnum_helper(wint_t __wc) { return iswalnum(__wc); }
# undef iswalnum
inline int
iswalnum(wint_t __wc) { return _S_iswalnum_helper(__wc); }
#endif
#ifdef iswgraph
inline int
_S_iswgraph_helper(wint_t __wc) { return iswgraph(__wc); }
# undef iswgraph
inline int
iswgraph(wint_t __wc) { return _S_iswgraph_helper(__wc); }
#endif
} // namespace std
#endif // _CPP_CWCTYPE
libstdc++-v3/bits/std_deque.h deleted 100644 → 0
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
#ifndef _CPP_DEQUE
#define _CPP_DEQUE 1
#include <bits/stl_range_errors.h>
#include <bits/stl_algobase.h>
#include <bits/stl_alloc.h>
#include <bits/stl_construct.h>
#include <bits/stl_uninitialized.h>
#include <bits/stl_deque.h>
#endif /* _CPP_DEQUE */
// Local Variables:
// mode:C++
// End:
libstdc++-v3/bits/std_exception.h deleted 100644 → 0
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#ifndef _CPP_EXCEPTION
#define _CPP_EXCEPTION 1
#ifdef __GNUG__
#pragma GCC system_header
#include_next <exception>
#else
#include <bits/stl_config.h>
__STL_BEGIN_NAMESPACE
// 18.6 Exception handling
class exception;
class bad_exception;
typedef void (*unexpected_handler)();
unexpected_handler set_unexpected(unexpected_handler) throw();
void unexpected();
typedef void (*terminate_handler)();
terminate_handler set_terminate(terminate_handler) throw();
void terminate();
bool uncaught_exception();
// 18.6.1 Class exception
class exception {
public:
exception() throw();
exception(const exception&) throw();
exception& operator=(const exception&) throw();
virtual ~exception() throw();
virtual const char* what() const throw();
};
// 18.6.2.1 Class bad_exception
class bad_exception : public exception {
public:
bad_exception() throw();
bad_exception(const bad_exception&) throw();
bad_exception& operator=(const bad_exception&) throw();
virtual ~bad_exception() throw();
virtual const char* what() const throw();
};
__STL_END_NAMESPACE
#endif /* __GNUG__ */
#endif /* _CPP_EXCEPTION */
// Local Variables:
// mode:C++
// End:
libstdc++-v3/bits/std_functional.h deleted 100644 → 0
/*
* Copyright (c) 1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*/
#ifndef _CPP_FUNCTIONAL
#define _CPP_FUNCTIONAL
#include <bits/stl_config.h>
#include <bits/std_cstddef.h>
#include <bits/stl_function.h>
#endif /* _CPP_FUNCTIONAL */
// Local Variables:
// mode:C++
// End:
libstdc++-v3/bits/std_iomanip.h deleted 100644 → 0
// Standard stream manipulators -*- C++ -*-
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 27.6.3 Standard manipulators
//
#ifndef _CPP_IOMANIP
#define _CPP_IOMANIP 1
#include <bits/c++config.h>
#include <bits/std_istream.h>
#include <bits/std_functional.h>
namespace std {
struct _Resetiosflags { ios_base::fmtflags _M_mask; };
inline _Resetiosflags
resetiosflags(ios_base::fmtflags __mask)
{
_Resetiosflags __x;
__x._M_mask = __mask;
return __x;
}
template <class _CharT, class _Traits>
basic_istream<_CharT,_Traits>&
operator>>(basic_istream<_CharT,_Traits>& __is, _Resetiosflags __f)
{
__is.setf(ios_base::fmtflags(0), __f._M_mask);
return __is;
}
template <class _CharT, class _Traits>
basic_ostream<_CharT,_Traits>&
operator<<(basic_ostream<_CharT,_Traits>& __os, _Resetiosflags __f)
{
__os.setf(ios_base::fmtflags(0), __f._M_mask);
return __os;
}
struct _Setiosflags { ios_base::fmtflags _M_mask; };
inline _Setiosflags
setiosflags (ios_base::fmtflags __mask)
{
_Setiosflags __x;
__x._M_mask = __mask;
return __x;
}
template <class _CharT, class _Traits>
basic_istream<_CharT,_Traits>&
operator>>(basic_istream<_CharT,_Traits>& __is, _Setiosflags __f)
{
__is.setf(__f._M_mask);
return __is;
}
template <class _CharT, class _Traits>
basic_ostream<_CharT,_Traits>&
operator<<(basic_ostream<_CharT,_Traits>& __os, _Setiosflags __f)
{
__os.setf(__f._M_mask);
return __os;
}
struct _Setbase { int _M_base; };
inline _Setbase
setbase (int __base)
{
_Setbase __x;
__x._M_base = __base;
return __x;
}
template <class _CharT, class _Traits>
basic_istream<_CharT,_Traits>&
operator>>(basic_istream<_CharT,_Traits>& __is, _Setbase __f)
{
__is.setf(__f._M_base == 8 ? ios_base::oct :
__f._M_base == 10 ? ios_base::dec :
__f._M_base == 16 ? ios_base::hex :
ios_base::fmtflags(0), ios_base::basefield);
return __is;
}
template <class _CharT, class _Traits>
basic_ostream<_CharT,_Traits>&
operator<<(basic_ostream<_CharT,_Traits>& __os, _Setbase __f)
{
__os.setf(__f._M_base == 8 ? ios_base::oct :
__f._M_base == 10 ? ios_base::dec :
__f._M_base == 16 ? ios_base::hex :
ios_base::fmtflags(0), ios_base::basefield);
return __os;
}
template<class _CharT>
struct _Setfill { _CharT _M_c; };
template<class _CharT>
_Setfill<_CharT>
setfill(_CharT __c)
{
_Setfill<_CharT> __x;
__x._M_c = __c;
return __x;
}
template <class _CharT, class _Traits>
basic_istream<_CharT,_Traits>&
operator>>(basic_istream<_CharT,_Traits>& __is, _Setfill<_CharT> __f)
{
__is.fill(__f._M_c);
return __is;
}
template <class _CharT, class _Traits>
basic_ostream<_CharT,_Traits>&
operator<<(basic_ostream<_CharT,_Traits>& __os, _Setfill<_CharT> __f)
{
__os.fill(__f._M_c);
return __os;
}
struct _Setprecision { int _M_n; };
inline _Setprecision
setprecision(int __n)
{
_Setprecision __x;
__x._M_n = __n;
return __x;
}
template <class _CharT, class _Traits>
basic_istream<_CharT,_Traits>&
operator>>(basic_istream<_CharT,_Traits>& __is, _Setprecision __f)
{
__is.precision(__f._M_n);
return __is;
}
template <class _CharT, class _Traits>
basic_ostream<_CharT,_Traits>&
operator<<(basic_ostream<_CharT,_Traits>& __os, _Setprecision __f)
{
__os.precision(__f._M_n);
return __os;
}
struct _Setw { int _M_n; };
inline _Setw
setw(int __n)
{
_Setw __x;
__x._M_n = __n;
return __x;
}
template <class _CharT, class _Traits>
basic_istream<_CharT,_Traits>&
operator>>(basic_istream<_CharT,_Traits>& __is, _Setw __f)
{
__is.width(__f._M_n);
return __is;
}
template <class _CharT, class _Traits>
basic_ostream<_CharT,_Traits>&
operator<<(basic_ostream<_CharT,_Traits>& __os, _Setw __f)
{
__os.width(__f._M_n);
return __os;
}
} // namespace std
#endif /* __IOMANIP */
libstdc++-v3/bits/std_ios.h deleted 100644 → 0
// Iostreams base classes -*- C++ -*-
// Copyright (C) 1997-1999 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 27.4 Iostreams base classes
//
#ifndef _CPP_IOS
#define _CPP_IOS 1
#include <bits/std_iosfwd.h>
#include <bits/std_exception.h> // For ios_base::failure
#include <bits/char_traits.h> // For char_traits, streamoff, streamsize, fpos
#include <bits/stl_string_fwd.h>// For string.
#include <bits/std_cstdio.h> // For SEEK_SET, SEEK_CUR, SEEK_END
#include <bits/localefwd.h> // For class locale
#include <bits/ios_base.h> // For ios_base declarations.
#include <bits/std_streambuf.h>
#include <bits/basic_ios.h>
#endif /* _CPP_IOS */
libstdc++-v3/bits/stl_algo.h deleted 100644 → 0
This source diff could not be displayed because it is too large. You can view the blob instead.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment