PostgreSQL Source Code  git master
snprintf.c File Reference
#include "c.h"
#include <math.h>
Include dependency graph for snprintf.c:

Go to the source code of this file.

Data Structures

struct  PrintfTarget
 
union  PrintfArgValue
 

Macros

#define PG_NL_ARGMAX   31
 

Enumerations

enum  PrintfArgType {
  ATYPE_NONE = 0 , ATYPE_INT , ATYPE_LONG , ATYPE_LONGLONG ,
  ATYPE_DOUBLE , ATYPE_CHARPTR
}
 

Functions

static void flushbuffer (PrintfTarget *target)
 
static void dopr (PrintfTarget *target, const char *format, va_list args)
 
int pg_vsnprintf (char *str, size_t count, const char *fmt, va_list args)
 
int pg_snprintf (char *str, size_t count, const char *fmt,...)
 
int pg_vsprintf (char *str, const char *fmt, va_list args)
 
int pg_sprintf (char *str, const char *fmt,...)
 
int pg_vfprintf (FILE *stream, const char *fmt, va_list args)
 
int pg_fprintf (FILE *stream, const char *fmt,...)
 
int pg_vprintf (const char *fmt, va_list args)
 
int pg_printf (const char *fmt,...)
 
static bool find_arguments (const char *format, va_list args, PrintfArgValue *argvalues)
 
static void fmtstr (const char *value, int leftjust, int minlen, int maxwidth, int pointflag, PrintfTarget *target)
 
static void fmtptr (const void *value, PrintfTarget *target)
 
static void fmtint (long long value, char type, int forcesign, int leftjust, int minlen, int zpad, int precision, int pointflag, PrintfTarget *target)
 
static void fmtchar (int value, int leftjust, int minlen, PrintfTarget *target)
 
static void fmtfloat (double value, char type, int forcesign, int leftjust, int minlen, int zpad, int precision, int pointflag, PrintfTarget *target)
 
static void dostr (const char *str, int slen, PrintfTarget *target)
 
static void dopr_outch (int c, PrintfTarget *target)
 
static void dopr_outchmulti (int c, int slen, PrintfTarget *target)
 
static int adjust_sign (int is_negative, int forcesign, int *signvalue)
 
static int compute_padlen (int minlen, int vallen, int leftjust)
 
static void leading_pad (int zpad, int signvalue, int *padlen, PrintfTarget *target)
 
static void trailing_pad (int padlen, PrintfTarget *target)
 
static const char * strchrnul (const char *s, int c)
 
int pg_strfromd (char *str, size_t count, int precision, double value)
 

Macro Definition Documentation

◆ PG_NL_ARGMAX

#define PG_NL_ARGMAX   31

Definition at line 44 of file snprintf.c.

Enumeration Type Documentation

◆ PrintfArgType

Enumerator
ATYPE_NONE 
ATYPE_INT 
ATYPE_LONG 
ATYPE_LONGLONG 
ATYPE_DOUBLE 
ATYPE_CHARPTR 

Definition at line 142 of file snprintf.c.

143 {
144  ATYPE_NONE = 0,
145  ATYPE_INT,
146  ATYPE_LONG,
148  ATYPE_DOUBLE,
150 } PrintfArgType;
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

Function Documentation

◆ adjust_sign()

static int adjust_sign ( int  is_negative,
int  forcesign,
int *  signvalue 
)
static

Definition at line 1471 of file snprintf.c.

1472 {
1473  if (is_negative)
1474  {
1475  *signvalue = '-';
1476  return true;
1477  }
1478  else if (forcesign)
1479  *signvalue = '+';
1480  return false;
1481 }

Referenced by fmtfloat(), and fmtint().

◆ compute_padlen()

static int compute_padlen ( int  minlen,
int  vallen,
int  leftjust 
)
static

Definition at line 1485 of file snprintf.c.

1486 {
1487  int padlen;
1488 
1489  padlen = minlen - vallen;
1490  if (padlen < 0)
1491  padlen = 0;
1492  if (leftjust)
1493  padlen = -padlen;
1494  return padlen;
1495 }

Referenced by fmtchar(), fmtfloat(), fmtint(), and fmtstr().

◆ dopr()

static void dopr ( PrintfTarget target,
const char *  format,
va_list  args 
)
static

