[thirdparty/gcc.git] / libstdc++-v3 / include / bits / char_traits.h

// Character Traits for use by standard string and iostream -*- C++ -*-

// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
// 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// 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.

//
// ISO C++ 14882: 21  Strings library
//

/** @file char_traits.h
 *  This is an internal header file, included by other library headers.
 *  You should not attempt to use it directly.
 */

#ifndef _CHAR_TRAITS_H
#define _CHAR_TRAITS_H 1

#pragma GCC system_header

#include <cstring>            // For memmove, memset, memchr
#include <bits/stl_algobase.h>// For copy, lexicographical_compare, fill_n
#include <bits/postypes.h>    // For streampos

namespace __gnu_cxx
{
  /**
   *  @brief  Mapping from character type to associated types.
   *
   *  @note This is an implementation class for the generic version
   *  of char_traits.  It defines int_type, off_type, pos_type, and
   *  state_type.  By default these are unsigned long, streamoff,
   *  streampos, and mbstate_t.  Users who need a different set of
   *  types, but who don't need to change the definitions of any function
   *  defined in char_traits, can specialize __gnu_cxx::_Char_types
   *  while leaving __gnu_cxx::char_traits alone. */
  template <class _CharT>
    struct _Char_types
    {
      typedef unsigned long   int_type;
      typedef std::streampos  pos_type;
      typedef std::streamoff  off_type;
      typedef std::mbstate_t  state_type;
    };


  /**
   *  @brief  Base class used to implement std::char_traits.
   *
   *  @note For any given actual character type, this definition is
   *  probably wrong.  (Most of the member functions are likely to be
   *  right, but the int_type and state_type typedefs, and the eof()
   *  member function, are likely to be wrong.)  The reason this class
   *  exists is so users can specialize it.  Classes in namespace std
   *  may not be specialized for fundamentl types, but classes in
   *  namespace __gnu_cxx may be.
   *
   *  See http://gcc.gnu.org/onlinedocs/libstdc++/21_strings/howto.html#5
   *  for advice on how to make use of this class for "unusual" character
   *  types. Also, check out include/ext/pod_char_traits.h.  
   */
  template<typename _CharT>
    struct char_traits
    {
      typedef _CharT                                    char_type;
      typedef typename _Char_types<_CharT>::int_type    int_type;
      typedef typename _Char_types<_CharT>::pos_type    pos_type;
      typedef typename _Char_types<_CharT>::off_type    off_type;
      typedef typename _Char_types<_CharT>::state_type  state_type;

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);

      static std::size_t
      length(const char_type* __s);

      static const char_type*
      find(const char_type* __s, std::size_t __n, const char_type& __a);

      static char_type*
      move(char_type* __s1, const char_type* __s2, std::size_t __n);

      static char_type*
      copy(char_type* __s1, const char_type* __s2, std::size_t __n);

      static char_type*
      assign(char_type* __s, std::size_t __n, char_type __a);

      static char_type
      to_char_type(const int_type& __c)
      { return static_cast<char_type>(__c); }

      static int_type
      to_int_type(const char_type& __c)
      { return static_cast<int_type>(__c); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static int_type
      eof()
      { return static_cast<int_type>(EOF); }

      static int_type
      not_eof(const int_type& __c)
      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
    };

  template<typename _CharT>
    int
    char_traits<_CharT>::
    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      for (size_t __i = 0; __i < __n; ++__i)
	if (lt(__s1[__i], __s2[__i]))
	  return -1;
	else if (lt(__s2[__i], __s1[__i]))
	  return 1;
      return 0;
    }

  template<typename _CharT>
    std::size_t
    char_traits<_CharT>::
    length(const char_type* __p)
    {
      std::size_t __i = 0;
      while (!eq(__p[__i], char_type()))
        ++__i;
      return __i;
    }

  template<typename _CharT>
    const typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    find(const char_type* __s, std::size_t __n, const char_type& __a)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
        if (eq(__s[__i], __a))
          return __s + __i;
      return 0;
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    move(char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      return static_cast<_CharT*>(std::memmove(__s1, __s2,
					       __n * sizeof(char_type)));
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      std::copy(__s2, __s2 + __n, __s1);
      return __s1;
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    assign(char_type* __s, std::size_t __n, char_type __a)
    {
      std::fill_n(__s, __n, __a);
      return __s;
    }
}

