#include "c.h"
#include <math.h>

Include dependency graph for snprintf.c:

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

enum PrintfArgType

Enumerator
ATYPE_NONE
ATYPE_INT
ATYPE_LONG
ATYPE_LONGLONG
ATYPE_DOUBLE
ATYPE_CHARPTR

Definition at line 142 of file snprintf.c.

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

Function Documentation

◆ adjust_sign()

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

static

Definition at line 1467 of file snprintf.c.

 {
     if (is_negative)
     {
         *signvalue = '-';
         return true;
     }
     else if (forcesign)
         *signvalue = '+';
     return false;
 }

Referenced by fmtfloat(), and fmtint().

◆ compute_padlen()

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

static

Definition at line 1481 of file snprintf.c.

 {
     int         padlen;
  
     padlen = minlen - vallen;
     if (padlen < 0)
         padlen = 0;
     if (leftjust)
         padlen = -padlen;
     return padlen;
 }

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.

 {
     int         save_errno = errno;
     const char *first_pct = NULL;
     int         ch;
     bool        have_dollar;
     bool        have_star;
     bool        afterstar;
     int         accum;
     int         longlongflag;
     int         longflag;
     int         pointflag;
     int         leftjust;
     int         fieldwidth;
     int         precision;
     int         zpad;
     int         forcesign;
     int         fmtpos;
     int         cvalue;
     long long   numvalue;
     double      fvalue;
     const char *strvalue;
     PrintfArgValue argvalues[PG_NL_ARGMAX + 1];
  
     /*
      * Initially, we suppose the format string does not use %n$.  The first
      * time we come to a conversion spec that has that, we'll call
      * find_arguments() to check for consistent use of %n$ and fill the
      * argvalues array with the argument values in the correct order.
      */
     have_dollar = false;
  
     while (*format != '\0')
     {
         /* Locate next conversion specifier */
         if (*format != '%')
         {
             /* Scan to next '%' or end of string */
             const char *next_pct = strchrnul(format + 1, '%');
  
             /* Dump literal data we just scanned over */
             dostr(format, next_pct - format, target);
             if (target->failed)
                 break;
  
             if (*next_pct == '\0')
                 break;
             format = next_pct;
         }
  
         /*
          * Remember start of first conversion spec; if we find %n$, then it's
          * sufficient for find_arguments() to start here, without rescanning
          * earlier literal text.
          */
         if (first_pct == NULL)
             first_pct = format;
  
         /* Process conversion spec starting at *format */
         format++;
  
         /* Fast path for conversion spec that is exactly %s */
         if (*format == 's')
         {
             format++;
             strvalue = va_arg(args, char *);
             if (strvalue == NULL)
                 strvalue = "(null)";
             dostr(strvalue, strlen(strvalue), target);
             if (target->failed)
                 break;
             continue;
         }
  
         fieldwidth = precision = zpad = leftjust = forcesign = 0;
         longflag = longlongflag = pointflag = 0;
         fmtpos = accum = 0;
         have_star = afterstar = false;
 nextch2:
         ch = *format++;
         switch (ch)
         {
             case '-':
                 leftjust = 1;
                 goto nextch2;
             case '+':
                 forcesign = 1;
                 goto nextch2;
             case '0':
                 /* set zero padding if no nonzero digits yet */
                 if (accum == 0 && !pointflag)
                     zpad = '0';
                 /* FALL THRU */
             case '1':
             case '2':
             case '3':
             case '4':
             case '5':
             case '6':
             case '7':
             case '8':
             case '9':
                 accum = accum * 10 + (ch - '0');
                 goto nextch2;
             case '.':
                 if (have_star)
                     have_star = false;
                 else
                     fieldwidth = accum;
                 pointflag = 1;
                 accum = 0;
                 goto nextch2;
             case '*':
                 if (have_dollar)
                 {
                     /*
                      * We'll process value after reading n$.  Note it's OK to
                      * assume have_dollar is set correctly, because in a valid
                      * format string the initial % must have had n$ if * does.
                      */
                     afterstar = true;
                 }
                 else
                 {
                     /* fetch and process value now */
                     int         starval = va_arg(args, int);
  
                     if (pointflag)
                     {
                         precision = starval;
                         if (precision < 0)
                         {
                             precision = 0;
                             pointflag = 0;
                         }
                     }
                     else
                     {
                         fieldwidth = starval;
                         if (fieldwidth < 0)
                         {
                             leftjust = 1;
                             fieldwidth = -fieldwidth;
                         }
                     }
                 }
                 have_star = true;
                 accum = 0;
                 goto nextch2;
             case '$':
                 /* First dollar sign? */
                 if (!have_dollar)
                 {
                     /* Yup, so examine all conversion specs in format */
                     if (!find_arguments(first_pct, args, argvalues))
                         goto bad_format;
                     have_dollar = true;
                 }
                 if (afterstar)
                 {
                     /* fetch and process star value */
                     int         starval = argvalues[accum].i;
  
                     if (pointflag)
                     {
                         precision = starval;
                         if (precision < 0)
                         {
                             precision = 0;
                             pointflag = 0;
                         }
                     }
                     else
                     {
                         fieldwidth = starval;
                         if (fieldwidth < 0)
                         {
                             leftjust = 1;
                             fieldwidth = -fieldwidth;
                         }
                     }
                     afterstar = false;
                 }
                 else
                     fmtpos = accum;
                 accum = 0;
                 goto nextch2;
             case 'l':
                 if (longflag)
                     longlongflag = 1;
                 else
                     longflag = 1;
                 goto nextch2;
             case 'z':
 #if SIZEOF_SIZE_T == 8
 #ifdef HAVE_LONG_INT_64
                 longflag = 1;
 #elif defined(HAVE_LONG_LONG_INT_64)
                 longlongflag = 1;
 #else
 #error "Don't know how to print 64bit integers"
 #endif
 #else
                 /* assume size_t is same size as int */
 #endif
                 goto nextch2;
             case 'h':
             case '\'':
                 /* ignore these */
                 goto nextch2;
             case 'd':
             case 'i':
                 if (!have_star)
                 {
                     if (pointflag)
                         precision = accum;
                     else
                         fieldwidth = accum;
                 }
                 if (have_dollar)
                 {
                     if (longlongflag)
                         numvalue = argvalues[fmtpos].ll;
                     else if (longflag)
                         numvalue = argvalues[fmtpos].l;
                     else
                         numvalue = argvalues[fmtpos].i;
                 }
                 else
                 {
                     if (longlongflag)
                         numvalue = va_arg(args, long long);
                     else if (longflag)
                         numvalue = va_arg(args, long);
                     else
                         numvalue = va_arg(args, int);
                 }
                 fmtint(numvalue, ch, forcesign, leftjust, fieldwidth, zpad,
                        precision, pointflag, target);
                 break;
             case 'o':
             case 'u':
             case 'x':
             case 'X':
                 if (!have_star)
                 {
                     if (pointflag)
                         precision = accum;
                     else
                         fieldwidth = accum;
                 }
                 if (have_dollar)
                 {
                     if (longlongflag)
                         numvalue = (unsigned long long) argvalues[fmtpos].ll;
                     else if (longflag)
                         numvalue = (unsigned long) argvalues[fmtpos].l;
                     else
                         numvalue = (unsigned int) argvalues[fmtpos].i;
                 }
                 else
                 {
                     if (longlongflag)
                         numvalue = (unsigned long long) va_arg(args, long long);
                     else if (longflag)
                         numvalue = (unsigned long) va_arg(args, long);
                     else
                         numvalue = (unsigned int) va_arg(args, int);
                 }
                 fmtint(numvalue, ch, forcesign, leftjust, fieldwidth, zpad,
                        precision, pointflag, target);
                 break;
             case 'c':
                 if (!have_star)
                 {
                     if (pointflag)
                         precision = accum;
                     else
                         fieldwidth = accum;
                 }
                 if (have_dollar)
                     cvalue = (unsigned char) argvalues[fmtpos].i;
                 else
                     cvalue = (unsigned char) va_arg(args, int);
                 fmtchar(cvalue, leftjust, fieldwidth, target);
                 break;
             case 's':
                 if (!have_star)
                 {
                     if (pointflag)
                         precision = accum;
                     else
                         fieldwidth = accum;
                 }
                 if (have_dollar)
                     strvalue = argvalues[fmtpos].cptr;
                 else
                     strvalue = va_arg(args, char *);
                 /* If string is NULL, silently substitute "(null)" */
                 if (strvalue == NULL)
                     strvalue = "(null)";
                 fmtstr(strvalue, leftjust, fieldwidth, precision, pointflag,
                        target);
                 break;
             case 'p':
                 /* fieldwidth/leftjust are ignored ... */
                 if (have_dollar)
                     strvalue = argvalues[fmtpos].cptr;
                 else
                     strvalue = va_arg(args, char *);
                 fmtptr((const void *) strvalue, target);
                 break;
             case 'e':
             case 'E':
             case 'f':
             case 'g':
             case 'G':
                 if (!have_star)
                 {
                     if (pointflag)
                         precision = accum;
                     else
                         fieldwidth = accum;
                 }
                 if (have_dollar)
                     fvalue = argvalues[fmtpos].d;
                 else
                     fvalue = va_arg(args, double);
                 fmtfloat(fvalue, ch, forcesign, leftjust,
                          fieldwidth, zpad,
                          precision, pointflag,
                          target);
                 break;
             case 'm':
                 {
                     char        errbuf[PG_STRERROR_R_BUFLEN];
                     const char *errm = strerror_r(save_errno,
                                                   errbuf, sizeof(errbuf));
  
                     dostr(errm, strlen(errm), target);
                 }
                 break;
             case '%':
                 dopr_outch('%', target);
                 break;
             default:
  
                 /*
                  * Anything else --- in particular, '\0' indicating end of
                  * format string --- is bogus.
                  */
                 goto bad_format;
         }
  
         /* Check for failure after each conversion spec */
         if (target->failed)
             break;
     }
  
     return;
  
 bad_format:
     errno = EINVAL;
     target->failed = true;
 }

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 1414 of file snprintf.c.

 {
     if (target->bufend != NULL && target->bufptr >= target->bufend)
     {
         /* buffer full, can we dump to stream? */
         if (target->stream == NULL)
         {
             target->nchars++;   /* no, lose the data */
             return;
         }
         flushbuffer(target);
     }
     *(target->bufptr++) = c;
 }

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 1430 of file snprintf.c.

 {
     /* fast path for common case of slen == 1 */
     if (slen == 1)
     {
         dopr_outch(c, target);
         return;
     }
  
     while (slen > 0)
     {
         int         avail;
  
         if (target->bufend != NULL)
             avail = target->bufend - target->bufptr;
         else
             avail = slen;
         if (avail <= 0)
         {
             /* buffer full, can we dump to stream? */
             if (target->stream == NULL)
             {
                 target->nchars += slen; /* no, lose the data */
                 return;
             }
             flushbuffer(target);
             continue;
         }
         avail = Min(avail, slen);
         memset(target->bufptr, c, avail);
         target->bufptr += avail;
         slen -= avail;
     }
 }

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 1377 of file snprintf.c.

 {
     /* fast path for common case of slen == 1 */
     if (slen == 1)
     {
         dopr_outch(*str, target);
         return;
     }
  
     while (slen > 0)
     {
         int         avail;
  
         if (target->bufend != NULL)
             avail = target->bufend - target->bufptr;
         else
             avail = slen;
         if (avail <= 0)
         {
             /* buffer full, can we dump to stream? */
             if (target->stream == NULL)
             {
                 target->nchars += slen; /* no, lose the data */
                 return;
             }
             flushbuffer(target);
             continue;
         }
         avail = Min(avail, slen);
         memmove(target->bufptr, str, avail);
         target->bufptr += avail;
         str += avail;
         slen -= avail;
     }
 }