Definition at line 376 of file snprintf.c.

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 }
int i
Definition: isn.c:73
static char format
#define PG_STRERROR_R_BUFLEN
Definition: port.h:243
#define strerror_r
Definition: port.h:242
static void dostr(const char *str, int slen, PrintfTarget *target)
Definition: snprintf.c:1381
static void dopr_outch(int c, PrintfTarget *target)
Definition: snprintf.c:1418
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:1014
static void fmtptr(const void *value, PrintfTarget *target)
Definition: snprintf.c:1000
static void fmtchar(int value, int leftjust, int minlen, PrintfTarget *target)
Definition: snprintf.c:1125
static void fmtstr(const char *value, int leftjust, int minlen, int maxwidth, int pointflag, PrintfTarget *target)
Definition: snprintf.c:971
#define PG_NL_ARGMAX
Definition: snprintf.c:44
static void fmtfloat(double value, char type, int forcesign, int leftjust, int minlen, int zpad, int precision, int pointflag, PrintfTarget *target)
Definition: snprintf.c:1143
static bool find_arguments(const char *format, va_list args, PrintfArgValue *argvalues)
Definition: snprintf.c:749
static const char * strchrnul(const char *s, int c)
Definition: snprintf.c:350
bool failed
Definition: snprintf.c:133
long long ll
Definition: snprintf.c:156
char * cptr
Definition: snprintf.c:158

References generate_unaccent_rules::args, PrintfArgValue::cptr, PrintfArgValue::d, dopr_outch(), dostr(), PrintfTarget::failed, find_arguments(), fmtchar(), fmtfloat(), fmtint(), fmtptr(), fmtstr(), format, i, PrintfArgValue::i, PrintfArgValue::l, PrintfArgValue::ll, PG_NL_ARGMAX, PG_STRERROR_R_BUFLEN, strchrnul(), and strerror_r.

Referenced by pg_vfprintf(), pg_vsnprintf(), and pg_vsprintf().

◆ dopr_outch()

static void dopr_outch ( int  c,
PrintfTarget target 
)
static

Definition at line 1418 of file snprintf.c.

1419 {
1420  if (target->bufend != NULL && target->bufptr >= target->bufend)
1421  {
1422  /* buffer full, can we dump to stream? */
1423  if (target->stream == NULL)
1424  {
1425  target->nchars++; /* no, lose the data */
1426  return;
1427  }
1428  flushbuffer(target);
1429  }
1430  *(target->bufptr++) = c;
1431 }
char * c
static void flushbuffer(PrintfTarget *target)
Definition: snprintf.c:298
char * bufend
Definition: snprintf.c:129
char * bufptr
Definition: snprintf.c:127
FILE * stream
Definition: snprintf.c:131

References PrintfTarget::bufend, PrintfTarget::bufptr, flushbuffer(), PrintfTarget::nchars, and PrintfTarget::stream.

Referenced by dopr(), dopr_outchmulti(), dostr(), fmtchar(), leading_pad(), and pg_strfromd().

◆ dopr_outchmulti()

static void dopr_outchmulti ( int  c,
int  slen,
PrintfTarget target 
)
static

Definition at line 1434 of file snprintf.c.

1435 {
1436  /* fast path for common case of slen == 1 */
1437  if (slen == 1)
1438  {
1439  dopr_outch(c, target);
1440  return;
1441  }
1442 
1443  while (slen > 0)
1444  {
1445  int avail;
1446 
1447  if (target->bufend != NULL)
1448  avail = target->bufend - target->bufptr;
1449  else
1450  avail = slen;
1451  if (avail <= 0)
1452  {
1453  /* buffer full, can we dump to stream? */
1454  if (target->stream == NULL)
1455  {
1456  target->nchars += slen; /* no, lose the data */
1457  return;
1458  }
1459  flushbuffer(target);
1460  continue;
1461  }
1462  avail = Min(avail, slen);
1463  memset(target->bufptr, c, avail);
1464  target->bufptr += avail;
1465  slen -= avail;
1466  }
1467 }
#define Min(x, y)
Definition: c.h:986

References PrintfTarget::bufend, PrintfTarget::bufptr, dopr_outch(), flushbuffer(), Min, PrintfTarget::nchars, and PrintfTarget::stream.

Referenced by fmtchar(), fmtfloat(), fmtint(), fmtstr(), leading_pad(), and trailing_pad().

◆ dostr()

static void dostr ( const char *  str,
int  slen,
PrintfTarget target 
)
static

Definition at line 1381 of file snprintf.c.

1382 {
1383  /* fast path for common case of slen == 1 */
1384  if (slen == 1)
1385  {
1386  dopr_outch(*str, target);
1387  return;
1388  }
1389 
1390  while (slen > 0)
1391  {
1392  int avail;
1393 
1394  if (target->bufend != NULL)
1395  avail = target->bufend - target->bufptr;
1396  else
1397  avail = slen;
1398  if (avail <= 0)
1399  {
1400  /* buffer full, can we dump to stream? */
1401  if (target->stream == NULL)
1402  {
1403  target->nchars += slen; /* no, lose the data */
1404  return;
1405  }
1406  flushbuffer(target);
1407  continue;
1408  }
1409  avail = Min(avail, slen);
1410  memmove(target->bufptr, str, avail);
1411  target->bufptr += avail;
1412  str += avail;
1413  slen -= avail;
1414  }
1415 }

