PostgreSQL Source Code  git master
snprintf.c
Go to the documentation of this file.
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-2023, 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 {
151 
152 typedef union
153 {
154  int i;
155  long l;
156  long long ll;
157  double d;
158  char *cptr;
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);
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
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
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 }
#define Min(x, y)
Definition: c.h:988
#define Max(x, y)
Definition: c.h:982
static struct @143 value
int i
Definition: isn.c:73
static void const char * fmt
va_end(args)
Assert(fmt[strlen(fmt) - 1] !='\n')
va_start(args, fmt)
static char format
const void size_t len
#define PG_STRERROR_R_BUFLEN
Definition: port.h:256
#define snprintf
Definition: port.h:238
#define strerror_r
Definition: port.h:255
size_t strnlen(const char *str, size_t maxlen)
Definition: strnlen.c:26
char * c
static void dostr(const char *str, int slen, PrintfTarget *target)
Definition: snprintf.c:1377
static void dopr_outch(int c, PrintfTarget *target)
Definition: snprintf.c:1414
static void fmtint(long long value, char type, int forcesign, int leftjust, int minlen, int zpad, int precision, int pointflag, PrintfTarget *target)
Definition: snprintf.c:1010
static void leading_pad(int zpad, int signvalue, int *padlen, PrintfTarget *target)
Definition: snprintf.c:1495
int pg_strfromd(char *str, size_t count, int precision, double value)
Definition: snprintf.c:1285
static void fmtptr(const void *value, PrintfTarget *target)
Definition: snprintf.c:996
static void flushbuffer(PrintfTarget *target)
Definition: snprintf.c:298
int pg_printf(const char *fmt,...)
Definition: snprintf.c:282
static void fmtchar(int value, int leftjust, int minlen, PrintfTarget *target)
Definition: snprintf.c:1121
static void fmtstr(const char *value, int leftjust, int minlen, int maxwidth, int pointflag, PrintfTarget *target)
Definition: snprintf.c:967
int pg_vprintf(const char *fmt, va_list args)
Definition: snprintf.c:276
int pg_snprintf(char *str, size_t count, const char *fmt,...)
Definition: snprintf.c:202
static int compute_padlen(int minlen, int vallen, int leftjust)
Definition: snprintf.c:1481
int pg_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
Definition: snprintf.c:174
#define PG_NL_ARGMAX
Definition: snprintf.c:44
static void trailing_pad(int padlen, PrintfTarget *target)
Definition: snprintf.c:1531
static void fmtfloat(double value, char type, int forcesign, int leftjust, int minlen, int zpad, int precision, int pointflag, PrintfTarget *target)
Definition: snprintf.c:1139
int pg_sprintf(char *str, const char *fmt,...)
Definition: snprintf.c:230
static bool find_arguments(const char *format, va_list args, PrintfArgValue *argvalues)
Definition: snprintf.c:749
int pg_vsprintf(char *str, const char *fmt, va_list args)
Definition: snprintf.c:214
static void dopr(PrintfTarget *target, const char *format, va_list args)
Definition: snprintf.c:376
static const char * strchrnul(const char *s, int c)
Definition: snprintf.c:350
static void dopr_outchmulti(int c, int slen, PrintfTarget *target)
Definition: snprintf.c:1430
int pg_fprintf(FILE *stream, const char *fmt,...)
Definition: snprintf.c:264
PrintfArgType
Definition: snprintf.c:143
@ ATYPE_LONGLONG
Definition: snprintf.c:147
@ ATYPE_INT
Definition: snprintf.c:145
@ ATYPE_LONG
Definition: snprintf.c:146
@ ATYPE_CHARPTR
Definition: snprintf.c:149
@ ATYPE_NONE
Definition: snprintf.c:144
@ ATYPE_DOUBLE
Definition: snprintf.c:148
int pg_vfprintf(FILE *stream, const char *fmt, va_list args)
Definition: snprintf.c:242
static int adjust_sign(int is_negative, int forcesign, int *signvalue)
Definition: snprintf.c:1467
bool failed
Definition: snprintf.c:133
char * bufstart
Definition: snprintf.c:128
char * bufend
Definition: snprintf.c:129
char * bufptr
Definition: snprintf.c:127
FILE * stream
Definition: snprintf.c:131
long long ll
Definition: snprintf.c:156
char * cptr
Definition: snprintf.c:158
static void convert(const int32 val, char *const buf)
Definition: zic.c:1992