References PrintfTarget::bufend, PrintfTarget::bufptr, dopr_outch(), flushbuffer(), Min, PrintfTarget::nchars, 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.

 {
     int         ch;
     bool        afterstar;
     int         accum;
     int         longlongflag;
     int         longflag;
     int         fmtpos;
     int         i;
     int         last_dollar = 0;    /* Init to "no dollar arguments known" */
     PrintfArgType argtypes[PG_NL_ARGMAX + 1] = {0};
  
     /*
      * This loop must accept the same format strings as the one in dopr().
      * However, we don't need to analyze them to the same level of detail.
      *
      * Since we're only called if there's a dollar-type spec somewhere, we can
      * fail immediately if we find a non-dollar spec.  Per the C99 standard,
      * all argument references in the format string must be one or the other.
      */
     while (*format != '\0')
     {
         /* Locate next conversion specifier */
         if (*format != '%')
         {
             /* Unlike dopr, we can just quit if there's no more specifiers */
             format = strchr(format + 1, '%');
             if (format == NULL)
                 break;
         }
  
         /* Process conversion spec starting at *format */
         format++;
         longflag = longlongflag = 0;
         fmtpos = accum = 0;
         afterstar = false;
 nextch1:
         ch = *format++;
         switch (ch)
         {
             case '-':
             case '+':
                 goto nextch1;
             case '0':
             case '1':
             case '2':
             case '3':
             case '4':
             case '5':
             case '6':
             case '7':
             case '8':
             case '9':
                 accum = accum * 10 + (ch - '0');
                 goto nextch1;
             case '.':
                 accum = 0;
                 goto nextch1;
             case '*':
                 if (afterstar)
                     return false;   /* previous star missing dollar */
                 afterstar = true;
                 accum = 0;
                 goto nextch1;
             case '$':
                 if (accum <= 0 || accum > PG_NL_ARGMAX)
                     return false;
                 if (afterstar)
                 {
                     if (argtypes[accum] &&
                         argtypes[accum] != ATYPE_INT)
                         return false;
                     argtypes[accum] = ATYPE_INT;
                     last_dollar = Max(last_dollar, accum);
                     afterstar = false;
                 }
                 else
                     fmtpos = accum;
                 accum = 0;
                 goto nextch1;
             case 'l':
                 if (longflag)
                     longlongflag = 1;
                 else
                     longflag = 1;
                 goto nextch1;
             case 'z':
 #if SIZEOF_SIZE_T == 8
 #ifdef HAVE_LONG_INT_64
                 longflag = 1;
 #elif defined(HAVE_LONG_LONG_INT_64)
                 longlongflag = 1;
 #else
 #error "Don't know how to print 64bit integers"
 #endif
 #else
                 /* assume size_t is same size as int */
 #endif
                 goto nextch1;
             case 'h':
             case '\'':
                 /* ignore these */
                 goto nextch1;
             case 'd':
             case 'i':
             case 'o':
             case 'u':
             case 'x':
             case 'X':
                 if (fmtpos)
                 {
                     PrintfArgType atype;
  
                     if (longlongflag)
                         atype = ATYPE_LONGLONG;
                     else if (longflag)
                         atype = ATYPE_LONG;
                     else
                         atype = ATYPE_INT;
                     if (argtypes[fmtpos] &&
                         argtypes[fmtpos] != atype)
                         return false;
                     argtypes[fmtpos] = atype;
                     last_dollar = Max(last_dollar, fmtpos);
                 }
                 else
                     return false;   /* non-dollar conversion spec */
                 break;
             case 'c':
                 if (fmtpos)
                 {
                     if (argtypes[fmtpos] &&
                         argtypes[fmtpos] != ATYPE_INT)
                         return false;
                     argtypes[fmtpos] = ATYPE_INT;
                     last_dollar = Max(last_dollar, fmtpos);
                 }
                 else
                     return false;   /* non-dollar conversion spec */
                 break;
             case 's':
             case 'p':
                 if (fmtpos)
                 {
                     if (argtypes[fmtpos] &&
                         argtypes[fmtpos] != ATYPE_CHARPTR)
                         return false;
                     argtypes[fmtpos] = ATYPE_CHARPTR;
                     last_dollar = Max(last_dollar, fmtpos);
                 }
                 else
                     return false;   /* non-dollar conversion spec */
                 break;
             case 'e':
             case 'E':
             case 'f':
             case 'g':
             case 'G':
                 if (fmtpos)
                 {
                     if (argtypes[fmtpos] &&
                         argtypes[fmtpos] != ATYPE_DOUBLE)
                         return false;
                     argtypes[fmtpos] = ATYPE_DOUBLE;
                     last_dollar = Max(last_dollar, fmtpos);
                 }
                 else
                     return false;   /* non-dollar conversion spec */
                 break;
             case 'm':
             case '%':
                 break;
             default:
                 return false;   /* bogus format string */
         }
  
         /*
          * If we finish the spec with afterstar still set, there's a
          * non-dollar star in there.
          */
         if (afterstar)
             return false;       /* non-dollar conversion spec */
     }
  
     /*
      * Format appears valid so far, so collect the arguments in physical
      * order.  (Since we rejected any non-dollar specs that would have
      * collected arguments, we know that dopr() hasn't collected any yet.)
      */
     for (i = 1; i <= last_dollar; i++)
     {
         switch (argtypes[i])
         {
             case ATYPE_NONE:
                 return false;
             case ATYPE_INT:
                 argvalues[i].i = va_arg(args, int);
                 break;
             case ATYPE_LONG:
                 argvalues[i].l = va_arg(args, long);
                 break;
             case ATYPE_LONGLONG:
                 argvalues[i].ll = va_arg(args, long long);
                 break;
             case ATYPE_DOUBLE:
                 argvalues[i].d = va_arg(args, double);
                 break;
             case ATYPE_CHARPTR:
                 argvalues[i].cptr = va_arg(args, char *);
                 break;
         }
     }
  
     return true;
 }

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, and PG_NL_ARGMAX.

Referenced by dopr().

◆ flushbuffer()

static void flushbuffer ( PrintfTarget * target )

static

Definition at line 298 of file snprintf.c.

 {
     size_t      nc = target->bufptr - target->bufstart;
  
     /*
      * Don't write anything if we already failed; this is to ensure we
      * preserve the original failure's errno.
      */
     if (!target->failed && nc > 0)
     {
         size_t      written;
  
         written = fwrite(target->bufstart, 1, nc, target->stream);
         target->nchars += written;
         if (written != nc)
             target->failed = true;
     }
     target->bufptr = target->bufstart;
 }

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 1121 of file snprintf.c.

 {
     int         padlen;         /* amount to pad */
  
     padlen = compute_padlen(minlen, 1, leftjust);
  
     if (padlen > 0)
     {
         dopr_outchmulti(' ', padlen, target);
         padlen = 0;
     }
  
     dopr_outch(value, target);
  
     trailing_pad(padlen, target);
 }

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 1139 of file snprintf.c.

 {
     int         signvalue = 0;
     int         prec;
     int         vallen;
     char        fmt[8];
     char        convert[1024];
     int         zeropadlen = 0; /* amount to pad with zeroes */
     int         padlen;         /* amount to pad with spaces */
  
     /*
      * We rely on the regular C library's snprintf to do the basic conversion,
      * then handle padding considerations here.
      *
      * The dynamic range of "double" is about 1E+-308 for IEEE math, and not
      * too wildly more than that with other hardware.  In "f" format, snprintf
      * could therefore generate at most 308 characters to the left of the
      * decimal point; while we need to allow the precision to get as high as
      * 308+17 to ensure that we don't truncate significant digits from very
      * small values.  To handle both these extremes, we use a buffer of 1024
      * bytes and limit requested precision to 350 digits; this should prevent
      * buffer overrun even with non-IEEE math.  If the original precision
      * request was more than 350, separately pad with zeroes.
      *
      * We handle infinities and NaNs specially to ensure platform-independent
      * output.
      */
     if (precision < 0)          /* cover possible overflow of "accum" */
         precision = 0;
     prec = Min(precision, 350);
  
     if (isnan(value))
     {
         strcpy(convert, "NaN");
         vallen = 3;
         /* no zero padding, regardless of precision spec */
     }
     else
     {
         /*
          * Handle sign (NaNs have no sign, so we don't do this in the case
          * above).  "value < 0.0" will not be true for IEEE minus zero, so we
          * detect that by looking for the case where value equals 0.0
          * according to == but not according to memcmp.
          */
         static const double dzero = 0.0;
  
         if (adjust_sign((value < 0.0 ||
                          (value == 0.0 &&
                           memcmp(&value, &dzero, sizeof(double)) != 0)),
                         forcesign, &signvalue))
             value = -value;
  
         if (isinf(value))
         {
             strcpy(convert, "Infinity");
             vallen = 8;
             /* no zero padding, regardless of precision spec */
         }
         else if (pointflag)
         {
             zeropadlen = precision - prec;
             fmt[0] = '%';
             fmt[1] = '.';
             fmt[2] = '*';
             fmt[3] = type;
             fmt[4] = '\0';
             vallen = snprintf(convert, sizeof(convert), fmt, prec, value);
         }
         else
         {
             fmt[0] = '%';
             fmt[1] = type;
             fmt[2] = '\0';
             vallen = snprintf(convert, sizeof(convert), fmt, value);
         }
         if (vallen < 0)
             goto fail;
  
         /*
          * Windows, alone among our supported platforms, likes to emit
          * three-digit exponent fields even when two digits would do.  Hack
          * such results to look like the way everyone else does it.
          */
 #ifdef WIN32
         if (vallen >= 6 &&
             convert[vallen - 5] == 'e' &&
             convert[vallen - 3] == '0')
         {
             convert[vallen - 3] = convert[vallen - 2];
             convert[vallen - 2] = convert[vallen - 1];
             vallen--;
         }
 #endif
     }
  
     padlen = compute_padlen(minlen, vallen + zeropadlen, leftjust);
  
     leading_pad(zpad, signvalue, &padlen, target);
  
     if (zeropadlen > 0)
     {
         /* If 'e' or 'E' format, inject zeroes before the exponent */
         char       *epos = strrchr(convert, 'e');
  
         if (!epos)
             epos = strrchr(convert, 'E');
         if (epos)
         {
             /* pad before exponent */
             dostr(convert, epos - convert, target);
             dopr_outchmulti('0', zeropadlen, target);
             dostr(epos, vallen - (epos - convert), target);
         }
         else
         {
             /* no exponent, pad after the digits */
             dostr(convert, vallen, target);
             dopr_outchmulti('0', zeropadlen, target);
         }
     }
     else
     {
         /* no zero padding, just emit the number as-is */
         dostr(convert, vallen, target);
     }
  
     trailing_pad(padlen, target);
     return;
  
 fail:
     target->failed = true;
 }

