#include <libioP.h>
#ifdef _LIBC
# include <dlfcn.h>
# include <wchar.h>
# include <locale/localeinfo.h>
# include <wcsmbs/wcsmbsload.h>
# include <iconv/gconv_int.h>
#endif
#include <stdlib.h>
#include <string.h>
#if defined(_LIBC) || defined(_GLIBCPP_USE_WCHAR_T)
# include <langinfo.h>
#endif
#ifdef _GLIBCPP_USE_WCHAR_T
static enum __codecvt_result do_out (struct _IO_codecvt *codecvt,
__c_mbstate_t *statep,
const wchar_t *from_start,
const wchar_t *from_end,
const wchar_t **from_stop, char *to_start,
char *to_end, char **to_stop);
static enum __codecvt_result do_unshift (struct _IO_codecvt *codecvt,
__c_mbstate_t *statep, char *to_start,
char *to_end, char **to_stop);
static enum __codecvt_result do_in (struct _IO_codecvt *codecvt,
__c_mbstate_t *statep,
const char *from_start,
const char *from_end,
const char **from_stop, wchar_t *to_start,
wchar_t *to_end, wchar_t **to_stop);
static int do_encoding (struct _IO_codecvt *codecvt);
static int do_length (struct _IO_codecvt *codecvt, __c_mbstate_t *statep,
const char *from_start,
const char *from_end, _IO_size_t max);
static int do_max_length (struct _IO_codecvt *codecvt);
static int do_always_noconv (struct _IO_codecvt *codecvt);
struct _IO_codecvt __libio_codecvt =
{
.__codecvt_destr = NULL,
.__codecvt_do_out = do_out,
.__codecvt_do_unshift = do_unshift,
.__codecvt_do_in = do_in,
.__codecvt_do_encoding = do_encoding,
.__codecvt_do_always_noconv = do_always_noconv,
.__codecvt_do_length = do_length,
.__codecvt_do_max_length = do_max_length
};
#ifdef _LIBC
static struct __gconv_trans_data libio_translit =
{
.__trans_fct = __gconv_transliterate
};
#endif
#endif
#undef _IO_fwide
int
_IO_fwide (fp, mode)
_IO_FILE *fp;
int mode;
{
mode = mode < 0 ? -1 : (mode == 0 ? 0 : 1);
if (mode == 0 || fp->_mode != 0)
return fp->_mode;
if (mode > 0)
{
#ifdef _GLIBCPP_USE_WCHAR_T
struct _IO_codecvt *cc = fp->_codecvt;
fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_end;
fp->_wide_data->_IO_write_ptr = fp->_wide_data->_IO_write_base;
#ifdef _LIBC
{
struct gconv_fcts fcts;
memset (&fp->_wide_data->_IO_state, '\0', sizeof (__c_mbstate_t));
memset (&fp->_wide_data->_IO_last_state, '\0', sizeof (__c_mbstate_t));
__wcsmbs_clone_conv (&fcts);
*cc = __libio_codecvt;
cc->__cd_in.__cd.__nsteps = 1;
cc->__cd_in.__cd.__steps = fcts.towc;
cc->__cd_in.__cd.__data[0].__invocation_counter = 0;
cc->__cd_in.__cd.__data[0].__internal_use = 1;
cc->__cd_in.__cd.__data[0].__flags = __GCONV_IS_LAST;
cc->__cd_in.__cd.__data[0].__statep = &fp->_wide_data->_IO_state;
cc->__cd_in.__cd.__data[0].__trans = NULL;
cc->__cd_out.__cd.__nsteps = 1;
cc->__cd_out.__cd.__steps = fcts.tomb;
cc->__cd_out.__cd.__data[0].__invocation_counter = 0;
cc->__cd_out.__cd.__data[0].__internal_use = 1;
cc->__cd_out.__cd.__data[0].__flags = __GCONV_IS_LAST;
cc->__cd_out.__cd.__data[0].__statep = &fp->_wide_data->_IO_state;
cc->__cd_out.__cd.__data[0].__trans = &libio_translit;
}
#else
# ifdef _GLIBCPP_USE_WCHAR_T
{
#if 0
const char *internal_ccs = _G_INTERNAL_CCS;
const char *external_ccs = nl_langinfo(CODESET);
if (external_ccs == NULL)
external_ccs = "ISO-8859-1";
cc->__cd_in = iconv_open (internal_ccs, external_ccs);
if (cc->__cd_in != (iconv_t) -1)
cc->__cd_out = iconv_open (external_ccs, internal_ccs);
#endif
}
# else
# error "somehow determine this from LC_CTYPE"
# endif
#endif
((struct _IO_FILE_plus *) fp)->vtable = fp->_wide_data->_wide_vtable;
#else
mode = fp->_mode;
#endif
}
fp->_mode = mode;
return mode;
}
#ifdef weak_alias
weak_alias (_IO_fwide, fwide)
#endif
#ifdef _GLIBCPP_USE_WCHAR_T
static enum __codecvt_result
do_out (struct _IO_codecvt *codecvt, __c_mbstate_t *statep,
const wchar_t *from_start, const wchar_t *from_end,
const wchar_t **from_stop, char *to_start, char *to_end,
char **to_stop)
{
enum __codecvt_result result;
#ifdef _LIBC
struct __gconv_step *gs = codecvt->__cd_out.__cd.__steps;
int status;
size_t dummy;
const unsigned char *from_start_copy = (unsigned char *) from_start;
codecvt->__cd_out.__cd.__data[0].__outbuf = to_start;
codecvt->__cd_out.__cd.__data[0].__outbufend = to_end;
codecvt->__cd_out.__cd.__data[0].__statep = statep;
status = DL_CALL_FCT (gs->__fct,
(gs, codecvt->__cd_out.__cd.__data, &from_start_copy,
(const unsigned char *) from_end, NULL,
&dummy, 0, 0));
*from_stop = (wchar_t *) from_start_copy;
*to_stop = codecvt->__cd_out.__cd.__data[0].__outbuf;
switch (status)
{
case __GCONV_OK:
case __GCONV_EMPTY_INPUT:
result = __codecvt_ok;
break;
case __GCONV_FULL_OUTPUT:
case __GCONV_INCOMPLETE_INPUT:
result = __codecvt_partial;
break;
default:
result = __codecvt_error;
break;
}
#else
# ifdef _GLIBCPP_USE_WCHAR_T
size_t res;
const char *from_start_copy = (const char *) from_start;
size_t from_len = from_end - from_start;
char *to_start_copy = to_start;
size_t to_len = to_end - to_start;
res = iconv (codecvt->__cd_out, &from_start_copy, &from_len,
&to_start_copy, &to_len);
if (res == 0 || from_len == 0)
result = __codecvt_ok;
else if (to_len < codecvt->__codecvt_do_max_length (codecvt))
result = __codecvt_partial;
else
result = __codecvt_error;
# else
result = __codecvt_error;
# endif
#endif
return result;
}
static enum __codecvt_result
do_unshift (struct _IO_codecvt *codecvt, __c_mbstate_t *statep,
char *to_start, char *to_end, char **to_stop)
{
enum __codecvt_result result;
#ifdef _LIBC
struct __gconv_step *gs = codecvt->__cd_out.__cd.__steps;
int status;
size_t dummy;
codecvt->__cd_out.__cd.__data[0].__outbuf = to_start;
codecvt->__cd_out.__cd.__data[0].__outbufend = to_end;
codecvt->__cd_out.__cd.__data[0].__statep = statep;
status = DL_CALL_FCT (gs->__fct,
(gs, codecvt->__cd_out.__cd.__data, NULL, NULL,
NULL, &dummy, 1, 0));
*to_stop = codecvt->__cd_out.__cd.__data[0].__outbuf;
switch (status)
{
case __GCONV_OK:
case __GCONV_EMPTY_INPUT:
result = __codecvt_ok;
break;
case __GCONV_FULL_OUTPUT:
case __GCONV_INCOMPLETE_INPUT:
result = __codecvt_partial;
break;
default:
result = __codecvt_error;
break;
}
#else
# ifdef _GLIBCPP_USE_WCHAR_T
size_t res;
char *to_start_copy = (char *) to_start;
size_t to_len = to_end - to_start;
res = iconv (codecvt->__cd_out, NULL, NULL, &to_start_copy, &to_len);
if (res == 0)
result = __codecvt_ok;
else if (to_len < codecvt->__codecvt_do_max_length (codecvt))
result = __codecvt_partial;
else
result = __codecvt_error;
# else
result = __codecvt_error;
# endif
#endif
return result;
}
static enum __codecvt_result
do_in (struct _IO_codecvt *codecvt, __c_mbstate_t *statep,
const char *from_start, const char *from_end, const char **from_stop,
wchar_t *to_start, wchar_t *to_end, wchar_t **to_stop)
{
enum __codecvt_result result;
#ifdef _LIBC
struct __gconv_step *gs = codecvt->__cd_in.__cd.__steps;
int status;
size_t dummy;
const unsigned char *from_start_copy = (unsigned char *) from_start;
codecvt->__cd_in.__cd.__data[0].__outbuf = (char *) to_start;
codecvt->__cd_in.__cd.__data[0].__outbufend = (char *) to_end;
codecvt->__cd_in.__cd.__data[0].__statep = statep;
status = DL_CALL_FCT (gs->__fct,
(gs, codecvt->__cd_in.__cd.__data, &from_start_copy,
from_end, NULL, &dummy, 0, 0));
*from_stop = from_start_copy;
*to_stop = (wchar_t *) codecvt->__cd_in.__cd.__data[0].__outbuf;
switch (status)
{
case __GCONV_OK:
case __GCONV_EMPTY_INPUT:
result = __codecvt_ok;
break;
case __GCONV_FULL_OUTPUT:
case __GCONV_INCOMPLETE_INPUT:
result = __codecvt_partial;
break;
default:
result = __codecvt_error;
break;
}
#else
# ifdef _GLIBCPP_USE_WCHAR_T
size_t res;
const char *from_start_copy = (const char *) from_start;
size_t from_len = from_end - from_start;
char *to_start_copy = (char *) from_start;
size_t to_len = to_end - to_start;
res = iconv (codecvt->__cd_in, &from_start_copy, &from_len,
&to_start_copy, &to_len);
if (res == 0)
result = __codecvt_ok;
else if (to_len == 0)
result = __codecvt_partial;
else if (from_len < codecvt->__codecvt_do_max_length (codecvt))
result = __codecvt_partial;
else
result = __codecvt_error;
# else
result = __codecvt_error;
# endif
#endif
return result;
}
static int
do_encoding (struct _IO_codecvt *codecvt)
{
#ifdef _LIBC
if (codecvt->__cd_in.__cd.__steps[0].__stateful)
return -1;
if (codecvt->__cd_in.__cd.__steps[0].__min_needed_from
!= codecvt->__cd_in.__cd.__steps[0].__max_needed_from)
return 0;
return codecvt->__cd_in.__cd.__steps[0].__min_needed_from;
#else
return -1;
#endif
}
static int
do_always_noconv (struct _IO_codecvt *codecvt)
{
return 0;
}
static int
do_length (struct _IO_codecvt *codecvt, __c_mbstate_t *statep,
const char *from_start, const char *from_end, _IO_size_t max)
{
int result;
#ifdef _LIBC
const unsigned char *cp = (const unsigned char *) from_start;
wchar_t to_buf[max];
struct __gconv_step *gs = codecvt->__cd_in.__cd.__steps;
int status;
size_t dummy;
codecvt->__cd_in.__cd.__data[0].__outbuf = (char *) to_buf;
codecvt->__cd_in.__cd.__data[0].__outbufend = (char *) &to_buf[max];
codecvt->__cd_in.__cd.__data[0].__statep = statep;
status = DL_CALL_FCT (gs->__fct,
(gs, codecvt->__cd_in.__cd.__data, &cp, from_end,
NULL, &dummy, 0, 0));
result = cp - (const unsigned char *) from_start;
#else
# ifdef _GLIBCPP_USE_WCHAR_T
const char *from_start_copy = (const char *) from_start;
size_t from_len = from_end - from_start;
wchar_t to_buf[max];
size_t res;
char *to_start = (char *) to_buf;
res = iconv (codecvt->__cd_in, &from_start_copy, &from_len,
&to_start, &max);
result = from_start_copy - (char *) from_start;
# else
result = 0;
# endif
#endif
return result;
}
static int
do_max_length (struct _IO_codecvt *codecvt)
{
#ifdef _LIBC
return codecvt->__cd_in.__cd.__steps[0].__max_needed_from;
#else
return MB_CUR_MAX;
#endif
}
#endif