string_help.cpp

Go to the documentation of this file.

/*
**  ClanLib SDK
**  Copyright (c) 1997-2005 The ClanLib Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries ClanLib link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
*/

#include "precomp.h"
#include "string_help.h"
#include "exception.h"
#ifndef WIN32
#include <wchar.h>
#include <wctype.h>
#else
#include <string.h>
#include <tchar.h>
#endif

// CL_StringHelp Operations:

std::vector<CL_String> CL_StringHelp::split_text(const CL_String &text, const CL_String &split_string)
{
        std::vector<CL_String> result;
        CL_String::size_type end_pos = 0, begin_pos = 0;
        while (true)
        {
                end_pos = text.find(split_string, begin_pos);
                if (end_pos == CL_String::npos)
                {
                        result.push_back(text.substr(begin_pos));
                        break;
                }
                else
                {
                        result.push_back(text.substr(begin_pos, end_pos-begin_pos));
                        begin_pos = end_pos + split_string.length();
                }
        }
        return result;
}

int CL_StringHelp::compare(const CL_StringA &a, const CL_StringA &b, bool case_insensitive)
{
#ifdef WIN32
        if (case_insensitive)
                return stricmp(a.c_str(), b.c_str());
        else
                return strcmp(a.c_str(), b.c_str());
#else
        if (case_insensitive)
                return strcasecmp(a.c_str(), b.c_str());
        else
                return strcmp(a.c_str(), b.c_str());
#endif
}

int CL_StringHelp::compare(const CL_StringW &a, const CL_StringW &b, bool case_insensitive)
{
#ifdef WIN32
        if (case_insensitive)
                return wcsicmp(a.c_str(), b.c_str());
        else
                return wcscmp(a.c_str(), b.c_str());
#else
        if (case_insensitive)
                return wcscasecmp(a.c_str(), b.c_str());
        else
                return wcscmp(a.c_str(), b.c_str());
#endif
}

CL_String CL_StringHelp::text_to_upper(const CL_String &s)
{
#ifdef UNICODE
        return ucs2_to_upper(s);
#else
        return local8_to_upper(s);
#endif
}
        
CL_StringA CL_StringHelp::local8_to_upper(const CL_StringA &s)
{
        CL_StringA result = s;
        CL_StringA::size_type index, size;
        size = result.length();
        for (index = 0; index < size; index++)
        {
                result[index] = (unsigned char) toupper((unsigned char) result[index]);
        }
        return result;
}

CL_StringW CL_StringHelp::ucs2_to_upper(const CL_StringW &s)
{
        CL_StringW result = s;
        CL_StringW::size_type index, size;
        size = result.length();
        for (index = 0; index < size; index++)
        {
                result[index] = towupper(result[index]);
        }
        return result;
}
        
CL_String CL_StringHelp::text_to_lower(const CL_String &s)
{
#ifdef UNICODE
        return ucs2_to_lower(s);
#else
        return local8_to_lower(s);
#endif
}
        
CL_StringA CL_StringHelp::local8_to_lower(const CL_StringA &s)
{
        CL_StringA result = s;
        CL_StringA::size_type index, size;
        size = result.length();
        for (index = 0; index < size; index++)
        {
                result[index] = (unsigned char) tolower((unsigned char) result[index]);
        }
        return result;
}
        
CL_StringW CL_StringHelp::ucs2_to_lower(const CL_StringW &s)
{
        CL_StringW result = s;
        CL_StringW::size_type index, size;
        size = result.length();
        for (index = 0; index < size; index++)
        {
                result[index] = towlower(result[index]);
        }
        return result;
}

CL_String CL_StringHelp::float_to_text(float value)
{
#ifdef UNICODE
        return float_to_ucs2(value);
#else
        return float_to_local8(value);
#endif
}

CL_StringA CL_StringHelp::float_to_local8(float value)
{
        char buf[64];
        memset(buf, 0, 64);
#ifdef WIN32
        _snprintf(buf, 63, "%f", value);
#else
        snprintf(buf, 63, "%f", value);
#endif
        return CL_StringA(buf);
}
        
CL_StringW CL_StringHelp::float_to_ucs2(float value)
{
#ifdef WIN32
        WCHAR buf[64];
        memset(buf, 0, 64 * sizeof(WCHAR));
        swprintf(buf, L"%f", value);
        return CL_StringW(buf);
#else
        wchar_t buf[64];
        memset(buf, 0, 64 * sizeof(wchar_t));
        swprintf(buf, 63, L"%f", value);
        return CL_StringW(buf);
#endif
}

float CL_StringHelp::text_to_float(const CL_String &value)
{
#ifdef UNICODE
        return ucs2_to_float(value);
#else
        return local8_to_float(value);
#endif
}
        
float CL_StringHelp::local8_to_float(const CL_StringA &value)
{
        return 0.0f;
}
        