References adjust_sign(), compute_padlen(), convert(), dopr_outchmulti(), dostr(), PrintfTarget::failed, fmt, leading_pad(), Min, snprintf, trailing_pad(), 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 1010 of file snprintf.c.

 {
     unsigned long long uvalue;
     int         base;
     int         dosign;
     const char *cvt = "0123456789abcdef";
     int         signvalue = 0;
     char        convert[64];
     int         vallen = 0;
     int         padlen;         /* amount to pad */
     int         zeropad;        /* extra leading zeroes */
  
     switch (type)
     {
         case 'd':
         case 'i':
             base = 10;
             dosign = 1;
             break;
         case 'o':
             base = 8;
             dosign = 0;
             break;
         case 'u':
             base = 10;
             dosign = 0;
             break;
         case 'x':
             base = 16;
             dosign = 0;
             break;
         case 'X':
             cvt = "0123456789ABCDEF";
             base = 16;
             dosign = 0;
             break;
         default:
             return;             /* keep compiler quiet */
     }
  
     /* disable MSVC warning about applying unary minus to an unsigned value */
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable: 4146)
 #endif
     /* Handle +/- */
     if (dosign && adjust_sign((value < 0), forcesign, &signvalue))
         uvalue = -(unsigned long long) value;
     else
         uvalue = (unsigned long long) value;
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
  
     /*
      * SUS: the result of converting 0 with an explicit precision of 0 is no
      * characters
      */
     if (value == 0 && pointflag && precision == 0)
         vallen = 0;
     else
     {
         /*
          * Convert integer to string.  We special-case each of the possible
          * base values so as to avoid general-purpose divisions.  On most
          * machines, division by a fixed constant can be done much more
          * cheaply than a general divide.
          */
         if (base == 10)
         {
             do
             {
                 convert[sizeof(convert) - (++vallen)] = cvt[uvalue % 10];
                 uvalue = uvalue / 10;
             } while (uvalue);
         }
         else if (base == 16)
         {
             do
             {
                 convert[sizeof(convert) - (++vallen)] = cvt[uvalue % 16];
                 uvalue = uvalue / 16;
             } while (uvalue);
         }
         else                    /* base == 8 */
         {
             do
             {
                 convert[sizeof(convert) - (++vallen)] = cvt[uvalue % 8];
                 uvalue = uvalue / 8;
             } while (uvalue);
         }
     }
  
     zeropad = Max(0, precision - vallen);
  
     padlen = compute_padlen(minlen, vallen + zeropad, leftjust);
  
     leading_pad(zpad, signvalue, &padlen, target);
  
     if (zeropad > 0)
         dopr_outchmulti('0', zeropad, target);
  
     dostr(convert + sizeof(convert) - vallen, vallen, target);
  
     trailing_pad(padlen, target);
 }

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