References PrintfTarget::bufend, PrintfTarget::bufptr, dopr_outch(), flushbuffer(), Min, PrintfTarget::nchars, generate_unaccent_rules::str, and PrintfTarget::stream.

Referenced by dopr(), fmtfloat(), fmtint(), fmtptr(), fmtstr(), and pg_strfromd().

◆ find_arguments()

static bool find_arguments ( const char *  format,
va_list  args,
PrintfArgValue argvalues 
)
static

Definition at line 749 of file snprintf.c.

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;
760  PrintfArgType argtypes[PG_NL_ARGMAX + 1];
761 
762  /* Initialize to "no dollar arguments known" */
763  last_dollar = 0;
764  MemSet(argtypes, 0, sizeof(argtypes));
765 
766  /*
767  * This loop must accept the same format strings as the one in dopr().
768  * However, we don't need to analyze them to the same level of detail.
769  *
770  * Since we're only called if there's a dollar-type spec somewhere, we can
771  * fail immediately if we find a non-dollar spec. Per the C99 standard,
772  * all argument references in the format string must be one or the other.
773  */
774  while (*format != '\0')
775  {
776  /* Locate next conversion specifier */
777  if (*format != '%')
778  {
779  /* Unlike dopr, we can just quit if there's no more specifiers */
780  format = strchr(format + 1, '%');
781  if (format == NULL)
782  break;
783  }
784 
785  /* Process conversion spec starting at *format */
786  format++;
787  longflag = longlongflag = 0;
788  fmtpos = accum = 0;
789  afterstar = false;
790 nextch1:
791  ch = *format++;
792  switch (ch)
793  {
794  case '-':
795  case '+':
796  goto nextch1;
797  case '0':
798  case '1':
799  case '2':
800  case '3':
801  case '4':
802  case '5':
803  case '6':
804  case '7':
805  case '8':
806  case '9':
807  accum = accum * 10 + (ch - '0');
808  goto nextch1;
809  case '.':
810  accum = 0;
811  goto nextch1;
812  case '*':
813  if (afterstar)
814  return false; /* previous star missing dollar */
815  afterstar = true;
816  accum = 0;
817  goto nextch1;
818  case '$':
819  if (accum <= 0 || accum > PG_NL_ARGMAX)
820  return false;
821  if (afterstar)
822  {
823  if (argtypes[accum] &&
824  argtypes[accum] != ATYPE_INT)
825  return false;
826  argtypes[accum] = ATYPE_INT;
827  last_dollar = Max(last_dollar, accum);
828  afterstar = false;
829  }
830  else
831  fmtpos = accum;
832  accum = 0;
833  goto nextch1;
834  case 'l':
835  if (longflag)
836  longlongflag = 1;
837  else
838  longflag = 1;
839  goto nextch1;
840  case 'z':
841 #if SIZEOF_SIZE_T == 8
842 #ifdef HAVE_LONG_INT_64
843  longflag = 1;
844 #elif defined(HAVE_LONG_LONG_INT_64)
845  longlongflag = 1;
846 #else
847 #error "Don't know how to print 64bit integers"
848 #endif
849 #else
850  /* assume size_t is same size as int */
851 #endif
852  goto nextch1;
853  case 'h':
854  case '\'':
855  /* ignore these */
856  goto nextch1;
857  case 'd':
858  case 'i':
859  case 'o':
860  case 'u':
861  case 'x':
862  case 'X':
863  if (fmtpos)
864  {
865  PrintfArgType atype;
866 
867  if (longlongflag)
868  atype = ATYPE_LONGLONG;
869  else if (longflag)
870  atype = ATYPE_LONG;
871  else
872  atype = ATYPE_INT;
873  if (argtypes[fmtpos] &&
874  argtypes[fmtpos] != atype)
875  return false;
876  argtypes[fmtpos] = atype;
877  last_dollar = Max(last_dollar, fmtpos);
878  }
879  else
880  return false; /* non-dollar conversion spec */
881  break;
882  case 'c':
883  if (fmtpos)
884  {
885  if (argtypes[fmtpos] &&
886  argtypes[fmtpos] != ATYPE_INT)
887  return false;
888  argtypes[fmtpos] = ATYPE_INT;
889  last_dollar = Max(last_dollar, fmtpos);
890  }
891  else
892  return false; /* non-dollar conversion spec */
893  break;
894  case 's':
895  case 'p':
896  if (fmtpos)
897  {
898  if (argtypes[fmtpos] &&
899  argtypes[fmtpos] != ATYPE_CHARPTR)
900  return false;
901  argtypes[fmtpos] = ATYPE_CHARPTR;
902  last_dollar = Max(last_dollar, fmtpos);
903  }
904  else
905  return false; /* non-dollar conversion spec */
906  break;
907  case 'e':
908  case 'E':
909  case 'f':
910  case 'g':
911  case 'G':
912  if (fmtpos)
913  {
914  if (argtypes[fmtpos] &&
915  argtypes[fmtpos] != ATYPE_DOUBLE)
916  return false;
917  argtypes[fmtpos] = ATYPE_DOUBLE;
918  last_dollar = Max(last_dollar, fmtpos);
919  }
920  else
921  return false; /* non-dollar conversion spec */
922  break;
923  case 'm':
924  case '%':
925  break;
926  default:
927  return false; /* bogus format string */
928  }
929 
930  /*
931  * If we finish the spec with afterstar still set, there's a
932  * non-dollar star in there.
933  */
934  if (afterstar)
935  return false; /* non-dollar conversion spec */
936  }
937 
938  /*
939  * Format appears valid so far, so collect the arguments in physical
940  * order. (Since we rejected any non-dollar specs that would have
941  * collected arguments, we know that dopr() hasn't collected any yet.)
942  */
943  for (i = 1; i <= last_dollar; i++)
944  {
945  switch (argtypes[i])
946  {
947  case ATYPE_NONE:
948  return false;
949  case ATYPE_INT:
950  argvalues[i].i = va_arg(args, int);
951  break;
952  case ATYPE_LONG:
953  argvalues[i].l = va_arg(args, long);
954  break;
955  case ATYPE_LONGLONG:
956  argvalues[i].ll = va_arg(args, long long);
957  break;
958  case ATYPE_DOUBLE:
959  argvalues[i].d = va_arg(args, double);
960  break;
961  case ATYPE_CHARPTR:
962  argvalues[i].cptr = va_arg(args, char *);
963  break;
964  }
965  }
966 
967  return true;
968 }
#define Max(x, y)
Definition: c.h:980
#define MemSet(start, val, len)
Definition: c.h:1008

