trio.c@ 51271

Last change on this file since 51271 was 39915, checked in by vboxsync, 13 years ago
libxml-2.6.31 unmodified
Property svn:eol-style set to `native`
File size: 155.9 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.6.31/trio.c@ 51271

Download in other formats: