OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

char_traits.h: Remove generic definitions.

Browse Source 
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.

Co-Authored-By: Gabriel Dos Reis <gdr@nerim.net>

From-SVN: r55893
This commit is contained in:
Benjamin Kosnik 2002-07-31 02:47:36 +00:00 committed by Benjamin Kosnik
parent 506a61b144
commit f13a69eccf
29 changed files with 875 additions and 347 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,50 @@
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.

62
libstdc++-v3/include/bits/char_traits.h
View File

@ -1,6 +1,7 @@
// 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
@ -57,82 +58,53 @@ namespace std
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);
};

2
libstdc++-v3/include/bits/fpos.h
View File

@ -105,7 +105,7 @@ namespace std
bool
operator!=(const fpos& __pos) const
{ return _M_off != __pos._M_off; }
streamoff
_M_position() const { return _M_off; }

93
libstdc++-v3/include/bits/fstream.tcc
View File

@ -112,7 +112,8 @@ namespace std
{
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...
@ -155,96 +156,6 @@ namespace std
_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

74
libstdc++-v3/include/bits/istream.tcc
View File

@ -54,13 +54,14 @@ namespace std
__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
}
@ -521,7 +522,7 @@ namespace std
{
__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);
@ -552,7 +553,7 @@ namespace std
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);
@ -588,13 +589,15 @@ namespace std
__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)
@ -627,14 +630,17 @@ namespace std
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)
@ -667,17 +673,19 @@ namespace std
__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;
@ -717,14 +725,16 @@ namespace std
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;
@ -806,9 +816,8 @@ namespace std
{
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)
@ -843,7 +852,8 @@ namespace std
{
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)
@ -873,7 +883,8 @@ namespace std
{
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)
@ -895,7 +906,7 @@ namespace std
basic_istream<_CharT, _Traits>::
sync(void)
{
int __ret = traits_type::eof();
int __ret = -1;
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
@ -903,10 +914,13 @@ namespace std
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)
{
@ -1186,16 +1200,18 @@ namespace std
__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)

21
libstdc++-v3/include/bits/locale_facets.h
View File

@ -55,6 +55,9 @@ namespace std
# 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>
@ -652,6 +655,7 @@ namespace std
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;
@ -697,6 +701,23 @@ namespace std
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
{

164
libstdc++-v3/include/bits/locale_facets.tcc
View File

@ -94,6 +94,7 @@ namespace std
_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);
@ -103,7 +104,8 @@ namespace std
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;
@ -113,7 +115,7 @@ namespace std
// 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;
@ -141,11 +143,10 @@ namespace std
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;
@ -153,7 +154,8 @@ namespace std
++__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.
@ -169,7 +171,7 @@ namespace std
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
@ -181,7 +183,8 @@ namespace std
__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.
@ -190,7 +193,8 @@ namespace std
__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());
@ -228,6 +232,7 @@ namespace std
_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);
@ -241,10 +246,13 @@ namespace std
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());
@ -259,7 +267,7 @@ namespace std
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;
@ -270,7 +278,9 @@ namespace std
++__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;
@ -284,12 +294,13 @@ namespace std
}
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;
@ -316,11 +327,10 @@ namespace std
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];
@ -328,7 +338,7 @@ namespace std
++__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.
@ -394,7 +404,9 @@ namespace std
// 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();
@ -407,8 +419,10 @@ namespace std
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;
@ -708,6 +722,7 @@ namespace std
_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();
@ -723,7 +738,7 @@ namespace std
// 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
@ -744,7 +759,7 @@ namespace std
// Tack on decimal part.
if (__p)
{
char_traits<_CharT>::copy(__p2, __p, __len - __declen);
__traits_type::copy(__p2, __p, __len - __declen);
__newlen += __len - __declen;
}
@ -816,13 +831,15 @@ namespace std
_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;
@ -845,7 +862,7 @@ namespace std
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
{
@ -866,14 +883,14 @@ namespace std
_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>
@ -894,7 +911,7 @@ namespace std
_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
@ -915,7 +932,7 @@ namespace std
__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);
}
@ -1591,7 +1608,7 @@ namespace std
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;
@ -1686,7 +1703,7 @@ namespace std
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];
@ -1729,7 +1746,7 @@ namespace std
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];
@ -1996,22 +2013,31 @@ namespace std
// internal-adjusted objects are padded according to the rules below
// concerning 0[xX] and +-, otherwise, exactly as right-adjusted
// ones are.
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)
{
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);
char_type* __beg;
char_type* __end;
// 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>
struct __pad
{
static void
_S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
const _CharT* __olds, const streamsize __newlen,
const streamsize __oldlen, const bool __num);
};
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;
@ -2019,7 +2045,7 @@ namespace std
if (__adjust == ios_base::left)
{
// Padding last.
__beg = const_cast<char_type*>(__olds);
__beg = const_cast<_CharT*>(__olds);
__beglen = __oldlen;
__end = __pads;
}
@ -2030,12 +2056,14 @@ namespace std
// 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];
@ -2044,23 +2072,23 @@ namespace std
__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
@ -2068,23 +2096,11 @@ namespace std
// 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.
@ -2401,5 +2417,3 @@ namespace std
} // namespace std
#endif

18
libstdc++-v3/include/bits/ostream.tcc
View File

@ -474,7 +474,8 @@ namespace std
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);
@ -509,7 +510,8 @@ namespace std
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);
@ -542,7 +544,8 @@ namespace std
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;
}
@ -590,7 +593,8 @@ namespace std
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;
}
@ -628,7 +632,8 @@ namespace std
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;
}
@ -668,7 +673,8 @@ namespace std
#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;
}

