?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(sigset): Return correct value reflecting previous signal state.
[glibc/history.git] / iconvdata / utf-16.c
blob7f6c7609004ecaff2654f25f0e96ea79fcc9c01c
1 /* Conversion module for UTF-16.
2 Copyright (C) 1999, 2000-2002, 2003, 2005 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1999.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 02111-1307 USA. */
20
21 #include <byteswap.h>
22 #include <dlfcn.h>
23 #include <gconv.h>
24 #include <stddef.h>
25 #include <stdint.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 /* This is the Byte Order Mark character (BOM). */
30 #define BOM 0xfeff
31 /* And in the other byte order. */
32 #define BOM_OE 0xfffe
33
34
35 /* Definitions used in the body of the `gconv' function. */
36 #define FROM_LOOP from_utf16_loop
37 #define TO_LOOP to_utf16_loop
38 #define DEFINE_INIT 0
39 #define DEFINE_FINI 0
40 #define MIN_NEEDED_FROM 2
41 #define MAX_NEEDED_FROM 4
42 #define MIN_NEEDED_TO 4
43 #define FROM_DIRECTION (dir == from_utf16)
44 #define PREPARE_LOOP \
45 enum direction dir = ((struct utf16_data *) step->__data)->dir; \
46 enum variant var = ((struct utf16_data *) step->__data)->var; \
47 if (__builtin_expect (data->__invocation_counter == 0, 0) && var == UTF_16) \
48 { \
49 if (FROM_DIRECTION) \
50 { \
51 /* We have to find out which byte order the file is encoded in. */ \
52 if (inptr + 2 > inend) \
53 return (inptr == inend \
54 ? __GCONV_EMPTY_INPUT : __GCONV_INCOMPLETE_INPUT); \
55 \
56 if (get16u (inptr) == BOM) \
57 /* Simply ignore the BOM character. */ \
58 *inptrp = inptr += 2; \
59 else if (get16u (inptr) == BOM_OE) \
60 { \
61 ((struct utf16_data *) step->__data)->swap = 1; \
62 *inptrp = inptr += 2; \
63 } \
64 } \
65 else if (!FROM_DIRECTION && !data->__internal_use) \
66 { \
67 /* Emit the Byte Order Mark. */ \
68 if (__builtin_expect (outbuf + 2 > outend, 0)) \
69 return __GCONV_FULL_OUTPUT; \
70 \
71 put16u (outbuf, BOM); \
72 outbuf += 2; \
73 } \
74 } \
75 int swap = ((struct utf16_data *) step->__data)->swap;
76 #define EXTRA_LOOP_ARGS , swap
77
78
79 /* Direction of the transformation. */
80 enum direction
81 {
82 illegal_dir,
83 to_utf16,
84 from_utf16
85 };
86
87 enum variant
88 {
89 illegal_var,
90 UTF_16,
91 UTF_16LE,
92 UTF_16BE
93 };
94
95 struct utf16_data
96 {
97 enum direction dir;
98 enum variant var;
99 int swap;
100 };
101
102
103 extern int gconv_init (struct __gconv_step *step);
104 int
105 gconv_init (struct __gconv_step *step)
106 {
107 /* Determine which direction. */
108 struct utf16_data *new_data;
109 enum direction dir = illegal_dir;
110 enum variant var = illegal_var;
111 int result;
112
113 if (__strcasecmp (step->__from_name, "UTF-16//") == 0)
114 {
115 dir = from_utf16;
116 var = UTF_16;
117 }
118 else if (__strcasecmp (step->__to_name, "UTF-16//") == 0)
119 {
120 dir = to_utf16;
121 var = UTF_16;
122 }
123 else if (__strcasecmp (step->__from_name, "UTF-16BE//") == 0)
124 {
125 dir = from_utf16;
126 var = UTF_16BE;
127 }
128 else if (__strcasecmp (step->__to_name, "UTF-16BE//") == 0)
129 {
130 dir = to_utf16;
131 var = UTF_16BE;
132 }
133 else if (__strcasecmp (step->__from_name, "UTF-16LE//") == 0)
134 {
135 dir = from_utf16;
136 var = UTF_16LE;
137 }
138 else if (__strcasecmp (step->__to_name, "UTF-16LE//") == 0)
139 {
140 dir = to_utf16;
141 var = UTF_16LE;
142 }
143
144 result = __GCONV_NOCONV;
145 if (__builtin_expect (dir, to_utf16) != illegal_dir)
146 {
147 new_data = (struct utf16_data *) malloc (sizeof (struct utf16_data));
148
149 result = __GCONV_NOMEM;
150 if (new_data != NULL)
151 {
152 new_data->dir = dir;
153 new_data->var = var;
154 new_data->swap = ((var == UTF_16LE && BYTE_ORDER == BIG_ENDIAN)
155 || (var == UTF_16BE
156 && BYTE_ORDER == LITTLE_ENDIAN));
157 step->__data = new_data;
158
159 if (dir == from_utf16)
160 {
161 step->__min_needed_from = MIN_NEEDED_FROM;
162 step->__max_needed_from = MAX_NEEDED_FROM;
163 step->__min_needed_to = MIN_NEEDED_TO;
164 step->__max_needed_to = MIN_NEEDED_TO;
165 }
166 else
167 {
168 step->__min_needed_from = MIN_NEEDED_TO;
169 step->__max_needed_from = MIN_NEEDED_TO;
170 step->__min_needed_to = MIN_NEEDED_FROM;
171 step->__max_needed_to = MAX_NEEDED_FROM;
172 }
173
174 step->__stateful = 0;
175
176 result = __GCONV_OK;
177 }
178 }
179
180 return result;
181 }
182
183
184 extern void gconv_end (struct __gconv_step *data);
185 void
186 gconv_end (struct __gconv_step *data)
187 {
188 free (data->__data);
189 }
190
191
192 /* Convert from the internal (UCS4-like) format to UTF-16. */
193 #define MIN_NEEDED_INPUT MIN_NEEDED_TO
194 #define MIN_NEEDED_OUTPUT MIN_NEEDED_FROM
195 #define MAX_NEEDED_OUTPUT MAX_NEEDED_FROM
196 #define LOOPFCT TO_LOOP
197 #define BODY \
198 { \
199 uint32_t c = get32 (inptr); \
200 \
201 if (__builtin_expect (c >= 0xd800 && c < 0xe000, 0)) \
202 { \
203 /* Surrogate characters in UCS-4 input are not valid. \
204 We must catch this. If we let surrogates pass through, \
205 attackers could make a security hole exploit by \
206 synthesizing any desired plane 1-16 character. */ \
207 result = __GCONV_ILLEGAL_INPUT; \
208 if (! ignore_errors_p ()) \
209 break; \
210 inptr += 4; \
211 ++*irreversible; \
212 continue; \
213 } \
214 \
215 if (swap) \
216 { \
217 if (__builtin_expect (c >= 0x10000, 0)) \
218 { \
219 if (__builtin_expect (c >= 0x110000, 0)) \
220 { \
221 STANDARD_TO_LOOP_ERR_HANDLER (4); \
222 } \
223 \
224 /* Generate a surrogate character. */ \
225 if (__builtin_expect (outptr + 4 > outend, 0)) \
226 { \
227 /* Overflow in the output buffer. */ \
228 result = __GCONV_FULL_OUTPUT; \
229 break; \
230 } \
231 \
232 put16 (outptr, bswap_16 (0xd7c0 + (c >> 10))); \
233 outptr += 2; \
234 put16 (outptr, bswap_16 (0xdc00 + (c & 0x3ff))); \
235 } \
236 else \
237 put16 (outptr, bswap_16 (c)); \
238 } \
239 else \
240 { \
241 if (__builtin_expect (c >= 0x10000, 0)) \
242 { \
243 if (__builtin_expect (c >= 0x110000, 0)) \
244 { \
245 STANDARD_TO_LOOP_ERR_HANDLER (4); \
246 } \
247 \
248 /* Generate a surrogate character. */ \
249 if (__builtin_expect (outptr + 4 > outend, 0)) \
250 { \
251 /* Overflow in the output buffer. */ \
252 result = __GCONV_FULL_OUTPUT; \
253 break; \
254 } \
255 \
256 put16 (outptr, 0xd7c0 + (c >> 10)); \
257 outptr += 2; \
258 put16 (outptr, 0xdc00 + (c & 0x3ff)); \
259 } \
260 else \
261 put16 (outptr, c); \
262 } \
263 outptr += 2; \
264 inptr += 4; \
265 }
266 #define LOOP_NEED_FLAGS
267 #define EXTRA_LOOP_DECLS \
268 , int swap
269 #include <iconv/loop.c>
270
271
272 /* Convert from UTF-16 to the internal (UCS4-like) format. */
273 #define MIN_NEEDED_INPUT MIN_NEEDED_FROM
274 #define MAX_NEEDED_INPUT MAX_NEEDED_FROM
275 #define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
276 #define LOOPFCT FROM_LOOP
277 #define BODY \
278 { \
279 uint16_t u1 = get16 (inptr); \
280 \
281 if (swap) \
282 { \
283 u1 = bswap_16 (u1); \
284 \
285 if (__builtin_expect (u1 < 0xd800, 1) || u1 > 0xdfff) \
286 { \
287 /* No surrogate. */ \
288 put32 (outptr, u1); \
289 inptr += 2; \
290 } \
291 else \
292 { \
293 uint16_t u2; \
294 \
295 /* It's a surrogate character. At least the first word says \
296 it is. */ \
297 if (__builtin_expect (inptr + 4 > inend, 0)) \
298 { \
299 /* We don't have enough input for another complete input \
300 character. */ \
301 result = __GCONV_INCOMPLETE_INPUT; \
302 break; \
303 } \
304 \
305 inptr += 2; \
306 u2 = bswap_16 (get16 (inptr)); \
307 if (__builtin_expect (u2 < 0xdc00, 0) \
308 || __builtin_expect (u2 > 0xdfff, 0)) \
309 { \
310 /* This is no valid second word for a surrogate. */ \
311 inptr -= 2; \
312 STANDARD_FROM_LOOP_ERR_HANDLER (2); \
313 } \
314 \
315 put32 (outptr, ((u1 - 0xd7c0) << 10) + (u2 - 0xdc00)); \
316 inptr += 2; \
317 } \
318 } \
319 else \
320 { \
321 if (__builtin_expect (u1 < 0xd800, 1) || u1 > 0xdfff) \
322 { \
323 /* No surrogate. */ \
324 put32 (outptr, u1); \
325 inptr += 2; \
326 } \
327 else \
328 { \
329 /* It's a surrogate character. At least the first word says \
330 it is. */ \
331 if (__builtin_expect (inptr + 4 > inend, 0)) \
332 { \
333 /* We don't have enough input for another complete input \
334 character. */ \
335 result = __GCONV_INCOMPLETE_INPUT; \
336 break; \
337 } \
338 \
339 inptr += 2; \
340 uint16_t u2 = get16 (inptr); \
341 if (__builtin_expect (u2 < 0xdc00, 0) \
342 || __builtin_expect (u2 > 0xdfff, 0)) \
343 { \
344 /* This is no valid second word for a surrogate. */ \
345 inptr -= 2; \
346 STANDARD_FROM_LOOP_ERR_HANDLER (2); \
347 } \
348 \
349 put32 (outptr, ((u1 - 0xd7c0) << 10) + (u2 - 0xdc00)); \
350 inptr += 2; \
351 } \
352 } \
353 outptr += 4; \
354 }
355 #define LOOP_NEED_FLAGS
356 #define EXTRA_LOOP_DECLS \
357 , int swap
358 #include <iconv/loop.c>
359
360
361 /* Now define the toplevel functions. */
362 #include <iconv/skeleton.c>
Unaltered CVS history