diff options
| author | upstream source tree <ports@midipix.org> | 2015-03-15 20:14:05 -0400 |
|---|---|---|
| committer | upstream source tree <ports@midipix.org> | 2015-03-15 20:14:05 -0400 |
| commit | 554fd8c5195424bdbcabf5de30fdc183aba391bd (patch) | |
| tree | 976dc5ab7fddf506dadce60ae936f43f58787092 /libstdc++-v3/include/std | |
| download | cbb-gcc-4.6.4-554fd8c5195424bdbcabf5de30fdc183aba391bd.tar.bz2 cbb-gcc-4.6.4-554fd8c5195424bdbcabf5de30fdc183aba391bd.tar.xz | |
obtained gcc-4.6.4.tar.bz2 from upstream website;upstream
verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.
downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.
if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.
Diffstat (limited to 'libstdc++-v3/include/std')
46 files changed, 22374 insertions, 0 deletions
diff --git a/libstdc++-v3/include/std/algorithm b/libstdc++-v3/include/std/algorithm new file mode 100644 index 000000000..7449ec3c9 --- /dev/null +++ b/libstdc++-v3/include/std/algorithm @@ -0,0 +1,69 @@ +// <algorithm> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * + * 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. + */ + +/** @file include/algorithm + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_ALGORITHM +#define _GLIBCXX_ALGORITHM 1 + +#pragma GCC system_header + +#include <utility> // UK-300. +#include <bits/stl_algobase.h> +#include <bits/stl_algo.h> + +#ifdef _GLIBCXX_PARALLEL +# include <parallel/algorithm> +#endif + +#endif /* _GLIBCXX_ALGORITHM */ diff --git a/libstdc++-v3/include/std/array b/libstdc++-v3/include/std/array new file mode 100644 index 000000000..a0bdd24a8 --- /dev/null +++ b/libstdc++-v3/include/std/array @@ -0,0 +1,274 @@ +// <array> -*- C++ -*- + +// Copyright (C) 2007, 2008, 2009, 2010 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/array + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_ARRAY +#define _GLIBCXX_ARRAY 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <bits/stl_algobase.h> +#include <bits/range_access.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief A standard container for storing a fixed size sequence of elements. + * + * @ingroup sequences + * + * Meets the requirements of a <a href="tables.html#65">container</a>, a + * <a href="tables.html#66">reversible container</a>, and a + * <a href="tables.html#67">sequence</a>. + * + * Sets support random access iterators. + * + * @param Tp Type of element. Required to be a complete type. + * @param N Number of elements. + */ + template<typename _Tp, std::size_t _Nm> + struct array + { + typedef _Tp value_type; + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef value_type* iterator; + typedef const value_type* const_iterator; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef std::reverse_iterator<iterator> reverse_iterator; + typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + + // Support for zero-sized arrays mandatory. + value_type _M_instance[_Nm ? _Nm : 1]; + + // No explicit construct/copy/destroy for aggregate type. + + // DR 776. + void + fill(const value_type& __u) + { std::fill_n(begin(), size(), __u); } + + void + swap(array& __other) + { std::swap_ranges(begin(), end(), __other.begin()); } + + // Iterators. + iterator + begin() + { return iterator(std::__addressof(_M_instance[0])); } + + const_iterator + begin() const + { return const_iterator(std::__addressof(_M_instance[0])); } + + iterator + end() + { return iterator(std::__addressof(_M_instance[_Nm])); } + + const_iterator + end() const + { return const_iterator(std::__addressof(_M_instance[_Nm])); } + + reverse_iterator + rbegin() + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const + { return const_reverse_iterator(begin()); } + + const_iterator + cbegin() const + { return const_iterator(std::__addressof(_M_instance[0])); } + + const_iterator + cend() const + { return const_iterator(std::__addressof(_M_instance[_Nm])); } + + const_reverse_iterator + crbegin() const + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const + { return const_reverse_iterator(begin()); } + + // Capacity. + constexpr size_type + size() const { return _Nm; } + + constexpr size_type + max_size() const { return _Nm; } + + constexpr bool + empty() const { return size() == 0; } + + // Element access. + reference + operator[](size_type __n) + { return _M_instance[__n]; } + + const_reference + operator[](size_type __n) const + { return _M_instance[__n]; } + + reference + at(size_type __n) + { + if (__n >= _Nm) + std::__throw_out_of_range(__N("array::at")); + return _M_instance[__n]; + } + + const_reference + at(size_type __n) const + { + if (__n >= _Nm) + std::__throw_out_of_range(__N("array::at")); + return _M_instance[__n]; + } + + reference + front() + { return *begin(); } + + const_reference + front() const + { return *begin(); } + + reference + back() + { return _Nm ? *(end() - 1) : *end(); } + + const_reference + back() const + { return _Nm ? *(end() - 1) : *end(); } + + _Tp* + data() + { return std::__addressof(_M_instance[0]); } + + const _Tp* + data() const + { return std::__addressof(_M_instance[0]); } + }; + + // Array comparisons. + template<typename _Tp, std::size_t _Nm> + inline bool + operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return std::equal(__one.begin(), __one.end(), __two.begin()); } + + template<typename _Tp, std::size_t _Nm> + inline bool + operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one == __two); } + + template<typename _Tp, std::size_t _Nm> + inline bool + operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) + { + return std::lexicographical_compare(__a.begin(), __a.end(), + __b.begin(), __b.end()); + } + + template<typename _Tp, std::size_t _Nm> + inline bool + operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return __two < __one; } + + template<typename _Tp, std::size_t _Nm> + inline bool + operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one > __two); } + + template<typename _Tp, std::size_t _Nm> + inline bool + operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one < __two); } + + // Specialized algorithms [6.2.2.2]. + template<typename _Tp, std::size_t _Nm> + inline void + swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) + { __one.swap(__two); } + + // Tuple interface to class template array [6.2.2.5]. + + /// tuple_size + template<typename _Tp> + class tuple_size; + + /// tuple_element + template<std::size_t _Int, typename _Tp> + class tuple_element; + + template<typename _Tp, std::size_t _Nm> + struct tuple_size<array<_Tp, _Nm> > + { static const std::size_t value = _Nm; }; + + template<typename _Tp, std::size_t _Nm> + const std::size_t + tuple_size<array<_Tp, _Nm> >::value; + + template<std::size_t _Int, typename _Tp, std::size_t _Nm> + struct tuple_element<_Int, array<_Tp, _Nm> > + { typedef _Tp type; }; + + template<std::size_t _Int, typename _Tp, std::size_t _Nm> + inline _Tp& + get(array<_Tp, _Nm>& __arr) + { return __arr[_Int]; } + + template<std::size_t _Int, typename _Tp, std::size_t _Nm> + inline const _Tp& + get(const array<_Tp, _Nm>& __arr) + { return __arr[_Int]; } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_ARRAY diff --git a/libstdc++-v3/include/std/atomic b/libstdc++-v3/include/std/atomic new file mode 100644 index 000000000..a19891dbd --- /dev/null +++ b/libstdc++-v3/include/std/atomic @@ -0,0 +1,1054 @@ +// -*- C++ -*- header. + +// Copyright (C) 2008, 2009, 2010, 2011 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/atomic + * This is a Standard C++ Library header. + */ + +// Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl. +// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html + +#ifndef _GLIBCXX_ATOMIC +#define _GLIBCXX_ATOMIC 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#endif + +#include <bits/atomic_base.h> +#include <bits/atomic_0.h> +#include <bits/atomic_2.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup atomics + * @{ + */ + + /// atomic_bool + // NB: No operators or fetch-operations for this type. + struct atomic_bool + { + private: + __atomic_base<bool> _M_base; + + public: + atomic_bool() = default; + ~atomic_bool() = default; + atomic_bool(const atomic_bool&) = delete; + atomic_bool& operator=(const atomic_bool&) = delete; + atomic_bool& operator=(const atomic_bool&) volatile = delete; + + constexpr atomic_bool(bool __i) : _M_base(__i) { } + + bool + operator=(bool __i) + { return _M_base.operator=(__i); } + + operator bool() const + { return _M_base.load(); } + + operator bool() const volatile + { return _M_base.load(); } + + bool + is_lock_free() const { return _M_base.is_lock_free(); } + + bool + is_lock_free() const volatile { return _M_base.is_lock_free(); } + + void + store(bool __i, memory_order __m = memory_order_seq_cst) + { _M_base.store(__i, __m); } + + void + store(bool __i, memory_order __m = memory_order_seq_cst) volatile + { _M_base.store(__i, __m); } + + bool + load(memory_order __m = memory_order_seq_cst) const + { return _M_base.load(__m); } + + bool + load(memory_order __m = memory_order_seq_cst) const volatile + { return _M_base.load(__m); } + + bool + exchange(bool __i, memory_order __m = memory_order_seq_cst) + { return _M_base.exchange(__i, __m); } + + bool + exchange(bool __i, memory_order __m = memory_order_seq_cst) volatile + { return _M_base.exchange(__i, __m); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) + { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) volatile + { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) + { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) volatile + { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) + { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) volatile + { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) + { return _M_base.compare_exchange_strong(__i1, __i2, __m); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) volatile + { return _M_base.compare_exchange_strong(__i1, __i2, __m); } + }; + + + /// atomic + /// 29.4.3, Generic atomic type, primary class template. + template<typename _Tp> + struct atomic + { + private: + _Tp _M_i; + + public: + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(_Tp __i) : _M_i(__i) { } + + operator _Tp() const; + + operator _Tp() const volatile; + + _Tp + operator=(_Tp __i) { store(__i); return __i; } + + _Tp + operator=(_Tp __i) volatile { store(__i); return __i; } + + bool + is_lock_free() const; + + bool + is_lock_free() const volatile; + + void + store(_Tp, memory_order = memory_order_seq_cst); + + void + store(_Tp, memory_order = memory_order_seq_cst) volatile; + + _Tp + load(memory_order = memory_order_seq_cst) const; + + _Tp + load(memory_order = memory_order_seq_cst) const volatile; + + _Tp + exchange(_Tp __i, memory_order = memory_order_seq_cst); + + _Tp + exchange(_Tp __i, memory_order = memory_order_seq_cst) volatile; + + bool + compare_exchange_weak(_Tp&, _Tp, memory_order, memory_order); + + bool + compare_exchange_weak(_Tp&, _Tp, memory_order, memory_order) volatile; + + bool + compare_exchange_weak(_Tp&, _Tp, memory_order = memory_order_seq_cst); + + bool + compare_exchange_weak(_Tp&, _Tp, + memory_order = memory_order_seq_cst) volatile; + + bool + compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order); + + bool + compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order) volatile; + + bool + compare_exchange_strong(_Tp&, _Tp, memory_order = memory_order_seq_cst); + + bool + compare_exchange_strong(_Tp&, _Tp, + memory_order = memory_order_seq_cst) volatile; + }; + + + /// Partial specialization for pointer types. + template<typename _Tp> + struct atomic<_Tp*> + { + typedef _Tp* __pointer_type; + typedef __atomic_base<_Tp*> __base_type; + __base_type _M_b; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__pointer_type __p) : _M_b(__p) { } + + operator __pointer_type() const + { return __pointer_type(_M_b); } + + operator __pointer_type() const volatile + { return __pointer_type(_M_b); } + + __pointer_type + operator=(__pointer_type __p) + { return _M_b.operator=(__p); } + + __pointer_type + operator=(__pointer_type __p) volatile + { return _M_b.operator=(__p); } + + __pointer_type + operator++(int) + { return _M_b++; } + + __pointer_type + operator++(int) volatile + { return _M_b++; } + + __pointer_type + operator--(int) + { return _M_b--; } + + __pointer_type + operator--(int) volatile + { return _M_b--; } + + __pointer_type + operator++() + { return ++_M_b; } + + __pointer_type + operator++() volatile + { return ++_M_b; } + + __pointer_type + operator--() + { return --_M_b; } + + __pointer_type + operator--() volatile + { return --_M_b; } + + __pointer_type + operator+=(ptrdiff_t __d) + { return _M_b.operator+=(__d); } + + __pointer_type + operator+=(ptrdiff_t __d) volatile + { return _M_b.operator+=(__d); } + + __pointer_type + operator-=(ptrdiff_t __d) + { return _M_b.operator-=(__d); } + + __pointer_type + operator-=(ptrdiff_t __d) volatile + { return _M_b.operator-=(__d); } + + bool + is_lock_free() const + { return _M_b.is_lock_free(); } + + bool + is_lock_free() const volatile + { return _M_b.is_lock_free(); } + + void + store(__pointer_type __p, memory_order __m = memory_order_seq_cst) + { return _M_b.store(__p, __m); } + + void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile + { return _M_b.store(__p, __m); } + + __pointer_type + load(memory_order __m = memory_order_seq_cst) const + { return _M_b.load(__m); } + + __pointer_type + load(memory_order __m = memory_order_seq_cst) const volatile + { return _M_b.load(__m); } + + __pointer_type + exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) + { return _M_b.exchange(__p, __m); } + + __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile + { return _M_b.exchange(__p, __m); } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, memory_order __m2) + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, memory_order __m2) volatile + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) + { + return compare_exchange_weak(__p1, __p2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) volatile + { + return compare_exchange_weak(__p1, __p2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, memory_order __m2) + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, memory_order __m2) volatile + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) + { + return _M_b.compare_exchange_strong(__p1, __p2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) volatile + { + return _M_b.compare_exchange_strong(__p1, __p2, __m, + __calculate_memory_order(__m)); + } + + __pointer_type + fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) + { return _M_b.fetch_add(__d, __m); } + + __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile + { return _M_b.fetch_add(__d, __m); } + + __pointer_type + fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) + { return _M_b.fetch_sub(__d, __m); } + + __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile + { return _M_b.fetch_sub(__d, __m); } + }; + + + /// Explicit specialization for bool. + template<> + struct atomic<bool> : public atomic_bool + { + typedef bool __integral_type; + typedef atomic_bool __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for char. + template<> + struct atomic<char> : public atomic_char + { + typedef char __integral_type; + typedef atomic_char __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for signed char. + template<> + struct atomic<signed char> : public atomic_schar + { + typedef signed char __integral_type; + typedef atomic_schar __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for unsigned char. + template<> + struct atomic<unsigned char> : public atomic_uchar + { + typedef unsigned char __integral_type; + typedef atomic_uchar __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for short. + template<> + struct atomic<short> : public atomic_short + { + typedef short __integral_type; + typedef atomic_short __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for unsigned short. + template<> + struct atomic<unsigned short> : public atomic_ushort + { + typedef unsigned short __integral_type; + typedef atomic_ushort __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for int. + template<> + struct atomic<int> : atomic_int + { + typedef int __integral_type; + typedef atomic_int __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for unsigned int. + template<> + struct atomic<unsigned int> : public atomic_uint + { + typedef unsigned int __integral_type; + typedef atomic_uint __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for long. + template<> + struct atomic<long> : public atomic_long + { + typedef long __integral_type; + typedef atomic_long __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for unsigned long. + template<> + struct atomic<unsigned long> : public atomic_ulong + { + typedef unsigned long __integral_type; + typedef atomic_ulong __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for long long. + template<> + struct atomic<long long> : public atomic_llong + { + typedef long long __integral_type; + typedef atomic_llong __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for unsigned long long. + template<> + struct atomic<unsigned long long> : public atomic_ullong + { + typedef unsigned long long __integral_type; + typedef atomic_ullong __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for wchar_t. + template<> + struct atomic<wchar_t> : public atomic_wchar_t + { + typedef wchar_t __integral_type; + typedef atomic_wchar_t __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for char16_t. + template<> + struct atomic<char16_t> : public atomic_char16_t + { + typedef char16_t __integral_type; + typedef atomic_char16_t __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for char32_t. + template<> + struct atomic<char32_t> : public atomic_char32_t + { + typedef char32_t __integral_type; + typedef atomic_char32_t __base_type; + + atomic() = default; + ~atomic() = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + // Function definitions, atomic_flag operations. + inline bool + atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m) + { return __a->test_and_set(__m); } + + inline bool + atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, + memory_order __m) + { return __a->test_and_set(__m); } + + inline void + atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) + { __a->clear(__m); } + + inline void + atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m) + { __a->clear(__m); } + + inline bool + atomic_flag_test_and_set(atomic_flag* __a) + { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } + + inline bool + atomic_flag_test_and_set(volatile atomic_flag* __a) + { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_flag_clear(atomic_flag* __a) + { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_flag_clear(volatile atomic_flag* __a) + { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } + + + // Function templates generally applicable to atomic types. + template<typename _ITp> + inline bool + atomic_is_lock_free(const atomic<_ITp>* __a) + { return __a->is_lock_free(); } + + template<typename _ITp> + inline bool + atomic_is_lock_free(const volatile atomic<_ITp>* __a) + { return __a->is_lock_free(); } + + template<typename _ITp> + inline void + atomic_init(atomic<_ITp>* __a, _ITp __i); + + template<typename _ITp> + inline void + atomic_init(volatile atomic<_ITp>* __a, _ITp __i); + + template<typename _ITp> + inline void + atomic_store_explicit(atomic<_ITp>* __a, _ITp __i, memory_order __m) + { __a->store(__i, __m); } + + template<typename _ITp> + inline void + atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i, + memory_order __m) + { __a->store(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) + { return __a->load(__m); } + + template<typename _ITp> + inline _ITp + atomic_load_explicit(const volatile atomic<_ITp>* __a, + memory_order __m) + { return __a->load(__m); } + + template<typename _ITp> + inline _ITp + atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->exchange(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->exchange(__i, __m); } + + template<typename _ITp> + inline bool + atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, memory_order __m2) + { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } + + template<typename _ITp> + inline bool + atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, memory_order __m2) + { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } + + template<typename _ITp> + inline bool + atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, + memory_order __m2) + { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } + + template<typename _ITp> + inline bool + atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, + memory_order __m2) + { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } + + + template<typename _ITp> + inline void + atomic_store(atomic<_ITp>* __a, _ITp __i) + { atomic_store_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline void + atomic_store(volatile atomic<_ITp>* __a, _ITp __i) + { atomic_store_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_load(const atomic<_ITp>* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_load(const volatile atomic<_ITp>* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_exchange(atomic<_ITp>* __a, _ITp __i) + { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) + { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline bool + atomic_compare_exchange_weak(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) + { + return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + template<typename _ITp> + inline bool + atomic_compare_exchange_weak(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) + { + return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + template<typename _ITp> + inline bool + atomic_compare_exchange_strong(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) + { + return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + template<typename _ITp> + inline bool + atomic_compare_exchange_strong(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) + { + return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + // Function templates for atomic_integral operations only, using + // __atomic_base. Template argument should be constricted to + // intergral types as specified in the standard, excluding address + // types. + template<typename _ITp> + inline _ITp + atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_add(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_add(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_sub(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_sub(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_and(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_and(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_or(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_or(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_xor(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_xor(__i, __m); } + + template<typename _ITp> + inline _ITp + atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp + atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } + + + // Partial specializations for pointers. + template<typename _ITp> + inline _ITp* + atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, + memory_order __m) + { return __a->fetch_add(__d, __m); } + + template<typename _ITp> + inline _ITp* + atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d, + memory_order __m) + { return __a->fetch_add(__d, __m); } + + template<typename _ITp> + inline _ITp* + atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) + { return __a->fetch_add(__d); } + + template<typename _ITp> + inline _ITp* + atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) + { return __a->fetch_add(__d); } + + template<typename _ITp> + inline _ITp* + atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a, + ptrdiff_t __d, memory_order __m) + { return __a->fetch_sub(__d, __m); } + + template<typename _ITp> + inline _ITp* + atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, + memory_order __m) + { return __a->fetch_sub(__d, __m); } + + template<typename _ITp> + inline _ITp* + atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) + { return __a->fetch_sub(__d); } + + template<typename _ITp> + inline _ITp* + atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) + { return __a->fetch_sub(__d); } + // @} group atomics + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/libstdc++-v3/include/std/bitset b/libstdc++-v3/include/std/bitset new file mode 100644 index 000000000..d34351b5e --- /dev/null +++ b/libstdc++-v3/include/std/bitset @@ -0,0 +1,1578 @@ +// <bitset> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, +// 2011 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * Copyright (c) 1998 + * 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. + */ + +/** @file include/bitset + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_BITSET +#define _GLIBCXX_BITSET 1 + +#pragma GCC system_header + +#include <string> +#include <bits/functexcept.h> // For invalid_argument, out_of_range, + // overflow_error +#include <iosfwd> +#include <bits/cxxabi_forced.h> + +#define _GLIBCXX_BITSET_BITS_PER_WORD (__CHAR_BIT__ * __SIZEOF_LONG__) +#define _GLIBCXX_BITSET_WORDS(__n) \ + ((__n) / _GLIBCXX_BITSET_BITS_PER_WORD + \ + ((__n) % _GLIBCXX_BITSET_BITS_PER_WORD == 0 ? 0 : 1)) + +#define _GLIBCXX_BITSET_BITS_PER_ULL (__CHAR_BIT__ * __SIZEOF_LONG_LONG__) + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /** + * Base class, general case. It is a class invariant that _Nw will be + * nonnegative. + * + * See documentation for bitset. + */ + template<size_t _Nw> + struct _Base_bitset + { + typedef unsigned long _WordT; + + /// 0 is the least significant word. + _WordT _M_w[_Nw]; + + _GLIBCXX_CONSTEXPR _Base_bitset() + : _M_w() { } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + constexpr _Base_bitset(unsigned long long __val) + : _M_w({ _WordT(__val) +#if __SIZEOF_LONG_LONG__ > __SIZEOF_LONG__ + , _WordT(__val >> _GLIBCXX_BITSET_BITS_PER_WORD) +#endif + }) { } +#else + _Base_bitset(unsigned long __val) + : _M_w() + { _M_w[0] = __val; } +#endif + + static _GLIBCXX_CONSTEXPR size_t + _S_whichword(size_t __pos ) + { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbyte(size_t __pos ) + { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbit(size_t __pos ) + { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR _WordT + _S_maskbit(size_t __pos ) + { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } + + _WordT& + _M_getword(size_t __pos) + { return _M_w[_S_whichword(__pos)]; } + + _WordT + _M_getword(size_t __pos) const + { return _M_w[_S_whichword(__pos)]; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + const _WordT* + _M_getdata() const + { return _M_w; } +#endif + + _WordT& + _M_hiword() + { return _M_w[_Nw - 1]; } + + _GLIBCXX_CONSTEXPR _WordT + _M_hiword() const + { return _M_w[_Nw - 1]; } + + void + _M_do_and(const _Base_bitset<_Nw>& __x) + { + for (size_t __i = 0; __i < _Nw; __i++) + _M_w[__i] &= __x._M_w[__i]; + } + + void + _M_do_or(const _Base_bitset<_Nw>& __x) + { + for (size_t __i = 0; __i < _Nw; __i++) + _M_w[__i] |= __x._M_w[__i]; + } + + void + _M_do_xor(const _Base_bitset<_Nw>& __x) + { + for (size_t __i = 0; __i < _Nw; __i++) + _M_w[__i] ^= __x._M_w[__i]; + } + + void + _M_do_left_shift(size_t __shift); + + void + _M_do_right_shift(size_t __shift); + + void + _M_do_flip() + { + for (size_t __i = 0; __i < _Nw; __i++) + _M_w[__i] = ~_M_w[__i]; + } + + void + _M_do_set() + { + for (size_t __i = 0; __i < _Nw; __i++) + _M_w[__i] = ~static_cast<_WordT>(0); + } + + void + _M_do_reset() + { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); } + + bool + _M_is_equal(const _Base_bitset<_Nw>& __x) const + { + for (size_t __i = 0; __i < _Nw; ++__i) + if (_M_w[__i] != __x._M_w[__i]) + return false; + return true; + } + + size_t + _M_are_all_aux() const + { + for (size_t __i = 0; __i < _Nw - 1; __i++) + if (_M_w[__i] != ~static_cast<_WordT>(0)) + return 0; + return ((_Nw - 1) * _GLIBCXX_BITSET_BITS_PER_WORD + + __builtin_popcountl(_M_hiword())); + } + + bool + _M_is_any() const + { + for (size_t __i = 0; __i < _Nw; __i++) + if (_M_w[__i] != static_cast<_WordT>(0)) + return true; + return false; + } + + size_t + _M_do_count() const + { + size_t __result = 0; + for (size_t __i = 0; __i < _Nw; __i++) + __result += __builtin_popcountl(_M_w[__i]); + return __result; + } + + unsigned long + _M_do_to_ulong() const; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + unsigned long long + _M_do_to_ullong() const; +#endif + + // find first "on" bit + size_t + _M_do_find_first(size_t __not_found) const; + + // find the next "on" bit that follows "prev" + size_t + _M_do_find_next(size_t __prev, size_t __not_found) const; + }; + + // Definitions of non-inline functions from _Base_bitset. + template<size_t _Nw> + void + _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) + { + if (__builtin_expect(__shift != 0, 1)) + { + const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD; + const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD; + + if (__offset == 0) + for (size_t __n = _Nw - 1; __n >= __wshift; --__n) + _M_w[__n] = _M_w[__n - __wshift]; + else + { + const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD + - __offset); + for (size_t __n = _Nw - 1; __n > __wshift; --__n) + _M_w[__n] = ((_M_w[__n - __wshift] << __offset) + | (_M_w[__n - __wshift - 1] >> __sub_offset)); + _M_w[__wshift] = _M_w[0] << __offset; + } + + std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0)); + } + } + + template<size_t _Nw> + void + _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) + { + if (__builtin_expect(__shift != 0, 1)) + { + const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD; + const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD; + const size_t __limit = _Nw - __wshift - 1; + + if (__offset == 0) + for (size_t __n = 0; __n <= __limit; ++__n) + _M_w[__n] = _M_w[__n + __wshift]; + else + { + const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD + - __offset); + for (size_t __n = 0; __n < __limit; ++__n) + _M_w[__n] = ((_M_w[__n + __wshift] >> __offset) + | (_M_w[__n + __wshift + 1] << __sub_offset)); + _M_w[__limit] = _M_w[_Nw-1] >> __offset; + } + + std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0)); + } + } + + template<size_t _Nw> + unsigned long + _Base_bitset<_Nw>::_M_do_to_ulong() const + { + for (size_t __i = 1; __i < _Nw; ++__i) + if (_M_w[__i]) + __throw_overflow_error(__N("_Base_bitset::_M_do_to_ulong")); + return _M_w[0]; + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<size_t _Nw> + unsigned long long + _Base_bitset<_Nw>::_M_do_to_ullong() const + { + const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long); + for (size_t __i = 1 + __dw; __i < _Nw; ++__i) + if (_M_w[__i]) + __throw_overflow_error(__N("_Base_bitset::_M_do_to_ullong")); + + if (__dw) + return _M_w[0] + (static_cast<unsigned long long>(_M_w[1]) + << _GLIBCXX_BITSET_BITS_PER_WORD); + return _M_w[0]; + } +#endif + + template<size_t _Nw> + size_t + _Base_bitset<_Nw>::_M_do_find_first(size_t __not_found) const + { + for (size_t __i = 0; __i < _Nw; __i++) + { + _WordT __thisword = _M_w[__i]; + if (__thisword != static_cast<_WordT>(0)) + return (__i * _GLIBCXX_BITSET_BITS_PER_WORD + + __builtin_ctzl(__thisword)); + } + // not found, so return an indication of failure. + return __not_found; + } + + template<size_t _Nw> + size_t + _Base_bitset<_Nw>::_M_do_find_next(size_t __prev, size_t __not_found) const + { + // make bound inclusive + ++__prev; + + // check out of bounds + if (__prev >= _Nw * _GLIBCXX_BITSET_BITS_PER_WORD) + return __not_found; + + // search first word + size_t __i = _S_whichword(__prev); + _WordT __thisword = _M_w[__i]; + + // mask off bits below bound + __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev); + + if (__thisword != static_cast<_WordT>(0)) + return (__i * _GLIBCXX_BITSET_BITS_PER_WORD + + __builtin_ctzl(__thisword)); + + // check subsequent words + __i++; + for (; __i < _Nw; __i++) + { + __thisword = _M_w[__i]; + if (__thisword != static_cast<_WordT>(0)) + return (__i * _GLIBCXX_BITSET_BITS_PER_WORD + + __builtin_ctzl(__thisword)); + } + // not found, so return an indication of failure. + return __not_found; + } // end _M_do_find_next + + /** + * Base class, specialization for a single word. + * + * See documentation for bitset. + */ + template<> + struct _Base_bitset<1> + { + typedef unsigned long _WordT; + _WordT _M_w; + + _GLIBCXX_CONSTEXPR _Base_bitset() + : _M_w(0) + { } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + constexpr _Base_bitset(unsigned long long __val) +#else + _Base_bitset(unsigned long __val) +#endif + : _M_w(__val) + { } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichword(size_t __pos ) + { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbyte(size_t __pos ) + { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbit(size_t __pos ) + { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR _WordT + _S_maskbit(size_t __pos ) + { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } + + _WordT& + _M_getword(size_t) + { return _M_w; } + + _WordT + _M_getword(size_t) const + { return _M_w; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + const _WordT* + _M_getdata() const + { return &_M_w; } +#endif + + _WordT& + _M_hiword() + { return _M_w; } + + _GLIBCXX_CONSTEXPR _WordT + _M_hiword() const + { return _M_w; } + + void + _M_do_and(const _Base_bitset<1>& __x) + { _M_w &= __x._M_w; } + + void + _M_do_or(const _Base_bitset<1>& __x) + { _M_w |= __x._M_w; } + + void + _M_do_xor(const _Base_bitset<1>& __x) + { _M_w ^= __x._M_w; } + + void + _M_do_left_shift(size_t __shift) + { _M_w <<= __shift; } + + void + _M_do_right_shift(size_t __shift) + { _M_w >>= __shift; } + + void + _M_do_flip() + { _M_w = ~_M_w; } + + void + _M_do_set() + { _M_w = ~static_cast<_WordT>(0); } + + void + _M_do_reset() + { _M_w = 0; } + + bool + _M_is_equal(const _Base_bitset<1>& __x) const + { return _M_w == __x._M_w; } + + size_t + _M_are_all_aux() const + { return __builtin_popcountl(_M_w); } + + bool + _M_is_any() const + { return _M_w != 0; } + + size_t + _M_do_count() const + { return __builtin_popcountl(_M_w); } + + unsigned long + _M_do_to_ulong() const + { return _M_w; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + unsigned long long + _M_do_to_ullong() const + { return _M_w; } +#endif + + size_t + _M_do_find_first(size_t __not_found) const + { + if (_M_w != 0) + return __builtin_ctzl(_M_w); + else + return __not_found; + } + + // find the next "on" bit that follows "prev" + size_t + _M_do_find_next(size_t __prev, size_t __not_found) const + { + ++__prev; + if (__prev >= ((size_t) _GLIBCXX_BITSET_BITS_PER_WORD)) + return __not_found; + + _WordT __x = _M_w >> __prev; + if (__x != 0) + return __builtin_ctzl(__x) + __prev; + else + return __not_found; + } + }; + + /** + * Base class, specialization for no storage (zero-length %bitset). + * + * See documentation for bitset. + */ + template<> + struct _Base_bitset<0> + { + typedef unsigned long _WordT; + + _GLIBCXX_CONSTEXPR _Base_bitset() + { } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + constexpr _Base_bitset(unsigned long long) +#else + _Base_bitset(unsigned long) +#endif + { } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichword(size_t __pos ) + { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbyte(size_t __pos ) + { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbit(size_t __pos ) + { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR _WordT + _S_maskbit(size_t __pos ) + { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } + + // This would normally give access to the data. The bounds-checking + // in the bitset class will prevent the user from getting this far, + // but (1) it must still return an lvalue to compile, and (2) the + // user might call _Unchecked_set directly, in which case this /needs/ + // to fail. Let's not penalize zero-length users unless they actually + // make an unchecked call; all the memory ugliness is therefore + // localized to this single should-never-get-this-far function. + _WordT& + _M_getword(size_t) + { + __throw_out_of_range(__N("_Base_bitset::_M_getword")); + return *new _WordT; + } + + _WordT + _M_getword(size_t __pos) const + { return 0; } + + _GLIBCXX_CONSTEXPR _WordT + _M_hiword() const + { return 0; } + + void + _M_do_and(const _Base_bitset<0>&) + { } + + void + _M_do_or(const _Base_bitset<0>&) + { } + + void + _M_do_xor(const _Base_bitset<0>&) + { } + + void + _M_do_left_shift(size_t) + { } + + void + _M_do_right_shift(size_t) + { } + + void + _M_do_flip() + { } + + void + _M_do_set() + { } + + void + _M_do_reset() + { } + + // Are all empty bitsets equal to each other? Are they equal to + // themselves? How to compare a thing which has no state? What is + // the sound of one zero-length bitset clapping? + bool + _M_is_equal(const _Base_bitset<0>&) const + { return true; } + + size_t + _M_are_all_aux() const + { return 0; } + + bool + _M_is_any() const + { return false; } + + size_t + _M_do_count() const + { return 0; } + + unsigned long + _M_do_to_ulong() const + { return 0; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + unsigned long long + _M_do_to_ullong() const + { return 0; } +#endif + + // Normally "not found" is the size, but that could also be + // misinterpreted as an index in this corner case. Oh well. + size_t + _M_do_find_first(size_t) const + { return 0; } + + size_t + _M_do_find_next(size_t, size_t) const + { return 0; } + }; + + + // Helper class to zero out the unused high-order bits in the highest word. + template<size_t _Extrabits> + struct _Sanitize + { + typedef unsigned long _WordT; + + static void + _S_do_sanitize(_WordT& __val) + { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); } + }; + + template<> + struct _Sanitize<0> + { + typedef unsigned long _WordT; + + static void + _S_do_sanitize(_WordT) { } + }; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<size_t _Nb, bool = _Nb < _GLIBCXX_BITSET_BITS_PER_ULL> + struct _Sanitize_val + { + static constexpr unsigned long long + _S_do_sanitize_val(unsigned long long __val) + { return __val; } + }; + + template<size_t _Nb> + struct _Sanitize_val<_Nb, true> + { + static constexpr unsigned long long + _S_do_sanitize_val(unsigned long long __val) + { return __val & ~((~static_cast<unsigned long long>(0)) << _Nb); } + }; +#endif + + /** + * @brief The %bitset class represents a @e fixed-size sequence of bits. + * + * @ingroup containers + * + * (Note that %bitset does @e not meet the formal requirements of a + * <a href="tables.html#65">container</a>. Mainly, it lacks iterators.) + * + * The template argument, @a Nb, may be any non-negative number, + * specifying the number of bits (e.g., "0", "12", "1024*1024"). + * + * In the general unoptimized case, storage is allocated in word-sized + * blocks. Let B be the number of bits in a word, then (Nb+(B-1))/B + * words will be used for storage. B - Nb%B bits are unused. (They are + * the high-order bits in the highest word.) It is a class invariant + * that those unused bits are always zero. + * + * If you think of %bitset as <em>a simple array of bits</em>, be + * aware that your mental picture is reversed: a %bitset behaves + * the same way as bits in integers do, with the bit at index 0 in + * the <em>least significant / right-hand</em> position, and the bit at + * index Nb-1 in the <em>most significant / left-hand</em> position. + * Thus, unlike other containers, a %bitset's index <em>counts from + * right to left</em>, to put it very loosely. + * + * This behavior is preserved when translating to and from strings. For + * example, the first line of the following program probably prints + * <em>b('a') is 0001100001</em> on a modern ASCII system. + * + * @code + * #include <bitset> + * #include <iostream> + * #include <sstream> + * + * using namespace std; + * + * int main() + * { + * long a = 'a'; + * bitset<10> b(a); + * + * cout << "b('a') is " << b << endl; + * + * ostringstream s; + * s << b; + * string str = s.str(); + * cout << "index 3 in the string is " << str[3] << " but\n" + * << "index 3 in the bitset is " << b[3] << endl; + * } + * @endcode + * + * Also see: + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch33s02.html + * for a description of extensions. + * + * Most of the actual code isn't contained in %bitset<> itself, but in the + * base class _Base_bitset. The base class works with whole words, not with + * individual bits. This allows us to specialize _Base_bitset for the + * important special case where the %bitset is only a single word. + * + * Extra confusion can result due to the fact that the storage for + * _Base_bitset @e is a regular array, and is indexed as such. This is + * carefully encapsulated. + */ + template<size_t _Nb> + class bitset + : private _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> + { + private: + typedef _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> _Base; + typedef unsigned long _WordT; + + void + _M_do_sanitize() + { + typedef _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD> __sanitize_type; + __sanitize_type::_S_do_sanitize(this->_M_hiword()); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename> friend class hash; +#endif + + public: + /** + * This encapsulates the concept of a single bit. An instance of this + * class is a proxy for an actual bit; this way the individual bit + * operations are done as faster word-size bitwise instructions. + * + * Most users will never need to use this class directly; conversions + * to and from bool are automatic and should be transparent. Overloaded + * operators help to preserve the illusion. + * + * (On a typical system, this <em>bit %reference</em> is 64 + * times the size of an actual bit. Ha.) + */ + class reference + { + friend class bitset; + + _WordT* _M_wp; + size_t _M_bpos; + + // left undefined + reference(); + + public: + reference(bitset& __b, size_t __pos) + { + _M_wp = &__b._M_getword(__pos); + _M_bpos = _Base::_S_whichbit(__pos); + } + + ~reference() + { } + + // For b[i] = __x; + reference& + operator=(bool __x) + { + if (__x) + *_M_wp |= _Base::_S_maskbit(_M_bpos); + else + *_M_wp &= ~_Base::_S_maskbit(_M_bpos); + return *this; + } + + // For b[i] = b[__j]; + reference& + operator=(const reference& __j) + { + if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos))) + *_M_wp |= _Base::_S_maskbit(_M_bpos); + else + *_M_wp &= ~_Base::_S_maskbit(_M_bpos); + return *this; + } + + // Flips the bit + bool + operator~() const + { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; } + + // For __x = b[i]; + operator bool() const + { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; } + + // For b[i].flip(); + reference& + flip() + { + *_M_wp ^= _Base::_S_maskbit(_M_bpos); + return *this; + } + }; + friend class reference; + + // 23.3.5.1 constructors: + /// All bits set to zero. + _GLIBCXX_CONSTEXPR bitset() + { } + + /// Initial bits bitwise-copied from a single word (others set to zero). +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + constexpr bitset(unsigned long long __val) + : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { } +#else + bitset(unsigned long __val) + : _Base(__val) + { _M_do_sanitize(); } +#endif + + /** + * @brief Use a subset of a string. + * @param s A string of @a 0 and @a 1 characters. + * @param position Index of the first character in @a s to use; + * defaults to zero. + * @throw std::out_of_range If @a pos is bigger the size of @a s. + * @throw std::invalid_argument If a character appears in the string + * which is neither @a 0 nor @a 1. + */ + template<class _CharT, class _Traits, class _Alloc> + explicit + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, + size_t __position = 0) + : _Base() + { + if (__position > __s.size()) + __throw_out_of_range(__N("bitset::bitset initial position " + "not valid")); + _M_copy_from_string(__s, __position, + std::basic_string<_CharT, _Traits, _Alloc>::npos, + _CharT('0'), _CharT('1')); + } + + /** + * @brief Use a subset of a string. + * @param s A string of @a 0 and @a 1 characters. + * @param position Index of the first character in @a s to use. + * @param n The number of characters to copy. + * @throw std::out_of_range If @a pos is bigger the size of @a s. + * @throw std::invalid_argument If a character appears in the string + * which is neither @a 0 nor @a 1. + */ + template<class _CharT, class _Traits, class _Alloc> + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, + size_t __position, size_t __n) + : _Base() + { + if (__position > __s.size()) + __throw_out_of_range(__N("bitset::bitset initial position " + "not valid")); + _M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1')); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 396. what are characters zero and one. + template<class _CharT, class _Traits, class _Alloc> + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, + size_t __position, size_t __n, + _CharT __zero, _CharT __one = _CharT('1')) + : _Base() + { + if (__position > __s.size()) + __throw_out_of_range(__N("bitset::bitset initial position " + "not valid")); + _M_copy_from_string(__s, __position, __n, __zero, __one); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Construct from a character %array. + * @param str An %array of characters @a zero and @a one. + * @param n The number of characters to use. + * @param zero The character corresponding to the value 0. + * @param one The character corresponding to the value 1. + * @throw std::invalid_argument If a character appears in the string + * which is neither @a zero nor @a one. + */ + template<typename _CharT> + explicit + bitset(const _CharT* __str, + typename std::basic_string<_CharT>::size_type __n + = std::basic_string<_CharT>::npos, + _CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) + : _Base() + { + if (!__str) + __throw_logic_error(__N("bitset::bitset(const _CharT*, ...)")); + + if (__n == std::basic_string<_CharT>::npos) + __n = std::char_traits<_CharT>::length(__str); + _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0, + __n, __zero, + __one); + } +#endif + + // 23.3.5.2 bitset operations: + //@{ + /** + * @brief Operations on bitsets. + * @param rhs A same-sized bitset. + * + * These should be self-explanatory. + */ + bitset<_Nb>& + operator&=(const bitset<_Nb>& __rhs) + { + this->_M_do_and(__rhs); + return *this; + } + + bitset<_Nb>& + operator|=(const bitset<_Nb>& __rhs) + { + this->_M_do_or(__rhs); + return *this; + } + + bitset<_Nb>& + operator^=(const bitset<_Nb>& __rhs) + { + this->_M_do_xor(__rhs); + return *this; + } + //@} + + //@{ + /** + * @brief Operations on bitsets. + * @param position The number of places to shift. + * + * These should be self-explanatory. + */ + bitset<_Nb>& + operator<<=(size_t __position) + { + if (__builtin_expect(__position < _Nb, 1)) + { + this->_M_do_left_shift(__position); + this->_M_do_sanitize(); + } + else + this->_M_do_reset(); + return *this; + } + + bitset<_Nb>& + operator>>=(size_t __position) + { + if (__builtin_expect(__position < _Nb, 1)) + { + this->_M_do_right_shift(__position); + this->_M_do_sanitize(); + } + else + this->_M_do_reset(); + return *this; + } + //@} + + //@{ + /** + * These versions of single-bit set, reset, flip, and test are + * extensions from the SGI version. They do no range checking. + * @ingroup SGIextensions + */ + bitset<_Nb>& + _Unchecked_set(size_t __pos) + { + this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); + return *this; + } + + bitset<_Nb>& + _Unchecked_set(size_t __pos, int __val) + { + if (__val) + this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); + else + this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); + return *this; + } + + bitset<_Nb>& + _Unchecked_reset(size_t __pos) + { + this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); + return *this; + } + + bitset<_Nb>& + _Unchecked_flip(size_t __pos) + { + this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos); + return *this; + } + + bool + _Unchecked_test(size_t __pos) const + { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos)) + != static_cast<_WordT>(0)); } + //@} + + // Set, reset, and flip. + /** + * @brief Sets every bit to true. + */ + bitset<_Nb>& + set() + { + this->_M_do_set(); + this->_M_do_sanitize(); + return *this; + } + + /** + * @brief Sets a given bit to a particular value. + * @param position The index of the bit. + * @param val Either true or false, defaults to true. + * @throw std::out_of_range If @a pos is bigger the size of the %set. + */ + bitset<_Nb>& + set(size_t __position, bool __val = true) + { + if (__position >= _Nb) + __throw_out_of_range(__N("bitset::set")); + return _Unchecked_set(__position, __val); + } + + /** + * @brief Sets every bit to false. + */ + bitset<_Nb>& + reset() + { + this->_M_do_reset(); + return *this; + } + + /** + * @brief Sets a given bit to false. + * @param position The index of the bit. + * @throw std::out_of_range If @a pos is bigger the size of the %set. + * + * Same as writing @c set(pos,false). + */ + bitset<_Nb>& + reset(size_t __position) + { + if (__position >= _Nb) + __throw_out_of_range(__N("bitset::reset")); + return _Unchecked_reset(__position); + } + + /** + * @brief Toggles every bit to its opposite value. + */ + bitset<_Nb>& + flip() + { + this->_M_do_flip(); + this->_M_do_sanitize(); + return *this; + } + + /** + * @brief Toggles a given bit to its opposite value. + * @param position The index of the bit. + * @throw std::out_of_range If @a pos is bigger the size of the %set. + */ + bitset<_Nb>& + flip(size_t __position) + { + if (__position >= _Nb) + __throw_out_of_range(__N("bitset::flip")); + return _Unchecked_flip(__position); + } + + /// See the no-argument flip(). + bitset<_Nb> + operator~() const + { return bitset<_Nb>(*this).flip(); } + + //@{ + /** + * @brief Array-indexing support. + * @param position Index into the %bitset. + * @return A bool for a <em>const %bitset</em>. For non-const + * bitsets, an instance of the reference proxy class. + * @note These operators do no range checking and throw no exceptions, + * as required by DR 11 to the standard. + * + * _GLIBCXX_RESOLVE_LIB_DEFECTS Note that this implementation already + * resolves DR 11 (items 1 and 2), but does not do the range-checking + * required by that DR's resolution. -pme + * The DR has since been changed: range-checking is a precondition + * (users' responsibility), and these functions must not throw. -pme + */ + reference + operator[](size_t __position) + { return reference(*this, __position); } + + bool + operator[](size_t __position) const + { return _Unchecked_test(__position); } + //@} + + /** + * @brief Returns a numerical interpretation of the %bitset. + * @return The integral equivalent of the bits. + * @throw std::overflow_error If there are too many bits to be + * represented in an @c unsigned @c long. + */ + unsigned long + to_ulong() const + { return this->_M_do_to_ulong(); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + unsigned long long + to_ullong() const + { return this->_M_do_to_ullong(); } +#endif + + /** + * @brief Returns a character interpretation of the %bitset. + * @return The string equivalent of the bits. + * + * Note the ordering of the bits: decreasing character positions + * correspond to increasing bit positions (see the main class notes for + * an example). + */ + template<class _CharT, class _Traits, class _Alloc> + std::basic_string<_CharT, _Traits, _Alloc> + to_string() const + { + std::basic_string<_CharT, _Traits, _Alloc> __result; + _M_copy_to_string(__result, _CharT('0'), _CharT('1')); + return __result; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 396. what are characters zero and one. + template<class _CharT, class _Traits, class _Alloc> + std::basic_string<_CharT, _Traits, _Alloc> + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { + std::basic_string<_CharT, _Traits, _Alloc> __result; + _M_copy_to_string(__result, __zero, __one); + return __result; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 434. bitset::to_string() hard to use. + template<class _CharT, class _Traits> + std::basic_string<_CharT, _Traits, std::allocator<_CharT> > + to_string() const + { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 853. to_string needs updating with zero and one. + template<class _CharT, class _Traits> + std::basic_string<_CharT, _Traits, std::allocator<_CharT> > + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { return to_string<_CharT, _Traits, + std::allocator<_CharT> >(__zero, __one); } + + template<class _CharT> + std::basic_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> > + to_string() const + { + return to_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> >(); + } + + template<class _CharT> + std::basic_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> > + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { + return to_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> >(__zero, __one); + } + + std::basic_string<char, std::char_traits<char>, std::allocator<char> > + to_string() const + { + return to_string<char, std::char_traits<char>, + std::allocator<char> >(); + } + + std::basic_string<char, std::char_traits<char>, std::allocator<char> > + to_string(char __zero, char __one = '1') const + { + return to_string<char, std::char_traits<char>, + std::allocator<char> >(__zero, __one); + } + + // Helper functions for string operations. + template<class _CharT, class _Traits> + void + _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t, + _CharT, _CharT); + + template<class _CharT, class _Traits, class _Alloc> + void + _M_copy_from_string(const std::basic_string<_CharT, + _Traits, _Alloc>& __s, size_t __pos, size_t __n, + _CharT __zero, _CharT __one) + { _M_copy_from_ptr<_CharT, _Traits>(__s.data(), __s.size(), __pos, __n, + __zero, __one); } + + template<class _CharT, class _Traits, class _Alloc> + void + _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&, + _CharT, _CharT) const; + + // NB: Backward compat. + template<class _CharT, class _Traits, class _Alloc> + void + _M_copy_from_string(const std::basic_string<_CharT, + _Traits, _Alloc>& __s, size_t __pos, size_t __n) + { _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); } + + template<class _CharT, class _Traits, class _Alloc> + void + _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const + { _M_copy_to_string(__s, _CharT('0'), _CharT('1')); } + + /// Returns the number of bits which are set. + size_t + count() const + { return this->_M_do_count(); } + + /// Returns the total number of bits. + _GLIBCXX_CONSTEXPR size_t + size() const + { return _Nb; } + + //@{ + /// These comparisons for equality/inequality are, well, @e bitwise. + bool + operator==(const bitset<_Nb>& __rhs) const + { return this->_M_is_equal(__rhs); } + + bool + operator!=(const bitset<_Nb>& __rhs) const + { return !this->_M_is_equal(__rhs); } + //@} + + /** + * @brief Tests the value of a bit. + * @param position The index of a bit. + * @return The value at @a pos. + * @throw std::out_of_range If @a pos is bigger the size of the %set. + */ + bool + test(size_t __position) const + { + if (__position >= _Nb) + __throw_out_of_range(__N("bitset::test")); + return _Unchecked_test(__position); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 693. std::bitset::all() missing. + /** + * @brief Tests whether all the bits are on. + * @return True if all the bits are set. + */ + bool + all() const + { return this->_M_are_all_aux() == _Nb; } + + /** + * @brief Tests whether any of the bits are on. + * @return True if at least one bit is set. + */ + bool + any() const + { return this->_M_is_any(); } + + /** + * @brief Tests whether any of the bits are on. + * @return True if none of the bits are set. + */ + bool + none() const + { return !this->_M_is_any(); } + + //@{ + /// Self-explanatory. + bitset<_Nb> + operator<<(size_t __position) const + { return bitset<_Nb>(*this) <<= __position; } + + bitset<_Nb> + operator>>(size_t __position) const + { return bitset<_Nb>(*this) >>= __position; } + //@} + + /** + * @brief Finds the index of the first "on" bit. + * @return The index of the first bit set, or size() if not found. + * @ingroup SGIextensions + * @sa _Find_next + */ + size_t + _Find_first() const + { return this->_M_do_find_first(_Nb); } + + /** + * @brief Finds the index of the next "on" bit after prev. + * @return The index of the next bit set, or size() if not found. + * @param prev Where to start searching. + * @ingroup SGIextensions + * @sa _Find_first + */ + size_t + _Find_next(size_t __prev ) const + { return this->_M_do_find_next(__prev, _Nb); } + }; + + // Definitions of non-inline member functions. + template<size_t _Nb> + template<class _CharT, class _Traits> + void + bitset<_Nb>:: + _M_copy_from_ptr(const _CharT* __s, size_t __len, + size_t __pos, size_t __n, _CharT __zero, _CharT __one) + { + reset(); + const size_t __nbits = std::min(_Nb, std::min(__n, __len - __pos)); + for (size_t __i = __nbits; __i > 0; --__i) + { + const _CharT __c = __s[__pos + __nbits - __i]; + if (_Traits::eq(__c, __zero)) + ; + else if (_Traits::eq(__c, __one)) + _Unchecked_set(__i - 1); + else + __throw_invalid_argument(__N("bitset::_M_copy_from_ptr")); + } + } + + template<size_t _Nb> + template<class _CharT, class _Traits, class _Alloc> + void + bitset<_Nb>:: + _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s, + _CharT __zero, _CharT __one) const + { + __s.assign(_Nb, __zero); + for (size_t __i = _Nb; __i > 0; --__i) + if (_Unchecked_test(__i - 1)) + _Traits::assign(__s[_Nb - __i], __one); + } + + // 23.3.5.3 bitset operations: + //@{ + /** + * @brief Global bitwise operations on bitsets. + * @param x A bitset. + * @param y A bitset of the same size as @a x. + * @return A new bitset. + * + * These should be self-explanatory. + */ + template<size_t _Nb> + inline bitset<_Nb> + operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) + { + bitset<_Nb> __result(__x); + __result &= __y; + return __result; + } + + template<size_t _Nb> + inline bitset<_Nb> + operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) + { + bitset<_Nb> __result(__x); + __result |= __y; + return __result; + } + + template <size_t _Nb> + inline bitset<_Nb> + operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) + { + bitset<_Nb> __result(__x); + __result ^= __y; + return __result; + } + //@} + + //@{ + /** + * @brief Global I/O operators for bitsets. + * + * Direct I/O between streams and bitsets is supported. Output is + * straightforward. Input will skip whitespace, only accept @a 0 and @a 1 + * characters, and will only extract as many digits as the %bitset will + * hold. + */ + template<class _CharT, class _Traits, size_t _Nb> + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) + { + typedef typename _Traits::char_type char_type; + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + std::basic_string<_CharT, _Traits> __tmp; + __tmp.reserve(_Nb); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 303. Bitset input operator underspecified + const char_type __zero = __is.widen('0'); + const char_type __one = __is.widen('1'); + + typename __ios_base::iostate __state = __ios_base::goodbit; + typename __istream_type::sentry __sentry(__is); + if (__sentry) + { + __try + { + for (size_t __i = _Nb; __i > 0; --__i) + { + static typename _Traits::int_type __eof = _Traits::eof(); + + typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc(); + if (_Traits::eq_int_type(__c1, __eof)) + { + __state |= __ios_base::eofbit; + break; + } + else + { + const char_type __c2 = _Traits::to_char_type(__c1); + if (_Traits::eq(__c2, __zero)) + __tmp.push_back(__zero); + else if (_Traits::eq(__c2, __one)) + __tmp.push_back(__one); + else if (_Traits:: + eq_int_type(__is.rdbuf()->sputbackc(__c2), + __eof)) + { + __state |= __ios_base::failbit; + break; + } + } + } + } + __catch(__cxxabiv1::__forced_unwind&) + { + __is._M_setstate(__ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { __is._M_setstate(__ios_base::badbit); } + } + + if (__tmp.empty() && _Nb) + __state |= __ios_base::failbit; + else + __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb, + __zero, __one); + if (__state) + __is.setstate(__state); + return __is; + } + + template <class _CharT, class _Traits, size_t _Nb> + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const bitset<_Nb>& __x) + { + std::basic_string<_CharT, _Traits> __tmp; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 396. what are characters zero and one. + const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__os.getloc()); + __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1')); + return __os << __tmp; + } + //@} + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#undef _GLIBCXX_BITSET_WORDS +#undef _GLIBCXX_BITSET_BITS_PER_WORD +#undef _GLIBCXX_BITSET_BITS_PER_ULL + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + +#include <bits/functional_hash.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // DR 1182. + /// std::hash specialization for bitset. + template<size_t _Nb> + struct hash<_GLIBCXX_STD_C::bitset<_Nb>> + : public __hash_base<size_t, _GLIBCXX_STD_C::bitset<_Nb>> + { + size_t + operator()(const _GLIBCXX_STD_C::bitset<_Nb>& __b) const + { + const size_t __clength = (_Nb + __CHAR_BIT__ - 1) / __CHAR_BIT__; + return std::_Hash_impl::hash(__b._M_getdata(), __clength); + } + }; + + template<> + struct hash<_GLIBCXX_STD_C::bitset<0>> + : public __hash_base<size_t, _GLIBCXX_STD_C::bitset<0>> + { + size_t + operator()(const _GLIBCXX_STD_C::bitset<0>&) const + { return 0; } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#ifdef _GLIBCXX_DEBUG +# include <debug/bitset> +#endif + +#ifdef _GLIBCXX_PROFILE +# include <profile/bitset> +#endif + +#endif /* _GLIBCXX_BITSET */ diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono new file mode 100644 index 000000000..89ded2c80 --- /dev/null +++ b/libstdc++-v3/include/std/chrono @@ -0,0 +1,723 @@ +// <chrono> -*- C++ -*- + +// Copyright (C) 2008, 2009, 2010, 2011 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/chrono + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_CHRONO +#define _GLIBCXX_CHRONO 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <ratio> +#include <type_traits> +#include <limits> +#include <ctime> + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ + /** + * @defgroup chrono Time + * @ingroup utilities + * + * Classes and functions for time. + * @{ + */ + + /** @namespace std::chrono + * @brief ISO C++ 0x entities sub namespace for time and date. + */ + namespace chrono + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + template<typename _Rep, typename _Period = ratio<1>> + struct duration; + + template<typename _Clock, typename _Dur = typename _Clock::duration> + struct time_point; + + _GLIBCXX_END_NAMESPACE_VERSION + } + +_GLIBCXX_BEGIN_NAMESPACE_VERSION + // 20.8.2.3 specialization of common_type (for duration) + template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2> + struct common_type<chrono::duration<_Rep1, _Period1>, + chrono::duration<_Rep2, _Period2>> + { + private: + typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num; + typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den; + typedef typename common_type<_Rep1, _Rep2>::type __cr; + typedef ratio<__gcd_num::value, + (_Period1::den / __gcd_den::value) * _Period2::den> __r; + + public: + typedef chrono::duration<__cr, __r> type; + }; + + // 20.8.2.3 specialization of common_type (for time_point) + template<typename _Clock, typename _Dur1, typename _Dur2> + struct common_type<chrono::time_point<_Clock, _Dur1>, + chrono::time_point<_Clock, _Dur2>> + { + private: + typedef typename common_type<_Dur1, _Dur2>::type __ct; + + public: + typedef chrono::time_point<_Clock, __ct> type; + }; +_GLIBCXX_END_NAMESPACE_VERSION + + namespace chrono + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Primary template for duration_cast impl. + template<typename _ToDur, typename _CF, typename _CR, + bool _NumIsOne = false, bool _DenIsOne = false> + struct __duration_cast_impl + { + template<typename _Rep, typename _Period> + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) + * static_cast<_CR>(_CF::num) + / static_cast<_CR>(_CF::den))); + } + }; + + template<typename _ToDur, typename _CF, typename _CR> + struct __duration_cast_impl<_ToDur, _CF, _CR, true, true> + { + template<typename _Rep, typename _Period> + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>(__d.count())); + } + }; + + template<typename _ToDur, typename _CF, typename _CR> + struct __duration_cast_impl<_ToDur, _CF, _CR, true, false> + { + template<typename _Rep, typename _Period> + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>( + static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); + } + }; + + template<typename _ToDur, typename _CF, typename _CR> + struct __duration_cast_impl<_ToDur, _CF, _CR, false, true> + { + template<typename _Rep, typename _Period> + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>( + static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); + } + }; + + template<typename _Tp> + struct __is_duration + : std::false_type + { }; + + template<typename _Rep, typename _Period> + struct __is_duration<duration<_Rep, _Period>> + : std::true_type + { }; + + /// duration_cast + template<typename _ToDur, typename _Rep, typename _Period> + inline constexpr typename enable_if<__is_duration<_ToDur>::value, + _ToDur>::type + duration_cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::period __to_period; + typedef typename _ToDur::rep __to_rep; + typedef ratio_divide<_Period, __to_period> __r_div; + typedef typename __r_div::type __cf; + typedef typename common_type<__to_rep, _Rep, intmax_t>::type + __cr; + typedef __duration_cast_impl<_ToDur, __cf, __cr, + __cf::num == 1, __cf::den == 1> __dc; + return __dc::__cast(__d); + } + + /// treat_as_floating_point + template<typename _Rep> + struct treat_as_floating_point + : is_floating_point<_Rep> + { }; + + /// duration_values + template<typename _Rep> + struct duration_values + { + static constexpr _Rep + zero() + { return _Rep(0); } + + static constexpr _Rep + max() + { return numeric_limits<_Rep>::max(); } + + static constexpr _Rep + min() + { return numeric_limits<_Rep>::min(); } + }; + + template<typename T> + struct __is_ratio + : std::false_type + { }; + + template<intmax_t _Num, intmax_t _Den> + struct __is_ratio<ratio<_Num, _Den>> + : std::true_type + { }; + + /// duration + template<typename _Rep, typename _Period> + struct duration + { + typedef _Rep rep; + typedef _Period period; + + static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration"); + static_assert(__is_ratio<_Period>::value, + "period must be a specialization of ratio"); + static_assert(_Period::num > 0, "period must be positive"); + + // 20.8.3.1 construction / copy / destroy + constexpr duration() : __r() { } + + constexpr duration(const duration&) = default; + + template<typename _Rep2, typename = typename + enable_if<is_convertible<_Rep2, rep>::value + && (treat_as_floating_point<rep>::value + || !treat_as_floating_point<_Rep2>::value)>::type> + constexpr explicit duration(const _Rep2& __rep) + : __r(static_cast<rep>(__rep)) { } + + template<typename _Rep2, typename _Period2, typename = typename + enable_if<treat_as_floating_point<rep>::value + || (ratio_divide<_Period2, period>::type::den == 1 + && !treat_as_floating_point<_Rep2>::value)>::type> + constexpr duration(const duration<_Rep2, _Period2>& __d) + : __r(duration_cast<duration>(__d).count()) { } + + ~duration() = default; + duration& operator=(const duration&) = default; + + // 20.8.3.2 observer + constexpr rep + count() const + { return __r; } + + // 20.8.3.3 arithmetic + constexpr duration + operator+() const + { return *this; } + + constexpr duration + operator-() const + { return duration(-__r); } + + duration& + operator++() + { + ++__r; + return *this; + } + + duration + operator++(int) + { return duration(__r++); } + + duration& + operator--() + { + --__r; + return *this; + } + + duration + operator--(int) + { return duration(__r--); } + + duration& + operator+=(const duration& __d) + { + __r += __d.count(); + return *this; + } + + duration& + operator-=(const duration& __d) + { + __r -= __d.count(); + return *this; + } + + duration& + operator*=(const rep& __rhs) + { + __r *= __rhs; + return *this; + } + + duration& + operator/=(const rep& __rhs) + { + __r /= __rhs; + return *this; + } + + // DR 934. + template<typename _Rep2 = rep> + typename enable_if<!treat_as_floating_point<_Rep2>::value, + duration&>::type + operator%=(const rep& __rhs) + { + __r %= __rhs; + return *this; + } + + template<typename _Rep2 = rep> + typename enable_if<!treat_as_floating_point<_Rep2>::value, + duration&>::type + operator%=(const duration& __d) + { + __r %= __d.count(); + return *this; + } + + // 20.8.3.4 special values + static constexpr duration + zero() + { return duration(duration_values<rep>::zero()); } + + static constexpr duration + min() + { return duration(duration_values<rep>::min()); } + + static constexpr duration + max() + { return duration(duration_values<rep>::max()); } + + private: + rep __r; + }; + + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type + operator+(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __ct; + return __ct(__lhs) += __rhs; + } + + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type + operator-(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __ct; + return __ct(__lhs) -= __rhs; + } + + template<typename _Rep1, typename _Rep2, bool = + is_convertible<_Rep2, + typename common_type<_Rep1, _Rep2>::type>::value> + struct __common_rep_type { }; + + template<typename _Rep1, typename _Rep2> + struct __common_rep_type<_Rep1, _Rep2, true> + { typedef typename common_type<_Rep1, _Rep2>::type type; }; + + template<typename _Rep1, typename _Period, typename _Rep2> + inline duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period> + operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) + { + typedef typename common_type<_Rep1, _Rep2>::type __cr; + return duration<__cr, _Period>(__d) *= __s; + } + + template<typename _Rep1, typename _Period, typename _Rep2> + inline duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period> + operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) + { return __d * __s; } + + template<typename _Rep1, typename _Period, typename _Rep2> + inline duration<typename __common_rep_type<_Rep1, typename + enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period> + operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) + { + typedef typename common_type<_Rep1, _Rep2>::type __cr; + return duration<__cr, _Period>(__d) /= __s; + } + + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline typename common_type<_Rep1, _Rep2>::type + operator/(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __ct; + return __ct(__lhs).count() / __ct(__rhs).count(); + } + + // DR 934. + template<typename _Rep1, typename _Period, typename _Rep2> + inline duration<typename __common_rep_type<_Rep1, typename + enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period> + operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) + { + typedef typename common_type<_Rep1, _Rep2>::type __cr; + return duration<__cr, _Period>(__d) %= __s; + } + + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type + operator%(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __ct; + return __ct(__lhs) %= __rhs; + } + + // comparisons + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline constexpr bool + operator==(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __ct; + return __ct(__lhs).count() == __ct(__rhs).count(); + } + + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline constexpr bool + operator<(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __ct; + return __ct(__lhs).count() < __ct(__rhs).count(); + } + + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline constexpr bool + operator!=(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return !(__lhs == __rhs); } + + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline constexpr bool + operator<=(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return !(__rhs < __lhs); } + + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline constexpr bool + operator>(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return __rhs < __lhs; } + + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline constexpr bool + operator>=(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return !(__lhs < __rhs); } + + /// nanoseconds + typedef duration<int64_t, nano> nanoseconds; + + /// microseconds + typedef duration<int64_t, micro> microseconds; + + /// milliseconds + typedef duration<int64_t, milli> milliseconds; + + /// seconds + typedef duration<int64_t> seconds; + + /// minutes + typedef duration<int, ratio< 60>> minutes; + + /// hours + typedef duration<int, ratio<3600>> hours; + + /// time_point + template<typename _Clock, typename _Dur> + struct time_point + { + typedef _Clock clock; + typedef _Dur duration; + typedef typename duration::rep rep; + typedef typename duration::period period; + + constexpr time_point() : __d(duration::zero()) + { } + + constexpr explicit time_point(const duration& __dur) + : __d(__dur) + { } + + // conversions + template<typename _Dur2> + constexpr time_point(const time_point<clock, _Dur2>& __t) + : __d(__t.time_since_epoch()) + { } + + // observer + constexpr duration + time_since_epoch() const + { return __d; } + + // arithmetic + time_point& + operator+=(const duration& __dur) + { + __d += __dur; + return *this; + } + + time_point& + operator-=(const duration& __dur) + { + __d -= __dur; + return *this; + } + + // special values + static constexpr time_point + min() + { return time_point(duration::min()); } + + static constexpr time_point + max() + { return time_point(duration::max()); } + + private: + duration __d; + }; + + /// time_point_cast + template<typename _ToDur, typename _Clock, typename _Dur> + inline constexpr typename enable_if<__is_duration<_ToDur>::value, + time_point<_Clock, _ToDur>>::type + time_point_cast(const time_point<_Clock, _Dur>& __t) + { + typedef time_point<_Clock, _ToDur> __time_point; + return __time_point(duration_cast<_ToDur>(__t.time_since_epoch())); + } + + template<typename _Clock, typename _Dur1, + typename _Rep2, typename _Period2> + inline time_point<_Clock, + typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> + operator+(const time_point<_Clock, _Dur1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<_Dur1,__dur2>::type __ct; + typedef time_point<_Clock, __ct> __time_point; + return __time_point(__lhs) += __rhs; + } + + template<typename _Rep1, typename _Period1, + typename _Clock, typename _Dur2> + inline time_point<_Clock, + typename common_type<duration<_Rep1, _Period1>, _Dur2>::type> + operator+(const duration<_Rep1, _Period1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __rhs + __lhs; } + + template<typename _Clock, typename _Dur1, + typename _Rep2, typename _Period2> + inline time_point<_Clock, + typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> + operator-(const time_point<_Clock, _Dur1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return __lhs + (-__rhs); } + + template<typename _Clock, typename _Dur1, typename _Dur2> + inline typename common_type<_Dur1, _Dur2>::type + operator-(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } + + template<typename _Clock, typename _Dur1, typename _Dur2> + inline constexpr bool + operator==(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); } + + template<typename _Clock, typename _Dur1, typename _Dur2> + inline constexpr bool + operator!=(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return !(__lhs == __rhs); } + + template<typename _Clock, typename _Dur1, typename _Dur2> + inline constexpr bool + operator<(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } + + template<typename _Clock, typename _Dur1, typename _Dur2> + inline constexpr bool + operator<=(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return !(__rhs < __lhs); } + + template<typename _Clock, typename _Dur1, typename _Dur2> + inline constexpr bool + operator>(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __rhs < __lhs; } + + template<typename _Clock, typename _Dur1, typename _Dur2> + inline constexpr bool + operator>=(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return !(__lhs < __rhs); } + + /// system_clock + struct system_clock + { +#ifdef _GLIBCXX_USE_CLOCK_REALTIME + typedef chrono::nanoseconds duration; +#elif defined(_GLIBCXX_USE_GETTIMEOFDAY) + typedef chrono::microseconds duration; +#else + typedef chrono::seconds duration; +#endif + + typedef duration::rep rep; + typedef duration::period period; + typedef chrono::time_point<system_clock, duration> time_point; + + static_assert(system_clock::duration::min() + < system_clock::duration::zero(), + "a clock's minimum duration cannot be less than its epoch"); + + static constexpr bool is_monotonic = false; + + static time_point + now() throw (); + + // Map to C API + static std::time_t + to_time_t(const time_point& __t) + { + return std::time_t(duration_cast<chrono::seconds> + (__t.time_since_epoch()).count()); + } + + static time_point + from_time_t(std::time_t __t) + { + typedef chrono::time_point<system_clock, seconds> __from; + return time_point_cast<system_clock::duration> + (__from(chrono::seconds(__t))); + } + }; + +#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC + /// monotonic_clock + struct monotonic_clock + { + typedef chrono::nanoseconds duration; + typedef duration::rep rep; + typedef duration::period period; + typedef chrono::time_point<monotonic_clock, duration> time_point; + + static constexpr bool is_monotonic = true; + + static time_point + now(); + }; +#else + typedef system_clock monotonic_clock; +#endif + + typedef system_clock high_resolution_clock; + + _GLIBCXX_END_NAMESPACE_VERSION + } // namespace chrono + + // @} group chrono +} // namespace + +#endif //_GLIBCXX_USE_C99_STDINT_TR1 + +#endif //__GXX_EXPERIMENTAL_CXX0X__ + +#endif //_GLIBCXX_CHRONO diff --git a/libstdc++-v3/include/std/complex b/libstdc++-v3/include/std/complex new file mode 100644 index 000000000..da3c469f8 --- /dev/null +++ b/libstdc++-v3/include/std/complex @@ -0,0 +1,1933 @@ +// The template and inlines for the -*- C++ -*- complex number classes. + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +// 2006, 2007, 2008, 2009, 2010, 2011 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/complex + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 14882: 26.2 Complex Numbers +// Note: this is not a conforming implementation. +// Initially implemented by Ulrich Drepper <drepper@cygnus.com> +// Improved by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> +// + +#ifndef _GLIBCXX_COMPLEX +#define _GLIBCXX_COMPLEX 1 + +#pragma GCC system_header + +#include <bits/c++config.h> +#include <bits/cpp_type_traits.h> +#include <ext/type_traits.h> +#include <cmath> +#include <sstream> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup complex_numbers Complex Numbers + * @ingroup numerics + * + * Classes and functions for complex numbers. + * @{ + */ + + // Forward declarations. + template<typename _Tp> class complex; + template<> class complex<float>; + template<> class complex<double>; + template<> class complex<long double>; + + /// Return magnitude of @a z. + template<typename _Tp> _Tp abs(const complex<_Tp>&); + /// Return phase angle of @a z. + template<typename _Tp> _Tp arg(const complex<_Tp>&); + /// Return @a z magnitude squared. + template<typename _Tp> _Tp norm(const complex<_Tp>&); + + /// Return complex conjugate of @a z. + template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&); + /// Return complex with magnitude @a rho and angle @a theta. + template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0); + + // Transcendentals: + /// Return complex cosine of @a z. + template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&); + /// Return complex hyperbolic cosine of @a z. + template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&); + /// Return complex base e exponential of @a z. + template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&); + /// Return complex natural logarithm of @a z. + template<typename _Tp> complex<_Tp> log(const complex<_Tp>&); + /// Return complex base 10 logarithm of @a z. + template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&); +#ifndef __GXX_EXPERIMENTAL_CXX0X__ + // DR 844. + /// Return @a x to the @a y'th power. + template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int); +#endif + /// Return @a x to the @a y'th power. + template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&); + /// Return @a x to the @a y'th power. + template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, + const complex<_Tp>&); + /// Return @a x to the @a y'th power. + template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&); + /// Return complex sine of @a z. + template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&); + /// Return complex hyperbolic sine of @a z. + template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&); + /// Return complex square root of @a z. + template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&); + /// Return complex tangent of @a z. + template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&); + /// Return complex hyperbolic tangent of @a z. + template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&); + + + // 26.2.2 Primary template class complex + /** + * Template to represent complex numbers. + * + * Specializations for float, double, and long double are part of the + * library. Results with any other type are not guaranteed. + * + * @param Tp Type of real and imaginary values. + */ + template<typename _Tp> + struct complex + { + /// Value typedef. + typedef _Tp value_type; + + /// Default constructor. First parameter is x, second parameter is y. + /// Unspecified parameters default to 0. + _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp()) + : _M_real(__r), _M_imag(__i) { } + + // Lets the compiler synthesize the copy constructor + // complex (const complex<_Tp>&); + /// Copy constructor. + template<typename _Up> + _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z) + : _M_real(__z.real()), _M_imag(__z.imag()) { } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + constexpr _Tp + real() const { return _M_real; } + + constexpr _Tp + imag() const { return _M_imag; } +#else + /// Return real part of complex number. + _Tp& + real() { return _M_real; } + + /// Return real part of complex number. + const _Tp& + real() const { return _M_real; } + + /// Return imaginary part of complex number. + _Tp& + imag() { return _M_imag; } + + /// Return imaginary part of complex number. + const _Tp& + imag() const { return _M_imag; } +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + void + real(_Tp __val) { _M_real = __val; } + + void + imag(_Tp __val) { _M_imag = __val; } + + /// Assign this complex number to scalar @a t. + complex<_Tp>& operator=(const _Tp&); + + /// Add @a t to this complex number. + // 26.2.5/1 + complex<_Tp>& + operator+=(const _Tp& __t) + { + _M_real += __t; + return *this; + } + + /// Subtract @a t from this complex number. + // 26.2.5/3 + complex<_Tp>& + operator-=(const _Tp& __t) + { + _M_real -= __t; + return *this; + } + + /// Multiply this complex number by @a t. + complex<_Tp>& operator*=(const _Tp&); + /// Divide this complex number by @a t. + complex<_Tp>& operator/=(const _Tp&); + + // Lets the compiler synthesize the + // copy and assignment operator + // complex<_Tp>& operator= (const complex<_Tp>&); + /// Assign this complex number to complex @a z. + template<typename _Up> + complex<_Tp>& operator=(const complex<_Up>&); + /// Add @a z to this complex number. + template<typename _Up> + complex<_Tp>& operator+=(const complex<_Up>&); + /// Subtract @a z from this complex number. + template<typename _Up> + complex<_Tp>& operator-=(const complex<_Up>&); + /// Multiply this complex number by @a z. + template<typename _Up> + complex<_Tp>& operator*=(const complex<_Up>&); + /// Divide this complex number by @a z. + template<typename _Up> + complex<_Tp>& operator/=(const complex<_Up>&); + + _GLIBCXX_USE_CONSTEXPR complex __rep() const + { return *this; } + + private: + _Tp _M_real; + _Tp _M_imag; + }; + + template<typename _Tp> + complex<_Tp>& + complex<_Tp>::operator=(const _Tp& __t) + { + _M_real = __t; + _M_imag = _Tp(); + return *this; + } + + // 26.2.5/5 + template<typename _Tp> + complex<_Tp>& + complex<_Tp>::operator*=(const _Tp& __t) + { + _M_real *= __t; + _M_imag *= __t; + return *this; + } + + // 26.2.5/7 + template<typename _Tp> + complex<_Tp>& + complex<_Tp>::operator/=(const _Tp& __t) + { + _M_real /= __t; + _M_imag /= __t; + return *this; + } + + template<typename _Tp> + template<typename _Up> + complex<_Tp>& + complex<_Tp>::operator=(const complex<_Up>& __z) + { + _M_real = __z.real(); + _M_imag = __z.imag(); + return *this; + } + + // 26.2.5/9 + template<typename _Tp> + template<typename _Up> + complex<_Tp>& + complex<_Tp>::operator+=(const complex<_Up>& __z) + { + _M_real += __z.real(); + _M_imag += __z.imag(); + return *this; + } + + // 26.2.5/11 + template<typename _Tp> + template<typename _Up> + complex<_Tp>& + complex<_Tp>::operator-=(const complex<_Up>& __z) + { + _M_real -= __z.real(); + _M_imag -= __z.imag(); + return *this; + } + + // 26.2.5/13 + // XXX: This is a grammar school implementation. + template<typename _Tp> + template<typename _Up> + complex<_Tp>& + complex<_Tp>::operator*=(const complex<_Up>& __z) + { + const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag(); + _M_imag = _M_real * __z.imag() + _M_imag * __z.real(); + _M_real = __r; + return *this; + } + + // 26.2.5/15 + // XXX: This is a grammar school implementation. + template<typename _Tp> + template<typename _Up> + complex<_Tp>& + complex<_Tp>::operator/=(const complex<_Up>& __z) + { + const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag(); + const _Tp __n = std::norm(__z); + _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n; + _M_real = __r / __n; + return *this; + } + + // Operators: + //@{ + /// Return new complex value @a x plus @a y. + template<typename _Tp> + inline complex<_Tp> + operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __x; + __r += __y; + return __r; + } + + template<typename _Tp> + inline complex<_Tp> + operator+(const complex<_Tp>& __x, const _Tp& __y) + { + complex<_Tp> __r = __x; + __r += __y; + return __r; + } + + template<typename _Tp> + inline complex<_Tp> + operator+(const _Tp& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __y; + __r += __x; + return __r; + } + //@} + + //@{ + /// Return new complex value @a x minus @a y. + template<typename _Tp> + inline complex<_Tp> + operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __x; + __r -= __y; + return __r; + } + + template<typename _Tp> + inline complex<_Tp> + operator-(const complex<_Tp>& __x, const _Tp& __y) + { + complex<_Tp> __r = __x; + __r -= __y; + return __r; + } + + template<typename _Tp> + inline complex<_Tp> + operator-(const _Tp& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r(__x, -__y.imag()); + __r -= __y.real(); + return __r; + } + //@} + + //@{ + /// Return new complex value @a x times @a y. + template<typename _Tp> + inline complex<_Tp> + operator*(const complex<_Tp>& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __x; + __r *= __y; + return __r; + } + + template<typename _Tp> + inline complex<_Tp> + operator*(const complex<_Tp>& __x, const _Tp& __y) + { + complex<_Tp> __r = __x; + __r *= __y; + return __r; + } + + template<typename _Tp> + inline complex<_Tp> + operator*(const _Tp& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __y; + __r *= __x; + return __r; + } + //@} + + //@{ + /// Return new complex value @a x divided by @a y. + template<typename _Tp> + inline complex<_Tp> + operator/(const complex<_Tp>& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __x; + __r /= __y; + return __r; + } + + template<typename _Tp> + inline complex<_Tp> + operator/(const complex<_Tp>& __x, const _Tp& __y) + { + complex<_Tp> __r = __x; + __r /= __y; + return __r; + } + + template<typename _Tp> + inline complex<_Tp> + operator/(const _Tp& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __x; + __r /= __y; + return __r; + } + //@} + + /// Return @a x. + template<typename _Tp> + inline complex<_Tp> + operator+(const complex<_Tp>& __x) + { return __x; } + + /// Return complex negation of @a x. + template<typename _Tp> + inline complex<_Tp> + operator-(const complex<_Tp>& __x) + { return complex<_Tp>(-__x.real(), -__x.imag()); } + + //@{ + /// Return true if @a x is equal to @a y. + template<typename _Tp> + inline _GLIBCXX_CONSTEXPR bool + operator==(const complex<_Tp>& __x, const complex<_Tp>& __y) + { return __x.real() == __y.real() && __x.imag() == __y.imag(); } + + template<typename _Tp> + inline _GLIBCXX_CONSTEXPR bool + operator==(const complex<_Tp>& __x, const _Tp& __y) + { return __x.real() == __y && __x.imag() == _Tp(); } + + template<typename _Tp> + inline _GLIBCXX_CONSTEXPR bool + operator==(const _Tp& __x, const complex<_Tp>& __y) + { return __x == __y.real() && _Tp() == __y.imag(); } + //@} + + //@{ + /// Return false if @a x is equal to @a y. + template<typename _Tp> + inline _GLIBCXX_CONSTEXPR bool + operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y) + { return __x.real() != __y.real() || __x.imag() != __y.imag(); } + + template<typename _Tp> + inline _GLIBCXX_CONSTEXPR bool + operator!=(const complex<_Tp>& __x, const _Tp& __y) + { return __x.real() != __y || __x.imag() != _Tp(); } + + template<typename _Tp> + inline _GLIBCXX_CONSTEXPR bool + operator!=(const _Tp& __x, const complex<_Tp>& __y) + { return __x != __y.real() || _Tp() != __y.imag(); } + //@} + + /// Extraction operator for complex values. + template<typename _Tp, typename _CharT, class _Traits> + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x) + { + _Tp __re_x, __im_x; + _CharT __ch; + __is >> __ch; + if (__ch == '(') + { + __is >> __re_x >> __ch; + if (__ch == ',') + { + __is >> __im_x >> __ch; + if (__ch == ')') + __x = complex<_Tp>(__re_x, __im_x); + else + __is.setstate(ios_base::failbit); + } + else if (__ch == ')') + __x = __re_x; + else + __is.setstate(ios_base::failbit); + } + else + { + __is.putback(__ch); + __is >> __re_x; + __x = __re_x; + } + return __is; + } + + /// Insertion operator for complex values. + template<typename _Tp, typename _CharT, class _Traits> + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x) + { + basic_ostringstream<_CharT, _Traits> __s; + __s.flags(__os.flags()); + __s.imbue(__os.getloc()); + __s.precision(__os.precision()); + __s << '(' << __x.real() << ',' << __x.imag() << ')'; + return __os << __s.str(); + } + + // Values +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Tp> + inline constexpr _Tp + real(const complex<_Tp>& __z) + { return __z.real(); } + + template<typename _Tp> + inline constexpr _Tp + imag(const complex<_Tp>& __z) + { return __z.imag(); } +#else + template<typename _Tp> + inline _Tp& + real(complex<_Tp>& __z) + { return __z.real(); } + + template<typename _Tp> + inline const _Tp& + real(const complex<_Tp>& __z) + { return __z.real(); } + + template<typename _Tp> + inline _Tp& + imag(complex<_Tp>& __z) + { return __z.imag(); } + + template<typename _Tp> + inline const _Tp& + imag(const complex<_Tp>& __z) + { return __z.imag(); } +#endif + + // 26.2.7/3 abs(__z): Returns the magnitude of __z. + template<typename _Tp> + inline _Tp + __complex_abs(const complex<_Tp>& __z) + { + _Tp __x = __z.real(); + _Tp __y = __z.imag(); + const _Tp __s = std::max(abs(__x), abs(__y)); + if (__s == _Tp()) // well ... + return __s; + __x /= __s; + __y /= __s; + return __s * sqrt(__x * __x + __y * __y); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline float + __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); } + + inline double + __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); } + + inline long double + __complex_abs(const __complex__ long double& __z) + { return __builtin_cabsl(__z); } + + template<typename _Tp> + inline _Tp + abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); } +#else + template<typename _Tp> + inline _Tp + abs(const complex<_Tp>& __z) { return __complex_abs(__z); } +#endif + + + // 26.2.7/4: arg(__z): Returns the phase angle of __z. + template<typename _Tp> + inline _Tp + __complex_arg(const complex<_Tp>& __z) + { return atan2(__z.imag(), __z.real()); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline float + __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); } + + inline double + __complex_arg(__complex__ double __z) { return __builtin_carg(__z); } + + inline long double + __complex_arg(const __complex__ long double& __z) + { return __builtin_cargl(__z); } + + template<typename _Tp> + inline _Tp + arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); } +#else + template<typename _Tp> + inline _Tp + arg(const complex<_Tp>& __z) { return __complex_arg(__z); } +#endif + + // 26.2.7/5: norm(__z) returns the squared magnitude of __z. + // As defined, norm() is -not- a norm is the common mathematical + // sens used in numerics. The helper class _Norm_helper<> tries to + // distinguish between builtin floating point and the rest, so as + // to deliver an answer as close as possible to the real value. + template<bool> + struct _Norm_helper + { + template<typename _Tp> + static inline _Tp _S_do_it(const complex<_Tp>& __z) + { + const _Tp __x = __z.real(); + const _Tp __y = __z.imag(); + return __x * __x + __y * __y; + } + }; + + template<> + struct _Norm_helper<true> + { + template<typename _Tp> + static inline _Tp _S_do_it(const complex<_Tp>& __z) + { + _Tp __res = std::abs(__z); + return __res * __res; + } + }; + + template<typename _Tp> + inline _Tp + norm(const complex<_Tp>& __z) + { + return _Norm_helper<__is_floating<_Tp>::__value + && !_GLIBCXX_FAST_MATH>::_S_do_it(__z); + } + + template<typename _Tp> + inline complex<_Tp> + polar(const _Tp& __rho, const _Tp& __theta) + { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); } + + template<typename _Tp> + inline complex<_Tp> + conj(const complex<_Tp>& __z) + { return complex<_Tp>(__z.real(), -__z.imag()); } + + // Transcendentals + + // 26.2.8/1 cos(__z): Returns the cosine of __z. + template<typename _Tp> + inline complex<_Tp> + __complex_cos(const complex<_Tp>& __z) + { + const _Tp __x = __z.real(); + const _Tp __y = __z.imag(); + return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y)); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); } + + inline __complex__ double + __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); } + + inline __complex__ long double + __complex_cos(const __complex__ long double& __z) + { return __builtin_ccosl(__z); } + + template<typename _Tp> + inline complex<_Tp> + cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); } +#else + template<typename _Tp> + inline complex<_Tp> + cos(const complex<_Tp>& __z) { return __complex_cos(__z); } +#endif + + // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z. + template<typename _Tp> + inline complex<_Tp> + __complex_cosh(const complex<_Tp>& __z) + { + const _Tp __x = __z.real(); + const _Tp __y = __z.imag(); + return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y)); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); } + + inline __complex__ double + __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); } + + inline __complex__ long double + __complex_cosh(const __complex__ long double& __z) + { return __builtin_ccoshl(__z); } + + template<typename _Tp> + inline complex<_Tp> + cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); } +#else + template<typename _Tp> + inline complex<_Tp> + cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); } +#endif + + // 26.2.8/3 exp(__z): Returns the complex base e exponential of x + template<typename _Tp> + inline complex<_Tp> + __complex_exp(const complex<_Tp>& __z) + { return std::polar(exp(__z.real()), __z.imag()); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); } + + inline __complex__ double + __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); } + + inline __complex__ long double + __complex_exp(const __complex__ long double& __z) + { return __builtin_cexpl(__z); } + + template<typename _Tp> + inline complex<_Tp> + exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); } +#else + template<typename _Tp> + inline complex<_Tp> + exp(const complex<_Tp>& __z) { return __complex_exp(__z); } +#endif + + // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z. + // The branch cut is along the negative axis. + template<typename _Tp> + inline complex<_Tp> + __complex_log(const complex<_Tp>& __z) + { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_log(__complex__ float __z) { return __builtin_clogf(__z); } + + inline __complex__ double + __complex_log(__complex__ double __z) { return __builtin_clog(__z); } + + inline __complex__ long double + __complex_log(const __complex__ long double& __z) + { return __builtin_clogl(__z); } + + template<typename _Tp> + inline complex<_Tp> + log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); } +#else + template<typename _Tp> + inline complex<_Tp> + log(const complex<_Tp>& __z) { return __complex_log(__z); } +#endif + + template<typename _Tp> + inline complex<_Tp> + log10(const complex<_Tp>& __z) + { return std::log(__z) / log(_Tp(10.0)); } + + // 26.2.8/10 sin(__z): Returns the sine of __z. + template<typename _Tp> + inline complex<_Tp> + __complex_sin(const complex<_Tp>& __z) + { + const _Tp __x = __z.real(); + const _Tp __y = __z.imag(); + return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y)); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); } + + inline __complex__ double + __complex_sin(__complex__ double __z) { return __builtin_csin(__z); } + + inline __complex__ long double + __complex_sin(const __complex__ long double& __z) + { return __builtin_csinl(__z); } + + template<typename _Tp> + inline complex<_Tp> + sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); } +#else + template<typename _Tp> + inline complex<_Tp> + sin(const complex<_Tp>& __z) { return __complex_sin(__z); } +#endif + + // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z. + template<typename _Tp> + inline complex<_Tp> + __complex_sinh(const complex<_Tp>& __z) + { + const _Tp __x = __z.real(); + const _Tp __y = __z.imag(); + return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y)); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); } + + inline __complex__ double + __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); } + + inline __complex__ long double + __complex_sinh(const __complex__ long double& __z) + { return __builtin_csinhl(__z); } + + template<typename _Tp> + inline complex<_Tp> + sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); } +#else + template<typename _Tp> + inline complex<_Tp> + sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); } +#endif + + // 26.2.8/13 sqrt(__z): Returns the complex square root of __z. + // The branch cut is on the negative axis. + template<typename _Tp> + complex<_Tp> + __complex_sqrt(const complex<_Tp>& __z) + { + _Tp __x = __z.real(); + _Tp __y = __z.imag(); + + if (__x == _Tp()) + { + _Tp __t = sqrt(abs(__y) / 2); + return complex<_Tp>(__t, __y < _Tp() ? -__t : __t); + } + else + { + _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x))); + _Tp __u = __t / 2; + return __x > _Tp() + ? complex<_Tp>(__u, __y / __t) + : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u); + } + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); } + + inline __complex__ double + __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); } + + inline __complex__ long double + __complex_sqrt(const __complex__ long double& __z) + { return __builtin_csqrtl(__z); } + + template<typename _Tp> + inline complex<_Tp> + sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); } +#else + template<typename _Tp> + inline complex<_Tp> + sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); } +#endif + + // 26.2.8/14 tan(__z): Return the complex tangent of __z. + + template<typename _Tp> + inline complex<_Tp> + __complex_tan(const complex<_Tp>& __z) + { return std::sin(__z) / std::cos(__z); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); } + + inline __complex__ double + __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); } + + inline __complex__ long double + __complex_tan(const __complex__ long double& __z) + { return __builtin_ctanl(__z); } + + template<typename _Tp> + inline complex<_Tp> + tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); } +#else + template<typename _Tp> + inline complex<_Tp> + tan(const complex<_Tp>& __z) { return __complex_tan(__z); } +#endif + + + // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z. + + template<typename _Tp> + inline complex<_Tp> + __complex_tanh(const complex<_Tp>& __z) + { return std::sinh(__z) / std::cosh(__z); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); } + + inline __complex__ double + __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); } + + inline __complex__ long double + __complex_tanh(const __complex__ long double& __z) + { return __builtin_ctanhl(__z); } + + template<typename _Tp> + inline complex<_Tp> + tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); } +#else + template<typename _Tp> + inline complex<_Tp> + tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); } +#endif + + + // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x + // raised to the __y-th power. The branch + // cut is on the negative axis. +#ifndef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Tp> + complex<_Tp> + __complex_pow_unsigned(complex<_Tp> __x, unsigned __n) + { + complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1); + + while (__n >>= 1) + { + __x *= __x; + if (__n % 2) + __y *= __x; + } + + return __y; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 844. complex pow return type is ambiguous. + template<typename _Tp> + inline complex<_Tp> + pow(const complex<_Tp>& __z, int __n) + { + return __n < 0 + ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -__n) + : std::__complex_pow_unsigned(__z, __n); + } +#endif + + template<typename _Tp> + complex<_Tp> + pow(const complex<_Tp>& __x, const _Tp& __y) + { +#ifndef _GLIBCXX_USE_C99_COMPLEX + if (__x == _Tp()) + return _Tp(); +#endif + if (__x.imag() == _Tp() && __x.real() > _Tp()) + return pow(__x.real(), __y); + + complex<_Tp> __t = std::log(__x); + return std::polar(exp(__y * __t.real()), __y * __t.imag()); + } + + template<typename _Tp> + inline complex<_Tp> + __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y) + { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_pow(__complex__ float __x, __complex__ float __y) + { return __builtin_cpowf(__x, __y); } + + inline __complex__ double + __complex_pow(__complex__ double __x, __complex__ double __y) + { return __builtin_cpow(__x, __y); } + + inline __complex__ long double + __complex_pow(const __complex__ long double& __x, + const __complex__ long double& __y) + { return __builtin_cpowl(__x, __y); } + + template<typename _Tp> + inline complex<_Tp> + pow(const complex<_Tp>& __x, const complex<_Tp>& __y) + { return __complex_pow(__x.__rep(), __y.__rep()); } +#else + template<typename _Tp> + inline complex<_Tp> + pow(const complex<_Tp>& __x, const complex<_Tp>& __y) + { return __complex_pow(__x, __y); } +#endif + + template<typename _Tp> + inline complex<_Tp> + pow(const _Tp& __x, const complex<_Tp>& __y) + { + return __x > _Tp() ? std::polar(pow(__x, __y.real()), + __y.imag() * log(__x)) + : std::pow(complex<_Tp>(__x), __y); + } + + // 26.2.3 complex specializations + // complex<float> specialization + template<> + struct complex<float> + { + typedef float value_type; + typedef __complex__ float _ComplexT; + + _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } + + _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f) +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // The list-initialization extension to __complex__ types is + // not available in GCC 4.6. Thus libstdc++/48760 cannot be + // fixed in C++0x mode, unfortunately. + : _M_value(__r + __i * 1.0fi) { } +#else + { + __real__ _M_value = __r; + __imag__ _M_value = __i; + } +#endif + + explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&); + explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&); + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + constexpr float + real() const { return __real__ _M_value; } + + constexpr float + imag() const { return __imag__ _M_value; } +#else + float& + real() { return __real__ _M_value; } + + const float& + real() const { return __real__ _M_value; } + + float& + imag() { return __imag__ _M_value; } + + const float& + imag() const { return __imag__ _M_value; } +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + void + real(float __val) { __real__ _M_value = __val; } + + void + imag(float __val) { __imag__ _M_value = __val; } + + complex& + operator=(float __f) + { + _M_value = __f; + return *this; + } + + complex& + operator+=(float __f) + { + _M_value += __f; + return *this; + } + + complex& + operator-=(float __f) + { + _M_value -= __f; + return *this; + } + + complex& + operator*=(float __f) + { + _M_value *= __f; + return *this; + } + + complex& + operator/=(float __f) + { + _M_value /= __f; + return *this; + } + + // Let the compiler synthesize the copy and assignment + // operator. It always does a pretty good job. + // complex& operator=(const complex&); + + template<typename _Tp> + complex& + operator=(const complex<_Tp>& __z) + { + __real__ _M_value = __z.real(); + __imag__ _M_value = __z.imag(); + return *this; + } + + template<typename _Tp> + complex& + operator+=(const complex<_Tp>& __z) + { + __real__ _M_value += __z.real(); + __imag__ _M_value += __z.imag(); + return *this; + } + + template<class _Tp> + complex& + operator-=(const complex<_Tp>& __z) + { + __real__ _M_value -= __z.real(); + __imag__ _M_value -= __z.imag(); + return *this; + } + + template<class _Tp> + complex& + operator*=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value *= __t; + return *this; + } + + template<class _Tp> + complex& + operator/=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value /= __t; + return *this; + } + + _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; } + + private: + _ComplexT _M_value; + }; + + // 26.2.3 complex specializations + // complex<double> specialization + template<> + struct complex<double> + { + typedef double value_type; + typedef __complex__ double _ComplexT; + + _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } + + _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0) +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // The list-initialization extension to __complex__ types is + // not available in GCC 4.6. Thus libstdc++/48760 cannot be + // fixed in C++0x mode, unfortunately. + : _M_value(__r + __i * 1.0i) { } +#else + { + __real__ _M_value = __r; + __imag__ _M_value = __i; + } +#endif + + _GLIBCXX_CONSTEXPR complex(const complex<float>& __z) + : _M_value(__z.__rep()) { } + + explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&); + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + constexpr double + real() const { return __real__ _M_value; } + + constexpr double + imag() const { return __imag__ _M_value; } +#else + double& + real() { return __real__ _M_value; } + + const double& + real() const { return __real__ _M_value; } + + double& + imag() { return __imag__ _M_value; } + + const double& + imag() const { return __imag__ _M_value; } +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + void + real(double __val) { __real__ _M_value = __val; } + + void + imag(double __val) { __imag__ _M_value = __val; } + + complex& + operator=(double __d) + { + _M_value = __d; + return *this; + } + + complex& + operator+=(double __d) + { + _M_value += __d; + return *this; + } + + complex& + operator-=(double __d) + { + _M_value -= __d; + return *this; + } + + complex& + operator*=(double __d) + { + _M_value *= __d; + return *this; + } + + complex& + operator/=(double __d) + { + _M_value /= __d; + return *this; + } + + // The compiler will synthesize this, efficiently. + // complex& operator=(const complex&); + + template<typename _Tp> + complex& + operator=(const complex<_Tp>& __z) + { + __real__ _M_value = __z.real(); + __imag__ _M_value = __z.imag(); + return *this; + } + + template<typename _Tp> + complex& + operator+=(const complex<_Tp>& __z) + { + __real__ _M_value += __z.real(); + __imag__ _M_value += __z.imag(); + return *this; + } + + template<typename _Tp> + complex& + operator-=(const complex<_Tp>& __z) + { + __real__ _M_value -= __z.real(); + __imag__ _M_value -= __z.imag(); + return *this; + } + + template<typename _Tp> + complex& + operator*=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value *= __t; + return *this; + } + + template<typename _Tp> + complex& + operator/=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value /= __t; + return *this; + } + + _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; } + + private: + _ComplexT _M_value; + }; + + // 26.2.3 complex specializations + // complex<long double> specialization + template<> + struct complex<long double> + { + typedef long double value_type; + typedef __complex__ long double _ComplexT; + + _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } + + _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L, + long double __i = 0.0L) +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // The list-initialization extension to __complex__ types is + // not available in GCC 4.6. Thus libstdc++/48760 cannot be + // fixed in C++0x mode, unfortunately. + : _M_value(__r + __i * 1.0Li) { } +#else + { + __real__ _M_value = __r; + __imag__ _M_value = __i; + } +#endif + + _GLIBCXX_CONSTEXPR complex(const complex<float>& __z) + : _M_value(__z.__rep()) { } + + _GLIBCXX_CONSTEXPR complex(const complex<double>& __z) + : _M_value(__z.__rep()) { } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + constexpr long double + real() const { return __real__ _M_value; } + + constexpr long double + imag() const { return __imag__ _M_value; } +#else + long double& + real() { return __real__ _M_value; } + + const long double& + real() const { return __real__ _M_value; } + + long double& + imag() { return __imag__ _M_value; } + + const long double& + imag() const { return __imag__ _M_value; } +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + void + real(long double __val) { __real__ _M_value = __val; } + + void + imag(long double __val) { __imag__ _M_value = __val; } + + complex& + operator=(long double __r) + { + _M_value = __r; + return *this; + } + + complex& + operator+=(long double __r) + { + _M_value += __r; + return *this; + } + + complex& + operator-=(long double __r) + { + _M_value -= __r; + return *this; + } + + complex& + operator*=(long double __r) + { + _M_value *= __r; + return *this; + } + + complex& + operator/=(long double __r) + { + _M_value /= __r; + return *this; + } + + // The compiler knows how to do this efficiently + // complex& operator=(const complex&); + + template<typename _Tp> + complex& + operator=(const complex<_Tp>& __z) + { + __real__ _M_value = __z.real(); + __imag__ _M_value = __z.imag(); + return *this; + } + + template<typename _Tp> + complex& + operator+=(const complex<_Tp>& __z) + { + __real__ _M_value += __z.real(); + __imag__ _M_value += __z.imag(); + return *this; + } + + template<typename _Tp> + complex& + operator-=(const complex<_Tp>& __z) + { + __real__ _M_value -= __z.real(); + __imag__ _M_value -= __z.imag(); + return *this; + } + + template<typename _Tp> + complex& + operator*=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value *= __t; + return *this; + } + + template<typename _Tp> + complex& + operator/=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value /= __t; + return *this; + } + + _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; } + + private: + _ComplexT _M_value; + }; + + // These bits have to be at the end of this file, so that the + // specializations have all been defined. + inline _GLIBCXX_CONSTEXPR + complex<float>::complex(const complex<double>& __z) + : _M_value(__z.__rep()) { } + + inline _GLIBCXX_CONSTEXPR + complex<float>::complex(const complex<long double>& __z) + : _M_value(__z.__rep()) { } + + inline _GLIBCXX_CONSTEXPR + complex<double>::complex(const complex<long double>& __z) + : _M_value(__z.__rep()) { } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. + // NB: This syntax is a GNU extension. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template istream& operator>>(istream&, complex<float>&); + extern template ostream& operator<<(ostream&, const complex<float>&); + extern template istream& operator>>(istream&, complex<double>&); + extern template ostream& operator<<(ostream&, const complex<double>&); + extern template istream& operator>>(istream&, complex<long double>&); + extern template ostream& operator<<(ostream&, const complex<long double>&); + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template wistream& operator>>(wistream&, complex<float>&); + extern template wostream& operator<<(wostream&, const complex<float>&); + extern template wistream& operator>>(wistream&, complex<double>&); + extern template wostream& operator<<(wostream&, const complex<double>&); + extern template wistream& operator>>(wistream&, complex<long double>&); + extern template wostream& operator<<(wostream&, const complex<long double>&); +#endif +#endif + + // @} group complex_numbers + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // See ext/type_traits.h for the primary template. + template<typename _Tp, typename _Up> + struct __promote_2<std::complex<_Tp>, _Up> + { + public: + typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; + }; + + template<typename _Tp, typename _Up> + struct __promote_2<_Tp, std::complex<_Up> > + { + public: + typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; + }; + + template<typename _Tp, typename _Up> + struct __promote_2<std::complex<_Tp>, std::complex<_Up> > + { + public: + typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Forward declarations. + template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&); + template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&); + template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&); + + template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&); + template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&); + template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&); + // DR 595. + template<typename _Tp> _Tp fabs(const std::complex<_Tp>&); + + template<typename _Tp> + inline std::complex<_Tp> + __complex_acos(const std::complex<_Tp>& __z) + { + const std::complex<_Tp> __t = std::asin(__z); + const _Tp __pi_2 = 1.5707963267948966192313216916397514L; + return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag()); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_acos(__complex__ float __z) + { return __builtin_cacosf(__z); } + + inline __complex__ double + __complex_acos(__complex__ double __z) + { return __builtin_cacos(__z); } + + inline __complex__ long double + __complex_acos(const __complex__ long double& __z) + { return __builtin_cacosl(__z); } + + template<typename _Tp> + inline std::complex<_Tp> + acos(const std::complex<_Tp>& __z) + { return __complex_acos(__z.__rep()); } +#else + /// acos(__z) [8.1.2]. + // Effects: Behaves the same as C99 function cacos, defined + // in subclause 7.3.5.1. + template<typename _Tp> + inline std::complex<_Tp> + acos(const std::complex<_Tp>& __z) + { return __complex_acos(__z); } +#endif + + template<typename _Tp> + inline std::complex<_Tp> + __complex_asin(const std::complex<_Tp>& __z) + { + std::complex<_Tp> __t(-__z.imag(), __z.real()); + __t = std::asinh(__t); + return std::complex<_Tp>(__t.imag(), -__t.real()); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_asin(__complex__ float __z) + { return __builtin_casinf(__z); } + + inline __complex__ double + __complex_asin(__complex__ double __z) + { return __builtin_casin(__z); } + + inline __complex__ long double + __complex_asin(const __complex__ long double& __z) + { return __builtin_casinl(__z); } + + template<typename _Tp> + inline std::complex<_Tp> + asin(const std::complex<_Tp>& __z) + { return __complex_asin(__z.__rep()); } +#else + /// asin(__z) [8.1.3]. + // Effects: Behaves the same as C99 function casin, defined + // in subclause 7.3.5.2. + template<typename _Tp> + inline std::complex<_Tp> + asin(const std::complex<_Tp>& __z) + { return __complex_asin(__z); } +#endif + + template<typename _Tp> + std::complex<_Tp> + __complex_atan(const std::complex<_Tp>& __z) + { + const _Tp __r2 = __z.real() * __z.real(); + const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag(); + + _Tp __num = __z.imag() + _Tp(1.0); + _Tp __den = __z.imag() - _Tp(1.0); + + __num = __r2 + __num * __num; + __den = __r2 + __den * __den; + + return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x), + _Tp(0.25) * log(__num / __den)); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_atan(__complex__ float __z) + { return __builtin_catanf(__z); } + + inline __complex__ double + __complex_atan(__complex__ double __z) + { return __builtin_catan(__z); } + + inline __complex__ long double + __complex_atan(const __complex__ long double& __z) + { return __builtin_catanl(__z); } + + template<typename _Tp> + inline std::complex<_Tp> + atan(const std::complex<_Tp>& __z) + { return __complex_atan(__z.__rep()); } +#else + /// atan(__z) [8.1.4]. + // Effects: Behaves the same as C99 function catan, defined + // in subclause 7.3.5.3. + template<typename _Tp> + inline std::complex<_Tp> + atan(const std::complex<_Tp>& __z) + { return __complex_atan(__z); } +#endif + + template<typename _Tp> + std::complex<_Tp> + __complex_acosh(const std::complex<_Tp>& __z) + { + // Kahan's formula. + return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0))) + + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0)))); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_acosh(__complex__ float __z) + { return __builtin_cacoshf(__z); } + + inline __complex__ double + __complex_acosh(__complex__ double __z) + { return __builtin_cacosh(__z); } + + inline __complex__ long double + __complex_acosh(const __complex__ long double& __z) + { return __builtin_cacoshl(__z); } + + template<typename _Tp> + inline std::complex<_Tp> + acosh(const std::complex<_Tp>& __z) + { return __complex_acosh(__z.__rep()); } +#else + /// acosh(__z) [8.1.5]. + // Effects: Behaves the same as C99 function cacosh, defined + // in subclause 7.3.6.1. + template<typename _Tp> + inline std::complex<_Tp> + acosh(const std::complex<_Tp>& __z) + { return __complex_acosh(__z); } +#endif + + template<typename _Tp> + std::complex<_Tp> + __complex_asinh(const std::complex<_Tp>& __z) + { + std::complex<_Tp> __t((__z.real() - __z.imag()) + * (__z.real() + __z.imag()) + _Tp(1.0), + _Tp(2.0) * __z.real() * __z.imag()); + __t = std::sqrt(__t); + + return std::log(__t + __z); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_asinh(__complex__ float __z) + { return __builtin_casinhf(__z); } + + inline __complex__ double + __complex_asinh(__complex__ double __z) + { return __builtin_casinh(__z); } + + inline __complex__ long double + __complex_asinh(const __complex__ long double& __z) + { return __builtin_casinhl(__z); } + + template<typename _Tp> + inline std::complex<_Tp> + asinh(const std::complex<_Tp>& __z) + { return __complex_asinh(__z.__rep()); } +#else + /// asinh(__z) [8.1.6]. + // Effects: Behaves the same as C99 function casin, defined + // in subclause 7.3.6.2. + template<typename _Tp> + inline std::complex<_Tp> + asinh(const std::complex<_Tp>& __z) + { return __complex_asinh(__z); } +#endif + + template<typename _Tp> + std::complex<_Tp> + __complex_atanh(const std::complex<_Tp>& __z) + { + const _Tp __i2 = __z.imag() * __z.imag(); + const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real(); + + _Tp __num = _Tp(1.0) + __z.real(); + _Tp __den = _Tp(1.0) - __z.real(); + + __num = __i2 + __num * __num; + __den = __i2 + __den * __den; + + return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)), + _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x)); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_atanh(__complex__ float __z) + { return __builtin_catanhf(__z); } + + inline __complex__ double + __complex_atanh(__complex__ double __z) + { return __builtin_catanh(__z); } + + inline __complex__ long double + __complex_atanh(const __complex__ long double& __z) + { return __builtin_catanhl(__z); } + + template<typename _Tp> + inline std::complex<_Tp> + atanh(const std::complex<_Tp>& __z) + { return __complex_atanh(__z.__rep()); } +#else + /// atanh(__z) [8.1.7]. + // Effects: Behaves the same as C99 function catanh, defined + // in subclause 7.3.6.3. + template<typename _Tp> + inline std::complex<_Tp> + atanh(const std::complex<_Tp>& __z) + { return __complex_atanh(__z); } +#endif + + template<typename _Tp> + inline _Tp + /// fabs(__z) [8.1.8]. + // Effects: Behaves the same as C99 function cabs, defined + // in subclause 7.3.8.1. + fabs(const std::complex<_Tp>& __z) + { return std::abs(__z); } + + /// Additional overloads [8.1.9]. + template<typename _Tp> + inline typename __gnu_cxx::__promote<_Tp>::__type + arg(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; +#if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC) + return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L) + : __type(); +#else + return std::arg(std::complex<__type>(__x)); +#endif + } + + template<typename _Tp> + inline typename __gnu_cxx::__promote<_Tp>::__type + imag(_Tp) + { return _Tp(); } + + template<typename _Tp> + inline typename __gnu_cxx::__promote<_Tp>::__type + norm(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __type(__x) * __type(__x); + } + + template<typename _Tp> + inline typename __gnu_cxx::__promote<_Tp>::__type + real(_Tp __x) + { return __x; } + + template<typename _Tp, typename _Up> + inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type> + pow(const std::complex<_Tp>& __x, const _Up& __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return std::pow(std::complex<__type>(__x), __type(__y)); + } + + template<typename _Tp, typename _Up> + inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type> + pow(const _Tp& __x, const std::complex<_Up>& __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return std::pow(__type(__x), std::complex<__type>(__y)); + } + + template<typename _Tp, typename _Up> + inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type> + pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return std::pow(std::complex<__type>(__x), + std::complex<__type>(__y)); + } + + // Forward declarations. + // DR 781. + template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&); + + template<typename _Tp> + std::complex<_Tp> + __complex_proj(const std::complex<_Tp>& __z) + { + const _Tp __den = (__z.real() * __z.real() + + __z.imag() * __z.imag() + _Tp(1.0)); + + return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den, + (_Tp(2.0) * __z.imag()) / __den); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_proj(__complex__ float __z) + { return __builtin_cprojf(__z); } + + inline __complex__ double + __complex_proj(__complex__ double __z) + { return __builtin_cproj(__z); } + + inline __complex__ long double + __complex_proj(const __complex__ long double& __z) + { return __builtin_cprojl(__z); } + + template<typename _Tp> + inline std::complex<_Tp> + proj(const std::complex<_Tp>& __z) + { return __complex_proj(__z.__rep()); } +#else + template<typename _Tp> + inline std::complex<_Tp> + proj(const std::complex<_Tp>& __z) + { return __complex_proj(__z); } +#endif + + // DR 1137. + template<typename _Tp> + inline typename __gnu_cxx::__promote<_Tp>::__type + proj(_Tp __x) + { return __x; } + + template<typename _Tp> + inline typename __gnu_cxx::__promote<_Tp>::__type + conj(_Tp __x) + { return __x; } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif /* _GLIBCXX_COMPLEX */ diff --git a/libstdc++-v3/include/std/condition_variable b/libstdc++-v3/include/std/condition_variable new file mode 100644 index 000000000..0f75d8e44 --- /dev/null +++ b/libstdc++-v3/include/std/condition_variable @@ -0,0 +1,289 @@ +// <condition_variable> -*- C++ -*- + +// Copyright (C) 2008, 2009, 2010, 2011, 2012 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/condition_variable + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_CONDITION_VARIABLE +#define _GLIBCXX_CONDITION_VARIABLE 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <chrono> +#include <mutex> // unique_lock + +#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup condition_variables Condition Variables + * @ingroup concurrency + * + * Classes for condition_variable support. + * @{ + */ + + /// cv_status + enum class cv_status { no_timeout, timeout }; + + /// condition_variable + class condition_variable + { + typedef chrono::system_clock __clock_t; + typedef __gthread_cond_t __native_type; + __native_type _M_cond; + + public: + typedef __native_type* native_handle_type; + + condition_variable() throw (); + ~condition_variable() throw (); + + condition_variable(const condition_variable&) = delete; + condition_variable& operator=(const condition_variable&) = delete; + + void + notify_one(); + + void + notify_all(); + + void + wait(unique_lock<mutex>& __lock); + + template<typename _Predicate> + void + wait(unique_lock<mutex>& __lock, _Predicate __p) + { + while (!__p()) + wait(__lock); + } + + template<typename _Duration> + cv_status + wait_until(unique_lock<mutex>& __lock, + const chrono::time_point<__clock_t, _Duration>& __atime) + { return __wait_until_impl(__lock, __atime); } + + template<typename _Clock, typename _Duration> + cv_status + wait_until(unique_lock<mutex>& __lock, + const chrono::time_point<_Clock, _Duration>& __atime) + { + // DR 887 - Sync unknown clock to known clock. + const typename _Clock::time_point __c_entry = _Clock::now(); + const __clock_t::time_point __s_entry = __clock_t::now(); + const chrono::nanoseconds __delta = __atime - __c_entry; + const __clock_t::time_point __s_atime = __s_entry + __delta; + + return __wait_until_impl(__lock, __s_atime); + } + + template<typename _Clock, typename _Duration, typename _Predicate> + bool + wait_until(unique_lock<mutex>& __lock, + const chrono::time_point<_Clock, _Duration>& __atime, + _Predicate __p) + { + while (!__p()) + if (wait_until(__lock, __atime) == cv_status::timeout) + return __p(); + return true; + } + + template<typename _Rep, typename _Period> + cv_status + wait_for(unique_lock<mutex>& __lock, + const chrono::duration<_Rep, _Period>& __rtime) + { return wait_until(__lock, __clock_t::now() + __rtime); } + + template<typename _Rep, typename _Period, typename _Predicate> + bool + wait_for(unique_lock<mutex>& __lock, + const chrono::duration<_Rep, _Period>& __rtime, + _Predicate __p) + { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); } + + native_handle_type + native_handle() + { return &_M_cond; } + + private: + template<typename _Clock, typename _Duration> + cv_status + __wait_until_impl(unique_lock<mutex>& __lock, + const chrono::time_point<_Clock, _Duration>& __atime) + { + chrono::time_point<__clock_t, chrono::seconds> __s = + chrono::time_point_cast<chrono::seconds>(__atime); + + chrono::nanoseconds __ns = + chrono::duration_cast<chrono::nanoseconds>(__atime - __s); + + __gthread_time_t __ts = + { + static_cast<std::time_t>(__s.time_since_epoch().count()), + static_cast<long>(__ns.count()) + }; + + __gthread_cond_timedwait(&_M_cond, __lock.mutex()->native_handle(), + &__ts); + + return (_Clock::now() < __atime + ? cv_status::no_timeout : cv_status::timeout); + } + }; + + /// condition_variable_any + // Like above, but mutex is not required to have try_lock. + class condition_variable_any + { + typedef chrono::system_clock __clock_t; + condition_variable _M_cond; + mutex _M_mutex; + + // scoped unlock - unlocks in ctor, re-locks in dtor + template<typename _Lock> + struct _Unlock + { + explicit _Unlock(_Lock& __lk) : _M_lock(__lk) { __lk.unlock(); } + + ~_Unlock() noexcept(false) + { + if (uncaught_exception()) + __try { _M_lock.lock(); } __catch(...) { } + else + _M_lock.lock(); + } + + _Unlock(const _Unlock&) = delete; + _Unlock& operator=(const _Unlock&) = delete; + + _Lock& _M_lock; + }; + + public: + typedef condition_variable::native_handle_type native_handle_type; + + condition_variable_any() throw (); + ~condition_variable_any() throw (); + + condition_variable_any(const condition_variable_any&) = delete; + condition_variable_any& operator=(const condition_variable_any&) = delete; + + void + notify_one() + { + lock_guard<mutex> __lock(_M_mutex); + _M_cond.notify_one(); + } + + void + notify_all() + { + lock_guard<mutex> __lock(_M_mutex); + _M_cond.notify_all(); + } + + template<typename _Lock> + void + wait(_Lock& __lock) + { + unique_lock<mutex> __my_lock(_M_mutex); + _Unlock<_Lock> __unlock(__lock); + // _M_mutex must be unlocked before re-locking __lock so move + // ownership of _M_mutex lock to an object with shorter lifetime. + unique_lock<mutex> __my_lock2(std::move(__my_lock)); + _M_cond.wait(__my_lock2); + } + + + template<typename _Lock, typename _Predicate> + void + wait(_Lock& __lock, _Predicate __p) + { + while (!__p()) + wait(__lock); + } + + template<typename _Lock, typename _Clock, typename _Duration> + cv_status + wait_until(_Lock& __lock, + const chrono::time_point<_Clock, _Duration>& __atime) + { + unique_lock<mutex> __my_lock(_M_mutex); + _Unlock<_Lock> __unlock(__lock); + // _M_mutex must be unlocked before re-locking __lock so move + // ownership of _M_mutex lock to an object with shorter lifetime. + unique_lock<mutex> __my_lock2(std::move(__my_lock)); + return _M_cond.wait_until(__my_lock2, __atime); + } + + template<typename _Lock, typename _Clock, + typename _Duration, typename _Predicate> + bool + wait_until(_Lock& __lock, + const chrono::time_point<_Clock, _Duration>& __atime, + _Predicate __p) + { + while (!__p()) + if (wait_until(__lock, __atime) == cv_status::timeout) + return __p(); + return true; + } + + template<typename _Lock, typename _Rep, typename _Period> + cv_status + wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rtime) + { return wait_until(__lock, __clock_t::now() + __rtime); } + + template<typename _Lock, typename _Rep, + typename _Period, typename _Predicate> + bool + wait_for(_Lock& __lock, + const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p) + { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); } + + native_handle_type + native_handle() + { return _M_cond.native_handle(); } + }; + + // @} group condition_variables +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_CONDITION_VARIABLE diff --git a/libstdc++-v3/include/std/deque b/libstdc++-v3/include/std/deque new file mode 100644 index 000000000..7b0604bf9 --- /dev/null +++ b/libstdc++-v3/include/std/deque @@ -0,0 +1,77 @@ +// <deque> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * + * 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. + */ + +/** @file include/deque + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_DEQUE +#define _GLIBCXX_DEQUE 1 + +#pragma GCC system_header + +#include <bits/stl_algobase.h> +#include <bits/allocator.h> +#include <bits/stl_construct.h> +#include <bits/stl_uninitialized.h> +#include <bits/stl_deque.h> +#include <bits/range_access.h> +#include <bits/deque.tcc> + +#ifdef _GLIBCXX_DEBUG +# include <debug/deque> +#endif + +#ifdef _GLIBCXX_PROFILE +# include <profile/deque> +#endif + +#endif /* _GLIBCXX_DEQUE */ diff --git a/libstdc++-v3/include/std/forward_list b/libstdc++-v3/include/std/forward_list new file mode 100644 index 000000000..a1befcf4b --- /dev/null +++ b/libstdc++-v3/include/std/forward_list @@ -0,0 +1,52 @@ +// <forward_list> -*- C++ -*- + +// Copyright (C) 2008, 2009, 2010, 2011 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/forward_list + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_FORWARD_LIST +#define _GLIBCXX_FORWARD_LIST 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <bits/forward_list.h> +#include <bits/range_access.h> +#include <bits/forward_list.tcc> + +#ifdef _GLIBCXX_DEBUG +# include <debug/forward_list> +#endif + +#ifdef _GLIBCXX_PROFILE +# include <profile/forward_list> +#endif + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_FORWARD_LIST diff --git a/libstdc++-v3/include/std/fstream b/libstdc++-v3/include/std/fstream new file mode 100644 index 000000000..8ad6e5ca1 --- /dev/null +++ b/libstdc++-v3/include/std/fstream @@ -0,0 +1,923 @@ +// File based streams -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +// 2006, 2007, 2008, 2009, 2010, 2011 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/fstream + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 14882: 27.8 File-based streams +// + +#ifndef _GLIBCXX_FSTREAM +#define _GLIBCXX_FSTREAM 1 + +#pragma GCC system_header + +#include <istream> +#include <ostream> +#include <bits/codecvt.h> +#include <cstdio> // For BUFSIZ +#include <bits/basic_file.h> // For __basic_file, __c_lock +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include <string> // For std::string overloads. +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // [27.8.1.1] template class basic_filebuf + /** + * @brief The actual work of input and output (for files). + * @ingroup io + * + * This class associates both its input and output sequence with an + * external disk file, and maintains a joint file position for both + * sequences. Many of its semantics are described in terms of similar + * behavior in the Standard C Library's @c FILE streams. + */ + // Requirements on traits_type, specific to this class: + // traits_type::pos_type must be fpos<traits_type::state_type> + // traits_type::off_type must be streamoff + // traits_type::state_type must be Assignable and DefaultConstructible, + // and traits_type::state_type() must be the initial state for codecvt. + template<typename _CharT, typename _Traits> + class basic_filebuf : public basic_streambuf<_CharT, _Traits> + { + public: + // Types: + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + typedef basic_streambuf<char_type, traits_type> __streambuf_type; + typedef basic_filebuf<char_type, traits_type> __filebuf_type; + typedef __basic_file<char> __file_type; + typedef typename traits_type::state_type __state_type; + typedef codecvt<char_type, char, __state_type> __codecvt_type; + + friend class ios_base; // For sync_with_stdio. + + protected: + // Data Members: + // MT lock inherited from libio or other low-level io library. + __c_lock _M_lock; + + // External buffer. + __file_type _M_file; + + /// Place to stash in || out || in | out settings for current filebuf. + ios_base::openmode _M_mode; + + // Beginning state type for codecvt. + __state_type _M_state_beg; + + // During output, the state that corresponds to pptr(), + // during input, the state that corresponds to egptr() and + // _M_ext_next. + __state_type _M_state_cur; + + // Not used for output. During input, the state that corresponds + // to eback() and _M_ext_buf. + __state_type _M_state_last; + + /// Pointer to the beginning of internal buffer. + char_type* _M_buf; + + /** + * Actual size of internal buffer. This number is equal to the size + * of the put area + 1 position, reserved for the overflow char of + * a full area. + */ + size_t _M_buf_size; + + // Set iff _M_buf is allocated memory from _M_allocate_internal_buffer. + bool _M_buf_allocated; + + /** + * _M_reading == false && _M_writing == false for @b uncommitted mode; + * _M_reading == true for @b read mode; + * _M_writing == true for @b write mode; + * + * NB: _M_reading == true && _M_writing == true is unused. + */ + bool _M_reading; + bool _M_writing; + + //@{ + /** + * Necessary bits for putback buffer management. + * + * @note pbacks of over one character are not currently supported. + */ + char_type _M_pback; + char_type* _M_pback_cur_save; + char_type* _M_pback_end_save; + bool _M_pback_init; + //@} + + // Cached codecvt facet. + const __codecvt_type* _M_codecvt; + + /** + * Buffer for external characters. Used for input when + * codecvt::always_noconv() == false. When valid, this corresponds + * to eback(). + */ + char* _M_ext_buf; + + /** + * Size of buffer held by _M_ext_buf. + */ + streamsize _M_ext_buf_size; + + /** + * Pointers into the buffer held by _M_ext_buf that delimit a + * subsequence of bytes that have been read but not yet converted. + * When valid, _M_ext_next corresponds to egptr(). + */ + const char* _M_ext_next; + char* _M_ext_end; + + /** + * Initializes pback buffers, and moves normal buffers to safety. + * Assumptions: + * _M_in_cur has already been moved back + */ + void + _M_create_pback() + { + if (!_M_pback_init) + { + _M_pback_cur_save = this->gptr(); + _M_pback_end_save = this->egptr(); + this->setg(&_M_pback, &_M_pback, &_M_pback + 1); + _M_pback_init = true; + } + } + + /** + * Deactivates pback buffer contents, and restores normal buffer. + * Assumptions: + * The pback buffer has only moved forward. + */ + void + _M_destroy_pback() throw() + { + if (_M_pback_init) + { + // Length _M_in_cur moved in the pback buffer. + _M_pback_cur_save += this->gptr() != this->eback(); + this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save); + _M_pback_init = false; + } + } + + public: + // Constructors/destructor: + /** + * @brief Does not open any files. + * + * The default constructor initializes the parent class using its + * own default ctor. + */ + basic_filebuf(); + + /** + * @brief The destructor closes the file first. + */ + virtual + ~basic_filebuf() + { this->close(); } + + // Members: + /** + * @brief Returns true if the external file is open. + */ + bool + is_open() const throw() + { return _M_file.is_open(); } + + /** + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * @return @c this on success, NULL on failure + * + * If a file is already open, this function immediately fails. + * Otherwise it tries to open the file named @a s using the flags + * given in @a mode. + * + * Table 92, adapted here, gives the relation between openmode + * combinations and the equivalent fopen() flags. + * (NB: lines app, in|out|app, in|app, binary|app, binary|in|out|app, + * and binary|in|app per DR 596) + * +---------------------------------------------------------+ + * | ios_base Flag combination stdio equivalent | + * |binary in out trunc app | + * +---------------------------------------------------------+ + * | + w | + * | + + a | + * | + a | + * | + + w | + * | + r | + * | + + r+ | + * | + + + w+ | + * | + + + a+ | + * | + + a+ | + * +---------------------------------------------------------+ + * | + + wb | + * | + + + ab | + * | + + ab | + * | + + + wb | + * | + + rb | + * | + + + r+b | + * | + + + + w+b | + * | + + + + a+b | + * | + + + a+b | + * +---------------------------------------------------------+ + */ + __filebuf_type* + open(const char* __s, ios_base::openmode __mode); + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * @return @c this on success, NULL on failure + */ + __filebuf_type* + open(const std::string& __s, ios_base::openmode __mode) + { return open(__s.c_str(), __mode); } +#endif + + /** + * @brief Closes the currently associated file. + * @return @c this on success, NULL on failure + * + * If no file is currently open, this function immediately fails. + * + * If a <em>put buffer area</em> exists, @c overflow(eof) is + * called to flush all the characters. The file is then + * closed. + * + * If any operations fail, this function also fails. + */ + __filebuf_type* + close(); + + protected: + void + _M_allocate_internal_buffer(); + + void + _M_destroy_internal_buffer() throw(); + + // [27.8.1.4] overridden virtual functions + virtual streamsize + showmanyc(); + + // Stroustrup, 1998, p. 628 + // underflow() and uflow() functions are called to get the next + // character from the real input source when the buffer is empty. + // Buffered input uses underflow() + + virtual int_type + underflow(); + + virtual int_type + pbackfail(int_type __c = _Traits::eof()); + + // Stroustrup, 1998, p 648 + // The overflow() function is called to transfer characters to the + // real output destination when the buffer is full. A call to + // overflow(c) outputs the contents of the buffer plus the + // character c. + // 27.5.2.4.5 + // Consume some sequence of the characters in the pending sequence. + virtual int_type + overflow(int_type __c = _Traits::eof()); + + // Convert internal byte sequence to external, char-based + // sequence via codecvt. + bool + _M_convert_to_external(char_type*, streamsize); + + /** + * @brief Manipulates the buffer. + * @param s Pointer to a buffer area. + * @param n Size of @a s. + * @return @c this + * + * If no file has been opened, and both @a s and @a n are zero, then + * the stream becomes unbuffered. Otherwise, @c s is used as a + * buffer; see + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html + * for more. + */ + virtual __streambuf_type* + setbuf(char_type* __s, streamsize __n); + + virtual pos_type + seekoff(off_type __off, ios_base::seekdir __way, + ios_base::openmode __mode = ios_base::in | ios_base::out); + + virtual pos_type + seekpos(pos_type __pos, + ios_base::openmode __mode = ios_base::in | ios_base::out); + + // Common code for seekoff, seekpos, and overflow + pos_type + _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state); + + int + _M_get_ext_pos(__state_type &__state); + + virtual int + sync(); + + virtual void + imbue(const locale& __loc); + + virtual streamsize + xsgetn(char_type* __s, streamsize __n); + + virtual streamsize + xsputn(const char_type* __s, streamsize __n); + + // Flushes output buffer, then writes unshift sequence. + bool + _M_terminate_output(); + + /** + * This function sets the pointers of the internal buffer, both get + * and put areas. Typically: + * + * __off == egptr() - eback() upon underflow/uflow (@b read mode); + * __off == 0 upon overflow (@b write mode); + * __off == -1 upon open, setbuf, seekoff/pos (@b uncommitted mode). + * + * NB: epptr() - pbase() == _M_buf_size - 1, since _M_buf_size + * reflects the actual allocated memory and the last cell is reserved + * for the overflow char of a full put area. + */ + void + _M_set_buffer(streamsize __off) + { + const bool __testin = _M_mode & ios_base::in; + const bool __testout = _M_mode & ios_base::out; + + if (__testin && __off > 0) + this->setg(_M_buf, _M_buf, _M_buf + __off); + else + this->setg(_M_buf, _M_buf, _M_buf); + + if (__testout && __off == 0 && _M_buf_size > 1 ) + this->setp(_M_buf, _M_buf + _M_buf_size - 1); + else + this->setp(0, 0); + } + }; + + // [27.8.1.5] Template class basic_ifstream + /** + * @brief Controlling input for files. + * @ingroup io + * + * This class supports reading from named files, using the inherited + * functions from std::basic_istream. To control the associated + * sequence, an instance of std::basic_filebuf is used, which this page + * refers to as @c sb. + */ + template<typename _CharT, typename _Traits> + class basic_ifstream : public basic_istream<_CharT, _Traits> + { + public: + // Types: + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + // Non-standard types: + typedef basic_filebuf<char_type, traits_type> __filebuf_type; + typedef basic_istream<char_type, traits_type> __istream_type; + + private: + __filebuf_type _M_filebuf; + + public: + // Constructors/Destructors: + /** + * @brief Default constructor. + * + * Initializes @c sb using its default constructor, and passes + * @c &sb to the base class initializer. Does not open any files + * (you haven't given it a filename to open). + */ + basic_ifstream() : __istream_type(), _M_filebuf() + { this->init(&_M_filebuf); } + + /** + * @brief Create an input file stream. + * @param s Null terminated string specifying the filename. + * @param mode Open file in specified mode (see std::ios_base). + * + * @c ios_base::in is automatically included in @a mode. + * + * Tip: When using std::string to hold the filename, you must use + * .c_str() before passing it to this constructor. + */ + explicit + basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in) + : __istream_type(), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Create an input file stream. + * @param s std::string specifying the filename. + * @param mode Open file in specified mode (see std::ios_base). + * + * @c ios_base::in is automatically included in @a mode. + */ + explicit + basic_ifstream(const std::string& __s, + ios_base::openmode __mode = ios_base::in) + : __istream_type(), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } +#endif + + /** + * @brief The destructor does nothing. + * + * The file is closed by the filebuf object, not the formatting + * stream. + */ + ~basic_ifstream() + { } + + // Members: + /** + * @brief Accessing the underlying buffer. + * @return The current basic_filebuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). + */ + __filebuf_type* + rdbuf() const + { return const_cast<__filebuf_type*>(&_M_filebuf); } + + /** + * @brief Wrapper to test for an open file. + * @return @c rdbuf()->is_open() + */ + bool + is_open() + { return _M_filebuf.is_open(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 365. Lack of const-qualification in clause 27 + bool + is_open() const + { return _M_filebuf.is_open(); } + + /** + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * + * Calls @c std::basic_filebuf::open(s,mode|in). If that function + * fails, @c failbit is set in the stream's error state. + * + * Tip: When using std::string to hold the filename, you must use + * .c_str() before passing it to this constructor. + */ + void + open(const char* __s, ios_base::openmode __mode = ios_base::in) + { + if (!_M_filebuf.open(__s, __mode | ios_base::in)) + this->setstate(ios_base::failbit); + else + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 409. Closing an fstream should clear error state + this->clear(); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * + * Calls @c std::basic_filebuf::open(s,mode|in). If that function + * fails, @c failbit is set in the stream's error state. + */ + void + open(const std::string& __s, ios_base::openmode __mode = ios_base::in) + { + if (!_M_filebuf.open(__s, __mode | ios_base::in)) + this->setstate(ios_base::failbit); + else + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 409. Closing an fstream should clear error state + this->clear(); + } +#endif + + /** + * @brief Close the file. + * + * Calls @c std::basic_filebuf::close(). If that function + * fails, @c failbit is set in the stream's error state. + */ + void + close() + { + if (!_M_filebuf.close()) + this->setstate(ios_base::failbit); + } + }; + + + // [27.8.1.8] Template class basic_ofstream + /** + * @brief Controlling output for files. + * @ingroup io + * + * This class supports reading from named files, using the inherited + * functions from std::basic_ostream. To control the associated + * sequence, an instance of std::basic_filebuf is used, which this page + * refers to as @c sb. + */ + template<typename _CharT, typename _Traits> + class basic_ofstream : public basic_ostream<_CharT,_Traits> + { + public: + // Types: + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + // Non-standard types: + typedef basic_filebuf<char_type, traits_type> __filebuf_type; + typedef basic_ostream<char_type, traits_type> __ostream_type; + + private: + __filebuf_type _M_filebuf; + + public: + // Constructors: + /** + * @brief Default constructor. + * + * Initializes @c sb using its default constructor, and passes + * @c &sb to the base class initializer. Does not open any files + * (you haven't given it a filename to open). + */ + basic_ofstream(): __ostream_type(), _M_filebuf() + { this->init(&_M_filebuf); } + + /** + * @brief Create an output file stream. + * @param s Null terminated string specifying the filename. + * @param mode Open file in specified mode (see std::ios_base). + * + * @c ios_base::out|ios_base::trunc is automatically included in + * @a mode. + * + * Tip: When using std::string to hold the filename, you must use + * .c_str() before passing it to this constructor. + */ + explicit + basic_ofstream(const char* __s, + ios_base::openmode __mode = ios_base::out|ios_base::trunc) + : __ostream_type(), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Create an output file stream. + * @param s std::string specifying the filename. + * @param mode Open file in specified mode (see std::ios_base). + * + * @c ios_base::out|ios_base::trunc is automatically included in + * @a mode. + */ + explicit + basic_ofstream(const std::string& __s, + ios_base::openmode __mode = ios_base::out|ios_base::trunc) + : __ostream_type(), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } +#endif + + /** + * @brief The destructor does nothing. + * + * The file is closed by the filebuf object, not the formatting + * stream. + */ + ~basic_ofstream() + { } + + // Members: + /** + * @brief Accessing the underlying buffer. + * @return The current basic_filebuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). + */ + __filebuf_type* + rdbuf() const + { return const_cast<__filebuf_type*>(&_M_filebuf); } + + /** + * @brief Wrapper to test for an open file. + * @return @c rdbuf()->is_open() + */ + bool + is_open() + { return _M_filebuf.is_open(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 365. Lack of const-qualification in clause 27 + bool + is_open() const + { return _M_filebuf.is_open(); } + + /** + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * + * Calls @c std::basic_filebuf::open(s,mode|out|trunc). If that + * function fails, @c failbit is set in the stream's error state. + * + * Tip: When using std::string to hold the filename, you must use + * .c_str() before passing it to this constructor. + */ + void + open(const char* __s, + ios_base::openmode __mode = ios_base::out | ios_base::trunc) + { + if (!_M_filebuf.open(__s, __mode | ios_base::out)) + this->setstate(ios_base::failbit); + else + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 409. Closing an fstream should clear error state + this->clear(); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * + * Calls @c std::basic_filebuf::open(s,mode|out|trunc). If that + * function fails, @c failbit is set in the stream's error state. + */ + void + open(const std::string& __s, + ios_base::openmode __mode = ios_base::out | ios_base::trunc) + { + if (!_M_filebuf.open(__s, __mode | ios_base::out)) + this->setstate(ios_base::failbit); + else + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 409. Closing an fstream should clear error state + this->clear(); + } +#endif + + /** + * @brief Close the file. + * + * Calls @c std::basic_filebuf::close(). If that function + * fails, @c failbit is set in the stream's error state. + */ + void + close() + { + if (!_M_filebuf.close()) + this->setstate(ios_base::failbit); + } + }; + + + // [27.8.1.11] Template class basic_fstream + /** + * @brief Controlling input and output for files. + * @ingroup io + * + * This class supports reading from and writing to named files, using + * the inherited functions from std::basic_iostream. To control the + * associated sequence, an instance of std::basic_filebuf is used, which + * this page refers to as @c sb. + */ + template<typename _CharT, typename _Traits> + class basic_fstream : public basic_iostream<_CharT, _Traits> + { + public: + // Types: + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + // Non-standard types: + typedef basic_filebuf<char_type, traits_type> __filebuf_type; + typedef basic_ios<char_type, traits_type> __ios_type; + typedef basic_iostream<char_type, traits_type> __iostream_type; + + private: + __filebuf_type _M_filebuf; + + public: + // Constructors/destructor: + /** + * @brief Default constructor. + * + * Initializes @c sb using its default constructor, and passes + * @c &sb to the base class initializer. Does not open any files + * (you haven't given it a filename to open). + */ + basic_fstream() + : __iostream_type(), _M_filebuf() + { this->init(&_M_filebuf); } + + /** + * @brief Create an input/output file stream. + * @param s Null terminated string specifying the filename. + * @param mode Open file in specified mode (see std::ios_base). + * + * Tip: When using std::string to hold the filename, you must use + * .c_str() before passing it to this constructor. + */ + explicit + basic_fstream(const char* __s, + ios_base::openmode __mode = ios_base::in | ios_base::out) + : __iostream_type(0), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Create an input/output file stream. + * @param s Null terminated string specifying the filename. + * @param mode Open file in specified mode (see std::ios_base). + */ + explicit + basic_fstream(const std::string& __s, + ios_base::openmode __mode = ios_base::in | ios_base::out) + : __iostream_type(0), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } +#endif + + /** + * @brief The destructor does nothing. + * + * The file is closed by the filebuf object, not the formatting + * stream. + */ + ~basic_fstream() + { } + + // Members: + /** + * @brief Accessing the underlying buffer. + * @return The current basic_filebuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). + */ + __filebuf_type* + rdbuf() const + { return const_cast<__filebuf_type*>(&_M_filebuf); } + + /** + * @brief Wrapper to test for an open file. + * @return @c rdbuf()->is_open() + */ + bool + is_open() + { return _M_filebuf.is_open(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 365. Lack of const-qualification in clause 27 + bool + is_open() const + { return _M_filebuf.is_open(); } + + /** + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * + * Calls @c std::basic_filebuf::open(s,mode). If that + * function fails, @c failbit is set in the stream's error state. + * + * Tip: When using std::string to hold the filename, you must use + * .c_str() before passing it to this constructor. + */ + void + open(const char* __s, + ios_base::openmode __mode = ios_base::in | ios_base::out) + { + if (!_M_filebuf.open(__s, __mode)) + this->setstate(ios_base::failbit); + else + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 409. Closing an fstream should clear error state + this->clear(); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Opens an external file. + * @param s The name of the file. + * @param mode The open mode flags. + * + * Calls @c std::basic_filebuf::open(s,mode). If that + * function fails, @c failbit is set in the stream's error state. + */ + void + open(const std::string& __s, + ios_base::openmode __mode = ios_base::in | ios_base::out) + { + if (!_M_filebuf.open(__s, __mode)) + this->setstate(ios_base::failbit); + else + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 409. Closing an fstream should clear error state + this->clear(); + } +#endif + + /** + * @brief Close the file. + * + * Calls @c std::basic_filebuf::close(). If that function + * fails, @c failbit is set in the stream's error state. + */ + void + close() + { + if (!_M_filebuf.close()) + this->setstate(ios_base::failbit); + } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#include <bits/fstream.tcc> + +#endif /* _GLIBCXX_FSTREAM */ diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional new file mode 100644 index 000000000..45bee8112 --- /dev/null +++ b/libstdc++-v3/include/std/functional @@ -0,0 +1,2271 @@ +// <functional> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, +// 2011 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * 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. + * + */ + +/** @file include/functional + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_FUNCTIONAL +#define _GLIBCXX_FUNCTIONAL 1 + +#pragma GCC system_header + +#include <bits/c++config.h> +#include <bits/stl_function.h> + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + +#include <typeinfo> +#include <new> +#include <tuple> +#include <type_traits> +#include <bits/functexcept.h> +#include <bits/functional_hash.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +_GLIBCXX_HAS_NESTED_TYPE(result_type) + + /// If we have found a result_type, extract it. + template<bool _Has_result_type, typename _Functor> + struct _Maybe_get_result_type + { }; + + template<typename _Functor> + struct _Maybe_get_result_type<true, _Functor> + { typedef typename _Functor::result_type result_type; }; + + /** + * Base class for any function object that has a weak result type, as + * defined in 3.3/3 of TR1. + */ + template<typename _Functor> + struct _Weak_result_type_impl + : _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor> + { }; + + /// Retrieve the result type for a function type. + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(_ArgTypes...)> + { typedef _Res result_type; }; + + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(_ArgTypes......)> + { typedef _Res result_type; }; + + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(_ArgTypes...) const> + { typedef _Res result_type; }; + + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(_ArgTypes......) const> + { typedef _Res result_type; }; + + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile> + { typedef _Res result_type; }; + + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile> + { typedef _Res result_type; }; + + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile> + { typedef _Res result_type; }; + + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile> + { typedef _Res result_type; }; + + /// Retrieve the result type for a function reference. + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> + { typedef _Res result_type; }; + + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)> + { typedef _Res result_type; }; + + /// Retrieve the result type for a function pointer. + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)> + { typedef _Res result_type; }; + + template<typename _Res, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)> + { typedef _Res result_type; }; + + /// Retrieve result type for a member function pointer. + template<typename _Res, typename _Class, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)> + { typedef _Res result_type; }; + + template<typename _Res, typename _Class, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)> + { typedef _Res result_type; }; + + /// Retrieve result type for a const member function pointer. + template<typename _Res, typename _Class, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const> + { typedef _Res result_type; }; + + template<typename _Res, typename _Class, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const> + { typedef _Res result_type; }; + + /// Retrieve result type for a volatile member function pointer. + template<typename _Res, typename _Class, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile> + { typedef _Res result_type; }; + + template<typename _Res, typename _Class, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile> + { typedef _Res result_type; }; + + /// Retrieve result type for a const volatile member function pointer. + template<typename _Res, typename _Class, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) + const volatile> + { typedef _Res result_type; }; + + template<typename _Res, typename _Class, typename... _ArgTypes> + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) + const volatile> + { typedef _Res result_type; }; + + /** + * Strip top-level cv-qualifiers from the function object and let + * _Weak_result_type_impl perform the real work. + */ + template<typename _Functor> + struct _Weak_result_type + : _Weak_result_type_impl<typename remove_cv<_Functor>::type> + { }; + + /// Determines if the type _Tp derives from unary_function. + template<typename _Tp> + struct _Derives_from_unary_function : __sfinae_types + { + private: + template<typename _T1, typename _Res> + static __one __test(const volatile unary_function<_T1, _Res>*); + + // It's tempting to change "..." to const volatile void*, but + // that fails when _Tp is a function type. + static __two __test(...); + + public: + static const bool value = sizeof(__test((_Tp*)0)) == 1; + }; + + /// Determines if the type _Tp derives from binary_function. + template<typename _Tp> + struct _Derives_from_binary_function : __sfinae_types + { + private: + template<typename _T1, typename _T2, typename _Res> + static __one __test(const volatile binary_function<_T1, _T2, _Res>*); + + // It's tempting to change "..." to const volatile void*, but + // that fails when _Tp is a function type. + static __two __test(...); + + public: + static const bool value = sizeof(__test((_Tp*)0)) == 1; + }; + + /** + * Invoke a function object, which may be either a member pointer or a + * function object. The first parameter will tell which. + */ + template<typename _Functor, typename... _Args> + inline + typename enable_if< + (!is_member_pointer<_Functor>::value + && !is_function<_Functor>::value + && !is_function<typename remove_pointer<_Functor>::type>::value), + typename result_of<_Functor(_Args&&...)>::type + >::type + __invoke(_Functor& __f, _Args&&... __args) + { + return __f(std::forward<_Args>(__args)...); + } + + template<typename _Functor, typename... _Args> + inline + typename enable_if< + (is_member_pointer<_Functor>::value + && !is_function<_Functor>::value + && !is_function<typename remove_pointer<_Functor>::type>::value), + typename result_of<_Functor(_Args&&...)>::type + >::type + __invoke(_Functor& __f, _Args&&... __args) + { + return mem_fn(__f)(std::forward<_Args>(__args)...); + } + + // To pick up function references (that will become function pointers) + template<typename _Functor, typename... _Args> + inline + typename enable_if< + (is_pointer<_Functor>::value + && is_function<typename remove_pointer<_Functor>::type>::value), + typename result_of<_Functor(_Args&&...)>::type + >::type + __invoke(_Functor __f, _Args&&... __args) + { + return __f(std::forward<_Args>(__args)...); + } + + /** + * Knowing which of unary_function and binary_function _Tp derives + * from, derives from the same and ensures that reference_wrapper + * will have a weak result type. See cases below. + */ + template<bool _Unary, bool _Binary, typename _Tp> + struct _Reference_wrapper_base_impl; + + // None of the nested argument types. + template<typename _Tp> + struct _Reference_wrapper_base_impl<false, false, _Tp> + : _Weak_result_type<_Tp> + { }; + + // Nested argument_type only. + template<typename _Tp> + struct _Reference_wrapper_base_impl<true, false, _Tp> + : _Weak_result_type<_Tp> + { + typedef typename _Tp::argument_type argument_type; + }; + + // Nested first_argument_type and second_argument_type only. + template<typename _Tp> + struct _Reference_wrapper_base_impl<false, true, _Tp> + : _Weak_result_type<_Tp> + { + typedef typename _Tp::first_argument_type first_argument_type; + typedef typename _Tp::second_argument_type second_argument_type; + }; + + // All the nested argument types. + template<typename _Tp> + struct _Reference_wrapper_base_impl<true, true, _Tp> + : _Weak_result_type<_Tp> + { + typedef typename _Tp::argument_type argument_type; + typedef typename _Tp::first_argument_type first_argument_type; + typedef typename _Tp::second_argument_type second_argument_type; + }; + + _GLIBCXX_HAS_NESTED_TYPE(argument_type) + _GLIBCXX_HAS_NESTED_TYPE(first_argument_type) + _GLIBCXX_HAS_NESTED_TYPE(second_argument_type) + + /** + * Derives from unary_function or binary_function when it + * can. Specializations handle all of the easy cases. The primary + * template determines what to do with a class type, which may + * derive from both unary_function and binary_function. + */ + template<typename _Tp> + struct _Reference_wrapper_base + : _Reference_wrapper_base_impl< + __has_argument_type<_Tp>::value, + __has_first_argument_type<_Tp>::value + && __has_second_argument_type<_Tp>::value, + _Tp> + { }; + + // - a function type (unary) + template<typename _Res, typename _T1> + struct _Reference_wrapper_base<_Res(_T1)> + : unary_function<_T1, _Res> + { }; + + template<typename _Res, typename _T1> + struct _Reference_wrapper_base<_Res(_T1) const> + : unary_function<_T1, _Res> + { }; + + template<typename _Res, typename _T1> + struct _Reference_wrapper_base<_Res(_T1) volatile> + : unary_function<_T1, _Res> + { }; + + template<typename _Res, typename _T1> + struct _Reference_wrapper_base<_Res(_T1) const volatile> + : unary_function<_T1, _Res> + { }; + + // - a function type (binary) + template<typename _Res, typename _T1, typename _T2> + struct _Reference_wrapper_base<_Res(_T1, _T2)> + : binary_function<_T1, _T2, _Res> + { }; + + template<typename _Res, typename _T1, typename _T2> + struct _Reference_wrapper_base<_Res(_T1, _T2) const> + : binary_function<_T1, _T2, _Res> + { }; + + template<typename _Res, typename _T1, typename _T2> + struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> + : binary_function<_T1, _T2, _Res> + { }; + + template<typename _Res, typename _T1, typename _T2> + struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> + : binary_function<_T1, _T2, _Res> + { }; + + // - a function pointer type (unary) + template<typename _Res, typename _T1> + struct _Reference_wrapper_base<_Res(*)(_T1)> + : unary_function<_T1, _Res> + { }; + + // - a function pointer type (binary) + template<typename _Res, typename _T1, typename _T2> + struct _Reference_wrapper_base<_Res(*)(_T1, _T2)> + : binary_function<_T1, _T2, _Res> + { }; + + // - a pointer to member function type (unary, no qualifiers) + template<typename _Res, typename _T1> + struct _Reference_wrapper_base<_Res (_T1::*)()> + : unary_function<_T1*, _Res> + { }; + + // - a pointer to member function type (binary, no qualifiers) + template<typename _Res, typename _T1, typename _T2> + struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> + : binary_function<_T1*, _T2, _Res> + { }; + + // - a pointer to member function type (unary, const) + template<typename _Res, typename _T1> + struct _Reference_wrapper_base<_Res (_T1::*)() const> + : unary_function<const _T1*, _Res> + { }; + + // - a pointer to member function type (binary, const) + template<typename _Res, typename _T1, typename _T2> + struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const> + : binary_function<const _T1*, _T2, _Res> + { }; + + // - a pointer to member function type (unary, volatile) + template<typename _Res, typename _T1> + struct _Reference_wrapper_base<_Res (_T1::*)() volatile> + : unary_function<volatile _T1*, _Res> + { }; + + // - a pointer to member function type (binary, volatile) + template<typename _Res, typename _T1, typename _T2> + struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile> + : binary_function<volatile _T1*, _T2, _Res> + { }; + + // - a pointer to member function type (unary, const volatile) + template<typename _Res, typename _T1> + struct _Reference_wrapper_base<_Res (_T1::*)() const volatile> + : unary_function<const volatile _T1*, _Res> + { }; + + // - a pointer to member function type (binary, const volatile) + template<typename _Res, typename _T1, typename _T2> + struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile> + : binary_function<const volatile _T1*, _T2, _Res> + { }; + + /** + * @brief Primary class template for reference_wrapper. + * @ingroup functors + * @{ + */ + template<typename _Tp> + class reference_wrapper + : public _Reference_wrapper_base<typename remove_cv<_Tp>::type> + { + _Tp* _M_data; + + public: + typedef _Tp type; + + reference_wrapper(_Tp& __indata) + : _M_data(std::__addressof(__indata)) + { } + + reference_wrapper(_Tp&&) = delete; + + reference_wrapper(const reference_wrapper<_Tp>& __inref): + _M_data(__inref._M_data) + { } + + reference_wrapper& + operator=(const reference_wrapper<_Tp>& __inref) + { + _M_data = __inref._M_data; + return *this; + } + + operator _Tp&() const + { return this->get(); } + + _Tp& + get() const + { return *_M_data; } + + template<typename... _Args> + typename result_of<_Tp&(_Args&&...)>::type + operator()(_Args&&... __args) const + { + return __invoke(get(), std::forward<_Args>(__args)...); + } + }; + + + /// Denotes a reference should be taken to a variable. + template<typename _Tp> + inline reference_wrapper<_Tp> + ref(_Tp& __t) + { return reference_wrapper<_Tp>(__t); } + + /// Denotes a const reference should be taken to a variable. + template<typename _Tp> + inline reference_wrapper<const _Tp> + cref(const _Tp& __t) + { return reference_wrapper<const _Tp>(__t); } + + template<typename _Tp> + void ref(const _Tp&&) = delete; + + template<typename _Tp> + void cref(const _Tp&&) = delete; + + /// Partial specialization. + template<typename _Tp> + inline reference_wrapper<_Tp> + ref(reference_wrapper<_Tp> __t) + { return ref(__t.get()); } + + /// Partial specialization. + template<typename _Tp> + inline reference_wrapper<const _Tp> + cref(reference_wrapper<_Tp> __t) + { return cref(__t.get()); } + + // @} group functors + + template<typename _MemberPointer> + class _Mem_fn; + + /** + * Derives from @c unary_function or @c binary_function, or perhaps + * nothing, depending on the number of arguments provided. The + * primary template is the basis case, which derives nothing. + */ + template<typename _Res, typename... _ArgTypes> + struct _Maybe_unary_or_binary_function { }; + + /// Derives from @c unary_function, as appropriate. + template<typename _Res, typename _T1> + struct _Maybe_unary_or_binary_function<_Res, _T1> + : std::unary_function<_T1, _Res> { }; + + /// Derives from @c binary_function, as appropriate. + template<typename _Res, typename _T1, typename _T2> + struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> + : std::binary_function<_T1, _T2, _Res> { }; + + /// Implementation of @c mem_fn for member function pointers. + template<typename _Res, typename _Class, typename... _ArgTypes> + class _Mem_fn<_Res (_Class::*)(_ArgTypes...)> + : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...> + { + typedef _Res (_Class::*_Functor)(_ArgTypes...); + + template<typename _Tp> + _Res + _M_call(_Tp& __object, const volatile _Class *, + _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + + template<typename _Tp> + _Res + _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const + { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } + + public: + typedef _Res result_type; + + explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } + + // Handle objects + _Res + operator()(_Class& __object, _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + + // Handle pointers + _Res + operator()(_Class* __object, _ArgTypes... __args) const + { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } + + // Handle smart pointers, references and pointers to derived + template<typename _Tp> + _Res + operator()(_Tp& __object, _ArgTypes... __args) const + { + return _M_call(__object, &__object, + std::forward<_ArgTypes>(__args)...); + } + + private: + _Functor __pmf; + }; + + /// Implementation of @c mem_fn for const member function pointers. + template<typename _Res, typename _Class, typename... _ArgTypes> + class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const> + : public _Maybe_unary_or_binary_function<_Res, const _Class*, + _ArgTypes...> + { + typedef _Res (_Class::*_Functor)(_ArgTypes...) const; + + template<typename _Tp> + _Res + _M_call(_Tp& __object, const volatile _Class *, + _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + + template<typename _Tp> + _Res + _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const + { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } + + public: + typedef _Res result_type; + + explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } + + // Handle objects + _Res + operator()(const _Class& __object, _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + + // Handle pointers + _Res + operator()(const _Class* __object, _ArgTypes... __args) const + { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } + + // Handle smart pointers, references and pointers to derived + template<typename _Tp> + _Res operator()(_Tp& __object, _ArgTypes... __args) const + { + return _M_call(__object, &__object, + std::forward<_ArgTypes>(__args)...); + } + + private: + _Functor __pmf; + }; + + /// Implementation of @c mem_fn for volatile member function pointers. + template<typename _Res, typename _Class, typename... _ArgTypes> + class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile> + : public _Maybe_unary_or_binary_function<_Res, volatile _Class*, + _ArgTypes...> + { + typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile; + + template<typename _Tp> + _Res + _M_call(_Tp& __object, const volatile _Class *, + _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + + template<typename _Tp> + _Res + _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const + { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } + + public: + typedef _Res result_type; + + explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } + + // Handle objects + _Res + operator()(volatile _Class& __object, _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + + // Handle pointers + _Res + operator()(volatile _Class* __object, _ArgTypes... __args) const + { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } + + // Handle smart pointers, references and pointers to derived + template<typename _Tp> + _Res + operator()(_Tp& __object, _ArgTypes... __args) const + { + return _M_call(__object, &__object, + std::forward<_ArgTypes>(__args)...); + } + + private: + _Functor __pmf; + }; + + /// Implementation of @c mem_fn for const volatile member function pointers. + template<typename _Res, typename _Class, typename... _ArgTypes> + class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile> + : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, + _ArgTypes...> + { + typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile; + + template<typename _Tp> + _Res + _M_call(_Tp& __object, const volatile _Class *, + _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + + template<typename _Tp> + _Res + _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const + { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } + + public: + typedef _Res result_type; + + explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } + + // Handle objects + _Res + operator()(const volatile _Class& __object, _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + + // Handle pointers + _Res + operator()(const volatile _Class* __object, _ArgTypes... __args) const + { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } + + // Handle smart pointers, references and pointers to derived + template<typename _Tp> + _Res operator()(_Tp& __object, _ArgTypes... __args) const + { + return _M_call(__object, &__object, + std::forward<_ArgTypes>(__args)...); + } + + private: + _Functor __pmf; + }; + + + template<typename _Tp, bool> + struct _Mem_fn_const_or_non + { + typedef const _Tp& type; + }; + + template<typename _Tp> + struct _Mem_fn_const_or_non<_Tp, false> + { + typedef _Tp& type; + }; + + template<typename _Res, typename _Class> + class _Mem_fn<_Res _Class::*> + { + // This bit of genius is due to Peter Dimov, improved slightly by + // Douglas Gregor. + template<typename _Tp> + _Res& + _M_call(_Tp& __object, _Class *) const + { return __object.*__pm; } + + template<typename _Tp, typename _Up> + _Res& + _M_call(_Tp& __object, _Up * const *) const + { return (*__object).*__pm; } + + template<typename _Tp, typename _Up> + const _Res& + _M_call(_Tp& __object, const _Up * const *) const + { return (*__object).*__pm; } + + template<typename _Tp> + const _Res& + _M_call(_Tp& __object, const _Class *) const + { return __object.*__pm; } + + template<typename _Tp> + const _Res& + _M_call(_Tp& __ptr, const volatile void*) const + { return (*__ptr).*__pm; } + + template<typename _Tp> static _Tp& __get_ref(); + + template<typename _Tp> + static __sfinae_types::__one __check_const(_Tp&, _Class*); + template<typename _Tp, typename _Up> + static __sfinae_types::__one __check_const(_Tp&, _Up * const *); + template<typename _Tp, typename _Up> + static __sfinae_types::__two __check_const(_Tp&, const _Up * const *); + template<typename _Tp> + static __sfinae_types::__two __check_const(_Tp&, const _Class*); + template<typename _Tp> + static __sfinae_types::__two __check_const(_Tp&, const volatile void*); + + public: + template<typename _Tp> + struct _Result_type + : _Mem_fn_const_or_non<_Res, + (sizeof(__sfinae_types::__two) + == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))> + { }; + + template<typename _Signature> + struct result; + + template<typename _CVMem, typename _Tp> + struct result<_CVMem(_Tp)> + : public _Result_type<_Tp> { }; + + template<typename _CVMem, typename _Tp> + struct result<_CVMem(_Tp&)> + : public _Result_type<_Tp> { }; + + explicit + _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { } + + // Handle objects + _Res& + operator()(_Class& __object) const + { return __object.*__pm; } + + const _Res& + operator()(const _Class& __object) const + { return __object.*__pm; } + + // Handle pointers + _Res& + operator()(_Class* __object) const + { return __object->*__pm; } + + const _Res& + operator()(const _Class* __object) const + { return __object->*__pm; } + + // Handle smart pointers and derived + template<typename _Tp> + typename _Result_type<_Tp>::type + operator()(_Tp& __unknown) const + { return _M_call(__unknown, &__unknown); } + + private: + _Res _Class::*__pm; + }; + + /** + * @brief Returns a function object that forwards to the member + * pointer @a pm. + * @ingroup functors + */ + template<typename _Tp, typename _Class> + inline _Mem_fn<_Tp _Class::*> + mem_fn(_Tp _Class::* __pm) + { + return _Mem_fn<_Tp _Class::*>(__pm); + } + + /** + * @brief Determines if the given type _Tp is a function object + * should be treated as a subexpression when evaluating calls to + * function objects returned by bind(). [TR1 3.6.1] + * @ingroup binders + */ + template<typename _Tp> + struct is_bind_expression + : public false_type { }; + + /** + * @brief Determines if the given type _Tp is a placeholder in a + * bind() expression and, if so, which placeholder it is. [TR1 3.6.2] + * @ingroup binders + */ + template<typename _Tp> + struct is_placeholder + : public integral_constant<int, 0> + { }; + + /// The type of placeholder objects defined by libstdc++. + template<int _Num> struct _Placeholder { }; + + _GLIBCXX_END_NAMESPACE_VERSION + + /** @namespace std::placeholders + * @brief ISO C++ 0x entities sub namespace for functional. + * @ingroup binders + * + * Define a large number of placeholders. There is no way to + * simplify this with variadic templates, because we're introducing + * unique names for each. + */ + namespace placeholders + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + extern const _Placeholder<1> _1; + extern const _Placeholder<2> _2; + extern const _Placeholder<3> _3; + extern const _Placeholder<4> _4; + extern const _Placeholder<5> _5; + extern const _Placeholder<6> _6; + extern const _Placeholder<7> _7; + extern const _Placeholder<8> _8; + extern const _Placeholder<9> _9; + extern const _Placeholder<10> _10; + extern const _Placeholder<11> _11; + extern const _Placeholder<12> _12; + extern const _Placeholder<13> _13; + extern const _Placeholder<14> _14; + extern const _Placeholder<15> _15; + extern const _Placeholder<16> _16; + extern const _Placeholder<17> _17; + extern const _Placeholder<18> _18; + extern const _Placeholder<19> _19; + extern const _Placeholder<20> _20; + extern const _Placeholder<21> _21; + extern const _Placeholder<22> _22; + extern const _Placeholder<23> _23; + extern const _Placeholder<24> _24; + extern const _Placeholder<25> _25; + extern const _Placeholder<26> _26; + extern const _Placeholder<27> _27; + extern const _Placeholder<28> _28; + extern const _Placeholder<29> _29; + _GLIBCXX_END_NAMESPACE_VERSION + } + + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * Partial specialization of is_placeholder that provides the placeholder + * number for the placeholder objects defined by libstdc++. + * @ingroup binders + */ + template<int _Num> + struct is_placeholder<_Placeholder<_Num> > + : public integral_constant<int, _Num> + { }; + + /** + * Used by _Safe_tuple_element to indicate that there is no tuple + * element at this position. + */ + struct _No_tuple_element; + + /** + * Implementation helper for _Safe_tuple_element. This primary + * template handles the case where it is safe to use @c + * tuple_element. + */ + template<int __i, typename _Tuple, bool _IsSafe> + struct _Safe_tuple_element_impl + : tuple_element<__i, _Tuple> { }; + + /** + * Implementation helper for _Safe_tuple_element. This partial + * specialization handles the case where it is not safe to use @c + * tuple_element. We just return @c _No_tuple_element. + */ + template<int __i, typename _Tuple> + struct _Safe_tuple_element_impl<__i, _Tuple, false> + { + typedef _No_tuple_element type; + }; + + /** + * Like tuple_element, but returns @c _No_tuple_element when + * tuple_element would return an error. + */ + template<int __i, typename _Tuple> + struct _Safe_tuple_element + : _Safe_tuple_element_impl<__i, _Tuple, + (__i >= 0 && __i < tuple_size<_Tuple>::value)> + { }; + + /** + * Maps an argument to bind() into an actual argument to the bound + * function object [TR1 3.6.3/5]. Only the first parameter should + * be specified: the rest are used to determine among the various + * implementations. Note that, although this class is a function + * object, it isn't entirely normal because it takes only two + * parameters regardless of the number of parameters passed to the + * bind expression. The first parameter is the bound argument and + * the second parameter is a tuple containing references to the + * rest of the arguments. + */ + template<typename _Arg, + bool _IsBindExp = is_bind_expression<_Arg>::value, + bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> + class _Mu; + + /** + * If the argument is reference_wrapper<_Tp>, returns the + * underlying reference. [TR1 3.6.3/5 bullet 1] + */ + template<typename _Tp> + class _Mu<reference_wrapper<_Tp>, false, false> + { + public: + typedef _Tp& result_type; + + /* Note: This won't actually work for const volatile + * reference_wrappers, because reference_wrapper::get() is const + * but not volatile-qualified. This might be a defect in the TR. + */ + template<typename _CVRef, typename _Tuple> + result_type + operator()(_CVRef& __arg, _Tuple&) const volatile + { return __arg.get(); } + }; + + /** + * If the argument is a bind expression, we invoke the underlying + * function object with the same cv-qualifiers as we are given and + * pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2] + */ + template<typename _Arg> + class _Mu<_Arg, true, false> + { + public: + template<typename _CVArg, typename... _Args> + auto + operator()(_CVArg& __arg, + tuple<_Args...>& __tuple) const volatile + -> decltype(__arg(declval<_Args>()...)) + { + // Construct an index tuple and forward to __call + typedef typename _Build_index_tuple<sizeof...(_Args)>::__type + _Indexes; + return this->__call(__arg, __tuple, _Indexes()); + } + + private: + // Invokes the underlying function object __arg by unpacking all + // of the arguments in the tuple. + template<typename _CVArg, typename... _Args, int... _Indexes> + auto + __call(_CVArg& __arg, tuple<_Args...>& __tuple, + const _Index_tuple<_Indexes...>&) const volatile + -> decltype(__arg(declval<_Args>()...)) + { + return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...); + } + }; + + /** + * If the argument is a placeholder for the Nth argument, returns + * a reference to the Nth argument to the bind function object. + * [TR1 3.6.3/5 bullet 3] + */ + template<typename _Arg> + class _Mu<_Arg, false, true> + { + public: + template<typename _Signature> class result; + + template<typename _CVMu, typename _CVArg, typename _Tuple> + class result<_CVMu(_CVArg, _Tuple)> + { + // Add a reference, if it hasn't already been done for us. + // This allows us to be a little bit sloppy in constructing + // the tuple that we pass to result_of<...>. + typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value + - 1), _Tuple>::type + __base_type; + + public: + typedef typename add_rvalue_reference<__base_type>::type type; + }; + + template<typename _Tuple> + typename result<_Mu(_Arg, _Tuple)>::type + operator()(const volatile _Arg&, _Tuple& __tuple) const volatile + { + return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>( + ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple)); + } + }; + + /** + * If the argument is just a value, returns a reference to that + * value. The cv-qualifiers on the reference are the same as the + * cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4] + */ + template<typename _Arg> + class _Mu<_Arg, false, false> + { + public: + template<typename _Signature> struct result; + + template<typename _CVMu, typename _CVArg, typename _Tuple> + struct result<_CVMu(_CVArg, _Tuple)> + { + typedef typename add_lvalue_reference<_CVArg>::type type; + }; + + // Pick up the cv-qualifiers of the argument + template<typename _CVArg, typename _Tuple> + _CVArg&& + operator()(_CVArg&& __arg, _Tuple&) const volatile + { return std::forward<_CVArg>(__arg); } + }; + + /** + * Maps member pointers into instances of _Mem_fn but leaves all + * other function objects untouched. Used by tr1::bind(). The + * primary template handles the non--member-pointer case. + */ + template<typename _Tp> + struct _Maybe_wrap_member_pointer + { + typedef _Tp type; + + static const _Tp& + __do_wrap(const _Tp& __x) + { return __x; } + + static _Tp&& + __do_wrap(_Tp&& __x) + { return static_cast<_Tp&&>(__x); } + }; + + /** + * Maps member pointers into instances of _Mem_fn but leaves all + * other function objects untouched. Used by tr1::bind(). This + * partial specialization handles the member pointer case. + */ + template<typename _Tp, typename _Class> + struct _Maybe_wrap_member_pointer<_Tp _Class::*> + { + typedef _Mem_fn<_Tp _Class::*> type; + + static type + __do_wrap(_Tp _Class::* __pm) + { return type(__pm); } + }; + + // Specialization needed to prevent "forming reference to void" errors when + // bind<void>() is called, because argument deduction instantiates + // _Maybe_wrap_member_pointer<void> outside the immediate context where + // SFINAE applies. + template<> + struct _Maybe_wrap_member_pointer<void> + { + typedef void type; + }; + + // std::get<I> for volatile-qualified tuples + template<size_t _Ind, typename... _Tp> + inline auto + __volget(volatile tuple<_Tp...>& __tuple) + -> typename tuple_element<_Ind, tuple<_Tp...>>::type volatile& + { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); } + + // std::get<I> for const-volatile-qualified tuples + template<size_t _Ind, typename... _Tp> + inline auto + __volget(const volatile tuple<_Tp...>& __tuple) + -> typename tuple_element<_Ind, tuple<_Tp...>>::type const volatile& + { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); } + + /// Type of the function object returned from bind(). + template<typename _Signature> + struct _Bind; + + template<typename _Functor, typename... _Bound_args> + class _Bind<_Functor(_Bound_args...)> + : public _Weak_result_type<_Functor> + { + typedef _Bind __self_type; + typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type + _Bound_indexes; + + _Functor _M_f; + tuple<_Bound_args...> _M_bound_args; + + // Call unqualified + template<typename _Result, typename... _Args, int... _Indexes> + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) + { + return _M_f(_Mu<_Bound_args>() + (get<_Indexes>(_M_bound_args), __args)...); + } + + // Call as const + template<typename _Result, typename... _Args, int... _Indexes> + _Result + __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const + { + return _M_f(_Mu<_Bound_args>() + (get<_Indexes>(_M_bound_args), __args)...); + } + + // Call as volatile + template<typename _Result, typename... _Args, int... _Indexes> + _Result + __call_v(tuple<_Args...>&& __args, + _Index_tuple<_Indexes...>) volatile + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + // Call as const volatile + template<typename _Result, typename... _Args, int... _Indexes> + _Result + __call_c_v(tuple<_Args...>&& __args, + _Index_tuple<_Indexes...>) const volatile + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + public: + template<typename... _Args> + explicit _Bind(const _Functor& __f, _Args&&... __args) + : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) + { } + + template<typename... _Args> + explicit _Bind(_Functor&& __f, _Args&&... __args) + : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) + { } + + _Bind(const _Bind&) = default; + + _Bind(_Bind&& __b) + : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args)) + { } + + // Call unqualified + template<typename... _Args, typename _Result + = decltype( std::declval<_Functor>()( + _Mu<_Bound_args>()( std::declval<_Bound_args&>(), + std::declval<tuple<_Args...>&>() )... ) )> + _Result + operator()(_Args&&... __args) + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + // Call as const + template<typename... _Args, typename _Result + = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0), + typename add_const<_Functor>::type>::type>()( + _Mu<_Bound_args>()( std::declval<const _Bound_args&>(), + std::declval<tuple<_Args...>&>() )... ) )> + _Result + operator()(_Args&&... __args) const + { + return this->__call_c<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + // Call as volatile + template<typename... _Args, typename _Result + = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0), + typename add_volatile<_Functor>::type>::type>()( + _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(), + std::declval<tuple<_Args...>&>() )... ) )> + _Result + operator()(_Args&&... __args) volatile + { + return this->__call_v<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + // Call as const volatile + template<typename... _Args, typename _Result + = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0), + typename add_cv<_Functor>::type>::type>()( + _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(), + std::declval<tuple<_Args...>&>() )... ) )> + _Result + operator()(_Args&&... __args) const volatile + { + return this->__call_c_v<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + }; + + /// Type of the function object returned from bind<R>(). + template<typename _Result, typename _Signature> + struct _Bind_result; + + template<typename _Result, typename _Functor, typename... _Bound_args> + class _Bind_result<_Result, _Functor(_Bound_args...)> + { + typedef _Bind_result __self_type; + typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type + _Bound_indexes; + + _Functor _M_f; + tuple<_Bound_args...> _M_bound_args; + + // sfinae types + template<typename _Res> + struct __enable_if_void : enable_if<is_void<_Res>::value, int> { }; + template<typename _Res> + struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { }; + + // Call unqualified + template<typename _Res, typename... _Args, int... _Indexes> + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) + { + return _M_f(_Mu<_Bound_args>() + (get<_Indexes>(_M_bound_args), __args)...); + } + + // Call unqualified, return void + template<typename _Res, typename... _Args, int... _Indexes> + void + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) + { + _M_f(_Mu<_Bound_args>() + (get<_Indexes>(_M_bound_args), __args)...); + } + + // Call as const + template<typename _Res, typename... _Args, int... _Indexes> + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) const + { + return _M_f(_Mu<_Bound_args>() + (get<_Indexes>(_M_bound_args), __args)...); + } + + // Call as const, return void + template<typename _Res, typename... _Args, int... _Indexes> + void + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) const + { + _M_f(_Mu<_Bound_args>() + (get<_Indexes>(_M_bound_args), __args)...); + } + + // Call as volatile + template<typename _Res, typename... _Args, int... _Indexes> + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) volatile + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + // Call as volatile, return void + template<typename _Res, typename... _Args, int... _Indexes> + void + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) volatile + { + _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + // Call as const volatile + template<typename _Res, typename... _Args, int... _Indexes> + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) const volatile + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + // Call as const volatile, return void + template<typename _Res, typename... _Args, int... _Indexes> + void + __call(tuple<_Args...>&& __args, + _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) const volatile + { + _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } + + public: + typedef _Result result_type; + + template<typename... _Args> + explicit _Bind_result(const _Functor& __f, _Args&&... __args) + : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) + { } + + template<typename... _Args> + explicit _Bind_result(_Functor&& __f, _Args&&... __args) + : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) + { } + + _Bind_result(const _Bind_result&) = default; + + _Bind_result(_Bind_result&& __b) + : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args)) + { } + + // Call unqualified + template<typename... _Args> + result_type + operator()(_Args&&... __args) + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + // Call as const + template<typename... _Args> + result_type + operator()(_Args&&... __args) const + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + // Call as volatile + template<typename... _Args> + result_type + operator()(_Args&&... __args) volatile + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + + // Call as const volatile + template<typename... _Args> + result_type + operator()(_Args&&... __args) const volatile + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } + }; + + /** + * @brief Class template _Bind is always a bind expression. + * @ingroup binders + */ + template<typename _Signature> + struct is_bind_expression<_Bind<_Signature> > + : public true_type { }; + + /** + * @brief Class template _Bind is always a bind expression. + * @ingroup binders + */ + template<typename _Result, typename _Signature> + struct is_bind_expression<_Bind_result<_Result, _Signature> > + : public true_type { }; + + template<typename _Functor, typename... _ArgTypes> + struct _Bind_helper + { + typedef _Maybe_wrap_member_pointer<typename decay<_Functor>::type> + __maybe_type; + typedef typename __maybe_type::type __functor_type; + typedef _Bind<__functor_type(typename decay<_ArgTypes>::type...)> type; + }; + + /** + * @brief Function template for std::bind. + * @ingroup binders + */ + template<typename _Functor, typename... _ArgTypes> + inline + typename _Bind_helper<_Functor, _ArgTypes...>::type + bind(_Functor&& __f, _ArgTypes&&... __args) + { + typedef _Bind_helper<_Functor, _ArgTypes...> __helper_type; + typedef typename __helper_type::__maybe_type __maybe_type; + typedef typename __helper_type::type __result_type; + return __result_type(__maybe_type::__do_wrap(std::forward<_Functor>(__f)), + std::forward<_ArgTypes>(__args)...); + } + + template<typename _Result, typename _Functor, typename... _ArgTypes> + struct _Bindres_helper + { + typedef _Maybe_wrap_member_pointer<typename decay<_Functor>::type> + __maybe_type; + typedef typename __maybe_type::type __functor_type; + typedef _Bind_result<_Result, + __functor_type(typename decay<_ArgTypes>::type...)> + type; + }; + + /** + * @brief Function template for std::bind<R>. + * @ingroup binders + */ + template<typename _Result, typename _Functor, typename... _ArgTypes> + inline + typename _Bindres_helper<_Result, _Functor, _ArgTypes...>::type + bind(_Functor&& __f, _ArgTypes&&... __args) + { + typedef _Bindres_helper<_Result, _Functor, _ArgTypes...> __helper_type; + typedef typename __helper_type::__maybe_type __maybe_type; + typedef typename __helper_type::type __result_type; + return __result_type(__maybe_type::__do_wrap(std::forward<_Functor>(__f)), + std::forward<_ArgTypes>(__args)...); + } + + /** + * @brief Exception class thrown when class template function's + * operator() is called with an empty target. + * @ingroup exceptions + */ + class bad_function_call : public std::exception + { + public: + virtual ~bad_function_call() throw(); + }; + + /** + * Trait identifying "location-invariant" types, meaning that the + * address of the object (or any of its members) will not escape. + * Also implies a trivial copy constructor and assignment operator. + */ + template<typename _Tp> + struct __is_location_invariant + : integral_constant<bool, (is_pointer<_Tp>::value + || is_member_pointer<_Tp>::value)> + { }; + + class _Undefined_class; + + union _Nocopy_types + { + void* _M_object; + const void* _M_const_object; + void (*_M_function_pointer)(); + void (_Undefined_class::*_M_member_pointer)(); + }; + + union _Any_data + { + void* _M_access() { return &_M_pod_data[0]; } + const void* _M_access() const { return &_M_pod_data[0]; } + + template<typename _Tp> + _Tp& + _M_access() + { return *static_cast<_Tp*>(_M_access()); } + + template<typename _Tp> + const _Tp& + _M_access() const + { return *static_cast<const _Tp*>(_M_access()); } + + _Nocopy_types _M_unused; + char _M_pod_data[sizeof(_Nocopy_types)]; + }; + + enum _Manager_operation + { + __get_type_info, + __get_functor_ptr, + __clone_functor, + __destroy_functor + }; + + // Simple type wrapper that helps avoid annoying const problems + // when casting between void pointers and pointers-to-pointers. + template<typename _Tp> + struct _Simple_type_wrapper + { + _Simple_type_wrapper(_Tp __value) : __value(__value) { } + + _Tp __value; + }; + + template<typename _Tp> + struct __is_location_invariant<_Simple_type_wrapper<_Tp> > + : __is_location_invariant<_Tp> + { }; + + // Converts a reference to a function object into a callable + // function object. + template<typename _Functor> + inline _Functor& + __callable_functor(_Functor& __f) + { return __f; } + + template<typename _Member, typename _Class> + inline _Mem_fn<_Member _Class::*> + __callable_functor(_Member _Class::* &__p) + { return mem_fn(__p); } + + template<typename _Member, typename _Class> + inline _Mem_fn<_Member _Class::*> + __callable_functor(_Member _Class::* const &__p) + { return mem_fn(__p); } + + template<typename _Signature> + class function; + + /// Base class of all polymorphic function object wrappers. + class _Function_base + { + public: + static const std::size_t _M_max_size = sizeof(_Nocopy_types); + static const std::size_t _M_max_align = __alignof__(_Nocopy_types); + + template<typename _Functor> + class _Base_manager + { + protected: + static const bool __stored_locally = + (__is_location_invariant<_Functor>::value + && sizeof(_Functor) <= _M_max_size + && __alignof__(_Functor) <= _M_max_align + && (_M_max_align % __alignof__(_Functor) == 0)); + + typedef integral_constant<bool, __stored_locally> _Local_storage; + + // Retrieve a pointer to the function object + static _Functor* + _M_get_pointer(const _Any_data& __source) + { + const _Functor* __ptr = + __stored_locally? std::__addressof(__source._M_access<_Functor>()) + /* have stored a pointer */ : __source._M_access<_Functor*>(); + return const_cast<_Functor*>(__ptr); + } + + // Clone a location-invariant function object that fits within + // an _Any_data structure. + static void + _M_clone(_Any_data& __dest, const _Any_data& __source, true_type) + { + new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); + } + + // Clone a function object that is not location-invariant or + // that cannot fit into an _Any_data structure. + static void + _M_clone(_Any_data& __dest, const _Any_data& __source, false_type) + { + __dest._M_access<_Functor*>() = + new _Functor(*__source._M_access<_Functor*>()); + } + + // Destroying a location-invariant object may still require + // destruction. + static void + _M_destroy(_Any_data& __victim, true_type) + { + __victim._M_access<_Functor>().~_Functor(); + } + + // Destroying an object located on the heap. + static void + _M_destroy(_Any_data& __victim, false_type) + { + delete __victim._M_access<_Functor*>(); + } + + public: + static bool + _M_manager(_Any_data& __dest, const _Any_data& __source, + _Manager_operation __op) + { + switch (__op) + { +#ifdef __GXX_RTTI + case __get_type_info: + __dest._M_access<const type_info*>() = &typeid(_Functor); + break; +#endif + case __get_functor_ptr: + __dest._M_access<_Functor*>() = _M_get_pointer(__source); + break; + + case __clone_functor: + _M_clone(__dest, __source, _Local_storage()); + break; + + case __destroy_functor: + _M_destroy(__dest, _Local_storage()); + break; + } + return false; + } + + static void + _M_init_functor(_Any_data& __functor, _Functor&& __f) + { _M_init_functor(__functor, std::move(__f), _Local_storage()); } + + template<typename _Signature> + static bool + _M_not_empty_function(const function<_Signature>& __f) + { return static_cast<bool>(__f); } + + template<typename _Tp> + static bool + _M_not_empty_function(const _Tp*& __fp) + { return __fp; } + + template<typename _Class, typename _Tp> + static bool + _M_not_empty_function(_Tp _Class::* const& __mp) + { return __mp; } + + template<typename _Tp> + static bool + _M_not_empty_function(const _Tp&) + { return true; } + + private: + static void + _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) + { new (__functor._M_access()) _Functor(std::move(__f)); } + + static void + _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type) + { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); } + }; + + template<typename _Functor> + class _Ref_manager : public _Base_manager<_Functor*> + { + typedef _Function_base::_Base_manager<_Functor*> _Base; + + public: + static bool + _M_manager(_Any_data& __dest, const _Any_data& __source, + _Manager_operation __op) + { + switch (__op) + { +#ifdef __GXX_RTTI + case __get_type_info: + __dest._M_access<const type_info*>() = &typeid(_Functor); + break; +#endif + case __get_functor_ptr: + __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source); + return is_const<_Functor>::value; + break; + + default: + _Base::_M_manager(__dest, __source, __op); + } + return false; + } + + static void + _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f) + { + // TBD: Use address_of function instead. + _Base::_M_init_functor(__functor, &__f.get()); + } + }; + + _Function_base() : _M_manager(0) { } + + ~_Function_base() + { + if (_M_manager) + _M_manager(_M_functor, _M_functor, __destroy_functor); + } + + + bool _M_empty() const { return !_M_manager; } + + typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, + _Manager_operation); + + _Any_data _M_functor; + _Manager_type _M_manager; + }; + + template<typename _Signature, typename _Functor> + class _Function_handler; + + template<typename _Res, typename _Functor, typename... _ArgTypes> + class _Function_handler<_Res(_ArgTypes...), _Functor> + : public _Function_base::_Base_manager<_Functor> + { + typedef _Function_base::_Base_manager<_Functor> _Base; + + public: + static _Res + _M_invoke(const _Any_data& __functor, _ArgTypes... __args) + { + return (*_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); + } + }; + + template<typename _Functor, typename... _ArgTypes> + class _Function_handler<void(_ArgTypes...), _Functor> + : public _Function_base::_Base_manager<_Functor> + { + typedef _Function_base::_Base_manager<_Functor> _Base; + + public: + static void + _M_invoke(const _Any_data& __functor, _ArgTypes... __args) + { + (*_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); + } + }; + + template<typename _Res, typename _Functor, typename... _ArgTypes> + class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> > + : public _Function_base::_Ref_manager<_Functor> + { + typedef _Function_base::_Ref_manager<_Functor> _Base; + + public: + static _Res + _M_invoke(const _Any_data& __functor, _ArgTypes... __args) + { + return __callable_functor(**_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); + } + }; + + template<typename _Functor, typename... _ArgTypes> + class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> > + : public _Function_base::_Ref_manager<_Functor> + { + typedef _Function_base::_Ref_manager<_Functor> _Base; + + public: + static void + _M_invoke(const _Any_data& __functor, _ArgTypes... __args) + { + __callable_functor(**_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); + } + }; + + template<typename _Class, typename _Member, typename _Res, + typename... _ArgTypes> + class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> + : public _Function_handler<void(_ArgTypes...), _Member _Class::*> + { + typedef _Function_handler<void(_ArgTypes...), _Member _Class::*> + _Base; + + public: + static _Res + _M_invoke(const _Any_data& __functor, _ArgTypes... __args) + { + return mem_fn(_Base::_M_get_pointer(__functor)->__value)( + std::forward<_ArgTypes>(__args)...); + } + }; + + template<typename _Class, typename _Member, typename... _ArgTypes> + class _Function_handler<void(_ArgTypes...), _Member _Class::*> + : public _Function_base::_Base_manager< + _Simple_type_wrapper< _Member _Class::* > > + { + typedef _Member _Class::* _Functor; + typedef _Simple_type_wrapper<_Functor> _Wrapper; + typedef _Function_base::_Base_manager<_Wrapper> _Base; + + public: + static bool + _M_manager(_Any_data& __dest, const _Any_data& __source, + _Manager_operation __op) + { + switch (__op) + { +#ifdef __GXX_RTTI + case __get_type_info: + __dest._M_access<const type_info*>() = &typeid(_Functor); + break; +#endif + case __get_functor_ptr: + __dest._M_access<_Functor*>() = + &_Base::_M_get_pointer(__source)->__value; + break; + + default: + _Base::_M_manager(__dest, __source, __op); + } + return false; + } + + static void + _M_invoke(const _Any_data& __functor, _ArgTypes... __args) + { + mem_fn(_Base::_M_get_pointer(__functor)->__value)( + std::forward<_ArgTypes>(__args)...); + } + }; + + /** + * @brief Primary class template for std::function. + * @ingroup functors + * + * Polymorphic function wrapper. + */ + template<typename _Res, typename... _ArgTypes> + class function<_Res(_ArgTypes...)> + : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, + private _Function_base + { + typedef _Res _Signature_type(_ArgTypes...); + + struct _Useless { }; + + public: + typedef _Res result_type; + + // [3.7.2.1] construct/copy/destroy + + /** + * @brief Default construct creates an empty function call wrapper. + * @post @c !(bool)*this + */ + function() : _Function_base() { } + + /** + * @brief Creates an empty function call wrapper. + * @post @c !(bool)*this + */ + function(nullptr_t) : _Function_base() { } + + /** + * @brief %Function copy constructor. + * @param x A %function object with identical call signature. + * @post @c (bool)*this == (bool)x + * + * The newly-created %function contains a copy of the target of @a + * x (if it has one). + */ + function(const function& __x); + + /** + * @brief %Function move constructor. + * @param x A %function object rvalue with identical call signature. + * + * The newly-created %function contains the target of @a x + * (if it has one). + */ + function(function&& __x) : _Function_base() + { + __x.swap(*this); + } + + // TODO: needs allocator_arg_t + + /** + * @brief Builds a %function that targets a copy of the incoming + * function object. + * @param f A %function object that is callable with parameters of + * type @c T1, @c T2, ..., @c TN and returns a value convertible + * to @c Res. + * + * The newly-created %function object will target a copy of @a + * f. If @a f is @c reference_wrapper<F>, then this function + * object will contain a reference to the function object @c + * f.get(). If @a f is a NULL function pointer or NULL + * pointer-to-member, the newly-created object will be empty. + * + * If @a f is a non-NULL function pointer or an object of type @c + * reference_wrapper<F>, this function will not throw. + */ + template<typename _Functor> + function(_Functor __f, + typename enable_if< + !is_integral<_Functor>::value, _Useless>::type + = _Useless()); + + /** + * @brief %Function assignment operator. + * @param x A %function with identical call signature. + * @post @c (bool)*this == (bool)x + * @returns @c *this + * + * The target of @a x is copied to @c *this. If @a x has no + * target, then @c *this will be empty. + * + * If @a x targets a function pointer or a reference to a function + * object, then this operation will not throw an %exception. + */ + function& + operator=(const function& __x) + { + function(__x).swap(*this); + return *this; + } + + /** + * @brief %Function move-assignment operator. + * @param x A %function rvalue with identical call signature. + * @returns @c *this + * + * The target of @a x is moved to @c *this. If @a x has no + * target, then @c *this will be empty. + * + * If @a x targets a function pointer or a reference to a function + * object, then this operation will not throw an %exception. + */ + function& + operator=(function&& __x) + { + function(std::move(__x)).swap(*this); + return *this; + } + + /** + * @brief %Function assignment to zero. + * @post @c !(bool)*this + * @returns @c *this + * + * The target of @c *this is deallocated, leaving it empty. + */ + function& + operator=(nullptr_t) + { + if (_M_manager) + { + _M_manager(_M_functor, _M_functor, __destroy_functor); + _M_manager = 0; + _M_invoker = 0; + } + return *this; + } + + /** + * @brief %Function assignment to a new target. + * @param f A %function object that is callable with parameters of + * type @c T1, @c T2, ..., @c TN and returns a value convertible + * to @c Res. + * @return @c *this + * + * This %function object wrapper will target a copy of @a + * f. If @a f is @c reference_wrapper<F>, then this function + * object will contain a reference to the function object @c + * f.get(). If @a f is a NULL function pointer or NULL + * pointer-to-member, @c this object will be empty. + * + * If @a f is a non-NULL function pointer or an object of type @c + * reference_wrapper<F>, this function will not throw. + */ + template<typename _Functor> + typename enable_if<!is_integral<_Functor>::value, function&>::type + operator=(_Functor&& __f) + { + function(std::forward<_Functor>(__f)).swap(*this); + return *this; + } + + /// @overload + template<typename _Functor> + typename enable_if<!is_integral<_Functor>::value, function&>::type + operator=(reference_wrapper<_Functor> __f) + { + function(__f).swap(*this); + return *this; + } + + // [3.7.2.2] function modifiers + + /** + * @brief Swap the targets of two %function objects. + * @param f A %function with identical call signature. + * + * Swap the targets of @c this function object and @a f. This + * function will not throw an %exception. + */ + void swap(function& __x) + { + std::swap(_M_functor, __x._M_functor); + std::swap(_M_manager, __x._M_manager); + std::swap(_M_invoker, __x._M_invoker); + } + + // TODO: needs allocator_arg_t + /* + template<typename _Functor, typename _Alloc> + void + assign(_Functor&& __f, const _Alloc& __a) + { + function(allocator_arg, __a, + std::forward<_Functor>(__f)).swap(*this); + } + */ + + // [3.7.2.3] function capacity + + /** + * @brief Determine if the %function wrapper has a target. + * + * @return @c true when this %function object contains a target, + * or @c false when it is empty. + * + * This function will not throw an %exception. + */ + explicit operator bool() const + { return !_M_empty(); } + + // [3.7.2.4] function invocation + + /** + * @brief Invokes the function targeted by @c *this. + * @returns the result of the target. + * @throws bad_function_call when @c !(bool)*this + * + * The function call operator invokes the target function object + * stored by @c this. + */ + _Res operator()(_ArgTypes... __args) const; + +#ifdef __GXX_RTTI + // [3.7.2.5] function target access + /** + * @brief Determine the type of the target of this function object + * wrapper. + * + * @returns the type identifier of the target function object, or + * @c typeid(void) if @c !(bool)*this. + * + * This function will not throw an %exception. + */ + const type_info& target_type() const; + + /** + * @brief Access the stored target function object. + * + * @return Returns a pointer to the stored target function object, + * if @c typeid(Functor).equals(target_type()); otherwise, a NULL + * pointer. + * + * This function will not throw an %exception. + */ + template<typename _Functor> _Functor* target(); + + /// @overload + template<typename _Functor> const _Functor* target() const; +#endif + + private: + typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...); + _Invoker_type _M_invoker; + }; + + // Out-of-line member definitions. + template<typename _Res, typename... _ArgTypes> + function<_Res(_ArgTypes...)>:: + function(const function& __x) + : _Function_base() + { + if (static_cast<bool>(__x)) + { + _M_invoker = __x._M_invoker; + _M_manager = __x._M_manager; + __x._M_manager(_M_functor, __x._M_functor, __clone_functor); + } + } + + template<typename _Res, typename... _ArgTypes> + template<typename _Functor> + function<_Res(_ArgTypes...)>:: + function(_Functor __f, + typename enable_if< + !is_integral<_Functor>::value, _Useless>::type) + : _Function_base() + { + typedef _Function_handler<_Signature_type, _Functor> _My_handler; + + if (_My_handler::_M_not_empty_function(__f)) + { + _M_invoker = &_My_handler::_M_invoke; + _M_manager = &_My_handler::_M_manager; + _My_handler::_M_init_functor(_M_functor, std::move(__f)); + } + } + + template<typename _Res, typename... _ArgTypes> + _Res + function<_Res(_ArgTypes...)>:: + operator()(_ArgTypes... __args) const + { + if (_M_empty()) + __throw_bad_function_call(); + return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); + } + +#ifdef __GXX_RTTI + template<typename _Res, typename... _ArgTypes> + const type_info& + function<_Res(_ArgTypes...)>:: + target_type() const + { + if (_M_manager) + { + _Any_data __typeinfo_result; + _M_manager(__typeinfo_result, _M_functor, __get_type_info); + return *__typeinfo_result._M_access<const type_info*>(); + } + else + return typeid(void); + } + + template<typename _Res, typename... _ArgTypes> + template<typename _Functor> + _Functor* + function<_Res(_ArgTypes...)>:: + target() + { + if (typeid(_Functor) == target_type() && _M_manager) + { + _Any_data __ptr; + if (_M_manager(__ptr, _M_functor, __get_functor_ptr) + && !is_const<_Functor>::value) + return 0; + else + return __ptr._M_access<_Functor*>(); + } + else + return 0; + } + + template<typename _Res, typename... _ArgTypes> + template<typename _Functor> + const _Functor* + function<_Res(_ArgTypes...)>:: + target() const + { + if (typeid(_Functor) == target_type() && _M_manager) + { + _Any_data __ptr; + _M_manager(__ptr, _M_functor, __get_functor_ptr); + return __ptr._M_access<const _Functor*>(); + } + else + return 0; + } +#endif + + // [20.7.15.2.6] null pointer comparisons + + /** + * @brief Compares a polymorphic function object wrapper against 0 + * (the NULL pointer). + * @returns @c true if the wrapper has no target, @c false otherwise + * + * This function will not throw an %exception. + */ + template<typename _Res, typename... _Args> + inline bool + operator==(const function<_Res(_Args...)>& __f, nullptr_t) + { return !static_cast<bool>(__f); } + + /// @overload + template<typename _Res, typename... _Args> + inline bool + operator==(nullptr_t, const function<_Res(_Args...)>& __f) + { return !static_cast<bool>(__f); } + + /** + * @brief Compares a polymorphic function object wrapper against 0 + * (the NULL pointer). + * @returns @c false if the wrapper has no target, @c true otherwise + * + * This function will not throw an %exception. + */ + template<typename _Res, typename... _Args> + inline bool + operator!=(const function<_Res(_Args...)>& __f, nullptr_t) + { return static_cast<bool>(__f); } + + /// @overload + template<typename _Res, typename... _Args> + inline bool + operator!=(nullptr_t, const function<_Res(_Args...)>& __f) + { return static_cast<bool>(__f); } + + // [20.7.15.2.7] specialized algorithms + + /** + * @brief Swap the targets of two polymorphic function object wrappers. + * + * This function will not throw an %exception. + */ + template<typename _Res, typename... _Args> + inline void + swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) + { __x.swap(__y); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_FUNCTIONAL diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future new file mode 100644 index 000000000..970ce7649 --- /dev/null +++ b/libstdc++-v3/include/std/future @@ -0,0 +1,1393 @@ +// <future> -*- C++ -*- + +// Copyright (C) 2009, 2010, 2011 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/future + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_FUTURE +#define _GLIBCXX_FUTURE 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <functional> +#include <memory> +#include <mutex> +#include <thread> +#include <condition_variable> +#include <system_error> +#include <exception> +#include <atomic> +#include <bits/functexcept.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup futures Futures + * @ingroup concurrency + * + * Classes for futures support. + * @{ + */ + + /// Error code for futures + enum class future_errc + { + broken_promise, + future_already_retrieved, + promise_already_satisfied, + no_state + }; + + /// Specialization. + template<> + struct is_error_code_enum<future_errc> : public true_type { }; + + /// Points to a statically-allocated object derived from error_category. + const error_category& + future_category(); + + /// Overload for make_error_code. + inline error_code + make_error_code(future_errc __errc) + { return error_code(static_cast<int>(__errc), future_category()); } + + /// Overload for make_error_condition. + inline error_condition + make_error_condition(future_errc __errc) + { return error_condition(static_cast<int>(__errc), future_category()); } + + /** + * @brief Exception type thrown by futures. + * @ingroup exceptions + */ + class future_error : public logic_error + { + error_code _M_code; + + public: + explicit future_error(error_code __ec) + : logic_error("std::future_error"), _M_code(__ec) + { } + + virtual ~future_error() throw(); + + virtual const char* + what() const throw(); + + const error_code& + code() const throw() { return _M_code; } + }; + + // Forward declarations. + template<typename _Res> + class future; + + template<typename _Res> + class shared_future; + + template<typename _Res> + class atomic_future; + + template<typename _Signature> + class packaged_task; + + template<typename _Res> + class promise; + + /// Launch code for futures + enum class launch + { + any, + async, + sync + }; + + /// Status code for futures + enum class future_status + { + ready, + timeout, + deferred + }; + + template<typename _Fn, typename... _Args> + future<typename result_of<_Fn(_Args...)>::type> + async(launch __policy, _Fn&& __fn, _Args&&... __args); + + template<typename _FnCheck, typename _Fn, typename... _Args> + struct __async_sfinae_helper + { + typedef future<typename result_of<_Fn(_Args...)>::type> type; + }; + + template<typename _Fn, typename... _Args> + struct __async_sfinae_helper<launch, _Fn, _Args...> + { }; + + template<typename _Fn, typename... _Args> + typename + __async_sfinae_helper<typename decay<_Fn>::type, _Fn, _Args...>::type + async(_Fn&& __fn, _Args&&... __args); + +#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) \ + && defined(_GLIBCXX_ATOMIC_BUILTINS_4) + + /// Base class and enclosing scope. + struct __future_base + { + /// Base class for results. + struct _Result_base + { + exception_ptr _M_error; + + _Result_base(const _Result_base&) = delete; + _Result_base& operator=(const _Result_base&) = delete; + + // _M_destroy() allows derived classes to control deallocation + virtual void _M_destroy() = 0; + + struct _Deleter + { + void operator()(_Result_base* __fr) const { __fr->_M_destroy(); } + }; + + protected: + _Result_base(); + virtual ~_Result_base(); + }; + + /// Result. + template<typename _Res> + struct _Result : _Result_base + { + private: + typedef alignment_of<_Res> __a_of; + typedef aligned_storage<sizeof(_Res), __a_of::value> __align_storage; + typedef typename __align_storage::type __align_type; + + __align_type _M_storage; + bool _M_initialized; + + public: + _Result() : _M_initialized() { } + + ~_Result() + { + if (_M_initialized) + _M_value().~_Res(); + } + + // Return lvalue, future will add const or rvalue-reference + _Res& + _M_value() { return *static_cast<_Res*>(_M_addr()); } + + void + _M_set(const _Res& __res) + { + ::new (_M_addr()) _Res(__res); + _M_initialized = true; + } + + void + _M_set(_Res&& __res) + { + ::new (_M_addr()) _Res(std::move(__res)); + _M_initialized = true; + } + + private: + void _M_destroy() { delete this; } + + void* _M_addr() { return static_cast<void*>(&_M_storage); } + }; + + // TODO: use template alias when available + /* + template<typename _Res> + using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>; + */ + /// A unique_ptr based on the instantiating type. + template<typename _Res> + struct _Ptr + { + typedef unique_ptr<_Res, _Result_base::_Deleter> type; + }; + + /// Result_alloc. + template<typename _Res, typename _Alloc> + struct _Result_alloc : _Result<_Res>, _Alloc + { + typedef typename _Alloc::template rebind<_Result_alloc>::other + __allocator_type; + + explicit + _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a) + { } + + private: + void _M_destroy() + { + __allocator_type __a(*this); + __a.destroy(this); + __a.deallocate(this, 1); + } + }; + + template<typename _Res, typename _Allocator> + static typename _Ptr<_Result_alloc<_Res, _Allocator>>::type + _S_allocate_result(const _Allocator& __a) + { + typedef _Result_alloc<_Res, _Allocator> __result_type; + typename __result_type::__allocator_type __a2(__a); + __result_type* __p = __a2.allocate(1); + __try + { + __a2.construct(__p, __a); + } + __catch(...) + { + __a2.deallocate(__p, 1); + __throw_exception_again; + } + return typename _Ptr<__result_type>::type(__p); + } + + + /// Base class for state between a promise and one or more + /// associated futures. + class _State_base + { + typedef _Ptr<_Result_base>::type _Ptr_type; + + _Ptr_type _M_result; + mutex _M_mutex; + condition_variable _M_cond; + atomic_flag _M_retrieved; + once_flag _M_once; + + public: + _State_base() : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { } + _State_base(const _State_base&) = delete; + _State_base& operator=(const _State_base&) = delete; + virtual ~_State_base(); + + _Result_base& + wait() + { + _M_run_deferred(); + unique_lock<mutex> __lock(_M_mutex); + if (!_M_ready()) + _M_cond.wait(__lock, std::bind<bool>(&_State_base::_M_ready, this)); + return *_M_result; + } + + template<typename _Rep, typename _Period> + bool + wait_for(const chrono::duration<_Rep, _Period>& __rel) + { + unique_lock<mutex> __lock(_M_mutex); + auto __bound = std::bind<bool>(&_State_base::_M_ready, this); + return _M_ready() || _M_cond.wait_for(__lock, __rel, __bound); + } + + template<typename _Clock, typename _Duration> + bool + wait_until(const chrono::time_point<_Clock, _Duration>& __abs) + { + unique_lock<mutex> __lock(_M_mutex); + auto __bound = std::bind<bool>(&_State_base::_M_ready, this); + return _M_ready() || _M_cond.wait_until(__lock, __abs, __bound); + } + + void + _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false) + { + bool __set = __ignore_failure; + // all calls to this function are serialized, + // side-effects of invoking __res only happen once + call_once(_M_once, &_State_base::_M_do_set, this, ref(__res), + ref(__set)); + if (!__set) + __throw_future_error(int(future_errc::promise_already_satisfied)); + } + + void + _M_break_promise(_Ptr_type __res) + { + if (static_cast<bool>(__res)) + { + error_code __ec(make_error_code(future_errc::broken_promise)); + __res->_M_error = copy_exception(future_error(__ec)); + { + lock_guard<mutex> __lock(_M_mutex); + _M_result.swap(__res); + } + _M_cond.notify_all(); + } + } + + // Called when this object is passed to a future. + void + _M_set_retrieved_flag() + { + if (_M_retrieved.test_and_set()) + __throw_future_error(int(future_errc::future_already_retrieved)); + } + + template<typename _Res, typename _Arg> + struct _Setter; + + // set lvalues + template<typename _Res, typename _Arg> + struct _Setter<_Res, _Arg&> + { + // check this is only used by promise<R>::set_value(const R&) + // or promise<R>::set_value(R&) + static_assert(is_same<_Res, _Arg&>::value // promise<R&> + || is_same<const _Res, _Arg>::value, // promise<R> + "Invalid specialisation"); + + typename promise<_Res>::_Ptr_type operator()() + { + _State_base::_S_check(_M_promise->_M_future); + _M_promise->_M_storage->_M_set(_M_arg); + return std::move(_M_promise->_M_storage); + } + promise<_Res>* _M_promise; + _Arg& _M_arg; + }; + + // set rvalues + template<typename _Res> + struct _Setter<_Res, _Res&&> + { + typename promise<_Res>::_Ptr_type operator()() + { + _State_base::_S_check(_M_promise->_M_future); + _M_promise->_M_storage->_M_set(std::move(_M_arg)); + return std::move(_M_promise->_M_storage); + } + promise<_Res>* _M_promise; + _Res& _M_arg; + }; + + struct __exception_ptr_tag { }; + + // set exceptions + template<typename _Res> + struct _Setter<_Res, __exception_ptr_tag> + { + typename promise<_Res>::_Ptr_type operator()() + { + _State_base::_S_check(_M_promise->_M_future); + _M_promise->_M_storage->_M_error = _M_ex; + return std::move(_M_promise->_M_storage); + } + + promise<_Res>* _M_promise; + exception_ptr& _M_ex; + }; + + template<typename _Res, typename _Arg> + static _Setter<_Res, _Arg&&> + __setter(promise<_Res>* __prom, _Arg&& __arg) + { + return _Setter<_Res, _Arg&&>{ __prom, __arg }; + } + + template<typename _Res> + static _Setter<_Res, __exception_ptr_tag> + __setter(exception_ptr& __ex, promise<_Res>* __prom) + { + return _Setter<_Res, __exception_ptr_tag>{ __prom, __ex }; + } + + static _Setter<void, void> + __setter(promise<void>* __prom); + + template<typename _Tp> + static bool + _S_check(const shared_ptr<_Tp>& __p) + { + if (!static_cast<bool>(__p)) + __throw_future_error((int)future_errc::no_state); + } + + private: + void + _M_do_set(function<_Ptr_type()>& __f, bool& __set) + { + _Ptr_type __res = __f(); + { + lock_guard<mutex> __lock(_M_mutex); + _M_result.swap(__res); + } + _M_cond.notify_all(); + __set = true; + } + + bool _M_ready() const { return static_cast<bool>(_M_result); } + + virtual void _M_run_deferred() { } + }; + + template<typename _Res> + class _Deferred_state; + + template<typename _Res> + class _Async_state; + + template<typename _Signature> + class _Task_state; + + template<typename _StateT, typename _Res = typename _StateT::_Res_type> + struct _Task_setter; + }; + + /// Partial specialization for reference types. + template<typename _Res> + struct __future_base::_Result<_Res&> : __future_base::_Result_base + { + _Result() : _M_value_ptr() { } + + void _M_set(_Res& __res) { _M_value_ptr = &__res; } + + _Res& _M_get() { return *_M_value_ptr; } + + private: + _Res* _M_value_ptr; + + void _M_destroy() { delete this; } + }; + + /// Explicit specialization for void. + template<> + struct __future_base::_Result<void> : __future_base::_Result_base + { + private: + void _M_destroy() { delete this; } + }; + + + /// Common implementation for future and shared_future. + template<typename _Res> + class __basic_future : public __future_base + { + protected: + typedef shared_ptr<_State_base> __state_type; + typedef __future_base::_Result<_Res>& __result_type; + + private: + __state_type _M_state; + + public: + // Disable copying. + __basic_future(const __basic_future&) = delete; + __basic_future& operator=(const __basic_future&) = delete; + + bool + valid() const { return static_cast<bool>(_M_state); } + + void + wait() const + { + _State_base::_S_check(_M_state); + _M_state->wait(); + } + + template<typename _Rep, typename _Period> + bool + wait_for(const chrono::duration<_Rep, _Period>& __rel) const + { + _State_base::_S_check(_M_state); + return _M_state->wait_for(__rel); + } + + template<typename _Clock, typename _Duration> + bool + wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const + { + _State_base::_S_check(_M_state); + return _M_state->wait_until(__abs); + } + + protected: + /// Wait for the state to be ready and rethrow any stored exception + __result_type + _M_get_result() + { + _State_base::_S_check(_M_state); + _Result_base& __res = _M_state->wait(); + if (!(__res._M_error == 0)) + rethrow_exception(__res._M_error); + return static_cast<__result_type>(__res); + } + + void _M_swap(__basic_future& __that) + { + _M_state.swap(__that._M_state); + } + + // Construction of a future by promise::get_future() + explicit + __basic_future(const __state_type& __state) : _M_state(__state) + { + _State_base::_S_check(_M_state); + _M_state->_M_set_retrieved_flag(); + } + + // Copy construction from a shared_future + explicit + __basic_future(const shared_future<_Res>&); + + // Move construction from a shared_future + explicit + __basic_future(shared_future<_Res>&&); + + // Move construction from a future + explicit + __basic_future(future<_Res>&&); + + constexpr __basic_future() : _M_state() { } + + struct _Reset + { + explicit _Reset(__basic_future& __fut) : _M_fut(__fut) { } + ~_Reset() { _M_fut._M_state.reset(); } + __basic_future& _M_fut; + }; + }; + + + /// Primary template for future. + template<typename _Res> + class future : public __basic_future<_Res> + { + friend class promise<_Res>; + template<typename> friend class packaged_task; + template<typename _Fn, typename... _Args> + friend future<typename result_of<_Fn(_Args...)>::type> + async(launch, _Fn&&, _Args&&...); + + typedef __basic_future<_Res> _Base_type; + typedef typename _Base_type::__state_type __state_type; + + explicit + future(const __state_type& __state) : _Base_type(__state) { } + + public: + constexpr future() : _Base_type() { } + + /// Move constructor + future(future&& __uf) : _Base_type(std::move(__uf)) { } + + // Disable copying + future(const future&) = delete; + future& operator=(const future&) = delete; + + future& operator=(future&& __fut) + { + future(std::move(__fut))._M_swap(*this); + return *this; + } + + /// Retrieving the value + _Res + get() + { + typename _Base_type::_Reset __reset(*this); + return std::move(this->_M_get_result()._M_value()); + } + }; + + /// Partial specialization for future<R&> + template<typename _Res> + class future<_Res&> : public __basic_future<_Res&> + { + friend class promise<_Res&>; + template<typename> friend class packaged_task; + template<typename _Fn, typename... _Args> + friend future<typename result_of<_Fn(_Args...)>::type> + async(launch, _Fn&&, _Args&&...); + + typedef __basic_future<_Res&> _Base_type; + typedef typename _Base_type::__state_type __state_type; + + explicit + future(const __state_type& __state) : _Base_type(__state) { } + + public: + constexpr future() : _Base_type() { } + + /// Move constructor + future(future&& __uf) : _Base_type(std::move(__uf)) { } + + // Disable copying + future(const future&) = delete; + future& operator=(const future&) = delete; + + future& operator=(future&& __fut) + { + future(std::move(__fut))._M_swap(*this); + return *this; + } + + /// Retrieving the value + _Res& + get() + { + typename _Base_type::_Reset __reset(*this); + return this->_M_get_result()._M_get(); + } + }; + + /// Explicit specialization for future<void> + template<> + class future<void> : public __basic_future<void> + { + friend class promise<void>; + template<typename> friend class packaged_task; + template<typename _Fn, typename... _Args> + friend future<typename result_of<_Fn(_Args...)>::type> + async(launch, _Fn&&, _Args&&...); + + typedef __basic_future<void> _Base_type; + typedef typename _Base_type::__state_type __state_type; + + explicit + future(const __state_type& __state) : _Base_type(__state) { } + + public: + constexpr future() : _Base_type() { } + + /// Move constructor + future(future&& __uf) : _Base_type(std::move(__uf)) { } + + // Disable copying + future(const future&) = delete; + future& operator=(const future&) = delete; + + future& operator=(future&& __fut) + { + future(std::move(__fut))._M_swap(*this); + return *this; + } + + /// Retrieving the value + void + get() + { + typename _Base_type::_Reset __reset(*this); + this->_M_get_result(); + } + }; + + + /// Primary template for shared_future. + template<typename _Res> + class shared_future : public __basic_future<_Res> + { + typedef __basic_future<_Res> _Base_type; + + public: + constexpr shared_future() : _Base_type() { } + + /// Copy constructor + shared_future(const shared_future& __sf) : _Base_type(__sf) { } + + /// Construct from a future rvalue + shared_future(future<_Res>&& __uf) + : _Base_type(std::move(__uf)) + { } + + /// Construct from a shared_future rvalue + shared_future(shared_future&& __sf) + : _Base_type(std::move(__sf)) + { } + + shared_future& operator=(const shared_future& __sf) + { + shared_future(__sf)._M_swap(*this); + return *this; + } + + shared_future& operator=(shared_future&& __sf) + { + shared_future(std::move(__sf))._M_swap(*this); + return *this; + } + + /// Retrieving the value + const _Res& + get() + { + typename _Base_type::__result_type __r = this->_M_get_result(); + _Res& __rs(__r._M_value()); + return __rs; + } + }; + + /// Partial specialization for shared_future<R&> + template<typename _Res> + class shared_future<_Res&> : public __basic_future<_Res&> + { + typedef __basic_future<_Res&> _Base_type; + + public: + constexpr shared_future() : _Base_type() { } + + /// Copy constructor + shared_future(const shared_future& __sf) : _Base_type(__sf) { } + + /// Construct from a future rvalue + shared_future(future<_Res&>&& __uf) + : _Base_type(std::move(__uf)) + { } + + /// Construct from a shared_future rvalue + shared_future(shared_future&& __sf) + : _Base_type(std::move(__sf)) + { } + + shared_future& operator=(const shared_future& __sf) + { + shared_future(__sf)._M_swap(*this); + return *this; + } + + shared_future& operator=(shared_future&& __sf) + { + shared_future(std::move(__sf))._M_swap(*this); + return *this; + } + + /// Retrieving the value + _Res& + get() { return this->_M_get_result()._M_get(); } + }; + + /// Explicit specialization for shared_future<void> + template<> + class shared_future<void> : public __basic_future<void> + { + typedef __basic_future<void> _Base_type; + + public: + constexpr shared_future() : _Base_type() { } + + /// Copy constructor + shared_future(const shared_future& __sf) : _Base_type(__sf) { } + + /// Construct from a future rvalue + shared_future(future<void>&& __uf) + : _Base_type(std::move(__uf)) + { } + + /// Construct from a shared_future rvalue + shared_future(shared_future&& __sf) + : _Base_type(std::move(__sf)) + { } + + shared_future& operator=(const shared_future& __sf) + { + shared_future(__sf)._M_swap(*this); + return *this; + } + + shared_future& operator=(shared_future&& __sf) + { + shared_future(std::move(__sf))._M_swap(*this); + return *this; + } + + // Retrieving the value + void + get() { this->_M_get_result(); } + }; + + // Now we can define the protected __basic_future constructors. + template<typename _Res> + inline __basic_future<_Res>:: + __basic_future(const shared_future<_Res>& __sf) + : _M_state(__sf._M_state) + { } + + template<typename _Res> + inline __basic_future<_Res>:: + __basic_future(shared_future<_Res>&& __sf) + : _M_state(std::move(__sf._M_state)) + { } + + template<typename _Res> + inline __basic_future<_Res>:: + __basic_future(future<_Res>&& __uf) + : _M_state(std::move(__uf._M_state)) + { } + + + /// Primary template for promise + template<typename _Res> + class promise + { + typedef __future_base::_State_base _State; + typedef __future_base::_Result<_Res> _Res_type; + typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; + template<typename, typename> friend class _State::_Setter; + + shared_ptr<_State> _M_future; + _Ptr_type _M_storage; + + public: + promise() + : _M_future(std::make_shared<_State>()), + _M_storage(new _Res_type()) + { } + + promise(promise&& __rhs) + : _M_future(std::move(__rhs._M_future)), + _M_storage(std::move(__rhs._M_storage)) + { } + + template<typename _Allocator> + promise(allocator_arg_t, const _Allocator& __a) + : _M_future(std::allocate_shared<_State>(__a)), + _M_storage(__future_base::_S_allocate_result<_Res>(__a)) + { } + + promise(const promise&) = delete; + + ~promise() + { + if (static_cast<bool>(_M_future) && !_M_future.unique()) + _M_future->_M_break_promise(std::move(_M_storage)); + } + + // Assignment + promise& + operator=(promise&& __rhs) + { + promise(std::move(__rhs)).swap(*this); + return *this; + } + + promise& operator=(const promise&) = delete; + + void + swap(promise& __rhs) + { + _M_future.swap(__rhs._M_future); + _M_storage.swap(__rhs._M_storage); + } + + // Retrieving the result + future<_Res> + get_future() + { return future<_Res>(_M_future); } + + // Setting the result + void + set_value(const _Res& __r) + { + auto __setter = _State::__setter(this, __r); + _M_future->_M_set_result(std::move(__setter)); + } + + void + set_value(_Res&& __r) + { + auto __setter = _State::__setter(this, std::move(__r)); + _M_future->_M_set_result(std::move(__setter)); + } + + void + set_exception(exception_ptr __p) + { + auto __setter = _State::__setter(__p, this); + _M_future->_M_set_result(std::move(__setter)); + } + }; + + template<typename _Res> + inline void + swap(promise<_Res>& __x, promise<_Res>& __y) + { __x.swap(__y); } + + template<typename _Res, typename _Alloc> + struct uses_allocator<promise<_Res>, _Alloc> + : public true_type { }; + + + /// Partial specialization for promise<R&> + template<typename _Res> + class promise<_Res&> + { + typedef __future_base::_State_base _State; + typedef __future_base::_Result<_Res&> _Res_type; + typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; + template<typename, typename> friend class _State::_Setter; + + shared_ptr<_State> _M_future; + _Ptr_type _M_storage; + + public: + promise() + : _M_future(std::make_shared<_State>()), + _M_storage(new _Res_type()) + { } + + promise(promise&& __rhs) + : _M_future(std::move(__rhs._M_future)), + _M_storage(std::move(__rhs._M_storage)) + { } + + template<typename _Allocator> + promise(allocator_arg_t, const _Allocator& __a) + : _M_future(std::allocate_shared<_State>(__a)), + _M_storage(__future_base::_S_allocate_result<_Res&>(__a)) + { } + + promise(const promise&) = delete; + + ~promise() + { + if (static_cast<bool>(_M_future) && !_M_future.unique()) + _M_future->_M_break_promise(std::move(_M_storage)); + } + + // Assignment + promise& + operator=(promise&& __rhs) + { + promise(std::move(__rhs)).swap(*this); + return *this; + } + + promise& operator=(const promise&) = delete; + + void + swap(promise& __rhs) + { + _M_future.swap(__rhs._M_future); + _M_storage.swap(__rhs._M_storage); + } + + // Retrieving the result + future<_Res&> + get_future() + { return future<_Res&>(_M_future); } + + // Setting the result + void + set_value(_Res& __r) + { + auto __setter = _State::__setter(this, __r); + _M_future->_M_set_result(std::move(__setter)); + } + + void + set_exception(exception_ptr __p) + { + auto __setter = _State::__setter(__p, this); + _M_future->_M_set_result(std::move(__setter)); + } + }; + + /// Explicit specialization for promise<void> + template<> + class promise<void> + { + typedef __future_base::_State_base _State; + typedef __future_base::_Result<void> _Res_type; + typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; + template<typename, typename> friend class _State::_Setter; + + shared_ptr<_State> _M_future; + _Ptr_type _M_storage; + + public: + promise() + : _M_future(std::make_shared<_State>()), + _M_storage(new _Res_type()) + { } + + promise(promise&& __rhs) + : _M_future(std::move(__rhs._M_future)), + _M_storage(std::move(__rhs._M_storage)) + { } + + template<typename _Allocator> + promise(allocator_arg_t, const _Allocator& __a) + : _M_future(std::allocate_shared<_State>(__a)), + _M_storage(__future_base::_S_allocate_result<void>(__a)) + { } + + promise(const promise&) = delete; + + ~promise() + { + if (static_cast<bool>(_M_future) && !_M_future.unique()) + _M_future->_M_break_promise(std::move(_M_storage)); + } + + // Assignment + promise& + operator=(promise&& __rhs) + { + promise(std::move(__rhs)).swap(*this); + return *this; + } + + promise& operator=(const promise&) = delete; + + void + swap(promise& __rhs) + { + _M_future.swap(__rhs._M_future); + _M_storage.swap(__rhs._M_storage); + } + + // Retrieving the result + future<void> + get_future() + { return future<void>(_M_future); } + + // Setting the result + void set_value(); + + void + set_exception(exception_ptr __p) + { + auto __setter = _State::__setter(__p, this); + _M_future->_M_set_result(std::move(__setter)); + } + }; + + // set void + template<> + struct __future_base::_State_base::_Setter<void, void> + { + promise<void>::_Ptr_type operator()() + { + _State_base::_S_check(_M_promise->_M_future); + return std::move(_M_promise->_M_storage); + } + + promise<void>* _M_promise; + }; + + inline __future_base::_State_base::_Setter<void, void> + __future_base::_State_base::__setter(promise<void>* __prom) + { + return _Setter<void, void>{ __prom }; + } + + inline void + promise<void>::set_value() + { + auto __setter = _State::__setter(this); + _M_future->_M_set_result(std::move(__setter)); + } + + + template<typename _StateT, typename _Res> + struct __future_base::_Task_setter + { + typename _StateT::_Ptr_type operator()() + { + __try + { + _M_state->_M_result->_M_set(_M_fn()); + } + __catch(...) + { + _M_state->_M_result->_M_error = current_exception(); + } + return std::move(_M_state->_M_result); + } + _StateT* _M_state; + std::function<_Res()> _M_fn; + }; + + template<typename _StateT> + struct __future_base::_Task_setter<_StateT, void> + { + typename _StateT::_Ptr_type operator()() + { + __try + { + _M_fn(); + } + __catch(...) + { + _M_state->_M_result->_M_error = current_exception(); + } + return std::move(_M_state->_M_result); + } + _StateT* _M_state; + std::function<void()> _M_fn; + }; + + template<typename _Res, typename... _Args> + struct __future_base::_Task_state<_Res(_Args...)> + : __future_base::_State_base + { + typedef _Res _Res_type; + + _Task_state(std::function<_Res(_Args...)> __task) + : _M_result(new _Result<_Res>()), _M_task(std::move(__task)) + { } + + template<typename _Func, typename _Alloc> + _Task_state(_Func&& __task, const _Alloc& __a) + : _M_result(_S_allocate_result<_Res>(__a)), + _M_task(allocator_arg, __a, std::move(__task)) + { } + + void + _M_run(_Args... __args) + { + // bound arguments decay so wrap lvalue references + auto __bound = std::bind<_Res>(std::ref(_M_task), + _S_maybe_wrap_ref(std::forward<_Args>(__args))...); + _Task_setter<_Task_state> __setter{ this, std::move(__bound) }; + _M_set_result(std::move(__setter)); + } + + template<typename, typename> friend class _Task_setter; + typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type; + _Ptr_type _M_result; + std::function<_Res(_Args...)> _M_task; + + template<typename _Tp> + static reference_wrapper<_Tp> + _S_maybe_wrap_ref(_Tp& __t) + { return std::ref(__t); } + + template<typename _Tp> + static typename enable_if<!is_lvalue_reference<_Tp>::value, + _Tp>::type&& + _S_maybe_wrap_ref(_Tp&& __t) + { return std::forward<_Tp>(__t); } + }; + + /// packaged_task + template<typename _Res, typename... _ArgTypes> + class packaged_task<_Res(_ArgTypes...)> + { + typedef __future_base::_Task_state<_Res(_ArgTypes...)> _State_type; + shared_ptr<_State_type> _M_state; + + public: + typedef _Res result_type; + + // Construction and destruction + packaged_task() { } + + template<typename _Fn> + explicit + packaged_task(const _Fn& __fn) + : _M_state(std::make_shared<_State_type>(__fn)) + { } + + template<typename _Fn> + explicit + packaged_task(_Fn&& __fn) + : _M_state(std::make_shared<_State_type>(std::move(__fn))) + { } + + explicit + packaged_task(_Res(*__fn)(_ArgTypes...)) + : _M_state(std::make_shared<_State_type>(__fn)) + { } + + template<typename _Fn, typename _Allocator> + explicit + packaged_task(allocator_arg_t __tag, const _Allocator& __a, _Fn __fn) + : _M_state(std::allocate_shared<_State_type>(__a, std::move(__fn))) + { } + + ~packaged_task() + { + if (static_cast<bool>(_M_state) && !_M_state.unique()) + _M_state->_M_break_promise(std::move(_M_state->_M_result)); + } + + // No copy + packaged_task(packaged_task&) = delete; + packaged_task& operator=(packaged_task&) = delete; + + // Move support + packaged_task(packaged_task&& __other) + { this->swap(__other); } + + packaged_task& operator=(packaged_task&& __other) + { + packaged_task(std::move(__other)).swap(*this); + return *this; + } + + void + swap(packaged_task& __other) + { _M_state.swap(__other._M_state); } + + bool + valid() const + { return static_cast<bool>(_M_state); } + + // Result retrieval + future<_Res> + get_future() + { return future<_Res>(_M_state); } + + // Execution + void + operator()(_ArgTypes... __args) + { + __future_base::_State_base::_S_check(_M_state); + _M_state->_M_run(std::forward<_ArgTypes>(__args)...); + } + + void + reset() + { + __future_base::_State_base::_S_check(_M_state); + packaged_task(std::move(_M_state->_M_task)).swap(*this); + } + }; + + /// swap + template<typename _Res, typename... _ArgTypes> + inline void + swap(packaged_task<_Res(_ArgTypes...)>& __x, + packaged_task<_Res(_ArgTypes...)>& __y) + { __x.swap(__y); } + + template<typename _Res, typename _Alloc> + struct uses_allocator<packaged_task<_Res>, _Alloc> + : public true_type { }; + + + template<typename _Res> + class __future_base::_Deferred_state : public __future_base::_State_base + { + public: + typedef _Res _Res_type; + + explicit + _Deferred_state(std::function<_Res()>&& __fn) + : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)) + { } + + private: + template<typename, typename> friend class _Task_setter; + typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type; + _Ptr_type _M_result; + std::function<_Res()> _M_fn; + + virtual void + _M_run_deferred() + { + _Task_setter<_Deferred_state> __setter{ this, _M_fn }; + // safe to call multiple times so ignore failure + _M_set_result(std::move(__setter), true); + } + }; + + template<typename _Res> + class __future_base::_Async_state : public __future_base::_State_base + { + public: + typedef _Res _Res_type; + + explicit + _Async_state(std::function<_Res()>&& __fn) + : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)), + _M_thread(mem_fn(&_Async_state::_M_do_run), this) + { } + + ~_Async_state() { _M_thread.join(); } + + private: + void _M_do_run() + { + _Task_setter<_Async_state> __setter{ this, std::move(_M_fn) }; + _M_set_result(std::move(__setter)); + } + + template<typename, typename> friend class _Task_setter; + typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type; + _Ptr_type _M_result; + std::function<_Res()> _M_fn; + thread _M_thread; + }; + + /// async + template<typename _Fn, typename... _Args> + future<typename result_of<_Fn(_Args...)>::type> + async(launch __policy, _Fn&& __fn, _Args&&... __args) + { + typedef typename result_of<_Fn(_Args...)>::type result_type; + std::shared_ptr<__future_base::_State_base> __state; + if (__policy == launch::async) + { + typedef typename __future_base::_Async_state<result_type> _State; + __state = std::make_shared<_State>(std::bind<result_type>( + std::forward<_Fn>(__fn), std::forward<_Args>(__args)...)); + } + else + { + typedef typename __future_base::_Deferred_state<result_type> _State; + __state = std::make_shared<_State>(std::bind<result_type>( + std::forward<_Fn>(__fn), std::forward<_Args>(__args)...)); + } + return future<result_type>(__state); + } + + /// async, potential overload + template<typename _Fn, typename... _Args> + inline typename + __async_sfinae_helper<typename decay<_Fn>::type, _Fn, _Args...>::type + async(_Fn&& __fn, _Args&&... __args) + { + return async(launch::any, std::forward<_Fn>(__fn), + std::forward<_Args>(__args)...); + } + +#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 + // && _GLIBCXX_ATOMIC_BUILTINS_4 + + // @} group futures +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_FUTURE diff --git a/libstdc++-v3/include/std/iomanip b/libstdc++-v3/include/std/iomanip new file mode 100644 index 000000000..91f90e5cb --- /dev/null +++ b/libstdc++-v3/include/std/iomanip @@ -0,0 +1,352 @@ +// Standard stream manipulators -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 +// 2006, 2007, 2008, 2009, 2010 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/iomanip + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 14882: 27.6.3 Standard manipulators +// + +#ifndef _GLIBCXX_IOMANIP +#define _GLIBCXX_IOMANIP 1 + +#pragma GCC system_header + +#include <bits/c++config.h> +#include <iosfwd> +#include <bits/ios_base.h> + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include <locale> +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // [27.6.3] standard manipulators + // Also see DR 183. + + struct _Resetiosflags { ios_base::fmtflags _M_mask; }; + + /** + * @brief Manipulator for @c setf. + * @param mask A format flags mask. + * + * Sent to a stream object, this manipulator resets the specified flags, + * via @e stream.setf(0,mask). + */ + inline _Resetiosflags + resetiosflags(ios_base::fmtflags __mask) + { return { __mask }; } + + template<typename _CharT, typename _Traits> + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f) + { + __is.setf(ios_base::fmtflags(0), __f._M_mask); + return __is; + } + + template<typename _CharT, typename _Traits> + inline 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; }; + + /** + * @brief Manipulator for @c setf. + * @param mask A format flags mask. + * + * Sent to a stream object, this manipulator sets the format flags + * to @a mask. + */ + inline _Setiosflags + setiosflags(ios_base::fmtflags __mask) + { return { __mask }; } + + template<typename _CharT, typename _Traits> + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f) + { + __is.setf(__f._M_mask); + return __is; + } + + template<typename _CharT, typename _Traits> + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f) + { + __os.setf(__f._M_mask); + return __os; + } + + + struct _Setbase { int _M_base; }; + + /** + * @brief Manipulator for @c setf. + * @param base A numeric base. + * + * Sent to a stream object, this manipulator changes the + * @c ios_base::basefield flags to @c oct, @c dec, or @c hex when @a base + * is 8, 10, or 16, accordingly, and to 0 if @a base is any other value. + */ + inline _Setbase + setbase(int __base) + { return { __base }; } + + template<typename _CharT, typename _Traits> + inline 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<typename _CharT, typename _Traits> + inline 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<typename _CharT> + struct _Setfill { _CharT _M_c; }; + + /** + * @brief Manipulator for @c fill. + * @param c The new fill character. + * + * Sent to a stream object, this manipulator calls @c fill(c) for that + * object. + */ + template<typename _CharT> + inline _Setfill<_CharT> + setfill(_CharT __c) + { return { __c }; } + + template<typename _CharT, typename _Traits> + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f) + { + __is.fill(__f._M_c); + return __is; + } + + template<typename _CharT, typename _Traits> + inline 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; }; + + /** + * @brief Manipulator for @c precision. + * @param n The new precision. + * + * Sent to a stream object, this manipulator calls @c precision(n) for + * that object. + */ + inline _Setprecision + setprecision(int __n) + { return { __n }; } + + template<typename _CharT, typename _Traits> + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f) + { + __is.precision(__f._M_n); + return __is; + } + + template<typename _CharT, typename _Traits> + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f) + { + __os.precision(__f._M_n); + return __os; + } + + + struct _Setw { int _M_n; }; + + /** + * @brief Manipulator for @c width. + * @param n The new width. + * + * Sent to a stream object, this manipulator calls @c width(n) for + * that object. + */ + inline _Setw + setw(int __n) + { return { __n }; } + + template<typename _CharT, typename _Traits> + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f) + { + __is.width(__f._M_n); + return __is; + } + + template<typename _CharT, typename _Traits> + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f) + { + __os.width(__f._M_n); + return __os; + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + + template<typename _MoneyT> + struct _Get_money { _MoneyT& _M_mon; bool _M_intl; }; + + /** + * @brief Extended manipulator for extracting money. + * @param mon Either long double or a specialization of @c basic_string. + * @param intl A bool indicating whether international format + * is to be used. + * + * Sent to a stream object, this manipulator extracts @a mon. + */ + template<typename _MoneyT> + inline _Get_money<_MoneyT> + get_money(_MoneyT& __mon, bool __intl = false) + { return { __mon, __intl }; } + + template<typename _CharT, typename _Traits, typename _MoneyT> + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f) + { + typedef istreambuf_iterator<_CharT, _Traits> _Iter; + typedef money_get<_CharT, _Iter> _MoneyGet; + + ios_base::iostate __err = ios_base::goodbit; + const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc()); + + __mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl, + __is, __err, __f._M_mon); + + if (ios_base::goodbit != __err) + __is.setstate(__err); + + return __is; + } + + + template<typename _MoneyT> + struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; }; + + /** + * @brief Extended manipulator for inserting money. + * @param mon Either long double or a specialization of @c basic_string. + * @param intl A bool indicating whether international format + * is to be used. + * + * Sent to a stream object, this manipulator inserts @a mon. + */ + template<typename _MoneyT> + inline _Put_money<_MoneyT> + put_money(const _MoneyT& __mon, bool __intl = false) + { return { __mon, __intl }; } + + template<typename _CharT, typename _Traits, typename _MoneyT> + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f) + { + typedef ostreambuf_iterator<_CharT, _Traits> _Iter; + typedef money_put<_CharT, _Iter> _MoneyPut; + + const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc()); + const _Iter __end = __mp.put(_Iter(__os.rdbuf()), __f._M_intl, + __os, __os.fill(), __f._M_mon); + + if (__end.failed()) + __os.setstate(ios_base::badbit); + + return __os; + } + +#endif + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. + // NB: This syntax is a GNU extension. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template ostream& operator<<(ostream&, _Setfill<char>); + extern template ostream& operator<<(ostream&, _Setiosflags); + extern template ostream& operator<<(ostream&, _Resetiosflags); + extern template ostream& operator<<(ostream&, _Setbase); + extern template ostream& operator<<(ostream&, _Setprecision); + extern template ostream& operator<<(ostream&, _Setw); + extern template istream& operator>>(istream&, _Setfill<char>); + extern template istream& operator>>(istream&, _Setiosflags); + extern template istream& operator>>(istream&, _Resetiosflags); + extern template istream& operator>>(istream&, _Setbase); + extern template istream& operator>>(istream&, _Setprecision); + extern template istream& operator>>(istream&, _Setw); + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template wostream& operator<<(wostream&, _Setfill<wchar_t>); + extern template wostream& operator<<(wostream&, _Setiosflags); + extern template wostream& operator<<(wostream&, _Resetiosflags); + extern template wostream& operator<<(wostream&, _Setbase); + extern template wostream& operator<<(wostream&, _Setprecision); + extern template wostream& operator<<(wostream&, _Setw); + extern template wistream& operator>>(wistream&, _Setfill<wchar_t>); + extern template wistream& operator>>(wistream&, _Setiosflags); + extern template wistream& operator>>(wistream&, _Resetiosflags); + extern template wistream& operator>>(wistream&, _Setbase); + extern template wistream& operator>>(wistream&, _Setprecision); + extern template wistream& operator>>(wistream&, _Setw); +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _GLIBCXX_IOMANIP */ diff --git a/libstdc++-v3/include/std/ios b/libstdc++-v3/include/std/ios new file mode 100644 index 000000000..9cf8368f5 --- /dev/null +++ b/libstdc++-v3/include/std/ios @@ -0,0 +1,47 @@ +// Iostreams base classes -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, +// 2005, 2006, 2007, 2009, 2010 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/ios + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 14882: 27.4 Iostreams base classes +// + +#ifndef _GLIBCXX_IOS +#define _GLIBCXX_IOS 1 + +#pragma GCC system_header + +#include <iosfwd> +#include <exception> // For ios_base::failure +#include <bits/char_traits.h> // For char_traits, streamoff, streamsize, fpos +#include <bits/localefwd.h> // For class locale +#include <bits/ios_base.h> // For ios_base declarations. +#include <streambuf> +#include <bits/basic_ios.h> + +#endif /* _GLIBCXX_IOS */ diff --git a/libstdc++-v3/include/std/iosfwd b/libstdc++-v3/include/std/iosfwd new file mode 100644 index 000000000..8906a1d34 --- /dev/null +++ b/libstdc++-v3/include/std/iosfwd @@ -0,0 +1,212 @@ +// Forwarding declarations -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +// 2006, 2007, 2009, 2010 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/iosfwd + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 14882: 27.2 Forward declarations +// + +#ifndef _GLIBCXX_IOSFWD +#define _GLIBCXX_IOSFWD 1 + +#pragma GCC system_header + +#include <bits/c++config.h> +#include <bits/stringfwd.h> // For string forward declarations. +#include <bits/postypes.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup io I/O + * + * Nearly all of the I/O classes are parameterized on the type of + * characters they read and write. (The major exception is ios_base at + * the top of the hierarchy.) This is a change from pre-Standard + * streams, which were not templates. + * + * For ease of use and compatibility, all of the basic_* I/O-related + * classes are given typedef names for both of the builtin character + * widths (wide and narrow). The typedefs are the same as the + * pre-Standard names, for example: + * + * @code + * typedef basic_ifstream<char> ifstream; + * @endcode + * + * Because properly forward-declaring these classes can be difficult, you + * should not do it yourself. Instead, include the <iosfwd> + * header, which contains only declarations of all the I/O classes as + * well as the typedefs. Trying to forward-declare the typedefs + * themselves (e.g., <code>class ostream;</code>) is not valid ISO C++. + * + * For more specific declarations, see + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch24.html + * + * @{ + */ + class ios_base; + + template<typename _CharT, typename _Traits = char_traits<_CharT> > + class basic_ios; + + template<typename _CharT, typename _Traits = char_traits<_CharT> > + class basic_streambuf; + + template<typename _CharT, typename _Traits = char_traits<_CharT> > + class basic_istream; + + template<typename _CharT, typename _Traits = char_traits<_CharT> > + class basic_ostream; + + template<typename _CharT, typename _Traits = char_traits<_CharT> > + class basic_iostream; + + template<typename _CharT, typename _Traits = char_traits<_CharT>, + typename _Alloc = allocator<_CharT> > + class basic_stringbuf; + + template<typename _CharT, typename _Traits = char_traits<_CharT>, + typename _Alloc = allocator<_CharT> > + class basic_istringstream; + + template<typename _CharT, typename _Traits = char_traits<_CharT>, + typename _Alloc = allocator<_CharT> > + class basic_ostringstream; + + template<typename _CharT, typename _Traits = char_traits<_CharT>, + typename _Alloc = allocator<_CharT> > + class basic_stringstream; + + template<typename _CharT, typename _Traits = char_traits<_CharT> > + class basic_filebuf; + + template<typename _CharT, typename _Traits = char_traits<_CharT> > + class basic_ifstream; + + template<typename _CharT, typename _Traits = char_traits<_CharT> > + class basic_ofstream; + + template<typename _CharT, typename _Traits = char_traits<_CharT> > + class basic_fstream; + + template<typename _CharT, typename _Traits = char_traits<_CharT> > + class istreambuf_iterator; + + template<typename _CharT, typename _Traits = char_traits<_CharT> > + class ostreambuf_iterator; + + + /// Base class for @c char streams. + typedef basic_ios<char> ios; + + /// Base class for @c char buffers. + typedef basic_streambuf<char> streambuf; + + /// Base class for @c char input streams. + typedef basic_istream<char> istream; + + /// Base class for @c char output streams. + typedef basic_ostream<char> ostream; + + /// Base class for @c char mixed input and output streams. + typedef basic_iostream<char> iostream; + + /// Class for @c char memory buffers. + typedef basic_stringbuf<char> stringbuf; + + /// Class for @c char input memory streams. + typedef basic_istringstream<char> istringstream; + + /// Class for @c char output memory streams. + typedef basic_ostringstream<char> ostringstream; + + /// Class for @c char mixed input and output memory streams. + typedef basic_stringstream<char> stringstream; + + /// Class for @c char file buffers. + typedef basic_filebuf<char> filebuf; + + /// Class for @c char input file streams. + typedef basic_ifstream<char> ifstream; + + /// Class for @c char output file streams. + typedef basic_ofstream<char> ofstream; + + /// Class for @c char mixed input and output file streams. + typedef basic_fstream<char> fstream; + +#ifdef _GLIBCXX_USE_WCHAR_T + /// Base class for @c wchar_t streams. + typedef basic_ios<wchar_t> wios; + + /// Base class for @c wchar_t buffers. + typedef basic_streambuf<wchar_t> wstreambuf; + + /// Base class for @c wchar_t input streams. + typedef basic_istream<wchar_t> wistream; + + /// Base class for @c wchar_t output streams. + typedef basic_ostream<wchar_t> wostream; + + /// Base class for @c wchar_t mixed input and output streams. + typedef basic_iostream<wchar_t> wiostream; + + /// Class for @c wchar_t memory buffers. + typedef basic_stringbuf<wchar_t> wstringbuf; + + /// Class for @c wchar_t input memory streams. + typedef basic_istringstream<wchar_t> wistringstream; + + /// Class for @c wchar_t output memory streams. + typedef basic_ostringstream<wchar_t> wostringstream; + + /// Class for @c wchar_t mixed input and output memory streams. + typedef basic_stringstream<wchar_t> wstringstream; + + /// Class for @c wchar_t file buffers. + typedef basic_filebuf<wchar_t> wfilebuf; + + /// Class for @c wchar_t input file streams. + typedef basic_ifstream<wchar_t> wifstream; + + /// Class for @c wchar_t output file streams. + typedef basic_ofstream<wchar_t> wofstream; + + /// Class for @c wchar_t mixed input and output file streams. + typedef basic_fstream<wchar_t> wfstream; +#endif + /** @} */ + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _GLIBCXX_IOSFWD */ diff --git a/libstdc++-v3/include/std/iostream b/libstdc++-v3/include/std/iostream new file mode 100644 index 000000000..7c71ba493 --- /dev/null +++ b/libstdc++-v3/include/std/iostream @@ -0,0 +1,80 @@ +// Standard iostream objects -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2001, 2002, 2005, 2008, 2009, 2010 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/iostream + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 14882: 27.3 Standard iostream objects +// + +#ifndef _GLIBCXX_IOSTREAM +#define _GLIBCXX_IOSTREAM 1 + +#pragma GCC system_header + +#include <bits/c++config.h> +#include <ostream> +#include <istream> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @name Standard Stream Objects + * + * The <iostream> header declares the eight <em>standard stream + * objects</em>. For other declarations, see + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch24.html + * and the @link iosfwd I/O forward declarations @endlink + * + * They are required by default to cooperate with the global C + * library's @c FILE streams, and to be available during program + * startup and termination. For more information, see the HOWTO + * linked to above. + */ + //@{ + extern istream cin; /// Linked to standard input + extern ostream cout; /// Linked to standard output + extern ostream cerr; /// Linked to standard error (unbuffered) + extern ostream clog; /// Linked to standard error (buffered) + +#ifdef _GLIBCXX_USE_WCHAR_T + extern wistream wcin; /// Linked to standard input + extern wostream wcout; /// Linked to standard output + extern wostream wcerr; /// Linked to standard error (unbuffered) + extern wostream wclog; /// Linked to standard error (buffered) +#endif + //@} + + // For construction of filebuffers for cout, cin, cerr, clog et. al. + static ios_base::Init __ioinit; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _GLIBCXX_IOSTREAM */ diff --git a/libstdc++-v3/include/std/istream b/libstdc++-v3/include/std/istream new file mode 100644 index 000000000..fb393921f --- /dev/null +++ b/libstdc++-v3/include/std/istream @@ -0,0 +1,861 @@ +// Input streams -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +// 2006, 2007, 2008, 2009, 2010, 2011 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// +// ISO C++ 14882: 27.6.1 Input streams +// + +/** @file include/istream + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_ISTREAM +#define _GLIBCXX_ISTREAM 1 + +#pragma GCC system_header + +#include <ios> +#include <ostream> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // [27.6.1.1] Template class basic_istream + /** + * @brief Controlling input. + * @ingroup io + * + * This is the base class for all input streams. It provides text + * formatting of all builtin types, and communicates with any class + * derived from basic_streambuf to do the actual input. + */ + template<typename _CharT, typename _Traits> + class basic_istream : virtual public basic_ios<_CharT, _Traits> + { + public: + // Types (inherited from basic_ios (27.4.4)): + 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 basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef basic_ios<_CharT, _Traits> __ios_type; + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > + __num_get_type; + typedef ctype<_CharT> __ctype_type; + + protected: + // Data Members: + /** + * The number of characters extracted in the previous unformatted + * function; see gcount(). + */ + streamsize _M_gcount; + + public: + // [27.6.1.1.1] constructor/destructor + /** + * @brief Base constructor. + * + * This ctor is almost never called by the user directly, rather from + * derived classes' initialization lists, which pass a pointer to + * their own stream buffer. + */ + explicit + basic_istream(__streambuf_type* __sb) + : _M_gcount(streamsize(0)) + { this->init(__sb); } + + /** + * @brief Base destructor. + * + * This does very little apart from providing a virtual base dtor. + */ + virtual + ~basic_istream() + { _M_gcount = streamsize(0); } + + // [27.6.1.1.2] prefix/suffix + class sentry; + friend class sentry; + + // [27.6.1.2] formatted input + // [27.6.1.2.3] basic_istream::operator>> + //@{ + /** + * @brief Interface for manipulators. + * + * Manipulators such as @c std::ws and @c std::dec use these + * functions in constructs like + * <code>std::cin >> std::ws</code>. + * For more information, see the iomanip header. + */ + __istream_type& + operator>>(__istream_type& (*__pf)(__istream_type&)) + { return __pf(*this); } + + __istream_type& + operator>>(__ios_type& (*__pf)(__ios_type&)) + { + __pf(*this); + return *this; + } + + __istream_type& + operator>>(ios_base& (*__pf)(ios_base&)) + { + __pf(*this); + return *this; + } + //@} + + // [27.6.1.2.2] arithmetic extractors + /** + * @name Arithmetic Extractors + * + * All the @c operator>> functions (aka <em>formatted input + * functions</em>) have some common behavior. Each starts by + * constructing a temporary object of type std::basic_istream::sentry + * with the second argument (noskipws) set to false. This has several + * effects, concluding with the setting of a status flag; see the + * sentry documentation for more. + * + * If the sentry status is good, the function tries to extract + * whatever data is appropriate for the type of the argument. + * + * If an exception is thrown during extraction, ios_base::badbit + * will be turned on in the stream's error state without causing an + * ios_base::failure to be thrown. The original exception will then + * be rethrown. + */ + //@{ + /** + * @brief Basic arithmetic extractors + * @param A variable of builtin type. + * @return @c *this if successful + * + * These functions use the stream's current locale (specifically, the + * @c num_get facet) to parse the input data. + */ + __istream_type& + operator>>(bool& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(short& __n); + + __istream_type& + operator>>(unsigned short& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(int& __n); + + __istream_type& + operator>>(unsigned int& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(long& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(unsigned long& __n) + { return _M_extract(__n); } + +#ifdef _GLIBCXX_USE_LONG_LONG + __istream_type& + operator>>(long long& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(unsigned long long& __n) + { return _M_extract(__n); } +#endif + + __istream_type& + operator>>(float& __f) + { return _M_extract(__f); } + + __istream_type& + operator>>(double& __f) + { return _M_extract(__f); } + + __istream_type& + operator>>(long double& __f) + { return _M_extract(__f); } + + __istream_type& + operator>>(void*& __p) + { return _M_extract(__p); } + + /** + * @brief Extracting into another streambuf. + * @param sb A pointer to a streambuf + * + * This function behaves like one of the basic arithmetic extractors, + * in that it also constructs a sentry object and has the same error + * handling behavior. + * + * If @a sb is NULL, the stream will set failbit in its error state. + * + * Characters are extracted from this stream and inserted into the + * @a sb streambuf until one of the following occurs: + * + * - the input stream reaches end-of-file, + * - insertion into the output buffer fails (in this case, the + * character that would have been inserted is not extracted), or + * - an exception occurs (and in this case is caught) + * + * If the function inserts no characters, failbit is set. + */ + __istream_type& + operator>>(__streambuf_type* __sb); + //@} + + // [27.6.1.3] unformatted input + /** + * @brief Character counting + * @return The number of characters extracted by the previous + * unformatted input function dispatched for this stream. + */ + streamsize + gcount() const + { return _M_gcount; } + + /** + * @name Unformatted Input Functions + * + * All the unformatted input functions have some common behavior. + * Each starts by constructing a temporary object of type + * std::basic_istream::sentry with the second argument (noskipws) + * set to true. This has several effects, concluding with the + * setting of a status flag; see the sentry documentation for more. + * + * If the sentry status is good, the function tries to extract + * whatever data is appropriate for the type of the argument. + * + * The number of characters extracted is stored for later retrieval + * by gcount(). + * + * If an exception is thrown during extraction, ios_base::badbit + * will be turned on in the stream's error state without causing an + * ios_base::failure to be thrown. The original exception will then + * be rethrown. + */ + //@{ + /** + * @brief Simple extraction. + * @return A character, or eof(). + * + * Tries to extract a character. If none are available, sets failbit + * and returns traits::eof(). + */ + int_type + get(); + + /** + * @brief Simple extraction. + * @param c The character in which to store data. + * @return *this + * + * Tries to extract a character and store it in @a c. If none are + * available, sets failbit and returns traits::eof(). + * + * @note This function is not overloaded on signed char and + * unsigned char. + */ + __istream_type& + get(char_type& __c); + + /** + * @brief Simple multiple-character extraction. + * @param s Pointer to an array. + * @param n Maximum number of characters to store in @a s. + * @param delim A "stop" character. + * @return *this + * + * Characters are extracted and stored into @a s until one of the + * following happens: + * + * - @c n-1 characters are stored + * - the input sequence reaches EOF + * - the next character equals @a delim, in which case the character + * is not extracted + * + * If no characters are stored, failbit is set in the stream's error + * state. + * + * In any case, a null character is stored into the next location in + * the array. + * + * @note This function is not overloaded on signed char and + * unsigned char. + */ + __istream_type& + get(char_type* __s, streamsize __n, char_type __delim); + + /** + * @brief Simple multiple-character extraction. + * @param s Pointer to an array. + * @param n Maximum number of characters to store in @a s. + * @return *this + * + * Returns @c get(s,n,widen('\\n')). + */ + __istream_type& + get(char_type* __s, streamsize __n) + { return this->get(__s, __n, this->widen('\n')); } + + /** + * @brief Extraction into another streambuf. + * @param sb A streambuf in which to store data. + * @param delim A "stop" character. + * @return *this + * + * Characters are extracted and inserted into @a sb until one of the + * following happens: + * + * - the input sequence reaches EOF + * - insertion into the output buffer fails (in this case, the + * character that would have been inserted is not extracted) + * - the next character equals @a delim (in this case, the character + * is not extracted) + * - an exception occurs (and in this case is caught) + * + * If no characters are stored, failbit is set in the stream's error + * state. + */ + __istream_type& + get(__streambuf_type& __sb, char_type __delim); + + /** + * @brief Extraction into another streambuf. + * @param sb A streambuf in which to store data. + * @return *this + * + * Returns @c get(sb,widen('\\n')). + */ + __istream_type& + get(__streambuf_type& __sb) + { return this->get(__sb, this->widen('\n')); } + + /** + * @brief String extraction. + * @param s A character array in which to store the data. + * @param n Maximum number of characters to extract. + * @param delim A "stop" character. + * @return *this + * + * Extracts and stores characters into @a s until one of the + * following happens. Note that these criteria are required to be + * tested in the order listed here, to allow an input line to exactly + * fill the @a s array without setting failbit. + * + * -# the input sequence reaches end-of-file, in which case eofbit + * is set in the stream error state + * -# the next character equals @c delim, in which case the character + * is extracted (and therefore counted in @c gcount()) but not stored + * -# @c n-1 characters are stored, in which case failbit is set + * in the stream error state + * + * If no characters are extracted, failbit is set. (An empty line of + * input should therefore not cause failbit to be set.) + * + * In any case, a null character is stored in the next location in + * the array. + */ + __istream_type& + getline(char_type* __s, streamsize __n, char_type __delim); + + /** + * @brief String extraction. + * @param s A character array in which to store the data. + * @param n Maximum number of characters to extract. + * @return *this + * + * Returns @c getline(s,n,widen('\\n')). + */ + __istream_type& + getline(char_type* __s, streamsize __n) + { return this->getline(__s, __n, this->widen('\n')); } + + /** + * @brief Discarding characters + * @param n Number of characters to discard. + * @param delim A "stop" character. + * @return *this + * + * Extracts characters and throws them away until one of the + * following happens: + * - if @a n @c != @c std::numeric_limits<int>::max(), @a n + * characters are extracted + * - the input sequence reaches end-of-file + * - the next character equals @a delim (in this case, the character + * is extracted); note that this condition will never occur if + * @a delim equals @c traits::eof(). + * + * NB: Provide three overloads, instead of the single function + * (with defaults) mandated by the Standard: this leads to a + * better performing implementation, while still conforming to + * the Standard. + */ + __istream_type& + ignore(); + + __istream_type& + ignore(streamsize __n); + + __istream_type& + ignore(streamsize __n, int_type __delim); + + /** + * @brief Looking ahead in the stream + * @return The next character, or eof(). + * + * If, after constructing the sentry object, @c good() is false, + * returns @c traits::eof(). Otherwise reads but does not extract + * the next input character. + */ + int_type + peek(); + + /** + * @brief Extraction without delimiters. + * @param s A character array. + * @param n Maximum number of characters to store. + * @return *this + * + * If the stream state is @c good(), extracts characters and stores + * them into @a s until one of the following happens: + * - @a n characters are stored + * - the input sequence reaches end-of-file, in which case the error + * state is set to @c failbit|eofbit. + * + * @note This function is not overloaded on signed char and + * unsigned char. + */ + __istream_type& + read(char_type* __s, streamsize __n); + + /** + * @brief Extraction until the buffer is exhausted, but no more. + * @param s A character array. + * @param n Maximum number of characters to store. + * @return The number of characters extracted. + * + * Extracts characters and stores them into @a s depending on the + * number of characters remaining in the streambuf's buffer, + * @c rdbuf()->in_avail(), called @c A here: + * - if @c A @c == @c -1, sets eofbit and extracts no characters + * - if @c A @c == @c 0, extracts no characters + * - if @c A @c > @c 0, extracts @c min(A,n) + * + * The goal is to empty the current buffer, and to not request any + * more from the external input sequence controlled by the streambuf. + */ + streamsize + readsome(char_type* __s, streamsize __n); + + /** + * @brief Unextracting a single character. + * @param c The character to push back into the input stream. + * @return *this + * + * If @c rdbuf() is not null, calls @c rdbuf()->sputbackc(c). + * + * If @c rdbuf() is null or if @c sputbackc() fails, sets badbit in + * the error state. + * + * @note This function first clears eofbit. Since no characters + * are extracted, the next call to @c gcount() will return 0, + * as required by DR 60. + */ + __istream_type& + putback(char_type __c); + + /** + * @brief Unextracting the previous character. + * @return *this + * + * If @c rdbuf() is not null, calls @c rdbuf()->sungetc(c). + * + * If @c rdbuf() is null or if @c sungetc() fails, sets badbit in + * the error state. + * + * @note This function first clears eofbit. Since no characters + * are extracted, the next call to @c gcount() will return 0, + * as required by DR 60. + */ + __istream_type& + unget(); + + /** + * @brief Synchronizing the stream buffer. + * @return 0 on success, -1 on failure + * + * If @c rdbuf() is a null pointer, returns -1. + * + * Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1, + * sets badbit and returns -1. + * + * Otherwise, returns 0. + * + * @note This function does not count the number of characters + * extracted, if any, and therefore does not affect the next + * call to @c gcount(). + */ + int + sync(); + + /** + * @brief Getting the current read position. + * @return A file position object. + * + * If @c fail() is not false, returns @c pos_type(-1) to indicate + * failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,in). + * + * @note This function does not count the number of characters + * extracted, if any, and therefore does not affect the next + * call to @c gcount(). At variance with putback, unget and + * seekg, eofbit is not cleared first. + */ + pos_type + tellg(); + + /** + * @brief Changing the current read position. + * @param pos A file position object. + * @return *this + * + * If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If + * that function fails, sets failbit. + * + * @note This function first clears eofbit. It does not count the + * number of characters extracted, if any, and therefore does + * not affect the next call to @c gcount(). + */ + __istream_type& + seekg(pos_type); + + /** + * @brief Changing the current read position. + * @param off A file offset object. + * @param dir The direction in which to seek. + * @return *this + * + * If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir). + * If that function fails, sets failbit. + * + * @note This function first clears eofbit. It does not count the + * number of characters extracted, if any, and therefore does + * not affect the next call to @c gcount(). + */ + __istream_type& + seekg(off_type, ios_base::seekdir); + //@} + + protected: + basic_istream() + : _M_gcount(streamsize(0)) + { this->init(0); } + + template<typename _ValueT> + __istream_type& + _M_extract(_ValueT& __v); + }; + + // Explicit specialization declarations, defined in src/istream.cc. + template<> + basic_istream<char>& + basic_istream<char>:: + getline(char_type* __s, streamsize __n, char_type __delim); + + template<> + basic_istream<char>& + basic_istream<char>:: + ignore(streamsize __n); + + template<> + basic_istream<char>& + basic_istream<char>:: + ignore(streamsize __n, int_type __delim); + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + basic_istream<wchar_t>& + basic_istream<wchar_t>:: + getline(char_type* __s, streamsize __n, char_type __delim); + + template<> + basic_istream<wchar_t>& + basic_istream<wchar_t>:: + ignore(streamsize __n); + + template<> + basic_istream<wchar_t>& + basic_istream<wchar_t>:: + ignore(streamsize __n, int_type __delim); +#endif + + /** + * @brief Performs setup work for input streams. + * + * Objects of this class are created before all of the standard + * extractors are run. It is responsible for <em>exception-safe + * prefix and suffix operations,</em> although only prefix actions + * are currently required by the standard. + */ + template<typename _CharT, typename _Traits> + class basic_istream<_CharT, _Traits>::sentry + { + // Data Members. + bool _M_ok; + + public: + /// Easy access to dependant types. + typedef _Traits traits_type; + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::__ctype_type __ctype_type; + typedef typename _Traits::int_type __int_type; + + /** + * @brief The constructor performs all the work. + * @param is The input stream to guard. + * @param noskipws Whether to consume whitespace or not. + * + * If the stream state is good (@a is.good() is true), then the + * following actions are performed, otherwise the sentry state + * is false (<em>not okay</em>) and failbit is set in the + * stream state. + * + * The sentry's preparatory actions are: + * + * -# if the stream is tied to an output stream, @c is.tie()->flush() + * is called to synchronize the output sequence + * -# if @a noskipws is false, and @c ios_base::skipws is set in + * @c is.flags(), the sentry extracts and discards whitespace + * characters from the stream. The currently imbued locale is + * used to determine whether each character is whitespace. + * + * If the stream state is still good, then the sentry state becomes + * true (@a okay). + */ + explicit + sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); + + /** + * @brief Quick status checking. + * @return The sentry state. + * + * For ease of use, sentries may be converted to booleans. The + * return value is that of the sentry state (true == okay). + */ +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + explicit +#endif + operator bool() const + { return _M_ok; } + }; + + // [27.6.1.2.3] character extraction templates + //@{ + /** + * @brief Character extractors + * @param in An input stream. + * @param c A character reference. + * @return in + * + * Behaves like one of the formatted arithmetic extractors described in + * std::basic_istream. After constructing a sentry object with good + * status, this function extracts a character (if one is available) and + * stores it in @a c. Otherwise, sets failbit in the input stream. + */ + template<typename _CharT, typename _Traits> + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); + + template<class _Traits> + inline basic_istream<char, _Traits>& + operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c) + { return (__in >> reinterpret_cast<char&>(__c)); } + + template<class _Traits> + inline basic_istream<char, _Traits>& + operator>>(basic_istream<char, _Traits>& __in, signed char& __c) + { return (__in >> reinterpret_cast<char&>(__c)); } + //@} + + //@{ + /** + * @brief Character string extractors + * @param in An input stream. + * @param s A pointer to a character array. + * @return in + * + * Behaves like one of the formatted arithmetic extractors described in + * std::basic_istream. After constructing a sentry object with good + * status, this function extracts up to @c n characters and stores them + * into the array starting at @a s. @c n is defined as: + * + * - if @c width() is greater than zero, @c n is width() otherwise + * - @c n is <em>the number of elements of the largest array of * + * - @c char_type that can store a terminating @c eos.</em> + * - [27.6.1.2.3]/6 + * + * Characters are extracted and stored until one of the following happens: + * - @c n-1 characters are stored + * - EOF is reached + * - the next character is whitespace according to the current locale + * - the next character is a null byte (i.e., @c charT() ) + * + * @c width(0) is then called for the input stream. + * + * If no characters are extracted, sets failbit. + */ + template<typename _CharT, typename _Traits> + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s); + + // Explicit specialization declaration, defined in src/istream.cc. + template<> + basic_istream<char>& + operator>>(basic_istream<char>& __in, char* __s); + + template<class _Traits> + inline basic_istream<char, _Traits>& + operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s) + { return (__in >> reinterpret_cast<char*>(__s)); } + + template<class _Traits> + inline basic_istream<char, _Traits>& + operator>>(basic_istream<char, _Traits>& __in, signed char* __s) + { return (__in >> reinterpret_cast<char*>(__s)); } + //@} + + // 27.6.1.5 Template class basic_iostream + /** + * @brief Merging istream and ostream capabilities. + * @ingroup io + * + * This class multiply inherits from the input and output stream classes + * simply to provide a single interface. + */ + template<typename _CharT, typename _Traits> + class basic_iostream + : public basic_istream<_CharT, _Traits>, + public basic_ostream<_CharT, _Traits> + { + public: + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 271. basic_iostream missing typedefs + // Types (inherited): + 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 basic_istream<_CharT, _Traits> __istream_type; + typedef basic_ostream<_CharT, _Traits> __ostream_type; + + /** + * @brief Constructor does nothing. + * + * Both of the parent classes are initialized with the same + * streambuf pointer passed to this constructor. + */ + explicit + basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) + : __istream_type(__sb), __ostream_type(__sb) { } + + /** + * @brief Destructor does nothing. + */ + virtual + ~basic_iostream() { } + + protected: + basic_iostream() + : __istream_type(), __ostream_type() { } + }; + + // [27.6.1.4] standard basic_istream manipulators + /** + * @brief Quick and easy way to eat whitespace + * + * This manipulator extracts whitespace characters, stopping when the + * next character is non-whitespace, or when the input sequence is empty. + * If the sequence is empty, @c eofbit is set in the stream, but not + * @c failbit. + * + * The current locale is used to distinguish whitespace characters. + * + * Example: + * @code + * MyClass mc; + * + * std::cin >> std::ws >> mc; + * @endcode + * will skip leading whitespace before calling operator>> on cin and your + * object. Note that the same effect can be achieved by creating a + * std::basic_istream::sentry inside your definition of operator>>. + */ + template<typename _CharT, typename _Traits> + basic_istream<_CharT, _Traits>& + ws(basic_istream<_CharT, _Traits>& __is); + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // [27.7.1.6] Rvalue stream extraction + /** + * @brief Generic extractor for rvalue stream + * @param is An input stream. + * @param x A reference to the extraction target. + * @return is + * + * This is just a forwarding function to allow extraction from + * rvalue streams since they won't bind to the extractor functions + * that take an lvalue reference. + */ + template<typename _CharT, typename _Traits, typename _Tp> + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x) + { return (__is >> __x); } +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#include <bits/istream.tcc> + +#endif /* _GLIBCXX_ISTREAM */ diff --git a/libstdc++-v3/include/std/iterator b/libstdc++-v3/include/std/iterator new file mode 100644 index 000000000..90152b7cb --- /dev/null +++ b/libstdc++-v3/include/std/iterator @@ -0,0 +1,70 @@ +// <iterator> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2009, 2010 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * + * 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. + */ + +/** @file include/iterator + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_ITERATOR +#define _GLIBCXX_ITERATOR 1 + +#pragma GCC system_header + +#include <bits/c++config.h> +#include <bits/stl_iterator_base_types.h> +#include <bits/stl_iterator_base_funcs.h> +#include <bits/stl_iterator.h> +#include <ostream> +#include <istream> +#include <bits/stream_iterator.h> +#include <bits/streambuf_iterator.h> +#include <bits/range_access.h> + +#endif /* _GLIBCXX_ITERATOR */ diff --git a/libstdc++-v3/include/std/limits b/libstdc++-v3/include/std/limits new file mode 100644 index 000000000..9a311973c --- /dev/null +++ b/libstdc++-v3/include/std/limits @@ -0,0 +1,1632 @@ +// The template and inlines for the numeric_limits classes. -*- C++ -*- + +// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, +// 2008, 2009, 2010 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/limits + * This is a Standard C++ Library header. + */ + +// Note: this is not a conforming implementation. +// Written by Gabriel Dos Reis <gdr@codesourcery.com> + +// +// ISO 14882:1998 +// 18.2.1 +// + +#ifndef _GLIBCXX_NUMERIC_LIMITS +#define _GLIBCXX_NUMERIC_LIMITS 1 + +#pragma GCC system_header + +#include <bits/c++config.h> + +// +// The numeric_limits<> traits document implementation-defined aspects +// of fundamental arithmetic data types (integers and floating points). +// From Standard C++ point of view, there are 14 such types: +// * integers +// bool (1) +// char, signed char, unsigned char, wchar_t (4) +// short, unsigned short (2) +// int, unsigned (2) +// long, unsigned long (2) +// +// * floating points +// float (1) +// double (1) +// long double (1) +// +// GNU C++ understands (where supported by the host C-library) +// * integer +// long long, unsigned long long (2) +// +// which brings us to 16 fundamental arithmetic data types in GNU C++. +// +// +// Since a numeric_limits<> is a bit tricky to get right, we rely on +// an interface composed of macros which should be defined in config/os +// or config/cpu when they differ from the generic (read arbitrary) +// definitions given here. +// + +// These values can be overridden in the target configuration file. +// The default values are appropriate for many 32-bit targets. + +// GCC only intrinsically supports modulo integral types. The only remaining +// integral exceptional values is division by zero. Only targets that do not +// signal division by zero in some "hard to ignore" way should use false. +#ifndef __glibcxx_integral_traps +# define __glibcxx_integral_traps true +#endif + +// float +// + +// Default values. Should be overridden in configuration files if necessary. + +#ifndef __glibcxx_float_has_denorm_loss +# define __glibcxx_float_has_denorm_loss false +#endif +#ifndef __glibcxx_float_traps +# define __glibcxx_float_traps false +#endif +#ifndef __glibcxx_float_tinyness_before +# define __glibcxx_float_tinyness_before false +#endif + +// double + +// Default values. Should be overridden in configuration files if necessary. + +#ifndef __glibcxx_double_has_denorm_loss +# define __glibcxx_double_has_denorm_loss false +#endif +#ifndef __glibcxx_double_traps +# define __glibcxx_double_traps false +#endif +#ifndef __glibcxx_double_tinyness_before +# define __glibcxx_double_tinyness_before false +#endif + +// long double + +// Default values. Should be overridden in configuration files if necessary. + +#ifndef __glibcxx_long_double_has_denorm_loss +# define __glibcxx_long_double_has_denorm_loss false +#endif +#ifndef __glibcxx_long_double_traps +# define __glibcxx_long_double_traps false +#endif +#ifndef __glibcxx_long_double_tinyness_before +# define __glibcxx_long_double_tinyness_before false +#endif + +// You should not need to define any macros below this point. + +#define __glibcxx_signed(T) ((T)(-1) < 0) + +#define __glibcxx_min(T) \ + (__glibcxx_signed (T) ? (T)1 << __glibcxx_digits (T) : (T)0) + +#define __glibcxx_max(T) \ + (__glibcxx_signed (T) ? \ + (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0) + +#define __glibcxx_digits(T) \ + (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T)) + +// The fraction 643/2136 approximates log10(2) to 7 significant digits. +#define __glibcxx_digits10(T) \ + (__glibcxx_digits (T) * 643L / 2136) + +#define __glibcxx_max_digits10(T) \ + (2 + (T) * 643L / 2136) + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief Describes the rounding style for floating-point types. + * + * This is used in the std::numeric_limits class. + */ + enum float_round_style + { + round_indeterminate = -1, /// Intermediate. + round_toward_zero = 0, /// To zero. + round_to_nearest = 1, /// To the nearest representable value. + round_toward_infinity = 2, /// To infinity. + round_toward_neg_infinity = 3 /// To negative infinity. + }; + + /** + * @brief Describes the denormalization for floating-point types. + * + * These values represent the presence or absence of a variable number + * of exponent bits. This type is used in the std::numeric_limits class. + */ + enum float_denorm_style + { + /// Indeterminate at compile time whether denormalized values are allowed. + denorm_indeterminate = -1, + /// The type does not allow denormalized values. + denorm_absent = 0, + /// The type allows denormalized values. + denorm_present = 1 + }; + + /** + * @brief Part of std::numeric_limits. + * + * The @c static @c const members are usable as integral constant + * expressions. + * + * @note This is a separate class for purposes of efficiency; you + * should only access these members as part of an instantiation + * of the std::numeric_limits class. + */ + struct __numeric_limits_base + { + /** This will be true for all fundamental types (which have + specializations), and false for everything else. */ + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false; + + /** The number of @c radix digits that be represented without change: for + integer types, the number of non-sign bits in the mantissa; for + floating types, the number of @c radix digits in the mantissa. */ + static _GLIBCXX_USE_CONSTEXPR int digits = 0; + + /** The number of base 10 digits that can be represented without change. */ + static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** The number of base 10 digits required to ensure that values which + differ are always differentiated. */ + static constexpr int max_digits10 = 0; +#endif + + /** True if the type is signed. */ + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + + /** True if the type is integer. + * Is this supposed to be <em>if the type is integral?</em> */ + static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; + + /** True if the type uses an exact representation. <em>All integer types are + exact, but not all exact types are integer. For example, rational and + fixed-exponent representations are exact but not integer.</em> + [18.2.1.2]/15 */ + static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; + + /** For integer types, specifies the base of the representation. For + floating types, specifies the base of the exponent representation. */ + static _GLIBCXX_USE_CONSTEXPR int radix = 0; + + /** The minimum negative integer such that @c radix raised to the power of + (one less than that integer) is a normalized floating point number. */ + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + + /** The minimum negative integer such that 10 raised to that power is in + the range of normalized floating point numbers. */ + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + + /** The maximum positive integer such that @c radix raised to the power of + (one less than that integer) is a representable finite floating point + number. */ + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + + /** The maximum positive integer such that 10 raised to that power is in + the range of representable finite floating point numbers. */ + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + /** True if the type has a representation for positive infinity. */ + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + + /** True if the type has a representation for a quiet (non-signaling) + <em>Not a Number</em>. */ + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + + /** True if the type has a representation for a signaling + <em>Not a Number</em>. */ + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + + /** See std::float_denorm_style for more information. */ + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; + + /** <em>True if loss of accuracy is detected as a denormalization loss, + rather than as an inexact result.</em> [18.2.1.2]/42 */ + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + /** True if-and-only-if the type adheres to the IEC 559 standard, also + known as IEEE 754. (Only makes sense for floating point types.) */ + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + + /** <em>True if the set of values representable by the type is + finite. All built-in types are bounded, this member would be + false for arbitrary precision types.</em> [18.2.1.2]/54 */ + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false; + + /** True if the type is @e modulo, that is, if it is possible to add two + positive numbers and have a result that wraps around to a third number + that is less. Typically false for floating types, true for unsigned + integers, and true for signed integers. */ + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; + + /** True if trapping is implemented for this type. */ + static _GLIBCXX_USE_CONSTEXPR bool traps = false; + + /** True if tininess is detected before rounding. (see IEC 559) */ + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + + /** See std::float_round_style for more information. This is only + meaningful for floating types; integer types will all be + round_toward_zero. */ + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = + round_toward_zero; + }; + + /** + * @brief Properties of fundamental types. + * + * This class allows a program to obtain information about the + * representation of a fundamental type on a given platform. For + * non-fundamental types, the functions will return 0 and the data + * members will all be @c false. + * + * _GLIBCXX_RESOLVE_LIB_DEFECTS: DRs 201 and 184 (hi Gaby!) are + * noted, but not incorporated in this documented (yet). + */ + template<typename _Tp> + struct numeric_limits : public __numeric_limits_base + { + /** The minimum finite value, or for floating types with + denormalization, the minimum positive normalized value. */ + static _GLIBCXX_CONSTEXPR _Tp + min() throw() { return static_cast<_Tp>(0); } + + /** The maximum finite value. */ + static _GLIBCXX_CONSTEXPR _Tp + max() throw() { return static_cast<_Tp>(0); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** A finite value x such that there is no other finite value y + * where y < x. */ + static constexpr _Tp + lowest() throw() { return static_cast<_Tp>(0); } +#endif + + /** The @e machine @e epsilon: the difference between 1 and the least + value greater than 1 that is representable. */ + static _GLIBCXX_CONSTEXPR _Tp + epsilon() throw() { return static_cast<_Tp>(0); } + + /** The maximum rounding error measurement (see LIA-1). */ + static _GLIBCXX_CONSTEXPR _Tp + round_error() throw() { return static_cast<_Tp>(0); } + + /** The representation of positive infinity, if @c has_infinity. */ + static _GLIBCXX_CONSTEXPR _Tp + infinity() throw() { return static_cast<_Tp>(0); } + + /** The representation of a quiet <em>Not a Number</em>, + if @c has_quiet_NaN. */ + static _GLIBCXX_CONSTEXPR _Tp + quiet_NaN() throw() { return static_cast<_Tp>(0); } + + /** The representation of a signaling <em>Not a Number</em>, if + @c has_signaling_NaN. */ + static _GLIBCXX_CONSTEXPR _Tp + signaling_NaN() throw() { return static_cast<_Tp>(0); } + + /** The minimum positive denormalized value. For types where + @c has_denorm is false, this is the minimum positive normalized + value. */ + static _GLIBCXX_CONSTEXPR _Tp + denorm_min() throw() { return static_cast<_Tp>(0); } + }; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Tp> + struct numeric_limits<const _Tp> + : public numeric_limits<_Tp> { }; + + template<typename _Tp> + struct numeric_limits<volatile _Tp> + : public numeric_limits<_Tp> { }; + + template<typename _Tp> + struct numeric_limits<const volatile _Tp> + : public numeric_limits<_Tp> { }; +#endif + + // Now there follow 16 explicit specializations. Yes, 16. Make sure + // you get the count right. (18 in c++0x mode) + + /// numeric_limits<bool> specialization. + template<> + struct numeric_limits<bool> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR bool + min() throw() { return false; } + + static _GLIBCXX_CONSTEXPR bool + max() throw() { return true; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr bool + lowest() throw() { return min(); } +#endif + static _GLIBCXX_USE_CONSTEXPR int digits = 1; + static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR bool + epsilon() throw() { return false; } + + static _GLIBCXX_CONSTEXPR bool + round_error() throw() { return false; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR bool + infinity() throw() { return false; } + + static _GLIBCXX_CONSTEXPR bool + quiet_NaN() throw() { return false; } + + static _GLIBCXX_CONSTEXPR bool + signaling_NaN() throw() { return false; } + + static _GLIBCXX_CONSTEXPR bool + denorm_min() throw() { return false; } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; + + // It is not clear what it means for a boolean type to trap. + // This is a DR on the LWG issue list. Here, I use integer + // promotion semantics. + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<char> specialization. + template<> + struct numeric_limits<char> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR char + min() throw() { return __glibcxx_min(char); } + + static _GLIBCXX_CONSTEXPR char + max() throw() { return __glibcxx_max(char); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr char + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char); + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char); + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR char + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR char + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR + char infinity() throw() { return char(); } + + static _GLIBCXX_CONSTEXPR char + quiet_NaN() throw() { return char(); } + + static _GLIBCXX_CONSTEXPR char + signaling_NaN() throw() { return char(); } + + static _GLIBCXX_CONSTEXPR char + denorm_min() throw() { return static_cast<char>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<signed char> specialization. + template<> + struct numeric_limits<signed char> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR signed char + min() throw() { return -__SCHAR_MAX__ - 1; } + + static _GLIBCXX_CONSTEXPR signed char + max() throw() { return __SCHAR_MAX__; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr signed char + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (signed char); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR signed char + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR signed char + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR signed char + infinity() throw() { return static_cast<signed char>(0); } + + static _GLIBCXX_CONSTEXPR signed char + quiet_NaN() throw() { return static_cast<signed char>(0); } + + static _GLIBCXX_CONSTEXPR signed char + signaling_NaN() throw() { return static_cast<signed char>(0); } + + static _GLIBCXX_CONSTEXPR signed char + denorm_min() throw() { return static_cast<signed char>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<unsigned char> specialization. + template<> + struct numeric_limits<unsigned char> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR unsigned char + min() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned char + max() throw() { return __SCHAR_MAX__ * 2U + 1; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr unsigned char + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (unsigned char); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (unsigned char); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR unsigned char + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned char + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR unsigned char + infinity() throw() { return static_cast<unsigned char>(0); } + + static _GLIBCXX_CONSTEXPR unsigned char + quiet_NaN() throw() { return static_cast<unsigned char>(0); } + + static _GLIBCXX_CONSTEXPR unsigned char + signaling_NaN() throw() { return static_cast<unsigned char>(0); } + + static _GLIBCXX_CONSTEXPR unsigned char + denorm_min() throw() { return static_cast<unsigned char>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<wchar_t> specialization. + template<> + struct numeric_limits<wchar_t> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR wchar_t + min() throw() { return __glibcxx_min (wchar_t); } + + static _GLIBCXX_CONSTEXPR wchar_t + max() throw() { return __glibcxx_max (wchar_t); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr wchar_t + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (wchar_t); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t); + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR wchar_t + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR wchar_t + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR wchar_t + infinity() throw() { return wchar_t(); } + + static _GLIBCXX_CONSTEXPR wchar_t + quiet_NaN() throw() { return wchar_t(); } + + static _GLIBCXX_CONSTEXPR wchar_t + signaling_NaN() throw() { return wchar_t(); } + + static _GLIBCXX_CONSTEXPR wchar_t + denorm_min() throw() { return wchar_t(); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /// numeric_limits<char16_t> specialization. + template<> + struct numeric_limits<char16_t> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR char16_t + min() throw() { return __glibcxx_min (char16_t); } + + static _GLIBCXX_CONSTEXPR char16_t + max() throw() { return __glibcxx_max (char16_t); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr char16_t + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (char16_t); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (char16_t); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed + = __glibcxx_signed (char16_t); + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR char16_t + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR char16_t + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR char16_t + infinity() throw() { return char16_t(); } + + static _GLIBCXX_CONSTEXPR char16_t + quiet_NaN() throw() { return char16_t(); } + + static _GLIBCXX_CONSTEXPR char16_t + signaling_NaN() throw() { return char16_t(); } + + static _GLIBCXX_CONSTEXPR char16_t + denorm_min() throw() { return char16_t(); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<char32_t> specialization. + template<> + struct numeric_limits<char32_t> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR char32_t + min() throw() { return __glibcxx_min (char32_t); } + + static _GLIBCXX_CONSTEXPR char32_t + max() throw() { return __glibcxx_max (char32_t); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr char32_t + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char32_t); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (char32_t); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed + = __glibcxx_signed (char32_t); + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR char32_t + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR char32_t + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR char32_t + infinity() throw() { return char32_t(); } + + static _GLIBCXX_CONSTEXPR char32_t + quiet_NaN() throw() { return char32_t(); } + + static _GLIBCXX_CONSTEXPR char32_t + signaling_NaN() throw() { return char32_t(); } + + static _GLIBCXX_CONSTEXPR char32_t + denorm_min() throw() { return char32_t(); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; +#endif + + /// numeric_limits<short> specialization. + template<> + struct numeric_limits<short> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR short + min() throw() { return -__SHRT_MAX__ - 1; } + + static _GLIBCXX_CONSTEXPR short + max() throw() { return __SHRT_MAX__; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr short + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short); + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR short + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR short + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR short + infinity() throw() { return short(); } + + static _GLIBCXX_CONSTEXPR short + quiet_NaN() throw() { return short(); } + + static _GLIBCXX_CONSTEXPR short + signaling_NaN() throw() { return short(); } + + static _GLIBCXX_CONSTEXPR short + denorm_min() throw() { return short(); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<unsigned short> specialization. + template<> + struct numeric_limits<unsigned short> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR unsigned short + min() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned short + max() throw() { return __SHRT_MAX__ * 2U + 1; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr unsigned short + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (unsigned short); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (unsigned short); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR unsigned short + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned short + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR unsigned short + infinity() throw() { return static_cast<unsigned short>(0); } + + static _GLIBCXX_CONSTEXPR unsigned short + quiet_NaN() throw() { return static_cast<unsigned short>(0); } + + static _GLIBCXX_CONSTEXPR unsigned short + signaling_NaN() throw() { return static_cast<unsigned short>(0); } + + static _GLIBCXX_CONSTEXPR unsigned short + denorm_min() throw() { return static_cast<unsigned short>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<int> specialization. + template<> + struct numeric_limits<int> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR int + min() throw() { return -__INT_MAX__ - 1; } + + static _GLIBCXX_CONSTEXPR int + max() throw() { return __INT_MAX__; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int); + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR int + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR int + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR int + infinity() throw() { return static_cast<int>(0); } + + static _GLIBCXX_CONSTEXPR int + quiet_NaN() throw() { return static_cast<int>(0); } + + static _GLIBCXX_CONSTEXPR int + signaling_NaN() throw() { return static_cast<int>(0); } + + static _GLIBCXX_CONSTEXPR int + denorm_min() throw() { return static_cast<int>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<unsigned int> specialization. + template<> + struct numeric_limits<unsigned int> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR unsigned int + min() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned int + max() throw() { return __INT_MAX__ * 2U + 1; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr unsigned int + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (unsigned int); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (unsigned int); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR unsigned int + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned int + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR unsigned int + infinity() throw() { return static_cast<unsigned int>(0); } + + static _GLIBCXX_CONSTEXPR unsigned int + quiet_NaN() throw() { return static_cast<unsigned int>(0); } + + static _GLIBCXX_CONSTEXPR unsigned int + signaling_NaN() throw() { return static_cast<unsigned int>(0); } + + static _GLIBCXX_CONSTEXPR unsigned int + denorm_min() throw() { return static_cast<unsigned int>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<long> specialization. + template<> + struct numeric_limits<long> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR long + min() throw() { return -__LONG_MAX__ - 1; } + + static _GLIBCXX_CONSTEXPR long + max() throw() { return __LONG_MAX__; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr long + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long); + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR long + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR long + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR long + infinity() throw() { return static_cast<long>(0); } + + static _GLIBCXX_CONSTEXPR long + quiet_NaN() throw() { return static_cast<long>(0); } + + static _GLIBCXX_CONSTEXPR long + signaling_NaN() throw() { return static_cast<long>(0); } + + static _GLIBCXX_CONSTEXPR long + denorm_min() throw() { return static_cast<long>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<unsigned long> specialization. + template<> + struct numeric_limits<unsigned long> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR unsigned long + min() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned long + max() throw() { return __LONG_MAX__ * 2UL + 1; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr unsigned long + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (unsigned long); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (unsigned long); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR unsigned long + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned long + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR unsigned long + infinity() throw() { return static_cast<unsigned long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long + quiet_NaN() throw() { return static_cast<unsigned long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long + signaling_NaN() throw() { return static_cast<unsigned long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long + denorm_min() throw() { return static_cast<unsigned long>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<long long> specialization. + template<> + struct numeric_limits<long long> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR long long + min() throw() { return -__LONG_LONG_MAX__ - 1; } + + static _GLIBCXX_CONSTEXPR long long + max() throw() { return __LONG_LONG_MAX__; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr long long + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (long long); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (long long); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR long long + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR long long + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR long long + infinity() throw() { return static_cast<long long>(0); } + + static _GLIBCXX_CONSTEXPR long long + quiet_NaN() throw() { return static_cast<long long>(0); } + + static _GLIBCXX_CONSTEXPR long long + signaling_NaN() throw() { return static_cast<long long>(0); } + + static _GLIBCXX_CONSTEXPR long long + denorm_min() throw() { return static_cast<long long>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<unsigned long long> specialization. + template<> + struct numeric_limits<unsigned long long> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR unsigned long long + min() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned long long + max() throw() { return __LONG_LONG_MAX__ * 2ULL + 1; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr unsigned long long + lowest() throw() { return min(); } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (unsigned long long); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (unsigned long long); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 = 0; +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR unsigned long long + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned long long + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR unsigned long long + infinity() throw() { return static_cast<unsigned long long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long long + quiet_NaN() throw() { return static_cast<unsigned long long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long long + signaling_NaN() throw() { return static_cast<unsigned long long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long long + denorm_min() throw() { return static_cast<unsigned long long>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; + }; + + /// numeric_limits<float> specialization. + template<> + struct numeric_limits<float> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR float + min() throw() { return __FLT_MIN__; } + + static _GLIBCXX_CONSTEXPR float + max() throw() { return __FLT_MAX__; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr float + lowest() throw() { return -__FLT_MAX__; } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__; + static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 + = __glibcxx_max_digits10 (__FLT_MANT_DIG__); +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; + static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; + + static _GLIBCXX_CONSTEXPR float + epsilon() throw() { return __FLT_EPSILON__; } + + static _GLIBCXX_CONSTEXPR float + round_error() throw() { return 0.5F; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss + = __glibcxx_float_has_denorm_loss; + + static _GLIBCXX_CONSTEXPR float + infinity() throw() { return __builtin_huge_valf (); } + + static _GLIBCXX_CONSTEXPR float + quiet_NaN() throw() { return __builtin_nanf (""); } + + static _GLIBCXX_CONSTEXPR float + signaling_NaN() throw() { return __builtin_nansf (""); } + + static _GLIBCXX_CONSTEXPR float + denorm_min() throw() { return __FLT_DENORM_MIN__; } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before + = __glibcxx_float_tinyness_before; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_to_nearest; + }; + +#undef __glibcxx_float_has_denorm_loss +#undef __glibcxx_float_traps +#undef __glibcxx_float_tinyness_before + + /// numeric_limits<double> specialization. + template<> + struct numeric_limits<double> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR double + min() throw() { return __DBL_MIN__; } + + static _GLIBCXX_CONSTEXPR double + max() throw() { return __DBL_MAX__; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr double + lowest() throw() { return -__DBL_MAX__; } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__; + static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr int max_digits10 + = __glibcxx_max_digits10 (__DBL_MANT_DIG__); +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; + static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; + + static _GLIBCXX_CONSTEXPR double + epsilon() throw() { return __DBL_EPSILON__; } + + static _GLIBCXX_CONSTEXPR double + round_error() throw() { return 0.5; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss + = __glibcxx_double_has_denorm_loss; + + static _GLIBCXX_CONSTEXPR double + infinity() throw() { return __builtin_huge_val(); } + + static _GLIBCXX_CONSTEXPR double + quiet_NaN() throw() { return __builtin_nan (""); } + + static _GLIBCXX_CONSTEXPR double + signaling_NaN() throw() { return __builtin_nans (""); } + + static _GLIBCXX_CONSTEXPR double + denorm_min() throw() { return __DBL_DENORM_MIN__; } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before + = __glibcxx_double_tinyness_before; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_to_nearest; + }; + +#undef __glibcxx_double_has_denorm_loss +#undef __glibcxx_double_traps +#undef __glibcxx_double_tinyness_before + + /// numeric_limits<long double> specialization. + template<> + struct numeric_limits<long double> + { + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR long double + min() throw() { return __LDBL_MIN__; } + + static _GLIBCXX_CONSTEXPR long double + max() throw() { return __LDBL_MAX__; } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static constexpr long double + lowest() throw() { return -__LDBL_MAX__; } +#endif + + static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__; + static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + static _GLIBCXX_USE_CONSTEXPR int max_digits10 + = __glibcxx_max_digits10 (__LDBL_MANT_DIG__); +#endif + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; + static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; + + static _GLIBCXX_CONSTEXPR long double + epsilon() throw() { return __LDBL_EPSILON__; } + + static _GLIBCXX_CONSTEXPR long double + round_error() throw() { return 0.5L; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss + = __glibcxx_long_double_has_denorm_loss; + + static _GLIBCXX_CONSTEXPR long double + infinity() throw() { return __builtin_huge_vall (); } + + static _GLIBCXX_CONSTEXPR long double + quiet_NaN() throw() { return __builtin_nanl (""); } + + static _GLIBCXX_CONSTEXPR long double + signaling_NaN() throw() { return __builtin_nansl (""); } + + static _GLIBCXX_CONSTEXPR long double + denorm_min() throw() { return __LDBL_DENORM_MIN__; } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = + __glibcxx_long_double_tinyness_before; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = + round_to_nearest; + }; + +#undef __glibcxx_long_double_has_denorm_loss +#undef __glibcxx_long_double_traps +#undef __glibcxx_long_double_tinyness_before + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#undef __glibcxx_signed +#undef __glibcxx_min +#undef __glibcxx_max +#undef __glibcxx_digits +#undef __glibcxx_digits10 +#undef __glibcxx_max_digits10 + +#endif // _GLIBCXX_NUMERIC_LIMITS diff --git a/libstdc++-v3/include/std/list b/libstdc++-v3/include/std/list new file mode 100644 index 000000000..abcba859b --- /dev/null +++ b/libstdc++-v3/include/std/list @@ -0,0 +1,76 @@ +// <list> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * + * 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. + */ + +/** @file include/list + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_LIST +#define _GLIBCXX_LIST 1 + +#pragma GCC system_header + +#include <bits/stl_algobase.h> +#include <bits/allocator.h> +#include <bits/range_access.h> +#include <bits/stl_list.h> +#include <bits/list.tcc> + +#ifdef _GLIBCXX_DEBUG +# include <debug/list> +#endif + +#ifdef _GLIBCXX_PROFILE +# include <profile/list> +#endif + +#endif /* _GLIBCXX_LIST */ + diff --git a/libstdc++-v3/include/std/locale b/libstdc++-v3/include/std/locale new file mode 100644 index 000000000..cfb152ac0 --- /dev/null +++ b/libstdc++-v3/include/std/locale @@ -0,0 +1,45 @@ +// Locale support -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 +// 2006, 2007, 2009, 2010 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// +// ISO C++ 14882: 22.1 Locales +// + +/** @file include/locale + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_LOCALE +#define _GLIBCXX_LOCALE 1 + +#pragma GCC system_header + +#include <bits/localefwd.h> +#include <bits/locale_classes.h> +#include <bits/locale_facets.h> +#include <bits/locale_facets_nonio.h> + +#endif /* _GLIBCXX_LOCALE */ diff --git a/libstdc++-v3/include/std/map b/libstdc++-v3/include/std/map new file mode 100644 index 000000000..b2e3bf5be --- /dev/null +++ b/libstdc++-v3/include/std/map @@ -0,0 +1,73 @@ +// <map> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2009, 2010 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * + * 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. + */ + +/** @file include/map + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_MAP +#define _GLIBCXX_MAP 1 + +#pragma GCC system_header + +#include <bits/stl_tree.h> +#include <bits/stl_map.h> +#include <bits/stl_multimap.h> +#include <bits/range_access.h> + +#ifdef _GLIBCXX_DEBUG +# include <debug/map> +#endif + +#ifdef _GLIBCXX_PROFILE +# include <profile/map> +#endif + +#endif /* _GLIBCXX_MAP */ diff --git a/libstdc++-v3/include/std/memory b/libstdc++-v3/include/std/memory new file mode 100644 index 000000000..791ffe048 --- /dev/null +++ b/libstdc++-v3/include/std/memory @@ -0,0 +1,91 @@ +// <memory> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, +// 2009, 2010, 2011 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * Copyright (c) 1997-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. + * + */ + +/** @file include/memory + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_MEMORY +#define _GLIBCXX_MEMORY 1 + +#pragma GCC system_header + +/** + * @defgroup memory Memory + * @ingroup utilities + * + * Components for memory allocation, deallocation, and management. + */ + +/** + * @defgroup pointer_abstractions Pointer Abstractions + * @ingroup memory + * + * Smart pointers, etc. + */ + +#include <bits/stl_algobase.h> +#include <bits/allocator.h> +#include <bits/stl_construct.h> +#include <bits/stl_uninitialized.h> +#include <bits/stl_tempbuf.h> +#include <bits/stl_raw_storage_iter.h> + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# include <exception> // std::exception +# include <typeinfo> // std::type_info in get_deleter +# include <iosfwd> // std::basic_ostream +# include <ext/atomicity.h> +# include <ext/concurrence.h> +# include <bits/functexcept.h> +# include <bits/stl_function.h> // std::less +# include <type_traits> +# include <functional> +# include <debug/debug.h> +# if _GLIBCXX_USE_DEPRECATED +# include <backward/auto_ptr.h> +# endif +# include <bits/unique_ptr.h> +# include <bits/shared_ptr.h> +#else +# include <backward/auto_ptr.h> +#endif + +#endif /* _GLIBCXX_MEMORY */ diff --git a/libstdc++-v3/include/std/mutex b/libstdc++-v3/include/std/mutex new file mode 100644 index 000000000..ed530e4f0 --- /dev/null +++ b/libstdc++-v3/include/std/mutex @@ -0,0 +1,830 @@ +// <mutex> -*- C++ -*- + +// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/mutex + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_MUTEX +#define _GLIBCXX_MUTEX 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <tuple> +#include <chrono> +#include <exception> +#include <type_traits> +#include <functional> +#include <system_error> +#include <bits/functexcept.h> +#include <bits/gthr.h> +#include <bits/move.h> // for std::swap + +#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup mutexes Mutexes + * @ingroup concurrency + * + * Classes for mutex support. + * @{ + */ + + /// mutex + class mutex + { + typedef __gthread_mutex_t __native_type; + __native_type _M_mutex; + + public: + typedef __native_type* native_handle_type; + +#ifdef __GTHREAD_MUTEX_INIT + constexpr mutex() : _M_mutex(__GTHREAD_MUTEX_INIT) { } +#else + mutex() + { + // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may) + __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex); + } + + ~mutex() { __gthread_mutex_destroy(&_M_mutex); } +#endif + + mutex(const mutex&) = delete; + mutex& operator=(const mutex&) = delete; + + void + lock() + { + int __e = __gthread_mutex_lock(&_M_mutex); + + // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) + if (__e) + __throw_system_error(__e); + } + + bool + try_lock() + { + // XXX EINVAL, EAGAIN, EBUSY + return !__gthread_mutex_trylock(&_M_mutex); + } + + void + unlock() + { + // XXX EINVAL, EAGAIN, EPERM + __gthread_mutex_unlock(&_M_mutex); + } + + native_handle_type + native_handle() + { return &_M_mutex; } + }; + +#ifndef __GTHREAD_RECURSIVE_MUTEX_INIT + // FIXME: gthreads doesn't define __gthread_recursive_mutex_destroy + // so we need to obtain a __gthread_mutex_t to destroy + class __destroy_recursive_mutex + { + template<typename _Mx, typename _Rm> + static void + _S_destroy_win32(_Mx* __mx, _Rm const* __rmx) + { + __mx->counter = __rmx->counter; + __mx->sema = __rmx->sema; + __gthread_mutex_destroy(__mx); + } + + public: + // matches a gthr-win32.h recursive mutex + template<typename _Rm> + static typename enable_if<(bool)sizeof(&_Rm::sema), void>::type + _S_destroy(_Rm* __mx) + { + __gthread_mutex_t __tmp; + _S_destroy_win32(&__tmp, __mx); + } + + // matches a recursive mutex with a member 'actual' + template<typename _Rm> + static typename enable_if<(bool)sizeof(&_Rm::actual), void>::type + _S_destroy(_Rm* __mx) + { __gthread_mutex_destroy(&__mx->actual); } + + // matches when there's only one mutex type + template<typename _Rm> + static + typename enable_if<is_same<_Rm, __gthread_mutex_t>::value, void>::type + _S_destroy(_Rm* __mx) + { __gthread_mutex_destroy(__mx); } + }; +#endif + + /// recursive_mutex + class recursive_mutex + { + typedef __gthread_recursive_mutex_t __native_type; + __native_type _M_mutex; + + public: + typedef __native_type* native_handle_type; + +#ifdef __GTHREAD_RECURSIVE_MUTEX_INIT + recursive_mutex() : _M_mutex(__GTHREAD_RECURSIVE_MUTEX_INIT) { } +#else + recursive_mutex() + { + // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may) + __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex); + } + + ~recursive_mutex() + { __destroy_recursive_mutex::_S_destroy(&_M_mutex); } +#endif + + recursive_mutex(const recursive_mutex&) = delete; + recursive_mutex& operator=(const recursive_mutex&) = delete; + + void + lock() + { + int __e = __gthread_recursive_mutex_lock(&_M_mutex); + + // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) + if (__e) + __throw_system_error(__e); + } + + bool + try_lock() + { + // XXX EINVAL, EAGAIN, EBUSY + return !__gthread_recursive_mutex_trylock(&_M_mutex); + } + + void + unlock() + { + // XXX EINVAL, EAGAIN, EBUSY + __gthread_recursive_mutex_unlock(&_M_mutex); + } + + native_handle_type + native_handle() + { return &_M_mutex; } + }; + + /// timed_mutex + class timed_mutex + { + typedef __gthread_mutex_t __native_type; + +#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC + typedef chrono::monotonic_clock __clock_t; +#else + typedef chrono::high_resolution_clock __clock_t; +#endif + + __native_type _M_mutex; + + public: + typedef __native_type* native_handle_type; + +#ifdef __GTHREAD_MUTEX_INIT + timed_mutex() : _M_mutex(__GTHREAD_MUTEX_INIT) { } +#else + timed_mutex() + { + __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex); + } + + ~timed_mutex() { __gthread_mutex_destroy(&_M_mutex); } +#endif + + timed_mutex(const timed_mutex&) = delete; + timed_mutex& operator=(const timed_mutex&) = delete; + + void + lock() + { + int __e = __gthread_mutex_lock(&_M_mutex); + + // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) + if (__e) + __throw_system_error(__e); + } + + bool + try_lock() + { + // XXX EINVAL, EAGAIN, EBUSY + return !__gthread_mutex_trylock(&_M_mutex); + } + + template <class _Rep, class _Period> + bool + try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) + { return __try_lock_for_impl(__rtime); } + + template <class _Clock, class _Duration> + bool + try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) + { + chrono::time_point<_Clock, chrono::seconds> __s = + chrono::time_point_cast<chrono::seconds>(__atime); + + chrono::nanoseconds __ns = + chrono::duration_cast<chrono::nanoseconds>(__atime - __s); + + __gthread_time_t __ts = { + static_cast<std::time_t>(__s.time_since_epoch().count()), + static_cast<long>(__ns.count()) + }; + + return !__gthread_mutex_timedlock(&_M_mutex, &__ts); + } + + void + unlock() + { + // XXX EINVAL, EAGAIN, EBUSY + __gthread_mutex_unlock(&_M_mutex); + } + + native_handle_type + native_handle() + { return &_M_mutex; } + + private: + template<typename _Rep, typename _Period> + typename enable_if< + ratio_less_equal<__clock_t::period, _Period>::value, bool>::type + __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime) + { + __clock_t::time_point __atime = __clock_t::now() + + chrono::duration_cast<__clock_t::duration>(__rtime); + + return try_lock_until(__atime); + } + + template <typename _Rep, typename _Period> + typename enable_if< + !ratio_less_equal<__clock_t::period, _Period>::value, bool>::type + __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime) + { + __clock_t::time_point __atime = __clock_t::now() + + ++chrono::duration_cast<__clock_t::duration>(__rtime); + + return try_lock_until(__atime); + } + }; + + /// recursive_timed_mutex + class recursive_timed_mutex + { + typedef __gthread_recursive_mutex_t __native_type; + +#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC + typedef chrono::monotonic_clock __clock_t; +#else + typedef chrono::high_resolution_clock __clock_t; +#endif + + __native_type _M_mutex; + + public: + typedef __native_type* native_handle_type; + +#ifdef __GTHREAD_RECURSIVE_MUTEX_INIT + recursive_timed_mutex() : _M_mutex(__GTHREAD_RECURSIVE_MUTEX_INIT) { } +#else + recursive_timed_mutex() + { + // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may) + __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex); + } + + ~recursive_timed_mutex() + { __destroy_recursive_mutex::_S_destroy(&_M_mutex); } +#endif + + recursive_timed_mutex(const recursive_timed_mutex&) = delete; + recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; + + void + lock() + { + int __e = __gthread_recursive_mutex_lock(&_M_mutex); + + // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) + if (__e) + __throw_system_error(__e); + } + + bool + try_lock() + { + // XXX EINVAL, EAGAIN, EBUSY + return !__gthread_recursive_mutex_trylock(&_M_mutex); + } + + template <class _Rep, class _Period> + bool + try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) + { return __try_lock_for_impl(__rtime); } + + template <class _Clock, class _Duration> + bool + try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) + { + chrono::time_point<_Clock, chrono::seconds> __s = + chrono::time_point_cast<chrono::seconds>(__atime); + + chrono::nanoseconds __ns = + chrono::duration_cast<chrono::nanoseconds>(__atime - __s); + + __gthread_time_t __ts = { + static_cast<std::time_t>(__s.time_since_epoch().count()), + static_cast<long>(__ns.count()) + }; + + return !__gthread_recursive_mutex_timedlock(&_M_mutex, &__ts); + } + + void + unlock() + { + // XXX EINVAL, EAGAIN, EBUSY + __gthread_recursive_mutex_unlock(&_M_mutex); + } + + native_handle_type + native_handle() + { return &_M_mutex; } + + private: + template<typename _Rep, typename _Period> + typename enable_if< + ratio_less_equal<__clock_t::period, _Period>::value, bool>::type + __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime) + { + __clock_t::time_point __atime = __clock_t::now() + + chrono::duration_cast<__clock_t::duration>(__rtime); + + return try_lock_until(__atime); + } + + template <typename _Rep, typename _Period> + typename enable_if< + !ratio_less_equal<__clock_t::period, _Period>::value, bool>::type + __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime) + { + __clock_t::time_point __atime = __clock_t::now() + + ++chrono::duration_cast<__clock_t::duration>(__rtime); + + return try_lock_until(__atime); + } + }; + + /// Do not acquire ownership of the mutex. + struct defer_lock_t { }; + + /// Try to acquire ownership of the mutex without blocking. + struct try_to_lock_t { }; + + /// Assume the calling thread has already obtained mutex ownership + /// and manage it. + struct adopt_lock_t { }; + + constexpr defer_lock_t defer_lock { }; + constexpr try_to_lock_t try_to_lock { }; + constexpr adopt_lock_t adopt_lock { }; + + /// @brief Scoped lock idiom. + // Acquire the mutex here with a constructor call, then release with + // the destructor call in accordance with RAII style. + template<typename _Mutex> + class lock_guard + { + public: + typedef _Mutex mutex_type; + + explicit lock_guard(mutex_type& __m) : _M_device(__m) + { _M_device.lock(); } + + lock_guard(mutex_type& __m, adopt_lock_t) : _M_device(__m) + { } // calling thread owns mutex + + ~lock_guard() + { _M_device.unlock(); } + + lock_guard(const lock_guard&) = delete; + lock_guard& operator=(const lock_guard&) = delete; + + private: + mutex_type& _M_device; + }; + + /// unique_lock + template<typename _Mutex> + class unique_lock + { + public: + typedef _Mutex mutex_type; + + unique_lock() + : _M_device(0), _M_owns(false) + { } + + explicit unique_lock(mutex_type& __m) + : _M_device(&__m), _M_owns(false) + { + lock(); + _M_owns = true; + } + + unique_lock(mutex_type& __m, defer_lock_t) + : _M_device(&__m), _M_owns(false) + { } + + unique_lock(mutex_type& __m, try_to_lock_t) + : _M_device(&__m), _M_owns(_M_device->try_lock()) + { } + + unique_lock(mutex_type& __m, adopt_lock_t) + : _M_device(&__m), _M_owns(true) + { + // XXX calling thread owns mutex + } + + template<typename _Clock, typename _Duration> + unique_lock(mutex_type& __m, + const chrono::time_point<_Clock, _Duration>& __atime) + : _M_device(&__m), _M_owns(_M_device->try_lock_until(__atime)) + { } + + template<typename _Rep, typename _Period> + unique_lock(mutex_type& __m, + const chrono::duration<_Rep, _Period>& __rtime) + : _M_device(&__m), _M_owns(_M_device->try_lock_for(__rtime)) + { } + + ~unique_lock() + { + if (_M_owns) + unlock(); + } + + unique_lock(const unique_lock&) = delete; + unique_lock& operator=(const unique_lock&) = delete; + + unique_lock(unique_lock&& __u) + : _M_device(__u._M_device), _M_owns(__u._M_owns) + { + __u._M_device = 0; + __u._M_owns = false; + } + + unique_lock& operator=(unique_lock&& __u) + { + if(_M_owns) + unlock(); + + unique_lock(std::move(__u)).swap(*this); + + __u._M_device = 0; + __u._M_owns = false; + + return *this; + } + + void + lock() + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_device->lock(); + _M_owns = true; + } + } + + bool + try_lock() + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_owns = _M_device->try_lock(); + return _M_owns; + } + } + + template<typename _Clock, typename _Duration> + bool + try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_owns = _M_device->try_lock_until(__atime); + return _M_owns; + } + } + + template<typename _Rep, typename _Period> + bool + try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_owns = _M_device->try_lock_for(__rtime); + return _M_owns; + } + } + + void + unlock() + { + if (!_M_owns) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_device) + { + _M_device->unlock(); + _M_owns = false; + } + } + + void + swap(unique_lock& __u) + { + std::swap(_M_device, __u._M_device); + std::swap(_M_owns, __u._M_owns); + } + + mutex_type* + release() + { + mutex_type* __ret = _M_device; + _M_device = 0; + _M_owns = false; + return __ret; + } + + bool + owns_lock() const + { return _M_owns; } + + explicit operator bool() const + { return owns_lock(); } + + mutex_type* + mutex() const + { return _M_device; } + + private: + mutex_type* _M_device; + bool _M_owns; // XXX use atomic_bool + }; + + template<typename _Mutex> + inline void + swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) + { __x.swap(__y); } + + template<int _Idx> + struct __unlock_impl + { + template<typename... _Lock> + static void + __do_unlock(tuple<_Lock&...>& __locks) + { + std::get<_Idx>(__locks).unlock(); + __unlock_impl<_Idx - 1>::__do_unlock(__locks); + } + }; + + template<> + struct __unlock_impl<-1> + { + template<typename... _Lock> + static void + __do_unlock(tuple<_Lock&...>&) + { } + }; + + template<typename _Lock> + unique_lock<_Lock> + __try_to_lock(_Lock& __l) + { return unique_lock<_Lock>(__l, try_to_lock); } + + template<int _Idx, bool _Continue = true> + struct __try_lock_impl + { + template<typename... _Lock> + static void + __do_try_lock(tuple<_Lock&...>& __locks, int& __idx) + { + __idx = _Idx; + auto __lock = __try_to_lock(std::get<_Idx>(__locks)); + if (__lock.owns_lock()) + { + __try_lock_impl<_Idx + 1, _Idx + 2 < sizeof...(_Lock)>:: + __do_try_lock(__locks, __idx); + if (__idx == -1) + __lock.release(); + } + } + }; + + template<int _Idx> + struct __try_lock_impl<_Idx, false> + { + template<typename... _Lock> + static void + __do_try_lock(tuple<_Lock&...>& __locks, int& __idx) + { + __idx = _Idx; + auto __lock = __try_to_lock(std::get<_Idx>(__locks)); + if (__lock.owns_lock()) + { + __idx = -1; + __lock.release(); + } + } + }; + + /** @brief Generic try_lock. + * @param __l1 Meets Mutex requirements (try_lock() may throw). + * @param __l2 Meets Mutex requirements (try_lock() may throw). + * @param __l3 Meets Mutex requirements (try_lock() may throw). + * @return Returns -1 if all try_lock() calls return true. Otherwise returns + * a 0-based index corresponding to the argument that returned false. + * @post Either all arguments are locked, or none will be. + * + * Sequentially calls try_lock() on each argument. + */ + template<typename _Lock1, typename _Lock2, typename... _Lock3> + int + try_lock(_Lock1& __l1, _Lock2& __l2, _Lock3&... __l3) + { + int __idx; + auto __locks = std::tie(__l1, __l2, __l3...); + __try + { __try_lock_impl<0>::__do_try_lock(__locks, __idx); } + __catch(...) + { } + return __idx; + } + + /** @brief Generic lock. + * @param __l1 Meets Mutex requirements (try_lock() may throw). + * @param __l2 Meets Mutex requirements (try_lock() may throw). + * @param __l3 Meets Mutex requirements (try_lock() may throw). + * @throw An exception thrown by an argument's lock() or try_lock() member. + * @post All arguments are locked. + * + * All arguments are locked via a sequence of calls to lock(), try_lock() + * and unlock(). If the call exits via an exception any locks that were + * obtained will be released. + */ + template<typename _L1, typename _L2, typename ..._L3> + void + lock(_L1& __l1, _L2& __l2, _L3&... __l3) + { + while (true) + { + unique_lock<_L1> __first(__l1); + int __idx; + auto __locks = std::tie(__l2, __l3...); + __try_lock_impl<0, sizeof...(_L3)>::__do_try_lock(__locks, __idx); + if (__idx == -1) + { + __first.release(); + return; + } + } + } + + /// once_flag + struct once_flag + { + private: + typedef __gthread_once_t __native_type; + __native_type _M_once; + + public: + constexpr once_flag() : _M_once(__GTHREAD_ONCE_INIT) { } + + once_flag(const once_flag&) = delete; + once_flag& operator=(const once_flag&) = delete; + + template<typename _Callable, typename... _Args> + friend void + call_once(once_flag& __once, _Callable&& __f, _Args&&... __args); + }; + +#ifdef _GLIBCXX_HAVE_TLS + extern __thread void* __once_callable; + extern __thread void (*__once_call)(); + + template<typename _Callable> + inline void + __once_call_impl() + { + (*(_Callable*)__once_callable)(); + } +#else + extern function<void()> __once_functor; + + extern void + __set_once_functor_lock_ptr(unique_lock<mutex>*); + + extern mutex& + __get_once_mutex(); +#endif + + extern "C" void __once_proxy(); + + /// call_once + template<typename _Callable, typename... _Args> + void + call_once(once_flag& __once, _Callable&& __f, _Args&&... __args) + { +#ifdef _GLIBCXX_HAVE_TLS + auto __bound_functor = std::bind<void>(std::forward<_Callable>(__f), + std::forward<_Args>(__args)...); + __once_callable = &__bound_functor; + __once_call = &__once_call_impl<decltype(__bound_functor)>; +#else + unique_lock<mutex> __functor_lock(__get_once_mutex()); + __once_functor = std::bind<void>(std::forward<_Callable>(__f), + std::forward<_Args>(__args)...); + __set_once_functor_lock_ptr(&__functor_lock); +#endif + + int __e = __gthread_once(&(__once._M_once), &__once_proxy); + +#ifndef _GLIBCXX_HAVE_TLS + if (__functor_lock) + __set_once_functor_lock_ptr(0); +#endif + + if (__e) + __throw_system_error(__e); + } + + // @} group mutexes +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_MUTEX diff --git a/libstdc++-v3/include/std/numeric b/libstdc++-v3/include/std/numeric new file mode 100644 index 000000000..1acedf4e6 --- /dev/null +++ b/libstdc++-v3/include/std/numeric @@ -0,0 +1,77 @@ +// <numeric> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2009 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * + * 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. + */ + +/** @file include/numeric + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_NUMERIC +#define _GLIBCXX_NUMERIC 1 + +#pragma GCC system_header + +#include <bits/c++config.h> +#include <bits/stl_iterator_base_types.h> +#include <bits/stl_numeric.h> + +#ifdef _GLIBCXX_PARALLEL +# include <parallel/numeric> +#endif + +/** + * @defgroup numerics Numerics + * + * Components for performing numeric operations. Includes support for + * for complex number types, random number generation, numeric + * (n-at-a-time) arrays, generalized numeric algorithms, and special + * math functions. + */ + +#endif /* _GLIBCXX_NUMERIC */ diff --git a/libstdc++-v3/include/std/ostream b/libstdc++-v3/include/std/ostream new file mode 100644 index 000000000..3004d4b69 --- /dev/null +++ b/libstdc++-v3/include/std/ostream @@ -0,0 +1,590 @@ +// Output streams -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +// 2006, 2007, 2008, 2009, 2010, 2011 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/ostream + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 14882: 27.6.2 Output streams +// + +#ifndef _GLIBCXX_OSTREAM +#define _GLIBCXX_OSTREAM 1 + +#pragma GCC system_header + +#include <ios> +#include <bits/ostream_insert.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // [27.6.2.1] Template class basic_ostream + /** + * @brief Controlling output. + * @ingroup io + * + * This is the base class for all output streams. It provides text + * formatting of all builtin types, and communicates with any class + * derived from basic_streambuf to do the actual output. + */ + template<typename _CharT, typename _Traits> + class basic_ostream : virtual public basic_ios<_CharT, _Traits> + { + public: + // Types (inherited from basic_ios (27.4.4)): + 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 basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef basic_ios<_CharT, _Traits> __ios_type; + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > + __num_put_type; + typedef ctype<_CharT> __ctype_type; + + // [27.6.2.2] constructor/destructor + /** + * @brief Base constructor. + * + * This ctor is almost never called by the user directly, rather from + * derived classes' initialization lists, which pass a pointer to + * their own stream buffer. + */ + explicit + basic_ostream(__streambuf_type* __sb) + { this->init(__sb); } + + /** + * @brief Base destructor. + * + * This does very little apart from providing a virtual base dtor. + */ + virtual + ~basic_ostream() { } + + // [27.6.2.3] prefix/suffix + class sentry; + friend class sentry; + + // [27.6.2.5] formatted output + // [27.6.2.5.3] basic_ostream::operator<< + //@{ + /** + * @brief Interface for manipulators. + * + * Manipulators such as @c std::endl and @c std::hex use these + * functions in constructs like "std::cout << std::endl". For more + * information, see the iomanip header. + */ + __ostream_type& + operator<<(__ostream_type& (*__pf)(__ostream_type&)) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 60. What is a formatted input function? + // The inserters for manipulators are *not* formatted output functions. + return __pf(*this); + } + + __ostream_type& + operator<<(__ios_type& (*__pf)(__ios_type&)) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 60. What is a formatted input function? + // The inserters for manipulators are *not* formatted output functions. + __pf(*this); + return *this; + } + + __ostream_type& + operator<<(ios_base& (*__pf) (ios_base&)) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 60. What is a formatted input function? + // The inserters for manipulators are *not* formatted output functions. + __pf(*this); + return *this; + } + //@} + + // [27.6.2.5.2] arithmetic inserters + /** + * @name Arithmetic Inserters + * + * All the @c operator<< functions (aka <em>formatted output + * functions</em>) have some common behavior. Each starts by + * constructing a temporary object of type std::basic_ostream::sentry. + * This can have several effects, concluding with the setting of a + * status flag; see the sentry documentation for more. + * + * If the sentry status is good, the function tries to generate + * whatever data is appropriate for the type of the argument. + * + * If an exception is thrown during insertion, ios_base::badbit + * will be turned on in the stream's error state without causing an + * ios_base::failure to be thrown. The original exception will then + * be rethrown. + */ + //@{ + /** + * @brief Basic arithmetic inserters + * @param A variable of builtin type. + * @return @c *this if successful + * + * These functions use the stream's current locale (specifically, the + * @c num_get facet) to perform numeric formatting. + */ + __ostream_type& + operator<<(long __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(unsigned long __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(bool __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(short __n); + + __ostream_type& + operator<<(unsigned short __n) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 117. basic_ostream uses nonexistent num_put member functions. + return _M_insert(static_cast<unsigned long>(__n)); + } + + __ostream_type& + operator<<(int __n); + + __ostream_type& + operator<<(unsigned int __n) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 117. basic_ostream uses nonexistent num_put member functions. + return _M_insert(static_cast<unsigned long>(__n)); + } + +#ifdef _GLIBCXX_USE_LONG_LONG + __ostream_type& + operator<<(long long __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(unsigned long long __n) + { return _M_insert(__n); } +#endif + + __ostream_type& + operator<<(double __f) + { return _M_insert(__f); } + + __ostream_type& + operator<<(float __f) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 117. basic_ostream uses nonexistent num_put member functions. + return _M_insert(static_cast<double>(__f)); + } + + __ostream_type& + operator<<(long double __f) + { return _M_insert(__f); } + + __ostream_type& + operator<<(const void* __p) + { return _M_insert(__p); } + + /** + * @brief Extracting from another streambuf. + * @param sb A pointer to a streambuf + * + * This function behaves like one of the basic arithmetic extractors, + * in that it also constructs a sentry object and has the same error + * handling behavior. + * + * If @a sb is NULL, the stream will set failbit in its error state. + * + * Characters are extracted from @a sb and inserted into @c *this + * until one of the following occurs: + * + * - the input stream reaches end-of-file, + * - insertion into the output sequence fails (in this case, the + * character that would have been inserted is not extracted), or + * - an exception occurs while getting a character from @a sb, which + * sets failbit in the error state + * + * If the function inserts no characters, failbit is set. + */ + __ostream_type& + operator<<(__streambuf_type* __sb); + //@} + + // [27.6.2.6] unformatted output functions + /** + * @name Unformatted Output Functions + * + * All the unformatted output functions have some common behavior. + * Each starts by constructing a temporary object of type + * std::basic_ostream::sentry. This has several effects, concluding + * with the setting of a status flag; see the sentry documentation + * for more. + * + * If the sentry status is good, the function tries to generate + * whatever data is appropriate for the type of the argument. + * + * If an exception is thrown during insertion, ios_base::badbit + * will be turned on in the stream's error state. If badbit is on in + * the stream's exceptions mask, the exception will be rethrown + * without completing its actions. + */ + //@{ + /** + * @brief Simple insertion. + * @param c The character to insert. + * @return *this + * + * Tries to insert @a c. + * + * @note This function is not overloaded on signed char and + * unsigned char. + */ + __ostream_type& + put(char_type __c); + + // Core write functionality, without sentry. + void + _M_write(const char_type* __s, streamsize __n) + { + const streamsize __put = this->rdbuf()->sputn(__s, __n); + if (__put != __n) + this->setstate(ios_base::badbit); + } + + /** + * @brief Character string insertion. + * @param s The array to insert. + * @param n Maximum number of characters to insert. + * @return *this + * + * Characters are copied from @a s and inserted into the stream until + * one of the following happens: + * + * - @a n characters are inserted + * - inserting into the output sequence fails (in this case, badbit + * will be set in the stream's error state) + * + * @note This function is not overloaded on signed char and + * unsigned char. + */ + __ostream_type& + write(const char_type* __s, streamsize __n); + //@} + + /** + * @brief Synchronizing the stream buffer. + * @return *this + * + * If @c rdbuf() is a null pointer, changes nothing. + * + * Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1, + * sets badbit. + */ + __ostream_type& + flush(); + + // [27.6.2.4] seek members + /** + * @brief Getting the current write position. + * @return A file position object. + * + * If @c fail() is not false, returns @c pos_type(-1) to indicate + * failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,out). + */ + pos_type + tellp(); + + /** + * @brief Changing the current write position. + * @param pos A file position object. + * @return *this + * + * If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If + * that function fails, sets failbit. + */ + __ostream_type& + seekp(pos_type); + + /** + * @brief Changing the current write position. + * @param off A file offset object. + * @param dir The direction in which to seek. + * @return *this + * + * If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir). + * If that function fails, sets failbit. + */ + __ostream_type& + seekp(off_type, ios_base::seekdir); + + protected: + basic_ostream() + { this->init(0); } + + template<typename _ValueT> + __ostream_type& + _M_insert(_ValueT __v); + }; + + /** + * @brief Performs setup work for output streams. + * + * Objects of this class are created before all of the standard + * inserters are run. It is responsible for <em>exception-safe prefix and + * suffix operations</em>. + */ + template <typename _CharT, typename _Traits> + class basic_ostream<_CharT, _Traits>::sentry + { + // Data Members. + bool _M_ok; + basic_ostream<_CharT, _Traits>& _M_os; + + public: + /** + * @brief The constructor performs preparatory work. + * @param os The output stream to guard. + * + * If the stream state is good (@a os.good() is true), then if the + * stream is tied to another output stream, @c is.tie()->flush() + * is called to synchronize the output sequences. + * + * If the stream state is still good, then the sentry state becomes + * true (@a okay). + */ + explicit + sentry(basic_ostream<_CharT, _Traits>& __os); + + /** + * @brief Possibly flushes the stream. + * + * If @c ios_base::unitbuf is set in @c os.flags(), and + * @c std::uncaught_exception() is true, the sentry destructor calls + * @c flush() on the output stream. + */ + ~sentry() + { + // XXX MT + if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception()) + { + // Can't call flush directly or else will get into recursive lock. + if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1) + _M_os.setstate(ios_base::badbit); + } + } + + /** + * @brief Quick status checking. + * @return The sentry state. + * + * For ease of use, sentries may be converted to booleans. The + * return value is that of the sentry state (true == okay). + */ +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + explicit +#endif + operator bool() const + { return _M_ok; } + }; + + // [27.6.2.5.4] character insertion templates + //@{ + /** + * @brief Character inserters + * @param out An output stream. + * @param c A character. + * @return out + * + * Behaves like one of the formatted arithmetic inserters described in + * std::basic_ostream. After constructing a sentry object with good + * status, this function inserts a single character and any required + * padding (as determined by [22.2.2.2.2]). @c out.width(0) is then + * called. + * + * If @a c is of type @c char and the character type of the stream is not + * @c char, the character is widened before insertion. + */ + template<typename _CharT, typename _Traits> + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) + { return __ostream_insert(__out, &__c, 1); } + + template<typename _CharT, typename _Traits> + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) + { return (__out << __out.widen(__c)); } + + // Specialization + template <class _Traits> + inline basic_ostream<char, _Traits>& + operator<<(basic_ostream<char, _Traits>& __out, char __c) + { return __ostream_insert(__out, &__c, 1); } + + // Signed and unsigned + template<class _Traits> + inline basic_ostream<char, _Traits>& + operator<<(basic_ostream<char, _Traits>& __out, signed char __c) + { return (__out << static_cast<char>(__c)); } + + template<class _Traits> + inline basic_ostream<char, _Traits>& + operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c) + { return (__out << static_cast<char>(__c)); } + //@} + + //@{ + /** + * @brief String inserters + * @param out An output stream. + * @param s A character string. + * @return out + * @pre @a s must be a non-NULL pointer + * + * Behaves like one of the formatted arithmetic inserters described in + * std::basic_ostream. After constructing a sentry object with good + * status, this function inserts @c traits::length(s) characters starting + * at @a s, widened if necessary, followed by any required padding (as + * determined by [22.2.2.2.2]). @c out.width(0) is then called. + */ + template<typename _CharT, typename _Traits> + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s) + { + if (!__s) + __out.setstate(ios_base::badbit); + else + __ostream_insert(__out, __s, + static_cast<streamsize>(_Traits::length(__s))); + return __out; + } + + template<typename _CharT, typename _Traits> + basic_ostream<_CharT, _Traits> & + operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s); + + // Partial specializations + template<class _Traits> + inline basic_ostream<char, _Traits>& + operator<<(basic_ostream<char, _Traits>& __out, const char* __s) + { + if (!__s) + __out.setstate(ios_base::badbit); + else + __ostream_insert(__out, __s, + static_cast<streamsize>(_Traits::length(__s))); + return __out; + } + + // Signed and unsigned + template<class _Traits> + inline basic_ostream<char, _Traits>& + operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s) + { return (__out << reinterpret_cast<const char*>(__s)); } + + template<class _Traits> + inline basic_ostream<char, _Traits> & + operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s) + { return (__out << reinterpret_cast<const char*>(__s)); } + //@} + + // [27.6.2.7] standard basic_ostream manipulators + /** + * @brief Write a newline and flush the stream. + * + * This manipulator is often mistakenly used when a simple newline is + * desired, leading to poor buffering performance. See + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html + * for more on this subject. + */ + template<typename _CharT, typename _Traits> + inline basic_ostream<_CharT, _Traits>& + endl(basic_ostream<_CharT, _Traits>& __os) + { return flush(__os.put(__os.widen('\n'))); } + + /** + * @brief Write a null character into the output sequence. + * + * <em>Null character</em> is @c CharT() by definition. For CharT of @c char, + * this correctly writes the ASCII @c NUL character string terminator. + */ + template<typename _CharT, typename _Traits> + inline basic_ostream<_CharT, _Traits>& + ends(basic_ostream<_CharT, _Traits>& __os) + { return __os.put(_CharT()); } + + /** + * @brief Flushes the output stream. + * + * This manipulator simply calls the stream's @c flush() member function. + */ + template<typename _CharT, typename _Traits> + inline basic_ostream<_CharT, _Traits>& + flush(basic_ostream<_CharT, _Traits>& __os) + { return __os.flush(); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // [27.7.2.9] Rvalue stream insertion + /** + * @brief Generic inserter for rvalue stream + * @param os An input stream. + * @param x A reference to the object being inserted. + * @return os + * + * This is just a forwarding function to allow insertion to + * rvalue streams since they won't bind to the inserter functions + * that take an lvalue reference. + */ + template<typename _CharT, typename _Traits, typename _Tp> + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x) + { return (__os << __x); } +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#include <bits/ostream.tcc> + +#endif /* _GLIBCXX_OSTREAM */ diff --git a/libstdc++-v3/include/std/queue b/libstdc++-v3/include/std/queue new file mode 100644 index 000000000..abf984212 --- /dev/null +++ b/libstdc++-v3/include/std/queue @@ -0,0 +1,67 @@ +// <queue> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * + * 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. + */ + +/** @file include/queue + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_QUEUE +#define _GLIBCXX_QUEUE 1 + +#pragma GCC system_header + +#include <deque> +#include <vector> +#include <bits/stl_heap.h> +#include <bits/stl_function.h> +#include <bits/stl_queue.h> + +#endif /* _GLIBCXX_QUEUE */ diff --git a/libstdc++-v3/include/std/random b/libstdc++-v3/include/std/random new file mode 100644 index 000000000..59aed8ef9 --- /dev/null +++ b/libstdc++-v3/include/std/random @@ -0,0 +1,57 @@ +// <random> -*- C++ -*- + +// Copyright (C) 2007, 2008, 2009, 2010, 2011 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/random + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_RANDOM +#define _GLIBCXX_RANDOM 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <cmath> +#include <cstdio> +#include <cstdlib> +#include <string> +#include <iosfwd> +#include <limits> +#include <debug/debug.h> +#include <type_traits> + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + +#include <cstdint> // For uint_fast32_t, uint_fast64_t, uint_least32_t +#include <bits/random.h> +#include <bits/random.tcc> + +#endif // _GLIBCXX_USE_C99_STDINT_TR1 + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_RANDOM diff --git a/libstdc++-v3/include/std/ratio b/libstdc++-v3/include/std/ratio new file mode 100644 index 000000000..17d28a10f --- /dev/null +++ b/libstdc++-v3/include/std/ratio @@ -0,0 +1,393 @@ +// ratio -*- C++ -*- + +// Copyright (C) 2008, 2009, 2010, 2011 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/ratio + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_RATIO +#define _GLIBCXX_RATIO 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <type_traits> +#include <cstdint> + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup ratio Rational Arithmetic + * @ingroup utilities + * + * Compile time representation of finite rational numbers. + * @{ + */ + + template<intmax_t _Pn> + struct __static_sign + : integral_constant<intmax_t, (_Pn < 0) ? -1 : 1> + { }; + + template<intmax_t _Pn> + struct __static_abs + : integral_constant<intmax_t, _Pn * __static_sign<_Pn>::value> + { }; + + template<intmax_t _Pn, intmax_t _Qn> + struct __static_gcd; + + template<intmax_t _Pn, intmax_t _Qn> + struct __static_gcd + : __static_gcd<_Qn, (_Pn % _Qn)> + { }; + + template<intmax_t _Pn> + struct __static_gcd<_Pn, 0> + : integral_constant<intmax_t, __static_abs<_Pn>::value> + { }; + + template<intmax_t _Qn> + struct __static_gcd<0, _Qn> + : integral_constant<intmax_t, __static_abs<_Qn>::value> + { }; + + // Let c = 2^(half # of bits in an intmax_t) + // then we find a1, a0, b1, b0 s.t. N = a1*c + a0, M = b1*c + b0 + // The multiplication of N and M becomes, + // N * M = (a1 * b1)c^2 + (a0 * b1 + b0 * a1)c + a0 * b0 + // Multiplication is safe if each term and the sum of the terms + // is representable by intmax_t. + template<intmax_t _Pn, intmax_t _Qn> + struct __safe_multiply + { + private: + static const uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4); + + static const uintmax_t __a0 = __static_abs<_Pn>::value % __c; + static const uintmax_t __a1 = __static_abs<_Pn>::value / __c; + static const uintmax_t __b0 = __static_abs<_Qn>::value % __c; + static const uintmax_t __b1 = __static_abs<_Qn>::value / __c; + + static_assert(__a1 == 0 || __b1 == 0, + "overflow in multiplication"); + static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1), + "overflow in multiplication"); + static_assert(__b0 * __a0 <= __INTMAX_MAX__, + "overflow in multiplication"); + static_assert((__a0 * __b1 + __b0 * __a1) * __c <= + __INTMAX_MAX__ - __b0 * __a0, "overflow in multiplication"); + + public: + static const intmax_t value = _Pn * _Qn; + }; + + // Helpers for __safe_add + template<intmax_t _Pn, intmax_t _Qn, bool> + struct __add_overflow_check_impl + : integral_constant<bool, (_Pn <= __INTMAX_MAX__ - _Qn)> + { }; + + template<intmax_t _Pn, intmax_t _Qn> + struct __add_overflow_check_impl<_Pn, _Qn, false> + : integral_constant<bool, (_Pn >= -__INTMAX_MAX__ - _Qn)> + { }; + + template<intmax_t _Pn, intmax_t _Qn> + struct __add_overflow_check + : __add_overflow_check_impl<_Pn, _Qn, (_Qn >= 0)> + { }; + + template<intmax_t _Pn, intmax_t _Qn> + struct __safe_add + { + static_assert(__add_overflow_check<_Pn, _Qn>::value != 0, + "overflow in addition"); + + static const intmax_t value = _Pn + _Qn; + }; + + /** + * @brief Provides compile-time rational arithmetic. + * + * This class template represents any finite rational number with a + * numerator and denominator representable by compile-time constants of + * type intmax_t. The ratio is simplified when instantiated. + * + * For example: + * @code + * std::ratio<7,-21>::num == -1; + * std::ratio<7,-21>::den == 3; + * @endcode + * + */ + template<intmax_t _Num, intmax_t _Den = 1> + struct ratio + { + static_assert(_Den != 0, "denominator cannot be zero"); + static_assert(_Num >= -__INTMAX_MAX__ && _Den >= -__INTMAX_MAX__, + "out of range"); + + // Note: sign(N) * abs(N) == N + static constexpr intmax_t num = + _Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value; + + static constexpr intmax_t den = + __static_abs<_Den>::value / __static_gcd<_Num, _Den>::value; + + typedef ratio<num, den> type; + }; + + template<intmax_t _Num, intmax_t _Den> + constexpr intmax_t ratio<_Num, _Den>::num; + + template<intmax_t _Num, intmax_t _Den> + constexpr intmax_t ratio<_Num, _Den>::den; + + /// ratio_add + template<typename _R1, typename _R2> + struct ratio_add + { + private: + static constexpr intmax_t __gcd = + __static_gcd<_R1::den, _R2::den>::value; + static constexpr intmax_t __n = __safe_add< + __safe_multiply<_R1::num, (_R2::den / __gcd)>::value, + __safe_multiply<_R2::num, (_R1::den / __gcd)>::value>::value; + + // The new numerator may have common factors with the denominator, + // but they have to also be factors of __gcd. + static constexpr intmax_t __gcd2 = __static_gcd<__n, __gcd>::value; + + public: + typedef ratio<__n / __gcd2, + __safe_multiply<_R1::den / __gcd2, _R2::den / __gcd>::value> type; + + static constexpr intmax_t num = type::num; + static constexpr intmax_t den = type::den; + }; + + template<typename _R1, typename _R2> + constexpr intmax_t ratio_add<_R1, _R2>::num; + + template<typename _R1, typename _R2> + constexpr intmax_t ratio_add<_R1, _R2>::den; + + /// ratio_subtract + template<typename _R1, typename _R2> + struct ratio_subtract + { + typedef typename ratio_add< + _R1, + ratio<-_R2::num, _R2::den>>::type type; + + static constexpr intmax_t num = type::num; + static constexpr intmax_t den = type::den; + }; + + template<typename _R1, typename _R2> + constexpr intmax_t ratio_subtract<_R1, _R2>::num; + + template<typename _R1, typename _R2> + constexpr intmax_t ratio_subtract<_R1, _R2>::den; + + /// ratio_multiply + template<typename _R1, typename _R2> + struct ratio_multiply + { + private: + static const intmax_t __gcd1 = + __static_gcd<_R1::num, _R2::den>::value; + static const intmax_t __gcd2 = + __static_gcd<_R2::num, _R1::den>::value; + + public: + typedef ratio< + __safe_multiply<(_R1::num / __gcd1), + (_R2::num / __gcd2)>::value, + __safe_multiply<(_R1::den / __gcd2), + (_R2::den / __gcd1)>::value> type; + + static constexpr intmax_t num = type::num; + static constexpr intmax_t den = type::den; + }; + + template<typename _R1, typename _R2> + constexpr intmax_t ratio_multiply<_R1, _R2>::num; + + template<typename _R1, typename _R2> + constexpr intmax_t ratio_multiply<_R1, _R2>::den; + + /// ratio_divide + template<typename _R1, typename _R2> + struct ratio_divide + { + static_assert(_R2::num != 0, "division by 0"); + + typedef typename ratio_multiply< + _R1, + ratio<_R2::den, _R2::num>>::type type; + + static constexpr intmax_t num = type::num; + static constexpr intmax_t den = type::den; + }; + + template<typename _R1, typename _R2> + constexpr intmax_t ratio_divide<_R1, _R2>::num; + + template<typename _R1, typename _R2> + constexpr intmax_t ratio_divide<_R1, _R2>::den; + + /// ratio_equal + template<typename _R1, typename _R2> + struct ratio_equal + : integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> + { }; + + /// ratio_not_equal + template<typename _R1, typename _R2> + struct ratio_not_equal + : integral_constant<bool, !ratio_equal<_R1, _R2>::value> + { }; + + // 0 <= _Ri < 1 + // If one is 0, conclude + // Otherwise, x < y iff 1/y < 1/x + template<typename _R1, typename _R2> + struct __ratio_less_impl_2; + + // _Ri > 0 + // Compare the integral parts, and remove them if they are equal + template<typename _R1, typename _R2, intmax_t __q1 = _R1::num / _R1::den, + intmax_t __q2 = _R2::num / _R2::den, bool __eq = (__q1 == __q2)> + struct __ratio_less_impl_1 + : __ratio_less_impl_2<ratio<_R1::num % _R1::den, _R1::den>, + ratio<_R2::num % _R2::den, _R2::den> >::type + { }; + + template<typename _R1, typename _R2, intmax_t __q1, intmax_t __q2> + struct __ratio_less_impl_1<_R1, _R2, __q1, __q2, false> + : integral_constant<bool, (__q1 < __q2) > + { }; + + template<typename _R1, typename _R2> + struct __ratio_less_impl_2 + : __ratio_less_impl_1<ratio<_R2::den, _R2::num>, + ratio<_R1::den, _R1::num> >::type + { }; + + template<intmax_t __d1, typename _R2> + struct __ratio_less_impl_2<ratio<0, __d1>, _R2> + : integral_constant<bool, true> + { }; + + template<typename _R1, intmax_t __d2> + struct __ratio_less_impl_2<_R1, ratio<0, __d2> > + : integral_constant<bool, false> + { }; + + template<intmax_t __d1, intmax_t __d2> + struct __ratio_less_impl_2<ratio<0, __d1>, ratio<0, __d2> > + : integral_constant<bool, false> + { }; + + template<typename _R1, typename _R2, + bool = (_R1::num == 0 || _R2::num == 0 + || (__static_sign<_R1::num>::value + != __static_sign<_R2::num>::value)), + bool = (__static_sign<_R1::num>::value == -1 + && __static_sign<_R2::num>::value == -1)> + struct __ratio_less_impl + : __ratio_less_impl_1<_R1, _R2>::type + { }; + + template<typename _R1, typename _R2> + struct __ratio_less_impl<_R1, _R2, true, false> + : integral_constant<bool, _R1::num < _R2::num> + { }; + + template<typename _R1, typename _R2> + struct __ratio_less_impl<_R1, _R2, false, true> + : __ratio_less_impl_1<ratio<-_R2::num, _R2::den>, + ratio<-_R1::num, _R1::den> >::type + { }; + + /// ratio_less + // using a continued fraction expansion + template<typename _R1, typename _R2> + struct ratio_less + : __ratio_less_impl<_R1, _R2>::type + { }; + + /// ratio_less_equal + template<typename _R1, typename _R2> + struct ratio_less_equal + : integral_constant<bool, !ratio_less<_R2, _R1>::value> + { }; + + /// ratio_greater + template<typename _R1, typename _R2> + struct ratio_greater + : integral_constant<bool, ratio_less<_R2, _R1>::value> + { }; + + /// ratio_greater_equal + template<typename _R1, typename _R2> + struct ratio_greater_equal + : integral_constant<bool, !ratio_less<_R1, _R2>::value> + { }; + + typedef ratio<1, 1000000000000000000> atto; + typedef ratio<1, 1000000000000000> femto; + typedef ratio<1, 1000000000000> pico; + typedef ratio<1, 1000000000> nano; + typedef ratio<1, 1000000> micro; + typedef ratio<1, 1000> milli; + typedef ratio<1, 100> centi; + typedef ratio<1, 10> deci; + typedef ratio< 10, 1> deca; + typedef ratio< 100, 1> hecto; + typedef ratio< 1000, 1> kilo; + typedef ratio< 1000000, 1> mega; + typedef ratio< 1000000000, 1> giga; + typedef ratio< 1000000000000, 1> tera; + typedef ratio< 1000000000000000, 1> peta; + typedef ratio< 1000000000000000000, 1> exa; + + // @} group ratio +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif //_GLIBCXX_USE_C99_STDINT_TR1 + +#endif //__GXX_EXPERIMENTAL_CXX0X__ + +#endif //_GLIBCXX_RATIO diff --git a/libstdc++-v3/include/std/regex b/libstdc++-v3/include/std/regex new file mode 100644 index 000000000..eabb84307 --- /dev/null +++ b/libstdc++-v3/include/std/regex @@ -0,0 +1,66 @@ +// <regex> -*- C++ -*- + +// Copyright (C) 2007, 2008, 2009, 2010 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/regex + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_REGEX +#define _GLIBCXX_REGEX 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <algorithm> +#include <bitset> +#include <functional> +#ifdef _GLIBCXX_DEBUG +# include <iosfwd> +#endif +#include <iterator> +#include <locale> +#include <memory> +#include <set> +#include <sstream> +#include <stack> +#include <stdexcept> +#include <string> +#include <utility> +#include <vector> + +#include <bits/range_access.h> +#include <bits/regex_constants.h> +#include <bits/regex_error.h> +#include <bits/regex_cursor.h> +#include <bits/regex_nfa.h> +#include <bits/regex_compiler.h> +#include <bits/regex_grep_matcher.h> +#include <bits/regex.h> + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_REGEX diff --git a/libstdc++-v3/include/std/set b/libstdc++-v3/include/std/set new file mode 100644 index 000000000..52fcbaa21 --- /dev/null +++ b/libstdc++-v3/include/std/set @@ -0,0 +1,73 @@ +// <set> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2009, 2010 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * + * 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. + */ + +/** @file include/set + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_SET +#define _GLIBCXX_SET 1 + +#pragma GCC system_header + +#include <bits/stl_tree.h> +#include <bits/stl_set.h> +#include <bits/stl_multiset.h> +#include <bits/range_access.h> + +#ifdef _GLIBCXX_DEBUG +# include <debug/set> +#endif + +#ifdef _GLIBCXX_PROFILE +# include <profile/set> +#endif + +#endif /* _GLIBCXX_SET */ diff --git a/libstdc++-v3/include/std/sstream b/libstdc++-v3/include/std/sstream new file mode 100644 index 000000000..bf2862add --- /dev/null +++ b/libstdc++-v3/include/std/sstream @@ -0,0 +1,582 @@ +// String based streams -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +// 2006, 2008, 2009, 2010, 2011 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/sstream + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 14882: 27.7 String-based streams +// + +#ifndef _GLIBCXX_SSTREAM +#define _GLIBCXX_SSTREAM 1 + +#pragma GCC system_header + +#include <istream> +#include <ostream> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // [27.7.1] template class basic_stringbuf + /** + * @brief The actual work of input and output (for std::string). + * @ingroup io + * + * This class associates either or both of its input and output sequences + * with a sequence of characters, which can be initialized from, or made + * available as, a @c std::basic_string. (Paraphrased from [27.7.1]/1.) + * + * For this class, open modes (of type @c ios_base::openmode) have + * @c in set if the input sequence can be read, and @c out set if the + * output sequence can be written. + */ + template<typename _CharT, typename _Traits, typename _Alloc> + class basic_stringbuf : public basic_streambuf<_CharT, _Traits> + { + public: + // Types: + typedef _CharT char_type; + typedef _Traits traits_type; + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 251. basic_stringbuf missing allocator_type + typedef _Alloc allocator_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + typedef basic_streambuf<char_type, traits_type> __streambuf_type; + typedef basic_string<char_type, _Traits, _Alloc> __string_type; + typedef typename __string_type::size_type __size_type; + + protected: + /// Place to stash in || out || in | out settings for current stringbuf. + ios_base::openmode _M_mode; + + // Data Members: + __string_type _M_string; + + public: + // Constructors: + /** + * @brief Starts with an empty string buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * The default constructor initializes the parent class using its + * own default ctor. + */ + explicit + basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out) + : __streambuf_type(), _M_mode(__mode), _M_string() + { } + + /** + * @brief Starts with an existing string buffer. + * @param str A string to copy as a starting buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * This constructor initializes the parent class using its + * own default ctor. + */ + explicit + basic_stringbuf(const __string_type& __str, + ios_base::openmode __mode = ios_base::in | ios_base::out) + : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size()) + { _M_stringbuf_init(__mode); } + + // Get and set: + /** + * @brief Copying out the string buffer. + * @return A copy of one of the underlying sequences. + * + * <em>If the buffer is only created in input mode, the underlying + * character sequence is equal to the input sequence; otherwise, it + * is equal to the output sequence.</em> [27.7.1.2]/1 + */ + __string_type + str() const + { + __string_type __ret; + if (this->pptr()) + { + // The current egptr() may not be the actual string end. + if (this->pptr() > this->egptr()) + __ret = __string_type(this->pbase(), this->pptr()); + else + __ret = __string_type(this->pbase(), this->egptr()); + } + else + __ret = _M_string; + return __ret; + } + + /** + * @brief Setting a new buffer. + * @param s The string to use as a new sequence. + * + * Deallocates any previous stored sequence, then copies @a s to + * use as a new one. + */ + void + str(const __string_type& __s) + { + // Cannot use _M_string = __s, since v3 strings are COW. + _M_string.assign(__s.data(), __s.size()); + _M_stringbuf_init(_M_mode); + } + + protected: + // Common initialization code goes here. + void + _M_stringbuf_init(ios_base::openmode __mode) + { + _M_mode = __mode; + __size_type __len = 0; + if (_M_mode & (ios_base::ate | ios_base::app)) + __len = _M_string.size(); + _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len); + } + + virtual streamsize + showmanyc() + { + streamsize __ret = -1; + if (_M_mode & ios_base::in) + { + _M_update_egptr(); + __ret = this->egptr() - this->gptr(); + } + return __ret; + } + + virtual int_type + underflow(); + + virtual int_type + pbackfail(int_type __c = traits_type::eof()); + + virtual int_type + overflow(int_type __c = traits_type::eof()); + + /** + * @brief Manipulates the buffer. + * @param s Pointer to a buffer area. + * @param n Size of @a s. + * @return @c this + * + * If no buffer has already been created, and both @a s and @a n are + * non-zero, then @c s is used as a buffer; see + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html + * for more. + */ + virtual __streambuf_type* + setbuf(char_type* __s, streamsize __n) + { + if (__s && __n >= 0) + { + // This is implementation-defined behavior, and assumes + // that an external char_type array of length __n exists + // and has been pre-allocated. If this is not the case, + // things will quickly blow up. + + // Step 1: Destroy the current internal array. + _M_string.clear(); + + // Step 2: Use the external array. + _M_sync(__s, __n, 0); + } + return this; + } + + virtual pos_type + seekoff(off_type __off, ios_base::seekdir __way, + ios_base::openmode __mode = ios_base::in | ios_base::out); + + virtual pos_type + seekpos(pos_type __sp, + ios_base::openmode __mode = ios_base::in | ios_base::out); + + // Internal function for correctly updating the internal buffer + // for a particular _M_string, due to initialization or re-sizing + // of an existing _M_string. + void + _M_sync(char_type* __base, __size_type __i, __size_type __o); + + // Internal function for correctly updating egptr() to the actual + // string end. + void + _M_update_egptr() + { + const bool __testin = _M_mode & ios_base::in; + if (this->pptr() && this->pptr() > this->egptr()) + { + if (__testin) + this->setg(this->eback(), this->gptr(), this->pptr()); + else + this->setg(this->pptr(), this->pptr(), this->pptr()); + } + } + + // Works around the issue with pbump, part of the protected + // interface of basic_streambuf, taking just an int. + void + _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off); + }; + + + // [27.7.2] Template class basic_istringstream + /** + * @brief Controlling input for std::string. + * @ingroup io + * + * This class supports reading from objects of type std::basic_string, + * using the inherited functions from std::basic_istream. To control + * the associated sequence, an instance of std::basic_stringbuf is used, + * which this page refers to as @c sb. + */ + template<typename _CharT, typename _Traits, typename _Alloc> + class basic_istringstream : public basic_istream<_CharT, _Traits> + { + public: + // Types: + typedef _CharT char_type; + typedef _Traits traits_type; + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 251. basic_stringbuf missing allocator_type + typedef _Alloc allocator_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + // Non-standard types: + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; + typedef basic_istream<char_type, traits_type> __istream_type; + + private: + __stringbuf_type _M_stringbuf; + + public: + // Constructors: + /** + * @brief Default constructor starts with an empty string buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * @c ios_base::in is automatically included in @a mode. + * + * Initializes @c sb using @c mode|in, and passes @c &sb to the base + * class initializer. Does not allocate any buffer. + * + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + */ + explicit + basic_istringstream(ios_base::openmode __mode = ios_base::in) + : __istream_type(), _M_stringbuf(__mode | ios_base::in) + { this->init(&_M_stringbuf); } + + /** + * @brief Starts with an existing string buffer. + * @param str A string to copy as a starting buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * @c ios_base::in is automatically included in @a mode. + * + * Initializes @c sb using @a str and @c mode|in, and passes @c &sb + * to the base class initializer. + * + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + */ + explicit + basic_istringstream(const __string_type& __str, + ios_base::openmode __mode = ios_base::in) + : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in) + { this->init(&_M_stringbuf); } + + /** + * @brief The destructor does nothing. + * + * The buffer is deallocated by the stringbuf object, not the + * formatting stream. + */ + ~basic_istringstream() + { } + + // Members: + /** + * @brief Accessing the underlying buffer. + * @return The current basic_stringbuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). + */ + __stringbuf_type* + rdbuf() const + { return const_cast<__stringbuf_type*>(&_M_stringbuf); } + + /** + * @brief Copying out the string buffer. + * @return @c rdbuf()->str() + */ + __string_type + str() const + { return _M_stringbuf.str(); } + + /** + * @brief Setting a new buffer. + * @param s The string to use as a new sequence. + * + * Calls @c rdbuf()->str(s). + */ + void + str(const __string_type& __s) + { _M_stringbuf.str(__s); } + }; + + + // [27.7.3] Template class basic_ostringstream + /** + * @brief Controlling output for std::string. + * @ingroup io + * + * This class supports writing to objects of type std::basic_string, + * using the inherited functions from std::basic_ostream. To control + * the associated sequence, an instance of std::basic_stringbuf is used, + * which this page refers to as @c sb. + */ + template <typename _CharT, typename _Traits, typename _Alloc> + class basic_ostringstream : public basic_ostream<_CharT, _Traits> + { + public: + // Types: + typedef _CharT char_type; + typedef _Traits traits_type; + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 251. basic_stringbuf missing allocator_type + typedef _Alloc allocator_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + // Non-standard types: + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; + typedef basic_ostream<char_type, traits_type> __ostream_type; + + private: + __stringbuf_type _M_stringbuf; + + public: + // Constructors/destructor: + /** + * @brief Default constructor starts with an empty string buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * @c ios_base::out is automatically included in @a mode. + * + * Initializes @c sb using @c mode|out, and passes @c &sb to the base + * class initializer. Does not allocate any buffer. + * + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + */ + explicit + basic_ostringstream(ios_base::openmode __mode = ios_base::out) + : __ostream_type(), _M_stringbuf(__mode | ios_base::out) + { this->init(&_M_stringbuf); } + + /** + * @brief Starts with an existing string buffer. + * @param str A string to copy as a starting buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * @c ios_base::out is automatically included in @a mode. + * + * Initializes @c sb using @a str and @c mode|out, and passes @c &sb + * to the base class initializer. + * + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + */ + explicit + basic_ostringstream(const __string_type& __str, + ios_base::openmode __mode = ios_base::out) + : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out) + { this->init(&_M_stringbuf); } + + /** + * @brief The destructor does nothing. + * + * The buffer is deallocated by the stringbuf object, not the + * formatting stream. + */ + ~basic_ostringstream() + { } + + // Members: + /** + * @brief Accessing the underlying buffer. + * @return The current basic_stringbuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). + */ + __stringbuf_type* + rdbuf() const + { return const_cast<__stringbuf_type*>(&_M_stringbuf); } + + /** + * @brief Copying out the string buffer. + * @return @c rdbuf()->str() + */ + __string_type + str() const + { return _M_stringbuf.str(); } + + /** + * @brief Setting a new buffer. + * @param s The string to use as a new sequence. + * + * Calls @c rdbuf()->str(s). + */ + void + str(const __string_type& __s) + { _M_stringbuf.str(__s); } + }; + + + // [27.7.4] Template class basic_stringstream + /** + * @brief Controlling input and output for std::string. + * @ingroup io + * + * This class supports reading from and writing to objects of type + * std::basic_string, using the inherited functions from + * std::basic_iostream. To control the associated sequence, an instance + * of std::basic_stringbuf is used, which this page refers to as @c sb. + */ + template <typename _CharT, typename _Traits, typename _Alloc> + class basic_stringstream : public basic_iostream<_CharT, _Traits> + { + public: + // Types: + typedef _CharT char_type; + typedef _Traits traits_type; + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 251. basic_stringbuf missing allocator_type + typedef _Alloc allocator_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + // Non-standard Types: + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; + typedef basic_iostream<char_type, traits_type> __iostream_type; + + private: + __stringbuf_type _M_stringbuf; + + public: + // Constructors/destructors + /** + * @brief Default constructor starts with an empty string buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * Initializes @c sb using @c mode, and passes @c &sb to the base + * class initializer. Does not allocate any buffer. + * + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + */ + explicit + basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in) + : __iostream_type(), _M_stringbuf(__m) + { this->init(&_M_stringbuf); } + + /** + * @brief Starts with an existing string buffer. + * @param str A string to copy as a starting buffer. + * @param mode Whether the buffer can read, or write, or both. + * + * Initializes @c sb using @a str and @c mode, and passes @c &sb + * to the base class initializer. + * + * That's a lie. We initialize the base class with NULL, because the + * string class does its own memory management. + */ + explicit + basic_stringstream(const __string_type& __str, + ios_base::openmode __m = ios_base::out | ios_base::in) + : __iostream_type(), _M_stringbuf(__str, __m) + { this->init(&_M_stringbuf); } + + /** + * @brief The destructor does nothing. + * + * The buffer is deallocated by the stringbuf object, not the + * formatting stream. + */ + ~basic_stringstream() + { } + + // Members: + /** + * @brief Accessing the underlying buffer. + * @return The current basic_stringbuf buffer. + * + * This hides both signatures of std::basic_ios::rdbuf(). + */ + __stringbuf_type* + rdbuf() const + { return const_cast<__stringbuf_type*>(&_M_stringbuf); } + + /** + * @brief Copying out the string buffer. + * @return @c rdbuf()->str() + */ + __string_type + str() const + { return _M_stringbuf.str(); } + + /** + * @brief Setting a new buffer. + * @param s The string to use as a new sequence. + * + * Calls @c rdbuf()->str(s). + */ + void + str(const __string_type& __s) + { _M_stringbuf.str(__s); } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#include <bits/sstream.tcc> + +#endif /* _GLIBCXX_SSTREAM */ diff --git a/libstdc++-v3/include/std/stack b/libstdc++-v3/include/std/stack new file mode 100644 index 000000000..4ee2c72a7 --- /dev/null +++ b/libstdc++-v3/include/std/stack @@ -0,0 +1,64 @@ +// <stack> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * + * 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. + */ + +/** @file include/stack + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_STACK +#define _GLIBCXX_STACK 1 + +#pragma GCC system_header + +#include <deque> +#include <bits/stl_stack.h> + +#endif /* _GLIBCXX_STACK */ diff --git a/libstdc++-v3/include/std/stdexcept b/libstdc++-v3/include/std/stdexcept new file mode 100644 index 000000000..a461795d7 --- /dev/null +++ b/libstdc++-v3/include/std/stdexcept @@ -0,0 +1,159 @@ +// Standard exception classes -*- C++ -*- + +// Copyright (C) 2001, 2002, 2005, 2007, 2009, 2010, 2011 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/stdexcept + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 19.1 Exception classes +// + +#ifndef _GLIBCXX_STDEXCEPT +#define _GLIBCXX_STDEXCEPT 1 + +#pragma GCC system_header + +#include <exception> +#include <string> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup exceptions + * @{ + */ + + /** Logic errors represent problems in the internal logic of a program; + * in theory, these are preventable, and even detectable before the + * program runs (e.g., violations of class invariants). + * @brief One of two subclasses of exception. + */ + class logic_error : public exception + { + string _M_msg; + + public: + /** Takes a character string describing the error. */ + explicit + logic_error(const string& __arg); + + virtual ~logic_error() throw(); + + /** Returns a C-style character string describing the general cause of + * the current error (the same string passed to the ctor). */ + virtual const char* + what() const throw(); + }; + + /** Thrown by the library, or by you, to report domain errors (domain in + * the mathematical sense). */ + class domain_error : public logic_error + { + public: + explicit domain_error(const string& __arg); + virtual ~domain_error() throw(); + }; + + /** Thrown to report invalid arguments to functions. */ + class invalid_argument : public logic_error + { + public: + explicit invalid_argument(const string& __arg); + virtual ~invalid_argument() throw(); + }; + + /** Thrown when an object is constructed that would exceed its maximum + * permitted size (e.g., a basic_string instance). */ + class length_error : public logic_error + { + public: + explicit length_error(const string& __arg); + virtual ~length_error() throw(); + }; + + /** This represents an argument whose value is not within the expected + * range (e.g., boundary checks in basic_string). */ + class out_of_range : public logic_error + { + public: + explicit out_of_range(const string& __arg); + virtual ~out_of_range() throw(); + }; + + /** Runtime errors represent problems outside the scope of a program; + * they cannot be easily predicted and can generally only be caught as + * the program executes. + * @brief One of two subclasses of exception. + */ + class runtime_error : public exception + { + string _M_msg; + + public: + /** Takes a character string describing the error. */ + explicit + runtime_error(const string& __arg); + + virtual ~runtime_error() throw(); + + /** Returns a C-style character string describing the general cause of + * the current error (the same string passed to the ctor). */ + virtual const char* + what() const throw(); + }; + + /** Thrown to indicate range errors in internal computations. */ + class range_error : public runtime_error + { + public: + explicit range_error(const string& __arg); + virtual ~range_error() throw(); + }; + + /** Thrown to indicate arithmetic overflow. */ + class overflow_error : public runtime_error + { + public: + explicit overflow_error(const string& __arg); + virtual ~overflow_error() throw(); + }; + + /** Thrown to indicate arithmetic underflow. */ + class underflow_error : public runtime_error + { + public: + explicit underflow_error(const string& __arg); + virtual ~underflow_error() throw(); + }; + + // @} group exceptions + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _GLIBCXX_STDEXCEPT */ diff --git a/libstdc++-v3/include/std/streambuf b/libstdc++-v3/include/std/streambuf new file mode 100644 index 000000000..383a99b5f --- /dev/null +++ b/libstdc++-v3/include/std/streambuf @@ -0,0 +1,809 @@ +// Stream buffer classes -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +// 2006, 2007, 2008, 2009, 2010, 2011, 2013 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/streambuf + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 14882: 27.5 Stream buffers +// + +#ifndef _GLIBXX_STREAMBUF +#define _GLIBXX_STREAMBUF 1 + +#pragma GCC system_header + +#include <bits/c++config.h> +#include <iosfwd> +#include <bits/localefwd.h> +#include <bits/ios_base.h> +#include <bits/cpp_type_traits.h> +#include <ext/type_traits.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template<typename _CharT, typename _Traits> + streamsize + __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*, + basic_streambuf<_CharT, _Traits>*, bool&); + + /** + * @brief The actual work of input and output (interface). + * @ingroup io + * + * This is a base class. Derived stream buffers each control a + * pair of character sequences: one for input, and one for output. + * + * Section [27.5.1] of the standard describes the requirements and + * behavior of stream buffer classes. That section (three paragraphs) + * is reproduced here, for simplicity and accuracy. + * + * -# Stream buffers can impose various constraints on the sequences + * they control. Some constraints are: + * - The controlled input sequence can be not readable. + * - The controlled output sequence can be not writable. + * - The controlled sequences can be associated with the contents of + * other representations for character sequences, such as external + * files. + * - The controlled sequences can support operations @e directly to or + * from associated sequences. + * - The controlled sequences can impose limitations on how the + * program can read characters from a sequence, write characters to + * a sequence, put characters back into an input sequence, or alter + * the stream position. + * . + * -# Each sequence is characterized by three pointers which, if non-null, + * all point into the same @c charT array object. The array object + * represents, at any moment, a (sub)sequence of characters from the + * sequence. Operations performed on a sequence alter the values + * stored in these pointers, perform reads and writes directly to or + * from associated sequences, and alter <em>the stream position</em> and + * conversion state as needed to maintain this subsequence relationship. + * The three pointers are: + * - the <em>beginning pointer</em>, or lowest element address in the + * array (called @e xbeg here); + * - the <em>next pointer</em>, or next element address that is a + * current candidate for reading or writing (called @e xnext here); + * - the <em>end pointer</em>, or first element address beyond the + * end of the array (called @e xend here). + * . + * -# The following semantic constraints shall always apply for any set + * of three pointers for a sequence, using the pointer names given + * immediately above: + * - If @e xnext is not a null pointer, then @e xbeg and @e xend shall + * also be non-null pointers into the same @c charT array, as + * described above; otherwise, @e xbeg and @e xend shall also be null. + * - If @e xnext is not a null pointer and @e xnext < @e xend for an + * output sequence, then a <em>write position</em> is available. + * In this case, @e *xnext shall be assignable as the next element + * to write (to put, or to store a character value, into the sequence). + * - If @e xnext is not a null pointer and @e xbeg < @e xnext for an + * input sequence, then a <em>putback position</em> is available. + * In this case, @e xnext[-1] shall have a defined value and is the + * next (preceding) element to store a character that is put back + * into the input sequence. + * - If @e xnext is not a null pointer and @e xnext< @e xend for an + * input sequence, then a <em>read position</em> is available. + * In this case, @e *xnext shall have a defined value and is the + * next element to read (to get, or to obtain a character value, + * from the sequence). + */ + template<typename _CharT, typename _Traits> + class basic_streambuf + { + public: + //@{ + /** + * These are standard types. They permit a standardized way of + * referring to names of (or names dependant on) the template + * parameters, which are specific to the implementation. + */ + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + //@} + + //@{ + /// This is a non-standard type. + typedef basic_streambuf<char_type, traits_type> __streambuf_type; + //@} + + friend class basic_ios<char_type, traits_type>; + friend class basic_istream<char_type, traits_type>; + friend class basic_ostream<char_type, traits_type>; + friend class istreambuf_iterator<char_type, traits_type>; + friend class ostreambuf_iterator<char_type, traits_type>; + + friend streamsize + __copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&); + + template<bool _IsMove, typename _CharT2> + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + _CharT2*>::__type + __copy_move_a2(istreambuf_iterator<_CharT2>, + istreambuf_iterator<_CharT2>, _CharT2*); + + template<typename _CharT2> + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + istreambuf_iterator<_CharT2> >::__type + find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + const _CharT2&); + + template<typename _CharT2, typename _Traits2> + friend basic_istream<_CharT2, _Traits2>& + operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*); + + template<typename _CharT2, typename _Traits2, typename _Alloc> + friend basic_istream<_CharT2, _Traits2>& + operator>>(basic_istream<_CharT2, _Traits2>&, + basic_string<_CharT2, _Traits2, _Alloc>&); + + template<typename _CharT2, typename _Traits2, typename _Alloc> + friend basic_istream<_CharT2, _Traits2>& + getline(basic_istream<_CharT2, _Traits2>&, + basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2); + + protected: + /* + * This is based on _IO_FILE, just reordered to be more consistent, + * and is intended to be the most minimal abstraction for an + * internal buffer. + * - get == input == read + * - put == output == write + */ + char_type* _M_in_beg; //< Start of get area. + char_type* _M_in_cur; //< Current read area. + char_type* _M_in_end; //< End of get area. + char_type* _M_out_beg; //< Start of put area. + char_type* _M_out_cur; //< Current put area. + char_type* _M_out_end; //< End of put area. + + /// Current locale setting. + locale _M_buf_locale; + + public: + /// Destructor deallocates no buffer space. + virtual + ~basic_streambuf() + { } + + // [27.5.2.2.1] locales + /** + * @brief Entry point for imbue(). + * @param loc The new locale. + * @return The previous locale. + * + * Calls the derived imbue(loc). + */ + locale + pubimbue(const locale &__loc) + { + locale __tmp(this->getloc()); + this->imbue(__loc); + _M_buf_locale = __loc; + return __tmp; + } + + /** + * @brief Locale access. + * @return The current locale in effect. + * + * If pubimbue(loc) has been called, then the most recent @c loc + * is returned. Otherwise the global locale in effect at the time + * of construction is returned. + */ + locale + getloc() const + { return _M_buf_locale; } + + // [27.5.2.2.2] buffer management and positioning + //@{ + /** + * @brief Entry points for derived buffer functions. + * + * The public versions of @c pubfoo dispatch to the protected + * derived @c foo member functions, passing the arguments (if any) + * and returning the result unchanged. + */ + __streambuf_type* + pubsetbuf(char_type* __s, streamsize __n) + { return this->setbuf(__s, __n); } + + pos_type + pubseekoff(off_type __off, ios_base::seekdir __way, + ios_base::openmode __mode = ios_base::in | ios_base::out) + { return this->seekoff(__off, __way, __mode); } + + pos_type + pubseekpos(pos_type __sp, + ios_base::openmode __mode = ios_base::in | ios_base::out) + { return this->seekpos(__sp, __mode); } + + int + pubsync() { return this->sync(); } + //@} + + // [27.5.2.2.3] get area + /** + * @brief Looking ahead into the stream. + * @return The number of characters available. + * + * If a read position is available, returns the number of characters + * available for reading before the buffer must be refilled. + * Otherwise returns the derived @c showmanyc(). + */ + streamsize + in_avail() + { + const streamsize __ret = this->egptr() - this->gptr(); + return __ret ? __ret : this->showmanyc(); + } + + /** + * @brief Getting the next character. + * @return The next character, or eof. + * + * Calls @c sbumpc(), and if that function returns + * @c traits::eof(), so does this function. Otherwise, @c sgetc(). + */ + int_type + snextc() + { + int_type __ret = traits_type::eof(); + if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), + __ret), true)) + __ret = this->sgetc(); + return __ret; + } + + /** + * @brief Getting the next character. + * @return The next character, or eof. + * + * If the input read position is available, returns that character + * and increments the read pointer, otherwise calls and returns + * @c uflow(). + */ + int_type + sbumpc() + { + int_type __ret; + if (__builtin_expect(this->gptr() < this->egptr(), true)) + { + __ret = traits_type::to_int_type(*this->gptr()); + this->gbump(1); + } + else + __ret = this->uflow(); + return __ret; + } + + /** + * @brief Getting the next character. + * @return The next character, or eof. + * + * If the input read position is available, returns that character, + * otherwise calls and returns @c underflow(). Does not move the + * read position after fetching the character. + */ + int_type + sgetc() + { + int_type __ret; + if (__builtin_expect(this->gptr() < this->egptr(), true)) + __ret = traits_type::to_int_type(*this->gptr()); + else + __ret = this->underflow(); + return __ret; + } + + /** + * @brief Entry point for xsgetn. + * @param s A buffer area. + * @param n A count. + * + * Returns xsgetn(s,n). The effect is to fill @a s[0] through + * @a s[n-1] with characters from the input sequence, if possible. + */ + streamsize + sgetn(char_type* __s, streamsize __n) + { return this->xsgetn(__s, __n); } + + // [27.5.2.2.4] putback + /** + * @brief Pushing characters back into the input stream. + * @param c The character to push back. + * @return The previous character, if possible. + * + * Similar to sungetc(), but @a c is pushed onto the stream + * instead of <em>the previous character.</em> If successful, + * the next character fetched from the input stream will be @a + * c. + */ + int_type + sputbackc(char_type __c) + { + int_type __ret; + const bool __testpos = this->eback() < this->gptr(); + if (__builtin_expect(!__testpos || + !traits_type::eq(__c, this->gptr()[-1]), false)) + __ret = this->pbackfail(traits_type::to_int_type(__c)); + else + { + this->gbump(-1); + __ret = traits_type::to_int_type(*this->gptr()); + } + return __ret; + } + + /** + * @brief Moving backwards in the input stream. + * @return The previous character, if possible. + * + * If a putback position is available, this function decrements + * the input pointer and returns that character. Otherwise, + * calls and returns pbackfail(). The effect is to @a unget + * the last character @a gotten. + */ + int_type + sungetc() + { + int_type __ret; + if (__builtin_expect(this->eback() < this->gptr(), true)) + { + this->gbump(-1); + __ret = traits_type::to_int_type(*this->gptr()); + } + else + __ret = this->pbackfail(); + return __ret; + } + + // [27.5.2.2.5] put area + /** + * @brief Entry point for all single-character output functions. + * @param c A character to output. + * @return @a c, if possible. + * + * One of two public output functions. + * + * If a write position is available for the output sequence (i.e., + * the buffer is not full), stores @a c in that position, increments + * the position, and returns @c traits::to_int_type(c). If a write + * position is not available, returns @c overflow(c). + */ + int_type + sputc(char_type __c) + { + int_type __ret; + if (__builtin_expect(this->pptr() < this->epptr(), true)) + { + *this->pptr() = __c; + this->pbump(1); + __ret = traits_type::to_int_type(__c); + } + else + __ret = this->overflow(traits_type::to_int_type(__c)); + return __ret; + } + + /** + * @brief Entry point for all single-character output functions. + * @param s A buffer read area. + * @param n A count. + * + * One of two public output functions. + * + * + * Returns xsputn(s,n). The effect is to write @a s[0] through + * @a s[n-1] to the output sequence, if possible. + */ + streamsize + sputn(const char_type* __s, streamsize __n) + { return this->xsputn(__s, __n); } + + protected: + /** + * @brief Base constructor. + * + * Only called from derived constructors, and sets up all the + * buffer data to zero, including the pointers described in the + * basic_streambuf class description. Note that, as a result, + * - the class starts with no read nor write positions available, + * - this is not an error + */ + basic_streambuf() + : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), + _M_out_beg(0), _M_out_cur(0), _M_out_end(0), + _M_buf_locale(locale()) + { } + + // [27.5.2.3.1] get area access + //@{ + /** + * @brief Access to the get area. + * + * These functions are only available to other protected functions, + * including derived classes. + * + * - eback() returns the beginning pointer for the input sequence + * - gptr() returns the next pointer for the input sequence + * - egptr() returns the end pointer for the input sequence + */ + char_type* + eback() const { return _M_in_beg; } + + char_type* + gptr() const { return _M_in_cur; } + + char_type* + egptr() const { return _M_in_end; } + //@} + + /** + * @brief Moving the read position. + * @param n The delta by which to move. + * + * This just advances the read position without returning any data. + */ + void + gbump(int __n) { _M_in_cur += __n; } + + /** + * @brief Setting the three read area pointers. + * @param gbeg A pointer. + * @param gnext A pointer. + * @param gend A pointer. + * @post @a gbeg == @c eback(), @a gnext == @c gptr(), and + * @a gend == @c egptr() + */ + void + setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) + { + _M_in_beg = __gbeg; + _M_in_cur = __gnext; + _M_in_end = __gend; + } + + // [27.5.2.3.2] put area access + //@{ + /** + * @brief Access to the put area. + * + * These functions are only available to other protected functions, + * including derived classes. + * + * - pbase() returns the beginning pointer for the output sequence + * - pptr() returns the next pointer for the output sequence + * - epptr() returns the end pointer for the output sequence + */ + char_type* + pbase() const { return _M_out_beg; } + + char_type* + pptr() const { return _M_out_cur; } + + char_type* + epptr() const { return _M_out_end; } + //@} + + /** + * @brief Moving the write position. + * @param n The delta by which to move. + * + * This just advances the write position without returning any data. + */ + void + pbump(int __n) { _M_out_cur += __n; } + + /** + * @brief Setting the three write area pointers. + * @param pbeg A pointer. + * @param pend A pointer. + * @post @a pbeg == @c pbase(), @a pbeg == @c pptr(), and + * @a pend == @c epptr() + */ + void + setp(char_type* __pbeg, char_type* __pend) + { + _M_out_beg = _M_out_cur = __pbeg; + _M_out_end = __pend; + } + + // [27.5.2.4] virtual functions + // [27.5.2.4.1] locales + /** + * @brief Changes translations. + * @param loc A new locale. + * + * Translations done during I/O which depend on the current + * locale are changed by this call. The standard adds, + * <em>Between invocations of this function a class derived + * from streambuf can safely cache results of calls to locale + * functions and to members of facets so obtained.</em> + * + * @note Base class version does nothing. + */ + virtual void + imbue(const locale&) + { } + + // [27.5.2.4.2] buffer management and positioning + /** + * @brief Manipulates the buffer. + * + * Each derived class provides its own appropriate behavior. See + * the next-to-last paragraph of + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html + * for more on this function. + * + * @note Base class version does nothing, returns @c this. + */ + virtual basic_streambuf<char_type,_Traits>* + setbuf(char_type*, streamsize) + { return this; } + + /** + * @brief Alters the stream positions. + * + * Each derived class provides its own appropriate behavior. + * @note Base class version does nothing, returns a @c pos_type + * that represents an invalid stream position. + */ + virtual pos_type + seekoff(off_type, ios_base::seekdir, + ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out) + { return pos_type(off_type(-1)); } + + /** + * @brief Alters the stream positions. + * + * Each derived class provides its own appropriate behavior. + * @note Base class version does nothing, returns a @c pos_type + * that represents an invalid stream position. + */ + virtual pos_type + seekpos(pos_type, + ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out) + { return pos_type(off_type(-1)); } + + /** + * @brief Synchronizes the buffer arrays with the controlled sequences. + * @return -1 on failure. + * + * Each derived class provides its own appropriate behavior, + * including the definition of @a failure. + * @note Base class version does nothing, returns zero. + */ + virtual int + sync() { return 0; } + + // [27.5.2.4.3] get area + /** + * @brief Investigating the data available. + * @return An estimate of the number of characters available in the + * input sequence, or -1. + * + * <em>If it returns a positive value, then successive calls to + * @c underflow() will not return @c traits::eof() until at + * least that number of characters have been supplied. If @c + * showmanyc() returns -1, then calls to @c underflow() or @c + * uflow() will fail.</em> [27.5.2.4.3]/1 + * + * @note Base class version does nothing, returns zero. + * @note The standard adds that <em>the intention is not only that the + * calls [to underflow or uflow] will not return @c eof() but + * that they will return immediately.</em> + * @note The standard adds that <em>the morphemes of @c showmanyc are + * @b es-how-many-see, not @b show-manic.</em> + */ + virtual streamsize + showmanyc() { return 0; } + + /** + * @brief Multiple character extraction. + * @param s A buffer area. + * @param n Maximum number of characters to assign. + * @return The number of characters assigned. + * + * Fills @a s[0] through @a s[n-1] with characters from the input + * sequence, as if by @c sbumpc(). Stops when either @a n characters + * have been copied, or when @c traits::eof() would be copied. + * + * It is expected that derived classes provide a more efficient + * implementation by overriding this definition. + */ + virtual streamsize + xsgetn(char_type* __s, streamsize __n); + + /** + * @brief Fetches more data from the controlled sequence. + * @return The first character from the <em>pending sequence</em>. + * + * Informally, this function is called when the input buffer is + * exhausted (or does not exist, as buffering need not actually be + * done). If a buffer exists, it is @a refilled. In either case, the + * next available character is returned, or @c traits::eof() to + * indicate a null pending sequence. + * + * For a formal definition of the pending sequence, see a good text + * such as Langer & Kreft, or [27.5.2.4.3]/7-14. + * + * A functioning input streambuf can be created by overriding only + * this function (no buffer area will be used). For an example, see + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25.html + * + * @note Base class version does nothing, returns eof(). + */ + virtual int_type + underflow() + { return traits_type::eof(); } + + /** + * @brief Fetches more data from the controlled sequence. + * @return The first character from the <em>pending sequence</em>. + * + * Informally, this function does the same thing as @c underflow(), + * and in fact is required to call that function. It also returns + * the new character, like @c underflow() does. However, this + * function also moves the read position forward by one. + */ + virtual int_type + uflow() + { + int_type __ret = traits_type::eof(); + const bool __testeof = traits_type::eq_int_type(this->underflow(), + __ret); + if (!__testeof) + { + __ret = traits_type::to_int_type(*this->gptr()); + this->gbump(1); + } + return __ret; + } + + // [27.5.2.4.4] putback + /** + * @brief Tries to back up the input sequence. + * @param c The character to be inserted back into the sequence. + * @return eof() on failure, <em>some other value</em> on success + * @post The constraints of @c gptr(), @c eback(), and @c pptr() + * are the same as for @c underflow(). + * + * @note Base class version does nothing, returns eof(). + */ + virtual int_type + pbackfail(int_type /* __c */ = traits_type::eof()) + { return traits_type::eof(); } + + // Put area: + /** + * @brief Multiple character insertion. + * @param s A buffer area. + * @param n Maximum number of characters to write. + * @return The number of characters written. + * + * Writes @a s[0] through @a s[n-1] to the output sequence, as if + * by @c sputc(). Stops when either @a n characters have been + * copied, or when @c sputc() would return @c traits::eof(). + * + * It is expected that derived classes provide a more efficient + * implementation by overriding this definition. + */ + virtual streamsize + xsputn(const char_type* __s, streamsize __n); + + /** + * @brief Consumes data from the buffer; writes to the + * controlled sequence. + * @param c An additional character to consume. + * @return eof() to indicate failure, something else (usually + * @a c, or not_eof()) + * + * Informally, this function is called when the output buffer + * is full (or does not exist, as buffering need not actually + * be done). If a buffer exists, it is @a consumed, with + * <em>some effect</em> on the controlled sequence. + * (Typically, the buffer is written out to the sequence + * verbatim.) In either case, the character @a c is also + * written out, if @a c is not @c eof(). + * + * For a formal definition of this function, see a good text + * such as Langer & Kreft, or [27.5.2.4.5]/3-7. + * + * A functioning output streambuf can be created by overriding only + * this function (no buffer area will be used). + * + * @note Base class version does nothing, returns eof(). + */ + virtual int_type + overflow(int_type /* __c */ = traits_type::eof()) + { return traits_type::eof(); } + +#if _GLIBCXX_USE_DEPRECATED + // Annex D.6 + public: + /** + * @brief Tosses a character. + * + * Advances the read pointer, ignoring the character that would have + * been read. + * + * See http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html + */ + void + stossc() + { + if (this->gptr() < this->egptr()) + this->gbump(1); + else + this->uflow(); + } +#endif + + // Also used by specializations for char and wchar_t in src. + void + __safe_gbump(streamsize __n) { _M_in_cur += __n; } + + void + __safe_pbump(streamsize __n) { _M_out_cur += __n; } + + private: + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // Side effect of DR 50. + basic_streambuf(const __streambuf_type& __sb) + : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur), + _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg), + _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur), + _M_buf_locale(__sb._M_buf_locale) + { } + + __streambuf_type& + operator=(const __streambuf_type&) { return *this; }; + }; + + // Explicit specialization declarations, defined in src/streambuf.cc. + template<> + streamsize + __copy_streambufs_eof(basic_streambuf<char>* __sbin, + basic_streambuf<char>* __sbout, bool& __ineof); +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + streamsize + __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin, + basic_streambuf<wchar_t>* __sbout, bool& __ineof); +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#include <bits/streambuf.tcc> + +#endif /* _GLIBCXX_STREAMBUF */ diff --git a/libstdc++-v3/include/std/string b/libstdc++-v3/include/std/string new file mode 100644 index 000000000..28933961a --- /dev/null +++ b/libstdc++-v3/include/std/string @@ -0,0 +1,57 @@ +// Components for manipulating sequences of characters -*- C++ -*- + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, +// 2005, 2006, 2007, 2009, 2010, 2011 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/string + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 14882: 21 Strings library +// + +#ifndef _GLIBCXX_STRING +#define _GLIBCXX_STRING 1 + +#pragma GCC system_header + +#include <bits/c++config.h> +#include <bits/stringfwd.h> +#include <bits/char_traits.h> // NB: In turn includes stl_algobase.h +#include <bits/allocator.h> +#include <bits/cpp_type_traits.h> +#include <bits/localefwd.h> // For operators >>, <<, and getline. +#include <bits/ostream_insert.h> +#include <bits/stl_iterator_base_types.h> +#include <bits/stl_iterator_base_funcs.h> +#include <bits/stl_iterator.h> +#include <bits/stl_function.h> // For less +#include <ext/numeric_traits.h> +#include <bits/stl_algobase.h> +#include <bits/range_access.h> +#include <bits/basic_string.h> +#include <bits/basic_string.tcc> + +#endif /* _GLIBCXX_STRING */ diff --git a/libstdc++-v3/include/std/system_error b/libstdc++-v3/include/std/system_error new file mode 100644 index 000000000..da09a7588 --- /dev/null +++ b/libstdc++-v3/include/std/system_error @@ -0,0 +1,376 @@ +// <system_error> -*- C++ -*- + +// Copyright (C) 2007, 2008, 2009, 2010, 2011 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/system_error + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_SYSTEM_ERROR +#define _GLIBCXX_SYSTEM_ERROR 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <bits/c++config.h> +#include <bits/error_constants.h> +#include <iosfwd> +#include <stdexcept> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + class error_code; + class error_condition; + class error_category; + class system_error; + + /// is_error_code_enum + template<typename _Tp> + struct is_error_code_enum : public false_type { }; + + /// is_error_condition_enum + template<typename _Tp> + struct is_error_condition_enum : public false_type { }; + + template<> + struct is_error_condition_enum<errc> + : public true_type { }; + + + /// error_category + class error_category + { + protected: + error_category(); + + public: + virtual ~error_category(); + + error_category(const error_category&) = delete; + error_category& operator=(const error_category&) = delete; + + virtual const char* + name() const = 0; + + virtual string + message(int) const = 0; + + virtual error_condition + default_error_condition(int __i) const; + + virtual bool + equivalent(int __i, const error_condition& __cond) const; + + virtual bool + equivalent(const error_code& __code, int __i) const; + + bool + operator<(const error_category& __other) const + { return less<const error_category*>()(this, &__other); } + + bool + operator==(const error_category& __other) const + { return this == &__other; } + + bool + operator!=(const error_category& __other) const + { return this != &__other; } + }; + + // DR 890. + _GLIBCXX_CONST const error_category& system_category() throw(); + _GLIBCXX_CONST const error_category& generic_category() throw(); + + error_code make_error_code(errc); + + template<typename _Tp> + struct hash; + + /// error_code + // Implementation-specific error identification + struct error_code + { + error_code() + : _M_value(0), _M_cat(&system_category()) { } + + error_code(int __v, const error_category& __cat) + : _M_value(__v), _M_cat(&__cat) { } + + template<typename _ErrorCodeEnum> + error_code(_ErrorCodeEnum __e, + typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type* = 0) + { *this = make_error_code(__e); } + + void + assign(int __v, const error_category& __cat) + { + _M_value = __v; + _M_cat = &__cat; + } + + void + clear() + { assign(0, system_category()); } + + // DR 804. + template<typename _ErrorCodeEnum> + typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value, + error_code&>::type + operator=(_ErrorCodeEnum __e) + { return *this = make_error_code(__e); } + + int + value() const { return _M_value; } + + const error_category& + category() const { return *_M_cat; } + + error_condition + default_error_condition() const; + + string + message() const + { return category().message(value()); } + + explicit operator bool() const + { return _M_value != 0 ? true : false; } + + // DR 804. + private: + friend class hash<error_code>; + + int _M_value; + const error_category* _M_cat; + }; + + // 19.4.2.6 non-member functions + inline error_code + make_error_code(errc __e) + { return error_code(static_cast<int>(__e), generic_category()); } + + inline bool + operator<(const error_code& __lhs, const error_code& __rhs) + { + return (__lhs.category() < __rhs.category() + || (__lhs.category() == __rhs.category() + && __lhs.value() < __rhs.value())); + } + + template<typename _CharT, typename _Traits> + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e) + { return (__os << __e.category().name() << ':' << __e.value()); } + + error_condition make_error_condition(errc); + + /// error_condition + // Portable error identification + struct error_condition + { + error_condition() + : _M_value(0), _M_cat(&generic_category()) { } + + error_condition(int __v, const error_category& __cat) + : _M_value(__v), _M_cat(&__cat) { } + + template<typename _ErrorConditionEnum> + error_condition(_ErrorConditionEnum __e, + typename enable_if<is_error_condition_enum + <_ErrorConditionEnum>::value>::type* = 0) + { *this = make_error_condition(__e); } + + void + assign(int __v, const error_category& __cat) + { + _M_value = __v; + _M_cat = &__cat; + } + + // DR 804. + template<typename _ErrorConditionEnum> + typename enable_if<is_error_condition_enum + <_ErrorConditionEnum>::value, error_condition&>::type + operator=(_ErrorConditionEnum __e) + { return *this = make_error_condition(__e); } + + void + clear() + { assign(0, generic_category()); } + + // 19.4.3.4 observers + int + value() const { return _M_value; } + + const error_category& + category() const { return *_M_cat; } + + string + message() const + { return category().message(value()); } + + explicit operator bool() const + { return _M_value != 0 ? true : false; } + + // DR 804. + private: + int _M_value; + const error_category* _M_cat; + }; + + // 19.4.3.6 non-member functions + inline error_condition + make_error_condition(errc __e) + { return error_condition(static_cast<int>(__e), generic_category()); } + + inline bool + operator<(const error_condition& __lhs, const error_condition& __rhs) + { + return (__lhs.category() < __rhs.category() + || (__lhs.category() == __rhs.category() + && __lhs.value() < __rhs.value())); + } + + // 19.4.4 Comparison operators + inline bool + operator==(const error_code& __lhs, const error_code& __rhs) + { return (__lhs.category() == __rhs.category() + && __lhs.value() == __rhs.value()); } + + inline bool + operator==(const error_code& __lhs, const error_condition& __rhs) + { + return (__lhs.category().equivalent(__lhs.value(), __rhs) + || __rhs.category().equivalent(__lhs, __rhs.value())); + } + + inline bool + operator==(const error_condition& __lhs, const error_code& __rhs) + { + return (__rhs.category().equivalent(__rhs.value(), __lhs) + || __lhs.category().equivalent(__rhs, __lhs.value())); + } + + inline bool + operator==(const error_condition& __lhs, const error_condition& __rhs) + { + return (__lhs.category() == __rhs.category() + && __lhs.value() == __rhs.value()); + } + + inline bool + operator!=(const error_code& __lhs, const error_code& __rhs) + { return !(__lhs == __rhs); } + + inline bool + operator!=(const error_code& __lhs, const error_condition& __rhs) + { return !(__lhs == __rhs); } + + inline bool + operator!=(const error_condition& __lhs, const error_code& __rhs) + { return !(__lhs == __rhs); } + + inline bool + operator!=(const error_condition& __lhs, const error_condition& __rhs) + { return !(__lhs == __rhs); } + + + /** + * @brief Thrown to indicate error code of underlying system. + * + * @ingroup exceptions + */ + class system_error : public std::runtime_error + { + private: + error_code _M_code; + + public: + system_error(error_code __ec = error_code()) + : runtime_error(__ec.message()), _M_code(__ec) { } + + system_error(error_code __ec, const string& __what) + : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { } + + /* + * TODO: Add const char* ctors to all exceptions. + * + * system_error(error_code __ec, const char* __what) + * : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { } + * + * system_error(int __v, const error_category& __ecat, const char* __what) + * : runtime_error(__what + (": " + __ec.message())), + * _M_code(error_code(__v, __ecat)) { } + */ + + system_error(int __v, const error_category& __ecat) + : runtime_error(error_code(__v, __ecat).message()), + _M_code(__v, __ecat) { } + + system_error(int __v, const error_category& __ecat, const string& __what) + : runtime_error(__what + ": " + error_code(__v, __ecat).message()), + _M_code(__v, __ecat) { } + + virtual ~system_error() throw(); + + const error_code& + code() const throw() { return _M_code; } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#ifndef _GLIBCXX_COMPATIBILITY_CXX0X + +#include <bits/functional_hash.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // DR 1182. + /// std::hash specialization for error_code. + template<> + struct hash<error_code> + : public __hash_base<size_t, error_code> + { + size_t + operator()(const error_code& __e) const + { + const size_t __tmp = std::_Hash_impl::hash(__e._M_value); + return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp); + } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // _GLIBCXX_COMPATIBILITY_CXX0X + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_SYSTEM_ERROR diff --git a/libstdc++-v3/include/std/thread b/libstdc++-v3/include/std/thread new file mode 100644 index 000000000..de58e8141 --- /dev/null +++ b/libstdc++-v3/include/std/thread @@ -0,0 +1,301 @@ +// <thread> -*- C++ -*- + +// Copyright (C) 2008, 2009, 2010, 2011 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/thread + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_THREAD +#define _GLIBCXX_THREAD 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <chrono> +#include <functional> +#include <memory> +#include <mutex> +#include <condition_variable> +#include <bits/functexcept.h> +#include <bits/functional_hash.h> +#include <bits/gthr.h> + +#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup threads Threads + * @ingroup concurrency + * + * Classes for thread support. + * @{ + */ + + /// thread + class thread + { + public: + typedef __gthread_t native_handle_type; + struct _Impl_base; + typedef shared_ptr<_Impl_base> __shared_base_type; + + /// thread::id + class id + { + native_handle_type _M_thread; + + public: + id() : _M_thread() { } + + explicit + id(native_handle_type __id) : _M_thread(__id) { } + + private: + friend class thread; + friend class hash<thread::id>; + + friend bool + operator==(thread::id __x, thread::id __y) + { return __gthread_equal(__x._M_thread, __y._M_thread); } + + friend bool + operator<(thread::id __x, thread::id __y) + { return __x._M_thread < __y._M_thread; } + + template<class _CharT, class _Traits> + friend basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id); + }; + + // Simple base type that the templatized, derived class containing + // an arbitrary functor can be converted to and called. + struct _Impl_base + { + __shared_base_type _M_this_ptr; + + inline virtual ~_Impl_base(); + + virtual void _M_run() = 0; + }; + + template<typename _Callable> + struct _Impl : public _Impl_base + { + _Callable _M_func; + + _Impl(_Callable&& __f) : _M_func(std::forward<_Callable>(__f)) + { } + + void + _M_run() { _M_func(); } + }; + + private: + id _M_id; + + public: + thread() = default; + thread(thread&) = delete; + thread(const thread&) = delete; + + thread(thread&& __t) + { swap(__t); } + + template<typename _Callable, typename... _Args> + explicit + thread(_Callable&& __f, _Args&&... __args) + { + _M_start_thread(_M_make_routine(std::bind<void>( + std::forward<_Callable>(__f), + std::forward<_Args>(__args)...))); + } + + ~thread() + { + if (joinable()) + std::terminate(); + } + + thread& operator=(const thread&) = delete; + + thread& operator=(thread&& __t) + { + if (joinable()) + std::terminate(); + swap(__t); + return *this; + } + + void + swap(thread& __t) + { std::swap(_M_id, __t._M_id); } + + bool + joinable() const + { return !(_M_id == id()); } + + void + join(); + + void + detach(); + + thread::id + get_id() const + { return _M_id; } + + /** @pre thread is joinable + */ + native_handle_type + native_handle() + { return _M_id._M_thread; } + + // Returns a value that hints at the number of hardware thread contexts. + static unsigned int + hardware_concurrency() + { return 0; } + + private: + void + _M_start_thread(__shared_base_type); + + template<typename _Callable> + shared_ptr<_Impl<_Callable>> + _M_make_routine(_Callable&& __f) + { + // Create and allocate full data structure, not base. + return make_shared<_Impl<_Callable>>(std::forward<_Callable>(__f)); + } + }; + + inline thread::_Impl_base::~_Impl_base() = default; + + inline void + swap(thread& __x, thread& __y) + { __x.swap(__y); } + + inline bool + operator!=(thread::id __x, thread::id __y) + { return !(__x == __y); } + + inline bool + operator<=(thread::id __x, thread::id __y) + { return !(__y < __x); } + + inline bool + operator>(thread::id __x, thread::id __y) + { return __y < __x; } + + inline bool + operator>=(thread::id __x, thread::id __y) + { return !(__x < __y); } + + // DR 889. + /// std::hash specialization for thread::id. + template<> + struct hash<thread::id> + : public __hash_base<size_t, thread::id> + { + size_t + operator()(const thread::id& __id) const + { return std::_Hash_impl::hash(__id._M_thread); } + }; + + template<class _CharT, class _Traits> + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id) + { + if (__id == thread::id()) + return __out << "thread::id of a non-executing thread"; + else + return __out << __id._M_thread; + } + +_GLIBCXX_END_NAMESPACE_VERSION + + /** @namespace std::this_thread + * @brief ISO C++ 0x entities sub namespace for thread. + * 30.2.2 Namespace this_thread. + */ + namespace this_thread + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + /// get_id + inline thread::id + get_id() { return thread::id(__gthread_self()); } + +#ifdef _GLIBCXX_USE_SCHED_YIELD + /// yield + inline void + yield() + { __gthread_yield(); } +#endif + +#ifdef _GLIBCXX_USE_NANOSLEEP + /// sleep_until + template<typename _Clock, typename _Duration> + inline void + sleep_until(const chrono::time_point<_Clock, _Duration>& __atime) + { sleep_for(__atime - _Clock::now()); } + + /// sleep_for + template<typename _Rep, typename _Period> + inline void + sleep_for(const chrono::duration<_Rep, _Period>& __rtime) + { + chrono::seconds __s = + chrono::duration_cast<chrono::seconds>(__rtime); + + chrono::nanoseconds __ns = + chrono::duration_cast<chrono::nanoseconds>(__rtime - __s); + + __gthread_time_t __ts = + { + static_cast<std::time_t>(__s.count()), + static_cast<long>(__ns.count()) + }; + + ::nanosleep(&__ts, 0); + } +#endif + + _GLIBCXX_END_NAMESPACE_VERSION + } + + // @} group threads + +} // namespace + +#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_THREAD diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple new file mode 100644 index 000000000..fb452aeb4 --- /dev/null +++ b/libstdc++-v3/include/std/tuple @@ -0,0 +1,808 @@ +// <tuple> -*- C++ -*- + +// Copyright (C) 2007, 2008, 2009, 2010, 2011 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/tuple + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_TUPLE +#define _GLIBCXX_TUPLE 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <utility> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Adds a const reference to a non-reference type. + template<typename _Tp> + struct __add_c_ref + { typedef const _Tp& type; }; + + template<typename _Tp> + struct __add_c_ref<_Tp&> + { typedef _Tp& type; }; + + // Adds a reference to a non-reference type. + template<typename _Tp> + struct __add_ref + { typedef _Tp& type; }; + + template<typename _Tp> + struct __add_ref<_Tp&> + { typedef _Tp& type; }; + + template<std::size_t _Idx, typename _Head, bool _IsEmpty> + struct _Head_base; + + template<std::size_t _Idx, typename _Head> + struct _Head_base<_Idx, _Head, true> + : public _Head + { + constexpr _Head_base() + : _Head() { } + + constexpr _Head_base(const _Head& __h) + : _Head(__h) { } + + template<typename _UHead> + _Head_base(_UHead&& __h) + : _Head(std::forward<_UHead>(__h)) { } + + _Head& _M_head() { return *this; } + const _Head& _M_head() const { return *this; } + + void + _M_swap_impl(_Head& __h) + { + using std::swap; + swap(__h, _M_head()); + } + }; + + template<std::size_t _Idx, typename _Head> + struct _Head_base<_Idx, _Head, false> + { + constexpr _Head_base() + : _M_head_impl() { } + + constexpr _Head_base(const _Head& __h) + : _M_head_impl(__h) { } + + template<typename _UHead> + _Head_base(_UHead&& __h) + : _M_head_impl(std::forward<_UHead>(__h)) { } + + _Head& _M_head() { return _M_head_impl; } + const _Head& _M_head() const { return _M_head_impl; } + + void + _M_swap_impl(_Head& __h) + { + using std::swap; + swap(__h, _M_head()); + } + + _Head _M_head_impl; + }; + + /** + * Contains the actual implementation of the @c tuple template, stored + * as a recursive inheritance hierarchy from the first element (most + * derived class) to the last (least derived class). The @c Idx + * parameter gives the 0-based index of the element stored at this + * point in the hierarchy; we use it to implement a constant-time + * get() operation. + */ + template<std::size_t _Idx, typename... _Elements> + struct _Tuple_impl; + + /** + * Zero-element tuple implementation. This is the basis case for the + * inheritance recursion. + */ + template<std::size_t _Idx> + struct _Tuple_impl<_Idx> + { + protected: + void _M_swap_impl(_Tuple_impl&) { /* no-op */ } + }; + + /** + * Recursive tuple implementation. Here we store the @c Head element + * and derive from a @c Tuple_impl containing the remaining elements + * (which contains the @c Tail). + */ + template<std::size_t _Idx, typename _Head, typename... _Tail> + struct _Tuple_impl<_Idx, _Head, _Tail...> + : public _Tuple_impl<_Idx + 1, _Tail...>, + private _Head_base<_Idx, _Head, std::is_empty<_Head>::value> + { + typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; + typedef _Head_base<_Idx, _Head, std::is_empty<_Head>::value> _Base; + + _Head& _M_head() { return _Base::_M_head(); } + const _Head& _M_head() const { return _Base::_M_head(); } + + _Inherited& _M_tail() { return *this; } + const _Inherited& _M_tail() const { return *this; } + + constexpr _Tuple_impl() + : _Inherited(), _Base() { } + + explicit + constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail) + : _Inherited(__tail...), _Base(__head) { } + + template<typename _UHead, typename... _UTail> + explicit + _Tuple_impl(_UHead&& __head, _UTail&&... __tail) + : _Inherited(std::forward<_UTail>(__tail)...), + _Base(std::forward<_UHead>(__head)) { } + + constexpr _Tuple_impl(const _Tuple_impl&) = default; + + _Tuple_impl(_Tuple_impl&& __in) + : _Inherited(std::move(__in._M_tail())), + _Base(std::forward<_Head>(__in._M_head())) { } + + template<typename... _UElements> + _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) + : _Inherited(__in._M_tail()), _Base(__in._M_head()) { } + + template<typename _UHead, typename... _UTails> + _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + : _Inherited(std::move(__in._M_tail())), + _Base(std::forward<_UHead>(__in._M_head())) { } + + _Tuple_impl& + operator=(const _Tuple_impl& __in) + { + _M_head() = __in._M_head(); + _M_tail() = __in._M_tail(); + return *this; + } + + _Tuple_impl& + operator=(_Tuple_impl&& __in) + { + _M_head() = std::forward<_Head>(__in._M_head()); + _M_tail() = std::move(__in._M_tail()); + return *this; + } + + template<typename... _UElements> + _Tuple_impl& + operator=(const _Tuple_impl<_Idx, _UElements...>& __in) + { + _M_head() = __in._M_head(); + _M_tail() = __in._M_tail(); + return *this; + } + + template<typename _UHead, typename... _UTails> + _Tuple_impl& + operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + { + _M_head() = std::forward<_UHead>(__in._M_head()); + _M_tail() = std::move(__in._M_tail()); + return *this; + } + + protected: + void + _M_swap_impl(_Tuple_impl& __in) + { + _Base::_M_swap_impl(__in._M_head()); + _Inherited::_M_swap_impl(__in._M_tail()); + } + }; + + /// tuple + template<typename... _Elements> + class tuple : public _Tuple_impl<0, _Elements...> + { + typedef _Tuple_impl<0, _Elements...> _Inherited; + + public: + constexpr tuple() + : _Inherited() { } + + explicit + constexpr tuple(const _Elements&... __elements) + : _Inherited(__elements...) { } + + template<typename... _UElements, typename = typename + std::enable_if<sizeof...(_UElements) + == sizeof...(_Elements)>::type> + explicit + tuple(_UElements&&... __elements) + : _Inherited(std::forward<_UElements>(__elements)...) { } + + constexpr tuple(const tuple&) = default; + + tuple(tuple&& __in) + : _Inherited(static_cast<_Inherited&&>(__in)) { } + + template<typename... _UElements, typename = typename + std::enable_if<sizeof...(_UElements) + == sizeof...(_Elements)>::type> + tuple(const tuple<_UElements...>& __in) + : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in)) + { } + + template<typename... _UElements, typename = typename + std::enable_if<sizeof...(_UElements) + == sizeof...(_Elements)>::type> + tuple(tuple<_UElements...>&& __in) + : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } + + tuple& + operator=(const tuple& __in) + { + static_cast<_Inherited&>(*this) = __in; + return *this; + } + + tuple& + operator=(tuple&& __in) + { + static_cast<_Inherited&>(*this) = std::move(__in); + return *this; + } + + template<typename... _UElements, typename = typename + std::enable_if<sizeof...(_UElements) + == sizeof...(_Elements)>::type> + tuple& + operator=(const tuple<_UElements...>& __in) + { + static_cast<_Inherited&>(*this) = __in; + return *this; + } + + template<typename... _UElements, typename = typename + std::enable_if<sizeof...(_UElements) + == sizeof...(_Elements)>::type> + tuple& + operator=(tuple<_UElements...>&& __in) + { + static_cast<_Inherited&>(*this) = std::move(__in); + return *this; + } + + void + swap(tuple& __in) + { _Inherited::_M_swap_impl(__in); } + }; + + template<> + class tuple<> + { + public: + void swap(tuple&) { /* no-op */ } + }; + + /// tuple (2-element), with construction and assignment from a pair. + template<typename _T1, typename _T2> + class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> + { + typedef _Tuple_impl<0, _T1, _T2> _Inherited; + + public: + constexpr tuple() + : _Inherited() { } + + explicit + constexpr tuple(const _T1& __a1, const _T2& __a2) + : _Inherited(__a1, __a2) { } + + template<typename _U1, typename _U2> + explicit + tuple(_U1&& __a1, _U2&& __a2) + : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } + + constexpr tuple(const tuple&) = default; + + tuple(tuple&& __in) + : _Inherited(static_cast<_Inherited&&>(__in)) { } + + template<typename _U1, typename _U2> + tuple(const tuple<_U1, _U2>& __in) + : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { } + + template<typename _U1, typename _U2> + tuple(tuple<_U1, _U2>&& __in) + : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } + + template<typename _U1, typename _U2> + tuple(const pair<_U1, _U2>& __in) + : _Inherited(__in.first, __in.second) { } + + template<typename _U1, typename _U2> + tuple(pair<_U1, _U2>&& __in) + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + tuple& + operator=(const tuple& __in) + { + static_cast<_Inherited&>(*this) = __in; + return *this; + } + + tuple& + operator=(tuple&& __in) + { + static_cast<_Inherited&>(*this) = std::move(__in); + return *this; + } + + template<typename _U1, typename _U2> + tuple& + operator=(const tuple<_U1, _U2>& __in) + { + static_cast<_Inherited&>(*this) = __in; + return *this; + } + + template<typename _U1, typename _U2> + tuple& + operator=(tuple<_U1, _U2>&& __in) + { + static_cast<_Inherited&>(*this) = std::move(__in); + return *this; + } + + template<typename _U1, typename _U2> + tuple& + operator=(const pair<_U1, _U2>& __in) + { + this->_M_head() = __in.first; + this->_M_tail()._M_head() = __in.second; + return *this; + } + + template<typename _U1, typename _U2> + tuple& + operator=(pair<_U1, _U2>&& __in) + { + this->_M_head() = std::forward<_U1>(__in.first); + this->_M_tail()._M_head() = std::forward<_U2>(__in.second); + return *this; + } + + void + swap(tuple& __in) + { + using std::swap; + swap(this->_M_head(), __in._M_head()); + swap(this->_M_tail()._M_head(), __in._M_tail()._M_head()); + } + }; + + /// tuple (1-element). + template<typename _T1> + class tuple<_T1> : public _Tuple_impl<0, _T1> + { + typedef _Tuple_impl<0, _T1> _Inherited; + + public: + constexpr tuple() + : _Inherited() { } + + explicit + constexpr tuple(const _T1& __a1) + : _Inherited(__a1) { } + + template<typename _U1, typename = typename + std::enable_if<std::is_convertible<_U1, _T1>::value>::type> + explicit + tuple(_U1&& __a1) + : _Inherited(std::forward<_U1>(__a1)) { } + + constexpr tuple(const tuple&) = default; + + tuple(tuple&& __in) + : _Inherited(static_cast<_Inherited&&>(__in)) { } + + template<typename _U1> + tuple(const tuple<_U1>& __in) + : _Inherited(static_cast<const _Tuple_impl<0, _U1>&>(__in)) { } + + template<typename _U1> + tuple(tuple<_U1>&& __in) + : _Inherited(static_cast<_Tuple_impl<0, _U1>&&>(__in)) { } + + tuple& + operator=(const tuple& __in) + { + static_cast<_Inherited&>(*this) = __in; + return *this; + } + + tuple& + operator=(tuple&& __in) + { + static_cast<_Inherited&>(*this) = std::move(__in); + return *this; + } + + template<typename _U1> + tuple& + operator=(const tuple<_U1>& __in) + { + static_cast<_Inherited&>(*this) = __in; + return *this; + } + + template<typename _U1> + tuple& + operator=(tuple<_U1>&& __in) + { + static_cast<_Inherited&>(*this) = std::move(__in); + return *this; + } + + void + swap(tuple& __in) + { _Inherited::_M_swap_impl(__in); } + }; + + + /// Gives the type of the ith element of a given tuple type. + template<std::size_t __i, typename _Tp> + struct tuple_element; + + /** + * Recursive case for tuple_element: strip off the first element in + * the tuple and retrieve the (i-1)th element of the remaining tuple. + */ + template<std::size_t __i, typename _Head, typename... _Tail> + struct tuple_element<__i, tuple<_Head, _Tail...> > + : tuple_element<__i - 1, tuple<_Tail...> > { }; + + /** + * Basis case for tuple_element: The first element is the one we're seeking. + */ + template<typename _Head, typename... _Tail> + struct tuple_element<0, tuple<_Head, _Tail...> > + { + typedef _Head type; + }; + + /// Finds the size of a given tuple type. + template<typename _Tp> + struct tuple_size; + + /// class tuple_size + template<typename... _Elements> + struct tuple_size<tuple<_Elements...> > + { + static const std::size_t value = sizeof...(_Elements); + }; + + template<typename... _Elements> + const std::size_t tuple_size<tuple<_Elements...> >::value; + + template<std::size_t __i, typename _Head, typename... _Tail> + inline typename __add_ref<_Head>::type + __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) + { return __t._M_head(); } + + template<std::size_t __i, typename _Head, typename... _Tail> + inline typename __add_c_ref<_Head>::type + __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) + { return __t._M_head(); } + + // Return a reference (const reference) to the ith element of a tuple. + // Any const or non-const ref elements are returned with their original type. + template<std::size_t __i, typename... _Elements> + inline typename __add_ref< + typename tuple_element<__i, tuple<_Elements...> >::type + >::type + get(tuple<_Elements...>& __t) + { return __get_helper<__i>(__t); } + + template<std::size_t __i, typename... _Elements> + inline typename __add_c_ref< + typename tuple_element<__i, tuple<_Elements...> >::type + >::type + get(const tuple<_Elements...>& __t) + { return __get_helper<__i>(__t); } + + // This class helps construct the various comparison operations on tuples + template<std::size_t __check_equal_size, std::size_t __i, std::size_t __j, + typename _Tp, typename _Up> + struct __tuple_compare; + + template<std::size_t __i, std::size_t __j, typename _Tp, typename _Up> + struct __tuple_compare<0, __i, __j, _Tp, _Up> + { + static bool __eq(const _Tp& __t, const _Up& __u) + { + return (get<__i>(__t) == get<__i>(__u) && + __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__eq(__t, __u)); + } + + static bool __less(const _Tp& __t, const _Up& __u) + { + return ((get<__i>(__t) < get<__i>(__u)) + || !(get<__i>(__u) < get<__i>(__t)) && + __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__less(__t, __u)); + } + }; + + template<std::size_t __i, typename _Tp, typename _Up> + struct __tuple_compare<0, __i, __i, _Tp, _Up> + { + static bool __eq(const _Tp&, const _Up&) + { return true; } + + static bool __less(const _Tp&, const _Up&) + { return false; } + }; + + template<typename... _TElements, typename... _UElements> + bool + operator==(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + typedef tuple<_TElements...> _Tp; + typedef tuple<_UElements...> _Up; + return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value, + 0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u)); + } + + template<typename... _TElements, typename... _UElements> + bool + operator<(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + typedef tuple<_TElements...> _Tp; + typedef tuple<_UElements...> _Up; + return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value, + 0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u)); + } + + template<typename... _TElements, typename... _UElements> + inline bool + operator!=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__t == __u); } + + template<typename... _TElements, typename... _UElements> + inline bool + operator>(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return __u < __t; } + + template<typename... _TElements, typename... _UElements> + inline bool + operator<=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__u < __t); } + + template<typename... _TElements, typename... _UElements> + inline bool + operator>=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__t < __u); } + + // NB: DR 705. + template<typename... _Elements> + inline tuple<typename __decay_and_strip<_Elements>::__type...> + make_tuple(_Elements&&... __args) + { + typedef tuple<typename __decay_and_strip<_Elements>::__type...> + __result_type; + return __result_type(std::forward<_Elements>(__args)...); + } + + template<typename... _Elements> + inline tuple<_Elements&&...> + forward_as_tuple(_Elements&&... __args) + { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } + + template<std::size_t...> struct __index_holder { }; + + template<std::size_t __i, typename _IdxHolder, typename... _Elements> + struct __index_holder_impl; + + template<std::size_t __i, std::size_t... _Indexes, typename _IdxHolder, + typename... _Elements> + struct __index_holder_impl<__i, __index_holder<_Indexes...>, + _IdxHolder, _Elements...> + { + typedef typename __index_holder_impl<__i + 1, + __index_holder<_Indexes..., __i>, + _Elements...>::type type; + }; + + template<std::size_t __i, std::size_t... _Indexes> + struct __index_holder_impl<__i, __index_holder<_Indexes...> > + { typedef __index_holder<_Indexes...> type; }; + + template<typename... _Elements> + struct __make_index_holder + : __index_holder_impl<0, __index_holder<>, _Elements...> { }; + + template<typename... _TElements, std::size_t... _TIdx, + typename... _UElements, std::size_t... _UIdx> + inline tuple<_TElements..., _UElements...> + __tuple_cat_helper(const tuple<_TElements...>& __t, + const __index_holder<_TIdx...>&, + const tuple<_UElements...>& __u, + const __index_holder<_UIdx...>&) + { return tuple<_TElements..., _UElements...>(get<_TIdx>(__t)..., + get<_UIdx>(__u)...); } + + template<typename... _TElements, std::size_t... _TIdx, + typename... _UElements, std::size_t... _UIdx> + inline tuple<_TElements..., _UElements...> + __tuple_cat_helper(tuple<_TElements...>&& __t, + const __index_holder<_TIdx...>&, + const tuple<_UElements...>& __u, + const __index_holder<_UIdx...>&) + { return tuple<_TElements..., _UElements...> + (std::forward<_TElements>(get<_TIdx>(__t))..., get<_UIdx>(__u)...); } + + template<typename... _TElements, std::size_t... _TIdx, + typename... _UElements, std::size_t... _UIdx> + inline tuple<_TElements..., _UElements...> + __tuple_cat_helper(const tuple<_TElements...>& __t, + const __index_holder<_TIdx...>&, + tuple<_UElements...>&& __u, + const __index_holder<_UIdx...>&) + { return tuple<_TElements..., _UElements...> + (get<_TIdx>(__t)..., std::forward<_UElements>(get<_UIdx>(__u))...); } + + template<typename... _TElements, std::size_t... _TIdx, + typename... _UElements, std::size_t... _UIdx> + inline tuple<_TElements..., _UElements...> + __tuple_cat_helper(tuple<_TElements...>&& __t, + const __index_holder<_TIdx...>&, + tuple<_UElements...>&& __u, + const __index_holder<_UIdx...>&) + { return tuple<_TElements..., _UElements...> + (std::forward<_TElements>(get<_TIdx>(__t))..., + std::forward<_UElements>(get<_UIdx>(__u))...); } + + template<typename... _TElements, typename... _UElements> + inline tuple<_TElements..., _UElements...> + tuple_cat(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) + { + return __tuple_cat_helper(__t, typename + __make_index_holder<_TElements...>::type(), + __u, typename + __make_index_holder<_UElements...>::type()); + } + + template<typename... _TElements, typename... _UElements> + inline tuple<_TElements..., _UElements...> + tuple_cat(tuple<_TElements...>&& __t, const tuple<_UElements...>& __u) + { + return __tuple_cat_helper(std::move(__t), typename + __make_index_holder<_TElements...>::type(), + __u, typename + __make_index_holder<_UElements...>::type()); + } + + template<typename... _TElements, typename... _UElements> + inline tuple<_TElements..., _UElements...> + tuple_cat(const tuple<_TElements...>& __t, tuple<_UElements...>&& __u) + { + return __tuple_cat_helper(__t, typename + __make_index_holder<_TElements...>::type(), + std::move(__u), typename + __make_index_holder<_UElements...>::type()); + } + + template<typename... _TElements, typename... _UElements> + inline tuple<_TElements..., _UElements...> + tuple_cat(tuple<_TElements...>&& __t, tuple<_UElements...>&& __u) + { + return __tuple_cat_helper(std::move(__t), typename + __make_index_holder<_TElements...>::type(), + std::move(__u), typename + __make_index_holder<_UElements...>::type()); + } + + template<typename... _Elements> + inline tuple<_Elements&...> + tie(_Elements&... __args) + { return tuple<_Elements&...>(__args...); } + + template<typename... _Elements> + inline void + swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) + { __x.swap(__y); } + + // A class (and instance) which can be used in 'tie' when an element + // of a tuple is not required + struct _Swallow_assign + { + template<class _Tp> + const _Swallow_assign& + operator=(const _Tp&) const + { return *this; } + }; + + const _Swallow_assign ignore{}; + + /** + * Stores a tuple of indices. Used by bind() to extract the elements + * in a tuple. + */ + template<int... _Indexes> + struct _Index_tuple + { + typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next; + }; + + /// Builds an _Index_tuple<0, 1, 2, ..., _Num-1>. + template<std::size_t _Num> + struct _Build_index_tuple + { + typedef typename _Build_index_tuple<_Num-1>::__type::__next __type; + }; + + template<> + struct _Build_index_tuple<0> + { + typedef _Index_tuple<> __type; + }; + + // See stl_pair.h... + template<class _T1, class _T2> + template<typename _Tp, typename... _Args> + inline _Tp + pair<_T1, _T2>:: + __cons(tuple<_Args...>&& __tuple) + { + typedef typename _Build_index_tuple<sizeof...(_Args)>::__type + _Indexes; + return __do_cons<_Tp>(std::move(__tuple), _Indexes()); + } + + template<class _T1, class _T2> + template<typename _Tp, typename... _Args, int... _Indexes> + inline _Tp + pair<_T1, _T2>:: + __do_cons(tuple<_Args...>&& __tuple, + const _Index_tuple<_Indexes...>&) + { return _Tp(std::forward<_Args>(get<_Indexes>(__tuple))...); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_TUPLE diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits new file mode 100644 index 000000000..23611525b --- /dev/null +++ b/libstdc++-v3/include/std/type_traits @@ -0,0 +1,1271 @@ +// C++0x type_traits -*- C++ -*- + +// Copyright (C) 2007, 2008, 2009, 2010 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/type_traits + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_TYPE_TRAITS +#define _GLIBCXX_TYPE_TRAITS 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <bits/c++config.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup metaprogramming + * @{ + */ + struct __sfinae_types + { + typedef char __one; + typedef struct { char __arr[2]; } __two; + }; + +#define _DEFINE_SPEC_0_HELPER \ + template<> + +#define _DEFINE_SPEC_1_HELPER \ + template<typename _Tp> + +#define _DEFINE_SPEC_2_HELPER \ + template<typename _Tp, typename _Cp> + +#define _DEFINE_SPEC(_Order, _Trait, _Type, _Value) \ + _DEFINE_SPEC_##_Order##_HELPER \ + struct _Trait<_Type> \ + : public integral_constant<bool, _Value> { }; + + // helper classes. + + /// integral_constant + template<typename _Tp, _Tp __v> + struct integral_constant + { + static constexpr _Tp value = __v; + typedef _Tp value_type; + typedef integral_constant<_Tp, __v> type; + constexpr operator value_type() { return value; } + }; + + /// typedef for true_type + typedef integral_constant<bool, true> true_type; + + /// typedef for false_type + typedef integral_constant<bool, false> false_type; + + template<typename _Tp, _Tp __v> + constexpr _Tp integral_constant<_Tp, __v>::value; + + /// remove_cv + template<typename> + struct remove_cv; + + template<typename> + struct __is_void_helper + : public false_type { }; + _DEFINE_SPEC(0, __is_void_helper, void, true) + + // primary type categories. + + /// is_void + template<typename _Tp> + struct is_void + : public integral_constant<bool, (__is_void_helper<typename + remove_cv<_Tp>::type>::value)> + { }; + + template<typename> + struct __is_integral_helper + : public false_type { }; + _DEFINE_SPEC(0, __is_integral_helper, bool, true) + _DEFINE_SPEC(0, __is_integral_helper, char, true) + _DEFINE_SPEC(0, __is_integral_helper, signed char, true) + _DEFINE_SPEC(0, __is_integral_helper, unsigned char, true) +#ifdef _GLIBCXX_USE_WCHAR_T + _DEFINE_SPEC(0, __is_integral_helper, wchar_t, true) +#endif + _DEFINE_SPEC(0, __is_integral_helper, char16_t, true) + _DEFINE_SPEC(0, __is_integral_helper, char32_t, true) + _DEFINE_SPEC(0, __is_integral_helper, short, true) + _DEFINE_SPEC(0, __is_integral_helper, unsigned short, true) + _DEFINE_SPEC(0, __is_integral_helper, int, true) + _DEFINE_SPEC(0, __is_integral_helper, unsigned int, true) + _DEFINE_SPEC(0, __is_integral_helper, long, true) + _DEFINE_SPEC(0, __is_integral_helper, unsigned long, true) + _DEFINE_SPEC(0, __is_integral_helper, long long, true) + _DEFINE_SPEC(0, __is_integral_helper, unsigned long long, true) + + /// is_integral + template<typename _Tp> + struct is_integral + : public integral_constant<bool, (__is_integral_helper<typename + remove_cv<_Tp>::type>::value)> + { }; + + template<typename> + struct __is_floating_point_helper + : public false_type { }; + _DEFINE_SPEC(0, __is_floating_point_helper, float, true) + _DEFINE_SPEC(0, __is_floating_point_helper, double, true) + _DEFINE_SPEC(0, __is_floating_point_helper, long double, true) + + /// is_floating_point + template<typename _Tp> + struct is_floating_point + : public integral_constant<bool, (__is_floating_point_helper<typename + remove_cv<_Tp>::type>::value)> + { }; + + /// is_array + template<typename> + struct is_array + : public false_type { }; + + template<typename _Tp, std::size_t _Size> + struct is_array<_Tp[_Size]> + : public true_type { }; + + template<typename _Tp> + struct is_array<_Tp[]> + : public true_type { }; + + template<typename> + struct __is_pointer_helper + : public false_type { }; + _DEFINE_SPEC(1, __is_pointer_helper, _Tp*, true) + + /// is_pointer + template<typename _Tp> + struct is_pointer + : public integral_constant<bool, (__is_pointer_helper<typename + remove_cv<_Tp>::type>::value)> + { }; + + /// is_reference + template<typename _Tp> + struct is_reference; + + /// is_function + template<typename _Tp> + struct is_function; + + template<typename> + struct __is_member_object_pointer_helper + : public false_type { }; + _DEFINE_SPEC(2, __is_member_object_pointer_helper, _Tp _Cp::*, + !is_function<_Tp>::value) + + /// is_member_object_pointer + template<typename _Tp> + struct is_member_object_pointer + : public integral_constant<bool, (__is_member_object_pointer_helper< + typename remove_cv<_Tp>::type>::value)> + { }; + + template<typename> + struct __is_member_function_pointer_helper + : public false_type { }; + _DEFINE_SPEC(2, __is_member_function_pointer_helper, _Tp _Cp::*, + is_function<_Tp>::value) + + /// is_member_function_pointer + template<typename _Tp> + struct is_member_function_pointer + : public integral_constant<bool, (__is_member_function_pointer_helper< + typename remove_cv<_Tp>::type>::value)> + { }; + + /// is_enum + template<typename _Tp> + struct is_enum + : public integral_constant<bool, __is_enum(_Tp)> + { }; + + /// is_union + template<typename _Tp> + struct is_union + : public integral_constant<bool, __is_union(_Tp)> + { }; + + /// is_class + template<typename _Tp> + struct is_class + : public integral_constant<bool, __is_class(_Tp)> + { }; + + /// is_function + template<typename> + struct is_function + : public false_type { }; + template<typename _Res, typename... _ArgTypes> + struct is_function<_Res(_ArgTypes...)> + : public true_type { }; + template<typename _Res, typename... _ArgTypes> + struct is_function<_Res(_ArgTypes......)> + : public true_type { }; + template<typename _Res, typename... _ArgTypes> + struct is_function<_Res(_ArgTypes...) const> + : public true_type { }; + template<typename _Res, typename... _ArgTypes> + struct is_function<_Res(_ArgTypes......) const> + : public true_type { }; + template<typename _Res, typename... _ArgTypes> + struct is_function<_Res(_ArgTypes...) volatile> + : public true_type { }; + template<typename _Res, typename... _ArgTypes> + struct is_function<_Res(_ArgTypes......) volatile> + : public true_type { }; + template<typename _Res, typename... _ArgTypes> + struct is_function<_Res(_ArgTypes...) const volatile> + : public true_type { }; + template<typename _Res, typename... _ArgTypes> + struct is_function<_Res(_ArgTypes......) const volatile> + : public true_type { }; + + template<typename> + struct __is_nullptr_t_helper + : public false_type { }; + _DEFINE_SPEC(0, __is_nullptr_t_helper, std::nullptr_t, true) + + // __is_nullptr_t (extension). + template<typename _Tp> + struct __is_nullptr_t + : public integral_constant<bool, (__is_nullptr_t_helper<typename + remove_cv<_Tp>::type>::value)> + { }; + + // composite type traits. + + /// is_arithmetic + template<typename _Tp> + struct is_arithmetic + : public integral_constant<bool, (is_integral<_Tp>::value + || is_floating_point<_Tp>::value)> + { }; + + /// is_fundamental + template<typename _Tp> + struct is_fundamental + : public integral_constant<bool, (is_arithmetic<_Tp>::value + || is_void<_Tp>::value)> + { }; + + /// is_object + template<typename _Tp> + struct is_object + : public integral_constant<bool, !(is_function<_Tp>::value + || is_reference<_Tp>::value + || is_void<_Tp>::value)> + { }; + + /// is_member_pointer + template<typename _Tp> + struct is_member_pointer; + + /// is_scalar + template<typename _Tp> + struct is_scalar + : public integral_constant<bool, (is_arithmetic<_Tp>::value + || is_enum<_Tp>::value + || is_pointer<_Tp>::value + || is_member_pointer<_Tp>::value + || __is_nullptr_t<_Tp>::value)> + { }; + + /// is_compound + template<typename _Tp> + struct is_compound + : public integral_constant<bool, !is_fundamental<_Tp>::value> { }; + + /// is_member_pointer + template<typename _Tp> + struct __is_member_pointer_helper + : public false_type { }; + _DEFINE_SPEC(2, __is_member_pointer_helper, _Tp _Cp::*, true) + + template<typename _Tp> + struct is_member_pointer + : public integral_constant<bool, (__is_member_pointer_helper< + typename remove_cv<_Tp>::type>::value)> + { }; + + // type properties. + /// is_const + template<typename> + struct is_const + : public false_type { }; + + template<typename _Tp> + struct is_const<_Tp const> + : public true_type { }; + + /// is_volatile + template<typename> + struct is_volatile + : public false_type { }; + + template<typename _Tp> + struct is_volatile<_Tp volatile> + : public true_type { }; + + /// is_empty + template<typename _Tp> + struct is_empty + : public integral_constant<bool, __is_empty(_Tp)> + { }; + + /// is_polymorphic + template<typename _Tp> + struct is_polymorphic + : public integral_constant<bool, __is_polymorphic(_Tp)> + { }; + + /// is_abstract + template<typename _Tp> + struct is_abstract + : public integral_constant<bool, __is_abstract(_Tp)> + { }; + + /// has_virtual_destructor + template<typename _Tp> + struct has_virtual_destructor + : public integral_constant<bool, __has_virtual_destructor(_Tp)> + { }; + + /// alignment_of + template<typename _Tp> + struct alignment_of + : public integral_constant<std::size_t, __alignof__(_Tp)> { }; + + /// rank + template<typename> + struct rank + : public integral_constant<std::size_t, 0> { }; + + template<typename _Tp, std::size_t _Size> + struct rank<_Tp[_Size]> + : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { }; + + template<typename _Tp> + struct rank<_Tp[]> + : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { }; + + /// extent + template<typename, unsigned _Uint = 0> + struct extent + : public integral_constant<std::size_t, 0> { }; + + template<typename _Tp, unsigned _Uint, std::size_t _Size> + struct extent<_Tp[_Size], _Uint> + : public integral_constant<std::size_t, + _Uint == 0 ? _Size : extent<_Tp, + _Uint - 1>::value> + { }; + + template<typename _Tp, unsigned _Uint> + struct extent<_Tp[], _Uint> + : public integral_constant<std::size_t, + _Uint == 0 ? 0 : extent<_Tp, + _Uint - 1>::value> + { }; + + // relationships between types [4.6]. + + /// is_same + template<typename, typename> + struct is_same + : public false_type { }; + + template<typename _Tp> + struct is_same<_Tp, _Tp> + : public true_type { }; + + // const-volatile modifications [4.7.1]. + + /// remove_const + template<typename _Tp> + struct remove_const + { typedef _Tp type; }; + + template<typename _Tp> + struct remove_const<_Tp const> + { typedef _Tp type; }; + + /// remove_volatile + template<typename _Tp> + struct remove_volatile + { typedef _Tp type; }; + + template<typename _Tp> + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + /// remove_cv + template<typename _Tp> + struct remove_cv + { + typedef typename + remove_const<typename remove_volatile<_Tp>::type>::type type; + }; + + /// add_const + template<typename _Tp> + struct add_const + { typedef _Tp const type; }; + + /// add_volatile + template<typename _Tp> + struct add_volatile + { typedef _Tp volatile type; }; + + /// add_cv + template<typename _Tp> + struct add_cv + { + typedef typename + add_const<typename add_volatile<_Tp>::type>::type type; + }; + + // array modifications. + + /// remove_extent + template<typename _Tp> + struct remove_extent + { typedef _Tp type; }; + + template<typename _Tp, std::size_t _Size> + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template<typename _Tp> + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + /// remove_all_extents + template<typename _Tp> + struct remove_all_extents + { typedef _Tp type; }; + + template<typename _Tp, std::size_t _Size> + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template<typename _Tp> + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + // pointer modifications. + + template<typename _Tp, typename> + struct __remove_pointer_helper + { typedef _Tp type; }; + + template<typename _Tp, typename _Up> + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + /// remove_pointer + template<typename _Tp> + struct remove_pointer + : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type> + { }; + + template<typename> + struct remove_reference; + + /// add_pointer + template<typename _Tp> + struct add_pointer + { typedef typename remove_reference<_Tp>::type* type; }; + + // Primary classification traits. + + /// is_lvalue_reference + template<typename> + struct is_lvalue_reference + : public false_type { }; + + template<typename _Tp> + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + /// is_rvalue_reference + template<typename> + struct is_rvalue_reference + : public false_type { }; + + template<typename _Tp> + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + // Secondary classification traits. + + /// is_reference + template<typename _Tp> + struct is_reference + : public integral_constant<bool, (is_lvalue_reference<_Tp>::value + || is_rvalue_reference<_Tp>::value)> + { }; + + // Reference transformations. + + /// remove_reference + template<typename _Tp> + struct remove_reference + { typedef _Tp type; }; + + template<typename _Tp> + struct remove_reference<_Tp&> + { typedef _Tp type; }; + + template<typename _Tp> + struct remove_reference<_Tp&&> + { typedef _Tp type; }; + + template<typename _Tp, + bool = !is_reference<_Tp>::value && !is_void<_Tp>::value, + bool = is_rvalue_reference<_Tp>::value> + struct __add_lvalue_reference_helper + { typedef _Tp type; }; + + template<typename _Tp> + struct __add_lvalue_reference_helper<_Tp, true, false> + { typedef _Tp& type; }; + + template<typename _Tp> + struct __add_lvalue_reference_helper<_Tp, false, true> + { typedef typename remove_reference<_Tp>::type& type; }; + + /// add_lvalue_reference + template<typename _Tp> + struct add_lvalue_reference + : public __add_lvalue_reference_helper<_Tp> + { }; + + template<typename _Tp, + bool = !is_reference<_Tp>::value && !is_void<_Tp>::value> + struct __add_rvalue_reference_helper + { typedef _Tp type; }; + + template<typename _Tp> + struct __add_rvalue_reference_helper<_Tp, true> + { typedef _Tp&& type; }; + + /// add_rvalue_reference + template<typename _Tp> + struct add_rvalue_reference + : public __add_rvalue_reference_helper<_Tp> + { }; + + // Scalar properties and transformations. + + template<typename _Tp, + bool = is_integral<_Tp>::value, + bool = is_floating_point<_Tp>::value> + struct __is_signed_helper + : public false_type { }; + + template<typename _Tp> + struct __is_signed_helper<_Tp, false, true> + : public true_type { }; + + template<typename _Tp> + struct __is_signed_helper<_Tp, true, false> + : public integral_constant<bool, static_cast<bool>(_Tp(-1) < _Tp(0))> + { }; + + /// is_signed + template<typename _Tp> + struct is_signed + : public integral_constant<bool, __is_signed_helper<_Tp>::value> + { }; + + /// is_unsigned + template<typename _Tp> + struct is_unsigned + : public integral_constant<bool, (is_arithmetic<_Tp>::value + && !is_signed<_Tp>::value)> + { }; + + // Member introspection. + + /// is_trivial + template<typename _Tp> + struct is_trivial + : public integral_constant<bool, __is_trivial(_Tp)> + { }; + + /// is_standard_layout + template<typename _Tp> + struct is_standard_layout + : public integral_constant<bool, __is_standard_layout(_Tp)> + { }; + + /// is_pod + // Could use is_standard_layout && is_trivial instead of the builtin. + template<typename _Tp> + struct is_pod + : public integral_constant<bool, __is_pod(_Tp)> + { }; + + /// is_literal_type + template<typename _Tp> + struct is_literal_type + : public integral_constant<bool, __is_literal_type(_Tp)> + { }; + + template<typename _Tp> + typename add_rvalue_reference<_Tp>::type declval() noexcept; + + template<typename _Tp, typename... _Args> + class __is_constructible_helper + : public __sfinae_types + { + template<typename _Tp1, typename... _Args1> + static decltype(_Tp1(declval<_Args1>()...), __one()) __test(int); + + template<typename, typename...> + static __two __test(...); + + public: + static const bool __value = sizeof(__test<_Tp, _Args...>(0)) == 1; + }; + + template<typename _Tp, typename _Arg> + class __is_constructible_helper<_Tp, _Arg> + : public __sfinae_types + { + template<typename _Tp1, typename _Arg1> + static decltype(static_cast<_Tp1>(declval<_Arg1>()), __one()) + __test(int); + + template<typename, typename> + static __two __test(...); + + public: + static const bool __value = sizeof(__test<_Tp, _Arg>(0)) == 1; + }; + + /// is_constructible + // XXX FIXME + // The C++0x specifications require front-end support, see N2255. + template<typename _Tp, typename... _Args> + struct is_constructible + : public integral_constant<bool, + __is_constructible_helper<_Tp, + _Args...>::__value> + { }; + + template<bool, typename _Tp, typename... _Args> + struct __is_nt_constructible_helper + { static const bool __value = false; }; + + template<typename _Tp, typename... _Args> + struct __is_nt_constructible_helper<true, _Tp, _Args...> + { static const bool __value = noexcept(_Tp(declval<_Args>()...)); }; + + template<typename _Tp, typename _Arg> + struct __is_nt_constructible_helper<true, _Tp, _Arg> + { + static const bool __value = noexcept(static_cast<_Tp>(declval<_Arg>())); + }; + + /// is_nothrow_constructible + template<typename _Tp, typename... _Args> + struct is_nothrow_constructible + : public integral_constant<bool, + __is_nt_constructible_helper<is_constructible<_Tp, _Args...>::value, + _Tp, _Args...>::__value> + { }; + + /// has_trivial_default_constructor + template<typename _Tp> + struct has_trivial_default_constructor + : public integral_constant<bool, __has_trivial_constructor(_Tp)> + { }; + + /// has_trivial_copy_constructor + template<typename _Tp> + struct has_trivial_copy_constructor + : public integral_constant<bool, __has_trivial_copy(_Tp)> + { }; + + /// has_trivial_copy_assign + template<typename _Tp> + struct has_trivial_copy_assign + : public integral_constant<bool, __has_trivial_assign(_Tp)> + { }; + + /// has_trivial_destructor + template<typename _Tp> + struct has_trivial_destructor + : public integral_constant<bool, __has_trivial_destructor(_Tp)> + { }; + + /// has_nothrow_default_constructor + template<typename _Tp> + struct has_nothrow_default_constructor + : public integral_constant<bool, __has_nothrow_constructor(_Tp)> + { }; + + /// has_nothrow_copy_constructor + template<typename _Tp> + struct has_nothrow_copy_constructor + : public integral_constant<bool, __has_nothrow_copy(_Tp)> + { }; + + /// has_nothrow_copy_assign + template<typename _Tp> + struct has_nothrow_copy_assign + : public integral_constant<bool, __has_nothrow_assign(_Tp)> + { }; + + // Relationships between types. + + /// is_base_of + template<typename _Base, typename _Derived> + struct is_base_of + : public integral_constant<bool, __is_base_of(_Base, _Derived)> + { }; + + template<typename _From, typename _To, + bool = (is_void<_From>::value || is_function<_To>::value + || is_array<_To>::value)> + struct __is_convertible_helper + { static const bool __value = is_void<_To>::value; }; + + template<typename _From, typename _To> + class __is_convertible_helper<_From, _To, false> + : public __sfinae_types + { + template<typename _To1> + static void __test_aux(_To1); + + template<typename _From1, typename _To1> + static decltype(__test_aux<_To1>(std::declval<_From1>()), __one()) + __test(int); + + template<typename, typename> + static __two __test(...); + + public: + static const bool __value = sizeof(__test<_From, _To>(0)) == 1; + }; + + /// is_convertible + // XXX FIXME + // The C++0x specifications require front-end support, see N2255. + template<typename _From, typename _To> + struct is_convertible + : public integral_constant<bool, + __is_convertible_helper<_From, _To>::__value> + { }; + + /// is_explicitly_convertible + template<typename _From, typename _To> + struct is_explicitly_convertible + : public is_constructible<_To, _From> + { }; + + template<std::size_t _Len> + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; + + /** + * @brief Alignment type. + * + * The value of _Align is a default-alignment which shall be the + * most stringent alignment requirement for any C++ object type + * whose size is no greater than _Len (3.9). The member typedef + * type shall be a POD type suitable for use as uninitialized + * storage for any object whose size is at most _Len and whose + * alignment is a divisor of _Align. + */ + template<std::size_t _Len, std::size_t _Align = + __alignof__(typename __aligned_storage_msa<_Len>::__type)> + struct aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + + // Define a nested type if some predicate holds. + // Primary template. + /// enable_if + template<bool, typename _Tp = void> + struct enable_if + { }; + + // Partial specialization for true. + template<typename _Tp> + struct enable_if<true, _Tp> + { typedef _Tp type; }; + + + // A conditional expression, but for types. If true, first, if false, second. + // Primary template. + /// conditional + template<bool _Cond, typename _Iftrue, typename _Iffalse> + struct conditional + { typedef _Iftrue type; }; + + // Partial specialization for false. + template<typename _Iftrue, typename _Iffalse> + struct conditional<false, _Iftrue, _Iffalse> + { typedef _Iffalse type; }; + + + // Decay trait for arrays and functions, used for perfect forwarding + // in make_pair, make_tuple, etc. + template<typename _Up, + bool _IsArray = is_array<_Up>::value, + bool _IsFunction = is_function<_Up>::value> + struct __decay_selector; + + // NB: DR 705. + template<typename _Up> + struct __decay_selector<_Up, false, false> + { typedef typename remove_cv<_Up>::type __type; }; + + template<typename _Up> + struct __decay_selector<_Up, true, false> + { typedef typename remove_extent<_Up>::type* __type; }; + + template<typename _Up> + struct __decay_selector<_Up, false, true> + { typedef typename add_pointer<_Up>::type __type; }; + + /// decay + template<typename _Tp> + class decay + { + typedef typename remove_reference<_Tp>::type __remove_type; + + public: + typedef typename __decay_selector<__remove_type>::__type type; + }; + + template<typename _Tp> + class reference_wrapper; + + // Helper which adds a reference to a type when given a reference_wrapper + template<typename _Tp> + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template<typename _Tp> + struct __strip_reference_wrapper<reference_wrapper<_Tp> > + { + typedef _Tp& __type; + }; + + template<typename _Tp> + struct __strip_reference_wrapper<const reference_wrapper<_Tp> > + { + typedef _Tp& __type; + }; + + template<typename _Tp> + struct __decay_and_strip + { + typedef typename __strip_reference_wrapper< + typename decay<_Tp>::type>::__type __type; + }; + + + // Utility for constructing identically cv-qualified types. + template<typename _Unqualified, bool _IsConst, bool _IsVol> + struct __cv_selector; + + template<typename _Unqualified> + struct __cv_selector<_Unqualified, false, false> + { typedef _Unqualified __type; }; + + template<typename _Unqualified> + struct __cv_selector<_Unqualified, false, true> + { typedef volatile _Unqualified __type; }; + + template<typename _Unqualified> + struct __cv_selector<_Unqualified, true, false> + { typedef const _Unqualified __type; }; + + template<typename _Unqualified> + struct __cv_selector<_Unqualified, true, true> + { typedef const volatile _Unqualified __type; }; + + template<typename _Qualified, typename _Unqualified, + bool _IsConst = is_const<_Qualified>::value, + bool _IsVol = is_volatile<_Qualified>::value> + class __match_cv_qualifiers + { + typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; + + public: + typedef typename __match::__type __type; + }; + + + // Utility for finding the unsigned versions of signed integral types. + template<typename _Tp> + struct __make_unsigned + { typedef _Tp __type; }; + + template<> + struct __make_unsigned<char> + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned<signed char> + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned<short> + { typedef unsigned short __type; }; + + template<> + struct __make_unsigned<int> + { typedef unsigned int __type; }; + + template<> + struct __make_unsigned<long> + { typedef unsigned long __type; }; + + template<> + struct __make_unsigned<long long> + { typedef unsigned long long __type; }; + + + // Select between integral and enum: not possible to be both. + template<typename _Tp, + bool _IsInt = is_integral<_Tp>::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_unsigned_selector; + + template<typename _Tp> + class __make_unsigned_selector<_Tp, true, false> + { + typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt; + typedef typename __unsignedt::__type __unsigned_type; + typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned; + + public: + typedef typename __cv_unsigned::__type __type; + }; + + template<typename _Tp> + class __make_unsigned_selector<_Tp, false, true> + { + // With -fshort-enums, an enum may be as small as a char. + typedef unsigned char __smallest; + static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest); + static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short); + static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int); + typedef conditional<__b2, unsigned int, unsigned long> __cond2; + typedef typename __cond2::type __cond2_type; + typedef conditional<__b1, unsigned short, __cond2_type> __cond1; + typedef typename __cond1::type __cond1_type; + + public: + typedef typename conditional<__b0, __smallest, __cond1_type>::type __type; + }; + + // Given an integral/enum type, return the corresponding unsigned + // integer type. + // Primary template. + /// make_unsigned + template<typename _Tp> + struct make_unsigned + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + // Integral, but don't define. + template<> + struct make_unsigned<bool>; + + + // Utility for finding the signed versions of unsigned integral types. + template<typename _Tp> + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed<char> + { typedef signed char __type; }; + + template<> + struct __make_signed<unsigned char> + { typedef signed char __type; }; + + template<> + struct __make_signed<unsigned short> + { typedef signed short __type; }; + + template<> + struct __make_signed<unsigned int> + { typedef signed int __type; }; + + template<> + struct __make_signed<unsigned long> + { typedef signed long __type; }; + + template<> + struct __make_signed<unsigned long long> + { typedef signed long long __type; }; + + + // Select between integral and enum: not possible to be both. + template<typename _Tp, + bool _IsInt = is_integral<_Tp>::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_signed_selector; + + template<typename _Tp> + class __make_signed_selector<_Tp, true, false> + { + typedef __make_signed<typename remove_cv<_Tp>::type> __signedt; + typedef typename __signedt::__type __signed_type; + typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed; + + public: + typedef typename __cv_signed::__type __type; + }; + + template<typename _Tp> + class __make_signed_selector<_Tp, false, true> + { + // With -fshort-enums, an enum may be as small as a char. + typedef signed char __smallest; + static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest); + static const bool __b1 = sizeof(_Tp) <= sizeof(signed short); + static const bool __b2 = sizeof(_Tp) <= sizeof(signed int); + typedef conditional<__b2, signed int, signed long> __cond2; + typedef typename __cond2::type __cond2_type; + typedef conditional<__b1, signed short, __cond2_type> __cond1; + typedef typename __cond1::type __cond1_type; + + public: + typedef typename conditional<__b0, __smallest, __cond1_type>::type __type; + }; + + // Given an integral/enum type, return the corresponding signed + // integer type. + // Primary template. + /// make_signed + template<typename _Tp> + struct make_signed + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + // Integral, but don't define. + template<> + struct make_signed<bool>; + + /// common_type + template<typename... _Tp> + struct common_type; + + template<typename _Tp> + struct common_type<_Tp> + { typedef _Tp type; }; + + template<typename _Tp, typename _Up> + struct common_type<_Tp, _Up> + { typedef decltype(true ? declval<_Tp>() : declval<_Up>()) type; }; + + template<typename _Tp, typename _Up, typename... _Vp> + struct common_type<_Tp, _Up, _Vp...> + { + typedef typename + common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type; + }; + + /// declval + template<typename _Tp> + struct __declval_protector + { + static const bool __stop = false; + static typename add_rvalue_reference<_Tp>::type __delegate(); + }; + + template<typename _Tp> + inline typename add_rvalue_reference<_Tp>::type + declval() noexcept + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval_protector<_Tp>::__delegate(); + } + + /// result_of + template<typename _Signature> + class result_of; + + template<typename _MemPtr, typename _Arg> + struct _Result_of_memobj; + + template<typename _Res, typename _Class, typename _Arg> + struct _Result_of_memobj<_Res _Class::*, _Arg> + { + private: + typedef _Res _Class::* _Func; + + template<typename _Tp> + static _Tp _S_get(const _Class&); + template<typename _Tp> + static decltype(*std::declval<_Tp>()) _S_get(...); + + public: + typedef + decltype(_S_get<_Arg>(std::declval<_Arg>()).*std::declval<_Func>()) + __type; + }; + + template<typename _MemPtr, typename _Arg, typename... _ArgTypes> + struct _Result_of_memfun; + + template<typename _Res, typename _Class, typename _Arg, typename... _Args> + struct _Result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + private: + typedef _Res _Class::* _Func; + + template<typename _Tp> + static _Tp _S_get(const _Class&); + template<typename _Tp> + static decltype(*std::declval<_Tp>()) _S_get(...); + + public: + typedef + decltype((_S_get<_Arg>(std::declval<_Arg>()).*std::declval<_Func>()) + (std::declval<_Args>()...) ) + __type; + }; + + template<bool, bool, typename _Functor, typename... _ArgTypes> + struct _Result_of_impl; + + template<typename _Functor, typename... _ArgTypes> + struct _Result_of_impl<false, false, _Functor, _ArgTypes...> + { + typedef + decltype( std::declval<_Functor>()(std::declval<_ArgTypes>()...) ) + __type; + }; + + template<typename _MemPtr, typename _Arg> + struct _Result_of_impl<true, false, _MemPtr, _Arg> + : _Result_of_memobj<typename remove_reference<_MemPtr>::type, _Arg> + { + typedef typename _Result_of_memobj< + typename remove_reference<_MemPtr>::type, _Arg>::__type + __type; + }; + + template<typename _MemPtr, typename _Arg, typename... _ArgTypes> + struct _Result_of_impl<false, true, _MemPtr, _Arg, _ArgTypes...> + : _Result_of_memfun<typename remove_reference<_MemPtr>::type, _Arg, + _ArgTypes...> + { + typedef typename _Result_of_memfun< + typename remove_reference<_MemPtr>::type, _Arg, _ArgTypes...>::__type + __type; + }; + + template<typename _Functor, typename... _ArgTypes> + struct result_of<_Functor(_ArgTypes...)> + : _Result_of_impl<is_member_object_pointer< + typename remove_reference<_Functor>::type >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type >::value, + _Functor, _ArgTypes...> + { + typedef typename _Result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type >::value, + _Functor, _ArgTypes...>::__type + type; + }; + + /** + * Use SFINAE to determine if the type _Tp has a publicly-accessible + * member type _NTYPE. + */ +#define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) \ + template<typename _Tp> \ + class __has_##_NTYPE##_helper \ + : __sfinae_types \ + { \ + template<typename _Up> \ + struct _Wrap_type \ + { }; \ + \ + template<typename _Up> \ + static __one __test(_Wrap_type<typename _Up::_NTYPE>*); \ + \ + template<typename _Up> \ + static __two __test(...); \ + \ + public: \ + static const bool value = sizeof(__test<_Tp>(0)) == 1; \ + }; \ + \ + template<typename _Tp> \ + struct __has_##_NTYPE \ + : integral_constant<bool, __has_##_NTYPE##_helper \ + <typename remove_cv<_Tp>::type>::value> \ + { }; + +#undef _DEFINE_SPEC_0_HELPER +#undef _DEFINE_SPEC_1_HELPER +#undef _DEFINE_SPEC_2_HELPER +#undef _DEFINE_SPEC + + // @} group metaprogramming +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_TYPE_TRAITS diff --git a/libstdc++-v3/include/std/typeindex b/libstdc++-v3/include/std/typeindex new file mode 100644 index 000000000..79b3eadf7 --- /dev/null +++ b/libstdc++-v3/include/std/typeindex @@ -0,0 +1,109 @@ +// C++0x typeindex -*- C++ -*- + +// Copyright (C) 2010 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/typeindex + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_TYPEINDEX +#define _GLIBCXX_TYPEINDEX 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <typeinfo> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + @brief The class type_index provides a simple wrapper for type_info + which can be used as an index type in associative containers (23.6) + and in unordered associative containers (23.7). + */ + struct type_index + { + type_index(const type_info& __rhs) + : _M_target(&__rhs) { } + + bool + operator==(const type_index& __rhs) const + { return *_M_target == *__rhs._M_target; } + + bool + operator!=(const type_index& __rhs) const + { return *_M_target != *__rhs._M_target; } + + bool + operator<(const type_index& __rhs) const + { return _M_target->before(*__rhs._M_target); } + + bool + operator<=(const type_index& __rhs) const + { return !__rhs._M_target->before(*_M_target); } + + bool + operator>(const type_index& __rhs) const + { return __rhs._M_target->before(*_M_target); } + + bool + operator>=(const type_index& __rhs) const + { return !_M_target->before(*__rhs._M_target); } + + size_t + hash_code() const + { return _M_target->hash_code(); } + + const char* + name() const + { return _M_target->name(); } + + private: + const type_info* _M_target; + }; + + template<typename _Tp> struct hash; + + /// std::hash specialization for type_index. + template<> + struct hash<type_index> + { + typedef size_t result_type; + typedef type_index argument_type; + + size_t + operator()(const type_index& __ti) const + { return __ti.hash_code(); } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_TYPEINDEX diff --git a/libstdc++-v3/include/std/unordered_map b/libstdc++-v3/include/std/unordered_map new file mode 100644 index 000000000..e77a2972a --- /dev/null +++ b/libstdc++-v3/include/std/unordered_map @@ -0,0 +1,59 @@ +// <unordered_map> -*- C++ -*- + +// Copyright (C) 2007, 2008, 2009, 2010 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/unordered_map + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_UNORDERED_MAP +#define _GLIBCXX_UNORDERED_MAP 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <utility> +#include <type_traits> +#include <initializer_list> +#include <bits/stl_algobase.h> +#include <bits/allocator.h> +#include <bits/stl_function.h> // equal_to, _Identity, _Select1st +#include <bits/functional_hash.h> +#include <bits/hashtable.h> +#include <bits/unordered_map.h> +#include <bits/range_access.h> + +#ifdef _GLIBCXX_DEBUG +# include <debug/unordered_map> +#endif + +#ifdef _GLIBCXX_PROFILE +# include <profile/unordered_map> +#endif + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_UNORDERED_MAP diff --git a/libstdc++-v3/include/std/unordered_set b/libstdc++-v3/include/std/unordered_set new file mode 100644 index 000000000..739e0a4a4 --- /dev/null +++ b/libstdc++-v3/include/std/unordered_set @@ -0,0 +1,58 @@ +// <unordered_set> -*- C++ -*- + +// Copyright (C) 2007, 2008, 2009, 2010 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/unordered_set + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_UNORDERED_SET +#define _GLIBCXX_UNORDERED_SET 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <bits/c++0x_warning.h> +#else + +#include <utility> +#include <type_traits> +#include <initializer_list> +#include <bits/stl_algobase.h> +#include <bits/allocator.h> +#include <bits/stl_function.h> // equal_to, _Identity, _Select1st +#include <bits/functional_hash.h> +#include <bits/hashtable.h> +#include <bits/unordered_set.h> +#include <bits/range_access.h> + +#ifdef _GLIBCXX_DEBUG +# include <debug/unordered_set> +#endif + +#ifdef _GLIBCXX_PROFILE +# include <profile/unordered_set> +#endif +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_UNORDERED_SET diff --git a/libstdc++-v3/include/std/utility b/libstdc++-v3/include/std/utility new file mode 100644 index 000000000..245c41fa7 --- /dev/null +++ b/libstdc++-v3/include/std/utility @@ -0,0 +1,146 @@ +// <utility> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * + * 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. + */ + +/** @file include/utility + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_UTILITY +#define _GLIBCXX_UTILITY 1 + +#pragma GCC system_header + +/** + * @defgroup utilities Utilities + * + * Components deemed generally useful. Includes pair, tuple, + * forward/move helpers, ratio, function object, metaprogramming and + * type traits, time, date, and memory functions. + */ + +#include <bits/c++config.h> +#include <bits/stl_relops.h> +#include <bits/stl_pair.h> + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include <bits/move.h> +#include <initializer_list> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template<class _Tp> + class tuple_size; + + template<std::size_t _Int, class _Tp> + class tuple_element; + + // Various functions which give std::pair a tuple-like interface. + template<class _Tp1, class _Tp2> + struct tuple_size<std::pair<_Tp1, _Tp2> > + { static const std::size_t value = 2; }; + + template<class _Tp1, class _Tp2> + const std::size_t + tuple_size<std::pair<_Tp1, _Tp2> >::value; + + template<class _Tp1, class _Tp2> + struct tuple_element<0, std::pair<_Tp1, _Tp2> > + { typedef _Tp1 type; }; + + template<class _Tp1, class _Tp2> + struct tuple_element<1, std::pair<_Tp1, _Tp2> > + { typedef _Tp2 type; }; + + template<std::size_t _Int> + struct __pair_get; + + template<> + struct __pair_get<0> + { + template<typename _Tp1, typename _Tp2> + static _Tp1& __get(std::pair<_Tp1, _Tp2>& __pair) + { return __pair.first; } + + template<typename _Tp1, typename _Tp2> + static const _Tp1& __const_get(const std::pair<_Tp1, _Tp2>& __pair) + { return __pair.first; } + }; + + template<> + struct __pair_get<1> + { + template<typename _Tp1, typename _Tp2> + static _Tp2& __get(std::pair<_Tp1, _Tp2>& __pair) + { return __pair.second; } + + template<typename _Tp1, typename _Tp2> + static const _Tp2& __const_get(const std::pair<_Tp1, _Tp2>& __pair) + { return __pair.second; } + }; + + template<std::size_t _Int, class _Tp1, class _Tp2> + inline typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type& + get(std::pair<_Tp1, _Tp2>& __in) + { return __pair_get<_Int>::__get(__in); } + + template<std::size_t _Int, class _Tp1, class _Tp2> + inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type& + get(const std::pair<_Tp1, _Tp2>& __in) + { return __pair_get<_Int>::__const_get(__in); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif + +#endif /* _GLIBCXX_UTILITY */ diff --git a/libstdc++-v3/include/std/valarray b/libstdc++-v3/include/std/valarray new file mode 100644 index 000000000..9c18e0503 --- /dev/null +++ b/libstdc++-v3/include/std/valarray @@ -0,0 +1,1165 @@ +// The template and inlines for the -*- C++ -*- valarray class. + +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +// 2006, 2007, 2008, 2009, 2010 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file include/valarray + * This is a Standard C++ Library header. + */ + +// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr> + +#ifndef _GLIBCXX_VALARRAY +#define _GLIBCXX_VALARRAY 1 + +#pragma GCC system_header + +#include <bits/c++config.h> +#include <cmath> +#include <algorithm> +#include <debug/debug.h> +#include <initializer_list> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template<class _Clos, typename _Tp> + class _Expr; + + template<typename _Tp1, typename _Tp2> + class _ValArray; + + template<class _Oper, template<class, class> class _Meta, class _Dom> + struct _UnClos; + + template<class _Oper, + template<class, class> class _Meta1, + template<class, class> class _Meta2, + class _Dom1, class _Dom2> + class _BinClos; + + template<template<class, class> class _Meta, class _Dom> + class _SClos; + + template<template<class, class> class _Meta, class _Dom> + class _GClos; + + template<template<class, class> class _Meta, class _Dom> + class _IClos; + + template<template<class, class> class _Meta, class _Dom> + class _ValFunClos; + + template<template<class, class> class _Meta, class _Dom> + class _RefFunClos; + + template<class _Tp> class valarray; // An array of type _Tp + class slice; // BLAS-like slice out of an array + template<class _Tp> class slice_array; + class gslice; // generalized slice out of an array + template<class _Tp> class gslice_array; + template<class _Tp> class mask_array; // masked array + template<class _Tp> class indirect_array; // indirected array + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#include <bits/valarray_array.h> +#include <bits/valarray_before.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup numeric_arrays Numeric Arrays + * @ingroup numerics + * + * Classes and functions for representing and manipulating arrays of elements. + * @{ + */ + + /** + * @brief Smart array designed to support numeric processing. + * + * A valarray is an array that provides constraints intended to allow for + * effective optimization of numeric array processing by reducing the + * aliasing that can result from pointer representations. It represents a + * one-dimensional array from which different multidimensional subsets can + * be accessed and modified. + * + * @param Tp Type of object in the array. + */ + template<class _Tp> + class valarray + { + template<class _Op> + struct _UnaryOp + { + typedef typename __fun<_Op, _Tp>::result_type __rt; + typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt; + }; + public: + typedef _Tp value_type; + + // _lib.valarray.cons_ construct/destroy: + /// Construct an empty array. + valarray(); + + /// Construct an array with @a n elements. + explicit valarray(size_t); + + /// Construct an array with @a n elements initialized to @a t. + valarray(const _Tp&, size_t); + + /// Construct an array initialized to the first @a n elements of @a t. + valarray(const _Tp* __restrict__, size_t); + + /// Copy constructor. + valarray(const valarray&); + + /// Construct an array with the same size and values in @a sa. + valarray(const slice_array<_Tp>&); + + /// Construct an array with the same size and values in @a ga. + valarray(const gslice_array<_Tp>&); + + /// Construct an array with the same size and values in @a ma. + valarray(const mask_array<_Tp>&); + + /// Construct an array with the same size and values in @a ia. + valarray(const indirect_array<_Tp>&); + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /// Construct an array with an initializer_list of values. + valarray(initializer_list<_Tp>); +#endif + + template<class _Dom> + valarray(const _Expr<_Dom, _Tp>& __e); + + ~valarray(); + + // _lib.valarray.assign_ assignment: + /** + * @brief Assign elements to an array. + * + * Assign elements of array to values in @a v. Results are undefined + * if @a v does not have the same size as this array. + * + * @param v Valarray to get values from. + */ + valarray<_Tp>& operator=(const valarray<_Tp>&); + + /** + * @brief Assign elements to a value. + * + * Assign all elements of array to @a t. + * + * @param t Value for elements. + */ + valarray<_Tp>& operator=(const _Tp&); + + /** + * @brief Assign elements to an array subset. + * + * Assign elements of array to values in @a sa. Results are undefined + * if @a sa does not have the same size as this array. + * + * @param sa Array slice to get values from. + */ + valarray<_Tp>& operator=(const slice_array<_Tp>&); + + /** + * @brief Assign elements to an array subset. + * + * Assign elements of array to values in @a ga. Results are undefined + * if @a ga does not have the same size as this array. + * + * @param ga Array slice to get values from. + */ + valarray<_Tp>& operator=(const gslice_array<_Tp>&); + + /** + * @brief Assign elements to an array subset. + * + * Assign elements of array to values in @a ma. Results are undefined + * if @a ma does not have the same size as this array. + * + * @param ma Array slice to get values from. + */ + valarray<_Tp>& operator=(const mask_array<_Tp>&); + + /** + * @brief Assign elements to an array subset. + * + * Assign elements of array to values in @a ia. Results are undefined + * if @a ia does not have the same size as this array. + * + * @param ia Array slice to get values from. + */ + valarray<_Tp>& operator=(const indirect_array<_Tp>&); + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Assign elements to an initializer_list. + * + * Assign elements of array to values in @a l. Results are undefined + * if @a l does not have the same size as this array. + * + * @param l initializer_list to get values from. + */ + valarray& operator=(initializer_list<_Tp>); +#endif + + template<class _Dom> valarray<_Tp>& + operator= (const _Expr<_Dom, _Tp>&); + + // _lib.valarray.access_ element access: + /** + * Return a reference to the i'th array element. + * + * @param i Index of element to return. + * @return Reference to the i'th element. + */ + _Tp& operator[](size_t); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 389. Const overload of valarray::operator[] returns by value. + const _Tp& operator[](size_t) const; + + // _lib.valarray.sub_ subset operations: + /** + * @brief Return an array subset. + * + * Returns a new valarray containing the elements of the array + * indicated by the slice argument. The new valarray has the same size + * as the input slice. @see slice. + * + * @param s The source slice. + * @return New valarray containing elements in @a s. + */ + _Expr<_SClos<_ValArray, _Tp>, _Tp> operator[](slice) const; + + /** + * @brief Return a reference to an array subset. + * + * Returns a new valarray containing the elements of the array + * indicated by the slice argument. The new valarray has the same size + * as the input slice. @see slice. + * + * @param s The source slice. + * @return New valarray containing elements in @a s. + */ + slice_array<_Tp> operator[](slice); + + /** + * @brief Return an array subset. + * + * Returns a slice_array referencing the elements of the array + * indicated by the slice argument. @see gslice. + * + * @param s The source slice. + * @return Slice_array referencing elements indicated by @a s. + */ + _Expr<_GClos<_ValArray, _Tp>, _Tp> operator[](const gslice&) const; + + /** + * @brief Return a reference to an array subset. + * + * Returns a new valarray containing the elements of the array + * indicated by the gslice argument. The new valarray has + * the same size as the input gslice. @see gslice. + * + * @param s The source gslice. + * @return New valarray containing elements in @a s. + */ + gslice_array<_Tp> operator[](const gslice&); + + /** + * @brief Return an array subset. + * + * Returns a new valarray containing the elements of the array + * indicated by the argument. The input is a valarray of bool which + * represents a bitmask indicating which elements should be copied into + * the new valarray. Each element of the array is added to the return + * valarray if the corresponding element of the argument is true. + * + * @param m The valarray bitmask. + * @return New valarray containing elements indicated by @a m. + */ + valarray<_Tp> operator[](const valarray<bool>&) const; + + /** + * @brief Return a reference to an array subset. + * + * Returns a new mask_array referencing the elements of the array + * indicated by the argument. The input is a valarray of bool which + * represents a bitmask indicating which elements are part of the + * subset. Elements of the array are part of the subset if the + * corresponding element of the argument is true. + * + * @param m The valarray bitmask. + * @return New valarray containing elements indicated by @a m. + */ + mask_array<_Tp> operator[](const valarray<bool>&); + + /** + * @brief Return an array subset. + * + * Returns a new valarray containing the elements of the array + * indicated by the argument. The elements in the argument are + * interpreted as the indices of elements of this valarray to copy to + * the return valarray. + * + * @param i The valarray element index list. + * @return New valarray containing elements in @a s. + */ + _Expr<_IClos<_ValArray, _Tp>, _Tp> + operator[](const valarray<size_t>&) const; + + /** + * @brief Return a reference to an array subset. + * + * Returns an indirect_array referencing the elements of the array + * indicated by the argument. The elements in the argument are + * interpreted as the indices of elements of this valarray to include + * in the subset. The returned indirect_array refers to these + * elements. + * + * @param i The valarray element index list. + * @return Indirect_array referencing elements in @a i. + */ + indirect_array<_Tp> operator[](const valarray<size_t>&); + + // _lib.valarray.unary_ unary operators: + /// Return a new valarray by applying unary + to each element. + typename _UnaryOp<__unary_plus>::_Rt operator+() const; + + /// Return a new valarray by applying unary - to each element. + typename _UnaryOp<__negate>::_Rt operator-() const; + + /// Return a new valarray by applying unary ~ to each element. + typename _UnaryOp<__bitwise_not>::_Rt operator~() const; + + /// Return a new valarray by applying unary ! to each element. + typename _UnaryOp<__logical_not>::_Rt operator!() const; + + // _lib.valarray.cassign_ computed assignment: + /// Multiply each element of array by @a t. + valarray<_Tp>& operator*=(const _Tp&); + + /// Divide each element of array by @a t. + valarray<_Tp>& operator/=(const _Tp&); + + /// Set each element e of array to e % @a t. + valarray<_Tp>& operator%=(const _Tp&); + + /// Add @a t to each element of array. + valarray<_Tp>& operator+=(const _Tp&); + + /// Subtract @a t to each element of array. + valarray<_Tp>& operator-=(const _Tp&); + + /// Set each element e of array to e ^ @a t. + valarray<_Tp>& operator^=(const _Tp&); + + /// Set each element e of array to e & @a t. + valarray<_Tp>& operator&=(const _Tp&); + + /// Set each element e of array to e | @a t. + valarray<_Tp>& operator|=(const _Tp&); + + /// Left shift each element e of array by @a t bits. + valarray<_Tp>& operator<<=(const _Tp&); + + /// Right shift each element e of array by @a t bits. + valarray<_Tp>& operator>>=(const _Tp&); + + /// Multiply elements of array by corresponding elements of @a v. + valarray<_Tp>& operator*=(const valarray<_Tp>&); + + /// Divide elements of array by corresponding elements of @a v. + valarray<_Tp>& operator/=(const valarray<_Tp>&); + + /// Modulo elements of array by corresponding elements of @a v. + valarray<_Tp>& operator%=(const valarray<_Tp>&); + + /// Add corresponding elements of @a v to elements of array. + valarray<_Tp>& operator+=(const valarray<_Tp>&); + + /// Subtract corresponding elements of @a v from elements of array. + valarray<_Tp>& operator-=(const valarray<_Tp>&); + + /// Logical xor corresponding elements of @a v with elements of array. + valarray<_Tp>& operator^=(const valarray<_Tp>&); + + /// Logical or corresponding elements of @a v with elements of array. + valarray<_Tp>& operator|=(const valarray<_Tp>&); + + /// Logical and corresponding elements of @a v with elements of array. + valarray<_Tp>& operator&=(const valarray<_Tp>&); + + /// Left shift elements of array by corresponding elements of @a v. + valarray<_Tp>& operator<<=(const valarray<_Tp>&); + + /// Right shift elements of array by corresponding elements of @a v. + valarray<_Tp>& operator>>=(const valarray<_Tp>&); + + template<class _Dom> + valarray<_Tp>& operator*=(const _Expr<_Dom, _Tp>&); + template<class _Dom> + valarray<_Tp>& operator/=(const _Expr<_Dom, _Tp>&); + template<class _Dom> + valarray<_Tp>& operator%=(const _Expr<_Dom, _Tp>&); + template<class _Dom> + valarray<_Tp>& operator+=(const _Expr<_Dom, _Tp>&); + template<class _Dom> + valarray<_Tp>& operator-=(const _Expr<_Dom, _Tp>&); + template<class _Dom> + valarray<_Tp>& operator^=(const _Expr<_Dom, _Tp>&); + template<class _Dom> + valarray<_Tp>& operator|=(const _Expr<_Dom, _Tp>&); + template<class _Dom> + valarray<_Tp>& operator&=(const _Expr<_Dom, _Tp>&); + template<class _Dom> + valarray<_Tp>& operator<<=(const _Expr<_Dom, _Tp>&); + template<class _Dom> + valarray<_Tp>& operator>>=(const _Expr<_Dom, _Tp>&); + + // _lib.valarray.members_ member functions: + /// Return the number of elements in array. + size_t size() const; + + /** + * @brief Return the sum of all elements in the array. + * + * Accumulates the sum of all elements into a Tp using +=. The order + * of adding the elements is unspecified. + */ + _Tp sum() const; + + /// Return the minimum element using operator<(). + _Tp min() const; + + /// Return the maximum element using operator<(). + _Tp max() const; + + /** + * @brief Return a shifted array. + * + * A new valarray is constructed as a copy of this array with elements + * in shifted positions. For an element with index i, the new position + * is i - n. The new valarray has the same size as the current one. + * New elements without a value are set to 0. Elements whose new + * position is outside the bounds of the array are discarded. + * + * Positive arguments shift toward index 0, discarding elements [0, n). + * Negative arguments discard elements from the top of the array. + * + * @param n Number of element positions to shift. + * @return New valarray with elements in shifted positions. + */ + valarray<_Tp> shift (int) const; + + /** + * @brief Return a rotated array. + * + * A new valarray is constructed as a copy of this array with elements + * in shifted positions. For an element with index i, the new position + * is (i - n) % size(). The new valarray has the same size as the + * current one. Elements that are shifted beyond the array bounds are + * shifted into the other end of the array. No elements are lost. + * + * Positive arguments shift toward index 0, wrapping around the top. + * Negative arguments shift towards the top, wrapping around to 0. + * + * @param n Number of element positions to rotate. + * @return New valarray with elements in shifted positions. + */ + valarray<_Tp> cshift(int) const; + + /** + * @brief Apply a function to the array. + * + * Returns a new valarray with elements assigned to the result of + * applying func to the corresponding element of this array. The new + * array has the same size as this one. + * + * @param func Function of Tp returning Tp to apply. + * @return New valarray with transformed elements. + */ + _Expr<_ValFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(_Tp)) const; + + /** + * @brief Apply a function to the array. + * + * Returns a new valarray with elements assigned to the result of + * applying func to the corresponding element of this array. The new + * array has the same size as this one. + * + * @param func Function of const Tp& returning Tp to apply. + * @return New valarray with transformed elements. + */ + _Expr<_RefFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(const _Tp&)) const; + + /** + * @brief Resize array. + * + * Resize this array to @a size and set all elements to @a c. All + * references and iterators are invalidated. + * + * @param size New array size. + * @param c New value for all elements. + */ + void resize(size_t __size, _Tp __c = _Tp()); + + private: + size_t _M_size; + _Tp* __restrict__ _M_data; + + friend class _Array<_Tp>; + }; + + template<typename _Tp> + inline const _Tp& + valarray<_Tp>::operator[](size_t __i) const + { + __glibcxx_requires_subscript(__i); + return _M_data[__i]; + } + + template<typename _Tp> + inline _Tp& + valarray<_Tp>::operator[](size_t __i) + { + __glibcxx_requires_subscript(__i); + return _M_data[__i]; + } + + // @} group numeric_arrays + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#include <bits/valarray_after.h> +#include <bits/slice_array.h> +#include <bits/gslice.h> +#include <bits/gslice_array.h> +#include <bits/mask_array.h> +#include <bits/indirect_array.h> + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup numeric_arrays + * @{ + */ + + template<typename _Tp> + inline + valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {} + + template<typename _Tp> + inline + valarray<_Tp>::valarray(size_t __n) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) + { std::__valarray_default_construct(_M_data, _M_data + __n); } + + template<typename _Tp> + inline + valarray<_Tp>::valarray(const _Tp& __t, size_t __n) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) + { std::__valarray_fill_construct(_M_data, _M_data + __n, __t); } + + template<typename _Tp> + inline + valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n) + : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) + { + _GLIBCXX_DEBUG_ASSERT(__p != 0 || __n == 0); + std::__valarray_copy_construct(__p, __p + __n, _M_data); + } + + template<typename _Tp> + inline + valarray<_Tp>::valarray(const valarray<_Tp>& __v) + : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size)) + { std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size, + _M_data); } + + template<typename _Tp> + inline + valarray<_Tp>::valarray(const slice_array<_Tp>& __sa) + : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz)) + { + std::__valarray_copy_construct + (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data)); + } + + template<typename _Tp> + inline + valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga) + : _M_size(__ga._M_index.size()), + _M_data(__valarray_get_storage<_Tp>(_M_size)) + { + std::__valarray_copy_construct + (__ga._M_array, _Array<size_t>(__ga._M_index), + _Array<_Tp>(_M_data), _M_size); + } + + template<typename _Tp> + inline + valarray<_Tp>::valarray(const mask_array<_Tp>& __ma) + : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz)) + { + std::__valarray_copy_construct + (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size); + } + + template<typename _Tp> + inline + valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia) + : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz)) + { + std::__valarray_copy_construct + (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size); + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Tp> + inline + valarray<_Tp>::valarray(initializer_list<_Tp> __l) + : _M_size(__l.size()), _M_data(__valarray_get_storage<_Tp>(__l.size())) + { std::__valarray_copy_construct (__l.begin(), __l.end(), _M_data); } +#endif + + template<typename _Tp> template<class _Dom> + inline + valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e) + : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size)) + { std::__valarray_copy_construct(__e, _M_size, _Array<_Tp>(_M_data)); } + + template<typename _Tp> + inline + valarray<_Tp>::~valarray() + { + std::__valarray_destroy_elements(_M_data, _M_data + _M_size); + std::__valarray_release_memory(_M_data); + } + + template<typename _Tp> + inline valarray<_Tp>& + valarray<_Tp>::operator=(const valarray<_Tp>& __v) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 630. arrays of valarray. + if (_M_size == __v._M_size) + std::__valarray_copy(__v._M_data, _M_size, _M_data); + else + { + if (_M_data) + { + std::__valarray_destroy_elements(_M_data, _M_data + _M_size); + std::__valarray_release_memory(_M_data); + } + _M_size = __v._M_size; + _M_data = __valarray_get_storage<_Tp>(_M_size); + std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size, + _M_data); + } + return *this; + } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Tp> + inline valarray<_Tp>& + valarray<_Tp>::operator=(initializer_list<_Tp> __l) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 630. arrays of valarray. + if (_M_size == __l.size()) + std::__valarray_copy(__l.begin(), __l.size(), _M_data); + else + { + if (_M_data) + { + std::__valarray_destroy_elements(_M_data, _M_data + _M_size); + std::__valarray_release_memory(_M_data); + } + _M_size = __l.size(); + _M_data = __valarray_get_storage<_Tp>(_M_size); + std::__valarray_copy_construct(__l.begin(), __l.begin() + _M_size, + _M_data); + } + return *this; + } +#endif + + template<typename _Tp> + inline valarray<_Tp>& + valarray<_Tp>::operator=(const _Tp& __t) + { + std::__valarray_fill(_M_data, _M_size, __t); + return *this; + } + + template<typename _Tp> + inline valarray<_Tp>& + valarray<_Tp>::operator=(const slice_array<_Tp>& __sa) + { + _GLIBCXX_DEBUG_ASSERT(_M_size == __sa._M_sz); + std::__valarray_copy(__sa._M_array, __sa._M_sz, + __sa._M_stride, _Array<_Tp>(_M_data)); + return *this; + } + + template<typename _Tp> + inline valarray<_Tp>& + valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga) + { + _GLIBCXX_DEBUG_ASSERT(_M_size == __ga._M_index.size()); + std::__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index), + _Array<_Tp>(_M_data), _M_size); + return *this; + } + + template<typename _Tp> + inline valarray<_Tp>& + valarray<_Tp>::operator=(const mask_array<_Tp>& __ma) + { + _GLIBCXX_DEBUG_ASSERT(_M_size == __ma._M_sz); + std::__valarray_copy(__ma._M_array, __ma._M_mask, + _Array<_Tp>(_M_data), _M_size); + return *this; + } + + template<typename _Tp> + inline valarray<_Tp>& + valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia) + { + _GLIBCXX_DEBUG_ASSERT(_M_size == __ia._M_sz); + std::__valarray_copy(__ia._M_array, __ia._M_index, + _Array<_Tp>(_M_data), _M_size); + return *this; + } + + template<typename _Tp> template<class _Dom> + inline valarray<_Tp>& + valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) + { + _GLIBCXX_DEBUG_ASSERT(_M_size == __e.size()); + std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); + return *this; + } + + template<typename _Tp> + inline _Expr<_SClos<_ValArray,_Tp>, _Tp> + valarray<_Tp>::operator[](slice __s) const + { + typedef _SClos<_ValArray,_Tp> _Closure; + return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s)); + } + + template<typename _Tp> + inline slice_array<_Tp> + valarray<_Tp>::operator[](slice __s) + { return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); } + + template<typename _Tp> + inline _Expr<_GClos<_ValArray,_Tp>, _Tp> + valarray<_Tp>::operator[](const gslice& __gs) const + { + typedef _GClos<_ValArray,_Tp> _Closure; + return _Expr<_Closure, _Tp> + (_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index)); + } + + template<typename _Tp> + inline gslice_array<_Tp> + valarray<_Tp>::operator[](const gslice& __gs) + { + return gslice_array<_Tp> + (_Array<_Tp>(_M_data), __gs._M_index->_M_index); + } + + template<typename _Tp> + inline valarray<_Tp> + valarray<_Tp>::operator[](const valarray<bool>& __m) const + { + size_t __s = 0; + size_t __e = __m.size(); + for (size_t __i=0; __i<__e; ++__i) + if (__m[__i]) ++__s; + return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s, + _Array<bool> (__m))); + } + + template<typename _Tp> + inline mask_array<_Tp> + valarray<_Tp>::operator[](const valarray<bool>& __m) + { + size_t __s = 0; + size_t __e = __m.size(); + for (size_t __i=0; __i<__e; ++__i) + if (__m[__i]) ++__s; + return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array<bool>(__m)); + } + + template<typename _Tp> + inline _Expr<_IClos<_ValArray,_Tp>, _Tp> + valarray<_Tp>::operator[](const valarray<size_t>& __i) const + { + typedef _IClos<_ValArray,_Tp> _Closure; + return _Expr<_Closure, _Tp>(_Closure(*this, __i)); + } + + template<typename _Tp> + inline indirect_array<_Tp> + valarray<_Tp>::operator[](const valarray<size_t>& __i) + { + return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(), + _Array<size_t>(__i)); + } + + template<class _Tp> + inline size_t + valarray<_Tp>::size() const + { return _M_size; } + + template<class _Tp> + inline _Tp + valarray<_Tp>::sum() const + { + _GLIBCXX_DEBUG_ASSERT(_M_size > 0); + return std::__valarray_sum(_M_data, _M_data + _M_size); + } + + template<class _Tp> + inline valarray<_Tp> + valarray<_Tp>::shift(int __n) const + { + valarray<_Tp> __ret; + + if (_M_size == 0) + return __ret; + + _Tp* __restrict__ __tmp_M_data = + std::__valarray_get_storage<_Tp>(_M_size); + + if (__n == 0) + std::__valarray_copy_construct(_M_data, + _M_data + _M_size, __tmp_M_data); + else if (__n > 0) // shift left + { + if (size_t(__n) > _M_size) + __n = int(_M_size); + + std::__valarray_copy_construct(_M_data + __n, + _M_data + _M_size, __tmp_M_data); + std::__valarray_default_construct(__tmp_M_data + _M_size - __n, + __tmp_M_data + _M_size); + } + else // shift right + { + if (-size_t(__n) > _M_size) + __n = -int(_M_size); + + std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n, + __tmp_M_data - __n); + std::__valarray_default_construct(__tmp_M_data, + __tmp_M_data - __n); + } + + __ret._M_size = _M_size; + __ret._M_data = __tmp_M_data; + return __ret; + } + + template<class _Tp> + inline valarray<_Tp> + valarray<_Tp>::cshift(int __n) const + { + valarray<_Tp> __ret; + + if (_M_size == 0) + return __ret; + + _Tp* __restrict__ __tmp_M_data = + std::__valarray_get_storage<_Tp>(_M_size); + + if (__n == 0) + std::__valarray_copy_construct(_M_data, + _M_data + _M_size, __tmp_M_data); + else if (__n > 0) // cshift left + { + if (size_t(__n) > _M_size) + __n = int(__n % _M_size); + + std::__valarray_copy_construct(_M_data, _M_data + __n, + __tmp_M_data + _M_size - __n); + std::__valarray_copy_construct(_M_data + __n, _M_data + _M_size, + __tmp_M_data); + } + else // cshift right + { + if (-size_t(__n) > _M_size) + __n = -int(-size_t(__n) % _M_size); + + std::__valarray_copy_construct(_M_data + _M_size + __n, + _M_data + _M_size, __tmp_M_data); + std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n, + __tmp_M_data - __n); + } + + __ret._M_size = _M_size; + __ret._M_data = __tmp_M_data; + return __ret; + } + + template<class _Tp> + inline void + valarray<_Tp>::resize(size_t __n, _Tp __c) + { + // This complication is so to make valarray<valarray<T> > work + // even though it is not required by the standard. Nobody should + // be saying valarray<valarray<T> > anyway. See the specs. + std::__valarray_destroy_elements(_M_data, _M_data + _M_size); + if (_M_size != __n) + { + std::__valarray_release_memory(_M_data); + _M_size = __n; + _M_data = __valarray_get_storage<_Tp>(__n); + } + std::__valarray_fill_construct(_M_data, _M_data + __n, __c); + } + + template<typename _Tp> + inline _Tp + valarray<_Tp>::min() const + { + _GLIBCXX_DEBUG_ASSERT(_M_size > 0); + return *std::min_element(_M_data, _M_data + _M_size); + } + + template<typename _Tp> + inline _Tp + valarray<_Tp>::max() const + { + _GLIBCXX_DEBUG_ASSERT(_M_size > 0); + return *std::max_element(_M_data, _M_data + _M_size); + } + + template<class _Tp> + inline _Expr<_ValFunClos<_ValArray, _Tp>, _Tp> + valarray<_Tp>::apply(_Tp func(_Tp)) const + { + typedef _ValFunClos<_ValArray, _Tp> _Closure; + return _Expr<_Closure, _Tp>(_Closure(*this, func)); + } + + template<class _Tp> + inline _Expr<_RefFunClos<_ValArray, _Tp>, _Tp> + valarray<_Tp>::apply(_Tp func(const _Tp &)) const + { + typedef _RefFunClos<_ValArray, _Tp> _Closure; + return _Expr<_Closure, _Tp>(_Closure(*this, func)); + } + +#define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \ + template<typename _Tp> \ + inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt \ + valarray<_Tp>::operator _Op() const \ + { \ + typedef _UnClos<_Name, _ValArray, _Tp> _Closure; \ + typedef typename __fun<_Name, _Tp>::result_type _Rt; \ + return _Expr<_Closure, _Rt>(_Closure(*this)); \ + } + + _DEFINE_VALARRAY_UNARY_OPERATOR(+, __unary_plus) + _DEFINE_VALARRAY_UNARY_OPERATOR(-, __negate) + _DEFINE_VALARRAY_UNARY_OPERATOR(~, __bitwise_not) + _DEFINE_VALARRAY_UNARY_OPERATOR (!, __logical_not) + +#undef _DEFINE_VALARRAY_UNARY_OPERATOR + +#define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \ + template<class _Tp> \ + inline valarray<_Tp>& \ + valarray<_Tp>::operator _Op##=(const _Tp &__t) \ + { \ + _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, __t); \ + return *this; \ + } \ + \ + template<class _Tp> \ + inline valarray<_Tp>& \ + valarray<_Tp>::operator _Op##=(const valarray<_Tp> &__v) \ + { \ + _GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size); \ + _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, \ + _Array<_Tp>(__v._M_data)); \ + return *this; \ + } + +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, __plus) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, __minus) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, __multiplies) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, __divides) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, __modulus) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, __bitwise_xor) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, __bitwise_and) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, __bitwise_or) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, __shift_left) +_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right) + +#undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT + +#define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \ + template<class _Tp> template<class _Dom> \ + inline valarray<_Tp>& \ + valarray<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e) \ + { \ + _Array_augmented_##_Name(_Array<_Tp>(_M_data), __e, _M_size); \ + return *this; \ + } + +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, __plus) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, __minus) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, __multiplies) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, __divides) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, __modulus) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, __bitwise_xor) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, __bitwise_and) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, __bitwise_or) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, __shift_left) +_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right) + +#undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT + + +#define _DEFINE_BINARY_OPERATOR(_Op, _Name) \ + template<typename _Tp> \ + inline _Expr<_BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp>, \ + typename __fun<_Name, _Tp>::result_type> \ + operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \ + { \ + _GLIBCXX_DEBUG_ASSERT(__v.size() == __w.size()); \ + typedef _BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp> _Closure; \ + typedef typename __fun<_Name, _Tp>::result_type _Rt; \ + return _Expr<_Closure, _Rt>(_Closure(__v, __w)); \ + } \ + \ + template<typename _Tp> \ + inline _Expr<_BinClos<_Name, _ValArray,_Constant, _Tp, _Tp>, \ + typename __fun<_Name, _Tp>::result_type> \ + operator _Op(const valarray<_Tp>& __v, const _Tp& __t) \ + { \ + typedef _BinClos<_Name, _ValArray, _Constant, _Tp, _Tp> _Closure; \ + typedef typename __fun<_Name, _Tp>::result_type _Rt; \ + return _Expr<_Closure, _Rt>(_Closure(__v, __t)); \ + } \ + \ + template<typename _Tp> \ + inline _Expr<_BinClos<_Name, _Constant, _ValArray, _Tp, _Tp>, \ + typename __fun<_Name, _Tp>::result_type> \ + operator _Op(const _Tp& __t, const valarray<_Tp>& __v) \ + { \ + typedef _BinClos<_Name, _Constant, _ValArray, _Tp, _Tp> _Closure; \ + typedef typename __fun<_Name, _Tp>::result_type _Rt; \ + return _Expr<_Closure, _Rt>(_Closure(__t, __v)); \ + } + +_DEFINE_BINARY_OPERATOR(+, __plus) +_DEFINE_BINARY_OPERATOR(-, __minus) +_DEFINE_BINARY_OPERATOR(*, __multiplies) +_DEFINE_BINARY_OPERATOR(/, __divides) +_DEFINE_BINARY_OPERATOR(%, __modulus) +_DEFINE_BINARY_OPERATOR(^, __bitwise_xor) +_DEFINE_BINARY_OPERATOR(&, __bitwise_and) +_DEFINE_BINARY_OPERATOR(|, __bitwise_or) +_DEFINE_BINARY_OPERATOR(<<, __shift_left) +_DEFINE_BINARY_OPERATOR(>>, __shift_right) +_DEFINE_BINARY_OPERATOR(&&, __logical_and) +_DEFINE_BINARY_OPERATOR(||, __logical_or) +_DEFINE_BINARY_OPERATOR(==, __equal_to) +_DEFINE_BINARY_OPERATOR(!=, __not_equal_to) +_DEFINE_BINARY_OPERATOR(<, __less) +_DEFINE_BINARY_OPERATOR(>, __greater) +_DEFINE_BINARY_OPERATOR(<=, __less_equal) +_DEFINE_BINARY_OPERATOR(>=, __greater_equal) + +#undef _DEFINE_BINARY_OPERATOR + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Return an iterator pointing to the first element of + * the valarray. + * @param va valarray. + */ + template<class _Tp> + inline _Tp* + begin(valarray<_Tp>& __va) + { return std::__addressof(__va[0]); } + + /** + * @brief Return an iterator pointing to the first element of + * the const valarray. + * @param va valarray. + */ + template<class _Tp> + inline const _Tp* + begin(const valarray<_Tp>& __va) + { return std::__addressof(__va[0]); } + + /** + * @brief Return an iterator pointing to one past the last element of + * the valarray. + * @param va valarray. + */ + template<class _Tp> + inline _Tp* + end(valarray<_Tp>& __va) + { return std::__addressof(__va[0]) + __va.size(); } + + /** + * @brief Return an iterator pointing to one past the last element of + * the const valarray. + * @param va valarray. + */ + template<class _Tp> + inline const _Tp* + end(const valarray<_Tp>& __va) + { return std::__addressof(__va[0]) + __va.size(); } +#endif // __GXX_EXPERIMENTAL_CXX0X__ + + // @} group numeric_arrays + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _GLIBCXX_VALARRAY */ diff --git a/libstdc++-v3/include/std/vector b/libstdc++-v3/include/std/vector new file mode 100644 index 000000000..5ea82d873 --- /dev/null +++ b/libstdc++-v3/include/std/vector @@ -0,0 +1,82 @@ +// <vector> -*- C++ -*- + +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010 +// 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 3, 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/* + * + * 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 + ded "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * 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. + */ + +/** @file include/vector + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_VECTOR +#define _GLIBCXX_VECTOR 1 + +#pragma GCC system_header + +#include <bits/stl_algobase.h> +#include <bits/allocator.h> +#include <bits/stl_construct.h> +#include <bits/stl_uninitialized.h> +#include <bits/stl_vector.h> +#include <bits/stl_bvector.h> +#include <bits/range_access.h> + +#ifndef _GLIBCXX_EXPORT_TEMPLATE +# include <bits/vector.tcc> +#endif + +#ifdef _GLIBCXX_DEBUG +# include <debug/vector> +#endif + +#ifdef _GLIBCXX_PROFILE +# include <profile/vector> +#endif + +#endif /* _GLIBCXX_VECTOR */ + |