pg_query 4.2.1 → 6.1.0

data/ext/pg_query/src_common_pg_prng.c

@@ -1,152 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - pg_prng_double
- * - xoroshiro128ss
- * - rotl
- * - pg_global_prng_state
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * Pseudo-Random Number Generator
- *
- * We use Blackman and Vigna's xoroshiro128** 1.0 algorithm
- * to have a small, fast PRNG suitable for generating reasonably
- * good-quality 64-bit data.  This should not be considered
- * cryptographically strong, however.
- *
- * About these generators: https://prng.di.unimi.it/
- * See also https://en.wikipedia.org/wiki/List_of_random_number_generators
- *
- * Copyright (c) 2021-2022, PostgreSQL Global Development Group
- *
- * src/common/pg_prng.c
- *
- *-------------------------------------------------------------------------
- */
-
-#include "c.h"
-
-#include <math.h>				/* for ldexp() */
-
-#include "common/pg_prng.h"
-#include "port/pg_bitutils.h"
-
-/* process-wide state vector */
-__thread pg_prng_state pg_global_prng_state;
-
-
-
-/*
- * 64-bit rotate left
- */
-static inline uint64
-rotl(uint64 x, int bits)
-{
-	return (x << bits) | (x >> (64 - bits));
-}
-
-/*
- * The basic xoroshiro128** algorithm.
- * Generates and returns a 64-bit uniformly distributed number,
- * updating the state vector for next time.
- *
- * Note: the state vector must not be all-zeroes, as that is a fixed point.
- */
-static uint64
-xoroshiro128ss(pg_prng_state *state)
-{
-	uint64		s0 = state->s0,
-				sx = state->s1 ^ s0,
-				val = rotl(s0 * 5, 7) * 9;
-
-	/* update state */
-	state->s0 = rotl(s0, 24) ^ sx ^ (sx << 16);
-	state->s1 = rotl(sx, 37);
-
-	return val;
-}
-
-/*
- * We use this generator just to fill the xoroshiro128** state vector
- * from a 64-bit seed.
- */
-
-
-/*
- * Initialize the PRNG state from a 64-bit integer,
- * taking care that we don't produce all-zeroes.
- */
-
-
-/*
- * Initialize the PRNG state from a double in the range [-1.0, 1.0],
- * taking care that we don't produce all-zeroes.
- */
-
-
-/*
- * Validate a PRNG seed value.
- */
-
-
-/*
- * Select a random uint64 uniformly from the range [0, PG_UINT64_MAX].
- */
-
-
-/*
- * Select a random uint64 uniformly from the range [rmin, rmax].
- * If the range is empty, rmin is always produced.
- */
-
-
-/*
- * Select a random int64 uniformly from the range [PG_INT64_MIN, PG_INT64_MAX].
- */
-
-
-/*
- * Select a random int64 uniformly from the range [0, PG_INT64_MAX].
- */
-
-
-/*
- * Select a random uint32 uniformly from the range [0, PG_UINT32_MAX].
- */
-
-
-/*
- * Select a random int32 uniformly from the range [PG_INT32_MIN, PG_INT32_MAX].
- */
-
-
-/*
- * Select a random int32 uniformly from the range [0, PG_INT32_MAX].
- */
-
-
-/*
- * Select a random double uniformly from the range [0.0, 1.0).
- *
- * Note: if you want a result in the range (0.0, 1.0], the standard way
- * to get that is "1.0 - pg_prng_double(state)".
- */
-double
-pg_prng_double(pg_prng_state *state)
-{
-	uint64		v = xoroshiro128ss(state);
-
-	/*
-	 * As above, assume there's 52 mantissa bits in a double.  This result
-	 * could round to 1.0 if double's precision is less than that; but we
-	 * assume IEEE float arithmetic elsewhere in Postgres, so this seems OK.
-	 */
-	return ldexp((double) (v >> (64 - 52)), -52);
-}
-
-/*
- * Select a random boolean value.
- */
-

data/ext/pg_query/src_common_string.c

