Virgin import of GCC 2.95.1's libstdc++

1 files changed, 176 insertions, 133 deletions

diff --git a/contrib/libstdc++/stl/stl_numeric.h b/contrib/libstdc++/stl/stl_numeric.h
index 57fee2b..392515a 100644
--- a/contrib/libstdc++/stl/stl_numeric.h
+++ b/contrib/libstdc++/stl/stl_numeric.h
@@ -34,157 +34,200 @@
 
 __STL_BEGIN_NAMESPACE
 
-template <class InputIterator, class T>
-T accumulate(InputIterator first, InputIterator last, T init) {
-  for ( ; first != last; ++first)
-    init = init + *first;
-  return init;
-}
-
-template <class InputIterator, class T, class BinaryOperation>
-T accumulate(InputIterator first, InputIterator last, T init,
-             BinaryOperation binary_op) {
-  for ( ; first != last; ++first)
-    init = binary_op(init, *first);
-  return init;
-}
-
-template <class InputIterator1, class InputIterator2, class T>
-T inner_product(InputIterator1 first1, InputIterator1 last1,
-                InputIterator2 first2, T init) {
-  for ( ; first1 != last1; ++first1, ++first2)
-    init = init + (*first1 * *first2);
-  return init;
-}
-
-template <class InputIterator1, class InputIterator2, class T,
-          class BinaryOperation1, class BinaryOperation2>
-T inner_product(InputIterator1 first1, InputIterator1 last1,
-                InputIterator2 first2, T init, BinaryOperation1 binary_op1,
-                BinaryOperation2 binary_op2) {
-  for ( ; first1 != last1; ++first1, ++first2)
-    init = binary_op1(init, binary_op2(*first1, *first2));
-  return init;
-}
-
-template <class InputIterator, class OutputIterator, class T>
-OutputIterator __partial_sum(InputIterator first, InputIterator last,
-                             OutputIterator result, T*) {
-  T value = *first;
-  while (++first != last) {
-    value = value + *first;
-    *++result = value;
+template <class _InputIterator, class _Tp>
+_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
+{
+  for ( ; __first != __last; ++__first)
+    __init = __init + *__first;
+  return __init;
+}
+
+template <class _InputIterator, class _Tp, class _BinaryOperation>
+_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
+               _BinaryOperation __binary_op)
+{
+  for ( ; __first != __last; ++__first)
+    __init = __binary_op(__init, *__first);
+  return __init;
+}
+
+template <class _InputIterator1, class _InputIterator2, class _Tp>
+_Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+                  _InputIterator2 __first2, _Tp __init)
+{
+  for ( ; __first1 != __last1; ++__first1, ++__first2)
+    __init = __init + (*__first1 * *__first2);
+  return __init;
+}
+
+template <class _InputIterator1, class _InputIterator2, class _Tp,
+          class _BinaryOperation1, class _BinaryOperation2>
+_Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+                  _InputIterator2 __first2, _Tp __init, 
+                  _BinaryOperation1 __binary_op1,
+                  _BinaryOperation2 __binary_op2)
+{
+  for ( ; __first1 != __last1; ++__first1, ++__first2)
+    __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
+  return __init;
+}
+
+template <class _InputIterator, class _OutputIterator, class _Tp>
+_OutputIterator 
+__partial_sum(_InputIterator __first, _InputIterator __last,
+              _OutputIterator __result, _Tp*)
+{
+  _Tp __value = *__first;
+  while (++__first != __last) {
+    __value = __value + *__first;
+    *++__result = __value;
   }
-  return ++result;
-}
-
-template <class InputIterator, class OutputIterator>
-OutputIterator partial_sum(InputIterator first, InputIterator last,
-                           OutputIterator result) {
-  if (first == last) return result;
-  *result = *first;
-  return __partial_sum(first, last, result, value_type(first));
-}
-
-template <class InputIterator, class OutputIterator, class T,
-          class BinaryOperation>
-OutputIterator __partial_sum(InputIterator first, InputIterator last,
-                             OutputIterator result, T*,
-                             BinaryOperation binary_op) {
-  T value = *first;
-  while (++first != last) {
-    value = binary_op(value, *first);
-    *++result = value;
+  return ++__result;
+}
+
+template <class _InputIterator, class _OutputIterator>
+_OutputIterator 
+partial_sum(_InputIterator __first, _InputIterator __last,
+            _OutputIterator __result)
+{
+  if (__first == __last) return __result;
+  *__result = *__first;
+  return __partial_sum(__first, __last, __result, __VALUE_TYPE(__first));
+}
+
+template <class _InputIterator, class _OutputIterator, class _Tp,
+          class _BinaryOperation>
+_OutputIterator 
+__partial_sum(_InputIterator __first, _InputIterator __last, 
+              _OutputIterator __result, _Tp*, _BinaryOperation __binary_op)
+{
+  _Tp __value = *__first;
+  while (++__first != __last) {
+    __value = __binary_op(__value, *__first);
+    *++__result = __value;
   }
-  return ++result;
+  return ++__result;
 }
 
-template <class InputIterator, class OutputIterator, class BinaryOperation>
-OutputIterator partial_sum(InputIterator first, InputIterator last,
-                           OutputIterator result, BinaryOperation binary_op) {
-  if (first == last) return result;
-  *result = *first;
-  return __partial_sum(first, last, result, value_type(first), binary_op);
+template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
+_OutputIterator 
+partial_sum(_InputIterator __first, _InputIterator __last,
+            _OutputIterator __result, _BinaryOperation __binary_op)
+{
+  if (__first == __last) return __result;
+  *__result = *__first;
+  return __partial_sum(__first, __last, __result, __VALUE_TYPE(__first), 
+                       __binary_op);
 }
 
-template <class InputIterator, class OutputIterator, class T>
-OutputIterator __adjacent_difference(InputIterator first, InputIterator last, 
-                                     OutputIterator result, T*) {
-  T value = *first;
-  while (++first != last) {
-    T tmp = *first;
-    *++result = tmp - value;
-    value = tmp;
+template <class _InputIterator, class _OutputIterator, class _Tp>
+_OutputIterator 
+__adjacent_difference(_InputIterator __first, _InputIterator __last,
+                      _OutputIterator __result, _Tp*)
+{
+  _Tp __value = *__first;
+  while (++__first != __last) {
+    _Tp __tmp = *__first;
+    *++__result = __tmp - __value;
+    __value = __tmp;
   }
-  return ++result;
-}
-
-template <class InputIterator, class OutputIterator>
-OutputIterator adjacent_difference(InputIterator first, InputIterator last, 
-                                   OutputIterator result) {
-  if (first == last) return result;
-  *result = *first;
-  return __adjacent_difference(first, last, result, value_type(first));
-}
-
-template <class InputIterator, class OutputIterator, class T, 
-          class BinaryOperation>
-OutputIterator __adjacent_difference(InputIterator first, InputIterator last, 
-                                     OutputIterator result, T*,
-                                     BinaryOperation binary_op) {
-  T value = *first;
-  while (++first != last) {
-    T tmp = *first;
-    *++result = binary_op(tmp, value);
-    value = tmp;
+  return ++__result;
+}
+
+template <class _InputIterator, class _OutputIterator>
+_OutputIterator
+adjacent_difference(_InputIterator __first,
+                    _InputIterator __last, _OutputIterator __result)
+{
+  if (__first == __last) return __result;
+  *__result = *__first;
+  return __adjacent_difference(__first, __last, __result,
+                               __VALUE_TYPE(__first));
+}
+
+template <class _InputIterator, class _OutputIterator, class _Tp, 
+          class _BinaryOperation>
+_OutputIterator
+__adjacent_difference(_InputIterator __first, _InputIterator __last, 
+                      _OutputIterator __result, _Tp*,
+                      _BinaryOperation __binary_op) {
+  _Tp __value = *__first;
+  while (++__first != __last) {
+    _Tp __tmp = *__first;
+    *++__result = __binary_op(__tmp, __value);
+    __value = __tmp;
   }
-  return ++result;
-}
-
-template <class InputIterator, class OutputIterator, class BinaryOperation>
-OutputIterator adjacent_difference(InputIterator first, InputIterator last,
-                                   OutputIterator result,
-                                   BinaryOperation binary_op) {
-  if (first == last) return result;
-  *result = *first;
-  return __adjacent_difference(first, last, result, value_type(first),
-                               binary_op);
-}
-
-// Returns x ** n, where n >= 0.  Note that "multiplication"
-//  is required to be associative, but not necessarily commutative.
-    
-template <class T, class Integer, class MonoidOperation>
-T power(T x, Integer n, MonoidOperation op) {
-  if (n == 0)
-    return identity_element(op);
+  return ++__result;
+}
+
+template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
+_OutputIterator 
+adjacent_difference(_InputIterator __first, _InputIterator __last,
+                    _OutputIterator __result, _BinaryOperation __binary_op)
+{
+  if (__first == __last) return __result;
+  *__result = *__first;
+  return __adjacent_difference(__first, __last, __result,
+                               __VALUE_TYPE(__first),
+                               __binary_op);
+}
+
+// Returns __x ** __n, where __n >= 0.  _Note that "multiplication"
+// is required to be associative, but not necessarily commutative.
+
+ 
+template <class _Tp, class _Integer, class _MonoidOperation>
+_Tp __power(_Tp __x, _Integer __n, _MonoidOperation __oper)
+{
+  if (__n == 0)
+    return identity_element(__oper);
   else {
-    while ((n & 1) == 0) {
-      n >>= 1;
-      x = op(x, x);
+    while ((__n & 1) == 0) {
+      __n >>= 1;
+      __x = __oper(__x, __x);
     }
 
-    T result = x;
-    n >>= 1;
-    while (n != 0) {
-      x = op(x, x);
-      if ((n & 1) != 0)
-        result = op(result, x);
-      n >>= 1;
+    _Tp __result = __x;
+    __n >>= 1;
+    while (__n != 0) {
+      __x = __oper(__x, __x);
+      if ((__n & 1) != 0)
+        __result = __oper(__result, __x);
+      __n >>= 1;
     }
-    return result;
+    return __result;
   }
 }
 
-template <class T, class Integer>
-inline T power(T x, Integer n) {
-  return power(x, n, multiplies<T>());
+template <class _Tp, class _Integer>
+inline _Tp __power(_Tp __x, _Integer __n)
+{
+  return __power(__x, __n, multiplies<_Tp>());
+}
+
+// Alias for the internal name __power.  Note that power is an extension,
+// not part of the C++ standard.
+
+template <class _Tp, class _Integer, class _MonoidOperation>
+inline _Tp power(_Tp __x, _Integer __n, _MonoidOperation __oper)
+{
+  return __power(__x, __n, __oper);
+}
+
+template <class _Tp, class _Integer>
+inline _Tp power(_Tp __x, _Integer __n)
+{
+  return __power(__x, __n);
 }
 
+// iota is not part of the C++ standard.  It is an extension.
 
-template <class ForwardIterator, class T>
-void iota(ForwardIterator first, ForwardIterator last, T value) {
-  while (first != last) *first++ = value++;
+template <class _ForwardIterator, class _Tp>
+void 
+iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
+{
+  while (__first != __last)
+    *__first++ = __value++;
 }
 
 __STL_END_NAMESPACE