float CL_StringHelp::ucs2_to_float(const CL_StringW &value)
{
        return 0.0f;
}

CL_String CL_StringHelp::double_to_text(double value)
{
#ifdef UNICODE
        return double_to_ucs2(value);
#else
        return double_to_local8(value);
#endif
}

CL_StringA CL_StringHelp::double_to_local8(double value)
{
        char buf[64];
        memset(buf, 0, 64);
#ifdef WIN32
        _snprintf(buf, 63, "%#f", value);
#else
        snprintf(buf, 63, "%#f", value);
#endif
        return CL_StringA(buf);
}
        
CL_StringW CL_StringHelp::double_to_ucs2(double value)
{
#ifdef WIN32
        WCHAR buf[64];
        memset(buf, 0, 64 * sizeof(WCHAR));
        swprintf(buf, L"%#f", value);
        return CL_StringW(buf);
#else
        wchar_t buf[64];
        memset(buf, 0, 64 * sizeof(wchar_t));
        swprintf(buf, 63, L"%#f", value);
        return CL_StringW(buf);
#endif
}
        
double CL_StringHelp::text_to_double(const CL_String &value)
{
#ifdef UNICODE
        return ucs2_to_double(value);
#else
        return local8_to_double(value);
#endif
}
        
double CL_StringHelp::local8_to_double(const CL_StringA &value)
{
        return 0.0;
}
        
double CL_StringHelp::ucs2_to_double(const CL_StringW &value)
{
        return 0.0;
}

CL_String CL_StringHelp::int_to_text(int value)
{
#ifdef UNICODE
        return int_to_ucs2(value);
#else
        return int_to_local8(value);
#endif
}

CL_StringA CL_StringHelp::int_to_local8(int value)
{
        char buf[32];
        memset(buf, 0, 32);
#ifdef WIN32
        _snprintf(buf, 31, "%d", value);
#else
        snprintf(buf, 31, "%d", value);
#endif
        return CL_StringA(buf);
}
        
CL_StringW CL_StringHelp::int_to_ucs2(int value)
{
#ifdef WIN32
        WCHAR buf[32];
        memset(buf, 0, 32 * sizeof(WCHAR));
        swprintf(buf, L"%d", value);
        return CL_StringW(buf);
#else
        wchar_t buf[32];
        memset(buf, 0, 32 * sizeof(wchar_t));
        swprintf(buf, 31, L"%d", value);
        return CL_StringW(buf);
#endif
}

int CL_StringHelp::text_to_int(const CL_String &value)
{
#ifdef UNICODE
        return ucs2_to_int(value);
#else
        return local8_to_int(value);
#endif
}
        
int CL_StringHelp::local8_to_int(const CL_StringA &value)
{
        return atoi(value.c_str());
}
        
int CL_StringHelp::ucs2_to_int(const CL_StringW &value)
{
#ifdef WIN32
        return _wtoi(value.c_str());
#else
        throw CL_Exception(TEXT("ucs2_to_int not implemented on unix yet"));
        return 0;
#endif
}

CL_StringA CL_StringHelp::text_to_local8(const CL_String &text)
{
#ifdef UNICODE
        return ucs2_to_local8(text);
#else
        return text;
#endif
}

CL_StringA CL_StringHelp::text_to_utf8(const CL_String &text)
{
#ifdef UNICODE
        return ucs2_to_utf8(text);
#else
        CL_StringW ucs2 = local8_to_ucs2(text);
        return ucs2_to_utf8(ucs2);
#endif
}

CL_StringA CL_StringHelp::ucs2_to_latin1(const CL_StringW &ucs2)
{
        CL_StringA::size_type i, length = ucs2.length();
        CL_StringA latin1(length, ' ');
        for (i=0; i<length; i++)
                latin1[i] = (char) ucs2[i];
        return latin1;
}

CL_StringA CL_StringHelp::ucs2_to_latin9(const CL_StringW &ucs2)
{
        CL_StringA::size_type i, length = ucs2.length();
        CL_StringA latin1(length, ' ');
        for (i=0; i<length; i++)
                latin1[i] = (ucs2[i] != 0x20ac) ? ucs2[i] : 0xa4;
        return latin1;
}

CL_StringA CL_StringHelp::ucs2_to_local8(const CL_StringW &ucs2)
{
        return ucs2_to_latin9(ucs2);
}

