This is an archive of the discontinued LLVM Phabricator instance.

Differential D157606

[C2x] Support -std=c23 and -std=gnu23
ClosedPublic

Authored by aaron.ballman on Aug 10 2023, 5:17 AM.

Details

Reviewers
jyknight
efriedma
hubert.reinterpretcast
cor3ntin
Group Reviewers
Restricted Project
Commits
rG13629b140801: [C2x] Support -std=c23 and -std=gnu23
Summary

C2x was finalized at the June 2023 WG14 meeting. The DIS is out for balloting and the comment period for that closes later this year/early next year. While that does leave an opportunity for more changes to the standard during the DIS ballot resolution process, only editorial changes are anticipated and as a result, the C committee considers C2x to be final. The committee took a straw poll on what we'd prefer the informal name of the standard be, and we decided it should be called C23 regardless of what year ISO publishes it.

However, because the final publication is not out, this patch does not add the language standard alias for the -std=iso9899:<year> spelling of the standard mode; that will be added once ISO finally publishes the document and the year chosen will match the publication date.

This also changes the value of __STDC_VERSION__ from the placeholder value 202000L to the final value 202311L.

Subsequent patches will start renaming things from c2x to c23, cleaning up documentation, etc.

Diff Detail

Event Timeline

aaron.ballman created this revision.Aug 10 2023, 5:17 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 10 2023, 5:17 AM
Herald added subscribers: kadircet, arphaman. · View Herald Transcript
aaron.ballman requested review of this revision.Aug 10 2023, 5:17 AM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptAug 10 2023, 5:17 AM
aaron.ballman mentioned this in D157331: [clang] Implement C23 <stdckdint.h>.Aug 10 2023, 5:30 AM
cor3ntin added a comment.Aug 10 2023, 6:30 AM

Options.td defines:
defvar c2x = LangOpts<"C2x">;

Does this need change as well?

UsersManual.rst also needs an update, but that can be another patch

aaron.ballman added a comment.Aug 10 2023, 6:35 AM
In D157606#4576694, @cor3ntin wrote:

Options.td defines:
defvar c2x = LangOpts<"C2x">;

Does this need change as well?

UsersManual.rst also needs an update, but that can be another patch

Both of those changes will happen separately as part of the C2x -> C23 cleanup. The Options.td one needs to change when I rename the LangOption field, and UsersManual.rst needs to change in several places as well (that could perhaps be done in this patch, but I figured it was best left to a follow-up).

cor3ntin accepted this revision.Aug 10 2023, 6:47 AM

Fair enough! the rest looked sensible to me :)

This revision is now accepted and ready to land.Aug 10 2023, 6:47 AM
This revision was landed with ongoing or failed builds.Aug 10 2023, 10:57 AM
Closed by commit rG13629b140801: [C2x] Support -std=c23 and -std=gnu23 (authored by aaron.ballman). · Explain Why
This revision was automatically updated to reflect the committed changes.
aaron.ballman added a commit: rG13629b140801: [C2x] Support -std=c23 and -std=gnu23.
Harbormaster completed remote builds in B251654: Diff 548984.Aug 10 2023, 12:43 PM

Revision Contents

PathSize
clang-tools-extra/
clangd/
index/
2 lines
clang/
docs/
4 lines
include/
clang/
Basic/
14 lines
lib/
Frontend/
3 lines
Headers/
4 lines
4 lines
8 lines
8 lines
8 lines
61 lines
test/
C/
C11/
4 lines
drs/
12 lines
4 lines
8 lines
3 lines
Driver/
4 lines
Headers/
4 lines
52 lines
Lexer/
2 lines
6 lines
Preprocessor/
4 lines
4 lines
Sema/
12 lines

Diff 549109

clang-tools-extra/clangd/index/StdLib.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines if (LO.CPlusPlus17)
return LangStandard::lang_cxx17; return LangStandard::lang_cxx17;
if (LO.CPlusPlus14) if (LO.CPlusPlus14)
return LangStandard::lang_cxx14; return LangStandard::lang_cxx14;
if (LO.CPlusPlus11) if (LO.CPlusPlus11)
return LangStandard::lang_cxx11; return LangStandard::lang_cxx11;
return LangStandard::lang_cxx98; return LangStandard::lang_cxx98;
} }
if (LO.C2x) if (LO.C2x)
return LangStandard::lang_c2x; return LangStandard::lang_c23;
// C17 has no new features, so treat {C11,C17} as C17. // C17 has no new features, so treat {C11,C17} as C17.
if (LO.C11) if (LO.C11)
return LangStandard::lang_c17; return LangStandard::lang_c17;
return LangStandard::lang_c99; return LangStandard::lang_c99;
} }
std::string buildUmbrella(llvm::StringLiteral Mandatory, std::string buildUmbrella(llvm::StringLiteral Mandatory,
llvm::ArrayRef<tooling::stdlib::Header> Headers) { llvm::ArrayRef<tooling::stdlib::Header> Headers) {
▲ Show 20 Lines • Show All 283 Lines • Show Last 20 Lines

clang/docs/ReleaseNotes.rst

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
C Language Changes C Language Changes
------------------ ------------------
- ``structs``, ``unions``, and ``arrays`` that are const may now be used as - ``structs``, ``unions``, and ``arrays`` that are const may now be used as
constant expressions. This change is more consistent with the behavior of constant expressions. This change is more consistent with the behavior of
GCC. GCC.
C2x Feature Support C2x Feature Support
^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
- Clang now accepts ``-std=c23`` and ``-std=gnu23`` as language standard modes,
and the ``__STDC_VERSION__`` macro now expands to ``202311L`` instead of its
previous placeholder value. Clang continues to accept ``-std=c2x`` and
``-std=gnu2x`` as aliases for C23 and GNU C23, respectively.
Non-comprehensive list of changes in this release Non-comprehensive list of changes in this release
------------------------------------------------- -------------------------------------------------
New Compiler Flags New Compiler Flags
------------------ ------------------
Deprecated Compiler Flags Deprecated Compiler Flags
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

clang/include/clang/Basic/LangStandards.def

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
LANGSTANDARD_ALIAS(c17, "iso9899:2017") LANGSTANDARD_ALIAS(c17, "iso9899:2017")
LANGSTANDARD_ALIAS(c17, "c18") LANGSTANDARD_ALIAS(c17, "c18")
LANGSTANDARD_ALIAS(c17, "iso9899:2018") LANGSTANDARD_ALIAS(c17, "iso9899:2018")
LANGSTANDARD(gnu17, "gnu17", LANGSTANDARD(gnu17, "gnu17",
C, "ISO C 2017 with GNU extensions", C, "ISO C 2017 with GNU extensions",
LineComment | C99 | C11 | C17 | Digraphs | GNUMode | HexFloat) LineComment | C99 | C11 | C17 | Digraphs | GNUMode | HexFloat)
LANGSTANDARD_ALIAS(gnu17, "gnu18") LANGSTANDARD_ALIAS(gnu17, "gnu18")
// C2x modes // C23 modes
LANGSTANDARD(c2x, "c2x", LANGSTANDARD(c23, "c23",
C, "Working Draft for ISO C2x", C, "Working Draft for ISO C23",
LineComment | C99 | C11 | C17 | C2x | Digraphs | HexFloat) LineComment | C99 | C11 | C17 | C2x | Digraphs | HexFloat)
LANGSTANDARD(gnu2x, "gnu2x", LANGSTANDARD_ALIAS_DEPR(c23, "c2x")
C, "Working Draft for ISO C2x with GNU extensions", LANGSTANDARD(gnu23, "gnu23",
C, "Working Draft for ISO C23 with GNU extensions",
LineComment | C99 | C11 | C17 | C2x | Digraphs | GNUMode | HexFloat) LineComment | C99 | C11 | C17 | C2x | Digraphs | GNUMode | HexFloat)
LANGSTANDARD_ALIAS_DEPR(gnu23, "gnu2x")
// FIXME: Add the alias for iso9899:202* once we know the year ISO publishes
// the document (expected to be 2024).
// C++ modes // C++ modes
LANGSTANDARD(cxx98, "c++98", LANGSTANDARD(cxx98, "c++98",
CXX, "ISO C++ 1998 with amendments", CXX, "ISO C++ 1998 with amendments",
LineComment | CPlusPlus | Digraphs) LineComment | CPlusPlus | Digraphs)
LANGSTANDARD_ALIAS(cxx98, "c++03") LANGSTANDARD_ALIAS(cxx98, "c++03")
LANGSTANDARD(gnucxx98, "gnu++98", LANGSTANDARD(gnucxx98, "gnu++98",
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

clang/lib/Frontend/InitPreprocessor.cpp

Show First 20 Lines • Show All 432 Lines • ▼ Show 20 Linesstatic void InitializeStandardPredefinedMacros(const TargetInfo &TI,
else else
Builder.defineMacro("__STDC_HOSTED__"); Builder.defineMacro("__STDC_HOSTED__");
// -- __STDC_VERSION__ // -- __STDC_VERSION__
// [C++] Whether __STDC_VERSION__ is predefined and if so, what its // [C++] Whether __STDC_VERSION__ is predefined and if so, what its
// value is, are implementation-defined. // value is, are implementation-defined.
// (Removed in C++20.) // (Removed in C++20.)
if (!LangOpts.CPlusPlus) { if (!LangOpts.CPlusPlus) {
// FIXME: Use correct value for C23.
if (LangOpts.C2x) if (LangOpts.C2x)
Builder.defineMacro("__STDC_VERSION__", "202000L"); Builder.defineMacro("__STDC_VERSION__", "202311L");
else if (LangOpts.C17) else if (LangOpts.C17)
Builder.defineMacro("__STDC_VERSION__", "201710L"); Builder.defineMacro("__STDC_VERSION__", "201710L");
else if (LangOpts.C11) else if (LangOpts.C11)
Builder.defineMacro("__STDC_VERSION__", "201112L"); Builder.defineMacro("__STDC_VERSION__", "201112L");
else if (LangOpts.C99) else if (LangOpts.C99)
Builder.defineMacro("__STDC_VERSION__", "199901L"); Builder.defineMacro("__STDC_VERSION__", "199901L");
else if (!LangOpts.GNUMode && LangOpts.Digraphs) else if (!LangOpts.GNUMode && LangOpts.Digraphs)
Builder.defineMacro("__STDC_VERSION__", "199409L"); Builder.defineMacro("__STDC_VERSION__", "199409L");
▲ Show 20 Lines • Show All 975 Lines • Show Last 20 Lines

clang/lib/Headers/limits.h

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
#ifndef MB_LEN_MAX #ifndef MB_LEN_MAX
#define MB_LEN_MAX 1 #define MB_LEN_MAX 1
#endif #endif
#define CHAR_BIT __CHAR_BIT__ #define CHAR_BIT __CHAR_BIT__
/* C2x 5.2.4.2.1 */ /* C2x 5.2.4.2.1 */
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
#define BOOL_WIDTH __BOOL_WIDTH__ #define BOOL_WIDTH __BOOL_WIDTH__
#define CHAR_WIDTH CHAR_BIT #define CHAR_WIDTH CHAR_BIT
#define SCHAR_WIDTH CHAR_BIT #define SCHAR_WIDTH CHAR_BIT
#define UCHAR_WIDTH CHAR_BIT #define UCHAR_WIDTH CHAR_BIT
#define USHRT_WIDTH __SHRT_WIDTH__ #define USHRT_WIDTH __SHRT_WIDTH__
#define SHRT_WIDTH __SHRT_WIDTH__ #define SHRT_WIDTH __SHRT_WIDTH__
#define UINT_WIDTH __INT_WIDTH__ #define UINT_WIDTH __INT_WIDTH__
#define INT_WIDTH __INT_WIDTH__ #define INT_WIDTH __INT_WIDTH__
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

clang/lib/Headers/stdalign.h

/*===---- stdalign.h - Standard header for alignment ------------------------=== /*===---- stdalign.h - Standard header for alignment ------------------------===
* *
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information. * See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
* *
*===-----------------------------------------------------------------------=== *===-----------------------------------------------------------------------===
*/ */
#ifndef __STDALIGN_H #ifndef __STDALIGN_H
#define __STDALIGN_H #define __STDALIGN_H
/* FIXME: This is using the placeholder dates Clang produces for these macros
in C2x mode; switch to the correct values once they've been published. */
#if defined(__cplusplus) || \ #if defined(__cplusplus) || \
(defined(__STDC_VERSION__) && __STDC_VERSION__ < 202000L) (defined(__STDC_VERSION__) && __STDC_VERSION__ < 202311L)
#ifndef __cplusplus #ifndef __cplusplus
#define alignas _Alignas #define alignas _Alignas
#define alignof _Alignof #define alignof _Alignof
#endif #endif
#define __alignas_is_defined 1 #define __alignas_is_defined 1
#define __alignof_is_defined 1 #define __alignof_is_defined 1
#endif /* __STDC_VERSION__ */ #endif /* __STDC_VERSION__ */
#endif /* __STDALIGN_H */ #endif /* __STDALIGN_H */

clang/lib/Headers/stdarg.h

Show All 17 Lines
#undef __need___va_list #undef __need___va_list
#else #else
#define __STDARG_H #define __STDARG_H
#ifndef _VA_LIST #ifndef _VA_LIST
typedef __builtin_va_list va_list; typedef __builtin_va_list va_list;
#define _VA_LIST #define _VA_LIST
#endif #endif
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */ /* C23 does not require the second parameter for va_start. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
/* C2x does not require the second parameter for va_start. */
#define va_start(ap, ...) __builtin_va_start(ap, 0) #define va_start(ap, ...) __builtin_va_start(ap, 0)
#else #else
/* Versions before C2x do require the second parameter. */ /* Versions before C23 do require the second parameter. */
#define va_start(ap, param) __builtin_va_start(ap, param) #define va_start(ap, param) __builtin_va_start(ap, param)
#endif #endif
#define va_end(ap) __builtin_va_end(ap) #define va_end(ap) __builtin_va_end(ap)
#define va_arg(ap, type) __builtin_va_arg(ap, type) #define va_arg(ap, type) __builtin_va_arg(ap, type)
/* GCC always defines __va_copy, but does not define va_copy unless in c99 mode /* GCC always defines __va_copy, but does not define va_copy unless in c99 mode
* or -ansi is not specified, since it was not part of C90. * or -ansi is not specified, since it was not part of C90.
*/ */
Show All 11 Lines

clang/lib/Headers/stdatomic.h

Show All 39 Lines
#define ATOMIC_WCHAR_T_LOCK_FREE __CLANG_ATOMIC_WCHAR_T_LOCK_FREE #define ATOMIC_WCHAR_T_LOCK_FREE __CLANG_ATOMIC_WCHAR_T_LOCK_FREE
#define ATOMIC_SHORT_LOCK_FREE __CLANG_ATOMIC_SHORT_LOCK_FREE #define ATOMIC_SHORT_LOCK_FREE __CLANG_ATOMIC_SHORT_LOCK_FREE
#define ATOMIC_INT_LOCK_FREE __CLANG_ATOMIC_INT_LOCK_FREE #define ATOMIC_INT_LOCK_FREE __CLANG_ATOMIC_INT_LOCK_FREE
#define ATOMIC_LONG_LOCK_FREE __CLANG_ATOMIC_LONG_LOCK_FREE #define ATOMIC_LONG_LOCK_FREE __CLANG_ATOMIC_LONG_LOCK_FREE
#define ATOMIC_LLONG_LOCK_FREE __CLANG_ATOMIC_LLONG_LOCK_FREE #define ATOMIC_LLONG_LOCK_FREE __CLANG_ATOMIC_LLONG_LOCK_FREE
#define ATOMIC_POINTER_LOCK_FREE __CLANG_ATOMIC_POINTER_LOCK_FREE #define ATOMIC_POINTER_LOCK_FREE __CLANG_ATOMIC_POINTER_LOCK_FREE
/* 7.17.2 Initialization */ /* 7.17.2 Initialization */
/* FIXME: This is using the placeholder dates Clang produces for these macros #if (defined(__STDC_VERSION__) && __STDC_VERSION__ < 202311L) || \
in C2x mode; switch to the correct values once they've been published. */
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ < 202000L) || \
defined(__cplusplus) defined(__cplusplus)
/* ATOMIC_VAR_INIT was removed in C2x, but still remains in C++23. */ /* ATOMIC_VAR_INIT was removed in C23, but still remains in C++23. */
#define ATOMIC_VAR_INIT(value) (value) #define ATOMIC_VAR_INIT(value) (value)
#endif #endif
#if ((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201710L && \ #if ((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201710L && \
__STDC_VERSION__ < 202000L) || \ __STDC_VERSION__ < 202311L) || \
(defined(__cplusplus) && __cplusplus >= 202002L)) && \ (defined(__cplusplus) && __cplusplus >= 202002L)) && \
!defined(_CLANG_DISABLE_CRT_DEPRECATION_WARNINGS) !defined(_CLANG_DISABLE_CRT_DEPRECATION_WARNINGS)
/* ATOMIC_VAR_INIT was deprecated in C17 and C++20. */ /* ATOMIC_VAR_INIT was deprecated in C17 and C++20. */
#pragma clang deprecated(ATOMIC_VAR_INIT) #pragma clang deprecated(ATOMIC_VAR_INIT)
#endif #endif
#define atomic_init __c11_atomic_init #define atomic_init __c11_atomic_init
/* 7.17.3 Order and consistency */ /* 7.17.3 Order and consistency */
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

clang/lib/Headers/stddef.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
#if defined(_MSC_EXTENSIONS) && defined(_NATIVE_NULLPTR_SUPPORTED) #if defined(_MSC_EXTENSIONS) && defined(_NATIVE_NULLPTR_SUPPORTED)
namespace std { typedef decltype(nullptr) nullptr_t; } namespace std { typedef decltype(nullptr) nullptr_t; }
using ::std::nullptr_t; using ::std::nullptr_t;
#endif #endif
#endif #endif
#undef __need_NULL #undef __need_NULL
#endif /* defined(__need_NULL) */ #endif /* defined(__need_NULL) */
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
typedef typeof(nullptr) nullptr_t; typedef typeof(nullptr) nullptr_t;
#endif /* defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L */ #endif /* defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L */
#if defined(__need_STDDEF_H_misc) && defined(__STDC_VERSION__) && \ #if defined(__need_STDDEF_H_misc) && defined(__STDC_VERSION__) && \
__STDC_VERSION__ >= 202000L __STDC_VERSION__ >= 202311L
#define unreachable() __builtin_unreachable() #define unreachable() __builtin_unreachable()
#endif /* defined(__need_STDDEF_H_misc) && >= C23 */ #endif /* defined(__need_STDDEF_H_misc) && >= C23 */
#if defined(__need_STDDEF_H_misc) #if defined(__need_STDDEF_H_misc)
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \ #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \
(defined(__cplusplus) && __cplusplus >= 201103L) (defined(__cplusplus) && __cplusplus >= 201103L)
#include "__stddef_max_align_t.h" #include "__stddef_max_align_t.h"
#endif #endif
Show All 18 Lines

clang/lib/Headers/stdint.h

Show First 20 Lines • Show All 493 Lines • ▼ Show 20 Lines
* Note that C++ should not check __STDC_LIMIT_MACROS here, contrary to the * Note that C++ should not check __STDC_LIMIT_MACROS here, contrary to the
* claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]). * claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]).
*/ */
#ifdef __INT64_TYPE__ #ifdef __INT64_TYPE__
# define INT64_MAX INT64_C( 9223372036854775807) # define INT64_MAX INT64_C( 9223372036854775807)
# define INT64_MIN (-INT64_C( 9223372036854775807)-1) # define INT64_MIN (-INT64_C( 9223372036854775807)-1)
# define UINT64_MAX UINT64_C(18446744073709551615) # define UINT64_MAX UINT64_C(18446744073709551615)
/* FIXME: This is using the placeholder dates Clang produces for these macros
in C2x mode; switch to the correct values once they've been published. */ #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
# define UINT64_WIDTH 64 # define UINT64_WIDTH 64
# define INT64_WIDTH UINT64_WIDTH # define INT64_WIDTH UINT64_WIDTH
# define __UINT_LEAST64_WIDTH UINT64_WIDTH # define __UINT_LEAST64_WIDTH UINT64_WIDTH
# undef __UINT_LEAST32_WIDTH # undef __UINT_LEAST32_WIDTH
# define __UINT_LEAST32_WIDTH UINT64_WIDTH # define __UINT_LEAST32_WIDTH UINT64_WIDTH
# undef __UINT_LEAST16_WIDTH # undef __UINT_LEAST16_WIDTH
# define __UINT_LEAST16_WIDTH UINT64_WIDTH # define __UINT_LEAST16_WIDTH UINT64_WIDTH
Show All 27 Lines
#ifdef __INT_LEAST64_MIN #ifdef __INT_LEAST64_MIN
# define INT_LEAST64_MIN __INT_LEAST64_MIN # define INT_LEAST64_MIN __INT_LEAST64_MIN
# define INT_LEAST64_MAX __INT_LEAST64_MAX # define INT_LEAST64_MAX __INT_LEAST64_MAX
# define UINT_LEAST64_MAX __UINT_LEAST64_MAX # define UINT_LEAST64_MAX __UINT_LEAST64_MAX
# define INT_FAST64_MIN __INT_LEAST64_MIN # define INT_FAST64_MIN __INT_LEAST64_MIN
# define INT_FAST64_MAX __INT_LEAST64_MAX # define INT_FAST64_MAX __INT_LEAST64_MAX
# define UINT_FAST64_MAX __UINT_LEAST64_MAX # define UINT_FAST64_MAX __UINT_LEAST64_MAX
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
# define UINT_LEAST64_WIDTH __UINT_LEAST64_WIDTH # define UINT_LEAST64_WIDTH __UINT_LEAST64_WIDTH
# define INT_LEAST64_WIDTH UINT_LEAST64_WIDTH # define INT_LEAST64_WIDTH UINT_LEAST64_WIDTH
# define UINT_FAST64_WIDTH __UINT_LEAST64_WIDTH # define UINT_FAST64_WIDTH __UINT_LEAST64_WIDTH
# define INT_FAST64_WIDTH UINT_FAST64_WIDTH # define INT_FAST64_WIDTH UINT_FAST64_WIDTH
#endif /* __STDC_VERSION__ */ #endif /* __STDC_VERSION__ */
#endif /* __INT_LEAST64_MIN */ #endif /* __INT_LEAST64_MIN */
Show All 22 Lines
# define __UINT_LEAST16_MAX UINT56_MAX # define __UINT_LEAST16_MAX UINT56_MAX
# undef __INT_LEAST8_MIN # undef __INT_LEAST8_MIN
# define __INT_LEAST8_MIN INT56_MIN # define __INT_LEAST8_MIN INT56_MIN
# undef __INT_LEAST8_MAX # undef __INT_LEAST8_MAX
# define __INT_LEAST8_MAX INT56_MAX # define __INT_LEAST8_MAX INT56_MAX
# undef __UINT_LEAST8_MAX # undef __UINT_LEAST8_MAX
# define __UINT_LEAST8_MAX UINT56_MAX # define __UINT_LEAST8_MAX UINT56_MAX
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
# define UINT56_WIDTH 56 # define UINT56_WIDTH 56
# define INT56_WIDTH UINT56_WIDTH # define INT56_WIDTH UINT56_WIDTH
# define UINT_LEAST56_WIDTH UINT56_WIDTH # define UINT_LEAST56_WIDTH UINT56_WIDTH
# define INT_LEAST56_WIDTH UINT_LEAST56_WIDTH # define INT_LEAST56_WIDTH UINT_LEAST56_WIDTH
# define UINT_FAST56_WIDTH UINT56_WIDTH # define UINT_FAST56_WIDTH UINT56_WIDTH
# define INT_FAST56_WIDTH UINT_FAST56_WIDTH # define INT_FAST56_WIDTH UINT_FAST56_WIDTH
# undef __UINT_LEAST32_WIDTH # undef __UINT_LEAST32_WIDTH
# define __UINT_LEAST32_WIDTH UINT56_WIDTH # define __UINT_LEAST32_WIDTH UINT56_WIDTH
Show All 30 Lines
# define __UINT_LEAST16_MAX UINT48_MAX # define __UINT_LEAST16_MAX UINT48_MAX
# undef __INT_LEAST8_MIN # undef __INT_LEAST8_MIN
# define __INT_LEAST8_MIN INT48_MIN # define __INT_LEAST8_MIN INT48_MIN
# undef __INT_LEAST8_MAX # undef __INT_LEAST8_MAX
# define __INT_LEAST8_MAX INT48_MAX # define __INT_LEAST8_MAX INT48_MAX
# undef __UINT_LEAST8_MAX # undef __UINT_LEAST8_MAX
# define __UINT_LEAST8_MAX UINT48_MAX # define __UINT_LEAST8_MAX UINT48_MAX
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
#define UINT48_WIDTH 48 #define UINT48_WIDTH 48
#define INT48_WIDTH UINT48_WIDTH #define INT48_WIDTH UINT48_WIDTH
#define UINT_LEAST48_WIDTH UINT48_WIDTH #define UINT_LEAST48_WIDTH UINT48_WIDTH
#define INT_LEAST48_WIDTH UINT_LEAST48_WIDTH #define INT_LEAST48_WIDTH UINT_LEAST48_WIDTH
#define UINT_FAST48_WIDTH UINT48_WIDTH #define UINT_FAST48_WIDTH UINT48_WIDTH
#define INT_FAST48_WIDTH UINT_FAST48_WIDTH #define INT_FAST48_WIDTH UINT_FAST48_WIDTH
#undef __UINT_LEAST32_WIDTH #undef __UINT_LEAST32_WIDTH
#define __UINT_LEAST32_WIDTH UINT48_WIDTH #define __UINT_LEAST32_WIDTH UINT48_WIDTH
Show All 30 Lines
# define __UINT_LEAST16_MAX UINT40_MAX # define __UINT_LEAST16_MAX UINT40_MAX
# undef __INT_LEAST8_MIN # undef __INT_LEAST8_MIN
# define __INT_LEAST8_MIN INT40_MIN # define __INT_LEAST8_MIN INT40_MIN
# undef __INT_LEAST8_MAX # undef __INT_LEAST8_MAX
# define __INT_LEAST8_MAX INT40_MAX # define __INT_LEAST8_MAX INT40_MAX
# undef __UINT_LEAST8_MAX # undef __UINT_LEAST8_MAX
# define __UINT_LEAST8_MAX UINT40_MAX # define __UINT_LEAST8_MAX UINT40_MAX
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
# define UINT40_WIDTH 40 # define UINT40_WIDTH 40
# define INT40_WIDTH UINT40_WIDTH # define INT40_WIDTH UINT40_WIDTH
# define UINT_LEAST40_WIDTH UINT40_WIDTH # define UINT_LEAST40_WIDTH UINT40_WIDTH
# define INT_LEAST40_WIDTH UINT_LEAST40_WIDTH # define INT_LEAST40_WIDTH UINT_LEAST40_WIDTH
# define UINT_FAST40_WIDTH UINT40_WIDTH # define UINT_FAST40_WIDTH UINT40_WIDTH
# define INT_FAST40_WIDTH UINT_FAST40_WIDTH # define INT_FAST40_WIDTH UINT_FAST40_WIDTH
# undef __UINT_LEAST32_WIDTH # undef __UINT_LEAST32_WIDTH
# define __UINT_LEAST32_WIDTH UINT40_WIDTH # define __UINT_LEAST32_WIDTH UINT40_WIDTH
Show All 24 Lines
# define __UINT_LEAST16_MAX UINT32_MAX # define __UINT_LEAST16_MAX UINT32_MAX
# undef __INT_LEAST8_MIN # undef __INT_LEAST8_MIN
# define __INT_LEAST8_MIN INT32_MIN # define __INT_LEAST8_MIN INT32_MIN
# undef __INT_LEAST8_MAX # undef __INT_LEAST8_MAX
# define __INT_LEAST8_MAX INT32_MAX # define __INT_LEAST8_MAX INT32_MAX
# undef __UINT_LEAST8_MAX # undef __UINT_LEAST8_MAX
# define __UINT_LEAST8_MAX UINT32_MAX # define __UINT_LEAST8_MAX UINT32_MAX
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
# define UINT32_WIDTH 32 # define UINT32_WIDTH 32
# define INT32_WIDTH UINT32_WIDTH # define INT32_WIDTH UINT32_WIDTH
# undef __UINT_LEAST32_WIDTH # undef __UINT_LEAST32_WIDTH
# define __UINT_LEAST32_WIDTH UINT32_WIDTH # define __UINT_LEAST32_WIDTH UINT32_WIDTH
# undef __UINT_LEAST16_WIDTH # undef __UINT_LEAST16_WIDTH
# define __UINT_LEAST16_WIDTH UINT32_WIDTH # define __UINT_LEAST16_WIDTH UINT32_WIDTH
# undef __UINT_LEAST8_WIDTH # undef __UINT_LEAST8_WIDTH
# define __UINT_LEAST8_WIDTH UINT32_WIDTH # define __UINT_LEAST8_WIDTH UINT32_WIDTH
#endif /* __STDC_VERSION__ */ #endif /* __STDC_VERSION__ */
#endif /* __INT32_TYPE__ */ #endif /* __INT32_TYPE__ */
#ifdef __INT_LEAST32_MIN #ifdef __INT_LEAST32_MIN
# define INT_LEAST32_MIN __INT_LEAST32_MIN # define INT_LEAST32_MIN __INT_LEAST32_MIN
# define INT_LEAST32_MAX __INT_LEAST32_MAX # define INT_LEAST32_MAX __INT_LEAST32_MAX
# define UINT_LEAST32_MAX __UINT_LEAST32_MAX # define UINT_LEAST32_MAX __UINT_LEAST32_MAX
# define INT_FAST32_MIN __INT_LEAST32_MIN # define INT_FAST32_MIN __INT_LEAST32_MIN
# define INT_FAST32_MAX __INT_LEAST32_MAX # define INT_FAST32_MAX __INT_LEAST32_MAX
# define UINT_FAST32_MAX __UINT_LEAST32_MAX # define UINT_FAST32_MAX __UINT_LEAST32_MAX
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
# define UINT_LEAST32_WIDTH __UINT_LEAST32_WIDTH # define UINT_LEAST32_WIDTH __UINT_LEAST32_WIDTH
# define INT_LEAST32_WIDTH UINT_LEAST32_WIDTH # define INT_LEAST32_WIDTH UINT_LEAST32_WIDTH
# define UINT_FAST32_WIDTH __UINT_LEAST32_WIDTH # define UINT_FAST32_WIDTH __UINT_LEAST32_WIDTH
# define INT_FAST32_WIDTH UINT_FAST32_WIDTH # define INT_FAST32_WIDTH UINT_FAST32_WIDTH
#endif /* __STDC_VERSION__ */ #endif /* __STDC_VERSION__ */
#endif /* __INT_LEAST32_MIN */ #endif /* __INT_LEAST32_MIN */
Show All 16 Lines
# define __UINT_LEAST16_MAX UINT24_MAX # define __UINT_LEAST16_MAX UINT24_MAX
# undef __INT_LEAST8_MIN # undef __INT_LEAST8_MIN
# define __INT_LEAST8_MIN INT24_MIN # define __INT_LEAST8_MIN INT24_MIN
# undef __INT_LEAST8_MAX # undef __INT_LEAST8_MAX
# define __INT_LEAST8_MAX INT24_MAX # define __INT_LEAST8_MAX INT24_MAX
# undef __UINT_LEAST8_MAX # undef __UINT_LEAST8_MAX
# define __UINT_LEAST8_MAX UINT24_MAX # define __UINT_LEAST8_MAX UINT24_MAX
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
# define UINT24_WIDTH 24 # define UINT24_WIDTH 24
# define INT24_WIDTH UINT24_WIDTH # define INT24_WIDTH UINT24_WIDTH
# define UINT_LEAST24_WIDTH UINT24_WIDTH # define UINT_LEAST24_WIDTH UINT24_WIDTH
# define INT_LEAST24_WIDTH UINT_LEAST24_WIDTH # define INT_LEAST24_WIDTH UINT_LEAST24_WIDTH
# define UINT_FAST24_WIDTH UINT24_WIDTH # define UINT_FAST24_WIDTH UINT24_WIDTH
# define INT_FAST24_WIDTH UINT_FAST24_WIDTH # define INT_FAST24_WIDTH UINT_FAST24_WIDTH
# undef __UINT_LEAST16_WIDTH # undef __UINT_LEAST16_WIDTH
# define __UINT_LEAST16_WIDTH UINT24_WIDTH # define __UINT_LEAST16_WIDTH UINT24_WIDTH
Show All 16 Lines
# define __UINT_LEAST16_MAX UINT16_MAX # define __UINT_LEAST16_MAX UINT16_MAX
# undef __INT_LEAST8_MIN # undef __INT_LEAST8_MIN
# define __INT_LEAST8_MIN INT16_MIN # define __INT_LEAST8_MIN INT16_MIN
# undef __INT_LEAST8_MAX # undef __INT_LEAST8_MAX
# define __INT_LEAST8_MAX INT16_MAX # define __INT_LEAST8_MAX INT16_MAX
# undef __UINT_LEAST8_MAX # undef __UINT_LEAST8_MAX
# define __UINT_LEAST8_MAX UINT16_MAX # define __UINT_LEAST8_MAX UINT16_MAX
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
# define UINT16_WIDTH 16 # define UINT16_WIDTH 16
# define INT16_WIDTH UINT16_WIDTH # define INT16_WIDTH UINT16_WIDTH
# undef __UINT_LEAST16_WIDTH # undef __UINT_LEAST16_WIDTH
# define __UINT_LEAST16_WIDTH UINT16_WIDTH # define __UINT_LEAST16_WIDTH UINT16_WIDTH
# undef __UINT_LEAST8_WIDTH # undef __UINT_LEAST8_WIDTH
# define __UINT_LEAST8_WIDTH UINT16_WIDTH # define __UINT_LEAST8_WIDTH UINT16_WIDTH
#endif /* __STDC_VERSION__ */ #endif /* __STDC_VERSION__ */
#endif /* __INT16_TYPE__ */ #endif /* __INT16_TYPE__ */
#ifdef __INT_LEAST16_MIN #ifdef __INT_LEAST16_MIN
# define INT_LEAST16_MIN __INT_LEAST16_MIN # define INT_LEAST16_MIN __INT_LEAST16_MIN
# define INT_LEAST16_MAX __INT_LEAST16_MAX # define INT_LEAST16_MAX __INT_LEAST16_MAX
# define UINT_LEAST16_MAX __UINT_LEAST16_MAX # define UINT_LEAST16_MAX __UINT_LEAST16_MAX
# define INT_FAST16_MIN __INT_LEAST16_MIN # define INT_FAST16_MIN __INT_LEAST16_MIN
# define INT_FAST16_MAX __INT_LEAST16_MAX # define INT_FAST16_MAX __INT_LEAST16_MAX
# define UINT_FAST16_MAX __UINT_LEAST16_MAX # define UINT_FAST16_MAX __UINT_LEAST16_MAX
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
# define UINT_LEAST16_WIDTH __UINT_LEAST16_WIDTH # define UINT_LEAST16_WIDTH __UINT_LEAST16_WIDTH
# define INT_LEAST16_WIDTH UINT_LEAST16_WIDTH # define INT_LEAST16_WIDTH UINT_LEAST16_WIDTH
# define UINT_FAST16_WIDTH __UINT_LEAST16_WIDTH # define UINT_FAST16_WIDTH __UINT_LEAST16_WIDTH
# define INT_FAST16_WIDTH UINT_FAST16_WIDTH # define INT_FAST16_WIDTH UINT_FAST16_WIDTH
#endif /* __STDC_VERSION__ */ #endif /* __STDC_VERSION__ */
#endif /* __INT_LEAST16_MIN */ #endif /* __INT_LEAST16_MIN */
#ifdef __INT8_TYPE__ #ifdef __INT8_TYPE__
# define INT8_MAX INT8_C(127) # define INT8_MAX INT8_C(127)
# define INT8_MIN (-INT8_C(127)-1) # define INT8_MIN (-INT8_C(127)-1)
# define UINT8_MAX UINT8_C(255) # define UINT8_MAX UINT8_C(255)
# undef __INT_LEAST8_MIN # undef __INT_LEAST8_MIN
# define __INT_LEAST8_MIN INT8_MIN # define __INT_LEAST8_MIN INT8_MIN
# undef __INT_LEAST8_MAX # undef __INT_LEAST8_MAX
# define __INT_LEAST8_MAX INT8_MAX # define __INT_LEAST8_MAX INT8_MAX
# undef __UINT_LEAST8_MAX # undef __UINT_LEAST8_MAX
# define __UINT_LEAST8_MAX UINT8_MAX # define __UINT_LEAST8_MAX UINT8_MAX
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
# define UINT8_WIDTH 8 # define UINT8_WIDTH 8
# define INT8_WIDTH UINT8_WIDTH # define INT8_WIDTH UINT8_WIDTH
# undef __UINT_LEAST8_WIDTH # undef __UINT_LEAST8_WIDTH
# define __UINT_LEAST8_WIDTH UINT8_WIDTH # define __UINT_LEAST8_WIDTH UINT8_WIDTH
#endif /* __STDC_VERSION__ */ #endif /* __STDC_VERSION__ */
#endif /* __INT8_TYPE__ */ #endif /* __INT8_TYPE__ */
#ifdef __INT_LEAST8_MIN #ifdef __INT_LEAST8_MIN
# define INT_LEAST8_MIN __INT_LEAST8_MIN # define INT_LEAST8_MIN __INT_LEAST8_MIN
# define INT_LEAST8_MAX __INT_LEAST8_MAX # define INT_LEAST8_MAX __INT_LEAST8_MAX
# define UINT_LEAST8_MAX __UINT_LEAST8_MAX # define UINT_LEAST8_MAX __UINT_LEAST8_MAX
# define INT_FAST8_MIN __INT_LEAST8_MIN # define INT_FAST8_MIN __INT_LEAST8_MIN
# define INT_FAST8_MAX __INT_LEAST8_MAX # define INT_FAST8_MAX __INT_LEAST8_MAX
# define UINT_FAST8_MAX __UINT_LEAST8_MAX # define UINT_FAST8_MAX __UINT_LEAST8_MAX
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
# define UINT_LEAST8_WIDTH __UINT_LEAST8_WIDTH # define UINT_LEAST8_WIDTH __UINT_LEAST8_WIDTH
# define INT_LEAST8_WIDTH UINT_LEAST8_WIDTH # define INT_LEAST8_WIDTH UINT_LEAST8_WIDTH
# define UINT_FAST8_WIDTH __UINT_LEAST8_WIDTH # define UINT_FAST8_WIDTH __UINT_LEAST8_WIDTH
# define INT_FAST8_WIDTH UINT_FAST8_WIDTH # define INT_FAST8_WIDTH UINT_FAST8_WIDTH
#endif /* __STDC_VERSION__ */ #endif /* __STDC_VERSION__ */
#endif /* __INT_LEAST8_MIN */ #endif /* __INT_LEAST8_MIN */
/* Some utility macros */ /* Some utility macros */
Show All 9 Lines
#define INTPTR_MIN (-__INTPTR_MAX__-1) #define INTPTR_MIN (-__INTPTR_MAX__-1)
#define INTPTR_MAX __INTPTR_MAX__ #define INTPTR_MAX __INTPTR_MAX__
#define UINTPTR_MAX __UINTPTR_MAX__ #define UINTPTR_MAX __UINTPTR_MAX__
#define PTRDIFF_MIN (-__PTRDIFF_MAX__-1) #define PTRDIFF_MIN (-__PTRDIFF_MAX__-1)
#define PTRDIFF_MAX __PTRDIFF_MAX__ #define PTRDIFF_MAX __PTRDIFF_MAX__
#define SIZE_MAX __SIZE_MAX__ #define SIZE_MAX __SIZE_MAX__
/* C2x 7.20.2.4 Width of integer types capable of holding object pointers. */ /* C2x 7.20.2.4 Width of integer types capable of holding object pointers. */
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
/* NB: The C standard requires that these be the same value, but the compiler /* NB: The C standard requires that these be the same value, but the compiler
exposes separate internal width macros. */ exposes separate internal width macros. */
#define INTPTR_WIDTH __INTPTR_WIDTH__ #define INTPTR_WIDTH __INTPTR_WIDTH__
#define UINTPTR_WIDTH __UINTPTR_WIDTH__ #define UINTPTR_WIDTH __UINTPTR_WIDTH__
#endif #endif
/* ISO9899:2011 7.20 (C11 Annex K): Define RSIZE_MAX if __STDC_WANT_LIB_EXT1__ /* ISO9899:2011 7.20 (C11 Annex K): Define RSIZE_MAX if __STDC_WANT_LIB_EXT1__
* is enabled. */ * is enabled. */
#if defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1 #if defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1
#define RSIZE_MAX (SIZE_MAX >> 1) #define RSIZE_MAX (SIZE_MAX >> 1)
#endif #endif
/* C99 7.18.2.5 Limits of greatest-width integer types. */ /* C99 7.18.2.5 Limits of greatest-width integer types. */
#define INTMAX_MIN (-__INTMAX_MAX__-1) #define INTMAX_MIN (-__INTMAX_MAX__-1)
#define INTMAX_MAX __INTMAX_MAX__ #define INTMAX_MAX __INTMAX_MAX__
#define UINTMAX_MAX __UINTMAX_MAX__ #define UINTMAX_MAX __UINTMAX_MAX__
/* C2x 7.20.2.5 Width of greatest-width integer types. */ /* C2x 7.20.2.5 Width of greatest-width integer types. */
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
/* NB: The C standard requires that these be the same value, but the compiler /* NB: The C standard requires that these be the same value, but the compiler
exposes separate internal width macros. */ exposes separate internal width macros. */
#define INTMAX_WIDTH __INTMAX_WIDTH__ #define INTMAX_WIDTH __INTMAX_WIDTH__
#define UINTMAX_WIDTH __UINTMAX_WIDTH__ #define UINTMAX_WIDTH __UINTMAX_WIDTH__
#endif #endif
/* C99 7.18.3 Limits of other integer types. */ /* C99 7.18.3 Limits of other integer types. */
#define SIG_ATOMIC_MIN __INTN_MIN(__SIG_ATOMIC_WIDTH__) #define SIG_ATOMIC_MIN __INTN_MIN(__SIG_ATOMIC_WIDTH__)
Show All 17 Lines
# endif # endif
#endif #endif
/* 7.18.4.2 Macros for greatest-width integer constants. */ /* 7.18.4.2 Macros for greatest-width integer constants. */
#define INTMAX_C(v) __int_c(v, __INTMAX_C_SUFFIX__) #define INTMAX_C(v) __int_c(v, __INTMAX_C_SUFFIX__)
#define UINTMAX_C(v) __int_c(v, __UINTMAX_C_SUFFIX__) #define UINTMAX_C(v) __int_c(v, __UINTMAX_C_SUFFIX__)
/* C2x 7.20.3.x Width of other integer types. */ /* C2x 7.20.3.x Width of other integer types. */
/* FIXME: This is using the placeholder dates Clang produces for these macros #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
#define PTRDIFF_WIDTH __PTRDIFF_WIDTH__ #define PTRDIFF_WIDTH __PTRDIFF_WIDTH__
#define SIG_ATOMIC_WIDTH __SIG_ATOMIC_WIDTH__ #define SIG_ATOMIC_WIDTH __SIG_ATOMIC_WIDTH__
#define SIZE_WIDTH __SIZE_WIDTH__ #define SIZE_WIDTH __SIZE_WIDTH__
#define WCHAR_WIDTH __WCHAR_WIDTH__ #define WCHAR_WIDTH __WCHAR_WIDTH__
#define WINT_WIDTH __WINT_WIDTH__ #define WINT_WIDTH __WINT_WIDTH__
#endif #endif
#endif /* __STDC_HOSTED__ */ #endif /* __STDC_HOSTED__ */
#endif /* __CLANG_STDINT_H */ #endif /* __CLANG_STDINT_H */

clang/test/C/C11/n1330.c

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines for (_Static_assert(1, "this should not compile"); i < 10; ++i) // expected-error {{expected identifier or '('}} \
expected-error {{expected ';' in 'for' statement specifier}} expected-error {{expected ';' in 'for' statement specifier}}
; ;
// Ensure that only an integer constant expression can be used as the // Ensure that only an integer constant expression can be used as the
// controlling expression. // controlling expression.
_Static_assert(1.0f, "this should not compile"); // expected-warning {{expression is not an integer constant expression; folding it to a constant is a GNU extension}} _Static_assert(1.0f, "this should not compile"); // expected-warning {{expression is not an integer constant expression; folding it to a constant is a GNU extension}}
} }
// FIXME: This is using the placeholder date Clang produces for the macro in #if __STDC_VERSION__ < 202311L
// C2x mode; switch to the correct value once it's been published.
#if __STDC_VERSION__ < 202000L
// The use of a _Static_assert in a K&R C function definition is prohibited per // The use of a _Static_assert in a K&R C function definition is prohibited per
// 6.9.1p6 requiring each declaration to have a declarator (which a static // 6.9.1p6 requiring each declaration to have a declarator (which a static
// assertion does not have) and only declare identifiers from the identifier // assertion does not have) and only declare identifiers from the identifier
// list. // list.
// The error about expecting a ';' is due to the static assertion confusing the // The error about expecting a ';' is due to the static assertion confusing the
// compiler. It'd be nice if we improved the diagnostics here, but because this // compiler. It'd be nice if we improved the diagnostics here, but because this
// involves a K&R C declaration, it's low priority. // involves a K&R C declaration, it's low priority.
void knr(a, b, c) // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} void knr(a, b, c) // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
int a, b; // expected-error {{expected ';' at end of declaration}} int a, b; // expected-error {{expected ';' at end of declaration}}
_Static_assert(1, "this should not compile"); // expected-error {{expected identifier or '('}} \ _Static_assert(1, "this should not compile"); // expected-error {{expected identifier or '('}} \
expected-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}} expected-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
float c; float c;
{ {
} }
#endif // __STDC_VERSION__ #endif // __STDC_VERSION__

