Annotation of OpenXM_contrib/gmp/printf/repl-vsnprintf.c, Revision 1.1.1.1
1.1 ohara 1: /* __gmp_replacement_vsnprintf -- for systems which don't have vsnprintf, or
2: only have a broken one.
3:
4: THE FUNCTIONS IN THIS FILE ARE FOR INTERNAL USE ONLY. THEY'RE ALMOST
5: CERTAIN TO BE SUBJECT TO INCOMPATIBLE CHANGES OR DISAPPEAR COMPLETELY IN
6: FUTURE GNU MP RELEASES.
7:
8: Copyright 2001, 2002 Free Software Foundation, Inc.
9:
10: This file is part of the GNU MP Library.
11:
12: The GNU MP Library is free software; you can redistribute it and/or modify
13: it under the terms of the GNU Lesser General Public License as published by
14: the Free Software Foundation; either version 2.1 of the License, or (at your
15: option) any later version.
16:
17: The GNU MP Library is distributed in the hope that it will be useful, but
18: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
20: License for more details.
21:
22: You should have received a copy of the GNU Lesser General Public License
23: along with the GNU MP Library; see the file COPYING.LIB. If not, write to
24: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
25: MA 02111-1307, USA. */
26:
27: #define _GNU_SOURCE /* for strnlen prototype */
28:
29: #include "config.h"
30:
31: #if HAVE_STDARG
32: #include <stdarg.h>
33: #else
34: #include <varargs.h>
35: #endif
36:
37: #include <ctype.h> /* for isdigit */
38: #include <float.h> /* for DBL_MAX_10_EXP etc */
39: #include <stddef.h> /* for ptrdiff_t */
40: #include <string.h>
41: #include <stdio.h> /* for NULL */
42: #include <stdlib.h>
43:
44: #if HAVE_INTTYPES_H
45: # include <inttypes.h> /* for intmax_t */
46: #else
47: # if HAVE_STDINT_H
48: # include <stdint.h>
49: # endif
50: #endif
51:
52: #if HAVE_SYS_TYPES_H
53: #include <sys/types.h> /* for quad_t */
54: #endif
55:
56: #include "gmp.h"
57: #include "gmp-impl.h"
58:
59:
60: /* Autoconf notes that AIX 4.3 has a broken strnlen, but fortunately it
61: doesn't affect us since __gmp_replacement_vsnprintf is not required on
62: that system. */
63: #if ! HAVE_STRNLEN
64: static size_t
65: strnlen (const char *s, size_t n)
66: {
67: size_t i;
68: for (i = 0; i < n; i++)
69: if (s[i] == '\0')
70: break;
71: return i;
72: }
73: #endif
74:
75:
76: /* The approach here is to parse the fmt string, and decide how much space
77: it requires, then use vsprintf into a big enough buffer. The space
78: calculated isn't an exact amount, but it's certainly no less than
79: required.
80:
81: This code was inspired by GNU libiberty/vasprintf.c but we support more
82: datatypes, when available.
83:
84: mingw32 - doesn't have vsnprintf, it seems. Because gcc is used a full
85: set of types are available, but "long double" is just a plain IEEE
86: 64-bit "double", so we avoid the big 15-bit exponent estimate
87: (LDBL_MAX_EXP_10 is defined). */
88:
89: int
90: __gmp_replacement_vsnprintf (char *buf, size_t buf_size,
91: const char *orig_fmt, va_list orig_ap)
92: {
93: va_list ap;
94: const char *fmt;
95: size_t total_width, integer_sizeof, floating_sizeof, len;
96: char fchar, type;
97: int width, prec, seen_prec, double_digits, long_double_digits;
98: int *value;
99:
100: /* preserve orig_ap for use after size estimation */
101: va_copy (ap, orig_ap);
102:
103: fmt = orig_fmt;
104: total_width = strlen (fmt) + 1; /* 1 extra for the '\0' */
105:
106: integer_sizeof = sizeof (long);
107: #if HAVE_LONG_LONG
108: integer_sizeof = MAX (integer_sizeof, sizeof (long long));
109: #endif
110: #if HAVE_QUAD_T
111: integer_sizeof = MAX (integer_sizeof, sizeof (quad_t));
112: #endif
113:
114: floating_sizeof = sizeof (double);
115: #if HAVE_LONG_DOUBLE
116: floating_sizeof = MAX (floating_sizeof, sizeof (long double));
117: #endif
118:
119: /* IEEE double or VAX G floats have an 11 bit exponent, so the default is
120: a maximum 308 decimal digits. VAX D floats have only an 8 bit
121: exponent, but we don't bother trying to detect that directly. */
122: double_digits = 308;
123: #ifdef DBL_MAX_10_EXP
124: /* but case prefer a value the compiler says */
125: double_digits = DBL_MAX_10_EXP;
126: #endif
127:
128: /* IEEE 128-bit quad, Intel 80-bit temporary, or VAX H floats all have 15
129: bit exponents, so the default is a maximum 4932 decimal digits. */
130: long_double_digits = 4932;
131: /* but if double == long double, then go with that size */
132: #if HAVE_LONG_DOUBLE
133: if (sizeof (double) == sizeof (long double))
134: long_double_digits = double_digits;
135: #endif
136: #ifdef LDBL_MAX_10_EXP
137: /* but in any case prefer a value the compiler says */
138: long_double_digits = LDBL_MAX_10_EXP;
139: #endif
140:
141: for (;;)
142: {
143: fmt = strchr (fmt, '%');
144: if (fmt == NULL)
145: break;
146: fmt++;
147:
148: type = '\0';
149: width = 0;
150: prec = 6;
151: seen_prec = 0;
152: value = &width;
153:
154: for (;;)
155: {
156: fchar = *fmt++;
157: switch (fchar) {
158:
159: case 'c':
160: /* char, already accounted for by strlen(fmt) */
161: goto next;
162:
163: case 'd':
164: case 'i':
165: case 'o':
166: case 'x':
167: case 'X':
168: case 'u':
169: /* at most 3 digits per byte in hex, dec or octal, plus a sign */
170: total_width += 3 * integer_sizeof + 1;
171:
172: switch (type) {
173: case 'j':
174: /* Let's assume uintmax_t is the same size as intmax_t. */
175: #if HAVE_INTMAX_T
176: (void) va_arg (ap, intmax_t);
177: #else
178: ASSERT_FAIL (intmax_t not available);
179: #endif
180: break;
181: case 'l':
182: (void) va_arg (ap, long);
183: break;
184: case 'L':
185: #if HAVE_LONG_LONG
186: (void) va_arg (ap, long long);
187: #else
188: ASSERT_FAIL (long long not available);
189: #endif
190: break;
191: case 'q':
192: /* quad_t is probably the same as long long, but let's treat
193: it separately just to be sure. Also let's assume u_quad_t
194: will be the same size as quad_t. */
195: #if HAVE_QUAD_T
196: (void) va_arg (ap, quad_t);
197: #else
198: ASSERT_FAIL (quad_t not available);
199: #endif
200: break;
201: case 't':
202: #if HAVE_PTRDIFF_T
203: (void) va_arg (ap, ptrdiff_t);
204: #else
205: ASSERT_FAIL (ptrdiff_t not available);
206: #endif
207: break;
208: case 'z':
209: (void) va_arg (ap, size_t);
210: break;
211: default:
212: /* default is an "int", and this includes h=short and hh=char
213: since they're promoted to int in a function call */
214: (void) va_arg (ap, int);
215: break;
216: }
217: goto next;
218:
219: case 'E':
220: case 'e':
221: case 'G':
222: case 'g':
223: /* Requested decimals, sign, point and e, plus an overestimate
224: of exponent digits (the assumption is all the float is
225: exponent!). */
226: total_width += prec + 3 + floating_sizeof * 3;
227: if (type == 'L')
228: {
229: #if HAVE_LONG_DOUBLE
230: (void) va_arg (ap, long double);
231: #else
232: ASSERT_FAIL (long double not available);
233: #endif
234: }
235: else
236: (void) va_arg (ap, double);
237: break;
238:
239: case 'f':
240: /* Requested decimals, sign and point, and a margin for error,
241: then add the maximum digits that can be in the integer part,
242: based on the maximum exponent value. */
243: total_width += prec + 2 + 10;
244: if (type == 'L')
245: {
246: #if HAVE_LONG_DOUBLE
247: (void) va_arg (ap, long double);
248: total_width += long_double_digits;
249: #else
250: ASSERT_FAIL (long double not available);
251: #endif
252: }
253: else
254: {
255: (void) va_arg (ap, double);
256: total_width += double_digits;
257: }
258: break;
259:
260: case 'h': /* short or char */
261: case 'j': /* intmax_t */
262: case 'L': /* long long or long double */
263: case 'q': /* quad_t */
264: case 't': /* ptrdiff_t */
265: set_type:
266: type = fchar;
267: break;
268:
269: case 'l':
270: /* long or long long */
271: if (type != 'l')
272: goto set_type;
273: type = 'L'; /* "ll" means "L" */
274: break;
275:
276: case 'n':
277: /* bytes written, no output as such */
278: (void) va_arg (ap, void *);
279: goto next;
280:
281: case 's':
282: /* If no precision was given, then determine the string length
283: and put it there, to be added to the total under "next". If
284: a precision was given then that's already the maximum from
285: this field, but see whether the string is shorter than that,
286: in case the limit was very big. */
287: {
288: const char *s = va_arg (ap, const char *);
289: prec = (seen_prec ? strnlen (s, prec) : strlen (s));
290: }
291: goto next;
292:
293: case 'p':
294: /* pointer, let's assume at worst it's octal with some padding */
295: (void) va_arg (ap, const void *);
296: total_width += 3 * sizeof (void *) + 16;
297: goto next;
298:
299: case '%':
300: /* literal %, already accounted for by strlen(fmt) */
301: goto next;
302:
303: case '#':
304: /* showbase, at most 2 for "0x" */
305: total_width += 2;
306: break;
307:
308: case '+':
309: case ' ':
310: /* sign, already accounted for under numerics */
311: break;
312:
313: case '-':
314: /* left justify, no effect on total width */
315: break;
316:
317: case '.':
318: seen_prec = 1;
319: value = ≺
320: break;
321:
322: case '*':
323: {
324: /* negative width means left justify which can be ignored,
325: negative prec would be invalid, just use absolute value */
326: int n = va_arg (ap, int);
327: *value = ABS (n);
328: }
329: break;
330:
331: case '0': case '1': case '2': case '3': case '4':
332: case '5': case '6': case '7': case '8': case '9':
333: /* process all digits to form a value */
334: {
335: int n = 0;
336: do {
337: n = n * 10 + (fchar-'0');
338: fchar = *fmt++;
339: } while (isascii (fchar) && isdigit (fchar));
340: fmt--; /* unget the non-digit */
341: *value = n;
342: }
343: break;
344:
345: default:
346: /* incomplete or invalid % sequence */
347: ASSERT (0);
348: goto next;
349: }
350: }
351:
352: next:
353: total_width += width;
354: total_width += prec;
355: }
356:
357: if (total_width <= buf_size)
358: {
359: vsprintf (buf, orig_fmt, orig_ap);
360: len = strlen (buf);
361: }
362: else
363: {
364: char *s;
365:
366: s = __GMP_ALLOCATE_FUNC_TYPE (total_width, char);
367: vsprintf (s, orig_fmt, orig_ap);
368: len = strlen (s);
369: if (buf_size != 0)
370: {
371: size_t copylen = MIN (len, buf_size-1);
372: memcpy (buf, s, copylen);
373: buf[copylen] = '\0';
374: }
375: (*__gmp_free_func) (s, total_width);
376: }
377:
378: /* If total_width was somehow wrong then chances are we've already
379: clobbered memory, but maybe this check will still work. */
380: ASSERT_ALWAYS (len < total_width);
381:
382: return len;
383: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to repl-vsnprintf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / printf