iqbalrifai
/
Aegisub
mirror of https://github.com/odrling/Aegisub
1
0
Fork 0
Code Issues Releases Wiki Activity
Aegisub/vendor/iconv/libiconv/loop_wchar.h

459 lines
15 KiB
C
Raw Blame History

/*
* Copyright (C) 2000-2002, 2005-2006, 2008 Free Software Foundation, Inc.
* This file is part of the GNU LIBICONV Library.
*
* The GNU LIBICONV Library is free software; you can redistribute it
* and/or modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* The GNU LIBICONV Library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with the GNU LIBICONV Library; see the file COPYING.LIB.
* If not, write to the Free Software Foundation, Inc., 51 Franklin Street,
* Fifth Floor, Boston, MA 02110-1301, USA.
*/
/* This file defines three conversion loops:
- from wchar_t to anything else,
- from anything else to wchar_t,
- from wchar_t to wchar_t.
*/
#if HAVE_WCRTOMB || HAVE_MBRTOWC
# include <wchar.h>
# define BUF_SIZE 64 /* assume MB_LEN_MAX <= 64 */
/* Some systems, like BeOS, have multibyte encodings but lack mbstate_t. */
extern size_t mbrtowc ();
# ifdef mbstate_t
# define mbrtowc(pwc, s, n, ps) (mbrtowc)(pwc, s, n, 0)
# define mbsinit(ps) 1
# endif
# ifndef mbsinit
# if !HAVE_MBSINIT
# define mbsinit(ps) 1
# endif
# endif
#endif
/*
* The first two conversion loops have an extended conversion descriptor.
*/
struct wchar_conv_struct {
struct conv_struct parent;
#if HAVE_WCRTOMB || HAVE_MBRTOWC
mbstate_t state;
#endif
};
#if HAVE_WCRTOMB
/* From wchar_t to anything else. */
#ifndef LIBICONV_PLUG
#if 0
struct wc_to_mb_fallback_locals {
struct wchar_conv_struct * l_wcd;
char* l_outbuf;
size_t l_outbytesleft;
int l_errno;
};
/* A callback that writes a string given in the locale encoding. */
static void wc_to_mb_write_replacement (const char *buf, size_t buflen,
void* callback_arg)
{
struct wc_to_mb_fallback_locals * plocals =
(struct wc_to_mb_fallback_locals *) callback_arg;
/* Do nothing if already encountered an error in a previous call. */
if (plocals->l_errno == 0) {
/* Attempt to convert the passed buffer to the target encoding.
Here we don't support characters split across multiple calls. */
const char* bufptr = buf;
size_t bufleft = buflen;
size_t res = unicode_loop_convert(&plocals->l_wcd->parent,
&bufptr,&bufleft,
&plocals->l_outbuf,&plocals->l_outbytesleft);
if (res == (size_t)(-1)) {
if (errno == EILSEQ || errno == EINVAL)
/* Invalid buf contents. */
plocals->l_errno = EILSEQ;
else if (errno == E2BIG)
/* Output buffer too small. */
plocals->l_errno = E2BIG;
else
abort();
} else {
/* Successful conversion. */
if (bufleft > 0)
abort();
}
}
}
#else
struct wc_to_mb_fallback_locals {
char* l_outbuf;
size_t l_outbytesleft;
int l_errno;
};
/* A callback that writes a string given in the target encoding. */
static void wc_to_mb_write_replacement (const char *buf, size_t buflen,
void* callback_arg)
{
struct wc_to_mb_fallback_locals * plocals =
(struct wc_to_mb_fallback_locals *) callback_arg;
/* Do nothing if already encountered an error in a previous call. */
if (plocals->l_errno == 0) {
/* Attempt to copy the passed buffer to the output buffer. */
if (plocals->l_outbytesleft < buflen)
plocals->l_errno = E2BIG;
else {
memcpy(plocals->l_outbuf, buf, buflen);
plocals->l_outbuf += buflen;
plocals->l_outbytesleft -= buflen;
}
}
}
#endif
#endif /* !LIBICONV_PLUG */
static size_t wchar_from_loop_convert (iconv_t icd,
const char* * inbuf, size_t *inbytesleft,
char* * outbuf, size_t *outbytesleft)
{
struct wchar_conv_struct * wcd = (struct wchar_conv_struct *) icd;
size_t result = 0;
while (*inbytesleft >= sizeof(wchar_t)) {
const wchar_t * inptr = (const wchar_t *) *inbuf;
size_t inleft = *inbytesleft;
char buf[BUF_SIZE];
mbstate_t state = wcd->state;
size_t bufcount = 0;
while (inleft >= sizeof(wchar_t)) {
/* Convert one wchar_t to multibyte representation. */
size_t count = wcrtomb(buf+bufcount,*inptr,&state);
if (count == (size_t)(-1)) {
/* Invalid input. */
if (wcd->parent.discard_ilseq) {
count = 0;
}
#ifndef LIBICONV_PLUG
else if (wcd->parent.fallbacks.wc_to_mb_fallback != NULL) {
/* Drop the contents of buf[] accumulated so far, and instead
pass all queued wide characters to the fallback handler. */
struct wc_to_mb_fallback_locals locals;
const wchar_t * fallback_inptr;
#if 0
locals.l_wcd = wcd;
#endif
locals.l_outbuf = *outbuf;
locals.l_outbytesleft = *outbytesleft;
locals.l_errno = 0;
for (fallback_inptr = (const wchar_t *) *inbuf;
fallback_inptr <= inptr;
fallback_inptr++)
wcd->parent.fallbacks.wc_to_mb_fallback(*fallback_inptr,
wc_to_mb_write_replacement,
&locals,
wcd->parent.fallbacks.data);
if (locals.l_errno != 0) {
errno = locals.l_errno;
return -1;
}
wcd->state = state;
*inbuf = (const char *) (inptr + 1);
*inbytesleft = inleft - sizeof(wchar_t);
*outbuf = locals.l_outbuf;
*outbytesleft = locals.l_outbytesleft;
result += 1;
break;
}
#endif
else {
errno = EILSEQ;
return -1;
}
}
inptr++;
inleft -= sizeof(wchar_t);
bufcount += count;
if (count == 0) {
/* Continue, append next wchar_t. */
} else {
/* Attempt to convert the accumulated multibyte representations
to the target encoding. */
const char* bufptr = buf;
size_t bufleft = bufcount;
char* outptr = *outbuf;
size_t outleft = *outbytesleft;
size_t res = unicode_loop_convert(&wcd->parent,
&bufptr,&bufleft,
&outptr,&outleft);
if (res == (size_t)(-1)) {
if (errno == EILSEQ)
/* Invalid input. */
return -1;
else if (errno == E2BIG)
/* Output buffer too small. */
return -1;
else if (errno == EINVAL) {
/* Continue, append next wchar_t, but avoid buffer overrun. */
if (bufcount + MB_CUR_MAX > BUF_SIZE)
abort();
} else
abort();
} else {
/* Successful conversion. */
wcd->state = state;
*inbuf = (const char *) inptr;
*inbytesleft = inleft;
*outbuf = outptr;
*outbytesleft = outleft;
result += res;
break;
}
}
}
}
return result;
}
static size_t wchar_from_loop_reset (iconv_t icd,
char* * outbuf, size_t *outbytesleft)
{
struct wchar_conv_struct * wcd = (struct wchar_conv_struct *) icd;
if (outbuf == NULL || *outbuf == NULL) {
/* Reset the states. */
memset(&wcd->state,'\0',sizeof(mbstate_t));
return unicode_loop_reset(&wcd->parent,NULL,NULL);
} else {
if (!mbsinit(&wcd->state)) {
mbstate_t state = wcd->state;
char buf[BUF_SIZE];
size_t bufcount = wcrtomb(buf,(wchar_t)0,&state);
if (bufcount == (size_t)(-1) || bufcount == 0 || buf[bufcount-1] != '\0')
abort();
else {
const char* bufptr = buf;
size_t bufleft = bufcount-1;
char* outptr = *outbuf;
size_t outleft = *outbytesleft;
size_t res = unicode_loop_convert(&wcd->parent,
&bufptr,&bufleft,
&outptr,&outleft);
if (res == (size_t)(-1)) {
if (errno == E2BIG)
return -1;
else
abort();
} else {
res = unicode_loop_reset(&wcd->parent,&outptr,&outleft);
if (res == (size_t)(-1))
return res;
else {
/* Successful. */
wcd->state = state;
*outbuf = outptr;
*outbytesleft = outleft;
return 0;
}
}
}
} else
return unicode_loop_reset(&wcd->parent,outbuf,outbytesleft);
}
}
#endif
#if HAVE_MBRTOWC
/* From anything else to wchar_t. */
#ifndef LIBICONV_PLUG
struct mb_to_wc_fallback_locals {
char* l_outbuf;
size_t l_outbytesleft;
int l_errno;
};
static void mb_to_wc_write_replacement (const wchar_t *buf, size_t buflen,
void* callback_arg)
{
struct mb_to_wc_fallback_locals * plocals =
(struct mb_to_wc_fallback_locals *) callback_arg;
/* Do nothing if already encountered an error in a previous call. */
if (plocals->l_errno == 0) {
/* Attempt to copy the passed buffer to the output buffer. */
if (plocals->l_outbytesleft < sizeof(wchar_t)*buflen)
plocals->l_errno = E2BIG;
else {
for (; buflen > 0; buf++, buflen--) {
*(wchar_t*) plocals->l_outbuf = *buf;
plocals->l_outbuf += sizeof(wchar_t);
plocals->l_outbytesleft -= sizeof(wchar_t);
}
}
}
}
#endif /* !LIBICONV_PLUG */
static size_t wchar_to_loop_convert (iconv_t icd,
const char* * inbuf, size_t *inbytesleft,
char* * outbuf, size_t *outbytesleft)
{
struct wchar_conv_struct * wcd = (struct wchar_conv_struct *) icd;
size_t result = 0;
while (*inbytesleft > 0) {
size_t incount;
for (incount = 1; incount <= *inbytesleft; incount++) {
char buf[BUF_SIZE];
const char* inptr = *inbuf;
size_t inleft = incount;
char* bufptr = buf;
size_t bufleft = BUF_SIZE;
size_t res = unicode_loop_convert(&wcd->parent,
&inptr,&inleft,
&bufptr,&bufleft);
if (res == (size_t)(-1)) {
if (errno == EILSEQ)
/* Invalid input. */
return -1;
else if (errno == EINVAL) {
/* Incomplete input. Next try with one more input byte. */
} else
/* E2BIG shouldn't occur. */
abort();
} else {
/* Successful conversion. */
size_t bufcount = bufptr-buf; /* = BUF_SIZE-bufleft */
mbstate_t state = wcd->state;
wchar_t wc;
res = mbrtowc(&wc,buf,bufcount,&state);
if (res == (size_t)(-2)) {
/* Next try with one more input byte. */
} else {
if (res == (size_t)(-1)) {
/* Invalid input. */
if (wcd->parent.discard_ilseq) {
}
#ifndef LIBICONV_PLUG
else if (wcd->parent.fallbacks.mb_to_wc_fallback != NULL) {
/* Drop the contents of buf[] accumulated so far, and instead
pass all queued chars to the fallback handler. */
struct mb_to_wc_fallback_locals locals;
locals.l_outbuf = *outbuf;
locals.l_outbytesleft = *outbytesleft;
locals.l_errno = 0;
wcd->parent.fallbacks.mb_to_wc_fallback(*inbuf, incount,
mb_to_wc_write_replacement,
&locals,
wcd->parent.fallbacks.data);
if (locals.l_errno != 0) {
errno = locals.l_errno;
return -1;
}
/* Restoring the state is not needed because it is the initial
state anyway: For all known locale encodings, the multibyte
to wchar_t conversion doesn't have shift state, and we have
excluded partial accumulated characters. */
/* wcd->state = state; */
*inbuf += incount;
*inbytesleft -= incount;
*outbuf = locals.l_outbuf;
*outbytesleft = locals.l_outbytesleft;
result += 1;
break;
}
#endif
else
return -1;
} else {
if (*outbytesleft < sizeof(wchar_t)) {
errno = E2BIG;
return -1;
}
*(wchar_t*) *outbuf = wc;
/* Restoring the state is not needed because it is the initial
state anyway: For all known locale encodings, the multibyte
to wchar_t conversion doesn't have shift state, and we have
excluded partial accumulated characters. */
/* wcd->state = state; */
*outbuf += sizeof(wchar_t);
*outbytesleft -= sizeof(wchar_t);
}
*inbuf += incount;
*inbytesleft -= incount;
result += res;
break;
}
}
}
}
return result;
}
static size_t wchar_to_loop_reset (iconv_t icd,
char* * outbuf, size_t *outbytesleft)
{
struct wchar_conv_struct * wcd = (struct wchar_conv_struct *) icd;
size_t res = unicode_loop_reset(&wcd->parent,outbuf,outbytesleft);
if (res == (size_t)(-1))
return res;
memset(&wcd->state,0,sizeof(mbstate_t));
return 0;
}
#endif
/* From wchar_t to wchar_t. */
static size_t wchar_id_loop_convert (iconv_t icd,
const char* * inbuf, size_t *inbytesleft,
char* * outbuf, size_t *outbytesleft)
{
struct conv_struct * cd = (struct conv_struct *) icd;
const wchar_t* inptr = (const wchar_t*) *inbuf;
size_t inleft = *inbytesleft / sizeof(wchar_t);
wchar_t* outptr = (wchar_t*) *outbuf;
size_t outleft = *outbytesleft / sizeof(wchar_t);
size_t count = (inleft <= outleft ? inleft : outleft);
if (count > 0) {
*inbytesleft -= count * sizeof(wchar_t);
*outbytesleft -= count * sizeof(wchar_t);
do {
wchar_t wc = *inptr++;
*outptr++ = wc;
#ifndef LIBICONV_PLUG
if (cd->hooks.wc_hook)
(*cd->hooks.wc_hook)(wc, cd->hooks.data);
#endif
} while (--count > 0);
*inbuf = (const char*) inptr;
*outbuf = (char*) outptr;
}
return 0;
}
static size_t wchar_id_loop_reset (iconv_t icd,
char* * outbuf, size_t *outbytesleft)
{
return 0;
}
Reference in New Issue View Git Blame Copy Permalink