The Tor Browser / file comparison

comparison: intl/icu/source/common/uinvchar.c

intl/icu/source/common/uinvchar.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:82fbc5e87218
1 /*
2 *******************************************************************************
3 *
4 * Copyright (C) 1999-2010, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 *******************************************************************************
8 * file name: uinvchar.c
9 * encoding: US-ASCII
10 * tab size: 8 (not used)
11 * indentation:2
12 *
13 * created on: 2004sep14
14 * created by: Markus W. Scherer
15 *
16 * Functions for handling invariant characters, moved here from putil.c
17 * for better modularization.
18 */
19
20 #include "unicode/utypes.h"
21 #include "unicode/ustring.h"
22 #include "udataswp.h"
23 #include "cstring.h"
24 #include "cmemory.h"
25 #include "uassert.h"
26 #include "uinvchar.h"
27
28 /* invariant-character handling --------------------------------------------- */
29
30 /*
31 * These maps for ASCII to/from EBCDIC map invariant characters (see utypes.h)
32 * appropriately for most EBCDIC codepages.
33 *
34 * They currently also map most other ASCII graphic characters,
35 * appropriately for codepages 37 and 1047.
36 * Exceptions: The characters for []^ have different codes in 37 & 1047.
37 * Both versions are mapped to ASCII.
38 *
39 * ASCII 37 1047
40 * [ 5B BA AD
41 * ] 5D BB BD
42 * ^ 5E B0 5F
43 *
44 * There are no mappings for variant characters from Unicode to EBCDIC.
45 *
46 * Currently, C0 control codes are also included in these maps.
47 * Exceptions: S/390 Open Edition swaps LF and NEL codes compared with other
48 * EBCDIC platforms; both codes (15 and 25) are mapped to ASCII LF (0A),
49 * but there is no mapping for ASCII LF back to EBCDIC.
50 *
51 * ASCII EBCDIC S/390-OE
52 * LF 0A 25 15
53 * NEL 85 15 25
54 *
55 * The maps below explicitly exclude the variant
56 * control and graphical characters that are in ASCII-based
57 * codepages at 0x80 and above.
58 * "No mapping" is expressed by mapping to a 00 byte.
59 *
60 * These tables do not establish a converter or a codepage.
61 */
62
63 static const uint8_t asciiFromEbcdic[256]={
64 0x00, 0x01, 0x02, 0x03, 0x00, 0x09, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
65 0x10, 0x11, 0x12, 0x13, 0x00, 0x0a, 0x08, 0x00, 0x18, 0x19, 0x00, 0x00, 0x1c, 0x1d, 0x1e, 0x1f,
66 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x17, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x07,
67 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x00, 0x1a,
68
69 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x3c, 0x28, 0x2b, 0x7c,
70 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x5e,
71 0x2d, 0x2f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x25, 0x5f, 0x3e, 0x3f,
72 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22,
73
74 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
75 0x00, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
76 0x00, 0x7e, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00,
77 0x5e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x5d, 0x00, 0x5d, 0x00, 0x00,
78
79 0x7b, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
80 0x7d, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
81 0x5c, 0x00, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
82 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
83 };
84
85 static const uint8_t ebcdicFromAscii[256]={
86 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x00, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
87 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
88 0x40, 0x00, 0x7f, 0x00, 0x00, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
89 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
90
91 0x00, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
92 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x00, 0x00, 0x00, 0x00, 0x6d,
93 0x00, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
94 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0x00, 0x00, 0x00, 0x00, 0x07,
95
96 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
97 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
98 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
99 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
100
101 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
102 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
103 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
104 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
105 };
106
107 /* Same as asciiFromEbcdic[] except maps all letters to lowercase. */
108 static const uint8_t lowercaseAsciiFromEbcdic[256]={
109 0x00, 0x01, 0x02, 0x03, 0x00, 0x09, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
110 0x10, 0x11, 0x12, 0x13, 0x00, 0x0a, 0x08, 0x00, 0x18, 0x19, 0x00, 0x00, 0x1c, 0x1d, 0x1e, 0x1f,
111 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x17, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x07,
112 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x00, 0x1a,
113
114 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x3c, 0x28, 0x2b, 0x7c,
115 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x5e,
116 0x2d, 0x2f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x25, 0x5f, 0x3e, 0x3f,
117 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22,
118
119 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
120 0x00, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
121 0x00, 0x7e, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00,
122 0x5e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x5d, 0x00, 0x5d, 0x00, 0x00,
123
124 0x7b, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
125 0x7d, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
126 0x7c, 0x00, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
127 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
128 };
129
130 /*
131 * Bit sets indicating which characters of the ASCII repertoire
132 * (by ASCII/Unicode code) are "invariant".
133 * See utypes.h for more details.
134 *
135 * As invariant are considered the characters of the ASCII repertoire except
136 * for the following:
137 * 21 '!' <exclamation mark>
138 * 23 '#' <number sign>
139 * 24 '$' <dollar sign>
140 *
141 * 40 '@' <commercial at>
142 *
143 * 5b '[' <left bracket>
144 * 5c '\' <backslash>
145 * 5d ']' <right bracket>
146 * 5e '^' <circumflex>
147 *
148 * 60 '`' <grave accent>
149 *
150 * 7b '{' <left brace>
151 * 7c '|' <vertical line>
152 * 7d '}' <right brace>
153 * 7e '~' <tilde>
154 */
155 static const uint32_t invariantChars[4]={
156 0xfffffbff, /* 00..1f but not 0a */
157 0xffffffe5, /* 20..3f but not 21 23 24 */
158 0x87fffffe, /* 40..5f but not 40 5b..5e */
159 0x87fffffe /* 60..7f but not 60 7b..7e */
160 };
161
162 /*
163 * test unsigned types (or values known to be non-negative) for invariant characters,
164 * tests ASCII-family character values
165 */
166 #define UCHAR_IS_INVARIANT(c) (((c)<=0x7f) && (invariantChars[(c)>>5]&((uint32_t)1<<((c)&0x1f)))!=0)
167
168 /* test signed types for invariant characters, adds test for positive values */
169 #define SCHAR_IS_INVARIANT(c) ((0<=(c)) && UCHAR_IS_INVARIANT(c))
170
171 #if U_CHARSET_FAMILY==U_ASCII_FAMILY
172 #define CHAR_TO_UCHAR(c) c
173 #define UCHAR_TO_CHAR(c) c
174 #elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY
175 #define CHAR_TO_UCHAR(u) asciiFromEbcdic[u]
176 #define UCHAR_TO_CHAR(u) ebcdicFromAscii[u]
177 #else
178 # error U_CHARSET_FAMILY is not valid
179 #endif
180
181
182 U_CAPI void U_EXPORT2
183 u_charsToUChars(const char *cs, UChar *us, int32_t length) {
184 UChar u;
185 uint8_t c;
186
187 /*
188 * Allow the entire ASCII repertoire to be mapped _to_ Unicode.
189 * For EBCDIC systems, this works for characters with codes from
190 * codepages 37 and 1047 or compatible.
191 */
192 while(length>0) {
193 c=(uint8_t)(*cs++);
194 u=(UChar)CHAR_TO_UCHAR(c);
195 U_ASSERT((u!=0 || c==0)); /* only invariant chars converted? */
196 *us++=u;
197 --length;
198 }
199 }
200
201 U_CAPI void U_EXPORT2
202 u_UCharsToChars(const UChar *us, char *cs, int32_t length) {
203 UChar u;
204
205 while(length>0) {
206 u=*us++;
207 if(!UCHAR_IS_INVARIANT(u)) {
208 U_ASSERT(FALSE); /* Variant characters were used. These are not portable in ICU. */
209 u=0;
210 }
211 *cs++=(char)UCHAR_TO_CHAR(u);
212 --length;
213 }
214 }
215
216 U_CAPI UBool U_EXPORT2
217 uprv_isInvariantString(const char *s, int32_t length) {
218 uint8_t c;
219
220 for(;;) {
221 if(length<0) {
222 /* NUL-terminated */
223 c=(uint8_t)*s++;
224 if(c==0) {
225 break;
226 }
227 } else {
228 /* count length */
229 if(length==0) {
230 break;
231 }
232 --length;
233 c=(uint8_t)*s++;
234 if(c==0) {
235 continue; /* NUL is invariant */
236 }
237 }
238 /* c!=0 now, one branch below checks c==0 for variant characters */
239
240 /*
241 * no assertions here because these functions are legitimately called
242 * for strings with variant characters
243 */
244 #if U_CHARSET_FAMILY==U_ASCII_FAMILY
245 if(!UCHAR_IS_INVARIANT(c)) {
246 return FALSE; /* found a variant char */
247 }
248 #elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY
249 c=CHAR_TO_UCHAR(c);
250 if(c==0 || !UCHAR_IS_INVARIANT(c)) {
251 return FALSE; /* found a variant char */
252 }
253 #else
254 # error U_CHARSET_FAMILY is not valid
255 #endif
256 }
257 return TRUE;
258 }
259
260 U_CAPI UBool U_EXPORT2
261 uprv_isInvariantUString(const UChar *s, int32_t length) {
262 UChar c;
263
264 for(;;) {
265 if(length<0) {
266 /* NUL-terminated */
267 c=*s++;
268 if(c==0) {
269 break;
270 }
271 } else {
272 /* count length */
273 if(length==0) {
274 break;
275 }
276 --length;
277 c=*s++;
278 }
279
280 /*
281 * no assertions here because these functions are legitimately called
282 * for strings with variant characters
283 */
284 if(!UCHAR_IS_INVARIANT(c)) {
285 return FALSE; /* found a variant char */
286 }
287 }
288 return TRUE;
289 }
290
291 /* UDataSwapFn implementations used in udataswp.c ------- */
292
293 /* convert ASCII to EBCDIC and verify that all characters are invariant */
294 U_CAPI int32_t U_EXPORT2
295 uprv_ebcdicFromAscii(const UDataSwapper *ds,
296 const void *inData, int32_t length, void *outData,
297 UErrorCode *pErrorCode) {
298 const uint8_t *s;
299 uint8_t *t;
300 uint8_t c;
301
302 int32_t count;
303
304 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
305 return 0;
306 }
307 if(ds==NULL || inData==NULL || length<0 || (length>0 && outData==NULL)) {
308 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
309 return 0;
310 }
311
312 /* setup and swapping */
313 s=(const uint8_t *)inData;
314 t=(uint8_t *)outData;
315 count=length;
316 while(count>0) {
317 c=*s++;
318 if(!UCHAR_IS_INVARIANT(c)) {
319 udata_printError(ds, "uprv_ebcdicFromAscii() string[%d] contains a variant character in position %d\n",
320 length, length-count);
321 *pErrorCode=U_INVALID_CHAR_FOUND;
322 return 0;
323 }
324 *t++=ebcdicFromAscii[c];
325 --count;
326 }
327
328 return length;
329 }
330
331 /* this function only checks and copies ASCII strings without conversion */
332 U_CFUNC int32_t
333 uprv_copyAscii(const UDataSwapper *ds,
334 const void *inData, int32_t length, void *outData,
335 UErrorCode *pErrorCode) {
336 const uint8_t *s;
337 uint8_t c;
338
339 int32_t count;
340
341 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
342 return 0;
343 }
344 if(ds==NULL || inData==NULL || length<0 || (length>0 && outData==NULL)) {
345 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
346 return 0;
347 }
348
349 /* setup and checking */
350 s=(const uint8_t *)inData;
351 count=length;
352 while(count>0) {
353 c=*s++;
354 if(!UCHAR_IS_INVARIANT(c)) {
355 udata_printError(ds, "uprv_copyFromAscii() string[%d] contains a variant character in position %d\n",
356 length, length-count);
357 *pErrorCode=U_INVALID_CHAR_FOUND;
358 return 0;
359 }
360 --count;
361 }
362
363 if(length>0 && inData!=outData) {
364 uprv_memcpy(outData, inData, length);
365 }
366
367 return length;
368 }
369
370 /* convert EBCDIC to ASCII and verify that all characters are invariant */
371 U_CFUNC int32_t
372 uprv_asciiFromEbcdic(const UDataSwapper *ds,
373 const void *inData, int32_t length, void *outData,
374 UErrorCode *pErrorCode) {
375 const uint8_t *s;
376 uint8_t *t;
377 uint8_t c;
378
379 int32_t count;
380
381 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
382 return 0;
383 }
384 if(ds==NULL || inData==NULL || length<0 || (length>0 && outData==NULL)) {
385 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
386 return 0;
387 }
388
389 /* setup and swapping */
390 s=(const uint8_t *)inData;
391 t=(uint8_t *)outData;
392 count=length;
393 while(count>0) {
394 c=*s++;
395 if(c!=0 && ((c=asciiFromEbcdic[c])==0 || !UCHAR_IS_INVARIANT(c))) {
396 udata_printError(ds, "uprv_asciiFromEbcdic() string[%d] contains a variant character in position %d\n",
397 length, length-count);
398 *pErrorCode=U_INVALID_CHAR_FOUND;
399 return 0;
400 }
401 *t++=c;
402 --count;
403 }
404
405 return length;
406 }
407
408 /* this function only checks and copies EBCDIC strings without conversion */
409 U_CFUNC int32_t
410 uprv_copyEbcdic(const UDataSwapper *ds,
411 const void *inData, int32_t length, void *outData,
412 UErrorCode *pErrorCode) {
413 const uint8_t *s;
414 uint8_t c;
415
416 int32_t count;
417
418 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
419 return 0;
420 }
421 if(ds==NULL || inData==NULL || length<0 || (length>0 && outData==NULL)) {
422 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
423 return 0;
424 }
425
426 /* setup and checking */
427 s=(const uint8_t *)inData;
428 count=length;
429 while(count>0) {
430 c=*s++;
431 if(c!=0 && ((c=asciiFromEbcdic[c])==0 || !UCHAR_IS_INVARIANT(c))) {
432 udata_printError(ds, "uprv_copyEbcdic() string[%] contains a variant character in position %d\n",
433 length, length-count);
434 *pErrorCode=U_INVALID_CHAR_FOUND;
435 return 0;
436 }
437 --count;
438 }
439
440 if(length>0 && inData!=outData) {
441 uprv_memcpy(outData, inData, length);
442 }
443
444 return length;
445 }
446
447 /* compare invariant strings; variant characters compare less than others and unlike each other */
448 U_CFUNC int32_t
449 uprv_compareInvAscii(const UDataSwapper *ds,
450 const char *outString, int32_t outLength,
451 const UChar *localString, int32_t localLength) {
452 int32_t minLength;
453 UChar32 c1, c2;
454 uint8_t c;
455
456 if(outString==NULL || outLength<-1 || localString==NULL || localLength<-1) {
457 return 0;
458 }
459
460 if(outLength<0) {
461 outLength=(int32_t)uprv_strlen(outString);
462 }
463 if(localLength<0) {
464 localLength=u_strlen(localString);
465 }
466
467 minLength= outLength<localLength ? outLength : localLength;
468
469 while(minLength>0) {
470 c=(uint8_t)*outString++;
471 if(UCHAR_IS_INVARIANT(c)) {
472 c1=c;
473 } else {
474 c1=-1;
475 }
476
477 c2=*localString++;
478 if(!UCHAR_IS_INVARIANT(c2)) {
479 c2=-2;
480 }
481
482 if((c1-=c2)!=0) {
483 return c1;
484 }
485
486 --minLength;
487 }
488
489 /* strings start with same prefix, compare lengths */
490 return outLength-localLength;
491 }
492
493 U_CFUNC int32_t
494 uprv_compareInvEbcdic(const UDataSwapper *ds,
495 const char *outString, int32_t outLength,
496 const UChar *localString, int32_t localLength) {
497 int32_t minLength;
498 UChar32 c1, c2;
499 uint8_t c;
500
501 if(outString==NULL || outLength<-1 || localString==NULL || localLength<-1) {
502 return 0;
503 }
504
505 if(outLength<0) {
506 outLength=(int32_t)uprv_strlen(outString);
507 }
508 if(localLength<0) {
509 localLength=u_strlen(localString);
510 }
511
512 minLength= outLength<localLength ? outLength : localLength;
513
514 while(minLength>0) {
515 c=(uint8_t)*outString++;
516 if(c==0) {
517 c1=0;
518 } else if((c1=asciiFromEbcdic[c])!=0 && UCHAR_IS_INVARIANT(c1)) {
519 /* c1 is set */
520 } else {
521 c1=-1;
522 }
523
524 c2=*localString++;
525 if(!UCHAR_IS_INVARIANT(c2)) {
526 c2=-2;
527 }
528
529 if((c1-=c2)!=0) {
530 return c1;
531 }
532
533 --minLength;
534 }
535
536 /* strings start with same prefix, compare lengths */
537 return outLength-localLength;
538 }
539
540 U_CAPI int32_t U_EXPORT2
541 uprv_compareInvEbcdicAsAscii(const char *s1, const char *s2) {
542 int32_t c1, c2;
543
544 for(;; ++s1, ++s2) {
545 c1=(uint8_t)*s1;
546 c2=(uint8_t)*s2;
547 if(c1!=c2) {
548 if(c1!=0 && ((c1=asciiFromEbcdic[c1])==0 || !UCHAR_IS_INVARIANT(c1))) {
549 c1=-(int32_t)(uint8_t)*s1;
550 }
551 if(c2!=0 && ((c2=asciiFromEbcdic[c2])==0 || !UCHAR_IS_INVARIANT(c2))) {
552 c2=-(int32_t)(uint8_t)*s2;
553 }
554 return c1-c2;
555 } else if(c1==0) {
556 return 0;
557 }
558 }
559 }
560
561 U_CAPI char U_EXPORT2
562 uprv_ebcdicToLowercaseAscii(char c) {
563 return (char)lowercaseAsciiFromEbcdic[(uint8_t)c];
564 }
565
566 U_INTERNAL uint8_t* U_EXPORT2
567 uprv_aestrncpy(uint8_t *dst, const uint8_t *src, int32_t n)
568 {
569 uint8_t *orig_dst = dst;
570
571 if(n==-1) {
572 n = uprv_strlen((const char*)src)+1; /* copy NUL */
573 }
574 /* copy non-null */
575 while(*src && n>0) {
576 *(dst++) = asciiFromEbcdic[*(src++)];
577 n--;
578 }
579 /* pad */
580 while(n>0) {
581 *(dst++) = 0;
582 n--;
583 }
584 return orig_dst;
585 }
586
587 U_INTERNAL uint8_t* U_EXPORT2
588 uprv_eastrncpy(uint8_t *dst, const uint8_t *src, int32_t n)
589 {
590 uint8_t *orig_dst = dst;
591
592 if(n==-1) {
593 n = uprv_strlen((const char*)src)+1; /* copy NUL */
594 }
595 /* copy non-null */
596 while(*src && n>0) {
597 char ch = ebcdicFromAscii[*(src++)];
598 if(ch == 0) {
599 ch = ebcdicFromAscii[0x3f]; /* questionmark (subchar) */
600 }
601 *(dst++) = ch;
602 n--;
603 }
604 /* pad */
605 while(n>0) {
606 *(dst++) = 0;
607 n--;
608 }
609 return orig_dst;
610 }
611

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial