On Fri, Nov 14, 2025 at 6:18 PM Chao Li <[email protected]> wrote: > As you added a semi-colon in the line, the one after the empty line can be > deleted, though C allows empty statement, but unnecessary, and may lead to > confusion for code readers.
> You missed to replace this pgac_cv__static_assert with the new name. Ugh, yeah, the configure change was hopeless. It looked like it worked in configure's stdout, which I mistook for success and posted too soon, sorry about that. I have fixed those points and verified that pg_config.h actually has the expected value. Thanks for the review!
From de0dbdd898a1c938c39d5a327d9bf1494960baff Mon Sep 17 00:00:00 2001 From: Thomas Munro <[email protected]> Date: Fri, 14 Nov 2025 14:10:14 +1300 Subject: [PATCH v2] Refactor static_assert() support. In meson, HAVE__STATIC_ASSERT was really a test for GCC statement expressions, as needed for StaticAssertExpr() now that _Static_assert could be assumed to be available through our C11 requirement. This artificially prevented Visual Studio from being able to use static_assert() in other contexts. The configure script only tested for _Static_assert, which was tautological (we require C11), but also incorrectly triggered the assumption about statement expressions in c.h. Instead, make a new test for HAVE_STATEMENT_EXPRESSIONS, and use that to control only whether StaticAssertExpr() uses fallback code, not the other variants. This improves the quality of failure messages in the (much more common) other variants under Visual Studio. Also get rid of the two separate implementations for C++, since the C implementation is also also valid as C++11. While it is a stretch to apply HAVE_STATEMENT_EXPRESSIONS tested with $CC to a C++ compiler, the previous C++ coding assumed that the C++ compiler had them unconditionally, so it isn't a new stretch. In practice, the C and C++ compilers are very likely to agree, and if a combination is ever reported that falsifies this assumption we can always reconsider that. Reviewed-by: Chao Li <[email protected]> Discussion: https://postgr.es/m/CA%2BhUKGKvr0x_oGmQTUkx%3DODgSksT2EtgCA6LmGx_jQFG%3DsDUpg%40mail.gmail.com --- config/c-compiler.m4 | 26 +++++++++------------- configure | 18 +++++++-------- configure.ac | 2 +- meson.build | 10 +++------ src/include/c.h | 42 +++++++++-------------------------- src/include/pg_config.h.in | 6 ++--- src/include/regex/regcustom.h | 1 + 7 files changed, 38 insertions(+), 67 deletions(-) diff --git a/config/c-compiler.m4 b/config/c-compiler.m4 index 236a59e8536..f59bcdbfd01 100644 --- a/config/c-compiler.m4 +++ b/config/c-compiler.m4 @@ -114,23 +114,19 @@ fi])# PGAC_TYPE_128BIT_INT -# PGAC_C_STATIC_ASSERT -# -------------------- -# Check if the C compiler understands _Static_assert(), -# and define HAVE__STATIC_ASSERT if so. -# -# We actually check the syntax ({ _Static_assert(...) }), because we need -# gcc-style compound expressions to be able to wrap the thing into macros. -AC_DEFUN([PGAC_C_STATIC_ASSERT], -[AC_CACHE_CHECK(for _Static_assert, pgac_cv__static_assert, +# PGAC_C_STATEMENT_EXPRESSIONS +# ---------------------------- +# Check if the C compiler understands GCC statement expressions. +AC_DEFUN([PGAC_C_STATEMENT_EXPRESSIONS], +[AC_CACHE_CHECK(for statement expressions, pgac_cv__statement_expressions, [AC_LINK_IFELSE([AC_LANG_PROGRAM([], [({ _Static_assert(1, "foo"); })])], -[pgac_cv__static_assert=yes], -[pgac_cv__static_assert=no])]) -if test x"$pgac_cv__static_assert" = xyes ; then -AC_DEFINE(HAVE__STATIC_ASSERT, 1, - [Define to 1 if your compiler understands _Static_assert.]) -fi])# PGAC_C_STATIC_ASSERT +[pgac_cv__statement_expressions=yes], +[pgac_cv__statement_expressions=no])]) +if test x"$pgac_cv__statement_expressions" = xyes ; then +AC_DEFINE(HAVE_STATEMENT_EXPRESSIONS, 1, + [Define to 1 if your compiler understands statement expressions.]) +fi])# PGAC_C_STATEMENT_EXPRESSIONS diff --git a/configure b/configure index 3a0ed11fa8e..73b2e20d002 100755 --- a/configure +++ b/configure @@ -14714,9 +14714,9 @@ cat >>confdefs.h <<_ACEOF _ACEOF -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for _Static_assert" >&5 -$as_echo_n "checking for _Static_assert... " >&6; } -if ${pgac_cv__static_assert+:} false; then : +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for statement expressions" >&5 +$as_echo_n "checking for statement expressions... " >&6; } +if ${pgac_cv__statement_expressions+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -14731,18 +14731,18 @@ main () } _ACEOF if ac_fn_c_try_link "$LINENO"; then : - pgac_cv__static_assert=yes + pgac_cv__statement_expressions=yes else - pgac_cv__static_assert=no + pgac_cv__statement_expressions=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $pgac_cv__static_assert" >&5 -$as_echo "$pgac_cv__static_assert" >&6; } -if test x"$pgac_cv__static_assert" = xyes ; then +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $pgac_cv__statement_expressions" >&5 +$as_echo "$pgac_cv__statement_expressions" >&6; } +if test x"$pgac_cv__statement_expressions" = xyes ; then -$as_echo "#define HAVE__STATIC_ASSERT 1" >>confdefs.h +$as_echo "#define HAVE_STATEMENT_EXPRESSIONS 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for typeof" >&5 diff --git a/configure.ac b/configure.ac index c2413720a18..04d7377ebd2 100644 --- a/configure.ac +++ b/configure.ac @@ -1674,7 +1674,7 @@ m4_defun([AC_PROG_CC_STDC], []) dnl We don't want that. AC_C_BIGENDIAN AC_C_INLINE PGAC_PRINTF_ARCHETYPE -PGAC_C_STATIC_ASSERT +PGAC_C_STATEMENT_EXPRESSIONS PGAC_C_TYPEOF PGAC_C_TYPES_COMPATIBLE PGAC_C_BUILTIN_CONSTANT_P diff --git a/meson.build b/meson.build index c1e17aa3040..99f9e3aed37 100644 --- a/meson.build +++ b/meson.build @@ -1877,20 +1877,16 @@ if cc.compiles(''' endif -# Check if the C compiler understands _Static_assert(), -# and define HAVE__STATIC_ASSERT if so. -# -# We actually check the syntax ({ _Static_assert(...) }), because we need -# gcc-style compound expressions to be able to wrap the thing into macros. +# Check if the C compiler understands GCC-style statement expressions. if cc.compiles(''' int main(int arg, char **argv) { ({ _Static_assert(1, "foo"); }); } ''', - name: '_Static_assert', + name: 'statement expressions', args: test_c_args) - cdata.set('HAVE__STATIC_ASSERT', 1) + cdata.set('HAVE_STATEMENT_EXPRESSIONS', 1) endif diff --git a/src/include/c.h b/src/include/c.h index 757dfff4782..16bfe7081ef 100644 --- a/src/include/c.h +++ b/src/include/c.h @@ -59,6 +59,7 @@ #include "pg_config_os.h" /* config from include/port/PORTNAME.h */ /* System header files that should be available everywhere in Postgres */ +#include <assert.h> #include <inttypes.h> #include <stdio.h> #include <stdlib.h> @@ -914,52 +915,29 @@ pg_noreturn extern void ExceptionalCondition(const char *conditionName, * If the "condition" (a compile-time-constant expression) evaluates to false, * throw a compile error using the "errmessage" (a string literal). * - * C11 has _Static_assert(), and most C99 compilers already support that. For - * portability, we wrap it into StaticAssertDecl(). _Static_assert() is a + * We wrap static_assert() in StaticAssertDecl(), because it is a * "declaration", and so it must be placed where for example a variable * declaration would be valid. As long as we compile with * -Wno-declaration-after-statement, that also means it cannot be placed after * statements in a function. Macros StaticAssertStmt() and StaticAssertExpr() * make it safe to use as a statement or in an expression, respectively. * - * For compilers without _Static_assert(), we fall back on a kluge that - * assumes the compiler will complain about a negative width for a struct + * For compilers without GCC statement expressions, we fall back on a kluge + * that assumes the compiler will complain about a negative width for a struct * bit-field. This will not include a helpful error message, but it beats not * getting an error at all. */ -#ifndef __cplusplus -#ifdef HAVE__STATIC_ASSERT -#define StaticAssertDecl(condition, errmessage) \ - _Static_assert(condition, errmessage) -#define StaticAssertStmt(condition, errmessage) \ - do { _Static_assert(condition, errmessage); } while(0) -#define StaticAssertExpr(condition, errmessage) \ - ((void) ({ StaticAssertStmt(condition, errmessage); true; })) -#else /* !HAVE__STATIC_ASSERT */ -#define StaticAssertDecl(condition, errmessage) \ - extern void static_assert_func(int static_assert_failure[(condition) ? 1 : -1]) -#define StaticAssertStmt(condition, errmessage) \ - ((void) sizeof(struct { int static_assert_failure : (condition) ? 1 : -1; })) -#define StaticAssertExpr(condition, errmessage) \ - StaticAssertStmt(condition, errmessage) -#endif /* HAVE__STATIC_ASSERT */ -#else /* C++ */ -#if defined(__cpp_static_assert) && __cpp_static_assert >= 200410 #define StaticAssertDecl(condition, errmessage) \ static_assert(condition, errmessage) #define StaticAssertStmt(condition, errmessage) \ - static_assert(condition, errmessage) + do { static_assert(condition, errmessage); } while(0) +#ifdef HAVE_STATEMENT_EXPRESSIONS #define StaticAssertExpr(condition, errmessage) \ - ({ static_assert(condition, errmessage); }) -#else /* !__cpp_static_assert */ -#define StaticAssertDecl(condition, errmessage) \ - extern void static_assert_func(int static_assert_failure[(condition) ? 1 : -1]) -#define StaticAssertStmt(condition, errmessage) \ - do { struct static_assert_struct { int static_assert_failure : (condition) ? 1 : -1; }; } while(0) + ((void) ({ static_assert(condition, errmessage); true; })) +#else #define StaticAssertExpr(condition, errmessage) \ - ((void) ({ StaticAssertStmt(condition, errmessage); })) -#endif /* __cpp_static_assert */ -#endif /* C++ */ + ((void) sizeof(struct { int static_assert_failure : (condition) ? 1 : -1; })) +#endif /* HAVE_STATEMENT_EXPRESSIONS */ /* diff --git a/src/include/pg_config.h.in b/src/include/pg_config.h.in index b0b0cfdaf79..2c118228a84 100644 --- a/src/include/pg_config.h.in +++ b/src/include/pg_config.h.in @@ -385,6 +385,9 @@ /* Define to 1 if you have the `SSL_CTX_set_num_tickets' function. */ #undef HAVE_SSL_CTX_SET_NUM_TICKETS +/* Define to 1 if your compiler understands statement expressions. */ +#undef HAVE_STATEMENT_EXPRESSIONS + /* Define to 1 if you have the <stdint.h> header file. */ #undef HAVE_STDINT_H @@ -565,9 +568,6 @@ /* Define to 1 if you have __get_cpuid_count. */ #undef HAVE__GET_CPUID_COUNT -/* Define to 1 if your compiler understands _Static_assert. */ -#undef HAVE__STATIC_ASSERT - /* Define as the maximum alignment requirement of any C data type. */ #undef MAXIMUM_ALIGNOF diff --git a/src/include/regex/regcustom.h b/src/include/regex/regcustom.h index 1c0e92f168f..4557e7a62c0 100644 --- a/src/include/regex/regcustom.h +++ b/src/include/regex/regcustom.h @@ -53,6 +53,7 @@ #define FREE(p) pfree(VS(p)) #define REALLOC(p,n) repalloc_extended(VS(p),(n), MCXT_ALLOC_NO_OOM) #define INTERRUPT(re) CHECK_FOR_INTERRUPTS() +#undef assert #define assert(x) Assert(x) /* internal character type and related */ -- 2.51.1
