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