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-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  */
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 {
150 } PrintfArgType;
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);
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
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(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  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;
453 nextch2:
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 
735 bad_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  */
746 static bool
747 find_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;
788 nextch1:
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 
968 static void
969 fmtstr(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 
997 static void
998 fmtptr(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 
1011 static void
1012 fmtint(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 
1098 static void
1099 fmtchar(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 
1116 static void
1117 fmtfloat(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 
1251 fail:
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  */
1264 int
1265 pg_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 
1349 fail:
1350  *(target.bufptr) = '\0';
1351  return target.failed ? -1 : (target.bufptr - target.bufstart
1352  + target.nchars);
1353 }
1354 
1355 
1356 static void
1357 dostr(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 
1393 static void
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 
1409 static void
1410 dopr_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 
1446 static int
1447 adjust_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 
1460 static int
1461 compute_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 
1474 static void
1475 leading_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 
1510 static void
1511 trailing_pad(int padlen, PrintfTarget *target)
1512 {
1513  if (padlen < 0)
1514  dopr_outchmulti(' ', -padlen, target);
1515 }
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:1012
char * bufend
Definition: snprintf.c:129
static void dopr_outch(int c, PrintfTarget *target)
Definition: snprintf.c:1394
static const char * strchrnul(const char *s, int c)
Definition: snprintf.c:350
int pg_snprintf(char *str, size_t count, const char *fmt,...)
Definition: snprintf.c:202
int pg_vfprintf(FILE *stream, const char *fmt, va_list args)
Definition: snprintf.c:242
static void fmtptr(void *value, PrintfTarget *target)
Definition: snprintf.c:998
#define PG_STRERROR_R_BUFLEN
Definition: port.h:210
#define Min(x, y)
Definition: c.h:904
static struct @144 value
static void dostr(const char *str, int slen, PrintfTarget *target)
Definition: snprintf.c:1357
static void fmtchar(int value, int leftjust, int minlen, PrintfTarget *target)
Definition: snprintf.c:1099
#define MemSet(start, val, len)
Definition: c.h:955
static bool find_arguments(const char *format, va_list args, PrintfArgValue *argvalues)
Definition: snprintf.c:747
char * bufstart
Definition: snprintf.c:128
#define sprintf
Definition: port.h:194
static void convert(const int32 val, char *const buf)
Definition: zic.c:1959
#define PG_NL_ARGMAX
Definition: snprintf.c:44
static void flushbuffer(PrintfTarget *target)
Definition: snprintf.c:298
int isinf(double x)
char * c
static void trailing_pad(int padlen, PrintfTarget *target)
Definition: snprintf.c:1511
#define memmove(d, s, c)
Definition: c.h:1238
int pg_printf(const char *fmt,...)
Definition: snprintf.c:282
int pg_sprintf(char *str, const char *fmt,...)
Definition: snprintf.c:230
char * cptr
Definition: snprintf.c:158
int pg_strfromd(char *str, size_t count, int precision, double value)
Definition: snprintf.c:1265
int pg_vprintf(const char *fmt, va_list args)
Definition: snprintf.c:276
FILE * stream
Definition: snprintf.c:131
int pg_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
Definition: snprintf.c:174
static int adjust_sign(int is_negative, int forcesign, int *signvalue)
Definition: snprintf.c:1447
long long ll
Definition: snprintf.c:156
bool failed
Definition: snprintf.c:133
#define Max(x, y)
Definition: c.h:898
PrintfArgType
Definition: snprintf.c:142
static void dopr_outchmulti(int c, int slen, PrintfTarget *target)
Definition: snprintf.c:1410
#define Assert(condition)
Definition: c.h:732
static void dopr(PrintfTarget *target, const char *format, va_list args)
Definition: snprintf.c:376
#define strerror_r
Definition: port.h:209
size_t strnlen(const char *str, size_t maxlen)
Definition: strnlen.c:26
static void leading_pad(int zpad, int signvalue, int *padlen, PrintfTarget *target)
Definition: snprintf.c:1475
static void fmtstr(const char *value, int leftjust, int minlen, int maxwidth, int pointflag, PrintfTarget *target)
Definition: snprintf.c:969
int i
static char format
Definition: pg_basebackup.c:89
char * bufptr
Definition: snprintf.c:127
int pg_fprintf(FILE *stream, const char *fmt,...)
Definition: snprintf.c:264
static int compute_padlen(int minlen, int vallen, int leftjust)
Definition: snprintf.c:1461
static void fmtfloat(double value, char type, int forcesign, int leftjust, int minlen, int zpad, int precision, int pointflag, PrintfTarget *target)
Definition: snprintf.c:1117
int pg_vsprintf(char *str, const char *fmt, va_list args)
Definition: snprintf.c:214