206 lines
4.8 KiB
C++
206 lines
4.8 KiB
C++
// Copyright (C) 2003 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
|
|
// terms of the GNU General Public License as published by the
|
|
// Free Software Foundation; either version 2, or (at your option)
|
|
// any later version.
|
|
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License along
|
|
// with this library; see the file COPYING. If not, write to the Free
|
|
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
// USA.
|
|
|
|
// 27.8.1.4 Overridden virtual functions
|
|
|
|
#include <fstream>
|
|
#include <string>
|
|
#include <iterator>
|
|
#include <algorithm>
|
|
#include <locale>
|
|
#include <testsuite_hooks.h>
|
|
|
|
template <typename InternT, typename StateT = mbstate_t>
|
|
class checksumcvt : public std::codecvt<InternT, char, StateT>
|
|
{
|
|
typedef std::codecvt<InternT, char, StateT> Base;
|
|
static const size_t width = sizeof(InternT) + 1;
|
|
|
|
public:
|
|
typedef InternT intern_type;
|
|
typedef char extern_type;
|
|
|
|
explicit checksumcvt(size_t refs = 0)
|
|
: Base(refs)
|
|
{ }
|
|
|
|
protected:
|
|
virtual typename std::codecvt<InternT, char, StateT>::result
|
|
do_out(StateT&, const intern_type* from,
|
|
const intern_type* from_end, const intern_type*& from_next,
|
|
extern_type* to, extern_type* to_end,
|
|
extern_type*& to_next) const
|
|
{
|
|
size_t len = std::min(static_cast<size_t>(from_end - from),
|
|
static_cast<size_t>(to_end - to) / width);
|
|
|
|
while (len--)
|
|
{
|
|
const char* p = reinterpret_cast<const char*>(from);
|
|
unsigned char checksum = 0;
|
|
|
|
for (size_t i = 0; i < sizeof(intern_type); ++i)
|
|
{
|
|
*to++ = p[i];
|
|
checksum ^= static_cast<unsigned char>(p[i]);
|
|
}
|
|
|
|
*to++ = checksum;
|
|
++from;
|
|
}
|
|
|
|
from_next = from;
|
|
to_next = to;
|
|
return from_next == from_end ? std::codecvt<InternT, char, StateT>::ok
|
|
: std::codecvt<InternT, char, StateT>::partial;
|
|
}
|
|
|
|
virtual typename std::codecvt<InternT, char, StateT>::result
|
|
do_unshift(StateT&, extern_type* to,
|
|
extern_type*, extern_type*& to_next) const
|
|
{
|
|
to_next = to;
|
|
return std::codecvt<InternT, char, StateT>::ok;
|
|
}
|
|
|
|
virtual typename std::codecvt<InternT, char, StateT>::result
|
|
do_in(StateT&, const extern_type* from,
|
|
const extern_type* from_end, const extern_type*& from_next,
|
|
intern_type* to, intern_type* to_end,
|
|
intern_type*& to_next) const
|
|
{
|
|
size_t len = std::min(static_cast<size_t>(to_end - to),
|
|
static_cast<size_t>(from_end - from) / width);
|
|
|
|
while (len)
|
|
{
|
|
const char* f = from;
|
|
intern_type tmp;
|
|
char* p = reinterpret_cast<char*>(&tmp);
|
|
unsigned char checksum = 0;
|
|
|
|
for (size_t i = 0; i < sizeof(intern_type); ++i)
|
|
{
|
|
p[i] = *f;
|
|
checksum ^= static_cast<unsigned char>(*f++);
|
|
}
|
|
|
|
if (*f++ != checksum)
|
|
break;
|
|
|
|
from = f;
|
|
*to++ = tmp;
|
|
len--;
|
|
}
|
|
|
|
from_next = from;
|
|
to_next = to;
|
|
return len ? std::codecvt<InternT, char, StateT>::error :
|
|
(from_next == from_end ? std::codecvt<InternT, char, StateT>::ok
|
|
: std::codecvt<InternT, char, StateT>::partial);
|
|
}
|
|
|
|
virtual int
|
|
do_encoding() const throw()
|
|
{
|
|
return width;
|
|
}
|
|
|
|
virtual int
|
|
do_length(StateT&, const extern_type* from,
|
|
const extern_type* end, size_t max) const
|
|
{
|
|
size_t len = std::min(max, static_cast<size_t>(end - from) / width);
|
|
|
|
int ret = 0;
|
|
while (len--)
|
|
{
|
|
unsigned char checksum = 0;
|
|
|
|
for (size_t i = 0; i < sizeof(intern_type); ++i)
|
|
{
|
|
checksum ^= static_cast<unsigned char>(*from++);
|
|
}
|
|
|
|
if (*from++ != checksum)
|
|
break;
|
|
|
|
ret++;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
virtual int
|
|
do_max_length() const throw()
|
|
{
|
|
return width;
|
|
}
|
|
|
|
virtual bool
|
|
do_always_noconv() const throw()
|
|
{
|
|
return false;
|
|
}
|
|
};
|
|
|
|
void test01()
|
|
{
|
|
using namespace std;
|
|
bool test __attribute__((unused)) = true;
|
|
|
|
locale loc;
|
|
loc = locale(loc, new checksumcvt<wchar_t>);
|
|
|
|
wfilebuf fbuf1;
|
|
fbuf1.pubimbue(loc);
|
|
fbuf1.open("tmp_9178", ios_base::out | ios_base::trunc);
|
|
|
|
string tmpstr = "abcdefghijklmnopqrstuvwxyz0123456789 \t\n";
|
|
|
|
wifstream stream;
|
|
wstring str1;
|
|
|
|
while (str1.length() < 20000)
|
|
{
|
|
transform(tmpstr.begin(), tmpstr.end(),
|
|
back_inserter(str1),
|
|
bind1st(std::mem_fun(&std::wios::widen), &stream));
|
|
}
|
|
|
|
fbuf1.sputn(str1.data(), str1.size());
|
|
fbuf1.close();
|
|
|
|
wfilebuf fbuf2;
|
|
fbuf2.pubimbue(loc);
|
|
fbuf2.open("tmp_9178", std::ios_base::in);
|
|
|
|
wstring str2;
|
|
copy(istreambuf_iterator<wchar_t>(&fbuf2),
|
|
istreambuf_iterator<wchar_t>(),
|
|
back_inserter(str2));
|
|
|
|
VERIFY( str1 == str2 );
|
|
}
|
|
|
|
int main()
|
|
{
|
|
test01();
|
|
return 0;
|
|
}
|