OSDN Git Service

2007-01-21 Paolo Carlini <pcarlini@suse.de>
authorpaolo <paolo@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 21 Jan 2007 09:57:42 +0000 (09:57 +0000)
committerpaolo <paolo@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 21 Jan 2007 09:57:42 +0000 (09:57 +0000)
PR libstdc++/30449 (fill, fill_n)
* include/bits/stl_algobase.h (__fill_aux(wchar_t*, wchar_t*,
const wchar_t&), __fill_n_aux(wchar_t*, _Size, const wchar_t&)): New.
(fill(signed char*, signed char*, const signed char&),
fill(unsigned char*, unsigned char*, const unsigned char&),
fill(char*, char*, char&), fill_n(signed char*, _Size,
const signed char&), fill_n(unsigned char*, _Size,
const unsigned char&), fill_n(char*, _Size, char&)): Rename to
__*_aux.
(__fill_normal, __fill_n_normal): New, call the latter.
(fill, fill_n): Adjust, call the latter.
* testsuite/25_algorithms/fill/4.cc: New.
* testsuite/25_algorithms/fill/5.cc: New.

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

libstdc++-v3/ChangeLog
libstdc++-v3/include/bits/stl_algobase.h
libstdc++-v3/testsuite/25_algorithms/fill/4.cc [new file with mode: 0644]
libstdc++-v3/testsuite/25_algorithms/fill/5.cc [new file with mode: 0644]

index 53fc417..80b49e1 100644 (file)
@@ -1,3 +1,19 @@
+2007-01-21  Paolo Carlini  <pcarlini@suse.de>
+
+       PR libstdc++/30449 (fill, fill_n)
+       * include/bits/stl_algobase.h (__fill_aux(wchar_t*, wchar_t*,
+       const wchar_t&), __fill_n_aux(wchar_t*, _Size, const wchar_t&)): New.
+       (fill(signed char*, signed char*, const signed char&),
+       fill(unsigned char*, unsigned char*, const unsigned char&),
+       fill(char*, char*, char&), fill_n(signed char*, _Size,
+       const signed char&), fill_n(unsigned char*, _Size,
+       const unsigned char&), fill_n(char*, _Size, char&)): Rename to
+       __*_aux.
+       (__fill_normal, __fill_n_normal): New, call the latter.
+       (fill, fill_n): Adjust, call the latter.        
+       * testsuite/25_algorithms/fill/4.cc: New.
+       * testsuite/25_algorithms/fill/5.cc: New.
+
 2007-01-18  Paolo Carlini  <pcarlini@suse.de>
 
        * include/bits/basic_string.h (basic_string<>::_S_compare): Add.
 2007-01-18  Paolo Carlini  <pcarlini@suse.de>
 
        * include/bits/basic_string.h (basic_string<>::_S_compare): Add.
index b5a0039..c0107fc 100644 (file)
@@ -1,6 +1,6 @@
 // Bits and pieces used in algorithms -*- C++ -*-
 
 // Bits and pieces used in algorithms -*- C++ -*-
 
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -64,6 +64,7 @@
 
 #include <bits/c++config.h>
 #include <cstring>
 
 #include <bits/c++config.h>
 #include <cstring>
+#include <cwchar>
 #include <climits>
 #include <cstdlib>
 #include <cstddef>
 #include <climits>
 #include <cstdlib>
 #include <cstddef>
@@ -540,6 +541,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
                                                                   __result);
     }
 
                                                                   __result);
     }
 
+
   template<bool>
     struct __fill
     {
   template<bool>
     struct __fill
     {
@@ -567,55 +569,93 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
        }
     };
 
        }
     };
 
-  /**
-   *  @brief Fills the range [first,last) with copies of value.
-   *  @param  first  A forward iterator.
-   *  @param  last   A forward iterator.
-   *  @param  value  A reference-to-const of arbitrary type.
-   *  @return   Nothing.
-   *
-   *  This function fills a range with copies of the same value.  For one-byte
-   *  types filling contiguous areas of memory, this becomes an inline call to
-   *  @c memset.
-  */
   template<typename _ForwardIterator, typename _Tp>
   template<typename _ForwardIterator, typename _Tp>
