1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1999 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
9: *
10: * This software is licensed as described in the file COPYING, which
11: * you should have received as part of this distribution. The terms
12: * are also available at https://curl.haxx.se/docs/copyright.html.
13: *
14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15: * copies of the Software, and permit persons to whom the Software is
16: * furnished to do so, under the terms of the COPYING file.
17: *
18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: * KIND, either express or implied.
20: *
21: *
22: * Purpose:
23: * A merge of Bjorn Reese's format() function and Daniel's dsprintf()
24: * 1.0. A full blooded printf() clone with full support for <num>$
25: * everywhere (parameters, widths and precisions) including variabled
26: * sized parameters (like doubles, long longs, long doubles and even
27: * void * in 64-bit architectures).
28: *
29: * Current restrictions:
30: * - Max 128 parameters
31: * - No 'long double' support.
32: *
33: * If you ever want truly portable and good *printf() clones, the project that
34: * took on from here is named 'Trio' and you find more details on the trio web
35: * page at https://daniel.haxx.se/projects/trio/
36: */
37:
38: #include "curl_setup.h"
39: #include <curl/mprintf.h>
40:
41: #include "curl_memory.h"
42: /* The last #include file should be: */
43: #include "memdebug.h"
44:
45: /*
46: * If SIZEOF_SIZE_T has not been defined, default to the size of long.
47: */
48:
49: #ifdef HAVE_LONGLONG
50: # define LONG_LONG_TYPE long long
51: # define HAVE_LONG_LONG_TYPE
52: #else
53: # if defined(_MSC_VER) && (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)
54: # define LONG_LONG_TYPE __int64
55: # define HAVE_LONG_LONG_TYPE
56: # else
57: # undef LONG_LONG_TYPE
58: # undef HAVE_LONG_LONG_TYPE
59: # endif
60: #endif
61:
62: /*
63: * Non-ANSI integer extensions
64: */
65:
66: #if (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)) || \
67: (defined(__WATCOMC__) && defined(__386__)) || \
68: (defined(__POCC__) && defined(_MSC_VER)) || \
69: (defined(_WIN32_WCE)) || \
70: (defined(__MINGW32__)) || \
71: (defined(_MSC_VER) && (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64))
72: # define MP_HAVE_INT_EXTENSIONS
73: #endif
74:
75: /*
76: * Max integer data types that mprintf.c is capable
77: */
78:
79: #ifdef HAVE_LONG_LONG_TYPE
80: # define mp_intmax_t LONG_LONG_TYPE
81: # define mp_uintmax_t unsigned LONG_LONG_TYPE
82: #else
83: # define mp_intmax_t long
84: # define mp_uintmax_t unsigned long
85: #endif
86:
87: #define BUFFSIZE 326 /* buffer for long-to-str and float-to-str calcs, should
88: fit negative DBL_MAX (317 letters) */
89: #define MAX_PARAMETERS 128 /* lame static limit */
90:
91: #ifdef __AMIGA__
92: # undef FORMAT_INT
93: #endif
94:
95: /* Lower-case digits. */
96: static const char lower_digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
97:
98: /* Upper-case digits. */
99: static const char upper_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
100:
101: #define OUTCHAR(x) \
102: do{ \
103: if(stream((unsigned char)(x), (FILE *)data) != -1) \
104: done++; \
105: else \
106: return done; /* return immediately on failure */ \
107: } while(0)
108:
109: /* Data type to read from the arglist */
110: typedef enum {
111: FORMAT_UNKNOWN = 0,
112: FORMAT_STRING,
113: FORMAT_PTR,
114: FORMAT_INT,
115: FORMAT_INTPTR,
116: FORMAT_LONG,
117: FORMAT_LONGLONG,
118: FORMAT_DOUBLE,
119: FORMAT_LONGDOUBLE,
120: FORMAT_WIDTH /* For internal use */
121: } FormatType;
122:
123: /* conversion and display flags */
124: enum {
125: FLAGS_NEW = 0,
126: FLAGS_SPACE = 1<<0,
127: FLAGS_SHOWSIGN = 1<<1,
128: FLAGS_LEFT = 1<<2,
129: FLAGS_ALT = 1<<3,
130: FLAGS_SHORT = 1<<4,
131: FLAGS_LONG = 1<<5,
132: FLAGS_LONGLONG = 1<<6,
133: FLAGS_LONGDOUBLE = 1<<7,
134: FLAGS_PAD_NIL = 1<<8,
135: FLAGS_UNSIGNED = 1<<9,
136: FLAGS_OCTAL = 1<<10,
137: FLAGS_HEX = 1<<11,
138: FLAGS_UPPER = 1<<12,
139: FLAGS_WIDTH = 1<<13, /* '*' or '*<num>$' used */
140: FLAGS_WIDTHPARAM = 1<<14, /* width PARAMETER was specified */
141: FLAGS_PREC = 1<<15, /* precision was specified */
142: FLAGS_PRECPARAM = 1<<16, /* precision PARAMETER was specified */
143: FLAGS_CHAR = 1<<17, /* %c story */
144: FLAGS_FLOATE = 1<<18, /* %e or %E */
145: FLAGS_FLOATG = 1<<19 /* %g or %G */
146: };
147:
148: typedef struct {
149: FormatType type;
150: int flags;
151: long width; /* width OR width parameter number */
152: long precision; /* precision OR precision parameter number */
153: union {
154: char *str;
155: void *ptr;
156: union {
157: mp_intmax_t as_signed;
158: mp_uintmax_t as_unsigned;
159: } num;
160: double dnum;
161: } data;
162: } va_stack_t;
163:
164: struct nsprintf {
165: char *buffer;
166: size_t length;
167: size_t max;
168: };
169:
170: struct asprintf {
171: char *buffer; /* allocated buffer */
172: size_t len; /* length of string */
173: size_t alloc; /* length of alloc */
174: int fail; /* (!= 0) if an alloc has failed and thus
175: the output is not the complete data */
176: };
177:
178: static long dprintf_DollarString(char *input, char **end)
179: {
180: int number = 0;
181: while(ISDIGIT(*input)) {
182: number *= 10;
183: number += *input-'0';
184: input++;
185: }
186: if(number && ('$'==*input++)) {
187: *end = input;
188: return number;
189: }
190: return 0;
191: }
192:
193: static bool dprintf_IsQualifierNoDollar(const char *fmt)
194: {
195: #if defined(MP_HAVE_INT_EXTENSIONS)
196: if(!strncmp(fmt, "I32", 3) || !strncmp(fmt, "I64", 3)) {
197: return TRUE;
198: }
199: #endif
200:
201: switch(*fmt) {
202: case '-': case '+': case ' ': case '#': case '.':
203: case '0': case '1': case '2': case '3': case '4':
204: case '5': case '6': case '7': case '8': case '9':
205: case 'h': case 'l': case 'L': case 'z': case 'q':
206: case '*': case 'O':
207: #if defined(MP_HAVE_INT_EXTENSIONS)
208: case 'I':
209: #endif
210: return TRUE;
211:
212: default:
213: return FALSE;
214: }
215: }
216:
217: /******************************************************************
218: *
219: * Pass 1:
220: * Create an index with the type of each parameter entry and its
221: * value (may vary in size)
222: *
223: * Returns zero on success.
224: *
225: ******************************************************************/
226:
227: static int dprintf_Pass1(const char *format, va_stack_t *vto, char **endpos,
228: va_list arglist)
229: {
230: char *fmt = (char *)format;
231: int param_num = 0;
232: long this_param;
233: long width;
234: long precision;
235: int flags;
236: long max_param = 0;
237: long i;
238:
239: while(*fmt) {
240: if(*fmt++ == '%') {
241: if(*fmt == '%') {
242: fmt++;
243: continue; /* while */
244: }
245:
246: flags = FLAGS_NEW;
247:
248: /* Handle the positional case (N$) */
249:
250: param_num++;
251:
252: this_param = dprintf_DollarString(fmt, &fmt);
253: if(0 == this_param)
254: /* we got no positional, get the next counter */
255: this_param = param_num;
256:
257: if(this_param > max_param)
258: max_param = this_param;
259:
260: /*
261: * The parameter with number 'i' should be used. Next, we need
262: * to get SIZE and TYPE of the parameter. Add the information
263: * to our array.
264: */
265:
266: width = 0;
267: precision = 0;
268:
269: /* Handle the flags */
270:
271: while(dprintf_IsQualifierNoDollar(fmt)) {
272: #if defined(MP_HAVE_INT_EXTENSIONS)
273: if(!strncmp(fmt, "I32", 3)) {
274: flags |= FLAGS_LONG;
275: fmt += 3;
276: }
277: else if(!strncmp(fmt, "I64", 3)) {
278: flags |= FLAGS_LONGLONG;
279: fmt += 3;
280: }
281: else
282: #endif
283:
284: switch(*fmt++) {
285: case ' ':
286: flags |= FLAGS_SPACE;
287: break;
288: case '+':
289: flags |= FLAGS_SHOWSIGN;
290: break;
291: case '-':
292: flags |= FLAGS_LEFT;
293: flags &= ~FLAGS_PAD_NIL;
294: break;
295: case '#':
296: flags |= FLAGS_ALT;
297: break;
298: case '.':
299: if('*' == *fmt) {
300: /* The precision is picked from a specified parameter */
301:
302: flags |= FLAGS_PRECPARAM;
303: fmt++;
304: param_num++;
305:
306: i = dprintf_DollarString(fmt, &fmt);
307: if(i)
308: precision = i;
309: else
310: precision = param_num;
311:
312: if(precision > max_param)
313: max_param = precision;
314: }
315: else {
316: flags |= FLAGS_PREC;
317: precision = strtol(fmt, &fmt, 10);
318: }
319: break;
320: case 'h':
321: flags |= FLAGS_SHORT;
322: break;
323: #if defined(MP_HAVE_INT_EXTENSIONS)
324: case 'I':
325: #if (SIZEOF_CURL_OFF_T > SIZEOF_LONG)
326: flags |= FLAGS_LONGLONG;
327: #else
328: flags |= FLAGS_LONG;
329: #endif
330: break;
331: #endif
332: case 'l':
333: if(flags & FLAGS_LONG)
334: flags |= FLAGS_LONGLONG;
335: else
336: flags |= FLAGS_LONG;
337: break;
338: case 'L':
339: flags |= FLAGS_LONGDOUBLE;
340: break;
341: case 'q':
342: flags |= FLAGS_LONGLONG;
343: break;
344: case 'z':
345: /* the code below generates a warning if -Wunreachable-code is
346: used */
347: #if (SIZEOF_SIZE_T > SIZEOF_LONG)
348: flags |= FLAGS_LONGLONG;
349: #else
350: flags |= FLAGS_LONG;
351: #endif
352: break;
353: case 'O':
354: #if (SIZEOF_CURL_OFF_T > SIZEOF_LONG)
355: flags |= FLAGS_LONGLONG;
356: #else
357: flags |= FLAGS_LONG;
358: #endif
359: break;
360: case '0':
361: if(!(flags & FLAGS_LEFT))
362: flags |= FLAGS_PAD_NIL;
363: /* FALLTHROUGH */
364: case '1': case '2': case '3': case '4':
365: case '5': case '6': case '7': case '8': case '9':
366: flags |= FLAGS_WIDTH;
367: width = strtol(fmt-1, &fmt, 10);
368: break;
369: case '*': /* Special case */
370: flags |= FLAGS_WIDTHPARAM;
371: param_num++;
372:
373: i = dprintf_DollarString(fmt, &fmt);
374: if(i)
375: width = i;
376: else
377: width = param_num;
378: if(width > max_param)
379: max_param = width;
380: break;
381: default:
382: break;
383: }
384: } /* switch */
385:
386: /* Handle the specifier */
387:
388: i = this_param - 1;
389:
390: if((i < 0) || (i >= MAX_PARAMETERS))
391: /* out of allowed range */
392: return 1;
393:
394: switch (*fmt) {
395: case 'S':
396: flags |= FLAGS_ALT;
397: /* FALLTHROUGH */
398: case 's':
399: vto[i].type = FORMAT_STRING;
400: break;
401: case 'n':
402: vto[i].type = FORMAT_INTPTR;
403: break;
404: case 'p':
405: vto[i].type = FORMAT_PTR;
406: break;
407: case 'd': case 'i':
408: vto[i].type = FORMAT_INT;
409: break;
410: case 'u':
411: vto[i].type = FORMAT_INT;
412: flags |= FLAGS_UNSIGNED;
413: break;
414: case 'o':
415: vto[i].type = FORMAT_INT;
416: flags |= FLAGS_OCTAL;
417: break;
418: case 'x':
419: vto[i].type = FORMAT_INT;
420: flags |= FLAGS_HEX|FLAGS_UNSIGNED;
421: break;
422: case 'X':
423: vto[i].type = FORMAT_INT;
424: flags |= FLAGS_HEX|FLAGS_UPPER|FLAGS_UNSIGNED;
425: break;
426: case 'c':
427: vto[i].type = FORMAT_INT;
428: flags |= FLAGS_CHAR;
429: break;
430: case 'f':
431: vto[i].type = FORMAT_DOUBLE;
432: break;
433: case 'e':
434: vto[i].type = FORMAT_DOUBLE;
435: flags |= FLAGS_FLOATE;
436: break;
437: case 'E':
438: vto[i].type = FORMAT_DOUBLE;
439: flags |= FLAGS_FLOATE|FLAGS_UPPER;
440: break;
441: case 'g':
442: vto[i].type = FORMAT_DOUBLE;
443: flags |= FLAGS_FLOATG;
444: break;
445: case 'G':
446: vto[i].type = FORMAT_DOUBLE;
447: flags |= FLAGS_FLOATG|FLAGS_UPPER;
448: break;
449: default:
450: vto[i].type = FORMAT_UNKNOWN;
451: break;
452: } /* switch */
453:
454: vto[i].flags = flags;
455: vto[i].width = width;
456: vto[i].precision = precision;
457:
458: if(flags & FLAGS_WIDTHPARAM) {
459: /* we have the width specified from a parameter, so we make that
460: parameter's info setup properly */
461: long k = width - 1;
462: vto[i].width = k;
463: vto[k].type = FORMAT_WIDTH;
464: vto[k].flags = FLAGS_NEW;
465: /* can't use width or precision of width! */
466: vto[k].width = 0;
467: vto[k].precision = 0;
468: }
469: if(flags & FLAGS_PRECPARAM) {
470: /* we have the precision specified from a parameter, so we make that
471: parameter's info setup properly */
472: long k = precision - 1;
473: vto[i].precision = k;
474: vto[k].type = FORMAT_WIDTH;
475: vto[k].flags = FLAGS_NEW;
476: /* can't use width or precision of width! */
477: vto[k].width = 0;
478: vto[k].precision = 0;
479: }
480: *endpos++ = fmt + 1; /* end of this sequence */
481: }
482: }
483:
484: /* Read the arg list parameters into our data list */
485: for(i = 0; i<max_param; i++) {
486: /* Width/precision arguments must be read before the main argument
487: they are attached to */
488: if(vto[i].flags & FLAGS_WIDTHPARAM) {
489: vto[vto[i].width].data.num.as_signed =
490: (mp_intmax_t)va_arg(arglist, int);
491: }
492: if(vto[i].flags & FLAGS_PRECPARAM) {
493: vto[vto[i].precision].data.num.as_signed =
494: (mp_intmax_t)va_arg(arglist, int);
495: }
496:
497: switch(vto[i].type) {
498: case FORMAT_STRING:
499: vto[i].data.str = va_arg(arglist, char *);
500: break;
501:
502: case FORMAT_INTPTR:
503: case FORMAT_UNKNOWN:
504: case FORMAT_PTR:
505: vto[i].data.ptr = va_arg(arglist, void *);
506: break;
507:
508: case FORMAT_INT:
509: #ifdef HAVE_LONG_LONG_TYPE
510: if((vto[i].flags & FLAGS_LONGLONG) && (vto[i].flags & FLAGS_UNSIGNED))
511: vto[i].data.num.as_unsigned =
512: (mp_uintmax_t)va_arg(arglist, mp_uintmax_t);
513: else if(vto[i].flags & FLAGS_LONGLONG)
514: vto[i].data.num.as_signed =
515: (mp_intmax_t)va_arg(arglist, mp_intmax_t);
516: else
517: #endif
518: {
519: if((vto[i].flags & FLAGS_LONG) && (vto[i].flags & FLAGS_UNSIGNED))
520: vto[i].data.num.as_unsigned =
521: (mp_uintmax_t)va_arg(arglist, unsigned long);
522: else if(vto[i].flags & FLAGS_LONG)
523: vto[i].data.num.as_signed =
524: (mp_intmax_t)va_arg(arglist, long);
525: else if(vto[i].flags & FLAGS_UNSIGNED)
526: vto[i].data.num.as_unsigned =
527: (mp_uintmax_t)va_arg(arglist, unsigned int);
528: else
529: vto[i].data.num.as_signed =
530: (mp_intmax_t)va_arg(arglist, int);
531: }
532: break;
533:
534: case FORMAT_DOUBLE:
535: vto[i].data.dnum = va_arg(arglist, double);
536: break;
537:
538: case FORMAT_WIDTH:
539: /* Argument has been read. Silently convert it into an integer
540: * for later use
541: */
542: vto[i].type = FORMAT_INT;
543: break;
544:
545: default:
546: break;
547: }
548: }
549:
550: return 0;
551:
552: }
553:
554: static int dprintf_formatf(
555: void *data, /* untouched by format(), just sent to the stream() function in
556: the second argument */
557: /* function pointer called for each output character */
558: int (*stream)(int, FILE *),
559: const char *format, /* %-formatted string */
560: va_list ap_save) /* list of parameters */
561: {
562: /* Base-36 digits for numbers. */
563: const char *digits = lower_digits;
564:
565: /* Pointer into the format string. */
566: char *f;
567:
568: /* Number of characters written. */
569: int done = 0;
570:
571: long param; /* current parameter to read */
572: long param_num = 0; /* parameter counter */
573:
574: va_stack_t vto[MAX_PARAMETERS];
575: char *endpos[MAX_PARAMETERS];
576: char **end;
577:
578: char work[BUFFSIZE];
579:
580: va_stack_t *p;
581:
582: /* 'workend' points to the final buffer byte position, but with an extra
583: byte as margin to avoid the (false?) warning Coverity gives us
584: otherwise */
585: char *workend = &work[sizeof(work) - 2];
586:
587: /* Do the actual %-code parsing */
588: if(dprintf_Pass1(format, vto, endpos, ap_save))
589: return -1;
590:
591: end = &endpos[0]; /* the initial end-position from the list dprintf_Pass1()
592: created for us */
593:
594: f = (char *)format;
595: while(*f != '\0') {
596: /* Format spec modifiers. */
597: int is_alt;
598:
599: /* Width of a field. */
600: long width;
601:
602: /* Precision of a field. */
603: long prec;
604:
605: /* Decimal integer is negative. */
606: int is_neg;
607:
608: /* Base of a number to be written. */
609: unsigned long base;
610:
611: /* Integral values to be written. */
612: mp_uintmax_t num;
613:
614: /* Used to convert negative in positive. */
615: mp_intmax_t signed_num;
616:
617: char *w;
618:
619: if(*f != '%') {
620: /* This isn't a format spec, so write everything out until the next one
621: OR end of string is reached. */
622: do {
623: OUTCHAR(*f);
624: } while(*++f && ('%' != *f));
625: continue;
626: }
627:
628: ++f;
629:
630: /* Check for "%%". Note that although the ANSI standard lists
631: '%' as a conversion specifier, it says "The complete format
632: specification shall be `%%'," so we can avoid all the width
633: and precision processing. */
634: if(*f == '%') {
635: ++f;
636: OUTCHAR('%');
637: continue;
638: }
639:
640: /* If this is a positional parameter, the position must follow immediately
641: after the %, thus create a %<num>$ sequence */
642: param = dprintf_DollarString(f, &f);
643:
644: if(!param)
645: param = param_num;
646: else
647: --param;
648:
649: param_num++; /* increase this always to allow "%2$s %1$s %s" and then the
650: third %s will pick the 3rd argument */
651:
652: p = &vto[param];
653:
654: /* pick up the specified width */
655: if(p->flags & FLAGS_WIDTHPARAM) {
656: width = (long)vto[p->width].data.num.as_signed;
657: param_num++; /* since the width is extracted from a parameter, we
658: must skip that to get to the next one properly */
659: if(width < 0) {
660: /* "A negative field width is taken as a '-' flag followed by a
661: positive field width." */
662: width = -width;
663: p->flags |= FLAGS_LEFT;
664: p->flags &= ~FLAGS_PAD_NIL;
665: }
666: }
667: else
668: width = p->width;
669:
670: /* pick up the specified precision */
671: if(p->flags & FLAGS_PRECPARAM) {
672: prec = (long)vto[p->precision].data.num.as_signed;
673: param_num++; /* since the precision is extracted from a parameter, we
674: must skip that to get to the next one properly */
675: if(prec < 0)
676: /* "A negative precision is taken as if the precision were
677: omitted." */
678: prec = -1;
679: }
680: else if(p->flags & FLAGS_PREC)
681: prec = p->precision;
682: else
683: prec = -1;
684:
685: is_alt = (p->flags & FLAGS_ALT) ? 1 : 0;
686:
687: switch(p->type) {
688: case FORMAT_INT:
689: num = p->data.num.as_unsigned;
690: if(p->flags & FLAGS_CHAR) {
691: /* Character. */
692: if(!(p->flags & FLAGS_LEFT))
693: while(--width > 0)
694: OUTCHAR(' ');
695: OUTCHAR((char) num);
696: if(p->flags & FLAGS_LEFT)
697: while(--width > 0)
698: OUTCHAR(' ');
699: break;
700: }
701: if(p->flags & FLAGS_OCTAL) {
702: /* Octal unsigned integer. */
703: base = 8;
704: goto unsigned_number;
705: }
706: else if(p->flags & FLAGS_HEX) {
707: /* Hexadecimal unsigned integer. */
708:
709: digits = (p->flags & FLAGS_UPPER)? upper_digits : lower_digits;
710: base = 16;
711: goto unsigned_number;
712: }
713: else if(p->flags & FLAGS_UNSIGNED) {
714: /* Decimal unsigned integer. */
715: base = 10;
716: goto unsigned_number;
717: }
718:
719: /* Decimal integer. */
720: base = 10;
721:
722: is_neg = (p->data.num.as_signed < (mp_intmax_t)0) ? 1 : 0;
723: if(is_neg) {
724: /* signed_num might fail to hold absolute negative minimum by 1 */
725: signed_num = p->data.num.as_signed + (mp_intmax_t)1;
726: signed_num = -signed_num;
727: num = (mp_uintmax_t)signed_num;
728: num += (mp_uintmax_t)1;
729: }
730:
731: goto number;
732:
733: unsigned_number:
734: /* Unsigned number of base BASE. */
735: is_neg = 0;
736:
737: number:
738: /* Number of base BASE. */
739:
740: /* Supply a default precision if none was given. */
741: if(prec == -1)
742: prec = 1;
743:
744: /* Put the number in WORK. */
745: w = workend;
746: while(num > 0) {
747: *w-- = digits[num % base];
748: num /= base;
749: }
750: width -= (long)(workend - w);
751: prec -= (long)(workend - w);
752:
753: if(is_alt && base == 8 && prec <= 0) {
754: *w-- = '0';
755: --width;
756: }
757:
758: if(prec > 0) {
759: width -= prec;
760: while(prec-- > 0)
761: *w-- = '0';
762: }
763:
764: if(is_alt && base == 16)
765: width -= 2;
766:
767: if(is_neg || (p->flags & FLAGS_SHOWSIGN) || (p->flags & FLAGS_SPACE))
768: --width;
769:
770: if(!(p->flags & FLAGS_LEFT) && !(p->flags & FLAGS_PAD_NIL))
771: while(width-- > 0)
772: OUTCHAR(' ');
773:
774: if(is_neg)
775: OUTCHAR('-');
776: else if(p->flags & FLAGS_SHOWSIGN)
777: OUTCHAR('+');
778: else if(p->flags & FLAGS_SPACE)
779: OUTCHAR(' ');
780:
781: if(is_alt && base == 16) {
782: OUTCHAR('0');
783: if(p->flags & FLAGS_UPPER)
784: OUTCHAR('X');
785: else
786: OUTCHAR('x');
787: }
788:
789: if(!(p->flags & FLAGS_LEFT) && (p->flags & FLAGS_PAD_NIL))
790: while(width-- > 0)
791: OUTCHAR('0');
792:
793: /* Write the number. */
794: while(++w <= workend) {
795: OUTCHAR(*w);
796: }
797:
798: if(p->flags & FLAGS_LEFT)
799: while(width-- > 0)
800: OUTCHAR(' ');
801: break;
802:
803: case FORMAT_STRING:
804: /* String. */
805: {
806: static const char null[] = "(nil)";
807: const char *str;
808: size_t len;
809:
810: str = (char *) p->data.str;
811: if(str == NULL) {
812: /* Write null[] if there's space. */
813: if(prec == -1 || prec >= (long) sizeof(null) - 1) {
814: str = null;
815: len = sizeof(null) - 1;
816: /* Disable quotes around (nil) */
817: p->flags &= (~FLAGS_ALT);
818: }
819: else {
820: str = "";
821: len = 0;
822: }
823: }
824: else if(prec != -1)
825: len = (size_t)prec;
826: else
827: len = strlen(str);
828:
829: width -= (len > LONG_MAX) ? LONG_MAX : (long)len;
830:
831: if(p->flags & FLAGS_ALT)
832: OUTCHAR('"');
833:
834: if(!(p->flags&FLAGS_LEFT))
835: while(width-- > 0)
836: OUTCHAR(' ');
837:
838: for(; len && *str; len--)
839: OUTCHAR(*str++);
840: if(p->flags&FLAGS_LEFT)
841: while(width-- > 0)
842: OUTCHAR(' ');
843:
844: if(p->flags & FLAGS_ALT)
845: OUTCHAR('"');
846: }
847: break;
848:
849: case FORMAT_PTR:
850: /* Generic pointer. */
851: {
852: void *ptr;
853: ptr = (void *) p->data.ptr;
854: if(ptr != NULL) {
855: /* If the pointer is not NULL, write it as a %#x spec. */
856: base = 16;
857: digits = (p->flags & FLAGS_UPPER)? upper_digits : lower_digits;
858: is_alt = 1;
859: num = (size_t) ptr;
860: is_neg = 0;
861: goto number;
862: }
863: else {
864: /* Write "(nil)" for a nil pointer. */
865: static const char strnil[] = "(nil)";
866: const char *point;
867:
868: width -= (long)(sizeof(strnil) - 1);
869: if(p->flags & FLAGS_LEFT)
870: while(width-- > 0)
871: OUTCHAR(' ');
872: for(point = strnil; *point != '\0'; ++point)
873: OUTCHAR(*point);
874: if(! (p->flags & FLAGS_LEFT))
875: while(width-- > 0)
876: OUTCHAR(' ');
877: }
878: }
879: break;
880:
881: case FORMAT_DOUBLE:
882: {
883: char formatbuf[32]="%";
884: char *fptr = &formatbuf[1];
885: size_t left = sizeof(formatbuf)-strlen(formatbuf);
886: int len;
887:
888: width = -1;
889: if(p->flags & FLAGS_WIDTH)
890: width = p->width;
891: else if(p->flags & FLAGS_WIDTHPARAM)
892: width = (long)vto[p->width].data.num.as_signed;
893:
894: prec = -1;
895: if(p->flags & FLAGS_PREC)
896: prec = p->precision;
897: else if(p->flags & FLAGS_PRECPARAM)
898: prec = (long)vto[p->precision].data.num.as_signed;
899:
900: if(p->flags & FLAGS_LEFT)
901: *fptr++ = '-';
902: if(p->flags & FLAGS_SHOWSIGN)
903: *fptr++ = '+';
904: if(p->flags & FLAGS_SPACE)
905: *fptr++ = ' ';
906: if(p->flags & FLAGS_ALT)
907: *fptr++ = '#';
908:
909: *fptr = 0;
910:
911: if(width >= 0) {
912: if(width >= (long)sizeof(work))
913: width = sizeof(work)-1;
914: /* RECURSIVE USAGE */
915: len = curl_msnprintf(fptr, left, "%ld", width);
916: fptr += len;
917: left -= len;
918: }
919: if(prec >= 0) {
920: /* for each digit in the integer part, we can have one less
921: precision */
922: size_t maxprec = sizeof(work) - 2;
923: double val = p->data.dnum;
924: while(val >= 10.0) {
925: val /= 10;
926: maxprec--;
927: }
928:
929: if(prec > (long)maxprec)
930: prec = (long)maxprec-1;
931: /* RECURSIVE USAGE */
932: len = curl_msnprintf(fptr, left, ".%ld", prec);
933: fptr += len;
934: }
935: if(p->flags & FLAGS_LONG)
936: *fptr++ = 'l';
937:
938: if(p->flags & FLAGS_FLOATE)
939: *fptr++ = (char)((p->flags & FLAGS_UPPER) ? 'E':'e');
940: else if(p->flags & FLAGS_FLOATG)
941: *fptr++ = (char)((p->flags & FLAGS_UPPER) ? 'G' : 'g');
942: else
943: *fptr++ = 'f';
944:
945: *fptr = 0; /* and a final zero termination */
946:
947: /* NOTE NOTE NOTE!! Not all sprintf implementations return number of
948: output characters */
949: (sprintf)(work, formatbuf, p->data.dnum);
950: DEBUGASSERT(strlen(work) <= sizeof(work));
951: for(fptr = work; *fptr; fptr++)
952: OUTCHAR(*fptr);
953: }
954: break;
955:
956: case FORMAT_INTPTR:
957: /* Answer the count of characters written. */
958: #ifdef HAVE_LONG_LONG_TYPE
959: if(p->flags & FLAGS_LONGLONG)
960: *(LONG_LONG_TYPE *) p->data.ptr = (LONG_LONG_TYPE)done;
961: else
962: #endif
963: if(p->flags & FLAGS_LONG)
964: *(long *) p->data.ptr = (long)done;
965: else if(!(p->flags & FLAGS_SHORT))
966: *(int *) p->data.ptr = (int)done;
967: else
968: *(short *) p->data.ptr = (short)done;
969: break;
970:
971: default:
972: break;
973: }
974: f = *end++; /* goto end of %-code */
975:
976: }
977: return done;
978: }
979:
980: /* fputc() look-alike */
981: static int addbyter(int output, FILE *data)
982: {
983: struct nsprintf *infop = (struct nsprintf *)data;
984: unsigned char outc = (unsigned char)output;
985:
986: if(infop->length < infop->max) {
987: /* only do this if we haven't reached max length yet */
988: infop->buffer[0] = outc; /* store */
989: infop->buffer++; /* increase pointer */
990: infop->length++; /* we are now one byte larger */
991: return outc; /* fputc() returns like this on success */
992: }
993: return -1;
994: }
995:
996: int curl_mvsnprintf(char *buffer, size_t maxlength, const char *format,
997: va_list ap_save)
998: {
999: int retcode;
1000: struct nsprintf info;
1001:
1002: info.buffer = buffer;
1003: info.length = 0;
1004: info.max = maxlength;
1005:
1006: retcode = dprintf_formatf(&info, addbyter, format, ap_save);
1007: if((retcode != -1) && info.max) {
1008: /* we terminate this with a zero byte */
1009: if(info.max == info.length)
1010: /* we're at maximum, scrap the last letter */
1011: info.buffer[-1] = 0;
1012: else
1013: info.buffer[0] = 0;
1014: }
1015: return retcode;
1016: }
1017:
1018: int curl_msnprintf(char *buffer, size_t maxlength, const char *format, ...)
1019: {
1020: int retcode;
1021: va_list ap_save; /* argument pointer */
1022: va_start(ap_save, format);
1023: retcode = curl_mvsnprintf(buffer, maxlength, format, ap_save);
1024: va_end(ap_save);
1025: return retcode;
1026: }
1027:
1028: /* fputc() look-alike */
1029: static int alloc_addbyter(int output, FILE *data)
1030: {
1031: struct asprintf *infop = (struct asprintf *)data;
1032: unsigned char outc = (unsigned char)output;
1033:
1034: if(!infop->buffer) {
1035: infop->buffer = malloc(32);
1036: if(!infop->buffer) {
1037: infop->fail = 1;
1038: return -1; /* fail */
1039: }
1040: infop->alloc = 32;
1041: infop->len = 0;
1042: }
1043: else if(infop->len + 1 >= infop->alloc) {
1044: char *newptr = NULL;
1045: size_t newsize = infop->alloc*2;
1046:
1047: /* detect wrap-around or other overflow problems */
1048: if(newsize > infop->alloc)
1049: newptr = realloc(infop->buffer, newsize);
1050:
1051: if(!newptr) {
1052: infop->fail = 1;
1053: return -1; /* fail */
1054: }
1055: infop->buffer = newptr;
1056: infop->alloc = newsize;
1057: }
1058:
1059: infop->buffer[ infop->len ] = outc;
1060:
1061: infop->len++;
1062:
1063: return outc; /* fputc() returns like this on success */
1064: }
1065:
1066: char *curl_maprintf(const char *format, ...)
1067: {
1068: va_list ap_save; /* argument pointer */
1069: int retcode;
1070: struct asprintf info;
1071:
1072: info.buffer = NULL;
1073: info.len = 0;
1074: info.alloc = 0;
1075: info.fail = 0;
1076:
1077: va_start(ap_save, format);
1078: retcode = dprintf_formatf(&info, alloc_addbyter, format, ap_save);
1079: va_end(ap_save);
1080: if((-1 == retcode) || info.fail) {
1081: if(info.alloc)
1082: free(info.buffer);
1083: return NULL;
1084: }
1085: if(info.alloc) {
1086: info.buffer[info.len] = 0; /* we terminate this with a zero byte */
1087: return info.buffer;
1088: }
1089: return strdup("");
1090: }
1091:
1092: char *curl_mvaprintf(const char *format, va_list ap_save)
1093: {
1094: int retcode;
1095: struct asprintf info;
1096:
1097: info.buffer = NULL;
1098: info.len = 0;
1099: info.alloc = 0;
1100: info.fail = 0;
1101:
1102: retcode = dprintf_formatf(&info, alloc_addbyter, format, ap_save);
1103: if((-1 == retcode) || info.fail) {
1104: if(info.alloc)
1105: free(info.buffer);
1106: return NULL;
1107: }
1108:
1109: if(info.alloc) {
1110: info.buffer[info.len] = 0; /* we terminate this with a zero byte */
1111: return info.buffer;
1112: }
1113: return strdup("");
1114: }
1115:
1116: static int storebuffer(int output, FILE *data)
1117: {
1118: char **buffer = (char **)data;
1119: unsigned char outc = (unsigned char)output;
1120: **buffer = outc;
1121: (*buffer)++;
1122: return outc; /* act like fputc() ! */
1123: }
1124:
1125: int curl_msprintf(char *buffer, const char *format, ...)
1126: {
1127: va_list ap_save; /* argument pointer */
1128: int retcode;
1129: va_start(ap_save, format);
1130: retcode = dprintf_formatf(&buffer, storebuffer, format, ap_save);
1131: va_end(ap_save);
1132: *buffer = 0; /* we terminate this with a zero byte */
1133: return retcode;
1134: }
1135:
1136: int curl_mprintf(const char *format, ...)
1137: {
1138: int retcode;
1139: va_list ap_save; /* argument pointer */
1140: va_start(ap_save, format);
1141:
1142: retcode = dprintf_formatf(stdout, fputc, format, ap_save);
1143: va_end(ap_save);
1144: return retcode;
1145: }
1146:
1147: int curl_mfprintf(FILE *whereto, const char *format, ...)
1148: {
1149: int retcode;
1150: va_list ap_save; /* argument pointer */
1151: va_start(ap_save, format);
1152: retcode = dprintf_formatf(whereto, fputc, format, ap_save);
1153: va_end(ap_save);
1154: return retcode;
1155: }
1156:
1157: int curl_mvsprintf(char *buffer, const char *format, va_list ap_save)
1158: {
1159: int retcode;
1160: retcode = dprintf_formatf(&buffer, storebuffer, format, ap_save);
1161: *buffer = 0; /* we terminate this with a zero byte */
1162: return retcode;
1163: }
1164:
1165: int curl_mvprintf(const char *format, va_list ap_save)
1166: {
1167: return dprintf_formatf(stdout, fputc, format, ap_save);
1168: }
1169:
1170: int curl_mvfprintf(FILE *whereto, const char *format, va_list ap_save)
1171: {
1172: return dprintf_formatf(whereto, fputc, format, ap_save);
1173: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mprintf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib