icuSources/io/uprntf_p.cpp

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