-    void
-    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
+    inline void
+    __fill_aux(_ForwardIterator __first, _ForwardIterator __last,
+              const _Tp& __value)
     {
     {
-      // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
-                                 _ForwardIterator>)
-      __glibcxx_requires_valid_range(__first, __last);
-
       const bool __scalar = __is_scalar<_Tp>::__value;
       std::__fill<__scalar>::fill(__first, __last, __value);
     }
 
       const bool __scalar = __is_scalar<_Tp>::__value;
       std::__fill<__scalar>::fill(__first, __last, __value);
     }
 
-  // Specialization: for one-byte types we can use memset.
+  // Specialization: for char types we can use memset (wmemset).
   inline void
   inline void
-  fill(unsigned char* __first, unsigned char* __last, const unsigned char& __c)
+  __fill_aux(unsigned char* __first, unsigned char* __last,
+            const unsigned char& __c)
   {
   {
-    __glibcxx_requires_valid_range(__first, __last);
     const unsigned char __tmp = __c;
     std::memset(__first, __tmp, __last - __first);
   }
 
   inline void
     const unsigned char __tmp = __c;
     std::memset(__first, __tmp, __last - __first);
   }
 
   inline void
-  fill(signed char* __first, signed char* __last, const signed char& __c)
+  __fill_aux(signed char* __first, signed char* __last,
+            const signed char& __c)
   {
   {
-    __glibcxx_requires_valid_range(__first, __last);
     const signed char __tmp = __c;
     std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
   }
 
   inline void
     const signed char __tmp = __c;
     std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
   }
 
   inline void
-  fill(char* __first, char* __last, const char& __c)
+  __fill_aux(char* __first, char* __last, const char& __c)
   {
   {
-    __glibcxx_requires_valid_range(__first, __last);
     const char __tmp = __c;
     std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
   }
 
     const char __tmp = __c;
     std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
   }
 
+#ifdef _GLIBCXX_USE_WCHAR_T
+  inline void
+  __fill_aux(wchar_t* __first, wchar_t* __last, const wchar_t& __c)
+  {
+    const wchar_t __tmp = __c;
+    std::wmemset(__first, __tmp, __last - __first);
+  }
+#endif
+
+  template<bool>
+    struct __fill_normal
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __fill_n(_ForwardIterator __first, _ForwardIterator __last,
+                const _Tp& __value)
+        { std::__fill_aux(__first, __last, __value); }
+    };
+
+  template<>
+    struct __fill_normal<true>
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __fill_n(_ForwardIterator __first, _ForwardIterator __last,
+                const _Tp& __value)
+        { std::__fill_aux(__first.base(), __last.base(), __value); }
+    };
+
+  /**
+   *  @brief Fills the range [first,last) with copies of value.
+   *  @param  first  A forward iterator.
+   *  @param  last   A forward iterator.
+   *  @param  value  A reference-to-const of arbitrary type.
+   *  @return   Nothing.
+   *
+   *  This function fills a range with copies of the same value.  For char
+   *  types filling contiguous areas of memory, this becomes an inline call
+   *  to @c memset or @c wmemset.
+  */
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+                                 _ForwardIterator>)
+      __glibcxx_requires_valid_range(__first, __last);
+
+      const bool __fi = __is_normal_iterator<_ForwardIterator>::__value;
+      std::__fill_normal<__fi>::__fill_n(__first, __last, __value);
+    }
+
+
   template<bool>
     struct __fill_n
     {
   template<bool>
     struct __fill_n
     {
@@ -643,51 +683,87 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
        }
     };
 
        }
     };
 
-  /**
-   *  @brief Fills the range [first,first+n) with copies of value.
-   *  @param  first  An output iterator.
-   *  @param  n      The count of copies to perform.
-   *  @param  value  A reference-to-const of arbitrary type.
-   *  @return   The iterator at first+n.
-   *
-   *  This function fills a range with copies of the same value.  For one-byte
-   *  types filling contiguous areas of memory, this becomes an inline call to
-   *  @c memset.
-  */
   template<typename _OutputIterator, typename _Size, typename _Tp>
   template<typename _OutputIterator, typename _Size, typename _Tp>
