icuSources/common/uinvchar.c

   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