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