Remove unnecessary casts in printf format arguments (%zu/%zd)

Many of these are probably left over from before use of %zu/%zd was
portable.

Reviewed-by: Bertrand Drouvot <bertranddrouvot.pg@gmail.com>
Discussion: https://www.postgresql.org/message-id/flat/07fa29f9-42d7-4aac-8834-197918cbbab6%40eisentraut.org

diff --git a/src/backend/access/gist/gistutil.c b/src/backend/access/gist/gistutil.c
index 75272827837bc886eac7d20b82823687c32dee39..0a29a6013efa545c552ce59294cd302012ed934d 100644 (file)
--- a/src/backend/access/gist/gistutil.c
+++ b/src/backend/access/gist/gistutil.c
@@ -46,8 +46,8 @@ gistfillbuffer(Page page, IndexTuple *itup, int len, OffsetNumber off)
 
        l = PageAddItem(page, itup[i], sz, off, false, false);
        if (l == InvalidOffsetNumber)
-           elog(ERROR, "failed to add item to GiST index page, item %d out of %d, size %d bytes",
-                i, len, (int) sz);
+           elog(ERROR, "failed to add item to GiST index page, item %d out of %d, size %zu bytes",
+                i, len, sz);
        off++;
    }
 }

diff --git a/src/backend/access/gist/gistxlog.c b/src/backend/access/gist/gistxlog.c
index 3f5340b92068f68db06f5a35dd0e1b7fb9046e87..6484ca5e2cac236a7f0cf65122ea2c6fffe730b9 100644 (file)
--- a/src/backend/access/gist/gistxlog.c
+++ b/src/backend/access/gist/gistxlog.c
@@ -99,8 +99,7 @@ gistRedoPageUpdateRecord(XLogReaderState *record)
            itup = (IndexTuple) data;
            itupsize = IndexTupleSize(itup);
            if (!PageIndexTupleOverwrite(page, offnum, itup, itupsize))
-               elog(ERROR, "failed to add item to GiST index page, size %d bytes",
-                    (int) itupsize);
+               elog(ERROR, "failed to add item to GiST index page, size %zu bytes", itupsize);
            data += itupsize;
            /* should be nothing left after consuming 1 tuple */
            Assert(data - begin == datalen);
@@ -135,8 +134,7 @@ gistRedoPageUpdateRecord(XLogReaderState *record)
 
                l = PageAddItem(page, itup, sz, off, false, false);
                if (l == InvalidOffsetNumber)
-                   elog(ERROR, "failed to add item to GiST index page, size %d bytes",
-                        (int) sz);
+                   elog(ERROR, "failed to add item to GiST index page, size %zu bytes", sz);
                off++;
                ninserted++;
            }

diff --git a/src/backend/access/hash/hash_xlog.c b/src/backend/access/hash/hash_xlog.c
index 923cab445075fe548749b66a449b3f64f6ec74a9..b3c0294884c07c6f944a918b2e68928339a8e108 100644 (file)
--- a/src/backend/access/hash/hash_xlog.c
+++ b/src/backend/access/hash/hash_xlog.c
@@ -557,8 +557,7 @@ hash_xlog_move_page_contents(XLogReaderState *record)
 
                l = PageAddItem(writepage, itup, itemsz, towrite[ninserted], false, false);
                if (l == InvalidOffsetNumber)
-                   elog(ERROR, "hash_xlog_move_page_contents: failed to add item to hash index page, size %d bytes",
-                        (int) itemsz);
+                   elog(ERROR, "hash_xlog_move_page_contents: failed to add item to hash index page, size %zu bytes", itemsz);
 
                ninserted++;
            }
@@ -689,8 +688,7 @@ hash_xlog_squeeze_page(XLogReaderState *record)
 
                l = PageAddItem(writepage, itup, itemsz, towrite[ninserted], false, false);
                if (l == InvalidOffsetNumber)
-                   elog(ERROR, "hash_xlog_squeeze_page: failed to add item to hash index page, size %d bytes",
-                        (int) itemsz);
+                   elog(ERROR, "hash_xlog_squeeze_page: failed to add item to hash index page, size %zu bytes", itemsz);
 
                ninserted++;
            }

diff --git a/src/backend/backup/basebackup_server.c b/src/backend/backup/basebackup_server.c
index f5c0c61640a9416895d7d85aee4b1c8a02c6e345..7678c6a231d98bacb48a8eebbfe9763d4d347c50 100644 (file)
--- a/src/backend/backup/basebackup_server.c
+++ b/src/backend/backup/basebackup_server.c
@@ -176,9 +176,9 @@ bbsink_server_archive_contents(bbsink *sink, size_t len)
        /* short write: complain appropriately */
        ereport(ERROR,
                (errcode(ERRCODE_DISK_FULL),
-                errmsg("could not write file \"%s\": wrote only %d of %d bytes at offset %u",
+                errmsg("could not write file \"%s\": wrote only %d of %zu bytes at offset %u",
                        FilePathName(mysink->file),
-                       nbytes, (int) len, (unsigned) mysink->filepos),
+                       nbytes, len, (unsigned) mysink->filepos),
                 errhint("Check free disk space.")));
    }
 
@@ -269,9 +269,9 @@ bbsink_server_manifest_contents(bbsink *sink, size_t len)
        /* short write: complain appropriately */
        ereport(ERROR,
                (errcode(ERRCODE_DISK_FULL),
-                errmsg("could not write file \"%s\": wrote only %d of %d bytes at offset %u",
+                errmsg("could not write file \"%s\": wrote only %d of %zu bytes at offset %u",
                        FilePathName(mysink->file),
-                       nbytes, (int) len, (unsigned) mysink->filepos),
+                       nbytes, len, (unsigned) mysink->filepos),
                 errhint("Check free disk space.")));
    }
 

diff --git a/src/backend/libpq/auth.c b/src/backend/libpq/auth.c
index 5854a2433bb6a705e87ea23e88b09c165e8a0119..a9181cde87b438bfac00b7c7401bb85faf9d6920 100644 (file)
--- a/src/backend/libpq/auth.c
+++ b/src/backend/libpq/auth.c
@@ -998,8 +998,8 @@ pg_GSS_recvauth(Port *port)
        gbuf.length = buf.len;
        gbuf.value = buf.data;
 
-       elog(DEBUG4, "processing received GSS token of length %u",
-            (unsigned int) gbuf.length);
+       elog(DEBUG4, "processing received GSS token of length %zu",
+            gbuf.length);
 
        maj_stat = gss_accept_sec_context(&min_stat,
                                          &port->gss->ctx,
@@ -1017,9 +1017,9 @@ pg_GSS_recvauth(Port *port)
        pfree(buf.data);
 
        elog(DEBUG5, "gss_accept_sec_context major: %u, "
-            "minor: %u, outlen: %u, outflags: %x",
+            "minor: %u, outlen: %zu, outflags: %x",
             maj_stat, min_stat,
-            (unsigned int) port->gss->outbuf.length, gflags);
+            port->gss->outbuf.length, gflags);
 
        CHECK_FOR_INTERRUPTS();
 
@@ -1034,8 +1034,8 @@ pg_GSS_recvauth(Port *port)
            /*
             * Negotiation generated data to be sent to the client.
             */
-           elog(DEBUG4, "sending GSS response token of length %u",
-                (unsigned int) port->gss->outbuf.length);
+           elog(DEBUG4, "sending GSS response token of length %zu",
+                port->gss->outbuf.length);
 
            sendAuthRequest(port, AUTH_REQ_GSS_CONT,
                            port->gss->outbuf.value, port->gss->outbuf.length);

diff --git a/src/backend/libpq/pqcomm.c b/src/backend/libpq/pqcomm.c
index 25f739a6a17d45b18113ffd9461c2c99b2e5e185..77b62edafb7e871dc063bf5a1839af0f76862248 100644 (file)
--- a/src/backend/libpq/pqcomm.c
+++ b/src/backend/libpq/pqcomm.c
@@ -454,9 +454,9 @@ ListenServerPort(int family, const char *hostName, unsigned short portNumber,
        if (strlen(unixSocketPath) >= UNIXSOCK_PATH_BUFLEN)
        {
            ereport(LOG,
-                   (errmsg("Unix-domain socket path \"%s\" is too long (maximum %d bytes)",
+                   (errmsg("Unix-domain socket path \"%s\" is too long (maximum %zu bytes)",
                            unixSocketPath,
-                           (int) (UNIXSOCK_PATH_BUFLEN - 1))));
+                           (UNIXSOCK_PATH_BUFLEN - 1))));
            return STATUS_ERROR;
        }
        if (Lock_AF_UNIX(unixSocketDir, unixSocketPath) != STATUS_OK)

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 0abca9f803b74c65c79bb5b45250f1c21e169dd7..808909537e4cd912fa1f27aacb3ade1a9e86fd2a 100644 (file)
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -354,7 +354,7 @@ outDatum(StringInfo str, Datum value, int typlen, bool typbyval)
    if (typbyval)
    {
        s = (char *) (&value);
-       appendStringInfo(str, "%u [ ", (unsigned int) length);
+       appendStringInfo(str, "%zu [ ", length);
        for (Size i = 0; i < (Size) sizeof(Datum); i++)
            appendStringInfo(str, "%d ", (int) (s[i]));
        appendStringInfoChar(str, ']');
@@ -366,7 +366,7 @@ outDatum(StringInfo str, Datum value, int typlen, bool typbyval)
            appendStringInfoString(str, "0 [ ]");
        else
        {
-           appendStringInfo(str, "%u [ ", (unsigned int) length);
+           appendStringInfo(str, "%zu [ ", length);
            for (Size i = 0; i < length; i++)
                appendStringInfo(str, "%d ", (int) (s[i]));
            appendStringInfoChar(str, ']');

diff --git a/src/backend/storage/page/bufpage.c b/src/backend/storage/page/bufpage.c
index aac6e695954677c882ba80674ad4371e37b9810b..91c8e758b19b522a80cebc9665c7feece21f9db5 100644 (file)
--- a/src/backend/storage/page/bufpage.c
+++ b/src/backend/storage/page/bufpage.c
@@ -785,8 +785,8 @@ PageRepairFragmentation(Page page)
        if (totallen > (Size) (pd_special - pd_lower))
            ereport(ERROR,
                    (errcode(ERRCODE_DATA_CORRUPTED),
-                    errmsg("corrupted item lengths: total %u, available space %u",
-                           (unsigned int) totallen, pd_special - pd_lower)));
+                    errmsg("corrupted item lengths: total %zu, available space %u",
+                           totallen, pd_special - pd_lower)));
 
        compactify_tuples(itemidbase, nstorage, page, presorted);
    }
@@ -1088,8 +1088,8 @@ PageIndexTupleDelete(Page page, OffsetNumber offnum)
        offset != MAXALIGN(offset))
        ereport(ERROR,
                (errcode(ERRCODE_DATA_CORRUPTED),
-                errmsg("corrupted line pointer: offset = %u, size = %u",
-                       offset, (unsigned int) size)));
+                errmsg("corrupted line pointer: offset = %u, size = %zu",
+                       offset, size)));
 
    /* Amount of space to actually be deleted */
    size = MAXALIGN(size);
@@ -1229,8 +1229,8 @@ PageIndexMultiDelete(Page page, OffsetNumber *itemnos, int nitems)
            offset != MAXALIGN(offset))
            ereport(ERROR,
                    (errcode(ERRCODE_DATA_CORRUPTED),
-                    errmsg("corrupted line pointer: offset = %u, size = %u",
-                           offset, (unsigned int) size)));
+                    errmsg("corrupted line pointer: offset = %u, size = %zu",
+                           offset, size)));
 
        if (nextitm < nitems && offnum == itemnos[nextitm])
        {
@@ -1262,8 +1262,8 @@ PageIndexMultiDelete(Page page, OffsetNumber *itemnos, int nitems)
    if (totallen > (Size) (pd_special - pd_lower))
        ereport(ERROR,
                (errcode(ERRCODE_DATA_CORRUPTED),
-                errmsg("corrupted item lengths: total %u, available space %u",
-                       (unsigned int) totallen, pd_special - pd_lower)));
+                errmsg("corrupted item lengths: total %zu, available space %u",
+                       totallen, pd_special - pd_lower)));
 
    /*
     * Looks good. Overwrite the line pointers with the copy, from which we've
@@ -1326,8 +1326,8 @@ PageIndexTupleDeleteNoCompact(Page page, OffsetNumber offnum)
        offset != MAXALIGN(offset))
        ereport(ERROR,
                (errcode(ERRCODE_DATA_CORRUPTED),
-                errmsg("corrupted line pointer: offset = %u, size = %u",
-                       offset, (unsigned int) size)));
+                errmsg("corrupted line pointer: offset = %u, size = %zu",
+                       offset, size)));
 
    /* Amount of space to actually be deleted */
    size = MAXALIGN(size);

diff --git a/src/backend/utils/adt/array_expanded.c b/src/backend/utils/adt/array_expanded.c
index fc036d1eb3007b62634aaf8d1340effb739c5f75..23627114f57cf5bfcc51df8744d67627d52badc0 100644 (file)
--- a/src/backend/utils/adt/array_expanded.c
+++ b/src/backend/utils/adt/array_expanded.c
@@ -271,8 +271,8 @@ EA_get_flat_size(ExpandedObjectHeader *eohptr)
        if (!AllocSizeIsValid(nbytes))
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                    errmsg("array size exceeds the maximum allowed (%d)",
-                           (int) MaxAllocSize)));
+                    errmsg("array size exceeds the maximum allowed (%zu)",
+                           MaxAllocSize)));
    }
 
    if (dnulls)

diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c
index cc76bdde723619b9439b6945b23cc531d10ee936..24e5b2adea18565beb3625814ef38c6597cfa06f 100644 (file)
--- a/src/backend/utils/adt/arrayfuncs.c
+++ b/src/backend/utils/adt/arrayfuncs.c
@@ -333,8 +333,8 @@ array_in(PG_FUNCTION_ARGS)
            if (!AllocSizeIsValid(nbytes))
                ereturn(escontext, (Datum) 0,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                        errmsg("array size exceeds the maximum allowed (%d)",
-                               (int) MaxAllocSize)));
+                        errmsg("array size exceeds the maximum allowed (%zu)",
+                               MaxAllocSize)));
        }
    }
    if (hasnulls)
@@ -492,8 +492,8 @@ ReadArrayDimensions(char **srcptr, int *ndim_p, int *dim, int *lBound,
            pg_add_s32_overflow(ub, 1, &ub))
            ereturn(escontext, false,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                    errmsg("array size exceeds the maximum allowed (%d)",
-                           (int) MaxArraySize)));
+                    errmsg("array size exceeds the maximum allowed (%zu)",
+                           MaxArraySize)));
 
        dim[ndim] = ub;
        ndim++;
@@ -725,8 +725,8 @@ ReadArrayStr(char **srcptr,
                    if (maxitems >= MaxArraySize)
                        ereturn(escontext, false,
                                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                                errmsg("array size exceeds the maximum allowed (%d)",
-                                       (int) MaxArraySize)));
+                                errmsg("array size exceeds the maximum allowed (%zu)",
+                                       MaxArraySize)));
                    maxitems = Min(maxitems * 2, MaxArraySize);
                    values = repalloc_array(values, Datum, maxitems);
                    nulls = repalloc_array(nulls, bool, maxitems);
@@ -1531,8 +1531,8 @@ ReadArrayBinary(StringInfo buf,
            if (!AllocSizeIsValid(totbytes))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                        errmsg("array size exceeds the maximum allowed (%d)",
-                               (int) MaxAllocSize)));
+                        errmsg("array size exceeds the maximum allowed (%zu)",
+                               MaxAllocSize)));
        }
    }
    *hasnulls = hasnull;
@@ -2339,8 +2339,8 @@ array_set_element(Datum arraydatum,
                pg_add_s32_overflow(dim[0], addedbefore, &dim[0]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                        errmsg("array size exceeds the maximum allowed (%d)",
-                               (int) MaxArraySize)));
+                        errmsg("array size exceeds the maximum allowed (%zu)",
+                               MaxArraySize)));
            lb[0] = indx[0];
            if (addedbefore > 1)
                newhasnulls = true; /* will insert nulls */
@@ -2354,8 +2354,8 @@ array_set_element(Datum arraydatum,
                pg_add_s32_overflow(dim[0], addedafter, &dim[0]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                        errmsg("array size exceeds the maximum allowed (%d)",
-                               (int) MaxArraySize)));
+                        errmsg("array size exceeds the maximum allowed (%zu)",
+                               MaxArraySize)));
            if (addedafter > 1)
                newhasnulls = true; /* will insert nulls */
        }
@@ -2616,8 +2616,8 @@ array_set_element_expanded(Datum arraydatum,
                pg_add_s32_overflow(dim[0], addedbefore, &dim[0]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                        errmsg("array size exceeds the maximum allowed (%d)",
-                               (int) MaxArraySize)));
+                        errmsg("array size exceeds the maximum allowed (%zu)",
+                               MaxArraySize)));
            lb[0] = indx[0];
            dimschanged = true;
            if (addedbefore > 1)
@@ -2632,8 +2632,8 @@ array_set_element_expanded(Datum arraydatum,
                pg_add_s32_overflow(dim[0], addedafter, &dim[0]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                        errmsg("array size exceeds the maximum allowed (%d)",
-                               (int) MaxArraySize)));
+                        errmsg("array size exceeds the maximum allowed (%zu)",
+                               MaxArraySize)));
            dimschanged = true;
            if (addedafter > 1)
                newhasnulls = true; /* will insert nulls */
@@ -2893,8 +2893,8 @@ array_set_slice(Datum arraydatum,
                pg_add_s32_overflow(dim[i], 1, &dim[i]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                        errmsg("array size exceeds the maximum allowed (%d)",
-                               (int) MaxArraySize)));
+                        errmsg("array size exceeds the maximum allowed (%zu)",
+                               MaxArraySize)));
 
            lb[i] = lowerIndx[i];
        }
@@ -2947,8 +2947,8 @@ array_set_slice(Datum arraydatum,
                pg_add_s32_overflow(dim[0], addedbefore, &dim[0]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                        errmsg("array size exceeds the maximum allowed (%d)",
-                               (int) MaxArraySize)));
+                        errmsg("array size exceeds the maximum allowed (%zu)",
+                               MaxArraySize)));
            lb[0] = lowerIndx[0];
            if (addedbefore > 1)
                newhasnulls = true; /* will insert nulls */
@@ -2962,8 +2962,8 @@ array_set_slice(Datum arraydatum,
                pg_add_s32_overflow(dim[0], addedafter, &dim[0]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                        errmsg("array size exceeds the maximum allowed (%d)",
-                               (int) MaxArraySize)));
+                        errmsg("array size exceeds the maximum allowed (%zu)",
+                               MaxArraySize)));
            if (addedafter > 1)
                newhasnulls = true; /* will insert nulls */
        }
