MIME-Version: 1.0
References: <E1ts2ug-001xVQ-04@gemulon.postgresql.org>
 <CAApHDvqrhFfnetbcwgGkJ=z63T8HfQ_OyP=vX8BYiXyxFKt67w@mail.gmail.com>
 <6c00a8b2-0c40-44f0-b603-f6ae28b7694a@eisentraut.org>
 <CAApHDvqf4tKwE0oP8ybL2Eu-SD=C34pdZ9vVDSJwvqDXi88nUg@mail.gmail.com>
 <dc9665a8-987a-443d-ab18-f9865d21d034@eisentraut.org>
 <CAApHDvrFdXjbrV6KCx_GHKYSufUbNDYSsjppcJQiGOURfJE6qg@mail.gmail.com>
 <1244428.1752677780@sss.pgh.pa.us>
 <CAApHDvoOnd4PBNV0qyJVLmbWvWUjztzcMH5xY2AGp5Vov6XU3Q@mail.gmail.com>
 <1330026.1752722396@sss.pgh.pa.us>
 <CAApHDvp-WCUTDU767Lpjw3m698gS+mCrNAnTEppZiXixneVxGQ@mail.gmail.com>
 <1337097.1752726030@sss.pgh.pa.us>
In-Reply-To: <1337097.1752726030@sss.pgh.pa.us>
From: David Rowley <dgrowleyml@gmail.com>
Date: Mon, 21 Jul 2025 12:39:36 +1200
Message-ID: 
 <CAApHDvqH_gsb4UwHAQGy9w_oJYyB8y-esQbHNUoGsB668RZ9gQ@mail.gmail.com>
Subject: Re: pgsql: pg_logicalinspect: Fix possible crash when passing a
 directory p
To: Tom Lane <tgl@sss.pgh.pa.us>
Cc: Peter Eisentraut <peter@eisentraut.org>,
 pgsql-committers@lists.postgresql.org
Content-Type: multipart/mixed; boundary="000000000000905e7a063a65b618"
Archived-At: 
 <https://www.postgresql.org/message-id/CAApHDvqH_gsb4UwHAQGy9w_oJYyB8y-esQbHNUoGsB668RZ9gQ%40mail.gmail.com>
Precedence: bulk

--000000000000905e7a063a65b618
Content-Type: text/plain; charset="UTF-8"

On Thu, 17 Jul 2025 at 16:20, Tom Lane <tgl@sss.pgh.pa.us> wrote:
>
> David Rowley <dgrowleyml@gmail.com> writes:
> > Unsure what other repercussions there are of compiling with C11 and
> > have not looked into what it would take to adjust the meson build
> > scripts to default to that for MSVC builds.
>
> In theory there should be no repercussions, because we already
> support compiling with C11: C99 is a minimum not a maximum.

Oh, right.

> But I've not checked the meson scripts either.

The attached seems to work.

It's my first time hacking on meson build scripts. I was surprised to
see the "-std=c99" test just does not work for MSVC since the flag is
spelt "/std:c99" for that compiler. The reason it's not causing
trouble is due to the code compiling without that flag, so the test
that passes the flag is never executed.  For the test I added, I had
to use the MSVC naming convention, which seems fine as it's only run
when "cc.get_id() == 'msvc'".

I've not gone over the other users of __builtin_constant_p() to
replace them with the pg_builtin_constant(). That's probably a good
exercise to do as I'm not sure how well the MSVC _Generic trick works
or if there might be some expressions it doesn't work with.

I also opted not to have the pg_builtin_constant() macro return 0 when
it's unsupported as I was worred some code might make too many
assumptions about the variability of the expression if that were to
return false. I don't quite have a problem case in mind for that.
Doing it that way was mostly erring on the side of caution.

For now, I've left in a commented out "return NULL;". I get no
compiler warnings from that.

David

--000000000000905e7a063a65b618
Content-Type: application/octet-stream;
	name="v2-0001-Detect-elog-ERROR-can-t-return-in-MSVC-when-using.patch"
Content-Disposition: attachment;
	filename="v2-0001-Detect-elog-ERROR-can-t-return-in-MSVC-when-using.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mdcdeckl0>
X-Attachment-Id: f_mdcdeckl0
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--000000000000905e7a063a65b618--