2004-10-07 Benjamin Kosnik <bkoz@redhat.com>

	* include/tr1: New.
	* include/tr1/array: New.
	* include/Makefile.am (tr1_headers): New.
	(stamp-tr1): New.
	(install-headers): New.
	(allstamped): Add stamp-tr1.

	* include/ext/array_allocator.h: New.
	* include/Makefile.am: Add.
	* include/Makefile.in: Regenerate.
	* testsuite/ext/array_allocator/1.cc: New.
	* testsuite/ext/array_allocator/2.cc: New.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@88711 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 200 insertions, 0 deletions

diff --git a/libstdc++-v3/include/tr1/array b/libstdc++-v3/include/tr1/array
new file mode 100644
index 00000000000..e41fced7f3b
--- /dev/null
+++ b/libstdc++-v3/include/tr1/array
@@ -0,0 +1,200 @@
+// class template array -*- C++ -*-
+
+// Copyright (C) 2004 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+#ifndef _ARRAY
+#define _ARRAY 1
+
+#include <new>
+#include <iterator>
+
+//namespace std::tr1
+namespace std
+{
+namespace tr1
+{
+  // [6.2.2] Class template array template
+  // Requires complete type _Tp.
+  // Use of char array allows _Tp to skirt default constructable requirement.
+  template<typename _Tp, size_t _Nm = 1>
+    struct array
+    {
+      enum { _S_index = _Nm };
+
+      typedef _Tp 	    			value_type;
+      typedef value_type&                   	reference;
+      typedef const value_type&             	const_reference;
+      typedef value_type*          		iterator;
+      typedef const value_type*			const_iterator;
+      typedef size_t                    	size_type;
+      typedef ptrdiff_t                     	difference_type;
+      typedef std::reverse_iterator<iterator>	reverse_iterator;
+      typedef std::reverse_iterator<const_iterator>	const_reverse_iterator;
+      typedef char layout_type[sizeof(_Tp)] __attribute__ ((aligned(__alignof__(_Tp))));
+
+      layout_type _M_instance[_Nm];
+
+      // No explicit construct/copy/destroy for aggregate type.
+
+      void 
+      assign(const value_type& u); 
+
+      void 
+      swap(array&);
+
+      // Iterators.
+      iterator 
+      begin()
+      { return reinterpret_cast<iterator>(&_M_instance[0]); }
+
+      const_iterator 
+      begin() const 
+      { return reinterpret_cast<const_iterator>(&_M_instance[0]); }
+
+      iterator 
+      end() 
+      { return reinterpret_cast<iterator>(&_M_instance[_S_index - 1]); }
+
+      const_iterator 
+      end() const
+      { return reinterpret_cast<iterator>(&_M_instance[_S_index - 1]); }
+
+      reverse_iterator 
+      rbegin()
+      { return reverse_iterator(this->end()); }
+
+      const_reverse_iterator 
+      rbegin() const
+      { return const_reverse_iterator(this->end()); }
+
+      reverse_iterator 
+      rend()
+      { return reverse_iterator(this->begin()); }
+
+      const_reverse_iterator 
+      rend() const
+      { return const_reverse_iterator(this->begin()); }
+
+      // Capacity.
+      size_type 
+      size() const { return _S_index; }
+
+      size_type 
+      max_size() const
+      { 
+	// XXX Not specified. Unnecessary, this is fixed-size.
+	return _S_index; 
+      }
+
+      bool 
+      empty() const;
+
+      // Element access.
+      reference 
+      operator[](size_type __n)
+      { return reinterpret_cast<reference>(_M_instance[__n]); }
+
+      const_reference 
+      operator[](size_type __n) const
+      { return reinterpret_cast<const_reference>(_M_instance[__n]); }
+
+      const_reference 
+      at(size_type __n) const
+      { 
+	if (__builtin_expect(__n > _S_index, false))
+	  throw std::bad_alloc();
+	return reinterpret_cast<const_reference>(_M_instance[__n]); 
+      }
+
+      reference 
+      at(size_type __n)
+      { 
+	if (__builtin_expect(__n > _S_index, false))
+	  throw std::bad_alloc();
+	return reinterpret_cast<reference>(_M_instance[__n]); 
+      }
+
+      reference 
+      front(); 
+
+      const_reference 
+      front() const; 
+
+      reference 
+      back(); 
+
+      const_reference 
+      back() const; 
+
+      _Tp* 
+      data(); 
+
+      const _Tp* 
+      data() const;
+    };
+
+  // Array comparisons.
+ template<typename _Tp, size_t _Nm>
+   bool 
+   operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+   { return false; }
+
+ template<typename _Tp, size_t _Nm>
+   bool 
+   operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+   { return !(__one == __two); }
+
+ template<typename _Tp, size_t _Nm>
+   bool 
+   operator<(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+   { return false; }
+
+ template<typename _Tp, size_t _Nm>
+   bool 
+   operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+   { return false; }
+
+ template<typename _Tp, size_t _Nm>
+   bool 
+   operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+   { return false; }
+
+ template<typename _Tp, size_t _Nm>
+   bool 
+   operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+   { return false; }
+
+  // [6.2.2.2] Specialized algorithms.
+ template<typename _Tp, size_t _Nm>
+   void
+   swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+   { swap_ranges(__one.begin(), __one.end(), __two.begin()); }
+} // namespace std::tr1
+}
+
+#endif