/* RUN: %clang_cc1 -std=c89 -fsyntax-only -verify=expected,c89only -pedantic -Wno-declaration-after-statement -Wno-c11-extensions %s
RUN: %clang_cc1 -std=c89 -fsyntax-only -verify=expected,c89only -pedantic -Wno-declaration-after-statement -Wno-c11-extensions -fno-signed-char %s
RUN: %clang_cc1 -std=c99 -fsyntax-only -verify=expected,c99untilc2x -pedantic -Wno-c11-extensions %s
RUN: %clang_cc1 -std=c11 -fsyntax-only -verify=expected,c99untilc2x -pedantic %s
RUN: %clang_cc1 -std=c17 -fsyntax-only -verify=expected,c99untilc2x -pedantic %s
RUN: %clang_cc1 -std=c2x -fsyntax-only -verify=expected,c2xandup -pedantic %s
*/
/* The following are DRs which do not require tests to demonstrate
* conformance or nonconformance.
*
* WG14 DR001: yes
* Do functions return values by copying?
*
* WG14 DR005: yes
* May a conforming implementation define and recognize a pragma which would
* change the semantics of the language?
*
* WG14 DR008: yes
* Can a conforming C compiler to perform dead-store elimination?
*
* WG14 DR020: yes
* Is a compiler which allows the Relaxed Ref/Def linkage model to be
* considered a conforming compiler?
*
* WG14 DR025: yes
* What is meant by 'representable floating-point value?'
*
* WG14 DR026: yes
* Can a strictly conforming program contain a string literal with '$' or '@'?
*
* WG14 DR033: yes
* Conformance questions around 'shall' violations outside of constraints
* sections
*
* WG14 DR036: yes
* May floating-point constants be represented with more precision than implied
* by its type?
*
* WG14 DR037: yes
* Questions about multibyte characters and Unicode
*
* WG14 DR051: yes
* Question on pointer arithmetic
*
* WG14 DR052: yes
* Editorial corrections
*
* WG14 DR056: yes
* Floating-point representation precision requirements
*
* WG14 DR057: yes
* Is there an integral type for every pointer?
*
* WG14 DR059: yes
* Do types have to be completed?
*
* WG14 DR063: dup 056
* Floating-point representation precision requirements
*
* WG14 DR067: yes
* Integer and integral type confusion
*
* WG14 DR069: yes
* Questions about the representation of integer types
*
* WG14 DR077: yes
* Stability of addresses
*
* WG14 DR080: yes
* Merging of string constants
*
* WG14 DR085: yes
* Returning from main
*
* WG14 DR087: yes
* Order of evaluation
* Note: this DR is covered by C/C11/n1282.c
*
* WG14 DR086: yes
* Object-like macros in system headers
*
* WG14 DR091: yes
* Multibyte encodings
*
* WG14 DR092: dup 060
* Partial initialization of strings
*
* WG14 DR093: yes
* Reservation of identifiers
*/
/* WG14 DR004: yes
* Are multiple definitions of unused identifiers with external linkage
* permitted?
*/
int dr004(void) {return 0;} /* expected-note {{previous definition is here}} */
int dr004(void) {return 1;} /* expected-error {{redefinition of 'dr004'}} */
/* WG14 DR007: yes
* Are declarations of the form struct-or-union identifier ; permitted after
* the identifier tag has already been declared?
*/
struct dr007_a;
struct dr007_a;
struct dr007_a {int a;};
struct dr007_a;
struct dr007_b {int a;};
struct dr007_b;
/* WG14 DR009: no
* Use of typedef names in parameter declarations
*
* FIXME: This should be diagnosed as expecting a declaration specifier instead
* of treated as declaring a parameter of type 'int (*)(dr009_t);'
*/
typedef int dr009_t;
void dr009_f((dr009_t)); /* c99untilc2x-error {{type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int}}
c2xandup-error {{a type specifier is required for all declarations}} */
/* WG14 DR010:
* Is a typedef to an incomplete type legal?
*/
typedef int dr010_t[];
dr010_t dr010_a = {1};
dr010_t dr010_b = {1, 2};
int dr010_c = sizeof(dr010_t); /* expected-error {{invalid application of 'sizeof' to an incomplete type 'dr010_t' (aka 'int[]')}} */
/* WG14 DR011: yes
* Merging of declarations for linked identifier
*
* Note: more of this DR is tested in dr011.c
*
* WG14 DR034: yes
* External declarations in different scopes
*
* Note: DR034 has a question resolved by DR011 and another question where the
* result is UB.
*/
static int dr011_a[]; /* expected-warning {{tentative array definition assumed to have one element}} */
void dr011(void) {
extern int i[];
{
/* a different declaration of the same object */
extern int i[10];
(void)sizeof(i);
_Static_assert(sizeof(i) == 10 * sizeof(int), "fail");
}
(void)sizeof(i); /* expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}} */
extern int dr011_a[10];
(void)sizeof(dr011_a);
_Static_assert(sizeof(dr011_a) == 10 * sizeof(int), "fail");
extern int j[10];
{
extern int j[];
(void)sizeof(j);
_Static_assert(sizeof(j) == 10 * sizeof(int), "fail");
}
}
/* WG14 DR012: yes
* Is it valid to take the address of a dereferenced void pointer?
*/
void dr012(void *p) {
/* The behavior changed between C89 and C99. */
(void)&*p; /* c89only-warning {{ISO C forbids taking the address of an expression of type 'void'}}
c89only-warning {{ISO C does not allow indirection on operand of type 'void *'}} */
}
/* WG14 DR013: yes
* Compatible and composite function types
*/
int dr013(int a[4]);
int dr013(int a[5]);
int dr013(int *a);
struct dr013_t {
struct dr013_t *p;
} dr013_v[sizeof(struct dr013_t)];
/* WG14 DR015: yes
* What is the promoted type of a plain int bit-field?
*/
void dr015(void) {
struct S {
int small_int_bitfield : 16;
unsigned int small_uint_bitfield : 16;
int int_bitfield : 32;
unsigned int uint_bitfield : 32;
} s;
_Static_assert(__builtin_types_compatible_p(__typeof__(+s.small_int_bitfield), int), "fail");
_Static_assert(__builtin_types_compatible_p(__typeof__(+s.small_uint_bitfield), int), "fail");
_Static_assert(__builtin_types_compatible_p(__typeof__(+s.int_bitfield), int), "fail");
_Static_assert(__builtin_types_compatible_p(__typeof__(+s.uint_bitfield), unsigned int), "fail");
}
/* WG14 DR027: yes
* Can there be characters in the character set that are not in the required
* source character set?
*/
#define THIS$AND$THAT(a, b) ((a) + (b)) /* expected-warning 2 {{'$' in identifier}} */
_Static_assert(THIS$AND$THAT(1, 1) == 2, "fail"); /* expected-warning 2 {{'$' in identifier}} */
/* WG14 DR029: no
* Do two types have to have the same tag to be compatible?
* Note: the rule changed in C99 to be different than the resolution to DR029,
* so it's not clear there's value in implementing this DR.
*/
_Static_assert(__builtin_types_compatible_p(struct S { int a; }, union U { int a; }), "fail"); /* expected-error {{static assertion failed due to requirement '__builtin_types_compatible_p(struct S, union U)': fail}} */
/* WG14 DR031: yes
* Can constant expressions overflow?
*/
void dr031(int i) {
switch (i) {
case __INT_MAX__ + 1: break; /* expected-warning {{overflow in expression; result is -2'147'483'648 with type 'int'}} */
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wswitch"
/* Silence the targets which issue:
* warning: overflow converting case value to switch condition type (2147483649 to 18446744071562067969)
*/
case __INT_MAX__ + 2ul: break;
#pragma clang diagnostic pop
case (__INT_MAX__ * 4) / 4: break; /* expected-warning {{overflow in expression; result is -4 with type 'int'}} */
}
}
/* WG14 DR032: no
* Must implementations diagnose extensions to the constant evaluation rules?
*
* This should issue a diagnostic because a constant-expression is a
* conditional-expression, which excludes the comma operator.
*/
int dr032 = (1, 2); /* expected-warning {{left operand of comma operator has no effect}} */
#if __STDC_VERSION__ < 202311L
/* WG14 DR035: partial
* 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 C23}} */
int a(enum b {x, y}); /* expected-warning {{declaration of 'enum b' will not be visible outside of this function}} */
int b; {
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 C23}} */
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
* the closing brace of the function per C89 6.1.2.1.
*/
int test = q; /* expected-error {{use of undeclared identifier 'q'}} */
}
#endif /* __STDC_VERSION__ < 202311L */
/* WG14 DR038: yes
* Questions about argument substitution during macro expansion
*/
#define DR038_X 0x000E
#define DR038_Y 0x0100
#define DR038(a) a
_Static_assert(DR038(DR038_X + DR038_Y) == DR038_X + DR038_Y, "fail");
/* WG14 DR039: yes
* Questions about the "C" locale
*/
_Static_assert(sizeof('a') == sizeof(int), "fail");
/* WG14 DR040: partial
* 9 unrelated questions about C89
*
* Question 6
*/
struct dr040 { /* expected-note {{definition of 'struct dr040' is not complete until the closing '}'}} */
char c;
short s;
int i[__builtin_offsetof(struct dr040, s)]; /* expected-error {{offsetof of incomplete type 'struct dr040'}} */
};
/* WG14 DR043: yes
* On the definition of the NULL macro
*/
void dr043(void) {
#include <stddef.h>
/* NULL has to be an integer constant expression with the value 0, or such an
* expression cast to void *. If it's an integer constant expression other
* than the literal 0 (such as #define NULL 4-4), this would fail to compile
* unless the macro replacement list is properly parenthesized as it would
* expand to: (void)(void *)4-4;
*/
(void)(void *)NULL;
/* If the NULL macro is an integer constant expression with the value 0 and
* it has been cast to void *, ensure that it's also fully parenthesized. If
* it isn't (such as #define NULL (void *)0), this would fail to compile as
* would expand to (void *)0->a; which gives a diagnostic about int not being
* a pointer, instead of((void *)0)->a; which gives a diagnostic about the
* base reference being void and not a structure.
*/
NULL->a; /* expected-error {{member reference base type 'void' is not a structure or union}} */
}
/* WG14 DR044: yes
* On the result of the offsetof macro
*/
void dr044(void) {
#include <stddef.h>
struct S { int a, b; };
/* Ensure that the result of offsetof is usable in a constant expression. */
_Static_assert(offsetof(struct S, b) == sizeof(int), "fail");
}
/* WG14 DR046: yes
* Use of typedef names in parameter declarations
*/
typedef int dr046_t;
int dr046(int dr046_t) { return dr046_t; }
/* WG14 DR047: yes
* Questions about declaration conformance
*/
struct dr047_t; /* expected-note 2 {{forward declaration of 'struct dr047_t'}} */
struct dr047_t *dr047_1(struct dr047_t *p) {return p; }
struct dr047_t *dr047_2(struct dr047_t a[]) {return a; } /* expected-error {{array has incomplete element type 'struct dr047_t'}} */
int *dr047_3(int a2[][]) {return *a2; } /* expected-error {{array has incomplete element type 'int[]'}} */
extern struct dr047_t es1;
extern struct dr047_t es2[1]; /* expected-error {{array has incomplete element type 'struct dr047_t'}} */
/* WG14 DR050: yes
* Do wide string literals implicitly include <stddef.h>?
*/
void dr050(void) {
/* The NULL macro is previously defined because we include <stddef.h> for
* other tests. Undefine the macro to demonstrate that use of a wide string
* literal doesn't magically include the header file.
*/
#undef NULL
(void)L"huttah!";
(void)NULL; /* expected-error {{use of undeclared identifier 'NULL'}} */
}
#if __STDC_VERSION__ < 202311L
/* WG14 DR053: yes
* Accessing a pointer to a function with a prototype through a pointer to
* pointer to function without a prototype
*/
void dr053(void) {
int f(int);
int (*fp1)(int);
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}} */
fp1 = f;
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 C23}} */
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 C23}} */
}
#endif /* __STDC_VERSION__ < 202311L */
/* WG14 DR064: yes
* Null pointer constants
*/
char *dr064_1(int i, int *pi) {
*pi = i;
return 0;
}
char *dr064_2(int i, int *pi) {
return (*pi = i, 0); /* expected-error {{incompatible integer to pointer conversion returning 'int' from a function with result type 'char *'}} */
}
/* WG14 DR068: yes
* 'char' and signed vs unsigned integer types
*/
void dr068(void) {
#include <limits.h>
#if CHAR_MAX == SCHAR_MAX
/* char is signed */
_Static_assert('\xFF' == -1, "fail");
#else
/* char is unsigned */
_Static_assert('\xFF' == 0xFF, "fail");
#endif
}
#if __STDC_VERSION__ < 202311L
/* WG14: DR070: yes
* Interchangeability of function arguments
*
* 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
* not obligated to do anything about it and we make it "just work" via the
* usual conversion rules.
*
* This behavior is specific to functions without prototypes. A function with
* a prototype causes implicit conversions rather than relying on default
* 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 C23}} */
int c; {
}
void dr070_2(void) {
dr070_1(6);
dr070_1(6U); /* Pedantically UB */
}
#endif /* __STDC_VERSION__ < 202311L */
/* WG14 DR071: yes
* Enumerated types
*/
enum dr071_t { foo_A = 0, foo_B = 1, foo_C = 8 };
void dr071(void) {
/* Test that in-range values not present in the enumeration still round-trip
* to the original value.
*/
_Static_assert(100 == (int)(enum dr071_t)100, "fail");
}
/* WG14 DR081: yes
* Left shift operator
*/
void dr081(void) {
/* Demonstrate that we don't crash when left shifting a signed value; that's
* implementation defined behavior.
*/
_Static_assert(-1 << 1 == -2, "fail"); /* expected-warning {{expression is not an integer constant expression; folding it to a constant is a GNU extension}}
expected-note {{left shift of negative value -1}} */
_Static_assert(1 << 3 == 1u << 3u, "fail"); /* Shift of a positive signed value does sensible things. */
}
/* WG14 DR084: yes
* Incomplete type in function declaration
*
* Note: because the situation is UB, we're free to do what we want. We elect
* to accept and require the incomplete type to be completed before the
* function definition.
*/
struct dr084_t; /* expected-note {{forward declaration of 'struct dr084_t'}} */
extern void (*dr084_1)(struct dr084_t);
void dr084_2(struct dr084_t);
void dr084_2(struct dr084_t val) {} /* expected-error {{variable has incomplete type 'struct dr084_t'}} */
/* WG14 DR088: yes
* Compatibility of incomplete types
*/
struct dr088_t_1;
void dr088_f(struct dr088_t_1 *); /* expected-note {{passing argument to parameter here}} */
void dr088_1(void) {
/* Distinct type from the file scope forward declaration. */
struct dr088_t_1;
/* FIXME: this diagnostic could be improved to not be utterly baffling. */
dr088_f((struct dr088_t_1 *)0); /* expected-warning {{incompatible pointer types passing 'struct dr088_t_1 *' to parameter of type 'struct dr088_t_1 *'}} */
}
void dr088_2(struct dr088_t_1 *p) { /* Pointer to incomplete type. */ }
struct dr088_t_1 { int i; }; /* Type is completed. */
void dr088_3(struct dr088_t_1 s) {
/* When passing a pointer to the completed type, is it the same type as the
* incomplete type used in the call declaration?
*/
dr088_2(&s);
}
/* WG14 DR089: yes
* Multiple definitions of macros
*/
#define DR089 object_like /* expected-note {{previous definition is here}} */
#define DR089(argument) function_like /* expected-warning {{'DR089' macro redefined}} */
/* WG14 DR095: yes
* Is initialization as constrained as assignment?
*/
void dr095(void) {
/* Ensure that type compatibility constraints on assignment are also honored
* for initializations.
*/
struct One {
int a;
} one;
struct Two {
float f;
} two = one; /* expected-error {{initializing 'struct Two' with an expression of incompatible type 'struct One'}} */
two = one; /* expected-error {{assigning to 'struct Two' from incompatible type 'struct One'}} */
}
/* WG14 DR096: yes
* Arrays of incomplete types
*/
void dr096(void) {
typedef void func_type(void);
func_type array_funcs[10]; /* expected-error {{'array_funcs' declared as array of functions of type 'func_type' (aka 'void (void)')}} */
void array_void[10]; /* expected-error {{array has incomplete element type 'void'}} */
struct S; /* expected-note {{forward declaration of 'struct S'}} */
struct S s[10]; /* expected-error {{array has incomplete element type 'struct S'}} */
union U; /* expected-note {{forward declaration of 'union U'}} */
union U u[10]; /* expected-error {{array has incomplete element type 'union U'}} */
union U { int i; };
int never_completed_incomplete_array[][]; /* expected-error {{array has incomplete element type 'int[]'}} */
extern int completed_later[][]; /* expected-error {{array has incomplete element type 'int[]'}} */
extern int completed_later[10][10];
}
/* WG14 DR098: yes
* Pre/post increment/decrement of function or incomplete types
*/
void dr098(void) {
typedef void func_type(void);
func_type fp;
struct incomplete *incomplete_ptr;
++fp; /* expected-error {{cannot increment value of type 'func_type' (aka 'void (void)')}} */
fp++; /* expected-error {{cannot increment value of type 'func_type' (aka 'void (void)')}} */
--fp; /* expected-error {{cannot decrement value of type 'func_type' (aka 'void (void)')}} */
fp--; /* expected-error {{cannot decrement value of type 'func_type' (aka 'void (void)')}} */
(*incomplete_ptr)++; /* expected-error {{cannot increment value of type 'struct incomplete'}} */
++(*incomplete_ptr); /* expected-error {{cannot increment value of type 'struct incomplete'}} */
(*incomplete_ptr)--; /* expected-error {{cannot decrement value of type 'struct incomplete'}} */
--(*incomplete_ptr); /* expected-error {{cannot decrement value of type 'struct incomplete'}} */
}
Codebase Browser
llvm