]> git.saurik.com Git - apple/icu.git/blob - icuSources/common/udataswp.cpp
projects / apple / icu.git / blob
? search:


86f302bd9c3ab938803309f92fe4296163a4b2b5
[apple/icu.git] / icuSources / common / udataswp.cpp
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 *******************************************************************************
5 *
6 * Copyright (C) 2003-2014, International Business Machines
7 * Corporation and others. All Rights Reserved.
8 *
9 *******************************************************************************
10 * file name: udataswp.c
11 * encoding: UTF-8
12 * tab size: 8 (not used)
13 * indentation:4
14 *
15 * created on: 2003jun05
16 * created by: Markus W. Scherer
17 *
18 * Definitions for ICU data transformations for different platforms,
19 * changing between big- and little-endian data and/or between
20 * charset families (ASCII<->EBCDIC).
21 */
22
23 #include <stdarg.h>
24 #include "unicode/utypes.h"
25 #include "unicode/udata.h" /* UDataInfo */
26 #include "ucmndata.h" /* DataHeader */
27 #include "cmemory.h"
28 #include "udataswp.h"
29
30 /* swapping primitives ------------------------------------------------------ */
31
32 static int32_t U_CALLCONV
33 uprv_swapArray16(const UDataSwapper *ds,
34 const void *inData, int32_t length, void *outData,
35 UErrorCode *pErrorCode) {
36 const uint16_t *p;
37 uint16_t *q;
38 int32_t count;
39 uint16_t x;
40
41 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
42 return 0;
43 }
44 if(ds==NULL || inData==NULL || length<0 || (length&1)!=0 || outData==NULL) {
45 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
46 return 0;
47 }
48
49 /* setup and swapping */
50 p=(const uint16_t *)inData;
51 q=(uint16_t *)outData;
52 count=length/2;
53 while(count>0) {
54 x=*p++;
55 *q++=(uint16_t)((x<<8)|(x>>8));
56 --count;
57 }
58
59 return length;
60 }
61
62 static int32_t U_CALLCONV
63 uprv_copyArray16(const UDataSwapper *ds,
64 const void *inData, int32_t length, void *outData,
65 UErrorCode *pErrorCode) {
66 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
67 return 0;
68 }
69 if(ds==NULL || inData==NULL || length<0 || (length&1)!=0 || outData==NULL) {
70 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
71 return 0;
72 }
73
74 if(length>0 && inData!=outData) {
75 uprv_memcpy(outData, inData, length);
76 }
77 return length;
78 }
79
80 static int32_t U_CALLCONV
81 uprv_swapArray32(const UDataSwapper *ds,
82 const void *inData, int32_t length, void *outData,
83 UErrorCode *pErrorCode) {
84 const uint32_t *p;
85 uint32_t *q;
86 int32_t count;
87 uint32_t x;
88
89 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
90 return 0;
91 }
92 if(ds==NULL || inData==NULL || length<0 || (length&3)!=0 || outData==NULL) {
93 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
94 return 0;
95 }
96
97 /* setup and swapping */
98 p=(const uint32_t *)inData;
99 q=(uint32_t *)outData;
100 count=length/4;
101 while(count>0) {
102 x=*p++;
103 *q++=(uint32_t)((x<<24)|((x<<8)&0xff0000)|((x>>8)&0xff00)|(x>>24));
104 --count;
105 }
106
107 return length;
108 }
109
110 static int32_t U_CALLCONV
111 uprv_copyArray32(const UDataSwapper *ds,
112 const void *inData, int32_t length, void *outData,
113 UErrorCode *pErrorCode) {
114 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
115 return 0;
116 }
117 if(ds==NULL || inData==NULL || length<0 || (length&3)!=0 || outData==NULL) {
118 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
119 return 0;
120 }
121
122 if(length>0 && inData!=outData) {
123 uprv_memcpy(outData, inData, length);
124 }
125 return length;
126 }
127
128 static int32_t U_CALLCONV
129 uprv_swapArray64(const UDataSwapper *ds,
130 const void *inData, int32_t length, void *outData,
131 UErrorCode *pErrorCode) {
132 const uint64_t *p;
133 uint64_t *q;
134 int32_t count;
135
136 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
137 return 0;
138 }
139 if(ds==NULL || inData==NULL || length<0 || (length&7)!=0 || outData==NULL) {
140 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
141 return 0;
142 }
143
144 /* setup and swapping */
145 p=(const uint64_t *)inData;
146 q=(uint64_t *)outData;
147 count=length/8;
148 while(count>0) {
149 uint64_t x=*p++;
150 x=(x<<56)|((x&0xff00)<<40)|((x&0xff0000)<<24)|((x&0xff000000)<<8)|
151 ((x>>8)&0xff000000)|((x>>24)&0xff0000)|((x>>40)&0xff00)|(x>>56);
152 *q++=x;
153 --count;
154 }
155
156 return length;
157 }
158
159 static int32_t U_CALLCONV
160 uprv_copyArray64(const UDataSwapper *ds,
161 const void *inData, int32_t length, void *outData,
162 UErrorCode *pErrorCode) {
163 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
164 return 0;
165 }
166 if(ds==NULL || inData==NULL || length<0 || (length&7)!=0 || outData==NULL) {
167 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
168 return 0;
169 }
170
171 if(length>0 && inData!=outData) {
172 uprv_memcpy(outData, inData, length);
173 }
174 return length;
175 }
176
177 static uint16_t U_CALLCONV
178 uprv_readSwapUInt16(uint16_t x) {
179 return (uint16_t)((x<<8)|(x>>8));
180 }
181
182 static uint16_t U_CALLCONV
183 uprv_readDirectUInt16(uint16_t x) {
184 return x;
185 }
186
187 static uint32_t U_CALLCONV
188 uprv_readSwapUInt32(uint32_t x) {
189 return (uint32_t)((x<<24)|((x<<8)&0xff0000)|((x>>8)&0xff00)|(x>>24));
190 }
191
192 static uint32_t U_CALLCONV
193 uprv_readDirectUInt32(uint32_t x) {
194 return x;
195 }
196
197 static void U_CALLCONV
198 uprv_writeSwapUInt16(uint16_t *p, uint16_t x) {
199 *p=(uint16_t)((x<<8)|(x>>8));
200 }
201
202 static void U_CALLCONV
203 uprv_writeDirectUInt16(uint16_t *p, uint16_t x) {
204 *p=x;
205 }
206
207 static void U_CALLCONV
208 uprv_writeSwapUInt32(uint32_t *p, uint32_t x) {
209 *p=(uint32_t)((x<<24)|((x<<8)&0xff0000)|((x>>8)&0xff00)|(x>>24));
210 }
211
212 static void U_CALLCONV
213 uprv_writeDirectUInt32(uint32_t *p, uint32_t x) {
214 *p=x;
215 }
216
217 U_CAPI int16_t U_EXPORT2
218 udata_readInt16(const UDataSwapper *ds, int16_t x) {
219 return (int16_t)ds->readUInt16((uint16_t)x);
220 }
221
222 U_CAPI int32_t U_EXPORT2
223 udata_readInt32(const UDataSwapper *ds, int32_t x) {
224 return (int32_t)ds->readUInt32((uint32_t)x);
225 }
226
227 /**
228 * Swap a block of invariant, NUL-terminated strings, but not padding
229 * bytes after the last string.
230 * @internal
231 */
232 U_CAPI int32_t U_EXPORT2
233 udata_swapInvStringBlock(const UDataSwapper *ds,
234 const void *inData, int32_t length, void *outData,
235 UErrorCode *pErrorCode) {
236 const char *inChars;
237 int32_t stringsLength;
238
239 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
240 return 0;
241 }
242 if(ds==NULL || inData==NULL || length<0 || (length>0 && outData==NULL)) {
243 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
244 return 0;
245 }
246
247 /* reduce the strings length to not include bytes after the last NUL */
248 inChars=(const char *)inData;
249 stringsLength=length;
250 while(stringsLength>0 && inChars[stringsLength-1]!=0) {
251 --stringsLength;
252 }
253
254 /* swap up to the last NUL */
255 ds->swapInvChars(ds, inData, stringsLength, outData, pErrorCode);
256
257 /* copy the bytes after the last NUL */
258 if(inData!=outData && length>stringsLength) {
259 uprv_memcpy((char *)outData+stringsLength, inChars+stringsLength, length-stringsLength);
260 }
261
262 /* return the length including padding bytes */
263 if(U_SUCCESS(*pErrorCode)) {
264 return length;
265 } else {
266 return 0;
267 }
268 }
269
270 U_CAPI void U_EXPORT2
271 udata_printError(const UDataSwapper *ds,
272 const char *fmt,
273 ...) {
274 va_list args;
275
276 if(ds->printError!=NULL) {
277 va_start(args, fmt);
278 ds->printError(ds->printErrorContext, fmt, args);
279 va_end(args);
280 }
281 }
282
283 /* swap a data header ------------------------------------------------------- */
284
285 U_CAPI int32_t U_EXPORT2
286 udata_swapDataHeader(const UDataSwapper *ds,
287 const void *inData, int32_t length, void *outData,
288 UErrorCode *pErrorCode) {
289 const DataHeader *pHeader;
290 uint16_t headerSize, infoSize;
291
292 /* argument checking */
293 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
294 return 0;
295 }
296 if(ds==NULL || inData==NULL || length<-1 || (length>0 && outData==NULL)) {
297 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
298 return 0;
299 }
300
301 /* check minimum length and magic bytes */
302 pHeader=(const DataHeader *)inData;
303 if( (length>=0 && length<(int32_t)sizeof(DataHeader)) ||
304 pHeader->dataHeader.magic1!=0xda ||
305 pHeader->dataHeader.magic2!=0x27 ||
306 pHeader->info.sizeofUChar!=2
307 ) {
308 udata_printError(ds, "udata_swapDataHeader(): initial bytes do not look like ICU data\n");
309 *pErrorCode=U_UNSUPPORTED_ERROR;
310 return 0;
311 }
312
313 headerSize=ds->readUInt16(pHeader->dataHeader.headerSize);
314 infoSize=ds->readUInt16(pHeader->info.size);
315
316 if( headerSize<sizeof(DataHeader) ||
317 infoSize<sizeof(UDataInfo) ||
318 headerSize<(sizeof(pHeader->dataHeader)+infoSize) ||
319 (length>=0 && length<headerSize)
320 ) {
321 udata_printError(ds, "udata_swapDataHeader(): header size mismatch - headerSize %d infoSize %d length %d\n",
322 headerSize, infoSize, length);
323 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
324 return 0;
325 }
326
327 if(length>0) {
328 DataHeader *outHeader;
329 const char *s;
330 int32_t maxLength;
331
332 /* Most of the fields are just bytes and need no swapping. */
333 if(inData!=outData) {
334 uprv_memcpy(outData, inData, headerSize);
335 }
336 outHeader=(DataHeader *)outData;
337
338 outHeader->info.isBigEndian = ds->outIsBigEndian;
339 outHeader->info.charsetFamily = ds->outCharset;
340
341 /* swap headerSize */
342 ds->swapArray16(ds, &pHeader->dataHeader.headerSize, 2, &outHeader->dataHeader.headerSize, pErrorCode);
343
344 /* swap UDataInfo size and reservedWord */
345 ds->swapArray16(ds, &pHeader->info.size, 4, &outHeader->info.size, pErrorCode);
346
347 /* swap copyright statement after the UDataInfo */
348 infoSize+=sizeof(pHeader->dataHeader);
349 s=(const char *)inData+infoSize;
350 maxLength=headerSize-infoSize;
351 /* get the length of the string */
352 for(length=0; length<maxLength && s[length]!=0; ++length) {}
353 /* swap the string contents */
354 ds->swapInvChars(ds, s, length, (char *)outData+infoSize, pErrorCode);
355 }
356
357 return headerSize;
358 }
359
360 /* API functions ------------------------------------------------------------ */
361
362 U_CAPI UDataSwapper * U_EXPORT2
363 udata_openSwapper(UBool inIsBigEndian, uint8_t inCharset,
364 UBool outIsBigEndian, uint8_t outCharset,
365 UErrorCode *pErrorCode) {
366 UDataSwapper *swapper;
367
368 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
369 return NULL;
370 }
371 if(inCharset>U_EBCDIC_FAMILY || outCharset>U_EBCDIC_FAMILY) {
372 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
373 return NULL;
374 }
375
376 /* allocate the swapper */
377 swapper=(UDataSwapper *)uprv_malloc(sizeof(UDataSwapper));
378 if(swapper==NULL) {
379 *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
380 return NULL;
381 }
382 uprv_memset(swapper, 0, sizeof(UDataSwapper));
383
384 /* set values and functions pointers according to in/out parameters */
385 swapper->inIsBigEndian=inIsBigEndian;
386 swapper->inCharset=inCharset;
387 swapper->outIsBigEndian=outIsBigEndian;
388 swapper->outCharset=outCharset;
389
390 swapper->readUInt16= inIsBigEndian==U_IS_BIG_ENDIAN ? uprv_readDirectUInt16 : uprv_readSwapUInt16;
391 swapper->readUInt32= inIsBigEndian==U_IS_BIG_ENDIAN ? uprv_readDirectUInt32 : uprv_readSwapUInt32;
392
393 swapper->writeUInt16= outIsBigEndian==U_IS_BIG_ENDIAN ? uprv_writeDirectUInt16 : uprv_writeSwapUInt16;
394 swapper->writeUInt32= outIsBigEndian==U_IS_BIG_ENDIAN ? uprv_writeDirectUInt32 : uprv_writeSwapUInt32;
395
396 swapper->compareInvChars= outCharset==U_ASCII_FAMILY ? uprv_compareInvAscii : uprv_compareInvEbcdic;
397
398 if(inIsBigEndian==outIsBigEndian) {
399 swapper->swapArray16=uprv_copyArray16;
400 swapper->swapArray32=uprv_copyArray32;
401 swapper->swapArray64=uprv_copyArray64;
402 } else {
403 swapper->swapArray16=uprv_swapArray16;
404 swapper->swapArray32=uprv_swapArray32;
405 swapper->swapArray64=uprv_swapArray64;
406 }
407
408 if(inCharset==U_ASCII_FAMILY) {
409 swapper->swapInvChars= outCharset==U_ASCII_FAMILY ? uprv_copyAscii : uprv_ebcdicFromAscii;
410 } else /* U_EBCDIC_FAMILY */ {
411 swapper->swapInvChars= outCharset==U_EBCDIC_FAMILY ? uprv_copyEbcdic : uprv_asciiFromEbcdic;
412 }
413
414 return swapper;
415 }
416
417 U_CAPI UDataSwapper * U_EXPORT2
418 udata_openSwapperForInputData(const void *data, int32_t length,
419 UBool outIsBigEndian, uint8_t outCharset,
420 UErrorCode *pErrorCode) {
421 const DataHeader *pHeader;
422 uint16_t headerSize, infoSize;
423 UBool inIsBigEndian;
424 int8_t inCharset;
425
426 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
427 return NULL;
428 }
429 if( data==NULL ||
430 (length>=0 && length<(int32_t)sizeof(DataHeader)) ||
431 outCharset>U_EBCDIC_FAMILY
432 ) {
433 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
434 return NULL;
435 }
436
437 pHeader=(const DataHeader *)data;
438 if( (length>=0 && length<(int32_t)sizeof(DataHeader)) ||
439 pHeader->dataHeader.magic1!=0xda ||
440 pHeader->dataHeader.magic2!=0x27 ||
441 pHeader->info.sizeofUChar!=2
442 ) {
443 *pErrorCode=U_UNSUPPORTED_ERROR;
444 return 0;
445 }
446
447 inIsBigEndian=(UBool)pHeader->info.isBigEndian;
448 inCharset=pHeader->info.charsetFamily;
449
450 if(inIsBigEndian==U_IS_BIG_ENDIAN) {
451 headerSize=pHeader->dataHeader.headerSize;
452 infoSize=pHeader->info.size;
453 } else {
454 headerSize=uprv_readSwapUInt16(pHeader->dataHeader.headerSize);
455 infoSize=uprv_readSwapUInt16(pHeader->info.size);
456 }
457
458 if( headerSize<sizeof(DataHeader) ||
459 infoSize<sizeof(UDataInfo) ||
460 headerSize<(sizeof(pHeader->dataHeader)+infoSize) ||
461 (length>=0 && length<headerSize)
462 ) {
463 *pErrorCode=U_UNSUPPORTED_ERROR;
464 return 0;
465 }
466
467 return udata_openSwapper(inIsBigEndian, inCharset, outIsBigEndian, outCharset, pErrorCode);
468 }
469
470 U_CAPI void U_EXPORT2
471 udata_closeSwapper(UDataSwapper *ds) {
472 uprv_free(ds);
473 }
mirror of ICU