// RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -Wformat-non-iso -Wformat-pedantic -fblocks %s
// RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -Wformat-non-iso -fblocks -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -Wformat-non-iso -Wformat-pedantic -fblocks -std=c++11 %s
#include <stdarg.h>
extern "C" {
extern int scanf(const char *restrict, ...);
extern int printf(const char *restrict, ...);
extern int vprintf(const char *restrict, va_list);
}
void f(char **sp, float *fp) {
scanf("%as", sp);
#if __cplusplus <= 199711L
// expected-warning@-2 {{'a' length modifier is not supported by ISO C}}
#else
// expected-warning@-4 {{format specifies type 'float *' but the argument has type 'char **'}}
#endif
printf("%a", 1.0);
scanf("%afoobar", fp);
}
void g() {
printf("%ls", "foo"); // expected-warning{{format specifies type 'wchar_t *' but the argument has type 'const char *'}}
}
// Test that we properly handle format_idx on C++ members.
class Foo {
public:
const char *gettext(const char *fmt) __attribute__((format_arg(2)));
int scanf(const char *, ...) __attribute__((format(scanf, 2, 3)));
int printf(const char *, ...) __attribute__((format(printf, 2, 3)));
int printf2(const char *, ...);
static const char *gettext_static(const char *fmt) __attribute__((format_arg(1)));
static int printf_static(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
};
void h(int *i) {
Foo foo;
foo.scanf("%d"); // expected-warning{{more '%' conversions than data arguments}}
foo.printf("%d", i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}}
Foo::printf_static("%d", i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}}
printf(foo.gettext("%d"), i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}}
printf(Foo::gettext_static("%d"), i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}}
}
// Test handling __null for format string literal checking.
extern "C" {
int test_null_format(const char *format, ...) __attribute__((__format__ (__printf__, 1, 2)));
#if __cplusplus >= 201103L
// expected-note@-2 {{candidate function not viable: no known conversion from 'bool' to 'const char *' for 1st argument}}
#endif
}
void rdar8269537(const char *f)
{
test_null_format(false);
#if __cplusplus <= 199711L
// expected-warning@-2 {{null from a constant boolean}}
#else
// expected-error@-4 {{no matching function for call to 'test_null_format'}}
#endif
test_null_format(0); // no-warning
test_null_format(__null); // no-warning
test_null_format(f); // expected-warning {{not a string literal}}
// expected-note@-1{{treat the string as an argument to avoid this}}
}
int Foo::printf(const char *fmt, ...) {
va_list ap;
va_start(ap,fmt);
const char * const format = fmt;
vprintf(format, ap); // no-warning
const char *format2 = fmt;
vprintf(format2, ap); // expected-warning{{format string is not a string literal}}
return 0;
}
int Foo::printf2(const char *fmt, ...) {
va_list ap;
va_start(ap,fmt);
vprintf(fmt, ap); // expected-warning{{format string is not a string literal}}
return 0;
}
namespace Templates {
template<typename T>
void my_uninstantiated_print(const T &arg) {
printf("%d", arg); // no-warning
}
template<typename T>
void my_print(const T &arg) {
printf("%d", arg); // expected-warning {{format specifies type 'int' but the argument has type 'const char *'}}
}
void use_my_print() {
my_print("abc"); // expected-note {{requested here}}
}
template<typename T>
class UninstantiatedPrinter {
public:
static void print(const T &arg) {
printf("%d", arg); // no-warning
}
};
template<typename T>
class Printer {
void format(const char *fmt, ...) __attribute__((format(printf,2,3)));
public:
void print(const T &arg) {
format("%d", arg); // expected-warning {{format specifies type 'int' but the argument has type 'const char *'}}
}
};
void use_class(Printer<const char *> &p) {
p.print("abc"); // expected-note {{requested here}}
}
extern void (^block_print)(const char * format, ...) __attribute__((format(printf, 1, 2)));
template<typename T>
void uninstantiated_call_block_print(const T &arg) {
block_print("%d", arg); // no-warning
}
template<typename T>
void call_block_print(const T &arg) {
block_print("%d", arg); // expected-warning {{format specifies type 'int' but the argument has type 'const char *'}}
}
void use_block_print() {
call_block_print("abc"); // expected-note {{requested here}}
}
}
namespace implicit_this_tests {
struct t {
void func1(const char *, ...) __attribute__((__format__(printf, 1, 2))); // expected-error {{format attribute cannot specify the implicit this argument as the format string}}
void (*func2)(const char *, ...) __attribute__((__format__(printf, 1, 2)));
static void (*func3)(const char *, ...) __attribute__((__format__(printf, 1, 2)));
static void func4(const char *, ...) __attribute__((__format__(printf, 1, 2)));
};
void f() {
t t1;
t1.func2("Hello %s"); // expected-warning {{more '%' conversions than data arguments}}
t::func3("Hello %s"); // expected-warning {{more '%' conversions than data arguments}}
t::func4("Hello %s"); // expected-warning {{more '%' conversions than data arguments}}
}
}
#if __cplusplus >= 201103L
namespace evaluated {
constexpr const char *basic() {
return
"%s %d"; // expected-note {{format string is defined here}}
}
constexpr const char *correct_fmt() {
return
"%d %d";
}
constexpr const char *string_linebreak() {
return
"%d %d"
"%d %s"; // expected-note {{format string is defined here}}
}
/*non-constexpr*/ const char *not_literal() {
return
"%d %d"
"%d %s";
}
constexpr const char *inner_call() {
return "%d %s"; // expected-note {{format string is defined here}}
}
constexpr const char *wrap_constexpr() {
return inner_call();
}
void f() {
printf(basic(), 1, 2); // expected-warning {{format specifies type 'char *' but the argument has type 'int'}}
printf(correct_fmt(), 1, 2);
printf(string_linebreak(), 1, 2, 3, 4); // expected-warning {{format specifies type 'char *' but the argument has type 'int'}}
printf(not_literal(), 1, 2, 3, 4); // expected-warning {{format string is not a string literal}}
printf(wrap_constexpr(), 1, 2); // expected-warning {{format specifies type 'char *' but the argument has type 'int'}}
constexpr const char *fmt {"%d%d"};
printf(fmt, 1, 1); // no-warning
constexpr const char *fmt2 {"%d"}; // expected-note{{format string is defined here}}
printf(fmt2, "oops"); // expected-warning{{format specifies type 'int' but the argument has type}}
}
}
namespace ScopedEnumerations {
enum class Scoped1 { One };
enum class Scoped2 : unsigned short { Two };
void f(Scoped1 S1, Scoped2 S2) {
printf("%hhd", S1); // expected-warning {{format specifies type 'char' but the argument has type 'Scoped1'}}
printf("%hd", S1); // expected-warning {{format specifies type 'short' but the argument has type 'Scoped1'}}
printf("%d", S1); // expected-warning {{format specifies type 'int' but the argument has type 'Scoped1'}}
printf("%hhd", S2); // expected-warning {{format specifies type 'char' but the argument has type 'Scoped2'}}
printf("%hd", S2); // expected-warning {{format specifies type 'short' but the argument has type 'Scoped2'}}
printf("%d", S2); // expected-warning {{format specifies type 'int' but the argument has type 'Scoped2'}}
scanf("%hhd", &S1); // expected-warning {{format specifies type 'char *' but the argument has type 'Scoped1 *'}}
scanf("%hd", &S1); // expected-warning {{format specifies type 'short *' but the argument has type 'Scoped1 *'}}
scanf("%d", &S1); // expected-warning {{format specifies type 'int *' but the argument has type 'Scoped1 *'}}
scanf("%hhd", &S2); // expected-warning {{format specifies type 'char *' but the argument has type 'Scoped2 *'}}
scanf("%hd", &S2); // expected-warning {{format specifies type 'short *' but the argument has type 'Scoped2 *'}}
scanf("%d", &S2); // expected-warning {{format specifies type 'int *' but the argument has type 'Scoped2 *'}}
}
}
#endif
Codebase Browser
llvm