hyung-hwan/qse
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

revised qse_mbstowcs()/qse_mbsntowcsn()/qse_wcstombs()/qse_wcsntombsn().

Browse Source 
changed the parts affected by the revision works including deleting unnecessary functions
This commit is contained in:
hyung-hwan
2011-12-11 15:43:19 +00:00
parent 2faee1f23f
commit 566e13d874
17 changed files with 1159 additions and 855 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
qse/lib/awk/StdAwk.cpp
View File

@ -114,27 +114,19 @@ int StdAwk::system (Run& run, Value& ret, const Value* args, size_t nargs,
#elif defined(QSE_CHAR_IS_MCHAR)
return ret.setInt ((long_t)::system(ptr));
#else
char* mbs = (char*) qse_awk_allocmem ((awk_t*)(Awk*)run, l*5+1);
if (mbs == QSE_NULL) return -1;
/* at this point, the string is guaranteed to be
* null-terminating. so qse_wcstombs() can be used to convert
* the string, not qse_wcsntombsn(). */
qse_size_t mbl = l * 5;
if (qse_wcstombs (ptr, mbs, &mbl) != l && mbl >= l * 5)
qse_mchar_t* mbs;
mbs = qse_wcstombsdup (ptr, ((awk_t*)(Awk*)run)->mmgr);
if (mbs == QSE_NULL)
{
/* not the entire string is converted.
* mbs is not null-terminated properly. */
qse_awk_freemem ((awk_t*)(Awk*)run, mbs);
return -1;
}
mbs[mbl] = '\0';
int n = ret.setInt ((long_t)::system(mbs));
qse_awk_freemem ((awk_t*)(Awk*)run, mbs);
return n;
#endif
}

41
qse/lib/awk/std.c
View File

