Adding upstream version 15.5.upstream/15.5

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 177 insertions, 0 deletions

diff --git a/contrib/seg/segparse.y b/contrib/seg/segparse.y
new file mode 100644
index 0000000..0dc6bb6
--- /dev/null
+++ b/contrib/seg/segparse.y
@@ -0,0 +1,177 @@
+%{
+/* contrib/seg/segparse.y */
+
+#include "postgres.h"
+
+#include <float.h>
+#include <math.h>
+
+#include "fmgr.h"
+#include "utils/builtins.h"
+
+#include "segdata.h"
+
+/*
+ * Bison doesn't allocate anything that needs to live across parser calls,
+ * so we can easily have it use palloc instead of malloc.  This prevents
+ * memory leaks if we error out during parsing.  Note this only works with
+ * bison >= 2.0.  However, in bison 1.875 the default is to use alloca()
+ * if possible, so there's not really much problem anyhow, at least if
+ * you're building with gcc.
+ */
+#define YYMALLOC palloc
+#define YYFREE   pfree
+
+static float seg_atof(const char *value);
+
+static int sig_digits(const char *value);
+
+static char strbuf[25] = {
+	'0', '0', '0', '0', '0',
+	'0', '0', '0', '0', '0',
+	'0', '0', '0', '0', '0',
+	'0', '0', '0', '0', '0',
+	'0', '0', '0', '0', '\0'
+};
+
+%}
+
+/* BISON Declarations */
+%parse-param {SEG *result}
+%expect 0
+%name-prefix="seg_yy"
+
+%union
+{
+	struct BND
+	{
+		float		val;
+		char		ext;
+		char		sigd;
+	} bnd;
+	char	   *text;
+}
+%token <text> SEGFLOAT
+%token <text> RANGE
+%token <text> PLUMIN
+%token <text> EXTENSION
+%type  <bnd>  boundary
+%type  <bnd>  deviation
+%start range
+
+/* Grammar follows */
+%%
+
+
+range: boundary PLUMIN deviation
+	{
+		result->lower = $1.val - $3.val;
+		result->upper = $1.val + $3.val;
+		sprintf(strbuf, "%g", result->lower);
+		result->l_sigd = Max(sig_digits(strbuf), Max($1.sigd, $3.sigd));
+		sprintf(strbuf, "%g", result->upper);
+		result->u_sigd = Max(sig_digits(strbuf), Max($1.sigd, $3.sigd));
+		result->l_ext = '\0';
+		result->u_ext = '\0';
+	}
+
+	| boundary RANGE boundary
+	{
+		result->lower = $1.val;
+		result->upper = $3.val;
+		if ( result->lower > result->upper ) {
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("swapped boundaries: %g is greater than %g",
+							result->lower, result->upper)));
+
+			YYERROR;
+		}
+		result->l_sigd = $1.sigd;
+		result->u_sigd = $3.sigd;
+		result->l_ext = ( $1.ext ? $1.ext : '\0' );
+		result->u_ext = ( $3.ext ? $3.ext : '\0' );
+	}
+
+	| boundary RANGE
+	{
+		result->lower = $1.val;
+		result->upper = HUGE_VAL;
+		result->l_sigd = $1.sigd;
+		result->u_sigd = 0;
+		result->l_ext = ( $1.ext ? $1.ext : '\0' );
+		result->u_ext = '-';
+	}
+
+	| RANGE boundary
+	{
+		result->lower = -HUGE_VAL;
+		result->upper = $2.val;
+		result->l_sigd = 0;
+		result->u_sigd = $2.sigd;
+		result->l_ext = '-';
+		result->u_ext = ( $2.ext ? $2.ext : '\0' );
+	}
+
+	| boundary
+	{
+		result->lower = result->upper = $1.val;
+		result->l_sigd = result->u_sigd = $1.sigd;
+		result->l_ext = result->u_ext = ( $1.ext ? $1.ext : '\0' );
+	}
+	;
+
+boundary: SEGFLOAT
+	{
+		/* temp variable avoids a gcc 3.3.x bug on Sparc64 */
+		float		val = seg_atof($1);
+
+		$$.ext = '\0';
+		$$.sigd = sig_digits($1);
+		$$.val = val;
+	}
+	| EXTENSION SEGFLOAT
+	{
+		/* temp variable avoids a gcc 3.3.x bug on Sparc64 */
+		float		val = seg_atof($2);
+
+		$$.ext = $1[0];
+		$$.sigd = sig_digits($2);
+		$$.val = val;
+	}
+	;
+
+deviation: SEGFLOAT
+	{
+		/* temp variable avoids a gcc 3.3.x bug on Sparc64 */
+		float		val = seg_atof($1);
+
+		$$.ext = '\0';
+		$$.sigd = sig_digits($1);
+		$$.val = val;
+	}
+	;
+
+%%
+
+
+static float
+seg_atof(const char *value)
+{
+	Datum		datum;
+
+	datum = DirectFunctionCall1(float4in, CStringGetDatum(value));
+	return DatumGetFloat4(datum);
+}
+
+static int
+sig_digits(const char *value)
+{
+	int			n = significant_digits(value);
+
+	/* Clamp, to ensure value will fit in sigd fields */
+	return Min(n, FLT_DIG);
+}
+
+
+#include "segscan.c"