2
libstdc++-v3/include/bits/sstream.tcc
View File

@ -184,7 +184,7 @@ namespace std
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;

29
libstdc++-v3/include/bits/streambuf_iterator.h
View File

@ -69,13 +69,13 @@ namespace std
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
@ -85,21 +85,25 @@ namespace std
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;
}
@ -110,8 +114,8 @@ namespace std
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
@ -120,13 +124,14 @@ namespace std
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;

9
libstdc++-v3/include/std/std_fstream.h
View File

@ -286,7 +286,16 @@ namespace std
}
};
// 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
/**

4
libstdc++-v3/include/std/std_streambuf.h
View File

@ -71,6 +71,7 @@ namespace std
// 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>;
@ -132,6 +133,9 @@ namespace std
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

1
libstdc++-v3/src/Makefile.am
View File

@ -70,6 +70,7 @@ sources = \
concept-inst.cc \
ctype.cc \
ext-inst.cc \
fstream.cc \
fstream-inst.cc \
functexcept.cc \
globals.cc \

3
libstdc++-v3/src/Makefile.in
View File

@ -175,6 +175,7 @@ sources = \
concept-inst.cc \
ctype.cc \
ext-inst.cc \
fstream.cc \
fstream-inst.cc \
functexcept.cc \
globals.cc \
@ -279,7 +280,7 @@ LDFLAGS = @LDFLAGS@
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 \

35
libstdc++-v3/src/locale-inst.cc
View File

@ -420,15 +420,7 @@ namespace std
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
@ -440,29 +432,23 @@ namespace std
__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
@ -471,7 +457,8 @@ namespace std
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

87
libstdc++-v3/testsuite/21_strings/capacity.cc
View File

@ -36,6 +36,93 @@ template<typename T>
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

68
libstdc++-v3/testsuite/22_locale/codecvt_members_unicode_char.cc
View File

@ -23,10 +23,71 @@
#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
@ -51,7 +112,7 @@ it shows that the other byte-order is used (25856 == 0x6500).
void
initialize_state(__enc_traits& state)
initialize_state(std::__enc_traits& state)
{ state._M_init(); }
// Partial specialization using __enc_traits.
@ -59,8 +120,8 @@ initialize_state(__enc_traits& state)
// 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;
@ -146,6 +207,7 @@ void test01()
// UNICODE - UCS2 (little endian)
void test02()
{
using namespace std;
typedef codecvt_base::result result;
typedef unsigned short unicode_t;
typedef unicode_t int_type;

69
libstdc++-v3/testsuite/22_locale/codecvt_members_unicode_wchar_t.cc
View File

@ -1,6 +1,6 @@
// 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
@ -23,21 +23,80 @@
#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;

63
libstdc++-v3/testsuite/22_locale/ctor_copy_dtor.cc
View File

@ -48,11 +48,70 @@ public:
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;

58
libstdc++-v3/testsuite/27_io/filebuf.cc
View File

@ -42,11 +42,67 @@ void test01()
// 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;
}

49
libstdc++-v3/testsuite/27_io/filebuf_virtuals.cc
View File

@ -514,54 +514,6 @@ void test06()
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();
@ -571,7 +523,6 @@ main()
test04();
test05();
test06();
test07();
return 0;
}

2
libstdc++-v3/testsuite/27_io/fstream.cc
View File

@ -31,6 +31,7 @@
// NB: This file is for testing basic_fstream with NO OTHER INCLUDES.
#include <fstream>
#include <testsuite_hooks.h>
// { dg-do compile }
@ -51,6 +52,7 @@ namespace test
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()

170
libstdc++-v3/testsuite/27_io/ios_init.cc
View File

@ -34,6 +34,176 @@
#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;

2
libstdc++-v3/testsuite/27_io/istream.cc
View File

@ -31,6 +31,7 @@
// NB: This file is for testing istream with NO OTHER INCLUDES.
#include <istream>
#include <testsuite_hooks.h>
// { dg-do compile }
@ -51,6 +52,7 @@ namespace test
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()

2
libstdc++-v3/testsuite/27_io/ostream.cc
View File

@ -31,6 +31,7 @@
// NB: This file is for testing ostream with NO OTHER INCLUDES.
#include <ostream>
#include <testsuite_hooks.h>
// { dg-do compile }
@ -51,6 +52,7 @@ namespace test
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()

2
libstdc++-v3/testsuite/27_io/streambuf.cc
View File

@ -31,6 +31,7 @@
// NB: This file is for testing basic_streambuf with NO OTHER INCLUDES.
#include <streambuf>
#include <testsuite_hooks.h>
// { dg-do compile }
@ -51,6 +52,7 @@ namespace test
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()

2
libstdc++-v3/testsuite/27_io/stringbuf.cc
View File

@ -31,6 +31,7 @@
// NB: This file is for testing basic_stringbuf with NO OTHER INCLUDES.
#include <sstream>
#include <testsuite_hooks.h>
// { dg-do compile }
@ -51,6 +52,7 @@ namespace test
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()

2
libstdc++-v3/testsuite/27_io/stringstream.cc
View File

@ -31,6 +31,7 @@
// NB: This file is for testing basic_stringstream with NO OTHER INCLUDES.
#include <sstream>
#include <testsuite_hooks.h>
// { dg-do compile }
@ -51,6 +52,7 @@ namespace test
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()

82
libstdc++-v3/testsuite/testsuite_hooks.h
View File

@ -50,10 +50,16 @@
// 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)
@ -61,8 +67,6 @@
# 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.
@ -146,6 +150,80 @@ class gnu_copy_tracker
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