References generate_unaccent_rules::args, ATYPE_CHARPTR, ATYPE_DOUBLE, ATYPE_INT, ATYPE_LONG, ATYPE_LONGLONG, ATYPE_NONE, PrintfArgValue::cptr, PrintfArgValue::d, format, i, PrintfArgValue::i, PrintfArgValue::l, PrintfArgValue::ll, Max, MemSet, and PG_NL_ARGMAX.

Referenced by dopr().

◆ flushbuffer()

static void flushbuffer ( PrintfTarget target)
static

Definition at line 298 of file snprintf.c.

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 }
char * bufstart
Definition: snprintf.c:128

References PrintfTarget::bufptr, PrintfTarget::bufstart, PrintfTarget::failed, PrintfTarget::nchars, and PrintfTarget::stream.

Referenced by dopr_outch(), dopr_outchmulti(), dostr(), and pg_vfprintf().

◆ fmtchar()

static void fmtchar ( int  value,
int  leftjust,
int  minlen,
PrintfTarget target 
)
static

Definition at line 1125 of file snprintf.c.

1126 {
1127  int padlen; /* amount to pad */
1128 
1129  padlen = compute_padlen(minlen, 1, leftjust);
1130 
1131  if (padlen > 0)
1132  {
1133  dopr_outchmulti(' ', padlen, target);
1134  padlen = 0;
1135  }
1136 
1137  dopr_outch(value, target);
1138 
1139  trailing_pad(padlen, target);
1140 }
static struct @151 value
static int compute_padlen(int minlen, int vallen, int leftjust)
Definition: snprintf.c:1485
static void trailing_pad(int padlen, PrintfTarget *target)
Definition: snprintf.c:1535
static void dopr_outchmulti(int c, int slen, PrintfTarget *target)
Definition: snprintf.c:1434

References compute_padlen(), dopr_outch(), dopr_outchmulti(), trailing_pad(), and value.

Referenced by dopr(), and rfmtlong().

◆ fmtfloat()

static void fmtfloat ( double  value,
char  type,
int  forcesign,
int  leftjust,
int  minlen,
int  zpad,
int  precision,
int  pointflag,
PrintfTarget target 
)
static

Definition at line 1143 of file snprintf.c.

