Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

306 lines (271 sloc) 8.299 kB
/*
Copyright (C) 2001-2006, William Joseph.
All Rights Reserved.
This file is part of GtkRadiant.
GtkRadiant 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 of the License, or
(at your option) any later version.
GtkRadiant 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 GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#if !defined(INCLUDED_CONVERT_H)
#define INCLUDED_CONVERT_H
/// \file
/// \brief Character encoding conversion.
#include "debugging/debugging.h"
#include <algorithm>
#include <glib/gunicode.h>
#include <glib/gconvert.h>
#include "character.h"
/// \brief Returns the number of bytes required to represent \p character in UTF-8 encoding.
inline std::size_t utf8_character_length(const char* character)
{
if((*character & 0xE0) == 0xC0) // 110xxxxx
{
return 2;
}
else if((*character & 0xF0) == 0xE0) // 1110xxxx
{
return 3;
}
else if((*character & 0xF8) == 0xF0) // 11110xxx
{
return 4;
}
else if((*character & 0xFC) == 0xF8) // 111110xx
{
return 5;
}
else if((*character & 0xFE) == 0xFC) // 1111110x
{
return 6;
}
ERROR_MESSAGE("");
return 0;
}
struct UTF8Character
{
const char* buffer;
std::size_t length;
UTF8Character() : buffer(0), length(0)
{
}
UTF8Character(const char* bytes) : buffer(bytes), length(utf8_character_length(bytes))
{
}
};
inline bool operator<(const UTF8Character& self, const UTF8Character& other)
{
return std::lexicographical_compare(self.buffer, self.buffer + self.length, other.buffer, other.buffer + other.length);
}
/// \brief Writes \p c to \p ostream in Hex form. Useful for debugging.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write(TextOutputStreamType& ostream, const UTF8Character& c)
{
for(const char* p = c.buffer; p != c.buffer + c.length; ++p)
{
ostream << HexChar(*p);
}
return ostream;
}
/// \brief The character-set encoding for the current C locale.
///
/// Obtain the global instance with globalCharacterSet().
class CharacterSet
{
const char* m_charSet;
public:
CharacterSet()
{
if(g_get_charset(&m_charSet) != FALSE)
{
m_charSet = 0;
}
}
bool isUTF8() const
{
return m_charSet == 0;
}
const char* get() const
{
return m_charSet;
}
};
typedef LazyStatic<CharacterSet> GlobalCharacterSet;
/// \brief Returns the global instance of CharacterSet.
inline CharacterSet& globalCharacterSet()
{
return GlobalCharacterSet::instance();
}
class UTF8CharacterToExtendedASCII
{
public:
UTF8Character m_utf8;
char m_c;
UTF8CharacterToExtendedASCII() : m_c('\0')
{
}
UTF8CharacterToExtendedASCII(const UTF8Character& utf8, char c) : m_utf8(utf8), m_c(c)
{
}
};
inline bool operator<(const UTF8CharacterToExtendedASCII& self, const UTF8CharacterToExtendedASCII& other)
{
return self.m_utf8 < other.m_utf8;
}
inline std::size_t extended_ascii_to_index(char c)
{
return static_cast<std::size_t>(c & 0x7F);
}
inline char extended_ascii_for_index(std::size_t i)
{
return static_cast<char>(i | 0x80);
}
/// \brief The active extended-ascii character set encoding.
/// Performs UTF-8 encoding and decoding of extended-ascii characters.
///
/// Obtain the global instance with globalExtendedASCIICharacterSet().
class ExtendedASCIICharacterSet
{
typedef char UTF8CharBuffer[6];
UTF8CharBuffer m_converted[128];
UTF8Character m_decodeMap[128];
UTF8CharacterToExtendedASCII m_encodeMap[128];
public:
ExtendedASCIICharacterSet()
{
if(!globalCharacterSet().isUTF8())
{
GIConv descriptor = g_iconv_open("UTF-8", globalCharacterSet().get());
for(std::size_t i = 1; i < 128; ++i)
{
char c = extended_ascii_for_index(i);
char* inbuf = &c;
std::size_t inbytesleft = 1;
char* outbuf = m_converted[i];
std::size_t outbytesleft = 6;
if(g_iconv(descriptor, &inbuf, &inbytesleft, &outbuf, &outbytesleft) != (size_t)(-1))
{
UTF8Character utf8(m_converted[i]);
m_decodeMap[i] = utf8;
m_encodeMap[i] = UTF8CharacterToExtendedASCII(utf8, c);
}
}
g_iconv_close(descriptor);
std::sort(m_encodeMap, m_encodeMap + 128);
}
}
/// \brief Prints the (up to) 128 characters in the current extended-ascii character set.
/// Useful for debugging.
void print() const
{
globalOutputStream() << "UTF-8 conversion required from charset: " << globalCharacterSet().get() << "\n";
for(std::size_t i = 1; i < 128; ++i)
{
if(m_decodeMap[i].buffer != 0)
{
globalOutputStream() << extended_ascii_for_index(i) << " = " << m_decodeMap[i] << "\n";
}
}
}
/// \brief Returns \p c decoded from extended-ascii to UTF-8.
/// \p c must be an extended-ascii character.
const UTF8Character& decode(char c) const
{
ASSERT_MESSAGE(!globalCharacterSet().isUTF8(), "locale is utf8, no conversion required");
ASSERT_MESSAGE(!char_is_ascii(c), "decode: ascii character");
ASSERT_MESSAGE(m_decodeMap[extended_ascii_to_index(c)].buffer != 0, "decode: invalid character: " << HexChar(c));
return m_decodeMap[extended_ascii_to_index(c)];
}
/// \brief Returns \p c encoded to extended-ascii from UTF-8.
/// \p c must map to an extended-ascii character.
char encode(const UTF8Character& c) const
{
ASSERT_MESSAGE(!globalCharacterSet().isUTF8(), "locale is utf8, no conversion required");
ASSERT_MESSAGE(!char_is_ascii(*c.buffer), "encode: ascii character");
std::pair<const UTF8CharacterToExtendedASCII*, const UTF8CharacterToExtendedASCII*> range
= std::equal_range(m_encodeMap, m_encodeMap + 128, UTF8CharacterToExtendedASCII(c, 0));
ASSERT_MESSAGE(range.first != range.second, "encode: invalid character: " << c);
return (*range.first).m_c;
}
};
typedef LazyStatic<ExtendedASCIICharacterSet> GlobalExtendedASCIICharacterSet;
/// \brief Returns the global instance of ExtendedASCIICharacterSet.
inline ExtendedASCIICharacterSet& globalExtendedASCIICharacterSet()
{
return GlobalExtendedASCIICharacterSet::instance();
}
class ConvertUTF8ToLocale
{
public:
StringRange m_range;
ConvertUTF8ToLocale(const char* string) : m_range(StringRange(string, string + strlen(string)))
{
}
ConvertUTF8ToLocale(const StringRange& range) : m_range(range)
{
}
};
/// \brief Writes \p convert to \p ostream after encoding each character to extended-ascii from UTF-8.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write(TextOutputStreamType& ostream, const ConvertUTF8ToLocale& convert)
{
if(globalCharacterSet().isUTF8())
{
return ostream << convert.m_range;
}
for(const char* p = convert.m_range.begin; p != convert.m_range.end;)
{
if(!char_is_ascii(*p))
{
UTF8Character c(p);
ostream << globalExtendedASCIICharacterSet().encode(c);
p += c.length;
}
else
{
ostream << *p++;
}
}
return ostream;
}
class ConvertLocaleToUTF8
{
public:
StringRange m_range;
ConvertLocaleToUTF8(const char* string) : m_range(StringRange(string, string + strlen(string)))
{
}
ConvertLocaleToUTF8(const StringRange& range) : m_range(range)
{
}
};
/// \brief Writes \p convert to \p ostream after decoding each character from extended-ascii to UTF-8.
template<typename TextOutputStreamType>
inline TextOutputStreamType& ostream_write(TextOutputStreamType& ostream, const ConvertLocaleToUTF8& convert)
{
if(globalCharacterSet().isUTF8())
{
return ostream << convert.m_range;
}
for(const char* p = convert.m_range.begin; p != convert.m_range.end; ++p)
{
if(!char_is_ascii(*p))
{
UTF8Character c(globalExtendedASCIICharacterSet().decode(*p));
ostream.write(c.buffer, c.length);
}
else
{
ostream << *p;
}
}
return ostream;
}
#endif
Jump to Line
Something went wrong with that request. Please try again.