• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_handler}
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}; /* "(null)" */
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 locales? */
121 static void
u_printf_set_sign(UNumberFormat * format,const u_printf_spec_info * info,UChar * prefixBuffer,int32_t * prefixBufLen,UErrorCode * status)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, &status); */
137             unum_setTextAttribute(format, UNUM_POSITIVE_PREFIX, gSpaceStr, 1, status);
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
u_printf_reset_sign(UNumberFormat * format,const u_printf_spec_info * info,UChar * prefixBuffer,int32_t * prefixBufLen,UErrorCode * status)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
u_printf_simple_percent_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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
u_printf_string_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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
u_printf_char_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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
u_printf_double_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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 locale */
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, &localStatus);
340     }
341 
342     return handler->pad_and_justify(context, info, result, resultLen);
343 }
344 
345 /* HSYS */
346 static int32_t
u_printf_integer_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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, &status);
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, &localStatus);
407     }
408 
409     return handler->pad_and_justify(context, info, result, resultLen);
410 }
411 
412 static int32_t
u_printf_hex_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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->fPrecision);
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
u_printf_octal_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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
u_printf_uinteger_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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, &status);
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
u_printf_pointer_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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
u_printf_scientific_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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, &localStatus);
665     }
666 
667     return handler->pad_and_justify(context, info, result, resultLen);
668 }
669 
670 static int32_t
u_printf_percent_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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, &localStatus);
740     }
741 
742     return handler->pad_and_justify(context, info, result, resultLen);
743 }
744 
745 static int32_t
u_printf_ustring_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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
u_printf_uchar_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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
u_printf_scidbl_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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.fPrecision)))
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, &scidbl_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_DIGITS);
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, maxSigDecimalDigits);
847         unum_setAttribute(format, UNUM_SIGNIFICANT_DIGITS_USED, FALSE);
848     }
849     return retVal;
850 }
851 
852 static int32_t
u_printf_count_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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
u_printf_spellout_handler(const u_printf_stream_handler * handler,void * context,ULocaleBundle * formatBundle,const u_printf_spec_info * info,const ufmt_args * args)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, &localStatus);
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/*deprecated*/,
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_EMPTY,
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. */
parseArguments(const UChar * alias,va_list ap,UErrorCode * status)1046 static ufmt_args* parseArguments(const UChar *alias, va_list ap, UErrorCode *status) {
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_DOLLARSIGN) {
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 argument 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
u_printf_parse(const u_printf_stream_handler * streamHandler,const UChar * fmt,void * context,u_localized_print_string * locStringContext,ULocaleBundle * formatBundle,int32_t * written,va_list ap)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)(alias - 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, info, &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 - lastAlias));
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 */
1590