trio.c@ 100743

Last change on this file since 100743 was 95312, checked in by vboxsync, 2 years ago
libs/{curl,libxml2}: OSE export fixes, bugref:8515
Property svn:eol-style set to `native`
File size: 156.8 KB

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

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

source: vbox/trunk/src/libs/libxml2-2.9.14/trio.c@ 100743

Download in other formats: