diff options
Diffstat (limited to 'tests/libcxx/include/locale')
| -rw-r--r-- | tests/libcxx/include/locale | 4302 |
1 files changed, 4302 insertions, 0 deletions
diff --git a/tests/libcxx/include/locale b/tests/libcxx/include/locale new file mode 100644 index 00000000..b88c6ac3 --- /dev/null +++ b/tests/libcxx/include/locale @@ -0,0 +1,4302 @@ +// -*- C++ -*- +//===-------------------------- locale ------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_LOCALE +#define _LIBCPP_LOCALE + +/* + locale synopsis + +namespace std +{ + +class locale +{ +public: + // types: + class facet; + class id; + + typedef int category; + static const category // values assigned here are for exposition only + none = 0x000, + collate = 0x010, + ctype = 0x020, + monetary = 0x040, + numeric = 0x080, + time = 0x100, + messages = 0x200, + all = collate | ctype | monetary | numeric | time | messages; + + // construct/copy/destroy: + locale() throw(); + locale(const locale& other) throw(); + explicit locale(const char* std_name); + explicit locale(const string& std_name); + locale(const locale& other, const char* std_name, category); + locale(const locale& other, const string& std_name, category); + template <class Facet> locale(const locale& other, Facet* f); + locale(const locale& other, const locale& one, category); + + ~locale() throw(); // not virtual + + const locale& operator=(const locale& other) throw(); + + template <class Facet> locale combine(const locale& other) const; + + // locale operations: + basic_string<char> name() const; + bool operator==(const locale& other) const; + bool operator!=(const locale& other) const; + template <class charT, class Traits, class Allocator> + bool operator()(const basic_string<charT,Traits,Allocator>& s1, + const basic_string<charT,Traits,Allocator>& s2) const; + + // global locale objects: + static locale global(const locale&); + static const locale& classic(); +}; + +template <class Facet> const Facet& use_facet(const locale&); +template <class Facet> bool has_facet(const locale&) throw(); + +// 22.3.3, convenience interfaces: +template <class charT> bool isspace (charT c, const locale& loc); +template <class charT> bool isprint (charT c, const locale& loc); +template <class charT> bool iscntrl (charT c, const locale& loc); +template <class charT> bool isupper (charT c, const locale& loc); +template <class charT> bool islower (charT c, const locale& loc); +template <class charT> bool isalpha (charT c, const locale& loc); +template <class charT> bool isdigit (charT c, const locale& loc); +template <class charT> bool ispunct (charT c, const locale& loc); +template <class charT> bool isxdigit(charT c, const locale& loc); +template <class charT> bool isalnum (charT c, const locale& loc); +template <class charT> bool isgraph (charT c, const locale& loc); +template <class charT> charT toupper(charT c, const locale& loc); +template <class charT> charT tolower(charT c, const locale& loc); + +template<class Codecvt, class Elem = wchar_t, + class Wide_alloc = allocator<Elem>, + class Byte_alloc = allocator<char>> +class wstring_convert +{ +public: + typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string; + typedef basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string; + typedef typename Codecvt::state_type state_type; + typedef typename wide_string::traits_type::int_type int_type; + + wstring_convert(Codecvt* pcvt = new Codecvt); + wstring_convert(Codecvt* pcvt, state_type state); + wstring_convert(const byte_string& byte_err, + const wide_string& wide_err = wide_string()); + ~wstring_convert(); + + wide_string from_bytes(char byte); + wide_string from_bytes(const char* ptr); + wide_string from_bytes(const byte_string& str); + wide_string from_bytes(const char* first, const char* last); + + byte_string to_bytes(Elem wchar); + byte_string to_bytes(const Elem* wptr); + byte_string to_bytes(const wide_string& wstr); + byte_string to_bytes(const Elem* first, const Elem* last); + + size_t converted() const; + state_type state() const; +}; + +template <class Codecvt, class Elem = wchar_t, class Tr = char_traits<Elem>> +class wbuffer_convert + : public basic_streambuf<Elem, Tr> +{ +public: + typedef typename Tr::state_type state_type; + + wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt, + state_type state = state_type()); + + streambuf* rdbuf() const; + streambuf* rdbuf(streambuf* bytebuf); + + state_type state() const; +}; + +// 22.4.1 and 22.4.1.3, ctype: +class ctype_base; +template <class charT> class ctype; +template <> class ctype<char>; // specialization +template <class charT> class ctype_byname; +template <> class ctype_byname<char>; // specialization + +class codecvt_base; +template <class internT, class externT, class stateT> class codecvt; +template <class internT, class externT, class stateT> class codecvt_byname; + +// 22.4.2 and 22.4.3, numeric: +template <class charT, class InputIterator> class num_get; +template <class charT, class OutputIterator> class num_put; +template <class charT> class numpunct; +template <class charT> class numpunct_byname; + +// 22.4.4, col lation: +template <class charT> class collate; +template <class charT> class collate_byname; + +// 22.4.5, date and time: +class time_base; +template <class charT, class InputIterator> class time_get; +template <class charT, class InputIterator> class time_get_byname; +template <class charT, class OutputIterator> class time_put; +template <class charT, class OutputIterator> class time_put_byname; + +// 22.4.6, money: +class money_base; +template <class charT, class InputIterator> class money_get; +template <class charT, class OutputIterator> class money_put; +template <class charT, bool Intl> class moneypunct; +template <class charT, bool Intl> class moneypunct_byname; + +// 22.4.7, message retrieval: +class messages_base; +template <class charT> class messages; +template <class charT> class messages_byname; + +} // std + +*/ + +#include <__config> +#include <__locale> +#include <algorithm> +#include <memory> +#include <ios> +#include <streambuf> +#include <iterator> +#include <limits> +#if !__APPLE__ +#include <cstdarg> +#endif +#include <cstdlib> +#include <ctime> +#include <nl_types.h> + +#pragma GCC system_header + +_LIBCPP_BEGIN_NAMESPACE_STD + +// OSX has nice foo_l() functions that let you turn off use of the global +// locale. Linux, not so much. The following functions avoid the locale when +// that's possible and otherwise do the wrong thing. FIXME. +#if __APPLE__ + +template <class _Tp> +inline _LIBCPP_INLINE_VISIBILITY +int +__nolocale_sprintf(char* __restrict __str, + const char* __restrict __format, _Tp __v) +{ + return sprintf_l(__str, 0, __format, __v); +} + +template <class _Tp> +inline _LIBCPP_INLINE_VISIBILITY +int +__nolocale_snprintf(char* __restrict __str, size_t __size, + const char* __restrict __format, _Tp __v) +{ + return snprintf_l(__str, __size, 0, __format, __v); +} + +template <class _Tp> +inline _LIBCPP_INLINE_VISIBILITY +int +__nolocale_snprintf(char* __restrict __str, size_t __size, + const char* __restrict __format, int __prec, _Tp __v) +{ + return snprintf_l(__str, __size, 0, __format, __prec, __v); +} + +template <class _Tp> +inline _LIBCPP_INLINE_VISIBILITY +int +__nolocale_asprintf(char** __ret, const char* __restrict __format, _Tp __v) +{ + return asprintf_l(__ret, 0, __format, __v); +} + +template <class _Tp> +inline _LIBCPP_INLINE_VISIBILITY +int +__nolocale_asprintf(char** __ret, const char* __restrict __format, int __prec, + _Tp __v) +{ + return asprintf_l(__ret, 0, __format, __prec, __v); +} + +template <class _Tp> +inline _LIBCPP_INLINE_VISIBILITY +int +__nolocale_sscanf(const char* __restrict __str, + const char* __restrict __format, _Tp* __v) +{ + return sscanf_l(__str, 0, __format, __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +__nolocale_isxdigit(int __c) +{ + return isxdigit_l(__c, 0); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +__nolocale_isdigit(int __c) +{ + return isdigit_l(__c, 0); +} + +#else // __APPLE__ +inline +#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS +_LIBCPP_INLINE_VISIBILITY +#endif +int +__nolocale_sprintf(char* __restrict __str, + const char* __restrict __format, ...) +{ + va_list __ap; + va_start(__ap, __format); + int __result = vsprintf(__str, __format, __ap); + va_end(__ap); + return __result; +} +inline +#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS +_LIBCPP_INLINE_VISIBILITY +#endif +int +__nolocale_snprintf(char* __restrict __str, size_t __size, + const char* __restrict __format, ...) +{ + va_list __ap; + va_start(__ap, __format); + int __result = vsnprintf(__str, __size, __format, __ap); + va_end(__ap); + return __result; +} +inline +#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS +_LIBCPP_INLINE_VISIBILITY +#endif +int +__nolocale_asprintf(char** __ret, + const char* __restrict __format, ...) +{ + va_list __ap; + va_start(__ap, __format); + int __result = vasprintf(__ret, __format, __ap); + va_end(__ap); + return __result; +} +inline +#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS +_LIBCPP_INLINE_VISIBILITY +#endif +int +__nolocale_sscanf(const char* __restrict __str, + const char* __restrict __format, ...) +{ + va_list __ap; + va_start(__ap, __format); + int __result = vsscanf(__str, __format, __ap); + va_end(__ap); + return __result; +} +inline _LIBCPP_INLINE_VISIBILITY +int +__nolocale_isxdigit(int __c) +{ + return isxdigit(__c); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +__nolocale_isdigit(int __c) +{ + return isdigit(__c); +} +#endif // __APPLE__ + +// __scan_keyword +// Scans [__b, __e) until a match is found in the basic_strings range +// [__kb, __ke) or until it can be shown that there is no match in [__kb, __ke). +// __b will be incremented (visibly), consuming CharT until a match is found +// or proved to not exist. A keyword may be "", in which will match anything. +// If one keyword is a prefix of another, and the next CharT in the input +// might match another keyword, the algorithm will attempt to find the longest +// matching keyword. If the longer matching keyword ends up not matching, then +// no keyword match is found. If no keyword match is found, __ke is returned +// and failbit is set in __err. +// Else an iterator pointing to the matching keyword is found. If more than +// one keyword matches, an iterator to the first matching keyword is returned. +// If on exit __b == __e, eofbit is set in __err. If __case_senstive is false, +// __ct is used to force to lower case before comparing characters. +// Examples: +// Keywords: "a", "abb" +// If the input is "a", the first keyword matches and eofbit is set. +// If the input is "abc", no match is found and "ab" are consumed. +template <class _InputIterator, class _ForwardIterator, class _Ctype> +_LIBCPP_HIDDEN +_ForwardIterator +__scan_keyword(_InputIterator& __b, _InputIterator __e, + _ForwardIterator __kb, _ForwardIterator __ke, + const _Ctype& __ct, ios_base::iostate& __err, + bool __case_sensitive = true) +{ + typedef typename iterator_traits<_InputIterator>::value_type _CharT; + size_t __nkw = _STD::distance(__kb, __ke); + const unsigned char __doesnt_match = '\0'; + const unsigned char __might_match = '\1'; + const unsigned char __does_match = '\2'; + unsigned char __statbuf[100]; + unsigned char* __status = __statbuf; + unique_ptr<unsigned char, void(*)(void*)> __stat_hold(0, free); + if (__nkw > sizeof(__statbuf)) + { + __status = (unsigned char*)malloc(__nkw); + if (__status == 0) + __throw_bad_alloc(); + __stat_hold.reset(__status); + } + size_t __n_might_match = __nkw; // At this point, any keyword might match + size_t __n_does_match = 0; // but none of them definitely do + // Initialize all statuses to __might_match, except for "" keywords are __does_match + unsigned char* __st = __status; + for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, ++__st) + { + if (!__ky->empty()) + *__st = __might_match; + else + { + *__st = __does_match; + --__n_might_match; + ++__n_does_match; + } + } + // While there might be a match, test keywords against the next CharT + for (size_t __indx = 0; __b != __e && __n_might_match > 0; ++__indx) + { + // Peek at the next CharT but don't consume it + _CharT __c = *__b; + if (!__case_sensitive) + __c = __ct.toupper(__c); + bool __consume = false; + // For each keyword which might match, see if the __indx character is __c + // If a match if found, consume __c + // If a match is found, and that is the last character in the keyword, + // then that keyword matches. + // If the keyword doesn't match this character, then change the keyword + // to doesn't match + __st = __status; + for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, ++__st) + { + if (*__st == __might_match) + { + _CharT __kc = (*__ky)[__indx]; + if (!__case_sensitive) + __kc = __ct.toupper(__kc); + if (__c == __kc) + { + __consume = true; + if (__ky->size() == __indx+1) + { + *__st = __does_match; + --__n_might_match; + ++__n_does_match; + } + } + else + { + *__st = __doesnt_match; + --__n_might_match; + } + } + } + // consume if we matched a character + if (__consume) + { + ++__b; + // If we consumed a character and there might be a matched keyword that + // was marked matched on a previous iteration, then such keywords + // which are now marked as not matching. + if (__n_might_match + __n_does_match > 1) + { + __st = __status; + for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, ++__st) + { + if (*__st == __does_match && __ky->size() != __indx+1) + { + *__st = __doesnt_match; + --__n_does_match; + } + } + } + } + } + // We've exited the loop because we hit eof and/or we have no more "might matches". + if (__b == __e) + __err |= ios_base::eofbit; + // Return the first matching result + for (__st = __status; __kb != __ke; ++__kb, ++__st) + if (*__st == __does_match) + break; + if (__kb == __ke) + __err |= ios_base::failbit; + return __kb; +} + +struct __num_get_base +{ + static const int __num_get_buf_sz = 40; + + static int __get_base(ios_base&); + static const char __src[33]; +}; + +void __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end, + ios_base::iostate& __err); + +template <class _CharT> +struct __num_get + : protected __num_get_base +{ + static string __stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep); + static string __stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point, + _CharT& __thousands_sep); + static int __stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end, + unsigned& __dc, _CharT __thousands_sep, const string& __grouping, + unsigned* __g, unsigned*& __g_end, _CharT* __atoms); + static int __stage2_float_loop(_CharT __ct, bool& __in_units, char& __exp, + char* __a, char*& __a_end, + _CharT __decimal_point, _CharT __thousands_sep, + const string& __grouping, unsigned* __g, + unsigned*& __g_end, unsigned& __dc, _CharT* __atoms); +}; + +template <class _CharT> +string +__num_get<_CharT>::__stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep) +{ + locale __loc = __iob.getloc(); + use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 26, __atoms); + const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); + __thousands_sep = __np.thousands_sep(); + return __np.grouping(); +} + +template <class _CharT> +string +__num_get<_CharT>::__stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point, + _CharT& __thousands_sep) +{ + locale __loc = __iob.getloc(); + use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 32, __atoms); + const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); + __decimal_point = __np.decimal_point(); + __thousands_sep = __np.thousands_sep(); + return __np.grouping(); +} + +template <class _CharT> +int +__num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end, + unsigned& __dc, _CharT __thousands_sep, const string& __grouping, + unsigned* __g, unsigned*& __g_end, _CharT* __atoms) +{ + if (__ct == __thousands_sep && __grouping.size() != 0) + { + if (__g_end-__g < __num_get_buf_sz) + { + *__g_end++ = __dc; + __dc = 0; + } + return 0; + } + ptrdiff_t __f = find(__atoms, __atoms + 26, __ct) - __atoms; + if (__f >= 26) + return -1; + if (__a_end-__a < __num_get_buf_sz - 1) + *__a_end++ = __src[__f]; + switch (__base) + { + case 8: + case 10: + if (__f >= __base) + return 0; + break; + default: + if (__f >= 22) + return 0; + break; + } + ++__dc; + return 0; +} + +template <class _CharT> +int +__num_get<_CharT>::__stage2_float_loop(_CharT __ct, bool& __in_units, char& __exp, char* __a, char*& __a_end, + _CharT __decimal_point, _CharT __thousands_sep, const string& __grouping, + unsigned* __g, unsigned*& __g_end, unsigned& __dc, _CharT* __atoms) +{ + if (__ct == __decimal_point) + { + if (!__in_units) + return -1; + __in_units = false; + *__a_end++ = '.'; + if (__grouping.size() != 0 && __g_end-__g < __num_get_buf_sz) + *__g_end++ = __dc; + return 0; + } + if (__ct == __thousands_sep && __grouping.size() != 0) + { + if (!__in_units) + return -1; + if (__g_end-__g < __num_get_buf_sz) + { + *__g_end++ = __dc; + __dc = 0; + } + return 0; + } + ptrdiff_t __f = find(__atoms, __atoms + 32, __ct) - __atoms; + if (__f >= 32) + return -1; + char __x = __src[__f]; + if (__a_end-__a < __num_get_buf_sz - 1) + *__a_end++ = __x; + if (__x == 'x' || __x == 'X') + __exp = 'P'; + else if ((__x & 0xDF) == __exp) + { + __in_units = false; + if (__grouping.size() != 0 && __g_end-__g < __num_get_buf_sz) + *__g_end++ = __dc; + } + if (__f >= 22) + return 0; + ++__dc; + return 0; +} + +extern template class __num_get<char>; +extern template class __num_get<wchar_t>; + +template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > +class _LIBCPP_VISIBLE num_get + : public locale::facet, + private __num_get<_CharT> +{ +public: + typedef _CharT char_type; + typedef _InputIterator iter_type; + + _LIBCPP_ALWAYS_INLINE + explicit num_get(size_t __refs = 0) + : locale::facet(__refs) {} + + _LIBCPP_ALWAYS_INLINE + iter_type get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, bool& __v) const + { + return do_get(__b, __e, __iob, __err, __v); + } + + _LIBCPP_ALWAYS_INLINE + iter_type get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, long& __v) const + { + return do_get(__b, __e, __iob, __err, __v); + } + + _LIBCPP_ALWAYS_INLINE + iter_type get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, long long& __v) const + { + return do_get(__b, __e, __iob, __err, __v); + } + + _LIBCPP_ALWAYS_INLINE + iter_type get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, unsigned short& __v) const + { + return do_get(__b, __e, __iob, __err, __v); + } + + _LIBCPP_ALWAYS_INLINE + iter_type get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, unsigned int& __v) const + { + return do_get(__b, __e, __iob, __err, __v); + } + + _LIBCPP_ALWAYS_INLINE + iter_type get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, unsigned long& __v) const + { + return do_get(__b, __e, __iob, __err, __v); + } + + _LIBCPP_ALWAYS_INLINE + iter_type get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, unsigned long long& __v) const + { + return do_get(__b, __e, __iob, __err, __v); + } + + _LIBCPP_ALWAYS_INLINE + iter_type get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, float& __v) const + { + return do_get(__b, __e, __iob, __err, __v); + } + + _LIBCPP_ALWAYS_INLINE + iter_type get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, double& __v) const + { + return do_get(__b, __e, __iob, __err, __v); + } + + _LIBCPP_ALWAYS_INLINE + iter_type get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, long double& __v) const + { + return do_get(__b, __e, __iob, __err, __v); + } + + _LIBCPP_ALWAYS_INLINE + iter_type get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, void*& __v) const + { + return do_get(__b, __e, __iob, __err, __v); + } + + static locale::id id; + +protected: + _LIBCPP_ALWAYS_INLINE + ~num_get() {} + + virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, bool& __v) const; + virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, long& __v) const; + virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, long long& __v) const; + virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, unsigned short& __v) const; + virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, unsigned int& __v) const; + virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, unsigned long& __v) const; + virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, unsigned long long& __v) const; + virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, float& __v) const; + virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, double& __v) const; + virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, long double& __v) const; + virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, + ios_base::iostate& __err, void*& __v) const; +}; + +template <class _CharT, class _InputIterator> +locale::id +num_get<_CharT, _InputIterator>::id; + +template <class _Tp> +_Tp +__num_get_signed_integral(const char* __a, const char* __a_end, + ios_base::iostate& __err, int __base) +{ + if (__a != __a_end) + { + char *__p2; + long long __ll = strtoll_l(__a, &__p2, __base, 0); + if (__p2 != __a_end) + { + __err = ios_base::failbit; + return 0; + } + else if (__ll > numeric_limits<_Tp>::max()) + { + __err = ios_base::failbit; + return numeric_limits<_Tp>::max(); + } + else if (__ll < numeric_limits<_Tp>::min()) + { + __err = ios_base::failbit; + return numeric_limits<_Tp>::min(); + } + return static_cast<_Tp>(__ll); + } + __err = ios_base::failbit; + return 0; +} + +template <class _Tp> +_Tp +__num_get_unsigned_integral(const char* __a, const char* __a_end, + ios_base::iostate& __err, int __base) +{ + if (__a != __a_end) + { + char *__p2; + unsigned long long __ll = strtoull_l(__a, &__p2, __base, 0); + if (__p2 != __a_end) + { + __err = ios_base::failbit; + return 0; + } + else if (__ll > numeric_limits<_Tp>::max()) + { + __err = ios_base::failbit; + return numeric_limits<_Tp>::max(); + } + return static_cast<_Tp>(__ll); + } + __err = ios_base::failbit; + return 0; +} + +template <class _Tp> +_Tp +__num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err) +{ + if (__a != __a_end) + { + char *__p2; + long double __ld = strtold_l(__a, &__p2, 0); + if (__p2 != __a_end) + { + __err = ios_base::failbit; + return 0; + } + return static_cast<_Tp>(__ld); + } + __err = ios_base::failbit; + return 0; +} + +template <class _CharT, class _InputIterator> +_InputIterator +num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, + ios_base& __iob, + ios_base::iostate& __err, + bool& __v) const +{ + if ((__iob.flags() & ios_base::boolalpha) == 0) + { + long __lv = -1; + __b = do_get(__b, __e, __iob, __err, __lv); + switch (__lv) + { + case 0: + __v = false; + break; + case 1: + __v = true; + break; + default: + __v = true; + __err = ios_base::failbit; + break; + } + return __b; + } + const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__iob.getloc()); + const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__iob.getloc()); + typedef typename numpunct<_CharT>::string_type string_type; + const string_type __names[2] = {__np.truename(), __np.falsename()}; + const string_type* __i = __scan_keyword(__b, __e, __names, __names+2, + __ct, __err); + __v = __i == __names; + return __b; +} + +template <class _CharT, class _InputIterator> +_InputIterator +num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, + ios_base& __iob, + ios_base::iostate& __err, + long& __v) const +{ + // Stage 1 + int __base = this->__get_base(__iob); + // Stage 2 + char_type __atoms[26]; + char_type __thousands_sep; + string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); + char __a[__num_get_base::__num_get_buf_sz] = {0}; + char* __a_end = __a; + unsigned __g[__num_get_base::__num_get_buf_sz]; + unsigned* __g_end = __g; + unsigned __dc = 0; + for (; __b != __e; ++__b) + if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, + __thousands_sep, __grouping, __g, __g_end, + __atoms)) + break; + if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) + *__g_end++ = __dc; + // Stage 3 + __v = __num_get_signed_integral<long>(__a, __a_end, __err, __base); + // Digit grouping checked + __check_grouping(__grouping, __g, __g_end, __err); + // EOF checked + if (__b == __e) + __err |= ios_base::eofbit; + return __b; +} + +template <class _CharT, class _InputIterator> +_InputIterator +num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, + ios_base& __iob, + ios_base::iostate& __err, + long long& __v) const +{ + // Stage 1 + int __base = this->__get_base(__iob); + // Stage 2 + char_type __atoms[26]; + char_type __thousands_sep; + string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); + char __a[__num_get_base::__num_get_buf_sz] = {0}; + char* __a_end = __a; + unsigned __g[__num_get_base::__num_get_buf_sz]; + unsigned* __g_end = __g; + unsigned __dc = 0; + for (; __b != __e; ++__b) + if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, + __thousands_sep, __grouping, __g, __g_end, + __atoms)) + break; + if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) + *__g_end++ = __dc; + // Stage 3 + __v = __num_get_signed_integral<long long>(__a, __a_end, __err, __base); + // Digit grouping checked + __check_grouping(__grouping, __g, __g_end, __err); + // EOF checked + if (__b == __e) + __err |= ios_base::eofbit; + return __b; +} + +template <class _CharT, class _InputIterator> +_InputIterator +num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, + ios_base& __iob, + ios_base::iostate& __err, + unsigned short& __v) const +{ + // Stage 1 + int __base = this->__get_base(__iob); + // Stage 2 + char_type __atoms[26]; + char_type __thousands_sep; + string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); + char __a[__num_get_base::__num_get_buf_sz] = {0}; + char* __a_end = __a; + unsigned __g[__num_get_base::__num_get_buf_sz]; + unsigned* __g_end = __g; + unsigned __dc = 0; + for (; __b != __e; ++__b) + if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, + __thousands_sep, __grouping, __g, __g_end, + __atoms)) + break; + if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) + *__g_end++ = __dc; + // Stage 3 + __v = __num_get_unsigned_integral<unsigned short>(__a, __a_end, __err, __base); + // Digit grouping checked + __check_grouping(__grouping, __g, __g_end, __err); + // EOF checked + if (__b == __e) + __err |= ios_base::eofbit; + return __b; +} + +template <class _CharT, class _InputIterator> +_InputIterator +num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, + ios_base& __iob, + ios_base::iostate& __err, + unsigned int& __v) const +{ + // Stage 1 + int __base = this->__get_base(__iob); + // Stage 2 + char_type __atoms[26]; + char_type __thousands_sep; + string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); + char __a[__num_get_base::__num_get_buf_sz] = {0}; + char* __a_end = __a; + unsigned __g[__num_get_base::__num_get_buf_sz]; + unsigned* __g_end = __g; + unsigned __dc = 0; + for (; __b != __e; ++__b) + if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, + __thousands_sep, __grouping, __g, __g_end, + __atoms)) + break; + if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) + *__g_end++ = __dc; + // Stage 3 + __v = __num_get_unsigned_integral<unsigned int>(__a, __a_end, __err, __base); + // Digit grouping checked + __check_grouping(__grouping, __g, __g_end, __err); + // EOF checked + if (__b == __e) + __err |= ios_base::eofbit; + return __b; +} + +template <class _CharT, class _InputIterator> +_InputIterator +num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, + ios_base& __iob, + ios_base::iostate& __err, + unsigned long& __v) const +{ + // Stage 1 + int __base = this->__get_base(__iob); + // Stage 2 + char_type __atoms[26]; + char_type __thousands_sep; + string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); + char __a[__num_get_base::__num_get_buf_sz] = {0}; + char* __a_end = __a; + unsigned __g[__num_get_base::__num_get_buf_sz]; + unsigned* __g_end = __g; + unsigned __dc = 0; + for (; __b != __e; ++__b) + if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, + __thousands_sep, __grouping, __g, __g_end, + __atoms)) + break; + if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) + *__g_end++ = __dc; + // Stage 3 + __v = __num_get_unsigned_integral<unsigned long>(__a, __a_end, __err, __base); + // Digit grouping checked + __check_grouping(__grouping, __g, __g_end, __err); + // EOF checked + if (__b == __e) + __err |= ios_base::eofbit; + return __b; +} + +template <class _CharT, class _InputIterator> +_InputIterator +num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, + ios_base& __iob, + ios_base::iostate& __err, + unsigned long long& __v) const +{ + // Stage 1 + int __base = this->__get_base(__iob); + // Stage 2 + char_type __atoms[26]; + char_type __thousands_sep; |