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