Commit 9199f88b authored by Michael Smith's avatar Michael Smith

BIG patch for sane and complete UTF conversion code (except on win32, where

it's not yet complete, and probably doesn't compile any more), from
Edmund Grimley Evans <edmundo@rano.org>

PLEASE test this thoroughly, everyone.

svn path=/trunk/vorbis-tools/; revision=2107
parent 48e9e3c9
......@@ -430,3 +430,19 @@ size_t iconv();
fi
AC_SUBST(LIBICONV)
])
dnl From Bruno Haible.
dnl
AC_DEFUN([AM_LANGINFO_CODESET],
[
AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
[AC_TRY_LINK([#include <langinfo.h>],
[char* cs = nl_langinfo(CODESET);],
am_cv_langinfo_codeset=yes,
am_cv_langinfo_codeset=no)
])
if test $am_cv_langinfo_codeset = yes; then
AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
[Define if you have <langinfo.h> and nl_langinfo(CODESET).])
fi
])
......@@ -111,6 +111,7 @@ dnl --------------------------------------------------
AM_ICONV
AC_FUNC_SMMAP
AM_LANGINFO_CODESET
dnl --------------------------------------------------
dnl Work around FHS stupidity
......
/* OggEnc
/*
* Convert a string between UTF-8 and the locale's charset.
* Invalid bytes are replaced by '#', and characters that are
* not available in the target encoding are replaced by '?'.
*
* If the locale's charset is not set explicitly then it is
* obtained using nl_langinfo(CODESET), where available, the
* environment variable CHARSET, or assumed to be US-ASCII.
*
* This program is distributed under the GNU General Public License, version 2.
* A copy of this license is included with this source.
* Return value of conversion functions:
*
* Copyright 2001, Daniel Resare <noa@metamatrix.se>
* -1 : memory allocation failed
* 0 : data was converted exactly
* 1 : valid data was converted approximately (using '?')
* 2 : input was invalid (but still converted, using '#')
* 3 : unknown encoding (but still converted, using '?')
*/
typedef struct
{
char* name;
int mapping[256];
} charset_map;
void convert_set_charset(const char *charset);
charset_map *get_map(const char *encoding);
char *make_utf8_string(const unsigned short *unicode);
int simple_utf8_encode(const char *from, char **to, const char *encoding);
int utf8_encode(char *from, char **to, const char *encoding);
int utf8_encode(const char *from, char **to);
int utf8_decode(const char *from, char **to);
......@@ -15,6 +15,7 @@
#include <getopt.h>
#include <string.h>
#include <time.h>
#include <locale.h>
#include "platform.h"
#include "encode.h"
......@@ -50,7 +51,6 @@ struct option long_options[] = {
{"date",1,0,'d'},
{"tracknum",1,0,'N'},
{"serial",1,0,'s'},
{"encoding",1,0,'e'},
{NULL,0,0,0}
};
......@@ -75,6 +75,8 @@ int main(int argc, char **argv)
int numfiles;
int errors=0;
setlocale(LC_ALL, "");
parse_options(argc, argv, &opt);
if(optind >= argc)
......@@ -320,8 +322,6 @@ static void usage(void)
" -s, --serial Specify a serial number for the stream. If encoding\n"
" multiple files, this will be incremented for each\n"
" stream after the first.\n"
" -e, --encoding Specify an encoding for the comments given (not\n"
" supported on windows)\n"
"\n"
" Naming:\n"
" -o, --output=fn Write file to fn (only valid in single-file mode)\n"
......@@ -477,7 +477,7 @@ static void parse_options(int argc, char **argv, oe_options *opt)
int ret;
int option_index = 1;
while((ret = getopt_long(argc, argv, "a:b:B:c:C:d:e:G:hl:m:M:n:N:o:P:q:QrR:s:t:vX:",
while((ret = getopt_long(argc, argv, "a:b:B:c:C:d:G:hl:m:M:n:N:o:P:q:QrR:s:t:vX:",
long_options, &option_index)) != -1)
{
switch(ret)
......@@ -498,9 +498,6 @@ static void parse_options(int argc, char **argv, oe_options *opt)
opt->dates = realloc(opt->dates, (++opt->date_count)*sizeof(char *));
opt->dates[opt->date_count - 1] = strdup(optarg);
break;
case 'e':
opt->encoding = strdup(optarg);
break;
case 'G':
opt->genre = realloc(opt->genre, (++opt->genre_count)*sizeof(char *));
opt->genre[opt->genre_count - 1] = strdup(optarg);
......@@ -646,7 +643,7 @@ static void parse_options(int argc, char **argv, oe_options *opt)
static void add_tag(vorbis_comment *vc, oe_options *opt,char *name, char *value)
{
char *utf8;
if(utf8_encode(value, &utf8, opt->encoding) == 0)
if(utf8_encode(value, &utf8) >= 0)
{
if(name == NULL)
vorbis_comment_add(vc, utf8);
......@@ -655,7 +652,7 @@ static void add_tag(vorbis_comment *vc, oe_options *opt,char *name, char *value)
free(utf8);
}
else
fprintf(stderr, "Couldn't convert comment to UTF8, cannot add\n");
fprintf(stderr, "Couldn't convert comment to UTF-8, cannot add\n");
}
static void build_comments(vorbis_comment *vc, oe_options *opt, int filenum,
......
This diff is collapsed.
This diff is collapsed.
......@@ -6,12 +6,11 @@ INCLUDES = -I$(top_srcdir)/include
noinst_LIBRARIES = libutf8.a libgetopt.a
libutf8_a_SOURCES = utf8.c
MAP_FILES = 8859-1.map 8859-2.map
libutf8_a_SOURCES = charset.c iconvert.c utf8.c
libgetopt_a_SOURCES = getopt.c getopt1.c
EXTRA_DIST = $(MAP_FILES) charsetmap.h make_code_map.pl
EXTRA_DIST = charmaps.h makemap.c charset_test.c
debug:
$(MAKE) all CFLAGS="@DEBUG@"
......
/*
* If you need to generate more maps, use makemap.c on a system
* with a decent iconv.
*/
static const unsigned short mapping_iso_8859_2[256] = {
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
0x00a0, 0x0104, 0x02d8, 0x0141, 0x00a4, 0x013d, 0x015a, 0x00a7,
0x00a8, 0x0160, 0x015e, 0x0164, 0x0179, 0x00ad, 0x017d, 0x017b,
0x00b0, 0x0105, 0x02db, 0x0142, 0x00b4, 0x013e, 0x015b, 0x02c7,
0x00b8, 0x0161, 0x015f, 0x0165, 0x017a, 0x02dd, 0x017e, 0x017c,
0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7,
0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7,
0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7,
0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7,
0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9
};
static struct {
const char *name;
const unsigned short *map;
struct charset *charset;
} maps[] = {
{ "ISO-8859-2", mapping_iso_8859_2, 0 },
{ 0, 0, 0 }
};
static const struct {
const char *bad;
const char *good;
} names[] = {
{ "ANSI_X3.4-1968", "us-ascii" },
{ 0, 0 }
};
This diff is collapsed.
/*
* Copyright (C) 2001 Edmund Grimley Evans <edmundo@rano.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <assert.h>
#include <string.h>
#include "charset.h"
void test_any(struct charset *charset)
{
int wc;
char s[2];
assert(charset);
/* Decoder */
assert(charset_mbtowc(charset, 0, (char *)(-1), 0) == 0);
assert(charset_mbtowc(charset, 0, 0, 1) == 0);
assert(charset_mbtowc(charset, &wc, "x", 0) == 0);
assert(charset_mbtowc(charset, &wc, "x", 1) == 1 && wc == 'x');
assert(charset_mbtowc(charset, &wc, "x", 2) == 1 && wc == 'x');
assert(charset_mbtowc(charset, &wc, "", 1) == 0 && wc == 0);
/* Encoder */
assert(charset_wctomb(charset, 0, 0) == 0);
s[0] = s[1] = '.';
assert(charset_wctomb(charset, s, 0) == 1 &&
s[0] == '\0' && s[1] == '.');
assert(charset_wctomb(charset, s, 'x') == 1 &&
s[0] == 'x' && s[1] == '.');
}
void test_utf8()
{
struct charset *charset;
int wc;
char s[8];
charset = charset_find("UTF-8");
test_any(charset);
/* Decoder */
wc = 0;
assert(charset_mbtowc(charset, &wc, "\177", 1) == 1 && wc == 127);
assert(charset_mbtowc(charset, &wc, "\200", 2) == -1);
assert(charset_mbtowc(charset, &wc, "\301\277", 9) == -1);
assert(charset_mbtowc(charset, &wc, "\302\200", 1) == -1);
assert(charset_mbtowc(charset, &wc, "\302\200", 2) == 2 && wc == 128);
assert(charset_mbtowc(charset, &wc, "\302\200", 3) == 2 && wc == 128);
assert(charset_mbtowc(charset, &wc, "\340\237\200", 9) == -1);
assert(charset_mbtowc(charset, &wc, "\340\240\200", 9) == 3 &&
wc == 1 << 11);
assert(charset_mbtowc(charset, &wc, "\360\217\277\277", 9) == -1);
assert(charset_mbtowc(charset, &wc, "\360\220\200\200", 9) == 4 &&
wc == 1 << 16);
assert(charset_mbtowc(charset, &wc, "\370\207\277\277\277", 9) == -1);
assert(charset_mbtowc(charset, &wc, "\370\210\200\200\200", 9) == 5 &&
wc == 1 << 21);
assert(charset_mbtowc(charset, &wc, "\374\203\277\277\277\277", 9) == -1);
assert(charset_mbtowc(charset, &wc, "\374\204\200\200\200\200", 9) == 6 &&
wc == 1 << 26);
assert(charset_mbtowc(charset, &wc, "\375\277\277\277\277\277", 9) == 6 &&
wc == 0x7fffffff);
/* Encoder */
strcpy(s, ".......");
assert(charset_wctomb(charset, s, 1 << 31) == -1 &&
!strcmp(s, "......."));
assert(charset_wctomb(charset, s, 127) == 1 &&
!strcmp(s, "\177......"));
assert(charset_wctomb(charset, s, 128) == 2 &&
!strcmp(s, "\302\200....."));
assert(charset_wctomb(charset, s, 0x7ff) == 2 &&
!strcmp(s, "\337\277....."));
assert(charset_wctomb(charset, s, 0x800) == 3 &&
!strcmp(s, "\340\240\200...."));
assert(charset_wctomb(charset, s, 0xffff) == 3 &&
!strcmp(s, "\357\277\277...."));
assert(charset_wctomb(charset, s, 0x10000) == 4 &&
!strcmp(s, "\360\220\200\200..."));
assert(charset_wctomb(charset, s, 0x1fffff) == 4 &&
!strcmp(s, "\367\277\277\277..."));
assert(charset_wctomb(charset, s, 0x200000) == 5 &&
!strcmp(s, "\370\210\200\200\200.."));
assert(charset_wctomb(charset, s, 0x3ffffff) == 5 &&
!strcmp(s, "\373\277\277\277\277.."));
assert(charset_wctomb(charset, s, 0x4000000) == 6 &&
!strcmp(s, "\374\204\200\200\200\200."));
assert(charset_wctomb(charset, s, 0x7fffffff) == 6 &&
!strcmp(s, "\375\277\277\277\277\277."));
}
void test_ascii()
{
struct charset *charset;
int wc;
char s[3];
charset = charset_find("us-ascii");
test_any(charset);
/* Decoder */
wc = 0;
assert(charset_mbtowc(charset, &wc, "\177", 2) == 1 && wc == 127);
assert(charset_mbtowc(charset, &wc, "\200", 2) == -1);
/* Encoder */
strcpy(s, "..");
assert(charset_wctomb(charset, s, 256) == -1 && !strcmp(s, ".."));
assert(charset_wctomb(charset, s, 255) == -1);
assert(charset_wctomb(charset, s, 128) == -1);
assert(charset_wctomb(charset, s, 127) == 1 && !strcmp(s, "\177."));
}
void test_iso1()
{
struct charset *charset;
int wc;
char s[3];
charset = charset_find("iso-8859-1");
test_any(charset);
/* Decoder */
wc = 0;
assert(charset_mbtowc(charset, &wc, "\302\200", 9) == 1 && wc == 0xc2);
/* Encoder */
strcpy(s, "..");
assert(charset_wctomb(charset, s, 256) == -1 && !strcmp(s, ".."));
assert(charset_wctomb(charset, s, 255) == 1 && !strcmp(s, "\377."));
assert(charset_wctomb(charset, s, 128) == 1 && !strcmp(s, "\200."));
}
void test_iso2()
{
struct charset *charset;
int wc;
char s[3];
charset = charset_find("iso-8859-2");
test_any(charset);
/* Decoder */
wc = 0;
assert(charset_mbtowc(charset, &wc, "\302\200", 9) == 1 && wc == 0xc2);
assert(charset_mbtowc(charset, &wc, "\377", 2) == 1 && wc == 0x2d9);
/* Encoder */
strcpy(s, "..");
assert(charset_wctomb(charset, s, 256) == -1 && !strcmp(s, ".."));
assert(charset_wctomb(charset, s, 255) == -1 && !strcmp(s, ".."));
assert(charset_wctomb(charset, s, 258) == 1 && !strcmp(s, "\303."));
assert(charset_wctomb(charset, s, 128) == 1 && !strcmp(s, "\200."));
}
void test_convert()
{
const char *p;
char *q, *r;
char s[256];
size_t n, n2;
int i;
p = "\000x\302\200\375\277\277\277\277\277";
assert(charset_convert("UTF-8", "UTF-8", p, 10, &q, &n) == 0 &&
n == 10 && !strcmp(p, q));
assert(charset_convert("UTF-8", "UTF-8", "x\301\277y", 4, &q, &n) == 2 &&
n == 4 && !strcmp(q, "x##y"));
assert(charset_convert("UTF-8", "UTF-8", "x\301\277y", 4, 0, &n) == 2 &&
n == 4);
assert(charset_convert("UTF-8", "UTF-8", "x\301\277y", 4, &q, 0) == 2 &&
!strcmp(q, "x##y"));
assert(charset_convert("UTF-8", "iso-8859-1",
"\302\200\304\200x", 5, &q, &n) == 1 &&
n == 3 && !strcmp(q, "\200?x"));
assert(charset_convert("iso-8859-1", "UTF-8",
"\000\200\377", 3, &q, &n) == 0 &&
n == 5 && !memcmp(q, "\000\302\200\303\277", 5));
assert(charset_convert("iso-8859-1", "iso-8859-1",
"\000\200\377", 3, &q, &n) == 0 &&
n == 3 && !memcmp(q, "\000\200\377", 3));
assert(charset_convert("iso-8859-2", "utf-8", "\300", 1, &q, &n) == 0 &&
n == 2 && !strcmp(q, "\305\224"));
assert(charset_convert("utf-8", "iso-8859-2", "\305\224", 2, &q, &n) == 0 &&
n == 1 && !strcmp(q, "\300"));
for (i = 0; i < 256; i++)
s[i] = i;
assert(charset_convert("iso-8859-2", "utf-8", s, 256, &q, &n) == 0);
assert(charset_convert("utf-8", "iso-8859-2", q, n, &r, &n2) == 0);
assert(n2 == 256 && !memcmp(r, s, n2));
}
int main()
{
test_utf8();
test_ascii();
test_iso1();
test_iso2();
test_convert();
return 0;
}
/*
* Copyright (C) 2001 Edmund Grimley Evans <edmundo@rano.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifdef HAVE_ICONV
#include <assert.h>
#include <errno.h>
#include <iconv.h>
#include <stdlib.h>
#include <string.h>
/*
* Convert data from one encoding to another. Return:
*
* -2 : memory allocation failed
* -1 : unknown encoding
* 0 : data was converted exactly
* 1 : data was converted inexactly
* 2 : data was invalid (but still converted)
*
* We convert in two steps, via UTF-8, as this is the only
* reliable way of distinguishing between invalid input
* and valid input which iconv refuses to transliterate.
* We convert from UTF-8 twice, because we have no way of
* knowing whether the conversion was exact if iconv returns
* E2BIG (due to a bug in the specification of iconv).
* An alternative approach is to assume that the output of
* iconv is never more than 4 times as long as the input,
* but I prefer to avoid that assumption if possible.
*/
int iconvert(const char *fromcode, const char *tocode,
const char *from, size_t fromlen,
char **to, size_t *tolen)
{
int ret = 0;
iconv_t cd1, cd2;
char *ib;
char *ob;
char *utfbuf, *outbuf, *newbuf;
size_t utflen, outlen, ibl, obl, k;
char tbuf[2048];
cd1 = iconv_open("UTF-8", fromcode);
if (cd1 == (iconv_t)(-1))
return -1;
cd2 = (iconv_t)(-1);
/* Don't use strcasecmp() as it's locale-dependent. */
if (!strchr("Uu", tocode[0]) ||
!strchr("Tt", tocode[1]) ||
!strchr("Ff", tocode[2]) ||
tocode[3] != '-' ||
tocode[4] != '8' ||
tocode[5] != '\0') {
char *tocode1;
/*
* Try using this non-standard feature of glibc and libiconv.
* This is deliberately not a config option as people often
* change their iconv library without rebuilding applications.
*/
tocode1 = (char *)malloc(strlen(tocode) + 11);
if (!tocode1)
goto fail;
strcpy(tocode1, tocode);
strcat(tocode1, "//TRANSLIT");
cd2 = iconv_open(tocode1, "UTF-8");
free(tocode1);
if (cd2 == (iconv_t)(-1))
cd2 = iconv_open(tocode, fromcode);
if (cd2 == (iconv_t)(-1)) {
iconv_close(cd1);
return -1;
}
}
utflen = 1; /*fromlen * 2 + 1; XXX */
utfbuf = (char *)malloc(utflen);
if (!utfbuf)
goto fail;
/* Convert to UTF-8 */
ib = from;
ibl = fromlen;
ob = utfbuf;
obl = utflen;
for (;;) {
k = iconv(cd1, &ib, &ibl, &ob, &obl);
assert((!k && !ibl) ||
(k == (size_t)(-1) && errno == E2BIG && ibl && obl < 6) ||
(k == (size_t)(-1) &&
(errno == EILSEQ || errno == EINVAL) && ibl));
if (!ibl)
break;
if (obl < 6) {
/* Enlarge the buffer */
utflen *= 2;
newbuf = (char *)realloc(utfbuf, utflen);
if (!newbuf)
goto fail;
ob = (ob - utfbuf) + newbuf;
obl = utflen - (ob - utfbuf);
utfbuf = newbuf;
}
else {
/* Invalid input */
ib++, ibl--;
*ob++ = '#', obl--;
ret = 2;
iconv(cd1, 0, 0, 0, 0);
}
}
if (cd2 == (iconv_t)(-1)) {
/* The target encoding was UTF-8 */
if (tolen)
*tolen = ob - utfbuf;
if (!to) {
free(utfbuf);
iconv_close(cd1);
return ret;
}
newbuf = (char *)realloc(utfbuf, (ob - utfbuf) + 1);
if (!newbuf)
goto fail;
ob = (ob - utfbuf) + newbuf;
*ob = '\0';
*to = newbuf;
iconv_close(cd1);
return ret;
}
/* Truncate the buffer to be tidy */
utflen = ob - utfbuf;
newbuf = (char *)realloc(utfbuf, utflen);
if (!newbuf)
goto fail;
utfbuf = newbuf;
/* Convert from UTF-8 to discover how long the output is */
outlen = 0;
ib = utfbuf;
ibl = utflen;
while (ibl) {
ob = tbuf;
obl = sizeof(tbuf);
k = iconv(cd2, &ib, &ibl, &ob, &obl);
assert((k != (size_t)(-1) && !ibl) ||
(k == (size_t)(-1) && errno == E2BIG && ibl) ||
(k == (size_t)(-1) && errno == EILSEQ && ibl));
if (ibl && !(k == (size_t)(-1) && errno == E2BIG)) {
/* Replace one character */
char *tb = "?";
size_t tbl = 1;
outlen += ob - tbuf;
ob = tbuf;
obl = sizeof(tbuf);
k = iconv(cd2, &tb, &tbl, &ob, &obl);
assert((!k && !tbl) ||
(k == (size_t)(-1) && errno == EILSEQ && tbl));
for (++ib, --ibl; ibl && (*ib & 0x80); ib++, ibl--)
;
}
outlen += ob - tbuf;
}
ob = tbuf;
obl = sizeof(tbuf);
k = iconv(cd2, 0, 0, &ob, &obl);
assert(!k);
outlen += ob - tbuf;