Referenced by dopr().

◆ fmtptr()

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

static

Definition at line 996 of file snprintf.c.

 {
     int         vallen;
     char        convert[64];
  
     /* we rely on regular C library's snprintf to do the basic conversion */
     vallen = snprintf(convert, sizeof(convert), "%p", value);
     if (vallen < 0)
         target->failed = true;
     else
         dostr(convert, vallen, target);
 }

References convert(), dostr(), PrintfTarget::failed, snprintf, 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 967 of file snprintf.c.

 {
     int         padlen,
                 vallen;         /* amount to pad */
  
     /*
      * If a maxwidth (precision) is specified, we must not fetch more bytes
      * than that.
      */
     if (pointflag)
         vallen = strnlen(value, maxwidth);
     else
         vallen = strlen(value);
  
     padlen = compute_padlen(minlen, vallen, leftjust);
  
     if (padlen > 0)
     {
         dopr_outchmulti(' ', padlen, target);
         padlen = 0;
     }
  
     dostr(value, vallen, target);
  
     trailing_pad(padlen, target);
 }

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 1495 of file snprintf.c.

 {
     int         maxpad;
  
     if (*padlen > 0 && zpad)
     {
         if (signvalue)
         {
             dopr_outch(signvalue, target);
             --(*padlen);
             signvalue = 0;
         }
         if (*padlen > 0)
         {
             dopr_outchmulti(zpad, *padlen, target);
             *padlen = 0;
         }
     }
     maxpad = (signvalue != 0);
     if (*padlen > maxpad)
     {
         dopr_outchmulti(' ', *padlen - maxpad, target);
         *padlen = maxpad;
     }
     if (signvalue)
     {
         dopr_outch(signvalue, target);
         if (*padlen > 0)
             --(*padlen);
         else if (*padlen < 0)
             ++(*padlen);
     }
 }

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.

 {
     int         len;
     va_list     args;
  
     va_start(args, fmt);
     len = pg_vfprintf(stream, fmt, args);
     va_end(args);
     return len;
 }

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.

 {
     int         len;
     va_list     args;
  
     va_start(args, fmt);
     len = pg_vfprintf(stdout, fmt, args);
     va_end(args);
     return len;
 }

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.

 {
     int         len;
     va_list     args;
  
     va_start(args, fmt);
     len = pg_vsnprintf(str, count, fmt, args);
     va_end(args);
     return len;
 }

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