1146 {
1147  int signvalue = 0;
1148  int prec;
1149  int vallen;
1150  char fmt[8];
1151  char convert[1024];
1152  int zeropadlen = 0; /* amount to pad with zeroes */
1153  int padlen; /* amount to pad with spaces */
1154 
1155  /*
1156  * We rely on the regular C library's sprintf to do the basic conversion,
1157  * then handle padding considerations here.
1158  *
1159  * The dynamic range of "double" is about 1E+-308 for IEEE math, and not
1160  * too wildly more than that with other hardware. In "f" format, sprintf
1161  * could therefore generate at most 308 characters to the left of the
1162  * decimal point; while we need to allow the precision to get as high as
1163  * 308+17 to ensure that we don't truncate significant digits from very
1164  * small values. To handle both these extremes, we use a buffer of 1024
1165  * bytes and limit requested precision to 350 digits; this should prevent
1166  * buffer overrun even with non-IEEE math. If the original precision
1167  * request was more than 350, separately pad with zeroes.
1168  *
1169  * We handle infinities and NaNs specially to ensure platform-independent
1170  * output.
1171  */
1172  if (precision < 0) /* cover possible overflow of "accum" */
1173  precision = 0;
1174  prec = Min(precision, 350);
1175 
1176  if (isnan(value))
1177  {
1178  strcpy(convert, "NaN");
1179  vallen = 3;
1180  /* no zero padding, regardless of precision spec */
1181  }
1182  else
1183  {
1184  /*
1185  * Handle sign (NaNs have no sign, so we don't do this in the case
1186  * above). "value < 0.0" will not be true for IEEE minus zero, so we
1187  * detect that by looking for the case where value equals 0.0
1188  * according to == but not according to memcmp.
1189  */
1190  static const double dzero = 0.0;
1191 
1192  if (adjust_sign((value < 0.0 ||
1193  (value == 0.0 &&
1194  memcmp(&value, &dzero, sizeof(double)) != 0)),
1195  forcesign, &signvalue))
1196  value = -value;
1197 
1198  if (isinf(value))
1199  {
1200  strcpy(convert, "Infinity");
1201  vallen = 8;
1202  /* no zero padding, regardless of precision spec */
1203  }
1204  else if (pointflag)
1205  {
1206  zeropadlen = precision - prec;
1207  fmt[0] = '%';
1208  fmt[1] = '.';
1209  fmt[2] = '*';
1210  fmt[3] = type;
1211  fmt[4] = '\0';
1212  vallen = sprintf(convert, fmt, prec, value);
1213  }
1214  else
1215  {
1216  fmt[0] = '%';
1217  fmt[1] = type;
1218  fmt[2] = '\0';
1219  vallen = sprintf(convert, fmt, value);
1220  }
1221  if (vallen < 0)
1222  goto fail;
1223 
1224  /*
1225  * Windows, alone among our supported platforms, likes to emit
1226  * three-digit exponent fields even when two digits would do. Hack
1227  * such results to look like the way everyone else does it.
1228  */
1229 #ifdef WIN32
1230  if (vallen >= 6 &&
1231  convert[vallen - 5] == 'e' &&
1232  convert[vallen - 3] == '0')
1233  {
1234  convert[vallen - 3] = convert[vallen - 2];
1235  convert[vallen - 2] = convert[vallen - 1];
1236  vallen--;
1237  }
1238 #endif
1239  }
1240 
1241  padlen = compute_padlen(minlen, vallen + zeropadlen, leftjust);
1242 
1243  leading_pad(zpad, signvalue, &padlen, target);
1244 
1245  if (zeropadlen > 0)
1246  {
1247  /* If 'e' or 'E' format, inject zeroes before the exponent */
1248  char *epos = strrchr(convert, 'e');
1249 
1250  if (!epos)
1251  epos = strrchr(convert, 'E');
1252  if (epos)
1253  {
1254  /* pad before exponent */
1255  dostr(convert, epos - convert, target);
1256  dopr_outchmulti('0', zeropadlen, target);
1257  dostr(epos, vallen - (epos - convert), target);
1258  }
1259  else
1260  {
1261  /* no exponent, pad after the digits */
1262  dostr(convert, vallen, target);
1263  dopr_outchmulti('0', zeropadlen, target);
1264  }
1265  }
1266  else
1267  {
1268  /* no zero padding, just emit the number as-is */
1269  dostr(convert, vallen, target);
1270  }
1271 
1272  trailing_pad(padlen, target);
1273  return;
1274 
1275 fail:
1276  target->failed = true;
1277 }
static void const char * fmt
#define sprintf
Definition: port.h:227
static void leading_pad(int zpad, int signvalue, int *padlen, PrintfTarget *target)
Definition: snprintf.c:1499
static int adjust_sign(int is_negative, int forcesign, int *signvalue)
Definition: snprintf.c:1471
static void convert(const int32 val, char *const buf)
Definition: zic.c:1990

References adjust_sign(), compute_padlen(), convert(), dopr_outchmulti(), dostr(), PrintfTarget::failed, fmt, leading_pad(), Min, sprintf, trailing_pad(), generate_unaccent_rules::type, and value.

