static int flag_isoc94 = 0;
static int flag_isoc99 = 0;
static int flag_isoc11 = 0;
-static int flag_isoc2x = 0;
+static int flag_isoc23 = 0;
/* Install what the common builtins.def offers plus our local additions.
targetm.libc_has_function (function_c11_misc, NULL_TREE), true)
/* Like DEF_LIB_BUILTIN, except that the function is only a part of
- the standard in C2x or above. */
-#undef DEF_C2X_BUILTIN
-#define DEF_C2X_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ the standard in C23 or above. */
+#undef DEF_C23_BUILTIN
+#define DEF_C23_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
- true, true, !flag_isoc2x, ATTRS, \
- targetm.libc_has_function (function_c2x_misc, NULL_TREE), true)
+ true, true, !flag_isoc23, ATTRS, \
+ targetm.libc_has_function (function_c23_misc, NULL_TREE), true)
/* Like DEF_C99_BUILTIN, but for complex math functions. */
#undef DEF_C99_COMPL_BUILTIN
DEF_C99_BUILTIN (BUILT_IN_ERFL, "erfl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
DEF_EXT_LIB_FLOATN_NX_BUILTINS (BUILT_IN_ERF, "erf", COSH_TYPE, ATTR_MATHFN_FPROUNDING)
DEF_LIB_BUILTIN (BUILT_IN_EXP, "exp", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
-DEF_C2X_BUILTIN (BUILT_IN_EXP10, "exp10", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
-DEF_C2X_BUILTIN (BUILT_IN_EXP10F, "exp10f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
-DEF_C2X_BUILTIN (BUILT_IN_EXP10L, "exp10l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C23_BUILTIN (BUILT_IN_EXP10, "exp10", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C23_BUILTIN (BUILT_IN_EXP10F, "exp10f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C23_BUILTIN (BUILT_IN_EXP10L, "exp10l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
DEF_C99_BUILTIN (BUILT_IN_EXP2, "exp2", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
DEF_C99_BUILTIN (BUILT_IN_EXP2F, "exp2f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
DEF_C99_BUILTIN (BUILT_IN_EXP2L, "exp2l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
#define FABS_TYPE(F) BT_FN_##F##_##F
DEF_EXT_LIB_FLOATN_NX_BUILTINS (BUILT_IN_FABS, "fabs", FABS_TYPE, ATTR_CONST_NOTHROW_LEAF_LIST)
#undef FABS_TYPE
-DEF_C2X_BUILTIN (BUILT_IN_FABSD32, "fabsd32", BT_FN_DFLOAT32_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST)
-DEF_C2X_BUILTIN (BUILT_IN_FABSD64, "fabsd64", BT_FN_DFLOAT64_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST)
-DEF_C2X_BUILTIN (BUILT_IN_FABSD128, "fabsd128", BT_FN_DFLOAT128_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C23_BUILTIN (BUILT_IN_FABSD32, "fabsd32", BT_FN_DFLOAT32_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C23_BUILTIN (BUILT_IN_FABSD64, "fabsd64", BT_FN_DFLOAT64_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C23_BUILTIN (BUILT_IN_FABSD128, "fabsd128", BT_FN_DFLOAT128_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST)
DEF_C99_BUILTIN (BUILT_IN_FDIM, "fdim", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
DEF_C99_BUILTIN (BUILT_IN_FDIMF, "fdimf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
DEF_C99_BUILTIN (BUILT_IN_FDIML, "fdiml", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
DEF_C99_BUILTIN (BUILT_IN_NANL, "nanl", BT_FN_LONGDOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
#define NAN_TYPE(F) BT_FN_##F##_CONST_STRING
DEF_EXT_LIB_FLOATN_NX_BUILTINS (BUILT_IN_NAN, "nan", NAN_TYPE, ATTR_CONST_NOTHROW_NONNULL)
-DEF_C2X_BUILTIN (BUILT_IN_NAND32, "nand32", BT_FN_DFLOAT32_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
-DEF_C2X_BUILTIN (BUILT_IN_NAND64, "nand64", BT_FN_DFLOAT64_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
-DEF_C2X_BUILTIN (BUILT_IN_NAND128, "nand128", BT_FN_DFLOAT128_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_C23_BUILTIN (BUILT_IN_NAND32, "nand32", BT_FN_DFLOAT32_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_C23_BUILTIN (BUILT_IN_NAND64, "nand64", BT_FN_DFLOAT64_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_C23_BUILTIN (BUILT_IN_NAND128, "nand128", BT_FN_DFLOAT128_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
DEF_GCC_BUILTIN (BUILT_IN_NANS, "nans", BT_FN_DOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
DEF_GCC_BUILTIN (BUILT_IN_NANSF, "nansf", BT_FN_FLOAT_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
DEF_GCC_BUILTIN (BUILT_IN_NANSL, "nansl", BT_FN_LONGDOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
#define RINT_TYPE(F) BT_FN_##F##_##F
DEF_EXT_LIB_FLOATN_NX_BUILTINS (BUILT_IN_RINT, "rint", RINT_TYPE, ATTR_CONST_NOTHROW_LEAF_LIST)
#undef RINT_TYPE
-DEF_C2X_BUILTIN (BUILT_IN_ROUNDEVEN, "roundeven", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
-DEF_C2X_BUILTIN (BUILT_IN_ROUNDEVENF, "roundevenf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
-DEF_C2X_BUILTIN (BUILT_IN_ROUNDEVENL, "roundevenl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C23_BUILTIN (BUILT_IN_ROUNDEVEN, "roundeven", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C23_BUILTIN (BUILT_IN_ROUNDEVENF, "roundevenf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C23_BUILTIN (BUILT_IN_ROUNDEVENL, "roundevenl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
DEF_C99_BUILTIN (BUILT_IN_ROUND, "round", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
DEF_C99_BUILTIN (BUILT_IN_ROUNDF, "roundf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
DEF_C99_BUILTIN (BUILT_IN_ROUNDL, "roundl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
DEF_LIB_BUILTIN (BUILT_IN_STRCMP, "strcmp", BT_FN_INT_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF)
DEF_LIB_BUILTIN (BUILT_IN_STRCPY, "strcpy", BT_FN_STRING_STRING_CONST_STRING, ATTR_NOTHROW_NONNULL_LEAF)
DEF_LIB_BUILTIN (BUILT_IN_STRCSPN, "strcspn", BT_FN_SIZE_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF)
-DEF_C2X_BUILTIN (BUILT_IN_STRDUP, "strdup", BT_FN_STRING_CONST_STRING, ATTR_MALLOC_WARN_UNUSED_RESULT_NOTHROW_NONNULL_LEAF)
-DEF_C2X_BUILTIN (BUILT_IN_STRNDUP, "strndup", BT_FN_STRING_CONST_STRING_SIZE, ATTR_MALLOC_WARN_UNUSED_RESULT_NOTHROW_NONNULL_LEAF)
+DEF_C23_BUILTIN (BUILT_IN_STRDUP, "strdup", BT_FN_STRING_CONST_STRING, ATTR_MALLOC_WARN_UNUSED_RESULT_NOTHROW_NONNULL_LEAF)
+DEF_C23_BUILTIN (BUILT_IN_STRNDUP, "strndup", BT_FN_STRING_CONST_STRING_SIZE, ATTR_MALLOC_WARN_UNUSED_RESULT_NOTHROW_NONNULL_LEAF)
DEF_LIB_BUILTIN (BUILT_IN_STRLEN, "strlen", BT_FN_SIZE_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF)
DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCASECMP, "strncasecmp", BT_FN_INT_CONST_STRING_CONST_STRING_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF)
DEF_LIB_BUILTIN (BUILT_IN_STRNCAT, "strncat", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
int flag_isoc11;
-/* Nonzero means use the ISO C2X dialect of C. */
+/* Nonzero means use the ISO C23 dialect of C. */
-int flag_isoc2x;
+int flag_isoc23;
/* Nonzero means that we have builtin functions, and main is an int. */
if they match the mask.
Masks for languages:
- C --std=c89: D_C99 | D_C2X | D_CXXONLY | D_OBJC | D_CXX_OBJC
- C --std=c99: D_C2X | D_CXXONLY | D_OBJC
- C --std=c17: D_C2X | D_CXXONLY | D_OBJC
- C --std=c2x: D_CXXONLY | D_OBJC
+ C --std=c89: D_C99 | D_C23 | D_CXXONLY | D_OBJC | D_CXX_OBJC
+ C --std=c99: D_C23 | D_CXXONLY | D_OBJC
+ C --std=c17: D_C23 | D_CXXONLY | D_OBJC
+ C --std=c23: D_CXXONLY | D_OBJC
ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
C++ --std=c++98: D_CONLY | D_CXX11 | D_CXX20 | D_OBJC
C++ --std=c++11: D_CONLY | D_CXX20 | D_OBJC
{ "__GIMPLE", RID_GIMPLE, D_CONLY },
{ "__PHI", RID_PHI, D_CONLY },
{ "__RTL", RID_RTL, D_CONLY },
- { "alignas", RID_ALIGNAS, D_C2X | D_CXX11 | D_CXXWARN },
- { "alignof", RID_ALIGNOF, D_C2X | D_CXX11 | D_CXXWARN },
+ { "alignas", RID_ALIGNAS, D_C23 | D_CXX11 | D_CXXWARN },
+ { "alignof", RID_ALIGNOF, D_C23 | D_CXX11 | D_CXXWARN },
{ "asm", RID_ASM, D_ASM },
{ "auto", RID_AUTO, 0 },
- { "bool", RID_BOOL, D_C2X | D_CXXWARN },
+ { "bool", RID_BOOL, D_C23 | D_CXXWARN },
{ "break", RID_BREAK, 0 },
{ "case", RID_CASE, 0 },
{ "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN },
{ "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN },
{ "const", RID_CONST, 0 },
{ "consteval", RID_CONSTEVAL, D_CXXONLY | D_CXX20 | D_CXXWARN },
- { "constexpr", RID_CONSTEXPR, D_C2X | D_CXX11 | D_CXXWARN },
+ { "constexpr", RID_CONSTEXPR, D_C23 | D_CXX11 | D_CXXWARN },
{ "constinit", RID_CONSTINIT, D_CXXONLY | D_CXX20 | D_CXXWARN },
{ "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN },
{ "continue", RID_CONTINUE, 0 },
{ "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN },
{ "export", RID_EXPORT, D_CXXONLY | D_CXXWARN },
{ "extern", RID_EXTERN, 0 },
- { "false", RID_FALSE, D_C2X | D_CXXWARN },
+ { "false", RID_FALSE, D_C23 | D_CXXWARN },
{ "float", RID_FLOAT, 0 },
{ "for", RID_FOR, 0 },
{ "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN },
{ "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
{ "new", RID_NEW, D_CXXONLY | D_CXXWARN },
{ "noexcept", RID_NOEXCEPT, D_CXXONLY | D_CXX11 | D_CXXWARN },
- { "nullptr", RID_NULLPTR, D_C2X | D_CXX11 | D_CXXWARN },
+ { "nullptr", RID_NULLPTR, D_C23 | D_CXX11 | D_CXXWARN },
{ "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
{ "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
{ "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
{ "signed", RID_SIGNED, 0 },
{ "sizeof", RID_SIZEOF, 0 },
{ "static", RID_STATIC, 0 },
- { "static_assert", RID_STATIC_ASSERT, D_C2X | D_CXX11 | D_CXXWARN },
+ { "static_assert", RID_STATIC_ASSERT, D_C23 | D_CXX11 | D_CXXWARN },
{ "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN },
{ "struct", RID_STRUCT, 0 },
{ "switch", RID_SWITCH, 0 },
{ "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN },
{ "this", RID_THIS, D_CXXONLY | D_CXXWARN },
- { "thread_local", RID_THREAD, D_C2X | D_CXX11 | D_CXXWARN },
+ { "thread_local", RID_THREAD, D_C23 | D_CXX11 | D_CXXWARN },
{ "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN },
- { "true", RID_TRUE, D_C2X | D_CXXWARN },
+ { "true", RID_TRUE, D_C23 | D_CXXWARN },
{ "try", RID_TRY, D_CXX_OBJC | D_CXXWARN },
{ "typedef", RID_TYPEDEF, 0 },
{ "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN },
{ "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN },
{ "typeof", RID_TYPEOF, D_EXT11 },
- { "typeof_unqual", RID_TYPEOF_UNQUAL, D_CONLY | D_C2X },
+ { "typeof_unqual", RID_TYPEOF_UNQUAL, D_CONLY | D_C23 },
{ "union", RID_UNION, 0 },
{ "unsigned", RID_UNSIGNED, 0 },
{ "using", RID_USING, D_CXXONLY | D_CXXWARN },
#define D_CONLY 0x0001 /* C only (not in C++). */
#define D_CXXONLY 0x0002 /* C++ only (not in C). */
#define D_C99 0x0004 /* In C, C99 only. */
-#define D_C2X 0x0008 /* In C, C2X only. */
+#define D_C23 0x0008 /* In C, C23 only. */
#define D_CXX11 0x0010 /* In C++, C++11 only. */
#define D_EXT 0x0020 /* GCC extension. */
#define D_EXT89 0x0040 /* GCC extension incorporated in C99. */
-#define D_EXT11 0x0080 /* GCC extension incorporated in C2X. */
+#define D_EXT11 0x0080 /* GCC extension incorporated in C23. */
#define D_ASM 0x0100 /* Disabled by -fno-asm. */
#define D_OBJC 0x0200 /* In Objective C and neither C nor C++. */
#define D_CXX_OBJC 0x0400 /* In Objective C, and C++, but not C. */
enum c_language_kind
{
- clk_c = 0, /* C90, C94, C99, C11 or C2X */
+ clk_c = 0, /* C90, C94, C99, C11 or C23 */
clk_objc = 1, /* clk_c with ObjC features. */
clk_cxx = 2, /* ANSI/ISO C++ */
clk_objcxx = 3 /* clk_cxx with ObjC features. */
extern int flag_isoc11;
-/* Nonzero means use the ISO C2X dialect of C. */
+/* Nonzero means use the ISO C23 dialect of C. */
-extern int flag_isoc2x;
+extern int flag_isoc23;
/* Nonzero means that we have builtin functions, and main is an int. */
underlying type is determined in different ways, depending on the
properties of the enum:
- - In C++0x or C2x, the underlying type can be explicitly specified, e.g.,
+ - In C++0x or C23, the underlying type can be explicitly specified, e.g.,
enum E1 : char { ... } // underlying type is char
/* The difference between 1 and the least value greater than 1 that is
representable in the given floating point type, b**(1-p). */
sprintf (name, "__%s_EPSILON__", name_prefix);
- if (fmt->pnan < fmt->p && (c_dialect_cxx () || !flag_isoc2x))
+ if (fmt->pnan < fmt->p && (c_dialect_cxx () || !flag_isoc23))
/* This is an IBM extended double format, so 1.0 + any double is
representable precisely. */
sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
builtin_define_with_int_value (name, 1);
}
- /* For C2x *_IS_IEC_60559. 0 means the type does not match an IEC
+ /* For C23 *_IS_IEC_60559. 0 means the type does not match an IEC
60559 format, 1 that it matches a format but not necessarily
operations. */
sprintf (name, "__%s_IS_IEC_60559__", name_prefix);
/* The C standard version we are checking formats against when pedantic. */
#define C_STD_VER ((int) (c_dialect_cxx () \
? CPLUSPLUS_STD_VER \
- : (flag_isoc2x \
- ? STD_C2X \
+ : (flag_isoc23 \
+ ? STD_C23 \
: (flag_isoc99 \
? STD_C99 \
: (flag_isoc94 ? STD_C94 : STD_C89)))))
: "ISO C++11") \
: ((FEATURE_VER) == STD_EXT \
? "ISO C" \
- : ((FEATURE_VER) == STD_C2X \
+ : ((FEATURE_VER) == STD_C23 \
? "ISO C17" \
: "ISO C90")))
/* Adjust a C standard version, which may be STD_C9L, to account for
{ "Z", FMT_LEN_z, STD_EXT, NO_FMT, 0 },
{ "t", FMT_LEN_t, STD_C99, NO_FMT, 0 },
{ "j", FMT_LEN_j, STD_C99, NO_FMT, 0 },
- { "H", FMT_LEN_H, STD_C2X, NO_FMT, 0 },
- { "D", FMT_LEN_D, STD_C2X, "DD", FMT_LEN_DD, STD_C2X, 0 },
- { "w8", FMT_LEN_w8, STD_C2X, NO_FMT, 0 },
- { "w16", FMT_LEN_w16, STD_C2X, NO_FMT, 0 },
- { "w32", FMT_LEN_w32, STD_C2X, NO_FMT, 0 },
- { "w64", FMT_LEN_w64, STD_C2X, NO_FMT, 0 },
- { "wf8", FMT_LEN_wf8, STD_C2X, NO_FMT, 0 },
- { "wf16", FMT_LEN_wf16, STD_C2X, NO_FMT, 0 },
- { "wf32", FMT_LEN_wf32, STD_C2X, NO_FMT, 0 },
- { "wf64", FMT_LEN_wf64, STD_C2X, NO_FMT, 0 },
+ { "H", FMT_LEN_H, STD_C23, NO_FMT, 0 },
+ { "D", FMT_LEN_D, STD_C23, "DD", FMT_LEN_DD, STD_C23, 0 },
+ { "w8", FMT_LEN_w8, STD_C23, NO_FMT, 0 },
+ { "w16", FMT_LEN_w16, STD_C23, NO_FMT, 0 },
+ { "w32", FMT_LEN_w32, STD_C23, NO_FMT, 0 },
+ { "w64", FMT_LEN_w64, STD_C23, NO_FMT, 0 },
+ { "wf8", FMT_LEN_wf8, STD_C23, NO_FMT, 0 },
+ { "wf16", FMT_LEN_wf16, STD_C23, NO_FMT, 0 },
+ { "wf32", FMT_LEN_wf32, STD_C23, NO_FMT, 0 },
+ { "wf64", FMT_LEN_wf64, STD_C23, NO_FMT, 0 },
{ NO_FMT, NO_FMT, 0 }
};
{ "z", FMT_LEN_z, STD_C99, NO_FMT, 0 },
{ "t", FMT_LEN_t, STD_C99, NO_FMT, 0 },
{ "j", FMT_LEN_j, STD_C99, NO_FMT, 0 },
- { "H", FMT_LEN_H, STD_C2X, NO_FMT, 0 },
- { "D", FMT_LEN_D, STD_C2X, "DD", FMT_LEN_DD, STD_C2X, 0 },
- { "w8", FMT_LEN_w8, STD_C2X, NO_FMT, 0 },
- { "w16", FMT_LEN_w16, STD_C2X, NO_FMT, 0 },
- { "w32", FMT_LEN_w32, STD_C2X, NO_FMT, 0 },
- { "w64", FMT_LEN_w64, STD_C2X, NO_FMT, 0 },
- { "wf8", FMT_LEN_wf8, STD_C2X, NO_FMT, 0 },
- { "wf16", FMT_LEN_wf16, STD_C2X, NO_FMT, 0 },
- { "wf32", FMT_LEN_wf32, STD_C2X, NO_FMT, 0 },
- { "wf64", FMT_LEN_wf64, STD_C2X, NO_FMT, 0 },
+ { "H", FMT_LEN_H, STD_C23, NO_FMT, 0 },
+ { "D", FMT_LEN_D, STD_C23, "DD", FMT_LEN_DD, STD_C23, 0 },
+ { "w8", FMT_LEN_w8, STD_C23, NO_FMT, 0 },
+ { "w16", FMT_LEN_w16, STD_C23, NO_FMT, 0 },
+ { "w32", FMT_LEN_w32, STD_C23, NO_FMT, 0 },
+ { "w64", FMT_LEN_w64, STD_C23, NO_FMT, 0 },
+ { "wf8", FMT_LEN_wf8, STD_C23, NO_FMT, 0 },
+ { "wf16", FMT_LEN_wf16, STD_C23, NO_FMT, 0 },
+ { "wf32", FMT_LEN_wf32, STD_C23, NO_FMT, 0 },
+ { "wf64", FMT_LEN_wf64, STD_C23, NO_FMT, 0 },
{ NO_FMT, NO_FMT, 0 }
};
{ 'E', 0, 0, 0, N_("'E' modifier"), N_("the 'E' strftime modifier"), STD_C99 },
{ 'O', 0, 0, 0, N_("'O' modifier"), N_("the 'O' strftime modifier"), STD_C99 },
{ 'O', 'o', 0, 0, NULL, N_("the 'O' modifier"), STD_EXT },
- { 'O', 'p', 0, 0, NULL, N_("the 'O' modifier"), STD_C2X },
+ { 'O', 'p', 0, 0, NULL, N_("the 'O' modifier"), STD_C23 },
{ 0, 0, 0, 0, NULL, NULL, STD_C89 }
};
/* C99 conversion specifiers. */
{ "F", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN, T2X_D32, T2X_D64, T2X_D128, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0 +#'I", "", NULL },
{ "aA", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN, T2X_D32, T2X_D64, T2X_D128, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0 +#", "", NULL },
- /* C2X conversion specifiers. */
- { "bB", 0, STD_C2X, { T2X_UI, T2X_UC, T2X_US, T2X_UL, T2X_ULL, TEX_ULL, T2X_ST, T2X_UPD, T2X_UIM, BADLEN, BADLEN, BADLEN, T2X_U8, T2X_U16, T2X_U32, T2X_U64, T2X_UF8, T2X_UF16, T2X_UF32, T2X_UF64 }, "-wp0#", "i", NULL },
+ /* C23 conversion specifiers. */
+ { "bB", 0, STD_C23, { T2X_UI, T2X_UC, T2X_US, T2X_UL, T2X_ULL, TEX_ULL, T2X_ST, T2X_UPD, T2X_UIM, BADLEN, BADLEN, BADLEN, T2X_U8, T2X_U16, T2X_U32, T2X_U64, T2X_UF8, T2X_UF16, T2X_UF32, T2X_UF64 }, "-wp0#", "i", NULL },
/* X/Open conversion specifiers. */
{ "C", 0, STD_EXT, { TEX_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "", NULL },
{ "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "R", NULL },
/* C99 conversion specifiers. */
{ "F", 1, STD_C99, { T99_F, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN, T2X_D32, T2X_D64, T2X_D128, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w'", "W", NULL },
{ "aA", 1, STD_C99, { T99_F, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN, T2X_D32, T2X_D64, T2X_D128, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w'", "W", NULL },
- /* C2X conversion specifiers. */
- { "b", 1, STD_C2X, { T2X_UI, T2X_UC, T2X_US, T2X_UL, T2X_ULL, TEX_ULL, T2X_ST, T2X_UPD, T2X_UIM, BADLEN, BADLEN, BADLEN, T2X_U8, T2X_U16, T2X_U32, T2X_U64, T2X_UF8, T2X_UF16, T2X_UF32, T2X_UF64 }, "*w", "W", NULL },
+ /* C23 conversion specifiers. */
+ { "b", 1, STD_C23, { T2X_UI, T2X_UC, T2X_US, T2X_UL, T2X_ULL, TEX_ULL, T2X_ST, T2X_UPD, T2X_UIM, BADLEN, BADLEN, BADLEN, T2X_U8, T2X_U16, T2X_U32, T2X_U64, T2X_UF8, T2X_UF16, T2X_UF32, T2X_UF64 }, "*w", "W", NULL },
/* X/Open conversion specifiers. */
{ "C", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*mw", "W", NULL },
{ "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*amw", "W", NULL },
STD_C94,
STD_C9L, /* C99, but treat as C89 if -Wno-long-long. */
STD_C99,
- STD_C2X,
+ STD_C23,
STD_EXT
};
two digit year formats, "3" for strftime formats giving two digit
years in some locales, "4" for "2" which becomes "3" with an "E" modifier,
"o" if use of strftime "O" is a GNU extension beyond C99,
- "p" if use of strftime "O" is a C2x feature,
+ "p" if use of strftime "O" is a C23 feature,
"W" if the argument is a pointer which is dereferenced and written into,
"R" if the argument is a pointer which is dereferenced and read from,
"i" for printf integer formats where the '0' flag is ignored with
#define T89_S { STD_C89, NULL, T_S }
#define T_UI &unsigned_type_node
#define T89_UI { STD_C89, NULL, T_UI }
-#define T2X_UI { STD_C2X, NULL, T_UI }
+#define T2X_UI { STD_C23, NULL, T_UI }
#define T_UL &long_unsigned_type_node
#define T89_UL { STD_C89, NULL, T_UL }
-#define T2X_UL { STD_C2X, NULL, T_UL }
+#define T2X_UL { STD_C23, NULL, T_UL }
#define T_ULL &long_long_unsigned_type_node
#define T9L_ULL { STD_C9L, NULL, T_ULL }
-#define T2X_ULL { STD_C2X, NULL, T_ULL }
+#define T2X_ULL { STD_C23, NULL, T_ULL }
#define TEX_ULL { STD_EXT, NULL, T_ULL }
#define T_US &short_unsigned_type_node
#define T89_US { STD_C89, NULL, T_US }
-#define T2X_US { STD_C2X, NULL, T_US }
+#define T2X_US { STD_C23, NULL, T_US }
#define T_F &float_type_node
#define T89_F { STD_C89, NULL, T_F }
#define T99_F { STD_C99, NULL, T_F }
#define T99_SC { STD_C99, NULL, T_SC }
#define T_UC &unsigned_char_type_node
#define T99_UC { STD_C99, NULL, T_UC }
-#define T2X_UC { STD_C2X, NULL, T_UC }
+#define T2X_UC { STD_C23, NULL, T_UC }
#define T_V &void_type_node
#define T89_G { STD_C89, NULL, &local_gimple_ptr_node }
#define T_CGRAPH_NODE { STD_C89, NULL, &local_cgraph_node_ptr_node }
#define TEX_WI { STD_EXT, "wint_t", T_WI }
#define T_ST &size_type_node
#define T99_ST { STD_C99, "size_t", T_ST }
-#define T2X_ST { STD_C2X, "size_t", T_ST }
+#define T2X_ST { STD_C23, "size_t", T_ST }
#define T_SST &signed_size_type_node
#define T99_SST { STD_C99, "signed size_t", T_SST }
#define T_PD &ptrdiff_type_node
#define T99_PD { STD_C99, "ptrdiff_t", T_PD }
#define T_UPD &unsigned_ptrdiff_type_node
#define T99_UPD { STD_C99, "unsigned ptrdiff_t", T_UPD }
-#define T2X_UPD { STD_C2X, "unsigned ptrdiff_t", T_UPD }
+#define T2X_UPD { STD_C23, "unsigned ptrdiff_t", T_UPD }
#define T_IM &intmax_type_node
#define T99_IM { STD_C99, "intmax_t", T_IM }
#define T_UIM &uintmax_type_node
#define T99_UIM { STD_C99, "uintmax_t", T_UIM }
-#define T2X_UIM { STD_C2X, "uintmax_t", T_UIM }
+#define T2X_UIM { STD_C23, "uintmax_t", T_UIM }
#define T_D32 &dfloat32_type_node
-#define T2X_D32 { STD_C2X, "_Decimal32", T_D32 }
+#define T2X_D32 { STD_C23, "_Decimal32", T_D32 }
#define T_D64 &dfloat64_type_node
-#define T2X_D64 { STD_C2X, "_Decimal64", T_D64 }
+#define T2X_D64 { STD_C23, "_Decimal64", T_D64 }
#define T_D128 &dfloat128_type_node
-#define T2X_D128 { STD_C2X, "_Decimal128", T_D128 }
+#define T2X_D128 { STD_C23, "_Decimal128", T_D128 }
#define T_I8 &int_least8_type_node
-#define T2X_I8 { STD_C2X, "int_least8_t", T_I8 }
+#define T2X_I8 { STD_C23, "int_least8_t", T_I8 }
#define T_I16 &int_least16_type_node
-#define T2X_I16 { STD_C2X, "int_least16_t", T_I16 }
+#define T2X_I16 { STD_C23, "int_least16_t", T_I16 }
#define T_I32 &int_least32_type_node
-#define T2X_I32 { STD_C2X, "int_least32_t", T_I32 }
+#define T2X_I32 { STD_C23, "int_least32_t", T_I32 }
#define T_I64 &int_least64_type_node
-#define T2X_I64 { STD_C2X, "int_least64_t", T_I64 }
+#define T2X_I64 { STD_C23, "int_least64_t", T_I64 }
#define T_U8 &uint_least8_type_node
-#define T2X_U8 { STD_C2X, "uint_least8_t", T_U8 }
+#define T2X_U8 { STD_C23, "uint_least8_t", T_U8 }
#define T_U16 &uint_least16_type_node
-#define T2X_U16 { STD_C2X, "uint_least16_t", T_U16 }
+#define T2X_U16 { STD_C23, "uint_least16_t", T_U16 }
#define T_U32 &uint_least32_type_node
-#define T2X_U32 { STD_C2X, "uint_least32_t", T_U32 }
+#define T2X_U32 { STD_C23, "uint_least32_t", T_U32 }
#define T_U64 &uint_least64_type_node
-#define T2X_U64 { STD_C2X, "uint_least64_t", T_U64 }
+#define T2X_U64 { STD_C23, "uint_least64_t", T_U64 }
#define T_IF8 &int_fast8_type_node
-#define T2X_IF8 { STD_C2X, "int_fast8_t", T_IF8 }
+#define T2X_IF8 { STD_C23, "int_fast8_t", T_IF8 }
#define T_IF16 &int_fast16_type_node
-#define T2X_IF16 { STD_C2X, "int_fast16_t", T_IF16 }
+#define T2X_IF16 { STD_C23, "int_fast16_t", T_IF16 }
#define T_IF32 &int_fast32_type_node
-#define T2X_IF32 { STD_C2X, "int_fast32_t", T_IF32 }
+#define T2X_IF32 { STD_C23, "int_fast32_t", T_IF32 }
#define T_IF64 &int_fast64_type_node
-#define T2X_IF64 { STD_C2X, "int_fast64_t", T_IF64 }
+#define T2X_IF64 { STD_C23, "int_fast64_t", T_IF64 }
#define T_UF8 &uint_fast8_type_node
-#define T2X_UF8 { STD_C2X, "uint_fast8_t", T_UF8 }
+#define T2X_UF8 { STD_C23, "uint_fast8_t", T_UF8 }
#define T_UF16 &uint_fast16_type_node
-#define T2X_UF16 { STD_C2X, "uint_fast16_t", T_UF16 }
+#define T2X_UF16 { STD_C23, "uint_fast16_t", T_UF16 }
#define T_UF32 &uint_fast32_type_node
-#define T2X_UF32 { STD_C2X, "uint_fast32_t", T_UF32 }
+#define T2X_UF32 { STD_C23, "uint_fast32_t", T_UF32 }
#define T_UF64 &uint_fast64_type_node
-#define T2X_UF64 { STD_C2X, "uint_fast64_t", T_UF64 }
+#define T2X_UF64 { STD_C23, "uint_fast64_t", T_UF64 }
/* Structure describing how format attributes such as "printf" are
interpreted as "gnu_printf" or "ms_printf" on a particular system.
}
else if (!c_dialect_cxx ())
{
- if (warn_c11_c2x_compat > 0)
+ if (warn_c11_c23_compat > 0)
{
- if (pedantic && !flag_isoc2x)
+ if (pedantic && !flag_isoc23)
pedwarn (input_location, OPT_Wc11_c23_compat,
"non-standard suffix on floating constant "
- "before C2X");
+ "before C23");
else
warning (OPT_Wc11_c23_compat,
"non-standard suffix on floating constant "
- "before C2X");
+ "before C23");
}
- else if (warn_c11_c2x_compat != 0 && pedantic && !flag_isoc2x)
+ else if (warn_c11_c23_compat != 0 && pedantic && !flag_isoc23)
pedwarn (input_location, OPT_Wpedantic,
"non-standard suffix on floating constant "
- "before C2X");
+ "before C23");
}
else if (!extended)
{
}
copy = (char *) alloca (copylen + 1);
- if (c_dialect_cxx () ? cxx_dialect > cxx11 : flag_isoc2x)
+ if (c_dialect_cxx () ? cxx_dialect > cxx11 : flag_isoc23)
{
size_t maxlen = 0;
for (size_t i = 0; i < copylen; ++i)
static void set_std_c99 (int);
static void set_std_c11 (int);
static void set_std_c17 (int);
-static void set_std_c2x (int);
+static void set_std_c23 (int);
static void check_deps_environment_vars (void);
static void handle_deferred_opts (void);
static void sanitize_cpp_opts (void);
case OPT_std_c23:
if (!preprocessing_asm_p)
- set_std_c2x (true /* ISO */);
+ set_std_c23 (true /* ISO */);
break;
case OPT_std_gnu23:
if (!preprocessing_asm_p)
- set_std_c2x (false /* ISO */);
+ set_std_c23 (false /* ISO */);
break;
case OPT_trigraphs:
else
flag_permitted_flt_eval_methods = PERMITTED_FLT_EVAL_METHODS_C11;
- /* C2X Annex F does not permit certain built-in functions to raise
+ /* C23 Annex F does not permit certain built-in functions to raise
"inexact". */
- if (flag_isoc2x)
+ if (flag_isoc23)
SET_OPTION_IF_UNSET (&global_options, &global_options_set,
flag_fp_int_builtin_inexact, 0);
if (warn_implicit_int == -1)
warn_implicit_int = flag_isoc99;
- /* -Wold-style-definition is enabled by default for C2X. */
+ /* -Wold-style-definition is enabled by default for C23. */
if (warn_old_style_definition == -1)
- warn_old_style_definition = flag_isoc2x;
+ warn_old_style_definition = flag_isoc23;
/* -Wshift-overflow is enabled by default in C99 and C++11 modes. */
if (warn_shift_overflow == -1)
if (warn_invalid_constexpr == -1)
warn_invalid_constexpr = (cxx_dialect < cxx23);
- /* char8_t support is implicitly enabled in C++20 and C2X. */
+ /* char8_t support is implicitly enabled in C++20 and C23. */
if (flag_char8_t == -1)
- flag_char8_t = (cxx_dialect >= cxx20) || flag_isoc2x;
+ flag_char8_t = (cxx_dialect >= cxx20) || flag_isoc23;
cpp_opts->unsigned_utf8char = flag_char8_t ? 1 : cpp_opts->unsigned_char;
if (flag_extern_tls_init)
flag_isoc94 = c94;
flag_isoc99 = 0;
flag_isoc11 = 0;
- flag_isoc2x = 0;
+ flag_isoc23 = 0;
lang_hooks.name = "GNU C89";
}
flag_no_asm = iso;
flag_no_nonansi_builtin = iso;
flag_iso = iso;
- flag_isoc2x = 0;
+ flag_isoc23 = 0;
flag_isoc11 = 0;
flag_isoc99 = 1;
flag_isoc94 = 1;
flag_no_asm = iso;
flag_no_nonansi_builtin = iso;
flag_iso = iso;
- flag_isoc2x = 0;
+ flag_isoc23 = 0;
flag_isoc11 = 1;
flag_isoc99 = 1;
flag_isoc94 = 1;
flag_no_asm = iso;
flag_no_nonansi_builtin = iso;
flag_iso = iso;
- flag_isoc2x = 0;
+ flag_isoc23 = 0;
flag_isoc11 = 1;
flag_isoc99 = 1;
flag_isoc94 = 1;
/* Set the C 2X standard (without GNU extensions if ISO). */
static void
-set_std_c2x (int iso)
+set_std_c23 (int iso)
{
- cpp_set_lang (parse_in, iso ? CLK_STDC2X: CLK_GNUC2X);
+ cpp_set_lang (parse_in, iso ? CLK_STDC23: CLK_GNUC23);
flag_no_asm = iso;
flag_no_nonansi_builtin = iso;
flag_iso = iso;
- flag_isoc2x = 1;
+ flag_isoc23 = 1;
flag_isoc11 = 1;
flag_isoc99 = 1;
flag_isoc94 = 1;
- lang_hooks.name = "GNU C2X";
+ lang_hooks.name = "GNU C23";
}
Warn when a built-in preprocessor macro is undefined or redefined.
Wc11-c23-compat
-C ObjC CPP(cpp_warn_c11_c2x_compat) CppReason(CPP_W_C11_C2X_COMPAT) Var(warn_c11_c2x_compat) Init(-1) Warning
+C ObjC CPP(cpp_warn_c11_c23_compat) CppReason(CPP_W_C11_C23_COMPAT) Var(warn_c11_c23_compat) Init(-1) Warning
Warn about features not present in ISO C11, but present in ISO C23.
Wc11-c2x-compat
}
\f
/* Whether we are curently inside the initializer for an
- underspecified object definition (C2x auto or constexpr). */
+ underspecified object definition (C23 auto or constexpr). */
static bool in_underspecified_init;
/* Start an underspecified object definition for NAME at LOC. This
}
}
/* Warn about enum/integer type mismatches. They are compatible types
- (C2X 6.7.2.2/5), but may pose portability problems. */
+ (C23 6.7.2.2/5), but may pose portability problems. */
else if (enum_and_int_p
&& TREE_CODE (newdecl) != TYPE_DECL
/* Don't warn about about acc_on_device built-in redeclaration,
}
/* Multiple initialized definitions are not allowed (6.9p3,5).
- For this purpose, C2x makes it clear that thread-local
+ For this purpose, C23 makes it clear that thread-local
declarations without extern are definitions, not tentative
definitions, whether or not they have initializers. The
- wording before C2x was unclear; literally it would have made
+ wording before C23 was unclear; literally it would have made
uninitialized thread-local declarations into tentative
definitions only if they also used static, but without saying
explicitly whether or not other cases count as
definitions at all. */
if ((DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
- || (flag_isoc2x
+ || (flag_isoc23
&& DECL_THREAD_LOCAL_P (newdecl)
&& !DECL_EXTERNAL (newdecl)
&& !DECL_EXTERNAL (olddecl)))
}
}
-/* Table of supported standard (C2x) attributes. */
+/* Table of supported standard (C23) attributes. */
const struct attribute_spec std_attribute_table[] =
{
/* { name, min_len, max_len, decl_req, type_req, fn_type_req,
/* A static variable with an incomplete type
is an error if it is initialized.
Also if it is not file scope.
- Also if it is thread-local (in C2x).
+ Also if it is thread-local (in C23).
Otherwise, let it through, but if it is not `extern'
then it may cause an error message later. */
? (DECL_INITIAL (decl) != NULL_TREE
|| !DECL_FILE_SCOPE_P (decl)
- || (flag_isoc2x && DECL_THREAD_LOCAL_P (decl)))
+ || (flag_isoc23 && DECL_THREAD_LOCAL_P (decl)))
/* An automatic variable with an incomplete type
is an error. */
: !DECL_EXTERNAL (decl)))
literal. NON_CONST is true if the initializers contain something
that cannot occur in a constant expression. If ALIGNAS_ALIGN is nonzero,
it is the (valid) alignment for this compound literal, as specified
- with _Alignas. SCSPECS are the storage class specifiers (C2x) from the
+ with _Alignas. SCSPECS are the storage class specifiers (C23) from the
compound literal. */
tree
if (type == NULL_TREE)
{
- /* This can occur for auto on a parameter in C2X mode. Set a
+ /* This can occur for auto on a parameter in C23 mode. Set a
dummy type here so subsequent code can give diagnostics for
this case. */
- gcc_assert (declspecs->c2x_auto_p);
+ gcc_assert (declspecs->c23_auto_p);
gcc_assert (decl_context == PARM);
type = declspecs->type = integer_type_node;
}
else if (decl_context != NORMAL && (storage_class != csc_none
|| threadp
|| constexprp
- || declspecs->c2x_auto_p))
+ || declspecs->c23_auto_p))
{
if (decl_context == PARM
&& storage_class == csc_register
&& !constexprp
- && !declspecs->c2x_auto_p)
+ && !declspecs->c23_auto_p)
;
else
{
them for noreturn functions. The resolution of C11
DR#423 means qualifiers (other than _Atomic) are
actually removed from the return type when
- determining the function type. For C2X, _Atomic is
+ determining the function type. For C23, _Atomic is
removed as well. */
int quals_used = type_quals;
- if (flag_isoc2x)
+ if (flag_isoc23)
quals_used = 0;
else if (flag_isoc11)
quals_used &= TYPE_QUAL_ATOMIC;
error ("%<[*]%> not allowed in other than function prototype scope");
}
- if (arg_types == NULL_TREE && !funcdef_flag && !flag_isoc2x
+ if (arg_types == NULL_TREE && !funcdef_flag && !flag_isoc23
&& !in_system_header_at (input_location))
warning (OPT_Wstrict_prototypes,
"function declaration isn%'t a prototype");
tree parm, type, typelt;
unsigned int parmno;
- /* In C2X, convert () to (void). */
- if (flag_isoc2x
+ /* In C23, convert () to (void). */
+ if (flag_isoc23
&& !arg_types
&& !arg_info->parms
&& !arg_info->no_named_args_stdarg_p)
/* Begin compiling the definition of an enumeration type.
NAME is its name (or null if anonymous).
LOC is the enum's location.
- FIXED_UNDERLYING_TYPE is the (C2x) underlying type specified in the
+ FIXED_UNDERLYING_TYPE is the (C23) underlying type specified in the
definition.
Returns the type object, as yet incomplete.
Also records info about it so that build_enumerator
TREE_TYPE (enu) = enumtype;
- /* Before C2X, the ISO C Standard mandates enumerators to
+ /* Before C23, the ISO C Standard mandates enumerators to
have type int, even though the underlying type of an enum
- type is unspecified. However, C2X allows enumerators of
+ type is unspecified. However, C23 allows enumerators of
any integer type, and if an enumeration has any
enumerators wider than int, all enumerators have the
enumerated type after it is parsed. Any enumerators that
{
/* Even though the underlying type of an enum is unspecified, the
type of enumeration constants is explicitly defined as int
- (6.4.4.3/2 in the C99 Standard). C2X allows any integer type, and
+ (6.4.4.3/2 in the C99 Standard). C23 allows any integer type, and
GCC allows such types for older standards as an extension. */
bool warned_range = false;
if (!int_fits_type_p (value,
? uintmax_type_node
: intmax_type_node)))
/* GCC does not consider its types larger than intmax_t to be
- extended integer types (although C2X would permit such types to
+ extended integer types (although C23 would permit such types to
be considered extended integer types if all the features
required by <stdint.h> and <inttypes.h> macros, such as support
for integer constants and I/O, were present), so diagnose if
if (!warned_range && !int_fits_type_p (value, integer_type_node))
pedwarn_c11 (loc, OPT_Wpedantic,
"ISO C restricts enumerator values to range of %<int%> "
- "before C2X");
+ "before C23");
/* The ISO C Standard mandates enumerators to have type int before
- C2X, even though the underlying type of an enum type is
- unspecified. C2X allows enumerators of any integer type. During
- the parsing of the enumeration, C2X specifies that constants
+ C23, even though the underlying type of an enum type is
+ unspecified. C23 allows enumerators of any integer type. During
+ the parsing of the enumeration, C23 specifies that constants
representable in int have type int, constants not representable
in int have the type of the given expression if any, and
constants not representable in int and derived by adding 1 to the
else
pedwarn_c11 (DECL_SOURCE_LOCATION (decl), OPT_Wpedantic,
"ISO C does not support omitting parameter names in "
- "function definitions before C2X");
+ "function definitions before C23");
}
/* Record the parameter list in the function declaration. */
if (!in_system_header_at (input_location))
{
- if (flag_isoc2x)
+ if (flag_isoc23)
pedwarn (DECL_SOURCE_LOCATION (fndecl),
OPT_Wold_style_definition, "old-style function definition");
else
struct c_arg_info *arg_info = current_function_arg_info;
current_function_arg_info = 0;
- /* True if this definition is written with a prototype. In C2X, an
+ /* True if this definition is written with a prototype. In C23, an
empty argument list was converted to (void) in grokparms; in
older C standard versions, it does not give the function a type
with a prototype for future calls. */
interpretation, to avoid creating an extension which later causes
problems.
- This constraint was removed in C2X. */
+ This constraint was removed in C23. */
for (b = current_scope->bindings; b; b = b->prev)
{
/* As a type specifier is present, "auto" must be used as a storage
class specifier, not for type deduction. */
- if (specs->c2x_auto_p)
+ if (specs->c23_auto_p)
{
- specs->c2x_auto_p = false;
+ specs->c23_auto_p = false;
if (specs->storage_class != csc_none)
error ("multiple storage classes in declaration specifiers");
else if (specs->thread_p)
if (!in_system_header_at (input_location))
pedwarn_c11 (loc, OPT_Wpedantic,
"ISO C does not support the %<_Float%d%s%> type"
- " before C2X",
+ " before C23",
floatn_nx_types[specs->u.floatn_nx_idx].n,
(floatn_nx_types[specs->u.floatn_nx_idx].extended
? "x"
"for this target"));
pedwarn_c11 (loc, OPT_Wpedantic,
"ISO C does not support decimal floating-point "
- "before C2X");
+ "before C23");
return specs;
case RID_FRACT:
case RID_ACCUM:
}
break;
case RID_AUTO:
- if (flag_isoc2x
+ if (flag_isoc23
&& specs->typespec_kind == ctsk_none
&& specs->storage_class != csc_typedef)
{
/* "auto" potentially used for type deduction. */
- if (specs->c2x_auto_p)
+ if (specs->c23_auto_p)
error ("duplicate %qE", scspec);
- specs->c2x_auto_p = true;
+ specs->c23_auto_p = true;
return specs;
}
n = csc_auto;
break;
case RID_TYPEDEF:
n = csc_typedef;
- if (specs->c2x_auto_p)
+ if (specs->c23_auto_p)
{
error ("%<typedef%> used with %<auto%>");
- specs->c2x_auto_p = false;
+ specs->c23_auto_p = false;
}
break;
case RID_CONSTEXPR:
{
gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
&& !specs->signed_p && !specs->unsigned_p
- && !specs->complex_p && !specs->c2x_auto_p);
+ && !specs->complex_p && !specs->c23_auto_p);
/* Set a dummy type. */
if (TREE_CODE (specs->type) == ERROR_MARK)
"ISO C does not support plain %<complex%> meaning "
"%<double complex%>");
}
- else if (specs->c2x_auto_p)
+ else if (specs->c23_auto_p)
{
/* Type to be filled in later, including applying postfix
attributes. This warning only actually appears for
- -Wc11-c2x-compat in C2X mode; in older modes, there may
+ -Wc11-c23-compat in C23 mode; in older modes, there may
be a warning or pedwarn for implicit "int" instead, or
other errors for use of auto at file scope. */
pedwarn_c11 (input_location, OPT_Wpedantic,
"ISO C does not support %<auto%> type deduction "
- "before C2X");
+ "before C23");
return specs;
}
else
specs->explicit_signed_p = specs->signed_p;
/* Now compute the actual type. */
- gcc_assert (!specs->c2x_auto_p);
+ gcc_assert (!specs->c23_auto_p);
switch (specs->typespec_word)
{
case cts_auto_type:
else
{
pedwarn_c11 (specs->locations[cdw_typespec], OPT_Wpedantic,
- "ISO C does not support %<%s_BitInt(%d)%> before C2X",
+ "ISO C does not support %<%s_BitInt(%d)%> before C23",
specs->unsigned_p ? "unsigned "
: specs->signed_p ? "signed " : "",
specs->u.bitint_prec);
#include "c-tree.h"
#include "opts.h"
-/* Issue an ISO C11 pedantic warning MSGID if -pedantic outside C2X mode,
- otherwise issue warning MSGID if -Wc11-c2X-compat is specified.
+/* Issue an ISO C11 pedantic warning MSGID if -pedantic outside C23 mode,
+ otherwise issue warning MSGID if -Wc11-c23-compat is specified.
This function is supposed to be used for matters that are allowed in
- ISO C2X but not supported in ISO C11, thus we explicitly don't pedwarn
- when C2X is specified. */
+ ISO C23 but not supported in ISO C11, thus we explicitly don't pedwarn
+ when C23 is specified. */
bool
pedwarn_c11 (location_t location, int opt, const char *gmsgid, ...)
rich_location richloc (line_table, location);
va_start (ap, gmsgid);
- /* If desired, issue the C11/C2X compat warning, which is more specific
+ /* If desired, issue the C11/C23 compat warning, which is more specific
than -pedantic. */
- if (warn_c11_c2x_compat > 0)
+ if (warn_c11_c23_compat > 0)
{
diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc,
- (pedantic && !flag_isoc2x)
+ (pedantic && !flag_isoc23)
? DK_PEDWARN : DK_WARNING);
diagnostic.option_index = OPT_Wc11_c23_compat;
warned = diagnostic_report_diagnostic (global_dc, &diagnostic);
}
- /* -Wno-c11-c2x-compat suppresses even the pedwarns. */
- else if (warn_c11_c2x_compat == 0)
+ /* -Wno-c11-c23-compat suppresses even the pedwarns. */
+ else if (warn_c11_c23_compat == 0)
;
- /* For -pedantic outside C2X, issue a pedwarn. */
- else if (pedantic && !flag_isoc2x)
+ /* For -pedantic outside C23, issue a pedwarn. */
+ else if (pedantic && !flag_isoc23)
{
diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc, DK_PEDWARN);
diagnostic.option_index = opt;
mask |= D_CXXONLY;
if (!flag_isoc99)
mask |= D_C99;
- if (!flag_isoc2x)
- mask |= D_C2X;
+ if (!flag_isoc23)
+ mask |= D_C23;
if (flag_no_asm)
{
mask |= D_ASM | D_EXT;
if (!flag_isoc99)
mask |= D_EXT89;
- if (!flag_isoc2x)
+ if (!flag_isoc23)
mask |= D_EXT11;
}
if (!c_dialect_objc ())
/* Similarly for warn_c99_c11_compat. */
| ((warn_c99_c11_compat == 1) << 9)
| ((warn_c99_c11_compat == -1) << 10)
- /* Similarly for warn_c11_c2x_compat. */
- | ((warn_c11_c2x_compat == 1) << 11)
- | ((warn_c11_c2x_compat == -1) << 12)
+ /* Similarly for warn_c11_c23_compat. */
+ | ((warn_c11_c23_compat == 1) << 11)
+ | ((warn_c11_c23_compat == -1) << 12)
);
cpp_opts->cpp_pedantic = pedantic = 0;
warn_pointer_arith = 0;
warn_overlength_strings = 0;
warn_c90_c99_compat = 0;
warn_c99_c11_compat = 0;
- warn_c11_c2x_compat = 0;
+ warn_c11_c23_compat = 0;
return ret;
}
/* See above for why is this needed. */
warn_c90_c99_compat = (flags >> 7) & 1 ? 1 : ((flags >> 8) & 1 ? -1 : 0);
warn_c99_c11_compat = (flags >> 9) & 1 ? 1 : ((flags >> 10) & 1 ? -1 : 0);
- warn_c11_c2x_compat = (flags >> 11) & 1 ? 1 : ((flags >> 12) & 1 ? -1 : 0);
+ warn_c11_c23_compat = (flags >> 11) & 1 ? 1 : ((flags >> 12) & 1 ? -1 : 0);
}
/* Helper data structure for parsing #pragma acc routine. */
finish_declspecs (specs);
bool gnu_auto_type_p = specs->typespec_word == cts_auto_type;
- bool std_auto_type_p = specs->c2x_auto_p;
+ bool std_auto_type_p = specs->c23_auto_p;
bool any_auto_type_p = gnu_auto_type_p || std_auto_type_p;
gcc_assert (!(gnu_auto_type_p && std_auto_type_p));
const char *auto_type_keyword = gnu_auto_type_p ? "__auto_type" : "auto";
specs->type = init_type;
if (specs->postfix_attrs)
{
- /* Postfix [[]] attributes are valid with C2X
+ /* Postfix [[]] attributes are valid with C23
auto, although not with __auto_type, and
modify the type given by the initializer. */
specs->postfix_attrs =
static_assert-declaration-no-semi:
_Static_assert ( constant-expression , string-literal )
- C2X:
+ C23:
static_assert-declaration-no-semi:
_Static_assert ( constant-expression )
*/
else if (flag_isoc11)
/* If pedantic for pre-C11, the use of _Static_assert itself will
have been diagnosed, so do not also diagnose the use of this
- new C2X feature of _Static_assert. */
+ new C23 feature of _Static_assert. */
pedwarn_c11 (assert_loc, OPT_Wpedantic,
"ISO C11 does not support omitting the string in "
"%qE", spelling);
(_Bool and _Complex are new in C99.)
(atomic-type-specifier is new in C11.)
- (_BitInt is new in C2X.)
+ (_BitInt is new in C23.)
C90 6.5.3, C99 6.7.3, C11 6.7.3:
enum gnu-attributes[opt] identifier
The form with trailing comma is new in C99; enum-type-specifiers
- are new in C2x. The forms with gnu-attributes are GNU extensions.
+ are new in C23. The forms with gnu-attributes are GNU extensions.
In GNU C, we accept any expression without commas in the syntax
(assignment expressions, not just conditional expressions);
assignment expressions will be diagnosed as non-constant.
{
pedwarn_c11 (enum_loc, OPT_Wpedantic,
"ISO C does not support specifying %<enum%> underlying "
- "types before C2X");
+ "types before C23");
if (ident)
{
/* The tag is in scope during the enum-type-specifier (which
return decls;
}
-/* Parse a typeof specifier (a GNU extension adopted in C2X).
+/* Parse a typeof specifier (a GNU extension adopted in C23).
typeof-specifier:
typeof ( expression )
{
is_unqual = false;
tree spelling = c_parser_peek_token (parser)->value;
- is_std = (flag_isoc2x
+ is_std = (flag_isoc23
&& strcmp (IDENTIFIER_POINTER (spelling), "typeof") == 0);
}
else
ret->types = NULL_TREE;
pedwarn_c11 (c_parser_peek_token (parser)->location, OPT_Wpedantic,
"ISO C requires a named argument before %<...%> "
- "before C2X");
+ "before C23");
c_parser_consume_token (parser);
if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
{
while (1);
}
-/* Parse standard (C2X) attributes (including GNU attributes in the
+/* Parse standard (C23) attributes (including GNU attributes in the
gnu:: namespace).
attribute-specifier-sequence:
{
if (!for_tm)
pedwarn_c11 (loc, OPT_Wpedantic,
- "ISO C does not support %<[[]]%> attributes before C2X");
+ "ISO C does not support %<[[]]%> attributes before C23");
attributes = c_parser_std_attribute_list (parser, for_tm);
}
c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
{
pedwarn_c11 (brace_loc, OPT_Wpedantic,
- "ISO C forbids empty initializer braces before C2X");
+ "ISO C forbids empty initializer braces before C23");
}
else
{
}
/* Parse a compound statement (possibly a function body) (C90 6.6.2,
- C99 6.8.2, C11 6.8.2, C2X 6.8.2).
+ C99 6.8.2, C11 6.8.2, C23 6.8.2).
compound-statement:
{ block-item-list[opt] }
|| strcmp (IDENTIFIER_POINTER (alignof_spelling),
"alignof") == 0);
/* A diagnostic is not required for the use of this identifier in
- the implementation namespace; only diagnose it for the C11 or C2X
+ the implementation namespace; only diagnose it for the C11 or C23
spelling because of existing code using the other spellings. */
if (is_c11_alignof)
{
expr.value = nullptr_node;
set_c_expr_source_range (&expr, tok_range);
pedwarn_c11 (loc, OPT_Wpedantic,
- "ISO C does not support %qs before C2X", "nullptr");
+ "ISO C does not support %qs before C23", "nullptr");
break;
case RID_TRUE:
c_parser_consume_token (parser);
"ISO C90 forbids compound literals") && scspecs)
pedwarn_c11 (start_loc, OPT_Wpedantic,
"ISO C forbids storage class specifiers in compound literals "
- "before C2X");
+ "before C23");
non_const = ((init.value && TREE_CODE (init.value) == CONSTRUCTOR)
? CONSTRUCTOR_NON_CONST (init.value)
: init.original_code == C_MAYBE_CONST_EXPR);
#define C_DECL_COMPOUND_LITERAL_P(DECL) \
DECL_LANG_FLAG_5 (VAR_DECL_CHECK (DECL))
-/* Set on decls used as placeholders for a C2x underspecified object
+/* Set on decls used as placeholders for a C23 underspecified object
definition. */
#define C_DECL_UNDERSPECIFIED(DECL) DECL_LANG_FLAG_7 (DECL)
specified other than in a definition of that enum (if so, this is
invalid unless it is an empty declaration "enum identifier
enum-type-specifier;", but such an empty declaration is valid in
- C2x when "enum identifier;" would not be). */
+ C23 when "enum identifier;" would not be). */
BOOL_BITFIELD enum_type_specifier_ref_p : 1;
- /* Whether "auto" was specified in C2X (or later) mode and means the
+ /* Whether "auto" was specified in C23 (or later) mode and means the
type is to be deduced from an initializer, or would mean that if
no type specifier appears later in these declaration
specifiers. */
- BOOL_BITFIELD c2x_auto_p : 1;
+ BOOL_BITFIELD c23_auto_p : 1;
/* Whether "constexpr" was specified. */
BOOL_BITFIELD constexpr_p : 1;
/* The address space that the declaration belongs to. */
if (val == 1 && val_ped != 1)
pedwarn_c11 (location, OPT_Wpedantic, "invalid use of pointers to arrays with different qualifiers "
- "in ISO C before C2X");
+ "in ISO C before C23");
if (val == 2)
pedwarn (location, OPT_Wpedantic, "types are not quite compatible");
return true;
}
-/* If EXPR is a named constant (C2x) derived from a constexpr variable
+/* If EXPR is a named constant (C23) derived from a constexpr variable
- that is, a reference to such a variable, or a member extracted by
a sequence of structure and union (but not array) member accesses
(where union member accesses must access the same member as
if ((TREE_CODE (t2) == ARRAY_TYPE)
&& (TYPE_QUALS (t2_stripped) & ~TYPE_QUALS (t1)))
{
- if (!flag_isoc2x)
+ if (!flag_isoc23)
warning_at (colon_loc, OPT_Wdiscarded_array_qualifiers,
"pointer to array loses qualifier "
"in conditional expression");
- else if (warn_c11_c2x_compat > 0)
+ else if (warn_c11_c23_compat > 0)
warning_at (colon_loc, OPT_Wc11_c23_compat,
"pointer to array loses qualifier "
- "in conditional expression in ISO C before C2X");
+ "in conditional expression in ISO C before C23");
}
if (TREE_CODE (t2) == FUNCTION_TYPE)
pedwarn (colon_loc, OPT_Wpedantic,
"ISO C forbids conditional expr between "
"%<void *%> and function pointer");
/* for array, use qualifiers of element type */
- if (flag_isoc2x)
+ if (flag_isoc23)
t2 = t2_stripped;
result_type = build_pointer_type (qualify_type (t1, t2));
}
if (TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttr)
& ~TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttl))
- WARNING_FOR_QUALIFIERS (flag_isoc2x,
+ WARNING_FOR_QUALIFIERS (flag_isoc23,
location, expr_loc,
OPT_Wdiscarded_array_qualifiers,
G_("passing argument %d of %qE discards "
/* Don't warn about loss of qualifier for conversions from
qualified void* to pointers to arrays with corresponding
qualifier on the element type (except for pedantic before C23). */
- if (warn_quals || (warn_quals_ped && pedantic && !flag_isoc2x))
+ if (warn_quals || (warn_quals_ped && pedantic && !flag_isoc23))
PEDWARN_FOR_QUALIFIERS (location, expr_loc,
OPT_Wdiscarded_qualifiers,
G_("passing argument %d of %qE discards "
TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
else if (warn_quals_ped)
pedwarn_c11 (location, OPT_Wc11_c23_compat,
- "array with qualifier on the element is not qualified before C2X");
+ "array with qualifier on the element is not qualified before C23");
/* If this is not a case of ignoring a mismatch in signedness,
no warning. */
{
/* A nonincremental scalar initializer--just return
the element, after verifying there is just one.
- Empty scalar initializers are supported in C2X. */
+ Empty scalar initializers are supported in C23. */
if (vec_safe_is_empty (constructor_elements))
{
if (constructor_erroneous || constructor_type == error_mark_node)
&& strcmp (lang_hooks.name, "GNU C")
&& strcmp (lang_hooks.name, "GNU C11")
&& strcmp (lang_hooks.name, "GNU C17")
- && strcmp (lang_hooks.name, "GNU C2X")
+ && strcmp (lang_hooks.name, "GNU C23")
&& strcmp (lang_hooks.name, "GNU C89")
&& strcmp (lang_hooks.name, "GNU C99")
/* Compiling with -flto results in a language of GNU GIMPLE being used... */
function_c99_math_complex,
function_sincos,
function_c11_misc,
- function_c2x_misc
+ function_c23_misc
};
/* Enumerate visibility settings. This is deliberately ordered from most
in @samp{#if} and @samp{#elif} expressions to test whether the attribute
referenced by its @var{operand} is recognized by GCC. Using the operator
in other contexts is not valid. In C code, if compiling for strict
-conformance to standards before C2x, @var{operand} must be
+conformance to standards before C23, @var{operand} must be
a valid identifier. Otherwise, @var{operand} may be optionally
introduced by the @code{@var{attribute-scope}::} prefix.
The @var{attribute-scope} prefix identifies the ``namespace'' within
pointers to @code{char}.
@end itemize
-The ISO C2X operator @code{typeof_unqual} is available in ISO C2X mode
+The ISO C23 operator @code{typeof_unqual} is available in ISO C23 mode
and its result is the non-atomic unqualified version of what @code{typeof}
operator returns. Alternate spelling @code{__typeof_unqual__} is
available in all C modes and provides non-atomic unqualified version of
@cindex code, mixed with declarations
ISO C99 and ISO C++ allow declarations and code to be freely mixed
-within compound statements. ISO C2X allows labels to be
+within compound statements. ISO C23 allows labels to be
placed before declarations and at the end of a compound statement.
As an extension, GNU C also allows all this in C90 mode. For example,
you could do:
@end smallexample
suppresses warnings about using @samp{[[]]} attributes in C versions
-that predate C2X@. Since the scope token @samp{::} is not a single
+that predate C23@. Since the scope token @samp{::} is not a single
lexing token in earlier versions of C, this construct also allows two colons
to be used in place of @code{::}. GCC does not check whether the two
colons are immediately adjacent.
@item #pragma GCC diagnostic ignored_attributes
Similarly to @option{-Wno-attributes=}, this pragma allows users to suppress
-warnings about unknown scoped attributes (in C++11 and C2X). For example,
+warnings about unknown scoped attributes (in C++11 and C23). For example,
@code{#pragma GCC diagnostic ignored_attributes "vendor::attr"} disables
warning about the following declaration:
errors by @option{-pedantic-errors}.
Additionally, using @option{-Wno-attributes=}, it is possible to suppress
-warnings about unknown scoped attributes (in C++11 and C2X). For example,
+warnings about unknown scoped attributes (in C++11 and C23). For example,
@option{-Wno-attributes=vendor::attr} disables warning about the following
declaration:
@item -Wold-style-definition @r{(C and Objective-C only)}
Warn if an old-style function definition is used. A warning is given
even if there is a previous prototype. A definition using @samp{()}
-is not considered an old-style definition in C2X mode, because it is
+is not considered an old-style definition in C23 mode, because it is
equivalent to @samp{(void)} in that case, but is considered an
old-style definition for older standards.
floating-point exception for noninteger arguments. ISO C99 and C11
allow these functions to raise the ``inexact'' exception, but ISO/IEC
TS 18661-1:2014, the C bindings to IEEE 754-2008, as integrated into
-ISO C2X, does not allow these functions to do so.
+ISO C23, does not allow these functions to do so.
The default is @option{-ffp-int-builtin-inexact}, allowing the
-exception to be raised, unless C2X or a later C standard is selected.
+exception to be raised, unless C23 or a later C standard is selected.
This option does nothing unless @option{-ftrapping-math} is in effect.
Even if @option{-fno-fp-int-builtin-inexact} is used, if the functions
if (strcmp ("GNU C++98", lang1) == 0 || strcmp ("GNU C++98", lang2) == 0)
return "GNU C++98";
- if (strcmp ("GNU C2X", lang1) == 0 || strcmp ("GNU C2X", lang2) == 0)
- return "GNU C2X";
+ if (strcmp ("GNU C23", lang1) == 0 || strcmp ("GNU C23", lang2) == 0)
+ return "GNU C23";
if (strcmp ("GNU C17", lang1) == 0 || strcmp ("GNU C17", lang2) == 0)
return "GNU C17";
if (strcmp ("GNU C11", lang1) == 0 || strcmp ("GNU C11", lang2) == 0)
if (dwarf_version >= 5 /* || !dwarf_strict */)
if (strcmp (language_string, "GNU C11") == 0
|| strcmp (language_string, "GNU C17") == 0
- || strcmp (language_string, "GNU C2X") == 0)
+ || strcmp (language_string, "GNU C23") == 0)
language = DW_LANG_C11;
}
}
unsigned int c_double : 1;
unsigned int c_long_double : 1;
unsigned int c_float128 : 1;
- /* True if for _Float128 C2X IEC 60559 *f128 APIs should be used
+ /* True if for _Float128 C23 IEC 60559 *f128 APIs should be used
instead of libquadmath *q APIs. */
unsigned int use_iec_60559 : 1;
}
#define LDBL_SNAN (__builtin_nansl (""))
#endif
-#endif /* C2X */
+#endif /* C23 */
#if (defined __STDC_WANT_IEC_60559_BFP_EXT__ \
|| defined __STDC_WANT_IEC_60559_EXT__)
#if defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L
#undef FLT16_SNAN
#define FLT16_SNAN (__builtin_nansf16 (""))
-#endif /* C2X */
+#endif /* C23 */
#endif /* __FLT16_MANT_DIG__. */
#ifdef __FLT32_MANT_DIG__
#if defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L
#undef FLT32_SNAN
#define FLT32_SNAN (__builtin_nansf32 (""))
-#endif /* C2X */
+#endif /* C23 */
#endif /* __FLT32_MANT_DIG__. */
#ifdef __FLT64_MANT_DIG__
#if defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L
#undef FLT64_SNAN
#define FLT64_SNAN (__builtin_nansf64 (""))
-#endif /* C2X */
+#endif /* C23 */
#endif /* __FLT64_MANT_DIG__. */
#ifdef __FLT128_MANT_DIG__
#if defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L
#undef FLT128_SNAN
#define FLT128_SNAN (__builtin_nansf128 (""))
-#endif /* C2X */
+#endif /* C23 */
#endif /* __FLT128_MANT_DIG__. */
#ifdef __FLT32X_MANT_DIG__
#if defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L
#undef FLT32X_SNAN
#define FLT32X_SNAN (__builtin_nansf32x (""))
-#endif /* C2X */
+#endif /* C23 */
#endif /* __FLT32X_MANT_DIG__. */
#ifdef __FLT64X_MANT_DIG__
#if defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L
#undef FLT64X_SNAN
#define FLT64X_SNAN (__builtin_nansf64x (""))
-#endif /* C2X */
+#endif /* C23 */
#endif /* __FLT64X_MANT_DIG__. */
#ifdef __FLT128X_MANT_DIG__
#if defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L
#undef FLT128X_SNAN
#define FLT128X_SNAN (__builtin_nansf128x (""))
-#endif /* C2X */
+#endif /* C23 */
#endif /* __FLT128X_MANT_DIG__. */
#endif /* __STDC_WANT_IEC_60559_TYPES_EXT__. */
#if (defined __STDC_WANT_DEC_FP__ \
|| defined __STDC_WANT_IEC_60559_DFP_EXT__ \
|| (defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L))
-/* C2X; formerly Technical Report 24732, extension for decimal
+/* C23; formerly Technical Report 24732, extension for decimal
floating-point arithmetic: Characteristic of decimal floating types
<float.h>, and TS 18661-2. */
#undef DEC_EVAL_METHOD
#define DEC_EVAL_METHOD __DEC_EVAL_METHOD__
-#endif /* __STDC_WANT_DEC_FP__ || __STDC_WANT_IEC_60559_DFP_EXT__ || C2X. */
+#endif /* __STDC_WANT_DEC_FP__ || __STDC_WANT_IEC_60559_DFP_EXT__ || C23. */
#ifdef __STDC_WANT_DEC_FP__
#define DEC64_TRUE_MIN __DEC64_SUBNORMAL_MIN__
#define DEC128_TRUE_MIN __DEC128_SUBNORMAL_MIN__
-#endif /* __STDC_WANT_IEC_60559_DFP_EXT__ || C2X. */
+#endif /* __STDC_WANT_IEC_60559_DFP_EXT__ || C23. */
#if defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L
#undef DEC128_SNAN
#define DEC128_SNAN (__builtin_nansd128 (""))
-#endif /* C2X */
+#endif /* C23 */
#endif /* __DEC32_MANT_DIG__ */
#if (defined __STDC_WANT_IEC_60559_BFP_EXT__ \
|| (defined (__STDC_VERSION__) && __STDC_VERSION__ > 201710L))
-/* TS 18661-1 / C2X widths of integer types. */
+/* TS 18661-1 / C23 widths of integer types. */
#ifdef __INT8_TYPE__
# undef INT8_WIDTH
#if (defined __STDC_WANT_IEC_60559_BFP_EXT__ \
|| (defined (__STDC_VERSION__) && __STDC_VERSION__ > 201710L))
-/* TS 18661-1 / C2X widths of integer types. */
+/* TS 18661-1 / C23 widths of integer types. */
# undef CHAR_WIDTH
# define CHAR_WIDTH __SCHAR_WIDTH__
# undef SCHAR_WIDTH
#endif
#if defined (__STDC_VERSION__) && __STDC_VERSION__ > 201710L
-/* C2X width and limit of _Bool. */
+/* C23 width and limit of _Bool. */
# undef BOOL_MAX
# define BOOL_MAX 1
# undef BOOL_WIDTH
int flag_isoc94;
int flag_isoc99;
int flag_isoc11;
-int flag_isoc2x;
+int flag_isoc23;
/* Attribute handlers. */
int
foo (void)
{
-#if FOO /* { dg-warning "binary constants are a C2X feature or GCC extension" } */
+#if FOO /* { dg-warning "binary constants are a C23 feature or GCC extension" } */
return 23;
#endif
- return 0b1101; /* { dg-warning "binary constants are a C2X feature or GCC extension" } */
+ return 0b1101; /* { dg-warning "binary constants are a C23 feature or GCC extension" } */
}
int
foo (void)
{
-#if FOO /* { dg-error "binary constants are a C2X feature or GCC extension" } */
+#if FOO /* { dg-error "binary constants are a C23 feature or GCC extension" } */
return 23;
#endif
- return 0b1101; /* { dg-error "binary constants are a C2X feature or GCC extension" } */
+ return 0b1101; /* { dg-error "binary constants are a C23 feature or GCC extension" } */
}
// { dg-do compile { target bitint } }
// { dg-options "-std=c2x -pedantic-errors -Wc11-c2x-compat" }
-_BitInt(63) a; /* { dg-warning "ISO C does not support '_BitInt\\\(63\\\)' before C2X" } */
-signed _BitInt(15) b; /* { dg-warning "ISO C does not support 'signed _BitInt\\\(15\\\)' before C2X" } */
-unsigned _BitInt(31) c; /* { dg-warning "ISO C does not support 'unsigned _BitInt\\\(31\\\)' before C2X" } */
-int d = 21wb; /* { dg-warning "ISO C does not support literal 'wb' suffixes before C2X" } */
-long long e = 60594869054uwb; /* { dg-warning "ISO C does not support literal 'wb' suffixes before C2X" } */
+_BitInt(63) a; /* { dg-warning "ISO C does not support '_BitInt\\\(63\\\)' before C23" } */
+signed _BitInt(15) b; /* { dg-warning "ISO C does not support 'signed _BitInt\\\(15\\\)' before C23" } */
+unsigned _BitInt(31) c; /* { dg-warning "ISO C does not support 'unsigned _BitInt\\\(31\\\)' before C23" } */
+int d = 21wb; /* { dg-warning "ISO C does not support literal 'wb' suffixes before C23" } */
+long long e = 60594869054uwb; /* { dg-warning "ISO C does not support literal 'wb' suffixes before C23" } */
__extension__ _BitInt(63) f;
__extension__ _BitInt(15) g;
__extension__ unsigned _BitInt(31) h;
int i = __extension__ 21wb;
long long j = __extension__ 60594869054uwb;
-#if 0wb == 0 /* { dg-warning "ISO C does not support literal 'wb' suffixes before C2X" } */
+#if 0wb == 0 /* { dg-warning "ISO C does not support literal 'wb' suffixes before C23" } */
#endif
-#if 0uwb == 0 /* { dg-warning "ISO C does not support literal 'wb' suffixes before C2X" } */
+#if 0uwb == 0 /* { dg-warning "ISO C does not support literal 'wb' suffixes before C23" } */
#endif
// { dg-do compile { target bitint } }
// { dg-options "-std=c11 -pedantic" }
-_BitInt(63) a; /* { dg-warning "ISO C does not support '_BitInt\\\(63\\\)' before C2X" } */
-signed _BitInt(15) b; /* { dg-warning "ISO C does not support 'signed _BitInt\\\(15\\\)' before C2X" } */
-unsigned _BitInt(31) c; /* { dg-warning "ISO C does not support 'unsigned _BitInt\\\(31\\\)' before C2X" } */
-int d = 21wb; /* { dg-warning "ISO C does not support literal 'wb' suffixes before C2X" } */
-long long e = 60594869054uwb; /* { dg-warning "ISO C does not support literal 'wb' suffixes before C2X" } */
+_BitInt(63) a; /* { dg-warning "ISO C does not support '_BitInt\\\(63\\\)' before C23" } */
+signed _BitInt(15) b; /* { dg-warning "ISO C does not support 'signed _BitInt\\\(15\\\)' before C23" } */
+unsigned _BitInt(31) c; /* { dg-warning "ISO C does not support 'unsigned _BitInt\\\(31\\\)' before C23" } */
+int d = 21wb; /* { dg-warning "ISO C does not support literal 'wb' suffixes before C23" } */
+long long e = 60594869054uwb; /* { dg-warning "ISO C does not support literal 'wb' suffixes before C23" } */
__extension__ _BitInt(63) f;
__extension__ _BitInt(15) g;
__extension__ unsigned _BitInt(31) h;
int i = __extension__ 21wb;
long long j = __extension__ 60594869054uwb;
-#if 0wb == 0 /* { dg-warning "ISO C does not support literal 'wb' suffixes before C2X" } */
+#if 0wb == 0 /* { dg-warning "ISO C does not support literal 'wb' suffixes before C23" } */
#endif
-#if 0uwb == 0 /* { dg-warning "ISO C does not support literal 'wb' suffixes before C2X" } */
+#if 0uwb == 0 /* { dg-warning "ISO C does not support literal 'wb' suffixes before C23" } */
#endif
// { dg-do compile { target bitint } }
// { dg-options "-std=c11 -pedantic-errors" }
-_BitInt(63) a; /* { dg-error "ISO C does not support '_BitInt\\\(63\\\)' before C2X" } */
-signed _BitInt(15) b; /* { dg-error "ISO C does not support 'signed _BitInt\\\(15\\\)' before C2X" } */
-unsigned _BitInt(31) c; /* { dg-error "ISO C does not support 'unsigned _BitInt\\\(31\\\)' before C2X" } */
-int d = 21wb; /* { dg-error "ISO C does not support literal 'wb' suffixes before C2X" } */
-long long e = 60594869054uwb; /* { dg-error "ISO C does not support literal 'wb' suffixes before C2X" } */
+_BitInt(63) a; /* { dg-error "ISO C does not support '_BitInt\\\(63\\\)' before C23" } */
+signed _BitInt(15) b; /* { dg-error "ISO C does not support 'signed _BitInt\\\(15\\\)' before C23" } */
+unsigned _BitInt(31) c; /* { dg-error "ISO C does not support 'unsigned _BitInt\\\(31\\\)' before C23" } */
+int d = 21wb; /* { dg-error "ISO C does not support literal 'wb' suffixes before C23" } */
+long long e = 60594869054uwb; /* { dg-error "ISO C does not support literal 'wb' suffixes before C23" } */
__extension__ _BitInt(63) f;
__extension__ _BitInt(15) g;
__extension__ unsigned _BitInt(31) h;
int i = __extension__ 21wb;
long long j = __extension__ 60594869054uwb;
-#if 0wb == 0 /* { dg-error "ISO C does not support literal 'wb' suffixes before C2X" } */
+#if 0wb == 0 /* { dg-error "ISO C does not support literal 'wb' suffixes before C23" } */
#endif
-#if 0uwb == 0 /* { dg-error "ISO C does not support literal 'wb' suffixes before C2X" } */
+#if 0uwb == 0 /* { dg-error "ISO C does not support literal 'wb' suffixes before C23" } */
#endif
-/* Test C2x attribute syntax: rejected in C11. */
+/* Test C23 attribute syntax: rejected in C11. */
/* { dg-do compile } */
/* { dg-options "-std=c11 -pedantic-errors" } */
-[[]]; /* { dg-error "attributes before C2X" } */
+[[]]; /* { dg-error "attributes before C23" } */
-void f [[]] (void); /* { dg-error "attributes before C2X" } */
+void f [[]] (void); /* { dg-error "attributes before C23" } */
-/* Test C2x attribute syntax: rejected in C11. */
+/* Test C23 attribute syntax: rejected in C11. */
/* { dg-do compile } */
/* { dg-options "-std=c11 -pedantic" } */
-[[]]; /* { dg-warning "attributes before C2X" } */
+[[]]; /* { dg-warning "attributes before C23" } */
-void f [[]] (void); /* { dg-warning "attributes before C2X" } */
+void f [[]] (void); /* { dg-warning "attributes before C23" } */
/* { dg-require-effective-target float32x } */
/* { dg-require-effective-target float64 } */
-_Float32 a /* { dg-error "ISO C does not support the '_Float32' type before C2X" } */
- = 1.0F32; /* { dg-error "non-standard suffix on floating constant before C2X" } */
-_Float64 b /* { dg-error "ISO C does not support the '_Float64' type before C2X" } */
- = 1.0F64; /* { dg-error "non-standard suffix on floating constant before C2X" } */
-_Float32x c /* { dg-error "ISO C does not support the '_Float32x' type before C2X" } */
- = 1.0F32x; /* { dg-error "non-standard suffix on floating constant before C2X" } */
+_Float32 a /* { dg-error "ISO C does not support the '_Float32' type before C23" } */
+ = 1.0F32; /* { dg-error "non-standard suffix on floating constant before C23" } */
+_Float64 b /* { dg-error "ISO C does not support the '_Float64' type before C23" } */
+ = 1.0F64; /* { dg-error "non-standard suffix on floating constant before C23" } */
+_Float32x c /* { dg-error "ISO C does not support the '_Float32x' type before C23" } */
+ = 1.0F32x; /* { dg-error "non-standard suffix on floating constant before C23" } */
__extension__ _Float32 d
= 2.0F32;
__extension__ _Float64 e
/* { dg-add-options float128 } */
/* { dg-require-effective-target float128 } */
-_Float128 a /* { dg-error "ISO C does not support the '_Float128' type before C2X" } */
- = 1.0F128; /* { dg-error "non-standard suffix on floating constant before C2X" } */
+_Float128 a /* { dg-error "ISO C does not support the '_Float128' type before C23" } */
+ = 1.0F128; /* { dg-error "non-standard suffix on floating constant before C23" } */
__extension__ _Float128 b
= 2.0F128;
/* { dg-add-options float16 } */
/* { dg-require-effective-target float16 } */
-_Float16 a /* { dg-error "ISO C does not support the '_Float16' type before C2X" } */
- = 1.0F16; /* { dg-error "non-standard suffix on floating constant before C2X" } */
+_Float16 a /* { dg-error "ISO C does not support the '_Float16' type before C23" } */
+ = 1.0F16; /* { dg-error "non-standard suffix on floating constant before C23" } */
__extension__ _Float16 b
= 2.0F16;
/* { dg-add-options float64x } */
/* { dg-require-effective-target float64x } */
-_Float64x a /* { dg-error "ISO C does not support the '_Float64x' type before C2X" } */
- = 1.0F64x; /* { dg-error "non-standard suffix on floating constant before C2X" } */
+_Float64x a /* { dg-error "ISO C does not support the '_Float64x' type before C23" } */
+ = 1.0F64x; /* { dg-error "non-standard suffix on floating constant before C23" } */
__extension__ _Float64x b
= 2.0F64x;
/* { dg-require-effective-target float32x } */
/* { dg-require-effective-target float64 } */
-_Float32 a /* { dg-warning "ISO C does not support the '_Float32' type before C2X" } */
- = 1.0F32; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
-_Float64 b /* { dg-warning "ISO C does not support the '_Float64' type before C2X" } */
- = 1.0F64; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
-_Float32x c /* { dg-warning "ISO C does not support the '_Float32x' type before C2X" } */
- = 1.0F32x; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
+_Float32 a /* { dg-warning "ISO C does not support the '_Float32' type before C23" } */
+ = 1.0F32; /* { dg-warning "non-standard suffix on floating constant before C23" } */
+_Float64 b /* { dg-warning "ISO C does not support the '_Float64' type before C23" } */
+ = 1.0F64; /* { dg-warning "non-standard suffix on floating constant before C23" } */
+_Float32x c /* { dg-warning "ISO C does not support the '_Float32x' type before C23" } */
+ = 1.0F32x; /* { dg-warning "non-standard suffix on floating constant before C23" } */
__extension__ _Float32 d
= 2.0F32;
__extension__ _Float64 e
/* { dg-add-options float128 } */
/* { dg-require-effective-target float128 } */
-_Float128 a /* { dg-warning "ISO C does not support the '_Float128' type before C2X" } */
- = 1.0F128; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
+_Float128 a /* { dg-warning "ISO C does not support the '_Float128' type before C23" } */
+ = 1.0F128; /* { dg-warning "non-standard suffix on floating constant before C23" } */
__extension__ _Float128 b
= 2.0F128;
/* { dg-add-options float16 } */
/* { dg-require-effective-target float16 } */
-_Float16 a /* { dg-warning "ISO C does not support the '_Float16' type before C2X" } */
- = 1.0F16; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
+_Float16 a /* { dg-warning "ISO C does not support the '_Float16' type before C23" } */
+ = 1.0F16; /* { dg-warning "non-standard suffix on floating constant before C23" } */
__extension__ _Float16 b
= 2.0F16;
/* { dg-add-options float64x } */
/* { dg-require-effective-target float64x } */
-_Float64x a /* { dg-warning "ISO C does not support the '_Float64x' type before C2X" } */
- = 1.0F64x; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
+_Float64x a /* { dg-warning "ISO C does not support the '_Float64x' type before C23" } */
+ = 1.0F64x; /* { dg-warning "non-standard suffix on floating constant before C23" } */
__extension__ _Float64x b
= 2.0F64x;
-/* Test C2x attribute syntax: diagnosed with -Wc11-c2x-compat. */
+/* Test C23 attribute syntax: diagnosed with -Wc11-c2x-compat. */
/* { dg-do compile } */
/* { dg-options "-std=c2x -pedantic-errors -Wc11-c2x-compat" } */
-[[]]; /* { dg-warning "attributes before C2X" } */
+[[]]; /* { dg-warning "attributes before C23" } */
-void f [[]] (void); /* { dg-warning "attributes before C2X" } */
+void f [[]] (void); /* { dg-warning "attributes before C23" } */
-/* Test C2x attribute syntax: use of __extension__ in C11 mode. */
+/* Test C23 attribute syntax: use of __extension__ in C11 mode. */
/* { dg-do compile } */
/* { dg-options "-std=c11 -pedantic-errors" } */
case 19:
case 33:
x *= 2;
- [[fallthrough]]; /* { dg-error {attributes before C2X} } */
+ [[fallthrough]]; /* { dg-error {attributes before C23} } */
case 99:
return x;
typedef int [[__extension__ gnu JOIN2(:,:) vector_size (4)]] b5; /* { dg-error {pasting ":" and ":" does not give a valid preprocessing token} } */
typedef int [[gnu::vector_size(4)]] b6; /* { dg-error {expected '\]' before ':'} } */
/* { dg-error {'gnu' attribute ignored} "" { target *-*-* } .-1 } */
-/* { dg-error {attributes before C2X} "" { target *-*-* } .-2 } */
+/* { dg-error {attributes before C23} "" { target *-*-* } .-2 } */
typedef int [[gnu : : vector_size(4)]] b7; /* { dg-error {expected '\]' before ':'} } */
/* { dg-error {'gnu' attribute ignored} "" { target *-*-* } .-1 } */
-/* { dg-error {attributes before C2X} "" { target *-*-* } .-2 } */
+/* { dg-error {attributes before C23} "" { target *-*-* } .-2 } */
typedef int [[gnu : vector_size(4)]] b8; /* { dg-error {expected '\]' before ':'} } */
/* { dg-error {'gnu' attribute ignored} "" { target *-*-* } .-1 } */
-/* { dg-error {attributes before C2X} "" { target *-*-* } .-2 } */
+/* { dg-error {attributes before C23} "" { target *-*-* } .-2 } */
-/* Test C2x attribute syntax: use of __extension__ in C11 mode. */
+/* Test C23 attribute syntax: use of __extension__ in C11 mode. */
/* { dg-do compile } */
/* { dg-options "-std=c2x -pedantic-errors -Wc11-c2x-compat" } */
case 19:
case 33:
x *= 2;
- [[fallthrough]]; /* { dg-warning {attributes before C2X} } */
+ [[fallthrough]]; /* { dg-warning {attributes before C23} } */
case 99:
return x;
typedef int [[__extension__ gnu:vector_size(4)]] b4; /* { dg-error {expected '\]' before ':'} } */
/* { dg-error {'gnu' attribute ignored} "" { target *-*-* } .-1 } */
typedef int [[__extension__ gnu JOIN2(:,:) vector_size (4)]] b5;
-typedef int [[gnu::vector_size(4)]] b6; /* { dg-warning {attributes before C2X} } */
+typedef int [[gnu::vector_size(4)]] b6; /* { dg-warning {attributes before C23} } */
typedef int [[gnu : : vector_size(4)]] b7; /* { dg-error {expected '\]' before ':'} } */
/* { dg-error {'gnu' attribute ignored} "" { target *-*-* } .-1 } */
-/* { dg-warning {attributes before C2X} "" { target *-*-* } .-2 } */
+/* { dg-warning {attributes before C23} "" { target *-*-* } .-2 } */
typedef int [[gnu : vector_size(4)]] b8; /* { dg-error {expected '\]' before ':'} } */
/* { dg-error {'gnu' attribute ignored} "" { target *-*-* } .-1 } */
-/* { dg-warning {attributes before C2X} "" { target *-*-* } .-2 } */
+/* { dg-warning {attributes before C23} "" { target *-*-* } .-2 } */
-/* Test that binary constants are accepted in C2X mode: compat warnings. */
+/* Test that binary constants are accepted in C23 mode: compat warnings. */
/* { dg-do compile } */
/* { dg-options "-std=c2x -Wc11-c2x-compat" } */
-int a = 0b1; /* { dg-warning "C2X feature" } */
-#if 0b101 /* { dg-warning "C2X feature" } */
+int a = 0b1; /* { dg-warning "C23 feature" } */
+#if 0b101 /* { dg-warning "C23 feature" } */
#endif
-int b = 0B1; /* { dg-warning "C2X feature" } */
-#if 0B101 /* { dg-warning "C2X feature" } */
+int b = 0B1; /* { dg-warning "C23 feature" } */
+#if 0B101 /* { dg-warning "C23 feature" } */
#endif
/* { dg-require-effective-target float32x } */
/* { dg-require-effective-target float64 } */
-_Float32 a /* { dg-warning "ISO C does not support the '_Float32' type before C2X" } */
- = 1.0F32; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
-_Float64 b /* { dg-warning "ISO C does not support the '_Float64' type before C2X" } */
- = 1.0F64; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
-_Float32x c /* { dg-warning "ISO C does not support the '_Float32x' type before C2X" } */
- = 1.0F32x; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
+_Float32 a /* { dg-warning "ISO C does not support the '_Float32' type before C23" } */
+ = 1.0F32; /* { dg-warning "non-standard suffix on floating constant before C23" } */
+_Float64 b /* { dg-warning "ISO C does not support the '_Float64' type before C23" } */
+ = 1.0F64; /* { dg-warning "non-standard suffix on floating constant before C23" } */
+_Float32x c /* { dg-warning "ISO C does not support the '_Float32x' type before C23" } */
+ = 1.0F32x; /* { dg-warning "non-standard suffix on floating constant before C23" } */
__extension__ _Float32 d
= 2.0F32;
__extension__ _Float64 e
/* { dg-add-options float128 } */
/* { dg-require-effective-target float128 } */
-_Float128 a /* { dg-warning "ISO C does not support the '_Float128' type before C2X" } */
- = 1.0F128; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
+_Float128 a /* { dg-warning "ISO C does not support the '_Float128' type before C23" } */
+ = 1.0F128; /* { dg-warning "non-standard suffix on floating constant before C23" } */
__extension__ _Float128 b
= 2.0F128;
/* { dg-add-options float16 } */
/* { dg-require-effective-target float16 } */
-_Float16 a /* { dg-warning "ISO C does not support the '_Float16' type before C2X" } */
- = 1.0F16; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
+_Float16 a /* { dg-warning "ISO C does not support the '_Float16' type before C23" } */
+ = 1.0F16; /* { dg-warning "non-standard suffix on floating constant before C23" } */
__extension__ _Float16 b
= 2.0F16;
/* { dg-add-options float64x } */
/* { dg-require-effective-target float64x } */
-_Float64x a /* { dg-warning "ISO C does not support the '_Float64x' type before C2X" } */
- = 1.0F64x; /* { dg-warning "non-standard suffix on floating constant before C2X" } */
+_Float64x a /* { dg-warning "ISO C does not support the '_Float64x' type before C23" } */
+ = 1.0F64x; /* { dg-warning "non-standard suffix on floating constant before C23" } */
__extension__ _Float64x b
= 2.0F64x;
/* Test that -Wc11-c2x-compat issues a warning (not a pedwarn) about
- `nullptr' in C2X. */
+ `nullptr' in C23. */
/* { dg-do compile } */
/* { dg-options "-std=c2x -pedantic-errors -Wc11-c2x-compat" } */
int *
fn (int *p)
{
- p = nullptr; /* { dg-warning "ISO C does not support .nullptr. before C2X" } */
+ p = nullptr; /* { dg-warning "ISO C does not support .nullptr. before C23" } */
return p;
}
-/* Tests related to qualifiers and pointers to arrays in C2X, PR98397 */
+/* Tests related to qualifiers and pointers to arrays in C23, PR98397 */
/* { dg-do compile } */
/* { dg-options "-std=c2x -Wc11-c2x-compat" } */
-/* test that qualifiers are preserved in tertiary operator for pointers to arrays in C2X */
+/* test that qualifiers are preserved in tertiary operator for pointers to arrays in C23 */
void f(void)
{
void h(void)
{
const void* x;
- const int (*p)[3] = x; /* { dg-warning "array with qualifier on the element is not qualified before C2X" } */
+ const int (*p)[3] = x; /* { dg-warning "array with qualifier on the element is not qualified before C23" } */
}
-/* Tests related to qualifiers and pointers to arrays in C2X, PR98397 */
+/* Tests related to qualifiers and pointers to arrays in C23, PR98397 */
/* { dg-do compile } */
/* { dg-options "-std=c2x -Wc11-c2x-compat -pedantic-errors" } */
-/* test that qualifiers are preserved in tertiary operator for pointers to arrays in C2X */
+/* test that qualifiers are preserved in tertiary operator for pointers to arrays in C23 */
void f(void)
{
void h(void)
{
const void* x;
- const int (*p)[3] = x; /* { dg-warning "array with qualifier on the element is not qualified before C2X" } */
+ const int (*p)[3] = x; /* { dg-warning "array with qualifier on the element is not qualified before C23" } */
}
void transpose1(double out[2][2], const double in[2][2]) { }
void transpose2(double out[2][2][2], const double in[2][2][2]) { }
// return
-int (*x2(const int x[3][3]))[3] { return x; } /* { dg-warning "before C2X" } */
+int (*x2(const int x[3][3]))[3] { return x; } /* { dg-warning "before C23" } */
/* { dg-error "return discards" "" { target *-*-* } .-1 } */
-const int (*x3(int x[3][3]))[3] { return x; } /* { dg-warning "before C2X" } */
+const int (*x3(int x[3][3]))[3] { return x; } /* { dg-warning "before C23" } */
void test(void)
{
double x0[2];
transpose1(pc, p); /* { dg-error "passing argument 1 of 'transpose1' discards 'const' qualifier from pointer target type" } */
transpose2(pc, p); /* { dg-error "passing argument 1 of 'transpose2' discards 'const' qualifier from pointer target type" } */
transpose0(p, pc);
- transpose1(p, pc); /* { dg-warning "before C2X" } */
- transpose2(p, pc); /* { dg-warning "before C2X" } */
+ transpose1(p, pc); /* { dg-warning "before C23" } */
+ transpose2(p, pc); /* { dg-warning "before C23" } */
// passing as arguments
transpose0(y0, x0);
transpose1(y1, o1); /* { dg-error "passing argument 2 of 'transpose1' from incompatible pointer type" } */
- transpose1(y1, x1); /* { dg-warning "before C2X" } */
+ transpose1(y1, x1); /* { dg-warning "before C23" } */
transpose2(y2, o2); /* { dg-error "passing argument 2 of 'transpose2' from incompatible pointer type" } */
- transpose2(y2, x2); /* { dg-warning "before C2X" } */
+ transpose2(y2, x2); /* { dg-warning "before C23" } */
// initialization
const double (*x0p) = x0;
- const double (*x1p)[2] = x1; /* { dg-warning "before C2X" } */
- const double (*x2p)[2][2] = x2; /* { dg-warning "before C2X" } */
+ const double (*x1p)[2] = x1; /* { dg-warning "before C23" } */
+ const double (*x2p)[2][2] = x2; /* { dg-warning "before C23" } */
double (*v0p) = z0; /* { dg-error "initialization discards 'const' qualifier from pointer target type" } */
- double (*v1p)[2] = z1; /* { dg-warning "before C2X" } */
+ double (*v1p)[2] = z1; /* { dg-warning "before C23" } */
/* { dg-error "initialization discards" "" { target *-*-* } .-1 } */
- double (*v2p)[2][2] = z2; /* { dg-warning "before C2X" } */
+ double (*v2p)[2][2] = z2; /* { dg-warning "before C23" } */
/* { dg-error "initialization discards" "" { target *-*-* } .-1 } */
// assignment
x0p = x0;
- x1p = x1; /* { dg-warning "before C2X" } */
- x2p = x2; /* { dg-warning "before C2X" } */
+ x1p = x1; /* { dg-warning "before C23" } */
+ x2p = x2; /* { dg-warning "before C23" } */
// subtraction
&(x0[1]) - &(z0[0]);
- &(x1[1]) - &(z1[0]); /* { dg-warning "before C2X" } */
- &(x2[1]) - &(z2[0]); /* { dg-warning "before C2X" } */
+ &(x1[1]) - &(z1[0]); /* { dg-warning "before C23" } */
+ &(x2[1]) - &(z2[0]); /* { dg-warning "before C23" } */
// comparison
x0 == z0;
- x1 == z1; /* { dg-warning "before C2X" } */
- x2 == z2; /* { dg-warning "before C2X" } */
+ x1 == z1; /* { dg-warning "before C23" } */
+ x2 == z2; /* { dg-warning "before C23" } */
x0 < z0;
- x1 < z1; /* { dg-warning "before C2X" } */
- x2 < z2; /* { dg-warning "before C2X" } */
+ x1 < z1; /* { dg-warning "before C23" } */
+ x2 < z2; /* { dg-warning "before C23" } */
x0 > z0;
- x1 > z1; /* { dg-warning "before C2X" } */
- x2 > z2; /* { dg-warning "before C2X" } */
+ x1 > z1; /* { dg-warning "before C23" } */
+ x2 > z2; /* { dg-warning "before C23" } */
// conditional expressions
(void)(1 ? x0 : z0);
- (void)(1 ? x1 : z1); /* { dg-warning "before C2X" } */
- (void)(1 ? x2 : z2); /* { dg-warning "before C2X" } */
+ (void)(1 ? x1 : z1); /* { dg-warning "before C23" } */
+ (void)(1 ? x2 : z2); /* { dg-warning "before C23" } */
(void)(1 ? x0 : x1); /* { dg-error "pointer type mismatch in conditional expression" } */
(void)(1 ? x1 : x2); /* { dg-error "pointer type mismatch in conditional expression" } */
(void)(1 ? x2 : x0); /* { dg-error "pointer type mismatch in conditional expression" } */
v0p = (1 ? z0 : v0p); /* { dg-error "assignment discards 'const' qualifier from pointer target type" } */
- v1p = (1 ? z1 : v1p); /* { dg-warning "before C2X" } */
+ v1p = (1 ? z1 : v1p); /* { dg-warning "before C23" } */
/* { dg-error "assignment discards" "" { target *-*-* } .-1 } */
- v2p = (1 ? z2 : v2p); /* { dg-warning "before C2X" } */
+ v2p = (1 ? z2 : v2p); /* { dg-warning "before C23" } */
/* { dg-error "assignment discards" "" { target *-*-* } .-1 } */
v0p = (1 ? x0 : x0p); /* { dg-error "assignment discards 'const' qualifier from pointer target type" } */
v1p = (1 ? x1 : x1p); /* { dg-error "assignment discards" } */
- /* { dg-warning "before C2X" "" { target *-*-* } .-1 } */
+ /* { dg-warning "before C23" "" { target *-*-* } .-1 } */
v2p = (1 ? x2 : x2p); /* { dg-error "assignment discards" } */
- /* { dg-warning "before C2X" "" { target *-*-* } .-1 } */
+ /* { dg-warning "before C23" "" { target *-*-* } .-1 } */
(1 ? x0 : z0)[0] = 1; /* { dg-error "assignment of read-only location" } */
(1 ? x1 : z1)[0][0] = 1; /* { dg-error "assignment of read-only location" } */
- /* { dg-warning "before C2X" "" { target *-*-* } .-1 } */
+ /* { dg-warning "before C23" "" { target *-*-* } .-1 } */
(1 ? x2 : z2)[0][0][0] = 1; /* { dg-error "assignment of read-only location" } */
- /* { dg-warning "before C2X" "" { target *-*-* } .-1 } */
+ /* { dg-warning "before C23" "" { target *-*-* } .-1 } */
v0p = (1 ? p : z0); /* { dg-error "assignment discards 'const' qualifier from pointer target type" } */
v1p = (1 ? p : z1); /* { dg-error "assignment discards 'const' qualifier from pointer target type" } */
- /* { dg-warning "before C2X" "" { target *-*-* } .-1 } */
+ /* { dg-warning "before C23" "" { target *-*-* } .-1 } */
v2p = (1 ? p : z2); /* { dg-error "assignment discards 'const' qualifier from pointer target type" } */
- /* { dg-warning "before C2X" "" { target *-*-* } .-1 } */
+ /* { dg-warning "before C23" "" { target *-*-* } .-1 } */
v0p = (1 ? pc : x0); /* { dg-error "assignment discards 'const' qualifier from pointer target type" } */
v1p = (1 ? pc : x1); /* { dg-error "assignment discards 'const' qualifier from pointer target type" } */
v2p = (1 ? pc : x2); /* { dg-error "assignment discards 'const' qualifier from pointer target type" } */
/* { dg-options "-std=c11 -pedantic-errors" } */
#warning example text /* { dg-warning "example text" } */
-/* { dg-error "#warning before C2X is a GCC extension" "pedantic" { target *-*-* } .-1 } */
+/* { dg-error "#warning before C23 is a GCC extension" "pedantic" { target *-*-* } .-1 } */
/* { dg-options "-std=c11 -pedantic" } */
#warning example text /* { dg-warning "example text" } */
-/* { dg-warning "#warning before C2X is a GCC extension" "pedantic" { target *-*-* } .-1 } */
+/* { dg-warning "#warning before C23 is a GCC extension" "pedantic" { target *-*-* } .-1 } */
/* { dg-options "-std=c11 -Wc11-c2x-compat" } */
#warning example text /* { dg-warning "example text" } */
-/* { dg-warning "#warning before C2X is a GCC extension" "compat" { target *-*-* } .-1 } */
+/* { dg-warning "#warning before C23 is a GCC extension" "compat" { target *-*-* } .-1 } */
-/* Test #warning in C2x: -Wc11-c2x-comapt. */
+/* Test #warning in C23: -Wc11-c2x-comapt. */
/* { dg-do preprocess } */
/* { dg-options "-std=c2x -pedantic-errors -Wc11-c2x-compat" } */
#warning example text /* { dg-warning "example text" } */
-/* { dg-warning "#warning before C2X is a GCC extension" "compat" { target *-*-* } .-1 } */
+/* { dg-warning "#warning before C23 is a GCC extension" "compat" { target *-*-* } .-1 } */
#undef B
#if 0
-#elifdef A /* { dg-warning "#elifdef before C2X is a GCC extension" } */
+#elifdef A /* { dg-warning "#elifdef before C23 is a GCC extension" } */
#define M1 1
#endif
#endif
#if 0
-#elifndef B /* { dg-warning "#elifndef before C2X is a GCC extension" } */
+#elifndef B /* { dg-warning "#elifndef before C23 is a GCC extension" } */
#define M2 2
#endif
#endif
#if 0
-#elifdef A /* { dg-warning "#elifdef before C2X is a GCC extension" } */
+#elifdef A /* { dg-warning "#elifdef before C23 is a GCC extension" } */
#else
#error "#elifdef A did not apply"
#endif
#if 0
-#elifndef B /* { dg-warning "#elifndef before C2X is a GCC extension" } */
+#elifndef B /* { dg-warning "#elifndef before C23 is a GCC extension" } */
#else
#error "#elifndef B did not apply"
#endif
#if 1
-#elifdef A /* { dg-warning "#elifdef before C2X is a GCC extension" } */
+#elifdef A /* { dg-warning "#elifdef before C23 is a GCC extension" } */
#endif
#if 1
-#elifndef B /* { dg-warning "#elifndef before C2X is a GCC extension" } */
+#elifndef B /* { dg-warning "#elifndef before C23 is a GCC extension" } */
#endif
/* As with #elif, the syntax of the new directives is relaxed after a
non-skipped group. */
#if 1
-#elifdef x * y /* { dg-warning "#elifdef before C2X is a GCC extension" } */
+#elifdef x * y /* { dg-warning "#elifdef before C23 is a GCC extension" } */
#endif
#if 1
-#elifndef ! /* { dg-warning "#elifndef before C2X is a GCC extension" } */
+#elifndef ! /* { dg-warning "#elifndef before C23 is a GCC extension" } */
#endif
#undef B
#if 0
-#elifdef A /* { dg-error "#elifdef before C2X is a GCC extension" } */
+#elifdef A /* { dg-error "#elifdef before C23 is a GCC extension" } */
#define M1 1
#endif
#endif
#if 0
-#elifndef B /* { dg-error "#elifndef before C2X is a GCC extension" } */
+#elifndef B /* { dg-error "#elifndef before C23 is a GCC extension" } */
#define M2 2
#endif
#endif
#if 0
-#elifdef A /* { dg-error "#elifdef before C2X is a GCC extension" } */
+#elifdef A /* { dg-error "#elifdef before C23 is a GCC extension" } */
#else
#error "#elifdef A did not apply"
#endif
#if 0
-#elifndef B /* { dg-error "#elifndef before C2X is a GCC extension" } */
+#elifndef B /* { dg-error "#elifndef before C23 is a GCC extension" } */
#else
#error "#elifndef B did not apply"
#endif
#if 1
-#elifdef A /* { dg-error "#elifdef before C2X is a GCC extension" } */
+#elifdef A /* { dg-error "#elifdef before C23 is a GCC extension" } */
#endif
#if 1
-#elifndef B /* { dg-error "#elifndef before C2X is a GCC extension" } */
+#elifndef B /* { dg-error "#elifndef before C23 is a GCC extension" } */
#endif
/* As with #elif, the syntax of the new directives is relaxed after a
non-skipped group. */
#if 1
-#elifdef x * y /* { dg-error "#elifdef before C2X is a GCC extension" } */
+#elifdef x * y /* { dg-error "#elifdef before C23 is a GCC extension" } */
#endif
#if 1
-#elifndef ! /* { dg-error "#elifndef before C2X is a GCC extension" } */
+#elifndef ! /* { dg-error "#elifndef before C23 is a GCC extension" } */
#endif
/* { dg-options "-std=gnu11 -pedantic-errors" } */
#warning example text /* { dg-warning "example text" } */
-/* { dg-error "#warning before C2X is a GCC extension" "pedantic" { target *-*-* } .-1 } */
+/* { dg-error "#warning before C23 is a GCC extension" "pedantic" { target *-*-* } .-1 } */
/* { dg-options "-std=gnu11 -pedantic" } */
#warning example text /* { dg-warning "example text" } */
-/* { dg-warning "#warning before C2X is a GCC extension" "pedantic" { target *-*-* } .-1 } */
+/* { dg-warning "#warning before C23 is a GCC extension" "pedantic" { target *-*-* } .-1 } */
/* { dg-options "-std=gnu11 -Wc11-c2x-compat" } */
#warning example text /* { dg-warning "example text" } */
-/* { dg-warning "#warning before C2X is a GCC extension" "compat" { target *-*-* } .-1 } */
+/* { dg-warning "#warning before C23 is a GCC extension" "compat" { target *-*-* } .-1 } */
-/* Test #warning in C2x: -Wc11-c2x-comapt. */
+/* Test #warning in C23: -Wc11-c2x-comapt. */
/* { dg-do preprocess } */
/* { dg-options "-std=gnu2x -pedantic-errors -Wc11-c2x-compat" } */
#warning example text /* { dg-warning "example text" } */
-/* { dg-warning "#warning before C2X is a GCC extension" "compat" { target *-*-* } .-1 } */
+/* { dg-warning "#warning before C23 is a GCC extension" "compat" { target *-*-* } .-1 } */
/* { dg-do compile } */
/* { dg-options "-std=c11 -pedantic" } */
-int a = (int) 1.1DF; /* { dg-warning "C2X feature" } */
-int b = (int) 2.df; /* { dg-warning "C2X feature" } */
-int c = (int) .33DD; /* { dg-warning "C2X feature" } */
-int d = (int) 2e1dd; /* { dg-warning "C2X feature" } */
-int e = (int) .3e2DL; /* { dg-warning "C2X feature" } */
-int f = (int) 4.5e3dl; /* { dg-warning "C2X feature" } */
-int g = (int) 5.e0DF; /* { dg-warning "C2X feature" } */
-int h = (int) 1e+2df; /* { dg-warning "C2X feature" } */
-int i = (int) 1000e-3DL; /* { dg-warning "C2X feature" } */
+int a = (int) 1.1DF; /* { dg-warning "C23 feature" } */
+int b = (int) 2.df; /* { dg-warning "C23 feature" } */
+int c = (int) .33DD; /* { dg-warning "C23 feature" } */
+int d = (int) 2e1dd; /* { dg-warning "C23 feature" } */
+int e = (int) .3e2DL; /* { dg-warning "C23 feature" } */
+int f = (int) 4.5e3dl; /* { dg-warning "C23 feature" } */
+int g = (int) 5.e0DF; /* { dg-warning "C23 feature" } */
+int h = (int) 1e+2df; /* { dg-warning "C23 feature" } */
+int i = (int) 1000e-3DL; /* { dg-warning "C23 feature" } */
/* { dg-do compile } */
/* { dg-options "-std=c11 -pedantic-errors" } */
-int a = (int) 1.1DF; /* { dg-error "C2X feature" } */
-int b = (int) 2.df; /* { dg-error "C2X feature" } */
-int c = (int) .33DD; /* { dg-error "C2X feature" } */
-int d = (int) 2e1dd; /* { dg-error "C2X feature" } */
-int e = (int) .3e2DL; /* { dg-error "C2X feature" } */
-int f = (int) 4.5e3dl; /* { dg-error "C2X feature" } */
-int g = (int) 5.e0DF; /* { dg-error "C2X feature" } */
-int h = (int) 1e+2df; /* { dg-error "C2X feature" } */
-int i = (int) 1000e-3DL; /* { dg-error "C2X feature" } */
+int a = (int) 1.1DF; /* { dg-error "C23 feature" } */
+int b = (int) 2.df; /* { dg-error "C23 feature" } */
+int c = (int) .33DD; /* { dg-error "C23 feature" } */
+int d = (int) 2e1dd; /* { dg-error "C23 feature" } */
+int e = (int) .3e2DL; /* { dg-error "C23 feature" } */
+int f = (int) 4.5e3dl; /* { dg-error "C23 feature" } */
+int g = (int) 5.e0DF; /* { dg-error "C23 feature" } */
+int h = (int) 1e+2df; /* { dg-error "C23 feature" } */
+int i = (int) 1000e-3DL; /* { dg-error "C23 feature" } */
-/* Test that DFP constants are accepted in C2X mode: compat warnings. */
+/* Test that DFP constants are accepted in C23 mode: compat warnings. */
/* { dg-do compile } */
/* { dg-options "-std=c2x -Wc11-c2x-compat" } */
-int a = (int) 1.1DF; /* { dg-warning "C2X feature" } */
-int b = (int) 2.df; /* { dg-warning "C2X feature" } */
-int c = (int) .33DD; /* { dg-warning "C2X feature" } */
-int d = (int) 2e1dd; /* { dg-warning "C2X feature" } */
-int e = (int) .3e2DL; /* { dg-warning "C2X feature" } */
-int f = (int) 4.5e3dl; /* { dg-warning "C2X feature" } */
-int g = (int) 5.e0DF; /* { dg-warning "C2X feature" } */
-int h = (int) 1e+2df; /* { dg-warning "C2X feature" } */
-int i = (int) 1000e-3DL; /* { dg-warning "C2X feature" } */
+int a = (int) 1.1DF; /* { dg-warning "C23 feature" } */
+int b = (int) 2.df; /* { dg-warning "C23 feature" } */
+int c = (int) .33DD; /* { dg-warning "C23 feature" } */
+int d = (int) 2e1dd; /* { dg-warning "C23 feature" } */
+int e = (int) .3e2DL; /* { dg-warning "C23 feature" } */
+int f = (int) 4.5e3dl; /* { dg-warning "C23 feature" } */
+int g = (int) 5.e0DF; /* { dg-warning "C23 feature" } */
+int h = (int) 1e+2df; /* { dg-warning "C23 feature" } */
+int i = (int) 1000e-3DL; /* { dg-warning "C23 feature" } */
#include "dfp-dbg.h"
-_Decimal32 a = 1.1df; /* { dg-warning "C2X feature|ISO C" } */
-_Decimal32 b = -.003DF; /* { dg-warning "C2X feature|ISO C" } */
-_Decimal64 c = 11e-1dl; /* { dg-warning "C2X feature|ISO C" } */
-_Decimal64 d = -.3DL; /* { dg-warning "C2X feature|ISO C" } */
-_Decimal128 e = 000.3e0dl; /* { dg-warning "C2X feature|ISO C" } */
-_Decimal128 f = 3000300030003e0DL; /* { dg-warning "C2X feature|ISO C" } */
+_Decimal32 a = 1.1df; /* { dg-warning "C23 feature|ISO C" } */
+_Decimal32 b = -.003DF; /* { dg-warning "C23 feature|ISO C" } */
+_Decimal64 c = 11e-1dl; /* { dg-warning "C23 feature|ISO C" } */
+_Decimal64 d = -.3DL; /* { dg-warning "C23 feature|ISO C" } */
+_Decimal128 e = 000.3e0dl; /* { dg-warning "C23 feature|ISO C" } */
+_Decimal128 f = 3000300030003e0DL; /* { dg-warning "C23 feature|ISO C" } */
return 0;
}
-enum E1 { e10 = INT_MAX, e11 }; /* { dg-warning "ISO C restricts enumerator values to range of 'int' before C2X" } */
-enum E2 { e20 = (unsigned) INT_MAX, e21 }; /* { dg-warning "ISO C restricts enumerator values to range of 'int' before C2X" } */
+enum E1 { e10 = INT_MAX, e11 }; /* { dg-warning "ISO C restricts enumerator values to range of 'int' before C23" } */
+enum E2 { e20 = (unsigned) INT_MAX, e21 }; /* { dg-warning "ISO C restricts enumerator values to range of 'int' before C23" } */
warning. */
return 23;
#endif
- return 0b1101; /* { dg-warning "binary constants are a C2X feature or GCC extension" } */
+ return 0b1101; /* { dg-warning "binary constants are a C23 feature or GCC extension" } */
}
normal GNU extensions for target-specific vector types. */
#define TYPE_INDIVISIBLE_P(NODE) (TYPE_CHECK (NODE)->type_common.indivisible_p)
-/* True if this is a stdarg function with no named arguments (C2x
+/* True if this is a stdarg function with no named arguments (C23
(...) prototype, where arguments can be accessed with va_start and
va_arg), as opposed to an unprototyped function. */
#define TYPE_NO_NAMED_ARGS_STDARG_P(NODE) \
/* Values for the origin field of struct directive. KANDR directives
come from traditional (K&R) C. STDC89 directives come from the
- 1989 C standard. STDC2X directives come from the C2X standard. EXTENSION
+ 1989 C standard. STDC23 directives come from the C23 standard. EXTENSION
directives are extensions. */
#define KANDR 0
#define STDC89 1
-#define STDC2X 2
+#define STDC23 2
#define EXTENSION 3
/* Values for the flags field of struct directive. COND indicates a
D(undef, T_UNDEF, KANDR, IN_I) \
D(line, T_LINE, KANDR, EXPAND) \
D(elif, T_ELIF, STDC89, COND | EXPAND) \
- D(elifdef, T_ELIFDEF, STDC2X, COND | ELIFDEF) \
- D(elifndef, T_ELIFNDEF, STDC2X, COND | ELIFDEF) \
+ D(elifdef, T_ELIFDEF, STDC23, COND | ELIFDEF) \
+ D(elifndef, T_ELIFNDEF, STDC23, COND | ELIFDEF) \
D(error, T_ERROR, STDC89, 0) \
D(pragma, T_PRAGMA, STDC89, IN_I) \
- D(warning, T_WARNING, STDC2X, 0) \
+ D(warning, T_WARNING, STDC23, 0) \
D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) \
D(ident, T_IDENT, EXTENSION, IN_I) \
D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* ObjC */ \
"#%s before C++23 is a GCC extension", dir->name);
else
cpp_error (pfile, CPP_DL_PEDWARN,
- "#%s before C2X is a GCC extension", dir->name);
+ "#%s before C23 is a GCC extension", dir->name);
}
- else if (CPP_OPTION (pfile, cpp_warn_c11_c2x_compat) > 0)
- cpp_warning (pfile, CPP_W_C11_C2X_COMPAT,
- "#%s before C2X is a GCC extension", dir->name);
+ else if (CPP_OPTION (pfile, cpp_warn_c11_c23_compat) > 0)
+ cpp_warning (pfile, CPP_W_C11_C23_COMPAT,
+ "#%s before C23 is a GCC extension", dir->name);
}
else if (((dir->flags & DEPRECATED) != 0
|| (dir == &dtable[T_IMPORT] && !CPP_OPTION (pfile, objc)))
pfile->directive->name);
else
cpp_error (pfile, CPP_DL_PEDWARN,
- "#%s before C2X is a GCC extension",
+ "#%s before C23 is a GCC extension",
pfile->directive->name);
}
pfile->state.skipping = 1;
pfile->directive->name);
else
cpp_error (pfile, CPP_DL_PEDWARN,
- "#%s before C2X is a GCC extension",
+ "#%s before C23 is a GCC extension",
pfile->directive->name);
}
pfile->state.skipping = skip;
f = d = l = w = q = i = fn = fnx = fn_bits = bf16 = 0;
/* The following decimal float suffixes, from TR 24732:2009, TS
- 18661-2:2015 and C2X, are supported:
+ 18661-2:2015 and C23, are supported:
df, DF - _Decimal32.
dd, DD - _Decimal64.
{
if (CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, dfp_constants))
cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
- "decimal float constants are a C2X feature");
- else if (CPP_OPTION (pfile, cpp_warn_c11_c2x_compat) > 0)
- cpp_warning_with_line (pfile, CPP_W_C11_C2X_COMPAT,
+ "decimal float constants are a C23 feature");
+ else if (CPP_OPTION (pfile, cpp_warn_c11_c23_compat) > 0)
+ cpp_warning_with_line (pfile, CPP_W_C11_C23_COMPAT,
virtual_location, 0,
- "decimal float constants are a C2X feature");
+ "decimal float constants are a C23 feature");
}
result |= CPP_N_FLOATING;
}
if ((result & CPP_N_BITINT) != 0
- && CPP_OPTION (pfile, cpp_warn_c11_c2x_compat) != 0)
+ && CPP_OPTION (pfile, cpp_warn_c11_c23_compat) != 0)
{
- if (CPP_OPTION (pfile, cpp_warn_c11_c2x_compat) > 0)
+ if (CPP_OPTION (pfile, cpp_warn_c11_c23_compat) > 0)
{
const char *message = N_("ISO C does not support literal "
- "%<wb%> suffixes before C2X");
+ "%<wb%> suffixes before C23");
if (CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, true_false))
- cpp_pedwarning_with_line (pfile, CPP_W_C11_C2X_COMPAT,
+ cpp_pedwarning_with_line (pfile, CPP_W_C11_C23_COMPAT,
virtual_location, 0, message);
else
- cpp_warning_with_line (pfile, CPP_W_C11_C2X_COMPAT,
+ cpp_warning_with_line (pfile, CPP_W_C11_C23_COMPAT,
virtual_location, 0, message);
}
else if (CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, true_false))
{
const char *message = N_("ISO C does not support literal "
- "%<wb%> suffixes before C2X");
+ "%<wb%> suffixes before C23");
cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
message);
}
CPP_OPTION (pfile, cplusplus)
? N_("binary constants are a C++14 feature "
"or GCC extension")
- : N_("binary constants are a C2X feature "
+ : N_("binary constants are a C23 feature "
"or GCC extension"));
- else if (CPP_OPTION (pfile, cpp_warn_c11_c2x_compat) > 0)
- cpp_warning_with_line (pfile, CPP_W_C11_C2X_COMPAT,
+ else if (CPP_OPTION (pfile, cpp_warn_c11_c23_compat) > 0)
+ cpp_warning_with_line (pfile, CPP_W_C11_C23_COMPAT,
virtual_location, 0,
- "binary constants are a C2X feature");
+ "binary constants are a C23 feature");
}
if (radix == 10)
#undef TK
/* C language kind, used when calling cpp_create_reader. */
-enum c_lang {CLK_GNUC89 = 0, CLK_GNUC99, CLK_GNUC11, CLK_GNUC17, CLK_GNUC2X,
+enum c_lang {CLK_GNUC89 = 0, CLK_GNUC99, CLK_GNUC11, CLK_GNUC17, CLK_GNUC23,
CLK_STDC89, CLK_STDC94, CLK_STDC99, CLK_STDC11, CLK_STDC17,
- CLK_STDC2X,
+ CLK_STDC23,
CLK_GNUCXX, CLK_CXX98, CLK_GNUCXX11, CLK_CXX11,
CLK_GNUCXX14, CLK_CXX14, CLK_GNUCXX17, CLK_CXX17,
CLK_GNUCXX20, CLK_CXX20, CLK_GNUCXX23, CLK_CXX23,
/* Nonzero for C++ 2014 Standard digit separators. */
unsigned char digit_separators;
- /* Nonzero for C2X decimal floating-point constants. */
+ /* Nonzero for C23 decimal floating-point constants. */
unsigned char dfp_constants;
/* Nonzero for C++20 __VA_OPT__ feature. */
/* True if warn about differences between C90 and C99. */
signed char cpp_warn_c90_c99_compat;
- /* True if warn about differences between C11 and C2X. */
- signed char cpp_warn_c11_c2x_compat;
+ /* True if warn about differences between C11 and C23. */
+ signed char cpp_warn_c11_c23_compat;
/* True if warn about differences between C++98 and C++11. */
bool cpp_warn_cxx11_compat;
CPP_W_DATE_TIME,
CPP_W_PEDANTIC,
CPP_W_C90_C99_COMPAT,
- CPP_W_C11_C2X_COMPAT,
+ CPP_W_C11_C23_COMPAT,
CPP_W_CXX11_COMPAT,
CPP_W_CXX20_COMPAT,
CPP_W_EXPANSION_TO_DEFINED,
#define CPP_N_SIZE_T 0x2000000 /* C++23 size_t literal. */
#define CPP_N_BFLOAT16 0x4000000 /* std::bfloat16_t type. */
-#define CPP_N_BITINT 0x8000000 /* C2X _BitInt literal. */
+#define CPP_N_BITINT 0x8000000 /* C23 _BitInt literal. */
#define CPP_N_WIDTH_FLOATN_NX 0xF0000000 /* _FloatN / _FloatNx value
of N, divided by 16. */
/* GNUC99 */ { 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0 },
/* GNUC11 */ { 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0 },
/* GNUC17 */ { 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0 },
- /* GNUC2X */ { 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1 },
+ /* GNUC23 */ { 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1 },
/* STDC89 */ { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
/* STDC94 */ { 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
/* STDC99 */ { 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
/* STDC11 */ { 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
/* STDC17 */ { 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
- /* STDC2X */ { 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1 },
+ /* STDC23 */ { 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1 },
/* GNUCXX */ { 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1 },
/* CXX98 */ { 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1 },
/* GNUCXX11 */ { 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1 },
CPP_OPTION (pfile, warn_trigraphs) = 2;
CPP_OPTION (pfile, warn_endif_labels) = 1;
CPP_OPTION (pfile, cpp_warn_c90_c99_compat) = -1;
- CPP_OPTION (pfile, cpp_warn_c11_c2x_compat) = -1;
+ CPP_OPTION (pfile, cpp_warn_c11_c23_compat) = -1;
CPP_OPTION (pfile, cpp_warn_cxx11_compat) = 0;
CPP_OPTION (pfile, cpp_warn_cxx20_compat) = 0;
CPP_OPTION (pfile, cpp_warn_deprecated) = 1;
_cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
_cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
- else if (CPP_OPTION (pfile, lang) == CLK_STDC2X
- || CPP_OPTION (pfile, lang) == CLK_GNUC2X)
+ else if (CPP_OPTION (pfile, lang) == CLK_STDC23
+ || CPP_OPTION (pfile, lang) == CLK_GNUC23)
_cpp_define_builtin (pfile, "__STDC_VERSION__ 202000L");
else if (CPP_OPTION (pfile, lang) == CLK_STDC17
|| CPP_OPTION (pfile, lang) == CLK_GNUC17)
"__VA_OPT__ is not available until C++20");
else
cpp_error (pfile, CPP_DL_PEDWARN,
- "__VA_OPT__ is not available until C2X");
+ "__VA_OPT__ is not available until C23");
}
}
else if (!pfile->state.va_args_ok)
if (argc < macro->paramc)
{
- /* In C++20 and C2X (here the va_opt flag is used), and also as a GNU
+ /* In C++20 and C23 (here the va_opt flag is used), and also as a GNU
extension, variadic arguments are allowed to not appear in
the invocation at all.
e.g. #define debug(format, args...) something
projects / thirdparty / gcc.git / commitdiff
