prestogres 0.1.0

data/pgpool2/parser/scanner.h

@@ -0,0 +1,120 @@
+/*-------------------------------------------------------------------------
+ *
+ * scanner.h
+ *		API for the core scanner (flex machine)
+ *
+ * The core scanner is also used by PL/pgsql, so we provide a public API
+ * for it.	However, the rest of the backend is only expected to use the
+ * higher-level API provided by parser.h.
+ *
+ *
+ * Portions Copyright (c) 2003-2013, PgPool Global Development Group
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/scanner.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef SCANNER_H
+#define SCANNER_H
+
+#include "keywords.h"
+
+/*
+ * The scanner returns extra data about scanned tokens in this union type.
+ * Note that this is a subset of the fields used in YYSTYPE of the bison
+ * parsers built atop the scanner.
+ */
+typedef union core_YYSTYPE
+{
+	int			ival;			/* for integer literals */
+	char	   *str;			/* for identifiers and non-integer literals */
+	const char *keyword;		/* canonical spelling of keywords */
+} core_YYSTYPE;
+
+/*
+ * We track token locations in terms of byte offsets from the start of the
+ * source string, not the column number/line number representation that
+ * bison uses by default.  Also, to minimize overhead we track only one
+ * location (usually the first token location) for each construct, not
+ * the beginning and ending locations as bison does by default.  It's
+ * therefore sufficient to make YYLTYPE an int.
+ */
+#define YYLTYPE  int
+
+/*
+ * Another important component of the scanner's API is the token code numbers.
+ * However, those are not defined in this file, because bison insists on
+ * defining them for itself.  The token codes used by the core scanner are
+ * the ASCII characters plus these:
+ *	%token <str>	IDENT FCONST SCONST BCONST XCONST Op
+ *	%token <ival>	ICONST PARAM
+ *	%token			TYPECAST DOT_DOT COLON_EQUALS
+ * The above token definitions *must* be the first ones declared in any
+ * bison parser built atop this scanner, so that they will have consistent
+ * numbers assigned to them (specifically, IDENT = 258 and so on).
+ */
+
+/*
+ * The YY_EXTRA data that a flex scanner allows us to pass around.
+ * Private state needed by the core scanner goes here.	Note that the actual
+ * yy_extra struct may be larger and have this as its first component, thus
+ * allowing the calling parser to keep some fields of its own in YY_EXTRA.
+ */
+typedef struct core_yy_extra_type
+{
+	/*
+	 * The string the scanner is physically scanning.  We keep this mainly so
+	 * that we can cheaply compute the offset of the current token (yytext).
+	 */
+	char	   *scanbuf;
+	Size		scanbuflen;
+
+	/*
+	 * The keyword list to use.
+	 */
+	const ScanKeyword *keywords;
+	int			num_keywords;
+
+	/*
+	 * literalbuf is used to accumulate literal values when multiple rules are
+	 * needed to parse a single literal.  Call startlit() to reset buffer to
+	 * empty, addlit() to add text.  NOTE: the string in literalbuf is NOT
+	 * necessarily null-terminated, but there always IS room to add a trailing
+	 * null at offset literallen.  We store a null only when we need it.
+	 */
+	char	   *literalbuf;		/* palloc'd expandable buffer */
+	int			literallen;		/* actual current string length */
+	int			literalalloc;	/* current allocated buffer size */
+
+	int			xcdepth;		/* depth of nesting in slash-star comments */
+	char	   *dolqstart;		/* current $foo$ quote start string */
+
+	/* first part of UTF16 surrogate pair for Unicode escapes */
+	int32		utf16_first_part;
+
+	/* state variables for literal-lexing warnings */
+	bool		warn_on_first_escape;
+	bool		saw_non_ascii;
+} core_yy_extra_type;
+
+/*
+ * The type of yyscanner is opaque outside scan.l.
+ */
+typedef void *core_yyscan_t;
+
+
+/* Entry points in parser/scan.l */
+extern core_yyscan_t scanner_init(const char *str,
+			 core_yy_extra_type *yyext,
+			 const ScanKeyword *keywords,
+			 int num_keywords);
+extern void scanner_finish(core_yyscan_t yyscanner);
+extern int core_yylex(core_YYSTYPE *lvalp, YYLTYPE *llocp,
+		   core_yyscan_t yyscanner);
+extern int	scanner_errposition(int location, core_yyscan_t yyscanner);
+extern void scanner_yyerror(const char *message, core_yyscan_t yyscanner);
+
+#endif   /* SCANNER_H */

