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