@@ -3303,8 +3303,8 @@ array_map(Datum arrayd,
            if (!AllocSizeIsValid(nbytes))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                        errmsg("array size exceeds the maximum allowed (%d)",
-                               (int) MaxAllocSize)));
+                        errmsg("array size exceeds the maximum allowed (%zu)",
+                               MaxAllocSize)));
        }
    }
 
@@ -3543,8 +3543,8 @@ construct_md_array(Datum *elems,
        if (!AllocSizeIsValid(nbytes))
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                    errmsg("array size exceeds the maximum allowed (%d)",
-                           (int) MaxAllocSize)));
+                    errmsg("array size exceeds the maximum allowed (%zu)",
+                           MaxAllocSize)));
    }
 
    /* Allocate and initialize result array */
@@ -5375,8 +5375,8 @@ accumArrayResult(ArrayBuildState *astate,
        if (!AllocSizeIsValid(astate->alen * sizeof(Datum)))
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                    errmsg("array size exceeds the maximum allowed (%d)",
-                           (int) MaxAllocSize)));
+                    errmsg("array size exceeds the maximum allowed (%zu)",
+                           MaxAllocSize)));
        astate->dvalues = (Datum *)
            repalloc(astate->dvalues, astate->alen * sizeof(Datum));
        astate->dnulls = (bool *)
@@ -6214,8 +6214,8 @@ array_fill_internal(ArrayType *dims, ArrayType *lbs,
            !AllocSizeIsValid(totbytes))
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                    errmsg("array size exceeds the maximum allowed (%d)",
-                           (int) MaxAllocSize)));
+                    errmsg("array size exceeds the maximum allowed (%zu)",
+                           MaxAllocSize)));
 
        /*
         * This addition can't overflow, but it might cause us to go past
@@ -6558,8 +6558,8 @@ array_replace_internal(ArrayType *array,
                if (!AllocSizeIsValid(nbytes))
                    ereport(ERROR,
                            (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-                            errmsg("array size exceeds the maximum allowed (%d)",
-                                   (int) MaxAllocSize)));
+                            errmsg("array size exceeds the maximum allowed (%zu)",
+                                   MaxAllocSize)));
            }
            nresult++;
        }

diff --git a/src/backend/utils/adt/varchar.c b/src/backend/utils/adt/varchar.c
index 3f40c9da1a0d5565316d2c8837acc1cda467b16c..39fc27e1f11f4dba05864c83ae4d334f5af1bda5 100644 (file)
--- a/src/backend/utils/adt/varchar.c
+++ b/src/backend/utils/adt/varchar.c
@@ -158,8 +158,8 @@ bpchar_input(const char *s, size_t len, int32 atttypmod, Node *escontext)
                if (s[j] != ' ')
                    ereturn(escontext, NULL,
                            (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
-                            errmsg("value too long for type character(%d)",
-                                   (int) maxlen)));
+                            errmsg("value too long for type character(%zu)",
+                                   maxlen)));
            }
 
            /*
@@ -472,8 +472,8 @@ varchar_input(const char *s, size_t len, int32 atttypmod, Node *escontext)
            if (s[j] != ' ')
                ereturn(escontext, NULL,
                        (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
-                        errmsg("value too long for type character varying(%d)",
-                               (int) maxlen)));
+                        errmsg("value too long for type character varying(%zu)",
+                               maxlen)));
        }
 
        len = mbmaxlen;

diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index c6484aea087c9f6f2ce43571b2bdc0e96140bf6a..d495ff15945487912f115de46a2b8375ac39d625 100644 (file)
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -1504,7 +1504,7 @@ InitializeGUCOptionsFromEnvironment(void)
                new_limit = 2048;
                source = PGC_S_DYNAMIC_DEFAULT;
            }
-           snprintf(limbuf, sizeof(limbuf), "%d", (int) new_limit);
+           snprintf(limbuf, sizeof(limbuf), "%zd", new_limit);
            SetConfigOption("max_stack_depth", limbuf,
                            PGC_POSTMASTER, source);
        }

diff --git a/src/bin/pg_combinebackup/write_manifest.c b/src/bin/pg_combinebackup/write_manifest.c
index 819a3fd0b7a6bb74a273d5d53616c2bf7c306438..c845175a82c71fae0f99ca3946814f83ed8e8a84 100644 (file)
--- a/src/bin/pg_combinebackup/write_manifest.c
+++ b/src/bin/pg_combinebackup/write_manifest.c
@@ -259,8 +259,8 @@ flush_manifest(manifest_writer *mwriter)
            if (wb < 0)
                pg_fatal("could not write file \"%s\": %m", mwriter->pathname);
            else
-               pg_fatal("could not write file \"%s\": wrote %d of %d",
-                        mwriter->pathname, (int) wb, mwriter->buf.len);
+               pg_fatal("could not write file \"%s\": wrote %zd of %d",
+                        mwriter->pathname, wb, mwriter->buf.len);
        }
 
        if (mwriter->still_checksumming &&

diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index c84b017f21b8f63fd3a930267409e9cbf40ce445..4a63f7392ae89674cb0611a5fbb68a7d42cafa24 100644 (file)
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -1346,8 +1346,8 @@ PrintTOCSummary(Archive *AHX)
    ahprintf(AH, ";     Dump Version: %d.%d-%d\n",
             ARCHIVE_MAJOR(AH->version), ARCHIVE_MINOR(AH->version), ARCHIVE_REV(AH->version));
    ahprintf(AH, ";     Format: %s\n", fmtName);
-   ahprintf(AH, ";     Integer: %d bytes\n", (int) AH->intSize);
-   ahprintf(AH, ";     Offset: %d bytes\n", (int) AH->offSize);
+   ahprintf(AH, ";     Integer: %zu bytes\n", AH->intSize);
+   ahprintf(AH, ";     Offset: %zu bytes\n", AH->offSize);
    if (AH->archiveRemoteVersion)
        ahprintf(AH, ";     Dumped from database version: %s\n",
                 AH->archiveRemoteVersion);
@@ -2307,8 +2307,7 @@ _discoverArchiveFormat(ArchiveHandle *AH)
        if (ferror(fh))
            pg_fatal("could not read input file: %m");
        else
-           pg_fatal("input file is too short (read %lu, expected 5)",
-                    (unsigned long) cnt);
+           pg_fatal("input file is too short (read %zu, expected 5)", cnt);
    }
 
    /* Save it, just in case we need it later */
