mutt

view snprintf.c @ 5178:55cd4cb611d9

flowed: consider a single space as a hard line break. Closes #2906
author Sertaç Ö. Yıldız
date Thu Jun 14 18:17:41 2007 -0700 (13 months ago)
parents ac2a2dcad1ec
children
line source
1/**************************************************************
2 * Original:
3 * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
4 * A bombproof version of doprnt (dopr) included.
5 * Sigh. This sort of thing is always nasty do deal with. Note that
6 * the version here does not include floating point...
7 *
8 * snprintf() is used instead of sprintf() as it does limit checks
9 * for string length. This covers a nasty loophole.
10 *
11 * The other functions are there to prevent NULL pointers from
12 * causing nast effects.
13 *
14 * More Recently:
15 * Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
16 * This was ugly. It is still ugly. I opted out of floating point
17 * numbers, but the formatter understands just about everything
18 * from the normal C string format, at least as far as I can tell from
19 * the Solaris 2.5 printf(3S) man page.
20 *
21 * Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
22 * Ok, added some minimal floating point support, which means this
23 * probably requires libm on most operating systems. Don't yet
24 * support the exponent (e,E) and sigfig (g,G). Also, fmtint()
25 * was pretty badly broken, it just wasn't being exercised in ways
26 * which showed it, so that's been fixed. Also, formated the code
27 * to mutt conventions, and removed dead code left over from the
28 * original. Also, there is now a builtin-test, just compile with:
29 * gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
30 * and run snprintf for results.
31 *
32 * Thomas Roessler <roessler@does-not-exist.org> 01/27/98 for mutt 0.89i
33 * The PGP code was using unsigned hexadecimal formats.
34 * Unfortunately, unsigned formats simply didn't work.
35 *
36 * Michael Elkins <me@mutt.org> 03/05/98 for mutt 0.90.8
37 * The original code assumed that both snprintf() and vsnprintf() were
38 * missing. Some systems only have snprintf() but not vsnprintf(), so
39 * the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
40 *
41 * Holger Weiss <holger@zedat.fu-berlin.de> 07/23/06 for mutt 1.5.13
42 * A C99 compliant [v]snprintf() returns the number of characters that
43 * would have been written to a sufficiently sized buffer (excluding
44 * the '\0'). Mutt now relies on this behaviour, but the original
45 * code simply returned the length of the resulting output string, so
46 * that's been fixed.
47 *
48 **************************************************************/
49
50#if HAVE_CONFIG_H
51# include "config.h"
52#endif
53
54#if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF)
55
56#include <string.h>
57# include <ctype.h>
58#include <sys/types.h>
59
60/* Define this as a fall through, HAVE_STDARG_H is probably already set */
61
62#define HAVE_VARARGS_H
63
64/* varargs declarations: */
65
66#if defined(HAVE_STDARG_H)
67# include <stdarg.h>
68# define HAVE_STDARGS /* let's hope that works everywhere (mj) */
69# define VA_LOCAL_DECL va_list ap
70# define VA_START(f) va_start(ap, f)
71# define VA_SHIFT(v,t) ; /* no-op for ANSI */
72# define VA_END va_end(ap)
73#else
74# if defined(HAVE_VARARGS_H)
75# include <varargs.h>
76# undef HAVE_STDARGS
77# define VA_LOCAL_DECL va_list ap
78# define VA_START(f) va_start(ap) /* f is ignored! */
79# define VA_SHIFT(v,t) v = va_arg(ap,t)
80# define VA_END va_end(ap)
81# else
82/*XX ** NO VARARGS ** XX*/
83# endif
84#endif
85
86/*int snprintf (char *str, size_t count, const char *fmt, ...);*/
87/*int vsnprintf (char *str, size_t count, const char *fmt, va_list arg);*/
88
89static int dopr (char *buffer, size_t maxlen, const char *format,
90 va_list args);
91static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
92 char *value, int flags, int min, int max);
93static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
94 long value, int base, int min, int max, int flags);
95static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
96 long double fvalue, int min, int max, int flags);
97static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c );
98
99/*
100 * dopr(): poor man's version of doprintf
101 */
102
103/* format read states */
104#define DP_S_DEFAULT 0
105#define DP_S_FLAGS 1
106#define DP_S_MIN 2
107#define DP_S_DOT 3
108#define DP_S_MAX 4
109#define DP_S_MOD 5
110#define DP_S_CONV 6
111#define DP_S_DONE 7
112
113/* format flags - Bits */
114#define DP_F_MINUS (1 << 0)
115#define DP_F_PLUS (1 << 1)
116#define DP_F_SPACE (1 << 2)
117#define DP_F_NUM (1 << 3)
118#define DP_F_ZERO (1 << 4)
119#define DP_F_UP (1 << 5)
120#define DP_F_UNSIGNED (1 << 6)
121
122/* Conversion Flags */
123#define DP_C_SHORT 1
124#define DP_C_LONG 2
125#define DP_C_LDOUBLE 3
126
127#define char_to_int(p) (p - '0')
128#undef MAX
129#define MAX(p,q) ((p >= q) ? p : q)
130
131static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
132{
133 char ch;
134 long value;
135 long double fvalue;
136 char *strvalue;
137 int min;
138 int max;
139 int state;
140 int flags;
141 int cflags;
142 size_t currlen;
143
144 state = DP_S_DEFAULT;
145 currlen = flags = cflags = min = 0;
146 max = -1;
147 ch = *format++;
148
149 while (state != DP_S_DONE)
150 {
151 if (ch == '\0')
152 state = DP_S_DONE;
153
154 switch(state)
155 {
156 case DP_S_DEFAULT:
157 if (ch == '%')
158 state = DP_S_FLAGS;
159 else
160 dopr_outch (buffer, &currlen, maxlen, ch);
161 ch = *format++;
162 break;
163 case DP_S_FLAGS:
164 switch (ch)
165 {
166 case '-':
167 flags |= DP_F_MINUS;
168 ch = *format++;
169 break;
170 case '+':
171 flags |= DP_F_PLUS;
172 ch = *format++;
173 break;
174 case ' ':
175 flags |= DP_F_SPACE;
176 ch = *format++;
177 break;
178 case '#':
179 flags |= DP_F_NUM;
180 ch = *format++;
181 break;
182 case '0':
183 flags |= DP_F_ZERO;
184 ch = *format++;
185 break;
186 default:
187 state = DP_S_MIN;
188 break;
189 }
190 break;
191 case DP_S_MIN:
192 if (isdigit((unsigned char)ch))
193 {
194 min = 10*min + char_to_int (ch);
195 ch = *format++;
196 }
197 else if (ch == '*')
198 {
199 min = va_arg (args, int);
200 ch = *format++;
201 state = DP_S_DOT;
202 }
203 else
204 state = DP_S_DOT;
205 break;
206 case DP_S_DOT:
207 if (ch == '.')
208 {
209 state = DP_S_MAX;
210 ch = *format++;
211 }
212 else
213 state = DP_S_MOD;
214 break;
215 case DP_S_MAX:
216 if (isdigit((unsigned char)ch))
217 {
218 if (max < 0)
219 max = 0;
220 max = 10*max + char_to_int (ch);
221 ch = *format++;
222 }
223 else if (ch == '*')
224 {
225 max = va_arg (args, int);
226 ch = *format++;
227 state = DP_S_MOD;
228 }
229 else
230 state = DP_S_MOD;
231 break;
232 case DP_S_MOD:
233 /* Currently, we don't support Long Long, bummer */
234 switch (ch)
235 {
236 case 'h':
237 cflags = DP_C_SHORT;
238 ch = *format++;
239 break;
240 case 'l':
241 cflags = DP_C_LONG;
242 ch = *format++;
243 break;
244 case 'L':
245 cflags = DP_C_LDOUBLE;
246 ch = *format++;
247 break;
248 default:
249 break;
250 }
251 state = DP_S_CONV;
252 break;
253 case DP_S_CONV:
254 switch (ch)
255 {
256 case 'd':
257 case 'i':
258 if (cflags == DP_C_SHORT)
259 value = va_arg (args, short int);
260 else if (cflags == DP_C_LONG)
261 value = va_arg (args, long int);
262 else
263 value = va_arg (args, int);
264 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
265 break;
266 case 'o':
267 flags |= DP_F_UNSIGNED;
268 if (cflags == DP_C_SHORT)
269 value = va_arg (args, unsigned short int);
270 else if (cflags == DP_C_LONG)
271 value = va_arg (args, unsigned long int);
272 else
273 value = va_arg (args, unsigned int);
274 fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
275 break;
276 case 'u':
277 flags |= DP_F_UNSIGNED;
278 if (cflags == DP_C_SHORT)
279 value = va_arg (args, unsigned short int);
280 else if (cflags == DP_C_LONG)
281 value = va_arg (args, unsigned long int);
282 else
283 value = va_arg (args, unsigned int);
284 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
285 break;
286 case 'X':
287 flags |= DP_F_UP;
288 case 'x':
289 flags |= DP_F_UNSIGNED;
290 if (cflags == DP_C_SHORT)
291 value = va_arg (args, unsigned short int);
292 else if (cflags == DP_C_LONG)
293 value = va_arg (args, unsigned long int);
294 else
295 value = va_arg (args, unsigned int);
296 fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
297 break;
298 case 'f':
299 if (cflags == DP_C_LDOUBLE)
300 fvalue = va_arg (args, long double);
301 else
302 fvalue = va_arg (args, double);
303 /* um, floating point? */
304 fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
305 break;
306 case 'E':
307 flags |= DP_F_UP;
308 case 'e':
309 if (cflags == DP_C_LDOUBLE)
310 fvalue = va_arg (args, long double);
311 else
312 fvalue = va_arg (args, double);
313 break;
314 case 'G':
315 flags |= DP_F_UP;
316 case 'g':
317 if (cflags == DP_C_LDOUBLE)
318 fvalue = va_arg (args, long double);
319 else
320 fvalue = va_arg (args, double);
321 break;
322 case 'c':
323 dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
324 break;
325 case 's':
326 strvalue = va_arg (args, char *);
327 fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
328 break;
329 case 'p':
330 strvalue = va_arg (args, void *);
331 fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
332 break;
333 case 'n':
334 if (cflags == DP_C_SHORT)
335 {
336 short int *num;
337 num = va_arg (args, short int *);
338 *num = currlen;
339 }
340 else if (cflags == DP_C_LONG)
341 {
342 long int *num;
343 num = va_arg (args, long int *);
344 *num = currlen;
345 }
346 else
347 {
348 int *num;
349 num = va_arg (args, int *);
350 *num = currlen;
351 }
352 break;
353 case '%':
354 dopr_outch (buffer, &currlen, maxlen, ch);
355 break;
356 case 'w':
357 /* not supported yet, treat as next char */
358 ch = *format++;
359 break;
360 default:
361 /* Unknown, skip */
362 break;
363 }
364 ch = *format++;
365 state = DP_S_DEFAULT;
366 flags = cflags = min = 0;
367 max = -1;
368 break;
369 case DP_S_DONE:
370 break;
371 default:
372 /* hmm? */
373 break; /* some picky compilers need this */
374 }
375 }
376 if (currlen < maxlen - 1)
377 buffer[currlen] = '\0';
378 else
379 buffer[maxlen - 1] = '\0';
380
381 return (int)currlen;
382}
383
384static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
385 char *value, int flags, int min, int max)
386{
387 int padlen, strln; /* amount to pad */
388 int cnt = 0;
389
390 if (value == 0)
391 {
392 value = "<NULL>";
393 }
394
395 for (strln = 0; value[strln]; ++strln); /* strlen */
396 padlen = min - strln;
397 if (padlen < 0)
398 padlen = 0;
399 if (flags & DP_F_MINUS)
400 padlen = -padlen; /* Left Justify */
401
402 while ((padlen > 0) && (max == -1 || cnt < max))
403 {
404 dopr_outch (buffer, currlen, maxlen, ' ');
405 --padlen;
406 ++cnt;
407 }
408 while (*value && (max == -1 || cnt < max))
409 {
410 dopr_outch (buffer, currlen, maxlen, *value++);
411 ++cnt;
412 }
413 while ((padlen < 0) && (max == -1 || cnt < max))
414 {
415 dopr_outch (buffer, currlen, maxlen, ' ');
416 ++padlen;
417 ++cnt;
418 }
419}
420
421/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
422
423static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
424 long value, int base, int min, int max, int flags)
425{
426 int signvalue = 0;
427 unsigned long uvalue;
428 char convert[20];
429 int place = 0;
430 int spadlen = 0; /* amount to space pad */
431 int zpadlen = 0; /* amount to zero pad */
432 int caps = 0;
433
434 if (max < 0)
435 max = 0;
436
437 uvalue = value;
438
439 if(!(flags & DP_F_UNSIGNED))
440 {
441 if( value < 0 ) {
442 signvalue = '-';
443 uvalue = -value;
444 }
445 else
446 if (flags & DP_F_PLUS) /* Do a sign (+/i) */
447 signvalue = '+';
448 else
449 if (flags & DP_F_SPACE)
450 signvalue = ' ';
451 }
452
453 if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
454
455 do {
456 convert[place++] =
457 (caps? "0123456789ABCDEF":"0123456789abcdef")
458 [uvalue % (unsigned)base ];
459 uvalue = (uvalue / (unsigned)base );
460 } while(uvalue && (place < 20));
461 if (place == 20) place--;
462 convert[place] = 0;
463
464 zpadlen = max - place;
465 spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
466 if (zpadlen < 0) zpadlen = 0;
467 if (spadlen < 0) spadlen = 0;
468 if (flags & DP_F_ZERO)
469 {
470 zpadlen = MAX(zpadlen, spadlen);
471 spadlen = 0;
472 }
473 if (flags & DP_F_MINUS)
474 spadlen = -spadlen; /* Left Justifty */
475
476#ifdef DEBUG_SNPRINTF
477 dprint (1, (debugfile, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
478 zpadlen, spadlen, min, max, place));
479#endif
480
481 /* Spaces */
482 while (spadlen > 0)
483 {
484 dopr_outch (buffer, currlen, maxlen, ' ');
485 --spadlen;
486 }
487
488 /* Sign */
489 if (signvalue)
490 dopr_outch (buffer, currlen, maxlen, signvalue);
491
492 /* Zeros */
493 if (zpadlen > 0)
494 {
495 while (zpadlen > 0)
496 {
497 dopr_outch (buffer, currlen, maxlen, '0');
498 --zpadlen;
499 }
500 }
501
502 /* Digits */
503 while (place > 0)
504 dopr_outch (buffer, currlen, maxlen, convert[--place]);
505
506 /* Left Justified spaces */
507 while (spadlen < 0) {
508 dopr_outch (buffer, currlen, maxlen, ' ');
509 ++spadlen;
510 }
511}
512
513static long double abs_val (long double value)
514{
515 long double result = value;
516
517 if (value < 0)
518 result = -value;
519
520 return result;
521}
522
523static long double pow10 (int exp)
524{
525 long double result = 1;
526
527 while (exp)
528 {
529 result *= 10;
530 exp--;
531 }
532
533 return result;
534}
535
536static long round (long double value)
537{
538 long intpart;
539
540 intpart = value;
541 value = value - intpart;
542 if (value >= 0.5)
543 intpart++;
544
545 return intpart;
546}
547
548static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
549 long double fvalue, int min, int max, int flags)
550{
551 int signvalue = 0;
552 long double ufvalue;
553 char iconvert[20];
554 char fconvert[20];
555 int iplace = 0;
556 int fplace = 0;
557 int padlen = 0; /* amount to pad */
558 int zpadlen = 0;
559 int caps = 0;
560 long intpart;
561 long fracpart;
562
563 /*
564 * AIX manpage says the default is 0, but Solaris says the default
565 * is 6, and sprintf on AIX defaults to 6
566 */
567 if (max < 0)
568 max = 6;
569
570 ufvalue = abs_val (fvalue);
571
572 if (fvalue < 0)
573 signvalue = '-';
574 else
575 if (flags & DP_F_PLUS) /* Do a sign (+/i) */
576 signvalue = '+';
577 else
578 if (flags & DP_F_SPACE)
579 signvalue = ' ';
580
581#if 0
582 if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
583#endif
584
585 intpart = ufvalue;
586
587 /*