clang/test/C/drs/dr0xx.c

Show First 20 Lines • Show All 228 Lines • ▼ Show 20 Lines
/* WG14 DR032: no /* WG14 DR032: no
* Must implementations diagnose extensions to the constant evaluation rules? * Must implementations diagnose extensions to the constant evaluation rules?
* *
* This should issue a diagnostic because a constant-expression is a * This should issue a diagnostic because a constant-expression is a
* conditional-expression, which excludes the comma operator. * conditional-expression, which excludes the comma operator.
*/ */
int dr032 = (1, 2); /* expected-warning {{left operand of comma operator has no effect}} */ int dr032 = (1, 2); /* expected-warning {{left operand of comma operator has no effect}} */
#if __STDC_VERSION__ < 202000L #if __STDC_VERSION__ < 202311L
/* WG14 DR035: partial /* WG14 DR035: partial
* Questions about definition of functions without a prototype * Questions about definition of functions without a prototype
*/ */
void dr035_1(a, b) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */ void dr035_1(a, b) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */
int a(enum b {x, y}); /* expected-warning {{declaration of 'enum b' will not be visible outside of this function}} */ int a(enum b {x, y}); /* expected-warning {{declaration of 'enum b' will not be visible outside of this function}} */
int b; { int b; {
int test = x; /* expected-error {{use of undeclared identifier 'x'}} */ int test = x; /* expected-error {{use of undeclared identifier 'x'}} */
} }
void dr035_2(c) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */ void dr035_2(c) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */
enum m{q, r} c; { /* expected-warning {{declaration of 'enum m' will not be visible outside of this function}} */ enum m{q, r} c; { /* expected-warning {{declaration of 'enum m' will not be visible outside of this function}} */
/* FIXME: This should be accepted because the scope of m, q, and r ends at /* FIXME: This should be accepted because the scope of m, q, and r ends at
* the closing brace of the function per C89 6.1.2.1. * the closing brace of the function per C89 6.1.2.1.
*/ */
int test = q; /* expected-error {{use of undeclared identifier 'q'}} */ int test = q; /* expected-error {{use of undeclared identifier 'q'}} */
} }
#endif /* __STDC_VERSION__ < 202000L */ #endif /* __STDC_VERSION__ < 202311L */
/* WG14 DR038: yes /* WG14 DR038: yes
* Questions about argument substitution during macro expansion * Questions about argument substitution during macro expansion
*/ */
#define DR038_X 0x000E #define DR038_X 0x000E
#define DR038_Y 0x0100 #define DR038_Y 0x0100
#define DR038(a) a #define DR038(a) a
_Static_assert(DR038(DR038_X + DR038_Y) == DR038_X + DR038_Y, "fail"); _Static_assert(DR038(DR038_X + DR038_Y) == DR038_X + DR038_Y, "fail");
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Linesvoid dr050(void) {
* other tests. Undefine the macro to demonstrate that use of a wide string * other tests. Undefine the macro to demonstrate that use of a wide string
* literal doesn't magically include the header file. * literal doesn't magically include the header file.
*/ */
#undef NULL #undef NULL
(void)L"huttah!"; (void)L"huttah!";
(void)NULL; /* expected-error {{use of undeclared identifier 'NULL'}} */ (void)NULL; /* expected-error {{use of undeclared identifier 'NULL'}} */
} }
#if __STDC_VERSION__ < 202000L #if __STDC_VERSION__ < 202311L
/* WG14 DR053: yes /* WG14 DR053: yes
* Accessing a pointer to a function with a prototype through a pointer to * Accessing a pointer to a function with a prototype through a pointer to
* pointer to function without a prototype * pointer to function without a prototype
*/ */
void dr053(void) { void dr053(void) {
int f(int); int f(int);
int (*fp1)(int); int (*fp1)(int);
int (*fp2)(); /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */ int (*fp2)(); /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */
int (**fpp)(); /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */ int (**fpp)(); /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */
fp1 = f; fp1 = f;
fp2 = fp1; fp2 = fp1;
(*fp2)(3); /* expected-warning {{passing arguments to a function without a prototype is deprecated in all versions of C and is not supported in C2x}} */ (*fp2)(3); /* expected-warning {{passing arguments to a function without a prototype is deprecated in all versions of C and is not supported in C2x}} */
fpp = &fp1; fpp = &fp1;
(**fpp)(3); /* expected-warning {{passing arguments to a function without a prototype is deprecated in all versions of C and is not supported in C2x}} */ (**fpp)(3); /* expected-warning {{passing arguments to a function without a prototype is deprecated in all versions of C and is not supported in C2x}} */
} }
#endif /* __STDC_VERSION__ < 202000L */ #endif /* __STDC_VERSION__ < 202311L */
/* WG14 DR064: yes /* WG14 DR064: yes
* Null pointer constants * Null pointer constants
*/ */
char *dr064_1(int i, int *pi) { char *dr064_1(int i, int *pi) {
*pi = i; *pi = i;
return 0; return 0;
} }
Show All 12 Lines#if CHAR_MAX == SCHAR_MAX
/* char is signed */ /* char is signed */
_Static_assert('\xFF' == -1, "fail"); _Static_assert('\xFF' == -1, "fail");
#else #else
/* char is unsigned */ /* char is unsigned */
_Static_assert('\xFF' == 0xFF, "fail"); _Static_assert('\xFF' == 0xFF, "fail");
#endif #endif
} }
#if __STDC_VERSION__ < 202000L #if __STDC_VERSION__ < 202311L
/* WG14: DR070: yes /* WG14: DR070: yes
* Interchangeability of function arguments * Interchangeability of function arguments
* *
* Note: we could issue a pedantic warning in this case. We are claiming * Note: we could issue a pedantic warning in this case. We are claiming
* conformance not because we diagnose the UB when we could but because we're * conformance not because we diagnose the UB when we could but because we're
* not obligated to do anything about it and we make it "just work" via the * not obligated to do anything about it and we make it "just work" via the
* usual conversion rules. * usual conversion rules.
* *
* This behavior is specific to functions without prototypes. A function with * This behavior is specific to functions without prototypes. A function with
* a prototype causes implicit conversions rather than relying on default * a prototype causes implicit conversions rather than relying on default
* argument promotion and warm thoughts. * argument promotion and warm thoughts.
*/ */
void dr070_1(c) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */ void dr070_1(c) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */
int c; { int c; {
} }
void dr070_2(void) { void dr070_2(void) {
dr070_1(6); dr070_1(6);
dr070_1(6U); /* Pedantically UB */ dr070_1(6U); /* Pedantically UB */
} }
#endif /* __STDC_VERSION__ < 202000L */ #endif /* __STDC_VERSION__ < 202311L */
/* WG14 DR071: yes /* WG14 DR071: yes
* Enumerated types * Enumerated types
*/ */
enum dr071_t { foo_A = 0, foo_B = 1, foo_C = 8 }; enum dr071_t { foo_A = 0, foo_B = 1, foo_C = 8 };
void dr071(void) { void dr071(void) {
/* Test that in-range values not present in the enumeration still round-trip /* Test that in-range values not present in the enumeration still round-trip
* to the original value. * to the original value.
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

clang/test/C/drs/dr2xx.c

Show First 20 Lines • Show All 225 Lines • ▼ Show 20 Lines
/* WG14 DR251: yes /* WG14 DR251: yes
* Are struct fred and union fred the same type? * Are struct fred and union fred the same type?
*/ */
union dr251_fred { int a; }; /* expected-note {{previous use is here}} */ union dr251_fred { int a; }; /* expected-note {{previous use is here}} */
void dr251(void) { void dr251(void) {
struct dr251_fred *ptr; /* expected-error {{use of 'dr251_fred' with tag type that does not match previous declaration}} */ struct dr251_fred *ptr; /* expected-error {{use of 'dr251_fred' with tag type that does not match previous declaration}} */
} }
#if __STDC_VERSION__ < 202000L #if __STDC_VERSION__ < 202311L
/* WG14 DR252: yes /* WG14 DR252: yes
* Incomplete argument types when calling non-prototyped functions * Incomplete argument types when calling non-prototyped functions
*/ */
void dr252_no_proto(); /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */ void dr252_no_proto(); /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */
void dr252_proto(void); /* expected-note {{'dr252_proto' declared here}} */ void dr252_proto(void); /* expected-note {{'dr252_proto' declared here}} */
void dr252(void) { void dr252(void) {
/* It's a constraint violation to pass an argument to a function with a /* It's a constraint violation to pass an argument to a function with a
* prototype that specifies a void parameter. * prototype that specifies a void parameter.
*/ */
dr252_proto(dr252_no_proto()); /* expected-error {{too many arguments to function call, expected 0, have 1}} */ dr252_proto(dr252_no_proto()); /* expected-error {{too many arguments to function call, expected 0, have 1}} */
/* It's technically UB to pass an incomplete type to a function without a /* It's technically UB to pass an incomplete type to a function without a
* prototype, but Clang treats it as an error. * prototype, but Clang treats it as an error.
*/ */
dr252_no_proto(dr252_proto()); /* expected-error {{argument type 'void' is incomplete}} dr252_no_proto(dr252_proto()); /* expected-error {{argument type 'void' is incomplete}}
expected-warning {{passing arguments to 'dr252_no_proto' without a prototype is deprecated in all versions of C and is not supported in C2x}} expected-warning {{passing arguments to 'dr252_no_proto' without a prototype is deprecated in all versions of C and is not supported in C2x}}
*/ */
} }
#endif /* __STDC_VERSION__ < 202000L */ #endif /* __STDC_VERSION__ < 202311L */
/* WG14 DR258: yes /* WG14 DR258: yes
* Ordering of "defined" and macro replacement * Ordering of "defined" and macro replacement
*/ */
void dr258(void) { void dr258(void) {
/* We get the diagnostic twice because the argument is used twice in the /* We get the diagnostic twice because the argument is used twice in the
* expansion. */ * expansion. */
#define repeat(x) x && x #define repeat(x) x && x
▲ Show 20 Lines • Show All 197 Lines • Show Last 20 Lines

clang/test/C/drs/dr3xx.c

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Linesstruct dr315_t {
short d : 8; short d : 8;
} dr315; } dr315;
_Static_assert(sizeof(dr315.a + dr315.b) == sizeof(unsigned long long), ""); /* c89only-warning {{'long long' is an extension when C99 mode is not enabled}} */ _Static_assert(sizeof(dr315.a + dr315.b) == sizeof(unsigned long long), ""); /* c89only-warning {{'long long' is an extension when C99 mode is not enabled}} */
/* Demonstrate that integer promotions still happen when less than the width of /* Demonstrate that integer promotions still happen when less than the width of
* an int. * an int.
*/ */
_Static_assert(sizeof(dr315.c + dr315.d) == sizeof(int), ""); _Static_assert(sizeof(dr315.c + dr315.d) == sizeof(int), "");
#if __STDC_VERSION__ < 202000L #if __STDC_VERSION__ < 202311L
/* WG14 DR316: yes /* WG14 DR316: yes
* Unprototyped function types * Unprototyped function types
*/ */
void dr316_1(a) int a; {} /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */ void dr316_1(a) int a; {} /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */
void (*dr316_1_ptr)(int, int, int) = dr316_1; void (*dr316_1_ptr)(int, int, int) = dr316_1;
/* WG14 DR317: yes /* WG14 DR317: yes
* Function definitions with empty parentheses * Function definitions with empty parentheses
* *
* Despite the function with empty parens being a definition, this does not * Despite the function with empty parens being a definition, this does not
* provide a prototype for the function. However, calling the function with * provide a prototype for the function. However, calling the function with
* arguments is undefined behavior, so it is defensible for us to warn the user * arguments is undefined behavior, so it is defensible for us to warn the user
* about it. They key point to this DR is that we give the "without a * about it. They key point to this DR is that we give the "without a
* prototype" warnings to demonstrate we don't give this function a prototype. * prototype" warnings to demonstrate we don't give this function a prototype.
*/ */
void dr317_1() {} /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */ void dr317_1() {} /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */
void dr317_2(void) { void dr317_2(void) {
if (0) if (0)
dr317_1(1); /* expected-warning {{too many arguments in call to 'dr317_1'}} dr317_1(1); /* expected-warning {{too many arguments in call to 'dr317_1'}}
expected-warning {{passing arguments to 'dr317_1' without a prototype is deprecated in all versions of C and is not supported in C2x}} expected-warning {{passing arguments to 'dr317_1' without a prototype is deprecated in all versions of C and is not supported in C2x}}
*/ */
} }
#endif /* __STDC_VERSION__ < 202000L */ #endif /* __STDC_VERSION__ < 202311L */
/* WG14 DR320: yes /* WG14 DR320: yes
* Scope of variably modified type * Scope of variably modified type
*/ */
int dr320_v; int dr320_v;
typedef int dr320_t[dr320_v]; /* c89only-warning {{variable length arrays are a C99 feature}} typedef int dr320_t[dr320_v]; /* c89only-warning {{variable length arrays are a C99 feature}}
expected-error {{variable length array declaration not allowed at file scope}} expected-error {{variable length array declaration not allowed at file scope}}
c99andup-warning {{variable length array used}} c99andup-warning {{variable length array used}}
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
/* WG14 DR340: yes /* WG14 DR340: yes
* Composite types for variable-length arrays * Composite types for variable-length arrays
* *
* The DR made this behavior undefined because implementations disagreed on the * The DR made this behavior undefined because implementations disagreed on the
* behavior. For this DR, Clang accepts the code and GCC rejects it. It's * behavior. For this DR, Clang accepts the code and GCC rejects it. It's
* unclear whether the Clang behavior is intentional, but because the code is * unclear whether the Clang behavior is intentional, but because the code is
* UB, any behavior is acceptable. * UB, any behavior is acceptable.
*/ */
#if __STDC_VERSION__ < 202000L #if __STDC_VERSION__ < 202311L
void dr340(int x, int y) { void dr340(int x, int y) {
typedef void (*T1)(int); typedef void (*T1)(int);
typedef void (*T2)(); /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */ typedef void (*T2)(); /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} */
T1 (*a)[] = 0; T1 (*a)[] = 0;
T2 (*b)[x] = 0; /* c89only-warning {{variable length arrays are a C99 feature}} T2 (*b)[x] = 0; /* c89only-warning {{variable length arrays are a C99 feature}}
c99andup-warning {{variable length array used}} c99andup-warning {{variable length array used}}
*/ */
(y ? a : b)[0][0](); (y ? a : b)[0][0]();
} }
#endif /* __STDC_VERSION__ < 202000L */ #endif /* __STDC_VERSION__ < 202311L */
/* WG14 DR341: yes /* WG14 DR341: yes
* [*] in abstract declarators * [*] in abstract declarators
*/ */
void dr341_1(int (*)[*]); /* c89only-warning {{variable length arrays are a C99 feature}} void dr341_1(int (*)[*]); /* c89only-warning {{variable length arrays are a C99 feature}}
c99andup-warning {{variable length array used}} c99andup-warning {{variable length array used}}
*/ */
void dr341_2(int (*)[sizeof(int (*)[*])]); /* expected-error {{star modifier used outside of function prototype}} */ void dr341_2(int (*)[sizeof(int (*)[*])]); /* expected-error {{star modifier used outside of function prototype}} */
Show All 29 Lines

clang/test/C/drs/dr411.c

Show All 19 Lines
#endif #endif
#elif defined(C99) #elif defined(C99)
_Static_assert(__STDC_VERSION__ == 199901L, ""); _Static_assert(__STDC_VERSION__ == 199901L, "");
#elif defined(C11) #elif defined(C11)
_Static_assert(__STDC_VERSION__ == 201112L, ""); _Static_assert(__STDC_VERSION__ == 201112L, "");
#elif defined(C17) #elif defined(C17)
_Static_assert(__STDC_VERSION__ == 201710L, ""); _Static_assert(__STDC_VERSION__ == 201710L, "");
#elif defined(C2X) #elif defined(C2X)
/* FIXME: this value will change once WG14 picks the final value for C2x. */ _Static_assert(__STDC_VERSION__ == 202311L, "");
_Static_assert(__STDC_VERSION__ == 202000L, "");
#else #else
#error "unknown language standard version" #error "unknown language standard version"
#endif #endif

clang/test/Driver/unknown-std.c

Show All 10 Lines
// CHECK-NEXT: note: use 'iso9899:199409' for 'ISO C 1990 with amendment 1' standard // CHECK-NEXT: note: use 'iso9899:199409' for 'ISO C 1990 with amendment 1' standard
// CHECK-NEXT: note: use 'gnu89' or 'gnu90' for 'ISO C 1990 with GNU extensions' standard // CHECK-NEXT: note: use 'gnu89' or 'gnu90' for 'ISO C 1990 with GNU extensions' standard
// CHECK-NEXT: note: use 'c99' or 'iso9899:1999' for 'ISO C 1999' standard // CHECK-NEXT: note: use 'c99' or 'iso9899:1999' for 'ISO C 1999' standard
// CHECK-NEXT: note: use 'gnu99' for 'ISO C 1999 with GNU extensions' standard // CHECK-NEXT: note: use 'gnu99' for 'ISO C 1999 with GNU extensions' standard
// CHECK-NEXT: note: use 'c11' or 'iso9899:2011' for 'ISO C 2011' standard // CHECK-NEXT: note: use 'c11' or 'iso9899:2011' for 'ISO C 2011' standard
// CHECK-NEXT: note: use 'gnu11' for 'ISO C 2011 with GNU extensions' standard // CHECK-NEXT: note: use 'gnu11' for 'ISO C 2011 with GNU extensions' standard
// CHECK-NEXT: note: use 'c17', 'iso9899:2017', 'c18', or 'iso9899:2018' for 'ISO C 2017' standard // CHECK-NEXT: note: use 'c17', 'iso9899:2017', 'c18', or 'iso9899:2018' for 'ISO C 2017' standard
// CHECK-NEXT: note: use 'gnu17' or 'gnu18' for 'ISO C 2017 with GNU extensions' standard // CHECK-NEXT: note: use 'gnu17' or 'gnu18' for 'ISO C 2017 with GNU extensions' standard
// CHECK-NEXT: note: use 'c2x' for 'Working Draft for ISO C2x' standard // CHECK-NEXT: note: use 'c23' for 'Working Draft for ISO C23' standard
// CHECK-NEXT: note: use 'gnu2x' for 'Working Draft for ISO C2x with GNU extensions' standard // CHECK-NEXT: note: use 'gnu23' for 'Working Draft for ISO C23 with GNU extensions' standard
// Make sure that no other output is present. // Make sure that no other output is present.
// CHECK-NOT: {{^.+$}} // CHECK-NOT: {{^.+$}}

clang/test/Headers/limits.cpp

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Lines
_Static_assert(ULLONG_MAX == (unsigned long long)~0ULL, ""); _Static_assert(ULLONG_MAX == (unsigned long long)~0ULL, "");
_Static_assert(EXPR_TYPE_IS(ULLONG_MAX, unsigned long long), ""); _Static_assert(EXPR_TYPE_IS(ULLONG_MAX, unsigned long long), "");
#if ULLONG_MAX #if ULLONG_MAX
#endif #endif
#else #else
int LLONG_MIN, LLONG_MAX, ULLONG_MAX; // Not defined. int LLONG_MIN, LLONG_MAX, ULLONG_MAX; // Not defined.
#endif #endif
/* FIXME: This is using the placeholder dates Clang produces for these macros #if __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if __STDC_VERSION__ >= 202000L
/* Validate the standard requirements. */ /* Validate the standard requirements. */
_Static_assert(BOOL_WIDTH >= 1); _Static_assert(BOOL_WIDTH >= 1);
#if BOOL_WIDTH #if BOOL_WIDTH
#endif #endif
_Static_assert(CHAR_WIDTH == CHAR_BIT); _Static_assert(CHAR_WIDTH == CHAR_BIT);
_Static_assert(CHAR_WIDTH / CHAR_BIT == sizeof(char)); _Static_assert(CHAR_WIDTH / CHAR_BIT == sizeof(char));
#if CHAR_WIDTH #if CHAR_WIDTH
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

clang/test/Headers/stdint.c

Show All 14 Lines
// RUN: %clang_cc1 %s -ffreestanding -std=c2x -fsyntax-only -triple=x86_64-none-none // RUN: %clang_cc1 %s -ffreestanding -std=c2x -fsyntax-only -triple=x86_64-none-none
// RUN: %clang_cc1 %s -ffreestanding -std=c2x -fsyntax-only -triple=x86_64-pc-linux-gnu // RUN: %clang_cc1 %s -ffreestanding -std=c2x -fsyntax-only -triple=x86_64-pc-linux-gnu
// RUN: %clang_cc1 %s -ffreestanding -std=c2x -fsyntax-only -triple=i386-mingw32 // RUN: %clang_cc1 %s -ffreestanding -std=c2x -fsyntax-only -triple=i386-mingw32
// RUN: %clang_cc1 %s -ffreestanding -std=c2x -fsyntax-only -triple=xcore-none-none // RUN: %clang_cc1 %s -ffreestanding -std=c2x -fsyntax-only -triple=xcore-none-none
// expected-no-diagnostics // expected-no-diagnostics
#include <stdint.h> #include <stdint.h>
/* FIXME: This is using the placeholder dates Clang produces for these macros #if __STDC_VERSION__ >= 202311L
in C2x mode; switch to the correct values once they've been published. */
#if __STDC_VERSION__ >= 202000L
/* Validate the standard requirements. */ /* Validate the standard requirements. */
_Static_assert(SIG_ATOMIC_WIDTH >= 8); _Static_assert(SIG_ATOMIC_WIDTH >= 8);
_Static_assert(SIZE_WIDTH >= 16); _Static_assert(SIZE_WIDTH >= 16);
_Static_assert(SIZE_WIDTH / __CHAR_BIT__ == sizeof(sizeof(0))); _Static_assert(SIZE_WIDTH / __CHAR_BIT__ == sizeof(sizeof(0)));
_Static_assert(WCHAR_WIDTH >= 8); _Static_assert(WCHAR_WIDTH >= 8);
_Static_assert(WCHAR_WIDTH / __CHAR_BIT__ == sizeof(L't')); _Static_assert(WCHAR_WIDTH / __CHAR_BIT__ == sizeof(L't'));
_Static_assert(WINT_WIDTH >= 16); _Static_assert(WINT_WIDTH >= 16);
_Static_assert(UINTPTR_WIDTH >= 16); _Static_assert(UINTPTR_WIDTH >= 16);
Show All 13 Lines
/* NB: WG14 N2412 set this to 17, but WG14 N2808 set it back to 16. */ /* NB: WG14 N2412 set this to 17, but WG14 N2808 set it back to 16. */
_Static_assert(PTRDIFF_WIDTH >= 16); _Static_assert(PTRDIFF_WIDTH >= 16);
#else #else
/* None of these are defined. */ /* None of these are defined. */
int PTRDIFF_WIDTH, SIG_ATOMIC_WIDTH, SIZE_WIDTH, WCHAR_WIDTH, WINT_WIDTH, int PTRDIFF_WIDTH, SIG_ATOMIC_WIDTH, SIZE_WIDTH, WCHAR_WIDTH, WINT_WIDTH,
INTPTR_WIDTH, UINTPTR_WIDTH, INTMAX_WIDTH, UINTMAX_WIDTH; INTPTR_WIDTH, UINTPTR_WIDTH, INTMAX_WIDTH, UINTMAX_WIDTH;
#endif #endif
#if defined(INT8_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT8_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT8_WIDTH == 8, ""); _Static_assert(INT8_WIDTH == 8, "");
_Static_assert(UINT8_WIDTH == INT8_WIDTH, ""); _Static_assert(UINT8_WIDTH == INT8_WIDTH, "");
_Static_assert(INT8_WIDTH / __CHAR_BIT__ == sizeof(int8_t), ""); _Static_assert(INT8_WIDTH / __CHAR_BIT__ == sizeof(int8_t), "");
_Static_assert(UINT8_WIDTH / __CHAR_BIT__ == sizeof(uint8_t), ""); _Static_assert(UINT8_WIDTH / __CHAR_BIT__ == sizeof(uint8_t), "");
#else #else
int INT8_WIDTH, UINT8_WIDTH; /* None of these are defined. */ int INT8_WIDTH, UINT8_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_LEAST8_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_LEAST8_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_LEAST8_WIDTH >= 8, ""); _Static_assert(INT_LEAST8_WIDTH >= 8, "");
_Static_assert(INT_LEAST8_WIDTH / __CHAR_BIT__ == sizeof(int_least8_t), ""); _Static_assert(INT_LEAST8_WIDTH / __CHAR_BIT__ == sizeof(int_least8_t), "");
_Static_assert(UINT_LEAST8_WIDTH == INT_LEAST8_WIDTH, ""); _Static_assert(UINT_LEAST8_WIDTH == INT_LEAST8_WIDTH, "");
_Static_assert(UINT_LEAST8_WIDTH / __CHAR_BIT__ == sizeof(uint_least8_t), ""); _Static_assert(UINT_LEAST8_WIDTH / __CHAR_BIT__ == sizeof(uint_least8_t), "");
#else #else
int INT_LEAST8_WIDTH, UINT_LEAST8_WIDTH; /* None of these are defined. */ int INT_LEAST8_WIDTH, UINT_LEAST8_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_FAST8_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_FAST8_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_FAST8_WIDTH >= 8, ""); _Static_assert(INT_FAST8_WIDTH >= 8, "");
_Static_assert(INT_FAST8_WIDTH / __CHAR_BIT__ == sizeof(int_fast8_t), ""); _Static_assert(INT_FAST8_WIDTH / __CHAR_BIT__ == sizeof(int_fast8_t), "");
_Static_assert(UINT_FAST8_WIDTH == INT_FAST8_WIDTH, ""); _Static_assert(UINT_FAST8_WIDTH == INT_FAST8_WIDTH, "");
_Static_assert(UINT_FAST8_WIDTH / __CHAR_BIT__ == sizeof(uint_fast8_t), ""); _Static_assert(UINT_FAST8_WIDTH / __CHAR_BIT__ == sizeof(uint_fast8_t), "");
#else #else
int INT_FAST8_WIDTH, UINT_FAST8_WIDTH; /* None of these are defined. */ int INT_FAST8_WIDTH, UINT_FAST8_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT16_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT16_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT16_WIDTH == 16, ""); _Static_assert(INT16_WIDTH == 16, "");
_Static_assert(UINT16_WIDTH == INT16_WIDTH, ""); _Static_assert(UINT16_WIDTH == INT16_WIDTH, "");
_Static_assert(INT16_WIDTH / __CHAR_BIT__ == sizeof(int16_t), ""); _Static_assert(INT16_WIDTH / __CHAR_BIT__ == sizeof(int16_t), "");
_Static_assert(UINT16_WIDTH / __CHAR_BIT__ == sizeof(uint16_t), ""); _Static_assert(UINT16_WIDTH / __CHAR_BIT__ == sizeof(uint16_t), "");
#else #else
int INT16_WIDTH, UINT16_WIDTH; /* None of these are defined. */ int INT16_WIDTH, UINT16_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_LEAST16_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_LEAST16_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_LEAST16_WIDTH >= 16, ""); _Static_assert(INT_LEAST16_WIDTH >= 16, "");
_Static_assert(INT_LEAST16_WIDTH / __CHAR_BIT__ == sizeof(int_least16_t), ""); _Static_assert(INT_LEAST16_WIDTH / __CHAR_BIT__ == sizeof(int_least16_t), "");
_Static_assert(UINT_LEAST16_WIDTH == INT_LEAST16_WIDTH, ""); _Static_assert(UINT_LEAST16_WIDTH == INT_LEAST16_WIDTH, "");
_Static_assert(UINT_LEAST16_WIDTH / __CHAR_BIT__ == sizeof(uint_least16_t), ""); _Static_assert(UINT_LEAST16_WIDTH / __CHAR_BIT__ == sizeof(uint_least16_t), "");
#else #else
int INT_LEAST16_WIDTH, UINT_LEAST16_WIDTH; /* None of these are defined. */ int INT_LEAST16_WIDTH, UINT_LEAST16_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_FAST16_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_FAST16_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_FAST16_WIDTH >= 16, ""); _Static_assert(INT_FAST16_WIDTH >= 16, "");
_Static_assert(INT_FAST16_WIDTH / __CHAR_BIT__ == sizeof(int_fast16_t), ""); _Static_assert(INT_FAST16_WIDTH / __CHAR_BIT__ == sizeof(int_fast16_t), "");
_Static_assert(UINT_FAST16_WIDTH == INT_FAST16_WIDTH, ""); _Static_assert(UINT_FAST16_WIDTH == INT_FAST16_WIDTH, "");
_Static_assert(UINT_FAST16_WIDTH / __CHAR_BIT__ == sizeof(int_fast16_t), ""); _Static_assert(UINT_FAST16_WIDTH / __CHAR_BIT__ == sizeof(int_fast16_t), "");
#else #else
int INT_FAST16_WIDTH, UINT_FAST16_WIDTH; /* None of these are defined. */ int INT_FAST16_WIDTH, UINT_FAST16_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT24_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT24_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT24_WIDTH == 24, ""); _Static_assert(INT24_WIDTH == 24, "");
_Static_assert(UINT24_WIDTH == INT24_WIDTH, ""); _Static_assert(UINT24_WIDTH == INT24_WIDTH, "");
_Static_assert(INT24_WIDTH / __CHAR_BIT__ == sizeof(int24_t), ""); _Static_assert(INT24_WIDTH / __CHAR_BIT__ == sizeof(int24_t), "");
_Static_assert(UINT24_WIDTH / __CHAR_BIT__ == sizeof(uint24_t), ""); _Static_assert(UINT24_WIDTH / __CHAR_BIT__ == sizeof(uint24_t), "");
#else #else
int INT24_WIDTH, UINT24_WIDTH; /* None of these are defined. */ int INT24_WIDTH, UINT24_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_LEAST24_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_LEAST24_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_LEAST24_WIDTH >= 24, ""); _Static_assert(INT_LEAST24_WIDTH >= 24, "");
_Static_assert(INT_LEAST24_WIDTH / __CHAR_BIT__ == sizeof(int_least24_t), ""); _Static_assert(INT_LEAST24_WIDTH / __CHAR_BIT__ == sizeof(int_least24_t), "");
_Static_assert(UINT_LEAST24_WIDTH == INT_LEAST24_WIDTH, ""); _Static_assert(UINT_LEAST24_WIDTH == INT_LEAST24_WIDTH, "");
_Static_assert(UINT_LEAST24_WIDTH / __CHAR_BIT__ == sizeof(uint_least24_t), ""); _Static_assert(UINT_LEAST24_WIDTH / __CHAR_BIT__ == sizeof(uint_least24_t), "");
#else #else
int INT_LEAST24_WIDTH, UINT_LEAST24_WIDTH; /* None of these are defined. */ int INT_LEAST24_WIDTH, UINT_LEAST24_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_FAST24_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_FAST24_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_FAST24_WIDTH >= 24, ""); _Static_assert(INT_FAST24_WIDTH >= 24, "");
_Static_assert(INT_FAST24_WIDTH / __CHAR_BIT__ == sizeof(int_fast24_t), ""); _Static_assert(INT_FAST24_WIDTH / __CHAR_BIT__ == sizeof(int_fast24_t), "");
_Static_assert(UINT_FAST24_WIDTH == INT_FAST24_WIDTH, ""); _Static_assert(UINT_FAST24_WIDTH == INT_FAST24_WIDTH, "");
_Static_assert(UINT_FAST24_WIDTH / __CHAR_BIT__ == sizeof(uint_fast24_t), ""); _Static_assert(UINT_FAST24_WIDTH / __CHAR_BIT__ == sizeof(uint_fast24_t), "");
#else #else
int INT_FAST24_WIDTH, UINT_FAST24_WIDTH; /* None of these are defined. */ int INT_FAST24_WIDTH, UINT_FAST24_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT32_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT32_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT32_WIDTH == 32, ""); _Static_assert(INT32_WIDTH == 32, "");
_Static_assert(UINT32_WIDTH == INT32_WIDTH, ""); _Static_assert(UINT32_WIDTH == INT32_WIDTH, "");
_Static_assert(INT32_WIDTH / __CHAR_BIT__ == sizeof(int32_t), ""); _Static_assert(INT32_WIDTH / __CHAR_BIT__ == sizeof(int32_t), "");
_Static_assert(UINT32_WIDTH / __CHAR_BIT__ == sizeof(uint32_t), ""); _Static_assert(UINT32_WIDTH / __CHAR_BIT__ == sizeof(uint32_t), "");
#else #else
int INT32_WIDTH, UINT32_WIDTH; /* None of these are defined. */ int INT32_WIDTH, UINT32_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_LEAST32_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_LEAST32_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_LEAST32_WIDTH >= 32, ""); _Static_assert(INT_LEAST32_WIDTH >= 32, "");
_Static_assert(INT_LEAST32_WIDTH / __CHAR_BIT__ == sizeof(int_least32_t), ""); _Static_assert(INT_LEAST32_WIDTH / __CHAR_BIT__ == sizeof(int_least32_t), "");
_Static_assert(UINT_LEAST32_WIDTH == INT_LEAST32_WIDTH, ""); _Static_assert(UINT_LEAST32_WIDTH == INT_LEAST32_WIDTH, "");
_Static_assert(UINT_LEAST32_WIDTH / __CHAR_BIT__ == sizeof(uint_least32_t), ""); _Static_assert(UINT_LEAST32_WIDTH / __CHAR_BIT__ == sizeof(uint_least32_t), "");
#else #else
int INT_LEAST32_WIDTH, UINT_LEAST32_WIDTH; /* None of these are defined. */ int INT_LEAST32_WIDTH, UINT_LEAST32_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_FAST32_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_FAST32_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_FAST32_WIDTH >= 32, ""); _Static_assert(INT_FAST32_WIDTH >= 32, "");
_Static_assert(INT_FAST32_WIDTH / __CHAR_BIT__ == sizeof(int_fast32_t), ""); _Static_assert(INT_FAST32_WIDTH / __CHAR_BIT__ == sizeof(int_fast32_t), "");
_Static_assert(UINT_FAST32_WIDTH == INT_FAST32_WIDTH, ""); _Static_assert(UINT_FAST32_WIDTH == INT_FAST32_WIDTH, "");
_Static_assert(UINT_FAST32_WIDTH / __CHAR_BIT__ == sizeof(uint_fast32_t), ""); _Static_assert(UINT_FAST32_WIDTH / __CHAR_BIT__ == sizeof(uint_fast32_t), "");
#else #else
int INT_FAST32_WIDTH, UINT_FAST32_WIDTH; /* None of these are defined. */ int INT_FAST32_WIDTH, UINT_FAST32_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT40_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT40_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT40_WIDTH == 40, ""); _Static_assert(INT40_WIDTH == 40, "");
_Static_assert(UINT40_WIDTH == INT40_WIDTH, ""); _Static_assert(UINT40_WIDTH == INT40_WIDTH, "");
_Static_assert(INT40_WIDTH / __CHAR_BIT__ == sizeof(int40_t), ""); _Static_assert(INT40_WIDTH / __CHAR_BIT__ == sizeof(int40_t), "");
_Static_assert(UINT40_WIDTH / __CHAR_BIT__ == sizeof(uint40_t), ""); _Static_assert(UINT40_WIDTH / __CHAR_BIT__ == sizeof(uint40_t), "");
#else #else
int INT40_WIDTH, UINT40_WIDTH; /* None of these are defined. */ int INT40_WIDTH, UINT40_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_LEAST40_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_LEAST40_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_LEAST40_WIDTH >= 40, ""); _Static_assert(INT_LEAST40_WIDTH >= 40, "");
_Static_assert(INT_LEAST40_WIDTH / __CHAR_BIT__ == sizeof(int_least40_t), ""); _Static_assert(INT_LEAST40_WIDTH / __CHAR_BIT__ == sizeof(int_least40_t), "");
_Static_assert(UINT_LEAST40_WIDTH == INT_LEAST40_WIDTH, ""); _Static_assert(UINT_LEAST40_WIDTH == INT_LEAST40_WIDTH, "");
_Static_assert(UINT_LEAST40_WIDTH / __CHAR_BIT__ == sizeof(int_least40_t), ""); _Static_assert(UINT_LEAST40_WIDTH / __CHAR_BIT__ == sizeof(int_least40_t), "");
#else #else
int INT_LEAST40_WIDTH, UINT_LEAST40_WIDTH; /* None of these are defined. */ int INT_LEAST40_WIDTH, UINT_LEAST40_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_FAST40_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_FAST40_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_FAST40_WIDTH >= 40, ""); _Static_assert(INT_FAST40_WIDTH >= 40, "");
_Static_assert(INT_FAST40_WIDTH / __CHAR_BIT__ == sizeof(int_fast40_t), ""); _Static_assert(INT_FAST40_WIDTH / __CHAR_BIT__ == sizeof(int_fast40_t), "");
_Static_assert(UINT_FAST40_WIDTH == INT_FAST40_WIDTH, ""); _Static_assert(UINT_FAST40_WIDTH == INT_FAST40_WIDTH, "");
_Static_assert(UINT_FAST40_WIDTH / __CHAR_BIT__ == sizeof(uint_fast40_t), ""); _Static_assert(UINT_FAST40_WIDTH / __CHAR_BIT__ == sizeof(uint_fast40_t), "");
#else #else
int INT_FAST40_WIDTH, UINT_FAST40_WIDTH; /* None of these are defined. */ int INT_FAST40_WIDTH, UINT_FAST40_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT48_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT48_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT48_WIDTH == 48, ""); _Static_assert(INT48_WIDTH == 48, "");
_Static_assert(UINT48_WIDTH == INT48_WIDTH, ""); _Static_assert(UINT48_WIDTH == INT48_WIDTH, "");
_Static_assert(INT48_WIDTH / __CHAR_BIT__ == sizeof(int48_t), ""); _Static_assert(INT48_WIDTH / __CHAR_BIT__ == sizeof(int48_t), "");
_Static_assert(UINT48_WIDTH / __CHAR_BIT__ == sizeof(uint48_t), ""); _Static_assert(UINT48_WIDTH / __CHAR_BIT__ == sizeof(uint48_t), "");
#else #else
int INT48_WIDTH, UINT48_WIDTH; /* None of these are defined. */ int INT48_WIDTH, UINT48_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_LEAST48_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_LEAST48_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_LEAST48_WIDTH >= 48, ""); _Static_assert(INT_LEAST48_WIDTH >= 48, "");
_Static_assert(INT_LEAST48_WIDTH / __CHAR_BIT__ == sizeof(int_least48_t), ""); _Static_assert(INT_LEAST48_WIDTH / __CHAR_BIT__ == sizeof(int_least48_t), "");
_Static_assert(UINT_LEAST48_WIDTH == INT_LEAST48_WIDTH, ""); _Static_assert(UINT_LEAST48_WIDTH == INT_LEAST48_WIDTH, "");
_Static_assert(UINT_LEAST48_WIDTH / __CHAR_BIT__ == sizeof(int_least48_t), ""); _Static_assert(UINT_LEAST48_WIDTH / __CHAR_BIT__ == sizeof(int_least48_t), "");
#else #else
int INT_LEAST48_WIDTH, UINT_LEAST48_WIDTH; /* None of these are defined. */ int INT_LEAST48_WIDTH, UINT_LEAST48_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_FAST48_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_FAST48_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_FAST48_WIDTH >= 48, ""); _Static_assert(INT_FAST48_WIDTH >= 48, "");
_Static_assert(INT_FAST48_WIDTH / __CHAR_BIT__ == sizeof(int_fast48_t), ""); _Static_assert(INT_FAST48_WIDTH / __CHAR_BIT__ == sizeof(int_fast48_t), "");
_Static_assert(UINT_FAST48_WIDTH == INT_FAST48_WIDTH, ""); _Static_assert(UINT_FAST48_WIDTH == INT_FAST48_WIDTH, "");
_Static_assert(UINT_FAST48_WIDTH / __CHAR_BIT__ == sizeof(int_fast48_t), ""); _Static_assert(UINT_FAST48_WIDTH / __CHAR_BIT__ == sizeof(int_fast48_t), "");
#else #else
int INT_FAST48_WIDTH, UINT_FAST48_WIDTH; /* None of these are defined. */ int INT_FAST48_WIDTH, UINT_FAST48_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT56_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT56_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT56_WIDTH == 56, ""); _Static_assert(INT56_WIDTH == 56, "");
_Static_assert(UINT56_WIDTH == INT56_WIDTH, ""); _Static_assert(UINT56_WIDTH == INT56_WIDTH, "");
_Static_assert(INT56_WIDTH / __CHAR_BIT__ == sizeof(int56_t), ""); _Static_assert(INT56_WIDTH / __CHAR_BIT__ == sizeof(int56_t), "");
_Static_assert(UINT56_WIDTH / __CHAR_BIT__ == sizeof(uint56_t), ""); _Static_assert(UINT56_WIDTH / __CHAR_BIT__ == sizeof(uint56_t), "");
#else #else
int INT56_WIDTH, UINT56_WIDTH; /* None of these are defined. */ int INT56_WIDTH, UINT56_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_LEAST56_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_LEAST56_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_LEAST56_WIDTH >= 56, ""); _Static_assert(INT_LEAST56_WIDTH >= 56, "");
_Static_assert(INT_LEAST56_WIDTH / __CHAR_BIT__ == sizeof(int_least56_t), ""); _Static_assert(INT_LEAST56_WIDTH / __CHAR_BIT__ == sizeof(int_least56_t), "");
_Static_assert(UINT_LEAST56_WIDTH == INT_LEAST56_WIDTH, ""); _Static_assert(UINT_LEAST56_WIDTH == INT_LEAST56_WIDTH, "");
_Static_assert(UINT_LEAST56_WIDTH / __CHAR_BIT__ == sizeof(int_least56_t), ""); _Static_assert(UINT_LEAST56_WIDTH / __CHAR_BIT__ == sizeof(int_least56_t), "");
#else #else
int INT_LEAST56_WIDTH, UINT_LEAST56_WIDTH; /* None of these are defined. */ int INT_LEAST56_WIDTH, UINT_LEAST56_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_FAST56_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_FAST56_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_FAST56_WIDTH >= 56, ""); _Static_assert(INT_FAST56_WIDTH >= 56, "");
_Static_assert(INT_FAST56_WIDTH / __CHAR_BIT__ == sizeof(int_fast56_t), ""); _Static_assert(INT_FAST56_WIDTH / __CHAR_BIT__ == sizeof(int_fast56_t), "");
_Static_assert(UINT_FAST56_WIDTH == INT_FAST56_WIDTH, ""); _Static_assert(UINT_FAST56_WIDTH == INT_FAST56_WIDTH, "");
_Static_assert(UINT_FAST56_WIDTH / __CHAR_BIT__ == sizeof(int_fast56_t), ""); _Static_assert(UINT_FAST56_WIDTH / __CHAR_BIT__ == sizeof(int_fast56_t), "");
#else #else
int INT_FAST56_WIDTH, UINT_FAST56_WIDTH; /* None of these are defined. */ int INT_FAST56_WIDTH, UINT_FAST56_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT64_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT64_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT64_WIDTH == 64, ""); _Static_assert(INT64_WIDTH == 64, "");
_Static_assert(UINT64_WIDTH == INT64_WIDTH, ""); _Static_assert(UINT64_WIDTH == INT64_WIDTH, "");
_Static_assert(INT64_WIDTH / __CHAR_BIT__ == sizeof(int64_t), ""); _Static_assert(INT64_WIDTH / __CHAR_BIT__ == sizeof(int64_t), "");
_Static_assert(UINT64_WIDTH / __CHAR_BIT__ == sizeof(uint64_t), ""); _Static_assert(UINT64_WIDTH / __CHAR_BIT__ == sizeof(uint64_t), "");
#else #else
int INT64_WIDTH, UINT64_WIDTH; /* None of these are defined. */ int INT64_WIDTH, UINT64_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_LEAST64_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_LEAST64_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_LEAST64_WIDTH >= 64, ""); _Static_assert(INT_LEAST64_WIDTH >= 64, "");
_Static_assert(INT_LEAST64_WIDTH / __CHAR_BIT__ == sizeof(int_least64_t), ""); _Static_assert(INT_LEAST64_WIDTH / __CHAR_BIT__ == sizeof(int_least64_t), "");
_Static_assert(UINT_LEAST64_WIDTH == INT_LEAST64_WIDTH, ""); _Static_assert(UINT_LEAST64_WIDTH == INT_LEAST64_WIDTH, "");
_Static_assert(UINT_LEAST64_WIDTH / __CHAR_BIT__ == sizeof(int_least64_t), ""); _Static_assert(UINT_LEAST64_WIDTH / __CHAR_BIT__ == sizeof(int_least64_t), "");
#else #else
int INT_LEAST64_WIDTH, UINT_LEAST64_WIDTH; /* None of these are defined. */ int INT_LEAST64_WIDTH, UINT_LEAST64_WIDTH; /* None of these are defined. */
#endif #endif
#if defined(INT_FAST64_MAX) && __STDC_VERSION__ >= 202000L #if defined(INT_FAST64_MAX) && __STDC_VERSION__ >= 202311L
_Static_assert(INT_FAST64_WIDTH >= 64, ""); _Static_assert(INT_FAST64_WIDTH >= 64, "");
_Static_assert(INT_FAST64_WIDTH / __CHAR_BIT__ == sizeof(int_fast64_t), ""); _Static_assert(INT_FAST64_WIDTH / __CHAR_BIT__ == sizeof(int_fast64_t), "");
_Static_assert(UINT_FAST64_WIDTH == INT_FAST64_WIDTH, ""); _Static_assert(UINT_FAST64_WIDTH == INT_FAST64_WIDTH, "");
_Static_assert(UINT_FAST64_WIDTH / __CHAR_BIT__ == sizeof(int_fast64_t), ""); _Static_assert(UINT_FAST64_WIDTH / __CHAR_BIT__ == sizeof(int_fast64_t), "");
#else #else
int INT_FAST64_WIDTH, UINT_FAST64_WIDTH; /* None of these are defined. */ int INT_FAST64_WIDTH, UINT_FAST64_WIDTH; /* None of these are defined. */
#endif #endif

