| OLD | NEW |
|---|
| (Empty) | |
| 1 /* |
| 2 ****************************************************************************** |
| 3 * |
| 4 * Copyright (C) 1998-2008, International Business Machines |
| 5 * Corporation and others. All Rights Reserved. |
| 6 * |
| 7 ****************************************************************************** |
| 8 * |
| 9 * File uprntf_p.c |
| 10 * |
| 11 * Modification History: |
| 12 * |
| 13 * Date Name Description |
| 14 * 11/23/98 stephen Creation. |
| 15 * 03/12/99 stephen Modified for new C API. |
| 16 * 08/07/2003 george Reunify printf implementations |
| 17 ****************************************************************************** |
| 18 */ |
| 19 |
| 20 #include "unicode/utypes.h" |
| 21 |
| 22 #if !UCONFIG_NO_FORMATTING |
| 23 |
| 24 #include "unicode/ustring.h" |
| 25 |
| 26 #include "uprintf.h" |
| 27 #include "ufmt_cmn.h" |
| 28 #include "cmemory.h" |
| 29 #include "putilimp.h" |
| 30 |
| 31 /* ANSI style formatting */ |
| 32 /* Use US-ASCII characters only for formatting */ |
| 33 |
| 34 /* % */ |
| 35 #define UFMT_SIMPLE_PERCENT {ufmt_simple_percent, u_printf_simple_percent_handle
r} |
| 36 /* s */ |
| 37 #define UFMT_STRING {ufmt_string, u_printf_string_handler} |
| 38 /* c */ |
| 39 #define UFMT_CHAR {ufmt_char, u_printf_char_handler} |
| 40 /* d, i */ |
| 41 #define UFMT_INT {ufmt_int, u_printf_integer_handler} |
| 42 /* u */ |
| 43 #define UFMT_UINT {ufmt_int, u_printf_uinteger_handler} |
| 44 /* o */ |
| 45 #define UFMT_OCTAL {ufmt_int, u_printf_octal_handler} |
| 46 /* x, X */ |
| 47 #define UFMT_HEX {ufmt_int, u_printf_hex_handler} |
| 48 /* f */ |
| 49 #define UFMT_DOUBLE {ufmt_double, u_printf_double_handler} |
| 50 /* e, E */ |
| 51 #define UFMT_SCIENTIFIC {ufmt_double, u_printf_scientific_handler} |
| 52 /* g, G */ |
| 53 #define UFMT_SCIDBL {ufmt_double, u_printf_scidbl_handler} |
| 54 /* n */ |
| 55 #define UFMT_COUNT {ufmt_count, u_printf_count_handler} |
| 56 |
| 57 /* non-ANSI extensions */ |
| 58 /* Use US-ASCII characters only for formatting */ |
| 59 |
| 60 /* p */ |
| 61 #define UFMT_POINTER {ufmt_pointer, u_printf_pointer_handler} |
| 62 /* V */ |
| 63 #define UFMT_SPELLOUT {ufmt_double, u_printf_spellout_handler} |
| 64 /* P */ |
| 65 #define UFMT_PERCENT {ufmt_double, u_printf_percent_handler} |
| 66 /* C K is old format */ |
| 67 #define UFMT_UCHAR {ufmt_uchar, u_printf_uchar_handler} |
| 68 /* S U is old format */ |
| 69 #define UFMT_USTRING {ufmt_ustring, u_printf_ustring_handler} |
| 70 |
| 71 |
| 72 #define UFMT_EMPTY {ufmt_empty, NULL} |
| 73 |
| 74 /** |
| 75 * A u_printf handler function. |
| 76 * A u_printf handler is responsible for handling a single u_printf |
| 77 * format specification, for example 'd' or 's'. |
| 78 * @param stream The UFILE to which to write output. |
| 79 * @param info A pointer to a <TT>u_printf_spec_info</TT> struct containing |
| 80 * information on the format specification. |
| 81 * @param args A pointer to the argument data |
| 82 * @return The number of Unicode characters written to <TT>stream</TT>. |
| 83 */ |
| 84 typedef int32_t U_EXPORT2 |
| 85 u_printf_handler(const u_printf_stream_handler *handler, |
| 86 |
| 87 void *context, |
| 88 ULocaleBundle *formatBundle, |
| 89 const u_printf_spec_info *info, |
| 90 const ufmt_args *args); |
| 91 |
| 92 typedef struct u_printf_info { |
| 93 ufmt_type_info info; |
| 94 u_printf_handler *handler; |
| 95 } u_printf_info; |
| 96 |
| 97 /** |
| 98 * Struct encapsulating a single uprintf format specification. |
| 99 */ |
| 100 typedef struct u_printf_spec { |
| 101 u_printf_spec_info fInfo; /* Information on this spec */ |
| 102 int32_t fWidthPos; /* Position of width in arg list */ |
| 103 int32_t fPrecisionPos; /* Position of precision in arg list */ |
| 104 int32_t fArgPos; /* Position of data in arg list */ |
| 105 } u_printf_spec; |
| 106 |
| 107 #define UPRINTF_NUM_FMT_HANDLERS 108 |
| 108 |
| 109 /* We do not use handlers for 0-0x1f */ |
| 110 #define UPRINTF_BASE_FMT_HANDLERS 0x20 |
| 111 |
| 112 /* buffer size for formatting */ |
| 113 #define UPRINTF_BUFFER_SIZE 1024 |
| 114 #define UPRINTF_SYMBOL_BUFFER_SIZE 8 |
| 115 |
| 116 static const UChar gNullStr[] = {0x28, 0x6E, 0x75, 0x6C, 0x6C, 0x29, 0}; /* "(nu
ll)" */ |
| 117 static const UChar gSpaceStr[] = {0x20, 0}; /* " " */ |
| 118 |
| 119 /* Sets the sign of a format based on u_printf_spec_info */ |
| 120 /* TODO: Is setting the prefix symbol to a positive sign a good idea in all loca
les? */ |
| 121 static void |
| 122 u_printf_set_sign(UNumberFormat *format, |
| 123 const u_printf_spec_info *info, |
| 124 UChar *prefixBuffer, |
| 125 int32_t *prefixBufLen, |
| 126 UErrorCode *status) |
| 127 { |
| 128 if(info->fShowSign) { |
| 129 *prefixBufLen = unum_getTextAttribute(format, |
| 130 UNUM_POSITIVE_PREFIX, |
| 131 prefixBuffer, |
| 132 *prefixBufLen, |
| 133 status); |
| 134 if (info->fSpace) { |
| 135 /* Setting UNUM_PLUS_SIGN_SYMBOL affects the exponent too. */ |
| 136 /* unum_setSymbol(format, UNUM_PLUS_SIGN_SYMBOL, gSpaceStr, 1, &stat
us); */ |
| 137 unum_setTextAttribute(format, UNUM_POSITIVE_PREFIX, gSpaceStr, 1, st
atus); |
| 138 } |
| 139 else { |
| 140 UChar plusSymbol[UPRINTF_SYMBOL_BUFFER_SIZE]; |
| 141 int32_t symbolLen; |
| 142 |
| 143 symbolLen = unum_getSymbol(format, |
| 144 UNUM_PLUS_SIGN_SYMBOL, |
| 145 plusSymbol, |
| 146 sizeof(plusSymbol)/sizeof(*plusSymbol), |
| 147 status); |
| 148 unum_setTextAttribute(format, |
| 149 UNUM_POSITIVE_PREFIX, |
| 150 plusSymbol, |
| 151 symbolLen, |
| 152 status); |
| 153 } |
| 154 } |
| 155 else { |
| 156 *prefixBufLen = 0; |
| 157 } |
| 158 } |
| 159 |
| 160 static void |
| 161 u_printf_reset_sign(UNumberFormat *format, |
| 162 const u_printf_spec_info *info, |
| 163 UChar *prefixBuffer, |
| 164 int32_t *prefixBufLen, |
| 165 UErrorCode *status) |
| 166 { |
| 167 if(info->fShowSign) { |
| 168 unum_setTextAttribute(format, |
| 169 UNUM_POSITIVE_PREFIX, |
| 170 prefixBuffer, |
| 171 *prefixBufLen, |
| 172 status); |
| 173 } |
| 174 } |
| 175 |
| 176 |
| 177 /* handle a '%' */ |
| 178 static int32_t |
| 179 u_printf_simple_percent_handler(const u_printf_stream_handler *handler, |
| 180 void *context, |
| 181 ULocaleBundle *formatBundle, |
| 182 const u_printf_spec_info *info, |
| 183 const ufmt_args *args) |
| 184 { |
| 185 static const UChar PERCENT[] = { UP_PERCENT }; |
| 186 |
| 187 /* put a single '%' onto the output */ |
| 188 return handler->write(context, PERCENT, 1); |
| 189 } |
| 190 |
| 191 /* handle 's' */ |
| 192 static int32_t |
| 193 u_printf_string_handler(const u_printf_stream_handler *handler, |
| 194 void *context, |
| 195 ULocaleBundle *formatBundle, |
| 196 const u_printf_spec_info *info, |
| 197 const ufmt_args *args) |
| 198 { |
| 199 UChar *s; |
| 200 UChar buffer[UFMT_DEFAULT_BUFFER_SIZE]; |
| 201 int32_t len, written; |
| 202 int32_t argSize; |
| 203 const char *arg = (const char*)(args[0].ptrValue); |
| 204 |
| 205 /* convert from the default codepage to Unicode */ |
| 206 if (arg) { |
| 207 argSize = (int32_t)strlen(arg) + 1; |
| 208 if (argSize >= MAX_UCHAR_BUFFER_SIZE(buffer)) { |
| 209 s = ufmt_defaultCPToUnicode(arg, argSize, |
| 210 (UChar *)uprv_malloc(MAX_UCHAR_BUFFER_NEEDED(argSize)), |
| 211 MAX_UCHAR_BUFFER_NEEDED(argSize)); |
| 212 if(s == NULL) { |
| 213 return 0; |
| 214 } |
| 215 } |
| 216 else { |
| 217 s = ufmt_defaultCPToUnicode(arg, argSize, buffer, |
| 218 sizeof(buffer)/sizeof(UChar)); |
| 219 } |
| 220 } |
| 221 else { |
| 222 s = (UChar *)gNullStr; |
| 223 } |
| 224 len = u_strlen(s); |
| 225 |
| 226 /* width = minimum # of characters to write */ |
| 227 /* precision = maximum # of characters to write */ |
| 228 if (info->fPrecision != -1 && info->fPrecision < len) { |
| 229 len = info->fPrecision; |
| 230 } |
| 231 |
| 232 written = handler->pad_and_justify(context, info, s, len); |
| 233 |
| 234 /* clean up */ |
| 235 if (gNullStr != s && buffer != s) { |
| 236 uprv_free(s); |
| 237 } |
| 238 |
| 239 return written; |
| 240 } |
| 241 |
| 242 static int32_t |
| 243 u_printf_char_handler(const u_printf_stream_handler *handler, |
| 244 void *context, |
| 245 ULocaleBundle *formatBundle, |
| 246 const u_printf_spec_info *info, |
| 247 const ufmt_args *args) |
| 248 { |
| 249 UChar s[UTF_MAX_CHAR_LENGTH+1]; |
| 250 int32_t len = 1, written; |
| 251 unsigned char arg = (unsigned char)(args[0].int64Value); |
| 252 |
| 253 /* convert from default codepage to Unicode */ |
| 254 ufmt_defaultCPToUnicode((const char *)&arg, 2, s, sizeof(s)/sizeof(UChar)); |
| 255 |
| 256 /* Remember that this may be an MBCS character */ |
| 257 if (arg != 0) { |
| 258 len = u_strlen(s); |
| 259 } |
| 260 |
| 261 /* width = minimum # of characters to write */ |
| 262 /* precision = maximum # of characters to write */ |
| 263 /* precision is ignored when handling a char */ |
| 264 |
| 265 written = handler->pad_and_justify(context, info, s, len); |
| 266 |
| 267 return written; |
| 268 } |
| 269 |
| 270 static int32_t |
| 271 u_printf_double_handler(const u_printf_stream_handler *handler, |
| 272 void *context, |
| 273 ULocaleBundle *formatBundle, |
| 274 const u_printf_spec_info *info, |
| 275 const ufmt_args *args) |
| 276 { |
| 277 double num = (double) (args[0].doubleValue); |
| 278 UNumberFormat *format; |
| 279 UChar result[UPRINTF_BUFFER_SIZE]; |
| 280 UChar prefixBuffer[UPRINTF_BUFFER_SIZE]; |
| 281 int32_t prefixBufferLen = sizeof(prefixBuffer); |
| 282 int32_t minDecimalDigits; |
| 283 int32_t maxDecimalDigits; |
| 284 int32_t resultLen; |
| 285 UErrorCode status = U_ZERO_ERROR; |
| 286 |
| 287 prefixBuffer[0] = 0; |
| 288 |
| 289 /* mask off any necessary bits */ |
| 290 /* if(! info->fIsLongDouble) |
| 291 num &= DBL_MAX;*/ |
| 292 |
| 293 /* get the formatter */ |
| 294 format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL); |
| 295 |
| 296 /* handle error */ |
| 297 if(format == 0) |
| 298 return 0; |
| 299 |
| 300 /* save the formatter's state */ |
| 301 minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS); |
| 302 maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS); |
| 303 |
| 304 /* set the appropriate flags and number of decimal digits on the formatter *
/ |
| 305 if(info->fPrecision != -1) { |
| 306 /* set the # of decimal digits */ |
| 307 unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision); |
| 308 } |
| 309 else if(info->fAlt) { |
| 310 /* '#' means always show decimal point */ |
| 311 /* copy of printf behavior on Solaris - '#' shows 6 digits */ |
| 312 unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); |
| 313 } |
| 314 else { |
| 315 /* # of decimal digits is 6 if precision not specified regardless of loc
ale */ |
| 316 unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); |
| 317 } |
| 318 |
| 319 /* set whether to show the sign */ |
| 320 if (info->fShowSign) { |
| 321 u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status)
; |
| 322 } |
| 323 |
| 324 /* format the number */ |
| 325 resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &
status); |
| 326 |
| 327 if (U_FAILURE(status)) { |
| 328 resultLen = 0; |
| 329 } |
| 330 |
| 331 /* restore the number format */ |
| 332 /* TODO: Is this needed? */ |
| 333 unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits); |
| 334 unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits); |
| 335 |
| 336 if (info->fShowSign) { |
| 337 /* Reset back to original value regardless of what the error was */ |
| 338 UErrorCode localStatus = U_ZERO_ERROR; |
| 339 u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &local
Status); |
| 340 } |
| 341 |
| 342 return handler->pad_and_justify(context, info, result, resultLen); |
| 343 } |
| 344 |
| 345 /* HSYS */ |
| 346 static int32_t |
| 347 u_printf_integer_handler(const u_printf_stream_handler *handler, |
| 348 void *context, |
| 349 ULocaleBundle *formatBundle, |
| 350 const u_printf_spec_info *info, |
| 351 const ufmt_args *args) |
| 352 { |
| 353 int64_t num = args[0].int64Value; |
| 354 UNumberFormat *format; |
| 355 UChar result[UPRINTF_BUFFER_SIZE]; |
| 356 UChar prefixBuffer[UPRINTF_BUFFER_SIZE]; |
| 357 int32_t prefixBufferLen = sizeof(prefixBuffer); |
| 358 int32_t minDigits = -1; |
| 359 int32_t resultLen; |
| 360 UErrorCode status = U_ZERO_ERROR; |
| 361 |
| 362 prefixBuffer[0] = 0; |
| 363 |
| 364 /* mask off any necessary bits */ |
| 365 if (info->fIsShort) |
| 366 num = (int16_t)num; |
| 367 else if (!info->fIsLongLong) |
| 368 num = (int32_t)num; |
| 369 |
| 370 /* get the formatter */ |
| 371 format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL); |
| 372 |
| 373 /* handle error */ |
| 374 if(format == 0) |
| 375 return 0; |
| 376 |
| 377 /* set the appropriate flags on the formatter */ |
| 378 |
| 379 /* set the minimum integer digits */ |
| 380 if(info->fPrecision != -1) { |
| 381 /* set the minimum # of digits */ |
| 382 minDigits = unum_getAttribute(format, UNUM_MIN_INTEGER_DIGITS); |
| 383 unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, info->fPrecision); |
| 384 } |
| 385 |
| 386 /* set whether to show the sign */ |
| 387 if(info->fShowSign) { |
| 388 u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status)
; |
| 389 } |
| 390 |
| 391 /* format the number */ |
| 392 resultLen = unum_formatInt64(format, num, result, UPRINTF_BUFFER_SIZE, 0, &s
tatus); |
| 393 |
| 394 if (U_FAILURE(status)) { |
| 395 resultLen = 0; |
| 396 } |
| 397 |
| 398 /* restore the number format */ |
| 399 if (minDigits != -1) { |
| 400 unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, minDigits); |
| 401 } |
| 402 |
| 403 if (info->fShowSign) { |
| 404 /* Reset back to original value regardless of what the error was */ |
| 405 UErrorCode localStatus = U_ZERO_ERROR; |
| 406 u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &local
Status); |
| 407 } |
| 408 |
| 409 return handler->pad_and_justify(context, info, result, resultLen); |
| 410 } |
| 411 |
| 412 static int32_t |
| 413 u_printf_hex_handler(const u_printf_stream_handler *handler, |
| 414 void *context, |
| 415 ULocaleBundle *formatBundle, |
| 416 const u_printf_spec_info *info, |
| 417 const ufmt_args *args) |
| 418 { |
| 419 int64_t num = args[0].int64Value; |
| 420 UChar result[UPRINTF_BUFFER_SIZE]; |
| 421 int32_t len = UPRINTF_BUFFER_SIZE; |
| 422 |
| 423 |
| 424 /* mask off any necessary bits */ |
| 425 if (info->fIsShort) |
| 426 num &= UINT16_MAX; |
| 427 else if (!info->fIsLongLong) |
| 428 num &= UINT32_MAX; |
| 429 |
| 430 /* format the number, preserving the minimum # of digits */ |
| 431 ufmt_64tou(result, &len, num, 16, |
| 432 (UBool)(info->fSpec == 0x0078), |
| 433 (info->fPrecision == -1 && info->fZero) ? info->fWidth : info->fPrecisio
n); |
| 434 |
| 435 /* convert to alt form, if desired */ |
| 436 if(num != 0 && info->fAlt && len < UPRINTF_BUFFER_SIZE - 2) { |
| 437 /* shift the formatted string right by 2 chars */ |
| 438 memmove(result + 2, result, len * sizeof(UChar)); |
| 439 result[0] = 0x0030; |
| 440 result[1] = info->fSpec; |
| 441 len += 2; |
| 442 } |
| 443 |
| 444 return handler->pad_and_justify(context, info, result, len); |
| 445 } |
| 446 |
| 447 static int32_t |
| 448 u_printf_octal_handler(const u_printf_stream_handler *handler, |
| 449 void *context, |
| 450 ULocaleBundle *formatBundle, |
| 451 const u_printf_spec_info *info, |
| 452 const ufmt_args *args) |
| 453 { |
| 454 int64_t num = args[0].int64Value; |
| 455 UChar result[UPRINTF_BUFFER_SIZE]; |
| 456 int32_t len = UPRINTF_BUFFER_SIZE; |
| 457 |
| 458 |
| 459 /* mask off any necessary bits */ |
| 460 if (info->fIsShort) |
| 461 num &= UINT16_MAX; |
| 462 else if (!info->fIsLongLong) |
| 463 num &= UINT32_MAX; |
| 464 |
| 465 /* format the number, preserving the minimum # of digits */ |
| 466 ufmt_64tou(result, &len, num, 8, |
| 467 FALSE, /* doesn't matter for octal */ |
| 468 info->fPrecision == -1 && info->fZero ? info->fWidth : info->fPrecision)
; |
| 469 |
| 470 /* convert to alt form, if desired */ |
| 471 if(info->fAlt && result[0] != 0x0030 && len < UPRINTF_BUFFER_SIZE - 1) { |
| 472 /* shift the formatted string right by 1 char */ |
| 473 memmove(result + 1, result, len * sizeof(UChar)); |
| 474 result[0] = 0x0030; |
| 475 len += 1; |
| 476 } |
| 477 |
| 478 return handler->pad_and_justify(context, info, result, len); |
| 479 } |
| 480 |
| 481 static int32_t |
| 482 u_printf_uinteger_handler(const u_printf_stream_handler *handler, |
| 483 void *context, |
| 484 ULocaleBundle *formatBundle, |
| 485 const u_printf_spec_info *info, |
| 486 const ufmt_args *args) |
| 487 { |
| 488 int64_t num = args[0].int64Value; |
| 489 UNumberFormat *format; |
| 490 UChar result[UPRINTF_BUFFER_SIZE]; |
| 491 int32_t minDigits = -1; |
| 492 int32_t resultLen; |
| 493 UErrorCode status = U_ZERO_ERROR; |
| 494 |
| 495 /* TODO: Fix this once uint64_t can be formatted. */ |
| 496 if (info->fIsShort) |
| 497 num &= UINT16_MAX; |
| 498 else if (!info->fIsLongLong) |
| 499 num &= UINT32_MAX; |
| 500 |
| 501 /* get the formatter */ |
| 502 format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL); |
| 503 |
| 504 /* handle error */ |
| 505 if(format == 0) |
| 506 return 0; |
| 507 |
| 508 /* set the appropriate flags on the formatter */ |
| 509 |
| 510 /* set the minimum integer digits */ |
| 511 if(info->fPrecision != -1) { |
| 512 /* set the minimum # of digits */ |
| 513 minDigits = unum_getAttribute(format, UNUM_MIN_INTEGER_DIGITS); |
| 514 unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, info->fPrecision); |
| 515 } |
| 516 |
| 517 /* To mirror other stdio implementations, we ignore the sign argument */ |
| 518 |
| 519 /* format the number */ |
| 520 resultLen = unum_formatInt64(format, num, result, UPRINTF_BUFFER_SIZE, 0, &s
tatus); |
| 521 |
| 522 if (U_FAILURE(status)) { |
| 523 resultLen = 0; |
| 524 } |
| 525 |
| 526 /* restore the number format */ |
| 527 if (minDigits != -1) { |
| 528 unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, minDigits); |
| 529 } |
| 530 |
| 531 return handler->pad_and_justify(context, info, result, resultLen); |
| 532 } |
| 533 |
| 534 static int32_t |
| 535 u_printf_pointer_handler(const u_printf_stream_handler *handler, |
| 536 void *context, |
| 537 ULocaleBundle *formatBundle, |
| 538 const u_printf_spec_info *info, |
| 539 const ufmt_args *args) |
| 540 { |
| 541 UChar result[UPRINTF_BUFFER_SIZE]; |
| 542 int32_t len = UPRINTF_BUFFER_SIZE; |
| 543 |
| 544 /* format the pointer in hex */ |
| 545 ufmt_ptou(result, &len, args[0].ptrValue, TRUE/*, info->fPrecision*/); |
| 546 |
| 547 return handler->pad_and_justify(context, info, result, len); |
| 548 } |
| 549 |
| 550 static int32_t |
| 551 u_printf_scientific_handler(const u_printf_stream_handler *handler, |
| 552 void *context, |
| 553 ULocaleBundle *formatBundle, |
| 554 const u_printf_spec_info *info, |
| 555 const ufmt_args *args) |
| 556 { |
| 557 double num = (double) (args[0].doubleValue); |
| 558 UNumberFormat *format; |
| 559 UChar result[UPRINTF_BUFFER_SIZE]; |
| 560 UChar prefixBuffer[UPRINTF_BUFFER_SIZE]; |
| 561 int32_t prefixBufferLen = sizeof(prefixBuffer); |
| 562 int32_t minDecimalDigits; |
| 563 int32_t maxDecimalDigits; |
| 564 UErrorCode status = U_ZERO_ERROR; |
| 565 UChar srcExpBuf[UPRINTF_SYMBOL_BUFFER_SIZE]; |
| 566 int32_t srcLen, expLen; |
| 567 int32_t resultLen; |
| 568 UChar expBuf[UPRINTF_SYMBOL_BUFFER_SIZE]; |
| 569 |
| 570 prefixBuffer[0] = 0; |
| 571 |
| 572 /* mask off any necessary bits */ |
| 573 /* if(! info->fIsLongDouble) |
| 574 num &= DBL_MAX;*/ |
| 575 |
| 576 /* get the formatter */ |
| 577 format = u_locbund_getNumberFormat(formatBundle, UNUM_SCIENTIFIC); |
| 578 |
| 579 /* handle error */ |
| 580 if(format == 0) |
| 581 return 0; |
| 582 |
| 583 /* set the appropriate flags on the formatter */ |
| 584 |
| 585 srcLen = unum_getSymbol(format, |
| 586 UNUM_EXPONENTIAL_SYMBOL, |
| 587 srcExpBuf, |
| 588 sizeof(srcExpBuf), |
| 589 &status); |
| 590 |
| 591 /* Upper/lower case the e */ |
| 592 if (info->fSpec == (UChar)0x65 /* e */) { |
| 593 expLen = u_strToLower(expBuf, (int32_t)sizeof(expBuf), |
| 594 srcExpBuf, srcLen, |
| 595 formatBundle->fLocale, |
| 596 &status); |
| 597 } |
| 598 else { |
| 599 expLen = u_strToUpper(expBuf, (int32_t)sizeof(expBuf), |
| 600 srcExpBuf, srcLen, |
| 601 formatBundle->fLocale, |
| 602 &status); |
| 603 } |
| 604 |
| 605 unum_setSymbol(format, |
| 606 UNUM_EXPONENTIAL_SYMBOL, |
| 607 expBuf, |
| 608 expLen, |
| 609 &status); |
| 610 |
| 611 /* save the formatter's state */ |
| 612 minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS); |
| 613 maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS); |
| 614 |
| 615 /* set the appropriate flags and number of decimal digits on the formatter *
/ |
| 616 if(info->fPrecision != -1) { |
| 617 /* set the # of decimal digits */ |
| 618 if (info->fOrigSpec == (UChar)0x65 /* e */ || info->fOrigSpec == (UChar)
0x45 /* E */) { |
| 619 unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision); |
| 620 } |
| 621 else { |
| 622 unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, 1); |
| 623 unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, info->fPrecision
); |
| 624 } |
| 625 } |
| 626 else if(info->fAlt) { |
| 627 /* '#' means always show decimal point */ |
| 628 /* copy of printf behavior on Solaris - '#' shows 6 digits */ |
| 629 unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); |
| 630 } |
| 631 else { |
| 632 /* # of decimal digits is 6 if precision not specified */ |
| 633 unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); |
| 634 } |
| 635 |
| 636 /* set whether to show the sign */ |
| 637 if (info->fShowSign) { |
| 638 u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status)
; |
| 639 } |
| 640 |
| 641 /* format the number */ |
| 642 resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &
status); |
| 643 |
| 644 if (U_FAILURE(status)) { |
| 645 resultLen = 0; |
| 646 } |
| 647 |
| 648 /* restore the number format */ |
| 649 /* TODO: Is this needed? */ |
| 650 unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits); |
| 651 unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits); |
| 652 |
| 653 /* Since we're the only one using the scientific |
| 654 format, we don't need to save the old exponent value. */ |
| 655 /*unum_setSymbol(format, |
| 656 UNUM_EXPONENTIAL_SYMBOL, |
| 657 srcExpBuf, |
| 658 srcLen, |
| 659 &status);*/ |
| 660 |
| 661 if (info->fShowSign) { |
| 662 /* Reset back to original value regardless of what the error was */ |
| 663 UErrorCode localStatus = U_ZERO_ERROR; |
| 664 u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &local
Status); |
| 665 } |
| 666 |
| 667 return handler->pad_and_justify(context, info, result, resultLen); |
| 668 } |
| 669 |
| 670 static int32_t |
| 671 u_printf_percent_handler(const u_printf_stream_handler *handler, |
| 672 void *context, |
| 673 ULocaleBundle *formatBundle, |
| 674 const u_printf_spec_info *info, |
| 675 const ufmt_args *args) |
| 676 { |
| 677 double num = (double) (args[0].doubleValue); |
| 678 UNumberFormat *format; |
| 679 UChar result[UPRINTF_BUFFER_SIZE]; |
| 680 UChar prefixBuffer[UPRINTF_BUFFER_SIZE]; |
| 681 int32_t prefixBufferLen = sizeof(prefixBuffer); |
| 682 int32_t minDecimalDigits; |
| 683 int32_t maxDecimalDigits; |
| 684 int32_t resultLen; |
| 685 UErrorCode status = U_ZERO_ERROR; |
| 686 |
| 687 prefixBuffer[0] = 0; |
| 688 |
| 689 /* mask off any necessary bits */ |
| 690 /* if(! info->fIsLongDouble) |
| 691 num &= DBL_MAX;*/ |
| 692 |
| 693 /* get the formatter */ |
| 694 format = u_locbund_getNumberFormat(formatBundle, UNUM_PERCENT); |
| 695 |
| 696 /* handle error */ |
| 697 if(format == 0) |
| 698 return 0; |
| 699 |
| 700 /* save the formatter's state */ |
| 701 minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS); |
| 702 maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS); |
| 703 |
| 704 /* set the appropriate flags and number of decimal digits on the formatter *
/ |
| 705 if(info->fPrecision != -1) { |
| 706 /* set the # of decimal digits */ |
| 707 unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision); |
| 708 } |
| 709 else if(info->fAlt) { |
| 710 /* '#' means always show decimal point */ |
| 711 /* copy of printf behavior on Solaris - '#' shows 6 digits */ |
| 712 unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); |
| 713 } |
| 714 else { |
| 715 /* # of decimal digits is 6 if precision not specified */ |
| 716 unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); |
| 717 } |
| 718 |
| 719 /* set whether to show the sign */ |
| 720 if (info->fShowSign) { |
| 721 u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status)
; |
| 722 } |
| 723 |
| 724 /* format the number */ |
| 725 resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &
status); |
| 726 |
| 727 if (U_FAILURE(status)) { |
| 728 resultLen = 0; |
| 729 } |
| 730 |
| 731 /* restore the number format */ |
| 732 /* TODO: Is this needed? */ |
| 733 unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits); |
| 734 unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits); |
| 735 |
| 736 if (info->fShowSign) { |
| 737 /* Reset back to original value regardless of what the error was */ |
| 738 UErrorCode localStatus = U_ZERO_ERROR; |
| 739 u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &local
Status); |
| 740 } |
| 741 |
| 742 return handler->pad_and_justify(context, info, result, resultLen); |
| 743 } |
| 744 |
| 745 static int32_t |
| 746 u_printf_ustring_handler(const u_printf_stream_handler *handler, |
| 747 void *context, |
| 748 ULocaleBundle *formatBundle, |
| 749 const u_printf_spec_info *info, |
| 750 const ufmt_args *args) |
| 751 { |
| 752 int32_t len, written; |
| 753 const UChar *arg = (const UChar*)(args[0].ptrValue); |
| 754 |
| 755 /* allocate enough space for the buffer */ |
| 756 if (arg == NULL) { |
| 757 arg = gNullStr; |
| 758 } |
| 759 len = u_strlen(arg); |
| 760 |
| 761 /* width = minimum # of characters to write */ |
| 762 /* precision = maximum # of characters to write */ |
| 763 if (info->fPrecision != -1 && info->fPrecision < len) { |
| 764 len = info->fPrecision; |
| 765 } |
| 766 |
| 767 /* determine if the string should be padded */ |
| 768 written = handler->pad_and_justify(context, info, arg, len); |
| 769 |
| 770 return written; |
| 771 } |
| 772 |
| 773 static int32_t |
| 774 u_printf_uchar_handler(const u_printf_stream_handler *handler, |
| 775 void *context, |
| 776 ULocaleBundle *formatBundle, |
| 777 const u_printf_spec_info *info, |
| 778 const ufmt_args *args) |
| 779 { |
| 780 int32_t written = 0; |
| 781 UChar arg = (UChar)(args[0].int64Value); |
| 782 |
| 783 /* width = minimum # of characters to write */ |
| 784 /* precision = maximum # of characters to write */ |
| 785 /* precision is ignored when handling a uchar */ |
| 786 |
| 787 /* determine if the string should be padded */ |
| 788 written = handler->pad_and_justify(context, info, &arg, 1); |
| 789 |
| 790 return written; |
| 791 } |
| 792 |
| 793 static int32_t |
| 794 u_printf_scidbl_handler(const u_printf_stream_handler *handler, |
| 795 void *context, |
| 796 ULocaleBundle *formatBundle, |
| 797 const u_printf_spec_info *info, |
| 798 const ufmt_args *args) |
| 799 { |
| 800 u_printf_spec_info scidbl_info; |
| 801 double num = args[0].doubleValue; |
| 802 int32_t retVal; |
| 803 UNumberFormat *format; |
| 804 int32_t maxSigDecimalDigits, significantDigits; |
| 805 |
| 806 memcpy(&scidbl_info, info, sizeof(u_printf_spec_info)); |
| 807 |
| 808 /* determine whether to use 'd', 'e' or 'f' notation */ |
| 809 if (scidbl_info.fPrecision == -1 && num == uprv_trunc(num)) |
| 810 { |
| 811 /* use 'f' notation */ |
| 812 scidbl_info.fSpec = 0x0066; |
| 813 scidbl_info.fPrecision = 0; |
| 814 /* call the double handler */ |
| 815 retVal = u_printf_double_handler(handler, context, formatBundle, &scidbl
_info, args); |
| 816 } |
| 817 else if(num < 0.0001 || (scidbl_info.fPrecision < 1 && 1000000.0 <= num) |
| 818 || (scidbl_info.fPrecision != -1 && num > uprv_pow10(scidbl_info.fPrecis
ion))) |
| 819 { |
| 820 /* use 'e' or 'E' notation */ |
| 821 scidbl_info.fSpec = scidbl_info.fSpec - 2; |
| 822 if (scidbl_info.fPrecision == -1) { |
| 823 scidbl_info.fPrecision = 5; |
| 824 } |
| 825 /* call the scientific handler */ |
| 826 retVal = u_printf_scientific_handler(handler, context, formatBundle, &sc
idbl_info, args); |
| 827 } |
| 828 else { |
| 829 format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL); |
| 830 /* Check for null pointer */ |
| 831 if (format == NULL) { |
| 832 return 0; |
| 833 } |
| 834 maxSigDecimalDigits = unum_getAttribute(format, UNUM_MAX_SIGNIFICANT_DIG
ITS); |
| 835 significantDigits = scidbl_info.fPrecision; |
| 836 |
| 837 /* use 'f' notation */ |
| 838 scidbl_info.fSpec = 0x0066; |
| 839 if (significantDigits == -1) { |
| 840 significantDigits = 6; |
| 841 } |
| 842 unum_setAttribute(format, UNUM_SIGNIFICANT_DIGITS_USED, TRUE); |
| 843 unum_setAttribute(format, UNUM_MAX_SIGNIFICANT_DIGITS, significantDigits
); |
| 844 /* call the double handler */ |
| 845 retVal = u_printf_double_handler(handler, context, formatBundle, &scidbl
_info, args); |
| 846 unum_setAttribute(format, UNUM_MAX_SIGNIFICANT_DIGITS, maxSigDecimalDigi
ts); |
| 847 unum_setAttribute(format, UNUM_SIGNIFICANT_DIGITS_USED, FALSE); |
| 848 } |
| 849 return retVal; |
| 850 } |
| 851 |
| 852 static int32_t |
| 853 u_printf_count_handler(const u_printf_stream_handler *handler, |
| 854 void *context, |
| 855 ULocaleBundle *formatBundle, |
| 856 const u_printf_spec_info *info, |
| 857 const ufmt_args *args) |
| 858 { |
| 859 int32_t *count = (int32_t*)(args[0].ptrValue); |
| 860 |
| 861 /* in the special case of count, the u_printf_spec_info's width */ |
| 862 /* will contain the # of chars written thus far */ |
| 863 *count = info->fWidth; |
| 864 |
| 865 return 0; |
| 866 } |
| 867 |
| 868 static int32_t |
| 869 u_printf_spellout_handler(const u_printf_stream_handler *handler, |
| 870 void *context, |
| 871 ULocaleBundle *formatBundle, |
| 872 const u_printf_spec_info *info, |
| 873 const ufmt_args *args) |
| 874 { |
| 875 double num = (double) (args[0].doubleValue); |
| 876 UNumberFormat *format; |
| 877 UChar result[UPRINTF_BUFFER_SIZE]; |
| 878 UChar prefixBuffer[UPRINTF_BUFFER_SIZE]; |
| 879 int32_t prefixBufferLen = sizeof(prefixBuffer); |
| 880 int32_t minDecimalDigits; |
| 881 int32_t maxDecimalDigits; |
| 882 int32_t resultLen; |
| 883 UErrorCode status = U_ZERO_ERROR; |
| 884 |
| 885 prefixBuffer[0] = 0; |
| 886 |
| 887 /* mask off any necessary bits */ |
| 888 /* if(! info->fIsLongDouble) |
| 889 num &= DBL_MAX;*/ |
| 890 |
| 891 /* get the formatter */ |
| 892 format = u_locbund_getNumberFormat(formatBundle, UNUM_SPELLOUT); |
| 893 |
| 894 /* handle error */ |
| 895 if(format == 0) |
| 896 return 0; |
| 897 |
| 898 /* save the formatter's state */ |
| 899 minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS); |
| 900 maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS); |
| 901 |
| 902 /* set the appropriate flags and number of decimal digits on the formatter *
/ |
| 903 if(info->fPrecision != -1) { |
| 904 /* set the # of decimal digits */ |
| 905 unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision); |
| 906 } |
| 907 else if(info->fAlt) { |
| 908 /* '#' means always show decimal point */ |
| 909 /* copy of printf behavior on Solaris - '#' shows 6 digits */ |
| 910 unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); |
| 911 } |
| 912 else { |
| 913 /* # of decimal digits is 6 if precision not specified */ |
| 914 unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); |
| 915 } |
| 916 |
| 917 /* set whether to show the sign */ |
| 918 if (info->fShowSign) { |
| 919 u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status)
; |
| 920 } |
| 921 |
| 922 /* format the number */ |
| 923 resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &
status); |
| 924 |
| 925 if (U_FAILURE(status)) { |
| 926 resultLen = 0; |
| 927 } |
| 928 |
| 929 /* restore the number format */ |
| 930 /* TODO: Is this needed? */ |
| 931 unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits); |
| 932 unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits); |
| 933 |
| 934 if (info->fShowSign) { |
| 935 /* Reset back to original value regardless of what the error was */ |
| 936 UErrorCode localStatus = U_ZERO_ERROR; |
| 937 u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &local
Status); |
| 938 } |
| 939 |
| 940 return handler->pad_and_justify(context, info, result, resultLen); |
| 941 } |
| 942 |
| 943 /* Use US-ASCII characters only for formatting. Most codepages have |
| 944 characters 20-7F from Unicode. Using any other codepage specific |
| 945 characters will make it very difficult to format the string on |
| 946 non-Unicode machines */ |
| 947 static const u_printf_info g_u_printf_infos[UPRINTF_NUM_FMT_HANDLERS] = { |
| 948 /* 0x20 */ |
| 949 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 950 UFMT_EMPTY, UFMT_SIMPLE_PERCENT,UFMT_EMPTY, UFMT_EMPTY, |
| 951 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 952 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 953 |
| 954 /* 0x30 */ |
| 955 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 956 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 957 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 958 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 959 |
| 960 /* 0x40 */ |
| 961 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_UCHAR, |
| 962 UFMT_EMPTY, UFMT_SCIENTIFIC, UFMT_EMPTY, UFMT_SCIDBL, |
| 963 #ifdef U_USE_OBSOLETE_IO_FORMATTING |
| 964 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_UCHAR/*depr
ecated*/, |
| 965 #else |
| 966 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 967 #endif |
| 968 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 969 |
| 970 /* 0x50 */ |
| 971 UFMT_PERCENT, UFMT_EMPTY, UFMT_EMPTY, UFMT_USTRING, |
| 972 #ifdef U_USE_OBSOLETE_IO_FORMATTING |
| 973 UFMT_EMPTY, UFMT_USTRING/*deprecated*/,UFMT_SPELLOUT, UFMT_EMPT
Y, |
| 974 #else |
| 975 UFMT_EMPTY, UFMT_EMPTY, UFMT_SPELLOUT, UFMT_EMPTY, |
| 976 #endif |
| 977 UFMT_HEX, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 978 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 979 |
| 980 /* 0x60 */ |
| 981 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_CHAR, |
| 982 UFMT_INT, UFMT_SCIENTIFIC, UFMT_DOUBLE, UFMT_SCIDBL, |
| 983 UFMT_EMPTY, UFMT_INT, UFMT_EMPTY, UFMT_EMPTY, |
| 984 UFMT_EMPTY, UFMT_EMPTY, UFMT_COUNT, UFMT_OCTAL, |
| 985 |
| 986 /* 0x70 */ |
| 987 UFMT_POINTER, UFMT_EMPTY, UFMT_EMPTY, UFMT_STRING, |
| 988 UFMT_EMPTY, UFMT_UINT, UFMT_EMPTY, UFMT_EMPTY, |
| 989 UFMT_HEX, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 990 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, |
| 991 }; |
| 992 |
| 993 /* flag characters for uprintf */ |
| 994 #define FLAG_MINUS 0x002D |
| 995 #define FLAG_PLUS 0x002B |
| 996 #define FLAG_SPACE 0x0020 |
| 997 #define FLAG_POUND 0x0023 |
| 998 #define FLAG_ZERO 0x0030 |
| 999 #define FLAG_PAREN 0x0028 |
| 1000 |
| 1001 #define ISFLAG(s) (s) == FLAG_MINUS || \ |
| 1002 (s) == FLAG_PLUS || \ |
| 1003 (s) == FLAG_SPACE || \ |
| 1004 (s) == FLAG_POUND || \ |
| 1005 (s) == FLAG_ZERO || \ |
| 1006 (s) == FLAG_PAREN |
| 1007 |
| 1008 /* special characters for uprintf */ |
| 1009 #define SPEC_ASTERISK 0x002A |
| 1010 #define SPEC_DOLLARSIGN 0x0024 |
| 1011 #define SPEC_PERIOD 0x002E |
| 1012 #define SPEC_PERCENT 0x0025 |
| 1013 |
| 1014 /* unicode digits */ |
| 1015 #define DIGIT_ZERO 0x0030 |
| 1016 #define DIGIT_ONE 0x0031 |
| 1017 #define DIGIT_TWO 0x0032 |
| 1018 #define DIGIT_THREE 0x0033 |
| 1019 #define DIGIT_FOUR 0x0034 |
| 1020 #define DIGIT_FIVE 0x0035 |
| 1021 #define DIGIT_SIX 0x0036 |
| 1022 #define DIGIT_SEVEN 0x0037 |
| 1023 #define DIGIT_EIGHT 0x0038 |
| 1024 #define DIGIT_NINE 0x0039 |
| 1025 |
| 1026 #define ISDIGIT(s) (s) == DIGIT_ZERO || \ |
| 1027 (s) == DIGIT_ONE || \ |
| 1028 (s) == DIGIT_TWO || \ |
| 1029 (s) == DIGIT_THREE || \ |
| 1030 (s) == DIGIT_FOUR || \ |
| 1031 (s) == DIGIT_FIVE || \ |
| 1032 (s) == DIGIT_SIX || \ |
| 1033 (s) == DIGIT_SEVEN || \ |
| 1034 (s) == DIGIT_EIGHT || \ |
| 1035 (s) == DIGIT_NINE |
| 1036 |
| 1037 /* u_printf modifiers */ |
| 1038 #define MOD_H 0x0068 |
| 1039 #define MOD_LOWERL 0x006C |
| 1040 #define MOD_L 0x004C |
| 1041 |
| 1042 #define ISMOD(s) (s) == MOD_H || \ |
| 1043 (s) == MOD_LOWERL || \ |
| 1044 (s) == MOD_L |
| 1045 /* Returns an array of the parsed argument type given in the format string. */ |
| 1046 static ufmt_args* parseArguments(const UChar *alias, va_list ap, UErrorCode *sta
tus) { |
| 1047 ufmt_args *arglist = NULL; |
| 1048 ufmt_type_info *typelist = NULL; |
| 1049 UBool *islonglong = NULL; |
| 1050 int32_t size = 0; |
| 1051 int32_t pos = 0; |
| 1052 UChar type; |
| 1053 uint16_t handlerNum; |
| 1054 const UChar *aliasStart = alias; |
| 1055 |
| 1056 /* get maximum number of arguments */ |
| 1057 for(;;) { |
| 1058 /* find % */ |
| 1059 while(*alias != UP_PERCENT && *alias != 0x0000) { |
| 1060 alias++; |
| 1061 } |
| 1062 |
| 1063 if(*alias == 0x0000) { |
| 1064 break; |
| 1065 } |
| 1066 |
| 1067 alias++; |
| 1068 |
| 1069 /* handle the pos number */ |
| 1070 if(ISDIGIT(*alias)) { |
| 1071 |
| 1072 /* handle positional parameters */ |
| 1073 if(ISDIGIT(*alias)) { |
| 1074 pos = (int) (*alias++ - DIGIT_ZERO); |
| 1075 |
| 1076 while(ISDIGIT(*alias)) { |
| 1077 pos *= 10; |
| 1078 pos += (int) (*alias++ - DIGIT_ZERO); |
| 1079 } |
| 1080 } |
| 1081 |
| 1082 /* if there is no '$', don't read anything */ |
| 1083 if(*alias != SPEC_DOLLARSIGN) { |
| 1084 return NULL; |
| 1085 } |
| 1086 } else { |
| 1087 return NULL; |
| 1088 } |
| 1089 |
| 1090 if (pos > size) { |
| 1091 size = pos; |
| 1092 } |
| 1093 } |
| 1094 |
| 1095 /* create the parsed argument list */ |
| 1096 typelist = (ufmt_type_info*)uprv_malloc(sizeof(ufmt_type_info) * size); |
| 1097 islonglong = (UBool*)uprv_malloc(sizeof(UBool) * size); |
| 1098 arglist = (ufmt_args*)uprv_malloc(sizeof(ufmt_args) * size); |
| 1099 |
| 1100 /* If malloc failed, return NULL */ |
| 1101 if (!typelist || !islonglong || !arglist) { |
| 1102 if (typelist) { |
| 1103 uprv_free(typelist); |
| 1104 } |
| 1105 |
| 1106 if (islonglong) { |
| 1107 uprv_free(islonglong); |
| 1108 } |
| 1109 |
| 1110 if (arglist) { |
| 1111 uprv_free(arglist); |
| 1112 } |
| 1113 |
| 1114 *status = U_MEMORY_ALLOCATION_ERROR; |
| 1115 return NULL; |
| 1116 } |
| 1117 |
| 1118 /* reset alias back to the beginning */ |
| 1119 alias = aliasStart; |
| 1120 |
| 1121 for(;;) { |
| 1122 /* find % */ |
| 1123 while(*alias != UP_PERCENT && *alias != 0x0000) { |
| 1124 alias++; |
| 1125 } |
| 1126 |
| 1127 if(*alias == 0x0000) { |
| 1128 break; |
| 1129 } |
| 1130 |
| 1131 alias++; |
| 1132 |
| 1133 /* handle positional parameters */ |
| 1134 if(ISDIGIT(*alias)) { |
| 1135 pos = (int) (*alias++ - DIGIT_ZERO); |
| 1136 |
| 1137 while(ISDIGIT(*alias)) { |
| 1138 pos *= 10; |
| 1139 pos += (int) (*alias++ - DIGIT_ZERO); |
| 1140 } |
| 1141 } |
| 1142 /* offset position by 1 */ |
| 1143 pos--; |
| 1144 |
| 1145 /* skip over everything except for the type */ |
| 1146 while (ISMOD(*alias) || ISFLAG(*alias) || ISDIGIT(*alias) || |
| 1147 *alias == SPEC_ASTERISK || *alias == SPEC_PERIOD || *alias == SPEC_D
OLLARSIGN) { |
| 1148 islonglong[pos] = FALSE; |
| 1149 if (ISMOD(*alias)) { |
| 1150 alias++; |
| 1151 if (*alias == MOD_LOWERL) { |
| 1152 islonglong[pos] = TRUE; |
| 1153 } |
| 1154 } |
| 1155 alias++; |
| 1156 } |
| 1157 type = *alias; |
| 1158 |
| 1159 /* store the argument type in the correct position of the parsed argumen
t list */ |
| 1160 handlerNum = (uint16_t)(type - UPRINTF_BASE_FMT_HANDLERS); |
| 1161 if (handlerNum < UPRINTF_NUM_FMT_HANDLERS) { |
| 1162 typelist[pos] = g_u_printf_infos[ handlerNum ].info; |
| 1163 } else { |
| 1164 typelist[pos] = ufmt_empty; |
| 1165 } |
| 1166 } |
| 1167 |
| 1168 /* store argument in arglist */ |
| 1169 for (pos = 0; pos < size; pos++) { |
| 1170 switch (typelist[pos]) { |
| 1171 case ufmt_string: |
| 1172 case ufmt_ustring: |
| 1173 case ufmt_pointer: |
| 1174 arglist[pos].ptrValue = va_arg(ap, void*); |
| 1175 break; |
| 1176 case ufmt_char: |
| 1177 case ufmt_uchar: |
| 1178 case ufmt_int: |
| 1179 if (islonglong[pos]) { |
| 1180 arglist[pos].int64Value = va_arg(ap, int64_t); |
| 1181 } |
| 1182 else { |
| 1183 arglist[pos].int64Value = va_arg(ap, int32_t); |
| 1184 } |
| 1185 break; |
| 1186 case ufmt_float: |
| 1187 arglist[pos].floatValue = (float) va_arg(ap, double); |
| 1188 break; |
| 1189 case ufmt_double: |
| 1190 arglist[pos].doubleValue = va_arg(ap, double); |
| 1191 break; |
| 1192 default: |
| 1193 /* else args is ignored */ |
| 1194 arglist[pos].ptrValue = NULL; |
| 1195 break; |
| 1196 } |
| 1197 } |
| 1198 |
| 1199 uprv_free(typelist); |
| 1200 uprv_free(islonglong); |
| 1201 |
| 1202 return arglist; |
| 1203 } |
| 1204 |
| 1205 /* We parse the argument list in Unicode */ |
| 1206 U_CFUNC int32_t |
| 1207 u_printf_parse(const u_printf_stream_handler *streamHandler, |
| 1208 const UChar *fmt, |
| 1209 void *context, |
| 1210 u_localized_print_string *locStringContext, |
| 1211 ULocaleBundle *formatBundle, |
| 1212 int32_t *written, |
| 1213 va_list ap) |
| 1214 { |
| 1215 uint16_t handlerNum; |
| 1216 ufmt_args args; |
| 1217 ufmt_type_info argType; |
| 1218 u_printf_handler *handler; |
| 1219 u_printf_spec spec; |
| 1220 u_printf_spec_info *info = &(spec.fInfo); |
| 1221 |
| 1222 const UChar *alias = fmt; |
| 1223 const UChar *backup; |
| 1224 const UChar *lastAlias; |
| 1225 const UChar *orgAlias = fmt; |
| 1226 /* parsed argument list */ |
| 1227 ufmt_args *arglist = NULL; /* initialized it to avoid compiler warnings */ |
| 1228 UErrorCode status = U_ZERO_ERROR; |
| 1229 if (!locStringContext || locStringContext->available >= 0) { |
| 1230 /* get the parsed list of argument types */ |
| 1231 arglist = parseArguments(orgAlias, ap, &status); |
| 1232 |
| 1233 /* Return error if parsing failed. */ |
| 1234 if (U_FAILURE(status)) { |
| 1235 return -1; |
| 1236 } |
| 1237 } |
| 1238 |
| 1239 /* iterate through the pattern */ |
| 1240 while(!locStringContext || locStringContext->available >= 0) { |
| 1241 |
| 1242 /* find the next '%' */ |
| 1243 lastAlias = alias; |
| 1244 while(*alias != UP_PERCENT && *alias != 0x0000) { |
| 1245 alias++; |
| 1246 } |
| 1247 |
| 1248 /* write any characters before the '%' */ |
| 1249 if(alias > lastAlias) { |
| 1250 *written += (streamHandler->write)(context, lastAlias, (int32_t)(ali
as - lastAlias)); |
| 1251 } |
| 1252 |
| 1253 /* break if at end of string */ |
| 1254 if(*alias == 0x0000) { |
| 1255 break; |
| 1256 } |
| 1257 |
| 1258 /* initialize spec to default values */ |
| 1259 spec.fWidthPos = -1; |
| 1260 spec.fPrecisionPos = -1; |
| 1261 spec.fArgPos = -1; |
| 1262 |
| 1263 uprv_memset(info, 0, sizeof(*info)); |
| 1264 info->fPrecision = -1; |
| 1265 info->fWidth = -1; |
| 1266 info->fPadChar = 0x0020; |
| 1267 |
| 1268 /* skip over the initial '%' */ |
| 1269 alias++; |
| 1270 |
| 1271 /* Check for positional argument */ |
| 1272 if(ISDIGIT(*alias)) { |
| 1273 |
| 1274 /* Save the current position */ |
| 1275 backup = alias; |
| 1276 |
| 1277 /* handle positional parameters */ |
| 1278 if(ISDIGIT(*alias)) { |
| 1279 spec.fArgPos = (int) (*alias++ - DIGIT_ZERO); |
| 1280 |
| 1281 while(ISDIGIT(*alias)) { |
| 1282 spec.fArgPos *= 10; |
| 1283 spec.fArgPos += (int) (*alias++ - DIGIT_ZERO); |
| 1284 } |
| 1285 } |
| 1286 |
| 1287 /* if there is no '$', don't read anything */ |
| 1288 if(*alias != SPEC_DOLLARSIGN) { |
| 1289 spec.fArgPos = -1; |
| 1290 alias = backup; |
| 1291 } |
| 1292 /* munge the '$' */ |
| 1293 else |
| 1294 alias++; |
| 1295 } |
| 1296 |
| 1297 /* Get any format flags */ |
| 1298 while(ISFLAG(*alias)) { |
| 1299 switch(*alias++) { |
| 1300 |
| 1301 /* left justify */ |
| 1302 case FLAG_MINUS: |
| 1303 info->fLeft = TRUE; |
| 1304 break; |
| 1305 |
| 1306 /* always show sign */ |
| 1307 case FLAG_PLUS: |
| 1308 info->fShowSign = TRUE; |
| 1309 break; |
| 1310 |
| 1311 /* use space if no sign present */ |
| 1312 case FLAG_SPACE: |
| 1313 info->fShowSign = TRUE; |
| 1314 info->fSpace = TRUE; |
| 1315 break; |
| 1316 |
| 1317 /* use alternate form */ |
| 1318 case FLAG_POUND: |
| 1319 info->fAlt = TRUE; |
| 1320 break; |
| 1321 |
| 1322 /* pad with leading zeroes */ |
| 1323 case FLAG_ZERO: |
| 1324 info->fZero = TRUE; |
| 1325 info->fPadChar = 0x0030; |
| 1326 break; |
| 1327 |
| 1328 /* pad character specified */ |
| 1329 case FLAG_PAREN: |
| 1330 |
| 1331 /* TODO test that all four are numbers */ |
| 1332 /* first four characters are hex values for pad char */ |
| 1333 info->fPadChar = (UChar)ufmt_digitvalue(*alias++); |
| 1334 info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue
(*alias++)); |
| 1335 info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue
(*alias++)); |
| 1336 info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue
(*alias++)); |
| 1337 |
| 1338 /* final character is ignored */ |
| 1339 alias++; |
| 1340 |
| 1341 break; |
| 1342 } |
| 1343 } |
| 1344 |
| 1345 /* Get the width */ |
| 1346 |
| 1347 /* width is specified out of line */ |
| 1348 if(*alias == SPEC_ASTERISK) { |
| 1349 |
| 1350 info->fWidth = -2; |
| 1351 |
| 1352 /* Skip the '*' */ |
| 1353 alias++; |
| 1354 |
| 1355 /* Save the current position */ |
| 1356 backup = alias; |
| 1357 |
| 1358 /* handle positional parameters */ |
| 1359 if(ISDIGIT(*alias)) { |
| 1360 spec.fWidthPos = (int) (*alias++ - DIGIT_ZERO); |
| 1361 |
| 1362 while(ISDIGIT(*alias)) { |
| 1363 spec.fWidthPos *= 10; |
| 1364 spec.fWidthPos += (int) (*alias++ - DIGIT_ZERO); |
| 1365 } |
| 1366 } |
| 1367 |
| 1368 /* if there is no '$', don't read anything */ |
| 1369 if(*alias != SPEC_DOLLARSIGN) { |
| 1370 spec.fWidthPos = -1; |
| 1371 alias = backup; |
| 1372 } |
| 1373 /* munge the '$' */ |
| 1374 else |
| 1375 alias++; |
| 1376 } |
| 1377 /* read the width, if present */ |
| 1378 else if(ISDIGIT(*alias)){ |
| 1379 info->fWidth = (int) (*alias++ - DIGIT_ZERO); |
| 1380 |
| 1381 while(ISDIGIT(*alias)) { |
| 1382 info->fWidth *= 10; |
| 1383 info->fWidth += (int) (*alias++ - DIGIT_ZERO); |
| 1384 } |
| 1385 } |
| 1386 |
| 1387 /* Get the precision */ |
| 1388 |
| 1389 if(*alias == SPEC_PERIOD) { |
| 1390 |
| 1391 /* eat up the '.' */ |
| 1392 alias++; |
| 1393 |
| 1394 /* precision is specified out of line */ |
| 1395 if(*alias == SPEC_ASTERISK) { |
| 1396 |
| 1397 info->fPrecision = -2; |
| 1398 |
| 1399 /* Skip the '*' */ |
| 1400 alias++; |
| 1401 |
| 1402 /* save the current position */ |
| 1403 backup = alias; |
| 1404 |
| 1405 /* handle positional parameters */ |
| 1406 if(ISDIGIT(*alias)) { |
| 1407 spec.fPrecisionPos = (int) (*alias++ - DIGIT_ZERO); |
| 1408 |
| 1409 while(ISDIGIT(*alias)) { |
| 1410 spec.fPrecisionPos *= 10; |
| 1411 spec.fPrecisionPos += (int) (*alias++ - DIGIT_ZERO); |
| 1412 } |
| 1413 |
| 1414 /* if there is no '$', don't read anything */ |
| 1415 if(*alias != SPEC_DOLLARSIGN) { |
| 1416 spec.fPrecisionPos = -1; |
| 1417 alias = backup; |
| 1418 } |
| 1419 else { |
| 1420 /* munge the '$' */ |
| 1421 alias++; |
| 1422 } |
| 1423 } |
| 1424 } |
| 1425 /* read the precision */ |
| 1426 else if(ISDIGIT(*alias)){ |
| 1427 info->fPrecision = (int) (*alias++ - DIGIT_ZERO); |
| 1428 |
| 1429 while(ISDIGIT(*alias)) { |
| 1430 info->fPrecision *= 10; |
| 1431 info->fPrecision += (int) (*alias++ - DIGIT_ZERO); |
| 1432 } |
| 1433 } |
| 1434 } |
| 1435 |
| 1436 /* Get any modifiers */ |
| 1437 if(ISMOD(*alias)) { |
| 1438 switch(*alias++) { |
| 1439 |
| 1440 /* short */ |
| 1441 case MOD_H: |
| 1442 info->fIsShort = TRUE; |
| 1443 break; |
| 1444 |
| 1445 /* long or long long */ |
| 1446 case MOD_LOWERL: |
| 1447 if(*alias == MOD_LOWERL) { |
| 1448 info->fIsLongLong = TRUE; |
| 1449 /* skip over the next 'l' */ |
| 1450 alias++; |
| 1451 } |
| 1452 else |
| 1453 info->fIsLong = TRUE; |
| 1454 break; |
| 1455 |
| 1456 /* long double */ |
| 1457 case MOD_L: |
| 1458 info->fIsLongDouble = TRUE; |
| 1459 break; |
| 1460 } |
| 1461 } |
| 1462 |
| 1463 /* finally, get the specifier letter */ |
| 1464 info->fSpec = *alias++; |
| 1465 info->fOrigSpec = info->fSpec; |
| 1466 |
| 1467 /* fill in the precision and width, if specified out of line */ |
| 1468 |
| 1469 /* width specified out of line */ |
| 1470 if(spec.fInfo.fWidth == -2) { |
| 1471 if(spec.fWidthPos == -1) { |
| 1472 /* read the width from the argument list */ |
| 1473 info->fWidth = va_arg(ap, int32_t); |
| 1474 } |
| 1475 /* else handle positional parameter */ |
| 1476 |
| 1477 /* if it's negative, take the absolute value and set left alignment
*/ |
| 1478 if(info->fWidth < 0) { |
| 1479 info->fWidth *= -1; /* Make positive */ |
| 1480 info->fLeft = TRUE; |
| 1481 } |
| 1482 } |
| 1483 |
| 1484 /* precision specified out of line */ |
| 1485 if(info->fPrecision == -2) { |
| 1486 if(spec.fPrecisionPos == -1) { |
| 1487 /* read the precision from the argument list */ |
| 1488 info->fPrecision = va_arg(ap, int32_t); |
| 1489 } |
| 1490 /* else handle positional parameter */ |
| 1491 |
| 1492 /* if it's negative, set it to zero */ |
| 1493 if(info->fPrecision < 0) |
| 1494 info->fPrecision = 0; |
| 1495 } |
| 1496 |
| 1497 handlerNum = (uint16_t)(info->fSpec - UPRINTF_BASE_FMT_HANDLERS); |
| 1498 if (handlerNum < UPRINTF_NUM_FMT_HANDLERS) { |
| 1499 /* query the info function for argument information */ |
| 1500 argType = g_u_printf_infos[ handlerNum ].info; |
| 1501 |
| 1502 /* goto the correct argument on arg_list if position is specified */ |
| 1503 if (spec.fArgPos > 0) { |
| 1504 /* offset position by 1 */ |
| 1505 spec.fArgPos--; |
| 1506 switch(argType) { |
| 1507 case ufmt_count: |
| 1508 /* set the spec's width to the # of chars written */ |
| 1509 info->fWidth = *written; |
| 1510 /* fall through to set the pointer */ |
| 1511 case ufmt_string: |
| 1512 case ufmt_ustring: |
| 1513 case ufmt_pointer: |
| 1514 args.ptrValue = arglist[spec.fArgPos].ptrValue; |
| 1515 break; |
| 1516 case ufmt_char: |
| 1517 case ufmt_uchar: |
| 1518 case ufmt_int: |
| 1519 args.int64Value = arglist[spec.fArgPos].int64Value; |
| 1520 break; |
| 1521 case ufmt_float: |
| 1522 args.floatValue = arglist[spec.fArgPos].floatValue; |
| 1523 break; |
| 1524 case ufmt_double: |
| 1525 args.doubleValue = arglist[spec.fArgPos].doubleValue; |
| 1526 break; |
| 1527 default: |
| 1528 /* else args is ignored */ |
| 1529 args.ptrValue = NULL; |
| 1530 break; |
| 1531 } |
| 1532 } else { /* no positional argument specified */ |
| 1533 switch(argType) { |
| 1534 case ufmt_count: |
| 1535 /* set the spec's width to the # of chars written */ |
| 1536 info->fWidth = *written; |
| 1537 /* fall through to set the pointer */ |
| 1538 case ufmt_string: |
| 1539 case ufmt_ustring: |
| 1540 case ufmt_pointer: |
| 1541 args.ptrValue = va_arg(ap, void*); |
| 1542 break; |
| 1543 case ufmt_char: |
| 1544 case ufmt_uchar: |
| 1545 case ufmt_int: |
| 1546 if (info->fIsLongLong) { |
| 1547 args.int64Value = va_arg(ap, int64_t); |
| 1548 } |
| 1549 else { |
| 1550 args.int64Value = va_arg(ap, int32_t); |
| 1551 } |
| 1552 break; |
| 1553 case ufmt_float: |
| 1554 args.floatValue = (float) va_arg(ap, double); |
| 1555 break; |
| 1556 case ufmt_double: |
| 1557 args.doubleValue = va_arg(ap, double); |
| 1558 break; |
| 1559 default: |
| 1560 /* else args is ignored */ |
| 1561 args.ptrValue = NULL; |
| 1562 break; |
| 1563 } |
| 1564 } |
| 1565 |
| 1566 /* call the handler function */ |
| 1567 handler = g_u_printf_infos[ handlerNum ].handler; |
| 1568 if(handler != 0) { |
| 1569 *written += (*handler)(streamHandler, context, formatBundle, inf
o, &args); |
| 1570 } |
| 1571 else { |
| 1572 /* just echo unknown tags */ |
| 1573 *written += (streamHandler->write)(context, fmt, (int32_t)(alias
- lastAlias)); |
| 1574 } |
| 1575 } |
| 1576 else { |
| 1577 /* just echo unknown tags */ |
| 1578 *written += (streamHandler->write)(context, fmt, (int32_t)(alias - l
astAlias)); |
| 1579 } |
| 1580 } |
| 1581 /* delete parsed argument list */ |
| 1582 if (arglist != NULL) { |
| 1583 uprv_free(arglist); |
| 1584 } |
| 1585 /* return # of characters in this format that have been parsed. */ |
| 1586 return (int32_t)(alias - fmt); |
| 1587 } |
| 1588 |
| 1589 #endif /* #if !UCONFIG_NO_FORMATTING */ |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 5516007:
Check in the pristine copy of ICU 4.6... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/deps/third_party/