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