@ -1446,7 +1446,7 @@ static int fnc_srand (qse_awk_rtx_t* run, const qse_cstr_t* fnm)
return 0;
}
static int fnc_system (qse_awk_rtx_t* run, const qse_cstr_t* fnm)
static int fnc_system (qse_awk_rtx_t* rtx, const qse_cstr_t* fnm)
{
qse_size_t nargs;
qse_awk_val_t* v;
@ -1454,10 +1454,10 @@ static int fnc_system (qse_awk_rtx_t* run, const qse_cstr_t* fnm)
qse_size_t len;
int n = 0;
nargs = qse_awk_rtx_getnargs (run);
nargs = qse_awk_rtx_getnargs (rtx);
QSE_ASSERT (nargs == 1);
v = qse_awk_rtx_getarg (run, 0);
v = qse_awk_rtx_getarg (rtx, 0);
if (v->type == QSE_AWK_VAL_STR)
{
str = ((qse_awk_val_str_t*)v)->val.ptr;
@ -1465,7 +1465,7 @@ static int fnc_system (qse_awk_rtx_t* run, const qse_cstr_t* fnm)
}
else
{
str = qse_awk_rtx_valtocpldup (run, v, &len);
str = qse_awk_rtx_valtocpldup (rtx, v, &len);
if (str == QSE_NULL) return -1;
}
@ -1488,45 +1488,28 @@ static int fnc_system (qse_awk_rtx_t* run, const qse_cstr_t* fnm)
#elif defined(QSE_CHAR_IS_MCHAR)
n = system (str);
#else
{
char* mbs;
qse_size_t mbl;
mbs = (char*) qse_awk_allocmem (run->awk, len*5+1);
{
qse_mchar_t* mbs;
mbs = qse_wcstombsdup (str, rtx->awk->mmgr);
if (mbs == QSE_NULL)
{
n = -1;
goto skip_system;
}
/* at this point, the string is guaranteed to be
* null-terminating. so qse_wcstombs() can be used to convert
* the string, not qse_wcsntombsn(). */
mbl = len * 5;
if (qse_wcstombs (str, mbs, &mbl) != len && mbl >= len * 5)
{
/* not the entire string is converted.
* mbs is not null-terminated properly. */
n = -1;
goto skip_system_mbs;
}
mbs[mbl] = '\0';
n = system (mbs);
skip_system_mbs:
qse_awk_freemem (run->awk, mbs);
QSE_AWK_FREE (rtx->awk, mbs);
}
#endif
skip_system:
if (v->type != QSE_AWK_VAL_STR) QSE_AWK_FREE (run->awk, str);
if (v->type != QSE_AWK_VAL_STR) QSE_AWK_FREE (rtx->awk, str);
v = qse_awk_rtx_makeintval (run, (qse_long_t)n);
v = qse_awk_rtx_makeintval (rtx, (qse_long_t)n);
if (v == QSE_NULL) return -1;
qse_awk_rtx_setretval (run, v);
qse_awk_rtx_setretval (rtx, v);
return 0;
}

11
qse/lib/cmn/assert.c
View File

@ -89,11 +89,6 @@ void qse_assert_failed (
void *btarray[128];
qse_size_t btsize, i;
char **btsyms;
#ifdef QSE_CHAR_IS_WCHAR
qse_wchar_t wcs[256];
#endif
#endif
qse_sio_puts (QSE_SIO_ERR, QSE_T("=[ASSERTION FAILURE]============================================================\n"));
@ -138,11 +133,15 @@ void qse_assert_failed (
for (i = 0; i < btsize; i++)
{
/* TODO: call qse_sio_putms() instead of using ifdef */
#ifdef QSE_CHAR_IS_MCHAR
qse_sio_puts (QSE_SIO_ERR, btsyms[i]);
#else
qse_wchar_t wcs[256];
qse_size_t wcslen = QSE_COUNTOF(wcs);
qse_mbstowcs (btsyms[i], wcs, &wcslen);
qse_size_t mbslen;
qse_mbstowcs (btsyms[i], &mbslen, wcs, &wcslen);
wcs[QSE_COUNTOF(wcs) - 1] = QSE_T('\0');
qse_sio_puts (QSE_SIO_ERR, wcs);
#endif
qse_sio_puts (QSE_SIO_ERR, QSE_T("\n"));

42
qse/lib/cmn/fio.c
View File

@ -252,8 +252,9 @@ int qse_fio_init (
const qse_mchar_t* path_mb = path;
#else
qse_mchar_t path_mb[CCHMAXPATH];
if (qse_wcstombsrigid (path,
path_mb, QSE_COUNTOF(path_mb)) <= -1) return -1;
qse_size_t wl, ml = QSE_COUNTOF(path_mb);
/* TODO: use wcstombsdup??? */
if (qse_wcstombs (path, &wl, path_mb, &ml) <= -1) return -1;
#endif
zero.ulLo = 0;
@ -342,8 +343,8 @@ int qse_fio_init (
const qse_mchar_t* path_mb = path;
#else
qse_mchar_t path_mb[_MAX_PATH];
if (qse_wcstombsrigid (path,
path_mb, QSE_COUNTOF(path_mb)) <= -1) return -1;
qse_size_t wl, ml = QSE_COUNTOF(path_mb);
if (qse_wcstombs (path, &wl, path_mb, &ml) <= -1) return -1;
#endif
if (flags & QSE_FIO_APPEND)
@ -395,8 +396,9 @@ int qse_fio_init (
const qse_mchar_t* path_mb = path;
#else
qse_mchar_t path_mb[PATH_MAX + 1];
if (qse_wcstombsrigid (path,
path_mb, QSE_COUNTOF(path_mb)) <= -1) return -1;
/* TODO: use qse_wcstombsdup(). path name may exceede PATH_MAX if it contains .. or . */
qse_size_t wl, ml = QSE_COUNTOF(path_mb);
if (qse_wcstombs (path, &wl, path_mb, &ml) <= -1) return -1;
#endif
/*
* rwa -> RDWR | APPEND
@ -655,7 +657,8 @@ static qse_ssize_t fio_read (qse_fio_t* fio, void* buf, qse_size_t size)
#if defined(_WIN32)
DWORD count;
if (size > QSE_TYPE_MAX(DWORD)) size = QSE_TYPE_MAX(DWORD);
if (size > (QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(DWORD)))
size = QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(DWORD);
if (ReadFile (fio->handle,
buf, (DWORD)size, &count, QSE_NULL) == FALSE) return -1;
return (qse_ssize_t)count;
@ -663,18 +666,22 @@ static qse_ssize_t fio_read (qse_fio_t* fio, void* buf, qse_size_t size)
#elif defined(__OS2__)
ULONG count;
if (size > QSE_TYPE_MAX(ULONG)) size = QSE_TYPE_MAX(ULONG);
if (size > (QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(ULONG)))
size = QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(ULONG);
if (DosRead (fio->handle,
buf, (ULONG)size, &count) != NO_ERROR) return -1;
return (qse_ssize_t)count;
#elif defined(__DOS__)
if (size > QSE_TYPE_MAX(size_t)) size = QSE_TYPE_MAX(size_t);
if (size > (QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(size_t)))
size = QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(size_t);
return read (fio->handle, buf, size);
#else
if (size > QSE_TYPE_MAX(size_t)) size = QSE_TYPE_MAX(size_t);
if (size > (QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(size_t)))
size = QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(size_t);
return QSE_READ (fio->handle, buf, size);
#endif
}
@ -690,8 +697,10 @@ qse_ssize_t qse_fio_read (qse_fio_t* fio, void* buf, qse_size_t size)
static qse_ssize_t fio_write (qse_fio_t* fio, const void* data, qse_size_t size)
{
#if defined(_WIN32)
DWORD count;
if (size > QSE_TYPE_MAX(DWORD)) size = QSE_TYPE_MAX(DWORD);
if (size > (QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(DWORD)))
size = QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(DWORD);
if (WriteFile (fio->handle,
data, (DWORD)size, &count, QSE_NULL) == FALSE) return -1;
return (qse_ssize_t)count;
@ -699,19 +708,23 @@ static qse_ssize_t fio_write (qse_fio_t* fio, const void* data, qse_size_t size)
#elif defined(__OS2__)
ULONG count;
if (size > QSE_TYPE_MAX(ULONG)) size = QSE_TYPE_MAX(ULONG);
if (size > (QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(ULONG)))
size = QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(ULONG);
if (DosWrite(fio->handle,
(PVOID)data, (ULONG)size, &count) != NO_ERROR) return -1;
return (qse_ssize_t)count;
#elif defined(__DOS__)
if (size > QSE_TYPE_MAX(size_t)) size = QSE_TYPE_MAX(size_t);
if (size > (QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(size_t)))
size = QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(size_t);
return write (fio->handle, data, size);
#else
if (size > QSE_TYPE_MAX(size_t)) size = QSE_TYPE_MAX(size_t);
if (size > (QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(size_t)))
size = QSE_TYPE_MAX(qse_ssize_t) & QSE_TYPE_MAX(size_t);
return QSE_WRITE (fio->handle, data, size);
#endif
@ -932,7 +945,6 @@ static qse_ssize_t fio_input (qse_tio_cmd_t cmd, void* arg, void* buf, qse_size_
QSE_ASSERT (fio != QSE_NULL);
if (cmd == QSE_TIO_IO_DATA) return fio_read (fio, buf, size);
/* take no actions for OPEN and CLOSE as they are handled
* by fio */
return 0;

23
qse/lib/cmn/fs.c
View File

@ -321,22 +321,23 @@ static int set_entry_name (qse_fs_t* fs, const qse_mchar_t* name)
info_t* info;
qse_size_t len;
#if defined(QSE_CHAR_IS_MCHAR) || defined(_WIN32)
/* nothing more to declare */
#else
qse_size_t mlen;
#endif
info = fs->info;
QSE_ASSERT (info != QSE_NULL);
#if defined(QSE_CHAR_IS_MCHAR) || defined(_WIN32)
len = qse_strlen (name);
#else
/* TODO: ignore MBWCERR */
if (qse_mbstowcs (name, &mlen, QSE_NULL, &len) <= -1)
{
qse_size_t mlen;
/* TODO: ignore MBWCERR */
mlen = qse_mbstowcslen (name, &len);
if (name[mlen] != QSE_MT('\0'))
{
/* invalid name ??? */
return -1;
}
/* invalid name ??? */
return -1;
}
#endif
@ -363,8 +364,8 @@ static int set_entry_name (qse_fs_t* fs, const qse_mchar_t* name)
#if defined(QSE_CHAR_IS_MCHAR) || defined(_WIN32)
qse_strcpy (info->name.ptr, name);
#else
len++;
qse_mbstowcs (name, info->name.ptr, &len);
len++; /* for terminating null */
qse_mbstowcs (name, &mlen, info->name.ptr, &len);
#endif
fs->ent.name.base = info->name.ptr;

57
qse/lib/cmn/main.c
View File

@ -48,31 +48,12 @@ int qse_runmain (
for (i = 0; i < argc; i++)
{
qse_size_t n, len, nlen;
qse_size_t mbslen;
mbslen = qse_mbslen (argv[i]);
n = qse_mbstowcslen (argv[i], &len);
if (n < mbslen) { ret = -1; goto oops; }
len++; /* include the terminating null */
v[i] = (qse_char_t*) QSE_MMGR_ALLOC (
mmgr, len*QSE_SIZEOF(qse_char_t));
if (v[i] == QSE_NULL) { ret = -1; goto oops; }
nlen = len;
n = qse_mbstowcs (argv[i], v[i], &nlen);
if (nlen >= len)
/* TODO: ignore MBWCERR */
v[i]= qse_mbstowcsdup (argv[i], mmgr);
if (v[i] == QSE_NULL)
{
/* no null-termination */
ret = -1; goto oops;
}
if (argv[i][n] != '\0')
{
/* partial processing */
ret = -1; goto oops;
ret = -1;
goto oops;
}
}
@ -117,36 +98,18 @@ int qse_runmainwithenv (
for (i = 0; i < argc + 1 + envc; i++)
{
qse_size_t n, len, nlen;
qse_size_t mbslen;
qse_achar_t* x;
if (i < argc) x = argv[i];
else if (i == argc) continue;
else x = envp[i - argc - 1];
mbslen = qse_mbslen (x);
n = qse_mbstowcslen (x, &len);
if (n < mbslen) { ret = -1; goto oops; }
len++; /* include the terminating null */
v[i] = (qse_char_t*) QSE_MMGR_ALLOC (
mmgr, len*QSE_SIZEOF(qse_char_t));
if (v[i] == QSE_NULL) { ret = -1; goto oops; }
nlen = len;
n = qse_mbstowcs (x, v[i], &nlen);
if (nlen >= len)
/* TODO: ignore MBWCERR */
v[i]= qse_mbstowcsdup (x, mmgr);
if (v[i] == QSE_NULL)
{
/* no null-termination */
ret = -1; goto oops;
}
if (x[n] != '\0')
{
/* partial processing */
ret = -1; goto oops;
ret = -1;
goto oops;
}
}

18
qse/lib/cmn/pio.c
View File

@ -838,12 +838,19 @@ int qse_pio_init (
if (oflags & QSE_PIO_SHELL)
{
#if 0
n = qse_wcstombslen (cmd, &mn);
if (cmd[n] != QSE_WT('\0'))
{
/* cmd has illegal sequence */
goto child_oops;
}
#endif
if (qse_wcstombs (cmd, &wl, QSE_NULL, &mn) <= -1)
{
/* cmd has illegal sequence */
goto child_oops;
}
}
else
{
@ -864,8 +871,11 @@ int qse_pio_init (
if (wcmd[wl++] == QSE_T('\0')) n--;
}
#if 0
n = qse_wcsntombsnlen (wcmd, wl, &mn);
if (n != wl) goto child_oops;
#endif
if (qse_wcsntombsn (wcmd, &wl, QSE_NULL, &mn) <= -1) goto child_oops;
}
/* prepare to reserve 1 more slot for the terminating '\0'
@ -887,16 +897,16 @@ int qse_pio_init (
if (oflags & QSE_PIO_SHELL)
{
/* qse_wcstombs() should succeed as
* qse_wcstombslen() was successful above */
qse_wcstombs (cmd, mcmd, &mn);
* it was successful above */
qse_wcstombs (cmd, &wl, mcmd, &mn);
/* qse_wcstombs() null-terminate mcmd */
}
else
{
QSE_ASSERT (wcmd != QSE_NULL);
/* qse_wcsntombsn() should succeed as
* qse_wcsntombsnlen() was successful above */
qse_wcsntombsn (wcmd, wl, mcmd, &mn);
* it was was successful above */
qse_wcsntombsn (wcmd, &wl, mcmd, &mn);
/* qse_wcsntombsn() doesn't null-terminate mcmd */
mcmd[mn] = QSE_MT('\0');
}

546
qse/lib/cmn/str-cnv.c
View File

@ -138,306 +138,134 @@ qse_ulong_t qse_strxtoulong (const qse_char_t* str, qse_size_t len)
/*
* TODO: fix wrong mbstate handling
*/
qse_size_t qse_mbstowcslen (const qse_mchar_t* mcs, qse_size_t* wcslen)
{
qse_wchar_t wc;
qse_size_t n, ml, wl = 0;
const qse_mchar_t* p = mcs;
qse_mbstate_t state = {{ 0, }};
while (*p != '\0') p++;
ml = p - mcs;
for (p = mcs; ml > 0; p += n, ml -= n)
{
n = qse_mbrtowc (p, ml, &wc, &state);
/* insufficient input or wrong sequence */
if (n == 0 || n > ml) break;
wl++;
}
if (wcslen) *wcslen = wl;
return p - mcs;
}
qse_size_t qse_mbsntowcsnlen (
const qse_mchar_t* mcs, qse_size_t mcslen, qse_size_t* wcslen)
{
qse_wchar_t wc;
qse_size_t n, ml = mcslen, wl = 0;
const qse_mchar_t* p = mcs;
qse_mbstate_t state = {{ 0, }};
for (p = mcs; ml > 0; p += n, ml -= n)
{
n = qse_mbrtowc (p, ml, &wc, &state);
/* insufficient or invalid sequence */
if (n == 0 || n > ml) break;
wl++;
}
if (wcslen) *wcslen = wl;
return mcslen - ml;
}
qse_size_t qse_mbstowcs (
const qse_mchar_t* mbs, qse_wchar_t* wcs, qse_size_t* wcslen)
{
qse_size_t wlen, mlen;
const qse_mchar_t* mp;
/* get the length of mbs and pass it to qse_mbsntowcsn as
* qse_mbtowc called by qse_mbsntowcsn needs it. */
wlen = *wcslen;
if (wlen <= 0)
{
/* buffer too small. also cannot null-terminate it */
*wcslen = 0;
return 0; /* 0 byte processed */
}
for (mp = mbs; *mp != QSE_MT('\0'); mp++);
mlen = qse_mbsntowcsn (mbs, mp - mbs, wcs, &wlen);
if (wlen < *wcslen)
{
/* null-terminate wcs if it is large enough. */
wcs[wlen] = QSE_WT('\0');
}
/* if null-terminated properly, the input wcslen must be less than
* the output wcslen. (input length includes the terminating null
* while the output length excludes the terminating null) */
*wcslen = wlen;
return mlen;
}
qse_size_t qse_mbsntowcsn (
const qse_mchar_t* mbs, qse_size_t mbslen,
int qse_mbstowcs (
const qse_mchar_t* mbs, qse_size_t* mbslen,
qse_wchar_t* wcs, qse_size_t* wcslen)
{
const qse_mchar_t* mp;
qse_size_t mlen, wlen;
int n;
for (mp = mbs; *mp != QSE_MT('\0'); mp++);
mlen = mp - mbs; wlen = *wcslen;
n = qse_mbsntowcsn (mbs, &mlen, wcs, &wlen);
if (wcs)
{
if (wlen < *wcslen) wcs[wlen] = QSE_WT('\0');
else n = -2; /* buffer too small */
}
*mbslen = mlen; *wcslen = wlen;
return n;
}
int qse_mbsntowcsn (
const qse_mchar_t* mbs, qse_size_t* mbslen,
qse_wchar_t* wcs, qse_size_t* wcslen)
{
qse_size_t mlen = mbslen, n;
const qse_mchar_t* p;
qse_wchar_t* q, * qend ;
qse_mbstate_t state = {{ 0, }};
int ret = 0;
qse_size_t mlen;
qend = wcs + *wcslen;
for (p = mbs, q = wcs; mlen > 0 && q < qend; p += n, mlen -= n)
if (wcs)
{
n = qse_mbrtowc (p, mlen, q, &state);
if (n == 0 || n > mlen)
qse_wchar_t* q, * qend;
p = mbs;
q = wcs;
qend = wcs + *wcslen;
mlen = *mbslen;
while (mlen > 0)
{
/* wrong sequence or insufficient input */
break;
qse_size_t n;
if (q >= qend)
{
/* buffer too small */
ret = -2;
break;
}
n = qse_mbrtowc (p, mlen, q, &state);
if (n == 0)
{
/* invalid sequence */
ret = -1;
break;
}
if (n > mlen)
{
/* incomplete sequence */
ret = -3;
break;
}
q++;
p += n;
mlen -= n;
}
q++;
*wcslen = q - wcs;
*mbslen = p - mbs;
}
*wcslen = q - wcs;
return p - mbs; /* returns the number of bytes processed */
}
qse_size_t qse_wcstombslen (const qse_wchar_t* wcs, qse_size_t* mbslen)
{
const qse_wchar_t* p = wcs;
qse_mchar_t mbs[QSE_MBLEN_MAX];
qse_size_t mlen = 0;
qse_mbstate_t state = {{ 0, }};
while (*p != QSE_WT('\0'))
else
{
qse_size_t n = qse_wcrtomb (*p, mbs, QSE_COUNTOF(mbs), &state);
if (n == 0) break; /* illegal character */
qse_wchar_t w;
qse_size_t wlen = 0;
/* it assumes that mbs is large enough to hold a character */
QSE_ASSERT (n <= QSE_COUNTOF(mbs));
p = mbs;
mlen = *mbslen;
p++; mlen += n;
}
/* this length holds the number of resulting multi-byte characters
* excluding the terminating null character */
*mbslen = mlen;
/* returns the number of characters handled.
* if the function has encountered an illegal character in
* the while loop above, wcs[p-wcs] will not be a null character */
return p - wcs;
}
qse_size_t qse_wcsntombsnlen (
const qse_wchar_t* wcs, qse_size_t wcslen, qse_size_t* mbslen)
{
const qse_wchar_t* p = wcs;
const qse_wchar_t* end = wcs + wcslen;
qse_mchar_t mbs[QSE_MBLEN_MAX];
qse_size_t mlen = 0;
qse_mbstate_t state = {{ 0, }};
while (p < end)
{
qse_size_t n = qse_wcrtomb (*p, mbs, QSE_COUNTOF(mbs), &state);
if (n == 0) break; /* illegal character */
/* it assumes that mbs is large enough to hold a character */
QSE_ASSERT (n <= QSE_COUNTOF(mbs));
p++; mlen += n;
}
/* this length excludes the terminating null character.
* this function doesn't event null-terminate the result. */
*mbslen = mlen;
/* returns the number of characters handled.
* if the function has encountered an illegal character in
* the while loop above, wcs[p-wcs] will not be a null character */
return p - wcs;
}
qse_size_t qse_wcstombs (
const qse_wchar_t* wcs, qse_mchar_t* mbs, qse_size_t* mbslen)
{
const qse_wchar_t* p = wcs;
qse_size_t rem = *mbslen;
qse_mbstate_t state = {{ 0, }};
while (*p != QSE_WT('\0') && rem > 0)
{
qse_size_t n = qse_wcrtomb (*p, mbs, rem, &state);
if (n == 0 || n > rem)
while (mlen > 0)
{
/* illegal character or buffer not enough */
break;
qse_size_t n;
n = qse_mbrtowc (p, mlen, &w, &state);
if (n == 0)
{
/* invalid sequence */
ret = -1;
break;
}
if (n > mlen)
{
/* incomplete sequence */
ret = -3;
break;
}
p += n;
mlen -= n;
wlen += 1;
}
mbs += n; rem -= n; p++;
*wcslen = wlen;
*mbslen = p - mbs;
}
/* update mbslen to the length of the mbs string converted excluding
* terminating null */
*mbslen -= rem;
/* null-terminate the multibyte sequence if it has sufficient space */
if (rem > 0) *mbs = QSE_MT('\0');
/* returns the number of characters handled. */
return p - wcs;
}
qse_size_t qse_wcsntombsn (
const qse_wchar_t* wcs, qse_size_t wcslen,
qse_mchar_t* mbs, qse_size_t* mbslen)
{
const qse_wchar_t* p = wcs;
const qse_wchar_t* end = wcs + wcslen;
qse_size_t len = *mbslen;
qse_mbstate_t state = {{ 0, }};
while (p < end && len > 0)
{
qse_size_t n = qse_wcrtomb (*p, mbs, len, &state);
if (n == 0 || n > len)
{
/* illegal character or buffer not enough */
break;
}
mbs += n; len -= n; p++;
}
*mbslen -= len;
/* returns the number of characters handled.
* the caller can check if the return value is as large is wcslen
* for an error. */
return p - wcs;
}
int qse_mbstowcsrigid (
const qse_mchar_t* mbs, qse_wchar_t* wcs, qse_size_t wcslen)
{
/* no truncation is allowed in this function for any reasons */
qse_size_t n;
qse_size_t wn = wcslen;
n = qse_mbstowcs (mbs, wcs, &wn);
if (mbs[n] != QSE_MT('\0'))
{
/* incomplete sequence or invalid sequence */
return -1;
}
if (wn >= wcslen)
{
/* wcs not big enough to be null-terminated.
* if it has been null-terminated properly,
* wn should be less than wcslen. */
return -2;
}
return 0;
}
int qse_wcstombsrigid (
const qse_wchar_t* wcs, qse_mchar_t* mbs, qse_size_t mbslen)
{
/* no truncation is allowed in this function for any reasons */
qse_size_t n;
qse_size_t mn = mbslen;
n = qse_wcstombs (wcs, mbs, &mn);
if (wcs[n] != QSE_WT('\0'))
{
/* if qse_wcstombs() processed all wide characters,
* the character at position 'n' should be a null character
* as 'n' is the number of wide characters processed. */
return -1;
}
if (mn >= mbslen)
{
/* mbs not big enough to be null-terminated.
* if it has been null-terminated properly,
* mn should be less than mbslen. */
return -2;
}
return 0;
return ret;
}
qse_wchar_t* qse_mbstowcsdup (const qse_mchar_t* mbs, qse_mmgr_t* mmgr)
{
qse_size_t n, req;
qse_size_t mbslen, wcslen;
qse_wchar_t* wcs;
n = qse_mbstowcslen (mbs, &req);
if (mbs[n] != QSE_WT('\0')) return QSE_NULL;
if (qse_mbstowcs (mbs, &mbslen, QSE_NULL, &wcslen) <= -1) return QSE_NULL;
req++;
wcs = QSE_MMGR_ALLOC (mmgr, req * QSE_SIZEOF(*wcs));
wcslen++; /* for terminating null */
wcs = QSE_MMGR_ALLOC (mmgr, wcslen * QSE_SIZEOF(*wcs));
if (wcs == QSE_NULL) return QSE_NULL;
qse_mbstowcs (mbs, wcs, &req);
qse_mbstowcs (mbs, &mbslen, wcs, &wcslen);
return wcs;
}
qse_mchar_t* qse_wcstombsdup (const qse_wchar_t* wcs, qse_mmgr_t* mmgr)
{
qse_size_t n, req;
qse_mchar_t* mbs;
n = qse_wcstombslen (wcs, &req);
if (wcs[n] != QSE_WT('\0')) return QSE_NULL;
req++;
mbs = QSE_MMGR_ALLOC (mmgr, req * QSE_SIZEOF(*mbs));
if (mbs == QSE_NULL) return QSE_NULL;
qse_wcstombs (wcs, mbs, &req);
return mbs;
}
qse_wchar_t* qse_mbsatowcsdup (const qse_mchar_t* mbs[], qse_mmgr_t* mmgr)
{
qse_wchar_t* buf, * ptr;
@ -449,8 +277,7 @@ qse_wchar_t* qse_mbsatowcsdup (const qse_mchar_t* mbs[], qse_mmgr_t* mmgr)
for (i = 0; mbs[i]; i++)
{
ml = qse_mbstowcslen(mbs[i], &wl);
if (mbs[i][ml] != QSE_MT('\0')) return QSE_NULL;
if (qse_mbstowcs(mbs[i], &ml, QSE_NULL, &wl) <= -1) return QSE_NULL;
capa += wl;
}
@ -462,7 +289,7 @@ qse_wchar_t* qse_mbsatowcsdup (const qse_mchar_t* mbs[], qse_mmgr_t* mmgr)
for (i = 0; mbs[i]; i++)
{
wl = capa + 1;
ml = qse_mbstowcs (mbs[i], ptr, &wl);
qse_mbstowcs (mbs[i], &ml, ptr, &wl);
ptr += wl;
capa -= wl;
}
@ -470,19 +297,188 @@ qse_wchar_t* qse_mbsatowcsdup (const qse_mchar_t* mbs[], qse_mmgr_t* mmgr)
return buf;
}
int qse_wcstombs (
const qse_wchar_t* wcs, qse_size_t* wcslen,
qse_mchar_t* mbs, qse_size_t* mbslen)
{
const qse_wchar_t* p = wcs;
qse_mbstate_t state = {{ 0, }};
int ret = 0;
if (mbs)
{
qse_size_t rem = *mbslen;
while (*p != QSE_WT('\0'))
{
qse_size_t n;
if (rem <= 0)
{
ret = -2;
break;
}
n = qse_wcrtomb (*p, mbs, rem, &state);
if (n == 0)
{
ret = -1;
break; /* illegal character */
}
if (n > rem)
{
ret = -2;
break; /* buffer too small */
}
mbs += n; rem -= n; p++;
}
/* update mbslen to the length of the mbs string converted excluding
* terminating null */
*mbslen -= rem;
/* null-terminate the multibyte sequence if it has sufficient space */
if (rem > 0) *mbs = QSE_MT('\0');
else
{
/* if ret is -2 and wcs[wcslen] == QSE_T('\0'),
* this means that the mbs buffer was lacking one
* slot for the terminating null */
ret = -2; /* buffer too small */
}
}
else
{
qse_mchar_t mbsbuf[QSE_MBLEN_MAX];
qse_size_t mlen = 0;
while (*p != QSE_WT('\0'))
{
qse_size_t n;
n = qse_wcrtomb (*p, mbsbuf, QSE_COUNTOF(mbsbuf), &state);
if (n == 0)
{
ret = -1;
break; /* illegal character */
}
/* it assumes that mbs is large enough to hold a character */
QSE_ASSERT (n <= QSE_COUNTOF(mbs));
p++; mlen += n;
}
/* this length holds the number of resulting multi-byte characters
* excluding the terminating null character */
*mbslen = mlen;
}
*wcslen = p - wcs; /* the number of wide characters handled. */
return ret;
}
int qse_wcsntombsn (
const qse_wchar_t* wcs, qse_size_t* wcslen,
qse_mchar_t* mbs, qse_size_t* mbslen)
{
const qse_wchar_t* p = wcs;
const qse_wchar_t* end = wcs + *wcslen;
qse_mbstate_t state = {{ 0, }};
int ret = 0;
if (mbs)
{
qse_size_t rem = *mbslen;
while (p < end)
{
qse_size_t n;
if (rem <= 0)
{
ret = -2; /* buffer too small */
break;
}
n = qse_wcrtomb (*p, mbs, rem, &state);
if (n == 0)
{
ret = -1;
break; /* illegal character */
}
if (n > rem)
{
ret = -2; /* buffer too small */
break;
}
mbs += n; rem -= n; p++;
}
*mbslen -= rem;
}
else
{
qse_mchar_t mbsbuf[QSE_MBLEN_MAX];
qse_size_t mlen = 0;
while (p < end)
{
qse_size_t n;
n = qse_wcrtomb (*p, mbs, QSE_COUNTOF(mbsbuf), &state);
if (n == 0)
{
ret = -1;
break; /* illegal character */
}
/* it assumes that mbs is large enough to hold a character */
QSE_ASSERT (n <= QSE_COUNTOF(mbsbuf));
p++; mlen += n;
}
/* this length excludes the terminating null character.
* this function doesn't event null-terminate the result. */
*mbslen = mlen;
}
*wcslen = p - wcs;
return ret;
}
qse_mchar_t* qse_wcstombsdup (const qse_wchar_t* wcs, qse_mmgr_t* mmgr)
{
qse_size_t wcslen, mbslen;
qse_mchar_t* mbs;
if (qse_wcstombs (wcs, &wcslen, QSE_NULL, &mbslen) <= -1) return QSE_NULL;
mbslen++; /* for the terminating null character */
mbs = QSE_MMGR_ALLOC (mmgr, mbslen * QSE_SIZEOF(*mbs));
if (mbs == QSE_NULL) return QSE_NULL;
qse_wcstombs (wcs, &wcslen, mbs, &mbslen);
return mbs;
}
qse_mchar_t* qse_wcsatombsdup (const qse_wchar_t* wcs[], qse_mmgr_t* mmgr)
{
qse_mchar_t* buf, * ptr;
qse_size_t i;
qse_size_t capa = 0;
qse_size_t wl, ml;
qse_size_t capa = 0;
QSE_ASSERT (mmgr != QSE_NULL);
for (i = 0; wcs[i]; i++)
{
wl = qse_wcstombslen(wcs[i], &ml);
if (wcs[i][wl] != QSE_WT('\0')) return QSE_NULL;
if (qse_wcstombs (wcs[i], &wl, QSE_NULL, &ml) <= -1) return QSE_NULL;
capa += ml;
}
@ -494,7 +490,7 @@ qse_mchar_t* qse_wcsatombsdup (const qse_wchar_t* wcs[], qse_mmgr_t* mmgr)
for (i = 0; wcs[i]; i++)
{
ml = capa + 1;
wl = qse_wcstombs (wcs[i], ptr, &ml);
qse_wcstombs (wcs[i], &wl, ptr, &ml);
ptr += ml;
capa -= ml;
}

87
qse/lib/cmn/tio-put.c
View File

@ -101,6 +101,7 @@ qse_ssize_t qse_tio_write (qse_tio_t* tio, const qse_char_t* str, qse_size_t siz
if (size == (qse_size_t)-1)
{
/* TODO: should not write more than than QSE_TYPE_MAX(qse_ssize_t) */
while (*p != QSE_T('\0'))
{
n = tio_putc (tio, *p, &flush_needed);
@ -111,7 +112,10 @@ qse_ssize_t qse_tio_write (qse_tio_t* tio, const qse_char_t* str, qse_size_t siz
}
else
{
const qse_char_t* end = str + size;
const qse_char_t* end;
/* TODO: size should not be longer than QSE_TYPE_MAX(qse_ssize_t) */
end = str + size;
while (p < end)
{
n = tio_putc (tio, *p, &flush_needed);
@ -125,3 +129,84 @@ qse_ssize_t qse_tio_write (qse_tio_t* tio, const qse_char_t* str, qse_size_t siz
return p - str;
}
qse_ssize_t qse_tio_writemstr (
qse_tio_t* tio, const qse_mchar_t* mptr, qse_size_t mlen)
{
const qse_mchar_t* xptr, * xend;
qse_size_t capa;
int nl = 0;
if (tio->outbuf_len >= QSE_COUNTOF(tio->outbuf))
{
/* maybe, previous flush operation has failed a few
* times previously. so the buffer is full.
*/
tio->errnum = QSE_TIO_ENOSPC;
return -1;
}
/* adjust mlen for the type difference between the parameter
* and the return value */
if (mlen > QSE_TYPE_MAX(qse_ssize_t)) mlen = QSE_TYPE_MAX(qse_ssize_t);
/* handle the parts that can't fit into the internal buffer */
while (mlen >= (capa = QSE_COUNTOF(tio->outbuf) - tio->outbuf_len))
{
for (xend = xptr + capa; xptr < xend; xptr++)
tio->outbuf[tio->outbuf_len++] = *xptr;
if (qse_tio_flush (tio) == -1) return -1;
mlen -= capa;
}
/* handle the last part that can fit into the internal buffer */
for (xend = xptr + mlen; xptr < xend; xptr++)
{
/* TODO: support different line terminating characeter */
if (*xptr == QSE_MT('\n')) nl = 1;
tio->outbuf[tio->outbuf_len++] = *xptr;
}
/* if the last part contains a new line, flush the internal
* buffer. note that this flushes characters after nl also.*/
if (nl && qse_tio_flush (tio) == -1) return -1;
/* returns the number multi-bytes characters handled */
return xptr - mptr;
}
#if 0
qse_ssize_t qse_tio_writewstr (
qse_tio_t* tio, const qse_wchar_t* wptr, qse_size_t wlen)
{
if (wlen > QSE_TYPE_MAX(qse_ssize_t)) wlen = QSE_TYPE_MAX(qse_ssize_t);
while (1)
{
qse_size_t capa, mcnt, wcnt;
capa = QSE_COUNTOF(tio->outbuf) - tio->outbuf_len;
mcnt = capa;
wcnt = qse_wcsntombsn (wptr, wlen, &tio->outbuf[tio->outbuf_len], &mcnt);
if (wcnt == wlen)
{
/* process the all*/
}
if (mcnt >= capa)
{
/* wcsntombsn doesn't null-terminate the result. * /
/* buffer is not large enough. flush first before continuing */
if (qse_tio_flush (tio) == -1) return -1;
continue;
}
else if (wcnt != wlen)
{
/* invalid wide-character is included. */
if (tio->flags & QSE_TIO_IGNOREMBWCERR)
{
}
}
}
#endif