@@ -1,92 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - strtoint
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * string.c
- *		string handling helpers
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/common/string.c
- *
- *-------------------------------------------------------------------------
- */
-
-
-#ifndef FRONTEND
-#include "postgres.h"
-#else
-#include "postgres_fe.h"
-#endif
-
-#include "common/string.h"
-
-
-/*
- * Returns whether the string `str' has the postfix `end'.
- */
-
-
-
-/*
- * strtoint --- just like strtol, but returns int not long
- */
-int
-strtoint(const char *pg_restrict str, char **pg_restrict endptr, int base)
-{
-	long		val;
-
-	val = strtol(str, endptr, base);
-	if (val != (int) val)
-		errno = ERANGE;
-	return (int) val;
-}
-
-
-/*
- * pg_clean_ascii -- Replace any non-ASCII chars with a '?' char
- *
- * Modifies the string passed in which must be '\0'-terminated.
- *
- * This function exists specifically to deal with filtering out
- * non-ASCII characters in a few places where the client can provide an almost
- * arbitrary string (and it isn't checked to ensure it's a valid username or
- * database name or similar) and we don't want to have control characters or other
- * things ending up in the log file where server admins might end up with a
- * messed up terminal when looking at them.
- *
- * In general, this function should NOT be used- instead, consider how to handle
- * the string without needing to filter out the non-ASCII characters.
- *
- * Ultimately, we'd like to improve the situation to not require stripping out
- * all non-ASCII but perform more intelligent filtering which would allow UTF or
- * similar, but it's unclear exactly what we should allow, so stick to ASCII only
- * for now.
- */
-
-
-
-/*
- * pg_is_ascii -- Check if string is made only of ASCII characters
- */
-
-
-
-/*
- * pg_strip_crlf -- Remove any trailing newline and carriage return
- *
- * Removes any trailing newline and carriage return characters (\r on
- * Windows) in the input string, zero-terminating it.
- *
- * The passed in string must be zero-terminated.  This function returns
- * the new length of the string.
- */
-

data/ext/pg_query/src_port_pgsleep.c

@@ -1,69 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - pg_usleep
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * pgsleep.c
- *	   Portable delay handling.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- *
- * src/port/pgsleep.c
- *
- *-------------------------------------------------------------------------
- */
-#include "c.h"
-
-#include <unistd.h>
-#include <sys/time.h>
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.h>
-#endif
-
-/*
- * In a Windows backend, we don't use this implementation, but rather
- * the signal-aware version in src/backend/port/win32/signal.c.
- */
-#if defined(FRONTEND) || !defined(WIN32)
-
-/*
- * pg_usleep --- delay the specified number of microseconds.
- *
- * NOTE: although the delay is specified in microseconds, the effective
- * resolution is only 1/HZ, or 10 milliseconds, on most Unixen.  Expect
- * the requested delay to be rounded up to the next resolution boundary.
- *
- * On machines where "long" is 32 bits, the maximum delay is ~2000 seconds.
- *
- * CAUTION: the behavior when a signal arrives during the sleep is platform
- * dependent.  On most Unix-ish platforms, a signal does not terminate the
- * sleep; but on some, it will (the Windows implementation also allows signals
- * to terminate pg_usleep).  And there are platforms where not only does a
- * signal not terminate the sleep, but it actually resets the timeout counter
- * so that the sleep effectively starts over!  It is therefore rather hazardous
- * to use this for long sleeps; a continuing stream of signal events could
- * prevent the sleep from ever terminating.  Better practice for long sleeps
- * is to use WaitLatch() with a timeout.
- */
-void
-pg_usleep(long microsec)
-{
-	if (microsec > 0)
-	{
-#ifndef WIN32
-		struct timeval delay;
-
-		delay.tv_sec = microsec / 1000000L;
-		delay.tv_usec = microsec % 1000000L;
-		(void) select(0, NULL, NULL, NULL, &delay);
-#else
-		SleepEx((microsec < 500 ? 1 : (microsec + 500) / 1000), FALSE);
-#endif
-	}
-}
-
-#endif							/* defined(FRONTEND) || !defined(WIN32) */

data/ext/pg_query/src_port_strnlen.c

@@ -1,39 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - strnlen
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * strnlen.c
- *		Fallback implementation of strnlen().
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * IDENTIFICATION
- *	  src/port/strnlen.c
- *
- *-------------------------------------------------------------------------
- */
-
-#include "c.h"
-
-/*
- * Implementation of posix' strnlen for systems where it's not available.
- *
- * Returns the number of characters before a null-byte in the string pointed
- * to by str, unless there's no null-byte before maxlen. In the latter case
- * maxlen is returned.
- */
-size_t
-strnlen(const char *str, size_t maxlen)
-{
-	const char *p = str;
-
-	while (maxlen-- > 0 && *p)
-		p++;
-	return p - str;
-}