namespace std
{
  // 21.1
  /**
   *  @brief  Basis for explicit traits specializations.
   *
   *  @note  For any given actual character type, this definition is
   *  probably wrong.  Since this is just a thin wrapper around
   *  __gnu_cxx::char_traits, it is possible to achieve a more
   *  appropriate definition by specializing __gnu_cxx::char_traits.
   *
   *  See http://gcc.gnu.org/onlinedocs/libstdc++/21_strings/howto.html#5
   *  for advice on how to make use of this class for "unusual" character
   *  types. Also, check out include/ext/pod_char_traits.h.
  */
  template<class _CharT>
    struct char_traits : public __gnu_cxx::char_traits<_CharT>
    { };


  /// @brief  21.1.3.1  char_traits specializations
  template<>
    struct char_traits<char>
    {
      typedef char              char_type;
      typedef int               int_type;
      typedef streampos         pos_type;
      typedef streamoff         off_type;
      typedef mbstate_t         state_type;

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      { return memcmp(__s1, __s2, __n); }

      static size_t
      length(const char_type* __s)
      { return strlen(__s); }

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      { return static_cast<const char_type*>(memchr(__s, __a, __n)); }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      { return static_cast<char_type*>(memmove(__s1, __s2, __n)); }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      { return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      { return static_cast<char_type*>(memset(__s, __a, __n)); }

      static char_type
      to_char_type(const int_type& __c)
      { return static_cast<char_type>(__c); }

      // To keep both the byte 0xff and the eof symbol 0xffffffff
      // from ending up as 0xffffffff.
      static int_type
      to_int_type(const char_type& __c)
      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static int_type
      eof() { return static_cast<int_type>(EOF); }

      static int_type
      not_eof(const int_type& __c)
      { return (__c == eof()) ? 0 : __c; }
  };


#ifdef _GLIBCXX_USE_WCHAR_T
  /// @brief  21.1.3.2  char_traits specializations
  template<>
    struct char_traits<wchar_t>
    {
      typedef wchar_t           char_type;
      typedef wint_t            int_type;
      typedef streamoff         off_type;
      typedef wstreampos        pos_type;
      typedef mbstate_t         state_type;

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      { return wmemcmp(__s1, __s2, __n); }

      static size_t
      length(const char_type* __s)
      { return wcslen(__s); }

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      { return wmemchr(__s, __a, __n); }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      { return wmemmove(__s1, __s2, __n); }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      { return wmemcpy(__s1, __s2, __n); }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      { return wmemset(__s, __a, __n); }

      static char_type
      to_char_type(const int_type& __c) { return char_type(__c); }

