icuSources/io/uscanf_p.c

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 1998-2010, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 *******************************************************************************
   8 *
   9 * File uscnnf_p.c
  10 *
  11 * Modification History:
  12 *
  13 *   Date        Name        Description
  14 *   12/02/98    stephen        Creation.
  15 *   03/13/99    stephen     Modified for new C API.
  16 *******************************************************************************
  17 */
  18
  19 #include "unicode/utypes.h"
  20
  21 #if !UCONFIG_NO_FORMATTING
  22
  23 #include "unicode/uchar.h"
  24 #include "unicode/ustring.h"
  25 #include "unicode/unum.h"
  26 #include "unicode/udat.h"
  27 #include "unicode/uset.h"
  28 #include "uscanf.h"
  29 #include "ufmt_cmn.h"
  30 #include "ufile.h"
  31 #include "locbund.h"
  32
  33 #include "cmemory.h"
  34 #include "ustr_cnv.h"
  35
  36 /* flag characters for u_scanf */
  37 #define FLAG_ASTERISK 0x002A
  38 #define FLAG_PAREN 0x0028
  39
  40 #define ISFLAG(s)    (s) == FLAG_ASTERISK || \
  41             (s) == FLAG_PAREN
  42
  43 /* special characters for u_scanf */
  44 #define SPEC_DOLLARSIGN 0x0024
  45
  46 /* unicode digits */
  47 #define DIGIT_ZERO 0x0030
  48 #define DIGIT_ONE 0x0031
  49 #define DIGIT_TWO 0x0032
  50 #define DIGIT_THREE 0x0033
  51 #define DIGIT_FOUR 0x0034
  52 #define DIGIT_FIVE 0x0035
  53 #define DIGIT_SIX 0x0036
  54 #define DIGIT_SEVEN 0x0037
  55 #define DIGIT_EIGHT 0x0038
  56 #define DIGIT_NINE 0x0039
  57
  58 #define ISDIGIT(s)    (s) == DIGIT_ZERO || \
  59             (s) == DIGIT_ONE || \
  60             (s) == DIGIT_TWO || \
  61             (s) == DIGIT_THREE || \
  62             (s) == DIGIT_FOUR || \
  63             (s) == DIGIT_FIVE || \
  64             (s) == DIGIT_SIX || \
  65             (s) == DIGIT_SEVEN || \
  66             (s) == DIGIT_EIGHT || \
  67             (s) == DIGIT_NINE
  68
  69 /* u_scanf modifiers */
  70 #define MOD_H 0x0068
  71 #define MOD_LOWERL 0x006C
  72 #define MOD_L 0x004C
  73
  74 #define ISMOD(s)    (s) == MOD_H || \
  75             (s) == MOD_LOWERL || \
  76             (s) == MOD_L
  77
  78 /**
  79  * Struct encapsulating a single uscanf format specification.
  80  */
  81 typedef struct u_scanf_spec_info {
  82     int32_t fWidth;         /* Width  */
  83
  84     UChar   fSpec;          /* Format specification  */
  85
  86     UChar   fPadChar;       /* Padding character  */
  87
  88     UBool   fSkipArg;       /* TRUE if arg should be skipped */
  89     UBool   fIsLongDouble;  /* L flag  */
  90     UBool   fIsShort;       /* h flag  */
  91     UBool   fIsLong;        /* l flag  */
  92     UBool   fIsLongLong;    /* ll flag  */
  93     UBool   fIsString;      /* TRUE if this is a NULL-terminated string. */
  94 } u_scanf_spec_info;
  95
  96
  97 /**
  98  * Struct encapsulating a single u_scanf format specification.
  99  */
 100 typedef struct u_scanf_spec {
 101     u_scanf_spec_info    fInfo;        /* Information on this spec */
 102     int32_t        fArgPos;    /* Position of data in arg list */
 103 } u_scanf_spec;
 104
 105 /**
 106  * Parse a single u_scanf format specifier in Unicode.
 107  * @param fmt A pointer to a '%' character in a u_scanf format specification.
 108  * @param spec A pointer to a <TT>u_scanf_spec</TT> to receive the parsed
 109  * format specifier.
 110  * @return The number of characters contained in this specifier.
 111  */
 112 static int32_t
 113 u_scanf_parse_spec (const UChar     *fmt,
 114             u_scanf_spec    *spec)
 115 {
 116     const UChar *s = fmt;
 117     const UChar *backup;
 118     u_scanf_spec_info *info = &(spec->fInfo);
 119
 120     /* initialize spec to default values */
 121     spec->fArgPos             = -1;
 122
 123     info->fWidth        = -1;
 124     info->fSpec         = 0x0000;
 125     info->fPadChar      = 0x0020;
 126     info->fSkipArg      = FALSE;
 127     info->fIsLongDouble = FALSE;
 128     info->fIsShort      = FALSE;
 129     info->fIsLong       = FALSE;
 130     info->fIsLongLong   = FALSE;
 131     info->fIsString     = TRUE;
 132
 133
 134     /* skip over the initial '%' */
 135     s++;
 136
 137     /* Check for positional argument */
 138     if(ISDIGIT(*s)) {
 139
 140         /* Save the current position */
 141         backup = s;
 142
 143         /* handle positional parameters */
 144         if(ISDIGIT(*s)) {
 145             spec->fArgPos = (int) (*s++ - DIGIT_ZERO);
 146
 147             while(ISDIGIT(*s)) {
 148                 spec->fArgPos *= 10;
 149                 spec->fArgPos += (int) (*s++ - DIGIT_ZERO);
 150             }
 151         }
 152
 153         /* if there is no '$', don't read anything */
 154         if(*s != SPEC_DOLLARSIGN) {
 155             spec->fArgPos = -1;
 156             s = backup;
 157         }
 158         /* munge the '$' */
 159         else
 160             s++;
 161     }
 162
 163     /* Get any format flags */
 164     while(ISFLAG(*s)) {
 165         switch(*s++) {
 166
 167             /* skip argument */
 168         case FLAG_ASTERISK:
 169             info->fSkipArg = TRUE;
 170             break;
 171
 172             /* pad character specified */
 173         case FLAG_PAREN:
 174
 175             /* first four characters are hex values for pad char */
 176             info->fPadChar = (UChar)ufmt_digitvalue(*s++);
 177             info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*s++));
 178             info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*s++));
 179             info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*s++));
 180
 181             /* final character is ignored */
 182             s++;
 183
 184             break;
 185         }
 186     }
 187
 188     /* Get the width */
 189     if(ISDIGIT(*s)){
 190         info->fWidth = (int) (*s++ - DIGIT_ZERO);
 191
 192         while(ISDIGIT(*s)) {
 193             info->fWidth *= 10;
 194             info->fWidth += (int) (*s++ - DIGIT_ZERO);
 195         }
 196     }
 197
 198     /* Get any modifiers */
 199     if(ISMOD(*s)) {
 200         switch(*s++) {
 201
 202             /* short */
 203         case MOD_H:
 204             info->fIsShort = TRUE;
 205             break;
 206
 207             /* long or long long */
 208         case MOD_LOWERL:
 209             if(*s == MOD_LOWERL) {
 210                 info->fIsLongLong = TRUE;
 211                 /* skip over the next 'l' */
 212                 s++;
 213             }
 214             else
 215                 info->fIsLong = TRUE;
 216             break;
 217
 218             /* long double */
 219         case MOD_L:
 220             info->fIsLongDouble = TRUE;
 221             break;
 222         }
 223     }
 224
 225     /* finally, get the specifier letter */
 226     info->fSpec = *s++;
 227
 228     /* return # of characters in this specifier */
 229     return (int32_t)(s - fmt);
 230 }
 231
 232 #define UP_PERCENT 0x0025
 233
 234
 235 /* ANSI style formatting */
 236 /* Use US-ASCII characters only for formatting */
 237
 238 /* % */
 239 #define UFMT_SIMPLE_PERCENT {ufmt_simple_percent, u_scanf_simple_percent_handler}
 240 /* s */
 241 #define UFMT_STRING         {ufmt_string, u_scanf_string_handler}
 242 /* c */
 243 #define UFMT_CHAR           {ufmt_string, u_scanf_char_handler}
 244 /* d, i */
 245 #define UFMT_INT            {ufmt_int, u_scanf_integer_handler}
 246 /* u */
 247 #define UFMT_UINT           {ufmt_int, u_scanf_uinteger_handler}
 248 /* o */
 249 #define UFMT_OCTAL          {ufmt_int, u_scanf_octal_handler}
 250 /* x, X */
 251 #define UFMT_HEX            {ufmt_int, u_scanf_hex_handler}
 252 /* f */
 253 #define UFMT_DOUBLE         {ufmt_double, u_scanf_double_handler}
 254 /* e, E */
 255 #define UFMT_SCIENTIFIC     {ufmt_double, u_scanf_scientific_handler}
 256 /* g, G */
 257 #define UFMT_SCIDBL         {ufmt_double, u_scanf_scidbl_handler}
 258 /* n */
 259 #define UFMT_COUNT          {ufmt_count, u_scanf_count_handler}
 260 /* [ */
 261 #define UFMT_SCANSET        {ufmt_string, u_scanf_scanset_handler}
 262
 263 /* non-ANSI extensions */
 264 /* Use US-ASCII characters only for formatting */
 265
 266 /* p */
 267 #define UFMT_POINTER        {ufmt_pointer, u_scanf_pointer_handler}
 268 /* V */
 269 #define UFMT_SPELLOUT       {ufmt_double, u_scanf_spellout_handler}
 270 /* P */
 271 #define UFMT_PERCENT        {ufmt_double, u_scanf_percent_handler}
 272 /* C  K is old format */
 273 #define UFMT_UCHAR          {ufmt_uchar, u_scanf_uchar_handler}
 274 /* S  U is old format */
 275 #define UFMT_USTRING        {ufmt_ustring, u_scanf_ustring_handler}
 276
 277
 278 #define UFMT_EMPTY {ufmt_empty, NULL}
 279
 280 /**
 281  * A u_scanf handler function.
 282  * A u_scanf handler is responsible for handling a single u_scanf
 283  * format specification, for example 'd' or 's'.
 284  * @param stream The UFILE to which to write output.
 285  * @param info A pointer to a <TT>u_scanf_spec_info</TT> struct containing
 286  * information on the format specification.
 287  * @param args A pointer to the argument data
 288  * @param fmt A pointer to the first character in the format string
 289  * following the spec.
 290  * @param fmtConsumed On output, set to the number of characters consumed
 291  * in <TT>fmt</TT>. Do nothing, if the argument isn't variable width.
 292  * @param argConverted The number of arguments converted and assigned, or -1 if an
 293  * error occurred.
 294  * @return The number of code points consumed during reading.
 295  */
 296 typedef int32_t (*u_scanf_handler) (UFILE   *stream,
 297                    u_scanf_spec_info  *info,
 298                    ufmt_args                *args,
 299                    const UChar              *fmt,
 300                    int32_t                  *fmtConsumed,
 301                    int32_t                  *argConverted);
 302
 303 typedef struct u_scanf_info {
 304     ufmt_type_info info;
 305     u_scanf_handler handler;
 306 } u_scanf_info;
 307
 308 #define USCANF_NUM_FMT_HANDLERS 108
 309 #define USCANF_SYMBOL_BUFFER_SIZE 8
 310
 311 /* We do not use handlers for 0-0x1f */
 312 #define USCANF_BASE_FMT_HANDLERS 0x20
 313
 314
 315 static int32_t
 316 u_scanf_skip_leading_ws(UFILE   *input,
 317                         UChar   pad)
 318 {
 319     UChar   c;
 320     int32_t count = 0;
 321     UBool isNotEOF;
 322
 323     /* skip all leading ws in the input */
 324     while( (isNotEOF = ufile_getch(input, &c)) && (c == pad || u_isWhitespace(c)) )
 325     {
 326         count++;
 327     }
 328
 329     /* put the final character back on the input */
 330     if(isNotEOF)
 331         u_fungetc(c, input);
 332
 333     return count;
 334 }
 335
 336 /* TODO: Is always skipping the prefix symbol as a positive sign a good idea in all locales? */
 337 static int32_t
 338 u_scanf_skip_leading_positive_sign(UFILE   *input,
 339                                    UNumberFormat *format,
 340                                    UErrorCode *status)
 341 {
 342     UChar   c;
 343     int32_t count = 0;
 344     UBool isNotEOF;
 345     UChar plusSymbol[USCANF_SYMBOL_BUFFER_SIZE];
 346     int32_t symbolLen;
 347     UErrorCode localStatus = U_ZERO_ERROR;
 348
 349     if (U_SUCCESS(*status)) {
 350         symbolLen = unum_getSymbol(format,
 351             UNUM_PLUS_SIGN_SYMBOL,
 352             plusSymbol,
 353             sizeof(plusSymbol)/sizeof(*plusSymbol),
 354             &localStatus);
 355
 356         if (U_SUCCESS(localStatus)) {
 357             /* skip all leading ws in the input */
 358             while( (isNotEOF = ufile_getch(input, &c)) && (count < symbolLen && c == plusSymbol[count]) )
 359             {
 360                 count++;
 361             }
 362
 363             /* put the final character back on the input */
 364             if(isNotEOF) {
 365                 u_fungetc(c, input);
 366             }
 367         }
 368     }
 369
 370     return count;
 371 }
 372
 373 static int32_t
 374 u_scanf_simple_percent_handler(UFILE        *input,
 375                                u_scanf_spec_info *info,
 376                                ufmt_args    *args,
 377                                const UChar  *fmt,
 378                                int32_t      *fmtConsumed,
 379                                int32_t      *argConverted)
 380 {
 381     /* make sure the next character in the input is a percent */
 382     *argConverted = 0;
 383     if(u_fgetc(input) != 0x0025) {
 384         *argConverted = -1;
 385     }
 386     return 1;
 387 }
 388
 389 static int32_t
 390 u_scanf_count_handler(UFILE         *input,
 391                       u_scanf_spec_info *info,
 392                       ufmt_args     *args,
 393                       const UChar   *fmt,
 394                       int32_t       *fmtConsumed,
 395                       int32_t       *argConverted)
 396 {
 397     /* in the special case of count, the u_scanf_spec_info's width */
 398     /* will contain the # of items converted thus far */
 399     if (!info->fSkipArg) {
 400         if (info->fIsShort)
 401             *(int16_t*)(args[0].ptrValue) = (int16_t)(UINT16_MAX & info->fWidth);
 402         else if (info->fIsLongLong)
 403             *(int64_t*)(args[0].ptrValue) = info->fWidth;
 404         else
 405             *(int32_t*)(args[0].ptrValue) = (int32_t)(UINT32_MAX & info->fWidth);
 406     }
 407     *argConverted = 0;
 408
 409     /* we converted 0 args */
 410     return 0;
 411 }
 412
 413 static int32_t
 414 u_scanf_double_handler(UFILE        *input,
 415                        u_scanf_spec_info *info,
 416                        ufmt_args    *args,
 417                        const UChar  *fmt,
 418                        int32_t      *fmtConsumed,
 419                        int32_t      *argConverted)
 420 {
 421     int32_t         len;
 422     double          num;
 423     UNumberFormat   *format;
 424     int32_t         parsePos    = 0;
 425     int32_t         skipped;
 426     UErrorCode      status      = U_ZERO_ERROR;
 427
 428
 429     /* skip all ws in the input */
 430     skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
 431
 432     /* fill the input's internal buffer */
 433     ufile_fill_uchar_buffer(input);
 434
 435     /* determine the size of the input's buffer */
 436     len = (int32_t)(input->str.fLimit - input->str.fPos);
 437
 438     /* truncate to the width, if specified */
 439     if(info->fWidth != -1)
 440         len = ufmt_min(len, info->fWidth);
 441
 442     /* get the formatter */
 443     format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL);
 444
 445     /* handle error */
 446     if(format == 0)
 447         return 0;
 448
 449     /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
 450     skipped += u_scanf_skip_leading_positive_sign(input, format, &status);
 451
 452     /* parse the number */
 453     num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status);
 454
 455     if (!info->fSkipArg) {
 456         if (info->fIsLong)
 457             *(double*)(args[0].ptrValue) = num;
 458         else if (info->fIsLongDouble)
 459             *(long double*)(args[0].ptrValue) = num;
 460         else
 461             *(float*)(args[0].ptrValue) = (float)num;
 462     }
 463
 464     /* mask off any necessary bits */
 465     /*  if(! info->fIsLong_double)
 466     num &= DBL_MAX;*/
 467
 468     /* update the input's position to reflect consumed data */
 469     input->str.fPos += parsePos;
 470
 471     /* we converted 1 arg */
 472     *argConverted = !info->fSkipArg;
 473     return parsePos + skipped;
 474 }
 475
 476 #define UPRINTF_SYMBOL_BUFFER_SIZE 8
 477
 478 static int32_t
 479 u_scanf_scientific_handler(UFILE        *input,
 480                            u_scanf_spec_info *info,
 481                            ufmt_args    *args,
 482                            const UChar  *fmt,
 483                            int32_t      *fmtConsumed,
 484                            int32_t      *argConverted)
 485 {
 486     int32_t         len;
 487     double          num;
 488     UNumberFormat   *format;
 489     int32_t         parsePos    = 0;
 490     int32_t         skipped;
 491     UErrorCode      status      = U_ZERO_ERROR;
 492     UChar srcExpBuf[UPRINTF_SYMBOL_BUFFER_SIZE];
 493     int32_t srcLen, expLen;
 494     UChar expBuf[UPRINTF_SYMBOL_BUFFER_SIZE];
 495
 496
 497     /* skip all ws in the input */
 498     skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
 499
 500     /* fill the input's internal buffer */
 501     ufile_fill_uchar_buffer(input);
 502
 503     /* determine the size of the input's buffer */
 504     len = (int32_t)(input->str.fLimit - input->str.fPos);
 505
 506     /* truncate to the width, if specified */
 507     if(info->fWidth != -1)
 508         len = ufmt_min(len, info->fWidth);
 509
 510     /* get the formatter */
 511     format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SCIENTIFIC);
 512
 513     /* handle error */
 514     if(format == 0)
 515         return 0;
 516
 517     /* set the appropriate flags on the formatter */
 518
 519     srcLen = unum_getSymbol(format,
 520         UNUM_EXPONENTIAL_SYMBOL,
 521         srcExpBuf,
 522         sizeof(srcExpBuf),
 523         &status);
 524
 525     /* Upper/lower case the e */
 526     if (info->fSpec == (UChar)0x65 /* e */) {
 527         expLen = u_strToLower(expBuf, (int32_t)sizeof(expBuf),
 528             srcExpBuf, srcLen,
 529             input->str.fBundle.fLocale,
 530             &status);
 531     }
 532     else {
 533         expLen = u_strToUpper(expBuf, (int32_t)sizeof(expBuf),
 534             srcExpBuf, srcLen,
 535             input->str.fBundle.fLocale,
 536             &status);
 537     }
 538
 539     unum_setSymbol(format,
 540         UNUM_EXPONENTIAL_SYMBOL,
 541         expBuf,
 542         expLen,
 543         &status);
 544
 545
 546
 547
 548     /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
 549     skipped += u_scanf_skip_leading_positive_sign(input, format, &status);
 550
 551     /* parse the number */
 552     num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status);
 553
 554     if (!info->fSkipArg) {
 555         if (info->fIsLong)
 556             *(double*)(args[0].ptrValue) = num;
 557         else if (info->fIsLongDouble)
 558             *(long double*)(args[0].ptrValue) = num;
 559         else
 560             *(float*)(args[0].ptrValue) = (float)num;
 561     }
 562
 563     /* mask off any necessary bits */
 564     /*  if(! info->fIsLong_double)
 565     num &= DBL_MAX;*/
 566
 567     /* update the input's position to reflect consumed data */
 568     input->str.fPos += parsePos;
 569
 570     /* we converted 1 arg */
 571     *argConverted = !info->fSkipArg;
 572     return parsePos + skipped;
 573 }
 574
 575 static int32_t
 576 u_scanf_scidbl_handler(UFILE        *input,
 577                        u_scanf_spec_info *info,
 578                        ufmt_args    *args,
 579                        const UChar  *fmt,
 580                        int32_t      *fmtConsumed,
 581                        int32_t      *argConverted)
 582 {
 583     int32_t       len;
 584     double        num;
 585     UNumberFormat *scientificFormat, *genericFormat;
 586     /*int32_t       scientificResult, genericResult;*/
 587     double        scientificResult, genericResult;
 588     int32_t       scientificParsePos = 0, genericParsePos = 0, parsePos = 0;
 589     int32_t       skipped;
 590     UErrorCode    scientificStatus = U_ZERO_ERROR;
 591     UErrorCode    genericStatus = U_ZERO_ERROR;
 592
 593
 594     /* since we can't determine by scanning the characters whether */
 595     /* a number was formatted in the 'f' or 'g' styles, parse the */
 596     /* string with both formatters, and assume whichever one */
 597     /* parsed the most is the correct formatter to use */
 598
 599
 600     /* skip all ws in the input */
 601     skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
 602
 603     /* fill the input's internal buffer */
 604     ufile_fill_uchar_buffer(input);
 605
 606     /* determine the size of the input's buffer */
 607     len = (int32_t)(input->str.fLimit - input->str.fPos);
 608
 609     /* truncate to the width, if specified */
 610     if(info->fWidth != -1)
 611         len = ufmt_min(len, info->fWidth);
 612
 613     /* get the formatters */
 614     scientificFormat = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SCIENTIFIC);
 615     genericFormat = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL);
 616
 617     /* handle error */
 618     if(scientificFormat == 0 || genericFormat == 0)
 619         return 0;
 620
 621     /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
 622     skipped += u_scanf_skip_leading_positive_sign(input, genericFormat, &genericStatus);
 623
 624     /* parse the number using each format*/
 625
 626     scientificResult = unum_parseDouble(scientificFormat, input->str.fPos, len,
 627         &scientificParsePos, &scientificStatus);
 628
 629     genericResult = unum_parseDouble(genericFormat, input->str.fPos, len,
 630         &genericParsePos, &genericStatus);
 631
 632     /* determine which parse made it farther */
 633     if(scientificParsePos > genericParsePos) {
 634         /* stash the result in num */
 635         num = scientificResult;
 636         /* update the input's position to reflect consumed data */
 637         parsePos += scientificParsePos;
 638     }
 639     else {
 640         /* stash the result in num */
 641         num = genericResult;
 642         /* update the input's position to reflect consumed data */
 643         parsePos += genericParsePos;
 644     }
 645     input->str.fPos += parsePos;
 646
 647     if (!info->fSkipArg) {
 648         if (info->fIsLong)
 649             *(double*)(args[0].ptrValue) = num;
 650         else if (info->fIsLongDouble)
 651             *(long double*)(args[0].ptrValue) = num;
 652         else
 653             *(float*)(args[0].ptrValue) = (float)num;
 654     }
 655
 656     /* mask off any necessary bits */
 657     /*  if(! info->fIsLong_double)
 658     num &= DBL_MAX;*/
 659
 660     /* we converted 1 arg */
 661     *argConverted = !info->fSkipArg;
 662     return parsePos + skipped;
 663 }
 664
 665 static int32_t
 666 u_scanf_integer_handler(UFILE       *input,
 667                         u_scanf_spec_info *info,
 668                         ufmt_args   *args,
 669                         const UChar *fmt,
 670                         int32_t     *fmtConsumed,
 671                         int32_t     *argConverted)
 672 {
 673     int32_t         len;
 674     void            *num        = (void*) (args[0].ptrValue);
 675     UNumberFormat   *format;
 676     int32_t         parsePos    = 0;
 677     int32_t         skipped;
 678     UErrorCode      status      = U_ZERO_ERROR;
 679     int64_t         result;
 680
 681
 682     /* skip all ws in the input */
 683     skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
 684
 685     /* fill the input's internal buffer */
 686     ufile_fill_uchar_buffer(input);
 687
 688     /* determine the size of the input's buffer */
 689     len = (int32_t)(input->str.fLimit - input->str.fPos);
 690
 691     /* truncate to the width, if specified */
 692     if(info->fWidth != -1)
 693         len = ufmt_min(len, info->fWidth);
 694
 695     /* get the formatter */
 696     format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL);
 697
 698     /* handle error */
 699     if(format == 0)
 700         return 0;
 701
 702     /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
 703     skipped += u_scanf_skip_leading_positive_sign(input, format, &status);
 704
 705     /* parse the number */
 706     result = unum_parseInt64(format, input->str.fPos, len, &parsePos, &status);
 707
 708     /* mask off any necessary bits */
 709     if (!info->fSkipArg) {
 710         if (info->fIsShort)
 711             *(int16_t*)num = (int16_t)(UINT16_MAX & result);
 712         else if (info->fIsLongLong)
 713             *(int64_t*)num = result;
 714         else
 715             *(int32_t*)num = (int32_t)(UINT32_MAX & result);
 716     }
 717
 718     /* update the input's position to reflect consumed data */
 719     input->str.fPos += parsePos;
 720
 721     /* we converted 1 arg */
 722     *argConverted = !info->fSkipArg;
 723     return parsePos + skipped;
 724 }
 725
 726 static int32_t
 727 u_scanf_uinteger_handler(UFILE          *input,
 728                          u_scanf_spec_info *info,
 729                          ufmt_args      *args,
 730                          const UChar    *fmt,
 731                          int32_t        *fmtConsumed,
 732                          int32_t        *argConverted)
 733 {
 734     /* TODO Fix this when Numberformat handles uint64_t */
 735     return u_scanf_integer_handler(input, info, args, fmt, fmtConsumed, argConverted);
 736 }
 737
 738 static int32_t
 739 u_scanf_percent_handler(UFILE       *input,
 740                         u_scanf_spec_info *info,
 741                         ufmt_args   *args,
 742                         const UChar *fmt,
 743                         int32_t     *fmtConsumed,
 744                         int32_t     *argConverted)
 745 {
 746     int32_t         len;
 747     double          num;
 748     UNumberFormat   *format;
 749     int32_t         parsePos    = 0;
 750     int32_t         skipped;
 751     UErrorCode      status      = U_ZERO_ERROR;
 752
 753
 754     /* skip all ws in the input */
 755     skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
 756
 757     /* fill the input's internal buffer */
 758     ufile_fill_uchar_buffer(input);
 759
 760     /* determine the size of the input's buffer */
 761     len = (int32_t)(input->str.fLimit - input->str.fPos);
 762
 763     /* truncate to the width, if specified */
 764     if(info->fWidth != -1)
 765         len = ufmt_min(len, info->fWidth);
 766
 767     /* get the formatter */
 768     format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_PERCENT);
 769
 770     /* handle error */
 771     if(format == 0)
 772         return 0;
 773
 774     /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
 775     skipped += u_scanf_skip_leading_positive_sign(input, format, &status);
 776
 777     /* parse the number */
 778     num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status);
 779
 780     if (!info->fSkipArg) {
 781         *(double*)(args[0].ptrValue) = num;
 782     }
 783
 784     /* mask off any necessary bits */
 785     /*  if(! info->fIsLong_double)
 786     num &= DBL_MAX;*/
 787
 788     /* update the input's position to reflect consumed data */
 789     input->str.fPos += parsePos;
 790
 791     /* we converted 1 arg */
 792     *argConverted = !info->fSkipArg;
 793     return parsePos;
 794 }
 795
 796 static int32_t
 797 u_scanf_string_handler(UFILE        *input,
 798                        u_scanf_spec_info *info,
 799                        ufmt_args    *args,
 800                        const UChar  *fmt,
 801                        int32_t      *fmtConsumed,
 802                        int32_t      *argConverted)
 803 {
 804     const UChar *source;
 805     UConverter  *conv;
 806     char        *arg    = (char*)(args[0].ptrValue);
 807     char        *alias  = arg;
 808     char        *limit;
 809     UErrorCode  status  = U_ZERO_ERROR;
 810     int32_t     count;
 811     int32_t     skipped = 0;
 812     UChar       c;
 813     UBool       isNotEOF = FALSE;
 814
 815     /* skip all ws in the input */
 816     if (info->fIsString) {
 817         skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
 818     }
 819
 820     /* get the string one character at a time, truncating to the width */
 821     count = 0;
 822
 823     /* open the default converter */
 824     conv = u_getDefaultConverter(&status);
 825
 826     if(U_FAILURE(status))
 827         return -1;
 828
 829     while( (info->fWidth == -1 || count < info->fWidth)
 830         && (isNotEOF = ufile_getch(input, &c))
 831         && (!info->fIsString || (c != info->fPadChar && !u_isWhitespace(c))))
 832     {
 833
 834         if (!info->fSkipArg) {
 835             /* put the character from the input onto the target */
 836             source = &c;
 837             /* Since we do this one character at a time, do it this way. */
 838             if (info->fWidth > 0) {
 839                 limit = alias + info->fWidth - count;
 840             }
 841             else {
 842                 limit = alias + ucnv_getMaxCharSize(conv);
 843             }
 844
 845             /* convert the character to the default codepage */
 846             ucnv_fromUnicode(conv, &alias, limit, &source, source + 1,
 847                 NULL, TRUE, &status);
 848
 849             if(U_FAILURE(status)) {
 850                 /* clean up */
 851                 u_releaseDefaultConverter(conv);
 852                 return -1;
 853             }
 854         }
 855
 856         /* increment the count */
 857         ++count;
 858     }
 859
 860     /* put the final character we read back on the input */
 861     if (!info->fSkipArg) {
 862         if ((info->fWidth == -1 || count < info->fWidth) && isNotEOF)
 863             u_fungetc(c, input);
 864
 865         /* add the terminator */
 866         if (info->fIsString) {
 867             *alias = 0x00;
 868         }
 869     }
 870
 871     /* clean up */
 872     u_releaseDefaultConverter(conv);
 873
 874     /* we converted 1 arg */
 875     *argConverted = !info->fSkipArg;
 876     return count + skipped;
 877 }
 878
 879 static int32_t
 880 u_scanf_char_handler(UFILE          *input,
 881                      u_scanf_spec_info *info,
 882                      ufmt_args      *args,
 883                      const UChar    *fmt,
 884                      int32_t        *fmtConsumed,
 885                      int32_t        *argConverted)
 886 {
 887     if (info->fWidth < 0) {
 888         info->fWidth = 1;
 889     }
 890     info->fIsString = FALSE;
 891     return u_scanf_string_handler(input, info, args, fmt, fmtConsumed, argConverted);
 892 }
 893
 894 static int32_t
 895 u_scanf_ustring_handler(UFILE       *input,
 896                         u_scanf_spec_info *info,
 897                         ufmt_args   *args,
 898                         const UChar *fmt,
 899                         int32_t     *fmtConsumed,
 900                         int32_t     *argConverted)
 901 {
 902     UChar   *arg     = (UChar*)(args[0].ptrValue);
 903     UChar   *alias     = arg;
 904     int32_t count;
 905     int32_t skipped = 0;
 906     UChar   c;
 907     UBool   isNotEOF = FALSE;
 908
 909     /* skip all ws in the input */
 910     if (info->fIsString) {
 911         skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
 912     }
 913
 914     /* get the string one character at a time, truncating to the width */
 915     count = 0;
 916
 917     while( (info->fWidth == -1 || count < info->fWidth)
 918         && (isNotEOF = ufile_getch(input, &c))
 919         && (!info->fIsString || (c != info->fPadChar && !u_isWhitespace(c))))
 920     {
 921
 922         /* put the character from the input onto the target */
 923         if (!info->fSkipArg) {
 924             *alias++ = c;
 925         }
 926
 927         /* increment the count */
 928         ++count;
 929     }
 930
 931     /* put the final character we read back on the input */
 932     if (!info->fSkipArg) {
 933         if((info->fWidth == -1 || count < info->fWidth) && isNotEOF) {
 934             u_fungetc(c, input);
 935         }
 936
 937         /* add the terminator */
 938         if (info->fIsString) {
 939             *alias = 0x0000;
 940         }
 941     }
 942
 943     /* we converted 1 arg */
 944     *argConverted = !info->fSkipArg;
 945     return count + skipped;
 946 }
 947
 948 static int32_t
 949 u_scanf_uchar_handler(UFILE         *input,
 950                       u_scanf_spec_info *info,
 951                       ufmt_args     *args,
 952                       const UChar   *fmt,
 953                       int32_t       *fmtConsumed,
 954                       int32_t       *argConverted)
 955 {
 956     if (info->fWidth < 0) {
 957         info->fWidth = 1;
 958     }
 959     info->fIsString = FALSE;
 960     return u_scanf_ustring_handler(input, info, args, fmt, fmtConsumed, argConverted);
 961 }
 962
 963 static int32_t
 964 u_scanf_spellout_handler(UFILE          *input,
 965                          u_scanf_spec_info *info,
 966                          ufmt_args      *args,
 967                          const UChar    *fmt,
 968                          int32_t        *fmtConsumed,
 969                          int32_t        *argConverted)
 970 {
 971     int32_t         len;
 972     double          num;
 973     UNumberFormat   *format;
 974     int32_t         parsePos    = 0;
 975     int32_t         skipped;
 976     UErrorCode      status      = U_ZERO_ERROR;
 977
 978
 979     /* skip all ws in the input */
 980     skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
 981
 982     /* fill the input's internal buffer */
 983     ufile_fill_uchar_buffer(input);
 984
 985     /* determine the size of the input's buffer */
 986     len = (int32_t)(input->str.fLimit - input->str.fPos);
 987
 988     /* truncate to the width, if specified */
 989     if(info->fWidth != -1)
 990         len = ufmt_min(len, info->fWidth);
 991
 992     /* get the formatter */
 993     format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SPELLOUT);
 994
 995     /* handle error */
 996     if(format == 0)
 997         return 0;
 998
 999     /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