@@ -4185,8 +4184,7 @@ ReadHead(ArchiveHandle *AH)
 
    AH->intSize = AH->ReadBytePtr(AH);
    if (AH->intSize > 32)
-       pg_fatal("sanity check on integer size (%lu) failed",
-                (unsigned long) AH->intSize);
+       pg_fatal("sanity check on integer size (%zu) failed", AH->intSize);
 
    if (AH->intSize > sizeof(int))
        pg_log_warning("archive was made on a machine with larger integers, some operations might fail");

diff --git a/src/bin/pg_rewind/libpq_source.c b/src/bin/pg_rewind/libpq_source.c
index e80edb7077e269131da1724490110419779bbb3a..575585357b78b948c4751d1e6bf9d98e512a885e 100644 (file)
--- a/src/bin/pg_rewind/libpq_source.c
+++ b/src/bin/pg_rewind/libpq_source.c
@@ -459,7 +459,7 @@ process_queued_fetch_requests(libpq_source *src)
 
        appendArrayEscapedString(&src->paths, rq->path);
        appendStringInfo(&src->offsets, INT64_FORMAT, (int64) rq->offset);
-       appendStringInfo(&src->lengths, INT64_FORMAT, (int64) rq->length);
+       appendStringInfo(&src->lengths, "%zu", rq->length);
    }
    appendStringInfoChar(&src->paths, '}');
    appendStringInfoChar(&src->offsets, '}');