Referenced by dopr().

◆ fmtint()

static void fmtint ( long long  value,
char  type,
int  forcesign,
int  leftjust,
int  minlen,
int  zpad,
int  precision,
int  pointflag,
PrintfTarget target 
)
static

Definition at line 1014 of file snprintf.c.

1017 {
1018  unsigned long long uvalue;
1019  int base;
1020  int dosign;
1021  const char *cvt = "0123456789abcdef";
1022  int signvalue = 0;
1023  char convert[64];
1024  int vallen = 0;
1025  int padlen; /* amount to pad */
1026  int zeropad; /* extra leading zeroes */
1027 
1028  switch (type)
1029  {
1030  case 'd':
1031  case 'i':
1032  base = 10;
1033  dosign = 1;
1034  break;
1035  case 'o':
1036  base = 8;
1037  dosign = 0;
1038  break;
1039  case 'u':
1040  base = 10;
1041  dosign = 0;
1042  break;
1043  case 'x':
1044  base = 16;
1045  dosign = 0;
1046  break;
1047  case 'X':
1048  cvt = "0123456789ABCDEF";
1049  base = 16;
1050  dosign = 0;
1051  break;
1052  default:
1053  return; /* keep compiler quiet */
1054  }
1055 
1056  /* disable MSVC warning about applying unary minus to an unsigned value */
1057 #ifdef _MSC_VER
1058 #pragma warning(push)
1059 #pragma warning(disable: 4146)
1060 #endif
1061  /* Handle +/- */
1062  if (dosign && adjust_sign((value < 0), forcesign, &signvalue))
1063  uvalue = -(unsigned long long) value;
1064  else
1065  uvalue = (unsigned long long) value;
1066 #ifdef _MSC_VER
1067 #pragma warning(pop)
1068 #endif
1069 
1070  /*
1071  * SUS: the result of converting 0 with an explicit precision of 0 is no
1072  * characters
1073  */
1074  if (value == 0 && pointflag && precision == 0)
1075  vallen = 0;
1076  else
1077  {
1078  /*
1079  * Convert integer to string. We special-case each of the possible
1080  * base values so as to avoid general-purpose divisions. On most
1081  * machines, division by a fixed constant can be done much more
1082  * cheaply than a general divide.
1083  */
1084  if (base == 10)
1085  {
1086  do
1087  {
1088  convert[sizeof(convert) - (++vallen)] = cvt[uvalue % 10];
1089  uvalue = uvalue / 10;
1090  } while (uvalue);
1091  }
1092  else if (base == 16)
1093  {
1094  do
1095  {
1096  convert[sizeof(convert) - (++vallen)] = cvt[uvalue % 16];
1097  uvalue = uvalue / 16;
1098  } while (uvalue);
1099  }
1100  else /* base == 8 */
1101  {
1102  do
1103  {
1104  convert[sizeof(convert) - (++vallen)] = cvt[uvalue % 8];
1105  uvalue = uvalue / 8;
1106  } while (uvalue);
1107  }
1108  }
1109 
1110  zeropad = Max(0, precision - vallen);
1111 
1112  padlen = compute_padlen(minlen, vallen + zeropad, leftjust);
1113 
1114  leading_pad(zpad, signvalue, &padlen, target);
1115 
1116  if (zeropad > 0)
1117  dopr_outchmulti('0', zeropad, target);
1118 
1119  dostr(convert + sizeof(convert) - vallen, vallen, target);
1120 
1121  trailing_pad(padlen, target);
1122 }

References adjust_sign(), compute_padlen(), convert(), dopr_outchmulti(), dostr(), leading_pad(), Max, trailing_pad(), generate_unaccent_rules::type, and value.

Referenced by dopr().

◆ fmtptr()

static void fmtptr ( const void *  value,
PrintfTarget target 
)
static

Definition at line 1000 of file snprintf.c.

1001 {
1002  int vallen;
1003  char convert[64];
1004 
1005  /* we rely on regular C library's sprintf to do the basic conversion */
1006  vallen = sprintf(convert, "%p", value);
1007  if (vallen < 0)
1008  target->failed = true;
1009  else
1010  dostr(convert, vallen, target);
1011 }

References convert(), dostr(), PrintfTarget::failed, sprintf, and value.

Referenced by dopr().

◆ fmtstr()

static void fmtstr ( const char *  value,
int  leftjust,
int  minlen,
int  maxwidth,
int  pointflag,
PrintfTarget target 
)
static

Definition at line 971 of file snprintf.c.