data/pgpool2/parser/scansup.c

@@ -0,0 +1,221 @@
+/*-------------------------------------------------------------------------
+ *
+ * scansup.c
+ *	  support routines for the lex/flex scanner, used by both the normal
+ * backend as well as the bootstrap backend
+ *
+ * Portions Copyright (c) 1996-2013, PgPool Global Development Group
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/parser/scansup.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "pool_parser.h"
+#include "pool_memory.h"
+
+#include <ctype.h>
+#include <string.h>
+
+#include "scansup.h"
+#include "pg_wchar.h"
+
+
+/* ----------------
+ *		scanstr
+ *
+ * if the string passed in has escaped codes, map the escape codes to actual
+ * chars
+ *
+ * the string returned is palloc'd and should eventually be pfree'd by the
+ * caller!
+ * ----------------
+ */
+char *
+scanstr(const char *s)
+{
+	char	   *newStr;
+	int			len,
+				i,
+				j;
+
+	if (s == NULL || s[0] == '\0')
+		return pstrdup("");
+
+	len = strlen(s);
+
+	newStr = palloc(len + 1);	/* string cannot get longer */
+
+	for (i = 0, j = 0; i < len; i++)
+	{
+		if (s[i] == '\'')
+		{
+			/*
+			 * Note: if scanner is working right, unescaped quotes can only
+			 * appear in pairs, so there should be another character.
+			 */
+			i++;
+			newStr[j] = s[i];
+		}
+		else if (s[i] == '\\')
+		{
+			i++;
+			switch (s[i])
+			{
+				case 'b':
+					newStr[j] = '\b';
+					break;
+				case 'f':
+					newStr[j] = '\f';
+					break;
+				case 'n':
+					newStr[j] = '\n';
+					break;
+				case 'r':
+					newStr[j] = '\r';
+					break;
+				case 't':
+					newStr[j] = '\t';
+					break;
+				case '0':
+				case '1':
+				case '2':
+				case '3':
+				case '4':
+				case '5':
+				case '6':
+				case '7':
+					{
+						int			k;
+						long		octVal = 0;
+
+						for (k = 0;
+							 s[i + k] >= '0' && s[i + k] <= '7' && k < 3;
+							 k++)
+							octVal = (octVal << 3) + (s[i + k] - '0');
+						i += k - 1;
+						newStr[j] = ((char) octVal);
+					}
+					break;
+				default:
+					newStr[j] = s[i];
+					break;
+			}					/* switch */
+		}						/* s[i] == '\\' */
+		else
+			newStr[j] = s[i];
+		j++;
+	}
+	newStr[j] = '\0';
+	return newStr;
+}
+
+
+/*
+ * downcase_truncate_identifier() --- do appropriate downcasing and
+ * truncation of an unquoted identifier.  Optionally warn of truncation.
+ *
+ * Returns a palloc'd string containing the adjusted identifier.
+ *
+ * Note: in some usages the passed string is not null-terminated.
+ *
+ * Note: the API of this function is designed to allow for downcasing
+ * transformations that increase the string length, but we don't yet
+ * support that.  If you want to implement it, you'll need to fix
+ * SplitIdentifierString() in utils/adt/varlena.c.
+ */
+char *
+downcase_truncate_identifier(const char *ident, int len, bool warn)
+{
+	char	   *result;
+	int			i;
+
+	result = palloc(len + 1);
+
+	/*
+	 * SQL99 specifies Unicode-aware case normalization, which we don't yet
+	 * have the infrastructure for.  Instead we use tolower() to provide a
+	 * locale-aware translation.  However, there are some locales where this
+	 * is not right either (eg, Turkish may do strange things with 'i' and
+	 * 'I').  Our current compromise is to use tolower() for characters with
+	 * the high bit set, and use an ASCII-only downcasing for 7-bit
+	 * characters.
+	 */
+	for (i = 0; i < len; i++)
+	{
+		unsigned char ch = (unsigned char) ident[i];
+
+		if (ch >= 'A' && ch <= 'Z')
+			ch += 'a' - 'A';
+		else if (IS_HIGHBIT_SET(ch) && isupper(ch))
+			ch = tolower(ch);
+		result[i] = (char) ch;
+	}
+	result[i] = '\0';
+
+	if (i >= NAMEDATALEN)
+		truncate_identifier(result, i, warn);
+
+	return result;
+}
+
+/*
+ * truncate_identifier() --- truncate an identifier to NAMEDATALEN-1 bytes.
+ *
+ * The given string is modified in-place, if necessary.  A warning is
+ * issued if requested.
+ *
+ * We require the caller to pass in the string length since this saves a
+ * strlen() call in some common usages.
+ */
+void
+truncate_identifier(char *ident, int len, bool warn)
+{
+#if PGPOOL_NOT_USED
+	if (len >= NAMEDATALEN)
+	{
+		len = pg_mbcliplen(ident, len, NAMEDATALEN - 1);
+		if (warn)
+		{
+			/*
+			 * We avoid using %.*s here because it can misbehave if the data
+			 * is not valid in what libc thinks is the prevailing encoding.
+			 */
+			char		buf[NAMEDATALEN];
+
+			memcpy(buf, ident, len);
+			buf[len] = '\0';
+			ereport(NOTICE,
+					(errcode(ERRCODE_NAME_TOO_LONG),
+					 errmsg("identifier \"%s\" will be truncated to \"%s\"",
+							ident, buf)));
+		}
+		ident[len] = '\0';
+	}
+#endif
+}
+
+/*
+ * scanner_isspace() --- return TRUE if flex scanner considers char whitespace
+ *
+ * This should be used instead of the potentially locale-dependent isspace()
+ * function when it's important to match the lexer's behavior.
+ *
+ * In principle we might need similar functions for isalnum etc, but for the
+ * moment only isspace seems needed.
+ */
+bool
+scanner_isspace(char ch)
+{
+	/* This must match scan.l's list of {space} characters */
+	if (ch == ' ' ||
+		ch == '\t' ||
+		ch == '\n' ||
+		ch == '\r' ||
+		ch == '\f')
+		return true;
+	return false;
+}

