1 files changed, 39 insertions, 39 deletions

diff --git a/libstdc++-v3/include/ext/pod_char_traits.h b/libstdc++-v3/include/ext/pod_char_traits.h
index 05190295f4b..c69025e005d 100644
--- a/libstdc++-v3/include/ext/pod_char_traits.h
+++ b/libstdc++-v3/include/ext/pod_char_traits.h
@@ -32,7 +32,7 @@
 
 #ifndef _POD_CHAR_TRAITS_H
 #define _POD_CHAR_TRAITS_H 1
- 
+
 #include <string>
 
 namespace __gnu_cxx
@@ -40,19 +40,19 @@ namespace __gnu_cxx
   template<typename V, typename I, typename S = mbstate_t>
     struct character
     {
-      typedef V 	value_type;
-      typedef I 	int_type;
-      typedef S 	state_type;
-      value_type 	value;
+      typedef V		value_type;
+      typedef I		int_type;
+      typedef S		state_type;
+      value_type	value;
     };
-  
+
   template<typename V, typename I>
-    inline bool 
+    inline bool
     operator==(const character<V, I>& lhs, const character<V, I>& rhs)
     { return lhs.value == rhs.value; }
-  
+
   template<typename V, typename I>
-    inline bool 
+    inline bool
     operator<(const character<V, I>& lhs, const character<V, I>& rhs)
     { return lhs.value < rhs.value; }
 } // namespace __gnu_cxx
@@ -63,93 +63,93 @@ namespace std
   template<typename V, typename I, typename S>
     struct char_traits<__gnu_cxx::character<V, I, S> >
     {
-      typedef __gnu_cxx::character<V, I, S> 	char_type;
+      typedef __gnu_cxx::character<V, I, S>	char_type;
 
       // NB: This type should be bigger than char_type, so as to
       // properly hold EOF values in addition to the full range of
       // char_type values.
-      // Also, assumes 
+      // Also, assumes
       // int_type(value_type) is valid.
       // int_type(-1) is possible.
       typedef typename char_type::int_type	int_type;
       typedef typename char_type::state_type	state_type;
       typedef fpos<state_type>			pos_type;
-      typedef streamoff 			off_type;
-      
-      static void 
+      typedef streamoff				off_type;
+
+      static void
       assign(char_type& __c1, const char_type& __c2)
       { __c1 = __c2; }
 
-      static bool 
+      static bool
       eq(const char_type& __c1, const char_type& __c2)
       { return __c1 == __c2; }
 
-      static bool 
+      static bool
       lt(const char_type& __c1, const char_type& __c2)
       { return __c1 < __c2; }
 
-      static int 
+      static int
       compare(const char_type* __s1, const char_type* __s2, size_t __n)
-      { 
+      {
 	for (size_t __i = 0; __i < __n; ++__i)
 	  if (!eq(__s1[__i], __s2[__i]))
 	    return lt(__s1[__i], __s2[__i]) ? -1 : 1;
-	return 0; 
+	return 0;
       }
 
       static size_t
       length(const char_type* __s)
-      { 
-	const char_type* __p = __s; 
-	while (__p->value) 
-	  ++__p; 
-	return (__p - __s); 
+      {
+	const char_type* __p = __s;
+	while (__p->value)
+	  ++__p;
+	return (__p - __s);
       }
 
-      static const char_type* 
+      static const char_type*
       find(const char_type* __s, size_t __n, const char_type& __a)
-      { 
+      {
 	for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
-	  if (*__p == __a) 
+	  if (*__p == __a)
 	    return __p;
 	return 0;
       }
 
-      static char_type* 
+      static char_type*
       move(char_type* __s1, const char_type* __s2, size_t __n)
       { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); }
 
-      static char_type* 
+      static char_type*
       copy(char_type* __s1, const char_type* __s2, size_t __n)
       { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); }
 
-      static char_type* 
+      static char_type*
       assign(char_type* __s, size_t __n, char_type __a)
-      { 
-	for (char_type* __p = __s; __p < __s + __n; ++__p) 
+      {
+	for (char_type* __p = __s; __p < __s + __n; ++__p)
 	  assign(*__p, __a);
-        return __s; 
+        return __s;
       }
 
-      static char_type 
+      static char_type
       to_char_type(const int_type& __c)
       {
 	char_type __r = { __c };
 	return __r;
       }
 
-      static int_type 
-      to_int_type(const char_type& __c) 
+      static int_type
+      to_int_type(const char_type& __c)
       { return int_type(__c.value); }
 
-      static bool 
+      static bool
       eq_int_type(const int_type& __c1, const int_type& __c2)
       { return __c1 == __c2; }
 
-      static int_type 
+      static int_type
       eof() { return static_cast<int_type>(-1); }
 
-      static int_type 
+      static int_type
       not_eof(const int_type& __c)
       { return eq_int_type(__c, eof()) ? int_type(0) : __c; }
     };