973 {
974  int padlen,
975  vallen; /* amount to pad */
976 
977  /*
978  * If a maxwidth (precision) is specified, we must not fetch more bytes
979  * than that.
980  */
981  if (pointflag)
982  vallen = strnlen(value, maxwidth);
983  else
984  vallen = strlen(value);
985 
986  padlen = compute_padlen(minlen, vallen, leftjust);
987 
988  if (padlen > 0)
989  {
990  dopr_outchmulti(' ', padlen, target);
991  padlen = 0;
992  }
993 
994  dostr(value, vallen, target);
995 
996  trailing_pad(padlen, target);
997 }
size_t strnlen(const char *str, size_t maxlen)
Definition: strnlen.c:26

References compute_padlen(), dopr_outchmulti(), dostr(), strnlen(), trailing_pad(), and value.

Referenced by dopr(), dtcvfmtasc(), dttofmtasc(), dttofmtasc_replace(), and PGTYPEStimestamp_fmt_asc().

◆ leading_pad()

static void leading_pad ( int  zpad,
int  signvalue,
int *  padlen,
PrintfTarget target 
)
static

Definition at line 1499 of file snprintf.c.

1500 {
1501  int maxpad;
1502 
1503  if (*padlen > 0 && zpad)
1504  {
1505  if (signvalue)
1506  {
1507  dopr_outch(signvalue, target);
1508  --(*padlen);
1509  signvalue = 0;
1510  }
1511  if (*padlen > 0)
1512  {
1513  dopr_outchmulti(zpad, *padlen, target);
1514  *padlen = 0;
1515  }
1516  }
1517  maxpad = (signvalue != 0);
1518  if (*padlen > maxpad)
1519  {
1520  dopr_outchmulti(' ', *padlen - maxpad, target);
1521  *padlen = maxpad;
1522  }
1523  if (signvalue)
1524  {
1525  dopr_outch(signvalue, target);
1526  if (*padlen > 0)
1527  --(*padlen);
1528  else if (*padlen < 0)
1529  ++(*padlen);
1530  }
1531 }

References dopr_outch(), and dopr_outchmulti().

Referenced by fmtfloat(), and fmtint().

◆ pg_fprintf()

int pg_fprintf ( FILE *  stream,
const char *  fmt,
  ... 
)

Definition at line 264 of file snprintf.c.

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 }
va_end(args)
va_start(args, fmt)
const void size_t len
int pg_vfprintf(FILE *stream, const char *fmt, va_list args)
Definition: snprintf.c:242

References generate_unaccent_rules::args, fmt, len, pg_vfprintf(), va_end(), and va_start().

◆ pg_printf()

int pg_printf ( const char *  fmt,
  ... 
)

Definition at line 282 of file snprintf.c.

283 {
284  int len;
285  va_list args;
286 
287  va_start(args, fmt);
289  va_end(args);
290  return len;
291 }

References generate_unaccent_rules::args, fmt, len, pg_vfprintf(), generate_unaccent_rules::stdout, va_end(), and va_start().

◆ pg_snprintf()

int pg_snprintf ( char *  str,
size_t  count,
const char *  fmt,
  ... 
)

Definition at line 202 of file snprintf.c.

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 }
int pg_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
Definition: snprintf.c:174

References generate_unaccent_rules::args, fmt, len, pg_vsnprintf(), generate_unaccent_rules::str, va_end(), and va_start().

◆ pg_sprintf()

int pg_sprintf ( char *  str,
const char *  fmt,
  ... 
)

Definition at line 230 of file snprintf.c.

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 }
int pg_vsprintf(char *str, const char *fmt, va_list args)
Definition: snprintf.c:214

References generate_unaccent_rules::args, fmt, len, pg_vsprintf(), generate_unaccent_rules::str, va_end(), and va_start().

◆ pg_strfromd()

int pg_strfromd ( char *  str,
size_t  count,
int  precision,
double  value 
)

Definition at line 1289 of file snprintf.c.

