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