      static int_type
      to_int_type(const char_type& __c) { return int_type(__c); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static int_type
      eof() { return static_cast<int_type>(WEOF); }

      static int_type
      not_eof(const int_type& __c)
      { return eq_int_type(__c, eof()) ? 0 : __c; }
  };
#endif //_GLIBCXX_USE_WCHAR_T

} // namespace std

#endif
Commit	Line	Data
725dc051 BK	1	// Character Traits for use by standard string and iostream -- C++ --
725dc051 BK	2
bb2b2a24	3	// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
f13a69ec	4	// Free Software Foundation, Inc.
725dc051 BK	5	//
	6	// This file is part of the GNU ISO C++ Library. This library is free
	7	// software; you can redistribute it and/or modify it under the
	8	// terms of the GNU General Public License as published by the
	9	// Free Software Foundation; either version 2, or (at your option)
	10	// any later version.
	11
	12	// This library is distributed in the hope that it will be useful,
	13	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	// GNU General Public License for more details.
	16
	17	// You should have received a copy of the GNU General Public License along
	18	// with this library; see the file COPYING. If not, write to the Free
83f51799	19	// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
725dc051 BK	20	// USA.
	21
	22	// As a special exception, you may use this file as part of a free software
	23	// library without restriction. Specifically, if other files instantiate
	24	// templates or use macros or inline functions from this file, or you compile
	25	// this file and link it with other files to produce an executable, this
	26	// file does not by itself cause the resulting executable to be covered by
	27	// the GNU General Public License. This exception does not however
	28	// invalidate any other reasons why the executable file might be covered by
	29	// the GNU General Public License.
	30
	31	//
	32	// ISO C++ 14882: 21 Strings library
	33	//
	34
729e3d3f PE	35	/** @file char_traits.h
	36	* This is an internal header file, included by other library headers.
	37	* You should not attempt to use it directly.
	38	*/
	39
3d7c150e BK	40	#ifndef _CHAR_TRAITS_H
3d7c150e BK	41	#define _CHAR_TRAITS_H 1
725dc051	42
b0a85b86 GDR	43	#pragma GCC system_header
b0a85b86 GDR	44
51122a42	45	#include <cstring> // For memmove, memset, memchr
d5ff4e3f	46	#include <bits/stl_algobase.h>// For copy, lexicographical_compare, fill_n
4c4809c1	47	#include <bits/postypes.h> // For streampos
725dc051	48
d5ff4e3f	49	namespace __gnu_cxx
d32c94be	50	{
aa2d5ba2	51	/**
d5ff4e3f	52	* @brief Mapping from character type to associated types.
ed6814f7	53	*
d5ff4e3f MA	54	* @note This is an implementation class for the generic version
	55	* of char_traits. It defines int_type, off_type, pos_type, and
	56	* state_type. By default these are unsigned long, streamoff,
ed6814f7	57	* streampos, and mbstate_t. Users who need a different set of
d5ff4e3f MA	58	* types, but who don't need to change the definitions of any function
	59	* defined in char_traits, can specialize __gnu_cxx::_Char_types
	60	* while leaving __gnu_cxx::char_traits alone. */
	61	template <class _CharT>
	62	struct _Char_types
	63	{
	64	typedef unsigned long int_type;
	65	typedef std::streampos pos_type;
	66	typedef std::streamoff off_type;
	67	typedef std::mbstate_t state_type;
	68	};
	69
	70
	71	/**
	72	* @brief Base class used to implement std::char_traits.
	73	*
	74	* @note For any given actual character type, this definition is
	75	* probably wrong. (Most of the member functions are likely to be
	76	* right, but the int_type and state_type typedefs, and the eof()
	77	* member function, are likely to be wrong.) The reason this class
	78	* exists is so users can specialize it. Classes in namespace std
	79	* may not be specialized for fundamentl types, but classes in
	80	* namespace __gnu_cxx may be.
51122a42 PE	81	*
	82	* See http://gcc.gnu.org/onlinedocs/libstdc++/21_strings/howto.html#5
	83	* for advice on how to make use of this class for "unusual" character
6309eefc BK	84	* types. Also, check out include/ext/pod_char_traits.h.
6309eefc BK	85	*/
d5ff4e3f	86	template<typename _CharT>
725dc051 BK	87	struct char_traits
725dc051 BK	88	{
d5ff4e3f MA	89	typedef _CharT char_type;
	90	typedef typename _Char_types<_CharT>::int_type int_type;
	91	typedef typename _Char_types<_CharT>::pos_type pos_type;
	92	typedef typename _Char_types<_CharT>::off_type off_type;
	93	typedef typename _Char_types<_CharT>::state_type state_type;
ed6814f7 BI	94
ed6814f7 BI	95	static void
d5ff4e3f MA	96	assign(char_type& __c1, const char_type& __c2)
d5ff4e3f MA	97	{ __c1 = __c2; }
725dc051	98
ed6814f7	99	static bool
d5ff4e3f MA	100	eq(const char_type& __c1, const char_type& __c2)
d5ff4e3f MA	101	{ return __c1 == __c2; }
725dc051	102
ed6814f7	103	static bool
d5ff4e3f MA	104	lt(const char_type& __c1, const char_type& __c2)
d5ff4e3f MA	105	{ return __c1 < __c2; }
725dc051	106
ed6814f7	107	static int
d5ff4e3f	108	compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
725dc051	109
d5ff4e3f	110	static std::size_t
f13a69ec	111	length(const char_type* __s);
725dc051	112
ed6814f7	113	static const char_type*
d5ff4e3f	114	find(const char_type* __s, std::size_t __n, const char_type& __a);
725dc051	115
ed6814f7	116	static char_type*
d5ff4e3f	117	move(char_type* __s1, const char_type* __s2, std::size_t __n);
725dc051	118
ed6814f7	119	static char_type*
d5ff4e3f	120	copy(char_type* __s1, const char_type* __s2, std::size_t __n);
725dc051	121
ed6814f7	122	static char_type*
d5ff4e3f	123	assign(char_type* __s, std::size_t __n, char_type __a);
725dc051	124
ed6814f7	125	static char_type
d5ff4e3f MA	126	to_char_type(const int_type& __c)
d5ff4e3f MA	127	{ return static_cast<char_type>(__c); }
725dc051	128
ed6814f7	129	static int_type
d5ff4e3f MA	130	to_int_type(const char_type& __c)
d5ff4e3f MA	131	{ return static_cast<int_type>(__c); }
725dc051	132
ed6814f7	133	static bool
d5ff4e3f MA	134	eq_int_type(const int_type& __c1, const int_type& __c2)
d5ff4e3f MA	135	{ return __c1 == __c2; }
725dc051	136
ed6814f7	137	static int_type
d5ff4e3f MA	138	eof()
d5ff4e3f MA	139	{ return static_cast<int_type>(EOF); }
725dc051	140
ed6814f7	141	static int_type
d5ff4e3f	142	not_eof(const int_type& __c)
5a9ed693	143	{ return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
725dc051 BK	144	};
725dc051 BK	145
d5ff4e3f MA	146	template<typename _CharT>
	147	int
	148	char_traits<_CharT>::
	149	compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
	150	{
	151	for (size_t __i = 0; __i < __n; ++__i)
	152	if (lt(__s1[__i], __s2[__i]))
	153	return -1;
	154	else if (lt(__s2[__i], __s1[__i]))
	155	return 1;
	156	return 0;
	157	}
	158
	159	template<typename _CharT>
	160	std::size_t
	161	char_traits<_CharT>::
	162	length(const char_type* __p)
	163	{
	164	std::size_t __i = 0;
	165	while (!eq(__p[__i], char_type()))
	166	++__i;
	167	return __i;
	168	}
	169
	170	template<typename _CharT>
ed6814f7	171	const typename char_traits<_CharT>::char_type*
d5ff4e3f MA	172	char_traits<_CharT>::
	173	find(const char_type* __s, std::size_t __n, const char_type& __a)
	174	{
	175	for (std::size_t __i = 0; __i < __n; ++__i)
	176	if (eq(__s[__i], __a))
	177	return __s + __i;
	178	return 0;
	179	}
	180
	181	template<typename _CharT>
	182	typename char_traits<_CharT>::char_type*
	183	char_traits<_CharT>::
	184	move(char_type* __s1, const char_type* __s2, std::size_t __n)
	185	{
	186	return static_cast<_CharT*>(std::memmove(__s1, __s2,
	187	__n * sizeof(char_type)));
	188	}
	189
	190	template<typename _CharT>
ed6814f7	191	typename char_traits<_CharT>::char_type*
d5ff4e3f MA	192	char_traits<_CharT>::
	193	copy(char_type* __s1, const char_type* __s2, std::size_t __n)
	194	{
	195	std::copy(__s2, __s2 + __n, __s1);
	196	return __s1;
	197	}
	198
	199	template<typename _CharT>
ed6814f7	200	typename char_traits<_CharT>::char_type*
d5ff4e3f MA	201	char_traits<_CharT>::
	202	assign(char_type* __s, std::size_t __n, char_type __a)
	203	{
	204	std::fill_n(__s, __n, __a);
	205	return __s;
	206	}
	207	}
	208
ed6814f7	209	namespace std
d5ff4e3f MA	210	{
	211	// 21.1
	212	/**
	213	* @brief Basis for explicit traits specializations.
	214	*
	215	* @note For any given actual character type, this definition is
	216	* probably wrong. Since this is just a thin wrapper around
	217	* __gnu_cxx::char_traits, it is possible to achieve a more
	218	* appropriate definition by specializing __gnu_cxx::char_traits.
	219	*
	220	* See http://gcc.gnu.org/onlinedocs/libstdc++/21_strings/howto.html#5
	221	* for advice on how to make use of this class for "unusual" character
	222	* types. Also, check out include/ext/pod_char_traits.h.
	223	*/
	224	template<class _CharT>
6309eefc	225	struct char_traits : public __gnu_cxx::char_traits<_CharT>
d5ff4e3f MA	226	{ };
d5ff4e3f MA	227
97644827	228
6309eefc	229	/// @brief 21.1.3.1 char_traits specializations
725dc051 BK	230	template<>
	231	struct char_traits<char>
	232	{
d5ff4e3f MA	233	typedef char char_type;
	234	typedef int int_type;
	235	typedef streampos pos_type;
	236	typedef streamoff off_type;
	237	typedef mbstate_t state_type;
725dc051	238
ed6814f7	239	static void
725dc051 BK	240	assign(char_type& __c1, const char_type& __c2)
	241	{ __c1 = __c2; }
	242
ed6814f7	243	static bool
725dc051	244	eq(const char_type& __c1, const char_type& __c2)
462ec415	245	{ return __c1 == __c2; }
725dc051	246
ed6814f7	247	static bool
725dc051 BK	248	lt(const char_type& __c1, const char_type& __c2)
	249	{ return __c1 < __c2; }
	250
ed6814f7	251	static int
725dc051 BK	252	compare(const char_type* __s1, const char_type* __s2, size_t __n)
	253	{ return memcmp(__s1, __s2, __n); }
	254
	255	static size_t
	256	length(const char_type* __s)
	257	{ return strlen(__s); }
	258
ed6814f7	259	static const char_type*
725dc051 BK	260	find(const char_type* __s, size_t __n, const char_type& __a)
	261	{ return static_cast<const char_type*>(memchr(__s, __a, __n)); }
	262
ed6814f7	263	static char_type*
725dc051 BK	264	move(char_type* __s1, const char_type* __s2, size_t __n)
	265	{ return static_cast<char_type*>(memmove(__s1, __s2, __n)); }
	266
ed6814f7	267	static char_type*
725dc051	268	copy(char_type* __s1, const char_type* __s2, size_t __n)
c094e9b9	269	{ return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }
725dc051	270
ed6814f7	271	static char_type*
725dc051 BK	272	assign(char_type* __s, size_t __n, char_type __a)
	273	{ return static_cast<char_type*>(memset(__s, __a, __n)); }
	274
ed6814f7	275	static char_type
725dc051 BK	276	to_char_type(const int_type& __c)
	277	{ return static_cast<char_type>(__c); }
	278
	279	// To keep both the byte 0xff and the eof symbol 0xffffffff
	280	// from ending up as 0xffffffff.
ed6814f7	281	static int_type
725dc051 BK	282	to_int_type(const char_type& __c)
	283	{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
	284
ed6814f7	285	static bool
725dc051 BK	286	eq_int_type(const int_type& __c1, const int_type& __c2)
	287	{ return __c1 == __c2; }
	288
ed6814f7	289	static int_type
725dc051 BK	290	eof() { return static_cast<int_type>(EOF); }
725dc051 BK	291
ed6814f7	292	static int_type
725dc051 BK	293	not_eof(const int_type& __c)
	294	{ return (__c == eof()) ? 0 : __c; }
	295	};
	296
	297
3d7c150e	298	#ifdef _GLIBCXX_USE_WCHAR_T
6309eefc	299	/// @brief 21.1.3.2 char_traits specializations
725dc051 BK	300	template<>
	301	struct char_traits<wchar_t>
	302	{
d5ff4e3f MA	303	typedef wchar_t char_type;
	304	typedef wint_t int_type;
	305	typedef streamoff off_type;
	306	typedef wstreampos pos_type;
	307	typedef mbstate_t state_type;
ed6814f7 BI	308
ed6814f7 BI	309	static void
725dc051 BK	310	assign(char_type& __c1, const char_type& __c2)
	311	{ __c1 = __c2; }
	312
ed6814f7	313	static bool
462ec415 JJ	314	eq(const char_type& __c1, const char_type& __c2)
462ec415 JJ	315	{ return __c1 == __c2; }
725dc051	316
ed6814f7	317	static bool
725dc051 BK	318	lt(const char_type& __c1, const char_type& __c2)
	319	{ return __c1 < __c2; }
	320
ed6814f7	321	static int
725dc051 BK	322	compare(const char_type* __s1, const char_type* __s2, size_t __n)
	323	{ return wmemcmp(__s1, __s2, __n); }
	324
	325	static size_t
	326	length(const char_type* __s)
	327	{ return wcslen(__s); }
	328
ed6814f7	329	static const char_type*
725dc051 BK	330	find(const char_type* __s, size_t __n, const char_type& __a)
	331	{ return wmemchr(__s, __a, __n); }
	332
ed6814f7	333	static char_type*
73a530bd	334	move(char_type* __s1, const char_type* __s2, size_t __n)
725dc051 BK	335	{ return wmemmove(__s1, __s2, __n); }
725dc051 BK	336
ed6814f7	337	static char_type*
725dc051 BK	338	copy(char_type* __s1, const char_type* __s2, size_t __n)
	339	{ return wmemcpy(__s1, __s2, __n); }
	340
ed6814f7	341	static char_type*
725dc051 BK	342	assign(char_type* __s, size_t __n, char_type __a)
	343	{ return wmemset(__s, __a, __n); }
	344
ed6814f7	345	static char_type
725dc051 BK	346	to_char_type(const int_type& __c) { return char_type(__c); }
725dc051 BK	347
ed6814f7	348	static int_type
725dc051 BK	349	to_int_type(const char_type& __c) { return int_type(__c); }
725dc051 BK	350
ed6814f7	351	static bool
725dc051 BK	352	eq_int_type(const int_type& __c1, const int_type& __c2)
	353	{ return __c1 == __c2; }
	354
ed6814f7	355	static int_type
725dc051 BK	356	eof() { return static_cast<int_type>(WEOF); }
725dc051 BK	357
ed6814f7	358	static int_type
725dc051 BK	359	not_eof(const int_type& __c)
	360	{ return eq_int_type(__c, eof()) ? 0 : __c; }
	361	};
3d7c150e	362	#endif //_GLIBCXX_USE_WCHAR_T
725dc051	363
725dc051 BK	364	} // namespace std
725dc051 BK	365
d32c94be	366	#endif