1/*
2 * Copyright (c) 1999
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// WARNING: This is an internal header file, included by other C++
19// standard library headers.  You should not attempt to use this header
20// file directly.
21
22
23#ifndef _STLP_INTERNAL_CODECVT_H
24#define _STLP_INTERNAL_CODECVT_H
25
26#ifndef _STLP_C_LOCALE_H
27#  include <stl/c_locale.h>
28#endif
29
30#ifndef _STLP_INTERNAL_LOCALE_H
31#  include <stl/_locale.h>
32#endif
33
34#ifndef _STLP_INTERNAL_ALGOBASE_H
35#  include <stl/_algobase.h>
36#endif
37
38_STLP_BEGIN_NAMESPACE
39
40class _STLP_CLASS_DECLSPEC codecvt_base {
41public:
42  enum result {ok, partial, error, noconv};
43};
44
45template <class _InternT, class _ExternT, class _StateT>
46class codecvt : public locale::facet, public codecvt_base {
47public:
48  typedef _InternT intern_type;
49  typedef _ExternT extern_type;
50  typedef _StateT state_type;
51
52#if defined (_STLP_MSVC) && (_STLP_MSVC < 1300)
53  /* For the moment VC6 do not support this facet default implementation
54   * because of the static locale::id instance. When VC6 see this definition
55   * it goes crasy with locale::id static instances and all the has_facet tests
56   * unit tests are failing.
57   */
58};
59#else
60  explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
61
62  result out(state_type&          __state,
63             const intern_type*   __from,
64             const intern_type*   __from_end,
65             const intern_type*&  __from_next,
66             extern_type*         __to,
67             extern_type*         __to_limit,
68             extern_type*&        __to_next) const {
69    _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
70    _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
71    return do_out(__state,
72                  __from, __from_end, __from_next,
73                  __to,   __to_limit, __to_next);
74  }
75
76  result unshift(state_type&    __state,
77                 extern_type*   __to,
78                 extern_type*   __to_limit,
79                 extern_type*&  __to_next) const {
80    _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
81    return do_unshift(__state, __to, __to_limit, __to_next);
82  }
83
84  result in(state_type&         __state,
85            const extern_type*  __from,
86            const extern_type*  __from_end,
87            const extern_type*& __from_next,
88            intern_type*        __to,
89            intern_type*        __to_limit,
90            intern_type*&       __to_next) const {
91    _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
92    _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
93    return do_in(__state,
94                 __from, __from_end, __from_next,
95                 __to,  __to_limit, __to_next);
96  }
97
98  int encoding() const _STLP_NOTHROW { return do_encoding(); }
99
100  bool always_noconv() const _STLP_NOTHROW { return do_always_noconv(); }
101
102  int length(state_type&  __state,
103             const extern_type* __from,
104             const extern_type* __from_end,
105             size_t             __max) const {
106    _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
107    return do_length(__state, __from, __from_end, __max);
108  }
109
110  int max_length() const _STLP_NOTHROW { return do_max_length(); }
111
112  static locale::id id;
113
114protected:
115  ~codecvt() {}
116
117  virtual result do_out(state_type&,
118                        const intern_type*  __from,
119                        const intern_type*,
120                        const intern_type*& __from_next,
121                        extern_type*        __to,
122                        extern_type*,
123                        extern_type*&       __to_next) const
124  { __from_next = __from; __to_next   = __to; return noconv; }
125
126  virtual result do_in (state_type&,
127                        const extern_type*  __from,
128                        const extern_type*,
129                        const extern_type*& __from_next,
130                        intern_type*        __to,
131                        intern_type*,
132                        intern_type*&       __to_next) const
133  { __from_next = __from; __to_next = __to; return noconv; }
134
135  virtual result do_unshift(state_type&,
136                            extern_type* __to,
137                            extern_type*,
138                            extern_type*& __to_next) const
139  { __to_next = __to; return noconv; }
140
141  virtual int do_encoding() const _STLP_NOTHROW
142  { return 1; }
143
144  virtual bool do_always_noconv() const _STLP_NOTHROW
145  { return true; }
146
147  virtual int do_length(state_type&,
148                        const extern_type* __from,
149                        const extern_type* __end,
150                        size_t __max) const
151  { return (int)(min) ( __STATIC_CAST(size_t, (__end - __from)), __max); }
152
153  virtual int do_max_length() const _STLP_NOTHROW
154  { return 1; }
155
156private:
157  codecvt(const codecvt<intern_type, extern_type, state_type>&);
158  codecvt<intern_type, extern_type, state_type>& operator = (const codecvt<intern_type, extern_type, state_type>&);
159};
160
161#  if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
162#    if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x590)
163template <class _InternT, class _ExternT, class _StateT>
164locale::id codecvt<_InternT, _ExternT, _StateT>::id;
165#    endif
166#  endif
167#endif
168
169template <class _InternT, class _ExternT, class _StateT>
170class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT> {};
171
172_STLP_TEMPLATE_NULL
173class _STLP_CLASS_DECLSPEC codecvt<char, char, mbstate_t>
174  : public locale::facet, public codecvt_base {
175public:
176  typedef char       intern_type;
177  typedef char       extern_type;
178  typedef mbstate_t  state_type;
179
180  explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
181
182  result out(state_type&   __state,
183             const char*  __from,
184             const char*  __from_end,
185             const char*& __from_next,
186             char*        __to,
187             char*        __to_limit,
188             char*&       __to_next) const {
189    _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
190    _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
191    return do_out(__state,
192                  __from, __from_end, __from_next,
193                  __to,   __to_limit, __to_next);
194  }
195
196  result unshift(state_type& __state,
197                 char* __to, char* __to_limit, char*& __to_next) const {
198    _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
199    return do_unshift(__state, __to, __to_limit, __to_next);
200  }
201
202  result in(state_type&   __state,
203            const char*  __from,
204            const char*  __from_end,
205            const char*& __from_next,
206            char*        __to,
207            char*        __to_limit,
208            char*&       __to_next) const {
209    _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
210    _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
211    return do_in(__state,
212                 __from, __from_end, __from_next,
213                 __to,   __to_limit, __to_next);
214  }
215
216  int encoding() const _STLP_NOTHROW { return do_encoding(); }
217
218  bool always_noconv() const _STLP_NOTHROW { return do_always_noconv(); }
219
220  int length(state_type& __state,
221             const char* __from, const char* __from_end,
222             size_t __max) const {
223    _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
224    return do_length(__state, __from, __from_end, __max);
225  }
226
227  int max_length() const _STLP_NOTHROW { return do_max_length(); }
228
229  static _STLP_STATIC_DECLSPEC locale::id id;
230
231protected:
232  ~codecvt();
233
234  virtual result do_out(state_type&   /* __state */,
235                        const char*  __from,
236                        const char*  /* __from_end */,
237                        const char*& __from_next,
238                        char*        __to,
239                        char*        /* __to_limit */,
240                        char*&       __to_next) const;
241
242  virtual result do_in (state_type&   /* __state */ ,
243                        const char*  __from,
244                        const char*  /* __from_end */,
245                        const char*& __from_next,
246                        char*        __to,
247                        char*        /* __to_end */,
248                        char*&       __to_next) const;
249
250  virtual result do_unshift(state_type& /* __state */,
251                            char*      __to,
252                            char*      /* __to_limit */,
253                            char*&     __to_next) const;
254
255  virtual int do_encoding() const _STLP_NOTHROW;
256  virtual bool do_always_noconv() const _STLP_NOTHROW;
257  virtual int do_length(state_type&  __state,
258                        const  char* __from,
259                        const  char* __end,
260                        size_t __max) const;
261  virtual int do_max_length() const _STLP_NOTHROW;
262private:
263  codecvt(const codecvt<char, char, mbstate_t>&);
264  codecvt<char, char, mbstate_t>& operator =(const codecvt<char, char, mbstate_t>&);
265};
266
267# ifndef _STLP_NO_WCHAR_T
268
269_STLP_TEMPLATE_NULL
270class _STLP_CLASS_DECLSPEC codecvt<wchar_t, char, mbstate_t>
271  : public locale::facet, public codecvt_base {
272public:
273  typedef wchar_t    intern_type;
274  typedef char       extern_type;
275  typedef mbstate_t  state_type;
276
277  explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
278
279  result out(state_type&      __state,
280             const wchar_t*  __from,
281             const wchar_t*  __from_end,
282             const wchar_t*& __from_next,
283             char*           __to,
284             char*           __to_limit,
285             char*&          __to_next) const {
286    _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
287    _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
288    return do_out(__state,
289                  __from, __from_end, __from_next,
290                  __to,   __to_limit, __to_next);
291  }
292
293  result unshift(state_type& __state,
294                 char*  __to, char*  __to_limit, char*& __to_next) const {
295    _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
296    return do_unshift(__state, __to, __to_limit, __to_next);
297  }
298
299  result in(state_type&   __state,
300            const char*  __from,
301            const char*  __from_end,
302            const char*& __from_next,
303            wchar_t*     __to,
304            wchar_t*     __to_limit,
305            wchar_t*&    __to_next) const {
306    _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
307    _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
308    return do_in(__state,
309                 __from, __from_end, __from_next,
310                 __to,   __to_limit, __to_next);
311  }
312
313  int encoding() const _STLP_NOTHROW { return do_encoding(); }
314
315  bool always_noconv() const _STLP_NOTHROW { return do_always_noconv(); }
316
317  int length(state_type& __state,
318             const char* __from, const char* __from_end,
319             size_t __max) const {
320    _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
321    return do_length(__state, __from, __from_end, __max);
322  }
323
324  int max_length() const _STLP_NOTHROW { return do_max_length(); }
325
326  static _STLP_STATIC_DECLSPEC locale::id id;
327
328protected:
329  ~codecvt();
330
331  virtual result do_out(state_type&         __state,
332                        const wchar_t*  __from,
333                        const wchar_t*  __from_end,
334                        const wchar_t*& __from_next,
335                        char*        __to,
336                        char*        __to_limit,
337                        char*&       __to_next) const;
338
339  virtual result do_in (state_type&         __state,
340                        const char*  __from,
341                        const char*  __from_end,
342                        const char*& __from_next,
343                        wchar_t*        __to,
344                        wchar_t*        __to_limit,
345                        wchar_t*&       __to_next) const;
346
347  virtual result do_unshift(state_type&   __state,
348                            char*  __to,
349                            char*  __to_limit,
350                            char*& __to_next) const;
351
352  virtual int do_encoding() const _STLP_NOTHROW;
353
354  virtual bool do_always_noconv() const _STLP_NOTHROW;
355
356  virtual int do_length(state_type&  __state,
357                        const  char* __from,
358                        const  char* __end,
359                        size_t __max) const;
360
361  virtual int do_max_length() const _STLP_NOTHROW;
362
363private:
364  codecvt(const codecvt<wchar_t, char, mbstate_t>&);
365  codecvt<wchar_t, char, mbstate_t>& operator = (const codecvt<wchar_t, char, mbstate_t>&);
366};
367
368# endif
369
370_STLP_TEMPLATE_NULL
371class _STLP_CLASS_DECLSPEC codecvt_byname<char, char, mbstate_t>
372  : public codecvt<char, char, mbstate_t> {
373public:
374  explicit codecvt_byname(const char* __name, size_t __refs = 0);
375  ~codecvt_byname();
376private:
377  codecvt_byname(const codecvt_byname<char, char, mbstate_t>&);
378  codecvt_byname<char, char, mbstate_t>& operator =(const codecvt_byname<char, char, mbstate_t>&);
379};
380
381# ifndef _STLP_NO_WCHAR_T
382_STLP_TEMPLATE_NULL
383class _STLP_CLASS_DECLSPEC codecvt_byname<wchar_t, char, mbstate_t>
384  : public codecvt<wchar_t, char, mbstate_t> {
385  friend class _Locale_impl;
386public:
387  explicit codecvt_byname(const char * __name, size_t __refs = 0);
388
389protected:
390  ~codecvt_byname();
391
392  virtual result do_out(state_type&         __state,
393                        const wchar_t*  __from,
394                        const wchar_t*  __from_end,
395                        const wchar_t*& __from_next,
396                        char*        __to,
397                        char*        __to_limit,
398                        char*&       __to_next) const;
399
400  virtual result do_in (state_type&         __state,
401                        const char*  __from,
402                        const char*  __from_end,
403                        const char*& __from_next,
404                        wchar_t*        __to,
405                        wchar_t*        __to_limit,
406                        wchar_t*&       __to_next) const;
407
408  virtual result do_unshift(state_type&   __state,
409                            char*  __to,
410                            char*  __to_limit,
411                            char*& __to_next) const;
412
413  virtual int do_encoding() const _STLP_NOTHROW;
414
415  virtual bool do_always_noconv() const _STLP_NOTHROW;
416
417  virtual int do_length(state_type&  __state,
418                        const  char* __from,
419                        const  char* __end,
420                        size_t __max) const;
421
422  virtual int do_max_length() const _STLP_NOTHROW;
423
424private:
425  codecvt_byname(_Locale_codecvt* __cvt)
426    : _M_codecvt(__cvt) {}
427
428  codecvt_byname(const codecvt_byname<wchar_t, char, mbstate_t>&);
429  codecvt_byname<wchar_t, char, mbstate_t>& operator =(const codecvt_byname<wchar_t, char, mbstate_t>&);
430  _Locale_codecvt* _M_codecvt;
431};
432
433# endif
434
435_STLP_END_NAMESPACE
436
437#endif /* _STLP_INTERNAL_CODECVT_H */
438
439// Local Variables:
440// mode:C++
441// End:
442
443