streamsize basic_streambuf<char, char_traits<char> >
::xsgetn(char* s, streamsize n)
{
streamsize result = 0;
const int_type eof = traits_type::eof();
while (result < n) {
if (_FILE_I_avail(_M_get) > 0) {
size_t chunk = min(__STATIC_CAST(size_t,_FILE_I_avail(_M_get)),
__STATIC_CAST(size_t,n - result));
traits_type::copy(s, _FILE_I_next(_M_get), chunk);
result += chunk;
s += chunk;
_FILE_I_bump(_M_get, chunk);
}
else {
int_type c = sbumpc();
if (c != eof) {
s[result] = c;
++result;
++s;
}
else
break;
}
}
return result;
}
streamsize basic_streambuf<char, char_traits<char> >
::xsputn(const char* s, streamsize n)
{
streamsize result = 0;
const int_type eof = traits_type::eof();
while (result < n) {
if (_FILE_O_avail(_M_put) > 0) {
size_t chunk = min(__STATIC_CAST(size_t,_FILE_O_avail(_M_put)),
__STATIC_CAST(size_t,n - result));
traits_type::copy(_FILE_O_next(_M_put), s, chunk);
result += chunk;
s += chunk;
_FILE_O_bump(_M_put, chunk);
}
else if (this->overflow(traits_type::to_int_type(*s)) != eof) {
++result;
++s;
}
else
break;
}
return result;
}
streamsize
basic_streambuf<_CharT, _Traits>::xsgetn(_CharT* __s, streamsize __n)
{
streamsize __result = 0;
const int_type __eof = _Traits::eof();
while (__result < __n) {
if (_M_gnext < _M_gend) {
size_t __chunk = min(__STATIC_CAST(size_t,_M_gend - _M_gnext),
__STATIC_CAST(size_t,__n - __result));
_Traits::copy(__s, _M_gnext, __chunk);
__result += __chunk;
__s += __chunk;
_M_gnext += __chunk;
}
else {
int_type __c = this->sbumpc();
if (!_Traits::eq_int_type(__c, __eof)) {
__s[__result] = __c;
++__result;
++__s;
}
else
break;
}
}
return __result;
}
streamsize
basic_streambuf<_CharT, _Traits>::xsputn(const _CharT* __s, streamsize __n)
{
streamsize __result = 0;
const int_type __eof = _Traits::eof();
while (__result < __n) {
if (_M_pnext < _M_pend) {
size_t __chunk = min(__STATIC_CAST(size_t,_M_pend - _M_pnext),
__STATIC_CAST(size_t,__n - __result));
_Traits::copy(_M_pnext, __s, __chunk);
__result += __chunk;
__s += __chunk;
_M_pnext += __chunk;
}
else if (!_Traits::eq_int_type(this->overflow(_Traits::to_int_type(*__s)),
__eof)) {
++__result;
++__s;
}
else
break;
}
return __result;
}
bool _STLP_CALL
__get_integer(_InputIter& __first, _InputIter& __last,
int __base, _Integer& __val,
int __got, bool __is_negative, _CharT __separator, const string& __grouping, const __false_type& /*_IsSigned*/) {
bool __ovflow = false;
_Integer __result = 0;
bool __is_group = !__grouping.empty();
char __group_sizes[64];
char __current_group_size = 0;
char* __group_sizes_end = __group_sizes;
_Integer __over_base = (numeric_limits<_Integer>::max)() / __STATIC_CAST(_Integer, __base);
for ( ; __first != __last ; ++__first) {
const _CharT __c = *__first;
if (__is_group && __c == __separator) {
*__group_sizes_end++ = __current_group_size;
__current_group_size = 0;
continue;
}
int __n = __get_digit_from_table(__c);
if (__n >= __base)
break;
++__got;
++__current_group_size;
if (__result > __over_base)
__ovflow = true; //don't need to keep accumulating
else {
_Integer __next = __STATIC_CAST(_Integer, __base * __result + __n);
if (__result != 0)
__ovflow = __ovflow || __next <= __result;
__result = __next;
}
}
if (__is_group && __group_sizes_end != __group_sizes) {
*__group_sizes_end++ = __current_group_size;
}
// fbp : added to not modify value if nothing was read
if (__got > 0) {
__val = __ovflow ? (numeric_limits<_Integer>::max)()
: (__is_negative ? __STATIC_CAST(_Integer, -__result)
: __result);
}
// overflow is being treated as failure
return ((__got > 0) && !__ovflow) &&
(__is_group == 0 ||
__valid_grouping(__group_sizes, __group_sizes_end,
__grouping.data(), __grouping.data()+ __grouping.size()));
}
_Underflow< char, char_traits<char> >::int_type _STLP_CALL
_Underflow< char, char_traits<char> >::_M_doit(basic_filebuf<char, char_traits<char> >* __this)
{
typedef char_traits<char> traits_type;
typedef traits_type::int_type int_type;
if (!__this->_M_in_input_mode) {
if (!__this->_M_switch_to_input_mode())
return traits_type::eof();
}
else if (__this->_M_in_putback_mode) {
__this->_M_exit_putback_mode();
if (__this->gptr() != __this->egptr()) {
int_type __c = traits_type::to_int_type(*__this->gptr());
return __c;
}
}
// If it's a disk file, and if the internal and external character
// sequences are guaranteed to be identical, then try to use memory
// mapped I/O. Otherwise, revert to ordinary read.
if (__this->_M_base.__regular_file()
&& __this->_M_always_noconv
&& __this->_M_base._M_in_binary_mode()) {
// If we've mmapped part of the file already, then unmap it.
if (__this->_M_mmap_base) {
__this->_M_base._M_unmap(__this->_M_mmap_base, __this->_M_mmap_len);
__this->_M_mmap_base = 0;
__this->_M_mmap_len = 0;
}
// Determine the position where we start mapping. It has to be
// a multiple of the page size.
streamoff __cur = __this->_M_base._M_seek(0, ios_base::cur);
streamoff __size = __this->_M_base._M_file_size();
if (__size > 0 && __cur >= 0 && __cur < __size) {
streamoff __offset = (__cur / __this->_M_base.__page_size()) * __this->_M_base.__page_size();
streamoff __remainder = __cur - __offset;
__this->_M_mmap_len = __size - __offset;
if (__this->_M_mmap_len > MMAP_CHUNK)
__this->_M_mmap_len = MMAP_CHUNK;
if ((__this->_M_mmap_base = __this->_M_base._M_mmap(__offset, __this->_M_mmap_len)) != 0) {
__this->setg((char*) __this->_M_mmap_base,
(char*) __this->_M_mmap_base + __STATIC_CAST(ptrdiff_t, __remainder),
(char*) __this->_M_mmap_base + __STATIC_CAST(ptrdiff_t, __this->_M_mmap_len));
return traits_type::to_int_type(*__this->gptr());
}
else
__this->_M_mmap_len = 0;
}
}
return __this->_M_underflow_aux();
}
_STLP_STD::streambuf* stdio_streambuf_base::setbuf(char* s, streamsize n) {
#ifdef _STLP_WCE
// no buffering in windows ce .NET
#else
size_t __n_size_t = (sizeof(streamsize) > sizeof(size_t)) ? __STATIC_CAST(size_t, (min)(__STATIC_CAST(streamsize, (numeric_limits<size_t>::max)()), n))
: __STATIC_CAST(size_t, n);
_STLP_VENDOR_CSTD::setvbuf(_M_file, s, (s == 0 && n == 0) ? _IONBF : _IOFBF, __n_size_t);
#endif
return this;
}
int codecvt<char, char, mbstate_t>::do_length(const mbstate_t&,
const char* from,
const char* end,
size_t max) const
{
return min( __STATIC_CAST(size_t, (end - from)), max);
}
_STLP_BEGIN_NAMESPACE
// strstreambuf constructor, destructor.
strstreambuf::strstreambuf(streamsize initial_capacity)
: _M_alloc_fun(0), _M_free_fun(0),
_M_dynamic(true), _M_frozen(false), _M_constant(false) {
size_t n = (sizeof(streamsize) > sizeof(size_t)) ? __STATIC_CAST(size_t, (min)(__STATIC_CAST(streamsize, (numeric_limits<size_t>::max)()),
(max)(initial_capacity, streamsize(16))))
: __STATIC_CAST(size_t, (max)(initial_capacity, streamsize(16)));
char* buf = _M_alloc(n);
if (buf) {
setp(buf, buf + n);
setg(buf, buf, buf);
}
}
void
_Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc>::_M_erase(_Rb_tree_node_base *__x) {
// erase without rebalancing
while (__x != 0) {
_M_erase(_S_right(__x));
_Base_ptr __y = _S_left(__x);
_STLP_STD::_Destroy(&_S_value(__x));
this->_M_header.deallocate(__STATIC_CAST(_Link_type, __x),1);
__x = __y;
}
}
_InputIter
num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
ios_base::iostate& __err,
long double& __val) const {
string __buf ;
bool __ok = _M_read_float(__buf, __in, __end, __str, (_CharT*)0 );
__string_to_float(__buf, __val);
__err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit);
if (__in == __end)
__err |= ios_base::eofbit;
return __in;
}
streamsize basic_streambuf<char, char_traits<char> >
::_M_xsputnc(char c, streamsize n)
{
streamsize result = 0;
const int_type eof = traits_type::eof();
while (result < n) {
if (_FILE_O_avail(_M_put) > 0) {
size_t chunk = min(__STATIC_CAST(size_t,_FILE_O_avail(_M_put)),
__STATIC_CAST(size_t,n - result));
traits_type::assign(_FILE_O_next(_M_put), chunk, c);
result += chunk;
_FILE_O_bump(_M_put, chunk);
}
else if (this->overflow(traits_type::to_int_type(c)) != eof)
++result;
else
break;
}
return result;
}
// Takes a reference to a locale::id, assign a numeric index if not already
// affected and returns it. The returned index is always positive.
static const locale::id& _Stl_loc_get_index(locale::id& id) {
if (id._M_index == 0) {
#if defined (_STLP_ATOMIC_INCREMENT) && !defined (_STLP_WIN95_LIKE)
static _STLP_VOLATILE __stl_atomic_t _S_index = __STATIC_CAST(__stl_atomic_t, locale::id::_S_max);
id._M_index = _STLP_ATOMIC_INCREMENT(&_S_index);
#else
static _STLP_STATIC_MUTEX _Index_lock _STLP_MUTEX_INITIALIZER;
_STLP_auto_lock sentry(_Index_lock);
size_t new_index = locale::id::_S_max++;
id._M_index = new_index;
#endif
}
return id;
}
streamsize
basic_streambuf<_CharT, _Traits>::_M_xsputnc(_CharT __c, streamsize __n)
{
streamsize __result = 0;
const int_type __eof = _Traits::eof();
while (__result < __n) {
if (_M_pnext < _M_pend) {
size_t __chunk = min(__STATIC_CAST(size_t,_M_pend - _M_pnext),
__STATIC_CAST(size_t,__n - __result));
_Traits::assign(_M_pnext, __chunk, __c);
__result += __chunk;
_M_pnext += __chunk;
}
else if (!_Traits::eq_int_type(this->overflow(_Traits::to_int_type(__c)),
__eof))
++__result;
else
break;
}
return __result;
}
_InputIter _STLP_CALL
_M_do_get_integer(_InputIter& __in, _InputIter& __end, ios_base& __str,
ios_base::iostate& __err, _Integer& __val, _CharT* __pc)
{
#if defined(__HP_aCC) && (__HP_aCC == 1)
bool _IsSigned = !((_Integer)(-1) > 0);
#else
typedef typename __bool2type<numeric_limits<_Integer>::is_signed>::_Ret _IsSigned;
#endif
const numpunct<_CharT>& __numpunct = *(const numpunct<_CharT>*)__str._M_numpunct_facet();
const string& __grouping = __str._M_grouping(); // cached copy
const int __base_or_zero = _M_get_base_or_zero(__in, __end, __str, __pc);
int __got = __base_or_zero & 1;
bool __result;
if (__in == __end) { // We may have already read a 0. If so,
if (__got > 0) { // the result is 0 even if we're at eof.
__val = 0;
__result = true;
}
else
__result = false;
} else {
const bool __negative = __base_or_zero & 2;
const int __base = __base_or_zero >> 2;
#if defined(__HP_aCC) && (__HP_aCC == 1)
if (_IsSigned)
__result = __get_integer(__in, __end, __base, __val, __got, __negative, __numpunct.thousands_sep(), __grouping, __true_type() );
else
__result = __get_integer(__in, __end, __base, __val, __got, __negative, __numpunct.thousands_sep(), __grouping, __false_type() );
#else
__result = __get_integer(__in, __end, __base, __val, __got, __negative, __numpunct.thousands_sep(), __grouping, _IsSigned());
# endif
}
__err = __STATIC_CAST(ios_base::iostate, __result ? ios_base::goodbit : ios_base::failbit);
if (__in == __end)
__err |= ios_base::eofbit;
return __in;
}
_InputIter _STLP_CALL
__do_get_integer(_InputIter& __in_ite, _InputIter& __end, ios_base& __str,
ios_base::iostate& __err, _Integer& __val, _CharT* /*__pc*/) {
locale __loc = __str.getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
#if defined (__HP_aCC) && (__HP_aCC == 1)
bool _IsSigned = !((_Integer)(-1) > 0);
#else
typedef typename is_signed<_Integer>::type::type _IsSigned;
#endif
const int __base_or_zero = __get_base_or_zero(__in_ite, __end, __str.flags(), __ctype);
int __got = __base_or_zero & 1;
bool __result;
if (__in_ite == __end) { // We may have already read a 0. If so,
if (__got > 0) { // the result is 0 even if we're at eof.
__val = 0;
__result = true;
}
else
__result = false;
}
else {
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
const bool __negative = (__base_or_zero & 2) != 0;
const int __base = __base_or_zero >> 2;
#if defined (__HP_aCC) && (__HP_aCC == 1)
if (_IsSigned)
__result = __get_integer(__in_ite, __end, __base, __val, __got, __negative, __np.thousands_sep(), __np.grouping(), __true_type() );
else
__result = __get_integer(__in_ite, __end, __base, __val, __got, __negative, __np.thousands_sep(), __np.grouping(), __false_type() );
#else
__result = __get_integer(__in_ite, __end, __base, __val, __got, __negative, __np.thousands_sep(), __np.grouping(), _IsSigned());
# endif
}
__err = __STATIC_CAST(ios_base::iostate, __result ? ios_base::goodbit : ios_base::failbit);
if (__in_ite == __end)
__err |= ios_base::eofbit;
return __in_ite;
}
uint32_t w32_get_current_thread_id()
{
return __STATIC_CAST( uint32_t, GetCurrentThread() );
}
basic_istream<_CharT, _Traits>& _STLP_CALL
operator>>(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT,_Traits, _Alloc>& __s)
{
_STLP_USING_IO
typedef basic_istream<_CharT, _Traits> __istream;
typename __istream::sentry __sentry(__is);
if (__sentry) {
basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
typedef ctype<_CharT> _C_type;
#ifdef _STLP_OWN_IOSTREAMS
// const _C_type& _Ctype = use_facet<_C_type>(__loc);
const _C_type& _Ctype = *(const _C_type*)__is._M_ctype_facet();
#else
# if defined (_STLP_MSVC) && (_STLP_MSVC <= 1200 ) || defined (__ICL)
const locale& __loc = __is.getloc();
const _C_type& _Ctype = use_facet(__loc , ( _C_type * ) 0, true);
# elif defined (__SUNPRO_CC)
const locale& __loc = __is.getloc();
const _C_type& _Ctype = use_facet(__loc , ( _C_type * ) 0);
# else
const locale& __loc = __is.getloc();
const _C_type& _Ctype = use_facet<_C_type>(__loc);
# endif
#endif
__s.clear();
size_t __n = __is.width(0);
if (__n == 0)
__n = __STATIC_CAST(size_t,-1);
else
__s.reserve(__n);
while (__n-- > 0) {
typename _Traits::int_type __c1 = __buf->sbumpc();
if (_Traits::eq_int_type(__c1, _Traits::eof())) {
__is.setstate(__istream::eofbit);
break;
}
else {
_CharT __c = _Traits::to_char_type(__c1);
if (_Ctype.is(_C_type::space, __c)) {
if (_Traits::eq_int_type(__buf->sputbackc(__c), _Traits::eof()))
__is.setstate(__istream::failbit);
break;
}
else
__s.push_back(__c);
}
}
// If we have read no characters, then set failbit.
if (__s.size() == 0)
__is.setstate(__istream::failbit);
}
else
__is.setstate(__istream::failbit);
return __is;
}
_OutputIter _S_do_put(_OutputIter __s, bool __intl, ios_base& __str,
_CharT __fill, const _Str& __digits, bool __check_digits,
_Str_Type * /*__dummy*/) {
typedef _CharT char_type;
typedef _Str_Type string_type;
typedef ctype<char_type> _Ctype;
typedef moneypunct<char_type, false> _Punct;
typedef moneypunct<char_type, true> _Punct_intl;
locale __loc = __str.getloc();
const _Ctype& __c_type = use_facet<_Ctype>(__loc) ;
const _Punct& __punct = use_facet<_Punct>(__loc) ;
const _Punct_intl& __punct_intl = use_facet<_Punct_intl>(__loc) ;
// some special characters
char_type __minus = __c_type.widen('-');
char_type __plus = __c_type.widen('+');
char_type __space = __c_type.widen(' ');
char_type __zero = __c_type.widen('0');
char_type __point = __intl ? __punct_intl.decimal_point()
: __punct.decimal_point();
char_type __sep = __intl ? __punct_intl.thousands_sep()
: __punct.thousands_sep();
string __grouping = __intl ? __punct_intl.grouping()
: __punct.grouping();
int __frac_digits = __intl ? __punct_intl.frac_digits()
: __punct.frac_digits();
string_type __curr_sym = __intl ? __punct_intl.curr_symbol()
: __punct.curr_symbol();
// if there are no digits we are going to return __s. If there
// are digits, but not enough to fill the frac_digits, we are
// going to add zeros. I don't know whether this is right or
// not.
if (__digits.empty())
return __s;
typename string_type::const_iterator __digits_first = __digits.begin();
typename string_type::const_iterator __digits_last = __digits.end();
bool __is_negative = *__digits_first == __minus;
if (__is_negative)
++__digits_first;
string_type __sign = __intl ? __is_negative ? __punct_intl.negative_sign()
: __punct_intl.positive_sign()
: __is_negative ? __punct.negative_sign()
: __punct.positive_sign();
if (__check_digits) {
typename string_type::const_iterator __cp = __digits_first;
while (__cp != __digits_last && __c_type.is(ctype_base::digit, *__cp))
++__cp;
if (__cp == __digits_first)
return __s;
__digits_last = __cp;
}
// If grouping is required, we make a copy of __digits and
// insert the grouping.
_STLP_BASIC_IOSTRING(char_type) __new_digits;
if (!__grouping.empty()) {
__new_digits.assign(__digits_first, __digits_last);
__insert_grouping(__new_digits,
__new_digits.size() - __frac_digits,
__grouping,
__sep, __plus, __minus, 0);
__digits_first = __new_digits.begin(); // <<--
__digits_last = __new_digits.end(); // <<--
}
// Determine the amount of padding required, if any.
streamsize __width = __str.width();
#if defined(_STLP_DEBUG) && (defined(__HP_aCC) && (__HP_aCC <= 1))
size_t __value_length = operator -(__digits_last, __digits_first);
#else
size_t __value_length = __digits_last - __digits_first;
#endif
size_t __length = __value_length + __sign.size();
if (__frac_digits != 0)
++__length;
bool __generate_curr = (__str.flags() & ios_base::showbase) !=0;
if (__generate_curr)
__length += __curr_sym.size();
money_base::pattern __format = __intl ? (__is_negative ? __punct_intl.neg_format()
: __punct_intl.pos_format())
: (__is_negative ? __punct.neg_format()
: __punct.pos_format());
{
//For the moment the following is commented for decoding reason.
//No reason to add a space last if the money symbol do not have to be display
//if (__format.field[3] == (char) money_base::symbol && !__generate_curr) {
// if (__format.field[2] == (char) money_base::space) {
// __format.field[2] = (char) money_base::none;
// }
//}
//space can only be second or third and only once (22.2.6.3-1):
if ((__format.field[1] == (char) money_base::space) ||
(__format.field[2] == (char) money_base::space))
++__length;
}
const bool __need_fill = (((sizeof(streamsize) > sizeof(size_t)) && (__STATIC_CAST(streamsize, __length) < __width)) ||
((sizeof(streamsize) <= sizeof(size_t)) && (__length < __STATIC_CAST(size_t, __width))));
streamsize __fill_amt = __need_fill ? __width - __length : 0;
ios_base::fmtflags __fill_pos = __str.flags() & ios_base::adjustfield;
if (__fill_amt != 0 &&
!(__fill_pos & (ios_base::left | ios_base::internal)))
__s = __fill_n(__s, __fill_amt, __fill);
for (int __i = 0; __i < 4; ++__i) {
char __ffield = __format.field[__i];
switch (__ffield) {
case money_base::none:
if (__fill_amt != 0 && __fill_pos == ios_base::internal)
__s = __fill_n(__s, __fill_amt, __fill);
break;
case money_base::space:
*__s++ = __space;
if (__fill_amt != 0 && __fill_pos == ios_base::internal)
__s = __fill_n(__s, __fill_amt, __fill);
break;
case money_base::symbol:
if (__generate_curr)
__s = copy(__curr_sym.begin(), __curr_sym.end(), __s);
break;
case money_base::sign:
if (!__sign.empty())
*__s++ = __sign[0];
break;
case money_base::value:
if (__frac_digits == 0)
__s = copy(__digits_first, __digits_last, __s);
else {
if ((int)__value_length <= __frac_digits) {
*__s++ = __point;
__s = copy(__digits_first, __digits_last, __s);
__s = __fill_n(__s, __frac_digits - __value_length, __zero);
}
else {
__s = copy(__digits_first, __digits_last - __frac_digits, __s);
if (__frac_digits != 0) {
*__s++ = __point;
__s = copy(__digits_last - __frac_digits, __digits_last, __s);
}
}
}
} //Close for switch
} // Close for loop
// Ouput rest of sign if necessary.
if (__sign.size() > 1)
__s = copy(__sign.begin() + 1, __sign.end(), __s);
if (__fill_amt != 0 &&
!(__fill_pos & (ios_base::right | ios_base::internal)))
__s = __fill_n(__s, __fill_amt, __fill);
return __s;
}
strstreambuf::pos_type
strstreambuf::seekoff(off_type off,
ios_base::seekdir dir, ios_base::openmode mode) {
bool do_get = false;
bool do_put = false;
if ((mode & (ios_base::in | ios_base::out)) ==
(ios_base::in | ios_base::out) &&
(dir == ios_base::beg || dir == ios_base::end))
do_get = do_put = true;
else if (mode & ios_base::in)
do_get = true;
else if (mode & ios_base::out)
do_put = true;
// !gptr() is here because, according to D.7.1 paragraph 4, the seekable
// area is undefined if there is no get area.
if ((!do_get && !do_put) || (do_put && !pptr()) || !gptr())
return pos_type(off_type(-1));
char* seeklow = eback();
char* seekhigh = epptr() ? epptr() : egptr();
off_type newoff;
switch(dir) {
case ios_base::beg:
newoff = 0;
break;
case ios_base::end:
newoff = seekhigh - seeklow;
break;
case ios_base::cur:
newoff = do_put ? pptr() - seeklow : gptr() - seeklow;
break;
default:
return pos_type(off_type(-1));
}
off += newoff;
if (off < 0 || off > seekhigh - seeklow)
return pos_type(off_type(-1));
if (do_put) {
if (seeklow + __STATIC_CAST(ptrdiff_t, off) < pbase()) {
setp(seeklow, epptr());
pbump((int)off);
}
else {
setp(pbase(), epptr());
pbump((int)(off - (pbase() - seeklow)));
}
}
if (do_get) {
if (off <= egptr() - seeklow)
setg(seeklow, seeklow + __STATIC_CAST(ptrdiff_t, off), egptr());
else if (off <= pptr() - seeklow)
setg(seeklow, seeklow + __STATIC_CAST(ptrdiff_t, off), pptr());
else
setg(seeklow, seeklow + __STATIC_CAST(ptrdiff_t, off), epptr());
}
return pos_type(newoff);
}
int codecvt<char, char, mbstate_t>::do_length(state_type&,
const char* from,
const char* end,
size_t mx) const
{ return (int)(min) ( __STATIC_CAST(size_t, (end - from)), mx); }