1290 {
1291  PrintfTarget target;
1292  int signvalue = 0;
1293  int vallen;
1294  char fmt[8];
1295  char convert[64];
1296 
1297  /* Set up the target like pg_snprintf, but require nonempty buffer */
1298  Assert(count > 0);
1299  target.bufstart = target.bufptr = str;
1300  target.bufend = str + count - 1;
1301  target.stream = NULL;
1302  target.nchars = 0;
1303  target.failed = false;
1304 
1305  /*
1306  * We bound precision to a reasonable range; the combination of this and
1307  * the knowledge that we're using "g" format without padding allows the
1308  * convert[] buffer to be reasonably small.
1309  */
1310  if (precision < 1)
1311  precision = 1;
1312  else if (precision > 32)
1313  precision = 32;
1314 
1315  /*
1316  * The rest is just an inlined version of the fmtfloat() logic above,
1317  * simplified using the knowledge that no padding is wanted.
1318  */
1319  if (isnan(value))
1320  {
1321  strcpy(convert, "NaN");
1322  vallen = 3;
1323  }
1324  else
1325  {
1326  static const double dzero = 0.0;
1327 
1328  if (value < 0.0 ||
1329  (value == 0.0 &&
1330  memcmp(&value, &dzero, sizeof(double)) != 0))
1331  {
1332  signvalue = '-';
1333  value = -value;
1334  }
1335 
1336  if (isinf(value))
1337  {
1338  strcpy(convert, "Infinity");
1339  vallen = 8;
1340  }
1341  else
1342  {
1343  fmt[0] = '%';
1344  fmt[1] = '.';
1345  fmt[2] = '*';
1346  fmt[3] = 'g';
1347  fmt[4] = '\0';
1348  vallen = sprintf(convert, fmt, precision, value);
1349  if (vallen < 0)
1350  {
1351  target.failed = true;
1352  goto fail;
1353  }
1354 
1355 #ifdef WIN32
1356  if (vallen >= 6 &&
1357  convert[vallen - 5] == 'e' &&
1358  convert[vallen - 3] == '0')
1359  {
1360  convert[vallen - 3] = convert[vallen - 2];
1361  convert[vallen - 2] = convert[vallen - 1];
1362  vallen--;
1363  }
1364 #endif
1365  }
1366  }
1367 
1368  if (signvalue)
1369  dopr_outch(signvalue, &target);
1370 
1371  dostr(convert, vallen, &target);
1372 
1373 fail:
1374  *(target.bufptr) = '\0';
1375  return target.failed ? -1 : (target.bufptr - target.bufstart
1376  + target.nchars);
1377 }
Assert(fmt[strlen(fmt) - 1] !='\n')

References Assert(), PrintfTarget::bufend, PrintfTarget::bufptr, PrintfTarget::bufstart, convert(), dopr_outch(), dostr(), PrintfTarget::failed, fmt, PrintfTarget::nchars, sprintf, generate_unaccent_rules::str, PrintfTarget::stream, and value.

Referenced by float4out(), and float8out_internal().

◆ pg_vfprintf()

int pg_vfprintf ( FILE *  stream,
const char *  fmt,
va_list  args 
)

Definition at line 242 of file snprintf.c.

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 }
static void dopr(PrintfTarget *target, const char *format, va_list args)
Definition: snprintf.c:376

References generate_unaccent_rules::args, PrintfTarget::bufend, PrintfTarget::bufptr, PrintfTarget::bufstart, dopr(), PrintfTarget::failed, flushbuffer(), fmt, PrintfTarget::nchars, and PrintfTarget::stream.

Referenced by pg_fprintf(), pg_printf(), and pg_vprintf().

◆ pg_vprintf()

int pg_vprintf ( const char *  fmt,
va_list  args 
)

Definition at line 276 of file snprintf.c.

277 {
278  return pg_vfprintf(stdout, fmt, args);
279 }

References generate_unaccent_rules::args, fmt, pg_vfprintf(), and generate_unaccent_rules::stdout.

◆ pg_vsnprintf()

int pg_vsnprintf ( char *  str,
size_t  count,
const char *  fmt,
va_list  args 
)

Definition at line 174 of file snprintf.c.

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 }

References generate_unaccent_rules::args, PrintfTarget::bufend, PrintfTarget::bufptr, PrintfTarget::bufstart, dopr(), PrintfTarget::failed, fmt, PrintfTarget::nchars, generate_unaccent_rules::str, and PrintfTarget::stream.

Referenced by pg_snprintf().

◆ pg_vsprintf()

int pg_vsprintf ( char *  str,
const char *  fmt,
va_list  args 
)

Definition at line 214 of file snprintf.c.

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 }

References generate_unaccent_rules::args, PrintfTarget::bufend, PrintfTarget::bufptr, PrintfTarget::bufstart, dopr(), PrintfTarget::failed, fmt, PrintfTarget::nchars, generate_unaccent_rules::str, and PrintfTarget::stream.

Referenced by pg_sprintf().

◆ strchrnul()

static const char* strchrnul ( const char *  s,
int  c 
)
inlinestatic

Definition at line 350 of file snprintf.c.

351 {
352  while (*s != '\0' && *s != c)
353  s++;
354  return s;
355 }

Referenced by dopr().

◆ trailing_pad()

static void trailing_pad ( int  padlen,
PrintfTarget target 
)
static

Definition at line 1535 of file snprintf.c.

1536 {
1537  if (padlen < 0)
1538  dopr_outchmulti(' ', -padlen, target);
1539 }

References dopr_outchmulti().

Referenced by fmtchar(), fmtfloat(), fmtint(), and fmtstr().