Fix contrib/cube and contrib/seg to build with bison 3.0.

These modules used the YYPARSE_PARAM macro, which has been deprecated
by the bison folk since 1.875, and which they finally removed in 3.0.
Adjust the code to use the replacement facility, %parse-param, which
is a much better solution anyway since it allows specification of the
type of the extra parser parameter.  We can thus get rid of a lot of
unsightly casting.

Back-patch to all active branches, since somebody might try to build
a back branch with up-to-date tools.

diff --git a/contrib/cube/cube.c b/contrib/cube/cube.c
index 1d119ddbb50bda9b4f08bece60c4db24f652acb9..37cbfdd20b8e4db92793e8e3d85a3883d30d1545 100644 (file)
--- a/contrib/cube/cube.c
+++ b/contrib/cube/cube.c
@@ -26,8 +26,8 @@ PG_MODULE_MAGIC;
 #define ARRPTR(x)  ( (double *) ARR_DATA_PTR(x) )
 #define ARRNELEMS(x)  ArrayGetNItems( ARR_NDIM(x), ARR_DIMS(x))
 
-extern int     cube_yyparse();
-extern void cube_yyerror(const char *message);
+extern int     cube_yyparse(NDBOX **result);
+extern void cube_yyerror(NDBOX **result, const char *message);
 extern void cube_scanner_init(const char *str);
 extern void cube_scanner_finish(void);
 
@@ -158,12 +158,12 @@ Datum
 cube_in(PG_FUNCTION_ARGS)
 {
        char       *str = PG_GETARG_CSTRING(0);
-       void       *result;
+       NDBOX      *result;
 
        cube_scanner_init(str);
 
        if (cube_yyparse(&result) != 0)
-               cube_yyerror("bogus input");
+               cube_yyerror(&result, "bogus input");
 
        cube_scanner_finish();
 

diff --git a/contrib/cube/cubeparse.y b/contrib/cube/cubeparse.y
index 21fe5378773da012bd223f4437f02d248da6b6c6..d7205b824cb5c0f21c913b5746552898d8590327 100644 (file)
--- a/contrib/cube/cubeparse.y
+++ b/contrib/cube/cubeparse.y
@@ -1,10 +1,9 @@
 %{
+/* contrib/cube/cubeparse.y */
+
 /* NdBox = [(lowerleft),(upperright)] */
 /* [(xLL(1)...xLL(N)),(xUR(1)...xUR(n))] */
 
-/* contrib/cube/cubeparse.y */
-
-#define YYPARSE_PARAM result  /* need this to pass a pointer (void *) to yyparse */
 #define YYSTYPE char *
 #define YYDEBUG 1
 
@@ -28,8 +27,8 @@ extern int cube_yylex(void);
 static char *scanbuf;
 static int     scanbuflen;
 
-void cube_yyerror(const char *message);
-int cube_yyparse(void *result);
+extern int     cube_yyparse(NDBOX **result);
+extern void cube_yyerror(NDBOX **result, const char *message);
 
 static int delim_count(char *s, char delim);
 static NDBOX * write_box(unsigned int dim, char *str1, char *str2);
@@ -38,6 +37,7 @@ static NDBOX * write_point_as_box(char *s, int dim);
 %}
 
 /* BISON Declarations */
+%parse-param {NDBOX **result}
 %expect 0
 %name-prefix="cube_yy"
 
@@ -70,7 +70,7 @@ box: O_BRACKET paren_list COMMA paren_list C_BRACKET
                        YYABORT;
                }
 
-               *((void **)result) = write_box( dim, $2, $4 );
+               *result = write_box( dim, $2, $4 );
 
        }
 
@@ -97,7 +97,7 @@ box: O_BRACKET paren_list COMMA paren_list C_BRACKET
                        YYABORT;
                }
 
-               *((void **)result) = write_box( dim, $1, $3 );
+               *result = write_box( dim, $1, $3 );
        }
 
        | paren_list
@@ -114,7 +114,7 @@ box: O_BRACKET paren_list COMMA paren_list C_BRACKET
                        YYABORT;
                }
 
-               *((void **)result) = write_point_as_box($1, dim);
+               *result = write_point_as_box($1, dim);
        }
 
        | list
@@ -130,7 +130,7 @@ box: O_BRACKET paren_list COMMA paren_list C_BRACKET
                                                           CUBE_MAX_DIM)));
                        YYABORT;
                }
-               *((void **)result) = write_point_as_box($1, dim);
+               *result = write_point_as_box($1, dim);
        }
        ;
 

diff --git a/contrib/cube/cubescan.l b/contrib/cube/cubescan.l
index c1849301585aad1f1c021c52e5ddd1e91d9f5616..6898af48686d582d7cae5676419aa5d104d61fb2 100644 (file)
--- a/contrib/cube/cubescan.l
+++ b/contrib/cube/cubescan.l
@@ -55,7 +55,7 @@ float        ({integer}|{real})([eE]{integer})?
 %%
 
 void
