source: vendor/synergy/1.3.1/lib/arch/CMultibyte.cpp

/*
 * synergy -- mouse and keyboard sharing utility
 * Copyright (C) 2002 Chris Schoeneman
 * 
 * This package is free software you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * found in the file COPYING that should have accompanied this file.
 * 
 * This package 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.
 */

#ifndef CMULTIBYTE_H
#define CMULTIBYTE_H

#include "common.h"
#include "CArch.h"
#include <limits.h>
#include <string.h>
#if HAVE_LOCALE_H
#       include <locale.h>
#endif
#if HAVE_WCHAR_H || defined(_MSC_VER)
#       include <wchar.h>
#elif __APPLE__
        // wtf?  Darwin puts mbtowc() et al. in stdlib
#       include <stdlib.h>
#else
        // platform apparently has no wchar_t support.  provide dummy
        // implementations.  hopefully at least the C++ compiler has
        // a built-in wchar_t type.

static inline
int
mbtowc(wchar_t* dst, const char* src, int n)
{
        *dst = static_cast<wchar_t>(*src);
        return 1;
}

static inline
int
wctomb(char* dst, wchar_t src)
{
        *dst = static_cast<char>(src);
        return 1;
}

#endif

//
// use C library non-reentrant multibyte conversion with mutex
//

static CArchMutex               s_mutex = NULL;

ARCH_STRING::ARCH_STRING()
{
        s_mutex = ARCH->newMutex();

#if HAVE_LOCALE_H
        // see if we can convert a Latin-1 character
        char mb[MB_LEN_MAX];
        if (wctomb(mb, 0xe3) == -1) {
                // can't convert.  try another locale so we can convert latin-1.
                setlocale(LC_CTYPE, "en_US");
        }
#endif
}

ARCH_STRING::~ARCH_STRING()
{
        ARCH->closeMutex(s_mutex);
        s_mutex = NULL;
}

int
ARCH_STRING::convStringWCToMB(char* dst,
                                const wchar_t* src, UInt32 n, bool* errors)
{
        int len = 0;

        bool dummyErrors;
        if (errors == NULL) {
                errors = &dummyErrors;
        }

        ARCH->lockMutex(s_mutex);
        if (dst == NULL) {
                char dummy[MB_LEN_MAX];
                for (const wchar_t* scan = src; n > 0; ++scan, --n) {
                        int mblen = wctomb(dummy, *scan);
                        if (mblen == -1) {
                                *errors = true;
                                mblen   = 1;
                        }
                        len += mblen;
                }
                int mblen = wctomb(dummy, L'\0');
                if (mblen != -1) {
                        len += mblen - 1;
                }
        }
        else {
                char* dst0 = dst;
                for (const wchar_t* scan = src; n > 0; ++scan, --n) {
                        int mblen = wctomb(dst, *scan);
                        if (mblen == -1) {
                                *errors = true;
                                *dst++  = '?';
                        }
                        else {
                                dst    += mblen;
                        }
                }
                int mblen = wctomb(dst, L'\0');
                if (mblen != -1) {
                        // don't include nul terminator
                        dst += mblen - 1;
                }
                len = (int)(dst - dst0);
        }
        ARCH->unlockMutex(s_mutex);

        return len;
}

int
ARCH_STRING::convStringMBToWC(wchar_t* dst,
                                const char* src, UInt32 n, bool* errors)
{
        int len = 0;
        wchar_t dummy;

        bool dummyErrors;
        if (errors == NULL) {
                errors = &dummyErrors;
        }

        ARCH->lockMutex(s_mutex);
        if (dst == NULL) {
                for (const char* scan = src; n > 0; ) {
                        int mblen = mbtowc(&dummy, scan, n);
                        switch (mblen) {
                        case -2:
                                // incomplete last character.  convert to unknown character.
                                *errors = true;
                                len    += 1;
                                n       = 0;
                                break;

                        case -1:
                                // invalid character.  count one unknown character and
                                // start at the next byte.
                                *errors = true;
                                len    += 1;
                                scan   += 1;
                                n      -= 1;
                                break;

                        case 0:
                                len    += 1;
                                scan   += 1;
                                n      -= 1;
                                break;

                        default:
                                // normal character
                                len    += 1;
                                scan   += mblen;
                                n      -= mblen;
                                break;
                        }
                }
        }
        else {
                wchar_t* dst0 = dst;
                for (const char* scan = src; n > 0; ++dst) {
                        int mblen = mbtowc(dst, scan, n);
                        switch (mblen) {
                        case -2:
                                // incomplete character.  convert to unknown character.
                                *errors = true;
                                *dst    = (wchar_t)0xfffd;
                                n       = 0;
                                break;

                        case -1:
                                // invalid character.  count one unknown character and
                                // start at the next byte.
                                *errors = true;
                                *dst    = (wchar_t)0xfffd;
                                scan   += 1;
                                n      -= 1;
                                break;

                        case 0:
                                *dst    = (wchar_t)0x0000;
                                scan   += 1;
                                n      -= 1;
                                break;

                        default:
                                // normal character
                                scan   += mblen;
                                n      -= mblen;
                                break;
                        }
                }
                len = (int)(dst - dst0);
        }
        ARCH->unlockMutex(s_mutex);

        return len;
}

#endif