Utf8.c

Go to the documentation of this file.

#include <wchar.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "errors.h"
 
#include <stdio.h>
 
struct Utf8 {
    char *locale;
    char *oldLocale;
    size_t wcharBufferLength;
    wchar_t *wcharBuffer;
};
 
struct Utf8 *Utf8_construct(char *locale, int *error)
{
    struct Utf8 *this = malloc(sizeof(struct Utf8));
 
    if (0 == this) {
        *error = ERROR_NO_MEMORY;
        return 0;
    }
 
    size_t length = strlen(locale) + 1;
 
    this->locale = malloc(sizeof(char) * length);
 
    strcpy(this->locale, locale);
 
    char *oldLocale = setlocale(LC_ALL, locale);
 
    size_t oldLength = strlen(oldLocale) + 1;
 
    this->oldLocale = malloc(sizeof(char) * oldLength);
 
    strcpy(this->oldLocale, oldLocale);
 
    return this;
}
 
struct Utf8 *Utf8_destruct(struct Utf8 *this)
{
    if (0 != this) {
        setlocale(LC_ALL, this->oldLocale);
        free(this->oldLocale);
        free(this->locale);
        free(this);
    }
 
    return 0;
}
 
char *Utf8_encode(struct Utf8 *this, const wchar_t* wchars, int *error)
{
    size_t wcharLength = wcslen(wchars);
    size_t charsLength = wcharLength * 4; // enough, but more than nessesary
 
    char *chars = malloc(sizeof(char) * charsLength);
 
    if (0 == chars) {
        *error = ERROR_NO_MEMORY;
        return 0;
    }
 
    mbstate_t convertState;
    memset(&convertState, 0, sizeof(convertState));
 
    wcsrtombs(chars, &wchars, charsLength, &convertState);
 
    if (EILSEQ == errno) {
        *error = ERROR_STRING_NOT_CONVERTED;
        return 0;
    }
 
    return chars;
}
 
wchar_t *Utf8_decode(struct Utf8 *this, const char *chars, int *error)
{
    size_t charsLength = strlen(chars) + 1;
 
    size_t wcharLength = charsLength; // enough, but more than nessesary
 
    wchar_t *wchars = malloc(sizeof(wchar_t) * wcharLength);
 
    if (0 == wchars) {
        *error = ERROR_NO_MEMORY;
        return 0;
    }
 
    mbstate_t convertState;
    memset(&convertState, 0, sizeof(convertState));
 
    mbsrtowcs(wchars, &chars, wcharLength, &convertState);
 
    if (EILSEQ == errno || EINVAL == errno) {
        *error = ERROR_STRING_NOT_CONVERTED;
        return 0;
    }
 
    return wchars;
}
 
size_t Utf8_countCodes(struct Utf8 *this, const char *chars, int *error)
{
    size_t charsLength = strlen(chars) + 1;
 
    size_t wcharLength = charsLength; // enough, but more than nessesary
 
    mbstate_t state;
    memset(&state, 0, sizeof(state));
 
    wchar_t *wchars = 0;
 
    size_t count = mbsrtowcs(wchars, &chars, wcharLength, &state);
 
    if (EILSEQ == errno || EINVAL == errno) {
        *error = ERROR_STRING_NOT_CONVERTED;
        return 0;
    }
 
    return count;
}