* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- * must display the following acknowledgement:
- * This product includes software developed by the University of
- * California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
+ *
+ * src/port/snprintf.c
*/
-#ifndef FRONTEND
-#include "postgres.h"
-#else
-#include "postgres_fe.h"
-#endif
+#include "c.h"
+#include <ctype.h>
+#ifdef _MSC_VER
+#include <float.h> /* for _isnan */
+#endif
+#include <limits.h>
+#include <math.h>
#ifndef WIN32
#include <sys/ioctl.h>
#endif
#include <sys/param.h>
+#ifndef NL_ARGMAX
+#define NL_ARGMAX 16
+#endif
+
+
/*
-** SNPRINTF, VSNPRINT -- counted versions of printf
-**
-** These versions have been grabbed off the net. They have been
-** cleaned up to compile properly and support for .precision and
-** %lx has been added.
-*/
+ * SNPRINTF, VSNPRINTF and friends
+ *
+ * These versions have been grabbed off the net. They have been
+ * cleaned up to compile properly and support for most of the Single Unix
+ * Specification has been added. Remaining unimplemented features are:
+ *
+ * 1. No locale support: the radix character is always '.' and the '
+ * (single quote) format flag is ignored.
+ *
+ * 2. No support for the "%n" format specification.
+ *
+ * 3. No support for wide characters ("lc" and "ls" formats).
+ *
+ * 4. No support for "long double" ("Lf" and related formats).
+ *
+ * 5. Space and '#' flags are not implemented.
+ *
+ *
+ * The result values of these functions are not the same across different
+ * platforms. This implementation is compatible with the Single Unix Spec:
+ *
+ * 1. -1 is returned only if processing is abandoned due to an invalid
+ * parameter, such as incorrect format string. (Although not required by
+ * the spec, this happens only when no characters have yet been transmitted
+ * to the destination.)
+ *
+ * 2. For snprintf and sprintf, 0 is returned if str == NULL or count == 0;
+ * no data has been stored.
+ *
+ * 3. Otherwise, the number of bytes actually transmitted to the destination
+ * is returned (excluding the trailing '\0' for snprintf and sprintf).
+ *
+ * For snprintf with nonzero count, the result cannot be more than count-1
+ * (a trailing '\0' is always stored); it is not possible to distinguish
+ * buffer overrun from exact fit. This is unlike some implementations that
+ * return the number of bytes that would have been needed for the complete
+ * result string.
+ */
/**************************************************************
* Original:
* Patrick Powell Tue Apr 11 09:48:21 PDT 1995
* A bombproof version of doprnt (dopr) included.
- * Sigh. This sort of thing is always nasty do deal with. Note that
+ * Sigh. This sort of thing is always nasty do deal with. Note that
* the version here does not include floating point. (now it does ... tgl)
- *
- * snprintf() is used instead of sprintf() as it does limit checks
- * for string length. This covers a nasty loophole.
- *
- * The other functions are there to prevent NULL pointers from
- * causing nasty effects.
**************************************************************/
-/*static char _id[] = "$PostgreSQL: pgsql/src/port/snprintf.c,v 1.20 2005/03/16 06:00:58 momjian Exp $";*/
-
-int pg_snprintf(char *str, size_t count, const char *fmt,...);
-int pg_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
-int pg_printf(const char *format, ...);
-static void dopr(char *buffer, const char *format, va_list args, char *end);
-
/* Prevent recursion */
#undef vsnprintf
#undef snprintf
+#undef sprintf
+#undef vfprintf
#undef fprintf
#undef printf
+/* Info about where the formatted output is going */
+typedef struct
+{
+ char *bufptr; /* next buffer output position */
+ char *bufstart; /* first buffer element */
+ char *bufend; /* last buffer element, or NULL */
+ /* bufend == NULL is for sprintf, where we assume buf is big enough */
+ FILE *stream; /* eventual output destination, or NULL */
+ int nchars; /* # chars already sent to stream */
+ bool failed; /* call is a failure; errno is set */
+} PrintfTarget;
+
+/*
+ * Info about the type and value of a formatting parameter. Note that we
+ * don't currently support "long double", "wint_t", or "wchar_t *" data,
+ * nor the '%n' formatting code; else we'd need more types. Also, at this
+ * level we need not worry about signed vs unsigned values.
+ */
+typedef enum
+{
+ ATYPE_NONE = 0,
+ ATYPE_INT,
+ ATYPE_LONG,
+ ATYPE_LONGLONG,
+ ATYPE_DOUBLE,
+ ATYPE_CHARPTR
+} PrintfArgType;
+
+typedef union
+{
+ int i;
+ long l;
+ int64 ll;
+ double d;
+ char *cptr;
+} PrintfArgValue;
+
+
+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)
{
- char *end;
- str[0] = '\0';
- end = str + count - 1;
- dopr(str, fmt, args, end);
- if (count > 0)
- end[0] = '\0';
- return strlen(str);
+ PrintfTarget target;
+
+ if (str == NULL || count == 0)
+ return 0;
+ target.bufstart = target.bufptr = str;
+ target.bufend = str + count - 1;
+ target.stream = NULL;
+ /* target.nchars is unused in this case */
+ target.failed = false;
+ dopr(&target, fmt, args);
+ *(target.bufptr) = '\0';
+ return target.failed ? -1 : (target.bufptr - target.bufstart);
}
int
return len;
}
+static int
+pg_vsprintf(char *str, const char *fmt, va_list args)
+{
+ PrintfTarget target;
+
+ if (str == NULL)
+ return 0;
+ target.bufstart = target.bufptr = str;
+ target.bufend = NULL;
+ target.stream = NULL;
+ /* target.nchars is unused in this case */
+ target.failed = false;
+ dopr(&target, fmt, args);
+ *(target.bufptr) = '\0';
+ return target.failed ? -1 : (target.bufptr - target.bufstart);
+}
+
+int
+pg_sprintf(char *str, const char *fmt,...)
+{
+ int len;
+ va_list args;
+
+ va_start(args, fmt);
+ len = pg_vsprintf(str, fmt, args);
+ va_end(args);
+ return len;
+}
+
+int
+pg_vfprintf(FILE *stream, const char *fmt, va_list args)
+{
+ 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) - 1;
+ 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;
+}
+
int
pg_fprintf(FILE *stream, const char *fmt,...)
{
int len;
va_list args;
- char* buffer[4096];
- char* p;
va_start(args, fmt);
- len = pg_vsnprintf((char*)buffer, (size_t)4096, fmt, args);
+ len = pg_vfprintf(stream, fmt, args);
va_end(args);
- p = (char*)buffer;
- for( ;*p; p++)
- putc(*p, stream);
return len;
}
{
int len;
va_list args;
- char* buffer[4096];
- char* p;
va_start(args, fmt);
- len = pg_vsnprintf((char*)buffer, (size_t)4096, fmt, args);
+ len = pg_vfprintf(stdout, fmt, args);
va_end(args);
- p = (char*)buffer;
- for( ;*p; p++)
- putchar(*p);
return len;
}
/*
- * dopr(): poor man's version of doprintf
+ * Attempt to write the entire buffer to target->stream; discard the entire
+ * buffer in any case. Call this only when target->stream is defined.
*/
+static void
+flushbuffer(PrintfTarget *target)
+{
+ size_t nc = target->bufptr - target->bufstart;
+
+ 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;
+}
+
-static void fmtstr(char *value, int ljust, int len, int zpad, int maxwidth,
- char *end, char **output);
-static void fmtnum(int64 value, int base, int dosign, int ljust, int len,
- int zpad, char *end, char **output);
-static void fmtfloat(double value, char type, int ljust, int len,
- int precision, int pointflag, char *end, char **output);
-static void dostr(char *str, int cut, char *end, char **output);
-static void dopr_outch(int c, char *end, char **output);
-
-#define FMTSTR 1
-#define FMTNUM 2
-#define FMTNUM_U 3
-#define FMTFLOAT 4
-#define FMTCHAR 5
-#define FMTWIDTH 6
-#define FMTLEN 7
+static void fmtstr(char *value, int leftjust, int minlen, int maxwidth,
+ int pointflag, PrintfTarget *target);
+static void fmtptr(void *value, PrintfTarget *target);
+static void fmtint(int64 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 int adjust_sign(int is_negative, int forcesign, int *signvalue);
+static void adjust_padlen(int minlen, int vallen, int leftjust, int *padlen);
+static void leading_pad(int zpad, int *signvalue, int *padlen,
+ PrintfTarget *target);
+static void trailing_pad(int *padlen, PrintfTarget *target);
+
+/*
+ * dopr(): poor man's version of doprintf
+ */
static void
-dopr(char *buffer, const char *format, va_list args, char *end)
+dopr(PrintfTarget *target, const char *format, va_list args)
{
+ const char *format_start = format;
int ch;
- int longlongflag = 0;
- int longflag = 0;
- int pointflag = 0;
- int maxwidth = 0;
- int ljust;
- int len;
+ bool have_dollar;
+ bool have_non_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 last_dollar;
+ int fmtpos;
+ int cvalue;
+ int64 numvalue;
+ double fvalue;
+ char *strvalue;
int i;
- const char* format_save;
- const char* fmtbegin;
- int fmtpos = 1;
- int realpos = 0;
- int precision;
- int position;
- char *output;
- int percents = 1;
- const char *p;
- struct fmtpar {
- const char* fmtbegin;
- const char* fmtend;
- void* value;
- int64 numvalue;
- double fvalue;
- int charvalue;
- int ljust;
- int len;
- int zpad;
- int maxwidth;
- int base;
- int dosign;
- char type;
- int precision;
- int pointflag;
- char func;
- int realpos;
- int longflag;
- int longlongflag;
- } *fmtpar, **fmtparptr;
-
- /* Create enough structures to hold all arguments */
- for (p = format; *p != '\0'; p++)
- if (*p == '%') /* counts %% as two, so overcounts */
- percents++;
-#ifndef FRONTEND
- fmtpar = pgport_palloc(sizeof(struct fmtpar) * percents);
- fmtparptr = pgport_palloc(sizeof(struct fmtpar *) * percents);
-#else
- if ((fmtpar = malloc(sizeof(struct fmtpar) * percents)) == NULL)
+ PrintfArgType argtypes[NL_ARGMAX + 1];
+ PrintfArgValue argvalues[NL_ARGMAX + 1];
+
+ /*
+ * Parse the format string to determine whether there are %n$ format
+ * specs, and identify the types and order of the format parameters.
+ */
+ have_dollar = have_non_dollar = false;
+ last_dollar = 0;
+ MemSet(argtypes, 0, sizeof(argtypes));
+
+ while ((ch = *format++) != '\0')
{
- fprintf(stderr, _("out of memory\n"));
- exit(1);
+ if (ch != '%')
+ continue;
+ longflag = longlongflag = pointflag = 0;
+ fmtpos = accum = 0;
+ afterstar = false;
+nextch1:
+ ch = *format++;
+ if (ch == '\0')
+ break; /* illegal, but we don't complain */
+ 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 '.':
+ pointflag = 1;
+ accum = 0;
+ goto nextch1;
+ case '*':
+ if (afterstar)
+ have_non_dollar = true; /* multiple stars */
+ afterstar = true;
+ accum = 0;
+ goto nextch1;
+ case '$':
+ have_dollar = true;
+ if (accum <= 0 || accum > NL_ARGMAX)
+ goto bad_format;
+ if (afterstar)
+ {
+ if (argtypes[accum] &&
+ argtypes[accum] != ATYPE_INT)
+ goto bad_format;
+ 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)
+ goto bad_format;
+ argtypes[fmtpos] = atype;
+ last_dollar = Max(last_dollar, fmtpos);
+ }
+ else
+ have_non_dollar = true;
+ break;
+ case 'c':
+ if (fmtpos)
+ {
+ if (argtypes[fmtpos] &&
+ argtypes[fmtpos] != ATYPE_INT)
+ goto bad_format;
+ argtypes[fmtpos] = ATYPE_INT;
+ last_dollar = Max(last_dollar, fmtpos);
+ }
+ else
+ have_non_dollar = true;
+ break;
+ case 's':
+ case 'p':
+ if (fmtpos)
+ {
+ if (argtypes[fmtpos] &&
+ argtypes[fmtpos] != ATYPE_CHARPTR)
+ goto bad_format;
+ argtypes[fmtpos] = ATYPE_CHARPTR;
+ last_dollar = Max(last_dollar, fmtpos);
+ }
+ else
+ have_non_dollar = true;
+ break;
+ case 'e':
+ case 'E':
+ case 'f':
+ case 'g':
+ case 'G':
+ if (fmtpos)
+ {
+ if (argtypes[fmtpos] &&
+ argtypes[fmtpos] != ATYPE_DOUBLE)
+ goto bad_format;
+ argtypes[fmtpos] = ATYPE_DOUBLE;
+ last_dollar = Max(last_dollar, fmtpos);
+ }
+ else
+ have_non_dollar = true;
+ break;
+ case '%':
+ break;
+ }
+
+ /*
+ * If we finish the spec with afterstar still set, there's a
+ * non-dollar star in there.
+ */
+ if (afterstar)
+ have_non_dollar = true;
}
- if ((fmtparptr = malloc(sizeof(struct fmtpar *) * percents)) == NULL)
+
+ /* Per spec, you use either all dollar or all not. */
+ if (have_dollar && have_non_dollar)
+ goto bad_format;
+
+ /*
+ * In dollar mode, collect the arguments in physical order.
+ */
+ for (i = 1; i <= last_dollar; i++)
{
- fprintf(stderr, _("out of memory\n"));
- exit(1);
+ switch (argtypes[i])
+ {
+ case ATYPE_NONE:
+ goto bad_format;
+ 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, int64);
+ break;
+ case ATYPE_DOUBLE:
+ argvalues[i].d = va_arg(args, double);
+ break;
+ case ATYPE_CHARPTR:
+ argvalues[i].cptr = va_arg(args, char *);
+ break;
+ }
}
-#endif
-
- format_save = format;
- output = buffer;
- while ((ch = *format++))
+ /*
+ * At last we can parse the format for real.
+ */
+ format = format_start;
+ while ((ch = *format++) != '\0')
{
+ if (target->failed)
+ break;
+
+ if (ch != '%')
+ {
+ dopr_outch(ch, target);
+ continue;
+ }
+ fieldwidth = precision = zpad = leftjust = forcesign = 0;
+ longflag = longlongflag = pointflag = 0;
+ fmtpos = accum = 0;
+ have_star = afterstar = false;
+nextch2:
+ ch = *format++;
+ if (ch == '\0')
+ break; /* illegal, but we don't complain */
switch (ch)
{
- case '%':
- ljust = len = zpad = maxwidth = 0;
- longflag = longlongflag = pointflag = 0;
- fmtbegin = format - 1;
- realpos = 0;
- position = precision = 0;
- nextch:
- 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)
+ {
+ /* process value after reading n$ */
+ afterstar = true;
+ }
+ else
{
- case '\0':
- goto performpr;
- case '-':
- ljust = 1;
- goto nextch;
- case '0': /* set zero padding if len not set */
- if (len == 0 && !pointflag)
- zpad = '0';
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- if (!pointflag)
- {
- len = len * 10 + ch - '0';
- position = position * 10 + ch - '0';
+ /* fetch and process value now */
+ int starval = va_arg(args, int);
+
+ if (pointflag)
+ {
+ precision = starval;
+ if (precision < 0)
+ {
+ precision = 0;
+ pointflag = 0;
}
- else
+ }
+ else
+ {
+ fieldwidth = starval;
+ if (fieldwidth < 0)
{
- maxwidth = maxwidth * 10 + ch - '0';
- precision = precision * 10 + ch - '0';
+ leftjust = 1;
+ fieldwidth = -fieldwidth;
}
- goto nextch;
- case '$':
- realpos = position;
- len = 0;
- goto nextch;
- case '*':
- MemSet(&fmtpar[fmtpos], 0, sizeof(fmtpar[fmtpos]));
- if (!pointflag)
- fmtpar[fmtpos].func = FMTLEN;
- else
- fmtpar[fmtpos].func = FMTWIDTH;
- fmtpar[fmtpos].realpos = realpos?realpos:fmtpos;
- fmtpos++;
- goto nextch;
- case '.':
- pointflag = 1;
- goto nextch;
- case 'l':
- if (longflag)
- longlongflag = 1;
- else
- longflag = 1;
- goto nextch;
-#ifdef NOT_USED
- /*
- * We might export this to client apps so we should
- * support 'qd' and 'I64d'(MinGW) also in case the
- * native version does.
- */
- case 'q':
- longlongflag = 1;
- longflag = 1;
- goto nextch;
- case 'I':
- if (*format == '6' && *(format+1) == '4')
+ }
+ }
+ have_star = true;
+ accum = 0;
+ goto nextch2;
+ case '$':
+ if (afterstar)
+ {
+ /* fetch and process star value */
+ int starval = argvalues[accum].i;
+
+ if (pointflag)
+ {
+ precision = starval;
+ if (precision < 0)
{
- format += 2;
- longlongflag = 1;
- longflag = 1;
- goto nextch;
+ precision = 0;
+ pointflag = 0;
}
- break;
+ }
+ 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
- case 'u':
- case 'U':
- fmtpar[fmtpos].longflag = longflag;
- fmtpar[fmtpos].longlongflag = longlongflag;
- fmtpar[fmtpos].fmtbegin = fmtbegin;
- fmtpar[fmtpos].fmtend = format;
- fmtpar[fmtpos].base = 10;
- fmtpar[fmtpos].dosign = 0;
- fmtpar[fmtpos].ljust = ljust;
- fmtpar[fmtpos].len = len;
- fmtpar[fmtpos].zpad = zpad;
- fmtpar[fmtpos].func = FMTNUM_U;
- fmtpar[fmtpos].realpos = realpos?realpos:fmtpos;
- fmtpos++;
- break;
- case 'o':
- case 'O':
- fmtpar[fmtpos].longflag = longflag;
- fmtpar[fmtpos].longlongflag = longlongflag;
- fmtpar[fmtpos].fmtbegin = fmtbegin;
- fmtpar[fmtpos].fmtend = format;
- fmtpar[fmtpos].base = 8;
- fmtpar[fmtpos].dosign = 0;
- fmtpar[fmtpos].ljust = ljust;
- fmtpar[fmtpos].len = len;
- fmtpar[fmtpos].zpad = zpad;
- fmtpar[fmtpos].func = FMTNUM_U;
- fmtpar[fmtpos].realpos = realpos?realpos:fmtpos;
- fmtpos++;
- break;
- case 'd':
- case 'D':
- fmtpar[fmtpos].longflag = longflag;
- fmtpar[fmtpos].longlongflag = longlongflag;
- fmtpar[fmtpos].fmtbegin = fmtbegin;
- fmtpar[fmtpos].fmtend = format;
- fmtpar[fmtpos].base = 10;
- fmtpar[fmtpos].dosign = 1;
- fmtpar[fmtpos].ljust = ljust;
- fmtpar[fmtpos].len = len;
- fmtpar[fmtpos].zpad = zpad;
- fmtpar[fmtpos].func = FMTNUM;
- fmtpar[fmtpos].realpos = realpos?realpos:fmtpos;
- fmtpos++;
- break;
- case 'x':
- fmtpar[fmtpos].longflag = longflag;
- fmtpar[fmtpos].longlongflag = longlongflag;
- fmtpar[fmtpos].fmtbegin = fmtbegin;
- fmtpar[fmtpos].fmtend = format;
- fmtpar[fmtpos].base = 16;
- fmtpar[fmtpos].dosign = 0;
- fmtpar[fmtpos].ljust = ljust;
- fmtpar[fmtpos].len = len;
- fmtpar[fmtpos].zpad = zpad;
- fmtpar[fmtpos].func = FMTNUM_U;
- fmtpar[fmtpos].realpos = realpos?realpos:fmtpos;
- fmtpos++;
- break;
- case 'X':
- fmtpar[fmtpos].longflag = longflag;
- fmtpar[fmtpos].longlongflag = longlongflag;
- fmtpar[fmtpos].fmtbegin = fmtbegin;
- fmtpar[fmtpos].fmtend = format;
- fmtpar[fmtpos].base = -16;
- fmtpar[fmtpos].dosign = 1;
- fmtpar[fmtpos].ljust = ljust;
- fmtpar[fmtpos].len = len;
- fmtpar[fmtpos].zpad = zpad;
- fmtpar[fmtpos].func = FMTNUM_U;
- fmtpar[fmtpos].realpos = realpos?realpos:fmtpos;
- fmtpos++;
- break;
- case 's':
- fmtpar[fmtpos].fmtbegin = fmtbegin;
- fmtpar[fmtpos].fmtend = format;
- fmtpar[fmtpos].ljust = ljust;
- fmtpar[fmtpos].len = len;
- fmtpar[fmtpos].zpad = zpad;
- fmtpar[fmtpos].maxwidth = maxwidth;
- fmtpar[fmtpos].func = FMTSTR;
- fmtpar[fmtpos].realpos = realpos?realpos:fmtpos;
- fmtpos++;
- break;
- case 'c':
- fmtpar[fmtpos].fmtbegin = fmtbegin;
- fmtpar[fmtpos].fmtend = format;
- fmtpar[fmtpos].func = FMTCHAR;
- fmtpar[fmtpos].realpos = realpos?realpos:fmtpos;
- fmtpos++;
- break;
- case 'e':
- case 'E':
- case 'f':
- case 'g':
- case 'G':
- fmtpar[fmtpos].fmtbegin = fmtbegin;
- fmtpar[fmtpos].fmtend = format;
- fmtpar[fmtpos].type = ch;
- fmtpar[fmtpos].ljust = ljust;
- fmtpar[fmtpos].len = len;
- fmtpar[fmtpos].maxwidth = maxwidth;
- fmtpar[fmtpos].precision = precision;
- fmtpar[fmtpos].pointflag = pointflag;
- fmtpar[fmtpos].func = FMTFLOAT;
- fmtpar[fmtpos].realpos = realpos?realpos:fmtpos;
- fmtpos++;
- break;
- case '%':
- break;
- default:
- dostr("???????", 0, end, &output);
+#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, int64);
+ 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 = (uint64) argvalues[fmtpos].ll;
+ else if (longflag)
+ numvalue = (unsigned long) argvalues[fmtpos].l;
+ else
+ numvalue = (unsigned int) argvalues[fmtpos].i;
+ }
+ else
+ {
+ if (longlongflag)
+ numvalue = (uint64) va_arg(args, int64);
+ 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 *);
+ 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((void *) strvalue, target);
break;
- default:
- dopr_outch(ch, end, &output);
+ 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 '%':
+ dopr_outch('%', target);
break;
}
}
-performpr:
- /* reorder pointers */
- for(i = 1; i < fmtpos; i++)
- fmtparptr[i] = &fmtpar[fmtpar[i].realpos];
+ return;
- /* assign values */
- for(i = 1; i < fmtpos; i++){
- switch(fmtparptr[i]->func){
- case FMTSTR:
- fmtparptr[i]->value = va_arg(args, char *);
- break;
- case FMTNUM:
- if (fmtparptr[i]->longflag)
- {
- if (fmtparptr[i]->longlongflag)
- fmtparptr[i]->numvalue = va_arg(args, int64);
- else
- fmtparptr[i]->numvalue = va_arg(args, long);
- }
- else
- fmtparptr[i]->numvalue = va_arg(args, int);
- break;
- case FMTNUM_U:
- if (fmtparptr[i]->longflag)
- {
- if (fmtparptr[i]->longlongflag)
- fmtparptr[i]->numvalue = va_arg(args, uint64);
- else
- fmtparptr[i]->numvalue = va_arg(args, unsigned long);
- }
- else
- fmtparptr[i]->numvalue = va_arg(args, unsigned int);
+bad_format:
+ errno = EINVAL;
+ target->failed = true;
+}
+
+static size_t
+pg_strnlen(const char *str, size_t maxlen)
+{
+ const char *p = str;
+
+ while (maxlen-- > 0 && *p)
+ p++;
+ return p - str;
+}
+
+static void
+fmtstr(char *value, int leftjust, int minlen, int maxwidth,
+ int pointflag, PrintfTarget *target)
+{
+ int padlen,
+ vallen; /* amount to pad */
+
+ /*
+ * If a maxwidth (precision) is specified, we must not fetch more bytes
+ * than that.
+ */
+ if (pointflag)
+ vallen = pg_strnlen(value, maxwidth);
+ else
+ vallen = strlen(value);
+
+ adjust_padlen(minlen, vallen, leftjust, &padlen);
+
+ while (padlen > 0)
+ {
+ dopr_outch(' ', target);
+ --padlen;
+ }
+
+ dostr(value, vallen, target);
+
+ trailing_pad(&padlen, target);
+}
+
+static void
+fmtptr(void *value, PrintfTarget *target)
+{
+ int vallen;
+ char convert[64];
+
+ /* we rely on regular C library's sprintf to do the basic conversion */
+ vallen = sprintf(convert, "%p", value);
+ if (vallen < 0)
+ target->failed = true;
+ else
+ dostr(convert, vallen, target);
+}
+
+static void
+fmtint(int64 value, char type, int forcesign, int leftjust,
+ int minlen, int zpad, int precision, int pointflag,
+ PrintfTarget *target)
+{
+ uint64 base;
+ int dosign;
+ const char *cvt = "0123456789abcdef";
+ int signvalue = 0;
+ char convert[64];
+ int vallen = 0;
+ int padlen = 0; /* amount to pad */
+ int zeropad; /* extra leading zeroes */
+
+ switch (type)
+ {
+ case 'd':
+ case 'i':
+ base = 10;
+ dosign = 1;
break;
- case FMTFLOAT:
- fmtparptr[i]->fvalue = va_arg(args, double);
+ case 'o':
+ base = 8;
+ dosign = 0;
break;
- case FMTCHAR:
- fmtparptr[i]->charvalue = va_arg(args, int);
+ case 'u':
+ base = 10;
+ dosign = 0;
break;
- case FMTLEN:
- if (i + 1 < fmtpos && fmtpar[i + 1].func != FMTWIDTH)
- fmtpar[i + 1].len = va_arg(args, int);
- /* For "%*.*f", use the second arg */
- if (i + 2 < fmtpos && fmtpar[i + 1].func == FMTWIDTH)
- fmtpar[i + 2].len = va_arg(args, int);
+ case 'x':
+ base = 16;
+ dosign = 0;
break;
- case FMTWIDTH:
- if (i + 1 < fmtpos)
- fmtpar[i + 1].maxwidth = fmtpar[i + 1].precision =
- va_arg(args, int);
+ case 'X':
+ cvt = "0123456789ABCDEF";
+ base = 16;
+ dosign = 0;
break;
- }
+ default:
+ return; /* keep compiler quiet */
}
- /* do the output */
- output = buffer;
- format = format_save;
- while ((ch = *format++))
+ /* Handle +/- */
+ if (dosign && adjust_sign((value < 0), forcesign, &signvalue))
+ value = -value;
+
+ /*
+ * SUS: the result of converting 0 with an explicit precision of 0 is no
+ * characters
+ */
+ if (value == 0 && pointflag && precision == 0)
+ vallen = 0;
+ else
{
- for(i = 1; i < fmtpos; i++)
+ /* make integer string */
+ uint64 uvalue = (uint64) value;
+
+ do
{
- if (ch == '%' && *format == '%')
- {
- format++;
- continue;
- }
- if (fmtpar[i].fmtbegin == format - 1)
- {
- switch(fmtparptr[i]->func){
- case FMTSTR:
- fmtstr(fmtparptr[i]->value, fmtparptr[i]->ljust,
- fmtparptr[i]->len, fmtparptr[i]->zpad,
- fmtparptr[i]->maxwidth, end, &output);
- break;
- case FMTNUM:
- case FMTNUM_U:
- fmtnum(fmtparptr[i]->numvalue, fmtparptr[i]->base,
- fmtparptr[i]->dosign, fmtparptr[i]->ljust,
- fmtparptr[i]->len, fmtparptr[i]->zpad, end, &output);
- break;
- case FMTFLOAT:
- fmtfloat(fmtparptr[i]->fvalue, fmtparptr[i]->type,
- fmtparptr[i]->ljust, fmtparptr[i]->len,
- fmtparptr[i]->precision, fmtparptr[i]->pointflag,
- end, &output);
- break;
- case FMTCHAR:
- dopr_outch(fmtparptr[i]->charvalue, end, &output);
- break;
- }
- format = fmtpar[i].fmtend;
- goto nochar;
- }
- }
- dopr_outch(ch, end, &output);
-nochar:
- /* nothing */
- ; /* semicolon required because a goto has to be attached to a statement */
+ convert[vallen++] = cvt[uvalue % base];
+ uvalue = uvalue / base;
+ } while (uvalue);
}
- *output = '\0';
-#ifndef FRONTEND
- pgport_pfree(fmtpar);
- pgport_pfree(fmtparptr);
-#else
- free(fmtpar);
- free(fmtparptr);
-#endif
+ zeropad = Max(0, precision - vallen);
+
+ adjust_padlen(minlen, vallen + zeropad, leftjust, &padlen);
+
+ leading_pad(zpad, &signvalue, &padlen, target);
+
+ while (zeropad-- > 0)
+ dopr_outch('0', target);
+
+ while (vallen > 0)
+ dopr_outch(convert[--vallen], target);
+
+ trailing_pad(&padlen, target);
}
static void
-fmtstr(char *value, int ljust, int len, int zpad, int maxwidth, char *end,
- char **output)
+fmtchar(int value, int leftjust, int minlen, PrintfTarget *target)
{
- int padlen,
- strlen; /* amount to pad */
-
- if (value == 0)
- value = "<NULL>";
- for (strlen = 0; value[strlen]; ++strlen); /* strlen */
- if (strlen > maxwidth && maxwidth)
- strlen = maxwidth;
- padlen = len - strlen;
- if (padlen < 0)
- padlen = 0;
- if (ljust)
- padlen = -padlen;
+ int padlen = 0; /* amount to pad */
+
+ adjust_padlen(minlen, 1, leftjust, &padlen);
+
while (padlen > 0)
{
- dopr_outch(' ', end, output);
+ dopr_outch(' ', target);
--padlen;
}
- dostr(value, maxwidth, end, output);
- while (padlen < 0)
- {
- dopr_outch(' ', end, output);
- ++padlen;
- }
+
+ dopr_outch(value, target);
+
+ trailing_pad(&padlen, target);
}
static void
-fmtnum(int64 value, int base, int dosign, int ljust, int len, int zpad,
- char *end, char **output)
+fmtfloat(double value, char type, int forcesign, int leftjust,
+ int minlen, int zpad, int precision, int pointflag,
+ PrintfTarget *target)
{
int signvalue = 0;
- uint64 uvalue;
- char convert[64];
- int place = 0;
- int padlen = 0; /* amount to pad */
- int caps = 0;
+ int prec;
+ int vallen;
+ char fmt[32];
+ char convert[1024];
+ int zeropadlen = 0; /* amount to pad with zeroes */
+ int padlen = 0; /* amount to pad with spaces */
/*
- * DEBUGP(("value 0x%x, base %d, dosign %d, ljust %d, len %d, zpad
- * %d\n", value, base, dosign, ljust, len, zpad ));
+ * We rely on the regular C library's sprintf 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, sprintf
+ * 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.
*/
- uvalue = value;
- if (dosign)
- {
- if (value < 0)
- {
- signvalue = '-';
- uvalue = -value;
- }
- }
- if (base < 0)
- {
- caps = 1;
- base = -base;
- }
- do
- {
- convert[place++] = (caps ? "0123456789ABCDEF" : "0123456789abcdef")
- [uvalue % (unsigned) base];
- uvalue = (uvalue / (unsigned) base);
- } while (uvalue);
- convert[place] = 0;
+ if (precision < 0) /* cover possible overflow of "accum" */
+ precision = 0;
+ prec = Min(precision, 350);
- if (len < 0)
+ if (pointflag)
{
- /* this could happen with a "*" width spec */
- ljust = 1;
- len = -len;
+ if (sprintf(fmt, "%%.%d%c", prec, type) < 0)
+ goto fail;
+ zeropadlen = precision - prec;
}
- padlen = len - place;
- if (padlen < 0)
- padlen = 0;
- if (ljust)
- padlen = -padlen;
+ else if (sprintf(fmt, "%%%c", type) < 0)
+ goto fail;
- /*
- * DEBUGP(( "str '%s', place %d, sign %c, padlen %d\n",
- * convert,place,signvalue,padlen));
- */
- if (zpad && padlen > 0)
+ if (!isnan(value) && adjust_sign((value < 0), forcesign, &signvalue))
+ value = -value;
+
+ vallen = sprintf(convert, fmt, value);
+ if (vallen < 0)
+ goto fail;
+
+ /* If it's infinity or NaN, forget about doing any zero-padding */
+ if (zeropadlen > 0 && !isdigit((unsigned char) convert[vallen - 1]))
+ zeropadlen = 0;
+
+ adjust_padlen(minlen, vallen + zeropadlen, leftjust, &padlen);
+
+ leading_pad(zpad, &signvalue, &padlen, target);
+
+ if (zeropadlen > 0)
{
- if (signvalue)
+ /* If 'e' or 'E' format, inject zeroes before the exponent */
+ char *epos = strrchr(convert, 'e');
+
+ if (!epos)
+ epos = strrchr(convert, 'E');
+ if (epos)
{
- dopr_outch(signvalue, end, output);
- --padlen;
- signvalue = 0;
+ /* pad after exponent */
+ dostr(convert, epos - convert, target);
+ while (zeropadlen-- > 0)
+ dopr_outch('0', target);
+ dostr(epos, vallen - (epos - convert), target);
}
- while (padlen > 0)
+ else
{
- dopr_outch(zpad, end, output);
- --padlen;
+ /* no exponent, pad after the digits */
+ dostr(convert, vallen, target);
+ while (zeropadlen-- > 0)
+ dopr_outch('0', target);
}
}
- while (padlen > 0)
- {
- dopr_outch(' ', end, output);
- --padlen;
- }
- if (signvalue)
- dopr_outch(signvalue, end, output);
- while (place > 0)
- dopr_outch(convert[--place], end, output);
- while (padlen < 0)
+ else
{
- dopr_outch(' ', end, output);
- ++padlen;
+ /* no zero padding, just emit the number as-is */
+ dostr(convert, vallen, target);
}
+
+ trailing_pad(&padlen, target);
+ return;
+
+fail:
+ target->failed = true;
}
static void
-fmtfloat(double value, char type, int ljust, int len, int precision,
- int pointflag, char *end, char **output)
+dostr(const char *str, int slen, PrintfTarget *target)
{
- char fmt[32];
- char convert[512];
- int padlen = 0; /* amount to pad */
-
- /* we rely on regular C library's sprintf to do the basic conversion */
- if (pointflag)
- sprintf(fmt, "%%.%d%c", precision, type);
- else
- sprintf(fmt, "%%%c", type);
- sprintf(convert, fmt, value);
-
- if (len < 0)
+ while (slen > 0)
{
- /* this could happen with a "*" width spec */
- ljust = 1;
- len = -len;
+ 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)
+ return; /* no, lose the data */
+ flushbuffer(target);
+ continue;
+ }
+ avail = Min(avail, slen);
+ memmove(target->bufptr, str, avail);
+ target->bufptr += avail;
+ str += avail;
+ slen -= avail;
}
- padlen = len - strlen(convert);
- if (padlen < 0)
- padlen = 0;
- if (ljust)
- padlen = -padlen;
+}
- while (padlen > 0)
+static void
+dopr_outch(int c, PrintfTarget *target)
+{
+ if (target->bufend != NULL && target->bufptr >= target->bufend)
{
- dopr_outch(' ', end, output);
- --padlen;
+ /* buffer full, can we dump to stream? */
+ if (target->stream == NULL)
+ return; /* no, lose the data */
+ flushbuffer(target);
}
- dostr(convert, 0, end, output);
- while (padlen < 0)
+ *(target->bufptr++) = c;
+}
+
+
+static int
+adjust_sign(int is_negative, int forcesign, int *signvalue)
+{
+ if (is_negative)
{
- dopr_outch(' ', end, output);
- ++padlen;
+ *signvalue = '-';
+ return true;
}
+ else if (forcesign)
+ *signvalue = '+';
+ return false;
}
+
+static void
+adjust_padlen(int minlen, int vallen, int leftjust, int *padlen)
+{
+ *padlen = minlen - vallen;
+ if (*padlen < 0)
+ *padlen = 0;
+ if (leftjust)
+ *padlen = -(*padlen);
+}
+
+
static void
-dostr(char *str, int cut, char *end, char **output)
+leading_pad(int zpad, int *signvalue, int *padlen, PrintfTarget *target)
{
- if (cut)
+ if (*padlen > 0 && zpad)
{
- while (*str && cut-- > 0)
- dopr_outch(*str++, end, output);
+ if (*signvalue)
+ {
+ dopr_outch(*signvalue, target);
+ --(*padlen);
+ *signvalue = 0;
+ }
+ while (*padlen > 0)
+ {
+ dopr_outch(zpad, target);
+ --(*padlen);
+ }
}
- else
+ while (*padlen > (*signvalue != 0))
{
- while (*str)
- dopr_outch(*str++, end, output);
+ dopr_outch(' ', target);
+ --(*padlen);
+ }
+ if (*signvalue)
+ {
+ dopr_outch(*signvalue, target);
+ if (*padlen > 0)
+ --(*padlen);
+ else if (*padlen < 0)
+ ++(*padlen);
}
}
+
static void
-dopr_outch(int c, char *end, char **output)
+trailing_pad(int *padlen, PrintfTarget *target)
{
-#ifdef NOT_USED
- if (iscntrl((unsigned char) c) && c != '\n' && c != '\t')
+ while (*padlen < 0)
{
- c = '@' + (c & 0x1F);
- if (end == 0 || *output < end)
- *(*output)++ = '^';
+ dopr_outch(' ', target);
+ ++(*padlen);
}
-#endif
- if (end == 0 || *output < end)
- *(*output)++ = c;
}
projects / postgresql / blobdiff