clang/test/Lexer/unicode.c

Show All 26 Lines
CHECK : The preprocessor should not complain about Unicode characters like ©. CHECK : The preprocessor should not complain about Unicode characters like ©.
#endif #endif
int a; int a;
extern int X\UAAAAAAAA; // expected-error {{not allowed in an identifier}} extern int X\UAAAAAAAA; // expected-error {{not allowed in an identifier}}
int Y = '\UAAAAAAAA'; // expected-error {{invalid universal character}} int Y = '\UAAAAAAAA'; // expected-error {{invalid universal character}}
#if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L) #if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L)
extern int ༀ; extern int ༀ;
extern int 𑩐; extern int 𑩐;
extern int 𐠈; extern int 𐠈;
extern int ꙮ; extern int ꙮ;
extern int \u1B4C; // BALINESE LETTER ARCHAIC JNYA - Added in Unicode 14 extern int \u1B4C; // BALINESE LETTER ARCHAIC JNYA - Added in Unicode 14
extern int \U00016AA2; // TANGSA LETTER GA - Added in Unicode 14 extern int \U00016AA2; // TANGSA LETTER GA - Added in Unicode 14
extern int \U0001E4D0; // 𞓐 NAG MUNDARI LETTER O - Added in Unicode 15 extern int \U0001E4D0; // 𞓐 NAG MUNDARI LETTER O - Added in Unicode 15
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

