Change internal integer representation of Value node

A Value node would store an integer as a long.  This causes needless
portability risks, as long can be of varying sizes.  Change it to use
int instead.  All code using this was already careful to only store
32-bit values anyway.

Reviewed-by: Michael Paquier <michael@paquier.xyz>

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 1785ea391863356c987269fefe975d498b592a09..fd8089195484f3536cc56a479ac698e246bac7c3 100644 (file)
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -3235,7 +3235,7 @@ _outValue(StringInfo str, const Value *value)
        switch (value->type)
        {
                case T_Integer:
-                       appendStringInfo(str, "%ld", value->val.ival);
+                       appendStringInfo(str, "%d", value->val.ival);
                        break;
                case T_Float:
 

diff --git a/src/backend/nodes/read.c b/src/backend/nodes/read.c
index 76414029d83cd466be3cbf0f56f34cd818bdc0f2..6e9fa45e37e37ff91c000e48d844d629b2b69f18 100644 (file)
--- a/src/backend/nodes/read.c
+++ b/src/backend/nodes/read.c
@@ -224,13 +224,9 @@ nodeTokenType(char *token, int length)
 
                errno = 0;
                val = strtol(token, &endptr, 10);
-               (void) val;                             /* avoid compiler warning if unused */
-               if (endptr != token + length || errno == ERANGE
-#ifdef HAVE_LONG_INT_64
-               /* if long > 32 bits, check for overflow of int4 */
-                       || val != (long) ((int32) val)
-#endif
-                       )
+               if (endptr != token + length || errno == ERANGE ||
+                       /* check for overflow of int */
+                       val != (int) val)
                        return T_Float;
                return T_Integer;
        }
@@ -387,9 +383,9 @@ nodeRead(char *token, int tok_len)
                case T_Integer:
 
                        /*
-                        * we know that the token terminates on a char atol will stop at
+                        * we know that the token terminates on a char atoi will stop at
                         */
-                       result = (Node *) makeInteger(atol(token));
+                       result = (Node *) makeInteger(atoi(token));
                        break;
                case T_Float:
                        {

diff --git a/src/backend/nodes/value.c b/src/backend/nodes/value.c
index 8f0428fce12c266371dbf14fed430ba2af9dc697..2a30307baf4b4c8560d1b22f664d3e0d1a2e2314 100644 (file)
--- a/src/backend/nodes/value.c
+++ b/src/backend/nodes/value.c
@@ -20,7 +20,7 @@
  *     makeInteger
  */
 Value *
-makeInteger(long i)
+makeInteger(int i)
 {
        Value      *v = makeNode(Value);
 

diff --git a/src/backend/parser/scan.l b/src/backend/parser/scan.l
index eedef7c00520f806e05f720bf9d434d1f32bb6dc..97d4dee6282859dc7f5f26069dae66e32e7b3b56 100644 (file)
--- a/src/backend/parser/scan.l
+++ b/src/backend/parser/scan.l
@@ -1216,12 +1216,9 @@ process_integer_literal(const char *token, YYSTYPE *lval)
 
        errno = 0;
        val = strtol(token, &endptr, 10);
-       if (*endptr != '\0' || errno == ERANGE
-#ifdef HAVE_LONG_INT_64
-       /* if long > 32 bits, check for overflow of int4 */
-               || val != (long) ((int32) val)
-#endif
-               )
+       if (*endptr != '\0' || errno == ERANGE ||
+               /* check for overflow of int */
+               val != (int) val)
        {
                /* integer too large, treat it as a float */
                lval->str = pstrdup(token);

diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index a4f9b3668e0d0958541b45bafa2270a816b90640..fc3e10c7509540d565b5fa58a47d935955993fa6 100644 (file)
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -6913,7 +6913,7 @@ flatten_set_variable_args(const char *name, List *args)
                switch (nodeTag(&con->val))
                {
                        case T_Integer:
-                               appendStringInfo(&buf, "%ld", intVal(&con->val));
+                               appendStringInfo(&buf, "%d", intVal(&con->val));
                                break;
                        case T_Float:
                                /* represented as a string, so just copy it */

diff --git a/src/include/nodes/value.h b/src/include/nodes/value.h
index 94d09e176eee58275fdf9f1682408c81b1b51463..1665714515373396eca661e8217760e3809d091a 100644 (file)
--- a/src/include/nodes/value.h
+++ b/src/include/nodes/value.h
@@ -34,7 +34,7 @@
  * better to use the more general representation.)
  *
  * Note that an integer-looking string will get lexed as T_Float if
- * the value is too large to fit in a 'long'.
+ * the value is too large to fit in an 'int'.
  *
  * Nulls, of course, don't need the value part at all.
  *----------------------
@@ -44,7 +44,7 @@ typedef struct Value
        NodeTag         type;                   /* tag appropriately (eg. T_String) */
        union ValUnion
        {
-               long            ival;           /* machine integer */
+               int                     ival;           /* machine integer */
                char       *str;                /* string */
        }                       val;
 } Value;
@@ -53,7 +53,7 @@ typedef struct Value
 #define floatVal(v)            atof(((Value *)(v))->val.str)
 #define strVal(v)              (((Value *)(v))->val.str)
 
-extern Value *makeInteger(long i);
+extern Value *makeInteger(int i);
 extern Value *makeFloat(char *numericStr);
 extern Value *makeString(char *str);
 extern Value *makeBitString(char *str);

diff --git a/src/interfaces/ecpg/preproc/pgc.l b/src/interfaces/ecpg/preproc/pgc.l
index e99b7ff5863177caa123cd6bd97ad0b9285a134e..ba1798c77eb252cbe3c82581b92a12107609fdcb 100644 (file)
--- a/src/interfaces/ecpg/preproc/pgc.l
+++ b/src/interfaces/ecpg/preproc/pgc.l
@@ -732,12 +732,9 @@ cppline                    {space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 
                                                errno = 0;
                                                val = strtol((char *)yytext, &endptr,10);
-                                               if (*endptr != '\0' || errno == ERANGE
-#ifdef HAVE_LONG_INT_64
-                                                       /* if long > 32 bits, check for overflow of int4 */
-                                                       || val != (long) ((int32) val)
-#endif
-                                                       )
+                                               if (*endptr != '\0' || errno == ERANGE ||
+                                                       /* check for overflow of int */
+                                                       val != (int) val)
                                                {
                                                        errno = 0;
                                                        base_yylval.str = mm_strdup(yytext);