1000     /* This is not applicable to RBNF. */
1001     /*skipped += u_scanf_skip_leading_positive_sign(input, format, &status);*/
1002
1003     /* parse the number */
1004     num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status);
1005
1006     if (!info->fSkipArg) {
1007         *(double*)(args[0].ptrValue) = num;
1008     }
1009
1010     /* mask off any necessary bits */
1011     /*  if(! info->fIsLong_double)
1012     num &= DBL_MAX;*/
1013
1014     /* update the input's position to reflect consumed data */
1015     input->str.fPos += parsePos;
1016
1017     /* we converted 1 arg */
1018     *argConverted = !info->fSkipArg;
1019     return parsePos + skipped;
1020 }
1021
1022 static int32_t
1023 u_scanf_hex_handler(UFILE       *input,
1024                     u_scanf_spec_info *info,
1025                     ufmt_args   *args,
1026                     const UChar *fmt,
1027                     int32_t     *fmtConsumed,
1028                     int32_t     *argConverted)
1029 {
1030     int32_t     len;
1031     int32_t     skipped;
1032     void        *num    = (void*) (args[0].ptrValue);
1033     int64_t     result;
1034
1035     /* skip all ws in the input */
1036     skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
1037
1038     /* fill the input's internal buffer */
1039     ufile_fill_uchar_buffer(input);
1040
1041     /* determine the size of the input's buffer */
1042     len = (int32_t)(input->str.fLimit - input->str.fPos);
1043
1044     /* truncate to the width, if specified */
1045     if(info->fWidth != -1)
1046         len = ufmt_min(len, info->fWidth);
1047
1048     /* check for alternate form */
1049     if( *(input->str.fPos) == 0x0030 &&
1050         (*(input->str.fPos + 1) == 0x0078 || *(input->str.fPos + 1) == 0x0058) ) {
1051
1052         /* skip the '0' and 'x' or 'X' if present */
1053         input->str.fPos += 2;
1054         len -= 2;
1055     }
1056
1057     /* parse the number */
1058     result = ufmt_uto64(input->str.fPos, &len, 16);
1059
1060     /* update the input's position to reflect consumed data */
1061     input->str.fPos += len;
1062
1063     /* mask off any necessary bits */
1064     if (!info->fSkipArg) {
1065         if (info->fIsShort)
1066             *(int16_t*)num = (int16_t)(UINT16_MAX & result);
1067         else if (info->fIsLongLong)
1068             *(int64_t*)num = result;
1069         else
1070             *(int32_t*)num = (int32_t)(UINT32_MAX & result);
1071     }
1072
1073     /* we converted 1 arg */
1074     *argConverted = !info->fSkipArg;
1075     return len + skipped;
1076 }
1077
1078 static int32_t
1079 u_scanf_octal_handler(UFILE         *input,
1080                       u_scanf_spec_info *info,
1081                       ufmt_args     *args,
1082                       const UChar   *fmt,
1083                       int32_t       *fmtConsumed,
1084                       int32_t       *argConverted)
1085 {
1086     int32_t     len;
1087     int32_t     skipped;
1088     void        *num         = (void*) (args[0].ptrValue);
1089     int64_t     result;
1090
1091     /* skip all ws in the input */
1092     skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
1093
1094     /* fill the input's internal buffer */
1095     ufile_fill_uchar_buffer(input);
1096
1097     /* determine the size of the input's buffer */
1098     len = (int32_t)(input->str.fLimit - input->str.fPos);
1099
1100     /* truncate to the width, if specified */
1101     if(info->fWidth != -1)
1102         len = ufmt_min(len, info->fWidth);
1103
1104     /* parse the number */
1105     result = ufmt_uto64(input->str.fPos, &len, 8);
1106
1107     /* update the input's position to reflect consumed data */
1108     input->str.fPos += len;
1109
1110     /* mask off any necessary bits */
1111     if (!info->fSkipArg) {
1112         if (info->fIsShort)
1113             *(int16_t*)num = (int16_t)(UINT16_MAX & result);
1114         else if (info->fIsLongLong)
1115             *(int64_t*)num = result;
1116         else
1117             *(int32_t*)num = (int32_t)(UINT32_MAX & result);
1118     }
1119
1120     /* we converted 1 arg */
1121     *argConverted = !info->fSkipArg;
1122     return len + skipped;
1123 }
1124
1125 static int32_t
1126 u_scanf_pointer_handler(UFILE       *input,
1127                         u_scanf_spec_info *info,
1128                         ufmt_args   *args,
1129                         const UChar *fmt,
1130                         int32_t     *fmtConsumed,
1131                         int32_t     *argConverted)
1132 {
1133     int32_t len;
1134     int32_t skipped;
1135     void    *result;
1136     void    **p     = (void**)(args[0].ptrValue);
1137
1138
1139     /* skip all ws in the input */
1140     skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
1141
1142     /* fill the input's internal buffer */
1143     ufile_fill_uchar_buffer(input);
1144
1145     /* determine the size of the input's buffer */
1146     len = (int32_t)(input->str.fLimit - input->str.fPos);
1147
1148     /* truncate to the width, if specified */
1149     if(info->fWidth != -1) {
1150         len = ufmt_min(len, info->fWidth);
1151     }
1152
1153     /* Make sure that we don't consume too much */
1154     if (len > (int32_t)(sizeof(void*)*2)) {
1155         len = (int32_t)(sizeof(void*)*2);
1156     }
1157
1158     /* parse the pointer - assign to temporary value */
1159     result = ufmt_utop(input->str.fPos, &len);
1160
1161     if (!info->fSkipArg) {
1162         *p = result;
1163     }
1164
1165     /* update the input's position to reflect consumed data */
1166     input->str.fPos += len;
1167
1168     /* we converted 1 arg */
1169     *argConverted = !info->fSkipArg;
1170     return len + skipped;
1171 }
1172
1173 static int32_t
1174 u_scanf_scanset_handler(UFILE       *input,
1175                         u_scanf_spec_info *info,
1176                         ufmt_args   *args,
1177                         const UChar *fmt,
1178                         int32_t     *fmtConsumed,
1179                         int32_t     *argConverted)
1180 {
1181     USet        *scanset;
1182     UErrorCode  status = U_ZERO_ERROR;
1183     int32_t     chLeft = INT32_MAX;
1184     UChar32     c;
1185     UChar       *alias = (UChar*) (args[0].ptrValue);
1186     UBool       isNotEOF = FALSE;
1187     UBool       readCharacter = FALSE;
1188
1189     /* Create an empty set */
1190     scanset = uset_open(0, -1);
1191
1192     /* Back up one to get the [ */
1193     fmt--;
1194
1195     /* truncate to the width, if specified and alias the target */
1196     if(info->fWidth >= 0) {
1197         chLeft = info->fWidth;
1198     }
1199
1200     /* parse the scanset from the fmt string */
1201     *fmtConsumed = uset_applyPattern(scanset, fmt, -1, 0, &status);
1202
1203     /* verify that the parse was successful */
1204     if (U_SUCCESS(status)) {
1205         c=0;
1206
1207         /* grab characters one at a time and make sure they are in the scanset */
1208         while(chLeft > 0) {
1209             if ((isNotEOF = ufile_getch32(input, &c)) && uset_contains(scanset, c)) {
1210                 readCharacter = TRUE;
1211                 if (!info->fSkipArg) {
1212                     int32_t idx = 0;
1213                     UBool isError = FALSE;
1214
1215                     U16_APPEND(alias, idx, chLeft, c, isError);
1216                     if (isError) {
1217                         break;
1218                     }
1219                     alias += idx;
1220                 }
1221                 chLeft -= (1 + U_IS_SUPPLEMENTARY(c));
1222             }
1223             else {
1224                 /* if the character's not in the scanset, break out */
1225                 break;
1226             }
1227         }
1228
1229         /* put the final character we read back on the input */
1230         if(isNotEOF && chLeft > 0) {
1231             u_fungetc(c, input);
1232         }
1233     }
1234
1235     uset_close(scanset);
1236
1237     /* if we didn't match at least 1 character, fail */
1238     if(!readCharacter)
1239         return -1;
1240     /* otherwise, add the terminator */
1241     else if (!info->fSkipArg) {
1242         *alias = 0x00;
1243     }
1244
1245     /* we converted 1 arg */
1246     *argConverted = !info->fSkipArg;
1247     return (info->fWidth >= 0 ? info->fWidth : INT32_MAX) - chLeft;
1248 }
1249
1250 /* Use US-ASCII characters only for formatting. Most codepages have
1251  characters 20-7F from Unicode. Using any other codepage specific
1252  characters will make it very difficult to format the string on
1253  non-Unicode machines */
1254 static const u_scanf_info g_u_scanf_infos[USCANF_NUM_FMT_HANDLERS] = {
1255 /* 0x20 */
1256     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1257     UFMT_EMPTY,         UFMT_SIMPLE_PERCENT,UFMT_EMPTY,         UFMT_EMPTY,
1258     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1259     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1260
1261 /* 0x30 */
1262     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1263     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1264     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1265     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1266
1267 /* 0x40 */
1268     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_UCHAR,
1269     UFMT_EMPTY,         UFMT_SCIENTIFIC,    UFMT_EMPTY,         UFMT_SCIDBL,
1270 #ifdef U_USE_OBSOLETE_IO_FORMATTING
1271     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_UCHAR/*deprecated*/,
1272 #else
1273     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1274 #endif
1275     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1276
1277 /* 0x50 */
1278     UFMT_PERCENT,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_USTRING,
1279 #ifdef U_USE_OBSOLETE_IO_FORMATTING
1280     UFMT_EMPTY,         UFMT_USTRING/*deprecated*/,UFMT_SPELLOUT,      UFMT_EMPTY,
1281 #else
1282     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_SPELLOUT,      UFMT_EMPTY,
1283 #endif
1284     UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_SCANSET,
1285     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1286
1287 /* 0x60 */
1288     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_CHAR,
1289     UFMT_INT,           UFMT_SCIENTIFIC,    UFMT_DOUBLE,        UFMT_SCIDBL,
1290     UFMT_EMPTY,         UFMT_INT,           UFMT_EMPTY,         UFMT_EMPTY,
1291     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_COUNT,         UFMT_OCTAL,
1292
1293 /* 0x70 */
1294     UFMT_POINTER,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_STRING,
1295     UFMT_EMPTY,         UFMT_UINT,          UFMT_EMPTY,         UFMT_EMPTY,
1296     UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1297     UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
1298 };
1299
1300 U_CFUNC int32_t
1301 u_scanf_parse(UFILE     *f,
1302             const UChar *patternSpecification,
1303             va_list     ap)
1304 {
1305     const UChar     *alias;
1306     int32_t         count, converted, argConsumed, cpConsumed;
1307     uint16_t        handlerNum;
1308
1309     ufmt_args       args;
1310     u_scanf_spec    spec;
1311     ufmt_type_info  info;
1312     u_scanf_handler handler;
1313
1314     /* alias the pattern */
1315     alias = patternSpecification;
1316
1317     /* haven't converted anything yet */
1318     argConsumed = 0;
1319     converted = 0;
1320     cpConsumed = 0;
1321
1322     /* iterate through the pattern */
1323     for(;;) {
1324
1325         /* match any characters up to the next '%' */
1326         while(*alias != UP_PERCENT && *alias != 0x0000 && u_fgetc(f) == *alias) {
1327             alias++;
1328         }
1329
1330         /* if we aren't at a '%', or if we're at end of string, break*/
1331         if(*alias != UP_PERCENT || *alias == 0x0000)
1332             break;
1333
1334         /* parse the specifier */
1335         count = u_scanf_parse_spec(alias, &spec);
1336
1337         /* update the pointer in pattern */
1338         alias += count;
1339
1340         handlerNum = (uint16_t)(spec.fInfo.fSpec - USCANF_BASE_FMT_HANDLERS);
1341         if (handlerNum < USCANF_NUM_FMT_HANDLERS) {
1342             /* skip the argument, if necessary */
1343             /* query the info function for argument information */
1344             info = g_u_scanf_infos[ handlerNum ].info;
1345             if (info != ufmt_count && u_feof(f)) {
1346                 break;
1347             }
1348             else if(spec.fInfo.fSkipArg) {
1349                 args.ptrValue = NULL;
1350             }
1351             else {
1352                 switch(info) {
1353                 case ufmt_count:
1354                     /* set the spec's width to the # of items converted */
1355                     spec.fInfo.fWidth = cpConsumed;
1356                     /* fall through to next case */
1357                 case ufmt_char:
1358                 case ufmt_uchar:
1359                 case ufmt_int:
1360                 case ufmt_string:
1361                 case ufmt_ustring:
1362                 case ufmt_pointer:
1363                 case ufmt_float:
1364                 case ufmt_double:
1365                     args.ptrValue = va_arg(ap, void*);
1366                     break;
1367
1368                 default:
1369                     /* else args is ignored */
1370                     args.ptrValue = NULL;
1371                     break;
1372                 }
1373             }
1374
1375             /* call the handler function */
1376             handler = g_u_scanf_infos[ handlerNum ].handler;
1377             if(handler != 0) {
1378
1379                 /* reset count to 1 so that += for alias works. */
1380                 count = 1;
1381
1382                 cpConsumed += (*handler)(f, &spec.fInfo, &args, alias, &count, &argConsumed);
1383
1384                 /* if the handler encountered an error condition, break */
1385                 if(argConsumed < 0) {
1386                     converted = -1;
1387                     break;
1388                 }
1389
1390                 /* add to the # of items converted */
1391                 converted += argConsumed;
1392
1393                 /* update the pointer in pattern */
1394                 alias += count-1;
1395             }
1396             /* else do nothing */
1397         }
1398         /* else do nothing */
1399
1400         /* just ignore unknown tags */
1401     }
1402
1403     /* return # of items converted */
1404     return converted;
1405 }
1406
1407 #endif /* #if !UCONFIG_NO_FORMATTING */