◆ pg_sprintf()

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

Definition at line 230 of file snprintf.c.

 {
     int         len;
     va_list     args;
  
     va_start(args, fmt);
     len = pg_vsprintf(str, fmt, args);
     va_end(args);
     return len;
 }

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

◆ pg_strfromd()

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

Definition at line 1285 of file snprintf.c.

 {
     PrintfTarget target;
     int         signvalue = 0;
     int         vallen;
     char        fmt[8];
     char        convert[64];
  
     /* Set up the target like pg_snprintf, but require nonempty buffer */
     Assert(count > 0);
     target.bufstart = target.bufptr = str;
     target.bufend = str + count - 1;
     target.stream = NULL;
     target.nchars = 0;
     target.failed = false;
  
     /*
      * We bound precision to a reasonable range; the combination of this and
      * the knowledge that we're using "g" format without padding allows the
      * convert[] buffer to be reasonably small.
      */
     if (precision < 1)
         precision = 1;
     else if (precision > 32)
         precision = 32;
  
     /*
      * The rest is just an inlined version of the fmtfloat() logic above,
      * simplified using the knowledge that no padding is wanted.
      */
     if (isnan(value))
     {
         strcpy(convert, "NaN");
         vallen = 3;
     }
     else
     {
         static const double dzero = 0.0;
  
         if (value < 0.0 ||
             (value == 0.0 &&
              memcmp(&value, &dzero, sizeof(double)) != 0))
         {
             signvalue = '-';
             value = -value;
         }
  
         if (isinf(value))
         {
             strcpy(convert, "Infinity");
             vallen = 8;
         }
         else
         {
             fmt[0] = '%';
             fmt[1] = '.';
             fmt[2] = '*';
             fmt[3] = 'g';
             fmt[4] = '\0';
             vallen = snprintf(convert, sizeof(convert), fmt, precision, value);
             if (vallen < 0)
             {
                 target.failed = true;
                 goto fail;
             }
  
 #ifdef WIN32
             if (vallen >= 6 &&
                 convert[vallen - 5] == 'e' &&
                 convert[vallen - 3] == '0')
             {
                 convert[vallen - 3] = convert[vallen - 2];
                 convert[vallen - 2] = convert[vallen - 1];
                 vallen--;
             }
 #endif
         }
     }
  
     if (signvalue)
         dopr_outch(signvalue, &target);
  
     dostr(convert, vallen, &target);
  
 fail:
     *(target.bufptr) = '\0';
     return target.failed ? -1 : (target.bufptr - target.bufstart
                                  + target.nchars);
 }

