libstdc++-v3/testsuite/testsuite_character.h - gcc - Git at Google

 // -*- C++ -*-
 // Testing character type and state type with char_traits and codecvt
 // specializations for the C++ library testsuite.
 //
 // 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 // USA.
 //
 // As a special exception, you may use this file as part of a free software
 // library without restriction.  Specifically, if other files instantiate
 // templates or use macros or inline functions from this file, or you compile
 // this file and link it with other files to produce an executable, this
 // file does not by itself cause the resulting executable to be covered by
 // the GNU General Public License.  This exception does not however
 // invalidate any other reasons why the executable file might be covered by
 // the GNU General Public License.

 #ifndef _GLIBCXX_TESTSUITE_CHARACTER_H
 #define _GLIBCXX_TESTSUITE_CHARACTER_H

 #include <string> // for char_traits
 #include <locale> // for codecvt
 #include <climits>

 namespace __gnu_test
 {
   // Character type
   struct character
   {
     unsigned char val;

     static character from_char(char c)
     {
       character ret;
       ret.val = c;
       return ret;
     }
   };

   inline bool
   operator==(const character& lhs, const character& rhs)
   { return lhs.val == rhs.val; }

   // State type.
   struct conversion_state
   {
     unsigned int state;
   };
 }; // namespace __gnu_test

 namespace std
 {
   // char_traits specialization. Meets the additional requirements for
   // basic_filebuf.
   template<>
     struct char_traits<__gnu_test::character>
     {
       typedef __gnu_test::character char_type;
       typedef unsigned int int_type;
       typedef __gnu_test::conversion_state state_type;
       typedef streamoff off_type;
       typedef fpos<state_type> pos_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.val == c2.val; }

       static bool
       lt(const char_type& c1, const char_type& c2)
       { return c1.val < c2.val; }

       static int
       compare(const char_type* s1, const char_type* s2, size_t n)
       {
 	for (size_t i = 0; i < n; ++i)
 	  {
 	    if (lt(s1[i], s2[i]))
 	      return -1;
 	    else if (lt(s2[i], s1[i]))
 	      return 1;
 	  }
 	return 0;
       }

       static size_t
       length(const char_type* s)
       {
 	size_t n = 0;
 	while (!eq(s[n], char_type()))
 	  ++n;
 	return n;
       }

       static const char_type*
       find(const char_type* s, size_t n, const char_type& a)
       {
 	for (size_t i = 0; i < n; ++i)
 	  {
 	    if (eq(s[i], a))
 	      return s + i;
 	  }
 	return NULL;
       }

       static char_type*
       move(char_type* s1, const char_type* s2, size_t n)
       {
 	if (s1 > s2)
 	  {
 	    for (size_t i = 0; i < n; ++i)
 	      assign(s1[n - i - 1], s2[n - i - 1]);
 	  }
 	else
 	  {
 	    for (size_t i = 0; i < n; ++i)
 	      assign(s1[i], s2[i]);
 	  }
 	return s1;
       }

       static char_type*
       copy(char_type* s1, const char_type* s2, size_t n)
       {
 	for (size_t i = 0; i < n; ++i)
 	  assign(s1[i], s2[i]);
 	return s1;
       }

       static char_type*
       assign(char_type* s, size_t n, char_type a)
       {
 	for (size_t i = 0; i < n; ++i)
 	  assign(s[i], a);
 	return s;
       }

       static int_type
       not_eof(const int_type& c)
       {
 	if (eq_int_type(c, eof()))
 	  return 0;
 	return c;
       }

       // Note non-trivial conversion to maximize chance of catching bugs
       static char_type
       to_char_type(const int_type& c)
       {
 	char_type ret;
 	ret.val = (c >> 5);
 	return ret;
       }

       static int_type
       to_int_type(const char_type& c)
       {
 	return c.val << 5;
       }

       static bool
       eq_int_type(const int_type& c1, const int_type& c2)
       { return c1 == c2; }

       static int_type eof()
       { return 0xf; }
     };

   // codecvt specialization
   //
   // The conversion performed by the specialization is not supposed to
   // be useful, rather it has been designed to demonstrate the
   // essential features of stateful conversions:
   // * Number and value of bytes for each internal character depends on the
   //   state in addition to the character itself.
   // * Unshift produces an unshift sequence and resets the state. On input
   //   the unshift sequence causes the state to be reset.
   //
   // The conversion for output is as follows:
   // 1. Calculate the value tmp by xor-ing the state and the internal
   //    character
   // 2. Split tmp into either two or three bytes depending on the value of
   //    state. Output those bytes.
   // 3. tmp becomes the new value of state.
   template<>
     class codecvt<__gnu_test::character, char, __gnu_test::conversion_state>
       : public locale::facet, public codecvt_base
     {
     public:
       typedef __gnu_test::character intern_type;
       typedef char extern_type;
       typedef __gnu_test::conversion_state state_type;

       explicit codecvt(size_t refs = 0)
       : locale::facet(refs)
       { }

       result
       out(state_type& state, const intern_type* from,
 	  const intern_type* from_end, const intern_type*& from_next,
 	  extern_type* to, extern_type* to_limit, extern_type*& to_next) const
       {
 	return do_out(state, from, from_end, from_next,
 		      to, to_limit, to_next);
       }

       result
       unshift(state_type& state, extern_type* to, extern_type* to_limit,
 	      extern_type*& to_next) const
       { return do_unshift(state, to, to_limit, to_next); }

       result
       in(state_type& state, const extern_type* from,
 	 const extern_type* from_end, const extern_type*& from_next,
 	 intern_type* to, intern_type* to_limit, intern_type*& to_next) const
       {
 	return do_in(state, from, from_end, from_next,
 		     to, to_limit, to_next);
       }

       int
       encoding() const throw()
       { return do_encoding(); }

       bool
       always_noconv() const throw()
       { return do_always_noconv(); }

       int
       length(state_type& state, const extern_type* from,
 	     const extern_type* end, size_t max) const
       { return do_length(state, from, end, max); }

       int
       max_length() const throw()
       { return do_max_length(); }

       static locale::id id;

     protected:
       ~codecvt()
       { }

       virtual result
       do_out(state_type& state, const intern_type* from,
 	     const intern_type* from_end, const intern_type*& from_next,
 	     extern_type* to, extern_type* to_limit,
 	     extern_type*& to_next) const
       {
 	while (from < from_end && to < to_limit)
 	  {
 	    unsigned char tmp = (state.state ^ from->val);
 	    if (state.state & 0x8)
 	      {
 		if (to >= to_limit - 2)
 		  break;
 		*to++ = (tmp & 0x7);
 		*to++ = ((tmp >> 3) & 0x7);
 		*to++ = ((tmp >> 6) & 0x3);
 	      }
 	    else
 	      {
 		if (to >= to_limit - 1)
 		  break;
 		*to++ = (tmp & 0xf);
 		*to++ = ((tmp >> 4) & 0xf);
 	      }
 	    state.state = tmp;
 	    ++from;
 	  }

 	from_next = from;
 	to_next = to;
 	return (from < from_end) ? partial : ok;
       }

       virtual result
       do_in(state_type& state, const extern_type* from,
 	    const extern_type* from_end, const extern_type*& from_next,
 	    intern_type* to, intern_type* to_limit,
 	    intern_type*& to_next) const
       {
 	while (from < from_end && to < to_limit)
 	  {
 	    unsigned char c = *from;
 	    if (c & 0xc0)
 	      {
 		// Unshift sequence
 		state.state &= c;
 		++from;
 		continue;
 	      }

 	    unsigned char tmp;
 	    if (state.state & 0x8)
 	      {
 		if (from >= from_end - 2)
 		  break;
 		tmp = (*from++ & 0x7);
 		tmp |= ((*from++ << 3) & 0x38);
 		tmp |= ((*from++ << 6) & 0xc0);
 	      }
 	    else
 	      {
 		if (from >= from_end - 1)
 		  break;
 		tmp = (*from++ & 0xf);
 		tmp |= ((*from++ << 4) & 0xf0);
 	      }
 	    to->val = (tmp ^ state.state);
 	    state.state = tmp;
 	    ++to;
 	  }

 	from_next = from;
 	to_next = to;
 	return (from < from_end) ? partial : ok;
       }

       virtual result
       do_unshift(state_type& state, extern_type* to, extern_type* to_limit,
 		 extern_type*& to_next) const
       {
 	for (unsigned int i = 0; i < CHAR_BIT; ++i)
 	  {
 	    unsigned int mask = (1 << i);
 	    if (state.state & mask)
 	      {
 		if (to == to_limit)
 		  {
 		    to_next = to;
 		    return partial;
 		  }

 		state.state &= ~mask;
 		*to++ = static_cast<unsigned char>(~mask);
 	      }
 	  }

 	to_next = to;
 	return state.state == 0 ? ok : error;
       }

       virtual int
       do_encoding() const throw()
       { return -1; }

       virtual bool
       do_always_noconv() const throw()
       { return false; }

       virtual int
       do_length(state_type& state, const extern_type* from,
 		const extern_type* end, size_t max) const
       {
 	const extern_type* beg = from;
 	while (from < end && max)
 	  {
 	    unsigned char c = *from;
 	    if (c & 0xc0)
 	      {
 		// Unshift sequence
 		state.state &= c;
 		++from;
 		continue;
 	      }

 	    unsigned char tmp;
 	    if (state.state & 0x8)
 	      {
 		if (from >= end - 2)
 		  break;
 		tmp = (*from++ & 0x7);
 		tmp |= ((*from++ << 3) & 0x38);
 		tmp |= ((*from++ << 6) & 0xc0);
 	      }
 	    else
 	      {
 		if (from >= end - 1)
 		  break;
 		tmp = (*from++ & 0xf);
 		tmp |= ((*from++ << 4) & 0xf0);
 	      }
 	    state.state = tmp;
 	    --max;
 	  }
 	return from - beg;
       }

       // Maximum 8 bytes unshift sequence followed by max 3 bytes for
       // one character.
       virtual int
       do_max_length() const throw()
       { return 11; }
     };

   locale::id
   codecvt<__gnu_test::character, char, __gnu_test::conversion_state>::id;
 } // namespace std

 #endif // _GLIBCXX_TESTSUITE_CHARACTER_H
	// -- C++ --
	// Testing character type and state type with char_traits and codecvt
	// specializations for the C++ library testsuite.
	//
	// 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
	// USA.
	//
	// As a special exception, you may use this file as part of a free software
	// library without restriction. Specifically, if other files instantiate
	// templates or use macros or inline functions from this file, or you compile
	// this file and link it with other files to produce an executable, this
	// file does not by itself cause the resulting executable to be covered by
	// the GNU General Public License. This exception does not however
	// invalidate any other reasons why the executable file might be covered by
	// the GNU General Public License.

	#ifndef _GLIBCXX_TESTSUITE_CHARACTER_H
	#define _GLIBCXX_TESTSUITE_CHARACTER_H

	#include <string> // for char_traits
	#include <locale> // for codecvt
	#include <climits>

	namespace __gnu_test
	{
	// Character type
	struct character
	{
	unsigned char val;

	static character from_char(char c)
	{
	character ret;
	ret.val = c;
	return ret;
	}
	};

	inline bool
	operator==(const character& lhs, const character& rhs)
	{ return lhs.val == rhs.val; }

	// State type.
	struct conversion_state
	{
	unsigned int state;
	};
	}; // namespace __gnu_test

	namespace std
	{
	// char_traits specialization. Meets the additional requirements for
	// basic_filebuf.
	template<>
	struct char_traits<__gnu_test::character>
	{
	typedef __gnu_test::character char_type;
	typedef unsigned int int_type;
	typedef __gnu_test::conversion_state state_type;
	typedef streamoff off_type;
	typedef fpos<state_type> pos_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.val == c2.val; }

	static bool
	lt(const char_type& c1, const char_type& c2)
	{ return c1.val < c2.val; }

	static int
	compare(const char_type* s1, const char_type* s2, size_t n)
	{
	for (size_t i = 0; i < n; ++i)
	{
	if (lt(s1[i], s2[i]))
	return -1;
	else if (lt(s2[i], s1[i]))
	return 1;
	}
	return 0;
	}

	static size_t
	length(const char_type* s)
	{
	size_t n = 0;
	while (!eq(s[n], char_type()))
	++n;
	return n;
	}

	static const char_type*
	find(const char_type* s, size_t n, const char_type& a)
	{
	for (size_t i = 0; i < n; ++i)
	{
	if (eq(s[i], a))
	return s + i;
	}
	return NULL;
	}

	static char_type*
	move(char_type* s1, const char_type* s2, size_t n)
	{
	if (s1 > s2)
	{
	for (size_t i = 0; i < n; ++i)
	assign(s1[n - i - 1], s2[n - i - 1]);
	}
	else
	{
	for (size_t i = 0; i < n; ++i)
	assign(s1[i], s2[i]);
	}
	return s1;
	}

	static char_type*
	copy(char_type* s1, const char_type* s2, size_t n)
	{
	for (size_t i = 0; i < n; ++i)
	assign(s1[i], s2[i]);
	return s1;
	}

	static char_type*
	assign(char_type* s, size_t n, char_type a)
	{
	for (size_t i = 0; i < n; ++i)
	assign(s[i], a);
	return s;
	}

	static int_type
	not_eof(const int_type& c)
	{
	if (eq_int_type(c, eof()))
	return 0;
	return c;
	}

	// Note non-trivial conversion to maximize chance of catching bugs
	static char_type
	to_char_type(const int_type& c)
	{
	char_type ret;
	ret.val = (c >> 5);
	return ret;
	}

	static int_type
	to_int_type(const char_type& c)
	{
	return c.val << 5;
	}

	static bool
	eq_int_type(const int_type& c1, const int_type& c2)
	{ return c1 == c2; }

	static int_type eof()
	{ return 0xf; }
	};

	// codecvt specialization
	//
	// The conversion performed by the specialization is not supposed to
	// be useful, rather it has been designed to demonstrate the
	// essential features of stateful conversions:
	// * Number and value of bytes for each internal character depends on the
	// state in addition to the character itself.
	// * Unshift produces an unshift sequence and resets the state. On input
	// the unshift sequence causes the state to be reset.
	//
	// The conversion for output is as follows:
	// 1. Calculate the value tmp by xor-ing the state and the internal
	// character
	// 2. Split tmp into either two or three bytes depending on the value of
	// state. Output those bytes.
	// 3. tmp becomes the new value of state.
	template<>
	class codecvt<__gnu_test::character, char, __gnu_test::conversion_state>
	: public locale::facet, public codecvt_base
	{
	public:
	typedef __gnu_test::character intern_type;
	typedef char extern_type;
	typedef __gnu_test::conversion_state state_type;

	explicit codecvt(size_t refs = 0)
	: locale::facet(refs)
	{ }

	result
	out(state_type& state, const intern_type* from,
	const intern_type* from_end, const intern_type*& from_next,
	extern_type* to, extern_type* to_limit, extern_type*& to_next) const
	{
	return do_out(state, from, from_end, from_next,
	to, to_limit, to_next);
	}

	result
	unshift(state_type& state, extern_type* to, extern_type* to_limit,
	extern_type*& to_next) const
	{ return do_unshift(state, to, to_limit, to_next); }

	result
	in(state_type& state, const extern_type* from,
	const extern_type* from_end, const extern_type*& from_next,
	intern_type* to, intern_type* to_limit, intern_type*& to_next) const
	{
	return do_in(state, from, from_end, from_next,
	to, to_limit, to_next);
	}

	int
	encoding() const throw()
	{ return do_encoding(); }

	bool
	always_noconv() const throw()
	{ return do_always_noconv(); }

	int
	length(state_type& state, const extern_type* from,
	const extern_type* end, size_t max) const
	{ return do_length(state, from, end, max); }

	int
	max_length() const throw()
	{ return do_max_length(); }

	static locale::id id;

	protected:
	~codecvt()
	{ }

	virtual result
	do_out(state_type& state, const intern_type* from,
	const intern_type* from_end, const intern_type*& from_next,
	extern_type* to, extern_type* to_limit,
	extern_type*& to_next) const
	{
	while (from < from_end && to < to_limit)
	{
	unsigned char tmp = (state.state ^ from->val);
	if (state.state & 0x8)
	{
	if (to >= to_limit - 2)
	break;
	*to++ = (tmp & 0x7);
	*to++ = ((tmp >> 3) & 0x7);
	*to++ = ((tmp >> 6) & 0x3);
	}
	else
	{
	if (to >= to_limit - 1)
	break;
	*to++ = (tmp & 0xf);
	*to++ = ((tmp >> 4) & 0xf);
	}
	state.state = tmp;
	++from;
	}

	from_next = from;
	to_next = to;
	return (from < from_end) ? partial : ok;
	}

	virtual result
	do_in(state_type& state, const extern_type* from,
	const extern_type* from_end, const extern_type*& from_next,
	intern_type* to, intern_type* to_limit,
	intern_type*& to_next) const
	{
	while (from < from_end && to < to_limit)
	{
	unsigned char c = *from;
	if (c & 0xc0)
	{
	// Unshift sequence
	state.state &= c;
	++from;
	continue;
	}

	unsigned char tmp;
	if (state.state & 0x8)
	{
	if (from >= from_end - 2)
	break;
	tmp = (*from++ & 0x7);
	tmp \|= ((*from++ << 3) & 0x38);
	tmp \|= ((*from++ << 6) & 0xc0);
	}
	else
	{
	if (from >= from_end - 1)
	break;
	tmp = (*from++ & 0xf);
	tmp \|= ((*from++ << 4) & 0xf0);
	}
	to->val = (tmp ^ state.state);
	state.state = tmp;
	++to;
	}

	from_next = from;
	to_next = to;
	return (from < from_end) ? partial : ok;
	}

	virtual result
	do_unshift(state_type& state, extern_type* to, extern_type* to_limit,
	extern_type*& to_next) const
	{
	for (unsigned int i = 0; i < CHAR_BIT; ++i)
	{
	unsigned int mask = (1 << i);
	if (state.state & mask)
	{
	if (to == to_limit)
	{
	to_next = to;
	return partial;
	}

	state.state &= ~mask;
	*to++ = static_cast<unsigned char>(~mask);
	}
	}

	to_next = to;
	return state.state == 0 ? ok : error;
	}

	virtual int
	do_encoding() const throw()
	{ return -1; }

	virtual bool
	do_always_noconv() const throw()
	{ return false; }

	virtual int
	do_length(state_type& state, const extern_type* from,
	const extern_type* end, size_t max) const
	{
	const extern_type* beg = from;
	while (from < end && max)
	{
	unsigned char c = *from;
	if (c & 0xc0)
	{
	// Unshift sequence
	state.state &= c;
	++from;
	continue;
	}

	unsigned char tmp;
	if (state.state & 0x8)
	{
	if (from >= end - 2)
	break;
	tmp = (*from++ & 0x7);
	tmp \|= ((*from++ << 3) & 0x38);
	tmp \|= ((*from++ << 6) & 0xc0);
	}
	else
	{
	if (from >= end - 1)
	break;
	tmp = (*from++ & 0xf);
	tmp \|= ((*from++ << 4) & 0xf0);
	}
	state.state = tmp;
	--max;
	}
	return from - beg;
	}

	// Maximum 8 bytes unshift sequence followed by max 3 bytes for
	// one character.
	virtual int
	do_max_length() const throw()
	{ return 11; }
	};

	locale::id
	codecvt<__gnu_test::character, char, __gnu_test::conversion_state>::id;
	} // namespace std

	#endif // _GLIBCXX_TESTSUITE_CHARACTER_H