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 254