-    _OutputIterator
-    fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
+    inline _OutputIterator
+    __fill_n_aux(_OutputIterator __first, _Size __n, const _Tp& __value)
     {
     {
-      // concept requirements
-      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, _Tp>)
-
       const bool __scalar = __is_scalar<_Tp>::__value;
       return std::__fill_n<__scalar>::fill_n(__first, __n, __value);
     }
 
   template<typename _Size>
     inline unsigned char*
       const bool __scalar = __is_scalar<_Tp>::__value;
       return std::__fill_n<__scalar>::fill_n(__first, __n, __value);
     }
 
   template<typename _Size>
     inline unsigned char*
-    fill_n(unsigned char* __first, _Size __n, const unsigned char& __c)
+    __fill_n_aux(unsigned char* __first, _Size __n, const unsigned char& __c)
     {
     {
-      std::fill(__first, __first + __n, __c);
+      std::__fill_aux(__first, __first + __n, __c);
       return __first + __n;
     }
 
   template<typename _Size>
     inline signed char*
       return __first + __n;
     }
 
   template<typename _Size>
     inline signed char*
-    fill_n(signed char* __first, _Size __n, const signed char& __c)
+    __fill_n_aux(signed char* __first, _Size __n, const signed char& __c)
     {
     {
-      std::fill(__first, __first + __n, __c);
+      std::__fill_aux(__first, __first + __n, __c);
       return __first + __n;
     }
 
   template<typename _Size>
     inline char*
       return __first + __n;
     }
 
   template<typename _Size>
     inline char*
-    fill_n(char* __first, _Size __n, const char& __c)
+    __fill_n_aux(char* __first, _Size __n, const char& __c)
+    {
+      std::__fill_aux(__first, __first + __n, __c);
+      return __first + __n;
+    }
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  template<typename _Size>
+    inline wchar_t*
+    __fill_n_aux(wchar_t* __first, _Size __n, const wchar_t& __c)
     {
     {
-      std::fill(__first, __first + __n, __c);
+      std::__fill_aux(__first, __first + __n, __c);
       return __first + __n;
     }
       return __first + __n;
     }