diff --git a/src/bin/pg_rewind/local_source.c b/src/bin/pg_rewind/local_source.c
index 5a6e805c158336cd69831ee07dd1963f41b7e38f..8db1a8c44aa2107e2f99faf1157c091fb58ad222 100644 (file)
--- a/src/bin/pg_rewind/local_source.c
+++ b/src/bin/pg_rewind/local_source.c
@@ -112,8 +112,8 @@ local_queue_fetch_file(rewind_source *source, const char *path, size_t len)
     * check that the size of the file matches our earlier expectation.
     */
    if (written_len != len)
-       pg_fatal("size of source file \"%s\" changed concurrently: %d bytes expected, %d copied",
-                srcpath, (int) len, (int) written_len);
+       pg_fatal("size of source file \"%s\" changed concurrently: %zu bytes expected, %zu copied",
+                srcpath, len, written_len);
 
    if (close(srcfd) != 0)
        pg_fatal("could not close file \"%s\": %m", srcpath);

diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index e9364d04f76e77e3277039470635e9a0a7e33942..7837e01d83db489b9ea8907668e0724c965e21fd 100644 (file)
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -1035,8 +1035,8 @@ digestControlFile(ControlFileData *ControlFile, const char *content,
                  size_t size)
 {
    if (size != PG_CONTROL_FILE_SIZE)
-       pg_fatal("unexpected control file size %d, expected %d",
-                (int) size, PG_CONTROL_FILE_SIZE);
+       pg_fatal("unexpected control file size %zu, expected %d",
+                size, PG_CONTROL_FILE_SIZE);
 
    memcpy(ControlFile, content, sizeof(ControlFileData));
 

diff --git a/src/interfaces/libpq/fe-connect.c b/src/interfaces/libpq/fe-connect.c
index c3a2448dce54bbd24e43e2867536fc4c1e9cf3a7..03eeb3dcdb55099f445895c03df2ada453f9bafc 100644 (file)
--- a/src/interfaces/libpq/fe-connect.c
+++ b/src/interfaces/libpq/fe-connect.c
@@ -3094,9 +3094,9 @@ keep_going:                       /* We will come back to here until there is
                UNIXSOCK_PATH(portstr, thisport, ch->host);
                if (strlen(portstr) >= UNIXSOCK_PATH_BUFLEN)
                {
-                   libpq_append_conn_error(conn, "Unix-domain socket path \"%s\" is too long (maximum %d bytes)",
+                   libpq_append_conn_error(conn, "Unix-domain socket path \"%s\" is too long (maximum %zu bytes)",
                                            portstr,
-                                           (int) (UNIXSOCK_PATH_BUFLEN - 1));
+                                           (UNIXSOCK_PATH_BUFLEN - 1));
                    goto keep_going;
                }
 

diff --git a/src/interfaces/libpq/fe-misc.c b/src/interfaces/libpq/fe-misc.c
index dca44fdc5d2f3dda9e995bb239eced7fadffa2ce..39cf42538de4c0ae29a4aa56bebb25311649e98d 100644 (file)
--- a/src/interfaces/libpq/fe-misc.c
+++ b/src/interfaces/libpq/fe-misc.c
@@ -236,8 +236,8 @@ pqGetInt(int *result, size_t bytes, PGconn *conn)
            break;
        default:
            pqInternalNotice(&conn->noticeHooks,
-                            "integer of size %lu not supported by pqGetInt",
-                            (unsigned long) bytes);
+                            "integer of size %zu not supported by pqGetInt",
+                            bytes);
            return EOF;
    }
 
@@ -269,8 +269,8 @@ pqPutInt(int value, size_t bytes, PGconn *conn)
            break;
        default:
            pqInternalNotice(&conn->noticeHooks,
-                            "integer of size %lu not supported by pqPutInt",
-                            (unsigned long) bytes);
+                            "integer of size %zu not supported by pqPutInt",
+                            bytes);
            return EOF;
    }