clang/test/Lexer/utf8-char-literal.cpp

Show All 10 Lines
int array1['ñ' != u'\xf1'? 1 : -1]; // expected-error {{character too large for enclosing character literal type}} int array1['ñ' != u'\xf1'? 1 : -1]; // expected-error {{character too large for enclosing character literal type}}
#if __cplusplus > 201402L #if __cplusplus > 201402L
char a = u8'ñ'; // expected-error {{character too large for enclosing character literal type}} char a = u8'ñ'; // expected-error {{character too large for enclosing character literal type}}
char b = u8'\x80'; // ok char b = u8'\x80'; // ok
char c = u8'\u0080'; // expected-error {{character too large for enclosing character literal type}} char c = u8'\u0080'; // expected-error {{character too large for enclosing character literal type}}
char d = u8'\u1234'; // expected-error {{character too large for enclosing character literal type}} char d = u8'\u1234'; // expected-error {{character too large for enclosing character literal type}}
char e = u8'ሴ'; // expected-error {{character too large for enclosing character literal type}} char e = u8'ሴ'; // expected-error {{character too large for enclosing character literal type}}
char f = u8'ab'; // expected-error {{Unicode character literals may not contain multiple characters}} char f = u8'ab'; // expected-error {{Unicode character literals may not contain multiple characters}}
#elif __STDC_VERSION__ >= 202000L #elif __STDC_VERSION__ >= 202311L
char a = u8'ñ'; // expected-error {{character too large for enclosing character literal type}} char a = u8'ñ'; // expected-error {{character too large for enclosing character literal type}}
char b = u8'\x80'; // ok char b = u8'\x80'; // ok
char c = u8'\u0000'; // ok char c = u8'\u0000'; // ok
char d = u8'\u1234'; // expected-error {{character too large for enclosing character literal type}} char d = u8'\u1234'; // expected-error {{character too large for enclosing character literal type}}
char e = u8'ሴ'; // expected-error {{character too large for enclosing character literal type}} char e = u8'ሴ'; // expected-error {{character too large for enclosing character literal type}}
char f = u8'ab'; // expected-error {{Unicode character literals may not contain multiple characters}} char f = u8'ab'; // expected-error {{Unicode character literals may not contain multiple characters}}
_Static_assert( _Static_assert(
_Generic(u8'a', _Generic(u8'a',
Show All 16 Lines
# endif # endif
# else # else
# if u8'\xff' == '\xff' // expected-warning {{right side of operator converted from negative value to unsigned}} # if u8'\xff' == '\xff' // expected-warning {{right side of operator converted from negative value to unsigned}}
# error UTF-8 character value matched ordinary character literal; this is unexpected # error UTF-8 character value matched ordinary character literal; this is unexpected
# endif # endif
# endif # endif
#endif #endif
/// In C2x, u8 char literals are always unsigned. /// In C23, u8 char literals are always unsigned.
#if __STDC_VERSION__ >= 202000L #if __STDC_VERSION__ >= 202311L
# if u8'\xff' == '\xff'// expected-warning {{right side of operator converted from negative value to unsigned}} # if u8'\xff' == '\xff'// expected-warning {{right side of operator converted from negative value to unsigned}}
# error u8 char literal is not unsigned # error u8 char literal is not unsigned
# endif # endif
#endif #endif

clang/test/Preprocessor/c2x.c

// RUN: %clang_cc1 -fsyntax-only -verify -std=c2x %s // RUN: %clang_cc1 -fsyntax-only -verify -std=c2x %s
// RUN: %clang_cc1 -fsyntax-only -verify -std=c23 %s
// expected-no-diagnostics // expected-no-diagnostics
// FIXME: Test the correct value once C23 ships. _Static_assert(__STDC_VERSION__ == 202311L, "Incorrect __STDC_VERSION__");
_Static_assert(__STDC_VERSION__ > 201710L, "Incorrect __STDC_VERSION__");

clang/test/Preprocessor/ucn-allowed-chars.c

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
# else # else
// C++03 // C++03
// expected-error@19 {{expected unqualified-id}} // expected-error@19 {{expected unqualified-id}}
// expected-warning@33 {{universal character name refers to a surrogate character}} // expected-warning@33 {{universal character name refers to a surrogate character}}
# endif # endif
#else #else
# if __STDC_VERSION__ >= 201800L # if __STDC_VERSION__ >= 202311L
// C2X // C23
// expected-warning@8 {{using this character in an identifier is incompatible with C99}} // expected-warning@8 {{using this character in an identifier is incompatible with C99}}
// expected-error@10 {{character <U+0384> not allowed in an identifier}} // expected-error@10 {{character <U+0384> not allowed in an identifier}}
// expected-error@12 {{character <U+FFFF> not allowed in an identifier}} // expected-error@12 {{character <U+FFFF> not allowed in an identifier}}
// expected-error@18 {{expected identifier}} // expected-error@18 {{expected identifier}}
// expected-error@19 {{expected identifier}} // expected-error@19 {{expected identifier}}
// expected-error@33 {{invalid universal character}} // expected-error@33 {{invalid universal character}}
# elif __STDC_VERSION__ >= 201112L # elif __STDC_VERSION__ >= 201112L
// C11 // C11
Show All 36 Lines

clang/test/Sema/atomic-expr.c

Show First 20 Lines • Show All 146 Lines • ▼ Show 20 Linesvoid func_17(void) {
const void *cvp = 0; const void *cvp = 0;
_Atomic(const int *) acip3 = cvp; _Atomic(const int *) acip3 = cvp;
_Atomic(const void *) acvip = cip; _Atomic(const void *) acvip = cip;
_Atomic(const int *) acip4 = vcip; // expected-warning {{initializing '_Atomic(const int *)' with an expression of type 'const volatile int *' discards qualifiers}} _Atomic(const int *) acip4 = vcip; // expected-warning {{initializing '_Atomic(const int *)' with an expression of type 'const volatile int *' discards qualifiers}}
_Atomic(const void *) acvip2 = vcip; // expected-warning {{initializing '_Atomic(const void *)' with an expression of type 'const volatile int *' discards qualifiers}} _Atomic(const void *) acvip2 = vcip; // expected-warning {{initializing '_Atomic(const void *)' with an expression of type 'const volatile int *' discards qualifiers}}
_Atomic(const int *) acip5 = cicp; _Atomic(const int *) acip5 = cicp;
_Atomic(const void *) acvip3 = cicp; _Atomic(const void *) acvip3 = cicp;
#if __STDC_VERSION__ >= 202000L #if __STDC_VERSION__ >= 202311L
// the left operand has an atomic ... version of the nullptr_t type and the // the left operand has an atomic ... version of the nullptr_t type and the
// right operand is a null pointer constant or its type is nullptr_t // right operand is a null pointer constant or its type is nullptr_t
typedef typeof(nullptr) nullptr_t; typedef typeof(nullptr) nullptr_t;
nullptr_t n; nullptr_t n;
_Atomic nullptr_t cn2 = n; _Atomic nullptr_t cn2 = n;
_Atomic nullptr_t cn3 = nullptr; _Atomic nullptr_t cn3 = nullptr;
#endif // __STDC_VERSION__ >= 202000L #endif // __STDC_VERSION__ >= 202311L
// the left operand is an atomic ... pointer, and the right operand is a null // the left operand is an atomic ... pointer, and the right operand is a null
// pointer constant or its type is nullptr_t; // pointer constant or its type is nullptr_t;
_Atomic(int *) aip2 = 0; _Atomic(int *) aip2 = 0;
#if __STDC_VERSION__ >= 202000L #if __STDC_VERSION__ >= 202311L
_Atomic(int *) ip2 = n; _Atomic(int *) ip2 = n;
_Atomic(int *) ip3 = nullptr; _Atomic(int *) ip3 = nullptr;
_Atomic(const int *) ip4 = nullptr; _Atomic(const int *) ip4 = nullptr;
#endif // __STDC_VERSION__ >= 202000L #endif // __STDC_VERSION__ >= 202311L
} }
// Ensure that the assignment constraints also work at file scope. // Ensure that the assignment constraints also work at file scope.
_Atomic int ai = 0; _Atomic int ai = 0;
_Atomic float af = 0.0f; _Atomic float af = 0.0f;
_Atomic(int *) aip1 = 0; _Atomic(int *) aip1 = 0;
struct S { int a; } non_atomic_s; struct S { int a; } non_atomic_s;
_Atomic struct S as = non_atomic_s; // expected-error {{initializer element is not a compile-time constant}} _Atomic struct S as = non_atomic_s; // expected-error {{initializer element is not a compile-time constant}}
const int *cip = 0; const int *cip = 0;
_Atomic(const int *) acip1 = cip; // expected-error {{initializer element is not a compile-time constant}} _Atomic(const int *) acip1 = cip; // expected-error {{initializer element is not a compile-time constant}}
const void *cvp = 0; const void *cvp = 0;
_Atomic(const int *) acip2 = cvp; // expected-error {{initializer element is not a compile-time constant}} _Atomic(const int *) acip2 = cvp; // expected-error {{initializer element is not a compile-time constant}}
#if __STDC_VERSION__ >= 202000L #if __STDC_VERSION__ >= 202311L
// the left operand has an atomic ... version of the nullptr_t type and the // the left operand has an atomic ... version of the nullptr_t type and the
// right operand is a null pointer constant or its type is nullptr_t // right operand is a null pointer constant or its type is nullptr_t
typedef typeof(nullptr) nullptr_t; typedef typeof(nullptr) nullptr_t;
nullptr_t n; nullptr_t n;
_Atomic nullptr_t cn2 = n; // expected-error {{initializer element is not a compile-time constant}} _Atomic nullptr_t cn2 = n; // expected-error {{initializer element is not a compile-time constant}}
_Atomic(int *) aip2 = nullptr; _Atomic(int *) aip2 = nullptr;
#endif // __STDC_VERSION__ >= 202000L #endif // __STDC_VERSION__ >= 202311L
// FIXME: &ai is an address constant, so this should be accepted as an // FIXME: &ai is an address constant, so this should be accepted as an
// initializer, but the bit-cast inserted due to the pointer conversion is // initializer, but the bit-cast inserted due to the pointer conversion is
// tripping up the test for whether the initializer is a constant expression. // tripping up the test for whether the initializer is a constant expression.
// The warning is correct but the error is not. // The warning is correct but the error is not.
_Atomic(int *) aip3 = &ai; /* expected-warning {{incompatible pointer types initializing '_Atomic(int *)' with an expression of type '_Atomic(int) *'}} _Atomic(int *) aip3 = &ai; /* expected-warning {{incompatible pointer types initializing '_Atomic(int *)' with an expression of type '_Atomic(int) *'}}
expected-error {{initializer element is not a compile-time constant}} expected-error {{initializer element is not a compile-time constant}}
*/ */
Show All 15 Lines