1 /************************************************************************* 2 * 3 * $Id$ 4 * 5 * Copyright (C) 1998 Bjorn Reese and Daniel Stenberg. 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED 12 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 13 * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND 14 * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER. 15 * 16 ************************************************************************* 17 * 18 * A note to trio contributors: 19 * 20 * Avoid heap allocation at all costs to ensure that the trio functions 21 * are async-safe. The exceptions are the printf/fprintf functions, which 22 * uses fputc, and the asprintf functions and the <alloc> modifier, which 23 * by design are required to allocate form the heap. 24 * 25 ************************************************************************/ 26 27 /* 28 * TODO: 29 * - Scan is probably too permissive about its modifiers. 30 * - C escapes in %#[] ? 31 * - Multibyte characters (done for format parsing, except scan groups) 32 * - Complex numbers? (C99 _Complex) 33 * - Boolean values? (C99 _Bool) 34 * - C99 NaN(n-char-sequence) missing. The n-char-sequence can be used 35 * to print the mantissa, e.g. NaN(0xc000000000000000) 36 * - Should we support the GNU %a alloc modifier? GNU has an ugly hack 37 * for %a, because C99 used %a for other purposes. If specified as 38 * %as or %a[ it is interpreted as the alloc modifier, otherwise as 39 * the C99 hex-float. This means that you cannot scan %as as a hex-float 40 * immediately followed by an 's'. 41 * - Scanning of collating symbols. 42 */ 43 44 /************************************************************************* 45 * Trio include files 46 */ 47 #include "triodef.h" 48 #include "trio.h" 49 #include "triop.h" 50 #include "trionan.h" 51 #if !defined(TRIO_MINIMAL) 52 # include "triostr.h" 53 #endif 54 55 /************************************************************************** 56 * 57 * Definitions 58 * 59 *************************************************************************/ 60 61 #include <math.h> 62 #include <limits.h> 63 #include <float.h> 64 65 #if (defined(__STDC_ISO_10646__) || defined(MB_LEN_MAX) \ 66 || defined(USE_MULTIBYTE) || TRIO_WIDECHAR) \ 67 && !defined(_WIN32_WCE) 68 # define TRIO_COMPILER_SUPPORTS_MULTIBYTE 69 # if !defined(MB_LEN_MAX) 70 # define MB_LEN_MAX 6 71 # endif 72 #endif 73 74 #if (defined(TRIO_COMPILER_MSVC) && (_MSC_VER >= 1100)) || defined(TRIO_COMPILER_BCB) 75 # define TRIO_COMPILER_SUPPORTS_MSVC_INT 76 #endif 77 78 #if defined(_WIN32_WCE) 79 #include <wincecompat.h> 80 #endif 81 82 /************************************************************************* 83 * Generic definitions 84 */ 85 86 #if !(defined(DEBUG) || defined(NDEBUG)) 87 # define NDEBUG 88 #endif 89 90 #include <assert.h> 91 #include <ctype.h> 92 #if !defined(TRIO_COMPILER_SUPPORTS_C99) 93 # define isblank(x) (((x)==32) || ((x)==9)) 94 #endif 95 #if defined(TRIO_COMPILER_ANCIENT) 96 # include <varargs.h> 97 #else 98 # include <stdarg.h> 99 #endif 100 #include <stddef.h> 101 102 #ifdef HAVE_ERRNO_H 103 #include <errno.h> 104 #endif 105 106 #ifndef NULL 107 # define NULL 0 108 #endif 109 #define NIL ((char)0) 110 #ifndef FALSE 111 # define FALSE (1 == 0) 112 # define TRUE (! FALSE) 113 #endif 114 #define BOOLEAN_T int 115 116 /* mincore() can be used for debugging purposes */ 117 #define VALID(x) (NULL != (x)) 118 119 #if TRIO_ERRORS 120 /* 121 * Encode the error code and the position. This is decoded 122 * with TRIO_ERROR_CODE and TRIO_ERROR_POSITION. 123 */ 124 # define TRIO_ERROR_RETURN(x,y) (- ((x) + ((y) << 8))) 125 #else 126 # define TRIO_ERROR_RETURN(x,y) (-1) 127 #endif 128 129 typedef unsigned long trio_flags_t; 130 131 132 /************************************************************************* 133 * Platform specific definitions 134 */ 135 #if defined(TRIO_PLATFORM_UNIX) 136 # include <unistd.h> 137 # include <signal.h> 138 # include <locale.h> 139 # define USE_LOCALE 140 #endif /* TRIO_PLATFORM_UNIX */ 141 #if defined(TRIO_PLATFORM_VMS) 142 # include <unistd.h> 143 #endif 144 #if defined(TRIO_PLATFORM_WIN32) 145 # if defined(_WIN32_WCE) 146 # include <wincecompat.h> 147 # else 148 # include <io.h> 149 # define read _read 150 # define write _write 151 # endif 152 #endif /* TRIO_PLATFORM_WIN32 */ 153 154 #if TRIO_WIDECHAR 155 # if defined(TRIO_COMPILER_SUPPORTS_ISO94) 156 # include <wchar.h> 157 # include <wctype.h> 158 typedef wchar_t trio_wchar_t; 159 typedef wint_t trio_wint_t; 160 # else 161 typedef char trio_wchar_t; 162 typedef int trio_wint_t; 163 # define WCONST(x) L ## x 164 # define WEOF EOF 165 # define iswalnum(x) isalnum(x) 166 # define iswalpha(x) isalpha(x) 167 # define iswblank(x) isblank(x) 168 # define iswcntrl(x) iscntrl(x) 169 # define iswdigit(x) isdigit(x) 170 # define iswgraph(x) isgraph(x) 171 # define iswlower(x) islower(x) 172 # define iswprint(x) isprint(x) 173 # define iswpunct(x) ispunct(x) 174 # define iswspace(x) isspace(x) 175 # define iswupper(x) isupper(x) 176 # define iswxdigit(x) isxdigit(x) 177 # endif 178 #endif 179 180 181 /************************************************************************* 182 * Compiler dependent definitions 183 */ 184 185 /* Support for long long */ 186 #ifndef __cplusplus 187 # if !defined(USE_LONGLONG) 188 # if defined(TRIO_COMPILER_GCC) && !defined(__STRICT_ANSI__) 189 # define USE_LONGLONG 190 # elif defined(TRIO_COMPILER_SUNPRO) 191 # define USE_LONGLONG 192 # elif defined(_LONG_LONG) || defined(_LONGLONG) 193 # define USE_LONGLONG 194 # endif 195 # endif 196 #endif 197 198 /* The extra long numbers */ 199 #if defined(USE_LONGLONG) 200 typedef signed long long int trio_longlong_t; 201 typedef unsigned long long int trio_ulonglong_t; 202 #elif defined(TRIO_COMPILER_SUPPORTS_MSVC_INT) 203 typedef signed __int64 trio_longlong_t; 204 typedef unsigned __int64 trio_ulonglong_t; 205 #else 206 typedef TRIO_SIGNED long int trio_longlong_t; 207 typedef unsigned long int trio_ulonglong_t; 208 #endif 209 210 /* Maximal and fixed integer types */ 211 #if defined(TRIO_COMPILER_SUPPORTS_C99) 212 # include <stdint.h> 213 typedef intmax_t trio_intmax_t; 214 typedef uintmax_t trio_uintmax_t; 215 typedef int8_t trio_int8_t; 216 typedef int16_t trio_int16_t; 217 typedef int32_t trio_int32_t; 218 typedef int64_t trio_int64_t; 219 #elif defined(TRIO_COMPILER_SUPPORTS_UNIX98) 220 # include <inttypes.h> 221 typedef intmax_t trio_intmax_t; 222 typedef uintmax_t trio_uintmax_t; 223 typedef int8_t trio_int8_t; 224 typedef int16_t trio_int16_t; 225 typedef int32_t trio_int32_t; 226 typedef int64_t trio_int64_t; 227 #elif defined(TRIO_COMPILER_SUPPORTS_MSVC_INT) 228 typedef trio_longlong_t trio_intmax_t; 229 typedef trio_ulonglong_t trio_uintmax_t; 230 typedef __int8 trio_int8_t; 231 typedef __int16 trio_int16_t; 232 typedef __int32 trio_int32_t; 233 typedef __int64 trio_int64_t; 234 #else 235 typedef trio_longlong_t trio_intmax_t; 236 typedef trio_ulonglong_t trio_uintmax_t; 237 # if defined(TRIO_INT8_T) 238 typedef TRIO_INT8_T trio_int8_t; 239 # else 240 typedef TRIO_SIGNED char trio_int8_t; 241 # endif 242 # if defined(TRIO_INT16_T) 243 typedef TRIO_INT16_T trio_int16_t; 244 # else 245 typedef TRIO_SIGNED short trio_int16_t; 246 # endif 247 # if defined(TRIO_INT32_T) 248 typedef TRIO_INT32_T trio_int32_t; 249 # else 250 typedef TRIO_SIGNED int trio_int32_t; 251 # endif 252 # if defined(TRIO_INT64_T) 253 typedef TRIO_INT64_T trio_int64_t; 254 # else 255 typedef trio_longlong_t trio_int64_t; 256 # endif 257 #endif 258 259 #if (!(defined(TRIO_COMPILER_SUPPORTS_C99) \ 260 || defined(TRIO_COMPILER_SUPPORTS_UNIX01))) \ 261 && !defined(_WIN32_WCE) 262 # define floorl(x) floor((double)(x)) 263 # define fmodl(x,y) fmod((double)(x),(double)(y)) 264 # define powl(x,y) pow((double)(x),(double)(y)) 265 #endif 266 267 #define TRIO_FABS(x) (((x) < 0.0) ? -(x) : (x)) 268 269 /************************************************************************* 270 * Internal Definitions 271 */ 272 273 #ifndef DECIMAL_DIG 274 # define DECIMAL_DIG DBL_DIG 275 #endif 276 277 /* Long double sizes */ 278 #ifdef LDBL_DIG 279 # define MAX_MANTISSA_DIGITS LDBL_DIG 280 # define MAX_EXPONENT_DIGITS 4 281 # define MAX_DOUBLE_DIGITS LDBL_MAX_10_EXP 282 #else 283 # define MAX_MANTISSA_DIGITS DECIMAL_DIG 284 # define MAX_EXPONENT_DIGITS 3 285 # define MAX_DOUBLE_DIGITS DBL_MAX_10_EXP 286 #endif 287 288 #if defined(TRIO_COMPILER_ANCIENT) || !defined(LDBL_DIG) 289 # undef LDBL_DIG 290 # undef LDBL_MANT_DIG 291 # undef LDBL_EPSILON 292 # define LDBL_DIG DBL_DIG 293 # define LDBL_MANT_DIG DBL_MANT_DIG 294 # define LDBL_EPSILON DBL_EPSILON 295 #endif 296 297 /* The maximal number of digits is for base 2 */ 298 #define MAX_CHARS_IN(x) (sizeof(x) * CHAR_BIT) 299 /* The width of a pointer. The number of bits in a hex digit is 4 */ 300 #define POINTER_WIDTH ((sizeof("0x") - 1) + sizeof(trio_pointer_t) * CHAR_BIT / 4) 301 302 /* Infinite and Not-A-Number for floating-point */ 303 #define INFINITE_LOWER "inf" 304 #define INFINITE_UPPER "INF" 305 #define LONG_INFINITE_LOWER "infinite" 306 #define LONG_INFINITE_UPPER "INFINITE" 307 #define NAN_LOWER "nan" 308 #define NAN_UPPER "NAN" 309 310 /* Various constants */ 311 enum { 312 TYPE_PRINT = 1, 313 TYPE_SCAN = 2, 314 315 /* Flags. FLAGS_LAST must be less than ULONG_MAX */ 316 FLAGS_NEW = 0, 317 FLAGS_STICKY = 1, 318 FLAGS_SPACE = 2 * FLAGS_STICKY, 319 FLAGS_SHOWSIGN = 2 * FLAGS_SPACE, 320 FLAGS_LEFTADJUST = 2 * FLAGS_SHOWSIGN, 321 FLAGS_ALTERNATIVE = 2 * FLAGS_LEFTADJUST, 322 FLAGS_SHORT = 2 * FLAGS_ALTERNATIVE, 323 FLAGS_SHORTSHORT = 2 * FLAGS_SHORT, 324 FLAGS_LONG = 2 * FLAGS_SHORTSHORT, 325 FLAGS_QUAD = 2 * FLAGS_LONG, 326 FLAGS_LONGDOUBLE = 2 * FLAGS_QUAD, 327 FLAGS_SIZE_T = 2 * FLAGS_LONGDOUBLE, 328 FLAGS_PTRDIFF_T = 2 * FLAGS_SIZE_T, 329 FLAGS_INTMAX_T = 2 * FLAGS_PTRDIFF_T, 330 FLAGS_NILPADDING = 2 * FLAGS_INTMAX_T, 331 FLAGS_UNSIGNED = 2 * FLAGS_NILPADDING, 332 FLAGS_UPPER = 2 * FLAGS_UNSIGNED, 333 FLAGS_WIDTH = 2 * FLAGS_UPPER, 334 FLAGS_WIDTH_PARAMETER = 2 * FLAGS_WIDTH, 335 FLAGS_PRECISION = 2 * FLAGS_WIDTH_PARAMETER, 336 FLAGS_PRECISION_PARAMETER = 2 * FLAGS_PRECISION, 337 FLAGS_BASE = 2 * FLAGS_PRECISION_PARAMETER, 338 FLAGS_BASE_PARAMETER = 2 * FLAGS_BASE, 339 FLAGS_FLOAT_E = 2 * FLAGS_BASE_PARAMETER, 340 FLAGS_FLOAT_G = 2 * FLAGS_FLOAT_E, 341 FLAGS_QUOTE = 2 * FLAGS_FLOAT_G, 342 FLAGS_WIDECHAR = 2 * FLAGS_QUOTE, 343 FLAGS_ALLOC = 2 * FLAGS_WIDECHAR, 344 FLAGS_IGNORE = 2 * FLAGS_ALLOC, 345 FLAGS_IGNORE_PARAMETER = 2 * FLAGS_IGNORE, 346 FLAGS_VARSIZE_PARAMETER = 2 * FLAGS_IGNORE_PARAMETER, 347 FLAGS_FIXED_SIZE = 2 * FLAGS_VARSIZE_PARAMETER, 348 FLAGS_LAST = FLAGS_FIXED_SIZE, 349 /* Reused flags */ 350 FLAGS_EXCLUDE = FLAGS_SHORT, 351 FLAGS_USER_DEFINED = FLAGS_IGNORE, 352 FLAGS_ROUNDING = FLAGS_INTMAX_T, 353 /* Compounded flags */ 354 FLAGS_ALL_VARSIZES = FLAGS_LONG | FLAGS_QUAD | FLAGS_INTMAX_T | FLAGS_PTRDIFF_T | FLAGS_SIZE_T, 355 FLAGS_ALL_SIZES = FLAGS_ALL_VARSIZES | FLAGS_SHORTSHORT | FLAGS_SHORT, 356 357 NO_POSITION = -1, 358 NO_WIDTH = 0, 359 NO_PRECISION = -1, 360 NO_SIZE = -1, 361 362 /* Do not change these */ 363 NO_BASE = -1, 364 MIN_BASE = 2, 365 MAX_BASE = 36, 366 BASE_BINARY = 2, 367 BASE_OCTAL = 8, 368 BASE_DECIMAL = 10, 369 BASE_HEX = 16, 370 371 /* Maximal number of allowed parameters */ 372 MAX_PARAMETERS = 64, 373 /* Maximal number of characters in class */ 374 MAX_CHARACTER_CLASS = UCHAR_MAX + 1, 375 376 /* Maximal string lengths for user-defined specifiers */ 377 MAX_USER_NAME = 64, 378 MAX_USER_DATA = 256, 379 380 /* Maximal length of locale separator strings */ 381 MAX_LOCALE_SEPARATOR_LENGTH = MB_LEN_MAX, 382 /* Maximal number of integers in grouping */ 383 MAX_LOCALE_GROUPS = 64, 384 385 /* Initial size of asprintf buffer */ 386 DYNAMIC_START_SIZE = 32 387 }; 388 389 #define NO_GROUPING ((int)CHAR_MAX) 390 391 /* Fundamental formatting parameter types */ 392 #define FORMAT_UNKNOWN 0 393 #define FORMAT_INT 1 394 #define FORMAT_DOUBLE 2 395 #define FORMAT_CHAR 3 396 #define FORMAT_STRING 4 397 #define FORMAT_POINTER 5 398 #define FORMAT_COUNT 6 399 #define FORMAT_PARAMETER 7 400 #define FORMAT_GROUP 8 401 #if TRIO_GNU 402 # define FORMAT_ERRNO 9 403 #endif 404 #if TRIO_EXTENSION 405 # define FORMAT_USER_DEFINED 10 406 #endif 407 408 /* Character constants */ 409 #define CHAR_IDENTIFIER '%' 410 #define CHAR_BACKSLASH '\\' 411 #define CHAR_QUOTE '\"' 412 #define CHAR_ADJUST ' ' 413 414 /* Character class expressions */ 415 #define CLASS_ALNUM "[:alnum:]" 416 #define CLASS_ALPHA "[:alpha:]" 417 #define CLASS_BLANK "[:blank:]" 418 #define CLASS_CNTRL "[:cntrl:]" 419 #define CLASS_DIGIT "[:digit:]" 420 #define CLASS_GRAPH "[:graph:]" 421 #define CLASS_LOWER "[:lower:]" 422 #define CLASS_PRINT "[:print:]" 423 #define CLASS_PUNCT "[:punct:]" 424 #define CLASS_SPACE "[:space:]" 425 #define CLASS_UPPER "[:upper:]" 426 #define CLASS_XDIGIT "[:xdigit:]" 427 428 /* 429 * SPECIFIERS: 430 * 431 * 432 * a Hex-float 433 * A Hex-float 434 * c Character 435 * C Widechar character (wint_t) 436 * d Decimal 437 * e Float 438 * E Float 439 * F Float 440 * F Float 441 * g Float 442 * G Float 443 * i Integer 444 * m Error message 445 * n Count 446 * o Octal 447 * p Pointer 448 * s String 449 * S Widechar string (wchar_t *) 450 * u Unsigned 451 * x Hex 452 * X Hex 453 * [] Group 454 * <> User-defined 455 * 456 * Reserved: 457 * 458 * D Binary Coded Decimal %D(length,precision) (OS/390) 459 */ 460 #define SPECIFIER_CHAR 'c' 461 #define SPECIFIER_STRING 's' 462 #define SPECIFIER_DECIMAL 'd' 463 #define SPECIFIER_INTEGER 'i' 464 #define SPECIFIER_UNSIGNED 'u' 465 #define SPECIFIER_OCTAL 'o' 466 #define SPECIFIER_HEX 'x' 467 #define SPECIFIER_HEX_UPPER 'X' 468 #define SPECIFIER_FLOAT_E 'e' 469 #define SPECIFIER_FLOAT_E_UPPER 'E' 470 #define SPECIFIER_FLOAT_F 'f' 471 #define SPECIFIER_FLOAT_F_UPPER 'F' 472 #define SPECIFIER_FLOAT_G 'g' 473 #define SPECIFIER_FLOAT_G_UPPER 'G' 474 #define SPECIFIER_POINTER 'p' 475 #define SPECIFIER_GROUP '[' 476 #define SPECIFIER_UNGROUP ']' 477 #define SPECIFIER_COUNT 'n' 478 #if TRIO_UNIX98 479 # define SPECIFIER_CHAR_UPPER 'C' 480 # define SPECIFIER_STRING_UPPER 'S' 481 #endif 482 #if TRIO_C99 483 # define SPECIFIER_HEXFLOAT 'a' 484 # define SPECIFIER_HEXFLOAT_UPPER 'A' 485 #endif 486 #if TRIO_GNU 487 # define SPECIFIER_ERRNO 'm' 488 #endif 489 #if TRIO_EXTENSION 490 # define SPECIFIER_BINARY 'b' 491 # define SPECIFIER_BINARY_UPPER 'B' 492 # define SPECIFIER_USER_DEFINED_BEGIN '<' 493 # define SPECIFIER_USER_DEFINED_END '>' 494 # define SPECIFIER_USER_DEFINED_SEPARATOR ':' 495 #endif 496 497 /* 498 * QUALIFIERS: 499 * 500 * 501 * Numbers = d,i,o,u,x,X 502 * Float = a,A,e,E,f,F,g,G 503 * String = s 504 * Char = c 505 * 506 * 507 * 9$ Position 508 * Use the 9th parameter. 9 can be any number between 1 and 509 * the maximal argument 510 * 511 * 9 Width 512 * Set width to 9. 9 can be any number, but must not be postfixed 513 * by '$' 514 * 515 * h Short 516 * Numbers: 517 * (unsigned) short int 518 * 519 * hh Short short 520 * Numbers: 521 * (unsigned) char 522 * 523 * l Long 524 * Numbers: 525 * (unsigned) long int 526 * String: 527 * as the S specifier 528 * Char: 529 * as the C specifier 530 * 531 * ll Long Long 532 * Numbers: 533 * (unsigned) long long int 534 * 535 * L Long Double 536 * Float 537 * long double 538 * 539 * # Alternative 540 * Float: 541 * Decimal-point is always present 542 * String: 543 * non-printable characters are handled as \number 544 * 545 * Spacing 546 * 547 * + Sign 548 * 549 * - Alignment 550 * 551 * . Precision 552 * 553 * * Parameter 554 * print: use parameter 555 * scan: no parameter (ignore) 556 * 557 * q Quad 558 * 559 * Z size_t 560 * 561 * w Widechar 562 * 563 * ' Thousands/quote 564 * Numbers: 565 * Integer part grouped in thousands 566 * Binary numbers: 567 * Number grouped in nibbles (4 bits) 568 * String: 569 * Quoted string 570 * 571 * j intmax_t 572 * t prtdiff_t 573 * z size_t 574 * 575 * ! Sticky 576 * @ Parameter (for both print and scan) 577 * 578 * I n-bit Integer 579 * Numbers: 580 * The following options exists 581 * I8 = 8-bit integer 582 * I16 = 16-bit integer 583 * I32 = 32-bit integer 584 * I64 = 64-bit integer 585 */ 586 #define QUALIFIER_POSITION '$' 587 #define QUALIFIER_SHORT 'h' 588 #define QUALIFIER_LONG 'l' 589 #define QUALIFIER_LONG_UPPER 'L' 590 #define QUALIFIER_ALTERNATIVE '#' 591 #define QUALIFIER_SPACE ' ' 592 #define QUALIFIER_PLUS '+' 593 #define QUALIFIER_MINUS '-' 594 #define QUALIFIER_DOT '.' 595 #define QUALIFIER_STAR '*' 596 #define QUALIFIER_CIRCUMFLEX '^' /* For scanlists */ 597 #if TRIO_C99 598 # define QUALIFIER_SIZE_T 'z' 599 # define QUALIFIER_PTRDIFF_T 't' 600 # define QUALIFIER_INTMAX_T 'j' 601 #endif 602 #if TRIO_BSD || TRIO_GNU 603 # define QUALIFIER_QUAD 'q' 604 #endif 605 #if TRIO_GNU 606 # define QUALIFIER_SIZE_T_UPPER 'Z' 607 #endif 608 #if TRIO_MISC 609 # define QUALIFIER_WIDECHAR 'w' 610 #endif 611 #if TRIO_MICROSOFT 612 # define QUALIFIER_FIXED_SIZE 'I' 613 #endif 614 #if TRIO_EXTENSION 615 # define QUALIFIER_QUOTE '\'' 616 # define QUALIFIER_STICKY '!' 617 # define QUALIFIER_VARSIZE '&' /* This should remain undocumented */ 618 # define QUALIFIER_PARAM '@' /* Experimental */ 619 # define QUALIFIER_COLON ':' /* For scanlists */ 620 # define QUALIFIER_EQUAL '=' /* For scanlists */ 621 # define QUALIFIER_ROUNDING_UPPER 'R' 622 #endif 623 624 625 /************************************************************************* 626 * 627 * Internal Structures 628 * 629 *************************************************************************/ 630 631 /* Parameters */ 632 typedef struct { 633 /* An indication of which entry in the data union is used */ 634 int type; 635 /* The flags */ 636 trio_flags_t flags; 637 /* The width qualifier */ 638 int width; 639 /* The precision qualifier */ 640 int precision; 641 /* The base qualifier */ 642 int base; 643 /* The size for the variable size qualifier */ 644 int varsize; 645 /* The marker of the end of the specifier */ 646 int indexAfterSpecifier; 647 /* The data from the argument list */ 648 union { 649 char *string; 650 #if TRIO_WIDECHAR 651 trio_wchar_t *wstring; 652 #endif 653 trio_pointer_t pointer; 654 union { 655 trio_intmax_t as_signed; 656 trio_uintmax_t as_unsigned; 657 } number; 658 double doubleNumber; 659 double *doublePointer; 660 trio_long_double_t longdoubleNumber; 661 trio_long_double_t *longdoublePointer; 662 int errorNumber; 663 } data; 664 /* For the user-defined specifier */ 665 char user_name[MAX_USER_NAME]; 666 char user_data[MAX_USER_DATA]; 667 } trio_parameter_t; 668 669 /* Container for customized functions */ 670 typedef struct { 671 union { 672 trio_outstream_t out; 673 trio_instream_t in; 674 } stream; 675 trio_pointer_t closure; 676 } trio_custom_t; 677 678 /* General trio "class" */ 679 typedef struct _trio_class_t { 680 /* 681 * The function to write characters to a stream. 682 */ 683 void (*OutStream) TRIO_PROTO((struct _trio_class_t *, int)); 684 /* 685 * The function to read characters from a stream. 686 */ 687 void (*InStream) TRIO_PROTO((struct _trio_class_t *, int *)); 688 /* 689 * The current location in the stream. 690 */ 691 trio_pointer_t location; 692 /* 693 * The character currently being processed. 694 */ 695 int current; 696 /* 697 * The number of characters that would have been written/read 698 * if there had been sufficient space. 699 */ 700 int processed; 701 /* 702 * The number of characters that are actually written/read. 703 * Processed and committed will only differ for the *nprintf 704 * and *nscanf functions. 705 */ 706 int committed; 707 /* 708 * The upper limit of characters that may be written/read. 709 */ 710 int max; 711 /* 712 * The last output error that was detected. 713 */ 714 int error; 715 } trio_class_t; 716 717 /* References (for user-defined callbacks) */ 718 typedef struct _trio_reference_t { 719 trio_class_t *data; 720 trio_parameter_t *parameter; 721 } trio_reference_t; 722 723 /* Registered entries (for user-defined callbacks) */ 724 typedef struct _trio_userdef_t { 725 struct _trio_userdef_t *next; 726 trio_callback_t callback; 727 char *name; 728 } trio_userdef_t; 729 730 /************************************************************************* 731 * 732 * Internal Variables 733 * 734 *************************************************************************/ 735 736 static TRIO_CONST char rcsid[] = "@(#)$Id$"; 737 738 /* 739 * Need this to workaround a parser bug in HP C/iX compiler that fails 740 * to resolves macro definitions that includes type 'long double', 741 * e.g: va_arg(arg_ptr, long double) 742 */ 743 #if defined(TRIO_PLATFORM_MPEIX) 744 static TRIO_CONST trio_long_double_t ___dummy_long_double = 0; 745 #endif 746 747 static TRIO_CONST char internalNullString[] = "(nil)"; 748 749 #if defined(USE_LOCALE) 750 static struct lconv *internalLocaleValues = NULL; 751 #endif 752 753 /* 754 * UNIX98 says "in a locale where the radix character is not defined, 755 * the radix character defaults to a period (.)" 756 */ 757 static int internalDecimalPointLength = 1; 758 static int internalThousandSeparatorLength = 1; 759 static char internalDecimalPoint = '.'; 760 static char internalDecimalPointString[MAX_LOCALE_SEPARATOR_LENGTH + 1] = "."; 761 static char internalThousandSeparator[MAX_LOCALE_SEPARATOR_LENGTH + 1] = ","; 762 static char internalGrouping[MAX_LOCALE_GROUPS] = { (char)NO_GROUPING }; 763 764 static TRIO_CONST char internalDigitsLower[] = "0123456789abcdefghijklmnopqrstuvwxyz"; 765 static TRIO_CONST char internalDigitsUpper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 766 static BOOLEAN_T internalDigitsUnconverted = TRUE; 767 static int internalDigitArray[128]; 768 #if TRIO_EXTENSION 769 static BOOLEAN_T internalCollationUnconverted = TRUE; 770 static char internalCollationArray[MAX_CHARACTER_CLASS][MAX_CHARACTER_CLASS]; 771 #endif 772 773 #if TRIO_EXTENSION 774 static TRIO_VOLATILE trio_callback_t internalEnterCriticalRegion = NULL; 775 static TRIO_VOLATILE trio_callback_t internalLeaveCriticalRegion = NULL; 776 static trio_userdef_t *internalUserDef = NULL; 777 #endif 778 779 780 /************************************************************************* 781 * 782 * Internal Functions 783 * 784 ************************************************************************/ 785 786 #if defined(TRIO_MINIMAL) 787 # define TRIO_STRING_PUBLIC static 788 # include "triostr.c" 789 #endif /* defined(TRIO_MINIMAL) */ 790 791 /************************************************************************* 792 * TrioIsQualifier 793 * 794 * Description: 795 * Remember to add all new qualifiers to this function. 796 * QUALIFIER_POSITION must not be added. 797 */ 798 TRIO_PRIVATE BOOLEAN_T 799 TrioIsQualifier 800 TRIO_ARGS1((character), 801 TRIO_CONST char character) 802 { 803 /* QUALIFIER_POSITION is not included */ 804 switch (character) 805 { 806 case '0': case '1': case '2': case '3': case '4': 807 case '5': case '6': case '7': case '8': case '9': 808 case QUALIFIER_PLUS: 809 case QUALIFIER_MINUS: 810 case QUALIFIER_SPACE: 811 case QUALIFIER_DOT: 812 case QUALIFIER_STAR: 813 case QUALIFIER_ALTERNATIVE: 814 case QUALIFIER_SHORT: 815 case QUALIFIER_LONG: 816 case QUALIFIER_LONG_UPPER: 817 case QUALIFIER_CIRCUMFLEX: 818 #if defined(QUALIFIER_SIZE_T) 819 case QUALIFIER_SIZE_T: 820 #endif 821 #if defined(QUALIFIER_PTRDIFF_T) 822 case QUALIFIER_PTRDIFF_T: 823 #endif 824 #if defined(QUALIFIER_INTMAX_T) 825 case QUALIFIER_INTMAX_T: 826 #endif 827 #if defined(QUALIFIER_QUAD) 828 case QUALIFIER_QUAD: 829 #endif 830 #if defined(QUALIFIER_SIZE_T_UPPER) 831 case QUALIFIER_SIZE_T_UPPER: 832 #endif 833 #if defined(QUALIFIER_WIDECHAR) 834 case QUALIFIER_WIDECHAR: 835 #endif 836 #if defined(QUALIFIER_QUOTE) 837 case QUALIFIER_QUOTE: 838 #endif 839 #if defined(QUALIFIER_STICKY) 840 case QUALIFIER_STICKY: 841 #endif 842 #if defined(QUALIFIER_VARSIZE) 843 case QUALIFIER_VARSIZE: 844 #endif 845 #if defined(QUALIFIER_PARAM) 846 case QUALIFIER_PARAM: 847 #endif 848 #if defined(QUALIFIER_FIXED_SIZE) 849 case QUALIFIER_FIXED_SIZE: 850 #endif 851 #if defined(QUALIFIER_ROUNDING_UPPER) 852 case QUALIFIER_ROUNDING_UPPER: 853 #endif 854 return TRUE; 855 default: 856 return FALSE; 857 } 858 } 859 860 /************************************************************************* 861 * TrioSetLocale 862 */ 863 #if defined(USE_LOCALE) 864 TRIO_PRIVATE void 865 TrioSetLocale(TRIO_NOARGS) 866 { 867 internalLocaleValues = (struct lconv *)localeconv(); 868 if (internalLocaleValues) 869 { 870 if ((internalLocaleValues->decimal_point) && 871 (internalLocaleValues->decimal_point[0] != NIL)) 872 { 873 internalDecimalPointLength = trio_length(internalLocaleValues->decimal_point); 874 if (internalDecimalPointLength == 1) 875 { 876 internalDecimalPoint = internalLocaleValues->decimal_point[0]; 877 } 878 else 879 { 880 internalDecimalPoint = NIL; 881 trio_copy_max(internalDecimalPointString, 882 sizeof(internalDecimalPointString), 883 internalLocaleValues->decimal_point); 884 } 885 } 886 if ((internalLocaleValues->thousands_sep) && 887 (internalLocaleValues->thousands_sep[0] != NIL)) 888 { 889 trio_copy_max(internalThousandSeparator, 890 sizeof(internalThousandSeparator), 891 internalLocaleValues->thousands_sep); 892 internalThousandSeparatorLength = trio_length(internalThousandSeparator); 893 } 894 if ((internalLocaleValues->grouping) && 895 (internalLocaleValues->grouping[0] != NIL)) 896 { 897 trio_copy_max(internalGrouping, 898 sizeof(internalGrouping), 899 internalLocaleValues->grouping); 900 } 901 } 902 } 903 #endif /* defined(USE_LOCALE) */ 904 905 TRIO_PRIVATE int 906 TrioCalcThousandSeparatorLength 907 TRIO_ARGS1((digits), 908 int digits) 909 { 910 #if TRIO_EXTENSION 911 int count = 0; 912 int step = NO_GROUPING; 913 char *groupingPointer = internalGrouping; 914 915 while (digits > 0) 916 { 917 if (*groupingPointer == CHAR_MAX) 918 { 919 /* Disable grouping */ 920 break; /* while */ 921 } 922 else if (*groupingPointer == 0) 923 { 924 /* Repeat last group */ 925 if (step == NO_GROUPING) 926 { 927 /* Error in locale */ 928 break; /* while */ 929 } 930 } 931 else 932 { 933 step = *groupingPointer++; 934 } 935 if (digits > step) 936 count += internalThousandSeparatorLength; 937 digits -= step; 938 } 939 return count; 940 #else 941 return 0; 942 #endif 943 } 944 945 TRIO_PRIVATE BOOLEAN_T 946 TrioFollowedBySeparator 947 TRIO_ARGS1((position), 948 int position) 949 { 950 #if TRIO_EXTENSION 951 int step = 0; 952 char *groupingPointer = internalGrouping; 953 954 position--; 955 if (position == 0) 956 return FALSE; 957 while (position > 0) 958 { 959 if (*groupingPointer == CHAR_MAX) 960 { 961 /* Disable grouping */ 962 break; /* while */ 963 } 964 else if (*groupingPointer != 0) 965 { 966 step = *groupingPointer++; 967 } 968 if (step == 0) 969 break; 970 position -= step; 971 } 972 return (position == 0); 973 #else 974 return FALSE; 975 #endif 976 } 977 978 /************************************************************************* 979 * TrioGetPosition 980 * 981 * Get the %n$ position. 982 */ 983 TRIO_PRIVATE int 984 TrioGetPosition 985 TRIO_ARGS2((format, indexPointer), 986 TRIO_CONST char *format, 987 int *indexPointer) 988 { 989 #if TRIO_UNIX98 990 char *tmpformat; 991 int number = 0; 992 int index = *indexPointer; 993 994 number = (int)trio_to_long(&format[index], &tmpformat, BASE_DECIMAL); 995 index = (int)(tmpformat - format); 996 if ((number != 0) && (QUALIFIER_POSITION == format[index++])) 997 { 998 *indexPointer = index; 999 /* 1000 * number is decreased by 1, because n$ starts from 1, whereas 1001 * the array it is indexing starts from 0. 1002 */ 1003 return number - 1; 1004 } 1005 #endif 1006 return NO_POSITION; 1007 } 1008 1009 #if TRIO_EXTENSION 1010 /************************************************************************* 1011 * TrioFindNamespace 1012 * 1013 * Find registered user-defined specifier. 1014 * The prev argument is used for optimization only. 1015 */ 1016 TRIO_PRIVATE trio_userdef_t * 1017 TrioFindNamespace 1018 TRIO_ARGS2((name, prev), 1019 TRIO_CONST char *name, 1020 trio_userdef_t **prev) 1021 { 1022 trio_userdef_t *def; 1023 1024 if (internalEnterCriticalRegion) 1025 (void)internalEnterCriticalRegion(NULL); 1026 1027 for (def = internalUserDef; def; def = def->next) 1028 { 1029 /* Case-sensitive string comparison */ 1030 if (trio_equal_case(def->name, name)) 1031 break; 1032 1033 if (prev) 1034 *prev = def; 1035 } 1036 1037 if (internalLeaveCriticalRegion) 1038 (void)internalLeaveCriticalRegion(NULL); 1039 1040 return def; 1041 } 1042 #endif 1043 1044 /************************************************************************* 1045 * TrioPower 1046 * 1047 * Description: 1048 * Calculate pow(base, exponent), where number and exponent are integers. 1049 */ 1050 TRIO_PRIVATE trio_long_double_t 1051 TrioPower 1052 TRIO_ARGS2((number, exponent), 1053 int number, 1054 int exponent) 1055 { 1056 trio_long_double_t result; 1057 1058 if (number == 10) 1059 { 1060 switch (exponent) 1061 { 1062 /* Speed up calculation of common cases */ 1063 case 0: 1064 result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E-1); 1065 break; 1066 case 1: 1067 result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+0); 1068 break; 1069 case 2: 1070 result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+1); 1071 break; 1072 case 3: 1073 result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+2); 1074 break; 1075 case 4: 1076 result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+3); 1077 break; 1078 case 5: 1079 result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+4); 1080 break; 1081 case 6: 1082 result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+5); 1083 break; 1084 case 7: 1085 result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+6); 1086 break; 1087 case 8: 1088 result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+7); 1089 break; 1090 case 9: 1091 result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+8); 1092 break; 1093 default: 1094 result = powl((trio_long_double_t)number, 1095 (trio_long_double_t)exponent); 1096 break; 1097 } 1098 } 1099 else 1100 { 1101 return powl((trio_long_double_t)number, (trio_long_double_t)exponent); 1102 } 1103 return result; 1104 } 1105 1106 /************************************************************************* 1107 * TrioLogarithm 1108 */ 1109 TRIO_PRIVATE double 1110 TrioLogarithm 1111 TRIO_ARGS2((number, base), 1112 double number, 1113 int base) 1114 { 1115 double result; 1116 1117 if (number <= 0.0) 1118 { 1119 /* xlC crashes on log(0) */ 1120 result = (number == 0.0) ? trio_ninf() : trio_nan(); 1121 } 1122 else 1123 { 1124 if (base == 10) 1125 { 1126 result = log10(number); 1127 } 1128 else 1129 { 1130 result = log10(number) / log10((double)base); 1131 } 1132 } 1133 return result; 1134 } 1135 1136 /************************************************************************* 1137 * TrioLogarithmBase 1138 */ 1139 TRIO_PRIVATE double 1140 TrioLogarithmBase 1141 TRIO_ARGS1((base), 1142 int base) 1143 { 1144 switch (base) 1145 { 1146 case BASE_BINARY : return 1.0; 1147 case BASE_OCTAL : return 3.0; 1148 case BASE_DECIMAL: return 3.321928094887362345; 1149 case BASE_HEX : return 4.0; 1150 default : return TrioLogarithm((double)base, 2); 1151 } 1152 } 1153 1154 /************************************************************************* 1155 * TrioParse 1156 * 1157 * Description: 1158 * Parse the format string 1159 */ 1160 TRIO_PRIVATE int 1161 TrioParse 1162 TRIO_ARGS5((type, format, parameters, arglist, argarray), 1163 int type, 1164 TRIO_CONST char *format, 1165 trio_parameter_t *parameters, 1166 va_list *arglist, 1167 trio_pointer_t *argarray) 1168 { 1169 /* Count the number of times a parameter is referenced */ 1170 unsigned short usedEntries[MAX_PARAMETERS]; 1171 /* Parameter counters */ 1172 int parameterPosition; 1173 int currentParam; 1174 int maxParam = -1; 1175 /* Utility variables */ 1176 trio_flags_t flags; 1177 int width; 1178 int precision; 1179 int varsize; 1180 int base; 1181 int index; /* Index into formatting string */ 1182 int dots; /* Count number of dots in modifier part */ 1183 BOOLEAN_T positional; /* Does the specifier have a positional? */ 1184 BOOLEAN_T gotSticky = FALSE; /* Are there any sticky modifiers at all? */ 1185 /* 1186 * indices specifies the order in which the parameters must be 1187 * read from the va_args (this is necessary to handle positionals) 1188 */ 1189 int indices[MAX_PARAMETERS]; 1190 int pos = 0; 1191 /* Various variables */ 1192 char ch; 1193 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) 1194 int charlen; 1195 #endif 1196 int save_errno; 1197 int i = -1; 1198 int num; 1199 char *tmpformat; 1200 1201 /* One and only one of arglist and argarray must be used */ 1202 assert((arglist != NULL) ^ (argarray != NULL)); 1203 1204 /* 1205 * The 'parameters' array is not initialized, but we need to 1206 * know which entries we have used. 1207 */ 1208 memset(usedEntries, 0, sizeof(usedEntries)); 1209 1210 save_errno = errno; 1211 index = 0; 1212 parameterPosition = 0; 1213 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) 1214 (void)mblen(NULL, 0); 1215 #endif 1216 1217 while (format[index]) 1218 { 1219 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) 1220 if (! isascii(format[index])) 1221 { 1222 /* 1223 * Multibyte characters cannot be legal specifiers or 1224 * modifiers, so we skip over them. 1225 */ 1226 charlen = mblen(&format[index], MB_LEN_MAX); 1227 index += (charlen > 0) ? charlen : 1; 1228 continue; /* while */ 1229 } 1230 #endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */ 1231 if (CHAR_IDENTIFIER == format[index++]) 1232 { 1233 if (CHAR_IDENTIFIER == format[index]) 1234 { 1235 index++; 1236 continue; /* while */ 1237 } 1238 1239 flags = FLAGS_NEW; 1240 dots = 0; 1241 currentParam = TrioGetPosition(format, &index); 1242 positional = (NO_POSITION != currentParam); 1243 if (!positional) 1244 { 1245 /* We have no positional, get the next counter */ 1246 currentParam = parameterPosition; 1247 } 1248 if(currentParam >= MAX_PARAMETERS) 1249 { 1250 /* Bail out completely to make the error more obvious */ 1251 return TRIO_ERROR_RETURN(TRIO_ETOOMANY, index); 1252 } 1253 1254 if (currentParam > maxParam) 1255 maxParam = currentParam; 1256 1257 /* Default values */ 1258 width = NO_WIDTH; 1259 precision = NO_PRECISION; 1260 base = NO_BASE; 1261 varsize = NO_SIZE; 1262 1263 while (TrioIsQualifier(format[index])) 1264 { 1265 ch = format[index++]; 1266 1267 switch (ch) 1268 { 1269 case QUALIFIER_SPACE: 1270 flags |= FLAGS_SPACE; 1271 break; 1272 1273 case QUALIFIER_PLUS: 1274 flags |= FLAGS_SHOWSIGN; 1275 break; 1276 1277 case QUALIFIER_MINUS: 1278 flags |= FLAGS_LEFTADJUST; 1279 flags &= ~FLAGS_NILPADDING; 1280 break; 1281 1282 case QUALIFIER_ALTERNATIVE: 1283 flags |= FLAGS_ALTERNATIVE; 1284 break; 1285 1286 case QUALIFIER_DOT: 1287 if (dots == 0) /* Precision */ 1288 { 1289 dots++; 1290 1291 /* Skip if no precision */ 1292 if (QUALIFIER_DOT == format[index]) 1293 break; 1294 1295 /* After the first dot we have the precision */ 1296 flags |= FLAGS_PRECISION; 1297 if ((QUALIFIER_STAR == format[index]) 1298 #if defined(QUALIFIER_PARAM) 1299 || (QUALIFIER_PARAM == format[index]) 1300 #endif 1301 ) 1302 { 1303 index++; 1304 flags |= FLAGS_PRECISION_PARAMETER; 1305 1306 precision = TrioGetPosition(format, &index); 1307 if (precision == NO_POSITION) 1308 { 1309 parameterPosition++; 1310 if (positional) 1311 precision = parameterPosition; 1312 else 1313 { 1314 precision = currentParam; 1315 currentParam = precision + 1; 1316 } 1317 } 1318 else 1319 { 1320 if (! positional) 1321 currentParam = precision + 1; 1322 if (width > maxParam) 1323 maxParam = precision; 1324 } 1325 if (currentParam > maxParam) 1326 maxParam = currentParam; 1327 } 1328 else 1329 { 1330 precision = trio_to_long(&format[index], 1331 &tmpformat, 1332 BASE_DECIMAL); 1333 index = (int)(tmpformat - format); 1334 } 1335 } 1336 else if (dots == 1) /* Base */ 1337 { 1338 dots++; 1339 1340 /* After the second dot we have the base */ 1341 flags |= FLAGS_BASE; 1342 if ((QUALIFIER_STAR == format[index]) 1343 #if defined(QUALIFIER_PARAM) 1344 || (QUALIFIER_PARAM == format[index]) 1345 #endif 1346 ) 1347 { 1348 index++; 1349 flags |= FLAGS_BASE_PARAMETER; 1350 base = TrioGetPosition(format, &index); 1351 if (base == NO_POSITION) 1352 { 1353 parameterPosition++; 1354 if (positional) 1355 base = parameterPosition; 1356 else 1357 { 1358 base = currentParam; 1359 currentParam = base + 1; 1360 } 1361 } 1362 else 1363 { 1364 if (! positional) 1365 currentParam = base + 1; 1366 if (base > maxParam) 1367 maxParam = base; 1368 } 1369 if (currentParam > maxParam) 1370 maxParam = currentParam; 1371 } 1372 else 1373 { 1374 base = trio_to_long(&format[index], 1375 &tmpformat, 1376 BASE_DECIMAL); 1377 if (base > MAX_BASE) 1378 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 1379 index = (int)(tmpformat - format); 1380 } 1381 } 1382 else 1383 { 1384 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 1385 } 1386 break; /* QUALIFIER_DOT */ 1387 1388 #if defined(QUALIFIER_PARAM) 1389 case QUALIFIER_PARAM: 1390 type = TYPE_PRINT; 1391 /* FALLTHROUGH */ 1392 #endif 1393 case QUALIFIER_STAR: 1394 /* This has different meanings for print and scan */ 1395 if (TYPE_PRINT == type) 1396 { 1397 /* Read with from parameter */ 1398 flags |= (FLAGS_WIDTH | FLAGS_WIDTH_PARAMETER); 1399 width = TrioGetPosition(format, &index); 1400 if (width == NO_POSITION) 1401 { 1402 parameterPosition++; 1403 if (positional) 1404 width = parameterPosition; 1405 else 1406 { 1407 width = currentParam; 1408 currentParam = width + 1; 1409 } 1410 } 1411 else 1412 { 1413 if (! positional) 1414 currentParam = width + 1; 1415 if (width > maxParam) 1416 maxParam = width; 1417 } 1418 if (currentParam > maxParam) 1419 maxParam = currentParam; 1420 } 1421 else 1422 { 1423 /* Scan, but do not store result */ 1424 flags |= FLAGS_IGNORE; 1425 } 1426 1427 break; /* QUALIFIER_STAR */ 1428 1429 case '0': 1430 if (! (flags & FLAGS_LEFTADJUST)) 1431 flags |= FLAGS_NILPADDING; 1432 /* FALLTHROUGH */ 1433 case '1': case '2': case '3': case '4': 1434 case '5': case '6': case '7': case '8': case '9': 1435 flags |= FLAGS_WIDTH; 1436 /* &format[index - 1] is used to "rewind" the read 1437 * character from format 1438 */ 1439 width = trio_to_long(&format[index - 1], 1440 &tmpformat, 1441 BASE_DECIMAL); 1442 index = (int)(tmpformat - format); 1443 break; 1444 1445 case QUALIFIER_SHORT: 1446 if (flags & FLAGS_SHORTSHORT) 1447 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 1448 else if (flags & FLAGS_SHORT) 1449 flags |= FLAGS_SHORTSHORT; 1450 else 1451 flags |= FLAGS_SHORT; 1452 break; 1453 1454 case QUALIFIER_LONG: 1455 if (flags & FLAGS_QUAD) 1456 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 1457 else if (flags & FLAGS_LONG) 1458 flags |= FLAGS_QUAD; 1459 else 1460 flags |= FLAGS_LONG; 1461 break; 1462 1463 case QUALIFIER_LONG_UPPER: 1464 flags |= FLAGS_LONGDOUBLE; 1465 break; 1466 1467 #if defined(QUALIFIER_SIZE_T) 1468 case QUALIFIER_SIZE_T: 1469 flags |= FLAGS_SIZE_T; 1470 /* Modify flags for later truncation of number */ 1471 if (sizeof(size_t) == sizeof(trio_ulonglong_t)) 1472 flags |= FLAGS_QUAD; 1473 else if (sizeof(size_t) == sizeof(long)) 1474 flags |= FLAGS_LONG; 1475 break; 1476 #endif 1477 1478 #if defined(QUALIFIER_PTRDIFF_T) 1479 case QUALIFIER_PTRDIFF_T: 1480 flags |= FLAGS_PTRDIFF_T; 1481 if (sizeof(ptrdiff_t) == sizeof(trio_ulonglong_t)) 1482 flags |= FLAGS_QUAD; 1483 else if (sizeof(ptrdiff_t) == sizeof(long)) 1484 flags |= FLAGS_LONG; 1485 break; 1486 #endif 1487 1488 #if defined(QUALIFIER_INTMAX_T) 1489 case QUALIFIER_INTMAX_T: 1490 flags |= FLAGS_INTMAX_T; 1491 if (sizeof(trio_intmax_t) == sizeof(trio_ulonglong_t)) 1492 flags |= FLAGS_QUAD; 1493 else if (sizeof(trio_intmax_t) == sizeof(long)) 1494 flags |= FLAGS_LONG; 1495 break; 1496 #endif 1497 1498 #if defined(QUALIFIER_QUAD) 1499 case QUALIFIER_QUAD: 1500 flags |= FLAGS_QUAD; 1501 break; 1502 #endif 1503 1504 #if defined(QUALIFIER_FIXED_SIZE) 1505 case QUALIFIER_FIXED_SIZE: 1506 if (flags & FLAGS_FIXED_SIZE) 1507 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 1508 1509 if (flags & (FLAGS_ALL_SIZES | FLAGS_LONGDOUBLE | 1510 FLAGS_WIDECHAR | FLAGS_VARSIZE_PARAMETER)) 1511 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 1512 1513 if ((format[index] == '6') && 1514 (format[index + 1] == '4')) 1515 { 1516 varsize = sizeof(trio_int64_t); 1517 index += 2; 1518 } 1519 else if ((format[index] == '3') && 1520 (format[index + 1] == '2')) 1521 { 1522 varsize = sizeof(trio_int32_t); 1523 index += 2; 1524 } 1525 else if ((format[index] == '1') && 1526 (format[index + 1] == '6')) 1527 { 1528 varsize = sizeof(trio_int16_t); 1529 index += 2; 1530 } 1531 else if (format[index] == '8') 1532 { 1533 varsize = sizeof(trio_int8_t); 1534 index++; 1535 } 1536 else 1537 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 1538 1539 flags |= FLAGS_FIXED_SIZE; 1540 break; 1541 #endif 1542 1543 #if defined(QUALIFIER_WIDECHAR) 1544 case QUALIFIER_WIDECHAR: 1545 flags |= FLAGS_WIDECHAR; 1546 break; 1547 #endif 1548 1549 #if defined(QUALIFIER_SIZE_T_UPPER) 1550 case QUALIFIER_SIZE_T_UPPER: 1551 break; 1552 #endif 1553 1554 #if defined(QUALIFIER_QUOTE) 1555 case QUALIFIER_QUOTE: 1556 flags |= FLAGS_QUOTE; 1557 break; 1558 #endif 1559 1560 #if defined(QUALIFIER_STICKY) 1561 case QUALIFIER_STICKY: 1562 flags |= FLAGS_STICKY; 1563 gotSticky = TRUE; 1564 break; 1565 #endif 1566 1567 #if defined(QUALIFIER_VARSIZE) 1568 case QUALIFIER_VARSIZE: 1569 flags |= FLAGS_VARSIZE_PARAMETER; 1570 parameterPosition++; 1571 if (positional) 1572 varsize = parameterPosition; 1573 else 1574 { 1575 varsize = currentParam; 1576 currentParam = varsize + 1; 1577 } 1578 if (currentParam > maxParam) 1579 maxParam = currentParam; 1580 break; 1581 #endif 1582 1583 #if defined(QUALIFIER_ROUNDING_UPPER) 1584 case QUALIFIER_ROUNDING_UPPER: 1585 flags |= FLAGS_ROUNDING; 1586 break; 1587 #endif 1588 1589 default: 1590 /* Bail out completely to make the error more obvious */ 1591 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 1592 } 1593 } /* while qualifier */ 1594 1595 /* 1596 * Parameters only need the type and value. The value is 1597 * read later. 1598 */ 1599 if (flags & FLAGS_WIDTH_PARAMETER) 1600 { 1601 usedEntries[width] += 1; 1602 parameters[pos].type = FORMAT_PARAMETER; 1603 parameters[pos].flags = 0; 1604 indices[width] = pos; 1605 width = pos++; 1606 } 1607 if (flags & FLAGS_PRECISION_PARAMETER) 1608 { 1609 usedEntries[precision] += 1; 1610 parameters[pos].type = FORMAT_PARAMETER; 1611 parameters[pos].flags = 0; 1612 indices[precision] = pos; 1613 precision = pos++; 1614 } 1615 if (flags & FLAGS_BASE_PARAMETER) 1616 { 1617 usedEntries[base] += 1; 1618 parameters[pos].type = FORMAT_PARAMETER; 1619 parameters[pos].flags = 0; 1620 indices[base] = pos; 1621 base = pos++; 1622 } 1623 if (flags & FLAGS_VARSIZE_PARAMETER) 1624 { 1625 usedEntries[varsize] += 1; 1626 parameters[pos].type = FORMAT_PARAMETER; 1627 parameters[pos].flags = 0; 1628 indices[varsize] = pos; 1629 varsize = pos++; 1630 } 1631 1632 indices[currentParam] = pos; 1633 1634 switch (format[index++]) 1635 { 1636 #if defined(SPECIFIER_CHAR_UPPER) 1637 case SPECIFIER_CHAR_UPPER: 1638 flags |= FLAGS_WIDECHAR; 1639 /* FALLTHROUGH */ 1640 #endif 1641 case SPECIFIER_CHAR: 1642 if (flags & FLAGS_LONG) 1643 flags |= FLAGS_WIDECHAR; 1644 else if (flags & FLAGS_SHORT) 1645 flags &= ~FLAGS_WIDECHAR; 1646 parameters[pos].type = FORMAT_CHAR; 1647 break; 1648 1649 #if defined(SPECIFIER_STRING_UPPER) 1650 case SPECIFIER_STRING_UPPER: 1651 flags |= FLAGS_WIDECHAR; 1652 /* FALLTHROUGH */ 1653 #endif 1654 case SPECIFIER_STRING: 1655 if (flags & FLAGS_LONG) 1656 flags |= FLAGS_WIDECHAR; 1657 else if (flags & FLAGS_SHORT) 1658 flags &= ~FLAGS_WIDECHAR; 1659 parameters[pos].type = FORMAT_STRING; 1660 break; 1661 1662 case SPECIFIER_GROUP: 1663 if (TYPE_SCAN == type) 1664 { 1665 int depth = 1; 1666 parameters[pos].type = FORMAT_GROUP; 1667 if (format[index] == QUALIFIER_CIRCUMFLEX) 1668 index++; 1669 if (format[index] == SPECIFIER_UNGROUP) 1670 index++; 1671 if (format[index] == QUALIFIER_MINUS) 1672 index++; 1673 /* Skip nested brackets */ 1674 while (format[index] != NIL) 1675 { 1676 if (format[index] == SPECIFIER_GROUP) 1677 { 1678 depth++; 1679 } 1680 else if (format[index] == SPECIFIER_UNGROUP) 1681 { 1682 if (--depth <= 0) 1683 { 1684 index++; 1685 break; 1686 } 1687 } 1688 index++; 1689 } 1690 } 1691 break; 1692 1693 case SPECIFIER_INTEGER: 1694 parameters[pos].type = FORMAT_INT; 1695 break; 1696 1697 case SPECIFIER_UNSIGNED: 1698 flags |= FLAGS_UNSIGNED; 1699 parameters[pos].type = FORMAT_INT; 1700 break; 1701 1702 case SPECIFIER_DECIMAL: 1703 /* Disable base modifier */ 1704 flags &= ~FLAGS_BASE_PARAMETER; 1705 base = BASE_DECIMAL; 1706 parameters[pos].type = FORMAT_INT; 1707 break; 1708 1709 case SPECIFIER_OCTAL: 1710 flags |= FLAGS_UNSIGNED; 1711 flags &= ~FLAGS_BASE_PARAMETER; 1712 base = BASE_OCTAL; 1713 parameters[pos].type = FORMAT_INT; 1714 break; 1715 1716 #if defined(SPECIFIER_BINARY) 1717 case SPECIFIER_BINARY_UPPER: 1718 flags |= FLAGS_UPPER; 1719 /* FALLTHROUGH */ 1720 case SPECIFIER_BINARY: 1721 flags |= FLAGS_NILPADDING; 1722 flags &= ~FLAGS_BASE_PARAMETER; 1723 base = BASE_BINARY; 1724 parameters[pos].type = FORMAT_INT; 1725 break; 1726 #endif 1727 1728 case SPECIFIER_HEX_UPPER: 1729 flags |= FLAGS_UPPER; 1730 /* FALLTHROUGH */ 1731 case SPECIFIER_HEX: 1732 flags |= FLAGS_UNSIGNED; 1733 flags &= ~FLAGS_BASE_PARAMETER; 1734 base = BASE_HEX; 1735 parameters[pos].type = FORMAT_INT; 1736 break; 1737 1738 case SPECIFIER_FLOAT_E_UPPER: 1739 flags |= FLAGS_UPPER; 1740 /* FALLTHROUGH */ 1741 case SPECIFIER_FLOAT_E: 1742 flags |= FLAGS_FLOAT_E; 1743 parameters[pos].type = FORMAT_DOUBLE; 1744 break; 1745 1746 case SPECIFIER_FLOAT_G_UPPER: 1747 flags |= FLAGS_UPPER; 1748 /* FALLTHROUGH */ 1749 case SPECIFIER_FLOAT_G: 1750 flags |= FLAGS_FLOAT_G; 1751 parameters[pos].type = FORMAT_DOUBLE; 1752 break; 1753 1754 case SPECIFIER_FLOAT_F_UPPER: 1755 flags |= FLAGS_UPPER; 1756 /* FALLTHROUGH */ 1757 case SPECIFIER_FLOAT_F: 1758 parameters[pos].type = FORMAT_DOUBLE; 1759 break; 1760 1761 case SPECIFIER_POINTER: 1762 if (sizeof(trio_pointer_t) == sizeof(trio_ulonglong_t)) 1763 flags |= FLAGS_QUAD; 1764 else if (sizeof(trio_pointer_t) == sizeof(long)) 1765 flags |= FLAGS_LONG; 1766 parameters[pos].type = FORMAT_POINTER; 1767 break; 1768 1769 case SPECIFIER_COUNT: 1770 parameters[pos].type = FORMAT_COUNT; 1771 break; 1772 1773 #if defined(SPECIFIER_HEXFLOAT) 1774 # if defined(SPECIFIER_HEXFLOAT_UPPER) 1775 case SPECIFIER_HEXFLOAT_UPPER: 1776 flags |= FLAGS_UPPER; 1777 /* FALLTHROUGH */ 1778 # endif 1779 case SPECIFIER_HEXFLOAT: 1780 base = BASE_HEX; 1781 parameters[pos].type = FORMAT_DOUBLE; 1782 break; 1783 #endif 1784 1785 #if defined(FORMAT_ERRNO) 1786 case SPECIFIER_ERRNO: 1787 parameters[pos].type = FORMAT_ERRNO; 1788 break; 1789 #endif 1790 1791 #if defined(SPECIFIER_USER_DEFINED_BEGIN) 1792 case SPECIFIER_USER_DEFINED_BEGIN: 1793 { 1794 unsigned int max; 1795 int without_namespace = TRUE; 1796 1797 parameters[pos].type = FORMAT_USER_DEFINED; 1798 parameters[pos].user_name[0] = NIL; 1799 tmpformat = (char *)&format[index]; 1800 1801 while ((ch = format[index])) 1802 { 1803 index++; 1804 if (ch == SPECIFIER_USER_DEFINED_END) 1805 { 1806 if (without_namespace) 1807 { 1808 /* We must get the handle first */ 1809 parameters[pos].type = FORMAT_PARAMETER; 1810 parameters[pos].indexAfterSpecifier = index; 1811 parameters[pos].flags = FLAGS_USER_DEFINED; 1812 /* Adjust parameters for insertion of new one */ 1813 pos++; 1814 usedEntries[currentParam] += 1; 1815 parameters[pos].type = FORMAT_USER_DEFINED; 1816 currentParam++; 1817 indices[currentParam] = pos; 1818 if (currentParam > maxParam) 1819 maxParam = currentParam; 1820 } 1821 /* Copy the user data */ 1822 max = (unsigned int)(&format[index] - tmpformat); 1823 if (max > MAX_USER_DATA) 1824 max = MAX_USER_DATA; 1825 trio_copy_max(parameters[pos].user_data, 1826 max, 1827 tmpformat); 1828 break; /* while */ 1829 } 1830 if (ch == SPECIFIER_USER_DEFINED_SEPARATOR) 1831 { 1832 without_namespace = FALSE; 1833 /* Copy the namespace for later looking-up */ 1834 max = (int)(&format[index] - tmpformat); 1835 if (max > MAX_USER_NAME) 1836 max = MAX_USER_NAME; 1837 trio_copy_max(parameters[pos].user_name, 1838 max, 1839 tmpformat); 1840 tmpformat = (char *)&format[index]; 1841 } 1842 } 1843 if (ch != SPECIFIER_USER_DEFINED_END) 1844 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 1845 } 1846 break; 1847 #endif /* defined(SPECIFIER_USER_DEFINED_BEGIN) */ 1848 1849 default: 1850 /* Bail out completely to make the error more obvious */ 1851 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 1852 } 1853 1854 /* Count the number of times this entry has been used */ 1855 usedEntries[currentParam] += 1; 1856 1857 /* Find last sticky parameters */ 1858 if (gotSticky && !(flags & FLAGS_STICKY)) 1859 { 1860 for (i = pos - 1; i >= 0; i--) 1861 { 1862 if (parameters[i].type == FORMAT_PARAMETER) 1863 continue; 1864 if ((parameters[i].flags & FLAGS_STICKY) && 1865 (parameters[i].type == parameters[pos].type)) 1866 { 1867 /* Do not overwrite current qualifiers */ 1868 flags |= (parameters[i].flags & (unsigned long)~FLAGS_STICKY); 1869 if (width == NO_WIDTH) 1870 width = parameters[i].width; 1871 if (precision == NO_PRECISION) 1872 precision = parameters[i].precision; 1873 if (base == NO_BASE) 1874 base = parameters[i].base; 1875 break; 1876 } 1877 } 1878 } 1879 1880 parameters[pos].indexAfterSpecifier = index; 1881 parameters[pos].flags = flags; 1882 parameters[pos].width = width; 1883 parameters[pos].precision = precision; 1884 parameters[pos].base = (base == NO_BASE) ? BASE_DECIMAL : base; 1885 parameters[pos].varsize = varsize; 1886 pos++; 1887 1888 if (! positional) 1889 parameterPosition++; 1890 1891 } /* if identifier */ 1892 1893 } /* while format characters left */ 1894 1895 for (num = 0; num <= maxParam; num++) 1896 { 1897 if (usedEntries[num] != 1) 1898 { 1899 if (usedEntries[num] == 0) /* gap detected */ 1900 return TRIO_ERROR_RETURN(TRIO_EGAP, num); 1901 else /* double references detected */ 1902 return TRIO_ERROR_RETURN(TRIO_EDBLREF, num); 1903 } 1904 1905 i = indices[num]; 1906 1907 /* 1908 * FORMAT_PARAMETERS are only present if they must be read, 1909 * so it makes no sense to check the ignore flag (besides, 1910 * the flags variable is not set for that particular type) 1911 */ 1912 if ((parameters[i].type != FORMAT_PARAMETER) && 1913 (parameters[i].flags & FLAGS_IGNORE)) 1914 continue; /* for all arguments */ 1915 1916 /* 1917 * The stack arguments are read according to ANSI C89 1918 * default argument promotions: 1919 * 1920 * char = int 1921 * short = int 1922 * unsigned char = unsigned int 1923 * unsigned short = unsigned int 1924 * float = double 1925 * 1926 * In addition to the ANSI C89 these types are read (the 1927 * default argument promotions of C99 has not been 1928 * considered yet) 1929 * 1930 * long long 1931 * long double 1932 * size_t 1933 * ptrdiff_t 1934 * intmax_t 1935 */ 1936 switch (parameters[i].type) 1937 { 1938 case FORMAT_GROUP: 1939 case FORMAT_STRING: 1940 #if TRIO_WIDECHAR 1941 if (flags & FLAGS_WIDECHAR) 1942 { 1943 parameters[i].data.wstring = (argarray == NULL) 1944 ? va_arg(*arglist, trio_wchar_t *) 1945 : (trio_wchar_t *)(argarray[num]); 1946 } 1947 else 1948 #endif 1949 { 1950 parameters[i].data.string = (argarray == NULL) 1951 ? va_arg(*arglist, char *) 1952 : (char *)(argarray[num]); 1953 } 1954 break; 1955 1956 #if defined(FORMAT_USER_DEFINED) 1957 case FORMAT_USER_DEFINED: 1958 #endif 1959 case FORMAT_POINTER: 1960 case FORMAT_COUNT: 1961 case FORMAT_UNKNOWN: 1962 parameters[i].data.pointer = (argarray == NULL) 1963 ? va_arg(*arglist, trio_pointer_t ) 1964 : argarray[num]; 1965 break; 1966 1967 case FORMAT_CHAR: 1968 case FORMAT_INT: 1969 if (TYPE_SCAN == type) 1970 { 1971 if (argarray == NULL) 1972 parameters[i].data.pointer = 1973 (trio_pointer_t)va_arg(*arglist, trio_pointer_t); 1974 else 1975 { 1976 if (parameters[i].type == FORMAT_CHAR) 1977 parameters[i].data.pointer = 1978 (trio_pointer_t)((char *)argarray[num]); 1979 else if (parameters[i].flags & FLAGS_SHORT) 1980 parameters[i].data.pointer = 1981 (trio_pointer_t)((short *)argarray[num]); 1982 else 1983 parameters[i].data.pointer = 1984 (trio_pointer_t)((int *)argarray[num]); 1985 } 1986 } 1987 else 1988 { 1989 #if defined(QUALIFIER_VARSIZE) || defined(QUALIFIER_FIXED_SIZE) 1990 if (parameters[i].flags 1991 & (FLAGS_VARSIZE_PARAMETER | FLAGS_FIXED_SIZE)) 1992 { 1993 if (parameters[i].flags & FLAGS_VARSIZE_PARAMETER) 1994 { 1995 /* 1996 * Variable sizes are mapped onto the fixed sizes, in 1997 * accordance with integer promotion. 1998 * 1999 * Please note that this may not be portable, as we 2000 * only guess the size, not the layout of the numbers. 2001 * For example, if int is little-endian, and long is 2002 * big-endian, then this will fail. 2003 */ 2004 varsize = (int)parameters[parameters[i].varsize].data.number.as_unsigned; 2005 } 2006 else 2007 { 2008 /* Used for the I<bits> modifiers */ 2009 varsize = parameters[i].varsize; 2010 } 2011 parameters[i].flags &= ~FLAGS_ALL_VARSIZES; 2012 2013 if (varsize <= (int)sizeof(int)) 2014 ; 2015 else if (varsize <= (int)sizeof(long)) 2016 parameters[i].flags |= FLAGS_LONG; 2017 #if defined(QUALIFIER_INTMAX_T) 2018 else if (varsize <= (int)sizeof(trio_longlong_t)) 2019 parameters[i].flags |= FLAGS_QUAD; 2020 else 2021 parameters[i].flags |= FLAGS_INTMAX_T; 2022 #else 2023 else 2024 parameters[i].flags |= FLAGS_QUAD; 2025 #endif 2026 } 2027 #endif /* defined(QUALIFIER_VARSIZE) */ 2028 #if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER) 2029 if (parameters[i].flags & FLAGS_SIZE_T) 2030 parameters[i].data.number.as_unsigned = (argarray == NULL) 2031 ? (trio_uintmax_t)va_arg(*arglist, size_t) 2032 : (trio_uintmax_t)(*((size_t *)argarray[num])); 2033 else 2034 #endif 2035 #if defined(QUALIFIER_PTRDIFF_T) 2036 if (parameters[i].flags & FLAGS_PTRDIFF_T) 2037 parameters[i].data.number.as_unsigned = (argarray == NULL) 2038 ? (trio_uintmax_t)va_arg(*arglist, ptrdiff_t) 2039 : (trio_uintmax_t)(*((ptrdiff_t *)argarray[num])); 2040 else 2041 #endif 2042 #if defined(QUALIFIER_INTMAX_T) 2043 if (parameters[i].flags & FLAGS_INTMAX_T) 2044 parameters[i].data.number.as_unsigned = (argarray == NULL) 2045 ? (trio_uintmax_t)va_arg(*arglist, trio_intmax_t) 2046 : (trio_uintmax_t)(*((trio_intmax_t *)argarray[num])); 2047 else 2048 #endif 2049 if (parameters[i].flags & FLAGS_QUAD) 2050 parameters[i].data.number.as_unsigned = (argarray == NULL) 2051 ? (trio_uintmax_t)va_arg(*arglist, trio_ulonglong_t) 2052 : (trio_uintmax_t)(*((trio_ulonglong_t *)argarray[num])); 2053 else if (parameters[i].flags & FLAGS_LONG) 2054 parameters[i].data.number.as_unsigned = (argarray == NULL) 2055 ? (trio_uintmax_t)va_arg(*arglist, long) 2056 : (trio_uintmax_t)(*((long *)argarray[num])); 2057 else 2058 { 2059 if (argarray == NULL) 2060 parameters[i].data.number.as_unsigned = (trio_uintmax_t)va_arg(*arglist, int); 2061 else 2062 { 2063 if (parameters[i].type == FORMAT_CHAR) 2064 parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((char *)argarray[num])); 2065 else if (parameters[i].flags & FLAGS_SHORT) 2066 parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((short *)argarray[num])); 2067 else 2068 parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((int *)argarray[num])); 2069 } 2070 } 2071 } 2072 break; 2073 2074 case FORMAT_PARAMETER: 2075 /* 2076 * The parameter for the user-defined specifier is a pointer, 2077 * whereas the rest (width, precision, base) uses an integer. 2078 */ 2079 if (parameters[i].flags & FLAGS_USER_DEFINED) 2080 parameters[i].data.pointer = (argarray == NULL) 2081 ? va_arg(*arglist, trio_pointer_t ) 2082 : argarray[num]; 2083 else 2084 parameters[i].data.number.as_unsigned = (argarray == NULL) 2085 ? (trio_uintmax_t)va_arg(*arglist, int) 2086 : (trio_uintmax_t)(*((int *)argarray[num])); 2087 break; 2088 2089 case FORMAT_DOUBLE: 2090 if (TYPE_SCAN == type) 2091 { 2092 if (parameters[i].flags & FLAGS_LONGDOUBLE) 2093 parameters[i].data.longdoublePointer = (argarray == NULL) 2094 ? va_arg(*arglist, trio_long_double_t *) 2095 : (trio_long_double_t *)argarray[num]; 2096 else 2097 { 2098 if (parameters[i].flags & FLAGS_LONG) 2099 parameters[i].data.doublePointer = (argarray == NULL) 2100 ? va_arg(*arglist, double *) 2101 : (double *)argarray[num]; 2102 else 2103 parameters[i].data.doublePointer = (argarray == NULL) 2104 ? (double *)va_arg(*arglist, float *) 2105 : (double *)((float *)argarray[num]); 2106 } 2107 } 2108 else 2109 { 2110 if (parameters[i].flags & FLAGS_LONGDOUBLE) 2111 parameters[i].data.longdoubleNumber = (argarray == NULL) 2112 ? va_arg(*arglist, trio_long_double_t) 2113 : (trio_long_double_t)(*((trio_long_double_t *)argarray[num])); 2114 else 2115 { 2116 if (argarray == NULL) 2117 parameters[i].data.longdoubleNumber = 2118 (trio_long_double_t)va_arg(*arglist, double); 2119 else 2120 { 2121 if (parameters[i].flags & FLAGS_SHORT) 2122 parameters[i].data.longdoubleNumber = 2123 (trio_long_double_t)(*((float *)argarray[num])); 2124 else 2125 parameters[i].data.longdoubleNumber = 2126 (trio_long_double_t)(*((double *)argarray[num])); 2127 } 2128 } 2129 } 2130 break; 2131 2132 #if defined(FORMAT_ERRNO) 2133 case FORMAT_ERRNO: 2134 parameters[i].data.errorNumber = save_errno; 2135 break; 2136 #endif 2137 2138 default: 2139 break; 2140 } 2141 } /* for all specifiers */ 2142 return num; 2143 } 2144 2145 2146 /************************************************************************* 2147 * 2148 * FORMATTING 2149 * 2150 ************************************************************************/ 2151 2152 2153 /************************************************************************* 2154 * TrioWriteNumber 2155 * 2156 * Description: 2157 * Output a number. 2158 * The complexity of this function is a result of the complexity 2159 * of the dependencies of the flags. 2160 */ 2161 TRIO_PRIVATE void 2162 TrioWriteNumber 2163 TRIO_ARGS6((self, number, flags, width, precision, base), 2164 trio_class_t *self, 2165 trio_uintmax_t number, 2166 trio_flags_t flags, 2167 int width, 2168 int precision, 2169 int base) 2170 { 2171 BOOLEAN_T isNegative; 2172 BOOLEAN_T isNumberZero; 2173 BOOLEAN_T isPrecisionZero; 2174 BOOLEAN_T ignoreNumber; 2175 char buffer[MAX_CHARS_IN(trio_uintmax_t) * (1 + MAX_LOCALE_SEPARATOR_LENGTH) + 1]; 2176 char *bufferend; 2177 char *pointer; 2178 TRIO_CONST char *digits; 2179 int i; 2180 int length; 2181 char *p; 2182 int count; 2183 2184 assert(VALID(self)); 2185 assert(VALID(self->OutStream)); 2186 assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE)); 2187 2188 digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower; 2189 if (base == NO_BASE) 2190 base = BASE_DECIMAL; 2191 2192 isNumberZero = (number == 0); 2193 isPrecisionZero = (precision == 0); 2194 ignoreNumber = (isNumberZero 2195 && isPrecisionZero 2196 && !((flags & FLAGS_ALTERNATIVE) && (base == BASE_OCTAL))); 2197 2198 if (flags & FLAGS_UNSIGNED) 2199 { 2200 isNegative = FALSE; 2201 flags &= ~FLAGS_SHOWSIGN; 2202 } 2203 else 2204 { 2205 isNegative = ((trio_intmax_t)number < 0); 2206 if (isNegative) 2207 number = -((trio_intmax_t)number); 2208 } 2209 2210 if (flags & FLAGS_QUAD) 2211 number &= (trio_ulonglong_t)-1; 2212 else if (flags & FLAGS_LONG) 2213 number &= (unsigned long)-1; 2214 else 2215 number &= (unsigned int)-1; 2216 2217 /* Build number */ 2218 pointer = bufferend = &buffer[sizeof(buffer) - 1]; 2219 *pointer-- = NIL; 2220 for (i = 1; i < (int)sizeof(buffer); i++) 2221 { 2222 *pointer-- = digits[number % base]; 2223 number /= base; 2224 if (number == 0) 2225 break; 2226 2227 if ((flags & FLAGS_QUOTE) && TrioFollowedBySeparator(i + 1)) 2228 { 2229 /* 2230 * We are building the number from the least significant 2231 * to the most significant digit, so we have to copy the 2232 * thousand separator backwards 2233 */ 2234 length = internalThousandSeparatorLength; 2235 if (((int)(pointer - buffer) - length) > 0) 2236 { 2237 p = &internalThousandSeparator[length - 1]; 2238 while (length-- > 0) 2239 *pointer-- = *p--; 2240 } 2241 } 2242 } 2243 2244 if (! ignoreNumber) 2245 { 2246 /* Adjust width */ 2247 width -= (bufferend - pointer) - 1; 2248 } 2249 2250 /* Adjust precision */ 2251 if (NO_PRECISION != precision) 2252 { 2253 precision -= (bufferend - pointer) - 1; 2254 if (precision < 0) 2255 precision = 0; 2256 flags |= FLAGS_NILPADDING; 2257 } 2258 2259 /* Calculate padding */ 2260 count = (! ((flags & FLAGS_LEFTADJUST) || (precision == NO_PRECISION))) 2261 ? precision 2262 : 0; 2263 2264 /* Adjust width further */ 2265 if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE)) 2266 width--; 2267 if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero) 2268 { 2269 switch (base) 2270 { 2271 case BASE_BINARY: 2272 case BASE_HEX: 2273 width -= 2; 2274 break; 2275 case BASE_OCTAL: 2276 if (!(flags & FLAGS_NILPADDING) || (count == 0)) 2277 width--; 2278 break; 2279 default: 2280 break; 2281 } 2282 } 2283 2284 /* Output prefixes spaces if needed */ 2285 if (! ((flags & FLAGS_LEFTADJUST) || 2286 ((flags & FLAGS_NILPADDING) && (precision == NO_PRECISION)))) 2287 { 2288 while (width-- > count) 2289 self->OutStream(self, CHAR_ADJUST); 2290 } 2291 2292 /* width has been adjusted for signs and alternatives */ 2293 if (isNegative) 2294 self->OutStream(self, '-'); 2295 else if (flags & FLAGS_SHOWSIGN) 2296 self->OutStream(self, '+'); 2297 else if (flags & FLAGS_SPACE) 2298 self->OutStream(self, ' '); 2299 2300 /* Prefix is not written when the value is zero */ 2301 if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero) 2302 { 2303 switch (base) 2304 { 2305 case BASE_BINARY: 2306 self->OutStream(self, '0'); 2307 self->OutStream(self, (flags & FLAGS_UPPER) ? 'B' : 'b'); 2308 break; 2309 2310 case BASE_OCTAL: 2311 if (!(flags & FLAGS_NILPADDING) || (count == 0)) 2312 self->OutStream(self, '0'); 2313 break; 2314 2315 case BASE_HEX: 2316 self->OutStream(self, '0'); 2317 self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x'); 2318 break; 2319 2320 default: 2321 break; 2322 } /* switch base */ 2323 } 2324 2325 /* Output prefixed zero padding if needed */ 2326 if (flags & FLAGS_NILPADDING) 2327 { 2328 if (precision == NO_PRECISION) 2329 precision = width; 2330 while (precision-- > 0) 2331 { 2332 self->OutStream(self, '0'); 2333 width--; 2334 } 2335 } 2336 2337 if (! ignoreNumber) 2338 { 2339 /* Output the number itself */ 2340 while (*(++pointer)) 2341 { 2342 self->OutStream(self, *pointer); 2343 } 2344 } 2345 2346 /* Output trailing spaces if needed */ 2347 if (flags & FLAGS_LEFTADJUST) 2348 { 2349 while (width-- > 0) 2350 self->OutStream(self, CHAR_ADJUST); 2351 } 2352 } 2353 2354 /************************************************************************* 2355 * TrioWriteStringCharacter 2356 * 2357 * Description: 2358 * Output a single character of a string 2359 */ 2360 TRIO_PRIVATE void 2361 TrioWriteStringCharacter 2362 TRIO_ARGS3((self, ch, flags), 2363 trio_class_t *self, 2364 int ch, 2365 trio_flags_t flags) 2366 { 2367 if (flags & FLAGS_ALTERNATIVE) 2368 { 2369 if (! isprint(ch)) 2370 { 2371 /* 2372 * Non-printable characters are converted to C escapes or 2373 * \number, if no C escape exists. 2374 */ 2375 self->OutStream(self, CHAR_BACKSLASH); 2376 switch (ch) 2377 { 2378 case '\007': self->OutStream(self, 'a'); break; 2379 case '\b': self->OutStream(self, 'b'); break; 2380 case '\f': self->OutStream(self, 'f'); break; 2381 case '\n': self->OutStream(self, 'n'); break; 2382 case '\r': self->OutStream(self, 'r'); break; 2383 case '\t': self->OutStream(self, 't'); break; 2384 case '\v': self->OutStream(self, 'v'); break; 2385 case '\\': self->OutStream(self, '\\'); break; 2386 default: 2387 self->OutStream(self, 'x'); 2388 TrioWriteNumber(self, (trio_uintmax_t)ch, 2389 FLAGS_UNSIGNED | FLAGS_NILPADDING, 2390 2, 2, BASE_HEX); 2391 break; 2392 } 2393 } 2394 else if (ch == CHAR_BACKSLASH) 2395 { 2396 self->OutStream(self, CHAR_BACKSLASH); 2397 self->OutStream(self, CHAR_BACKSLASH); 2398 } 2399 else 2400 { 2401 self->OutStream(self, ch); 2402 } 2403 } 2404 else 2405 { 2406 self->OutStream(self, ch); 2407 } 2408 } 2409 2410 /************************************************************************* 2411 * TrioWriteString 2412 * 2413 * Description: 2414 * Output a string 2415 */ 2416 TRIO_PRIVATE void 2417 TrioWriteString 2418 TRIO_ARGS5((self, string, flags, width, precision), 2419 trio_class_t *self, 2420 TRIO_CONST char *string, 2421 trio_flags_t flags, 2422 int width, 2423 int precision) 2424 { 2425 int length; 2426 int ch; 2427 2428 assert(VALID(self)); 2429 assert(VALID(self->OutStream)); 2430 2431 if (string == NULL) 2432 { 2433 string = internalNullString; 2434 length = sizeof(internalNullString) - 1; 2435 /* Disable quoting for the null pointer */ 2436 flags &= (~FLAGS_QUOTE); 2437 width = 0; 2438 } 2439 else 2440 { 2441 length = trio_length(string); 2442 } 2443 if ((NO_PRECISION != precision) && 2444 (precision < length)) 2445 { 2446 length = precision; 2447 } 2448 width -= length; 2449 2450 if (flags & FLAGS_QUOTE) 2451 self->OutStream(self, CHAR_QUOTE); 2452 2453 if (! (flags & FLAGS_LEFTADJUST)) 2454 { 2455 while (width-- > 0) 2456 self->OutStream(self, CHAR_ADJUST); 2457 } 2458 2459 while (length-- > 0) 2460 { 2461 /* The ctype parameters must be an unsigned char (or EOF) */ 2462 ch = (int)((unsigned char)(*string++)); 2463 TrioWriteStringCharacter(self, ch, flags); 2464 } 2465 2466 if (flags & FLAGS_LEFTADJUST) 2467 { 2468 while (width-- > 0) 2469 self->OutStream(self, CHAR_ADJUST); 2470 } 2471 if (flags & FLAGS_QUOTE) 2472 self->OutStream(self, CHAR_QUOTE); 2473 } 2474 2475 /************************************************************************* 2476 * TrioWriteWideStringCharacter 2477 * 2478 * Description: 2479 * Output a wide string as a multi-byte sequence 2480 */ 2481 #if TRIO_WIDECHAR 2482 TRIO_PRIVATE int 2483 TrioWriteWideStringCharacter 2484 TRIO_ARGS4((self, wch, flags, width), 2485 trio_class_t *self, 2486 trio_wchar_t wch, 2487 trio_flags_t flags, 2488 int width) 2489 { 2490 int size; 2491 int i; 2492 int ch; 2493 char *string; 2494 char buffer[MB_LEN_MAX + 1]; 2495 2496 if (width == NO_WIDTH) 2497 width = sizeof(buffer); 2498 2499 size = wctomb(buffer, wch); 2500 if ((size <= 0) || (size > width) || (buffer[0] == NIL)) 2501 return 0; 2502 2503 string = buffer; 2504 i = size; 2505 while ((width >= i) && (width-- > 0) && (i-- > 0)) 2506 { 2507 /* The ctype parameters must be an unsigned char (or EOF) */ 2508 ch = (int)((unsigned char)(*string++)); 2509 TrioWriteStringCharacter(self, ch, flags); 2510 } 2511 return size; 2512 } 2513 #endif /* TRIO_WIDECHAR */ 2514 2515 /************************************************************************* 2516 * TrioWriteWideString 2517 * 2518 * Description: 2519 * Output a wide character string as a multi-byte string 2520 */ 2521 #if TRIO_WIDECHAR 2522 TRIO_PRIVATE void 2523 TrioWriteWideString 2524 TRIO_ARGS5((self, wstring, flags, width, precision), 2525 trio_class_t *self, 2526 TRIO_CONST trio_wchar_t *wstring, 2527 trio_flags_t flags, 2528 int width, 2529 int precision) 2530 { 2531 int length; 2532 int size; 2533 2534 assert(VALID(self)); 2535 assert(VALID(self->OutStream)); 2536 2537 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) 2538 (void)mblen(NULL, 0); 2539 #endif 2540 2541 if (wstring == NULL) 2542 { 2543 TrioWriteString(self, NULL, flags, width, precision); 2544 return; 2545 } 2546 2547 if (NO_PRECISION == precision) 2548 { 2549 length = INT_MAX; 2550 } 2551 else 2552 { 2553 length = precision; 2554 width -= length; 2555 } 2556 2557 if (flags & FLAGS_QUOTE) 2558 self->OutStream(self, CHAR_QUOTE); 2559 2560 if (! (flags & FLAGS_LEFTADJUST)) 2561 { 2562 while (width-- > 0) 2563 self->OutStream(self, CHAR_ADJUST); 2564 } 2565 2566 while (length > 0) 2567 { 2568 size = TrioWriteWideStringCharacter(self, *wstring++, flags, length); 2569 if (size == 0) 2570 break; /* while */ 2571 length -= size; 2572 } 2573 2574 if (flags & FLAGS_LEFTADJUST) 2575 { 2576 while (width-- > 0) 2577 self->OutStream(self, CHAR_ADJUST); 2578 } 2579 if (flags & FLAGS_QUOTE) 2580 self->OutStream(self, CHAR_QUOTE); 2581 } 2582 #endif /* TRIO_WIDECHAR */ 2583 2584 /************************************************************************* 2585 * TrioWriteDouble 2586 * 2587 * http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/dr_211.htm 2588 * 2589 * "5.2.4.2.2 paragraph #4 2590 * 2591 * The accuracy [...] is implementation defined, as is the accuracy 2592 * of the conversion between floating-point internal representations 2593 * and string representations performed by the libray routine in 2594 * <stdio.h>" 2595 */ 2596 /* FIXME: handle all instances of constant long-double number (L) 2597 * and *l() math functions. 2598 */ 2599 TRIO_PRIVATE void 2600 TrioWriteDouble 2601 TRIO_ARGS6((self, number, flags, width, precision, base), 2602 trio_class_t *self, 2603 trio_long_double_t number, 2604 trio_flags_t flags, 2605 int width, 2606 int precision, 2607 int base) 2608 { 2609 trio_long_double_t integerNumber; 2610 trio_long_double_t fractionNumber; 2611 trio_long_double_t workNumber; 2612 int integerDigits; 2613 int fractionDigits; 2614 int exponentDigits; 2615 int baseDigits; 2616 int integerThreshold; 2617 int fractionThreshold; 2618 int expectedWidth; 2619 int exponent = 0; 2620 unsigned int uExponent = 0; 2621 int exponentBase; 2622 trio_long_double_t dblBase; 2623 trio_long_double_t dblIntegerBase; 2624 trio_long_double_t dblFractionBase; 2625 trio_long_double_t integerAdjust; 2626 trio_long_double_t fractionAdjust; 2627 BOOLEAN_T isNegative; 2628 BOOLEAN_T isExponentNegative = FALSE; 2629 BOOLEAN_T requireTwoDigitExponent; 2630 BOOLEAN_T isHex; 2631 TRIO_CONST char *digits; 2632 char *groupingPointer; 2633 int i; 2634 int index; 2635 BOOLEAN_T hasOnlyZeroes; 2636 int zeroes = 0; 2637 register int trailingZeroes; 2638 BOOLEAN_T keepTrailingZeroes; 2639 BOOLEAN_T keepDecimalPoint; 2640 trio_long_double_t epsilon; 2641 2642 assert(VALID(self)); 2643 assert(VALID(self->OutStream)); 2644 assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE)); 2645 2646 /* Determine sign and look for special quantities */ 2647 switch (trio_fpclassify_and_signbit(number, &isNegative)) 2648 { 2649 case TRIO_FP_NAN: 2650 TrioWriteString(self, 2651 (flags & FLAGS_UPPER) 2652 ? NAN_UPPER 2653 : NAN_LOWER, 2654 flags, width, precision); 2655 return; 2656 2657 case TRIO_FP_INFINITE: 2658 if (isNegative) 2659 { 2660 /* Negative infinity */ 2661 TrioWriteString(self, 2662 (flags & FLAGS_UPPER) 2663 ? "-" INFINITE_UPPER 2664 : "-" INFINITE_LOWER, 2665 flags, width, precision); 2666 return; 2667 } 2668 else 2669 { 2670 /* Positive infinity */ 2671 TrioWriteString(self, 2672 (flags & FLAGS_UPPER) 2673 ? INFINITE_UPPER 2674 : INFINITE_LOWER, 2675 flags, width, precision); 2676 return; 2677 } 2678 2679 default: 2680 /* Finitude */ 2681 break; 2682 } 2683 2684 /* Normal numbers */ 2685 if (flags & FLAGS_LONGDOUBLE) 2686 { 2687 baseDigits = (base == 10) 2688 ? LDBL_DIG 2689 : (int)floor(LDBL_MANT_DIG / TrioLogarithmBase(base)); 2690 epsilon = LDBL_EPSILON; 2691 } 2692 else if (flags & FLAGS_SHORT) 2693 { 2694 baseDigits = (base == BASE_DECIMAL) 2695 ? FLT_DIG 2696 : (int)floor(FLT_MANT_DIG / TrioLogarithmBase(base)); 2697 epsilon = FLT_EPSILON; 2698 } 2699 else 2700 { 2701 baseDigits = (base == BASE_DECIMAL) 2702 ? DBL_DIG 2703 : (int)floor(DBL_MANT_DIG / TrioLogarithmBase(base)); 2704 epsilon = DBL_EPSILON; 2705 } 2706 2707 digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower; 2708 isHex = (base == BASE_HEX); 2709 if (base == NO_BASE) 2710 base = BASE_DECIMAL; 2711 dblBase = (trio_long_double_t)base; 2712 keepTrailingZeroes = !( (flags & FLAGS_ROUNDING) || 2713 ( (flags & FLAGS_FLOAT_G) && 2714 !(flags & FLAGS_ALTERNATIVE) ) ); 2715 2716 if (flags & FLAGS_ROUNDING) 2717 precision = baseDigits; 2718 2719 if (precision == NO_PRECISION) 2720 { 2721 if (isHex) 2722 { 2723 keepTrailingZeroes = FALSE; 2724 precision = FLT_MANT_DIG; 2725 } 2726 else 2727 { 2728 precision = FLT_DIG; 2729 } 2730 } 2731 2732 if (isNegative) 2733 number = -number; 2734 2735 if (isHex) 2736 flags |= FLAGS_FLOAT_E; 2737 2738 if (flags & FLAGS_FLOAT_G) 2739 { 2740 if (precision == 0) 2741 precision = 1; 2742 2743 if ((number < 1.0E-4) || (number > powl(base, 2744 (trio_long_double_t)precision))) 2745 { 2746 /* Use scientific notation */ 2747 flags |= FLAGS_FLOAT_E; 2748 } 2749 else if (number < 1.0) 2750 { 2751 /* 2752 * Use normal notation. If the integer part of the number is 2753 * zero, then adjust the precision to include leading fractional 2754 * zeros. 2755 */ 2756 workNumber = TrioLogarithm(number, base); 2757 workNumber = TRIO_FABS(workNumber); 2758 if (workNumber - floorl(workNumber) < 0.001) 2759 workNumber--; 2760 zeroes = (int)floorl(workNumber); 2761 } 2762 } 2763 2764 if (flags & FLAGS_FLOAT_E) 2765 { 2766 /* Scale the number */ 2767 workNumber = TrioLogarithm(number, base); 2768 if (trio_isinf(workNumber) == -1) 2769 { 2770 exponent = 0; 2771 /* Undo setting */ 2772 if (flags & FLAGS_FLOAT_G) 2773 flags &= ~FLAGS_FLOAT_E; 2774 } 2775 else 2776 { 2777 exponent = (int)floorl(workNumber); 2778 number /= powl(dblBase, (trio_long_double_t)exponent); 2779 isExponentNegative = (exponent < 0); 2780 uExponent = (isExponentNegative) ? -exponent : exponent; 2781 if (isHex) 2782 uExponent *= 4; /* log16(2) */ 2783 /* No thousand separators */ 2784 flags &= ~FLAGS_QUOTE; 2785 } 2786 } 2787 2788 integerNumber = floorl(number); 2789 fractionNumber = number - integerNumber; 2790 2791 /* 2792 * Truncated number. 2793 * 2794 * Precision is number of significant digits for FLOAT_G 2795 * and number of fractional digits for others. 2796 */ 2797 integerDigits = (integerNumber > epsilon) 2798 ? 1 + (int)TrioLogarithm(integerNumber, base) 2799 : 1; 2800 fractionDigits = ((flags & FLAGS_FLOAT_G) && (zeroes == 0)) 2801 ? precision - integerDigits 2802 : zeroes + precision; 2803 2804 dblFractionBase = TrioPower(base, fractionDigits); 2805 2806 workNumber = number + 0.5 / dblFractionBase; 2807 if (floorl(number) != floorl(workNumber)) 2808 { 2809 if (flags & FLAGS_FLOAT_E) 2810 { 2811 /* Adjust if number was rounded up one digit (ie. 0.99 to 1.00) */ 2812 exponent++; 2813 isExponentNegative = (exponent < 0); 2814 uExponent = (isExponentNegative) ? -exponent : exponent; 2815 if (isHex) 2816 uExponent *= 4; /* log16(2) */ 2817 workNumber = (number + 0.5 / dblFractionBase) / dblBase; 2818 integerNumber = floorl(workNumber); 2819 fractionNumber = workNumber - integerNumber; 2820 } 2821 else 2822 { 2823 /* Adjust if number was rounded up one digit (ie. 99 to 100) */ 2824 integerNumber = floorl(number + 0.5); 2825 fractionNumber = 0.0; 2826 integerDigits = (integerNumber > epsilon) 2827 ? 1 + (int)TrioLogarithm(integerNumber, base) 2828 : 1; 2829 } 2830 } 2831 2832 /* Estimate accuracy */ 2833 integerAdjust = fractionAdjust = 0.5; 2834 if (flags & FLAGS_ROUNDING) 2835 { 2836 if (integerDigits > baseDigits) 2837 { 2838 integerThreshold = baseDigits; 2839 fractionDigits = 0; 2840 dblFractionBase = 1.0; 2841 fractionThreshold = 0; 2842 precision = 0; /* Disable decimal-point */ 2843 integerAdjust = TrioPower(base, integerDigits - integerThreshold - 1); 2844 fractionAdjust = 0.0; 2845 } 2846 else 2847 { 2848 integerThreshold = integerDigits; 2849 fractionThreshold = fractionDigits - integerThreshold; 2850 fractionAdjust = 1.0; 2851 } 2852 } 2853 else 2854 { 2855 integerThreshold = INT_MAX; 2856 fractionThreshold = INT_MAX; 2857 } 2858 2859 /* 2860 * Calculate expected width. 2861 * sign + integer part + thousands separators + decimal point 2862 * + fraction + exponent 2863 */ 2864 fractionAdjust /= dblFractionBase; 2865 hasOnlyZeroes = (floorl((fractionNumber + fractionAdjust) * dblFractionBase) < epsilon); 2866 keepDecimalPoint = ( (flags & FLAGS_ALTERNATIVE) || 2867 !((precision == 0) || 2868 (!keepTrailingZeroes && hasOnlyZeroes)) ); 2869 if (flags & FLAGS_FLOAT_E) 2870 { 2871 exponentDigits = (uExponent == 0) 2872 ? 1 2873 : (int)ceil(TrioLogarithm((double)(uExponent + 1), 2874 (isHex) ? 10.0 : base)); 2875 } 2876 else 2877 exponentDigits = 0; 2878 requireTwoDigitExponent = ((base == BASE_DECIMAL) && (exponentDigits == 1)); 2879 2880 expectedWidth = integerDigits + fractionDigits 2881 + (keepDecimalPoint 2882 ? internalDecimalPointLength 2883 : 0) 2884 + ((flags & FLAGS_QUOTE) 2885 ? TrioCalcThousandSeparatorLength(integerDigits) 2886 : 0); 2887 if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE)) 2888 expectedWidth += sizeof("-") - 1; 2889 if (exponentDigits > 0) 2890 expectedWidth += exponentDigits + 2891 ((requireTwoDigitExponent ? sizeof("E+0") : sizeof("E+")) - 1); 2892 if (isHex) 2893 expectedWidth += sizeof("0X") - 1; 2894 2895 /* Output prefixing */ 2896 if (flags & FLAGS_NILPADDING) 2897 { 2898 /* Leading zeros must be after sign */ 2899 if (isNegative) 2900 self->OutStream(self, '-'); 2901 else if (flags & FLAGS_SHOWSIGN) 2902 self->OutStream(self, '+'); 2903 else if (flags & FLAGS_SPACE) 2904 self->OutStream(self, ' '); 2905 if (isHex) 2906 { 2907 self->OutStream(self, '0'); 2908 self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x'); 2909 } 2910 if (!(flags & FLAGS_LEFTADJUST)) 2911 { 2912 for (i = expectedWidth; i < width; i++) 2913 { 2914 self->OutStream(self, '0'); 2915 } 2916 } 2917 } 2918 else 2919 { 2920 /* Leading spaces must be before sign */ 2921 if (!(flags & FLAGS_LEFTADJUST)) 2922 { 2923 for (i = expectedWidth; i < width; i++) 2924 { 2925 self->OutStream(self, CHAR_ADJUST); 2926 } 2927 } 2928 if (isNegative) 2929 self->OutStream(self, '-'); 2930 else if (flags & FLAGS_SHOWSIGN) 2931 self->OutStream(self, '+'); 2932 else if (flags & FLAGS_SPACE) 2933 self->OutStream(self, ' '); 2934 if (isHex) 2935 { 2936 self->OutStream(self, '0'); 2937 self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x'); 2938 } 2939 } 2940 2941 /* Output the integer part and thousand separators */ 2942 dblIntegerBase = 1.0 / TrioPower(base, integerDigits - 1); 2943 for (i = 0; i < integerDigits; i++) 2944 { 2945 workNumber = floorl(((integerNumber + integerAdjust) * dblIntegerBase)); 2946 if (i > integerThreshold) 2947 { 2948 /* Beyond accuracy */ 2949 self->OutStream(self, digits[0]); 2950 } 2951 else 2952 { 2953 self->OutStream(self, digits[(int)fmodl(workNumber, dblBase)]); 2954 } 2955 dblIntegerBase *= dblBase; 2956 2957 if (((flags & (FLAGS_FLOAT_E | FLAGS_QUOTE)) == FLAGS_QUOTE) 2958 && TrioFollowedBySeparator(integerDigits - i)) 2959 { 2960 for (groupingPointer = internalThousandSeparator; 2961 *groupingPointer != NIL; 2962 groupingPointer++) 2963 { 2964 self->OutStream(self, *groupingPointer); 2965 } 2966 } 2967 } 2968 2969 /* Insert decimal point and build the fraction part */ 2970 trailingZeroes = 0; 2971 2972 if (keepDecimalPoint) 2973 { 2974 if (internalDecimalPoint) 2975 { 2976 self->OutStream(self, internalDecimalPoint); 2977 } 2978 else 2979 { 2980 for (i = 0; i < internalDecimalPointLength; i++) 2981 { 2982 self->OutStream(self, internalDecimalPointString[i]); 2983 } 2984 } 2985 } 2986 2987 for (i = 0; i < fractionDigits; i++) 2988 { 2989 if ((integerDigits > integerThreshold) || (i > fractionThreshold)) 2990 { 2991 /* Beyond accuracy */ 2992 trailingZeroes++; 2993 } 2994 else 2995 { 2996 fractionNumber *= dblBase; 2997 fractionAdjust *= dblBase; 2998 workNumber = floorl(fractionNumber + fractionAdjust); 2999 fractionNumber -= workNumber; 3000 index = (int)fmodl(workNumber, dblBase); 3001 if (index == 0) 3002 { 3003 trailingZeroes++; 3004 } 3005 else 3006 { 3007 while (trailingZeroes > 0) 3008 { 3009 /* Not trailing zeroes after all */ 3010 self->OutStream(self, digits[0]); 3011 trailingZeroes--; 3012 } 3013 self->OutStream(self, digits[index]); 3014 } 3015 } 3016 } 3017 3018 if (keepTrailingZeroes) 3019 { 3020 while (trailingZeroes > 0) 3021 { 3022 self->OutStream(self, digits[0]); 3023 trailingZeroes--; 3024 } 3025 } 3026 3027 /* Output exponent */ 3028 if (exponentDigits > 0) 3029 { 3030 self->OutStream(self, 3031 isHex 3032 ? ((flags & FLAGS_UPPER) ? 'P' : 'p') 3033 : ((flags & FLAGS_UPPER) ? 'E' : 'e')); 3034 self->OutStream(self, (isExponentNegative) ? '-' : '+'); 3035 3036 /* The exponent must contain at least two digits */ 3037 if (requireTwoDigitExponent) 3038 self->OutStream(self, '0'); 3039 3040 if (isHex) 3041 base = 10.0; 3042 exponentBase = (int)TrioPower(base, exponentDigits - 1); 3043 for (i = 0; i < exponentDigits; i++) 3044 { 3045 self->OutStream(self, digits[(uExponent / exponentBase) % base]); 3046 exponentBase /= base; 3047 } 3048 } 3049 /* Output trailing spaces */ 3050 if (flags & FLAGS_LEFTADJUST) 3051 { 3052 for (i = expectedWidth; i < width; i++) 3053 { 3054 self->OutStream(self, CHAR_ADJUST); 3055 } 3056 } 3057 } 3058 3059 /************************************************************************* 3060 * TrioFormatProcess 3061 * 3062 * Description: 3063 * This is the main engine for formatting output 3064 */ 3065 TRIO_PRIVATE int 3066 TrioFormatProcess 3067 TRIO_ARGS3((data, format, parameters), 3068 trio_class_t *data, 3069 TRIO_CONST char *format, 3070 trio_parameter_t *parameters) 3071 { 3072 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) 3073 int charlen; 3074 #endif 3075 int i; 3076 TRIO_CONST char *string; 3077 trio_pointer_t pointer; 3078 trio_flags_t flags; 3079 int width; 3080 int precision; 3081 int base; 3082 int index; 3083 3084 index = 0; 3085 i = 0; 3086 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) 3087 (void)mblen(NULL, 0); 3088 #endif 3089 3090 while (format[index]) 3091 { 3092 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) 3093 if (! isascii(format[index])) 3094 { 3095 charlen = mblen(&format[index], MB_LEN_MAX); 3096 /* 3097 * Only valid multibyte characters are handled here. Invalid 3098 * multibyte characters (charlen == -1) are handled as normal 3099 * characters. 3100 */ 3101 if (charlen != -1) 3102 { 3103 while (charlen-- > 0) 3104 { 3105 data->OutStream(data, format[index++]); 3106 } 3107 continue; /* while characters left in formatting string */ 3108 } 3109 } 3110 #endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */ 3111 if (CHAR_IDENTIFIER == format[index]) 3112 { 3113 if (CHAR_IDENTIFIER == format[index + 1]) 3114 { 3115 data->OutStream(data, CHAR_IDENTIFIER); 3116 index += 2; 3117 } 3118 else 3119 { 3120 /* Skip the parameter entries */ 3121 while (parameters[i].type == FORMAT_PARAMETER) 3122 i++; 3123 3124 flags = parameters[i].flags; 3125 3126 /* Find width */ 3127 width = parameters[i].width; 3128 if (flags & FLAGS_WIDTH_PARAMETER) 3129 { 3130 /* Get width from parameter list */ 3131 width = (int)parameters[width].data.number.as_signed; 3132 if (width < 0) 3133 { 3134 /* 3135 * A negative width is the same as the - flag and 3136 * a positive width. 3137 */ 3138 flags |= FLAGS_LEFTADJUST; 3139 flags &= ~FLAGS_NILPADDING; 3140 width = -width; 3141 } 3142 } 3143 3144 /* Find precision */ 3145 if (flags & FLAGS_PRECISION) 3146 { 3147 precision = parameters[i].precision; 3148 if (flags & FLAGS_PRECISION_PARAMETER) 3149 { 3150 /* Get precision from parameter list */ 3151 precision = (int)parameters[precision].data.number.as_signed; 3152 if (precision < 0) 3153 { 3154 /* 3155 * A negative precision is the same as no 3156 * precision 3157 */ 3158 precision = NO_PRECISION; 3159 } 3160 } 3161 } 3162 else 3163 { 3164 precision = NO_PRECISION; 3165 } 3166 3167 /* Find base */ 3168 base = parameters[i].base; 3169 if (flags & FLAGS_BASE_PARAMETER) 3170 { 3171 /* Get base from parameter list */ 3172 base = (int)parameters[base].data.number.as_signed; 3173 } 3174 3175 switch (parameters[i].type) 3176 { 3177 case FORMAT_CHAR: 3178 if (flags & FLAGS_QUOTE) 3179 data->OutStream(data, CHAR_QUOTE); 3180 if (! (flags & FLAGS_LEFTADJUST)) 3181 { 3182 while (--width > 0) 3183 data->OutStream(data, CHAR_ADJUST); 3184 } 3185 #if TRIO_WIDECHAR 3186 if (flags & FLAGS_WIDECHAR) 3187 { 3188 TrioWriteWideStringCharacter(data, 3189 (trio_wchar_t)parameters[i].data.number.as_signed, 3190 flags, 3191 NO_WIDTH); 3192 } 3193 else 3194 #endif 3195 { 3196 TrioWriteStringCharacter(data, 3197 (int)parameters[i].data.number.as_signed, 3198 flags); 3199 } 3200 3201 if (flags & FLAGS_LEFTADJUST) 3202 { 3203 while(--width > 0) 3204 data->OutStream(data, CHAR_ADJUST); 3205 } 3206 if (flags & FLAGS_QUOTE) 3207 data->OutStream(data, CHAR_QUOTE); 3208 3209 break; /* FORMAT_CHAR */ 3210 3211 case FORMAT_INT: 3212 TrioWriteNumber(data, 3213 parameters[i].data.number.as_unsigned, 3214 flags, 3215 width, 3216 precision, 3217 base); 3218 3219 break; /* FORMAT_INT */ 3220 3221 case FORMAT_DOUBLE: 3222 TrioWriteDouble(data, 3223 parameters[i].data.longdoubleNumber, 3224 flags, 3225 width, 3226 precision, 3227 base); 3228 break; /* FORMAT_DOUBLE */ 3229 3230 case FORMAT_STRING: 3231 #if TRIO_WIDECHAR 3232 if (flags & FLAGS_WIDECHAR) 3233 { 3234 TrioWriteWideString(data, 3235 parameters[i].data.wstring, 3236 flags, 3237 width, 3238 precision); 3239 } 3240 else 3241 #endif 3242 { 3243 TrioWriteString(data, 3244 parameters[i].data.string, 3245 flags, 3246 width, 3247 precision); 3248 } 3249 break; /* FORMAT_STRING */ 3250 3251 case FORMAT_POINTER: 3252 { 3253 trio_reference_t reference; 3254 3255 reference.data = data; 3256 reference.parameter = ¶meters[i]; 3257 trio_print_pointer(&reference, parameters[i].data.pointer); 3258 } 3259 break; /* FORMAT_POINTER */ 3260 3261 case FORMAT_COUNT: 3262 pointer = parameters[i].data.pointer; 3263 if (NULL != pointer) 3264 { 3265 /* 3266 * C99 paragraph 7.19.6.1.8 says "the number of 3267 * characters written to the output stream so far by 3268 * this call", which is data->committed 3269 */ 3270 #if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER) 3271 if (flags & FLAGS_SIZE_T) 3272 *(size_t *)pointer = (size_t)data->committed; 3273 else 3274 #endif 3275 #if defined(QUALIFIER_PTRDIFF_T) 3276 if (flags & FLAGS_PTRDIFF_T) 3277 *(ptrdiff_t *)pointer = (ptrdiff_t)data->committed; 3278 else 3279 #endif 3280 #if defined(QUALIFIER_INTMAX_T) 3281 if (flags & FLAGS_INTMAX_T) 3282 *(trio_intmax_t *)pointer = (trio_intmax_t)data->committed; 3283 else 3284 #endif 3285 if (flags & FLAGS_QUAD) 3286 { 3287 *(trio_ulonglong_t *)pointer = (trio_ulonglong_t)data->committed; 3288 } 3289 else if (flags & FLAGS_LONG) 3290 { 3291 *(long int *)pointer = (long int)data->committed; 3292 } 3293 else if (flags & FLAGS_SHORT) 3294 { 3295 *(short int *)pointer = (short int)data->committed; 3296 } 3297 else 3298 { 3299 *(int *)pointer = (int)data->committed; 3300 } 3301 } 3302 break; /* FORMAT_COUNT */ 3303 3304 case FORMAT_PARAMETER: 3305 break; /* FORMAT_PARAMETER */ 3306 3307 #if defined(FORMAT_ERRNO) 3308 case FORMAT_ERRNO: 3309 string = trio_error(parameters[i].data.errorNumber); 3310 if (string) 3311 { 3312 TrioWriteString(data, 3313 string, 3314 flags, 3315 width, 3316 precision); 3317 } 3318 else 3319 { 3320 data->OutStream(data, '#'); 3321 TrioWriteNumber(data, 3322 (trio_uintmax_t)parameters[i].data.errorNumber, 3323 flags, 3324 width, 3325 precision, 3326 BASE_DECIMAL); 3327 } 3328 break; /* FORMAT_ERRNO */ 3329 #endif /* defined(FORMAT_ERRNO) */ 3330 3331 #if defined(FORMAT_USER_DEFINED) 3332 case FORMAT_USER_DEFINED: 3333 { 3334 trio_reference_t reference; 3335 trio_userdef_t *def = NULL; 3336 3337 if (parameters[i].user_name[0] == NIL) 3338 { 3339 /* Use handle */ 3340 if ((i > 0) || 3341 (parameters[i - 1].type == FORMAT_PARAMETER)) 3342 def = (trio_userdef_t *)parameters[i - 1].data.pointer; 3343 } 3344 else 3345 { 3346 /* Look up namespace */ 3347 def = TrioFindNamespace(parameters[i].user_name, NULL); 3348 } 3349 if (def) { 3350 reference.data = data; 3351 reference.parameter = ¶meters[i]; 3352 def->callback(&reference); 3353 } 3354 } 3355 break; 3356 #endif /* defined(FORMAT_USER_DEFINED) */ 3357 3358 default: 3359 break; 3360 } /* switch parameter type */ 3361 3362 /* Prepare for next */ 3363 index = parameters[i].indexAfterSpecifier; 3364 i++; 3365 } 3366 } 3367 else /* not identifier */ 3368 { 3369 data->OutStream(data, format[index++]); 3370 } 3371 } 3372 return data->processed; 3373 } 3374 3375 /************************************************************************* 3376 * TrioFormatRef 3377 */ 3378 TRIO_PRIVATE int 3379 TrioFormatRef 3380 TRIO_ARGS4((reference, format, arglist, argarray), 3381 trio_reference_t *reference, 3382 TRIO_CONST char *format, 3383 va_list *arglist, 3384 trio_pointer_t *argarray) 3385 { 3386 int status; 3387 trio_parameter_t parameters[MAX_PARAMETERS]; 3388 3389 status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray); 3390 if (status < 0) 3391 return status; 3392 3393 status = TrioFormatProcess(reference->data, format, parameters); 3394 if (reference->data->error != 0) 3395 { 3396 status = reference->data->error; 3397 } 3398 return status; 3399 } 3400 3401 /************************************************************************* 3402 * TrioFormat 3403 */ 3404 TRIO_PRIVATE int 3405 TrioFormat 3406 TRIO_ARGS6((destination, destinationSize, OutStream, format, arglist, argarray), 3407 trio_pointer_t destination, 3408 size_t destinationSize, 3409 void (*OutStream) TRIO_PROTO((trio_class_t *, int)), 3410 TRIO_CONST char *format, 3411 va_list *arglist, 3412 trio_pointer_t *argarray) 3413 { 3414 int status; 3415 trio_class_t data; 3416 trio_parameter_t parameters[MAX_PARAMETERS]; 3417 3418 assert(VALID(OutStream)); 3419 assert(VALID(format)); 3420 3421 memset(&data, 0, sizeof(data)); 3422 data.OutStream = OutStream; 3423 data.location = destination; 3424 data.max = destinationSize; 3425 data.error = 0; 3426 3427 #if defined(USE_LOCALE) 3428 if (NULL == internalLocaleValues) 3429 { 3430 TrioSetLocale(); 3431 } 3432 #endif 3433 3434 status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray); 3435 if (status < 0) 3436 return status; 3437 3438 status = TrioFormatProcess(&data, format, parameters); 3439 if (data.error != 0) 3440 { 3441 status = data.error; 3442 } 3443 return status; 3444 } 3445 3446 /************************************************************************* 3447 * TrioOutStreamFile 3448 */ 3449 TRIO_PRIVATE void 3450 TrioOutStreamFile 3451 TRIO_ARGS2((self, output), 3452 trio_class_t *self, 3453 int output) 3454 { 3455 FILE *file; 3456 3457 assert(VALID(self)); 3458 assert(VALID(self->location)); 3459 3460 file = (FILE *)self->location; 3461 self->processed++; 3462 if (fputc(output, file) == EOF) 3463 { 3464 self->error = TRIO_ERROR_RETURN(TRIO_EOF, 0); 3465 } 3466 else 3467 { 3468 self->committed++; 3469 } 3470 } 3471 3472 /************************************************************************* 3473 * TrioOutStreamFileDescriptor 3474 */ 3475 TRIO_PRIVATE void 3476 TrioOutStreamFileDescriptor 3477 TRIO_ARGS2((self, output), 3478 trio_class_t *self, 3479 int output) 3480 { 3481 int fd; 3482 char ch; 3483 3484 assert(VALID(self)); 3485 3486 fd = *((int *)self->location); 3487 ch = (char)output; 3488 self->processed++; 3489 if (write(fd, &ch, sizeof(char)) == -1) 3490 { 3491 self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0); 3492 } 3493 else 3494 { 3495 self->committed++; 3496 } 3497 } 3498 3499 /************************************************************************* 3500 * TrioOutStreamCustom 3501 */ 3502 TRIO_PRIVATE void 3503 TrioOutStreamCustom 3504 TRIO_ARGS2((self, output), 3505 trio_class_t *self, 3506 int output) 3507 { 3508 int status; 3509 trio_custom_t *data; 3510 3511 assert(VALID(self)); 3512 assert(VALID(self->location)); 3513 3514 data = (trio_custom_t *)self->location; 3515 if (data->stream.out) 3516 { 3517 status = (data->stream.out)(data->closure, output); 3518 if (status >= 0) 3519 { 3520 self->committed++; 3521 } 3522 else 3523 { 3524 if (self->error == 0) 3525 { 3526 self->error = TRIO_ERROR_RETURN(TRIO_ECUSTOM, -status); 3527 } 3528 } 3529 } 3530 self->processed++; 3531 } 3532 3533 /************************************************************************* 3534 * TrioOutStreamString 3535 */ 3536 TRIO_PRIVATE void 3537 TrioOutStreamString 3538 TRIO_ARGS2((self, output), 3539 trio_class_t *self, 3540 int output) 3541 { 3542 char **buffer; 3543 3544 assert(VALID(self)); 3545 assert(VALID(self->location)); 3546 3547 buffer = (char **)self->location; 3548 **buffer = (char)output; 3549 (*buffer)++; 3550 self->processed++; 3551 self->committed++; 3552 } 3553 3554 /************************************************************************* 3555 * TrioOutStreamStringMax 3556 */ 3557 TRIO_PRIVATE void 3558 TrioOutStreamStringMax 3559 TRIO_ARGS2((self, output), 3560 trio_class_t *self, 3561 int output) 3562 { 3563 char **buffer; 3564 3565 assert(VALID(self)); 3566 assert(VALID(self->location)); 3567 3568 buffer = (char **)self->location; 3569 3570 if (self->processed < self->max) 3571 { 3572 **buffer = (char)output; 3573 (*buffer)++; 3574 self->committed++; 3575 } 3576 self->processed++; 3577 } 3578 3579 /************************************************************************* 3580 * TrioOutStreamStringDynamic 3581 */ 3582 TRIO_PRIVATE void 3583 TrioOutStreamStringDynamic 3584 TRIO_ARGS2((self, output), 3585 trio_class_t *self, 3586 int output) 3587 { 3588 assert(VALID(self)); 3589 assert(VALID(self->location)); 3590 3591 if (self->error == 0) 3592 { 3593 trio_xstring_append_char((trio_string_t *)self->location, 3594 (char)output); 3595 self->committed++; 3596 } 3597 /* The processed variable must always be increased */ 3598 self->processed++; 3599 } 3600 3601 /************************************************************************* 3602 * 3603 * Formatted printing functions 3604 * 3605 ************************************************************************/ 3606 3607 #if defined(TRIO_DOCUMENTATION) 3608 # include "doc/doc_printf.h" 3609 #endif 3610 /** @addtogroup Printf 3611 @{ 3612 */ 3613 3614 /************************************************************************* 3615 * printf 3616 */ 3617 3618 /** 3619 Print to standard output stream. 3620 3621 @param format Formatting string. 3622 @param ... Arguments. 3623 @return Number of printed characters. 3624 */ 3625 TRIO_PUBLIC int 3626 trio_printf 3627 TRIO_VARGS2((format, va_alist), 3628 TRIO_CONST char *format, 3629 TRIO_VA_DECL) 3630 { 3631 int status; 3632 va_list args; 3633 3634 assert(VALID(format)); 3635 3636 TRIO_VA_START(args, format); 3637 status = TrioFormat(stdout, 0, TrioOutStreamFile, format, &args, NULL); 3638 TRIO_VA_END(args); 3639 return status; 3640 } 3641 3642 /** 3643 Print to standard output stream. 3644 3645 @param format Formatting string. 3646 @param args Arguments. 3647 @return Number of printed characters. 3648 */ 3649 TRIO_PUBLIC int 3650 trio_vprintf 3651 TRIO_ARGS2((format, args), 3652 TRIO_CONST char *format, 3653 va_list args) 3654 { 3655 assert(VALID(format)); 3656 3657 return TrioFormat(stdout, 0, TrioOutStreamFile, format, &args, NULL); 3658 } 3659 3660 /** 3661 Print to standard output stream. 3662 3663 @param format Formatting string. 3664 @param args Arguments. 3665 @return Number of printed characters. 3666 */ 3667 TRIO_PUBLIC int 3668 trio_printfv 3669 TRIO_ARGS2((format, args), 3670 TRIO_CONST char *format, 3671 trio_pointer_t * args) 3672 { 3673 assert(VALID(format)); 3674 3675 return TrioFormat(stdout, 0, TrioOutStreamFile, format, NULL, args); 3676 } 3677 3678 /************************************************************************* 3679 * fprintf 3680 */ 3681 3682 /** 3683 Print to file. 3684 3685 @param file File pointer. 3686 @param format Formatting string. 3687 @param ... Arguments. 3688 @return Number of printed characters. 3689 */ 3690 TRIO_PUBLIC int 3691 trio_fprintf 3692 TRIO_VARGS3((file, format, va_alist), 3693 FILE *file, 3694 TRIO_CONST char *format, 3695 TRIO_VA_DECL) 3696 { 3697 int status; 3698 va_list args; 3699 3700 assert(VALID(file)); 3701 assert(VALID(format)); 3702 3703 TRIO_VA_START(args, format); 3704 status = TrioFormat(file, 0, TrioOutStreamFile, format, &args, NULL); 3705 TRIO_VA_END(args); 3706 return status; 3707 } 3708 3709 /** 3710 Print to file. 3711 3712 @param file File pointer. 3713 @param format Formatting string. 3714 @param args Arguments. 3715 @return Number of printed characters. 3716 */ 3717 TRIO_PUBLIC int 3718 trio_vfprintf 3719 TRIO_ARGS3((file, format, args), 3720 FILE *file, 3721 TRIO_CONST char *format, 3722 va_list args) 3723 { 3724 assert(VALID(file)); 3725 assert(VALID(format)); 3726 3727 return TrioFormat(file, 0, TrioOutStreamFile, format, &args, NULL); 3728 } 3729 3730 /** 3731 Print to file. 3732 3733 @param file File pointer. 3734 @param format Formatting string. 3735 @param args Arguments. 3736 @return Number of printed characters. 3737 */ 3738 TRIO_PUBLIC int 3739 trio_fprintfv 3740 TRIO_ARGS3((file, format, args), 3741 FILE *file, 3742 TRIO_CONST char *format, 3743 trio_pointer_t * args) 3744 { 3745 assert(VALID(file)); 3746 assert(VALID(format)); 3747 3748 return TrioFormat(file, 0, TrioOutStreamFile, format, NULL, args); 3749 } 3750 3751 /************************************************************************* 3752 * dprintf 3753 */ 3754 3755 /** 3756 Print to file descriptor. 3757 3758 @param fd File descriptor. 3759 @param format Formatting string. 3760 @param ... Arguments. 3761 @return Number of printed characters. 3762 */ 3763 TRIO_PUBLIC int 3764 trio_dprintf 3765 TRIO_VARGS3((fd, format, va_alist), 3766 int fd, 3767 TRIO_CONST char *format, 3768 TRIO_VA_DECL) 3769 { 3770 int status; 3771 va_list args; 3772 3773 assert(VALID(format)); 3774 3775 TRIO_VA_START(args, format); 3776 status = TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, &args, NULL); 3777 TRIO_VA_END(args); 3778 return status; 3779 } 3780 3781 /** 3782 Print to file descriptor. 3783 3784 @param fd File descriptor. 3785 @param format Formatting string. 3786 @param args Arguments. 3787 @return Number of printed characters. 3788 */ 3789 TRIO_PUBLIC int 3790 trio_vdprintf 3791 TRIO_ARGS3((fd, format, args), 3792 int fd, 3793 TRIO_CONST char *format, 3794 va_list args) 3795 { 3796 assert(VALID(format)); 3797 3798 return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, &args, NULL); 3799 } 3800 3801 /** 3802 Print to file descriptor. 3803 3804 @param fd File descriptor. 3805 @param format Formatting string. 3806 @param args Arguments. 3807 @return Number of printed characters. 3808 */ 3809 TRIO_PUBLIC int 3810 trio_dprintfv 3811 TRIO_ARGS3((fd, format, args), 3812 int fd, 3813 TRIO_CONST char *format, 3814 trio_pointer_t *args) 3815 { 3816 assert(VALID(format)); 3817 3818 return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, NULL, args); 3819 } 3820 3821 /************************************************************************* 3822 * cprintf 3823 */ 3824 TRIO_PUBLIC int 3825 trio_cprintf 3826 TRIO_VARGS4((stream, closure, format, va_alist), 3827 trio_outstream_t stream, 3828 trio_pointer_t closure, 3829 TRIO_CONST char *format, 3830 TRIO_VA_DECL) 3831 { 3832 int status; 3833 va_list args; 3834 trio_custom_t data; 3835 3836 assert(VALID(stream)); 3837 assert(VALID(format)); 3838 3839 TRIO_VA_START(args, format); 3840 data.stream.out = stream; 3841 data.closure = closure; 3842 status = TrioFormat(&data, 0, TrioOutStreamCustom, format, &args, NULL); 3843 TRIO_VA_END(args); 3844 return status; 3845 } 3846 3847 TRIO_PUBLIC int 3848 trio_vcprintf 3849 TRIO_ARGS4((stream, closure, format, args), 3850 trio_outstream_t stream, 3851 trio_pointer_t closure, 3852 TRIO_CONST char *format, 3853 va_list args) 3854 { 3855 trio_custom_t data; 3856 3857 assert(VALID(stream)); 3858 assert(VALID(format)); 3859 3860 data.stream.out = stream; 3861 data.closure = closure; 3862 return TrioFormat(&data, 0, TrioOutStreamCustom, format, &args, NULL); 3863 } 3864 3865 TRIO_PUBLIC int 3866 trio_cprintfv 3867 TRIO_ARGS4((stream, closure, format, args), 3868 trio_outstream_t stream, 3869 trio_pointer_t closure, 3870 TRIO_CONST char *format, 3871 void **args) 3872 { 3873 trio_custom_t data; 3874 3875 assert(VALID(stream)); 3876 assert(VALID(format)); 3877 3878 data.stream.out = stream; 3879 data.closure = closure; 3880 return TrioFormat(&data, 0, TrioOutStreamCustom, format, NULL, args); 3881 } 3882 3883 /************************************************************************* 3884 * sprintf 3885 */ 3886 3887 /** 3888 Print to string. 3889 3890 @param buffer Output string. 3891 @param format Formatting string. 3892 @param ... Arguments. 3893 @return Number of printed characters. 3894 */ 3895 TRIO_PUBLIC int 3896 trio_sprintf 3897 TRIO_VARGS3((buffer, format, va_alist), 3898 char *buffer, 3899 TRIO_CONST char *format, 3900 TRIO_VA_DECL) 3901 { 3902 int status; 3903 va_list args; 3904 3905 assert(VALID(buffer)); 3906 assert(VALID(format)); 3907 3908 TRIO_VA_START(args, format); 3909 status = TrioFormat(&buffer, 0, TrioOutStreamString, format, &args, NULL); 3910 *buffer = NIL; /* Terminate with NIL character */ 3911 TRIO_VA_END(args); 3912 return status; 3913 } 3914 3915 /** 3916 Print to string. 3917 3918 @param buffer Output string. 3919 @param format Formatting string. 3920 @param args Arguments. 3921 @return Number of printed characters. 3922 */ 3923 TRIO_PUBLIC int 3924 trio_vsprintf 3925 TRIO_ARGS3((buffer, format, args), 3926 char *buffer, 3927 TRIO_CONST char *format, 3928 va_list args) 3929 { 3930 int status; 3931 3932 assert(VALID(buffer)); 3933 assert(VALID(format)); 3934 3935 status = TrioFormat(&buffer, 0, TrioOutStreamString, format, &args, NULL); 3936 *buffer = NIL; 3937 return status; 3938 } 3939 3940 /** 3941 Print to string. 3942 3943 @param buffer Output string. 3944 @param format Formatting string. 3945 @param args Arguments. 3946 @return Number of printed characters. 3947 */ 3948 TRIO_PUBLIC int 3949 trio_sprintfv 3950 TRIO_ARGS3((buffer, format, args), 3951 char *buffer, 3952 TRIO_CONST char *format, 3953 trio_pointer_t *args) 3954 { 3955 int status; 3956 3957 assert(VALID(buffer)); 3958 assert(VALID(format)); 3959 3960 status = TrioFormat(&buffer, 0, TrioOutStreamString, format, NULL, args); 3961 *buffer = NIL; 3962 return status; 3963 } 3964 3965 /************************************************************************* 3966 * snprintf 3967 */ 3968 3969 /** 3970 Print at most @p max characters to string. 3971 3972 @param buffer Output string. 3973 @param max Maximum number of characters to print. 3974 @param format Formatting string. 3975 @param ... Arguments. 3976 @return Number of printed characters. 3977 */ 3978 TRIO_PUBLIC int 3979 trio_snprintf 3980 TRIO_VARGS4((buffer, max, format, va_alist), 3981 char *buffer, 3982 size_t max, 3983 TRIO_CONST char *format, 3984 TRIO_VA_DECL) 3985 { 3986 int status; 3987 va_list args; 3988 3989 assert(VALID(buffer)); 3990 assert(VALID(format)); 3991 3992 TRIO_VA_START(args, format); 3993 status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, 3994 TrioOutStreamStringMax, format, &args, NULL); 3995 if (max > 0) 3996 *buffer = NIL; 3997 TRIO_VA_END(args); 3998 return status; 3999 } 4000 4001 /** 4002 Print at most @p max characters to string. 4003 4004 @param buffer Output string. 4005 @param max Maximum number of characters to print. 4006 @param format Formatting string. 4007 @param args Arguments. 4008 @return Number of printed characters. 4009 */ 4010 TRIO_PUBLIC int 4011 trio_vsnprintf 4012 TRIO_ARGS4((buffer, max, format, args), 4013 char *buffer, 4014 size_t max, 4015 TRIO_CONST char *format, 4016 va_list args) 4017 { 4018 int status; 4019 4020 assert(VALID(buffer)); 4021 assert(VALID(format)); 4022 4023 status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, 4024 TrioOutStreamStringMax, format, &args, NULL); 4025 if (max > 0) 4026 *buffer = NIL; 4027 return status; 4028 } 4029 4030 /** 4031 Print at most @p max characters to string. 4032 4033 @param buffer Output string. 4034 @param max Maximum number of characters to print. 4035 @param format Formatting string. 4036 @param args Arguments. 4037 @return Number of printed characters. 4038 */ 4039 TRIO_PUBLIC int 4040 trio_snprintfv 4041 TRIO_ARGS4((buffer, max, format, args), 4042 char *buffer, 4043 size_t max, 4044 TRIO_CONST char *format, 4045 trio_pointer_t *args) 4046 { 4047 int status; 4048 4049 assert(VALID(buffer)); 4050 assert(VALID(format)); 4051 4052 status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, 4053 TrioOutStreamStringMax, format, NULL, args); 4054 if (max > 0) 4055 *buffer = NIL; 4056 return status; 4057 } 4058 4059 /************************************************************************* 4060 * snprintfcat 4061 * Appends the new string to the buffer string overwriting the '\0' 4062 * character at the end of buffer. 4063 */ 4064 TRIO_PUBLIC int 4065 trio_snprintfcat 4066 TRIO_VARGS4((buffer, max, format, va_alist), 4067 char *buffer, 4068 size_t max, 4069 TRIO_CONST char *format, 4070 TRIO_VA_DECL) 4071 { 4072 int status; 4073 va_list args; 4074 size_t buf_len; 4075 4076 TRIO_VA_START(args, format); 4077 4078 assert(VALID(buffer)); 4079 assert(VALID(format)); 4080 4081 buf_len = trio_length(buffer); 4082 buffer = &buffer[buf_len]; 4083 4084 status = TrioFormat(&buffer, max - 1 - buf_len, 4085 TrioOutStreamStringMax, format, &args, NULL); 4086 TRIO_VA_END(args); 4087 *buffer = NIL; 4088 return status; 4089 } 4090 4091 TRIO_PUBLIC int 4092 trio_vsnprintfcat 4093 TRIO_ARGS4((buffer, max, format, args), 4094 char *buffer, 4095 size_t max, 4096 TRIO_CONST char *format, 4097 va_list args) 4098 { 4099 int status; 4100 size_t buf_len; 4101 4102 assert(VALID(buffer)); 4103 assert(VALID(format)); 4104 4105 buf_len = trio_length(buffer); 4106 buffer = &buffer[buf_len]; 4107 status = TrioFormat(&buffer, max - 1 - buf_len, 4108 TrioOutStreamStringMax, format, &args, NULL); 4109 *buffer = NIL; 4110 return status; 4111 } 4112 4113 /************************************************************************* 4114 * trio_aprintf 4115 */ 4116 4117 /* Deprecated */ 4118 TRIO_PUBLIC char * 4119 trio_aprintf 4120 TRIO_VARGS2((format, va_alist), 4121 TRIO_CONST char *format, 4122 TRIO_VA_DECL) 4123 { 4124 va_list args; 4125 trio_string_t *info; 4126 char *result = NULL; 4127 4128 assert(VALID(format)); 4129 4130 info = trio_xstring_duplicate(""); 4131 if (info) 4132 { 4133 TRIO_VA_START(args, format); 4134 (void)TrioFormat(info, 0, TrioOutStreamStringDynamic, 4135 format, &args, NULL); 4136 TRIO_VA_END(args); 4137 4138 trio_string_terminate(info); 4139 result = trio_string_extract(info); 4140 trio_string_destroy(info); 4141 } 4142 return result; 4143 } 4144 4145 /* Deprecated */ 4146 TRIO_PUBLIC char * 4147 trio_vaprintf 4148 TRIO_ARGS2((format, args), 4149 TRIO_CONST char *format, 4150 va_list args) 4151 { 4152 trio_string_t *info; 4153 char *result = NULL; 4154 4155 assert(VALID(format)); 4156 4157 info = trio_xstring_duplicate(""); 4158 if (info) 4159 { 4160 (void)TrioFormat(info, 0, TrioOutStreamStringDynamic, 4161 format, &args, NULL); 4162 trio_string_terminate(info); 4163 result = trio_string_extract(info); 4164 trio_string_destroy(info); 4165 } 4166 return result; 4167 } 4168 4169 TRIO_PUBLIC int 4170 trio_asprintf 4171 TRIO_VARGS3((result, format, va_alist), 4172 char **result, 4173 TRIO_CONST char *format, 4174 TRIO_VA_DECL) 4175 { 4176 va_list args; 4177 int status; 4178 trio_string_t *info; 4179 4180 assert(VALID(format)); 4181 4182 *result = NULL; 4183 4184 info = trio_xstring_duplicate(""); 4185 if (info == NULL) 4186 { 4187 status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0); 4188 } 4189 else 4190 { 4191 TRIO_VA_START(args, format); 4192 status = TrioFormat(info, 0, TrioOutStreamStringDynamic, 4193 format, &args, NULL); 4194 TRIO_VA_END(args); 4195 if (status >= 0) 4196 { 4197 trio_string_terminate(info); 4198 *result = trio_string_extract(info); 4199 } 4200 trio_string_destroy(info); 4201 } 4202 return status; 4203 } 4204 4205 TRIO_PUBLIC int 4206 trio_vasprintf 4207 TRIO_ARGS3((result, format, args), 4208 char **result, 4209 TRIO_CONST char *format, 4210 va_list args) 4211 { 4212 int status; 4213 trio_string_t *info; 4214 4215 assert(VALID(format)); 4216 4217 *result = NULL; 4218 4219 info = trio_xstring_duplicate(""); 4220 if (info == NULL) 4221 { 4222 status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0); 4223 } 4224 else 4225 { 4226 status = TrioFormat(info, 0, TrioOutStreamStringDynamic, 4227 format, &args, NULL); 4228 if (status >= 0) 4229 { 4230 trio_string_terminate(info); 4231 *result = trio_string_extract(info); 4232 } 4233 trio_string_destroy(info); 4234 } 4235 return status; 4236 } 4237 4238 /** @} End of Printf documentation module */ 4239 4240 /************************************************************************* 4241 * 4242 * CALLBACK 4243 * 4244 ************************************************************************/ 4245 4246 #if defined(TRIO_DOCUMENTATION) 4247 # include "doc/doc_register.h" 4248 #endif 4249 /** 4250 @addtogroup UserDefined 4251 @{ 4252 */ 4253 4254 #if TRIO_EXTENSION 4255 4256 /************************************************************************* 4257 * trio_register 4258 */ 4259 4260 /** 4261 Register new user-defined specifier. 4262 4263 @param callback 4264 @param name 4265 @return Handle. 4266 */ 4267 TRIO_PUBLIC trio_pointer_t 4268 trio_register 4269 TRIO_ARGS2((callback, name), 4270 trio_callback_t callback, 4271 TRIO_CONST char *name) 4272 { 4273 trio_userdef_t *def; 4274 trio_userdef_t *prev = NULL; 4275 4276 if (callback == NULL) 4277 return NULL; 4278 4279 if (name) 4280 { 4281 /* Handle built-in namespaces */ 4282 if (name[0] == ':') 4283 { 4284 if (trio_equal(name, ":enter")) 4285 { 4286 internalEnterCriticalRegion = callback; 4287 } 4288 else if (trio_equal(name, ":leave")) 4289 { 4290 internalLeaveCriticalRegion = callback; 4291 } 4292 return NULL; 4293 } 4294 4295 /* Bail out if namespace is too long */ 4296 if (trio_length(name) >= MAX_USER_NAME) 4297 return NULL; 4298 4299 /* Bail out if namespace already is registered */ 4300 def = TrioFindNamespace(name, &prev); 4301 if (def) 4302 return NULL; 4303 } 4304 4305 def = (trio_userdef_t *)TRIO_MALLOC(sizeof(trio_userdef_t)); 4306 if (def) 4307 { 4308 if (internalEnterCriticalRegion) 4309 (void)internalEnterCriticalRegion(NULL); 4310 4311 if (name) 4312 { 4313 /* Link into internal list */ 4314 if (prev == NULL) 4315 internalUserDef = def; 4316 else 4317 prev->next = def; 4318 } 4319 /* Initialize */ 4320 def->callback = callback; 4321 def->name = (name == NULL) 4322 ? NULL 4323 : trio_duplicate(name); 4324 def->next = NULL; 4325 4326 if (internalLeaveCriticalRegion) 4327 (void)internalLeaveCriticalRegion(NULL); 4328 } 4329 return (trio_pointer_t)def; 4330 } 4331 4332 /** 4333 Unregister an existing user-defined specifier. 4334 4335 @param handle 4336 */ 4337 void 4338 trio_unregister 4339 TRIO_ARGS1((handle), 4340 trio_pointer_t handle) 4341 { 4342 trio_userdef_t *self = (trio_userdef_t *)handle; 4343 trio_userdef_t *def; 4344 trio_userdef_t *prev = NULL; 4345 4346 assert(VALID(self)); 4347 4348 if (self->name) 4349 { 4350 def = TrioFindNamespace(self->name, &prev); 4351 if (def) 4352 { 4353 if (internalEnterCriticalRegion) 4354 (void)internalEnterCriticalRegion(NULL); 4355 4356 if (prev == NULL) 4357 internalUserDef = NULL; 4358 else 4359 prev->next = def->next; 4360 4361 if (internalLeaveCriticalRegion) 4362 (void)internalLeaveCriticalRegion(NULL); 4363 } 4364 trio_destroy(self->name); 4365 } 4366 TRIO_FREE(self); 4367 } 4368 4369 /************************************************************************* 4370 * trio_get_format [public] 4371 */ 4372 TRIO_CONST char * 4373 trio_get_format 4374 TRIO_ARGS1((ref), 4375 trio_pointer_t ref) 4376 { 4377 #if defined(FORMAT_USER_DEFINED) 4378 assert(((trio_reference_t *)ref)->parameter->type == FORMAT_USER_DEFINED); 4379 #endif 4380 4381 return (((trio_reference_t *)ref)->parameter->user_data); 4382 } 4383 4384 /************************************************************************* 4385 * trio_get_argument [public] 4386 */ 4387 trio_pointer_t 4388 trio_get_argument 4389 TRIO_ARGS1((ref), 4390 trio_pointer_t ref) 4391 { 4392 #if defined(FORMAT_USER_DEFINED) 4393 assert(((trio_reference_t *)ref)->parameter->type == FORMAT_USER_DEFINED); 4394 #endif 4395 4396 return ((trio_reference_t *)ref)->parameter->data.pointer; 4397 } 4398 4399 /************************************************************************* 4400 * trio_get_width / trio_set_width [public] 4401 */ 4402 int 4403 trio_get_width 4404 TRIO_ARGS1((ref), 4405 trio_pointer_t ref) 4406 { 4407 return ((trio_reference_t *)ref)->parameter->width; 4408 } 4409 4410 void 4411 trio_set_width 4412 TRIO_ARGS2((ref, width), 4413 trio_pointer_t ref, 4414 int width) 4415 { 4416 ((trio_reference_t *)ref)->parameter->width = width; 4417 } 4418 4419 /************************************************************************* 4420 * trio_get_precision / trio_set_precision [public] 4421 */ 4422 int 4423 trio_get_precision 4424 TRIO_ARGS1((ref), 4425 trio_pointer_t ref) 4426 { 4427 return (((trio_reference_t *)ref)->parameter->precision); 4428 } 4429 4430 void 4431 trio_set_precision 4432 TRIO_ARGS2((ref, precision), 4433 trio_pointer_t ref, 4434 int precision) 4435 { 4436 ((trio_reference_t *)ref)->parameter->precision = precision; 4437 } 4438 4439 /************************************************************************* 4440 * trio_get_base / trio_set_base [public] 4441 */ 4442 int 4443 trio_get_base 4444 TRIO_ARGS1((ref), 4445 trio_pointer_t ref) 4446 { 4447 return (((trio_reference_t *)ref)->parameter->base); 4448 } 4449 4450 void 4451 trio_set_base 4452 TRIO_ARGS2((ref, base), 4453 trio_pointer_t ref, 4454 int base) 4455 { 4456 ((trio_reference_t *)ref)->parameter->base = base; 4457 } 4458 4459 /************************************************************************* 4460 * trio_get_long / trio_set_long [public] 4461 */ 4462 int 4463 trio_get_long 4464 TRIO_ARGS1((ref), 4465 trio_pointer_t ref) 4466 { 4467 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LONG) 4468 ? TRUE 4469 : FALSE; 4470 } 4471 4472 void 4473 trio_set_long 4474 TRIO_ARGS2((ref, is_long), 4475 trio_pointer_t ref, 4476 int is_long) 4477 { 4478 if (is_long) 4479 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LONG; 4480 else 4481 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LONG; 4482 } 4483 4484 /************************************************************************* 4485 * trio_get_longlong / trio_set_longlong [public] 4486 */ 4487 int 4488 trio_get_longlong 4489 TRIO_ARGS1((ref), 4490 trio_pointer_t ref) 4491 { 4492 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_QUAD) 4493 ? TRUE 4494 : FALSE; 4495 } 4496 4497 void 4498 trio_set_longlong 4499 TRIO_ARGS2((ref, is_longlong), 4500 trio_pointer_t ref, 4501 int is_longlong) 4502 { 4503 if (is_longlong) 4504 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_QUAD; 4505 else 4506 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_QUAD; 4507 } 4508 4509 /************************************************************************* 4510 * trio_get_longdouble / trio_set_longdouble [public] 4511 */ 4512 int 4513 trio_get_longdouble 4514 TRIO_ARGS1((ref), 4515 trio_pointer_t ref) 4516 { 4517 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LONGDOUBLE) 4518 ? TRUE 4519 : FALSE; 4520 } 4521 4522 void 4523 trio_set_longdouble 4524 TRIO_ARGS2((ref, is_longdouble), 4525 trio_pointer_t ref, 4526 int is_longdouble) 4527 { 4528 if (is_longdouble) 4529 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LONGDOUBLE; 4530 else 4531 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LONGDOUBLE; 4532 } 4533 4534 /************************************************************************* 4535 * trio_get_short / trio_set_short [public] 4536 */ 4537 int 4538 trio_get_short 4539 TRIO_ARGS1((ref), 4540 trio_pointer_t ref) 4541 { 4542 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHORT) 4543 ? TRUE 4544 : FALSE; 4545 } 4546 4547 void 4548 trio_set_short 4549 TRIO_ARGS2((ref, is_short), 4550 trio_pointer_t ref, 4551 int is_short) 4552 { 4553 if (is_short) 4554 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHORT; 4555 else 4556 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHORT; 4557 } 4558 4559 /************************************************************************* 4560 * trio_get_shortshort / trio_set_shortshort [public] 4561 */ 4562 int 4563 trio_get_shortshort 4564 TRIO_ARGS1((ref), 4565 trio_pointer_t ref) 4566 { 4567 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHORTSHORT) 4568 ? TRUE 4569 : FALSE; 4570 } 4571 4572 void 4573 trio_set_shortshort 4574 TRIO_ARGS2((ref, is_shortshort), 4575 trio_pointer_t ref, 4576 int is_shortshort) 4577 { 4578 if (is_shortshort) 4579 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHORTSHORT; 4580 else 4581 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHORTSHORT; 4582 } 4583 4584 /************************************************************************* 4585 * trio_get_alternative / trio_set_alternative [public] 4586 */ 4587 int 4588 trio_get_alternative 4589 TRIO_ARGS1((ref), 4590 trio_pointer_t ref) 4591 { 4592 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_ALTERNATIVE) 4593 ? TRUE 4594 : FALSE; 4595 } 4596 4597 void 4598 trio_set_alternative 4599 TRIO_ARGS2((ref, is_alternative), 4600 trio_pointer_t ref, 4601 int is_alternative) 4602 { 4603 if (is_alternative) 4604 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_ALTERNATIVE; 4605 else 4606 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_ALTERNATIVE; 4607 } 4608 4609 /************************************************************************* 4610 * trio_get_alignment / trio_set_alignment [public] 4611 */ 4612 int 4613 trio_get_alignment 4614 TRIO_ARGS1((ref), 4615 trio_pointer_t ref) 4616 { 4617 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LEFTADJUST) 4618 ? TRUE 4619 : FALSE; 4620 } 4621 4622 void 4623 trio_set_alignment 4624 TRIO_ARGS2((ref, is_leftaligned), 4625 trio_pointer_t ref, 4626 int is_leftaligned) 4627 { 4628 if (is_leftaligned) 4629 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LEFTADJUST; 4630 else 4631 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LEFTADJUST; 4632 } 4633 4634 /************************************************************************* 4635 * trio_get_spacing /trio_set_spacing [public] 4636 */ 4637 int 4638 trio_get_spacing 4639 TRIO_ARGS1((ref), 4640 trio_pointer_t ref) 4641 { 4642 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SPACE) 4643 ? TRUE 4644 : FALSE; 4645 } 4646 4647 void 4648 trio_set_spacing 4649 TRIO_ARGS2((ref, is_space), 4650 trio_pointer_t ref, 4651 int is_space) 4652 { 4653 if (is_space) 4654 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SPACE; 4655 else 4656 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SPACE; 4657 } 4658 4659 /************************************************************************* 4660 * trio_get_sign / trio_set_sign [public] 4661 */ 4662 int 4663 trio_get_sign 4664 TRIO_ARGS1((ref), 4665 trio_pointer_t ref) 4666 { 4667 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHOWSIGN) 4668 ? TRUE 4669 : FALSE; 4670 } 4671 4672 void 4673 trio_set_sign 4674 TRIO_ARGS2((ref, is_sign), 4675 trio_pointer_t ref, 4676 int is_sign) 4677 { 4678 if (is_sign) 4679 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHOWSIGN; 4680 else 4681 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHOWSIGN; 4682 } 4683 4684 /************************************************************************* 4685 * trio_get_padding / trio_set_padding [public] 4686 */ 4687 int 4688 trio_get_padding 4689 TRIO_ARGS1((ref), 4690 trio_pointer_t ref) 4691 { 4692 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_NILPADDING) 4693 ? TRUE 4694 : FALSE; 4695 } 4696 4697 void 4698 trio_set_padding 4699 TRIO_ARGS2((ref, is_padding), 4700 trio_pointer_t ref, 4701 int is_padding) 4702 { 4703 if (is_padding) 4704 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_NILPADDING; 4705 else 4706 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_NILPADDING; 4707 } 4708 4709 /************************************************************************* 4710 * trio_get_quote / trio_set_quote [public] 4711 */ 4712 int 4713 trio_get_quote 4714 TRIO_ARGS1((ref), 4715 trio_pointer_t ref) 4716 { 4717 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_QUOTE) 4718 ? TRUE 4719 : FALSE; 4720 } 4721 4722 void 4723 trio_set_quote 4724 TRIO_ARGS2((ref, is_quote), 4725 trio_pointer_t ref, 4726 int is_quote) 4727 { 4728 if (is_quote) 4729 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_QUOTE; 4730 else 4731 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_QUOTE; 4732 } 4733 4734 /************************************************************************* 4735 * trio_get_upper / trio_set_upper [public] 4736 */ 4737 int 4738 trio_get_upper 4739 TRIO_ARGS1((ref), 4740 trio_pointer_t ref) 4741 { 4742 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_UPPER) 4743 ? TRUE 4744 : FALSE; 4745 } 4746 4747 void 4748 trio_set_upper 4749 TRIO_ARGS2((ref, is_upper), 4750 trio_pointer_t ref, 4751 int is_upper) 4752 { 4753 if (is_upper) 4754 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_UPPER; 4755 else 4756 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_UPPER; 4757 } 4758 4759 /************************************************************************* 4760 * trio_get_largest / trio_set_largest [public] 4761 */ 4762 #if TRIO_C99 4763 int 4764 trio_get_largest 4765 TRIO_ARGS1((ref), 4766 trio_pointer_t ref) 4767 { 4768 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_INTMAX_T) 4769 ? TRUE 4770 : FALSE; 4771 } 4772 4773 void 4774 trio_set_largest 4775 TRIO_ARGS2((ref, is_largest), 4776 trio_pointer_t ref, 4777 int is_largest) 4778 { 4779 if (is_largest) 4780 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_INTMAX_T; 4781 else 4782 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_INTMAX_T; 4783 } 4784 #endif 4785 4786 /************************************************************************* 4787 * trio_get_ptrdiff / trio_set_ptrdiff [public] 4788 */ 4789 int 4790 trio_get_ptrdiff 4791 TRIO_ARGS1((ref), 4792 trio_pointer_t ref) 4793 { 4794 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_PTRDIFF_T) 4795 ? TRUE 4796 : FALSE; 4797 } 4798 4799 void 4800 trio_set_ptrdiff 4801 TRIO_ARGS2((ref, is_ptrdiff), 4802 trio_pointer_t ref, 4803 int is_ptrdiff) 4804 { 4805 if (is_ptrdiff) 4806 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_PTRDIFF_T; 4807 else 4808 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_PTRDIFF_T; 4809 } 4810 4811 /************************************************************************* 4812 * trio_get_size / trio_set_size [public] 4813 */ 4814 #if TRIO_C99 4815 int 4816 trio_get_size 4817 TRIO_ARGS1((ref), 4818 trio_pointer_t ref) 4819 { 4820 return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SIZE_T) 4821 ? TRUE 4822 : FALSE; 4823 } 4824 4825 void 4826 trio_set_size 4827 TRIO_ARGS2((ref, is_size), 4828 trio_pointer_t ref, 4829 int is_size) 4830 { 4831 if (is_size) 4832 ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SIZE_T; 4833 else 4834 ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SIZE_T; 4835 } 4836 #endif 4837 4838 /************************************************************************* 4839 * trio_print_int [public] 4840 */ 4841 void 4842 trio_print_int 4843 TRIO_ARGS2((ref, number), 4844 trio_pointer_t ref, 4845 int number) 4846 { 4847 trio_reference_t *self = (trio_reference_t *)ref; 4848 4849 TrioWriteNumber(self->data, 4850 (trio_uintmax_t)number, 4851 self->parameter->flags, 4852 self->parameter->width, 4853 self->parameter->precision, 4854 self->parameter->base); 4855 } 4856 4857 /************************************************************************* 4858 * trio_print_uint [public] 4859 */ 4860 void 4861 trio_print_uint 4862 TRIO_ARGS2((ref, number), 4863 trio_pointer_t ref, 4864 unsigned int number) 4865 { 4866 trio_reference_t *self = (trio_reference_t *)ref; 4867 4868 TrioWriteNumber(self->data, 4869 (trio_uintmax_t)number, 4870 self->parameter->flags | FLAGS_UNSIGNED, 4871 self->parameter->width, 4872 self->parameter->precision, 4873 self->parameter->base); 4874 } 4875 4876 /************************************************************************* 4877 * trio_print_double [public] 4878 */ 4879 void 4880 trio_print_double 4881 TRIO_ARGS2((ref, number), 4882 trio_pointer_t ref, 4883 double number) 4884 { 4885 trio_reference_t *self = (trio_reference_t *)ref; 4886 4887 TrioWriteDouble(self->data, 4888 number, 4889 self->parameter->flags, 4890 self->parameter->width, 4891 self->parameter->precision, 4892 self->parameter->base); 4893 } 4894 4895 /************************************************************************* 4896 * trio_print_string [public] 4897 */ 4898 void 4899 trio_print_string 4900 TRIO_ARGS2((ref, string), 4901 trio_pointer_t ref, 4902 char *string) 4903 { 4904 trio_reference_t *self = (trio_reference_t *)ref; 4905 4906 TrioWriteString(self->data, 4907 string, 4908 self->parameter->flags, 4909 self->parameter->width, 4910 self->parameter->precision); 4911 } 4912 4913 /************************************************************************* 4914 * trio_print_ref [public] 4915 */ 4916 int 4917 trio_print_ref 4918 TRIO_VARGS3((ref, format, va_alist), 4919 trio_pointer_t ref, 4920 TRIO_CONST char *format, 4921 TRIO_VA_DECL) 4922 { 4923 int status; 4924 va_list arglist; 4925 4926 assert(VALID(format)); 4927 4928 TRIO_VA_START(arglist, format); 4929 status = TrioFormatRef((trio_reference_t *)ref, format, &arglist, NULL); 4930 TRIO_VA_END(arglist); 4931 return status; 4932 } 4933 4934 /************************************************************************* 4935 * trio_vprint_ref [public] 4936 */ 4937 int 4938 trio_vprint_ref 4939 TRIO_ARGS3((ref, format, arglist), 4940 trio_pointer_t ref, 4941 TRIO_CONST char *format, 4942 va_list arglist) 4943 { 4944 assert(VALID(format)); 4945 4946 return TrioFormatRef((trio_reference_t *)ref, format, &arglist, NULL); 4947 } 4948 4949 /************************************************************************* 4950 * trio_printv_ref [public] 4951 */ 4952 int 4953 trio_printv_ref 4954 TRIO_ARGS3((ref, format, argarray), 4955 trio_pointer_t ref, 4956 TRIO_CONST char *format, 4957 trio_pointer_t *argarray) 4958 { 4959 assert(VALID(format)); 4960 4961 return TrioFormatRef((trio_reference_t *)ref, format, NULL, argarray); 4962 } 4963 4964 #endif /* TRIO_EXTENSION */ 4965 4966 /************************************************************************* 4967 * trio_print_pointer [public] 4968 */ 4969 void 4970 trio_print_pointer 4971 TRIO_ARGS2((ref, pointer), 4972 trio_pointer_t ref, 4973 trio_pointer_t pointer) 4974 { 4975 trio_reference_t *self = (trio_reference_t *)ref; 4976 trio_flags_t flags; 4977 trio_uintmax_t number; 4978 4979 if (NULL == pointer) 4980 { 4981 TRIO_CONST char *string = internalNullString; 4982 while (*string) 4983 self->data->OutStream(self->data, *string++); 4984 } 4985 else 4986 { 4987 /* 4988 * The subtraction of the null pointer is a workaround 4989 * to avoid a compiler warning. The performance overhead 4990 * is negligible (and likely to be removed by an 4991 * optimizing compiler). The (char *) casting is done 4992 * to please ANSI C++. 4993 */ 4994 number = (trio_uintmax_t)((char *)pointer - (char *)0); 4995 /* Shrink to size of pointer */ 4996 number &= (trio_uintmax_t)-1; 4997 flags = self->parameter->flags; 4998 flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | 4999 FLAGS_NILPADDING); 5000 TrioWriteNumber(self->data, 5001 number, 5002 flags, 5003 POINTER_WIDTH, 5004 NO_PRECISION, 5005 BASE_HEX); 5006 } 5007 } 5008 5009 /** @} End of UserDefined documentation module */ 5010 5011 /************************************************************************* 5012 * 5013 * LOCALES 5014 * 5015 ************************************************************************/ 5016 5017 /************************************************************************* 5018 * trio_locale_set_decimal_point 5019 * 5020 * Decimal point can only be one character. The input argument is a 5021 * string to enable multibyte characters. At most MB_LEN_MAX characters 5022 * will be used. 5023 */ 5024 TRIO_PUBLIC void 5025 trio_locale_set_decimal_point 5026 TRIO_ARGS1((decimalPoint), 5027 char *decimalPoint) 5028 { 5029 #if defined(USE_LOCALE) 5030 if (NULL == internalLocaleValues) 5031 { 5032 TrioSetLocale(); 5033 } 5034 #endif 5035 internalDecimalPointLength = trio_length(decimalPoint); 5036 if (internalDecimalPointLength == 1) 5037 { 5038 internalDecimalPoint = *decimalPoint; 5039 } 5040 else 5041 { 5042 internalDecimalPoint = NIL; 5043 trio_copy_max(internalDecimalPointString, 5044 sizeof(internalDecimalPointString), 5045 decimalPoint); 5046 } 5047 } 5048 5049 /************************************************************************* 5050 * trio_locale_set_thousand_separator 5051 * 5052 * See trio_locale_set_decimal_point 5053 */ 5054 TRIO_PUBLIC void 5055 trio_locale_set_thousand_separator 5056 TRIO_ARGS1((thousandSeparator), 5057 char *thousandSeparator) 5058 { 5059 #if defined(USE_LOCALE) 5060 if (NULL == internalLocaleValues) 5061 { 5062 TrioSetLocale(); 5063 } 5064 #endif 5065 trio_copy_max(internalThousandSeparator, 5066 sizeof(internalThousandSeparator), 5067 thousandSeparator); 5068 internalThousandSeparatorLength = trio_length(internalThousandSeparator); 5069 } 5070 5071 /************************************************************************* 5072 * trio_locale_set_grouping 5073 * 5074 * Array of bytes. Reversed order. 5075 * 5076 * CHAR_MAX : No further grouping 5077 * 0 : Repeat last group for the remaining digits (not necessary 5078 * as C strings are zero-terminated) 5079 * n : Set current group to n 5080 * 5081 * Same order as the grouping attribute in LC_NUMERIC. 5082 */ 5083 TRIO_PUBLIC void 5084 trio_locale_set_grouping 5085 TRIO_ARGS1((grouping), 5086 char *grouping) 5087 { 5088 #if defined(USE_LOCALE) 5089 if (NULL == internalLocaleValues) 5090 { 5091 TrioSetLocale(); 5092 } 5093 #endif 5094 trio_copy_max(internalGrouping, 5095 sizeof(internalGrouping), 5096 grouping); 5097 } 5098 5099 5100 /************************************************************************* 5101 * 5102 * SCANNING 5103 * 5104 ************************************************************************/ 5105 5106 /************************************************************************* 5107 * TrioSkipWhitespaces 5108 */ 5109 TRIO_PRIVATE int 5110 TrioSkipWhitespaces 5111 TRIO_ARGS1((self), 5112 trio_class_t *self) 5113 { 5114 int ch; 5115 5116 ch = self->current; 5117 while (isspace(ch)) 5118 { 5119 self->InStream(self, &ch); 5120 } 5121 return ch; 5122 } 5123 5124 /************************************************************************* 5125 * TrioGetCollation 5126 */ 5127 #if TRIO_EXTENSION 5128 TRIO_PRIVATE void 5129 TrioGetCollation(TRIO_NOARGS) 5130 { 5131 int i; 5132 int j; 5133 int k; 5134 char first[2]; 5135 char second[2]; 5136 5137 /* This is computationally expensive */ 5138 first[1] = NIL; 5139 second[1] = NIL; 5140 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5141 { 5142 k = 0; 5143 first[0] = (char)i; 5144 for (j = 0; j < MAX_CHARACTER_CLASS; j++) 5145 { 5146 second[0] = (char)j; 5147 if (trio_equal_locale(first, second)) 5148 internalCollationArray[i][k++] = (char)j; 5149 } 5150 internalCollationArray[i][k] = NIL; 5151 } 5152 } 5153 #endif 5154 5155 /************************************************************************* 5156 * TrioGetCharacterClass 5157 * 5158 * FIXME: 5159 * multibyte 5160 */ 5161 TRIO_PRIVATE int 5162 TrioGetCharacterClass 5163 TRIO_ARGS4((format, indexPointer, flagsPointer, characterclass), 5164 TRIO_CONST char *format, 5165 int *indexPointer, 5166 trio_flags_t *flagsPointer, 5167 int *characterclass) 5168 { 5169 int index = *indexPointer; 5170 int i; 5171 char ch; 5172 char range_begin; 5173 char range_end; 5174 5175 *flagsPointer &= ~FLAGS_EXCLUDE; 5176 5177 if (format[index] == QUALIFIER_CIRCUMFLEX) 5178 { 5179 *flagsPointer |= FLAGS_EXCLUDE; 5180 index++; 5181 } 5182 /* 5183 * If the ungroup character is at the beginning of the scanlist, 5184 * it will be part of the class, and a second ungroup character 5185 * must follow to end the group. 5186 */ 5187 if (format[index] == SPECIFIER_UNGROUP) 5188 { 5189 characterclass[(int)SPECIFIER_UNGROUP]++; 5190 index++; 5191 } 5192 /* 5193 * Minus is used to specify ranges. To include minus in the class, 5194 * it must be at the beginning of the list 5195 */ 5196 if (format[index] == QUALIFIER_MINUS) 5197 { 5198 characterclass[(int)QUALIFIER_MINUS]++; 5199 index++; 5200 } 5201 /* Collect characters */ 5202 for (ch = format[index]; 5203 (ch != SPECIFIER_UNGROUP) && (ch != NIL); 5204 ch = format[++index]) 5205 { 5206 switch (ch) 5207 { 5208 case QUALIFIER_MINUS: /* Scanlist ranges */ 5209 5210 /* 5211 * Both C99 and UNIX98 describes ranges as implementation- 5212 * defined. 5213 * 5214 * We support the following behaviour (although this may 5215 * change as we become wiser) 5216 * - only increasing ranges, ie. [a-b] but not [b-a] 5217 * - transitive ranges, ie. [a-b-c] == [a-c] 5218 * - trailing minus, ie. [a-] is interpreted as an 'a' 5219 * and a '-' 5220 * - duplicates (although we can easily convert these 5221 * into errors) 5222 */ 5223 range_begin = format[index - 1]; 5224 range_end = format[++index]; 5225 if (range_end == SPECIFIER_UNGROUP) 5226 { 5227 /* Trailing minus is included */ 5228 characterclass[(int)ch]++; 5229 ch = range_end; 5230 break; /* for */ 5231 } 5232 if (range_end == NIL) 5233 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 5234 if (range_begin > range_end) 5235 return TRIO_ERROR_RETURN(TRIO_ERANGE, index); 5236 5237 for (i = (int)range_begin; i <= (int)range_end; i++) 5238 characterclass[i]++; 5239 5240 ch = range_end; 5241 break; 5242 5243 #if TRIO_EXTENSION 5244 5245 case SPECIFIER_GROUP: 5246 5247 switch (format[index + 1]) 5248 { 5249 case QUALIFIER_DOT: /* Collating symbol */ 5250 /* 5251 * FIXME: This will be easier to implement when multibyte 5252 * characters have been implemented. Until now, we ignore 5253 * this feature. 5254 */ 5255 for (i = index + 2; ; i++) 5256 { 5257 if (format[i] == NIL) 5258 /* Error in syntax */ 5259 return -1; 5260 else if (format[i] == QUALIFIER_DOT) 5261 break; /* for */ 5262 } 5263 if (format[++i] != SPECIFIER_UNGROUP) 5264 return -1; 5265 5266 index = i; 5267 break; 5268 5269 case QUALIFIER_EQUAL: /* Equivalence class expressions */ 5270 { 5271 unsigned int j; 5272 unsigned int k; 5273 5274 if (internalCollationUnconverted) 5275 { 5276 /* Lazy evaluation of collation array */ 5277 TrioGetCollation(); 5278 internalCollationUnconverted = FALSE; 5279 } 5280 for (i = index + 2; ; i++) 5281 { 5282 if (format[i] == NIL) 5283 /* Error in syntax */ 5284 return -1; 5285 else if (format[i] == QUALIFIER_EQUAL) 5286 break; /* for */ 5287 else 5288 { 5289 /* Mark any equivalent character */ 5290 k = (unsigned int)format[i]; 5291 for (j = 0; internalCollationArray[k][j] != NIL; j++) 5292 characterclass[(int)internalCollationArray[k][j]]++; 5293 } 5294 } 5295 if (format[++i] != SPECIFIER_UNGROUP) 5296 return -1; 5297 5298 index = i; 5299 } 5300 break; 5301 5302 case QUALIFIER_COLON: /* Character class expressions */ 5303 5304 if (trio_equal_max(CLASS_ALNUM, sizeof(CLASS_ALNUM) - 1, 5305 &format[index])) 5306 { 5307 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5308 if (isalnum(i)) 5309 characterclass[i]++; 5310 index += sizeof(CLASS_ALNUM) - 1; 5311 } 5312 else if (trio_equal_max(CLASS_ALPHA, sizeof(CLASS_ALPHA) - 1, 5313 &format[index])) 5314 { 5315 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5316 if (isalpha(i)) 5317 characterclass[i]++; 5318 index += sizeof(CLASS_ALPHA) - 1; 5319 } 5320 else if (trio_equal_max(CLASS_CNTRL, sizeof(CLASS_CNTRL) - 1, 5321 &format[index])) 5322 { 5323 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5324 if (iscntrl(i)) 5325 characterclass[i]++; 5326 index += sizeof(CLASS_CNTRL) - 1; 5327 } 5328 else if (trio_equal_max(CLASS_DIGIT, sizeof(CLASS_DIGIT) - 1, 5329 &format[index])) 5330 { 5331 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5332 if (isdigit(i)) 5333 characterclass[i]++; 5334 index += sizeof(CLASS_DIGIT) - 1; 5335 } 5336 else if (trio_equal_max(CLASS_GRAPH, sizeof(CLASS_GRAPH) - 1, 5337 &format[index])) 5338 { 5339 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5340 if (isgraph(i)) 5341 characterclass[i]++; 5342 index += sizeof(CLASS_GRAPH) - 1; 5343 } 5344 else if (trio_equal_max(CLASS_LOWER, sizeof(CLASS_LOWER) - 1, 5345 &format[index])) 5346 { 5347 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5348 if (islower(i)) 5349 characterclass[i]++; 5350 index += sizeof(CLASS_LOWER) - 1; 5351 } 5352 else if (trio_equal_max(CLASS_PRINT, sizeof(CLASS_PRINT) - 1, 5353 &format[index])) 5354 { 5355 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5356 if (isprint(i)) 5357 characterclass[i]++; 5358 index += sizeof(CLASS_PRINT) - 1; 5359 } 5360 else if (trio_equal_max(CLASS_PUNCT, sizeof(CLASS_PUNCT) - 1, 5361 &format[index])) 5362 { 5363 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5364 if (ispunct(i)) 5365 characterclass[i]++; 5366 index += sizeof(CLASS_PUNCT) - 1; 5367 } 5368 else if (trio_equal_max(CLASS_SPACE, sizeof(CLASS_SPACE) - 1, 5369 &format[index])) 5370 { 5371 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5372 if (isspace(i)) 5373 characterclass[i]++; 5374 index += sizeof(CLASS_SPACE) - 1; 5375 } 5376 else if (trio_equal_max(CLASS_UPPER, sizeof(CLASS_UPPER) - 1, 5377 &format[index])) 5378 { 5379 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5380 if (isupper(i)) 5381 characterclass[i]++; 5382 index += sizeof(CLASS_UPPER) - 1; 5383 } 5384 else if (trio_equal_max(CLASS_XDIGIT, sizeof(CLASS_XDIGIT) - 1, 5385 &format[index])) 5386 { 5387 for (i = 0; i < MAX_CHARACTER_CLASS; i++) 5388 if (isxdigit(i)) 5389 characterclass[i]++; 5390 index += sizeof(CLASS_XDIGIT) - 1; 5391 } 5392 else 5393 { 5394 characterclass[(int)ch]++; 5395 } 5396 break; 5397 5398 default: 5399 characterclass[(int)ch]++; 5400 break; 5401 } 5402 break; 5403 5404 #endif /* TRIO_EXTENSION */ 5405 5406 default: 5407 characterclass[(int)ch]++; 5408 break; 5409 } 5410 } 5411 return 0; 5412 } 5413 5414 /************************************************************************* 5415 * TrioReadNumber 5416 * 5417 * We implement our own number conversion in preference of strtol and 5418 * strtoul, because we must handle 'long long' and thousand separators. 5419 */ 5420 TRIO_PRIVATE BOOLEAN_T 5421 TrioReadNumber 5422 TRIO_ARGS5((self, target, flags, width, base), 5423 trio_class_t *self, 5424 trio_uintmax_t *target, 5425 trio_flags_t flags, 5426 int width, 5427 int base) 5428 { 5429 trio_uintmax_t number = 0; 5430 int digit; 5431 int count; 5432 BOOLEAN_T isNegative = FALSE; 5433 BOOLEAN_T gotNumber = FALSE; 5434 int j; 5435 5436 assert(VALID(self)); 5437 assert(VALID(self->InStream)); 5438 assert((base >= MIN_BASE && base <= MAX_BASE) || (base == NO_BASE)); 5439 5440 if (internalDigitsUnconverted) 5441 { 5442 /* Lazy evaluation of digits array */ 5443 memset(internalDigitArray, -1, sizeof(internalDigitArray)); 5444 for (j = 0; j < (int)sizeof(internalDigitsLower) - 1; j++) 5445 { 5446 internalDigitArray[(int)internalDigitsLower[j]] = j; 5447 internalDigitArray[(int)internalDigitsUpper[j]] = j; 5448 } 5449 internalDigitsUnconverted = FALSE; 5450 } 5451 5452 TrioSkipWhitespaces(self); 5453 5454 if (!(flags & FLAGS_UNSIGNED)) 5455 { 5456 /* Leading sign */ 5457 if (self->current == '+') 5458 { 5459 self->InStream(self, NULL); 5460 } 5461 else if (self->current == '-') 5462 { 5463 self->InStream(self, NULL); 5464 isNegative = TRUE; 5465 } 5466 } 5467 5468 count = self->processed; 5469 5470 if (flags & FLAGS_ALTERNATIVE) 5471 { 5472 switch (base) 5473 { 5474 case NO_BASE: 5475 case BASE_OCTAL: 5476 case BASE_HEX: 5477 case BASE_BINARY: 5478 if (self->current == '0') 5479 { 5480 self->InStream(self, NULL); 5481 if (self->current) 5482 { 5483 if ((base == BASE_HEX) && 5484 (trio_to_upper(self->current) == 'X')) 5485 { 5486 self->InStream(self, NULL); 5487 } 5488 else if ((base == BASE_BINARY) && 5489 (trio_to_upper(self->current) == 'B')) 5490 { 5491 self->InStream(self, NULL); 5492 } 5493 } 5494 } 5495 else 5496 return FALSE; 5497 break; 5498 default: 5499 break; 5500 } 5501 } 5502 5503 while (((width == NO_WIDTH) || (self->processed - count < width)) && 5504 (! ((self->current == EOF) || isspace(self->current)))) 5505 { 5506 if (isascii(self->current)) 5507 { 5508 digit = internalDigitArray[self->current]; 5509 /* Abort if digit is not allowed in the specified base */ 5510 if ((digit == -1) || (digit >= base)) 5511 break; 5512 } 5513 else if (flags & FLAGS_QUOTE) 5514 { 5515 /* Compare with thousands separator */ 5516 for (j = 0; internalThousandSeparator[j] && self->current; j++) 5517 { 5518 if (internalThousandSeparator[j] != self->current) 5519 break; 5520 5521 self->InStream(self, NULL); 5522 } 5523 if (internalThousandSeparator[j]) 5524 break; /* Mismatch */ 5525 else 5526 continue; /* Match */ 5527 } 5528 else 5529 break; 5530 5531 number *= base; 5532 number += digit; 5533 gotNumber = TRUE; /* we need at least one digit */ 5534 5535 self->InStream(self, NULL); 5536 } 5537 5538 /* Was anything read at all? */ 5539 if (!gotNumber) 5540 return FALSE; 5541 5542 if (target) 5543 *target = (isNegative) ? -((trio_intmax_t)number) : number; 5544 return TRUE; 5545 } 5546 5547 /************************************************************************* 5548 * TrioReadChar 5549 */ 5550 TRIO_PRIVATE int 5551 TrioReadChar 5552 TRIO_ARGS4((self, target, flags, width), 5553 trio_class_t *self, 5554 char *target, 5555 trio_flags_t flags, 5556 int width) 5557 { 5558 int i; 5559 char ch; 5560 trio_uintmax_t number; 5561 5562 assert(VALID(self)); 5563 assert(VALID(self->InStream)); 5564 5565 for (i = 0; 5566 (self->current != EOF) && (i < width); 5567 i++) 5568 { 5569 ch = (char)self->current; 5570 self->InStream(self, NULL); 5571 if ((flags & FLAGS_ALTERNATIVE) && (ch == CHAR_BACKSLASH)) 5572 { 5573 switch (self->current) 5574 { 5575 case '\\': ch = '\\'; break; 5576 case 'a': ch = '\007'; break; 5577 case 'b': ch = '\b'; break; 5578 case 'f': ch = '\f'; break; 5579 case 'n': ch = '\n'; break; 5580 case 'r': ch = '\r'; break; 5581 case 't': ch = '\t'; break; 5582 case 'v': ch = '\v'; break; 5583 default: 5584 if (isdigit(self->current)) 5585 { 5586 /* Read octal number */ 5587 if (!TrioReadNumber(self, &number, 0, 3, BASE_OCTAL)) 5588 return 0; 5589 ch = (char)number; 5590 } 5591 else if (trio_to_upper(self->current) == 'X') 5592 { 5593 /* Read hexadecimal number */ 5594 self->InStream(self, NULL); 5595 if (!TrioReadNumber(self, &number, 0, 2, BASE_HEX)) 5596 return 0; 5597 ch = (char)number; 5598 } 5599 else 5600 { 5601 ch = (char)self->current; 5602 } 5603 break; 5604 } 5605 } 5606 5607 if (target) 5608 target[i] = ch; 5609 } 5610 return i + 1; 5611 } 5612 5613 /************************************************************************* 5614 * TrioReadString 5615 */ 5616 TRIO_PRIVATE BOOLEAN_T 5617 TrioReadString 5618 TRIO_ARGS4((self, target, flags, width), 5619 trio_class_t *self, 5620 char *target, 5621 trio_flags_t flags, 5622 int width) 5623 { 5624 int i; 5625 5626 assert(VALID(self)); 5627 assert(VALID(self->InStream)); 5628 5629 TrioSkipWhitespaces(self); 5630 5631 /* 5632 * Continue until end of string is reached, a whitespace is encountered, 5633 * or width is exceeded 5634 */ 5635 for (i = 0; 5636 ((width == NO_WIDTH) || (i < width)) && 5637 (! ((self->current == EOF) || isspace(self->current))); 5638 i++) 5639 { 5640 if (TrioReadChar(self, (target ? &target[i] : 0), flags, 1) == 0) 5641 break; /* for */ 5642 } 5643 if (target) 5644 target[i] = NIL; 5645 return TRUE; 5646 } 5647 5648 /************************************************************************* 5649 * TrioReadWideChar 5650 */ 5651 #if TRIO_WIDECHAR 5652 TRIO_PRIVATE int 5653 TrioReadWideChar 5654 TRIO_ARGS4((self, target, flags, width), 5655 trio_class_t *self, 5656 trio_wchar_t *target, 5657 trio_flags_t flags, 5658 int width) 5659 { 5660 int i; 5661 int j; 5662 int size; 5663 int amount = 0; 5664 trio_wchar_t wch; 5665 char buffer[MB_LEN_MAX + 1]; 5666 5667 assert(VALID(self)); 5668 assert(VALID(self->InStream)); 5669 5670 for (i = 0; 5671 (self->current != EOF) && (i < width); 5672 i++) 5673 { 5674 if (isascii(self->current)) 5675 { 5676 if (TrioReadChar(self, buffer, flags, 1) == 0) 5677 return 0; 5678 buffer[1] = NIL; 5679 } 5680 else 5681 { 5682 /* 5683 * Collect a multibyte character, by enlarging buffer until 5684 * it contains a fully legal multibyte character, or the 5685 * buffer is full. 5686 */ 5687 j = 0; 5688 do 5689 { 5690 buffer[j++] = (char)self->current; 5691 buffer[j] = NIL; 5692 self->InStream(self, NULL); 5693 } 5694 while ((j < (int)sizeof(buffer)) && (mblen(buffer, (size_t)j) != j)); 5695 } 5696 if (target) 5697 { 5698 size = mbtowc(&wch, buffer, sizeof(buffer)); 5699 if (size > 0) 5700 target[i] = wch; 5701 } 5702 amount += size; 5703 self->InStream(self, NULL); 5704 } 5705 return amount; 5706 } 5707 #endif /* TRIO_WIDECHAR */ 5708 5709 /************************************************************************* 5710 * TrioReadWideString 5711 */ 5712 #if TRIO_WIDECHAR 5713 TRIO_PRIVATE BOOLEAN_T 5714 TrioReadWideString 5715 TRIO_ARGS4((self, target, flags, width), 5716 trio_class_t *self, 5717 trio_wchar_t *target, 5718 trio_flags_t flags, 5719 int width) 5720 { 5721 int i; 5722 int size; 5723 5724 assert(VALID(self)); 5725 assert(VALID(self->InStream)); 5726 5727 TrioSkipWhitespaces(self); 5728 5729 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) 5730 (void)mblen(NULL, 0); 5731 #endif 5732 5733 /* 5734 * Continue until end of string is reached, a whitespace is encountered, 5735 * or width is exceeded 5736 */ 5737 for (i = 0; 5738 ((width == NO_WIDTH) || (i < width)) && 5739 (! ((self->current == EOF) || isspace(self->current))); 5740 ) 5741 { 5742 size = TrioReadWideChar(self, &target[i], flags, 1); 5743 if (size == 0) 5744 break; /* for */ 5745 5746 i += size; 5747 } 5748 if (target) 5749 target[i] = WCONST('\0'); 5750 return TRUE; 5751 } 5752 #endif /* TRIO_WIDECHAR */ 5753 5754 /************************************************************************* 5755 * TrioReadGroup 5756 * 5757 * FIXME: characterclass does not work with multibyte characters 5758 */ 5759 TRIO_PRIVATE BOOLEAN_T 5760 TrioReadGroup 5761 TRIO_ARGS5((self, target, characterclass, flags, width), 5762 trio_class_t *self, 5763 char *target, 5764 int *characterclass, 5765 trio_flags_t flags, 5766 int width) 5767 { 5768 int ch; 5769 int i; 5770 5771 assert(VALID(self)); 5772 assert(VALID(self->InStream)); 5773 5774 ch = self->current; 5775 for (i = 0; 5776 ((width == NO_WIDTH) || (i < width)) && 5777 (! ((ch == EOF) || 5778 (((flags & FLAGS_EXCLUDE) != 0) ^ (characterclass[ch] == 0)))); 5779 i++) 5780 { 5781 if (target) 5782 target[i] = (char)ch; 5783 self->InStream(self, &ch); 5784 } 5785 5786 if (target) 5787 target[i] = NIL; 5788 return TRUE; 5789 } 5790 5791 /************************************************************************* 5792 * TrioReadDouble 5793 * 5794 * FIXME: 5795 * add long double 5796 * handle base 5797 */ 5798 TRIO_PRIVATE BOOLEAN_T 5799 TrioReadDouble 5800 TRIO_ARGS4((self, target, flags, width), 5801 trio_class_t *self, 5802 trio_pointer_t target, 5803 trio_flags_t flags, 5804 int width) 5805 { 5806 int ch; 5807 char doubleString[512]; 5808 int index = 0; 5809 int start; 5810 int j; 5811 BOOLEAN_T isHex = FALSE; 5812 5813 doubleString[0] = 0; 5814 5815 if ((width == NO_WIDTH) || (width > (int)sizeof(doubleString) - 1)) 5816 width = sizeof(doubleString) - 1; 5817 5818 TrioSkipWhitespaces(self); 5819 5820 /* 5821 * Read entire double number from stream. trio_to_double requires 5822 * a string as input, but InStream can be anything, so we have to 5823 * collect all characters. 5824 */ 5825 ch = self->current; 5826 if ((ch == '+') || (ch == '-')) 5827 { 5828 doubleString[index++] = (char)ch; 5829 self->InStream(self, &ch); 5830 width--; 5831 } 5832 5833 start = index; 5834 switch (ch) 5835 { 5836 case 'n': 5837 case 'N': 5838 /* Not-a-number */ 5839 if (index != 0) 5840 break; 5841 /* FALLTHROUGH */ 5842 case 'i': 5843 case 'I': 5844 /* Infinity */ 5845 while (isalpha(ch) && (index - start < width)) 5846 { 5847 doubleString[index++] = (char)ch; 5848 self->InStream(self, &ch); 5849 } 5850 doubleString[index] = NIL; 5851 5852 /* Case insensitive string comparison */ 5853 if (trio_equal(&doubleString[start], INFINITE_UPPER) || 5854 trio_equal(&doubleString[start], LONG_INFINITE_UPPER)) 5855 { 5856 if (flags & FLAGS_LONGDOUBLE) 5857 { 5858 if ((start == 1) && (doubleString[0] == '-')) 5859 { 5860 *((trio_long_double_t *)target) = trio_ninf(); 5861 } 5862 else 5863 { 5864 *((trio_long_double_t *)target) = trio_pinf(); 5865 } 5866 } 5867 else 5868 { 5869 if ((start == 1) && (doubleString[0] == '-')) 5870 { 5871 *((double *)target) = trio_ninf(); 5872 } 5873 else 5874 { 5875 *((double *)target) = trio_pinf(); 5876 } 5877 } 5878 return TRUE; 5879 } 5880 if (trio_equal(doubleString, NAN_UPPER)) 5881 { 5882 /* NaN must not have a preceeding + nor - */ 5883 if (flags & FLAGS_LONGDOUBLE) 5884 { 5885 *((trio_long_double_t *)target) = trio_nan(); 5886 } 5887 else 5888 { 5889 *((double *)target) = trio_nan(); 5890 } 5891 return TRUE; 5892 } 5893 return FALSE; 5894 5895 case '0': 5896 doubleString[index++] = (char)ch; 5897 self->InStream(self, &ch); 5898 if (trio_to_upper(ch) == 'X') 5899 { 5900 isHex = TRUE; 5901 doubleString[index++] = (char)ch; 5902 self->InStream(self, &ch); 5903 } 5904 break; 5905 5906 default: 5907 break; 5908 } 5909 5910 while ((ch != EOF) && (index - start < width)) 5911 { 5912 /* Integer part */ 5913 if (isHex ? isxdigit(ch) : isdigit(ch)) 5914 { 5915 doubleString[index++] = (char)ch; 5916 self->InStream(self, &ch); 5917 } 5918 else if (flags & FLAGS_QUOTE) 5919 { 5920 /* Compare with thousands separator */ 5921 for (j = 0; internalThousandSeparator[j] && self->current; j++) 5922 { 5923 if (internalThousandSeparator[j] != self->current) 5924 break; 5925 5926 self->InStream(self, &ch); 5927 } 5928 if (internalThousandSeparator[j]) 5929 break; /* Mismatch */ 5930 else 5931 continue; /* Match */ 5932 } 5933 else 5934 break; /* while */ 5935 } 5936 if (ch == '.') 5937 { 5938 /* Decimal part */ 5939 doubleString[index++] = (char)ch; 5940 self->InStream(self, &ch); 5941 while ((isHex ? isxdigit(ch) : isdigit(ch)) && 5942 (index - start < width)) 5943 { 5944 doubleString[index++] = (char)ch; 5945 self->InStream(self, &ch); 5946 } 5947 if (isHex ? (trio_to_upper(ch) == 'P') : (trio_to_upper(ch) == 'E')) 5948 { 5949 /* Exponent */ 5950 doubleString[index++] = (char)ch; 5951 self->InStream(self, &ch); 5952 if ((ch == '+') || (ch == '-')) 5953 { 5954 doubleString[index++] = (char)ch; 5955 self->InStream(self, &ch); 5956 } 5957 while (isdigit(ch) && (index - start < width)) 5958 { 5959 doubleString[index++] = (char)ch; 5960 self->InStream(self, &ch); 5961 } 5962 } 5963 } 5964 5965 if ((index == start) || (*doubleString == NIL)) 5966 return FALSE; 5967 5968 doubleString[index] = 0; 5969 5970 if (flags & FLAGS_LONGDOUBLE) 5971 { 5972 *((trio_long_double_t *)target) = trio_to_long_double(doubleString, NULL); 5973 } 5974 else 5975 { 5976 *((double *)target) = trio_to_double(doubleString, NULL); 5977 } 5978 return TRUE; 5979 } 5980 5981 /************************************************************************* 5982 * TrioReadPointer 5983 */ 5984 TRIO_PRIVATE BOOLEAN_T 5985 TrioReadPointer 5986 TRIO_ARGS3((self, target, flags), 5987 trio_class_t *self, 5988 trio_pointer_t *target, 5989 trio_flags_t flags) 5990 { 5991 trio_uintmax_t number; 5992 char buffer[sizeof(internalNullString)]; 5993 5994 flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | FLAGS_NILPADDING); 5995 5996 if (TrioReadNumber(self, 5997 &number, 5998 flags, 5999 POINTER_WIDTH, 6000 BASE_HEX)) 6001 { 6002 /* 6003 * The strange assignment of number is a workaround for a compiler 6004 * warning 6005 */ 6006 if (target) 6007 *target = (char *)0 + number; 6008 return TRUE; 6009 } 6010 else if (TrioReadString(self, 6011 (flags & FLAGS_IGNORE) 6012 ? NULL 6013 : buffer, 6014 0, 6015 sizeof(internalNullString) - 1)) 6016 { 6017 if (trio_equal_case(buffer, internalNullString)) 6018 { 6019 if (target) 6020 *target = NULL; 6021 return TRUE; 6022 } 6023 } 6024 return FALSE; 6025 } 6026 6027 /************************************************************************* 6028 * TrioScanProcess 6029 */ 6030 TRIO_PRIVATE int 6031 TrioScanProcess 6032 TRIO_ARGS3((data, format, parameters), 6033 trio_class_t *data, 6034 TRIO_CONST char *format, 6035 trio_parameter_t *parameters) 6036 { 6037 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) 6038 int charlen; 6039 int cnt; 6040 #endif 6041 int assignment; 6042 int ch; 6043 int index; /* Index of format string */ 6044 int i; /* Index of current parameter */ 6045 trio_flags_t flags; 6046 int width; 6047 int base; 6048 trio_pointer_t pointer; 6049 6050 assignment = 0; 6051 i = 0; 6052 index = 0; 6053 data->InStream(data, &ch); 6054 6055 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) 6056 (void)mblen(NULL, 0); 6057 #endif 6058 6059 while (format[index]) 6060 { 6061 #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) 6062 if (! isascii(format[index])) 6063 { 6064 charlen = mblen(&format[index], MB_LEN_MAX); 6065 if (charlen != -1) 6066 { 6067 /* Compare multibyte characters in format string */ 6068 for (cnt = 0; cnt < charlen - 1; cnt++) 6069 { 6070 if (ch != format[index + cnt]) 6071 { 6072 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 6073 } 6074 data->InStream(data, &ch); 6075 } 6076 continue; /* while characters left in formatting string */ 6077 } 6078 } 6079 #endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */ 6080 6081 if ((EOF == ch) && (parameters[i].type != FORMAT_COUNT)) 6082 { 6083 return (assignment > 0) ? assignment : EOF; 6084 } 6085 6086 if (CHAR_IDENTIFIER == format[index]) 6087 { 6088 if (CHAR_IDENTIFIER == format[index + 1]) 6089 { 6090 /* Two % in format matches one % in input stream */ 6091 if (CHAR_IDENTIFIER == ch) 6092 { 6093 data->InStream(data, &ch); 6094 index += 2; 6095 continue; /* while format chars left */ 6096 } 6097 else 6098 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 6099 } 6100 6101 /* Skip the parameter entries */ 6102 while (parameters[i].type == FORMAT_PARAMETER) 6103 i++; 6104 6105 flags = parameters[i].flags; 6106 /* Find width */ 6107 width = parameters[i].width; 6108 if (flags & FLAGS_WIDTH_PARAMETER) 6109 { 6110 /* Get width from parameter list */ 6111 width = (int)parameters[width].data.number.as_signed; 6112 } 6113 /* Find base */ 6114 base = parameters[i].base; 6115 if (flags & FLAGS_BASE_PARAMETER) 6116 { 6117 /* Get base from parameter list */ 6118 base = (int)parameters[base].data.number.as_signed; 6119 } 6120 6121 switch (parameters[i].type) 6122 { 6123 case FORMAT_INT: 6124 { 6125 trio_uintmax_t number; 6126 6127 if (0 == base) 6128 base = BASE_DECIMAL; 6129 6130 if (!TrioReadNumber(data, 6131 &number, 6132 flags, 6133 width, 6134 base)) 6135 return assignment; 6136 6137 if (!(flags & FLAGS_IGNORE)) 6138 { 6139 assignment++; 6140 6141 pointer = parameters[i].data.pointer; 6142 #if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER) 6143 if (flags & FLAGS_SIZE_T) 6144 *(size_t *)pointer = (size_t)number; 6145 else 6146 #endif 6147 #if defined(QUALIFIER_PTRDIFF_T) 6148 if (flags & FLAGS_PTRDIFF_T) 6149 *(ptrdiff_t *)pointer = (ptrdiff_t)number; 6150 else 6151 #endif 6152 #if defined(QUALIFIER_INTMAX_T) 6153 if (flags & FLAGS_INTMAX_T) 6154 *(trio_intmax_t *)pointer = (trio_intmax_t)number; 6155 else 6156 #endif 6157 if (flags & FLAGS_QUAD) 6158 *(trio_ulonglong_t *)pointer = (trio_ulonglong_t)number; 6159 else if (flags & FLAGS_LONG) 6160 *(long int *)pointer = (long int)number; 6161 else if (flags & FLAGS_SHORT) 6162 *(short int *)pointer = (short int)number; 6163 else 6164 *(int *)pointer = (int)number; 6165 } 6166 } 6167 break; /* FORMAT_INT */ 6168 6169 case FORMAT_STRING: 6170 #if TRIO_WIDECHAR 6171 if (flags & FLAGS_WIDECHAR) 6172 { 6173 if (!TrioReadWideString(data, 6174 (flags & FLAGS_IGNORE) 6175 ? NULL 6176 : parameters[i].data.wstring, 6177 flags, 6178 width)) 6179 return assignment; 6180 } 6181 else 6182 #endif 6183 { 6184 if (!TrioReadString(data, 6185 (flags & FLAGS_IGNORE) 6186 ? NULL 6187 : parameters[i].data.string, 6188 flags, 6189 width)) 6190 return assignment; 6191 } 6192 if (!(flags & FLAGS_IGNORE)) 6193 assignment++; 6194 break; /* FORMAT_STRING */ 6195 6196 case FORMAT_DOUBLE: 6197 { 6198 trio_pointer_t pointer; 6199 6200 if (flags & FLAGS_IGNORE) 6201 { 6202 pointer = NULL; 6203 } 6204 else 6205 { 6206 pointer = (flags & FLAGS_LONGDOUBLE) 6207 ? (trio_pointer_t)parameters[i].data.longdoublePointer 6208 : (trio_pointer_t)parameters[i].data.doublePointer; 6209 } 6210 if (!TrioReadDouble(data, pointer, flags, width)) 6211 { 6212 return assignment; 6213 } 6214 if (!(flags & FLAGS_IGNORE)) 6215 { 6216 assignment++; 6217 } 6218 break; /* FORMAT_DOUBLE */ 6219 } 6220 case FORMAT_GROUP: 6221 { 6222 int characterclass[MAX_CHARACTER_CLASS + 1]; 6223 int rc; 6224 6225 /* Skip over modifiers */ 6226 while (format[index] != SPECIFIER_GROUP) 6227 { 6228 index++; 6229 } 6230 /* Skip over group specifier */ 6231 index++; 6232 6233 memset(characterclass, 0, sizeof(characterclass)); 6234 rc = TrioGetCharacterClass(format, 6235 &index, 6236 &flags, 6237 characterclass); 6238 if (rc < 0) 6239 return rc; 6240 6241 if (!TrioReadGroup(data, 6242 (flags & FLAGS_IGNORE) 6243 ? NULL 6244 : parameters[i].data.string, 6245 characterclass, 6246 flags, 6247 parameters[i].width)) 6248 return assignment; 6249 if (!(flags & FLAGS_IGNORE)) 6250 assignment++; 6251 } 6252 break; /* FORMAT_GROUP */ 6253 6254 case FORMAT_COUNT: 6255 pointer = parameters[i].data.pointer; 6256 if (NULL != pointer) 6257 { 6258 int count = data->committed; 6259 if (ch != EOF) 6260 count--; /* a character is read, but is not consumed yet */ 6261 #if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER) 6262 if (flags & FLAGS_SIZE_T) 6263 *(size_t *)pointer = (size_t)count; 6264 else 6265 #endif 6266 #if defined(QUALIFIER_PTRDIFF_T) 6267 if (flags & FLAGS_PTRDIFF_T) 6268 *(ptrdiff_t *)pointer = (ptrdiff_t)count; 6269 else 6270 #endif 6271 #if defined(QUALIFIER_INTMAX_T) 6272 if (flags & FLAGS_INTMAX_T) 6273 *(trio_intmax_t *)pointer = (trio_intmax_t)count; 6274 else 6275 #endif 6276 if (flags & FLAGS_QUAD) 6277 { 6278 *(trio_ulonglong_t *)pointer = (trio_ulonglong_t)count; 6279 } 6280 else if (flags & FLAGS_LONG) 6281 { 6282 *(long int *)pointer = (long int)count; 6283 } 6284 else if (flags & FLAGS_SHORT) 6285 { 6286 *(short int *)pointer = (short int)count; 6287 } 6288 else 6289 { 6290 *(int *)pointer = (int)count; 6291 } 6292 } 6293 break; /* FORMAT_COUNT */ 6294 6295 case FORMAT_CHAR: 6296 #if TRIO_WIDECHAR 6297 if (flags & FLAGS_WIDECHAR) 6298 { 6299 if (TrioReadWideChar(data, 6300 (flags & FLAGS_IGNORE) 6301 ? NULL 6302 : parameters[i].data.wstring, 6303 flags, 6304 (width == NO_WIDTH) ? 1 : width) == 0) 6305 return assignment; 6306 } 6307 else 6308 #endif 6309 { 6310 if (TrioReadChar(data, 6311 (flags & FLAGS_IGNORE) 6312 ? NULL 6313 : parameters[i].data.string, 6314 flags, 6315 (width == NO_WIDTH) ? 1 : width) == 0) 6316 return assignment; 6317 } 6318 if (!(flags & FLAGS_IGNORE)) 6319 assignment++; 6320 break; /* FORMAT_CHAR */ 6321 6322 case FORMAT_POINTER: 6323 if (!TrioReadPointer(data, 6324 (flags & FLAGS_IGNORE) 6325 ? NULL 6326 : (trio_pointer_t *)parameters[i].data.pointer, 6327 flags)) 6328 return assignment; 6329 if (!(flags & FLAGS_IGNORE)) 6330 assignment++; 6331 break; /* FORMAT_POINTER */ 6332 6333 case FORMAT_PARAMETER: 6334 break; /* FORMAT_PARAMETER */ 6335 6336 default: 6337 return TRIO_ERROR_RETURN(TRIO_EINVAL, index); 6338 } 6339 ch = data->current; 6340 index = parameters[i].indexAfterSpecifier; 6341 i++; 6342 } 6343 else /* Not an % identifier */ 6344 { 6345 if (isspace((int)format[index])) 6346 { 6347 /* Whitespaces may match any amount of whitespaces */ 6348 ch = TrioSkipWhitespaces(data); 6349 } 6350 else if (ch == format[index]) 6351 { 6352 data->InStream(data, &ch); 6353 } 6354 else 6355 return assignment; 6356 6357 index++; 6358 } 6359 } 6360 return assignment; 6361 } 6362 6363 /************************************************************************* 6364 * TrioScan 6365 */ 6366 TRIO_PRIVATE int 6367 TrioScan 6368 TRIO_ARGS6((source, sourceSize, InStream, format, arglist, argarray), 6369 trio_pointer_t source, 6370 size_t sourceSize, 6371 void (*InStream) TRIO_PROTO((trio_class_t *, int *)), 6372 TRIO_CONST char *format, 6373 va_list *arglist, 6374 trio_pointer_t *argarray) 6375 { 6376 int status; 6377 trio_parameter_t parameters[MAX_PARAMETERS]; 6378 trio_class_t data; 6379 6380 assert(VALID(InStream)); 6381 assert(VALID(format)); 6382 6383 memset(&data, 0, sizeof(data)); 6384 data.InStream = InStream; 6385 data.location = (trio_pointer_t)source; 6386 data.max = sourceSize; 6387 data.error = 0; 6388 6389 #if defined(USE_LOCALE) 6390 if (NULL == internalLocaleValues) 6391 { 6392 TrioSetLocale(); 6393 } 6394 #endif 6395 6396 status = TrioParse(TYPE_SCAN, format, parameters, arglist, argarray); 6397 if (status < 0) 6398 return status; 6399 6400 status = TrioScanProcess(&data, format, parameters); 6401 if (data.error != 0) 6402 { 6403 status = data.error; 6404 } 6405 return status; 6406 } 6407 6408 /************************************************************************* 6409 * TrioInStreamFile 6410 */ 6411 TRIO_PRIVATE void 6412 TrioInStreamFile 6413 TRIO_ARGS2((self, intPointer), 6414 trio_class_t *self, 6415 int *intPointer) 6416 { 6417 FILE *file = (FILE *)self->location; 6418 6419 assert(VALID(self)); 6420 assert(VALID(file)); 6421 6422 self->current = fgetc(file); 6423 if (self->current == EOF) 6424 { 6425 self->error = (ferror(file)) 6426 ? TRIO_ERROR_RETURN(TRIO_ERRNO, 0) 6427 : TRIO_ERROR_RETURN(TRIO_EOF, 0); 6428 } 6429 else 6430 { 6431 self->processed++; 6432 self->committed++; 6433 } 6434 6435 if (VALID(intPointer)) 6436 { 6437 *intPointer = self->current; 6438 } 6439 } 6440 6441 /************************************************************************* 6442 * TrioInStreamFileDescriptor 6443 */ 6444 TRIO_PRIVATE void 6445 TrioInStreamFileDescriptor 6446 TRIO_ARGS2((self, intPointer), 6447 trio_class_t *self, 6448 int *intPointer) 6449 { 6450 int fd = *((int *)self->location); 6451 int size; 6452 unsigned char input; 6453 6454 assert(VALID(self)); 6455 6456 size = read(fd, &input, sizeof(char)); 6457 if (size == -1) 6458 { 6459 self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0); 6460 self->current = EOF; 6461 } 6462 else 6463 { 6464 self->current = (size == 0) ? EOF : input; 6465 } 6466 if (self->current != EOF) 6467 { 6468 self->committed++; 6469 self->processed++; 6470 } 6471 6472 if (VALID(intPointer)) 6473 { 6474 *intPointer = self->current; 6475 } 6476 } 6477 6478 /************************************************************************* 6479 * TrioInStreamCustom 6480 */ 6481 TRIO_PRIVATE void 6482 TrioInStreamCustom 6483 TRIO_ARGS2((self, intPointer), 6484 trio_class_t *self, 6485 int *intPointer) 6486 { 6487 trio_custom_t *data; 6488 6489 assert(VALID(self)); 6490 assert(VALID(self->location)); 6491 6492 data = (trio_custom_t *)self->location; 6493 6494 self->current = (data->stream.in == NULL) 6495 ? NIL 6496 : (data->stream.in)(data->closure); 6497 6498 if (self->current == NIL) 6499 { 6500 self->current = EOF; 6501 } 6502 else 6503 { 6504 self->processed++; 6505 self->committed++; 6506 } 6507 6508 if (VALID(intPointer)) 6509 { 6510 *intPointer = self->current; 6511 } 6512 } 6513 6514 /************************************************************************* 6515 * TrioInStreamString 6516 */ 6517 TRIO_PRIVATE void 6518 TrioInStreamString 6519 TRIO_ARGS2((self, intPointer), 6520 trio_class_t *self, 6521 int *intPointer) 6522 { 6523 unsigned char **buffer; 6524 6525 assert(VALID(self)); 6526 assert(VALID(self->location)); 6527 6528 buffer = (unsigned char **)self->location; 6529 self->current = (*buffer)[0]; 6530 if (self->current == NIL) 6531 { 6532 self->current = EOF; 6533 } 6534 else 6535 { 6536 (*buffer)++; 6537 self->processed++; 6538 self->committed++; 6539 } 6540 6541 if (VALID(intPointer)) 6542 { 6543 *intPointer = self->current; 6544 } 6545 } 6546 6547 /************************************************************************* 6548 * 6549 * Formatted scanning functions 6550 * 6551 ************************************************************************/ 6552 6553 #if defined(TRIO_DOCUMENTATION) 6554 # include "doc/doc_scanf.h" 6555 #endif 6556 /** @addtogroup Scanf 6557 @{ 6558 */ 6559 6560 /************************************************************************* 6561 * scanf 6562 */ 6563 6564 /** 6565 Scan characters from standard input stream. 6566 6567 @param format Formatting string. 6568 @param ... Arguments. 6569 @return Number of scanned characters. 6570 */ 6571 TRIO_PUBLIC int 6572 trio_scanf 6573 TRIO_VARGS2((format, va_alist), 6574 TRIO_CONST char *format, 6575 TRIO_VA_DECL) 6576 { 6577 int status; 6578 va_list args; 6579 6580 assert(VALID(format)); 6581 6582 TRIO_VA_START(args, format); 6583 status = TrioScan((trio_pointer_t)stdin, 0, 6584 TrioInStreamFile, 6585 format, &args, NULL); 6586 TRIO_VA_END(args); 6587 return status; 6588 } 6589 6590 TRIO_PUBLIC int 6591 trio_vscanf 6592 TRIO_ARGS2((format, args), 6593 TRIO_CONST char *format, 6594 va_list args) 6595 { 6596 assert(VALID(format)); 6597 6598 return TrioScan((trio_pointer_t)stdin, 0, 6599 TrioInStreamFile, 6600 format, &args, NULL); 6601 } 6602 6603 TRIO_PUBLIC int 6604 trio_scanfv 6605 TRIO_ARGS2((format, args), 6606 TRIO_CONST char *format, 6607 trio_pointer_t *args) 6608 { 6609 assert(VALID(format)); 6610 6611 return TrioScan((trio_pointer_t)stdin, 0, 6612 TrioInStreamFile, 6613 format, NULL, args); 6614 } 6615 6616 /************************************************************************* 6617 * fscanf 6618 */ 6619 TRIO_PUBLIC int 6620 trio_fscanf 6621 TRIO_VARGS3((file, format, va_alist), 6622 FILE *file, 6623 TRIO_CONST char *format, 6624 TRIO_VA_DECL) 6625 { 6626 int status; 6627 va_list args; 6628 6629 assert(VALID(file)); 6630 assert(VALID(format)); 6631 6632 TRIO_VA_START(args, format); 6633 status = TrioScan((trio_pointer_t)file, 0, 6634 TrioInStreamFile, 6635 format, &args, NULL); 6636 TRIO_VA_END(args); 6637 return status; 6638 } 6639 6640 TRIO_PUBLIC int 6641 trio_vfscanf 6642 TRIO_ARGS3((file, format, args), 6643 FILE *file, 6644 TRIO_CONST char *format, 6645 va_list args) 6646 { 6647 assert(VALID(file)); 6648 assert(VALID(format)); 6649 6650 return TrioScan((trio_pointer_t)file, 0, 6651 TrioInStreamFile, 6652 format, &args, NULL); 6653 } 6654 6655 TRIO_PUBLIC int 6656 trio_fscanfv 6657 TRIO_ARGS3((file, format, args), 6658 FILE *file, 6659 TRIO_CONST char *format, 6660 trio_pointer_t *args) 6661 { 6662 assert(VALID(file)); 6663 assert(VALID(format)); 6664 6665 return TrioScan((trio_pointer_t)file, 0, 6666 TrioInStreamFile, 6667 format, NULL, args); 6668 } 6669 6670 /************************************************************************* 6671 * dscanf 6672 */ 6673 TRIO_PUBLIC int 6674 trio_dscanf 6675 TRIO_VARGS3((fd, format, va_alist), 6676 int fd, 6677 TRIO_CONST char *format, 6678 TRIO_VA_DECL) 6679 { 6680 int status; 6681 va_list args; 6682 6683 assert(VALID(format)); 6684 6685 TRIO_VA_START(args, format); 6686 status = TrioScan((trio_pointer_t)&fd, 0, 6687 TrioInStreamFileDescriptor, 6688 format, &args, NULL); 6689 TRIO_VA_END(args); 6690 return status; 6691 } 6692 6693 TRIO_PUBLIC int 6694 trio_vdscanf 6695 TRIO_ARGS3((fd, format, args), 6696 int fd, 6697 TRIO_CONST char *format, 6698 va_list args) 6699 { 6700 assert(VALID(format)); 6701 6702 return TrioScan((trio_pointer_t)&fd, 0, 6703 TrioInStreamFileDescriptor, 6704 format, &args, NULL); 6705 } 6706 6707 TRIO_PUBLIC int 6708 trio_dscanfv 6709 TRIO_ARGS3((fd, format, args), 6710 int fd, 6711 TRIO_CONST char *format, 6712 trio_pointer_t *args) 6713 { 6714 assert(VALID(format)); 6715 6716 return TrioScan((trio_pointer_t)&fd, 0, 6717 TrioInStreamFileDescriptor, 6718 format, NULL, args); 6719 } 6720 6721 /************************************************************************* 6722 * cscanf 6723 */ 6724 TRIO_PUBLIC int 6725 trio_cscanf 6726 TRIO_VARGS4((stream, closure, format, va_alist), 6727 trio_instream_t stream, 6728 trio_pointer_t closure, 6729 TRIO_CONST char *format, 6730 TRIO_VA_DECL) 6731 { 6732 int status; 6733 va_list args; 6734 trio_custom_t data; 6735 6736 assert(VALID(stream)); 6737 assert(VALID(format)); 6738 6739 TRIO_VA_START(args, format); 6740 data.stream.in = stream; 6741 data.closure = closure; 6742 status = TrioScan(&data, 0, TrioInStreamCustom, format, &args, NULL); 6743 TRIO_VA_END(args); 6744 return status; 6745 } 6746 6747 TRIO_PUBLIC int 6748 trio_vcscanf 6749 TRIO_ARGS4((stream, closure, format, args), 6750 trio_instream_t stream, 6751 trio_pointer_t closure, 6752 TRIO_CONST char *format, 6753 va_list args) 6754 { 6755 trio_custom_t data; 6756 6757 assert(VALID(stream)); 6758 assert(VALID(format)); 6759 6760 data.stream.in = stream; 6761 data.closure = closure; 6762 return TrioScan(&data, 0, TrioInStreamCustom, format, &args, NULL); 6763 } 6764 6765 TRIO_PUBLIC int 6766 trio_cscanfv 6767 TRIO_ARGS4((stream, closure, format, args), 6768 trio_instream_t stream, 6769 trio_pointer_t closure, 6770 TRIO_CONST char *format, 6771 trio_pointer_t *args) 6772 { 6773 trio_custom_t data; 6774 6775 assert(VALID(stream)); 6776 assert(VALID(format)); 6777 6778 data.stream.in = stream; 6779 data.closure = closure; 6780 return TrioScan(&data, 0, TrioInStreamCustom, format, NULL, args); 6781 } 6782 6783 /************************************************************************* 6784 * sscanf 6785 */ 6786 TRIO_PUBLIC int 6787 trio_sscanf 6788 TRIO_VARGS3((buffer, format, va_alist), 6789 TRIO_CONST char *buffer, 6790 TRIO_CONST char *format, 6791 TRIO_VA_DECL) 6792 { 6793 int status; 6794 va_list args; 6795 6796 assert(VALID(buffer)); 6797 assert(VALID(format)); 6798 6799 TRIO_VA_START(args, format); 6800 status = TrioScan((trio_pointer_t)&buffer, 0, 6801 TrioInStreamString, 6802 format, &args, NULL); 6803 TRIO_VA_END(args); 6804 return status; 6805 } 6806 6807 TRIO_PUBLIC int 6808 trio_vsscanf 6809 TRIO_ARGS3((buffer, format, args), 6810 TRIO_CONST char *buffer, 6811 TRIO_CONST char *format, 6812 va_list args) 6813 { 6814 assert(VALID(buffer)); 6815 assert(VALID(format)); 6816 6817 return TrioScan((trio_pointer_t)&buffer, 0, 6818 TrioInStreamString, 6819 format, &args, NULL); 6820 } 6821 6822 TRIO_PUBLIC int 6823 trio_sscanfv 6824 TRIO_ARGS3((buffer, format, args), 6825 TRIO_CONST char *buffer, 6826 TRIO_CONST char *format, 6827 trio_pointer_t *args) 6828 { 6829 assert(VALID(buffer)); 6830 assert(VALID(format)); 6831 6832 return TrioScan((trio_pointer_t)&buffer, 0, 6833 TrioInStreamString, 6834 format, NULL, args); 6835 } 6836 6837 /** @} End of Scanf documentation module */ 6838 6839 /************************************************************************* 6840 * trio_strerror 6841 */ 6842 TRIO_PUBLIC TRIO_CONST char * 6843 trio_strerror 6844 TRIO_ARGS1((errorcode), 6845 int errorcode) 6846 { 6847 /* Textual versions of the error codes */ 6848 switch (TRIO_ERROR_CODE(errorcode)) 6849 { 6850 case TRIO_EOF: 6851 return "End of file"; 6852 case TRIO_EINVAL: 6853 return "Invalid argument"; 6854 case TRIO_ETOOMANY: 6855 return "Too many arguments"; 6856 case TRIO_EDBLREF: 6857 return "Double reference"; 6858 case TRIO_EGAP: 6859 return "Reference gap"; 6860 case TRIO_ENOMEM: 6861 return "Out of memory"; 6862 case TRIO_ERANGE: 6863 return "Invalid range"; 6864 case TRIO_ECUSTOM: 6865 return "Custom error"; 6866 default: 6867 return "Unknown"; 6868 } 6869 } 6870
