]>
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
51 #if HAVE_LANGINFO_CODESET && ! USE_INCLUDED_LIBINTL
52 # include <langinfo.h>
55 #include "unicodeio.h"
57 /* When we pass a Unicode character to iconv(), we must pass it in a
58 suitable encoding. The standardized Unicode encodings are
59 UTF-8, UCS-2, UCS-4, UTF-16, UTF-16BE, UTF-16LE, UTF-7.
60 UCS-2 supports only characters up to \U0000FFFF.
61 UTF-16 and variants support only characters up to \U0010FFFF.
62 UTF-7 is way too complex and not supported by glibc-2.1.
63 UCS-4 specification leaves doubts about endianness and byte order
64 mark. glibc currently interprets it as big endian without byte order
65 mark, but this is not backed by an RFC.
66 So we use UTF-8. It supports characters up to \U7FFFFFFF and is
67 unambiguously defined. */
69 /* Stores the UTF-8 representation of the Unicode character wc in r[0..5].
70 Returns the number of bytes stored, or -1 if wc is out of range. */
72 utf8_wctomb (unsigned char *r
, unsigned int wc
)
80 else if (wc
< 0x10000)
82 else if (wc
< 0x200000)
84 else if (wc
< 0x4000000)
86 else if (wc
<= 0x7fffffff)
93 /* Note: code falls through cases! */
94 case 6: r
[5] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x4000000;
95 case 5: r
[4] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x200000;
96 case 4: r
[3] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x10000;
97 case 3: r
[2] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x800;
98 case 2: r
[1] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0xc0;
105 /* Luckily, the encoding's name is platform independent. */
106 #define UTF8_NAME "UTF-8"
108 /* Converts the Unicode character CODE to its multibyte representation
109 in the current locale and calls SUCCESS on the resulting byte
110 sequence. If an error occurs, invoke FAILURE instead,
111 passing it CODE with errno set appropriately.
112 Assumes that the locale doesn't change between two calls.
113 Return whatever the SUCCESS or FAILURE returns. */
115 unicode_to_mb (unsigned int code
,
116 int (*success
) PARAMS((const char *buf
, size_t buflen
,
117 void *callback_arg
)),
118 int (*failure
) PARAMS((unsigned int code
,
119 void *callback_arg
)),
122 static int initialized
;
125 static iconv_t utf8_to_local
;
135 #if USE_INCLUDED_LIBINTL
136 extern const char *locale_charset
PARAMS ((void));
137 charset
= locale_charset ();
139 # if HAVE_LANGINFO_CODESET
140 charset
= nl_langinfo (CODESET
);
146 is_utf8
= !strcmp (charset
, UTF8_NAME
);
150 utf8_to_local
= iconv_open (charset
, UTF8_NAME
);
151 if (utf8_to_local
== (iconv_t
)(-1))
153 /* For an unknown encoding, assume ASCII. */
154 utf8_to_local
= iconv_open ("ASCII", UTF8_NAME
);
155 if (utf8_to_local
== (iconv_t
)(-1))
156 return failure (code
, callback_arg
);
163 /* Convert the character to UTF-8. */
164 count
= utf8_wctomb ((unsigned char *) inbuf
, code
);
168 return failure (code
, callback_arg
);
173 return success (inbuf
, count
, callback_arg
);
188 outbytesleft
= sizeof (outbuf
);
190 /* Convert the character from UTF-8 to the locale's charset. */
191 res
= iconv (utf8_to_local
,
192 (ICONV_CONST
char **)&inptr
, &inbytesleft
,
193 &outptr
, &outbytesleft
);
194 if (inbytesleft
> 0 || res
== (size_t)(-1)
195 /* Irix iconv() inserts a NUL byte if it cannot convert. */
196 # if !defined _LIBICONV_VERSION && (defined sgi || defined __sgi)
197 || (res
> 0 && code
!= 0 && outptr
- outbuf
== 1 && *outbuf
== '\0')
201 if (res
!= (size_t)(-1))
203 return failure (code
, callback_arg
);
206 /* Avoid glibc-2.1 bug and Solaris 2.7 bug. */
207 # if defined _LIBICONV_VERSION \
208 || !((__GLIBC__ - 0 == 2 && __GLIBC_MINOR__ - 0 <= 1) || defined __sun)
210 /* Get back to the initial shift state. */
211 res
= iconv (utf8_to_local
, NULL
, NULL
, &outptr
, &outbytesleft
);
212 if (res
== (size_t)(-1))
213 return failure (code
, callback_arg
);
216 return success (outbuf
, outptr
- outbuf
, callback_arg
);
219 return failure (code
, callback_arg
);
224 /* Simple success callback that outputs the converted string.
225 The STREAM is passed as callback_arg. */
227 print_unicode_success (const char *buf
, size_t buflen
, void *callback_arg
)
229 FILE *stream
= (FILE *) callback_arg
;
231 return fwrite (buf
, 1, buflen
, stream
) == 0 ? -1 : 0;
234 /* Simple failure callback that prints an ASCII representation, using
235 the same notation as C99 strings. */
237 print_unicode_failure (unsigned int code
, void *callback_arg
)
240 FILE *stream
= callback_arg
;
242 fprintf (stream
, code
< 0x10000 ? "\\u%04X" : "\\U%08X", code
);
247 /* Outputs the Unicode character CODE to the output stream STREAM.
248 Returns zero if successful, -1 (setting errno) otherwise.
249 Assumes that the locale doesn't change between two calls. */
251 print_unicode_char (FILE *stream
, unsigned int code
)
253 return unicode_to_mb (code
, print_unicode_success
, print_unicode_failure
,
This page took 0.04198 seconds and 4 git commands to generate.