+2002-07-30 Benjamin Kosnik <bkoz@redhat.com>
+ Gabriel Dos Reis <gdr@nerim.net>
+
+ * include/bits/char_traits.h: Remove generic definitions.
+ * include/bits/streambuf_iterator.h (istreambuf_iterator): Use
+ eof, not -2.
+ * include/bits/istream.tcc (istream::readsome): Don't check
+ against eof, instead use constants.
+ (istream::sync): Same.
+ (istream::sentry::sentry): Use eq_int_type.
+ (istream::get): Same.
+ * include/bits/ostream.tcc: Change __pad to
+ __pad<_CharT, _Traits>::_S_pad.
+ * include/bits/locale_facets.h: Add __pad_traits generic and
+ ostreambuf_iterator specialization.
+ * include/bits/locale_facets.tcc: Change __pad into struct __pad
+ with a _CharT and _Traits template parameter and _S_pad static
+ member function.
+ * src/locale-inst.cc: Update __pad instantiations.
+
+ * include/std/std_fstream.h: Declare _M_underflow_common
+ specializations.
+ * src/fstream.cc: New. Add _M_underflow_common specializations.
+ * include/bits/fstream.tcc (filebuf::close): Use traits_type.
+ (filebuf::_M_underflow_common(bool)): Remove generic version, as
+ sys_ungetc and custom int_types don't get along.
+ * include/std/std_streambuf.h: Add _M_pos.
+ * src/Makefile.am (sources): Add fstream.cc.
+ * src/Makefile.in: Regenerate.
+
+ * testsuite/21_strings/capacity.cc: Add char_traits specializations.
+ * testsuite/22_locale/codecvt_members_unicode_char.cc: Same.
+ * testsuite/22_locale/codecvt_members_unicode_wchar_t.cc: Same.
+ * testsuite/22_locale/ctor_copy_dtor.cc: Same.
+ * testsuite/27_io/filebuf_virtuals.cc (test07): Move to...
+ * testsuite/27_io/filebuf.cc: ...here.
+ * testsuite/testsuite_hooks.h: Add gnu_char, gnu_int, char_traits
+ specialization for both.
+ * testsuite/27_io/streambuf.cc: Add instantiation test,
+ testsuite_hooks include.
+ * testsuite/27_io/istream.cc: Same.
+ * testsuite/27_io/ostream.cc: Same.
+ * testsuite/27_io/fstream.cc: Same.
+ * testsuite/27_io/stringstream.cc: Same.
+ * testsuite/27_io/filebuf.cc: Same.
+ * testsuite/27_io/stringbuf.cc: Same.
+
2002-07-29 Alan Modra <amodra@bigpond.net.au>
* config/cpu/powerpc/cpu_limits.h (__glibcpp_long_bits): Define.
// Character Traits for use by standard string and iostream -*- C++ -*-
-// Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
+// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
struct char_traits
{
typedef _CharT char_type;
- // Unsigned as wint_t in unsigned.
+ // Unsigned as wint_t is unsigned.
typedef unsigned long int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
static void
- assign(char_type& __c1, const char_type& __c2)
- { __c1 = __c2; }
+ assign(char_type& __c1, const char_type& __c2);
static bool
- eq(const char_type& __c1, const char_type& __c2)
- { return __c1 == __c2; }
+ eq(const char_type& __c1, const char_type& __c2);
static bool
- lt(const char_type& __c1, const char_type& __c2)
- { return __c1 < __c2; }
+ lt(const char_type& __c1, const char_type& __c2);
static int
- compare(const char_type* __s1, const char_type* __s2, size_t __n)
- {
- for (size_t __i = 0; __i < __n; ++__i)
- if (!eq(__s1[__i], __s2[__i]))
- return lt(__s1[__i], __s2[__i]) ? -1 : 1;
- return 0;
- }
+ compare(const char_type* __s1, const char_type* __s2, size_t __n);
static size_t
- length(const char_type* __s)
- {
- const char_type* __p = __s;
- while (*__p) ++__p;
- return (__p - __s);
- }
+ length(const char_type* __s);
static const char_type*
- find(const char_type* __s, size_t __n, const char_type& __a)
- {
- for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
- if (*__p == __a) return __p;
- return 0;
- }
+ find(const char_type* __s, size_t __n, const char_type& __a);
static char_type*
- move(char_type* __s1, const char_type* __s2, size_t __n)
- { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); }
+ move(char_type* __s1, const char_type* __s2, size_t __n);
static char_type*
- copy(char_type* __s1, const char_type* __s2, size_t __n)
- { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); }
+ copy(char_type* __s1, const char_type* __s2, size_t __n);
static char_type*
- assign(char_type* __s, size_t __n, char_type __a)
- {
- for (char_type* __p = __s; __p < __s + __n; ++__p)
- assign(*__p, __a);
- return __s;
- }
+ assign(char_type* __s, size_t __n, char_type __a);
static char_type
- to_char_type(const int_type& __c)
- { return char_type(__c); }
+ to_char_type(const int_type& __c);
static int_type
- to_int_type(const char_type& __c) { return int_type(__c); }
+ to_int_type(const char_type& __c);
static bool
- eq_int_type(const int_type& __c1, const int_type& __c2)
- { return __c1 == __c2; }
+ eq_int_type(const int_type& __c1, const int_type& __c2);
static int_type
- eof() { return static_cast<int_type>(-1); }
+ eof();
static int_type
- not_eof(const int_type& __c)
- { return eq_int_type(__c, eof()) ? int_type(0) : __c; }
+ not_eof(const int_type& __c);
};
bool
operator!=(const fpos& __pos) const
{ return _M_off != __pos._M_off; }
-
+
streamoff
_M_position() const { return _M_off; }
{
const int_type __eof = traits_type::eof();
bool __testput = _M_out_cur && _M_out_beg < _M_out_end;
- if (__testput && _M_really_overflow(__eof) == __eof)
+ if (__testput
+ && traits_type::eq_int_type(_M_really_overflow(__eof), __eof))
return __ret;
// NB: Do this here so that re-opened filebufs will be cool...
_M_last_overflowed = false;
return __ret;
}
-
- template<typename _CharT, typename _Traits>
- typename basic_filebuf<_CharT, _Traits>::int_type
- basic_filebuf<_CharT, _Traits>::
- _M_underflow_common(bool __bump)
- {
- int_type __ret = traits_type::eof();
- bool __testin = _M_mode & ios_base::in;
- bool __testout = _M_mode & ios_base::out;
-
- if (__testin)
- {
- // Check for pback madness, and if so swich back to the
- // normal buffers and jet outta here before expensive
- // fileops happen...
- if (_M_pback_init)
- {
- _M_pback_destroy();
- if (_M_in_cur < _M_in_end)
- return traits_type::to_int_type(*_M_in_cur);
- }
-
- // Sync internal and external buffers.
- // NB: __testget -> __testput as _M_buf_unified here.
- bool __testget = _M_in_cur && _M_in_beg < _M_in_cur;
- bool __testinit = _M_is_indeterminate();
- if (__testget)
- {
- if (__testout)
- _M_really_overflow();
- else if (_M_in_cur != _M_filepos)
- _M_file.seekoff(_M_in_cur - _M_filepos,
- ios_base::cur, ios_base::in);
- }
-
- if (__testinit || __testget)
- {
- const locale __loc = this->getloc();
- const __codecvt_type& __cvt = use_facet<__codecvt_type>(__loc);
-
- streamsize __elen = 0;
- streamsize __ilen = 0;
- if (__cvt.always_noconv())
- {
- __elen = _M_file.xsgetn(reinterpret_cast<char*>(_M_in_beg),
- _M_buf_size);
- __ilen = __elen;
- }
- else
- {
- char* __buf = static_cast<char*>(__builtin_alloca(_M_buf_size));
- __elen = _M_file.xsgetn(__buf, _M_buf_size);
-
- const char* __eend;
- char_type* __iend;
- __res_type __r = __cvt.in(_M_state_cur, __buf,
- __buf + __elen, __eend, _M_in_beg,
- _M_in_beg + _M_buf_size, __iend);
- if (__r == codecvt_base::ok)
- __ilen = __iend - _M_in_beg;
- else
- {
- // Unwind.
- __ilen = 0;
- _M_file.seekoff(-__elen, ios_base::cur, ios_base::in);
- }
- }
-
- if (0 < __ilen)
- {
- _M_set_determinate(__ilen);
- if (__testout)
- _M_out_cur = _M_in_cur;
- __ret = traits_type::to_int_type(*_M_in_cur);
- if (__bump)
- _M_in_cur_move(1);
- else if (_M_buf_size == 1)
- {
- // If we are synced with stdio, we have to unget the
- // character we just read so that the file pointer
- // doesn't move.
- _M_file.sys_ungetc(*_M_in_cur);
- _M_set_indeterminate();
- }
- }
- }
- }
- _M_last_overflowed = false;
- return __ret;
- }
template<typename _CharT, typename _Traits>
typename basic_filebuf<_CharT, _Traits>::int_type
__int_type __c = __sb->sgetc();
if (__in._M_check_facet(__in._M_fctype))
- while (__c != __eof
- && __in._M_fctype->is(ctype_base::space, __c))
+ while (!traits_type::eq_int_type(__c, __eof)
+ && __in._M_fctype->is(ctype_base::space,
+ traits_type::to_char_type(__c)))
__c = __sb->snextc();
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
//195. Should basic_istream::sentry's constructor ever set eofbit?
- if (__c == __eof)
+ if (traits_type::eq_int_type(__c, __eof))
__in.setstate(ios_base::eofbit);
#endif
}
{
__c = this->rdbuf()->sbumpc();
// 27.6.1.1 paragraph 3
- if (__c != __eof)
+ if (!traits_type::eq_int_type(__c, __eof))
_M_gcount = 1;
else
this->setstate(ios_base::eofbit | ios_base::failbit);
const int_type __eof = traits_type::eof();
int_type __bufval = this->rdbuf()->sbumpc();
// 27.6.1.1 paragraph 3
- if (__bufval != __eof)
+ if (!traits_type::eq_int_type(__bufval, __eof))
{
_M_gcount = 1;
__c = traits_type::to_char_type(__bufval);
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
- while (_M_gcount + 1 < __n && __c != __eof && __c != __idelim)
+ while (_M_gcount + 1 < __n
+ && !traits_type::eq_int_type(__c, __eof)
+ && !traits_type::eq_int_type(__c, __idelim))
{
*__s++ = traits_type::to_char_type(__c);
__c = __sb->snextc();
++_M_gcount;
}
- if (__c == __eof)
+ if (traits_type::eq_int_type(__c, __eof))
this->setstate(ios_base::eofbit);
}
catch(exception& __fail)
const int_type __eof = traits_type::eof();
__streambuf_type* __this_sb = this->rdbuf();
int_type __c = __this_sb->sgetc();
+ char_type __c2 = traits_type::to_char_type(__c);
- while (__c != __eof && __c != __idelim
- && (__sb.sputc(traits_type::to_char_type(__c)) != __eof))
+ while (!traits_type::eq_int_type(__c, __eof)
+ && !traits_type::eq_int_type(__c, __idelim)
+ && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
{
++_M_gcount;
__c = __this_sb->snextc();
+ __c2 = traits_type::to_char_type(__c);
}
- if (__c == __eof)
+ if (traits_type::eq_int_type(__c, __eof))
this->setstate(ios_base::eofbit);
}
catch(exception& __fail)
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
- while (_M_gcount + 1 < __n && __c != __eof && __c != __idelim)
+ while (_M_gcount + 1 < __n
+ && !traits_type::eq_int_type(__c, __eof)
+ && !traits_type::eq_int_type(__c, __idelim))
{
*__s++ = traits_type::to_char_type(__c);
__c = __sb->snextc();
++_M_gcount;
}
- if (__c == __eof)
+ if (traits_type::eq_int_type(__c, __eof))
this->setstate(ios_base::eofbit);
else
{
- if (__c == __idelim)
+ if (traits_type::eq_int_type(__c, __idelim))
{
__sb->sbumpc();
++_M_gcount;
int_type __c = __sb->sgetc();
__n = min(__n, numeric_limits<streamsize>::max());
- while (_M_gcount < __n && __c !=__eof && __c != __delim)
+ while (_M_gcount < __n
+ && !traits_type::eq_int_type(__c, __eof)
+ && !traits_type::eq_int_type(__c, __delim))
{
__c = __sb->snextc();
++_M_gcount;
}
- if (__c == __eof)
+ if (traits_type::eq_int_type(__c, __eof))
this->setstate(ios_base::eofbit);
- else if (__c == __delim)
+ else if (traits_type::eq_int_type(__c, __delim))
{
__sb->sbumpc();
++_M_gcount;
{
try
{
- const int_type __eof = traits_type::eof();
streamsize __num = this->rdbuf()->in_avail();
- if (__num != static_cast<streamsize>(__eof))
+ if (__num > 0)
{
__num = min(__num, __n);
if (__num)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
- if (!__sb || __sb->sputbackc(__c) == __eof)
+ if (!__sb
+ || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
this->setstate(ios_base::badbit);
}
catch(exception& __fail)
{
const int_type __eof = traits_type::eof();
__streambuf_type* __sb = this->rdbuf();
- if (!__sb || __eof == __sb->sungetc())
+ if (!__sb
+ || traits_type::eq_int_type(__sb->sungetc(), __eof))
this->setstate(ios_base::badbit);
}
catch(exception& __fail)
basic_istream<_CharT, _Traits>::
sync(void)
{
- int __ret = traits_type::eof();
+ int __ret = -1;
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
try
{
__streambuf_type* __sb = this->rdbuf();
- if (!__sb || __ret == __sb->pubsync())
- this->setstate(ios_base::badbit);
- else
- __ret = 0;
+ if (__sb)
+ {
+ if (__sb->pubsync() == -1)
+ this->setstate(ios_base::badbit);
+ else
+ __ret = 0;
+ }
}
catch(exception& __fail)
{
__streambuf_type* __sb = __in.rdbuf();
__int_type __c = __sb->sbumpc();
const __int_type __eof = _Traits::eof();
- __testdelim = __c == __idelim;
+ __testdelim = _Traits::eq_int_type(__c, __idelim);
- while (__extracted <= __n && __c != __eof && !__testdelim)
+ while (__extracted <= __n
+ && !_Traits::eq_int_type(__c, __eof)
+ && !__testdelim)
{
__str += _Traits::to_char_type(__c);
++__extracted;
__c = __sb->sbumpc();
- __testdelim = __c == __idelim;
+ __testdelim = _Traits::eq_int_type(__c, __idelim);
}
- if (__c == __eof)
+ if (_Traits::eq_int_type(__c, __eof))
__in.setstate(ios_base::eofbit);
}
if (!__extracted && !__testdelim)
# define _GLIBCPP_NUM_FACETS 14
#endif
+ template<typename _CharT, typename _Traits>
+ struct __pad;
+
// 22.2.1.1 Template class ctype
// Include host and configuration specific ctype enums for ctype_base.
#include <bits/ctype_base.h>
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
+
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const;
template<typename _CharT, typename _InIter>
locale::id num_get<_CharT, _InIter>::id;
+#if 0
+ // Partial specialization for istreambuf_iterator, so can use traits_type.
+ template<typename _CharT>
+ class num_get<_CharT, istreambuf_iterator<_CharT> >;
+
+ iter_type
+ _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
+ string& __xtrc) const;
+
+ iter_type
+ _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
+ string& __xtrc, int& __base) const;
+
+ virtual iter_type
+ do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
+#endif
+
template<typename _CharT, typename _OutIter>
class num_put : public locale::facet, public __num_base
{
_M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
ios_base::iostate& __err, string& __xtrc) const
{
+ typedef char_traits<_CharT> __traits_type;
const locale __loc = __io.getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
const char_type __minus = __ctype.widen('-');
int __pos = 0;
char_type __c = *__beg;
- if ((__c == __plus || __c == __minus) && __beg != __end)
+ if ((__traits_type::eq(__c, __plus) || __traits_type::eq(__c, __minus))
+ && __beg != __end)
{
__xtrc += __ctype.narrow(__c, char());
++__pos;
// Next, strip leading zeros.
const char_type __zero = __ctype.widen(_S_atoms[_M_zero]);
bool __found_zero = false;
- while (__c == __zero && __beg != __end)
+ while (__traits_type::eq(__c, __zero) && __beg != __end)
{
__c = *(++__beg);
__found_zero = true;
while (__beg != __end)
{
// Only look in digits.
- typedef char_traits<_CharT> __traits_type;
const char_type* __p = __traits_type::find(__watoms, 10, __c);
// NB: strchr returns true for __c == 0x0
- if (__p && __c)
+ if (__p && !__traits_type::eq(__c, char_type()))
{
// Try first for acceptable digit; record it if found.
++__pos;
++__sep_pos;
__c = *(++__beg);
}
- else if (__c == __sep && __check_grouping && !__found_dec)
+ else if (__traits_type::eq(__c, __sep)
+ && __check_grouping && !__found_dec)
{
// NB: Thousands separator at the beginning of a string
// is a no-no, as is two consecutive thousands separators.
break;
}
}
- else if (__c == __dec && !__found_dec)
+ else if (__traits_type::eq(__c, __dec) && !__found_dec)
{
// According to the standard, if no grouping chars are seen,
// no grouping check is applied. Therefore __found_grouping
__c = *(++__beg);
__found_dec = true;
}
- else if ((__c == __watoms[_M_e] || __c == __watoms[_M_E])
+ else if ((__traits_type::eq(__c, __watoms[_M_e])
+ || __traits_type::eq(__c, __watoms[_M_E]))
&& !__found_sci && __pos)
{
// Scientific notation.
__c = *(++__beg);
// Remove optional plus or minus sign, if they exist.
- if (__c == __plus || __c == __minus)
+ if (__traits_type::eq(__c, __plus)
+ || __traits_type::eq(__c, __minus))
{
++__pos;
__xtrc += __ctype.narrow(__c, char());
_M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
ios_base::iostate& __err, string& __xtrc, int& __base) const
{
+ typedef char_traits<_CharT> __traits_type;
const locale __loc = __io.getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
else
__base = 10;
- // First check for sign.
+ // First check for sign.
int __pos = 0;
char_type __c = *__beg;
- if ((__c == __ctype.widen('+') || __c == __ctype.widen('-'))
+ const char_type __plus = __ctype.widen('+');
+ const char_type __minus = __ctype.widen('-');
+
+ if ((__traits_type::eq(__c, __plus) || __traits_type::eq(__c, __minus))
&& __beg != __end)
{
__xtrc += __ctype.narrow(__c, char());
if (__base == 10)
{
bool __found_zero = false;
- while (__c == __zero && __beg != __end)
+ while (__traits_type::eq(__c, __zero) && __beg != __end)
{
__c = *(++__beg);
__found_zero = true;
++__pos;
if (__basefield == 0)
{
- if ((__c == __x || __c == __X) && __beg != __end)
+ if ((__traits_type::eq(__c, __x)
+ || __traits_type::eq(__c, __X))
+ && __beg != __end)
{
__xtrc += __ctype.narrow(__c, char());
++__pos;
}
else if (__base == 16)
{
- if (__c == __zero && __beg != __end)
+ if (__traits_type::eq(__c, __zero) && __beg != __end)
{
__xtrc += _S_atoms[_M_zero];
++__pos;
__c = *(++__beg);
- if ((__c == __x || __c == __X) && __beg != __end)
+ if ((__traits_type::eq(__c, __x) || __traits_type::eq(__c, __X))
+ && __beg != __end)
{
__xtrc += __ctype.narrow(__c, char());
++__pos;
const char_type __sep = __np.thousands_sep();
while (__beg != __end)
{
- typedef char_traits<_CharT> __traits_type;
const char_type* __p = __traits_type::find(__watoms, __len, __c);
// NB: strchr returns true for __c == 0x0
- if (__p && __c)
+ if (__p && !__traits_type::eq(__c, char_type()))
{
// Try first for acceptable digit; record it if found.
__xtrc += _S_atoms[__p - __watoms];
++__sep_pos;
__c = *(++__beg);
}
- else if (__c == __sep && __check_grouping)
+ else if (__traits_type::eq(__c, __sep) && __check_grouping)
{
// NB: Thousands separator at the beginning of a string
// is a no-no, as is two consecutive thousands separators.
// Parse bool values as alphanumeric
else
{
- typedef basic_string<_CharT> __string_type;
+ typedef char_traits<_CharT> __traits_type;
+ typedef basic_string<_CharT> __string_type;
+
locale __loc = __io.getloc();
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
const __string_type __true = __np.truename();
for (size_t __n = 0; __beg != __end; ++__n)
{
char_type __c = *__beg++;
- bool __testf = __n <= __falsen ? __c == __falses[__n] : false;
- bool __testt = __n <= __truen ? __c == __trues[__n] : false;
+ bool __testf = __n <= __falsen
+ ? __traits_type::eq(__c, __falses[__n]) : false;
+ bool __testt = __n <= __truen
+ ? __traits_type::eq(__c, __trues[__n]) : false;
if (!(__testf || __testt))
{
__err |= ios_base::failbit;
_M_widen_float(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs,
int __len) const
{
+ typedef char_traits<_CharT> __traits_type;
// [22.2.2.2.2] Stage 2, convert to char_type, using correct
// numpunct.decimal_point() values for '.' and adding grouping.
const locale __loc = __io.getloc();
// Replace decimal point.
const _CharT* __p;
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
- if (__p = char_traits<_CharT>::find(__ws, __len, __ctype.widen('.')))
+ if (__p = __traits_type::find(__ws, __len, __ctype.widen('.')))
__ws[__p - __ws] = __np.decimal_point();
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
// Tack on decimal part.
if (__p)
{
- char_traits<_CharT>::copy(__p2, __p, __len - __declen);
+ __traits_type::copy(__p2, __p, __len - __declen);
__newlen += __len - __declen;
}
_M_insert(_OutIter __s, ios_base& __io, _CharT __fill, const _CharT* __ws,
int __len) const
{
+ typedef char_traits<_CharT> __traits_type;
// [22.2.2.2.2] Stage 3.
streamsize __w = __io.width();
_CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __w));
if (__w > static_cast<streamsize>(__len))
{
- __pad(__io, __fill, __ws2, __ws, __w, __len, true);
+ __pad<_CharT, __traits_type>::_S_pad(__io, __fill, __ws2, __ws,
+ __w, __len, true);
__len = static_cast<int>(__w);
// Switch strings.
__ws = __ws2;
if ((__flags & ios_base::boolalpha) == 0)
{
unsigned long __uv = __v;
- __s = _M_convert_int(__s, __io, __fill, 'u', char_type(), __uv);
+ __s = _M_convert_int(__s, __io, __fill, 'u', char(), __uv);
}
else
{
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
- { return _M_convert_int(__s, __io, __fill, 'd', char_type(), __v); }
+ { return _M_convert_int(__s, __io, __fill, 'd', char(), __v); }
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
- { return _M_convert_int(__s, __io, __fill, 'u', char_type(), __v); }
+ { return _M_convert_int(__s, __io, __fill, 'u', char(), __v); }
#ifdef _GLIBCPP_USE_LONG_LONG
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
- { return _M_convert_float(__s, __io, __fill, char_type(), __v); }
+ { return _M_convert_float(__s, __io, __fill, char(), __v); }
template<typename _CharT, typename _OutIter>
_OutIter
__io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase));
try
{
- __s = _M_convert_int(__s, __io, __fill, 'u', char_type(),
+ __s = _M_convert_int(__s, __io, __fill, 'u', char(),
reinterpret_cast<unsigned long>(__v));
__io.flags(__flags);
}
const _CharT** __names, size_t __indexlen,
ios_base::iostate& __err) const
{
- typedef char_traits<char_type> __traits_type;
+ typedef char_traits<_CharT> __traits_type;
int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int) * __indexlen));
size_t __nmatches = 0;
size_t __pos = 0;
do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{
- typedef char_traits<char_type> __traits_type;
+ typedef char_traits<_CharT> __traits_type;
locale __loc = __io.getloc();
__timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
const char_type* __days[7];
do_get_monthname(iter_type __beg, iter_type __end,
ios_base& __io, ios_base::iostate& __err, tm* __tm) const
{
- typedef char_traits<char_type> __traits_type;
+ typedef char_traits<_CharT> __traits_type;
locale __loc = __io.getloc();
__timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
const char_type* __months[12];
// internal-adjusted objects are padded according to the rules below
// concerning 0[xX] and +-, otherwise, exactly as right-adjusted
// ones are.
+
+ // NB: Of the two parameters, _CharT can be deduced from the
+ // function arguments. The other (_Traits) has to be explicitly specified.
template<typename _CharT, typename _Traits>
- void
- __pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds,
- const streamsize __newlen, const streamsize __oldlen,
- const bool __num)
+ struct __pad
{
- typedef _CharT char_type;
- typedef _Traits traits_type;
- typedef typename traits_type::int_type int_type;
-
- int_type __plen = static_cast<size_t>(__newlen - __oldlen);
- char_type* __pads = static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __plen));
- traits_type::assign(__pads, __plen, __fill);
+ static void
+ _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
+ const _CharT* __olds, const streamsize __newlen,
+ const streamsize __oldlen, const bool __num);
+ };
- char_type* __beg;
- char_type* __end;
+ template<typename _CharT, typename _Traits>
+ void
+ __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
+ _CharT* __news, const _CharT* __olds,
+ const streamsize __newlen,
+ const streamsize __oldlen, const bool __num)
+ {
+ size_t __plen = static_cast<size_t>(__newlen - __oldlen);
+ _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __plen));
+ _Traits::assign(__pads, __plen, __fill);
+
+ _CharT* __beg;
+ _CharT* __end;
size_t __mod = 0;
size_t __beglen; //either __plen or __oldlen
ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
if (__adjust == ios_base::left)
{
// Padding last.
- __beg = const_cast<char_type*>(__olds);
+ __beg = const_cast<_CharT*>(__olds);
__beglen = __oldlen;
__end = __pads;
}
// Who came up with these rules, anyway? Jeeze.
locale __loc = __io.getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
- const char_type __minus = __ctype.widen('-');
- const char_type __plus = __ctype.widen('+');
- bool __testsign = __olds[0] == __minus || __olds[0] == __plus;
- bool __testhex = __ctype.widen('0') == __olds[0]
- && (__ctype.widen('x') == __olds[1]
- || __ctype.widen('X') == __olds[1]);
+ const _CharT __minus = __ctype.widen('-');
+ const _CharT __plus = __ctype.widen('+');
+ bool __testsign = _Traits::eq(__olds[0], __minus)
+ || _Traits::eq(__olds[0], __plus);
+
+ bool __testhex = _Traits::eq(__ctype.widen('0'), __olds[0])
+ && (_Traits::eq(__ctype.widen('x'), __olds[1])
+ || _Traits::eq(__ctype.widen('X'), __olds[1]));
if (__testhex)
{
__news[0] = __olds[0];
__news += 2;
__beg = __pads;
__beglen = __plen;
- __end = const_cast<char_type*>(__olds + __mod);
+ __end = const_cast<_CharT*>(__olds + __mod);
}
else if (__testsign)
{
- __news[0] = __olds[0] == __plus ? __plus : __minus;
+ _Traits::eq((__news[0] = __olds[0]), __plus) ? __plus : __minus;
++__mod;
++__news;
__beg = __pads;
__beglen = __plen;
- __end = const_cast<char_type*>(__olds + __mod);
+ __end = const_cast<_CharT*>(__olds + __mod);
}
else
{
// Padding first.
__beg = __pads;
__beglen = __plen;
- __end = const_cast<char_type*>(__olds);
+ __end = const_cast<_CharT*>(__olds);
}
}
else
// Padding first.
__beg = __pads;
__beglen = __plen;
- __end = const_cast<char_type*>(__olds);
+ __end = const_cast<_CharT*>(__olds);
}
- traits_type::copy(__news, __beg, __beglen);
- traits_type::copy(__news + __beglen, __end, __newlen - __beglen - __mod);
- }
-
- // NB: Can't have default argument on non-member template, and
- // num_put doesn't have a _Traits template parameter, so this
- // forwarding template adds in the default template argument.
- template<typename _CharT>
- void
- __pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds,
- const streamsize __newlen, const streamsize __oldlen,
- const bool __num)
- {
- return __pad<_CharT, char_traits<_CharT> >(__io, __fill, __news, __olds,
- __newlen, __oldlen, __num);
+ _Traits::copy(__news, __beg, __beglen);
+ _Traits::copy(__news + __beglen, __end,
+ __newlen - __beglen - __mod);
}
// Used by both numeric and monetary facets.
} // namespace std
#endif
-
-
streamsize __len = 1;
if (__w > __len)
{
- __pad(__out, __out.fill(), __pads, &__c, __w, __len, false);
+ __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
+ &__c, __w, __len, false);
__len = __w;
}
__out.write(__pads, __len);
streamsize __len = 1;
if (__w > __len)
{
- __pad(__out, __out.fill(), __pads, &__c, __w, __len, false);
+ __pad<char, _Traits>::_S_pad(__out, __out.fill(), __pads,
+ &__c, __w, __len, false);
__len = __w;
}
__out.write(__pads, __len);
streamsize __len = static_cast<streamsize>(_Traits::length(__s));
if (__w > __len)
{
- __pad(__out, __out.fill(), __pads, __s, __w, __len, false);
+ __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
+ __s, __w, __len, false);
__s = __pads;
__len = __w;
}
if (__w > __len)
{
- __pad(__out, __out.fill(), __pads, __ws, __w, __len, false);
+ __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
+ __ws, __w, __len, false);
__str = __pads;
__len = __w;
}
if (__w > __len)
{
- __pad(__out, __out.fill(), __pads, __s, __w, __len, false);
+ __pad<char, _Traits>::_S_pad(__out, __out.fill(), __pads,
+ __s, __w, __len, false);
__s = __pads;
__len = __w;
}
#endif
if (__w > __len)
{
- __pad(__out, __out.fill(), __pads, __s, __w, __len, false);
+ __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads, __s,
+ __w, __len, false);
__s = __pads;
__len = __w;
}
if (_M_buf_size)
{
- off_type __pos = __sp._M_position();
+ off_type __pos = __sp; // Use streamoff operator to do conversion.
char_type* __beg = NULL;
char_type* __end = NULL;
bool __testin = (ios_base::in & _M_mode & __mode) != 0;
public:
istreambuf_iterator() throw()
- : _M_sbuf(0), _M_c(-2) { }
+ : _M_sbuf(0), _M_c(traits_type::eof()) { }
istreambuf_iterator(istream_type& __s) throw()
- : _M_sbuf(__s.rdbuf()), _M_c(-2) { }
+ : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
istreambuf_iterator(streambuf_type* __s) throw()
- : _M_sbuf(__s), _M_c(-2) { }
+ : _M_sbuf(__s), _M_c(traits_type::eof()) { }
// NB: The result of operator*() on an end of stream is undefined.
char_type
istreambuf_iterator&
operator++()
{
- if (_M_sbuf && _M_sbuf->sbumpc() == traits_type::eof())
+ const int_type __eof = traits_type::eof();
+ if (_M_sbuf && traits_type::eq_int_type(_M_sbuf->sbumpc(), __eof))
_M_sbuf = 0;
else
- _M_c = -2;
+ _M_c = __eof;
return *this;
}
istreambuf_iterator
operator++(int)
{
+ const int_type __eof = traits_type::eof();
istreambuf_iterator __old = *this;
- if (_M_sbuf && (__old._M_c = _M_sbuf->sbumpc()) == traits_type::eof())
+ if (_M_sbuf
+ && traits_type::eq_int_type((__old._M_c = _M_sbuf->sbumpc()),
+ __eof))
_M_sbuf = 0;
else
- _M_c = -2;
+ _M_c = __eof;
return __old;
}
equal(const istreambuf_iterator& __b) const
{
const int_type __eof = traits_type::eof();
- bool __thiseof = _M_get() == __eof;
- bool __beof = __b._M_get() == __eof;
+ bool __thiseof = traits_type::eq_int_type(_M_get(), __eof);
+ bool __beof = traits_type::eq_int_type(__b._M_get(), __eof);
return (__thiseof && __beof || (!__thiseof && !__beof));
}
#endif
int_type
_M_get() const
{
- int_type __ret = traits_type::eof();
+ const int_type __eof = traits_type::eof();
+ int_type __ret = __eof;
if (_M_sbuf)
{
- if (_M_c != static_cast<int_type>(-2))
+ if (!traits_type::eq_int_type(_M_c, __eof))
__ret = _M_c;
else
- if ((__ret = _M_sbuf->sgetc()) == traits_type::eof())
+ if (traits_type::eq_int_type((__ret = _M_sbuf->sgetc()), __eof))
_M_sbuf = 0;
}
return __ret;
}
};
-
+ // Explicit specializations.
+ template<>
+ basic_filebuf<char>::int_type
+ basic_filebuf<char>::_M_underflow_common(bool __bump);
+
+ #ifdef _GLIBCPP_USE_WCHAR_T
+ template<>
+ basic_filebuf<wchar_t>::int_type
+ basic_filebuf<wchar_t>::_M_underflow_common(bool __bump);
+ #endif
// 27.8.1.5 Template class basic_ifstream
/**
// Non-standard Types:
typedef ctype<char_type> __ctype_type;
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+ typedef typename traits_type::state_type __state_type;
friend class basic_ios<char_type, traits_type>;
friend class basic_istream<char_type, traits_type>;
char_type* _M_pback_end_save;
bool _M_pback_init;
+ // Yet unused.
+ fpos<__state_type> _M_pos;
+
// Initializes pback buffers, and moves normal buffers to safety.
// Assumptions:
// _M_in_cur has already been moved back
concept-inst.cc \
ctype.cc \
ext-inst.cc \
+ fstream.cc \
fstream-inst.cc \
functexcept.cc \
globals.cc \
concept-inst.cc \
ctype.cc \
ext-inst.cc \
+ fstream.cc \
fstream-inst.cc \
functexcept.cc \
globals.cc \
LIBS = @LIBS@
libstdc___la_OBJECTS = basic_file.lo bitset.lo c++locale.lo codecvt.lo \
collate.lo complex_io.lo concept-inst.lo ctype.lo ext-inst.lo \
-fstream-inst.lo functexcept.lo globals.lo io-inst.lo ios.lo \
+fstream.lo fstream-inst.lo functexcept.lo globals.lo io-inst.lo ios.lo \
istream-inst.lo limits.lo locale-inst.lo locale.lo localename.lo \
messages.lo misc-inst.lo monetary.lo numeric.lo ostream-inst.lo \
sstream-inst.lo stdexcept.lo stl-inst.lo streambuf-inst.lo \
bool
__verify_grouping<char>(const basic_string<char>&, basic_string<char>&);
- template
- void
- __pad<char>(ios_base&, char, char*, const char *, streamsize,
- streamsize, const bool);
-
- template
- void
- __pad<char, char_traits<char> >(ios_base&, char, char*, const char *,
- streamsize, streamsize, const bool);
+ template class __pad<char, char_traits<char> >;
#ifdef _GLIBCPP_USE_WCHAR_T
template
__verify_grouping<wchar_t>(const basic_string<wchar_t>&,
basic_string<wchar_t>&);
- template
- void
- __pad<wchar_t>(ios_base&, wchar_t, wchar_t*, const wchar_t*,
- streamsize, streamsize, const bool);
-
- template
- void
- __pad<wchar_t, char_traits<wchar_t> >(ios_base&, wchar_t, wchar_t*,
- const wchar_t*, streamsize,
- streamsize, const bool);
-#endif // _GLIBCPP_USE_WCHAR_T
+ template class __pad<wchar_t, char_traits<wchar_t> >;
+#endif
template
int
- __convert_from_v(char*, const int, const char*, double, const __c_locale&, int);
+ __convert_from_v(char*, const int, const char*, double,
+ const __c_locale&, int);
template
int
- __convert_from_v(char*, const int, const char*, long double, const __c_locale&, int);
+ __convert_from_v(char*, const int, const char*, long double,
+ const __c_locale&, int);
template
int
- __convert_from_v(char*, const int, const char*, long, const __c_locale&, int);
+ __convert_from_v(char*, const int, const char*, long,
+ const __c_locale&, int);
template
int
template
int
- __convert_from_v(char*, const int, const char*, long long, const __c_locale&, int);
+ __convert_from_v(char*, const int, const char*, long long,
+ const __c_locale&, int);
template
int
struct B { };
+// char_traits specialization
+namespace std
+{
+ template<>
+ struct char_traits<A<B> >
+ {
+ typedef A<B> char_type;
+ // Unsigned as wint_t in unsigned.
+ typedef unsigned long int_type;
+ typedef streampos pos_type;
+ typedef streamoff off_type;
+ typedef mbstate_t state_type;
+
+ static void
+ assign(char_type& __c1, const char_type& __c2)
+ { __c1 = __c2; }
+
+ static bool
+ eq(const char_type& __c1, const char_type& __c2)
+ { return __c1 == __c2; }
+
+ static bool
+ lt(const char_type& __c1, const char_type& __c2)
+ { return __c1 < __c2; }
+
+ static int
+ compare(const char_type* __s1, const char_type* __s2, size_t __n)
+ {
+ for (size_t __i = 0; __i < __n; ++__i)
+ if (!eq(__s1[__i], __s2[__i]))
+ return lt(__s1[__i], __s2[__i]) ? -1 : 1;
+ return 0;
+ }
+
+ static size_t
+ length(const char_type* __s)
+ {
+ const char_type* __p = __s;
+ while (__p)
+ ++__p;
+ return (__p - __s);
+ }
+
+ static const char_type*
+ find(const char_type* __s, size_t __n, const char_type& __a)
+ {
+ for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
+ if (*__p == __a) return __p;
+ return 0;
+ }
+
+ static char_type*
+ move(char_type* __s1, const char_type* __s2, size_t __n)
+ { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); }
+
+ static char_type*
+ copy(char_type* __s1, const char_type* __s2, size_t __n)
+ { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); }
+
+ static char_type*
+ assign(char_type* __s, size_t __n, char_type __a)
+ {
+ for (char_type* __p = __s; __p < __s + __n; ++__p)
+ assign(*__p, __a);
+ return __s;
+ }
+
+ static char_type
+ to_char_type(const int_type& __c)
+ { return char_type(); }
+
+ static int_type
+ to_int_type(const char_type& __c) { return int_type(); }
+
+ static bool
+ eq_int_type(const int_type& __c1, const int_type& __c2)
+ { return __c1 == __c2; }
+
+ static int_type
+ eof() { return static_cast<int_type>(-1); }
+
+ static int_type
+ not_eof(const int_type& __c)
+ { return eq_int_type(__c, eof()) ? int_type(0) : __c; }
+ };
+} // namespace std
+
void test01()
{
// 1 POD types : resize, capacity, reserve
#include <locale>
#include <testsuite_hooks.h>
-using namespace std;
+
#ifdef _GLIBCPP_USE___ENC_TRAITS
+// Need some char_traits specializations for this to work.
+typedef unsigned short unicode_t;
+
+namespace std
+{
+ template<>
+ struct char_traits<unicode_t>
+ {
+ typedef unicode_t char_type;
+ // Unsigned as wint_t is unsigned.
+ typedef unsigned long int_type;
+ typedef streampos pos_type;
+ typedef streamoff off_type;
+ typedef mbstate_t state_type;
+
+ static void
+ assign(char_type& __c1, const char_type& __c2);
+
+ static bool
+ eq(const char_type& __c1, const char_type& __c2);
+
+ static bool
+ lt(const char_type& __c1, const char_type& __c2);
+
+ static int
+ compare(const char_type* __s1, const char_type* __s2, size_t __n)
+ { return memcmp(__s1, __s2, __n); }
+
+ static size_t
+ length(const char_type* __s);
+
+ static const char_type*
+ find(const char_type* __s, size_t __n, const char_type& __a);
+
+ static char_type*
+ move(char_type* __s1, const char_type* __s2, size_t __n);
+
+ static char_type*
+ copy(char_type* __s1, const char_type* __s2, size_t __n)
+ { return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }
+
+ static char_type*
+ assign(char_type* __s, size_t __n, char_type __a);
+
+ static char_type
+ to_char_type(const int_type& __c);
+
+ static int_type
+ to_int_type(const char_type& __c);
+
+ static bool
+ eq_int_type(const int_type& __c1, const int_type& __c2);
+
+ static int_type
+ eof();
+
+ static int_type
+ not_eof(const int_type& __c);
+ };
+}
+
/*
> how do I check that these conversions are correct?
Very easy. Since all the characters are from ASCII you simply
void
-initialize_state(__enc_traits& state)
+initialize_state(std::__enc_traits& state)
{ state._M_init(); }
// Partial specialization using __enc_traits.
// UNICODE - UCS2 (big endian)
void test01()
{
+ using namespace std;
typedef codecvt_base::result result;
- typedef unsigned short unicode_t;
typedef unicode_t int_type;
typedef char ext_type;
typedef __enc_traits enc_type;
// UNICODE - UCS2 (little endian)
void test02()
{
+ using namespace std;
typedef codecvt_base::result result;
typedef unsigned short unicode_t;
typedef unicode_t int_type;
// 2000-08-23 Benjamin Kosnik <bkoz@cygnus.com>
-// Copyright (C) 2000, 2001 Free Software Foundation
+// Copyright (C) 2000, 2001, 2002 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <locale>
#include <testsuite_hooks.h>
-using namespace std;
-
#ifdef _GLIBCPP_USE___ENC_TRAITS
#ifdef _GLIBCPP_USE_WCHAR_T
+// Need some char_traits specializations for this to work.
+typedef unsigned short unicode_t;
+
+namespace std
+{
+ template<>
+ struct char_traits<unicode_t>
+ {
+ typedef unicode_t char_type;
+ // Unsigned as wint_t is unsigned.
+ typedef unsigned long int_type;
+ typedef streampos pos_type;
+ typedef streamoff off_type;
+ typedef mbstate_t state_type;
+
+ static void
+ assign(char_type& __c1, const char_type& __c2);
+
+ static bool
+ eq(const char_type& __c1, const char_type& __c2);
+
+ static bool
+ lt(const char_type& __c1, const char_type& __c2);
+
+ static int
+ compare(const char_type* __s1, const char_type* __s2, size_t __n)
+ { return memcmp(__s1, __s2, __n); }
+
+ static size_t
+ length(const char_type* __s);
+
+ static const char_type*
+ find(const char_type* __s, size_t __n, const char_type& __a);
+
+ static char_type*
+ move(char_type* __s1, const char_type* __s2, size_t __n);
+
+ static char_type*
+ copy(char_type* __s1, const char_type* __s2, size_t __n)
+ { return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }
+
+ static char_type*
+ assign(char_type* __s, size_t __n, char_type __a);
+
+ static char_type
+ to_char_type(const int_type& __c);
+
+ static int_type
+ to_int_type(const char_type& __c);
+
+ static bool
+ eq_int_type(const int_type& __c1, const int_type& __c2);
+
+ static int_type
+ eof();
+
+ static int_type
+ not_eof(const int_type& __c);
+ };
+}
+
void
-initialize_state(__enc_traits& state)
+initialize_state(std::__enc_traits& state)
{ state._M_init(); }
// Partial specialization using __enc_traits.
// codecvt<unicode_t, wchar_t, __enc_traits>
void test01()
{
+ using namespace std;
typedef codecvt_base::result result;
- typedef unsigned short unicode_t;
typedef unicode_t int_type;
typedef wchar_t ext_type;
typedef __enc_traits enc_type;
std::locale::id gnu_facet::id;
+// Need some char_traits specializations for this to work.
+typedef unsigned short unicode_t;
+
+namespace std
+{
+ template<>
+ struct char_traits<unicode_t>
+ {
+ typedef unicode_t char_type;
+ // Unsigned as wint_t is unsigned.
+ typedef unsigned long int_type;
+ typedef streampos pos_type;
+ typedef streamoff off_type;
+ typedef mbstate_t state_type;
+
+ static void
+ assign(char_type& __c1, const char_type& __c2);
+
+ static bool
+ eq(const char_type& __c1, const char_type& __c2);
+
+ static bool
+ lt(const char_type& __c1, const char_type& __c2);
+
+ static int
+ compare(const char_type* __s1, const char_type* __s2, size_t __n)
+ { return memcmp(__s1, __s2, __n); }
+
+ static size_t
+ length(const char_type* __s);
+
+ static const char_type*
+ find(const char_type* __s, size_t __n, const char_type& __a);
+
+ static char_type*
+ move(char_type* __s1, const char_type* __s2, size_t __n);
+
+ static char_type*
+ copy(char_type* __s1, const char_type* __s2, size_t __n)
+ { return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }
+
+ static char_type*
+ assign(char_type* __s, size_t __n, char_type __a);
+
+ static char_type
+ to_char_type(const int_type& __c);
+
+ static int_type
+ to_int_type(const char_type& __c);
+
+ static bool
+ eq_int_type(const int_type& __c1, const int_type& __c2);
+
+ static int_type
+ eof();
+
+ static int_type
+ not_eof(const int_type& __c);
+ };
+}
+
void test01()
{
using namespace std;
-
- typedef unsigned short unicode_t;
typedef unicode_t int_type;
typedef char ext_type;
typedef __enc_traits enc_type;
// test05
// libstdc++/1886
// should be able to instantiate basic_filebuf for non-standard types.
-template class std::basic_filebuf<short, std::char_traits<short> >;
+namespace test
+{
+ using namespace std;
+ typedef short type_t;
+ template class basic_filebuf<type_t, char_traits<type_t> >;
+ template class basic_filebuf<gnu_char, char_traits<gnu_char> >;
+} // test
+
+
+// test07
+// libstdc++/2020
+// should be able to use custom char_type
+class gnu_char_type
+{
+ unsigned long character;
+public:
+ // operator ==
+ bool
+ operator==(const gnu_char_type& __lhs)
+ { return character == __lhs.character; }
+
+ // operator <
+ bool
+ operator<(const gnu_char_type& __lhs)
+ { return character < __lhs.character; }
+
+ // default ctor
+ gnu_char_type() { }
+
+ // to_char_type
+ gnu_char_type(const unsigned long& __l) : character(__l) { }
+
+ // to_int_type
+ operator unsigned long() const { return character; }
+};
+
+void test07()
+{
+ bool test = true;
+ typedef std::basic_filebuf<gnu_char_type> gnu_filebuf;
+
+ try
+ { gnu_filebuf obj; }
+ catch(std::exception& obj)
+ {
+ test = false;
+ VERIFY( test );
+ }
+}
+
+#if !__GXX_WEAK__
+// Explicitly instantiate for systems with no COMDAT or weak support.
+template
+ std::basic_streambuf<gnu_char_type>::int_type
+ std::basic_streambuf<gnu_char_type>::_S_pback_size;
+#endif
int main()
{
test01();
+ test07();
return 0;
}
VERIFY( buffer[0] == 'a' );
}
-// test06
-// libstdc++/2020
-// should be able to use custom char_type
-class gnu_char_type
-{
- unsigned long character;
-public:
- // operator ==
- bool
- operator==(const gnu_char_type& __lhs)
- { return character == __lhs.character; }
-
- // operator <
- bool
- operator<(const gnu_char_type& __lhs)
- { return character < __lhs.character; }
-
- // default ctor
- gnu_char_type() { }
-
- // to_char_type
- gnu_char_type(const unsigned long& __l) : character(__l) { }
-
- // to_int_type
- operator unsigned long() const { return character; }
-};
-
-void test07()
-{
- bool test = true;
- typedef std::basic_filebuf<gnu_char_type> gnu_filebuf;
-
- try
- { gnu_filebuf obj; }
- catch(std::exception& obj)
- {
- test = false;
- VERIFY( test );
- }
-}
-
-#if !__GXX_WEAK__
-// Explicitly instantiate for systems with no COMDAT or weak support.
-template
- std::basic_streambuf<gnu_char_type>::int_type
- std::basic_streambuf<gnu_char_type>::_S_pback_size;
-#endif
-
main()
{
test01();
test04();
test05();
test06();
- test07();
return 0;
}
// NB: This file is for testing basic_fstream with NO OTHER INCLUDES.
#include <fstream>
+#include <testsuite_hooks.h>
// { dg-do compile }
using namespace std;
typedef short type_t;
template class basic_fstream<type_t, char_traits<type_t> >;
+ template class basic_fstream<gnu_char, char_traits<gnu_char> >;
} // test
int main()
#include <iostream>
#include <testsuite_hooks.h>
+// char_traits specialization
+namespace std
+{
+ template<>
+ struct char_traits<unsigned short>
+ {
+ typedef unsigned short char_type;
+ // Unsigned as wint_t in unsigned.
+ typedef unsigned long int_type;
+ typedef streampos pos_type;
+ typedef streamoff off_type;
+ typedef mbstate_t state_type;
+
+ static void
+ assign(char_type& __c1, const char_type& __c2)
+ { __c1 = __c2; }
+
+ static bool
+ eq(const char_type& __c1, const char_type& __c2)
+ { return __c1 == __c2; }
+
+ static bool
+ lt(const char_type& __c1, const char_type& __c2)
+ { return __c1 < __c2; }
+
+ static int
+ compare(const char_type* __s1, const char_type* __s2, size_t __n)
+ {
+ for (size_t __i = 0; __i < __n; ++__i)
+ if (!eq(__s1[__i], __s2[__i]))
+ return lt(__s1[__i], __s2[__i]) ? -1 : 1;
+ return 0;
+ }
+
+ static size_t
+ length(const char_type* __s)
+ {
+ const char_type* __p = __s;
+ while (__p)
+ ++__p;
+ return (__p - __s);
+ }
+
+ static const char_type*
+ find(const char_type* __s, size_t __n, const char_type& __a)
+ {
+ for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
+ if (*__p == __a) return __p;
+ return 0;
+ }
+
+ static char_type*
+ move(char_type* __s1, const char_type* __s2, size_t __n)
+ { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); }
+
+ static char_type*
+ copy(char_type* __s1, const char_type* __s2, size_t __n)
+ { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); }
+
+ static char_type*
+ assign(char_type* __s, size_t __n, char_type __a)
+ {
+ for (char_type* __p = __s; __p < __s + __n; ++__p)
+ assign(*__p, __a);
+ return __s;
+ }
+
+ static char_type
+ to_char_type(const int_type& __c)
+ { return char_type(); }
+
+ static int_type
+ to_int_type(const char_type& __c) { return int_type(); }
+
+ static bool
+ eq_int_type(const int_type& __c1, const int_type& __c2)
+ { return __c1 == __c2; }
+
+ static int_type
+ eof() { return static_cast<int_type>(-1); }
+
+ static int_type
+ not_eof(const int_type& __c)
+ { return eq_int_type(__c, eof()) ? int_type(0) : __c; }
+ };
+
+ template<>
+ struct char_traits<unsigned char>
+ {
+ typedef unsigned char char_type;
+ // Unsigned as wint_t in unsigned.
+ typedef unsigned long int_type;
+ typedef streampos pos_type;
+ typedef streamoff off_type;
+ typedef mbstate_t state_type;
+
+ static void
+ assign(char_type& __c1, const char_type& __c2)
+ { __c1 = __c2; }
+
+ static bool
+ eq(const char_type& __c1, const char_type& __c2)
+ { return __c1 == __c2; }
+
+ static bool
+ lt(const char_type& __c1, const char_type& __c2)
+ { return __c1 < __c2; }
+
+ static int
+ compare(const char_type* __s1, const char_type* __s2, size_t __n)
+ {
+ for (size_t __i = 0; __i < __n; ++__i)
+ if (!eq(__s1[__i], __s2[__i]))
+ return lt(__s1[__i], __s2[__i]) ? -1 : 1;
+ return 0;
+ }
+
+ static size_t
+ length(const char_type* __s)
+ {
+ const char_type* __p = __s;
+ while (__p && *__p)
+ ++__p;
+ return (__p - __s);
+ }
+
+ static const char_type*
+ find(const char_type* __s, size_t __n, const char_type& __a)
+ {
+ for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
+ if (*__p == __a) return __p;
+ return 0;
+ }
+
+ static char_type*
+ move(char_type* __s1, const char_type* __s2, size_t __n)
+ { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); }
+
+ static char_type*
+ copy(char_type* __s1, const char_type* __s2, size_t __n)
+ { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); }
+
+ static char_type*
+ assign(char_type* __s, size_t __n, char_type __a)
+ {
+ for (char_type* __p = __s; __p < __s + __n; ++__p)
+ assign(*__p, __a);
+ return __s;
+ }
+
+ static char_type
+ to_char_type(const int_type& __c)
+ { return char_type(); }
+
+ static int_type
+ to_int_type(const char_type& __c) { return int_type(); }
+
+ static bool
+ eq_int_type(const int_type& __c1, const int_type& __c2)
+ { return __c1 == __c2; }
+
+ static int_type
+ eof() { return static_cast<int_type>(-1); }
+
+ static int_type
+ not_eof(const int_type& __c)
+ { return eq_int_type(__c, eof()) ? int_type(0) : __c; }
+ };
+} // namespace std
+
class gnu_filebuf: public std::filebuf
{
int i;
// NB: This file is for testing istream with NO OTHER INCLUDES.
#include <istream>
+#include <testsuite_hooks.h>
// { dg-do compile }
using namespace std;
typedef short type_t;
template class basic_istream<type_t, char_traits<type_t> >;
+ template class basic_istream<gnu_char, char_traits<gnu_char> >;
} // test
int main()
// NB: This file is for testing ostream with NO OTHER INCLUDES.
#include <ostream>
+#include <testsuite_hooks.h>
// { dg-do compile }
using namespace std;
typedef short type_t;
template class basic_ostream<type_t, char_traits<type_t> >;
+ template class basic_ostream<gnu_char, char_traits<gnu_char> >;
} // test
int main()
// NB: This file is for testing basic_streambuf with NO OTHER INCLUDES.
#include <streambuf>
+#include <testsuite_hooks.h>
// { dg-do compile }
using namespace std;
typedef short type_t;
template class basic_streambuf<type_t, char_traits<type_t> >;
+ template class basic_streambuf<gnu_char, char_traits<gnu_char> >;
} // test
int main()
// NB: This file is for testing basic_stringbuf with NO OTHER INCLUDES.
#include <sstream>
+#include <testsuite_hooks.h>
// { dg-do compile }
using namespace std;
typedef short type_t;
template class basic_stringbuf<type_t, char_traits<type_t> >;
+ template class basic_stringbuf<gnu_char, char_traits<gnu_char> >;
} // test
int main()
// NB: This file is for testing basic_stringstream with NO OTHER INCLUDES.
#include <sstream>
+#include <testsuite_hooks.h>
// { dg-do compile }
using namespace std;
typedef short type_t;
template class basic_stringstream<type_t, char_traits<type_t> >;
+ template class basic_stringstream<gnu_char, char_traits<gnu_char> >;
} // test
int main()
// 4) gnu_copy_tracker, from Stephen M. Webb <stephen@bregmasoft.com>.
// A class with nontrivial ctor/dtor that provides the ability to track the
// number of copy ctors and dtors, and will throw on demand during copy.
+//
+// 5) gnu_char, gnu_char_traits, abstract character classes and
+// char_traits specializations for testing instantiations.
#ifndef _GLIBCPP_TESTSUITE_HOOKS_H
#define _GLIBCPP_TESTSUITE_HOOKS_H
+#include <bits/c++config.h>
+#include <cstddef>
+
#ifdef DEBUG_ASSERT
# include <cassert>
# define VERIFY(fn) assert(fn)
# define VERIFY(fn) test &= (fn)
#endif
-#include <bits/c++config.h>
-
// Defined in GLIBCPP_CONFIGURE_TESTSUITE.
#ifndef _GLIBCPP_MEM_LIMITS
// Don't do memory limits.
static int itsDtorCount;
};
+struct gnu_char
+{
+ unsigned long c;
+};
+
+struct gnu_int
+{
+ unsigned long i;
+};
+
+struct gnu_state
+{
+ unsigned long l;
+ unsigned long l2;
+};
+
+// char_traits specialization
+namespace std
+{
+ template<class _CharT>
+ struct char_traits;
+
+ template<>
+ struct char_traits<gnu_char>
+ {
+ typedef gnu_char char_type;
+ typedef gnu_int int_type;
+ typedef long pos_type;
+ typedef unsigned long off_type;
+ typedef gnu_state state_type;
+
+ static void
+ assign(char_type& __c1, const char_type& __c2);
+
+ static bool
+ eq(const char_type& __c1, const char_type& __c2);
+
+ static bool
+ lt(const char_type& __c1, const char_type& __c2);
+
+ static int
+ compare(const char_type* __s1, const char_type* __s2, size_t __n);
+
+ static size_t
+ length(const char_type* __s);
+
+ static const char_type*
+ find(const char_type* __s, size_t __n, const char_type& __a);
+
+ static char_type*
+ move(char_type* __s1, const char_type* __s2, size_t __n);
+
+ static char_type*
+ copy(char_type* __s1, const char_type* __s2, size_t __n);
+
+ static char_type*
+ assign(char_type* __s, size_t __n, char_type __a);
+
+ static char_type
+ to_char_type(const int_type& __c);
+
+ static int_type
+ to_int_type(const char_type& __c);
+
+ static bool
+ eq_int_type(const int_type& __c1, const int_type& __c2);
+
+ static int_type
+ eof();
+
+ static int_type
+ not_eof(const int_type& __c);
+ };
+} // namespace std
#endif // _GLIBCPP_TESTSUITE_HOOKS_H
projects / thirdparty / gcc.git / commitdiff
