]>
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 #include "unicodeio.h"
53 /* When we pass a Unicode character to iconv(), we must pass it in a
54 suitable encoding. The standardized Unicode encodings are
55 UTF-8, UCS-2, UCS-4, UTF-16, UTF-16BE, UTF-16LE, UTF-7.
56 UCS-2 supports only characters up to \U0000FFFF.
57 UTF-16 and variants support only characters up to \U0010FFFF.
58 UTF-7 is way too complex and not supported by glibc-2.1.
59 UCS-4 specification leaves doubts about endianness and byte order
60 mark. glibc currently interprets it as big endian without byte order
61 mark, but this is not backed by an RFC.
62 So we use UTF-8. It supports characters up to \U7FFFFFFF and is
63 unambiguously defined. */
65 /* Stores the UTF-8 representation of the Unicode character wc in r[0..5].
66 Returns the number of bytes stored, or -1 if wc is out of range. */
68 utf8_wctomb (unsigned char *r
, unsigned int wc
)
76 else if (wc
< 0x10000)
78 else if (wc
< 0x200000)
80 else if (wc
< 0x4000000)
82 else if (wc
<= 0x7fffffff)
89 /* Note: code falls through cases! */
90 case 6: r
[5] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x4000000;
91 case 5: r
[4] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x200000;
92 case 4: r
[3] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x10000;
93 case 3: r
[2] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0x800;
94 case 2: r
[1] = 0x80 | (wc
& 0x3f); wc
= wc
>> 6; wc
|= 0xc0;
101 /* Luckily, the encoding's name is platform independent. */
102 #define UTF8_NAME "UTF-8"
104 /* Converts the Unicode character CODE to its multibyte representation
105 in the current locale and calls SUCCESS on the resulting byte
106 sequence. If an error occurs, invoke FAILURE instead,
107 passing it CODE with errno set appropriately.
108 Assumes that the locale doesn't change between two calls.
109 Return whatever the SUCCESS or FAILURE returns. */
111 unicode_to_mb (unsigned int code
,
112 int (*success
) PARAMS((const char *buf
, size_t buflen
,
113 void *callback_arg
)),
114 int (*failure
) PARAMS((unsigned int code
,
115 void *callback_arg
)),
118 static int initialized
;
121 static iconv_t utf8_to_local
;
129 extern const char *locale_charset
PARAMS ((void));
130 const char *charset
= locale_charset ();
132 is_utf8
= !strcmp (charset
, UTF8_NAME
);
136 utf8_to_local
= iconv_open (charset
, UTF8_NAME
);
137 if (utf8_to_local
== (iconv_t
)(-1))
139 /* For an unknown encoding, assume ASCII. */
140 utf8_to_local
= iconv_open ("ASCII", UTF8_NAME
);
141 if (utf8_to_local
== (iconv_t
)(-1))
142 return failure (code
, callback_arg
);
149 /* Convert the character to UTF-8. */
150 count
= utf8_wctomb ((unsigned char *) inbuf
, code
);
154 return failure (code
, callback_arg
);
159 return success (inbuf
, count
, callback_arg
);
174 outbytesleft
= sizeof (outbuf
);
176 /* Convert the character from UTF-8 to the locale's charset. */
177 res
= iconv (utf8_to_local
,
178 (ICONV_CONST
char **)&inptr
, &inbytesleft
,
179 &outptr
, &outbytesleft
);
180 if (inbytesleft
> 0 || res
== (size_t)(-1)
181 /* Irix iconv() inserts a NUL byte if it cannot convert. */
182 # if !defined _LIBICONV_VERSION && (defined sgi || defined __sgi)
183 || (res
> 0 && code
!= 0 && outptr
- outbuf
== 1 && *outbuf
== '\0')
187 if (res
!= (size_t)(-1))
189 return failure (code
, callback_arg
);
192 /* Avoid glibc-2.1 bug and Solaris 2.7 bug. */
193 # if defined _LIBICONV_VERSION \
194 || !((__GLIBC__ - 0 == 2 && __GLIBC_MINOR__ - 0 <= 1) || defined __sun)
196 /* Get back to the initial shift state. */
197 res
= iconv (utf8_to_local
, NULL
, NULL
, &outptr
, &outbytesleft
);
198 if (res
== (size_t)(-1))
199 return failure (code
, callback_arg
);
202 return success (outbuf
, outptr
- outbuf
, callback_arg
);
205 return failure (code
, callback_arg
);
210 /* Simple success callback that outputs the converted string.
211 The STREAM is passed as callback_arg. */
213 print_unicode_success (const char *buf
, size_t buflen
, void *callback_arg
)
215 FILE *stream
= (FILE *) callback_arg
;
217 return fwrite (buf
, 1, buflen
, stream
) == 0 ? -1 : 0;
220 /* Simple failure callback that prints an ASCII representation, using
221 the same notation as C99 strings. */
223 print_unicode_failure (unsigned int code
, void *callback_arg
)
226 FILE *stream
= callback_arg
;
228 fprintf (stream
, code
< 0x10000 ? "\\u%04X" : "\\U%08X", code
);
233 /* Outputs the Unicode character CODE to the output stream STREAM.
234 Returns zero if successful, -1 (setting errno) otherwise.
235 Assumes that the locale doesn't change between two calls. */
237 print_unicode_char (FILE *stream
, unsigned int code
)
239 return unicode_to_mb (code
, print_unicode_success
, print_unicode_failure
,
This page took 0.050656 seconds and 5 git commands to generate.