X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=format_check.c;h=06e0f7a5705971031d1e3d1fa9b0da3629207db9;hb=b63886b188eeedf36d8df12df3fe1f5fd90818d4;hp=d5ea272c1fb7225ed6a4e4e7877017d13008c5b1;hpb=fe9aa8a20c3fc2be53a9486916d4d25db76e7368;p=cparser

diff --git a/format_check.c b/format_check.c
index d5ea272..06e0f7a 100644
--- a/format_check.c
+++ b/format_check.c
@@ -23,6 +23,7 @@
 #include "format_check.h"
 #include "symbol_t.h"
 #include "ast_t.h"
+#include "entity_t.h"
 #include "diagnostic.h"
 #include "types.h"
 #include "type_t.h"
@@ -148,15 +149,12 @@ static bool atend(vchar_t *self) {
 static void check_format_arguments(const call_argument_t *arg, unsigned idx_fmt,
 		unsigned idx_param)
 {
-	const call_argument_t *fmt_arg;
-	unsigned idx = 0;
-
 	/* find format arg */
-	for(idx = 0; idx < idx_fmt; ++idx)
+	unsigned idx = 0;
+	for (; idx < idx_fmt; ++idx)
 		arg = arg->next;
-	fmt_arg = arg;
 
-	const expression_t *fmt_expr = fmt_arg->expression;
+	const expression_t *fmt_expr = arg->expression;
 	if (fmt_expr->kind == EXPR_UNARY_CAST_IMPLICIT) {
 		fmt_expr = fmt_expr->unary.value;
 	}
@@ -182,7 +180,8 @@ static void check_format_arguments(const call_argument_t *arg, unsigned idx_fmt,
 		arg = arg->next;
 
 	const source_position_t *pos = &fmt_expr->base.source_position;
-	unsigned fmt = vchar.first(&vchar);
+	unsigned fmt     = vchar.first(&vchar);
+	unsigned num_fmt = 0;
 	for (; fmt != '\0'; fmt = vchar.next(&vchar)) {
 		if (fmt != '%')
 			continue;
@@ -191,6 +190,8 @@ static void check_format_arguments(const call_argument_t *arg, unsigned idx_fmt,
 		if (fmt == '%')
 			continue;
 
+		++num_fmt;
+
 		format_flags_t fmt_flags = FMT_FLAG_NONE;
 		if (fmt == '0') {
 			fmt = vchar.next(&vchar);
@@ -223,14 +224,14 @@ static void check_format_arguments(const call_argument_t *arg, unsigned idx_fmt,
 
 					case ' ':
 						if (fmt_flags & FMT_FLAG_PLUS) {
-							warningf(pos, "' ' is overridden by prior '+' in conversion specification");
+							warningf(pos, "' ' is overridden by prior '+' in conversion specification %u", num_fmt);
 						}
 						flag = FMT_FLAG_SPACE;
 						break;
 
 					case '+':
 						if (fmt_flags & FMT_FLAG_SPACE) {
-							warningf(pos, "'+' overrides prior ' ' in conversion specification");
+							warningf(pos, "'+' overrides prior ' ' in conversion specification %u", num_fmt);
 						}
 						flag = FMT_FLAG_PLUS;
 						break;
@@ -238,7 +239,7 @@ static void check_format_arguments(const call_argument_t *arg, unsigned idx_fmt,
 					default: goto break_fmt_flags;
 				}
 				if (fmt_flags & flag) {
-					warningf(pos, "repeated flag '%c' in conversion specification", (char)fmt);
+					warningf(pos, "repeated flag '%c' in conversion specification %u", (char)fmt, num_fmt);
 				}
 				fmt_flags |= flag;
 				fmt = vchar.next(&vchar);
@@ -247,13 +248,14 @@ break_fmt_flags:
 
 			/* minimum field width */
 			if (fmt == '*') {
+				fmt = vchar.next(&vchar);
 				if (arg == NULL) {
-					warningf(pos, "missing argument for '*' field width in conversion specification");
+					warningf(pos, "missing argument for '*' field width in conversion specification %u", num_fmt);
 					return;
 				}
 				const type_t *const arg_type = arg->expression->base.type;
 				if (arg_type != type_int) {
-					warningf(pos, "argument for '*' field width in conversion specification is not an 'int', but an '%T'", arg_type);
+					warningf(pos, "argument for '*' field width in conversion specification %u is not an 'int', but an '%T'", num_fmt, arg_type);
 				}
 				arg = arg->next;
 			} else {
@@ -267,13 +269,14 @@ break_fmt_flags:
 		if (fmt == '.') {
 			fmt = vchar.next(&vchar);
 			if (fmt == '*') {
+				fmt = vchar.next(&vchar);
 				if (arg == NULL) {
-					warningf(pos, "missing argument for '*' precision in conversion specification");
+					warningf(pos, "missing argument for '*' precision in conversion specification %u", num_fmt);
 					return;
 				}
 				const type_t *const arg_type = arg->expression->base.type;
 				if (arg_type != type_int) {
-					warningf(pos, "argument for '*' precision in conversion specification is not an 'int', but an '%T'", arg_type);
+					warningf(pos, "argument for '*' precision in conversion specification %u is not an 'int', but an '%T'", num_fmt, arg_type);
 				}
 				arg = arg->next;
 			} else {
@@ -356,7 +359,7 @@ break_fmt_flags:
 			break;
 		}
 
-		const type_t      *expected_type;
+		type_t            *expected_type;
 		type_qualifiers_t  expected_qual = TYPE_QUALIFIER_NONE;
 		format_flags_t     allowed_flags;
 		switch (fmt) {
@@ -387,7 +390,6 @@ break_fmt_flags:
 			case 'x':
 				allowed_flags = FMT_FLAG_MINUS | FMT_FLAG_HASH | FMT_FLAG_ZERO;
 				goto eval_fmt_mod_unsigned;
-				break;
 
 			case 'u':
 				allowed_flags = FMT_FLAG_MINUS | FMT_FLAG_ZERO;
@@ -461,7 +463,7 @@ eval_fmt_mod_unsigned:
 				}
 				expected_type = type_wchar_t_ptr;
 				expected_qual = TYPE_QUALIFIER_CONST;
-				allowed_flags = FMT_FLAG_NONE;
+				allowed_flags = FMT_FLAG_MINUS;
 				break;
 
 			case 's':
@@ -475,7 +477,7 @@ eval_fmt_mod_unsigned:
 						goto next_arg;
 				}
 				expected_qual = TYPE_QUALIFIER_CONST;
-				allowed_flags = FMT_FLAG_NONE;
+				allowed_flags = FMT_FLAG_MINUS;
 				break;
 
 			case 'p':
@@ -506,13 +508,23 @@ eval_fmt_mod_unsigned:
 				break;
 
 			default:
-				warningf(pos, "encountered unknown conversion specifier '%%%C'", (wint_t)fmt);
+				warningf(pos, "encountered unknown conversion specifier '%%%C' at position %u", (wint_t)fmt, num_fmt);
 				goto next_arg;
 		}
 
-		if ((fmt_flags & ~allowed_flags) != 0) {
-			/* TODO better warning message text */
-			warningf(pos, "invalid format flags in conversion specification");
+		format_flags_t wrong_flags = fmt_flags & ~allowed_flags;
+		if (wrong_flags != 0) {
+			char wrong[8];
+			int idx = 0;
+			if (wrong_flags & FMT_FLAG_HASH)  wrong[idx++] = '#';
+			if (wrong_flags & FMT_FLAG_ZERO)  wrong[idx++] = '0';
+			if (wrong_flags & FMT_FLAG_MINUS) wrong[idx++] = '-';
+			if (wrong_flags & FMT_FLAG_SPACE) wrong[idx++] = ' ';
+			if (wrong_flags & FMT_FLAG_PLUS)  wrong[idx++] = '+';
+			if (wrong_flags & FMT_FLAG_TICK)  wrong[idx++] = '\'';
+			wrong[idx] = '\0';
+
+			warningf(pos, "invalid format flags \"%s\" in conversion specification %%%c at position %u", wrong, fmt, num_fmt);
 		}
 
 		if (arg == NULL) {
@@ -521,11 +533,12 @@ eval_fmt_mod_unsigned:
 		}
 
 		{	/* create a scope here to prevent warning about the jump to next_arg */
-			type_t *const arg_type = arg->expression->base.type;
-			if (is_type_pointer(expected_type)) {
-				type_t *const arg_skip = skip_typeref(arg_type);
+			type_t *const arg_type           = arg->expression->base.type;
+			type_t *const arg_skip           = skip_typeref(arg_type);
+			type_t *const expected_type_skip = skip_typeref(expected_type);
+			if (is_type_pointer(expected_type_skip)) {
 				if (is_type_pointer(arg_skip)) {
-					type_t *const exp_to = skip_typeref(expected_type->pointer.points_to);
+					type_t *const exp_to = skip_typeref(expected_type_skip->pointer.points_to);
 					type_t *const arg_to = skip_typeref(arg_skip->pointer.points_to);
 					if ((arg_to->base.qualifiers & ~expected_qual) == 0 &&
 						get_unqualified_type(arg_to) == exp_to) {
@@ -533,14 +546,14 @@ eval_fmt_mod_unsigned:
 					}
 				}
 			} else {
-				if (get_unqualified_type(skip_typeref(arg_type)) == expected_type) {
+				if (get_unqualified_type(arg_skip) == expected_type_skip) {
 					goto next_arg;
 				}
 			}
-			if (is_type_valid(arg_type)) {
+			if (is_type_valid(arg_skip)) {
 				warningf(pos,
-					"argument type '%T' does not match conversion specifier '%%%s%c'",
-					arg_type, get_length_modifier_name(fmt_mod), (char)fmt);
+					"argument type '%T' does not match conversion specifier '%%%s%c' at position %u",
+					arg_type, get_length_modifier_name(fmt_mod), (char)fmt, num_fmt);
 			}
 		}
 next_arg:
@@ -550,7 +563,14 @@ next_arg:
 		warningf(pos, "format string contains NUL");
 	}
 	if (arg != NULL) {
-		warningf(pos, "too many arguments for format string");
+		unsigned num_args = num_fmt;
+		while (arg != NULL) {
+			++num_args;
+			arg = arg->next;
+		}
+		warningf(pos, "%u argument%s but only %u format string%s",
+			num_args, num_args != 1 ? "s" : "",
+			num_fmt, num_fmt != 1 ? "s" : "");
 	}
 }
 
@@ -617,8 +637,8 @@ void check_format(const call_expression_t *const call)
 	if (func_expr->kind != EXPR_REFERENCE)
 		return;
 
-	const declaration_t   *const decl = func_expr->reference.declaration;
-	const call_argument_t *      arg  = call->arguments;
+	const entity_t        *const entity = func_expr->reference.entity;
+	const call_argument_t *      arg    = call->arguments;
 
 	if(false) {
 		/* the declaration has a GNU format attribute, check it */
@@ -627,7 +647,7 @@ void check_format(const call_expression_t *const call)
 		 * For some functions we always check the format, even if it was not specified.
 		 * This allows to check format even in MS mode or without header included.
 		 */
-		const char            *const name = decl->symbol->string;
+		const char *const name = entity->base.symbol->string;
 		for(size_t i = 0; i < sizeof(builtin_table) / sizeof(builtin_table[0]); ++i) {
 			if(strcmp(name, builtin_table[i].name) == 0) {
 				if(builtin_table[i].fmt_kind == FORMAT_PRINTF) {