]>
Dogcows Code - chaz/tar/blob - lib/unicodeio.c
1 /* Unicode character output to streams with locale dependent encoding.
3 Copyright (C) 2000, 2001 Free Software Foundation, Inc.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software Foundation,
17 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19 /* Written by Bruno Haible <haible@clisp.cons.org>. */
41 # define EILSEQ EINVAL
44 # define ENOTSUP EINVAL
53 # define _(Text) gettext (Text)
58 #include "unicodeio.h"
60 /* When we pass a Unicode character to iconv(), we must pass it in a
61 suitable encoding. The standardized Unicode encodings are
62 UTF-8, UCS-2, UCS-4, UTF-16, UTF-16BE, UTF-16LE, UTF-7.
63 UCS-2 supports only characters up to \U0000FFFF.
64 UTF-16 and variants support only characters up to \U0010FFFF.
65 UTF-7 is way too complex and not supported by glibc-2.1.
66 UCS-4 specification leaves doubts about endianness and byte order
67 mark. glibc currently interprets it as big endian without byte order
68 mark, but this is not backed by an RFC.
69 So we use UTF-8. It supports characters up to \U7FFFFFFF and is
70 unambiguously defined. */
72 /* Stores the UTF-8 representation of the Unicode character wc in r[0..5].
73 Returns the number of bytes stored, or -1 if wc is out of range. */
75 utf8_wctomb (unsigned char *r
, unsigned int wc
)
83 else if (wc
< 0x10000)
85 else if (wc
< 0x200000)
87 else if (wc
< 0x4000000)
89 else if (wc
<= 0x7fffffff)
96 /* Note: code falls through cases! */
97 case 6: r
[5] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x4000000;
98 case 5: r
[4] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x200000;
99 case 4: r
[3] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x10000;
100 case 3: r
[2] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x800;
101 case 2: r
[1] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0xc0;
108 /* Luckily, the encoding's name is platform independent. */
109 #define UTF8_NAME "UTF-8"
111 /* Converts the Unicode character CODE to its multibyte representation
112 in the current locale and calls SUCCESS on the resulting byte
113 sequence. If an error occurs, invoke FAILURE instead,
114 passing it CODE with errno set appropriately.
115 Assumes that the locale doesn't change between two calls.
116 Return whatever the SUCCESS or FAILURE returns. */
118 unicode_to_mb (unsigned int code
,
119 int (*success
) PARAMS((const char *buf
, size_t buflen
,
120 void *callback_arg
)),
121 int (*failure
) PARAMS((unsigned int code
,
122 void *callback_arg
)),
125 static int initialized
;
128 static iconv_t utf8_to_local
;
136 extern const char *locale_charset
PARAMS ((void));
137 const char *charset
= locale_charset ();
139 is_utf8
= !strcmp (charset
, UTF8_NAME
);
143 utf8_to_local
= iconv_open (charset
, UTF8_NAME
);
144 if (utf8_to_local
== (iconv_t
)(-1))
146 /* For an unknown encoding, assume ASCII. */
147 utf8_to_local
= iconv_open ("ASCII", UTF8_NAME
);
148 if (utf8_to_local
== (iconv_t
)(-1))
149 return failure (code
, callback_arg
);
156 /* Convert the character to UTF-8. */
157 count
= utf8_wctomb ((unsigned char *) inbuf
, code
);
161 return failure (code
, callback_arg
);
166 return success (inbuf
, count
, callback_arg
);
181 outbytesleft
= sizeof (outbuf
);
183 /* Convert the character from UTF-8 to the locale's charset. */
184 res
= iconv (utf8_to_local
,
185 (ICONV_CONST
char **)&inptr
, &inbytesleft
,
186 &outptr
, &outbytesleft
);
187 if (inbytesleft
> 0 || res
== (size_t)(-1)
188 /* Irix iconv() inserts a NUL byte if it cannot convert. */
189 # if !defined _LIBICONV_VERSION && (defined sgi || defined __sgi)
190 || (res
> 0 && code
!= 0 && outptr
- outbuf
== 1 && *outbuf
== '\0')
194 if (res
!= (size_t)(-1))
196 return failure (code
, callback_arg
);
199 /* Avoid glibc-2.1 bug and Solaris 2.7 bug. */
200 # if defined _LIBICONV_VERSION \
201 || !((__GLIBC__ - 0 == 2 && __GLIBC_MINOR__ - 0 <= 1) || defined __sun)
203 /* Get back to the initial shift state. */
204 res
= iconv (utf8_to_local
, NULL
, NULL
, &outptr
, &outbytesleft
);
205 if (res
== (size_t)(-1))
206 return failure (code
, callback_arg
);
209 return success (outbuf
, outptr
- outbuf
, callback_arg
);
212 return failure (code
, callback_arg
);
217 /* Simple success callback that outputs the converted string.
218 The STREAM is passed as callback_arg. */
220 print_unicode_success (const char *buf
, size_t buflen
, void *callback_arg
)
222 FILE *stream
= (FILE *) callback_arg
;
224 return fwrite (buf
, 1, buflen
, stream
) == 0 ? -1 : 0;
227 /* Simple failure callback that prints an ASCII representation, using
228 the same notation as C99 strings. */
230 print_unicode_failure (unsigned int code
, void *callback_arg
)
233 FILE *stream
= callback_arg
;
235 fprintf (stream
, code
< 0x10000 ? "\\u%04X" : "\\U%08X", code
);
240 /* Outputs the Unicode character CODE to the output stream STREAM.
241 Returns zero if successful, -1 (setting errno) otherwise.
242 Assumes that the locale doesn't change between two calls. */
244 print_unicode_char (FILE *stream
, unsigned int code
)
246 return unicode_to_mb (code
, print_unicode_success
, print_unicode_failure
,
This page took 0.046073 seconds and 4 git commands to generate.