1 /* 2 ******************************************************************************* 3 * 4 * Copyright (C) 1998-2006, 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 static int32_t 477 u_scanf_scientific_handler(UFILE *input, 478 u_scanf_spec_info *info, 479 ufmt_args *args, 480 const UChar *fmt, 481 int32_t *fmtConsumed, 482 int32_t *argConverted) 483 { 484 int32_t len; 485 double num; 486 UNumberFormat *format; 487 int32_t parsePos = 0; 488 int32_t skipped; 489 UErrorCode status = U_ZERO_ERROR; 490 491 492 /* skip all ws in the input */ 493 skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 494 495 /* fill the input's internal buffer */ 496 ufile_fill_uchar_buffer(input); 497 498 /* determine the size of the input's buffer */ 499 len = (int32_t)(input->str.fLimit - input->str.fPos); 500 501 /* truncate to the width, if specified */ 502 if(info->fWidth != -1) 503 len = ufmt_min(len, info->fWidth); 504 505 /* get the formatter */ 506 format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SCIENTIFIC); 507 508 /* handle error */ 509 if(format == 0) 510 return 0; 511 512 /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */ 513 skipped += u_scanf_skip_leading_positive_sign(input, format, &status); 514 515 /* parse the number */ 516 num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status); 517 518 if (!info->fSkipArg) { 519 if (info->fIsLong) 520 *(double*)(args[0].ptrValue) = num; 521 else if (info->fIsLongDouble) 522 *(long double*)(args[0].ptrValue) = num; 523 else 524 *(float*)(args[0].ptrValue) = (float)num; 525 } 526 527 /* mask off any necessary bits */ 528 /* if(! info->fIsLong_double) 529 num &= DBL_MAX;*/ 530 531 /* update the input's position to reflect consumed data */ 532 input->str.fPos += parsePos; 533 534 /* we converted 1 arg */ 535 *argConverted = !info->fSkipArg; 536 return parsePos + skipped; 537 } 538 539 static int32_t 540 u_scanf_scidbl_handler(UFILE *input, 541 u_scanf_spec_info *info, 542 ufmt_args *args, 543 const UChar *fmt, 544 int32_t *fmtConsumed, 545 int32_t *argConverted) 546 { 547 int32_t len; 548 double num; 549 UNumberFormat *scientificFormat, *genericFormat; 550 /*int32_t scientificResult, genericResult;*/ 551 double scientificResult, genericResult; 552 int32_t scientificParsePos = 0, genericParsePos = 0, parsePos = 0; 553 int32_t skipped; 554 UErrorCode scientificStatus = U_ZERO_ERROR; 555 UErrorCode genericStatus = U_ZERO_ERROR; 556 557 558 /* since we can't determine by scanning the characters whether */ 559 /* a number was formatted in the 'f' or 'g' styles, parse the */ 560 /* string with both formatters, and assume whichever one */ 561 /* parsed the most is the correct formatter to use */ 562 563 564 /* skip all ws in the input */ 565 skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 566 567 /* fill the input's internal buffer */ 568 ufile_fill_uchar_buffer(input); 569 570 /* determine the size of the input's buffer */ 571 len = (int32_t)(input->str.fLimit - input->str.fPos); 572 573 /* truncate to the width, if specified */ 574 if(info->fWidth != -1) 575 len = ufmt_min(len, info->fWidth); 576 577 /* get the formatters */ 578 scientificFormat = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SCIENTIFIC); 579 genericFormat = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL); 580 581 /* handle error */ 582 if(scientificFormat == 0 || genericFormat == 0) 583 return 0; 584 585 /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */ 586 skipped += u_scanf_skip_leading_positive_sign(input, genericFormat, &genericStatus); 587 588 /* parse the number using each format*/ 589 590 scientificResult = unum_parseDouble(scientificFormat, input->str.fPos, len, 591 &scientificParsePos, &scientificStatus); 592 593 genericResult = unum_parseDouble(genericFormat, input->str.fPos, len, 594 &genericParsePos, &genericStatus); 595 596 /* determine which parse made it farther */ 597 if(scientificParsePos > genericParsePos) { 598 /* stash the result in num */ 599 num = scientificResult; 600 /* update the input's position to reflect consumed data */ 601 parsePos += scientificParsePos; 602 } 603 else { 604 /* stash the result in num */ 605 num = genericResult; 606 /* update the input's position to reflect consumed data */ 607 parsePos += genericParsePos; 608 } 609 input->str.fPos += parsePos; 610 611 if (!info->fSkipArg) { 612 if (info->fIsLong) 613 *(double*)(args[0].ptrValue) = num; 614 else if (info->fIsLongDouble) 615 *(long double*)(args[0].ptrValue) = num; 616 else 617 *(float*)(args[0].ptrValue) = (float)num; 618 } 619 620 /* mask off any necessary bits */ 621 /* if(! info->fIsLong_double) 622 num &= DBL_MAX;*/ 623 624 /* we converted 1 arg */ 625 *argConverted = !info->fSkipArg; 626 return parsePos + skipped; 627 } 628 629 static int32_t 630 u_scanf_integer_handler(UFILE *input, 631 u_scanf_spec_info *info, 632 ufmt_args *args, 633 const UChar *fmt, 634 int32_t *fmtConsumed, 635 int32_t *argConverted) 636 { 637 int32_t len; 638 void *num = (void*) (args[0].ptrValue); 639 UNumberFormat *format; 640 int32_t parsePos = 0; 641 int32_t skipped; 642 UErrorCode status = U_ZERO_ERROR; 643 int64_t result; 644 645 646 /* skip all ws in the input */ 647 skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 648 649 /* fill the input's internal buffer */ 650 ufile_fill_uchar_buffer(input); 651 652 /* determine the size of the input's buffer */ 653 len = (int32_t)(input->str.fLimit - input->str.fPos); 654 655 /* truncate to the width, if specified */ 656 if(info->fWidth != -1) 657 len = ufmt_min(len, info->fWidth); 658 659 /* get the formatter */ 660 format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL); 661 662 /* handle error */ 663 if(format == 0) 664 return 0; 665 666 /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */ 667 skipped += u_scanf_skip_leading_positive_sign(input, format, &status); 668 669 /* parse the number */ 670 result = unum_parseInt64(format, input->str.fPos, len, &parsePos, &status); 671 672 /* mask off any necessary bits */ 673 if (!info->fSkipArg) { 674 if (info->fIsShort) 675 *(int16_t*)num = (int16_t)(UINT16_MAX & result); 676 else if (info->fIsLongLong) 677 *(int64_t*)num = result; 678 else 679 *(int32_t*)num = (int32_t)(UINT32_MAX & result); 680 } 681 682 /* update the input's position to reflect consumed data */ 683 input->str.fPos += parsePos; 684 685 /* we converted 1 arg */ 686 *argConverted = !info->fSkipArg; 687 return parsePos + skipped; 688 } 689 690 static int32_t 691 u_scanf_uinteger_handler(UFILE *input, 692 u_scanf_spec_info *info, 693 ufmt_args *args, 694 const UChar *fmt, 695 int32_t *fmtConsumed, 696 int32_t *argConverted) 697 { 698 /* TODO Fix this when Numberformat handles uint64_t */ 699 return u_scanf_integer_handler(input, info, args, fmt, fmtConsumed, argConverted); 700 } 701 702 static int32_t 703 u_scanf_percent_handler(UFILE *input, 704 u_scanf_spec_info *info, 705 ufmt_args *args, 706 const UChar *fmt, 707 int32_t *fmtConsumed, 708 int32_t *argConverted) 709 { 710 int32_t len; 711 double num; 712 UNumberFormat *format; 713 int32_t parsePos = 0; 714 int32_t skipped; 715 UErrorCode status = U_ZERO_ERROR; 716 717 718 /* skip all ws in the input */ 719 skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 720 721 /* fill the input's internal buffer */ 722 ufile_fill_uchar_buffer(input); 723 724 /* determine the size of the input's buffer */ 725 len = (int32_t)(input->str.fLimit - input->str.fPos); 726 727 /* truncate to the width, if specified */ 728 if(info->fWidth != -1) 729 len = ufmt_min(len, info->fWidth); 730 731 /* get the formatter */ 732 format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_PERCENT); 733 734 /* handle error */ 735 if(format == 0) 736 return 0; 737 738 /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */ 739 skipped += u_scanf_skip_leading_positive_sign(input, format, &status); 740 741 /* parse the number */ 742 num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status); 743 744 if (!info->fSkipArg) { 745 *(double*)(args[0].ptrValue) = num; 746 } 747 748 /* mask off any necessary bits */ 749 /* if(! info->fIsLong_double) 750 num &= DBL_MAX;*/ 751 752 /* update the input's position to reflect consumed data */ 753 input->str.fPos += parsePos; 754 755 /* we converted 1 arg */ 756 *argConverted = !info->fSkipArg; 757 return parsePos; 758 } 759 760 static int32_t 761 u_scanf_string_handler(UFILE *input, 762 u_scanf_spec_info *info, 763 ufmt_args *args, 764 const UChar *fmt, 765 int32_t *fmtConsumed, 766 int32_t *argConverted) 767 { 768 const UChar *source; 769 UConverter *conv; 770 char *arg = (char*)(args[0].ptrValue); 771 char *alias = arg; 772 char *limit; 773 UErrorCode status = U_ZERO_ERROR; 774 int32_t count; 775 int32_t skipped = 0; 776 UChar c; 777 UBool isNotEOF = FALSE; 778 779 /* skip all ws in the input */ 780 if (info->fIsString) { 781 skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 782 } 783 784 /* get the string one character at a time, truncating to the width */ 785 count = 0; 786 787 /* open the default converter */ 788 conv = u_getDefaultConverter(&status); 789 790 if(U_FAILURE(status)) 791 return -1; 792 793 while( (info->fWidth == -1 || count < info->fWidth) 794 && (isNotEOF = ufile_getch(input, &c)) 795 && (!info->fIsString || (c != info->fPadChar && !u_isWhitespace(c)))) 796 { 797 798 if (!info->fSkipArg) { 799 /* put the character from the input onto the target */ 800 source = &c; 801 /* Since we do this one character at a time, do it this way. */ 802 if (info->fWidth > 0) { 803 limit = alias + info->fWidth - count; 804 } 805 else { 806 limit = alias + ucnv_getMaxCharSize(conv); 807 } 808 809 /* convert the character to the default codepage */ 810 ucnv_fromUnicode(conv, &alias, limit, &source, source + 1, 811 NULL, TRUE, &status); 812 813 if(U_FAILURE(status)) { 814 /* clean up */ 815 u_releaseDefaultConverter(conv); 816 return -1; 817 } 818 } 819 820 /* increment the count */ 821 ++count; 822 } 823 824 /* put the final character we read back on the input */ 825 if (!info->fSkipArg) { 826 if ((info->fWidth == -1 || count < info->fWidth) && isNotEOF) 827 u_fungetc(c, input); 828 829 /* add the terminator */ 830 if (info->fIsString) { 831 *alias = 0x00; 832 } 833 } 834 835 /* clean up */ 836 u_releaseDefaultConverter(conv); 837 838 /* we converted 1 arg */ 839 *argConverted = !info->fSkipArg; 840 return count + skipped; 841 } 842 843 static int32_t 844 u_scanf_char_handler(UFILE *input, 845 u_scanf_spec_info *info, 846 ufmt_args *args, 847 const UChar *fmt, 848 int32_t *fmtConsumed, 849 int32_t *argConverted) 850 { 851 if (info->fWidth < 0) { 852 info->fWidth = 1; 853 } 854 info->fIsString = FALSE; 855 return u_scanf_string_handler(input, info, args, fmt, fmtConsumed, argConverted); 856 } 857 858 static int32_t 859 u_scanf_ustring_handler(UFILE *input, 860 u_scanf_spec_info *info, 861 ufmt_args *args, 862 const UChar *fmt, 863 int32_t *fmtConsumed, 864 int32_t *argConverted) 865 { 866 UChar *arg = (UChar*)(args[0].ptrValue); 867 UChar *alias = arg; 868 int32_t count; 869 int32_t skipped = 0; 870 UChar c; 871 UBool isNotEOF = FALSE; 872 873 /* skip all ws in the input */ 874 if (info->fIsString) { 875 skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 876 } 877 878 /* get the string one character at a time, truncating to the width */ 879 count = 0; 880 881 while( (info->fWidth == -1 || count < info->fWidth) 882 && (isNotEOF = ufile_getch(input, &c)) 883 && (!info->fIsString || (c != info->fPadChar && !u_isWhitespace(c)))) 884 { 885 886 /* put the character from the input onto the target */ 887 if (!info->fSkipArg) { 888 *alias++ = c; 889 } 890 891 /* increment the count */ 892 ++count; 893 } 894 895 /* put the final character we read back on the input */ 896 if (!info->fSkipArg) { 897 if((info->fWidth == -1 || count < info->fWidth) && isNotEOF) { 898 u_fungetc(c, input); 899 } 900 901 /* add the terminator */ 902 if (info->fIsString) { 903 *alias = 0x0000; 904 } 905 } 906 907 /* we converted 1 arg */ 908 *argConverted = !info->fSkipArg; 909 return count + skipped; 910 } 911 912 static int32_t 913 u_scanf_uchar_handler(UFILE *input, 914 u_scanf_spec_info *info, 915 ufmt_args *args, 916 const UChar *fmt, 917 int32_t *fmtConsumed, 918 int32_t *argConverted) 919 { 920 if (info->fWidth < 0) { 921 info->fWidth = 1; 922 } 923 info->fIsString = FALSE; 924 return u_scanf_ustring_handler(input, info, args, fmt, fmtConsumed, argConverted); 925 } 926 927 static int32_t 928 u_scanf_spellout_handler(UFILE *input, 929 u_scanf_spec_info *info, 930 ufmt_args *args, 931 const UChar *fmt, 932 int32_t *fmtConsumed, 933 int32_t *argConverted) 934 { 935 int32_t len; 936 double num; 937 UNumberFormat *format; 938 int32_t parsePos = 0; 939 int32_t skipped; 940 UErrorCode status = U_ZERO_ERROR; 941 942 943 /* skip all ws in the input */ 944 skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 945 946 /* fill the input's internal buffer */ 947 ufile_fill_uchar_buffer(input); 948 949 /* determine the size of the input's buffer */ 950 len = (int32_t)(input->str.fLimit - input->str.fPos); 951 952 /* truncate to the width, if specified */ 953 if(info->fWidth != -1) 954 len = ufmt_min(len, info->fWidth); 955 956 /* get the formatter */ 957 format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SPELLOUT); 958 959 /* handle error */ 960 if(format == 0) 961 return 0; 962 963 /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */ 964 /* This is not applicable to RBNF. */ 965 /*skipped += u_scanf_skip_leading_positive_sign(input, format, &status);*/ 966 967 /* parse the number */ 968 num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status); 969 970 if (!info->fSkipArg) { 971 *(double*)(args[0].ptrValue) = num; 972 } 973 974 /* mask off any necessary bits */ 975 /* if(! info->fIsLong_double) 976 num &= DBL_MAX;*/ 977 978 /* update the input's position to reflect consumed data */ 979 input->str.fPos += parsePos; 980 981 /* we converted 1 arg */ 982 *argConverted = !info->fSkipArg; 983 return parsePos + skipped; 984 } 985 986 static int32_t 987 u_scanf_hex_handler(UFILE *input, 988 u_scanf_spec_info *info, 989 ufmt_args *args, 990 const UChar *fmt, 991 int32_t *fmtConsumed, 992 int32_t *argConverted) 993 { 994 int32_t len; 995 int32_t skipped; 996 void *num = (void*) (args[0].ptrValue); 997 int64_t result; 998 999 /* skip all ws in the input */ 1000 skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 1001 1002 /* fill the input's internal buffer */ 1003 ufile_fill_uchar_buffer(input); 1004 1005 /* determine the size of the input's buffer */ 1006 len = (int32_t)(input->str.fLimit - input->str.fPos); 1007 1008 /* truncate to the width, if specified */ 1009 if(info->fWidth != -1) 1010 len = ufmt_min(len, info->fWidth); 1011 1012 /* check for alternate form */ 1013 if( *(input->str.fPos) == 0x0030 && 1014 (*(input->str.fPos + 1) == 0x0078 || *(input->str.fPos + 1) == 0x0058) ) { 1015 1016 /* skip the '0' and 'x' or 'X' if present */ 1017 input->str.fPos += 2; 1018 len -= 2; 1019 } 1020 1021 /* parse the number */ 1022 result = ufmt_uto64(input->str.fPos, &len, 16); 1023 1024 /* update the input's position to reflect consumed data */ 1025 input->str.fPos += len; 1026 1027 /* mask off any necessary bits */ 1028 if (!info->fSkipArg) { 1029 if (info->fIsShort) 1030 *(int16_t*)num = (int16_t)(UINT16_MAX & result); 1031 else if (info->fIsLongLong) 1032 *(int64_t*)num = result; 1033 else 1034 *(int32_t*)num = (int32_t)(UINT32_MAX & result); 1035 } 1036 1037 /* we converted 1 arg */ 1038 *argConverted = !info->fSkipArg; 1039 return len + skipped; 1040 } 1041 1042 static int32_t 1043 u_scanf_octal_handler(UFILE *input, 1044 u_scanf_spec_info *info, 1045 ufmt_args *args, 1046 const UChar *fmt, 1047 int32_t *fmtConsumed, 1048 int32_t *argConverted) 1049 { 1050 int32_t len; 1051 int32_t skipped; 1052 void *num = (void*) (args[0].ptrValue); 1053 int64_t result; 1054 1055 /* skip all ws in the input */ 1056 skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 1057 1058 /* fill the input's internal buffer */ 1059 ufile_fill_uchar_buffer(input); 1060 1061 /* determine the size of the input's buffer */ 1062 len = (int32_t)(input->str.fLimit - input->str.fPos); 1063 1064 /* truncate to the width, if specified */ 1065 if(info->fWidth != -1) 1066 len = ufmt_min(len, info->fWidth); 1067 1068 /* parse the number */ 1069 result = ufmt_uto64(input->str.fPos, &len, 8); 1070 1071 /* update the input's position to reflect consumed data */ 1072 input->str.fPos += len; 1073 1074 /* mask off any necessary bits */ 1075 if (!info->fSkipArg) { 1076 if (info->fIsShort) 1077 *(int16_t*)num = (int16_t)(UINT16_MAX & result); 1078 else if (info->fIsLongLong) 1079 *(int64_t*)num = result; 1080 else 1081 *(int32_t*)num = (int32_t)(UINT32_MAX & result); 1082 } 1083 1084 /* we converted 1 arg */ 1085 *argConverted = !info->fSkipArg; 1086 return len + skipped; 1087 } 1088 1089 static int32_t 1090 u_scanf_pointer_handler(UFILE *input, 1091 u_scanf_spec_info *info, 1092 ufmt_args *args, 1093 const UChar *fmt, 1094 int32_t *fmtConsumed, 1095 int32_t *argConverted) 1096 { 1097 int32_t len; 1098 int32_t skipped; 1099 void *result; 1100 void **p = (void**)(args[0].ptrValue); 1101 1102 1103 /* skip all ws in the input */ 1104 skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 1105 1106 /* fill the input's internal buffer */ 1107 ufile_fill_uchar_buffer(input); 1108 1109 /* determine the size of the input's buffer */ 1110 len = (int32_t)(input->str.fLimit - input->str.fPos); 1111 1112 /* truncate to the width, if specified */ 1113 if(info->fWidth != -1) { 1114 len = ufmt_min(len, info->fWidth); 1115 } 1116 1117 /* Make sure that we don't consume too much */ 1118 if (len > (int32_t)(sizeof(void*)*2)) { 1119 len = (int32_t)(sizeof(void*)*2); 1120 } 1121 1122 /* parse the pointer - assign to temporary value */ 1123 result = ufmt_utop(input->str.fPos, &len); 1124 1125 if (!info->fSkipArg) { 1126 *p = result; 1127 } 1128 1129 /* update the input's position to reflect consumed data */ 1130 input->str.fPos += len; 1131 1132 /* we converted 1 arg */ 1133 *argConverted = !info->fSkipArg; 1134 return len + skipped; 1135 } 1136 1137 static int32_t 1138 u_scanf_scanset_handler(UFILE *input, 1139 u_scanf_spec_info *info, 1140 ufmt_args *args, 1141 const UChar *fmt, 1142 int32_t *fmtConsumed, 1143 int32_t *argConverted) 1144 { 1145 USet *scanset; 1146 UErrorCode status = U_ZERO_ERROR; 1147 int32_t chLeft = INT32_MAX; 1148 UChar32 c; 1149 UChar *alias = (UChar*) (args[0].ptrValue); 1150 UBool isNotEOF = FALSE; 1151 UBool readCharacter = FALSE; 1152 1153 /* Create an empty set */ 1154 scanset = uset_open(0, -1); 1155 1156 /* Back up one to get the [ */ 1157 fmt--; 1158 1159 /* truncate to the width, if specified and alias the target */ 1160 if(info->fWidth >= 0) { 1161 chLeft = info->fWidth; 1162 } 1163 1164 /* parse the scanset from the fmt string */ 1165 *fmtConsumed = uset_applyPattern(scanset, fmt, -1, 0, &status); 1166 1167 /* verify that the parse was successful */ 1168 if (U_SUCCESS(status)) { 1169 c=0; 1170 1171 /* grab characters one at a time and make sure they are in the scanset */ 1172 while(chLeft > 0) { 1173 if ((isNotEOF = ufile_getch32(input, &c)) && uset_contains(scanset, c)) { 1174 readCharacter = TRUE; 1175 if (!info->fSkipArg) { 1176 int32_t idx = 0; 1177 UBool isError = FALSE; 1178 1179 U16_APPEND(alias, idx, chLeft, c, isError); 1180 if (isError) { 1181 break; 1182 } 1183 alias += idx; 1184 } 1185 chLeft -= (1 + U_IS_SUPPLEMENTARY(c)); 1186 } 1187 else { 1188 /* if the character's not in the scanset, break out */ 1189 break; 1190 } 1191 } 1192 1193 /* put the final character we read back on the input */ 1194 if(isNotEOF && chLeft > 0) { 1195 u_fungetc(c, input); 1196 } 1197 } 1198 1199 uset_close(scanset); 1200 1201 /* if we didn't match at least 1 character, fail */ 1202 if(!readCharacter) 1203 return -1; 1204 /* otherwise, add the terminator */ 1205 else if (!info->fSkipArg) { 1206 *alias = 0x00; 1207 } 1208 1209 /* we converted 1 arg */ 1210 *argConverted = !info->fSkipArg; 1211 return (info->fWidth >= 0 ? info->fWidth : INT32_MAX) - chLeft; 1212 } 1213 1214 /* Use US-ASCII characters only for formatting. Most codepages have 1215 characters 20-7F from Unicode. Using any other codepage specific 1216 characters will make it very difficult to format the string on 1217 non-Unicode machines */ 1218 static const u_scanf_info g_u_scanf_infos[USCANF_NUM_FMT_HANDLERS] = { 1219 /* 0x20 */ 1220 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1221 UFMT_EMPTY, UFMT_SIMPLE_PERCENT,UFMT_EMPTY, UFMT_EMPTY, 1222 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1223 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1224 1225 /* 0x30 */ 1226 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1227 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1228 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1229 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1230 1231 /* 0x40 */ 1232 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_UCHAR, 1233 UFMT_EMPTY, UFMT_SCIENTIFIC, UFMT_EMPTY, UFMT_SCIDBL, 1234 #ifdef U_USE_OBSOLETE_IO_FORMATTING 1235 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_UCHAR/*deprecated*/, 1236 #else 1237 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1238 #endif 1239 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1240 1241 /* 0x50 */ 1242 UFMT_PERCENT, UFMT_EMPTY, UFMT_EMPTY, UFMT_USTRING, 1243 #ifdef U_USE_OBSOLETE_IO_FORMATTING 1244 UFMT_EMPTY, UFMT_USTRING/*deprecated*/,UFMT_SPELLOUT, UFMT_EMPTY, 1245 #else 1246 UFMT_EMPTY, UFMT_EMPTY, UFMT_SPELLOUT, UFMT_EMPTY, 1247 #endif 1248 UFMT_HEX, UFMT_EMPTY, UFMT_EMPTY, UFMT_SCANSET, 1249 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1250 1251 /* 0x60 */ 1252 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_CHAR, 1253 UFMT_INT, UFMT_SCIENTIFIC, UFMT_DOUBLE, UFMT_SCIDBL, 1254 UFMT_EMPTY, UFMT_INT, UFMT_EMPTY, UFMT_EMPTY, 1255 UFMT_EMPTY, UFMT_EMPTY, UFMT_COUNT, UFMT_OCTAL, 1256 1257 /* 0x70 */ 1258 UFMT_POINTER, UFMT_EMPTY, UFMT_EMPTY, UFMT_STRING, 1259 UFMT_EMPTY, UFMT_UINT, UFMT_EMPTY, UFMT_EMPTY, 1260 UFMT_HEX, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1261 UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, 1262 }; 1263 1264 U_CFUNC int32_t 1265 u_scanf_parse(UFILE *f, 1266 const UChar *patternSpecification, 1267 va_list ap) 1268 { 1269 const UChar *alias; 1270 int32_t count, converted, argConsumed, cpConsumed; 1271 uint16_t handlerNum; 1272 1273 ufmt_args args; 1274 u_scanf_spec spec; 1275 ufmt_type_info info; 1276 u_scanf_handler handler; 1277 1278 /* alias the pattern */ 1279 alias = patternSpecification; 1280 1281 /* haven't converted anything yet */ 1282 argConsumed = 0; 1283 converted = 0; 1284 cpConsumed = 0; 1285 1286 /* iterate through the pattern */ 1287 for(;;) { 1288 1289 /* match any characters up to the next '%' */ 1290 while(*alias != UP_PERCENT && *alias != 0x0000 && u_fgetc(f) == *alias) { 1291 alias++; 1292 } 1293 1294 /* if we aren't at a '%', or if we're at end of string, break*/ 1295 if(*alias != UP_PERCENT || *alias == 0x0000) 1296 break; 1297 1298 /* parse the specifier */ 1299 count = u_scanf_parse_spec(alias, &spec); 1300 1301 /* update the pointer in pattern */ 1302 alias += count; 1303 1304 handlerNum = (uint16_t)(spec.fInfo.fSpec - USCANF_BASE_FMT_HANDLERS); 1305 if (handlerNum < USCANF_NUM_FMT_HANDLERS) { 1306 /* skip the argument, if necessary */ 1307 /* query the info function for argument information */ 1308 info = g_u_scanf_infos[ handlerNum ].info; 1309 if (info != ufmt_count && u_feof(f)) { 1310 break; 1311 } 1312 else if(spec.fInfo.fSkipArg) { 1313 args.ptrValue = NULL; 1314 } 1315 else { 1316 switch(info) { 1317 case ufmt_count: 1318 /* set the spec's width to the # of items converted */ 1319 spec.fInfo.fWidth = cpConsumed; 1320 /* fall through to next case */ 1321 case ufmt_char: 1322 case ufmt_uchar: 1323 case ufmt_int: 1324 case ufmt_string: 1325 case ufmt_ustring: 1326 case ufmt_pointer: 1327 case ufmt_float: 1328 case ufmt_double: 1329 args.ptrValue = va_arg(ap, void*); 1330 break; 1331 1332 default: 1333 /* else args is ignored */ 1334 args.ptrValue = NULL; 1335 break; 1336 } 1337 } 1338 1339 /* call the handler function */ 1340 handler = g_u_scanf_infos[ handlerNum ].handler; 1341 if(handler != 0) { 1342 1343 /* reset count to 1 so that += for alias works. */ 1344 count = 1; 1345 1346 cpConsumed += (*handler)(f, &spec.fInfo, &args, alias, &count, &argConsumed); 1347 1348 /* if the handler encountered an error condition, break */ 1349 if(argConsumed < 0) { 1350 converted = -1; 1351 break; 1352 } 1353 1354 /* add to the # of items converted */ 1355 converted += argConsumed; 1356 1357 /* update the pointer in pattern */ 1358 alias += count-1; 1359 } 1360 /* else do nothing */ 1361 } 1362 /* else do nothing */ 1363 1364 /* just ignore unknown tags */ 1365 } 1366 1367 /* return # of items converted */ 1368 return converted; 1369 } 1370 1371 #endif /* #if !UCONFIG_NO_FORMATTING */ 1372