References Assert, PrintfTarget::bufend, PrintfTarget::bufptr, PrintfTarget::bufstart, convert(), dopr_outch(), dostr(), PrintfTarget::failed, fmt, PrintfTarget::nchars, snprintf, 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.

 {
     PrintfTarget target;
     char        buffer[1024];   /* size is arbitrary */
  
     if (stream == NULL)
     {
         errno = EINVAL;
         return -1;
     }
     target.bufstart = target.bufptr = buffer;
     target.bufend = buffer + sizeof(buffer);    /* use the whole buffer */
     target.stream = stream;
     target.nchars = 0;
     target.failed = false;
     dopr(&target, fmt, args);
     /* dump any remaining buffer contents */
     flushbuffer(&target);
     return target.failed ? -1 : target.nchars;
 }

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.

 {
     return pg_vfprintf(stdout, fmt, args);
 }

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.

 {
     PrintfTarget target;
     char        onebyte[1];
  
     /*
      * C99 allows the case str == NULL when count == 0.  Rather than
      * special-casing this situation further down, we substitute a one-byte
      * local buffer.  Callers cannot tell, since the function result doesn't
      * depend on count.
      */
     if (count == 0)
     {
         str = onebyte;
         count = 1;
     }
     target.bufstart = target.bufptr = str;
     target.bufend = str + count - 1;
     target.stream = NULL;
     target.nchars = 0;
     target.failed = false;
     dopr(&target, fmt, args);
     *(target.bufptr) = '\0';
     return target.failed ? -1 : (target.bufptr - target.bufstart
                                  + target.nchars);
 }