CL_StringA CL_StringHelp::ucs2_to_utf8(const CL_StringW &ucs2)
{
        // Calculate length:

        CL_StringW::size_type length_ucs2 = ucs2.length();
        CL_StringA::size_type length_utf8 = 0;
        CL_StringW::size_type pos;
        for (pos = 0; pos < length_ucs2; pos++)
        {
                if (ucs2[pos] < 0x0080)
                        length_utf8++;
                else if (ucs2[pos] < 0x0800)
                        length_utf8 += 2;
                else
                        length_utf8 += 3;
        }
        
        // Perform conversion:
        
        CL_StringA utf8(length_utf8, ' ');
        CL_StringA::size_type pos_utf8 = 0;
        for (pos = 0; pos < length_ucs2; pos++)
        {
                if (ucs2[pos] < 0x0080)
                {
                        utf8[pos_utf8++] = (char) ucs2[pos];
                }
                else if (ucs2[pos] < 0x0800)
                {
                        utf8[pos_utf8++] = 0xc0 + (ucs2[pos] >> 6);
                        utf8[pos_utf8++] = (ucs2[pos] & 0x3f);
                }
                else
                {
                        utf8[pos_utf8++] = 0xe0 + (ucs2[pos] >> 12);
                        utf8[pos_utf8++] = ((ucs2[pos] >> 6) & 0x3f);
                        utf8[pos_utf8++] = (ucs2[pos] & 0x3f);
                }
        }

        return utf8;
}

CL_StringW CL_StringHelp::latin1_to_ucs2(const CL_StringA &latin1)
{
        CL_StringW::size_type i, length = latin1.length();
        CL_StringW ucs2(length, ' ');
        for (i=0; i<length; i++)
                ucs2[i] = latin1[i];
        return ucs2;
}

CL_StringW CL_StringHelp::latin9_to_ucs2(const CL_StringA &latin9)
{
        CL_StringW::size_type i, length = latin9.length();
        CL_StringW ucs2(length, ' ');
        for (i=0; i<length; i++)
                ucs2[i] = ((unsigned char) latin9[i] != 0xa4) ? latin9[i] : 0x20ac;
        return ucs2;
}

CL_String CL_StringHelp::local8_to_text(const CL_StringA &local8)
{
#ifdef UNICODE
        return local8_to_ucs2(local8);
#else
        return local8;
#endif
}

CL_String CL_StringHelp::ucs2_to_text(const CL_StringW &ucs2)
{
#ifdef UNICODE
        return ucs2;
#else
        return ucs2_to_local8(ucs2);
#endif
}

CL_StringW CL_StringHelp::local8_to_ucs2(const CL_StringA &local8)
{
        return latin9_to_ucs2(local8);
}

CL_StringW CL_StringHelp::utf8_to_ucs2(const CL_StringA &utf8)
{
        // Calculate length:

        CL_StringW::size_type length_ucs2 = 0;
        CL_StringA::size_type length_utf8 = utf8.length();
        CL_StringA::size_type pos = 0;
        while (pos < length_utf8)
        {
                unsigned char c = utf8[pos++];
                int trailing_bytes = trailing_bytes_for_utf8[c];
                length_ucs2++;
                pos += trailing_bytes;
        }
        if (pos != length_utf8)
        {
                // error in utf8 string
                length_ucs2--;
        }
        if (pos <= 0)
                return CL_StringW();

        // Perform conversion:
        
        CL_StringW ucs2(length_ucs2, L'?');
        pos = 0;
        CL_StringW::size_type ucs2_pos = 0;
        while (pos < length_utf8 && ucs2_pos < length_ucs2)
        {
                unsigned char c = utf8[pos++];
                int trailing_bytes = trailing_bytes_for_utf8[c];
                if (trailing_bytes == 0)
                {
                        ucs2[ucs2_pos] = c;
                }
                else
                {
                        unsigned int ucs4 = (c & bitmask_leadbyte_for_utf8[trailing_bytes]);
                        for (int i=1; i<=trailing_bytes; i++)
                        {
                                c = (unsigned char) utf8[pos+i];
                                if (c < 0xc0)
                                {
                                        ucs4 = (ucs4 << 6) + (c & 0x3f);
                                }
                                else
                                {
                                        // error in utf8 string
                                        ucs4 = 0;
                                        break;
                                }
                        }
                        if (ucs4 > 0 && ucs4 <= 0xffff)
                                ucs2[ucs2_pos] = ucs4;
                        else
                                ucs2[ucs2_pos] = L'?';
                }
                ucs2_pos++;
                pos += trailing_bytes;
        }
        return ucs2;
}

CL_String CL_StringHelp::utf8_to_text(const CL_StringA &utf8)
{
#ifdef UNICODE
        return utf8_to_ucs2(utf8);
#else
        CL_StringW ucs2 = utf8_to_ucs2(utf8);
        return ucs2_to_local8(ucs2);
#endif
}

// CL_StringHelp Implementation:

const char CL_StringHelp::trailing_bytes_for_utf8[256] =
{
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
        1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
        2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
};

const unsigned char CL_StringHelp::bitmask_leadbyte_for_utf8[6] =
{
        0x7f,
        0x1f,
        0x0f,
        0x07,
        0x03,
        0x01
};

---