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