1/* 2 * Copyright (c) 1996,1997 3 * Silicon Graphics Computer Systems, Inc. 4 * 5 * Copyright (c) 1999 6 * Boris Fomitchev 7 * 8 * This material is provided "as is", with absolutely no warranty expressed 9 * or implied. Any use is at your own risk. 10 * 11 * Permission to use or copy this software for any purpose is hereby granted 12 * without fee, provided the above notices are retained on all copies. 13 * Permission to modify the code and to distribute modified code is granted, 14 * provided the above notices are retained, and a notice that the code was 15 * modified is included with the above copyright notice. 16 * 17 */ 18 19#ifndef _STLP_CHAR_TRAITS_H 20#define _STLP_CHAR_TRAITS_H 21 22// Define char_traits 23 24#ifndef _STLP_INTERNAL_CSTDDEF 25# include <stl/_cstddef.h> 26#endif 27 28#ifndef _STLP_INTERNAL_CSTRING 29# include <stl/_cstring.h> 30#endif 31 32#if defined (__unix) 33# include <sys/types.h> // For off_t 34#endif /* __unix */ 35 36#if defined (__BORLANDC__) 37# include <mem.h> 38# include <string.h> 39# include <_stddef.h> 40# include <sys/types.h> 41#endif 42 43#ifndef _STLP_INTERNAL_CONSTRUCT_H 44# include <stl/_construct.h> 45#endif 46 47#ifndef _STLP_INTERNAL_CWCHAR 48# include <stl/_cwchar.h> 49#endif 50 51_STLP_BEGIN_NAMESPACE 52 53template <class _Tp> class allocator; 54 55#define _STLP_NULL_CHAR_INIT(_ChT) _STLP_DEFAULT_CONSTRUCTED(_ChT) 56 57#if defined(_STLP_WCE) 58typedef long streamoff; 59#elif defined (_STLP_WIN32) 60# if defined (_STLP_LONG_LONG) && !defined (__CYGWIN__) 61//The Win32 file io API support 64 bits access so streamoff and streamsize 62//has to reflect that. Do not change the stringbuf behavior. 63typedef _STLP_LONG_LONG streamoff; 64# else 65typedef ptrdiff_t streamoff; 66# endif 67#else // __unix 68# ifdef _STLP_USE_DEFAULT_FILE_OFFSET 69typedef off_t streamoff; 70# elif defined(_LARGEFILE_SOURCE) || defined(_LARGEFILE64_SOURCE) /* || defined(__USE_FILE_OFFSET64) */ \ 71 /* || (defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)) */ /* || defined (__sgi) && defined (_STLP_HAS_NO_NEW_C_HEADERS) */ 72typedef off64_t streamoff; 73# else 74typedef off_t streamoff; 75# endif 76#endif /* __unix */ 77 78#if defined (_STLP_WIN32) 79typedef streamoff streamsize; 80#else 81typedef ptrdiff_t streamsize; 82#endif 83 84// Class fpos, which represents a position within a file. (The C++ 85// standard calls for it to be defined in <ios>. This implementation 86// moves it to <iosfwd>, which is included by <ios>.) 87template <class _StateT> class fpos { 88public: // From table 88 of the C++ standard. 89 fpos(streamoff __pos) : _M_pos(__pos), _M_st(_STLP_NULL_CHAR_INIT(_StateT)) {} 90 fpos() : _M_pos(0), _M_st(_STLP_NULL_CHAR_INIT(_StateT)) {} 91 92 operator streamoff() const { return _M_pos; } 93 94 bool operator==(const fpos& __y) const 95 { return _M_pos == __y._M_pos; } 96 bool operator!=(const fpos& __y) const 97 { return _M_pos != __y._M_pos; } 98 99 fpos& operator+=(streamoff __off) { 100 _M_pos += __off; 101 return *this; 102 } 103 fpos& operator-=(streamoff __off) { 104 _M_pos -= __off; 105 return *this; 106 } 107 108 fpos operator+(streamoff __off) { 109 fpos __tmp(*this); 110 __tmp += __off; 111 return __tmp; 112 } 113 fpos operator-(streamoff __off) { 114 fpos __tmp(*this); 115 __tmp -= __off; 116 return __tmp; 117 } 118 119public: // Manipulation of the state member. 120 _StateT state() const { return _M_st; } 121 void state(_StateT __st) { _M_st = __st; } 122private: 123 streamoff _M_pos; 124 _StateT _M_st; 125}; 126 127typedef fpos<mbstate_t> streampos; 128typedef fpos<mbstate_t> wstreampos; 129 130// Class __char_traits_base. 131template <class _CharT, class _IntT> 132class __char_traits_base { 133public: 134 typedef _CharT char_type; 135 typedef _IntT int_type; 136 typedef streamoff off_type; 137 typedef streampos pos_type; 138 typedef mbstate_t state_type; 139 140 static void _STLP_CALL assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; } 141 static bool _STLP_CALL eq(const char_type& __c1, const char_type& __c2) 142 { return __c1 == __c2; } 143 static bool _STLP_CALL lt(const char_type& __c1, const char_type& __c2) 144 { return __c1 < __c2; } 145 146 static int _STLP_CALL compare(const char_type* __s1, const char_type* __s2, size_t __n) { 147 for (size_t __i = 0; __i < __n; ++__i) 148 if (!eq(__s1[__i], __s2[__i])) 149 return __s1[__i] < __s2[__i] ? -1 : 1; 150 return 0; 151 } 152 153 static size_t _STLP_CALL length(const char_type* __s) { 154 const char_type _NullChar = _STLP_DEFAULT_CONSTRUCTED(char_type); 155 size_t __i(0); 156 for (; !eq(__s[__i], _NullChar); ++__i) {} 157 return __i; 158 } 159 160 static const char_type* _STLP_CALL find(const char_type* __s, size_t __n, const char_type& __c) { 161 for ( ; __n > 0 ; ++__s, --__n) 162 if (eq(*__s, __c)) 163 return __s; 164 return 0; 165 } 166 167 static char_type* _STLP_CALL move(char_type* __s1, const char_type* __s2, size_t _Sz) 168 { return (_Sz == 0 ? __s1 : (char_type*)memmove(__s1, __s2, _Sz * sizeof(char_type))); } 169 170 static char_type* _STLP_CALL copy(char_type* __s1, const char_type* __s2, size_t __n) { 171 return (__n == 0 ? __s1 : 172 (char_type*)memcpy(__s1, __s2, __n * sizeof(char_type))); 173 } 174 175 static char_type* _STLP_CALL assign(char_type* __s, size_t __n, char_type __c) { 176 for (size_t __i = 0; __i < __n; ++__i) 177 __s[__i] = __c; 178 return __s; 179 } 180 181 static int_type _STLP_CALL not_eof(const int_type& __c) 182 { return !eq_int_type(__c, eof()) ? __c : __STATIC_CAST(int_type, 0); } 183 184 static char_type _STLP_CALL to_char_type(const int_type& __c) 185 { return (char_type)__c; } 186 187 static int_type _STLP_CALL to_int_type(const char_type& __c) 188 { return (int_type)__c; } 189 190 static bool _STLP_CALL eq_int_type(const int_type& __c1, const int_type& __c2) 191 { return __c1 == __c2; } 192 193 static int_type _STLP_CALL eof() 194 { return (int_type)-1; } 195}; 196 197// Generic char_traits class. Note that this class is provided only 198// as a base for explicit specialization; it is unlikely to be useful 199// as is for any particular user-defined type. In particular, it 200// *will not work* for a non-POD type. 201 202template <class _CharT> 203class char_traits 204 : public __char_traits_base<_CharT, _CharT> {}; 205 206// Specialization for char. 207 208_STLP_TEMPLATE_NULL 209class _STLP_CLASS_DECLSPEC char_traits<char> 210 : public __char_traits_base<char, int>, 211 public __stlport_class<char_traits<char> > { 212public: 213 typedef char char_type; 214 typedef int int_type; 215 typedef streamoff off_type; 216 typedef streampos pos_type; 217 typedef mbstate_t state_type; 218 219 static char _STLP_CALL to_char_type(const int& __c) 220 { return (char)(unsigned char)__c; } 221 222 static int _STLP_CALL to_int_type(const char& __c) 223 { return (unsigned char)__c; } 224 225 static int _STLP_CALL compare(const char* __s1, const char* __s2, size_t __n) 226 { return memcmp(__s1, __s2, __n); } 227 228 static size_t _STLP_CALL length(const char* __s) 229 { return strlen(__s); } 230 231 static void _STLP_CALL assign(char& __c1, const char& __c2) 232 { __c1 = __c2; } 233 234 static char* _STLP_CALL assign(char* __s, size_t __n, char __c) { 235 memset(__s, __c, __n); 236 return __s; 237 } 238}; 239 240#if defined (_STLP_HAS_WCHAR_T) 241// Specialization for wchar_t. 242_STLP_TEMPLATE_NULL 243class _STLP_CLASS_DECLSPEC char_traits<wchar_t> 244 : public __char_traits_base<wchar_t, wint_t> { 245# if !defined (_STLP_NO_NATIVE_WIDE_FUNCTIONS) && !defined (_STLP_WCHAR_HPACC_EXCLUDE) 246public: 247# if !defined (__BORLANDC__) 248 static wchar_t* _STLP_CALL move(wchar_t* __dest, const wchar_t* __src, size_t __n) 249 { return wmemmove(__dest, __src, __n); } 250# endif 251 252 static wchar_t* _STLP_CALL copy(wchar_t* __dest, const wchar_t* __src, size_t __n) 253 { return wmemcpy(__dest, __src, __n); } 254 255# if !defined (__DMC__) && !defined (__BORLANDC__) 256 static int _STLP_CALL compare(const wchar_t* __s1, const wchar_t* __s2, size_t __n) 257 { return wmemcmp(__s1, __s2, __n); } 258# endif 259 260 static wchar_t* _STLP_CALL assign(wchar_t* __s, size_t __n, wchar_t __c) 261 { return wmemset(__s, __c, __n); } 262 263 static size_t _STLP_CALL length(const wchar_t* __s) 264 { return wcslen(__s); } 265 266 static void _STLP_CALL assign(wchar_t& __c1, const wchar_t& __c2) 267 { __c1 = __c2; } 268# endif 269}; 270#endif 271 272_STLP_END_NAMESPACE 273 274#endif /* _STLP_CHAR_TRAITS_H */ 275 276// Local Variables: 277// mode:C++ 278// End: 279