References generate_unaccent_rules::args, PrintfTarget::bufend, PrintfTarget::bufptr, PrintfTarget::bufstart, dopr(), PrintfTarget::failed, fmt, PrintfTarget::nchars, 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.

 {
     PrintfTarget target;
  
     target.bufstart = target.bufptr = str;
     target.bufend = NULL;
     target.stream = NULL;
     target.nchars = 0;          /* not really used in this case */
     target.failed = false;
     dopr(&target, fmt, args);
     *(target.bufptr) = '\0';
     return target.failed ? -1 : (target.bufptr - target.bufstart
                                  + target.nchars);
 }

References generate_unaccent_rules::args, PrintfTarget::bufend, PrintfTarget::bufptr, PrintfTarget::bufstart, dopr(), PrintfTarget::failed, fmt, PrintfTarget::nchars, 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.

 {
     while (*s != '\0' && *s != c)
         s++;
     return s;
 }

Referenced by dopr().

◆ trailing_pad()

static void trailing_pad	(	int	padlen,
		PrintfTarget *	target
	)

static

Definition at line 1531 of file snprintf.c.

 {
     if (padlen < 0)
         dopr_outchmulti(' ', -padlen, target);
 }

References dopr_outchmulti().

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

Data Structures

Macros

Enumerations

Functions

Macro Definition Documentation

◆ PG_NL_ARGMAX

Enumeration Type Documentation

◆ PrintfArgType

Function Documentation

◆ adjust_sign()

◆ compute_padlen()

◆ dopr()

◆ dopr_outch()

◆ dopr_outchmulti()

◆ dostr()

◆ find_arguments()

◆ flushbuffer()

◆ fmtchar()

◆ fmtfloat()

◆ fmtint()

◆ fmtptr()

◆ fmtstr()

◆ leading_pad()

◆ pg_fprintf()

◆ pg_printf()

◆ pg_snprintf()

◆ pg_sprintf()

◆ pg_strfromd()

◆ pg_vfprintf()

◆ pg_vprintf()

◆ pg_vsnprintf()

◆ pg_vsprintf()

◆ strchrnul()

◆ trailing_pad()