llvm-project/clang/test/Sema/knr-def-call.c

// RUN: %clang_cc1 -fsyntax-only -verify %s

// C DR #316, PR 3626.
void f0(a, b, c, d) int a,b,c,d; {}
void t0(void) { 
  f0(1);  // expected-warning{{too few arguments}}
}

void f1(a, b) int a, b; {}
void t1(void) { 
  f1(1, 2, 3); // expected-warning{{too many arguments}}
}

void f2(float); // expected-note{{previous declaration is here}}
void f2(x) float x; { } // expected-warning{{promoted type 'double' of K&R function parameter is not compatible with the parameter type 'float' declared in a previous prototype}}

typedef void (*f3)(void);
f3 t3(int b) { return b? f0 : f1; } // okay
Update tests to use %clang_cc1 instead of 'clang-cc' or 'clang -cc1'. - This is designed to make it obvious that %clang_cc1 is a "test variable" which is substituted. It is '%clang_cc1' instead of '%clang -cc1' because it can be useful to redefine what gets run as 'clang -cc1' (for example, to set a default target). llvm-svn: 91446 2009-12-16 04:14:24 +08:00			`// RUN: %clang_cc1 -fsyntax-only -verify %s`
C99 DR #316 implies that the function parameter types that are known only from a function definition (that does not have a prototype) are only used to determine the compatible with other declarations of that same function. In particular, when referencing the function we pretend as if it does not have a prototype. Implement this behavior, which fixes PR3626. llvm-svn: 65460 2009-02-26 00:33:18 +08:00
			`// C DR #316, PR 3626.`
			`void f0(a, b, c, d) int a,b,c,d; {}`
When calling a function without a prototype for which we have a definition, warn if there are too many/too few function call arguments. llvm-svn: 68318 2009-04-02 23:37:10 +08:00			`void t0(void) {`
			`f0(1); // expected-warning{{too few arguments}}`
			`}`
C99 DR #316 implies that the function parameter types that are known only from a function definition (that does not have a prototype) are only used to determine the compatible with other declarations of that same function. In particular, when referencing the function we pretend as if it does not have a prototype. Implement this behavior, which fixes PR3626. llvm-svn: 65460 2009-02-26 00:33:18 +08:00
			`void f1(a, b) int a, b; {}`
When calling a function without a prototype for which we have a definition, warn if there are too many/too few function call arguments. llvm-svn: 68318 2009-04-02 23:37:10 +08:00			`void t1(void) {`
			`f1(1, 2, 3); // expected-warning{{too many arguments}}`
			`}`
C99 DR #316 implies that the function parameter types that are known only from a function definition (that does not have a prototype) are only used to determine the compatible with other declarations of that same function. In particular, when referencing the function we pretend as if it does not have a prototype. Implement this behavior, which fixes PR3626. llvm-svn: 65460 2009-02-26 00:33:18 +08:00
			`void f2(float); // expected-note{{previous declaration is here}}`
Implement GNU C semantics for K&R function definitions that follow a prototype of the same function, where the promoted parameter types in the K&R definition are not compatible with the types in the prototype. Fixes PR2821. llvm-svn: 66301 2009-03-07 06:43:54 +08:00			`void f2(x) float x; { } // expected-warning{{promoted type 'double' of K&R function parameter is not compatible with the parameter type 'float' declared in a previous prototype}}`
C99 DR #316 implies that the function parameter types that are known only from a function definition (that does not have a prototype) are only used to determine the compatible with other declarations of that same function. In particular, when referencing the function we pretend as if it does not have a prototype. Implement this behavior, which fixes PR3626. llvm-svn: 65460 2009-02-26 00:33:18 +08:00
			`typedef void (*f3)(void);`
			`f3 t3(int b) { return b? f0 : f1; } // okay`