/*
* Copyright (C) 2020 Linux Studio Plugins Project
* (C) 2020 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 18 июн. 2018 г.
*
* lsp-runtime-lib is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* lsp-runtime-lib 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with lsp-runtime-lib. If not, see .
*/
#ifndef LSP_PLUG_IN_IO_CHARSET_H_
#define LSP_PLUG_IN_IO_CHARSET_H_
#include
#include
#include
#if defined(PLATFORM_WINDOWS)
#else
#include
#include
#endif /* PLATFORM_WINDOWS */
#define LSP_UTF32_EOF lsp_utf32_t(-1)
namespace lsp
{
#if defined(PLATFORM_WINDOWS)
typedef uint32_t LCID;
ssize_t get_codepage(LCID locale, bool ansi = true);
ssize_t codepage_from_name(const char *charset);
/**
* This is a MultiByteToWideChar wrapping function that handles additional cases
* for non-MBCS encodings
*
* @param cp code page
* @param src source buffer
* @param nsrc number of bytes available in source buffer (will be updated on exit)
* @param dst destination buffer (can be NULL for just estimating the length)
* @param ndst number of characters in destination buffer (will be updated on exit,
* can be NULL or point to zero value for just estimating the length)
* @return number of UTF-16 characters written to destination buffer or negative error code
*/
ssize_t multibyte_to_widechar(size_t cp, const char *src, size_t *nsrc, lsp_utf16_t *dst, size_t *ndst);
/**
* This is a WideCharToMultiByte wrapping function that handles additional cases
* for non-MBCS encodings
*
* @param cp code page
* @param src source wide string to perform encoding
* @param nsrc number of characters available in source wide string (will be updated on exit)
* @param dst target string to perform encoding (can be NULL for just estimating the length)
* @param ndst number of bytes in destination buffer (will be updated on exit,
* can be NULL or point to zero value for just estimating the length)
* @return number of bytes written to destination buffer or negative error code
*/
ssize_t widechar_to_multibyte(size_t cp, const lsp_utf16_t *src, size_t *nsrc, char *dst, size_t *ndst);
#else
iconv_t init_iconv_to_wchar_t(const char *charset);
iconv_t init_iconv_from_wchar_t(const char *charset);
#endif /* PLATFORM_WINDOWS */
/**
* Read UTF-16 codepoint from the NULL-terminated UTF-16 string, replace invalid
* code sequence by 0xfffd code point
* @param str pointer to the NULL-terminated UTF-16 string
* @return code point
*/
lsp_utf32_t read_utf16le_codepoint(const lsp_utf16_t **str);
lsp_utf32_t read_utf16be_codepoint(const lsp_utf16_t **str);
inline lsp_utf32_t read_utf16_codepoint(const lsp_utf16_t **str) { return __IF_LEBE(read_utf16le_codepoint, read_utf16be_codepoint)(str); };
/**
* Read UTF-16 codepoint from the NULL-terminated UTF-16 string in streaming mode,
* replace invalid code sequence by 0xfffd code point
* @param str pointer to the pointer to the NULL-terminated UTF-16 string
* @param nsrc counter containing number of unread array elements
* @param force process data as there will be no future data on the input
* @return parsed code point or LSP_UTF32_EOF as end of sequence
*/
lsp_utf32_t read_utf16le_streaming(const lsp_utf16_t **str, size_t *nsrc, bool force);
lsp_utf32_t read_utf16be_streaming(const lsp_utf16_t **str, size_t *nsrc, bool force);
inline lsp_utf32_t read_utf16_streaming(const lsp_utf16_t **str, size_t *nsrc, bool force) { return __IF_LEBE(read_utf16le_streaming, read_utf16be_streaming)(str, nsrc, force); }
/**
* Read UTF-16 codepoint from the NULL-terminated UTF-8 string, replace invalid
* code sequence by 0xfffd code point
* @param str pointer to the NULL-terminated UTF-8 string
* @return code point
*/
lsp_utf32_t read_utf8_codepoint(const char **str);
/**
* Read UTF-8 codepoint from the NULL-terminated UTF-8 string in streaming mode,
* replace invalid code sequence by 0xfffd code point
* @param str pointer to the pointer to the NULL-terminated UTF-8 string
* @param nsrc counter containing number of unread array elements
* @param force process data as there will be no future data on the input
* @return parsed code point or LSP_UTF32_EOF as end of sequence
*/
lsp_utf32_t read_utf8_streaming(const char **str, size_t *nsrc, bool force);
/**
* Write UTF-8 code point to buffer, buffer should be of enough size
* @param str pointer to target buffer
* @param cp code point to write
*/
void write_utf8_codepoint(char **str, lsp_utf32_t cp);
/**
* Write UTF-16 code point to buffer, buffer should be of enough size
* @param str pointer to target buffer
* @param cp code point to write
*/
void write_utf16le_codepoint(lsp_utf16_t **str, lsp_utf32_t cp);
void write_utf16be_codepoint(lsp_utf16_t **str, lsp_utf32_t cp);
inline void write_utf16_codepoint(lsp_utf16_t **str, lsp_utf32_t cp) { return __IF_LEBE(write_utf16le_codepoint, write_utf16be_codepoint)(str, cp); }
/**
* Encode NULL-terminated UTF-8 string to NULL-terminated UTF-16 string
* @param str string to encode
* @return pointer to allocated UTF-16 string that should be free()'d after use
*/
lsp_utf16_t *utf8_to_utf16le(const char *str);
lsp_utf16_t *utf8_to_utf16be(const char *str);
inline lsp_utf16_t *utf8_to_utf16(const char *str) { return __IF_LEBE(utf8_to_utf16le, utf8_to_utf16be)(str); }
/**
* Encode NULL-terminated UTF-8 string to NULL-terminated UTF-16 string
* @param dst destination buffer to store data
* @param src string to encode
* @param count number of elements available in destination buffer
* @return number of elements produced (including zero-terminating character) or zero if there is not enough space
*/
size_t utf8_to_utf16le(lsp_utf16_t *dst, const char *src, size_t count);
size_t utf8_to_utf16be(lsp_utf16_t *dst, const char *src, size_t count);
inline size_t utf8_to_utf16(lsp_utf16_t *dst, const char *src, size_t count) { return __IF_LEBE(utf8_to_utf16le, utf8_to_utf16be)(dst, src, count); }
/**
* Encode sequence of UTF-8 characters into sequence of UTF-16 characters
* @param dst target buffer to store characters
* @param ndst number of elements available in target buffer
* @param src source buffer to read characters
* @param nsrc number of elements available in source buffer
* @param force force flag that treats the input block as last in the character sequence
* @return number of processed code points
*/
size_t utf8_to_utf16le(lsp_utf16_t *dst, size_t *ndst, const char *src, size_t *nsrc, bool force);
size_t utf8_to_utf16be(lsp_utf16_t *dst, size_t *ndst, const char *src, size_t *nsrc, bool force);
inline size_t utf8_to_utf16(lsp_utf16_t *dst, size_t *ndst, const char *src, size_t *nsrc, bool force) { return __IF_LEBE(utf8_to_utf16le, utf8_to_utf16be)(dst, ndst, src, nsrc, force); }
/**
* Encode NULL-terminated UTF-8 string to NULL-terminated UTF-32 string
* @param str string to encode
* @return pointer to allocated UTF-32 string that should be free()'d after use
*/
lsp_utf32_t *utf8_to_utf32le(const char *str);
lsp_utf32_t *utf8_to_utf32be(const char *str);
inline lsp_utf32_t *utf8_to_utf32(const char *str) { return __IF_LEBE(utf8_to_utf32le, utf8_to_utf32be)(str); };
/**
* Encode NULL-terminated UTF-8 string to NULL-terminated UTF-32 string
* @param dst destination buffer to store data
* @param src string to encode
* @param count number of elements available in destination buffer
* @return number of elements produced (including zero-terminating character) or negative value if there is not enough space
*/
size_t utf8_to_utf32le(lsp_utf32_t *dst, const char *src, size_t count);
size_t utf8_to_utf32be(lsp_utf32_t *dst, const char *src, size_t count);
inline size_t utf8_to_utf32(lsp_utf32_t *dst, const char *src, size_t count) { return __IF_LEBE(utf8_to_utf32le, utf8_to_utf32be)(dst, src, count); }
/**
* Encode sequence of UTF-8 characters into sequence of UTF-32 characters
* @param dst target buffer to store characters
* @param ndst number of elements available in target buffer
* @param src source buffer to read characters
* @param nsrc number of elements available in source buffer
* @param force force flag that treats the input block as last in the character sequence
* @return number of processed code points
*/
size_t utf8_to_utf32le(lsp_utf32_t *dst, size_t *ndst, const char *src, size_t *nsrc, bool force);
size_t utf8_to_utf32be(lsp_utf32_t *dst, size_t *ndst, const char *src, size_t *nsrc, bool force);
inline size_t utf8_to_utf32(lsp_utf32_t *dst, size_t *ndst, const char *src, size_t *nsrc, bool force) { return __IF_LEBE(utf8_to_utf32le, utf8_to_utf32be)(dst, ndst, src, nsrc, force); };
/**
* Encode NULL-terminated UTF-16 string to NULL-terminated UTF-8 string
* @param str string to encode
* @return pointer to allocated UTF-8 string that should be free()'d after use
*/
char *utf16le_to_utf8(const lsp_utf16_t *str);
char *utf16be_to_utf8(const lsp_utf16_t *str);
inline char *utf16_to_utf8(const lsp_utf16_t *str) { return __IF_LEBE(utf16le_to_utf8, utf16be_to_utf8)(str); };
/**
* Encode NULL-terminated UTF-16 string to NULL-terminated UTF-8 string
* @param dst destination buffer to store data
* @param src string to encode
* @param count number of elements available in destination buffer
* @return number of elements produced (including zero-terminating character) or negative value if there is not enough space
*/
size_t utf16le_to_utf8(char *dst, const lsp_utf16_t *src, size_t count);
size_t utf16be_to_utf8(char *dst, const lsp_utf16_t *src, size_t count);
inline size_t utf16_to_utf8(char *dst, const lsp_utf16_t *src, size_t count) { return __IF_LEBE(utf16le_to_utf8, utf16be_to_utf8)(dst, src, count); }
/**
* Encode sequence of UTF-16 characters into sequence of UTF-16 characters
* @param dst target buffer to store characters
* @param ndst number of elements available in target buffer
* @param src source buffer to read characters
* @param nsrc number of elements available in source buffer
* @param force force flag that treats the input block as last in the character sequence
* @return number of processed code points
*/
size_t utf16le_to_utf8(char *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force);
size_t utf16be_to_utf8(char *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force);
inline size_t utf16_to_utf8(char *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf16le_to_utf8, utf16be_to_utf8)(dst, ndst, src, nsrc, force); };
/**
* Encode NULL-terminated UTF-16 string to NULL-terminated UTF-32 string
* @param str string to encode
* @return pointer to allocated UTF-32 string that should be free()'d after use
*/
lsp_utf32_t *utf16le_to_utf32le(const lsp_utf16_t *str);
lsp_utf32_t *utf16le_to_utf32be(const lsp_utf16_t *str);
lsp_utf32_t *utf16be_to_utf32le(const lsp_utf16_t *str);
lsp_utf32_t *utf16be_to_utf32be(const lsp_utf16_t *str);
inline lsp_utf32_t *utf16le_to_utf32(const lsp_utf16_t *str) { return __IF_LEBE(utf16le_to_utf32le, utf16le_to_utf32be)(str); }
inline lsp_utf32_t *utf16be_to_utf32(const lsp_utf16_t *str) { return __IF_LEBE(utf16be_to_utf32le, utf16be_to_utf32be)(str); }
inline lsp_utf32_t *utf16_to_utf32le(const lsp_utf16_t *str) { return __IF_LEBE(utf16le_to_utf32le, utf16be_to_utf32le)(str); }
inline lsp_utf32_t *utf16_to_utf32be(const lsp_utf16_t *str) { return __IF_LEBE(utf16le_to_utf32be, utf16be_to_utf32be)(str); }
inline lsp_utf32_t *utf16_to_utf32(const lsp_utf16_t *str) { return __IF_LEBE(utf16le_to_utf32le, utf16be_to_utf32be)(str); }
/**
* Encode NULL-terminated UTF-16 string to NULL-terminated UTF-32 string
* @param dst destination buffer to store data
* @param src string to encode
* @param count number of elements available in destination buffer
* @return number of elements produced (including zero-terminating character) or negative value if there is not enough space
*/
size_t utf16le_to_utf32le(lsp_utf32_t *dst, const lsp_utf16_t *src, size_t count);
size_t utf16le_to_utf32be(lsp_utf32_t *dst, const lsp_utf16_t *src, size_t count);
size_t utf16be_to_utf32le(lsp_utf32_t *dst, const lsp_utf16_t *src, size_t count);
size_t utf16be_to_utf32be(lsp_utf32_t *dst, const lsp_utf16_t *src, size_t count);
inline size_t utf16le_to_utf32(lsp_utf32_t *dst, const lsp_utf16_t *src, size_t count) { return __IF_LEBE(utf16le_to_utf32le, utf16le_to_utf32be)(dst, src, count); }
inline size_t utf16be_to_utf32(lsp_utf32_t *dst, const lsp_utf16_t *src, size_t count) { return __IF_LEBE(utf16be_to_utf32le, utf16be_to_utf32be)(dst, src, count); }
inline size_t utf16_to_utf32le(lsp_utf32_t *dst, const lsp_utf16_t *src, size_t count) { return __IF_LEBE(utf16le_to_utf32le, utf16be_to_utf32le)(dst, src, count); }
inline size_t utf16_to_utf32be(lsp_utf32_t *dst, const lsp_utf16_t *src, size_t count) { return __IF_LEBE(utf16le_to_utf32be, utf16be_to_utf32be)(dst, src, count); }
inline size_t utf16_to_utf32(lsp_utf32_t *dst, const lsp_utf16_t *src, size_t count) { return __IF_LEBE(utf16le_to_utf32le, utf16be_to_utf32be)(dst, src, count); }
/**
* Encode sequence of UTF-16 characters into sequence of UTF-32 characters
* @param dst target buffer to store characters
* @param ndst number of elements available in target buffer
* @param src source buffer to read characters
* @param nsrc number of elements available in source buffer
* @param force force flag that treats the input block as last in the character sequence
* @return number of processed code points
*/
size_t utf16le_to_utf32le(lsp_utf32_t *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force);
size_t utf16le_to_utf32be(lsp_utf32_t *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force);
size_t utf16be_to_utf32le(lsp_utf32_t *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force);
size_t utf16be_to_utf32be(lsp_utf32_t *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force);
inline size_t utf16le_to_utf32(lsp_utf32_t *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf16le_to_utf32le, utf16le_to_utf32be)(dst, ndst, src, nsrc, force); }
inline size_t utf16be_to_utf32(lsp_utf32_t *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf16be_to_utf32le, utf16be_to_utf32be)(dst, ndst, src, nsrc, force); }
inline size_t utf16_to_utf32le(lsp_utf32_t *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf16le_to_utf32le, utf16be_to_utf32le)(dst, ndst, src, nsrc, force); }
inline size_t utf16_to_utf32be(lsp_utf32_t *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf16le_to_utf32be, utf16be_to_utf32be)(dst, ndst, src, nsrc, force); }
inline size_t utf16_to_utf32(lsp_utf32_t *dst, size_t *ndst, const lsp_utf16_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf16le_to_utf32le, utf16be_to_utf32be)(dst, ndst, src, nsrc, force); }
/**
* Encode NULL-terminated UTF-32 string to NULL-terminated UTF-8 string
* @param str string to encode
* @return pointer to allocated UTF-16 string that should be free()'d after use
*/
char *utf32le_to_utf8(const lsp_utf32_t *str);
char *utf32be_to_utf8(const lsp_utf32_t *str);
inline char *utf32_to_utf8(const lsp_utf32_t *str) { return __IF_LEBE(utf32le_to_utf8, utf32be_to_utf8)(str); };
/**
* Encode NULL-terminated UTF-32 string to NULL-terminated UTF-8 string
* @param dst destination buffer to store data
* @param src string to encode
* @param count number of elements available in destination buffer
* @return number of elements produced (including zero-terminating character) or negative value if there is not enough space
*/
size_t utf32le_to_utf8(char *dst, const lsp_utf32_t *src, size_t count);
size_t utf32be_to_utf8(char *dst, const lsp_utf32_t *src, size_t count);
inline size_t utf32_to_utf8(char *dst, const lsp_utf32_t *src, size_t count) { return __IF_LEBE(utf32le_to_utf8, utf32be_to_utf8)(dst, src, count); };
/**
* Encode sequence of UTF-8 characters into sequence of UTF-16 characters
* @param dst target buffer to store characters
* @param ndst number of elements available in target buffer
* @param src source buffer to read characters
* @param nsrc number of elements available in source buffer
* @param force force flag that treats the input block as last in the character sequence
* @return number of processed code points
*/
size_t utf32le_to_utf8(char *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force);
size_t utf32be_to_utf8(char *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force);
inline size_t utf32_to_utf8(char *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf32le_to_utf8, utf32be_to_utf8)(dst, ndst, src, nsrc, force); }
/**
* Encode NULL-terminated UTF-32 string to NULL-terminated UTF-16 string
* @param str string to encode
* @return pointer to allocated UTF-16 string that should be free()'d after use
*/
lsp_utf16_t *utf32le_to_utf16le(const lsp_utf32_t *str);
lsp_utf16_t *utf32le_to_utf16be(const lsp_utf32_t *str);
lsp_utf16_t *utf32be_to_utf16le(const lsp_utf32_t *str);
lsp_utf16_t *utf32be_to_utf16be(const lsp_utf32_t *str);
inline lsp_utf16_t *utf32le_to_utf16(const lsp_utf32_t *str) { return __IF_LEBE(utf32le_to_utf16le, utf32le_to_utf16be)(str); }
inline lsp_utf16_t *utf32be_to_utf16(const lsp_utf32_t *str) { return __IF_LEBE(utf32be_to_utf16le, utf32be_to_utf16be)(str); }
inline lsp_utf16_t *utf32_to_utf16le(const lsp_utf32_t *str) { return __IF_LEBE(utf32le_to_utf16le, utf32be_to_utf16le)(str); }
inline lsp_utf16_t *utf32_to_utf16be(const lsp_utf32_t *str) { return __IF_LEBE(utf32le_to_utf16be, utf32be_to_utf16be)(str); }
inline lsp_utf16_t *utf32_to_utf16(const lsp_utf32_t *str) { return __IF_LEBE(utf32le_to_utf16le, utf32be_to_utf16be)(str); }
/**
* Encode NULL-terminated UTF-32 string to NULL-terminated UTF-16 string
* @param dst destination buffer to store data
* @param src string to encode
* @param count number of elements available in destination buffer
* @return number of elements produced (including zero-terminating character) or negative value if there is not enough space
*/
size_t utf32le_to_utf16le(lsp_utf16_t *dst, const lsp_utf32_t *src, size_t count);
size_t utf32le_to_utf16be(lsp_utf16_t *dst, const lsp_utf32_t *src, size_t count);
size_t utf32be_to_utf16le(lsp_utf16_t *dst, const lsp_utf32_t *src, size_t count);
size_t utf32be_to_utf16be(lsp_utf16_t *dst, const lsp_utf32_t *src, size_t count);
inline size_t utf32le_to_utf16(lsp_utf16_t *dst, const lsp_utf32_t *src, size_t count) { return __IF_LEBE(utf32le_to_utf16le, utf32le_to_utf16be)(dst, src, count); }
inline size_t utf32be_to_utf16(lsp_utf16_t *dst, const lsp_utf32_t *src, size_t count) { return __IF_LEBE(utf32be_to_utf16le, utf32be_to_utf16be)(dst, src, count); }
inline size_t utf32_to_utf16le(lsp_utf16_t *dst, const lsp_utf32_t *src, size_t count) { return __IF_LEBE(utf32le_to_utf16le, utf32be_to_utf16le)(dst, src, count); }
inline size_t utf32_to_utf16be(lsp_utf16_t *dst, const lsp_utf32_t *src, size_t count) { return __IF_LEBE(utf32le_to_utf16be, utf32be_to_utf16be)(dst, src, count); }
inline size_t utf32_to_utf16(lsp_utf16_t *dst, const lsp_utf32_t *src, size_t count) { return __IF_LEBE(utf32le_to_utf16le, utf32be_to_utf16be)(dst, src, count); }
/**
* Encode sequence of UTF-8 characters into sequence of UTF-16 characters
* @param dst target buffer to store characters
* @param ndst number of elements available in target buffer
* @param src source buffer to read characters
* @param nsrc number of elements available in source buffer
* @param force force flag that treats the input block as last in the character sequence
* @return number of processed code points
*/
size_t utf32le_to_utf16le(lsp_utf16_t *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force);
size_t utf32le_to_utf16be(lsp_utf16_t *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force);
size_t utf32be_to_utf16le(lsp_utf16_t *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force);
size_t utf32be_to_utf16be(lsp_utf16_t *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force);
inline size_t utf32_to_utf16le(lsp_utf16_t *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf32le_to_utf16le, utf32be_to_utf16le)(dst, ndst, src, nsrc, force); }
inline size_t utf32_to_utf16be(lsp_utf16_t *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf32le_to_utf16be, utf32be_to_utf16be)(dst, ndst, src, nsrc, force); }
inline size_t utf32le_to_utf16(lsp_utf16_t *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf32le_to_utf16le, utf32le_to_utf16be)(dst, ndst, src, nsrc, force); }
inline size_t utf32be_to_utf16(lsp_utf16_t *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf32be_to_utf16le, utf32be_to_utf16be)(dst, ndst, src, nsrc, force); }
inline size_t utf32_to_utf16(lsp_utf16_t *dst, size_t *ndst, const lsp_utf32_t *src, size_t *nsrc, bool force) { return __IF_LEBE(utf32le_to_utf16le, utf32be_to_utf16be)(dst, ndst, src, nsrc, force); }
/**
* Compare two character sequences.
* @param s1 character sequence 1
* @param s2 character sequence 2
* @param count number of characters to compare, you must be sure that both sequences have at least count characters
* @return comparison result
*/
#ifdef ARCH_LE
inline int wchar_cmp(const lsp_wchar_t *s1, const lsp_wchar_t *s2, size_t count) { return ::memcmp(s1, s2, count * sizeof(lsp_wchar_t)); }
#else
int wchar_cmp(const lsp_wchar_t *s1, const lsp_wchar_t *s2, size_t count);
#endif
int wchar_casecmp(const lsp_wchar_t *s1, const lsp_wchar_t *s2, size_t count);
/**
* Convert character to lower case
* @param c character to convert
* @return converted character
*/
lsp_wchar_t to_lower(lsp_wchar_t c);
/**
* Convert character to upper case
* @param c character to convert
* @return converted character
*/
lsp_wchar_t to_upper(lsp_wchar_t c);
} /* namespace lsp */
#endif /* LSP_PLUG_IN_IO_CHARSET_H_ */