-yyerror(const char *message)
+yyerror(NDBOX **result, const char *message)
 {
        if (*yytext == YY_END_OF_BUFFER_CHAR)
        {

diff --git a/contrib/seg/seg.c b/contrib/seg/seg.c
index 1c14c49fecab78e7f4da6be9f6e71489f371be6e..0cf9853060b4e127876cd6da267f93dcd0783009 100644 (file)
--- a/contrib/seg/seg.c
+++ b/contrib/seg/seg.c
@@ -23,8 +23,8 @@
 
 PG_MODULE_MAGIC;
 
-extern int     seg_yyparse();
-extern void seg_yyerror(const char *message);
+extern int     seg_yyparse(SEG *result);
+extern void seg_yyerror(SEG *result, const char *message);
 extern void seg_scanner_init(const char *str);
 extern void seg_scanner_finish(void);
 
@@ -126,7 +126,7 @@ seg_in(PG_FUNCTION_ARGS)
        seg_scanner_init(str);
 
        if (seg_yyparse(result) != 0)
-               seg_yyerror("bogus input");
+               seg_yyerror(result, "bogus input");
 
        seg_scanner_finish();
 

diff --git a/contrib/seg/segparse.y b/contrib/seg/segparse.y
index e6a0bad59125e1bad3324502ef5e153c254c5381..3fad9910bd54d382368a352d466ea2c203aa99c8 100644 (file)
--- a/contrib/seg/segparse.y
+++ b/contrib/seg/segparse.y
@@ -1,5 +1,5 @@
 %{
-#define YYPARSE_PARAM result  /* need this to pass a pointer (void *) to yyparse */
+/* contrib/seg/segparse.y */
 
 #include "postgres.h"
 
@@ -24,8 +24,8 @@ extern int seg_yylex(void);
 
 extern int significant_digits(char *str);              /* defined in seg.c */
 
-void seg_yyerror(const char *message);
-int seg_yyparse(void *result);
+extern int     seg_yyparse(SEG *result);
+extern void seg_yyerror(SEG *result, const char *message);
 
 static float seg_atof(char *value);
 
@@ -40,6 +40,7 @@ static char strbuf[25] = {
 %}
 
 /* BISON Declarations */
+%parse-param {SEG *result}
 %expect 0
 %name-prefix="seg_yy"
 
@@ -65,59 +66,59 @@ static char strbuf[25] = {
 
 range: boundary PLUMIN deviation
        {
-               ((SEG *)result)->lower = $1.val - $3.val;
-               ((SEG *)result)->upper = $1.val + $3.val;
-               sprintf(strbuf, "%g", ((SEG *)result)->lower);
-               ((SEG *)result)->l_sigd = Max(Min(6, significant_digits(strbuf)), Max($1.sigd, $3.sigd));
-               sprintf(strbuf, "%g", ((SEG *)result)->upper);
-               ((SEG *)result)->u_sigd = Max(Min(6, significant_digits(strbuf)), Max($1.sigd, $3.sigd));
-               ((SEG *)result)->l_ext = '\0';
-               ((SEG *)result)->u_ext = '\0';
+               result->lower = $1.val - $3.val;
+               result->upper = $1.val + $3.val;
+               sprintf(strbuf, "%g", result->lower);
+               result->l_sigd = Max(Min(6, significant_digits(strbuf)), Max($1.sigd, $3.sigd));
+               sprintf(strbuf, "%g", result->upper);
+               result->u_sigd = Max(Min(6, significant_digits(strbuf)), Max($1.sigd, $3.sigd));
+               result->l_ext = '\0';
+               result->u_ext = '\0';
        }
 
        | boundary RANGE boundary
        {
-               ((SEG *)result)->lower = $1.val;
-               ((SEG *)result)->upper = $3.val;
-               if ( ((SEG *)result)->lower > ((SEG *)result)->upper ) {
+               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",
-                                                       ((SEG *)result)->lower, ((SEG *)result)->upper)));
+                                                       result->lower, result->upper)));
 
                        YYERROR;
                }
-               ((SEG *)result)->l_sigd = $1.sigd;
-               ((SEG *)result)->u_sigd = $3.sigd;
-               ((SEG *)result)->l_ext = ( $1.ext ? $1.ext : '\0' );
-               ((SEG *)result)->u_ext = ( $3.ext ? $3.ext : '\0' );
+               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
        {
-               ((SEG *)result)->lower = $1.val;
-               ((SEG *)result)->upper = HUGE_VAL;
-               ((SEG *)result)->l_sigd = $1.sigd;
-               ((SEG *)result)->u_sigd = 0;
-               ((SEG *)result)->l_ext = ( $1.ext ? $1.ext : '\0' );
-               ((SEG *)result)->u_ext = '-';
+               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
        {
-               ((SEG *)result)->lower = -HUGE_VAL;
-               ((SEG *)result)->upper = $2.val;
-               ((SEG *)result)->l_sigd = 0;
-               ((SEG *)result)->u_sigd = $2.sigd;
-               ((SEG *)result)->l_ext = '-';
-               ((SEG *)result)->u_ext = ( $2.ext ? $2.ext : '\0' );
+               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
        {
-               ((SEG *)result)->lower = ((SEG *)result)->upper = $1.val;
-               ((SEG *)result)->l_sigd = ((SEG *)result)->u_sigd = $1.sigd;
-               ((SEG *)result)->l_ext = ((SEG *)result)->u_ext = ( $1.ext ? $1.ext : '\0' );
+               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' );
        }
        ;
 

diff --git a/contrib/seg/segscan.l b/contrib/seg/segscan.l
index e4feab39b379840ba24433342c3ba6350d106142..b1f54084f9fd1b1cd761d82892a2a6f143f36be0 100644 (file)
--- a/contrib/seg/segscan.l
+++ b/contrib/seg/segscan.l
@@ -54,7 +54,7 @@ float        ({integer}|{real})([eE]{integer})?
 %%
 
 void
-yyerror(const char *message)
+yyerror(SEG *result, const char *message)
 {
        if (*yytext == YY_END_OF_BUFFER_CHAR)
        {