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 #include "stlport_prefix.h"
19
20 #include <hash_map>
21 #include <vector>
22
23 #include <locale>
24 #include <istream>
25
26 #include <algorithm>
27 #include <functional>
28
29 #include "c_locale.h"
30 #include "locale_impl.h"
31 #include "acquire_release.h"
32
33 _STLP_BEGIN_NAMESPACE
34
35 //----------------------------------------------------------------------
36 // ctype_byname<char>
37
ctype_byname(const char * name,size_t refs,_Locale_name_hint * hint)38 ctype_byname<char>::ctype_byname(const char* name, size_t refs, _Locale_name_hint* hint) :
39 ctype<char>( 0, false, refs),
40 _M_ctype(_STLP_PRIV __acquire_ctype(name, hint)) {
41 ctype<char>::_M_ctype_table = _M_byname_table;
42 if (!_M_ctype)
43 locale::_M_throw_runtime_error();
44
45 // We have to do this, instead of just pointer twiddling, because
46 // ctype_base::mask isn't the same type as _Locale_mask_t.
47
48 const _Locale_mask_t* p = _Locale_ctype_table(_M_ctype);
49
50 if (!p)
51 locale::_M_throw_runtime_error();
52
53 for (size_t i = 0; i < table_size; ++i) {
54 _Locale_mask_t __m = p[i];
55 if (__m & (upper | lower))
56 __m |= alpha;
57 _M_byname_table[i] = ctype_base::mask(__m);
58 }
59 }
60
~ctype_byname()61 ctype_byname<char>::~ctype_byname()
62 { _STLP_PRIV __release_ctype(_M_ctype); }
63
do_toupper(char c) const64 char ctype_byname<char>::do_toupper(char c) const
65 { return (char)_Locale_toupper(_M_ctype, c); }
66
do_tolower(char c) const67 char ctype_byname<char>::do_tolower(char c) const
68 { return (char)_Locale_tolower(_M_ctype, c); }
69
70 const char*
do_toupper(char * first,const char * last) const71 ctype_byname<char>::do_toupper(char* first, const char* last) const {
72 for ( ; first != last ; ++first)
73 *first = (char)_Locale_toupper(_M_ctype, *first);
74 return last;
75 }
76
77 const char*
do_tolower(char * first,const char * last) const78 ctype_byname<char>::do_tolower(char* first, const char* last) const {
79 for ( ; first != last ; ++first)
80 *first = (char)_Locale_tolower(_M_ctype, *first);
81 return last;
82 }
83
84
85 // Some helper functions used in ctype<>::scan_is and scan_is_not.
86 #if !defined (_STLP_NO_WCHAR_T)
87
88 _STLP_MOVE_TO_PRIV_NAMESPACE
89
90 // ctype_byname<wchar_t>
91
92 struct _Ctype_byname_w_is_mask {
93 typedef wchar_t argument_type;
94 typedef bool result_type;
95
96 /* ctype_base::mask*/ int M;
97 _Locale_ctype* M_ctp;
98
_Ctype_byname_w_is_mask_Ctype_byname_w_is_mask99 _Ctype_byname_w_is_mask(/* ctype_base::mask */ int m, _Locale_ctype* c) : M((int)m), M_ctp(c) {}
operator ()_Ctype_byname_w_is_mask100 bool operator()(wchar_t c) const
101 { return (M & _Locale_wchar_ctype(M_ctp, c, M)) != 0; }
102 };
103
104 _STLP_MOVE_TO_STD_NAMESPACE
105
ctype_byname(const char * name,size_t refs,_Locale_name_hint * hint)106 ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs, _Locale_name_hint* hint)
107 : ctype<wchar_t>(refs),
108 _M_ctype(_STLP_PRIV __acquire_ctype(name, hint)) {
109 if (!_M_ctype)
110 locale::_M_throw_runtime_error();
111 }
112
~ctype_byname()113 ctype_byname<wchar_t>::~ctype_byname()
114 { _STLP_PRIV __release_ctype(_M_ctype); }
115
do_is(ctype_base::mask m,wchar_t c) const116 bool ctype_byname<wchar_t>::do_is(ctype_base::mask m, wchar_t c) const
117 { return (m & _Locale_wchar_ctype(_M_ctype, c, m)) != 0; }
118
119 const wchar_t*
do_is(const wchar_t * low,const wchar_t * high,ctype_base::mask * m) const120 ctype_byname<wchar_t>::do_is(const wchar_t* low, const wchar_t* high,
121 ctype_base::mask * m) const {
122 ctype_base::mask all_bits = ctype_base::mask(
123 ctype_base::space |
124 ctype_base::print |
125 ctype_base::cntrl |
126 ctype_base::upper |
127 ctype_base::lower |
128 ctype_base::alpha |
129 ctype_base::digit |
130 ctype_base::punct |
131 ctype_base::xdigit);
132
133 for ( ; low < high; ++low, ++m)
134 *m = ctype_base::mask (_Locale_wchar_ctype(_M_ctype, *low, all_bits));
135 return high;
136 }
137
138 const wchar_t*
139 ctype_byname<wchar_t>
do_scan_is(ctype_base::mask m,const wchar_t * low,const wchar_t * high) const140 ::do_scan_is(ctype_base::mask m, const wchar_t* low, const wchar_t* high) const
141 { return find_if(low, high, _STLP_PRIV _Ctype_byname_w_is_mask(m, _M_ctype)); }
142
143 const wchar_t*
144 ctype_byname<wchar_t>
do_scan_not(ctype_base::mask m,const wchar_t * low,const wchar_t * high) const145 ::do_scan_not(ctype_base::mask m, const wchar_t* low, const wchar_t* high) const
146 { return find_if(low, high, not1(_STLP_PRIV _Ctype_byname_w_is_mask(m, _M_ctype))); }
147
do_toupper(wchar_t c) const148 wchar_t ctype_byname<wchar_t>::do_toupper(wchar_t c) const
149 { return _Locale_wchar_toupper(_M_ctype, c); }
150
151 const wchar_t*
do_toupper(wchar_t * low,const wchar_t * high) const152 ctype_byname<wchar_t>::do_toupper(wchar_t* low, const wchar_t* high) const {
153 for ( ; low < high; ++low)
154 *low = _Locale_wchar_toupper(_M_ctype, *low);
155 return high;
156 }
157
do_tolower(wchar_t c) const158 wchar_t ctype_byname<wchar_t>::do_tolower(wchar_t c) const
159 { return _Locale_wchar_tolower(_M_ctype, c); }
160
161 const wchar_t*
do_tolower(wchar_t * low,const wchar_t * high) const162 ctype_byname<wchar_t>::do_tolower(wchar_t* low, const wchar_t* high) const {
163 for ( ; low < high; ++low)
164 *low = _Locale_wchar_tolower(_M_ctype, *low);
165 return high;
166 }
167
168 #endif /* WCHAR_T */
169
170 // collate_byname<char>
collate_byname(const char * name,size_t refs,_Locale_name_hint * hint)171 collate_byname<char>::collate_byname(const char* name, size_t refs, _Locale_name_hint* hint)
172 : collate<char>(refs),
173 _M_collate(_STLP_PRIV __acquire_collate(name, hint)) {
174 if (!_M_collate)
175 locale::_M_throw_runtime_error();
176 }
177
~collate_byname()178 collate_byname<char>::~collate_byname()
179 { _STLP_PRIV __release_collate(_M_collate); }
180
do_compare(const char * __low1,const char * __high1,const char * __low2,const char * __high2) const181 int collate_byname<char>::do_compare(const char* __low1,
182 const char* __high1,
183 const char* __low2,
184 const char* __high2) const {
185 return _Locale_strcmp(_M_collate,
186 __low1, __high1 - __low1,
187 __low2, __high2 - __low2);
188 }
189
190 collate_byname<char>::string_type
do_transform(const char * low,const char * high) const191 collate_byname<char>::do_transform(const char* low, const char* high) const {
192 if (low == high)
193 return string_type();
194
195 size_t n = _Locale_strxfrm(_M_collate, NULL, 0, low, high - low);
196
197 // NOT PORTABLE. What we're doing relies on internal details of the
198 // string implementation. (Contiguity of string elements and presence
199 // of trailing zero.)
200 string_type buf(n, 0);
201 _Locale_strxfrm(_M_collate, &(*buf.begin()), n + 1, low, high - low);
202 return buf;
203 }
204
205
206 #if !defined (_STLP_NO_WCHAR_T)
207
208 // collate_byname<wchar_t>
209
collate_byname(const char * name,size_t refs,_Locale_name_hint * hint)210 collate_byname<wchar_t>::collate_byname(const char* name, size_t refs, _Locale_name_hint* hint)
211 : collate<wchar_t>(refs),
212 _M_collate(_STLP_PRIV __acquire_collate(name, hint)) {
213 if (!_M_collate)
214 locale::_M_throw_runtime_error();
215 }
216
~collate_byname()217 collate_byname<wchar_t>::~collate_byname()
218 { _STLP_PRIV __release_collate(_M_collate); }
219
do_compare(const wchar_t * low1,const wchar_t * high1,const wchar_t * low2,const wchar_t * high2) const220 int collate_byname<wchar_t>::do_compare(const wchar_t* low1,
221 const wchar_t* high1,
222 const wchar_t* low2,
223 const wchar_t* high2) const {
224 return _Locale_strwcmp(_M_collate,
225 low1, high1 - low1,
226 low2, high2 - low2);
227 }
228
229 collate_byname<wchar_t>::string_type
do_transform(const wchar_t * low,const wchar_t * high) const230 collate_byname<wchar_t>::do_transform(const wchar_t* low,
231 const wchar_t* high) const {
232 if (low == high)
233 return string_type();
234
235 size_t n = _Locale_strwxfrm(_M_collate, NULL, 0, low, high - low);
236
237 // NOT PORTABLE. What we're doing relies on internal details of the
238 // string implementation. (Contiguity of string elements and presence
239 // of trailing zero.)
240 string_type buf(n, 0);
241 _Locale_strwxfrm(_M_collate, &(*buf.begin()), n + 1, low, high - low);
242 return buf;
243 }
244
245 #endif /* _STLP_NO_WCHAR_T */
246
247 _STLP_END_NAMESPACE
248
249 #if !defined (_STLP_NO_MBSTATE_T)
250
251 _STLP_BEGIN_NAMESPACE
252
253 //----------------------------------------------------------------------
254 // codecvt_byname<char>
255
256 codecvt_byname<char, char, mbstate_t>
codecvt_byname(const char *,size_t refs)257 ::codecvt_byname(const char* /* name */, size_t refs)
258 : codecvt<char, char, mbstate_t>(refs) {}
259
~codecvt_byname()260 codecvt_byname<char, char, mbstate_t>::~codecvt_byname() {}
261
262
263 # if !defined (_STLP_NO_WCHAR_T)
264
265 //----------------------------------------------------------------------
266 // codecvt_byname<wchar_t>
267 codecvt_byname<wchar_t, char, mbstate_t>
codecvt_byname(const char * name,size_t refs,_Locale_name_hint * hint)268 ::codecvt_byname(const char* name, size_t refs, _Locale_name_hint* hint)
269 : codecvt<wchar_t, char, mbstate_t>(refs),
270 _M_ctype(_STLP_PRIV __acquire_ctype(name, hint)) {
271 if (!_M_ctype)
272 locale::_M_throw_runtime_error();
273 }
274
~codecvt_byname()275 codecvt_byname<wchar_t, char, mbstate_t>::~codecvt_byname()
276 { _STLP_PRIV __release_ctype(_M_ctype); }
277
278 codecvt<wchar_t, char, mbstate_t>::result
279 codecvt_byname<wchar_t, char, mbstate_t>
do_out(state_type & state,const wchar_t * from,const wchar_t * from_end,const wchar_t * & from_next,char * to,char * to_limit,char * & to_next) const280 ::do_out(state_type& state,
281 const wchar_t* from,
282 const wchar_t* from_end,
283 const wchar_t*& from_next,
284 char* to,
285 char* to_limit,
286 char*& to_next) const {
287 while (from != from_end) {
288 size_t chars_stored = _Locale_wctomb(_M_ctype,
289 to, to_limit - to, *from,
290 &state);
291 if (chars_stored == (size_t) -1) {
292 from_next = from;
293 to_next = to;
294 return error;
295 }
296 else if (chars_stored == (size_t) -2) {
297 from_next = from;
298 to_next = to;
299 return partial;
300 }
301
302 ++from;
303 to += chars_stored;
304 }
305
306 from_next = from;
307 to_next = to;
308 return ok;
309 }
310
311 codecvt<wchar_t, char, mbstate_t>::result
312 codecvt_byname<wchar_t, char, mbstate_t>
do_in(state_type & state,const extern_type * from,const extern_type * from_end,const extern_type * & from_next,intern_type * to,intern_type *,intern_type * & to_next) const313 ::do_in(state_type& state,
314 const extern_type* from,
315 const extern_type* from_end,
316 const extern_type*& from_next,
317 intern_type* to,
318 intern_type* ,
319 intern_type*& to_next) const {
320 while (from != from_end) {
321 size_t chars_read = _Locale_mbtowc(_M_ctype,
322 to, from, from_end - from,
323 &state);
324 if (chars_read == (size_t) -1) {
325 from_next = from;
326 to_next = to;
327 return error;
328 }
329
330 if (chars_read == (size_t) -2) {
331 from_next = from;
332 to_next = to;
333 return partial;
334 }
335
336 from += chars_read;
337 to++;
338 }
339
340 from_next = from;
341 to_next = to;
342 return ok;
343 }
344
345 codecvt<wchar_t, char, mbstate_t>::result
346 codecvt_byname<wchar_t, char, mbstate_t>
do_unshift(state_type & state,extern_type * to,extern_type * to_limit,extern_type * & to_next) const347 ::do_unshift(state_type& state,
348 extern_type* to,
349 extern_type* to_limit,
350 extern_type*& to_next) const {
351 to_next = to;
352 size_t result = _Locale_unshift(_M_ctype, &state,
353 to, to_limit - to, &to_next);
354 if (result == (size_t) -1)
355 return error;
356 else if (result == (size_t) -2)
357 return partial;
358 else
359 # if defined (__ISCPP__)
360 return /*to_next == to ? noconv :*/ ok;
361 # else
362 return to_next == to ? noconv : ok;
363 # endif
364 }
365
366 int
do_encoding() const367 codecvt_byname<wchar_t, char, mbstate_t>::do_encoding() const _STLP_NOTHROW {
368 if (_Locale_is_stateless(_M_ctype)) {
369 int max_width = _Locale_mb_cur_max(_M_ctype);
370 int min_width = _Locale_mb_cur_min(_M_ctype);
371 return min_width == max_width ? min_width : 0;
372 }
373 else
374 return -1;
375 }
376
377 bool codecvt_byname<wchar_t, char, mbstate_t>
do_always_noconv() const378 ::do_always_noconv() const _STLP_NOTHROW {
379 return false;
380 }
381
382 int
do_length(const state_type &,const extern_type * from,const extern_type * end,size_t mx) const383 codecvt_byname<wchar_t, char, mbstate_t>::do_length(const state_type&,
384 const extern_type* from, const extern_type* end,
385 size_t mx) const
386 { return (int)(min) ((size_t) (end - from), mx); }
387
388 int
do_max_length() const389 codecvt_byname<wchar_t, char, mbstate_t>::do_max_length() const _STLP_NOTHROW
390 { return _Locale_mb_cur_max(_M_ctype); }
391 # endif
392
393 _STLP_END_NAMESPACE
394
395 #endif /* MBSTATE_T */
396
397 _STLP_BEGIN_NAMESPACE
398
399 // numpunct_byname<char>
numpunct_byname(const char * name,size_t refs,_Locale_name_hint * hint)400 numpunct_byname<char>::numpunct_byname(const char* name, size_t refs, _Locale_name_hint* hint)
401 : numpunct<char>(refs),
402 _M_numeric(_STLP_PRIV __acquire_numeric(name, hint)) {
403 if (!_M_numeric)
404 locale::_M_throw_runtime_error();
405
406 _M_truename = _Locale_true(_M_numeric);
407 _M_falsename = _Locale_false(_M_numeric);
408 }
409
~numpunct_byname()410 numpunct_byname<char>::~numpunct_byname()
411 { _STLP_PRIV __release_numeric(_M_numeric); }
412
do_decimal_point() const413 char numpunct_byname<char>::do_decimal_point() const
414 { return _Locale_decimal_point(_M_numeric); }
415
do_thousands_sep() const416 char numpunct_byname<char>::do_thousands_sep() const
417 { return _Locale_thousands_sep(_M_numeric); }
418
do_grouping() const419 string numpunct_byname<char>::do_grouping() const {
420 const char * __grouping = _Locale_grouping(_M_numeric);
421 if (__grouping != NULL && __grouping[0] == CHAR_MAX)
422 __grouping = "";
423 return __grouping;
424 }
425
426 //----------------------------------------------------------------------
427 // numpunct<wchar_t>
428
429 #if !defined (_STLP_NO_WCHAR_T)
430
431 // numpunct_byname<wchar_t>
432
numpunct_byname(const char * name,size_t refs,_Locale_name_hint * hint)433 numpunct_byname<wchar_t>::numpunct_byname(const char* name, size_t refs, _Locale_name_hint* hint)
434 : numpunct<wchar_t>(refs),
435 _M_numeric(_STLP_PRIV __acquire_numeric(name, hint)) {
436 if (!_M_numeric)
437 locale::_M_throw_runtime_error();
438
439 const char* truename = _Locale_true(_M_numeric);
440 const char* falsename = _Locale_false(_M_numeric);
441 _M_truename.resize(strlen(truename));
442 _M_falsename.resize(strlen(falsename));
443 copy(truename, truename + strlen(truename), _M_truename.begin());
444 copy(falsename, falsename + strlen(falsename), _M_falsename.begin());
445 }
446
~numpunct_byname()447 numpunct_byname<wchar_t>::~numpunct_byname()
448 { _STLP_PRIV __release_numeric(_M_numeric); }
449
do_decimal_point() const450 wchar_t numpunct_byname<wchar_t>::do_decimal_point() const
451 { return (wchar_t) _Locale_decimal_point(_M_numeric); }
452
do_thousands_sep() const453 wchar_t numpunct_byname<wchar_t>::do_thousands_sep() const
454 { return (wchar_t) _Locale_thousands_sep(_M_numeric); }
455
do_grouping() const456 string numpunct_byname<wchar_t>::do_grouping() const {
457 const char * __grouping = _Locale_grouping(_M_numeric);
458 if (__grouping != NULL && __grouping[0] == CHAR_MAX)
459 __grouping = "";
460 return __grouping;
461 }
462
463 #endif
464
465 _STLP_MOVE_TO_PRIV_NAMESPACE
466
_Init_monetary_formats(money_base::pattern & pos_format,money_base::pattern & neg_format,_Locale_monetary * monetary)467 static void _Init_monetary_formats(money_base::pattern& pos_format,
468 money_base::pattern& neg_format,
469 _Locale_monetary * monetary) {
470 switch (_Locale_p_sign_posn(monetary)) {
471 case 0: // Parentheses surround the quantity and currency_symbol
472 case 1: // The sign string precedes the quantity and currency_symbol
473 pos_format.field[0] = (char) money_base::sign;
474 if (_Locale_p_cs_precedes(monetary)) {
475 // 1 if currency_symbol precedes a positive value
476 pos_format.field[1] = (char) money_base::symbol;
477 if (_Locale_p_sep_by_space(monetary)) {
478 // a space separates currency_symbol from a positive value.
479 pos_format.field[2] = (char) money_base::space;
480 pos_format.field[3] = (char) money_base::value;
481 } else {
482 // a space not separates currency_symbol from a positive value.
483 pos_format.field[2] = (char) money_base::value;
484 pos_format.field[3] = (char) money_base::none;
485 }
486 } else {
487 // 0 if currency_symbol succeeds a positive value
488 pos_format.field[1] = (char) money_base::value;
489 if (_Locale_p_sep_by_space(monetary)) {
490 // a space separates currency_symbol from a positive value.
491 pos_format.field[2] = (char) money_base::space;
492 pos_format.field[3] = (char) money_base::symbol;
493 } else {
494 // a space not separates currency_symbol from a positive value.
495 pos_format.field[2] = (char) money_base::symbol;
496 pos_format.field[3] = (char) money_base::none;
497 }
498 }
499 break;
500 case 2: // The sign string succeeds the quantity and currency_symbol.
501 if (_Locale_p_cs_precedes(monetary)) {
502 // 1 if currency_symbol precedes a positive value
503 pos_format.field[0] = (char) money_base::symbol;
504 if (_Locale_p_sep_by_space(monetary)) {
505 // a space separates currency_symbol from a positive value.
506 pos_format.field[1] = (char) money_base::space;
507 pos_format.field[2] = (char) money_base::value;
508 pos_format.field[3] = (char) money_base::sign;
509 } else {
510 // a space not separates currency_symbol from a positive value.
511 pos_format.field[1] = (char) money_base::value;
512 pos_format.field[2] = (char) money_base::sign;
513 pos_format.field[3] = (char) money_base::none;
514 }
515 } else {
516 // 0 if currency_symbol succeeds a positive value
517 pos_format.field[0] = (char) money_base::value;
518 if (_Locale_p_sep_by_space(monetary)) {
519 // a space separates currency_symbol from a positive value.
520 pos_format.field[1] = (char) money_base::space;
521 pos_format.field[2] = (char) money_base::symbol;
522 pos_format.field[3] = (char) money_base::sign;
523 } else {
524 // a space not separates currency_symbol from a positive value.
525 pos_format.field[1] = (char) money_base::symbol;
526 pos_format.field[2] = (char) money_base::sign;
527 pos_format.field[3] = (char) money_base::none;
528 }
529 }
530 break;
531 case 3: // The sign string immediately precedes the currency_symbol.
532 if (_Locale_p_cs_precedes(monetary)) {
533 // 1 if currency_symbol precedes a positive value
534 pos_format.field[0] = (char) money_base::sign;
535 pos_format.field[1] = (char) money_base::symbol;
536 if (_Locale_p_sep_by_space(monetary)) {
537 // a space separates currency_symbol from a positive value.
538 pos_format.field[2] = (char) money_base::space;
539 pos_format.field[3] = (char) money_base::value;
540 } else {
541 // a space not separates currency_symbol from a positive value.
542 pos_format.field[2] = (char) money_base::value;
543 pos_format.field[3] = (char) money_base::none;
544 }
545 } else {
546 // 0 if currency_symbol succeeds a positive value
547 pos_format.field[0] = (char) money_base::value;
548 pos_format.field[1] = (char) money_base::sign;
549 pos_format.field[2] = (char) money_base::symbol;
550 pos_format.field[3] = (char) money_base::none;
551 }
552 break;
553 case 4: // The sign string immediately succeeds the currency_symbol.
554 default:
555 if (_Locale_p_cs_precedes(monetary)) {
556 // 1 if currency_symbol precedes a positive value
557 pos_format.field[0] = (char) money_base::symbol;
558 pos_format.field[1] = (char) money_base::sign;
559 pos_format.field[2] = (char) money_base::value;
560 pos_format.field[3] = (char) money_base::none;
561 } else {
562 // 0 if currency_symbol succeeds a positive value
563 pos_format.field[0] = (char) money_base::value;
564 if (_Locale_p_sep_by_space(monetary)) {
565 // a space separates currency_symbol from a positive value.
566 pos_format.field[1] = (char) money_base::space;
567 pos_format.field[2] = (char) money_base::symbol;
568 pos_format.field[3] = (char) money_base::sign;
569 } else {
570 // a space not separates currency_symbol from a positive value.
571 pos_format.field[1] = (char) money_base::symbol;
572 pos_format.field[2] = (char) money_base::sign;
573 pos_format.field[3] = (char) money_base::none;
574 }
575 }
576 break;
577 }
578
579 switch (_Locale_n_sign_posn(monetary)) {
580 case 0: // Parentheses surround the quantity and currency_symbol
581 case 1: // The sign string precedes the quantity and currency_symbol
582 neg_format.field[0] = (char) money_base::sign;
583 if (_Locale_n_cs_precedes(monetary)) {
584 // 1 if currency_symbol precedes a negative value
585 neg_format.field[1] = (char) money_base::symbol;
586 if (_Locale_n_sep_by_space(monetary)) {
587 // a space separates currency_symbol from a negative value.
588 neg_format.field[2] = (char) money_base::space;
589 neg_format.field[3] = (char) money_base::value;
590 } else {
591 // a space not separates currency_symbol from a negative value.
592 neg_format.field[2] = (char) money_base::value;
593 neg_format.field[3] = (char) money_base::none;
594 }
595 } else {
596 // 0 if currency_symbol succeeds a negative value
597 neg_format.field[1] = (char) money_base::value;
598 if (_Locale_n_sep_by_space(monetary)) {
599 // a space separates currency_symbol from a negative value.
600 neg_format.field[2] = (char) money_base::space;
601 neg_format.field[3] = (char) money_base::symbol;
602 } else {
603 // a space not separates currency_symbol from a negative value.
604 neg_format.field[2] = (char) money_base::symbol;
605 neg_format.field[3] = (char) money_base::none;
606 }
607 }
608 break;
609 case 2: // The sign string succeeds the quantity and currency_symbol.
610 if (_Locale_n_cs_precedes(monetary)) {
611 // 1 if currency_symbol precedes a negative value
612 neg_format.field[0] = (char) money_base::symbol;
613 if (_Locale_n_sep_by_space(monetary)) {
614 // a space separates currency_symbol from a negative value.
615 neg_format.field[1] = (char) money_base::space;
616 neg_format.field[2] = (char) money_base::value;
617 neg_format.field[3] = (char) money_base::sign;
618 } else {
619 // a space not separates currency_symbol from a negative value.
620 neg_format.field[1] = (char) money_base::value;
621 neg_format.field[2] = (char) money_base::sign;
622 neg_format.field[3] = (char) money_base::none;
623 }
624 } else {
625 // 0 if currency_symbol succeeds a negative value
626 neg_format.field[0] = (char) money_base::value;
627 if (_Locale_n_sep_by_space(monetary)) {
628 // a space separates currency_symbol from a negative value.
629 neg_format.field[1] = (char) money_base::space;
630 neg_format.field[2] = (char) money_base::symbol;
631 neg_format.field[3] = (char) money_base::sign;
632 } else {
633 // a space not separates currency_symbol from a negative value.
634 neg_format.field[1] = (char) money_base::symbol;
635 neg_format.field[2] = (char) money_base::sign;
636 neg_format.field[3] = (char) money_base::none;
637 }
638 }
639 break;
640 case 3: // The sign string immediately precedes the currency_symbol.
641 if (_Locale_n_cs_precedes(monetary)) {
642 // 1 if currency_symbol precedes a negative value
643 neg_format.field[0] = (char) money_base::sign;
644 neg_format.field[1] = (char) money_base::symbol;
645 if (_Locale_n_sep_by_space(monetary)) {
646 // a space separates currency_symbol from a negative value.
647 neg_format.field[2] = (char) money_base::space;
648 neg_format.field[3] = (char) money_base::value;
649 } else {
650 // a space not separates currency_symbol from a negative value.
651 neg_format.field[2] = (char) money_base::value;
652 neg_format.field[3] = (char) money_base::none;
653 }
654 } else {
655 // 0 if currency_symbol succeeds a negative value
656 neg_format.field[0] = (char) money_base::value;
657 neg_format.field[1] = (char) money_base::sign;
658 neg_format.field[2] = (char) money_base::symbol;
659 neg_format.field[3] = (char) money_base::none;
660 }
661 break;
662 case 4: // The sign string immediately succeeds the currency_symbol.
663 default:
664 if (_Locale_n_cs_precedes(monetary)) {
665 // 1 if currency_symbol precedes a negative value
666 neg_format.field[0] = (char) money_base::symbol;
667 neg_format.field[1] = (char) money_base::sign;
668 neg_format.field[2] = (char) money_base::value;
669 neg_format.field[3] = (char) money_base::none;
670 } else {
671 // 0 if currency_symbol succeeds a negative value
672 neg_format.field[0] = (char) money_base::value;
673 if (_Locale_n_sep_by_space(monetary)) {
674 // a space separates currency_symbol from a negative value.
675 neg_format.field[1] = (char) money_base::space;
676 neg_format.field[2] = (char) money_base::symbol;
677 neg_format.field[3] = (char) money_base::sign;
678 } else {
679 // a space not separates currency_symbol from a negative value.
680 neg_format.field[1] = (char) money_base::symbol;
681 neg_format.field[2] = (char) money_base::sign;
682 neg_format.field[3] = (char) money_base::none;
683 }
684 }
685 break;
686 }
687 }
688
689 // international variant of monetary
690
691 /*
692 * int_curr_symbol
693 *
694 * The international currency symbol. The operand is a four-character
695 * string, with the first three characters containing the alphabetic
696 * international currency symbol in accordance with those specified
697 * in the ISO 4217 specification. The fourth character is the character used
698 * to separate the international currency symbol from the monetary quantity.
699 *
700 * (http://www.opengroup.org/onlinepubs/7990989775/xbd/locale.html)
701 */
702
703 /*
704 * Standards are unclear in the usage of international currency
705 * and monetary formats.
706 * But I am expect that international currency symbol should be the first
707 * (not depends upon where currency symbol situated in the national
708 * format).
709 *
710 * If this isn't so, let's see:
711 * 1 234.56 RUR
712 * GBP 1,234.56
713 * USD 1,234.56
714 * The situation really is worse than you see above:
715 * RUR typed wrong here---it prints '1 234.56 RUR ' (see space after RUR).
716 * This is due to intl_fmp.curr_symbol() == "RUR ". (see reference in comments
717 * above).
718 *
719 */
720
_Init_monetary_formats_int(money_base::pattern & pos_format,money_base::pattern & neg_format,_Locale_monetary * monetary)721 static void _Init_monetary_formats_int(money_base::pattern& pos_format,
722 money_base::pattern& neg_format,
723 _Locale_monetary * monetary)
724 {
725 pos_format.field[0] = (char) money_base::symbol;
726 // pos_format.field[1] = (char) money_base::space;
727
728 switch (_Locale_p_sign_posn(monetary)) {
729 case 0: // Parentheses surround the quantity and currency_symbol
730 case 1: // The sign string precedes the quantity and currency_symbol
731 pos_format.field[1] = (char) money_base::sign;
732 pos_format.field[2] = (char) money_base::value;
733 break;
734 case 2: // The sign string succeeds the quantity and currency_symbol.
735 pos_format.field[1] = (char) money_base::value;
736 pos_format.field[2] = (char) money_base::sign;
737 break;
738 case 3: // The sign string immediately precedes the currency_symbol.
739 case 4: // The sign string immediately succeeds the currency_symbol.
740 default:
741 if (_Locale_p_cs_precedes(monetary)) {
742 // 1 if currency_symbol precedes a positive value
743 pos_format.field[1] = (char) money_base::sign;
744 pos_format.field[2] = (char) money_base::value;
745 } else {
746 // 0 if currency_symbol succeeds a positive value
747 pos_format.field[1] = (char) money_base::value;
748 pos_format.field[2] = (char) money_base::sign;
749 }
750 break;
751 }
752 pos_format.field[3] = (char) money_base::none;
753
754 neg_format.field[0] = (char) money_base::symbol;
755 // neg_format.field[1] = (char) money_base::space;
756
757 switch (_Locale_n_sign_posn(monetary)) {
758 case 0: // Parentheses surround the quantity and currency_symbol
759 case 1: // The sign string precedes the quantity and currency_symbol
760 neg_format.field[1] = (char) money_base::sign;
761 neg_format.field[2] = (char) money_base::value;
762 break;
763 case 2: // The sign string succeeds the quantity and currency_symbol.
764 neg_format.field[1] = (char) money_base::value;
765 neg_format.field[2] = (char) money_base::sign;
766 break;
767 case 3: // The sign string immediately precedes the currency_symbol.
768 case 4: // The sign string immediately succeeds the currency_symbol.
769 default:
770 if (_Locale_n_cs_precedes(monetary)) {
771 // 1 if currency_symbol precedes a negative value
772 neg_format.field[1] = (char) money_base::sign;
773 neg_format.field[2] = (char) money_base::value;
774 } else {
775 // 0 if currency_symbol succeeds a negative value
776 neg_format.field[1] = (char) money_base::value;
777 neg_format.field[2] = (char) money_base::sign;
778 }
779 break;
780 }
781 neg_format.field[3] = (char) money_base::none;
782 }
783
784 _STLP_MOVE_TO_STD_NAMESPACE
785
786 //
787 // moneypunct_byname<>
788 //
moneypunct_byname(const char * name,size_t refs,_Locale_name_hint * hint)789 moneypunct_byname<char, true>::moneypunct_byname(const char * name,
790 size_t refs, _Locale_name_hint* hint):
791 moneypunct<char, true>(refs), _M_monetary(_STLP_PRIV __acquire_monetary(name, hint)) {
792 if (!_M_monetary)
793 locale::_M_throw_runtime_error();
794 _STLP_PRIV _Init_monetary_formats_int(_M_pos_format, _M_neg_format, _M_monetary);
795 }
796
~moneypunct_byname()797 moneypunct_byname<char, true>::~moneypunct_byname()
798 { _STLP_PRIV __release_monetary(_M_monetary); }
799
do_decimal_point() const800 char moneypunct_byname<char, true>::do_decimal_point() const
801 { return _Locale_mon_decimal_point(_M_monetary); }
802
do_thousands_sep() const803 char moneypunct_byname<char, true>::do_thousands_sep() const
804 { return _Locale_mon_thousands_sep(_M_monetary); }
805
do_grouping() const806 string moneypunct_byname<char, true>::do_grouping() const
807 { return _Locale_mon_grouping(_M_monetary); }
808
do_curr_symbol() const809 string moneypunct_byname<char, true>::do_curr_symbol() const
810 { return _Locale_int_curr_symbol(_M_monetary); }
811
do_positive_sign() const812 string moneypunct_byname<char, true>::do_positive_sign() const
813 { return _Locale_positive_sign(_M_monetary); }
814
do_negative_sign() const815 string moneypunct_byname<char, true>::do_negative_sign() const
816 { return _Locale_negative_sign(_M_monetary); }
817
do_frac_digits() const818 int moneypunct_byname<char, true>::do_frac_digits() const
819 { return _Locale_int_frac_digits(_M_monetary); }
820
moneypunct_byname(const char * name,size_t refs,_Locale_name_hint * hint)821 moneypunct_byname<char, false>::moneypunct_byname(const char * name,
822 size_t refs, _Locale_name_hint* hint):
823 moneypunct<char, false>(refs), _M_monetary(_STLP_PRIV __acquire_monetary(name, hint)) {
824 if (!_M_monetary)
825 locale::_M_throw_runtime_error();
826 _STLP_PRIV _Init_monetary_formats(_M_pos_format, _M_neg_format, _M_monetary);
827 }
828
~moneypunct_byname()829 moneypunct_byname<char, false>::~moneypunct_byname()
830 { _STLP_PRIV __release_monetary(_M_monetary); }
831
do_decimal_point() const832 char moneypunct_byname<char, false>::do_decimal_point() const
833 { return _Locale_mon_decimal_point(_M_monetary); }
834
do_thousands_sep() const835 char moneypunct_byname<char, false>::do_thousands_sep() const
836 { return _Locale_mon_thousands_sep(_M_monetary); }
837
do_grouping() const838 string moneypunct_byname<char, false>::do_grouping() const
839 { return _Locale_mon_grouping(_M_monetary); }
840
do_curr_symbol() const841 string moneypunct_byname<char, false>::do_curr_symbol() const
842 { return _Locale_currency_symbol(_M_monetary); }
843
do_positive_sign() const844 string moneypunct_byname<char, false>::do_positive_sign() const
845 { return _Locale_positive_sign(_M_monetary); }
846
do_negative_sign() const847 string moneypunct_byname<char, false>::do_negative_sign() const
848 { return _Locale_negative_sign(_M_monetary); }
849
do_frac_digits() const850 int moneypunct_byname<char, false>::do_frac_digits() const
851 { return _Locale_frac_digits(_M_monetary); }
852
853 //
854 // moneypunct_byname<wchar_t>
855 //
856 #if !defined (_STLP_NO_WCHAR_T)
857
moneypunct_byname(const char * name,size_t refs,_Locale_name_hint * hint)858 moneypunct_byname<wchar_t, true>::moneypunct_byname(const char * name,
859 size_t refs, _Locale_name_hint* hint):
860 moneypunct<wchar_t, true>(refs), _M_monetary(_STLP_PRIV __acquire_monetary(name, hint)) {
861 if (!_M_monetary)
862 locale::_M_throw_runtime_error();
863 _STLP_PRIV _Init_monetary_formats_int(_M_pos_format, _M_neg_format, _M_monetary);
864 }
865
~moneypunct_byname()866 moneypunct_byname<wchar_t, true>::~moneypunct_byname()
867 { _STLP_PRIV __release_monetary(_M_monetary); }
868
do_decimal_point() const869 wchar_t moneypunct_byname<wchar_t, true>::do_decimal_point() const
870 { return _Locale_mon_decimal_point(_M_monetary); }
871
do_thousands_sep() const872 wchar_t moneypunct_byname<wchar_t, true>::do_thousands_sep() const
873 { return _Locale_mon_thousands_sep(_M_monetary); }
874
do_grouping() const875 string moneypunct_byname<wchar_t, true>::do_grouping() const
876 { return _Locale_mon_grouping(_M_monetary); }
877
__do_widen(string const & str)878 inline wstring __do_widen (string const& str) {
879 #if defined (_STLP_NO_MEMBER_TEMPLATES) || defined (_STLP_MSVC) || defined(__MRC__) || defined(__SC__) //*ty 05/26/2001 - added workaround for mpw
880 wstring::_Reserve_t __Reserve;
881 size_t __size = str.size();
882 wstring result(__Reserve, __size);
883 copy(str.begin(), str.end(), result.begin());
884 #else
885 wstring result(str.begin(), str.end());
886 #endif
887 return result;
888 }
889
do_curr_symbol() const890 wstring moneypunct_byname<wchar_t, true>::do_curr_symbol() const
891 { return __do_widen(_Locale_int_curr_symbol(_M_monetary)); }
892
do_positive_sign() const893 wstring moneypunct_byname<wchar_t, true>::do_positive_sign() const
894 { return __do_widen(_Locale_positive_sign(_M_monetary)); }
895
do_negative_sign() const896 wstring moneypunct_byname<wchar_t, true>::do_negative_sign() const
897 { return __do_widen(_Locale_negative_sign(_M_monetary)); }
898
do_frac_digits() const899 int moneypunct_byname<wchar_t, true>::do_frac_digits() const
900 { return _Locale_int_frac_digits(_M_monetary); }
901
moneypunct_byname(const char * name,size_t refs,_Locale_name_hint * hint)902 moneypunct_byname<wchar_t, false>::moneypunct_byname(const char * name,
903 size_t refs, _Locale_name_hint* hint):
904 moneypunct<wchar_t, false>(refs), _M_monetary(_STLP_PRIV __acquire_monetary(name, hint)) {
905 if (!_M_monetary)
906 locale::_M_throw_runtime_error() ;
907 _STLP_PRIV _Init_monetary_formats(_M_pos_format, _M_neg_format, _M_monetary);
908 }
909
~moneypunct_byname()910 moneypunct_byname<wchar_t, false>::~moneypunct_byname()
911 { _STLP_PRIV __release_monetary(_M_monetary); }
912
do_decimal_point() const913 wchar_t moneypunct_byname<wchar_t, false>::do_decimal_point() const
914 { return _Locale_mon_decimal_point(_M_monetary); }
915
do_thousands_sep() const916 wchar_t moneypunct_byname<wchar_t, false>::do_thousands_sep() const
917 { return _Locale_mon_thousands_sep(_M_monetary); }
918
do_grouping() const919 string moneypunct_byname<wchar_t, false>::do_grouping() const
920 { return _Locale_mon_grouping(_M_monetary); }
921
do_curr_symbol() const922 wstring moneypunct_byname<wchar_t, false>::do_curr_symbol() const
923 { return __do_widen(_Locale_currency_symbol(_M_monetary)); }
924
do_positive_sign() const925 wstring moneypunct_byname<wchar_t, false>::do_positive_sign() const
926 { return __do_widen(_Locale_positive_sign(_M_monetary)); }
927
do_negative_sign() const928 wstring moneypunct_byname<wchar_t, false>::do_negative_sign() const
929 { return __do_widen(_Locale_negative_sign(_M_monetary)); }
930
do_frac_digits() const931 int moneypunct_byname<wchar_t, false>::do_frac_digits() const
932 { return _Locale_frac_digits(_M_monetary); }
933
934 #endif
935
936 _STLP_END_NAMESPACE
937
938 #include "message_facets.h"
939
940 _STLP_BEGIN_NAMESPACE
941
942 _STLP_MOVE_TO_PRIV_NAMESPACE
943
insert(nl_catd_type key,const locale & L)944 void _Catalog_locale_map::insert(nl_catd_type key, const locale& L) {
945 _STLP_TRY {
946 #if !defined(_STLP_NO_TYPEINFO) && !defined(_STLP_NO_RTTI)
947 // Don't bother to do anything unless we're using a non-default ctype facet
948 # ifdef _STLP_NO_WCHAR_T
949 typedef char _Char;
950 # else
951 typedef wchar_t _Char;
952 # endif
953
954 typedef ctype<_Char> wctype;
955 wctype const& wct = use_facet<wctype>(L);
956 if (typeid(wct) != typeid(wctype)) {
957 # endif /* _STLP_NO_TYPEINFO */
958 if (!M)
959 M = _CHECK_PTR(new map_type);
960
961 #if defined (__SC__)
962 if (!M) delete M;
963 #endif
964 M->insert(map_type::value_type(key, L));
965 #if !defined(_STLP_NO_TYPEINFO) && !defined(_STLP_NO_RTTI)
966 }
967 # endif /* _STLP_NO_TYPEINFO */
968 }
969 _STLP_CATCH_ALL {}
970 }
971
erase(nl_catd_type key)972 void _Catalog_locale_map::erase(nl_catd_type key) {
973 if (M)
974 M->erase(key);
975 }
976
lookup(nl_catd_type key) const977 locale _Catalog_locale_map::lookup(nl_catd_type key) const {
978 if (M) {
979 map_type::const_iterator i = M->find(key);
980 return i != M->end() ? (*i).second : locale::classic();
981 }
982 else
983 return locale::classic();
984 }
985
986
987 #if defined (_STLP_USE_NL_CATD_MAPPING)
988 _STLP_VOLATILE __stl_atomic_t _Catalog_nl_catd_map::_count = 0;
989
insert(nl_catd_type cat)990 messages_base::catalog _Catalog_nl_catd_map::insert(nl_catd_type cat) {
991 messages_base::catalog &res = Mr[cat];
992 if ( res == 0 ) {
993 #if defined (_STLP_ATOMIC_INCREMENT)
994 res = __STATIC_CAST(int, _STLP_ATOMIC_INCREMENT(&_count));
995 #else
996 static _STLP_STATIC_MUTEX _Count_lock _STLP_MUTEX_INITIALIZER;
997 {
998 _STLP_auto_lock sentry(_Count_lock);
999 res = __STATIC_CAST(int, ++_count);
1000 }
1001 #endif
1002 M[res] = cat;
1003 }
1004 return res;
1005 }
1006
erase(messages_base::catalog cat)1007 void _Catalog_nl_catd_map::erase(messages_base::catalog cat) {
1008 map_type::iterator mit(M.find(cat));
1009 if (mit != M.end()) {
1010 Mr.erase((*mit).second);
1011 M.erase(mit);
1012 }
1013 }
1014 #endif
1015
1016 //----------------------------------------------------------------------
1017 //
1018 //
1019
_Messages_impl(bool is_wide,_Locale_name_hint * hint)1020 _Messages_impl::_Messages_impl(bool is_wide, _Locale_name_hint* hint) :
1021 _M_message_obj(0), _M_map(0) {
1022 _M_delete = true;
1023 if (is_wide)
1024 _M_map = _CHECK_PTR(new _Catalog_locale_map);
1025 _M_message_obj = __acquire_messages("C", hint);
1026 }
1027
_Messages_impl(bool is_wide,_Locale_messages * msg_obj)1028 _Messages_impl::_Messages_impl(bool is_wide, _Locale_messages* msg_obj ) :
1029 _M_message_obj(msg_obj), _M_map(0) {
1030 _M_delete = true;
1031 if (is_wide)
1032 _M_map = _CHECK_PTR(new _Catalog_locale_map);
1033 }
1034
~_Messages_impl()1035 _Messages_impl::~_Messages_impl() {
1036 __release_messages(_M_message_obj);
1037 if (_M_map) delete _M_map;
1038 }
1039
do_open(const string & filename,const locale & L) const1040 _Messages::catalog _Messages_impl::do_open(const string& filename, const locale& L) const {
1041 nl_catd_type result = _M_message_obj ? _Locale_catopen(_M_message_obj, filename.c_str())
1042 : (nl_catd_type)(-1);
1043
1044 if ( result != (nl_catd_type)(-1) ) {
1045 if ( _M_map != 0 ) {
1046 _M_map->insert(result, L);
1047 }
1048 return _M_cat.insert( result );
1049 }
1050
1051 return -1;
1052 }
1053
do_get(catalog cat,int set,int p_id,const string & dfault) const1054 string _Messages_impl::do_get(catalog cat,
1055 int set, int p_id, const string& dfault) const {
1056 return _M_message_obj != 0 && cat >= 0
1057 ? string(_Locale_catgets(_M_message_obj, _M_cat[cat], set, p_id, dfault.c_str()))
1058 : dfault;
1059 }
1060
1061 #if !defined (_STLP_NO_WCHAR_T)
1062
1063 wstring
do_get(catalog thecat,int set,int p_id,const wstring & dfault) const1064 _Messages_impl::do_get(catalog thecat,
1065 int set, int p_id, const wstring& dfault) const {
1066 typedef ctype<wchar_t> wctype;
1067 const wctype& ct = use_facet<wctype>(_M_map->lookup( _M_cat[thecat] ) );
1068
1069 const char* str = _Locale_catgets(_M_message_obj, _M_cat[thecat], set, p_id, "");
1070
1071 // Verify that the lookup failed; an empty string might represent success.
1072 if (!str)
1073 return dfault;
1074 else if (str[0] == '\0') {
1075 const char* str2 = _Locale_catgets(_M_message_obj, _M_cat[thecat], set, p_id, "*");
1076 if (!str2 || ((str2[0] == '*') && (str2[1] == '\0')))
1077 return dfault;
1078 }
1079
1080 // str is correct. Now we must widen it to get a wstring.
1081 size_t n = strlen(str);
1082
1083 // NOT PORTABLE. What we're doing relies on internal details of the
1084 // string implementation. (Contiguity of string elements.)
1085 wstring result(n, wchar_t(0));
1086 ct.widen(str, str + n, &*result.begin());
1087 return result;
1088 }
1089
1090 #endif
1091
do_close(catalog thecat) const1092 void _Messages_impl::do_close(catalog thecat) const {
1093 if (_M_message_obj)
1094 _Locale_catclose(_M_message_obj, _M_cat[thecat]);
1095 if (_M_map) _M_map->erase(_M_cat[thecat]);
1096 _M_cat.erase( thecat );
1097 }
1098
1099 _STLP_MOVE_TO_STD_NAMESPACE
1100
1101 //----------------------------------------------------------------------
1102 // messages<char>
1103
messages(size_t refs)1104 messages<char>::messages(size_t refs) :
1105 locale::facet(refs), _M_impl(_CHECK_PTR(new _STLP_PRIV _Messages_impl(false))) {}
1106
messages(size_t refs,_Locale_messages * msg_obj)1107 messages<char>::messages(size_t refs, _Locale_messages* msg_obj) : locale::facet(refs),
1108 _M_impl(_CHECK_PTR(new _STLP_PRIV _Messages_impl(false, msg_obj))) {}
1109
1110
1111 //----------------------------------------------------------------------
1112 // messages_byname<char>
1113
messages_byname(const char * name,size_t refs,_Locale_name_hint * hint)1114 messages_byname<char>::messages_byname(const char* name, size_t refs, _Locale_name_hint* hint)
1115 : messages<char>(refs, name ? _STLP_PRIV __acquire_messages(name, hint) : 0) {}
1116
~messages_byname()1117 messages_byname<char>::~messages_byname() {}
1118
1119 #if !defined (_STLP_NO_WCHAR_T)
1120
1121 //----------------------------------------------------------------------
1122 // messages<wchar_t>
1123
messages(size_t refs)1124 messages<wchar_t>::messages(size_t refs) :
1125 locale::facet(refs), _M_impl(_CHECK_PTR(new _STLP_PRIV _Messages_impl(true))) {}
1126
messages(size_t refs,_Locale_messages * msg_obj)1127 messages<wchar_t>::messages(size_t refs, _Locale_messages* msg_obj)
1128 : locale::facet(refs),
1129 _M_impl(_CHECK_PTR(new _STLP_PRIV _Messages_impl(true, msg_obj))) {}
1130
1131 //----------------------------------------------------------------------
1132 // messages_byname<wchar_t>
1133
1134
messages_byname(const char * name,size_t refs,_Locale_name_hint * hint)1135 messages_byname<wchar_t>::messages_byname(const char* name, size_t refs, _Locale_name_hint* hint)
1136 : messages<wchar_t>(refs, name ? _STLP_PRIV __acquire_messages(name, hint) : 0) {}
1137
~messages_byname()1138 messages_byname<wchar_t>::~messages_byname() {}
1139
1140 #endif
1141
1142 _STLP_END_NAMESPACE
1143
1144