| /*************************************************************************** |
| * |
| * _money_get.cc - definition of std::money_get members |
| * |
| * $Id$ |
| * |
| *************************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| * Copyright 2001-2008 Rogue Wave Software, Inc. |
| * |
| **************************************************************************/ |
| |
| #include <streambuf> |
| #include <loc/_ctype.h> |
| #include <loc/_moneypunct.h> |
| #include <rw/_defs.h> |
| |
| |
| _RWSTD_NAMESPACE (__rw) { |
| |
| _RWSTD_EXPORT int |
| __rw_get_num (void*, const char*, int, int, |
| const char*, _RWSTD_SIZE_T, const char*, _RWSTD_SIZE_T); |
| |
| _RWSTD_EXPORT int |
| __rw_check_grouping (const char*, _RWSTD_SIZE_T, |
| const char*, _RWSTD_SIZE_T); |
| |
| } // namespace __rw |
| |
| |
| _RWSTD_NAMESPACE (std) { |
| |
| |
| template <class _CharT, class _InputIter> |
| _RW::__rw_facet_id money_get<_CharT, _InputIter>::id; |
| |
| |
| template <class _CharT, class _InputIter> |
| typename money_get<_CharT, _InputIter>::iter_type |
| money_get<_CharT, _InputIter>:: |
| _C_get (iter_type __it, iter_type __end, bool __intl, ios_base &__flags, |
| _RWSTD_IOSTATE &__err, void *__pval, string_type *__pstr) const |
| { |
| typedef moneypunct<_CharT, false> _Punct0; |
| typedef moneypunct<_CharT, true> _Punct1; |
| |
| const _Punct0 &__pun = __intl ? |
| _RWSTD_REINTERPRET_CAST (const _Punct0&, |
| _RWSTD_USE_FACET (_Punct1, |
| __flags.getloc ())) |
| : _RWSTD_USE_FACET (_Punct0, __flags.getloc ()); |
| |
| // retrieve positive and negative sign, currency symbol, |
| // the grouping string and the pattern format |
| const string_type __ps = __pun.positive_sign (); |
| const string_type __ns = __pun.negative_sign (); |
| const string_type __cs = __pun.curr_symbol (); |
| const string __gr = __pun.grouping (); |
| const money_base::pattern __pat = __pun.neg_format (); |
| |
| _RWSTD_IOSTATE __ebits = _RW::__rw_goodbit; |
| |
| bool __needws = false; // whitespace required? |
| bool __seendp = false; // seen decimal point in input |
| |
| const ctype<_CharT> &__ctp = |
| _RWSTD_USE_FACET (ctype<_CharT>, __flags.getloc ()); |
| |
| char __buf [304]; |
| char *__pcur = __buf; |
| |
| typedef typename string_type::traits_type _Traits; |
| |
| char __grpbuf [sizeof __buf]; // holds sizes of discovered groups |
| char *__pgrp = __grpbuf; // current group |
| const char *__grpstart = 0; // the start of the last group |
| const char *__grpend = 0; // the end of the last group |
| |
| |
| int __sign = 0; // the sign of the result if detected (-1, 0, or +1) |
| |
| // buffer must always start with a sign (__rw_get_num requirement) |
| // use a '+' and overwrite it with a '-' if necessary |
| *__pcur++ = '+'; |
| |
| const int __fl = __flags.flags (); |
| |
| typedef _RWSTD_SIZE_T _SizeT; |
| |
| for (_SizeT __i = 0; !__ebits && __i != sizeof __pat.field; ++__i) { |
| |
| switch (__pat.field [__i]) { |
| |
| case /* '\1' */ money_base::space: |
| __needws = true; |
| // fall through... |
| |
| case /* '\0' */ money_base::none: { |
| |
| // optional or even required whitespace is consumed only if |
| // other characters may be required to complete the format |
| if ( sizeof __pat.field == __i + 1 |
| || 2 == __i && money_base::symbol == __pat.field [3] |
| && (!(__fl & _RW::__rw_showbase) || 0 == __cs.size ()) |
| && !( __sign < 0 && __ns.size () > 1 |
| || __sign > 0 && __ps.size () > 1) |
| || 1 == __i && money_base::value == __pat.field [0] |
| && 0 == __ns.size () && 0 == __ps.size () |
| && (0 == __cs.size () || !(__fl & _RW::__rw_showbase))) |
| break; |
| |
| _SizeT __nc = 0; |
| |
| while (__it != __end && __ctp.is (ctype_base::space, *__it)) { |
| ++__it; |
| ++__nc; |
| } |
| |
| if (__needws && !__nc) |
| __ebits |= _RW::__rw_failbit; |
| break; |
| } |
| |
| case /* '\2' */ money_base::symbol: { |
| |
| // if optional, currency symbol is not extracted unless |
| // it is consumed only if it is followed by characters |
| // required to complete the pattern (see example in |
| // 22.2.6.1.2, p3) |
| if ( __fl & _RW::__rw_showbase |
| || __i < 2 |
| || 2 == __i && (money_base::none != __pat.field [3]) |
| || __sign < 0 && __ns.size () > 1 |
| || __sign > 0 && __ps.size () > 1) { |
| |
| for (_SizeT __nc = 0; __nc != __cs.size (); |
| ++__nc, ++__it) { |
| if (__it == __end || !_Traits::eq (*__it, __cs [__nc])) { |
| |
| // 22.2.6.1.2, p2: unless showbase is set, |
| // curr_symbol is optional |
| if (__nc || __fl & _RW::__rw_showbase) |
| __ebits |= _RW::__rw_failbit; |
| break; |
| } |
| } |
| } |
| break; |
| } |
| |
| case /* '\3' */ money_base::sign: { |
| |
| if (__it == __end) { |
| if (__ps.size () && __ns.size ()) |
| __ebits |= _RW::__rw_failbit; |
| else |
| __sign = __ps.empty () - 1; |
| break; |
| } |
| |
| const char_type __c = *__it; |
| |
| // 22.2.6.1.2, p3: if the first character of positive |
| // and negative sign is the same, the result is positive |
| |
| if (__ps.size () && _Traits::eq (__c, __ps [0])) { |
| __sign = 1; |
| ++__it; |
| } |
| else if (__ns.size () && _Traits::eq (__c, __ns [0])) { |
| __sign = -1; |
| ++__it; |
| } |
| |
| break; |
| } |
| |
| case /* '\4' */ money_base::value: { |
| |
| const char_type __ts = |
| __gr.size () && __gr [0] && __gr [0] != _RWSTD_CHAR_MAX ? |
| __pun.thousands_sep () : __ctp.widen ('0'); |
| |
| int __fd = __pun.frac_digits (); |
| |
| for (; __it != __end; ++__it) { |
| |
| // read and narrow a character (note that narrow() may |
| // yield the same narrow char for more than one wide |
| // character; e.g., there may be two sets of digits) |
| const char_type __c = *__it; |
| const char __ch = __ctp.narrow (__c, '\0'); |
| |
| if (__ch >= '0' && __ch <= '9') { |
| if (!__seendp || __fd-- > 0) |
| *__pcur++ = __ch; |
| } |
| else if ( !__seendp && __fd > 0 |
| && _Traits::eq (__c, __pun.decimal_point ())) { |
| __grpend = __pcur; |
| __seendp = true; |
| } |
| else if (!__seendp && _Traits::eq (__c, __ts)) { |
| // add the length of the current group to the array groups |
| // store UCHAR_MAX if group length exceeds the size of char |
| _RWSTD_PTRDIFF_T __len; |
| |
| if (__grpstart) |
| __len = __pcur - __grpstart; |
| else { |
| __grpstart = __pcur; |
| __len = __pcur - __buf - 1; |
| } |
| |
| typedef unsigned char _UChar; |
| |
| *__pgrp++ = char (__len < _UChar (-1) ? __len : -1); |
| __grpstart = __pcur; |
| } |
| else |
| break; |
| } |
| |
| if (__pcur - __buf > 1) { |
| // append zeros to a non-empty string of digits |
| // up to the number of frac_digits |
| while (__fd-- > 0) |
| *__pcur++ = '0'; |
| } |
| |
| *__pcur = '\0'; |
| break; |
| } |
| |
| default: |
| __ebits = _RW::__rw_failbit; |
| break; |
| |
| } |
| } |
| |
| if (!(__ebits & _RW::__rw_failbit)) { |
| |
| if (__buf [1]) { |
| |
| // process the remainder of a multicharacter sign |
| const _SizeT __sizes [] = { |
| __ps.size () ? __ps.size () -1 : 0, |
| __ns.size () ? __ns.size () -1 : 0 |
| }; |
| |
| const char_type* const __names [] = { |
| __ps.data () + !!__sizes [0], |
| __ns.data () + !!__sizes [1] |
| }; |
| |
| if (__sign && (__sizes [0] || __sizes [1])) { |
| |
| // if the first character of a multi-character sign |
| // has been seen, try to extract the rest of the sign |
| |
| _SizeT __inx = 0; |
| |
| int __errtmp = 1; // no duplicates allowed |
| |
| __it = _RW::__rw_match_name (__it, __end, __names, __sizes, |
| sizeof __names / sizeof *__names, |
| __inx, __errtmp, 0); |
| |
| if (1 < __inx && __sizes [__sign < 0]) { |
| |
| // failed to match the remainder of the sign to |
| // the input and the first character of the sign |
| // does not form the complete (positive or negative) |
| // sign |
| __ebits = _RW::__rw_failbit; |
| __buf [1] = '\0'; |
| } |
| else if (!_Traits::eq (*__ps.data (), *__ns.data ())) { |
| |
| // if the first extracted character of the sign string |
| // forms the complete sign whose first character doesn't |
| // form an initial substring of the other sign string |
| // the resulting sign is determined by the one-character |
| // sign string |
| if (1 < __inx) |
| __inx = 0 < __sizes [__sign < 0]; |
| |
| // if both signs begin with the same character, |
| // the result is positive (22.2.6.1.2, p3) |
| *__buf = __inx ? '-' : '+'; |
| __sign = -int (__inx); |
| } |
| } |
| else if (__sign < 0) { |
| *__buf = '-'; |
| } |
| |
| if (__pstr && !(__ebits & _RW::__rw_failbit)) { |
| // skip over the leading sign and any redundant zeros after it |
| const char *__start = __buf + 1; |
| for (; '0' == *__start && '0' == __start [1]; ++__start); |
| |
| // invert the sign if negative |
| __sign = __sign < 0; |
| |
| // widen narrow digits optionally preceded by the minus sign |
| // into the basic_string object as required by 22.2.6.1.2, p1 |
| __pstr->resize ((__pcur - __start) + _SizeT (__sign)); |
| |
| if (__sign) |
| _Traits::assign ((*__pstr)[0], __ctp.widen ('-')); |
| |
| __ctp.widen (__start, __pcur, &(*__pstr)[_SizeT (__sign)]); |
| } |
| |
| const char *__grs = ""; |
| _SizeT __grn = 0; |
| |
| // 22.2.6.1.2, p1: thousands separators are optional |
| |
| // add the length of the last group to the array of groups |
| // store UCHAR_MAX if group length exceeds the size of char |
| if (__grpstart) { |
| const _RWSTD_PTRDIFF_T __len = |
| (__grpend ? __grpend : __pcur) - __grpstart; |
| |
| typedef unsigned char _UChar; |
| |
| *__pgrp++ = char (__len < _UChar (-1) ? __len : -1); |
| *__pgrp = '\0'; |
| __grs = __gr.data (); |
| __grn = __gr.size (); |
| } |
| |
| if (__pval) { |
| // produce a number from the extracted string of digits |
| // and (optionally) check grouping |
| |
| const int __errtmp = |
| _RW::__rw_get_num (__pval, __buf, _C_ldouble, 0, |
| __grpbuf, __pgrp - __grpbuf, |
| __grs, __grn); |
| |
| __ebits |= _RWSTD_IOSTATE (__errtmp); |
| } |
| else if (0 > _RW::__rw_check_grouping (__grpbuf, __pgrp - __grpbuf, |
| __grs, __grn)) |
| __ebits |= _RW::__rw_failbit; |
| } |
| else |
| __ebits |= _RW::__rw_failbit; |
| } |
| |
| if (__it == __end) |
| __ebits |= _RW::__rw_eofbit; |
| |
| __err |= __ebits; |
| |
| return __it; |
| } |
| |
| |
| } // namespace std |