+#endif
+
+  template<bool>
+    struct __fill_n_normal
+    {
+      template<typename _OI, typename _Size, typename _Tp>
+        static _OI
+        __fill_n_n(_OI __first, _Size __n, const _Tp& __value)
+        { return std::__fill_n_aux(__first, __n, __value); }
+    };
+
+  template<>
+    struct __fill_n_normal<true>
+    {
+      template<typename _OI, typename _Size, typename _Tp>
+        static _OI
+        __fill_n_n(_OI __first, _Size __n, const _Tp& __value)
+        { return _OI(std::__fill_n_aux(__first.base(), __n, __value)); }
+    };
+
+  /**
+   *  @brief Fills the range [first,first+n) with copies of value.
+   *  @param  first  An output iterator.
+   *  @param  n      The count of copies to perform.
+   *  @param  value  A reference-to-const of arbitrary type.
+   *  @return   The iterator at first+n.
+   *
+   *  This function fills a range with copies of the same value.  For char
+   *  types filling contiguous areas of memory, this becomes an inline call
+   *  to @c memset or @ wmemset.
+  */
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    inline _OutputIterator
+    fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      // concept requirements
+      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, _Tp>)
+
+      const bool __oi = __is_normal_iterator<_OutputIterator>::__value;
+      return std::__fill_n_normal<__oi>::__fill_n_n(__first, __n, __value);
+    }
 
   /**
    *  @brief Finds the places in ranges which don't match.
 
   /**
    *  @brief Finds the places in ranges which don't match.
diff --git a/libstdc++-v3/testsuite/25_algorithms/fill/4.cc b/libstdc++-v3/testsuite/25_algorithms/fill/4.cc
new file mode 100644 (file)
index 0000000..e8d5238
--- /dev/null
@@ -0,0 +1,76 @@
+// 2007-01-19  Paolo Carlini  <pcarlini@suse.de>
+
+// Copyright (C) 2007 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 Pred 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 25.2.5 [lib.alg.fill] Fill.
+
+#include <algorithm>
+#include <vector>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+  using namespace std;
+  bool test __attribute__((unused)) = true;
+
+  const int A1[] = {3, 3, 3, 3, 3, 3, 3, 3, 3, 3};
+  const int N1 = sizeof(A1) / sizeof(int);
+  
+  int i1[N1];
+  fill(i1, i1 + N1, 3);
+  VERIFY( equal(i1, i1 + N1, A1) );
+
+  vector<int> v1(N1);
+  fill(v1.begin(), v1.end(), 3);
+  VERIFY( equal(v1.begin(), v1.end(), A1) );
+
+  const char A2[] = {'\3', '\3', '\3', '\3', '\3',
+                    '\3', '\3', '\3', '\3', '\3'};
+  const int N2 = sizeof(A2) / sizeof(char);
+
+  char i2[N2];
+  fill(i2, i2 + N2, '\3');
+  VERIFY( equal(i2, i2 + N2, A2) );
+
+  vector<char> v2(N2);
+  fill(v2.begin(), v2.end(), '\3');
+  VERIFY( equal(v2.begin(), v2.end(), A2) );
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  const wchar_t A3[] = {L'\3', L'\3', L'\3', L'\3', L'\3',
+                       L'\3', L'\3', L'\3', L'\3', L'\3'};
+  const int N3 = sizeof(A3) / sizeof(wchar_t);
+
+  wchar_t i3[N3];
+  fill(i3, i3 + N3, L'\3');
+  VERIFY( equal(i3, i3 + N3, A3) );
+
+  vector<wchar_t> v3(N3);
+  fill(v3.begin(), v3.end(), L'\3');
+  VERIFY( equal(v3.begin(), v3.end(), A3) );
+#endif
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/25_algorithms/fill/5.cc b/libstdc++-v3/testsuite/25_algorithms/fill/5.cc
new file mode 100644 (file)
index 0000000..8fdb153
--- /dev/null
@@ -0,0 +1,76 @@
+// 2007-01-19  Paolo Carlini  <pcarlini@suse.de>
+
+// Copyright (C) 2007 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 Pred 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 25.2.5 [lib.alg.fill] Fill_n.
+
+#include <algorithm>
+#include <vector>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+  using namespace std;
+  bool test __attribute__((unused)) = true;
+
+  const int A1[] = {3, 3, 3, 3, 3, 3, 3, 3, 3, 3};
+  const int N1 = sizeof(A1) / sizeof(int);
+  
+  int i1[N1];
+  fill_n(i1, N1, 3);
+  VERIFY( equal(i1, i1 + N1, A1) );
+
+  vector<int> v1(N1);
+  fill_n(v1.begin(), N1, 3);
+  VERIFY( equal(v1.begin(), v1.end(), A1) );
+
+  const char A2[] = {'\3', '\3', '\3', '\3', '\3',
+                    '\3', '\3', '\3', '\3', '\3'};
+  const int N2 = sizeof(A2) / sizeof(char);
+
+  char i2[N2];
+  fill_n(i2, N2, '\3');
+  VERIFY( equal(i2, i2 + N2, A2) );
+
+  vector<char> v2(N2);
+  fill_n(v2.begin(), N2, '\3');
+  VERIFY( equal(v2.begin(), v2.end(), A2) );
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  const wchar_t A3[] = {L'\3', L'\3', L'\3', L'\3', L'\3',
+                       L'\3', L'\3', L'\3', L'\3', L'\3'};
+  const int N3 = sizeof(A3) / sizeof(wchar_t);
+
+  wchar_t i3[N3];
+  fill_n(i3, N3, L'\3');
+  VERIFY( equal(i3, i3 + N3, A3) );
+
+  vector<wchar_t> v3(N3);
+  fill_n(v3.begin(), N3, L'\3');
+  VERIFY( equal(v3.begin(), v3.end(), A3) );
+#endif
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}