1/*
2 * Copyright (c) 1983, 1995, 1996 Eric P. Allman
3 * Copyright (c) 1988, 1993
4 * The Regents of the University of California. All rights reserved.
5 * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 * src/port/snprintf.c
32 */
33
34#include "c.h"
35
36#include <math.h>
37
38/*
39 * We used to use the platform's NL_ARGMAX here, but that's a bad idea,
40 * first because the point of this module is to remove platform dependencies
41 * not perpetuate them, and second because some platforms use ridiculously
42 * large values, leading to excessive stack consumption in dopr().
43 */
44#define PG_NL_ARGMAX 31
45
46
47/*
48 * SNPRINTF, VSNPRINTF and friends
49 *
50 * These versions have been grabbed off the net. They have been
51 * cleaned up to compile properly and support for most of the C99
52 * specification has been added. Remaining unimplemented features are:
53 *
54 * 1. No locale support: the radix character is always '.' and the '
55 * (single quote) format flag is ignored.
56 *
57 * 2. No support for the "%n" format specification.
58 *
59 * 3. No support for wide characters ("lc" and "ls" formats).
60 *
61 * 4. No support for "long double" ("Lf" and related formats).
62 *
63 * 5. Space and '#' flags are not implemented.
64 *
65 * In addition, we support some extensions over C99:
66 *
67 * 1. Argument order control through "%n$" and "*n$", as required by POSIX.
68 *
69 * 2. "%m" expands to the value of strerror(errno), where errno is the
70 * value that variable had at the start of the call. This is a glibc
71 * extension, but a very useful one.
72 *
73 *
74 * Historically the result values of sprintf/snprintf varied across platforms.
75 * This implementation now follows the C99 standard:
76 *
77 * 1. -1 is returned if an error is detected in the format string, or if
78 * a write to the target stream fails (as reported by fwrite). Note that
79 * overrunning snprintf's target buffer is *not* an error.
80 *
81 * 2. For successful writes to streams, the actual number of bytes written
82 * to the stream is returned.
83 *
84 * 3. For successful sprintf/snprintf, the number of bytes that would have
85 * been written to an infinite-size buffer (excluding the trailing '\0')
86 * is returned. snprintf will truncate its output to fit in the buffer
87 * (ensuring a trailing '\0' unless count == 0), but this is not reflected
88 * in the function result.
89 *
90 * snprintf buffer overrun can be detected by checking for function result
91 * greater than or equal to the supplied count.
92 */
93
94/**************************************************************
95 * Original:
96 * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
97 * A bombproof version of doprnt (dopr) included.
98 * Sigh. This sort of thing is always nasty do deal with. Note that
99 * the version here does not include floating point. (now it does ... tgl)
100 **************************************************************/
101
102/* Prevent recursion */
103#undef vsnprintf
104#undef snprintf
105#undef vsprintf
106#undef sprintf
107#undef vfprintf
108#undef fprintf
109#undef vprintf
110#undef printf
111
112/*
113 * Info about where the formatted output is going.
114 *
115 * dopr and subroutines will not write at/past bufend, but snprintf
116 * reserves one byte, ensuring it may place the trailing '\0' there.
117 *
118 * In snprintf, we use nchars to count the number of bytes dropped on the
119 * floor due to buffer overrun. The correct result of snprintf is thus
120 * (bufptr - bufstart) + nchars. (This isn't as inconsistent as it might
121 * seem: nchars is the number of emitted bytes that are not in the buffer now,
122 * either because we sent them to the stream or because we couldn't fit them
123 * into the buffer to begin with.)
124 */
125typedef struct
126{
127 char *bufptr; /* next buffer output position */
128 char *bufstart; /* first buffer element */
129 char *bufend; /* last+1 buffer element, or NULL */
130 /* bufend == NULL is for sprintf, where we assume buf is big enough */
131 FILE *stream; /* eventual output destination, or NULL */
132 int nchars; /* # chars sent to stream, or dropped */
133 bool failed; /* call is a failure; errno is set */
134} PrintfTarget;
135
136/*
137 * Info about the type and value of a formatting parameter. Note that we
138 * don't currently support "long double", "wint_t", or "wchar_t *" data,
139 * nor the '%n' formatting code; else we'd need more types. Also, at this
140 * level we need not worry about signed vs unsigned values.
141 */
142typedef enum
143{
144 ATYPE_NONE = 0,
145 ATYPE_INT,
146 ATYPE_LONG,
147 ATYPE_LONGLONG,
148 ATYPE_DOUBLE,
149 ATYPE_CHARPTR
150} PrintfArgType;
151
152typedef union
153{
154 int i;
155 long l;
156 long long ll;
157 double d;
158 char *cptr;
159} PrintfArgValue;
160
161
162static void flushbuffer(PrintfTarget *target);
163static void dopr(PrintfTarget *target, const char *format, va_list args);
164
165
166/*
167 * Externally visible entry points.
168 *
169 * All of these are just wrappers around dopr(). Note it's essential that
170 * they not change the value of "errno" before reaching dopr().
171 */
172
173int
174pg_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
175{
176 PrintfTarget target;
177 char onebyte[1];
178
179 /*
180 * C99 allows the case str == NULL when count == 0. Rather than
181 * special-casing this situation further down, we substitute a one-byte
182 * local buffer. Callers cannot tell, since the function result doesn't
183 * depend on count.
184 */
185 if (count == 0)
186 {
187 str = onebyte;
188 count = 1;
189 }
190 target.bufstart = target.bufptr = str;
191 target.bufend = str + count - 1;
192 target.stream = NULL;
193 target.nchars = 0;
194 target.failed = false;
195 dopr(&target, fmt, args);
196 *(target.bufptr) = '\0';
197 return target.failed ? -1 : (target.bufptr - target.bufstart
198 + target.nchars);
199}
200
201int
202pg_snprintf(char *str, size_t count, const char *fmt,...)
203{
204 int len;
205 va_list args;
206
207 va_start(args, fmt);
208 len = pg_vsnprintf(str, count, fmt, args);
209 va_end(args);
210 return len;
211}
212
213int
214pg_vsprintf(char *str, const char *fmt, va_list args)
215{
216 PrintfTarget target;
217
218 target.bufstart = target.bufptr = str;
219 target.bufend = NULL;
220 target.stream = NULL;
221 target.nchars = 0; /* not really used in this case */
222 target.failed = false;
223 dopr(&target, fmt, args);
224 *(target.bufptr) = '\0';
225 return target.failed ? -1 : (target.bufptr - target.bufstart
226 + target.nchars);
227}
228
229int
230pg_sprintf(char *str, const char *fmt,...)
231{
232 int len;
233 va_list args;
234
235 va_start(args, fmt);
236 len = pg_vsprintf(str, fmt, args);
237 va_end(args);
238 return len;
239}
240
241int
242pg_vfprintf(FILE *stream, const char *fmt, va_list args)
243{
244 PrintfTarget target;
245 char buffer[1024]; /* size is arbitrary */
246
247 if (stream == NULL)
248 {
249 errno = EINVAL;
250 return -1;
251 }
252 target.bufstart = target.bufptr = buffer;
253 target.bufend = buffer + sizeof(buffer); /* use the whole buffer */
254 target.stream = stream;
255 target.nchars = 0;
256 target.failed = false;
257 dopr(&target, fmt, args);
258 /* dump any remaining buffer contents */
259 flushbuffer(&target);
260 return target.failed ? -1 : target.nchars;
261}
262
263int
264pg_fprintf(FILE *stream, const char *fmt,...)
265{
266 int len;
267 va_list args;
268
269 va_start(args, fmt);
270 len = pg_vfprintf(stream, fmt, args);
271 va_end(args);
272 return len;
273}
274
275int
276pg_vprintf(const char *fmt, va_list args)
277{
278 return pg_vfprintf(stdout, fmt, args);
279}
280
281int
282pg_printf(const char *fmt,...)
283{
284 int len;
285 va_list args;
286
287 va_start(args, fmt);
288 len = pg_vfprintf(stdout, fmt, args);
289 va_end(args);
290 return len;
291}
292
293/*
294 * Attempt to write the entire buffer to target->stream; discard the entire
295 * buffer in any case. Call this only when target->stream is defined.
296 */
297static void
298flushbuffer(PrintfTarget *target)
299{
300 size_t nc = target->bufptr - target->bufstart;
301
302 /*
303 * Don't write anything if we already failed; this is to ensure we
304 * preserve the original failure's errno.
305 */
306 if (!target->failed && nc > 0)
307 {
308 size_t written;
309
310 written = fwrite(target->bufstart, 1, nc, target->stream);
311 target->nchars += written;
312 if (written != nc)
313 target->failed = true;
314 }
315 target->bufptr = target->bufstart;
316}
317
318
319static bool find_arguments(const char *format, va_list args,
320 PrintfArgValue *argvalues);
321static void fmtstr(const char *value, int leftjust, int minlen, int maxwidth,
322 int pointflag, PrintfTarget *target);
323static void fmtptr(void *value, PrintfTarget *target);
324static void fmtint(long long value, char type, int forcesign,
325 int leftjust, int minlen, int zpad, int precision, int pointflag,
326 PrintfTarget *target);
327static void fmtchar(int value, int leftjust, int minlen, PrintfTarget *target);
328static void fmtfloat(double value, char type, int forcesign,
329 int leftjust, int minlen, int zpad, int precision, int pointflag,
330 PrintfTarget *target);
331static void dostr(const char *str, int slen, PrintfTarget *target);
332static void dopr_outch(int c, PrintfTarget *target);
333static void dopr_outchmulti(int c, int slen, PrintfTarget *target);
334static int adjust_sign(int is_negative, int forcesign, int *signvalue);
335static int compute_padlen(int minlen, int vallen, int leftjust);
336static void leading_pad(int zpad, int signvalue, int *padlen,
337 PrintfTarget *target);
338static void trailing_pad(int padlen, PrintfTarget *target);
339
340/*
341 * If strchrnul exists (it's a glibc-ism), it's a good bit faster than the
342 * equivalent manual loop. If it doesn't exist, provide a replacement.
343 *
344 * Note: glibc declares this as returning "char *", but that would require
345 * casting away const internally, so we don't follow that detail.
346 */
347#ifndef HAVE_STRCHRNUL
348
349static inline const char *
350strchrnul(const char *s, int c)
351{
352 while (*s != '\0' && *s != c)
353 s++;
354 return s;
355}
356
357#else
358
359/*
360 * glibc's <string.h> declares strchrnul only if _GNU_SOURCE is defined.
361 * While we typically use that on glibc platforms, configure will set
362 * HAVE_STRCHRNUL whether it's used or not. Fill in the missing declaration
363 * so that this file will compile cleanly with or without _GNU_SOURCE.
364 */
365#ifndef _GNU_SOURCE
366extern char *strchrnul(const char *s, int c);
367#endif
368
369#endif /* HAVE_STRCHRNUL */
370
371
372/*
373 * dopr(): the guts of *printf for all cases.
374 */
375static void
376dopr(PrintfTarget *target, const char *format, va_list args)
377{
378 int save_errno = errno;
379 const char *first_pct = NULL;
380 int ch;
381 bool have_dollar;
382 bool have_star;
383 bool afterstar;
384 int accum;
385 int longlongflag;
386 int longflag;
387 int pointflag;
388 int leftjust;
389 int fieldwidth;
390 int precision;
391 int zpad;
392 int forcesign;
393 int fmtpos;
394 int cvalue;
395 long long numvalue;
396 double fvalue;
397 char *strvalue;
398 PrintfArgValue argvalues[PG_NL_ARGMAX + 1];
399
400 /*
401 * Initially, we suppose the format string does not use %n$. The first
402 * time we come to a conversion spec that has that, we'll call
403 * find_arguments() to check for consistent use of %n$ and fill the
404 * argvalues array with the argument values in the correct order.
405 */
406 have_dollar = false;
407
408 while (*format != '\0')
409 {
410 /* Locate next conversion specifier */
411 if (*format != '%')
412 {
413 /* Scan to next '%' or end of string */
414 const char *next_pct = strchrnul(format + 1, '%');
415
416 /* Dump literal data we just scanned over */
417 dostr(format, next_pct - format, target);
418 if (target->failed)
419 break;
420
421 if (*next_pct == '\0')
422 break;
423 format = next_pct;
424 }
425
426 /*
427 * Remember start of first conversion spec; if we find %n$, then it's
428 * sufficient for find_arguments() to start here, without rescanning
429 * earlier literal text.
430 */
431 if (first_pct == NULL)
432 first_pct = format;
433
434 /* Process conversion spec starting at *format */
435 format++;
436
437 /* Fast path for conversion spec that is exactly %s */
438 if (*format == 's')
439 {
440 format++;
441 strvalue = va_arg(args, char *);
442 Assert(strvalue != NULL);
443 dostr(strvalue, strlen(strvalue), target);
444 if (target->failed)
445 break;
446 continue;
447 }
448
449 fieldwidth = precision = zpad = leftjust = forcesign = 0;
450 longflag = longlongflag = pointflag = 0;
451 fmtpos = accum = 0;
452 have_star = afterstar = false;
453nextch2:
454 ch = *format++;
455 switch (ch)
456 {
457 case '-':
458 leftjust = 1;
459 goto nextch2;
460 case '+':
461 forcesign = 1;
462 goto nextch2;
463 case '0':
464 /* set zero padding if no nonzero digits yet */
465 if (accum == 0 && !pointflag)
466 zpad = '0';
467 /* FALL THRU */
468 case '1':
469 case '2':
470 case '3':
471 case '4':
472 case '5':
473 case '6':
474 case '7':
475 case '8':
476 case '9':
477 accum = accum * 10 + (ch - '0');
478 goto nextch2;
479 case '.':
480 if (have_star)
481 have_star = false;
482 else
483 fieldwidth = accum;
484 pointflag = 1;
485 accum = 0;
486 goto nextch2;
487 case '*':
488 if (have_dollar)
489 {
490 /*
491 * We'll process value after reading n$. Note it's OK to
492 * assume have_dollar is set correctly, because in a valid
493 * format string the initial % must have had n$ if * does.
494 */
495 afterstar = true;
496 }
497 else
498 {
499 /* fetch and process value now */
500 int starval = va_arg(args, int);
501
502 if (pointflag)
503 {
504 precision = starval;
505 if (precision < 0)
506 {
507 precision = 0;
508 pointflag = 0;
509 }
510 }
511 else
512 {
513 fieldwidth = starval;
514 if (fieldwidth < 0)
515 {
516 leftjust = 1;
517 fieldwidth = -fieldwidth;
518 }
519 }
520 }
521 have_star = true;
522 accum = 0;
523 goto nextch2;
524 case '$':
525 /* First dollar sign? */
526 if (!have_dollar)
527 {
528 /* Yup, so examine all conversion specs in format */
529 if (!find_arguments(first_pct, args, argvalues))
530 goto bad_format;
531 have_dollar = true;
532 }
533 if (afterstar)
534 {
535 /* fetch and process star value */
536 int starval = argvalues[accum].i;
537
538 if (pointflag)
539 {
540 precision = starval;
541 if (precision < 0)
542 {
543 precision = 0;
544 pointflag = 0;
545 }
546 }
547 else
548 {
549 fieldwidth = starval;
550 if (fieldwidth < 0)
551 {
552 leftjust = 1;
553 fieldwidth = -fieldwidth;
554 }
555 }
556 afterstar = false;
557 }
558 else
559 fmtpos = accum;
560 accum = 0;
561 goto nextch2;
562 case 'l':
563 if (longflag)
564 longlongflag = 1;
565 else
566 longflag = 1;
567 goto nextch2;
568 case 'z':
569#if SIZEOF_SIZE_T == 8
570#ifdef HAVE_LONG_INT_64
571 longflag = 1;
572#elif defined(HAVE_LONG_LONG_INT_64)
573 longlongflag = 1;
574#else
575#error "Don't know how to print 64bit integers"
576#endif
577#else
578 /* assume size_t is same size as int */
579#endif
580 goto nextch2;
581 case 'h':
582 case '\'':
583 /* ignore these */
584 goto nextch2;
585 case 'd':
586 case 'i':
587 if (!have_star)
588 {
589 if (pointflag)
590 precision = accum;
591 else
592 fieldwidth = accum;
593 }
594 if (have_dollar)
595 {
596 if (longlongflag)
597 numvalue = argvalues[fmtpos].ll;
598 else if (longflag)
599 numvalue = argvalues[fmtpos].l;
600 else
601 numvalue = argvalues[fmtpos].i;
602 }
603 else
604 {
605 if (longlongflag)
606 numvalue = va_arg(args, long long);
607 else if (longflag)
608 numvalue = va_arg(args, long);
609 else
610 numvalue = va_arg(args, int);
611 }
612 fmtint(numvalue, ch, forcesign, leftjust, fieldwidth, zpad,
613 precision, pointflag, target);
614 break;
615 case 'o':
616 case 'u':
617 case 'x':
618 case 'X':
619 if (!have_star)
620 {
621 if (pointflag)
622 precision = accum;
623 else
624 fieldwidth = accum;
625 }
626 if (have_dollar)
627 {
628 if (longlongflag)
629 numvalue = (unsigned long long) argvalues[fmtpos].ll;
630 else if (longflag)
631 numvalue = (unsigned long) argvalues[fmtpos].l;
632 else
633 numvalue = (unsigned int) argvalues[fmtpos].i;
634 }
635 else
636 {
637 if (longlongflag)
638 numvalue = (unsigned long long) va_arg(args, long long);
639 else if (longflag)
640 numvalue = (unsigned long) va_arg(args, long);
641 else
642 numvalue = (unsigned int) va_arg(args, int);
643 }
644 fmtint(numvalue, ch, forcesign, leftjust, fieldwidth, zpad,
645 precision, pointflag, target);
646 break;
647 case 'c':
648 if (!have_star)
649 {
650 if (pointflag)
651 precision = accum;
652 else
653 fieldwidth = accum;
654 }
655 if (have_dollar)
656 cvalue = (unsigned char) argvalues[fmtpos].i;
657 else
658 cvalue = (unsigned char) va_arg(args, int);
659 fmtchar(cvalue, leftjust, fieldwidth, target);
660 break;
661 case 's':
662 if (!have_star)
663 {
664 if (pointflag)
665 precision = accum;
666 else
667 fieldwidth = accum;
668 }
669 if (have_dollar)
670 strvalue = argvalues[fmtpos].cptr;
671 else
672 strvalue = va_arg(args, char *);
673 /* Whine if someone tries to print a NULL string */
674 Assert(strvalue != NULL);
675 fmtstr(strvalue, leftjust, fieldwidth, precision, pointflag,
676 target);
677 break;
678 case 'p':
679 /* fieldwidth/leftjust are ignored ... */
680 if (have_dollar)
681 strvalue = argvalues[fmtpos].cptr;
682 else
683 strvalue = va_arg(args, char *);
684 fmtptr((void *) strvalue, target);
685 break;
686 case 'e':
687 case 'E':
688 case 'f':
689 case 'g':
690 case 'G':
691 if (!have_star)
692 {
693 if (pointflag)
694 precision = accum;
695 else
696 fieldwidth = accum;
697 }
698 if (have_dollar)
699 fvalue = argvalues[fmtpos].d;
700 else
701 fvalue = va_arg(args, double);
702 fmtfloat(fvalue, ch, forcesign, leftjust,
703 fieldwidth, zpad,
704 precision, pointflag,
705 target);
706 break;
707 case 'm':
708 {
709 char errbuf[PG_STRERROR_R_BUFLEN];
710 const char *errm = strerror_r(save_errno,
711 errbuf, sizeof(errbuf));
712
713 dostr(errm, strlen(errm), target);
714 }
715 break;
716 case '%':
717 dopr_outch('%', target);
718 break;
719 default:
720
721 /*
722 * Anything else --- in particular, '\0' indicating end of
723 * format string --- is bogus.
724 */
725 goto bad_format;
726 }
727
728 /* Check for failure after each conversion spec */
729 if (target->failed)
730 break;
731 }
732
733 return;
734
735bad_format:
736 errno = EINVAL;
737 target->failed = true;
738}
739
740/*
741 * find_arguments(): sort out the arguments for a format spec with %n$
742 *
743 * If format is valid, return true and fill argvalues[i] with the value
744 * for the conversion spec that has %i$ or *i$. Else return false.
745 */
746static bool
747find_arguments(const char *format, va_list args,
748 PrintfArgValue *argvalues)
749{
750 int ch;
751 bool afterstar;
752 int accum;
753 int longlongflag;
754 int longflag;
755 int fmtpos;
756 int i;
757 int last_dollar;
758 PrintfArgType argtypes[PG_NL_ARGMAX + 1];
759
760 /* Initialize to "no dollar arguments known" */
761 last_dollar = 0;
762 MemSet(argtypes, 0, sizeof(argtypes));
763
764 /*
765 * This loop must accept the same format strings as the one in dopr().
766 * However, we don't need to analyze them to the same level of detail.
767 *
768 * Since we're only called if there's a dollar-type spec somewhere, we can
769 * fail immediately if we find a non-dollar spec. Per the C99 standard,
770 * all argument references in the format string must be one or the other.
771 */
772 while (*format != '\0')
773 {
774 /* Locate next conversion specifier */
775 if (*format != '%')
776 {
777 /* Unlike dopr, we can just quit if there's no more specifiers */
778 format = strchr(format + 1, '%');
779 if (format == NULL)
780 break;
781 }
782
783 /* Process conversion spec starting at *format */
784 format++;
785 longflag = longlongflag = 0;
786 fmtpos = accum = 0;
787 afterstar = false;
788nextch1:
789 ch = *format++;
790 switch (ch)
791 {
792 case '-':
793 case '+':
794 goto nextch1;
795 case '0':
796 case '1':
797 case '2':
798 case '3':
799 case '4':
800 case '5':
801 case '6':
802 case '7':
803 case '8':
804 case '9':
805 accum = accum * 10 + (ch - '0');
806 goto nextch1;
807 case '.':
808 accum = 0;
809 goto nextch1;
810 case '*':
811 if (afterstar)
812 return false; /* previous star missing dollar */
813 afterstar = true;
814 accum = 0;
815 goto nextch1;
816 case '$':
817 if (accum <= 0 || accum > PG_NL_ARGMAX)
818 return false;
819 if (afterstar)
820 {
821 if (argtypes[accum] &&
822 argtypes[accum] != ATYPE_INT)
823 return false;
824 argtypes[accum] = ATYPE_INT;
825 last_dollar = Max(last_dollar, accum);
826 afterstar = false;
827 }
828 else
829 fmtpos = accum;
830 accum = 0;
831 goto nextch1;
832 case 'l':
833 if (longflag)
834 longlongflag = 1;
835 else
836 longflag = 1;
837 goto nextch1;
838 case 'z':
839#if SIZEOF_SIZE_T == 8
840#ifdef HAVE_LONG_INT_64
841 longflag = 1;
842#elif defined(HAVE_LONG_LONG_INT_64)
843 longlongflag = 1;
844#else
845#error "Don't know how to print 64bit integers"
846#endif
847#else
848 /* assume size_t is same size as int */
849#endif
850 goto nextch1;
851 case 'h':
852 case '\'':
853 /* ignore these */
854 goto nextch1;
855 case 'd':
856 case 'i':
857 case 'o':
858 case 'u':
859 case 'x':
860 case 'X':
861 if (fmtpos)
862 {
863 PrintfArgType atype;
864
865 if (longlongflag)
866 atype = ATYPE_LONGLONG;
867 else if (longflag)
868 atype = ATYPE_LONG;
869 else
870 atype = ATYPE_INT;
871 if (argtypes[fmtpos] &&
872 argtypes[fmtpos] != atype)
873 return false;
874 argtypes[fmtpos] = atype;
875 last_dollar = Max(last_dollar, fmtpos);
876 }
877 else
878 return false; /* non-dollar conversion spec */
879 break;
880 case 'c':
881 if (fmtpos)
882 {
883 if (argtypes[fmtpos] &&
884 argtypes[fmtpos] != ATYPE_INT)
885 return false;
886 argtypes[fmtpos] = ATYPE_INT;
887 last_dollar = Max(last_dollar, fmtpos);
888 }
889 else
890 return false; /* non-dollar conversion spec */
891 break;
892 case 's':
893 case 'p':
894 if (fmtpos)
895 {
896 if (argtypes[fmtpos] &&
897 argtypes[fmtpos] != ATYPE_CHARPTR)
898 return false;
899 argtypes[fmtpos] = ATYPE_CHARPTR;
900 last_dollar = Max(last_dollar, fmtpos);
901 }
902 else
903 return false; /* non-dollar conversion spec */
904 break;
905 case 'e':
906 case 'E':
907 case 'f':
908 case 'g':
909 case 'G':
910 if (fmtpos)
911 {
912 if (argtypes[fmtpos] &&
913 argtypes[fmtpos] != ATYPE_DOUBLE)
914 return false;
915 argtypes[fmtpos] = ATYPE_DOUBLE;
916 last_dollar = Max(last_dollar, fmtpos);
917 }
918 else
919 return false; /* non-dollar conversion spec */
920 break;
921 case 'm':
922 case '%':
923 break;
924 default:
925 return false; /* bogus format string */
926 }
927
928 /*
929 * If we finish the spec with afterstar still set, there's a
930 * non-dollar star in there.
931 */
932 if (afterstar)
933 return false; /* non-dollar conversion spec */
934 }
935
936 /*
937 * Format appears valid so far, so collect the arguments in physical
938 * order. (Since we rejected any non-dollar specs that would have
939 * collected arguments, we know that dopr() hasn't collected any yet.)
940 */
941 for (i = 1; i <= last_dollar; i++)
942 {
943 switch (argtypes[i])
944 {
945 case ATYPE_NONE:
946 return false;
947 case ATYPE_INT:
948 argvalues[i].i = va_arg(args, int);
949 break;
950 case ATYPE_LONG:
951 argvalues[i].l = va_arg(args, long);
952 break;
953 case ATYPE_LONGLONG:
954 argvalues[i].ll = va_arg(args, long long);
955 break;
956 case ATYPE_DOUBLE:
957 argvalues[i].d = va_arg(args, double);
958 break;
959 case ATYPE_CHARPTR:
960 argvalues[i].cptr = va_arg(args, char *);
961 break;
962 }
963 }
964
965 return true;
966}
967
968static void
969fmtstr(const char *value, int leftjust, int minlen, int maxwidth,
970 int pointflag, PrintfTarget *target)
971{
972 int padlen,
973 vallen; /* amount to pad */
974
975 /*
976 * If a maxwidth (precision) is specified, we must not fetch more bytes
977 * than that.
978 */
979 if (pointflag)
980 vallen = strnlen(value, maxwidth);
981 else
982 vallen = strlen(value);
983
984 padlen = compute_padlen(minlen, vallen, leftjust);
985
986 if (padlen > 0)
987 {
988 dopr_outchmulti(' ', padlen, target);
989 padlen = 0;
990 }
991
992 dostr(value, vallen, target);
993
994 trailing_pad(padlen, target);
995}
996
997static void
998fmtptr(void *value, PrintfTarget *target)
999{
1000 int vallen;
1001 char convert[64];
1002
1003 /* we rely on regular C library's sprintf to do the basic conversion */
1004 vallen = sprintf(convert, "%p", value);
1005 if (vallen < 0)
1006 target->failed = true;
1007 else
1008 dostr(convert, vallen, target);
1009}
1010
1011static void
1012fmtint(long long value, char type, int forcesign, int leftjust,
1013 int minlen, int zpad, int precision, int pointflag,
1014 PrintfTarget *target)
1015{
1016 unsigned long long base;
1017 unsigned long long uvalue;
1018 int dosign;
1019 const char *cvt = "0123456789abcdef";
1020 int signvalue = 0;
1021 char convert[64];
1022 int vallen = 0;
1023 int padlen; /* amount to pad */
1024 int zeropad; /* extra leading zeroes */
1025
1026 switch (type)
1027 {
1028 case 'd':
1029 case 'i':
1030 base = 10;
1031 dosign = 1;
1032 break;
1033 case 'o':
1034 base = 8;
1035 dosign = 0;
1036 break;
1037 case 'u':
1038 base = 10;
1039 dosign = 0;
1040 break;
1041 case 'x':
1042 base = 16;
1043 dosign = 0;
1044 break;
1045 case 'X':
1046 cvt = "0123456789ABCDEF";
1047 base = 16;
1048 dosign = 0;
1049 break;
1050 default:
1051 return; /* keep compiler quiet */
1052 }
1053
1054 /* disable MSVC warning about applying unary minus to an unsigned value */
1055#if _MSC_VER
1056#pragma warning(push)
1057#pragma warning(disable: 4146)
1058#endif
1059 /* Handle +/- */
1060 if (dosign && adjust_sign((value < 0), forcesign, &signvalue))
1061 uvalue = -(unsigned long long) value;
1062 else
1063 uvalue = (unsigned long long) value;
1064#if _MSC_VER
1065#pragma warning(pop)
1066#endif
1067
1068 /*
1069 * SUS: the result of converting 0 with an explicit precision of 0 is no
1070 * characters
1071 */
1072 if (value == 0 && pointflag && precision == 0)
1073 vallen = 0;
1074 else
1075 {
1076 /* make integer string */
1077 do
1078 {
1079 convert[sizeof(convert) - (++vallen)] = cvt[uvalue % base];
1080 uvalue = uvalue / base;
1081 } while (uvalue);
1082 }
1083
1084 zeropad = Max(0, precision - vallen);
1085
1086 padlen = compute_padlen(minlen, vallen + zeropad, leftjust);
1087
1088 leading_pad(zpad, signvalue, &padlen, target);
1089
1090 if (zeropad > 0)
1091 dopr_outchmulti('0', zeropad, target);
1092
1093 dostr(convert + sizeof(convert) - vallen, vallen, target);
1094
1095 trailing_pad(padlen, target);
1096}
1097
1098static void
1099fmtchar(int value, int leftjust, int minlen, PrintfTarget *target)
1100{
1101 int padlen; /* amount to pad */
1102
1103 padlen = compute_padlen(minlen, 1, leftjust);
1104
1105 if (padlen > 0)
1106 {
1107 dopr_outchmulti(' ', padlen, target);
1108 padlen = 0;
1109 }
1110
1111 dopr_outch(value, target);
1112
1113 trailing_pad(padlen, target);
1114}
1115
1116static void
1117fmtfloat(double value, char type, int forcesign, int leftjust,
1118 int minlen, int zpad, int precision, int pointflag,
1119 PrintfTarget *target)
1120{
1121 int signvalue = 0;
1122 int prec;
1123 int vallen;
1124 char fmt[8];
1125 char convert[1024];
1126 int zeropadlen = 0; /* amount to pad with zeroes */
1127 int padlen; /* amount to pad with spaces */
1128
1129 /*
1130 * We rely on the regular C library's sprintf to do the basic conversion,
1131 * then handle padding considerations here.
1132 *
1133 * The dynamic range of "double" is about 1E+-308 for IEEE math, and not
1134 * too wildly more than that with other hardware. In "f" format, sprintf
1135 * could therefore generate at most 308 characters to the left of the
1136 * decimal point; while we need to allow the precision to get as high as
1137 * 308+17 to ensure that we don't truncate significant digits from very
1138 * small values. To handle both these extremes, we use a buffer of 1024
1139 * bytes and limit requested precision to 350 digits; this should prevent
1140 * buffer overrun even with non-IEEE math. If the original precision
1141 * request was more than 350, separately pad with zeroes.
1142 *
1143 * We handle infinities and NaNs specially to ensure platform-independent
1144 * output.
1145 */
1146 if (precision < 0) /* cover possible overflow of "accum" */
1147 precision = 0;
1148 prec = Min(precision, 350);
1149
1150 if (isnan(value))
1151 {
1152 strcpy(convert, "NaN");
1153 vallen = 3;
1154 /* no zero padding, regardless of precision spec */
1155 }
1156 else
1157 {
1158 /*
1159 * Handle sign (NaNs have no sign, so we don't do this in the case
1160 * above). "value < 0.0" will not be true for IEEE minus zero, so we
1161 * detect that by looking for the case where value equals 0.0
1162 * according to == but not according to memcmp.
1163 */
1164 static const double dzero = 0.0;
1165
1166 if (adjust_sign((value < 0.0 ||
1167 (value == 0.0 &&
1168 memcmp(&value, &dzero, sizeof(double)) != 0)),
1169 forcesign, &signvalue))
1170 value = -value;
1171
1172 if (isinf(value))
1173 {
1174 strcpy(convert, "Infinity");
1175 vallen = 8;
1176 /* no zero padding, regardless of precision spec */
1177 }
1178 else if (pointflag)
1179 {
1180 zeropadlen = precision - prec;
1181 fmt[0] = '%';
1182 fmt[1] = '.';
1183 fmt[2] = '*';
1184 fmt[3] = type;
1185 fmt[4] = '\0';
1186 vallen = sprintf(convert, fmt, prec, value);
1187 }
1188 else
1189 {
1190 fmt[0] = '%';
1191 fmt[1] = type;
1192 fmt[2] = '\0';
1193 vallen = sprintf(convert, fmt, value);
1194 }
1195 if (vallen < 0)
1196 goto fail;
1197
1198 /*
1199 * Windows, alone among our supported platforms, likes to emit
1200 * three-digit exponent fields even when two digits would do. Hack
1201 * such results to look like the way everyone else does it.
1202 */
1203#ifdef WIN32
1204 if (vallen >= 6 &&
1205 convert[vallen - 5] == 'e' &&
1206 convert[vallen - 3] == '0')
1207 {
1208 convert[vallen - 3] = convert[vallen - 2];
1209 convert[vallen - 2] = convert[vallen - 1];
1210 vallen--;
1211 }
1212#endif
1213 }
1214
1215 padlen = compute_padlen(minlen, vallen + zeropadlen, leftjust);
1216
1217 leading_pad(zpad, signvalue, &padlen, target);
1218
1219 if (zeropadlen > 0)
1220 {
1221 /* If 'e' or 'E' format, inject zeroes before the exponent */
1222 char *epos = strrchr(convert, 'e');
1223
1224 if (!epos)
1225 epos = strrchr(convert, 'E');
1226 if (epos)
1227 {
1228 /* pad before exponent */
1229 dostr(convert, epos - convert, target);
1230 if (zeropadlen > 0)
1231 dopr_outchmulti('0', zeropadlen, target);
1232 dostr(epos, vallen - (epos - convert), target);
1233 }
1234 else
1235 {
1236 /* no exponent, pad after the digits */
1237 dostr(convert, vallen, target);
1238 if (zeropadlen > 0)
1239 dopr_outchmulti('0', zeropadlen, target);
1240 }
1241 }
1242 else
1243 {
1244 /* no zero padding, just emit the number as-is */
1245 dostr(convert, vallen, target);
1246 }
1247
1248 trailing_pad(padlen, target);
1249 return;
1250
1251fail:
1252 target->failed = true;
1253}
1254
1255/*
1256 * Nonstandard entry point to print a double value efficiently.
1257 *
1258 * This is approximately equivalent to strfromd(), but has an API more
1259 * adapted to what float8out() wants. The behavior is like snprintf()
1260 * with a format of "%.ng", where n is the specified precision.
1261 * However, the target buffer must be nonempty (i.e. count > 0), and
1262 * the precision is silently bounded to a sane range.
1263 */
1264int
1265pg_strfromd(char *str, size_t count, int precision, double value)
1266{
1267 PrintfTarget target;
1268 int signvalue = 0;
1269 int vallen;
1270 char fmt[8];
1271 char convert[64];
1272
1273 /* Set up the target like pg_snprintf, but require nonempty buffer */
1274 Assert(count > 0);
1275 target.bufstart = target.bufptr = str;
1276 target.bufend = str + count - 1;
1277 target.stream = NULL;
1278 target.nchars = 0;
1279 target.failed = false;
1280
1281 /*
1282 * We bound precision to a reasonable range; the combination of this and
1283 * the knowledge that we're using "g" format without padding allows the
1284 * convert[] buffer to be reasonably small.
1285 */
1286 if (precision < 1)
1287 precision = 1;
1288 else if (precision > 32)
1289 precision = 32;
1290
1291 /*
1292 * The rest is just an inlined version of the fmtfloat() logic above,
1293 * simplified using the knowledge that no padding is wanted.
1294 */
1295 if (isnan(value))
1296 {
1297 strcpy(convert, "NaN");
1298 vallen = 3;
1299 }
1300 else
1301 {
1302 static const double dzero = 0.0;
1303
1304 if (value < 0.0 ||
1305 (value == 0.0 &&
1306 memcmp(&value, &dzero, sizeof(double)) != 0))
1307 {
1308 signvalue = '-';
1309 value = -value;
1310 }
1311
1312 if (isinf(value))
1313 {
1314 strcpy(convert, "Infinity");
1315 vallen = 8;
1316 }
1317 else
1318 {
1319 fmt[0] = '%';
1320 fmt[1] = '.';
1321 fmt[2] = '*';
1322 fmt[3] = 'g';
1323 fmt[4] = '\0';
1324 vallen = sprintf(convert, fmt, precision, value);
1325 if (vallen < 0)
1326 {
1327 target.failed = true;
1328 goto fail;
1329 }
1330
1331#ifdef WIN32
1332 if (vallen >= 6 &&
1333 convert[vallen - 5] == 'e' &&
1334 convert[vallen - 3] == '0')
1335 {
1336 convert[vallen - 3] = convert[vallen - 2];
1337 convert[vallen - 2] = convert[vallen - 1];
1338 vallen--;
1339 }
1340#endif
1341 }
1342 }
1343
1344 if (signvalue)
1345 dopr_outch(signvalue, &target);
1346
1347 dostr(convert, vallen, &target);
1348
1349fail:
1350 *(target.bufptr) = '\0';
1351 return target.failed ? -1 : (target.bufptr - target.bufstart
1352 + target.nchars);
1353}
1354
1355
1356static void
1357dostr(const char *str, int slen, PrintfTarget *target)
1358{
1359 /* fast path for common case of slen == 1 */
1360 if (slen == 1)
1361 {
1362 dopr_outch(*str, target);
1363 return;
1364 }
1365
1366 while (slen > 0)
1367 {
1368 int avail;
1369
1370 if (target->bufend != NULL)
1371 avail = target->bufend - target->bufptr;
1372 else
1373 avail = slen;
1374 if (avail <= 0)
1375 {
1376 /* buffer full, can we dump to stream? */
1377 if (target->stream == NULL)
1378 {
1379 target->nchars += slen; /* no, lose the data */
1380 return;
1381 }
1382 flushbuffer(target);
1383 continue;
1384 }
1385 avail = Min(avail, slen);
1386 memmove(target->bufptr, str, avail);
1387 target->bufptr += avail;
1388 str += avail;
1389 slen -= avail;
1390 }
1391}
1392
1393static void
1394dopr_outch(int c, PrintfTarget *target)
1395{
1396 if (target->bufend != NULL && target->bufptr >= target->bufend)
1397 {
1398 /* buffer full, can we dump to stream? */
1399 if (target->stream == NULL)
1400 {
1401 target->nchars++; /* no, lose the data */
1402 return;
1403 }
1404 flushbuffer(target);
1405 }
1406 *(target->bufptr++) = c;
1407}
1408
1409static void
1410dopr_outchmulti(int c, int slen, PrintfTarget *target)
1411{
1412 /* fast path for common case of slen == 1 */
1413 if (slen == 1)
1414 {
1415 dopr_outch(c, target);
1416 return;
1417 }
1418
1419 while (slen > 0)
1420 {
1421 int avail;
1422
1423 if (target->bufend != NULL)
1424 avail = target->bufend - target->bufptr;
1425 else
1426 avail = slen;
1427 if (avail <= 0)
1428 {
1429 /* buffer full, can we dump to stream? */
1430 if (target->stream == NULL)
1431 {
1432 target->nchars += slen; /* no, lose the data */
1433 return;
1434 }
1435 flushbuffer(target);
1436 continue;
1437 }
1438 avail = Min(avail, slen);
1439 memset(target->bufptr, c, avail);
1440 target->bufptr += avail;
1441 slen -= avail;
1442 }
1443}
1444
1445
1446static int
1447adjust_sign(int is_negative, int forcesign, int *signvalue)
1448{
1449 if (is_negative)
1450 {
1451 *signvalue = '-';
1452 return true;
1453 }
1454 else if (forcesign)
1455 *signvalue = '+';
1456 return false;
1457}
1458
1459
1460static int
1461compute_padlen(int minlen, int vallen, int leftjust)
1462{
1463 int padlen;
1464
1465 padlen = minlen - vallen;
1466 if (padlen < 0)
1467 padlen = 0;
1468 if (leftjust)
1469 padlen = -padlen;
1470 return padlen;
1471}
1472
1473
1474static void
1475leading_pad(int zpad, int signvalue, int *padlen, PrintfTarget *target)
1476{
1477 int maxpad;
1478
1479 if (*padlen > 0 && zpad)
1480 {
1481 if (signvalue)
1482 {
1483 dopr_outch(signvalue, target);
1484 --(*padlen);
1485 signvalue = 0;
1486 }
1487 if (*padlen > 0)
1488 {
1489 dopr_outchmulti(zpad, *padlen, target);
1490 *padlen = 0;
1491 }
1492 }
1493 maxpad = (signvalue != 0);
1494 if (*padlen > maxpad)
1495 {
1496 dopr_outchmulti(' ', *padlen - maxpad, target);
1497 *padlen = maxpad;
1498 }
1499 if (signvalue)
1500 {
1501 dopr_outch(signvalue, target);
1502 if (*padlen > 0)
1503 --(*padlen);
1504 else if (*padlen < 0)
1505 ++(*padlen);
1506 }
1507}
1508
1509
1510static void
1511trailing_pad(int padlen, PrintfTarget *target)
1512{
1513 if (padlen < 0)
1514 dopr_outchmulti(' ', -padlen, target);
1515}
1516