?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Ignore not-yet-defined Portals in pg_cursors view.
[pgsql.git] / src / port / snprintf.c
blob884f0262dd15ccf6f4ae18c4779e24a7867cfa3d
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-2024, 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 */
125 typedef 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 */
142 typedef enum
143 {
144 ATYPE_NONE = 0,
145 ATYPE_INT,
146 ATYPE_LONG,
147 ATYPE_LONGLONG,
148 ATYPE_DOUBLE,
149 ATYPE_CHARPTR
150 } PrintfArgType;
151
152 typedef union
153 {
154 int i;
155 long l;
156 long long ll;
157 double d;
158 char *cptr;
159 } PrintfArgValue;
160
161
162 static void flushbuffer(PrintfTarget *target);
163 static 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
173 int
174 pg_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
201 int
202 pg_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
213 int
214 pg_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
229 int
230 pg_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
241 int
242 pg_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
263 int
264 pg_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
275 int
276 pg_vprintf(const char *fmt, va_list args)
277 {
278 return pg_vfprintf(stdout, fmt, args);
279 }
280
281 int
282 pg_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 */
297 static void
298 flushbuffer(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
319 static bool find_arguments(const char *format, va_list args,
320 PrintfArgValue *argvalues);
321 static void fmtstr(const char *value, int leftjust, int minlen, int maxwidth,
322 int pointflag, PrintfTarget *target);
323 static void fmtptr(const void *value, PrintfTarget *target);
324 static void fmtint(long long value, char type, int forcesign,
325 int leftjust, int minlen, int zpad, int precision, int pointflag,
326 PrintfTarget *target);
327 static void fmtchar(int value, int leftjust, int minlen, PrintfTarget *target);
328 static void fmtfloat(double value, char type, int forcesign,
329 int leftjust, int minlen, int zpad, int precision, int pointflag,
330 PrintfTarget *target);
331 static void dostr(const char *str, int slen, PrintfTarget *target);
332 static void dopr_outch(int c, PrintfTarget *target);
333 static void dopr_outchmulti(int c, int slen, PrintfTarget *target);
334 static int adjust_sign(int is_negative, int forcesign, int *signvalue);
335 static int compute_padlen(int minlen, int vallen, int leftjust);
336 static void leading_pad(int zpad, int signvalue, int *padlen,
337 PrintfTarget *target);
338 static 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
349 static inline const char *
350 strchrnul(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
366 extern 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 */
375 static void
376 dopr(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 const 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 if (strvalue == NULL)
443 strvalue = "(null)";
444 dostr(strvalue, strlen(strvalue), target);
445 if (target->failed)
446 break;
447 continue;
448 }
449
450 fieldwidth = precision = zpad = leftjust = forcesign = 0;
451 longflag = longlongflag = pointflag = 0;
452 fmtpos = accum = 0;
453 have_star = afterstar = false;
454 nextch2:
455 ch = *format++;
456 switch (ch)
457 {
458 case '-':
459 leftjust = 1;
460 goto nextch2;
461 case '+':
462 forcesign = 1;
463 goto nextch2;
464 case '0':
465 /* set zero padding if no nonzero digits yet */
466 if (accum == 0 && !pointflag)
467 zpad = '0';
468 /* FALL THRU */
469 case '1':
470 case '2':
471 case '3':
472 case '4':
473 case '5':
474 case '6':
475 case '7':
476 case '8':
477 case '9':
478 accum = accum * 10 + (ch - '0');
479 goto nextch2;
480 case '.':
481 if (have_star)
482 have_star = false;
483 else
484 fieldwidth = accum;
485 pointflag = 1;
486 accum = 0;
487 goto nextch2;
488 case '*':
489 if (have_dollar)
490 {
491 /*
492 * We'll process value after reading n$. Note it's OK to
493 * assume have_dollar is set correctly, because in a valid
494 * format string the initial % must have had n$ if * does.
495 */
496 afterstar = true;
497 }
498 else
499 {
500 /* fetch and process value now */
501 int starval = va_arg(args, int);
502
503 if (pointflag)
504 {
505 precision = starval;
506 if (precision < 0)
507 {
508 precision = 0;
509 pointflag = 0;
510 }
511 }
512 else
513 {
514 fieldwidth = starval;
515 if (fieldwidth < 0)
516 {
517 leftjust = 1;
518 fieldwidth = -fieldwidth;
519 }
520 }
521 }
522 have_star = true;
523 accum = 0;
524 goto nextch2;
525 case '$':
526 /* First dollar sign? */
527 if (!have_dollar)
528 {
529 /* Yup, so examine all conversion specs in format */
530 if (!find_arguments(first_pct, args, argvalues))
531 goto bad_format;
532 have_dollar = true;
533 }
534 if (afterstar)
535 {
536 /* fetch and process star value */
537 int starval = argvalues[accum].i;
538
539 if (pointflag)
540 {
541 precision = starval;
542 if (precision < 0)
543 {
544 precision = 0;
545 pointflag = 0;
546 }
547 }
548 else
549 {
550 fieldwidth = starval;
551 if (fieldwidth < 0)
552 {
553 leftjust = 1;
554 fieldwidth = -fieldwidth;
555 }
556 }
557 afterstar = false;
558 }
559 else
560 fmtpos = accum;
561 accum = 0;
562 goto nextch2;
563 case 'l':
564 if (longflag)
565 longlongflag = 1;
566 else
567 longflag = 1;
568 goto nextch2;
569 case 'z':
570 #if SIZEOF_SIZE_T == 8
571 #ifdef HAVE_LONG_INT_64
572 longflag = 1;
573 #elif defined(HAVE_LONG_LONG_INT_64)
574 longlongflag = 1;
575 #else
576 #error "Don't know how to print 64bit integers"
577 #endif
578 #else
579 /* assume size_t is same size as int */
580 #endif
581 goto nextch2;
582 case 'h':
583 case '\'':
584 /* ignore these */
585 goto nextch2;
586 case 'd':
587 case 'i':
588 if (!have_star)
589 {
590 if (pointflag)
591 precision = accum;
592 else
593 fieldwidth = accum;
594 }
595 if (have_dollar)
596 {
597 if (longlongflag)
598 numvalue = argvalues[fmtpos].ll;
599 else if (longflag)
600 numvalue = argvalues[fmtpos].l;
601 else
602 numvalue = argvalues[fmtpos].i;
603 }
604 else
605 {
606 if (longlongflag)
607 numvalue = va_arg(args, long long);
608 else if (longflag)
609 numvalue = va_arg(args, long);
610 else
611 numvalue = va_arg(args, int);
612 }
613 fmtint(numvalue, ch, forcesign, leftjust, fieldwidth, zpad,
614 precision, pointflag, target);
615 break;
616 case 'o':
617 case 'u':
618 case 'x':
619 case 'X':
620 if (!have_star)
621 {
622 if (pointflag)
623 precision = accum;
624 else
625 fieldwidth = accum;
626 }
627 if (have_dollar)
628 {
629 if (longlongflag)
630 numvalue = (unsigned long long) argvalues[fmtpos].ll;
631 else if (longflag)
632 numvalue = (unsigned long) argvalues[fmtpos].l;
633 else
634 numvalue = (unsigned int) argvalues[fmtpos].i;
635 }
636 else
637 {
638 if (longlongflag)
639 numvalue = (unsigned long long) va_arg(args, long long);
640 else if (longflag)
641 numvalue = (unsigned long) va_arg(args, long);
642 else
643 numvalue = (unsigned int) va_arg(args, int);
644 }
645 fmtint(numvalue, ch, forcesign, leftjust, fieldwidth, zpad,
646 precision, pointflag, target);
647 break;
648 case 'c':
649 if (!have_star)
650 {
651 if (pointflag)
652 precision = accum;
653 else
654 fieldwidth = accum;
655 }
656 if (have_dollar)
657 cvalue = (unsigned char) argvalues[fmtpos].i;
658 else
659 cvalue = (unsigned char) va_arg(args, int);
660 fmtchar(cvalue, leftjust, fieldwidth, target);
661 break;
662 case 's':
663 if (!have_star)
664 {
665 if (pointflag)
666 precision = accum;
667 else
668 fieldwidth = accum;
669 }
670 if (have_dollar)
671 strvalue = argvalues[fmtpos].cptr;
672 else
673 strvalue = va_arg(args, char *);
674 /* If string is NULL, silently substitute "(null)" */
675 if (strvalue == NULL)
676 strvalue = "(null)";
677 fmtstr(strvalue, leftjust, fieldwidth, precision, pointflag,
678 target);
679 break;
680 case 'p':
681 /* fieldwidth/leftjust are ignored ... */
682 if (have_dollar)
683 strvalue = argvalues[fmtpos].cptr;
684 else
685 strvalue = va_arg(args, char *);
686 fmtptr((const void *) strvalue, target);
687 break;
688 case 'e':
689 case 'E':
690 case 'f':
691 case 'g':
692 case 'G':
693 if (!have_star)
694 {
695 if (pointflag)
696 precision = accum;
697 else
698 fieldwidth = accum;
699 }
700 if (have_dollar)
701 fvalue = argvalues[fmtpos].d;
702 else
703 fvalue = va_arg(args, double);
704 fmtfloat(fvalue, ch, forcesign, leftjust,
705 fieldwidth, zpad,
706 precision, pointflag,
707 target);
708 break;
709 case 'm':
710 {
711 char errbuf[PG_STRERROR_R_BUFLEN];
712 const char *errm = strerror_r(save_errno,
713 errbuf, sizeof(errbuf));
714
715 dostr(errm, strlen(errm), target);
716 }
717 break;
718 case '%':
719 dopr_outch('%', target);
720 break;
721 default:
722
723 /*
724 * Anything else --- in particular, '\0' indicating end of
725 * format string --- is bogus.
726 */
727 goto bad_format;
728 }
729
730 /* Check for failure after each conversion spec */
731 if (target->failed)
732 break;
733 }
734
735 return;
736
737 bad_format:
738 errno = EINVAL;
739 target->failed = true;
740 }
741
742 /*
743 * find_arguments(): sort out the arguments for a format spec with %n$
744 *
745 * If format is valid, return true and fill argvalues[i] with the value
746 * for the conversion spec that has %i$ or *i$. Else return false.
747 */
748 static bool
749 find_arguments(const char *format, va_list args,
750 PrintfArgValue *argvalues)
751 {
752 int ch;
753 bool afterstar;
754 int accum;
755 int longlongflag;
756 int longflag;
757 int fmtpos;
758 int i;
759 int last_dollar = 0; /* Init to "no dollar arguments known" */
760 PrintfArgType argtypes[PG_NL_ARGMAX + 1] = {0};
761
762 /*
763 * This loop must accept the same format strings as the one in dopr().
764 * However, we don't need to analyze them to the same level of detail.
765 *
766 * Since we're only called if there's a dollar-type spec somewhere, we can
767 * fail immediately if we find a non-dollar spec. Per the C99 standard,
768 * all argument references in the format string must be one or the other.
769 */
770 while (*format != '\0')
771 {
772 /* Locate next conversion specifier */
773 if (*format != '%')
774 {
775 /* Unlike dopr, we can just quit if there's no more specifiers */
776 format = strchr(format + 1, '%');
777 if (format == NULL)
778 break;
779 }
780
781 /* Process conversion spec starting at *format */
782 format++;
783 longflag = longlongflag = 0;
784 fmtpos = accum = 0;
785 afterstar = false;
786 nextch1:
787 ch = *format++;
788 switch (ch)
789 {
790 case '-':
791 case '+':
792 goto nextch1;
793 case '0':
794 case '1':
795 case '2':
796 case '3':
797 case '4':
798 case '5':
799 case '6':
800 case '7':
801 case '8':
802 case '9':
803 accum = accum * 10 + (ch - '0');
804 goto nextch1;
805 case '.':
806 accum = 0;
807 goto nextch1;
808 case '*':
809 if (afterstar)
810 return false; /* previous star missing dollar */
811 afterstar = true;
812 accum = 0;
813 goto nextch1;
814 case '$':
815 if (accum <= 0 || accum > PG_NL_ARGMAX)
816 return false;
817 if (afterstar)
818 {
819 if (argtypes[accum] &&
820 argtypes[accum] != ATYPE_INT)
821 return false;
822 argtypes[accum] = ATYPE_INT;
823 last_dollar = Max(last_dollar, accum);
824 afterstar = false;
825 }
826 else
827 fmtpos = accum;
828 accum = 0;
829 goto nextch1;
830 case 'l':
831 if (longflag)
832 longlongflag = 1;
833 else
834 longflag = 1;
835 goto nextch1;
836 case 'z':
837 #if SIZEOF_SIZE_T == 8
838 #ifdef HAVE_LONG_INT_64
839 longflag = 1;
840 #elif defined(HAVE_LONG_LONG_INT_64)
841 longlongflag = 1;
842 #else
843 #error "Don't know how to print 64bit integers"
844 #endif
845 #else
846 /* assume size_t is same size as int */
847 #endif
848 goto nextch1;
849 case 'h':
850 case '\'':
851 /* ignore these */
852 goto nextch1;
853 case 'd':
854 case 'i':
855 case 'o':
856 case 'u':
857 case 'x':
858 case 'X':
859 if (fmtpos)
860 {
861 PrintfArgType atype;
862
863 if (longlongflag)
864 atype = ATYPE_LONGLONG;
865 else if (longflag)
866 atype = ATYPE_LONG;
867 else
868 atype = ATYPE_INT;
869 if (argtypes[fmtpos] &&
870 argtypes[fmtpos] != atype)
871 return false;
872 argtypes[fmtpos] = atype;
873 last_dollar = Max(last_dollar, fmtpos);
874 }
875 else
876 return false; /* non-dollar conversion spec */
877 break;
878 case 'c':
879 if (fmtpos)
880 {
881 if (argtypes[fmtpos] &&
882 argtypes[fmtpos] != ATYPE_INT)
883 return false;
884 argtypes[fmtpos] = ATYPE_INT;
885 last_dollar = Max(last_dollar, fmtpos);
886 }
887 else
888 return false; /* non-dollar conversion spec */
889 break;
890 case 's':
891 case 'p':
892 if (fmtpos)
893 {
894 if (argtypes[fmtpos] &&
895 argtypes[fmtpos] != ATYPE_CHARPTR)
896 return false;
897 argtypes[fmtpos] = ATYPE_CHARPTR;
898 last_dollar = Max(last_dollar, fmtpos);
899 }
900 else
901 return false; /* non-dollar conversion spec */
902 break;
903 case 'e':
904 case 'E':
905 case 'f':
906 case 'g':
907 case 'G':
908 if (fmtpos)
909 {
910 if (argtypes[fmtpos] &&
911 argtypes[fmtpos] != ATYPE_DOUBLE)
912 return false;
913 argtypes[fmtpos] = ATYPE_DOUBLE;
914 last_dollar = Max(last_dollar, fmtpos);
915 }
916 else
917 return false; /* non-dollar conversion spec */
918 break;
919 case 'm':
920 case '%':
921 break;
922 default:
923 return false; /* bogus format string */
924 }
925
926 /*
927 * If we finish the spec with afterstar still set, there's a
928 * non-dollar star in there.
929 */
930 if (afterstar)
931 return false; /* non-dollar conversion spec */
932 }
933
934 /*
935 * Format appears valid so far, so collect the arguments in physical
936 * order. (Since we rejected any non-dollar specs that would have
937 * collected arguments, we know that dopr() hasn't collected any yet.)
938 */
939 for (i = 1; i <= last_dollar; i++)
940 {
941 switch (argtypes[i])
942 {
943 case ATYPE_NONE:
944 return false;
945 case ATYPE_INT:
946 argvalues[i].i = va_arg(args, int);
947 break;
948 case ATYPE_LONG:
949 argvalues[i].l = va_arg(args, long);
950 break;
951 case ATYPE_LONGLONG:
952 argvalues[i].ll = va_arg(args, long long);
953 break;
954 case ATYPE_DOUBLE:
955 argvalues[i].d = va_arg(args, double);
956 break;
957 case ATYPE_CHARPTR:
958 argvalues[i].cptr = va_arg(args, char *);
959 break;
960 }
961 }
962
963 return true;
964 }
965
966 static void
967 fmtstr(const char *value, int leftjust, int minlen, int maxwidth,
968 int pointflag, PrintfTarget *target)
969 {
970 int padlen,
971 vallen; /* amount to pad */
972
973 /*
974 * If a maxwidth (precision) is specified, we must not fetch more bytes
975 * than that.
976 */
977 if (pointflag)
978 vallen = strnlen(value, maxwidth);
979 else
980 vallen = strlen(value);
981
982 padlen = compute_padlen(minlen, vallen, leftjust);
983
984 if (padlen > 0)
985 {
986 dopr_outchmulti(' ', padlen, target);
987 padlen = 0;
988 }
989
990 dostr(value, vallen, target);
991
992 trailing_pad(padlen, target);
993 }
994
995 static void
996 fmtptr(const void *value, PrintfTarget *target)
997 {
998 int vallen;
999 char convert[64];
1000
1001 /* we rely on regular C library's snprintf to do the basic conversion */
1002 vallen = snprintf(convert, sizeof(convert), "%p", value);
1003 if (vallen < 0)
1004 target->failed = true;
1005 else
1006 dostr(convert, vallen, target);
1007 }
1008
1009 static void
1010 fmtint(long long value, char type, int forcesign, int leftjust,
1011 int minlen, int zpad, int precision, int pointflag,
1012 PrintfTarget *target)
1013 {
1014 unsigned long long uvalue;
1015 int base;
1016 int dosign;
1017 const char *cvt = "0123456789abcdef";
1018 int signvalue = 0;
1019 char convert[64];
1020 int vallen = 0;
1021 int padlen; /* amount to pad */
1022 int zeropad; /* extra leading zeroes */
1023
1024 switch (type)
1025 {
1026 case 'd':
1027 case 'i':
1028 base = 10;
1029 dosign = 1;
1030 break;
1031 case 'o':
1032 base = 8;
1033 dosign = 0;
1034 break;
1035 case 'u':
1036 base = 10;
1037 dosign = 0;
1038 break;
1039 case 'x':
1040 base = 16;
1041 dosign = 0;
1042 break;
1043 case 'X':
1044 cvt = "0123456789ABCDEF";
1045 base = 16;
1046 dosign = 0;
1047 break;
1048 default:
1049 return; /* keep compiler quiet */
1050 }
1051
1052 /* disable MSVC warning about applying unary minus to an unsigned value */
1053 #ifdef _MSC_VER
1054 #pragma warning(push)
1055 #pragma warning(disable: 4146)
1056 #endif
1057 /* Handle +/- */
1058 if (dosign && adjust_sign((value < 0), forcesign, &signvalue))
1059 uvalue = -(unsigned long long) value;
1060 else
1061 uvalue = (unsigned long long) value;
1062 #ifdef _MSC_VER
1063 #pragma warning(pop)
1064 #endif
1065
1066 /*
1067 * SUS: the result of converting 0 with an explicit precision of 0 is no
1068 * characters
1069 */
1070 if (value == 0 && pointflag && precision == 0)
1071 vallen = 0;
1072 else
1073 {
1074 /*
1075 * Convert integer to string. We special-case each of the possible
1076 * base values so as to avoid general-purpose divisions. On most
1077 * machines, division by a fixed constant can be done much more
1078 * cheaply than a general divide.
1079 */
1080 if (base == 10)
1081 {
1082 do
1083 {
1084 convert[sizeof(convert) - (++vallen)] = cvt[uvalue % 10];
1085 uvalue = uvalue / 10;
1086 } while (uvalue);
1087 }
1088 else if (base == 16)
1089 {
1090 do
1091 {
1092 convert[sizeof(convert) - (++vallen)] = cvt[uvalue % 16];
1093 uvalue = uvalue / 16;
1094 } while (uvalue);
1095 }
1096 else /* base == 8 */
1097 {
1098 do
1099 {
1100 convert[sizeof(convert) - (++vallen)] = cvt[uvalue % 8];
1101 uvalue = uvalue / 8;
1102 } while (uvalue);
1103 }
1104 }
1105
1106 zeropad = Max(0, precision - vallen);
1107
1108 padlen = compute_padlen(minlen, vallen + zeropad, leftjust);
1109
1110 leading_pad(zpad, signvalue, &padlen, target);
1111
1112 if (zeropad > 0)
1113 dopr_outchmulti('0', zeropad, target);
1114
1115 dostr(convert + sizeof(convert) - vallen, vallen, target);
1116
1117 trailing_pad(padlen, target);
1118 }
1119
1120 static void
1121 fmtchar(int value, int leftjust, int minlen, PrintfTarget *target)
1122 {
1123 int padlen; /* amount to pad */
1124
1125 padlen = compute_padlen(minlen, 1, leftjust);
1126
1127 if (padlen > 0)
1128 {
1129 dopr_outchmulti(' ', padlen, target);
1130 padlen = 0;
1131 }
1132
1133 dopr_outch(value, target);
1134
1135 trailing_pad(padlen, target);
1136 }
1137
1138 static void
1139 fmtfloat(double value, char type, int forcesign, int leftjust,
1140 int minlen, int zpad, int precision, int pointflag,
1141 PrintfTarget *target)
1142 {
1143 int signvalue = 0;
1144 int prec;
1145 int vallen;
1146 char fmt[8];
1147 char convert[1024];
1148 int zeropadlen = 0; /* amount to pad with zeroes */
1149 int padlen; /* amount to pad with spaces */
1150
1151 /*
1152 * We rely on the regular C library's snprintf to do the basic conversion,
1153 * then handle padding considerations here.
1154 *
1155 * The dynamic range of "double" is about 1E+-308 for IEEE math, and not
1156 * too wildly more than that with other hardware. In "f" format, snprintf
1157 * could therefore generate at most 308 characters to the left of the
1158 * decimal point; while we need to allow the precision to get as high as
1159 * 308+17 to ensure that we don't truncate significant digits from very
1160 * small values. To handle both these extremes, we use a buffer of 1024
1161 * bytes and limit requested precision to 350 digits; this should prevent
1162 * buffer overrun even with non-IEEE math. If the original precision
1163 * request was more than 350, separately pad with zeroes.
1164 *
1165 * We handle infinities and NaNs specially to ensure platform-independent
1166 * output.
1167 */
1168 if (precision < 0) /* cover possible overflow of "accum" */
1169 precision = 0;
1170 prec = Min(precision, 350);
1171
1172 if (isnan(value))
1173 {
1174 strcpy(convert, "NaN");
1175 vallen = 3;
1176 /* no zero padding, regardless of precision spec */
1177 }
1178 else
1179 {
1180 /*
1181 * Handle sign (NaNs have no sign, so we don't do this in the case
1182 * above). "value < 0.0" will not be true for IEEE minus zero, so we
1183 * detect that by looking for the case where value equals 0.0
1184 * according to == but not according to memcmp.
1185 */
1186 static const double dzero = 0.0;
1187
1188 if (adjust_sign((value < 0.0 ||
1189 (value == 0.0 &&
1190 memcmp(&value, &dzero, sizeof(double)) != 0)),
1191 forcesign, &signvalue))
1192 value = -value;
1193
1194 if (isinf(value))
1195 {
1196 strcpy(convert, "Infinity");
1197 vallen = 8;
1198 /* no zero padding, regardless of precision spec */
1199 }
1200 else if (pointflag)
1201 {
1202 zeropadlen = precision - prec;
1203 fmt[0] = '%';
1204 fmt[1] = '.';
1205 fmt[2] = '*';
1206 fmt[3] = type;
1207 fmt[4] = '\0';
1208 vallen = snprintf(convert, sizeof(convert), fmt, prec, value);
1209 }
1210 else
1211 {
1212 fmt[0] = '%';
1213 fmt[1] = type;
1214 fmt[2] = '\0';
1215 vallen = snprintf(convert, sizeof(convert), fmt, value);
1216 }
1217 if (vallen < 0)
1218 goto fail;
1219
1220 /*
1221 * Windows, alone among our supported platforms, likes to emit
1222 * three-digit exponent fields even when two digits would do. Hack
1223 * such results to look like the way everyone else does it.
1224 */
1225 #ifdef WIN32
1226 if (vallen >= 6 &&
1227 convert[vallen - 5] == 'e' &&
1228 convert[vallen - 3] == '0')
1229 {
1230 convert[vallen - 3] = convert[vallen - 2];
1231 convert[vallen - 2] = convert[vallen - 1];
1232 vallen--;
1233 }
1234 #endif
1235 }
1236
1237 padlen = compute_padlen(minlen, vallen + zeropadlen, leftjust);
1238
1239 leading_pad(zpad, signvalue, &padlen, target);
1240
1241 if (zeropadlen > 0)
1242 {
1243 /* If 'e' or 'E' format, inject zeroes before the exponent */
1244 char *epos = strrchr(convert, 'e');
1245
1246 if (!epos)
1247 epos = strrchr(convert, 'E');
1248 if (epos)
1249 {
1250 /* pad before exponent */
1251 dostr(convert, epos - convert, target);
1252 dopr_outchmulti('0', zeropadlen, target);
1253 dostr(epos, vallen - (epos - convert), target);
1254 }
1255 else
1256 {
1257 /* no exponent, pad after the digits */
1258 dostr(convert, vallen, target);
1259 dopr_outchmulti('0', zeropadlen, target);
1260 }
1261 }
1262 else
1263 {
1264 /* no zero padding, just emit the number as-is */
1265 dostr(convert, vallen, target);
1266 }
1267
1268 trailing_pad(padlen, target);
1269 return;
1270
1271 fail:
1272 target->failed = true;
1273 }
1274
1275 /*
1276 * Nonstandard entry point to print a double value efficiently.
1277 *
1278 * This is approximately equivalent to strfromd(), but has an API more
1279 * adapted to what float8out() wants. The behavior is like snprintf()
1280 * with a format of "%.ng", where n is the specified precision.
1281 * However, the target buffer must be nonempty (i.e. count > 0), and
1282 * the precision is silently bounded to a sane range.
1283 */
1284 int
1285 pg_strfromd(char *str, size_t count, int precision, double value)
1286 {
1287 PrintfTarget target;
1288 int signvalue = 0;
1289 int vallen;
1290 char fmt[8];
1291 char convert[64];
1292
1293 /* Set up the target like pg_snprintf, but require nonempty buffer */
1294 Assert(count > 0);
1295 target.bufstart = target.bufptr = str;
1296 target.bufend = str + count - 1;
1297 target.stream = NULL;
1298 target.nchars = 0;
1299 target.failed = false;
1300
1301 /*
1302 * We bound precision to a reasonable range; the combination of this and
1303 * the knowledge that we're using "g" format without padding allows the
1304 * convert[] buffer to be reasonably small.
1305 */
1306 if (precision < 1)
1307 precision = 1;
1308 else if (precision > 32)
1309 precision = 32;
1310
1311 /*
1312 * The rest is just an inlined version of the fmtfloat() logic above,
1313 * simplified using the knowledge that no padding is wanted.
1314 */
1315 if (isnan(value))
1316 {
1317 strcpy(convert, "NaN");
1318 vallen = 3;
1319 }
1320 else
1321 {
1322 static const double dzero = 0.0;
1323
1324 if (value < 0.0 ||
1325 (value == 0.0 &&
1326 memcmp(&value, &dzero, sizeof(double)) != 0))
1327 {
1328 signvalue = '-';
1329 value = -value;
1330 }
1331
1332 if (isinf(value))
1333 {
1334 strcpy(convert, "Infinity");
1335 vallen = 8;
1336 }
1337 else
1338 {
1339 fmt[0] = '%';
1340 fmt[1] = '.';
1341 fmt[2] = '*';
1342 fmt[3] = 'g';
1343 fmt[4] = '\0';
1344 vallen = snprintf(convert, sizeof(convert), fmt, precision, value);
1345 if (vallen < 0)
1346 {
1347 target.failed = true;
1348 goto fail;
1349 }
1350
1351 #ifdef WIN32
1352 if (vallen >= 6 &&
1353 convert[vallen - 5] == 'e' &&
1354 convert[vallen - 3] == '0')
1355 {
1356 convert[vallen - 3] = convert[vallen - 2];
1357 convert[vallen - 2] = convert[vallen - 1];
1358 vallen--;
1359 }
1360 #endif
1361 }
1362 }
1363
1364 if (signvalue)
1365 dopr_outch(signvalue, &target);
1366
1367 dostr(convert, vallen, &target);
1368
1369 fail:
1370 *(target.bufptr) = '\0';
1371 return target.failed ? -1 : (target.bufptr - target.bufstart
1372 + target.nchars);
1373 }
1374
1375
1376 static void
1377 dostr(const char *str, int slen, PrintfTarget *target)
1378 {
1379 /* fast path for common case of slen == 1 */
1380 if (slen == 1)
1381 {
1382 dopr_outch(*str, target);
1383 return;
1384 }
1385
1386 while (slen > 0)
1387 {
1388 int avail;
1389
1390 if (target->bufend != NULL)
1391 avail = target->bufend - target->bufptr;
1392 else
1393 avail = slen;
1394 if (avail <= 0)
1395 {
1396 /* buffer full, can we dump to stream? */
1397 if (target->stream == NULL)
1398 {
1399 target->nchars += slen; /* no, lose the data */
1400 return;
1401 }
1402 flushbuffer(target);
1403 continue;
1404 }
1405 avail = Min(avail, slen);
1406 memmove(target->bufptr, str, avail);
1407 target->bufptr += avail;
1408 str += avail;
1409 slen -= avail;
1410 }
1411 }
1412
1413 static void
1414 dopr_outch(int c, PrintfTarget *target)
1415 {
1416 if (target->bufend != NULL && target->bufptr >= target->bufend)
1417 {
1418 /* buffer full, can we dump to stream? */
1419 if (target->stream == NULL)
1420 {
1421 target->nchars++; /* no, lose the data */
1422 return;
1423 }
1424 flushbuffer(target);
1425 }
1426 *(target->bufptr++) = c;
1427 }
1428
1429 static void
1430 dopr_outchmulti(int c, int slen, PrintfTarget *target)
1431 {
1432 /* fast path for common case of slen == 1 */
1433 if (slen == 1)
1434 {
1435 dopr_outch(c, target);
1436 return;
1437 }
1438
1439 while (slen > 0)
1440 {
1441 int avail;
1442
1443 if (target->bufend != NULL)
1444 avail = target->bufend - target->bufptr;
1445 else
1446 avail = slen;
1447 if (avail <= 0)
1448 {
1449 /* buffer full, can we dump to stream? */
1450 if (target->stream == NULL)
1451 {
1452 target->nchars += slen; /* no, lose the data */
1453 return;
1454 }
1455 flushbuffer(target);
1456 continue;
1457 }
1458 avail = Min(avail, slen);
1459 memset(target->bufptr, c, avail);
1460 target->bufptr += avail;
1461 slen -= avail;
1462 }
1463 }
1464
1465
1466 static int
1467 adjust_sign(int is_negative, int forcesign, int *signvalue)
1468 {
1469 if (is_negative)
1470 {
1471 *signvalue = '-';
1472 return true;
1473 }
1474 else if (forcesign)
1475 *signvalue = '+';
1476 return false;
1477 }
1478
1479
1480 static int
1481 compute_padlen(int minlen, int vallen, int leftjust)
1482 {
1483 int padlen;
1484
1485 padlen = minlen - vallen;
1486 if (padlen < 0)
1487 padlen = 0;
1488 if (leftjust)
1489 padlen = -padlen;
1490 return padlen;
1491 }
1492
1493
1494 static void
1495 leading_pad(int zpad, int signvalue, int *padlen, PrintfTarget *target)
1496 {
1497 int maxpad;
1498
1499 if (*padlen > 0 && zpad)
1500 {
1501 if (signvalue)
1502 {
1503 dopr_outch(signvalue, target);
1504 --(*padlen);
1505 signvalue = 0;
1506 }
1507 if (*padlen > 0)
1508 {
1509 dopr_outchmulti(zpad, *padlen, target);
1510 *padlen = 0;
1511 }
1512 }
1513 maxpad = (signvalue != 0);
1514 if (*padlen > maxpad)
1515 {
1516 dopr_outchmulti(' ', *padlen - maxpad, target);
1517 *padlen = maxpad;
1518 }
1519 if (signvalue)
1520 {
1521 dopr_outch(signvalue, target);
1522 if (*padlen > 0)
1523 --(*padlen);
1524 else if (*padlen < 0)
1525 ++(*padlen);
1526 }
1527 }
1528
1529
1530 static void
1531 trailing_pad(int padlen, PrintfTarget *target)
1532 {
1533 if (padlen < 0)
1534 dopr_outchmulti(' ', -padlen, target);
1535 }
Postgresql Clone from git://git.postgresql.org/git/postgresql.git