data/pgpool2/parser/scansup.h

@@ -0,0 +1,28 @@
+/*-------------------------------------------------------------------------
+ *
+ * scansup.h
+ *	  scanner support routines.  used by both the bootstrap lexer
+ * as well as the normal lexer
+ *
+ * Portions Copyright (c) 2003-2013, PgPool Global Development Group
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/scansup.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef SCANSUP_H
+#define SCANSUP_H
+
+extern char *scanstr(const char *s);
+
+extern char *downcase_truncate_identifier(const char *ident, int len,
+							 bool warn);
+
+extern void truncate_identifier(char *ident, int len, bool warn);
+
+extern bool scanner_isspace(char ch);
+
+#endif   /* SCANSUP_H */

data/pgpool2/parser/snprintf.c

@@ -0,0 +1,1102 @@
+/*
+ * Copyright (c) 1983, 1995, 1996 Eric P. Allman
+ * Copyright (c) 1988, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *	  notice, this list of conditions and the following disclaimer.
+ * 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. 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
+ * 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)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * 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
+ */
+
+/*
+#include "c.h"
+
+#include <limits.h>
+#ifndef WIN32
+#include <sys/ioctl.h>
+#endif
+#include <sys/param.h>
+*/
+
+#ifndef NL_ARGMAX
+#define NL_ARGMAX 16
+#endif
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include "pool_memory.h"
+#include "pool_parser.h"
+#include "stringinfo.h"
+
+/* --------------------------------------------------------------------- */
+/* c.h                                                                   */
+/* --------------------------------------------------------------------- */
+
+/* Get a bit mask of the bits set in non-long aligned addresses */
+#define LONG_ALIGN_MASK (sizeof(long) - 1)
+
+#define MEMSET_LOOP_LIMIT 1024
+
+/*
+ * MemSet
+ *  Exactly the same as standard library function memset(), but considerably
+ *  faster for zeroing small word-aligned structures (such as parsetree nodes).
+ *  This has to be a macro because the main point is to avoid function-call
+ *  overhead.   However, we have also found that the loop is faster than
+ *  native libc memset() on some platforms, even those with assembler
+ *  memset() functions.  More research needs to be done, perhaps with
+ *  MEMSET_LOOP_LIMIT tests in configure.
+ */
+#define MemSet(start, val, len) \
+    do \
+    { \
+        /* must be void* because we don't know if it is integer aligned yet */ \
+        void   *_vstart = (void *) (start); \
+        int     _val = (val); \
+        Size    _len = (len); \
+\
+        if ((((intptr_t) _vstart) & LONG_ALIGN_MASK) == 0 && \
+            (_len & LONG_ALIGN_MASK) == 0 && \
+            _val == 0 && \
+            _len <= MEMSET_LOOP_LIMIT && \
+            /* \
+             *  If MEMSET_LOOP_LIMIT == 0, optimizer should find \
+             *  the whole "if" false at compile time. \
+             */ \
+            MEMSET_LOOP_LIMIT != 0) \
+        { \
+            long *_start = (long *) _vstart; \
+            long *_stop = (long *) ((char *) _start + _len); \
+            while (_start < _stop) \
+                *_start++ = 0; \
+        } \
+        else \
+            memset(_vstart, _val, _len); \
+    } while (0)
+
+/*
+ *	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
+ * the version here does not include floating point. (now it does ... tgl)
+ **************************************************************/
+
+/* 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 */
+} 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 int	dopr(PrintfTarget *target, const char *format, va_list args);
+
+
+int
+pg_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
+{
+	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 */
+	if (dopr(&target, fmt, args))
+	{
+		*(target.bufptr) = '\0';
+
+		errno = EINVAL;			/* bad format */
+
+		return -1;
+	}
+	*(target.bufptr) = '\0';
+	return target.bufptr - target.bufstart;
+}
+
+#if 0
+int
+pg_snprintf(char *str, size_t count, const char *fmt,...)
+{
+	int			len;
+	va_list		args;
+
+	va_start(args, fmt);
+	len = pg_vsnprintf(str, count, fmt, args);
+	va_end(args);
+	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 */
+	if (dopr(&target, fmt, args))
+	{
+		*(target.bufptr) = '\0';
+
+		errno = EINVAL;			/* bad format */
+
+		return -1;
+	}
+	*(target.bufptr) = '\0';
+	return 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;
+	if (dopr(&target, fmt, args))
+	{
+		errno = EINVAL;			/* bad format */
+		return -1;
+	}
+	/* dump any remaining buffer contents */
+	flushbuffer(&target);
+	return target.nchars;
+}
+
+int
+pg_fprintf(FILE *stream, const char *fmt,...)
+{
+	int			len;
+	va_list		args;
+
+	va_start(args, fmt);
+	len = pg_vfprintf(stream, fmt, args);
+	va_end(args);
+	return len;
+}
+
+int
+pg_printf(const char *fmt,...)
+{
+	int			len;
+	va_list		args;
+
+	va_start(args, fmt);
+	len = pg_vfprintf(stdout, fmt, args);
+	va_end(args);
+	return len;
+}
+#endif
+
+/* call this only when stream is defined */
+static void
+flushbuffer(PrintfTarget *target)
+{
+	size_t		nc = target->bufptr - target->bufstart;
+
+	if (nc > 0)
+		target->nchars += fwrite(target->bufstart, 1, nc, target->stream);
+	target->bufptr = target->bufstart;
+}
+
+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 int
+dopr(PrintfTarget *target, const char *format, va_list args)
+{
+	const char *format_start = format;
+	int			ch;
+	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;
+	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')
+	{
+		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)
+					return -1;
+				if (afterstar)
+				{
+					if (argtypes[accum] &&
+						argtypes[accum] != ATYPE_INT)
+						return -1;
+					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 '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 -1;
+					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)
+						return -1;
+					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)
+						return -1;
+					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)
+						return -1;
+					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;
+	}
+
+	/* Per spec, you use either all dollar or all not. */
+	if (have_dollar && have_non_dollar)
+		return -1;
+
+	/*
+	 * In dollar mode, collect the arguments in physical order.
+	 */
+	for (i = 1; i <= last_dollar; i++)
+	{
+		switch (argtypes[i])
+		{
+			case ATYPE_NONE:
+				return -1;		/* invalid 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;
+		}
+	}
+
+	/*
+	 * At last we can parse the format for real.
+	 */
+	format = format_start;
+	while ((ch = *format++) != '\0')
+	{
+		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 '-':
+				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
+				{
+					/* 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 '$':
+				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 '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;
+			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;
+		}
+	}
+
+	return 0;
+}
+
+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);
+
+	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 '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 */
+	}
+
+	/* 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
+	{
+		/* make integer string */
+		uint64		uvalue = (uint64) value;
+
+		do
+		{
+			convert[vallen++] = cvt[uvalue % base];
+			uvalue = uvalue / base;
+		} while (uvalue);
+	}
+
+	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
+fmtchar(int value, int leftjust, int minlen, PrintfTarget *target)
+{
+	int			padlen = 0;		/* amount to pad */
+
+	adjust_padlen(minlen, 1, leftjust, &padlen);
+
+	while (padlen > 0)
+	{
+		dopr_outch(' ', target);
+		--padlen;
+	}
+
+	dopr_outch(value, target);
+
+	trailing_pad(&padlen, target);
+}
+
+static void
+fmtfloat(double value, char type, int forcesign, int leftjust,
+		 int minlen, int zpad, int precision, int pointflag,
+		 PrintfTarget *target)
+{
+	int			signvalue = 0;
+	int			vallen;
+	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);
+
+	if (adjust_sign((value < 0), forcesign, &signvalue))
+		value = -value;
+
+	vallen = sprintf(convert, fmt, value);
+
+	adjust_padlen(minlen, vallen, leftjust, &padlen);
+
+	leading_pad(zpad, &signvalue, &padlen, target);
+
+	dostr(convert, vallen, target);
+
+	trailing_pad(&padlen, target);
+}
+
+static void
+dostr(const char *str, int slen, PrintfTarget *target)
+{
+	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)
+				return;			/* no, lose the data */
+			flushbuffer(target);
+			continue;
+		}
+		avail = Min(avail, slen);
+		memmove(target->bufptr, str, avail);
+		target->bufptr += avail;
+		str += avail;
+		slen -= avail;
+	}
+}
+
+static void
+dopr_outch(int c, PrintfTarget *target)
+{
+	if (target->bufend != NULL && target->bufptr >= target->bufend)
+	{
+		/* buffer full, can we dump to stream? */
+		if (target->stream == NULL)
+			return;				/* no, lose the data */
+		flushbuffer(target);
+	}
+	*(target->bufptr++) = c;
+}
+
+static int
+adjust_sign(int is_negative, int forcesign, int *signvalue)
+{
+	if (is_negative)
+	{
+		*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
+leading_pad(int zpad, int *signvalue, int *padlen, PrintfTarget *target)
+{
+	if (*padlen > 0 && zpad)
+	{
+		if (*signvalue)
+		{
+			dopr_outch(*signvalue, target);
+			--(*padlen);
+			*signvalue = 0;
+		}
+		while (*padlen > 0)
+		{
+			dopr_outch(zpad, target);
+			--(*padlen);
+		}
+	}
+	while (*padlen > (*signvalue != 0))
+	{
+		dopr_outch(' ', target);
+		--(*padlen);
+	}
+	if (*signvalue)
+	{
+		dopr_outch(*signvalue, target);
+		if (*padlen > 0)
+			--(*padlen);
+		else if (*padlen < 0)
+			++(*padlen);
+	}
+}
+
+
+static void
+trailing_pad(int *padlen, PrintfTarget *target)
+{
+	while (*padlen < 0)
+	{
+		dopr_outch(' ', target);
+		++(*padlen);
+	}
+}