The Tor Browser / file comparison
comparison: intl/icu/source/io/ufmt_cmn.c
intl/icu/source/io/ufmt_cmn.c
- branch
- TOR_BUG_3246
- changeset 4
- fc2d59ddac77
equal
deleted
inserted
replaced
| -1:000000000000 | 0:dbe6e68cc401 |
|---|---|
| 1 /* | |
| 2 ****************************************************************************** | |
| 3 * | |
| 4 * Copyright (C) 1998-2006, International Business Machines | |
| 5 * Corporation and others. All Rights Reserved. | |
| 6 * | |
| 7 ****************************************************************************** | |
| 8 * | |
| 9 * File ufmt_cmn.c | |
| 10 * | |
| 11 * Modification History: | |
| 12 * | |
| 13 * Date Name Description | |
| 14 * 12/02/98 stephen Creation. | |
| 15 * 03/12/99 stephen Modified for new C API. | |
| 16 * 03/15/99 stephen Added defaultCPToUnicode, unicodeToDefaultCP | |
| 17 * 07/19/99 stephen Fixed bug in defaultCPToUnicode | |
| 18 ****************************************************************************** | |
| 19 */ | |
| 20 | |
| 21 #include "cstring.h" | |
| 22 #include "cmemory.h" | |
| 23 #include "ufmt_cmn.h" | |
| 24 #include "unicode/uchar.h" | |
| 25 #include "unicode/ucnv.h" | |
| 26 #include "ustr_cnv.h" | |
| 27 | |
| 28 #define DIGIT_0 0x0030 | |
| 29 #define DIGIT_9 0x0039 | |
| 30 #define LOWERCASE_A 0x0061 | |
| 31 #define UPPERCASE_A 0x0041 | |
| 32 #define LOWERCASE_Z 0x007A | |
| 33 #define UPPERCASE_Z 0x005A | |
| 34 | |
| 35 int | |
| 36 ufmt_digitvalue(UChar c) | |
| 37 { | |
| 38 if( ((c>=DIGIT_0)&&(c<=DIGIT_9)) || | |
| 39 ((c>=LOWERCASE_A)&&(c<=LOWERCASE_Z)) || | |
| 40 ((c>=UPPERCASE_A)&&(c<=UPPERCASE_Z)) ) | |
| 41 { | |
| 42 return c - DIGIT_0 - (c >= 0x0041 ? (c >= 0x0061 ? 39 : 7) : 0); | |
| 43 } | |
| 44 else | |
| 45 { | |
| 46 return -1; | |
| 47 } | |
| 48 } | |
| 49 | |
| 50 UBool | |
| 51 ufmt_isdigit(UChar c, | |
| 52 int32_t radix) | |
| 53 { | |
| 54 int digitVal = ufmt_digitvalue(c); | |
| 55 | |
| 56 return (UBool)(digitVal < radix && digitVal >= 0); | |
| 57 } | |
| 58 | |
| 59 #define TO_UC_DIGIT(a) a <= 9 ? (DIGIT_0 + a) : (0x0037 + a) | |
| 60 #define TO_LC_DIGIT(a) a <= 9 ? (DIGIT_0 + a) : (0x0057 + a) | |
| 61 | |
| 62 void | |
| 63 ufmt_64tou(UChar *buffer, | |
| 64 int32_t *len, | |
| 65 uint64_t value, | |
| 66 uint8_t radix, | |
| 67 UBool uselower, | |
| 68 int32_t minDigits) | |
| 69 { | |
| 70 int32_t length = 0; | |
| 71 uint32_t digit; | |
| 72 UChar *left, *right, temp; | |
| 73 | |
| 74 do { | |
| 75 digit = (uint32_t)(value % radix); | |
| 76 value = value / radix; | |
| 77 buffer[length++] = (UChar)(uselower ? TO_LC_DIGIT(digit) | |
| 78 : TO_UC_DIGIT(digit)); | |
| 79 } while(value); | |
| 80 | |
| 81 /* pad with zeroes to make it minDigits long */ | |
| 82 if(minDigits != -1 && length < minDigits) { | |
| 83 while(length < minDigits && length < *len) | |
| 84 buffer[length++] = DIGIT_0; /*zero padding */ | |
| 85 } | |
| 86 | |
| 87 /* reverse the buffer */ | |
| 88 left = buffer; | |
| 89 right = buffer + length; | |
| 90 while(left < --right) { | |
| 91 temp = *left; | |
| 92 *left++ = *right; | |
| 93 *right = temp; | |
| 94 } | |
| 95 | |
| 96 *len = length; | |
| 97 } | |
| 98 | |
| 99 void | |
| 100 ufmt_ptou(UChar *buffer, | |
| 101 int32_t *len, | |
| 102 void *value, | |
| 103 UBool uselower) | |
| 104 { | |
| 105 int32_t i; | |
| 106 int32_t length = 0; | |
| 107 uint8_t *ptrIdx = (uint8_t *)&value; | |
| 108 | |
| 109 #if U_IS_BIG_ENDIAN | |
| 110 for (i = 0; i < (int32_t)sizeof(void *); i++) | |
| 111 #else | |
| 112 for (i = (int32_t)sizeof(void *)-1; i >= 0 ; i--) | |
| 113 #endif | |
| 114 { | |
| 115 uint8_t byteVal = ptrIdx[i]; | |
| 116 uint16_t firstNibble = (uint16_t)(byteVal>>4); | |
| 117 uint16_t secondNibble = (uint16_t)(byteVal&0xF); | |
| 118 if (uselower) { | |
| 119 buffer[length++]=TO_LC_DIGIT(firstNibble); | |
| 120 buffer[length++]=TO_LC_DIGIT(secondNibble); | |
| 121 } | |
| 122 else { | |
| 123 buffer[length++]=TO_UC_DIGIT(firstNibble); | |
| 124 buffer[length++]=TO_UC_DIGIT(secondNibble); | |
| 125 } | |
| 126 } | |
| 127 | |
| 128 *len = length; | |
| 129 } | |
| 130 | |
| 131 int64_t | |
| 132 ufmt_uto64(const UChar *buffer, | |
| 133 int32_t *len, | |
| 134 int8_t radix) | |
| 135 { | |
| 136 const UChar *limit; | |
| 137 int32_t count; | |
| 138 int64_t result; | |
| 139 | |
| 140 | |
| 141 /* intialize parameters */ | |
| 142 limit = buffer + *len; | |
| 143 count = 0; | |
| 144 result = 0; | |
| 145 | |
| 146 /* iterate through buffer */ | |
| 147 while(ufmt_isdigit(*buffer, radix) && buffer < limit) { | |
| 148 | |
| 149 /* read the next digit */ | |
| 150 result *= radix; | |
| 151 result += ufmt_digitvalue(*buffer++); | |
| 152 | |
| 153 /* increment our count */ | |
| 154 ++count; | |
| 155 } | |
| 156 | |
| 157 *len = count; | |
| 158 return result; | |
| 159 } | |
| 160 | |
| 161 #define NIBBLE_PER_BYTE 2 | |
| 162 void * | |
| 163 ufmt_utop(const UChar *buffer, | |
| 164 int32_t *len) | |
| 165 { | |
| 166 int32_t count, resultIdx, incVal, offset; | |
| 167 /* This union allows the pointer to be written as an array. */ | |
| 168 union { | |
| 169 void *ptr; | |
| 170 uint8_t bytes[sizeof(void*)]; | |
| 171 } result; | |
| 172 | |
| 173 /* intialize variables */ | |
| 174 count = 0; | |
| 175 offset = 0; | |
| 176 result.ptr = NULL; | |
| 177 | |
| 178 /* Skip the leading zeros */ | |
| 179 while(buffer[count] == DIGIT_0 || u_isspace(buffer[count])) { | |
| 180 count++; | |
| 181 offset++; | |
| 182 } | |
| 183 | |
| 184 /* iterate through buffer, stop when you hit the end */ | |
| 185 while(ufmt_isdigit(buffer[count], 16) && count < *len) { | |
| 186 /* increment the count consumed */ | |
| 187 ++count; | |
| 188 } | |
| 189 | |
| 190 /* detect overflow */ | |
| 191 if (count - offset > (int32_t)(sizeof(void*)*NIBBLE_PER_BYTE)) { | |
| 192 offset = count - (int32_t)(sizeof(void*)*NIBBLE_PER_BYTE); | |
| 193 } | |
| 194 | |
| 195 /* Initialize the direction of the input */ | |
| 196 #if U_IS_BIG_ENDIAN | |
| 197 incVal = -1; | |
| 198 resultIdx = (int32_t)(sizeof(void*) - 1); | |
| 199 #else | |
| 200 incVal = 1; | |
| 201 resultIdx = 0; | |
| 202 #endif | |
| 203 /* Write how much was consumed. */ | |
| 204 *len = count; | |
| 205 while(--count >= offset) { | |
| 206 /* Get the first nibble of the byte */ | |
| 207 uint8_t byte = (uint8_t)ufmt_digitvalue(buffer[count]); | |
| 208 | |
| 209 if (count > offset) { | |
| 210 /* Get the second nibble of the byte when available */ | |
| 211 byte = (uint8_t)(byte + (ufmt_digitvalue(buffer[--count]) << 4)); | |
| 212 } | |
| 213 /* Write the byte into the array */ | |
| 214 result.bytes[resultIdx] = byte; | |
| 215 resultIdx += incVal; | |
| 216 } | |
| 217 | |
| 218 return result.ptr; | |
| 219 } | |
| 220 | |
| 221 UChar* | |
| 222 ufmt_defaultCPToUnicode(const char *s, int32_t sSize, | |
| 223 UChar *target, int32_t tSize) | |
| 224 { | |
| 225 UChar *alias; | |
| 226 UErrorCode status = U_ZERO_ERROR; | |
| 227 UConverter *defConverter = u_getDefaultConverter(&status); | |
| 228 | |
| 229 if(U_FAILURE(status) || defConverter == 0) | |
| 230 return 0; | |
| 231 | |
| 232 if(sSize <= 0) { | |
| 233 sSize = uprv_strlen(s) + 1; | |
| 234 } | |
| 235 | |
| 236 /* perform the conversion in one swoop */ | |
| 237 if(target != 0) { | |
| 238 | |
| 239 alias = target; | |
| 240 ucnv_toUnicode(defConverter, &alias, alias + tSize, &s, s + sSize - 1, | |
| 241 NULL, TRUE, &status); | |
| 242 | |
| 243 | |
| 244 /* add the null terminator */ | |
| 245 *alias = 0x0000; | |
| 246 } | |
| 247 | |
| 248 u_releaseDefaultConverter(defConverter); | |
| 249 | |
| 250 return target; | |
| 251 } | |
| 252 | |
| 253 |
