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