1 /* Check calls to formatted I/O functions (-Wformat).
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
29 #include "diagnostic.h"
30 #include "langhooks.h"
32 /* Set format warning options according to a -Wformat=n option. */
38 warn_format
= setting
;
39 warn_format_y2k
= setting
;
40 warn_format_extra_args
= setting
;
41 warn_format_zero_length
= setting
;
44 warn_format_nonliteral
= setting
;
45 warn_format_security
= setting
;
47 /* Make sure not to disable -Wnonnull if -Wformat=0 is specified. */
49 warn_nonnull
= setting
;
53 /* Handle attributes associated with format checking. */
55 /* This must be in the same order as format_types, with format_type_error
57 enum format_type
{ printf_format_type
, scanf_format_type
,
58 strftime_format_type
, strfmon_format_type
,
61 typedef struct function_format_info
63 enum format_type format_type
; /* type of format (printf, scanf, etc.) */
64 unsigned HOST_WIDE_INT format_num
; /* number of format argument */
65 unsigned HOST_WIDE_INT first_arg_num
; /* number of first arg (zero for varargs) */
66 } function_format_info
;
68 static bool decode_format_attr
PARAMS ((tree
,
69 function_format_info
*, int));
70 static enum format_type decode_format_type
PARAMS ((const char *));
72 /* Handle a "format" attribute; arguments as in
73 struct attribute_spec.handler. */
75 handle_format_attribute (node
, name
, args
, flags
, no_add_attrs
)
77 tree name ATTRIBUTE_UNUSED
;
83 function_format_info info
;
85 unsigned HOST_WIDE_INT arg_num
;
87 if (!decode_format_attr (args
, &info
, 0))
93 /* If a parameter list is specified, verify that the format_num
94 argument is actually a string, in case the format attribute
96 argument
= TYPE_ARG_TYPES (type
);
99 for (arg_num
= 1; argument
!= 0 && arg_num
!= info
.format_num
;
100 ++arg_num
, argument
= TREE_CHAIN (argument
))
104 || TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
105 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument
)))
108 if (!(flags
& (int) ATTR_FLAG_BUILT_IN
))
109 error ("format string arg not a string type");
110 *no_add_attrs
= true;
114 else if (info
.first_arg_num
!= 0)
116 /* Verify that first_arg_num points to the last arg,
119 arg_num
++, argument
= TREE_CHAIN (argument
);
121 if (arg_num
!= info
.first_arg_num
)
123 if (!(flags
& (int) ATTR_FLAG_BUILT_IN
))
124 error ("args to be formatted is not '...'");
125 *no_add_attrs
= true;
131 if (info
.format_type
== strftime_format_type
&& info
.first_arg_num
!= 0)
133 error ("strftime formats cannot format arguments");
134 *no_add_attrs
= true;
142 /* Handle a "format_arg" attribute; arguments as in
143 struct attribute_spec.handler. */
145 handle_format_arg_attribute (node
, name
, args
, flags
, no_add_attrs
)
147 tree name ATTRIBUTE_UNUSED
;
153 tree format_num_expr
= TREE_VALUE (args
);
154 unsigned HOST_WIDE_INT format_num
;
155 unsigned HOST_WIDE_INT arg_num
;
158 /* Strip any conversions from the first arg number and verify it
160 while (TREE_CODE (format_num_expr
) == NOP_EXPR
161 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
162 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
163 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
165 if (TREE_CODE (format_num_expr
) != INTEGER_CST
166 || TREE_INT_CST_HIGH (format_num_expr
) != 0)
168 error ("format string has invalid operand number");
169 *no_add_attrs
= true;
173 format_num
= TREE_INT_CST_LOW (format_num_expr
);
175 /* If a parameter list is specified, verify that the format_num
176 argument is actually a string, in case the format attribute
178 argument
= TYPE_ARG_TYPES (type
);
181 for (arg_num
= 1; argument
!= 0 && arg_num
!= format_num
;
182 ++arg_num
, argument
= TREE_CHAIN (argument
))
186 || TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
187 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument
)))
190 if (!(flags
& (int) ATTR_FLAG_BUILT_IN
))
191 error ("format string arg not a string type");
192 *no_add_attrs
= true;
197 if (TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
198 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
201 if (!(flags
& (int) ATTR_FLAG_BUILT_IN
))
202 error ("function does not return string type");
203 *no_add_attrs
= true;
211 /* Decode the arguments to a "format" attribute into a function_format_info
212 structure. It is already known that the list is of the right length.
213 If VALIDATED_P is true, then these attributes have already been validated
214 and this function will abort if they are erroneous; if false, it
215 will give an error message. Returns true if the attributes are
216 successfully decoded, false otherwise. */
219 decode_format_attr (args
, info
, validated_p
)
221 function_format_info
*info
;
224 tree format_type_id
= TREE_VALUE (args
);
225 tree format_num_expr
= TREE_VALUE (TREE_CHAIN (args
));
226 tree first_arg_num_expr
227 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args
)));
229 if (TREE_CODE (format_type_id
) != IDENTIFIER_NODE
)
233 error ("unrecognized format specifier");
238 const char *p
= IDENTIFIER_POINTER (format_type_id
);
240 info
->format_type
= decode_format_type (p
);
242 if (info
->format_type
== format_type_error
)
246 warning ("`%s' is an unrecognized format function type", p
);
251 /* Strip any conversions from the string index and first arg number
252 and verify they are constants. */
253 while (TREE_CODE (format_num_expr
) == NOP_EXPR
254 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
255 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
256 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
258 while (TREE_CODE (first_arg_num_expr
) == NOP_EXPR
259 || TREE_CODE (first_arg_num_expr
) == CONVERT_EXPR
260 || TREE_CODE (first_arg_num_expr
) == NON_LVALUE_EXPR
)
261 first_arg_num_expr
= TREE_OPERAND (first_arg_num_expr
, 0);
263 if (TREE_CODE (format_num_expr
) != INTEGER_CST
264 || TREE_INT_CST_HIGH (format_num_expr
) != 0
265 || TREE_CODE (first_arg_num_expr
) != INTEGER_CST
266 || TREE_INT_CST_HIGH (first_arg_num_expr
) != 0)
270 error ("format string has invalid operand number");
274 info
->format_num
= TREE_INT_CST_LOW (format_num_expr
);
275 info
->first_arg_num
= TREE_INT_CST_LOW (first_arg_num_expr
);
276 if (info
->first_arg_num
!= 0 && info
->first_arg_num
<= info
->format_num
)
280 error ("format string arg follows the args to be formatted");
287 /* Check a call to a format function against a parameter list. */
289 /* The meaningfully distinct length modifiers for format checking recognized
306 /* The standard versions in which various format features appeared. */
307 enum format_std_version
311 STD_C9L
, /* C99, but treat as C89 if -Wno-long-long. */
316 /* The C standard version C++ is treated as equivalent to
317 or inheriting from, for the purpose of format features supported. */
318 #define CPLUSPLUS_STD_VER STD_C94
319 /* The C standard version we are checking formats against when pedantic. */
320 #define C_STD_VER ((int)(c_language == clk_cplusplus \
321 ? CPLUSPLUS_STD_VER \
324 : (flag_isoc94 ? STD_C94 : STD_C89))))
325 /* The name to give to the standard version we are warning about when
326 pedantic. FEATURE_VER is the version in which the feature warned out
327 appeared, which is higher than C_STD_VER. */
328 #define C_STD_NAME(FEATURE_VER) (c_language == clk_cplusplus \
330 : ((FEATURE_VER) == STD_EXT \
333 /* Adjust a C standard version, which may be STD_C9L, to account for
334 -Wno-long-long. Returns other standard versions unchanged. */
335 #define ADJ_STD(VER) ((int)((VER) == STD_C9L \
336 ? (warn_long_long ? STD_C99 : STD_C89) \
339 /* Flags that may apply to a particular kind of format checked by GCC. */
342 /* This format converts arguments of types determined by the
344 FMT_FLAG_ARG_CONVERT
= 1,
345 /* The scanf allocation 'a' kludge applies to this format kind. */
346 FMT_FLAG_SCANF_A_KLUDGE
= 2,
347 /* A % during parsing a specifier is allowed to be a modified % rather
348 that indicating the format is broken and we are out-of-sync. */
349 FMT_FLAG_FANCY_PERCENT_OK
= 4,
350 /* With $ operand numbers, it is OK to reference the same argument more
352 FMT_FLAG_DOLLAR_MULTIPLE
= 8,
353 /* This format type uses $ operand numbers (strfmon doesn't). */
354 FMT_FLAG_USE_DOLLAR
= 16,
355 /* Zero width is bad in this type of format (scanf). */
356 FMT_FLAG_ZERO_WIDTH_BAD
= 32,
357 /* Empty precision specification is OK in this type of format (printf). */
358 FMT_FLAG_EMPTY_PREC_OK
= 64,
359 /* Gaps are allowed in the arguments with $ operand numbers if all
360 arguments are pointers (scanf). */
361 FMT_FLAG_DOLLAR_GAP_POINTER_OK
= 128
362 /* Not included here: details of whether width or precision may occur
363 (controlled by width_char and precision_char); details of whether
364 '*' can be used for these (width_type and precision_type); details
365 of whether length modifiers can occur (length_char_specs). */
369 /* Structure describing a length modifier supported in format checking, and
370 possibly a doubled version such as "hh". */
373 /* Name of the single-character length modifier. */
374 const char *const name
;
375 /* Index into a format_char_info.types array. */
376 const enum format_lengths index
;
377 /* Standard version this length appears in. */
378 const enum format_std_version std
;
379 /* Same, if the modifier can be repeated, or NULL if it can't. */
380 const char *const double_name
;
381 const enum format_lengths double_index
;
382 const enum format_std_version double_std
;
383 } format_length_info
;
386 /* Structure describing the combination of a conversion specifier
387 (or a set of specifiers which act identically) and a length modifier. */
390 /* The standard version this combination of length and type appeared in.
391 This is only relevant if greater than those for length and type
392 individually; otherwise it is ignored. */
393 enum format_std_version std
;
394 /* The name to use for the type, if different from that generated internally
395 (e.g., "signed size_t"). */
397 /* The type itself. */
399 } format_type_detail
;
402 /* Macros to fill out tables of these. */
403 #define BADLEN { 0, NULL, NULL }
404 #define NOLENGTHS { BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
407 /* Structure describing a format conversion specifier (or a set of specifiers
408 which act identically), and the length modifiers used with it. */
411 const char *const format_chars
;
412 const int pointer_count
;
413 const enum format_std_version std
;
414 /* Types accepted for each length modifier. */
415 const format_type_detail types
[FMT_LEN_MAX
];
416 /* List of other modifier characters allowed with these specifiers.
417 This lists flags, and additionally "w" for width, "p" for precision
418 (right precision, for strfmon), "#" for left precision (strfmon),
419 "a" for scanf "a" allocation extension (not applicable in C99 mode),
420 "*" for scanf suppression, and "E" and "O" for those strftime
422 const char *const flag_chars
;
423 /* List of additional flags describing these conversion specifiers.
424 "c" for generic character pointers being allowed, "2" for strftime
425 two digit year formats, "3" for strftime formats giving two digit
426 years in some locales, "4" for "2" which becomes "3" with an "E" modifier,
427 "o" if use of strftime "O" is a GNU extension beyond C99,
428 "W" if the argument is a pointer which is dereferenced and written into,
429 "R" if the argument is a pointer which is dereferenced and read from,
430 "i" for printf integer formats where the '0' flag is ignored with
431 precision, and "[" for the starting character of a scanf scanset. */
432 const char *const flags2
;
436 /* Structure describing a flag accepted by some kind of format. */
439 /* The flag character in question (0 for end of array). */
441 /* Zero if this entry describes the flag character in general, or a
442 nonzero character that may be found in flags2 if it describes the
443 flag when used with certain formats only. If the latter, only
444 the first such entry found that applies to the current conversion
445 specifier is used; the values of `name' and `long_name' it supplies
446 will be used, if non-NULL and the standard version is higher than
447 the unpredicated one, for any pedantic warning. For example, 'o'
448 for strftime formats (meaning 'O' is an extension over C99). */
450 /* Nonzero if the next character after this flag in the format should
451 be skipped ('=' in strfmon), zero otherwise. */
452 const int skip_next_char
;
453 /* The name to use for this flag in diagnostic messages. For example,
454 N_("`0' flag"), N_("field width"). */
455 const char *const name
;
456 /* Long name for this flag in diagnostic messages; currently only used for
457 "ISO C does not support ...". For example, N_("the `I' printf flag"). */
458 const char *const long_name
;
459 /* The standard version in which it appeared. */
460 const enum format_std_version std
;
464 /* Structure describing a combination of flags that is bad for some kind
468 /* The first flag character in question (0 for end of array). */
469 const int flag_char1
;
470 /* The second flag character. */
471 const int flag_char2
;
472 /* Nonzero if the message should say that the first flag is ignored with
473 the second, zero if the combination should simply be objected to. */
475 /* Zero if this entry applies whenever this flag combination occurs,
476 a nonzero character from flags2 if it only applies in some
477 circumstances (e.g. 'i' for printf formats ignoring 0 with precision). */
482 /* Structure describing a particular kind of format processed by GCC. */
485 /* The name of this kind of format, for use in diagnostics. Also
486 the name of the attribute (without preceding and following __). */
487 const char *const name
;
488 /* Specifications of the length modifiers accepted; possibly NULL. */
489 const format_length_info
*const length_char_specs
;
490 /* Details of the conversion specification characters accepted. */
491 const format_char_info
*const conversion_specs
;
492 /* String listing the flag characters that are accepted. */
493 const char *const flag_chars
;
494 /* String listing modifier characters (strftime) accepted. May be NULL. */
495 const char *const modifier_chars
;
496 /* Details of the flag characters, including pseudo-flags. */
497 const format_flag_spec
*const flag_specs
;
498 /* Details of bad combinations of flags. */
499 const format_flag_pair
*const bad_flag_pairs
;
500 /* Flags applicable to this kind of format. */
502 /* Flag character to treat a width as, or 0 if width not used. */
503 const int width_char
;
504 /* Flag character to treat a left precision (strfmon) as,
505 or 0 if left precision not used. */
506 const int left_precision_char
;
507 /* Flag character to treat a precision (for strfmon, right precision) as,
508 or 0 if precision not used. */
509 const int precision_char
;
510 /* If a flag character has the effect of suppressing the conversion of
511 an argument ('*' in scanf), that flag character, otherwise 0. */
512 const int suppression_char
;
513 /* Flag character to treat a length modifier as (ignored if length
514 modifiers not used). Need not be placed in flag_chars for conversion
515 specifiers, but is used to check for bad combinations such as length
516 modifier with assignment suppression in scanf. */
517 const int length_code_char
;
518 /* Pointer to type of argument expected if '*' is used for a width,
519 or NULL if '*' not used for widths. */
520 tree
*const width_type
;
521 /* Pointer to type of argument expected if '*' is used for a precision,
522 or NULL if '*' not used for precisions. */
523 tree
*const precision_type
;
527 /* Structure describing details of a type expected in format checking,
528 and the type to check against it. */
529 typedef struct format_wanted_type
531 /* The type wanted. */
533 /* The name of this type to use in diagnostics. */
534 const char *wanted_type_name
;
535 /* The level of indirection through pointers at which this type occurs. */
537 /* Whether, when pointer_count is 1, to allow any character type when
538 pedantic, rather than just the character or void type specified. */
539 int char_lenient_flag
;
540 /* Whether the argument, dereferenced once, is written into and so the
541 argument must not be a pointer to a const-qualified type. */
543 /* Whether the argument, dereferenced once, is read from and so
544 must not be a NULL pointer. */
545 int reading_from_flag
;
546 /* If warnings should be of the form "field precision is not type int",
547 the name to use (in this case "field precision"), otherwise NULL,
548 for "%s format, %s arg" type messages. If (in an extension), this
549 is a pointer type, wanted_type_name should be set to include the
550 terminating '*' characters of the type name to give a correct
553 /* The actual parameter to check against the wanted type. */
555 /* The argument number of that parameter. */
557 /* The next type to check for this format conversion, or NULL if none. */
558 struct format_wanted_type
*next
;
559 } format_wanted_type
;
562 static const format_length_info printf_length_specs
[] =
564 { "h", FMT_LEN_h
, STD_C89
, "hh", FMT_LEN_hh
, STD_C99
},
565 { "l", FMT_LEN_l
, STD_C89
, "ll", FMT_LEN_ll
, STD_C9L
},
566 { "q", FMT_LEN_ll
, STD_EXT
, NULL
, 0, 0 },
567 { "L", FMT_LEN_L
, STD_C89
, NULL
, 0, 0 },
568 { "z", FMT_LEN_z
, STD_C99
, NULL
, 0, 0 },
569 { "Z", FMT_LEN_z
, STD_EXT
, NULL
, 0, 0 },
570 { "t", FMT_LEN_t
, STD_C99
, NULL
, 0, 0 },
571 { "j", FMT_LEN_j
, STD_C99
, NULL
, 0, 0 },
572 { NULL
, 0, 0, NULL
, 0, 0 }
576 /* This differs from printf_length_specs only in that "Z" is not accepted. */
577 static const format_length_info scanf_length_specs
[] =
579 { "h", FMT_LEN_h
, STD_C89
, "hh", FMT_LEN_hh
, STD_C99
},
580 { "l", FMT_LEN_l
, STD_C89
, "ll", FMT_LEN_ll
, STD_C9L
},
581 { "q", FMT_LEN_ll
, STD_EXT
, NULL
, 0, 0 },
582 { "L", FMT_LEN_L
, STD_C89
, NULL
, 0, 0 },
583 { "z", FMT_LEN_z
, STD_C99
, NULL
, 0, 0 },
584 { "t", FMT_LEN_t
, STD_C99
, NULL
, 0, 0 },
585 { "j", FMT_LEN_j
, STD_C99
, NULL
, 0, 0 },
586 { NULL
, 0, 0, NULL
, 0, 0 }
590 /* All tables for strfmon use STD_C89 everywhere, since -pedantic warnings
591 make no sense for a format type not part of any C standard version. */
592 static const format_length_info strfmon_length_specs
[] =
594 /* A GNU extension. */
595 { "L", FMT_LEN_L
, STD_C89
, NULL
, 0, 0 },
596 { NULL
, 0, 0, NULL
, 0, 0 }
599 static const format_flag_spec printf_flag_specs
[] =
601 { ' ', 0, 0, N_("` ' flag"), N_("the ` ' printf flag"), STD_C89
},
602 { '+', 0, 0, N_("`+' flag"), N_("the `+' printf flag"), STD_C89
},
603 { '#', 0, 0, N_("`#' flag"), N_("the `#' printf flag"), STD_C89
},
604 { '0', 0, 0, N_("`0' flag"), N_("the `0' printf flag"), STD_C89
},
605 { '-', 0, 0, N_("`-' flag"), N_("the `-' printf flag"), STD_C89
},
606 { '\'', 0, 0, N_("`'' flag"), N_("the `'' printf flag"), STD_EXT
},
607 { 'I', 0, 0, N_("`I' flag"), N_("the `I' printf flag"), STD_EXT
},
608 { 'w', 0, 0, N_("field width"), N_("field width in printf format"), STD_C89
},
609 { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89
},
610 { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89
},
611 { 0, 0, 0, NULL
, NULL
, 0 }
615 static const format_flag_pair printf_flag_pairs
[] =
619 { '0', 'p', 1, 'i' },
624 static const format_flag_spec scanf_flag_specs
[] =
626 { '*', 0, 0, N_("assignment suppression"), N_("the assignment suppression scanf feature"), STD_C89
},
627 { 'a', 0, 0, N_("`a' flag"), N_("the `a' scanf flag"), STD_EXT
},
628 { 'w', 0, 0, N_("field width"), N_("field width in scanf format"), STD_C89
},
629 { 'L', 0, 0, N_("length modifier"), N_("length modifier in scanf format"), STD_C89
},
630 { '\'', 0, 0, N_("`'' flag"), N_("the `'' scanf flag"), STD_EXT
},
631 { 'I', 0, 0, N_("`I' flag"), N_("the `I' scanf flag"), STD_EXT
},
632 { 0, 0, 0, NULL
, NULL
, 0 }
636 static const format_flag_pair scanf_flag_pairs
[] =
643 static const format_flag_spec strftime_flag_specs
[] =
645 { '_', 0, 0, N_("`_' flag"), N_("the `_' strftime flag"), STD_EXT
},
646 { '-', 0, 0, N_("`-' flag"), N_("the `-' strftime flag"), STD_EXT
},
647 { '0', 0, 0, N_("`0' flag"), N_("the `0' strftime flag"), STD_EXT
},
648 { '^', 0, 0, N_("`^' flag"), N_("the `^' strftime flag"), STD_EXT
},
649 { '#', 0, 0, N_("`#' flag"), N_("the `#' strftime flag"), STD_EXT
},
650 { 'w', 0, 0, N_("field width"), N_("field width in strftime format"), STD_EXT
},
651 { 'E', 0, 0, N_("`E' modifier"), N_("the `E' strftime modifier"), STD_C99
},
652 { 'O', 0, 0, N_("`O' modifier"), N_("the `O' strftime modifier"), STD_C99
},
653 { 'O', 'o', 0, NULL
, N_("the `O' modifier"), STD_EXT
},
654 { 0, 0, 0, NULL
, NULL
, 0 }
658 static const format_flag_pair strftime_flag_pairs
[] =
669 static const format_flag_spec strfmon_flag_specs
[] =
671 { '=', 0, 1, N_("fill character"), N_("fill character in strfmon format"), STD_C89
},
672 { '^', 0, 0, N_("`^' flag"), N_("the `^' strfmon flag"), STD_C89
},
673 { '+', 0, 0, N_("`+' flag"), N_("the `+' strfmon flag"), STD_C89
},
674 { '(', 0, 0, N_("`(' flag"), N_("the `(' strfmon flag"), STD_C89
},
675 { '!', 0, 0, N_("`!' flag"), N_("the `!' strfmon flag"), STD_C89
},
676 { '-', 0, 0, N_("`-' flag"), N_("the `-' strfmon flag"), STD_C89
},
677 { 'w', 0, 0, N_("field width"), N_("field width in strfmon format"), STD_C89
},
678 { '#', 0, 0, N_("left precision"), N_("left precision in strfmon format"), STD_C89
},
679 { 'p', 0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89
},
680 { 'L', 0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89
},
681 { 0, 0, 0, NULL
, NULL
, 0 }
684 static const format_flag_pair strfmon_flag_pairs
[] =
691 #define T_I &integer_type_node
692 #define T89_I { STD_C89, NULL, T_I }
693 #define T_L &long_integer_type_node
694 #define T89_L { STD_C89, NULL, T_L }
695 #define T_LL &long_long_integer_type_node
696 #define T9L_LL { STD_C9L, NULL, T_LL }
697 #define TEX_LL { STD_EXT, NULL, T_LL }
698 #define T_S &short_integer_type_node
699 #define T89_S { STD_C89, NULL, T_S }
700 #define T_UI &unsigned_type_node
701 #define T89_UI { STD_C89, NULL, T_UI }
702 #define T_UL &long_unsigned_type_node
703 #define T89_UL { STD_C89, NULL, T_UL }
704 #define T_ULL &long_long_unsigned_type_node
705 #define T9L_ULL { STD_C9L, NULL, T_ULL }
706 #define TEX_ULL { STD_EXT, NULL, T_ULL }
707 #define T_US &short_unsigned_type_node
708 #define T89_US { STD_C89, NULL, T_US }
709 #define T_F &float_type_node
710 #define T89_F { STD_C89, NULL, T_F }
711 #define T99_F { STD_C99, NULL, T_F }
712 #define T_D &double_type_node
713 #define T89_D { STD_C89, NULL, T_D }
714 #define T99_D { STD_C99, NULL, T_D }
715 #define T_LD &long_double_type_node
716 #define T89_LD { STD_C89, NULL, T_LD }
717 #define T99_LD { STD_C99, NULL, T_LD }
718 #define T_C &char_type_node
719 #define T89_C { STD_C89, NULL, T_C }
720 #define T_SC &signed_char_type_node
721 #define T99_SC { STD_C99, NULL, T_SC }
722 #define T_UC &unsigned_char_type_node
723 #define T99_UC { STD_C99, NULL, T_UC }
724 #define T_V &void_type_node
725 #define T89_V { STD_C89, NULL, T_V }
726 #define T_W &wchar_type_node
727 #define T94_W { STD_C94, "wchar_t", T_W }
728 #define TEX_W { STD_EXT, "wchar_t", T_W }
729 #define T_WI &wint_type_node
730 #define T94_WI { STD_C94, "wint_t", T_WI }
731 #define TEX_WI { STD_EXT, "wint_t", T_WI }
732 #define T_ST &c_size_type_node
733 #define T99_ST { STD_C99, "size_t", T_ST }
734 #define T_SST &signed_size_type_node
735 #define T99_SST { STD_C99, "signed size_t", T_SST }
736 #define T_PD &ptrdiff_type_node
737 #define T99_PD { STD_C99, "ptrdiff_t", T_PD }
738 #define T_UPD &unsigned_ptrdiff_type_node
739 #define T99_UPD { STD_C99, "unsigned ptrdiff_t", T_UPD }
740 #define T_IM &intmax_type_node
741 #define T99_IM { STD_C99, "intmax_t", T_IM }
742 #define T_UIM &uintmax_type_node
743 #define T99_UIM { STD_C99, "uintmax_t", T_UIM }
745 static const format_char_info print_char_table
[] =
747 /* C89 conversion specifiers. */
748 { "di", 0, STD_C89
, { T89_I
, T99_SC
, T89_S
, T89_L
, T9L_LL
, TEX_LL
, T99_SST
, T99_PD
, T99_IM
}, "-wp0 +'I", "i" },
749 { "oxX", 0, STD_C89
, { T89_UI
, T99_UC
, T89_US
, T89_UL
, T9L_ULL
, TEX_ULL
, T99_ST
, T99_UPD
, T99_UIM
}, "-wp0#", "i" },
750 { "u", 0, STD_C89
, { T89_UI
, T99_UC
, T89_US
, T89_UL
, T9L_ULL
, TEX_ULL
, T99_ST
, T99_UPD
, T99_UIM
}, "-wp0'I", "i" },
751 { "fgG", 0, STD_C89
, { T89_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T89_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#'", "" },
752 { "eE", 0, STD_C89
, { T89_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T89_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#", "" },
753 { "c", 0, STD_C89
, { T89_I
, BADLEN
, BADLEN
, T94_WI
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-w", "" },
754 { "s", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-wp", "cR" },
755 { "p", 1, STD_C89
, { T89_V
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-w", "c" },
756 { "n", 1, STD_C89
, { T89_I
, T99_SC
, T89_S
, T89_L
, T9L_LL
, BADLEN
, T99_SST
, T99_PD
, T99_IM
}, "", "W" },
757 /* C99 conversion specifiers. */
758 { "F", 0, STD_C99
, { T99_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T99_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#'", "" },
759 { "aA", 0, STD_C99
, { T99_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T99_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#", "" },
760 /* X/Open conversion specifiers. */
761 { "C", 0, STD_EXT
, { TEX_WI
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-w", "" },
762 { "S", 1, STD_EXT
, { TEX_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-wp", "R" },
763 /* GNU conversion specifiers. */
764 { "m", 0, STD_EXT
, { T89_V
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-wp", "" },
765 { NULL
, 0, 0, NOLENGTHS
, NULL
, NULL
}
768 static const format_char_info scan_char_table
[] =
770 /* C89 conversion specifiers. */
771 { "di", 1, STD_C89
, { T89_I
, T99_SC
, T89_S
, T89_L
, T9L_LL
, TEX_LL
, T99_SST
, T99_PD
, T99_IM
}, "*w'I", "W" },
772 { "u", 1, STD_C89
, { T89_UI
, T99_UC
, T89_US
, T89_UL
, T9L_ULL
, TEX_ULL
, T99_ST
, T99_UPD
, T99_UIM
}, "*w'I", "W" },
773 { "oxX", 1, STD_C89
, { T89_UI
, T99_UC
, T89_US
, T89_UL
, T9L_ULL
, TEX_ULL
, T99_ST
, T99_UPD
, T99_UIM
}, "*w", "W" },
774 { "efgEG", 1, STD_C89
, { T89_F
, BADLEN
, BADLEN
, T89_D
, BADLEN
, T89_LD
, BADLEN
, BADLEN
, BADLEN
}, "*w'", "W" },
775 { "c", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*w", "cW" },
776 { "s", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*aw", "cW" },
777 { "[", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*aw", "cW[" },
778 { "p", 2, STD_C89
, { T89_V
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*w", "W" },
779 { "n", 1, STD_C89
, { T89_I
, T99_SC
, T89_S
, T89_L
, T9L_LL
, BADLEN
, T99_SST
, T99_PD
, T99_IM
}, "", "W" },
780 /* C99 conversion specifiers. */
781 { "FaA", 1, STD_C99
, { T99_F
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T99_LD
, BADLEN
, BADLEN
, BADLEN
}, "*w'", "W" },
782 /* X/Open conversion specifiers. */
783 { "C", 1, STD_EXT
, { TEX_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*w", "W" },
784 { "S", 1, STD_EXT
, { TEX_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*aw", "W" },
785 { NULL
, 0, 0, NOLENGTHS
, NULL
, NULL
}
788 static const format_char_info time_char_table
[] =
790 /* C89 conversion specifiers. */
791 { "ABZab", 0, STD_C89
, NOLENGTHS
, "^#", "" },
792 { "cx", 0, STD_C89
, NOLENGTHS
, "E", "3" },
793 { "HIMSUWdmw", 0, STD_C89
, NOLENGTHS
, "-_0Ow", "" },
794 { "j", 0, STD_C89
, NOLENGTHS
, "-_0Ow", "o" },
795 { "p", 0, STD_C89
, NOLENGTHS
, "#", "" },
796 { "X", 0, STD_C89
, NOLENGTHS
, "E", "" },
797 { "y", 0, STD_C89
, NOLENGTHS
, "EO-_0w", "4" },
798 { "Y", 0, STD_C89
, NOLENGTHS
, "-_0EOw", "o" },
799 { "%", 0, STD_C89
, NOLENGTHS
, "", "" },
800 /* C99 conversion specifiers. */
801 { "C", 0, STD_C99
, NOLENGTHS
, "-_0EOw", "o" },
802 { "D", 0, STD_C99
, NOLENGTHS
, "", "2" },
803 { "eVu", 0, STD_C99
, NOLENGTHS
, "-_0Ow", "" },
804 { "FRTnrt", 0, STD_C99
, NOLENGTHS
, "", "" },
805 { "g", 0, STD_C99
, NOLENGTHS
, "O-_0w", "2o" },
806 { "G", 0, STD_C99
, NOLENGTHS
, "-_0Ow", "o" },
807 { "h", 0, STD_C99
, NOLENGTHS
, "^#", "" },
808 { "z", 0, STD_C99
, NOLENGTHS
, "O", "o" },
809 /* GNU conversion specifiers. */
810 { "kls", 0, STD_EXT
, NOLENGTHS
, "-_0Ow", "" },
811 { "P", 0, STD_EXT
, NOLENGTHS
, "", "" },
812 { NULL
, 0, 0, NOLENGTHS
, NULL
, NULL
}
815 static const format_char_info monetary_char_table
[] =
817 { "in", 0, STD_C89
, { T89_D
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, T89_LD
, BADLEN
, BADLEN
, BADLEN
}, "=^+(!-w#p", "" },
818 { NULL
, 0, 0, NOLENGTHS
, NULL
, NULL
}
822 /* This must be in the same order as enum format_type. */
823 static const format_kind_info format_types
[] =
825 { "printf", printf_length_specs
, print_char_table
, " +#0-'I", NULL
,
826 printf_flag_specs
, printf_flag_pairs
,
827 FMT_FLAG_ARG_CONVERT
|FMT_FLAG_DOLLAR_MULTIPLE
|FMT_FLAG_USE_DOLLAR
|FMT_FLAG_EMPTY_PREC_OK
,
829 &integer_type_node
, &integer_type_node
831 { "scanf", scanf_length_specs
, scan_char_table
, "*'I", NULL
,
832 scanf_flag_specs
, scanf_flag_pairs
,
833 FMT_FLAG_ARG_CONVERT
|FMT_FLAG_SCANF_A_KLUDGE
|FMT_FLAG_USE_DOLLAR
|FMT_FLAG_ZERO_WIDTH_BAD
|FMT_FLAG_DOLLAR_GAP_POINTER_OK
,
837 { "strftime", NULL
, time_char_table
, "_-0^#", "EO",
838 strftime_flag_specs
, strftime_flag_pairs
,
839 FMT_FLAG_FANCY_PERCENT_OK
, 'w', 0, 0, 0, 0,
842 { "strfmon", strfmon_length_specs
, monetary_char_table
, "=^+(!-", NULL
,
843 strfmon_flag_specs
, strfmon_flag_pairs
,
844 FMT_FLAG_ARG_CONVERT
, 'w', '#', 'p', 0, 'L',
850 /* Structure detailing the results of checking a format function call
851 where the format expression may be a conditional expression with
852 many leaves resulting from nested conditional expressions. */
855 /* Number of leaves of the format argument that could not be checked
856 as they were not string literals. */
857 int number_non_literal
;
858 /* Number of leaves of the format argument that were null pointers or
859 string literals, but had extra format arguments. */
860 int number_extra_args
;
861 /* Number of leaves of the format argument that were null pointers or
862 string literals, but had extra format arguments and used $ operand
864 int number_dollar_extra_args
;
865 /* Number of leaves of the format argument that were wide string
868 /* Number of leaves of the format argument that were empty strings. */
870 /* Number of leaves of the format argument that were unterminated
872 int number_unterminated
;
873 /* Number of leaves of the format argument that were not counted above. */
875 } format_check_results
;
879 format_check_results
*res
;
880 function_format_info
*info
;
883 } format_check_context
;
885 static void check_format_info
PARAMS ((int *, function_format_info
*, tree
));
886 static void check_format_arg
PARAMS ((void *, tree
, unsigned HOST_WIDE_INT
));
887 static void check_format_info_main
PARAMS ((int *, format_check_results
*,
888 function_format_info
*,
889 const char *, int, tree
,
890 unsigned HOST_WIDE_INT
));
891 static void status_warning
PARAMS ((int *, const char *, ...))
894 static void init_dollar_format_checking
PARAMS ((int, tree
));
895 static int maybe_read_dollar_number
PARAMS ((int *, const char **, int,
897 const format_kind_info
*));
898 static void finish_dollar_format_checking
PARAMS ((int *, format_check_results
*, int));
900 static const format_flag_spec
*get_flag_spec
PARAMS ((const format_flag_spec
*,
903 static void check_format_types
PARAMS ((int *, format_wanted_type
*));
905 /* Decode a format type from a string, returning the type, or
906 format_type_error if not valid, in which case the caller should print an
908 static enum format_type
909 decode_format_type (s
)
915 for (i
= 0; i
< (int) format_type_error
; i
++)
918 if (!strcmp (s
, format_types
[i
].name
))
920 alen
= strlen (format_types
[i
].name
);
921 if (slen
== alen
+ 4 && s
[0] == '_' && s
[1] == '_'
922 && s
[slen
- 1] == '_' && s
[slen
- 2] == '_'
923 && !strncmp (s
+ 2, format_types
[i
].name
, alen
))
926 return ((enum format_type
) i
);
930 /* Check the argument list of a call to printf, scanf, etc.
931 ATTRS are the attributes on the function type.
932 PARAMS is the list of argument values. Also, if -Wmissing-format-attribute,
933 warn for calls to vprintf or vscanf in functions with no such format
934 attribute themselves. */
937 check_function_format (status
, attrs
, params
)
944 /* See if this function has any format attributes. */
945 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
947 if (is_attribute_p ("format", TREE_PURPOSE (a
)))
950 function_format_info info
;
951 decode_format_attr (TREE_VALUE (a
), &info
, 1);
952 check_format_info (status
, &info
, params
);
953 if (warn_missing_format_attribute
&& info
.first_arg_num
== 0
954 && (format_types
[info
.format_type
].flags
955 & (int) FMT_FLAG_ARG_CONVERT
))
958 for (c
= TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
));
961 if (is_attribute_p ("format", TREE_PURPOSE (c
))
962 && (decode_format_type (IDENTIFIER_POINTER
963 (TREE_VALUE (TREE_VALUE (c
))))
964 == info
.format_type
))
968 /* Check if the current function has a parameter to which
969 the format attribute could be attached; if not, it
970 can't be a candidate for a format attribute, despite
971 the vprintf-like or vscanf-like call. */
973 for (args
= DECL_ARGUMENTS (current_function_decl
);
975 args
= TREE_CHAIN (args
))
977 if (TREE_CODE (TREE_TYPE (args
)) == POINTER_TYPE
978 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (args
)))
983 warning ("function might be possible candidate for `%s' format attribute",
984 format_types
[info
.format_type
].name
);
991 /* This function replaces `warning' inside the printf format checking
992 functions. If the `status' parameter is non-NULL, then it is
993 dereferenced and set to 1 whenever a warning is caught. Otherwise
994 it warns as usual by replicating the innards of the warning
995 function from diagnostic.c. */
997 status_warning
VPARAMS ((int *status
, const char *msgid
, ...))
999 diagnostic_info diagnostic
;
1001 VA_OPEN (ap
, msgid
);
1002 VA_FIXEDARG (ap
, int *, status
);
1003 VA_FIXEDARG (ap
, const char *, msgid
);
1009 /* This duplicates the warning function behavior. */
1010 diagnostic_set_info (&diagnostic
, _(msgid
), &ap
, input_filename
, lineno
,
1012 report_diagnostic (&diagnostic
);
1018 /* Variables used by the checking of $ operand number formats. */
1019 static char *dollar_arguments_used
= NULL
;
1020 static char *dollar_arguments_pointer_p
= NULL
;
1021 static int dollar_arguments_alloc
= 0;
1022 static int dollar_arguments_count
;
1023 static int dollar_first_arg_num
;
1024 static int dollar_max_arg_used
;
1025 static int dollar_format_warned
;
1027 /* Initialize the checking for a format string that may contain $
1028 parameter number specifications; we will need to keep track of whether
1029 each parameter has been used. FIRST_ARG_NUM is the number of the first
1030 argument that is a parameter to the format, or 0 for a vprintf-style
1031 function; PARAMS is the list of arguments starting at this argument. */
1034 init_dollar_format_checking (first_arg_num
, params
)
1038 tree oparams
= params
;
1040 dollar_first_arg_num
= first_arg_num
;
1041 dollar_arguments_count
= 0;
1042 dollar_max_arg_used
= 0;
1043 dollar_format_warned
= 0;
1044 if (first_arg_num
> 0)
1048 dollar_arguments_count
++;
1049 params
= TREE_CHAIN (params
);
1052 if (dollar_arguments_alloc
< dollar_arguments_count
)
1054 if (dollar_arguments_used
)
1055 free (dollar_arguments_used
);
1056 if (dollar_arguments_pointer_p
)
1057 free (dollar_arguments_pointer_p
);
1058 dollar_arguments_alloc
= dollar_arguments_count
;
1059 dollar_arguments_used
= xmalloc (dollar_arguments_alloc
);
1060 dollar_arguments_pointer_p
= xmalloc (dollar_arguments_alloc
);
1062 if (dollar_arguments_alloc
)
1064 memset (dollar_arguments_used
, 0, dollar_arguments_alloc
);
1065 if (first_arg_num
> 0)
1071 dollar_arguments_pointer_p
[i
] = (TREE_CODE (TREE_TYPE (TREE_VALUE (params
)))
1073 params
= TREE_CHAIN (params
);
1081 /* Look for a decimal number followed by a $ in *FORMAT. If DOLLAR_NEEDED
1082 is set, it is an error if one is not found; otherwise, it is OK. If
1083 such a number is found, check whether it is within range and mark that
1084 numbered operand as being used for later checking. Returns the operand
1085 number if found and within range, zero if no such number was found and
1086 this is OK, or -1 on error. PARAMS points to the first operand of the
1087 format; PARAM_PTR is made to point to the parameter referred to. If
1088 a $ format is found, *FORMAT is updated to point just after it. */
1091 maybe_read_dollar_number (status
, format
, dollar_needed
, params
, param_ptr
,
1094 const char **format
;
1098 const format_kind_info
*fki
;
1102 const char *fcp
= *format
;
1103 if (! ISDIGIT (*fcp
))
1107 status_warning (status
, "missing $ operand number in format");
1115 while (ISDIGIT (*fcp
))
1118 nargnum
= 10 * argnum
+ (*fcp
- '0');
1119 if (nargnum
< 0 || nargnum
/ 10 != argnum
)
1128 status_warning (status
, "missing $ operand number in format");
1135 if (pedantic
&& !dollar_format_warned
)
1137 status_warning (status
,
1138 "%s does not support %%n$ operand number formats",
1139 C_STD_NAME (STD_EXT
));
1140 dollar_format_warned
= 1;
1142 if (overflow_flag
|| argnum
== 0
1143 || (dollar_first_arg_num
&& argnum
> dollar_arguments_count
))
1145 status_warning (status
, "operand number out of range in format");
1148 if (argnum
> dollar_max_arg_used
)
1149 dollar_max_arg_used
= argnum
;
1150 /* For vprintf-style functions we may need to allocate more memory to
1151 track which arguments are used. */
1152 while (dollar_arguments_alloc
< dollar_max_arg_used
)
1155 nalloc
= 2 * dollar_arguments_alloc
+ 16;
1156 dollar_arguments_used
= xrealloc (dollar_arguments_used
, nalloc
);
1157 dollar_arguments_pointer_p
= xrealloc (dollar_arguments_pointer_p
,
1159 memset (dollar_arguments_used
+ dollar_arguments_alloc
, 0,
1160 nalloc
- dollar_arguments_alloc
);
1161 dollar_arguments_alloc
= nalloc
;
1163 if (!(fki
->flags
& (int) FMT_FLAG_DOLLAR_MULTIPLE
)
1164 && dollar_arguments_used
[argnum
- 1] == 1)
1166 dollar_arguments_used
[argnum
- 1] = 2;
1167 status_warning (status
,
1168 "format argument %d used more than once in %s format",
1172 dollar_arguments_used
[argnum
- 1] = 1;
1173 if (dollar_first_arg_num
)
1176 *param_ptr
= params
;
1177 for (i
= 1; i
< argnum
&& *param_ptr
!= 0; i
++)
1178 *param_ptr
= TREE_CHAIN (*param_ptr
);
1180 if (*param_ptr
== 0)
1182 /* This case shouldn't be caught here. */
1192 /* Finish the checking for a format string that used $ operand number formats
1193 instead of non-$ formats. We check for unused operands before used ones
1194 (a serious error, since the implementation of the format function
1195 can't know what types to pass to va_arg to find the later arguments).
1196 and for unused operands at the end of the format (if we know how many
1197 arguments the format had, so not for vprintf). If there were operand
1198 numbers out of range on a non-vprintf-style format, we won't have reached
1199 here. If POINTER_GAP_OK, unused arguments are OK if all arguments are
1203 finish_dollar_format_checking (status
, res
, pointer_gap_ok
)
1205 format_check_results
*res
;
1209 bool found_pointer_gap
= false;
1210 for (i
= 0; i
< dollar_max_arg_used
; i
++)
1212 if (!dollar_arguments_used
[i
])
1214 if (pointer_gap_ok
&& (dollar_first_arg_num
== 0
1215 || dollar_arguments_pointer_p
[i
]))
1216 found_pointer_gap
= true;
1218 status_warning (status
, "format argument %d unused before used argument %d in $-style format",
1219 i
+ 1, dollar_max_arg_used
);
1222 if (found_pointer_gap
1223 || (dollar_first_arg_num
1224 && dollar_max_arg_used
< dollar_arguments_count
))
1226 res
->number_other
--;
1227 res
->number_dollar_extra_args
++;
1232 /* Retrieve the specification for a format flag. SPEC contains the
1233 specifications for format flags for the applicable kind of format.
1234 FLAG is the flag in question. If PREDICATES is NULL, the basic
1235 spec for that flag must be retrieved and this function aborts if
1236 it cannot be found. If PREDICATES is not NULL, it is a string listing
1237 possible predicates for the spec entry; if an entry predicated on any
1238 of these is found, it is returned, otherwise NULL is returned. */
1240 static const format_flag_spec
*
1241 get_flag_spec (spec
, flag
, predicates
)
1242 const format_flag_spec
*spec
;
1244 const char *predicates
;
1247 for (i
= 0; spec
[i
].flag_char
!= 0; i
++)
1249 if (spec
[i
].flag_char
!= flag
)
1251 if (predicates
!= NULL
)
1253 if (spec
[i
].predicate
!= 0
1254 && strchr (predicates
, spec
[i
].predicate
) != 0)
1257 else if (spec
[i
].predicate
== 0)
1260 if (predicates
== NULL
)
1267 /* Check the argument list of a call to printf, scanf, etc.
1268 INFO points to the function_format_info structure.
1269 PARAMS is the list of argument values. */
1272 check_format_info (status
, info
, params
)
1274 function_format_info
*info
;
1277 format_check_context format_ctx
;
1278 unsigned HOST_WIDE_INT arg_num
;
1280 format_check_results res
;
1281 /* Skip to format argument. If the argument isn't available, there's
1282 no work for us to do; prototype checking will catch the problem. */
1283 for (arg_num
= 1; ; ++arg_num
)
1287 if (arg_num
== info
->format_num
)
1289 params
= TREE_CHAIN (params
);
1291 format_tree
= TREE_VALUE (params
);
1292 params
= TREE_CHAIN (params
);
1293 if (format_tree
== 0)
1296 res
.number_non_literal
= 0;
1297 res
.number_extra_args
= 0;
1298 res
.number_dollar_extra_args
= 0;
1299 res
.number_wide
= 0;
1300 res
.number_empty
= 0;
1301 res
.number_unterminated
= 0;
1302 res
.number_other
= 0;
1304 format_ctx
.res
= &res
;
1305 format_ctx
.info
= info
;
1306 format_ctx
.params
= params
;
1307 format_ctx
.status
= status
;
1309 check_function_arguments_recurse (check_format_arg
, &format_ctx
,
1310 format_tree
, arg_num
);
1312 if (res
.number_non_literal
> 0)
1314 /* Functions taking a va_list normally pass a non-literal format
1315 string. These functions typically are declared with
1316 first_arg_num == 0, so avoid warning in those cases. */
1317 if (!(format_types
[info
->format_type
].flags
& (int) FMT_FLAG_ARG_CONVERT
))
1319 /* For strftime-like formats, warn for not checking the format
1320 string; but there are no arguments to check. */
1321 if (warn_format_nonliteral
)
1322 status_warning (status
, "format not a string literal, format string not checked");
1324 else if (info
->first_arg_num
!= 0)
1326 /* If there are no arguments for the format at all, we may have
1327 printf (foo) which is likely to be a security hole. */
1328 while (arg_num
+ 1 < info
->first_arg_num
)
1332 params
= TREE_CHAIN (params
);
1335 if (params
== 0 && (warn_format_nonliteral
|| warn_format_security
))
1336 status_warning (status
, "format not a string literal and no format arguments");
1337 else if (warn_format_nonliteral
)
1338 status_warning (status
, "format not a string literal, argument types not checked");
1342 /* If there were extra arguments to the format, normally warn. However,
1343 the standard does say extra arguments are ignored, so in the specific
1344 case where we have multiple leaves (conditional expressions or
1345 ngettext) allow extra arguments if at least one leaf didn't have extra
1346 arguments, but was otherwise OK (either non-literal or checked OK).
1347 If the format is an empty string, this should be counted similarly to the
1348 case of extra format arguments. */
1349 if (res
.number_extra_args
> 0 && res
.number_non_literal
== 0
1350 && res
.number_other
== 0 && warn_format_extra_args
)
1351 status_warning (status
, "too many arguments for format");
1352 if (res
.number_dollar_extra_args
> 0 && res
.number_non_literal
== 0
1353 && res
.number_other
== 0 && warn_format_extra_args
)
1354 status_warning (status
, "unused arguments in $-style format");
1355 if (res
.number_empty
> 0 && res
.number_non_literal
== 0
1356 && res
.number_other
== 0 && warn_format_zero_length
)
1357 status_warning (status
, "zero-length %s format string",
1358 format_types
[info
->format_type
].name
);
1360 if (res
.number_wide
> 0)
1361 status_warning (status
, "format is a wide character string");
1363 if (res
.number_unterminated
> 0)
1364 status_warning (status
, "unterminated format string");
1367 /* Callback from check_function_arguments_recurse to check a
1368 format string. FORMAT_TREE is the format parameter. ARG_NUM
1369 is the number of the format argument. CTX points to a
1370 format_check_context. */
1373 check_format_arg (ctx
, format_tree
, arg_num
)
1376 unsigned HOST_WIDE_INT arg_num
;
1378 format_check_context
*format_ctx
= ctx
;
1379 format_check_results
*res
= format_ctx
->res
;
1380 function_format_info
*info
= format_ctx
->info
;
1381 tree params
= format_ctx
->params
;
1382 int *status
= format_ctx
->status
;
1385 HOST_WIDE_INT offset
;
1386 const char *format_chars
;
1387 tree array_size
= 0;
1390 if (integer_zerop (format_tree
))
1392 /* Skip to first argument to check, so we can see if this format
1393 has any arguments (it shouldn't). */
1394 while (arg_num
+ 1 < info
->first_arg_num
)
1398 params
= TREE_CHAIN (params
);
1403 res
->number_other
++;
1405 res
->number_extra_args
++;
1411 if (TREE_CODE (format_tree
) == PLUS_EXPR
)
1415 arg0
= TREE_OPERAND (format_tree
, 0);
1416 arg1
= TREE_OPERAND (format_tree
, 1);
1419 if (TREE_CODE (arg1
) == INTEGER_CST
)
1421 else if (TREE_CODE (arg0
) == INTEGER_CST
)
1428 res
->number_non_literal
++;
1431 if (!host_integerp (arg1
, 0)
1432 || (offset
= tree_low_cst (arg1
, 0)) < 0)
1434 res
->number_non_literal
++;
1438 if (TREE_CODE (format_tree
) != ADDR_EXPR
)
1440 res
->number_non_literal
++;
1443 format_tree
= TREE_OPERAND (format_tree
, 0);
1444 if (TREE_CODE (format_tree
) == VAR_DECL
1445 && TREE_CODE (TREE_TYPE (format_tree
)) == ARRAY_TYPE
1446 && (array_init
= decl_constant_value (format_tree
)) != format_tree
1447 && TREE_CODE (array_init
) == STRING_CST
)
1449 /* Extract the string constant initializer. Note that this may include
1450 a trailing NUL character that is not in the array (e.g.
1451 const char a[3] = "foo";). */
1452 array_size
= DECL_SIZE_UNIT (format_tree
);
1453 format_tree
= array_init
;
1455 if (TREE_CODE (format_tree
) != STRING_CST
)
1457 res
->number_non_literal
++;
1460 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree
))) != char_type_node
)
1465 format_chars
= TREE_STRING_POINTER (format_tree
);
1466 format_length
= TREE_STRING_LENGTH (format_tree
);
1467 if (array_size
!= 0)
1469 /* Variable length arrays can't be initialized. */
1470 if (TREE_CODE (array_size
) != INTEGER_CST
)
1472 if (host_integerp (array_size
, 0))
1474 HOST_WIDE_INT array_size_value
= TREE_INT_CST_LOW (array_size
);
1475 if (array_size_value
> 0
1476 && array_size_value
== (int) array_size_value
1477 && format_length
> array_size_value
)
1478 format_length
= array_size_value
;
1483 if (offset
>= format_length
)
1485 res
->number_non_literal
++;
1488 format_chars
+= offset
;
1489 format_length
-= offset
;
1491 if (format_length
< 1)
1493 res
->number_unterminated
++;
1496 if (format_length
== 1)
1498 res
->number_empty
++;
1501 if (format_chars
[--format_length
] != 0)
1503 res
->number_unterminated
++;
1507 /* Skip to first argument to check. */
1508 while (arg_num
+ 1 < info
->first_arg_num
)
1512 params
= TREE_CHAIN (params
);
1515 /* Provisionally increment res->number_other; check_format_info_main
1516 will decrement it if it finds there are extra arguments, but this way
1517 need not adjust it for every return. */
1518 res
->number_other
++;
1519 check_format_info_main (status
, res
, info
, format_chars
, format_length
,
1524 /* Do the main part of checking a call to a format function. FORMAT_CHARS
1525 is the NUL-terminated format string (which at this point may contain
1526 internal NUL characters); FORMAT_LENGTH is its length (excluding the
1527 terminating NUL character). ARG_NUM is one less than the number of
1528 the first format argument to check; PARAMS points to that format
1529 argument in the list of arguments. */
1532 check_format_info_main (status
, res
, info
, format_chars
, format_length
,
1535 format_check_results
*res
;
1536 function_format_info
*info
;
1537 const char *format_chars
;
1540 unsigned HOST_WIDE_INT arg_num
;
1542 const char *orig_format_chars
= format_chars
;
1543 tree first_fillin_param
= params
;
1545 const format_kind_info
*fki
= &format_types
[info
->format_type
];
1546 const format_flag_spec
*flag_specs
= fki
->flag_specs
;
1547 const format_flag_pair
*bad_flag_pairs
= fki
->bad_flag_pairs
;
1549 /* -1 if no conversions taking an operand have been found; 0 if one has
1550 and it didn't use $; 1 if $ formats are in use. */
1551 int has_operand_number
= -1;
1553 init_dollar_format_checking (info
->first_arg_num
, first_fillin_param
);
1558 int suppressed
= FALSE
;
1559 const char *length_chars
= NULL
;
1560 enum format_lengths length_chars_val
= FMT_LEN_none
;
1561 enum format_std_version length_chars_std
= STD_C89
;
1565 int main_arg_num
= 0;
1566 tree main_arg_params
= 0;
1567 enum format_std_version wanted_type_std
;
1568 const char *wanted_type_name
;
1569 format_wanted_type width_wanted_type
;
1570 format_wanted_type precision_wanted_type
;
1571 format_wanted_type main_wanted_type
;
1572 format_wanted_type
*first_wanted_type
= NULL
;
1573 format_wanted_type
*last_wanted_type
= NULL
;
1574 const format_length_info
*fli
= NULL
;
1575 const format_char_info
*fci
= NULL
;
1576 char flag_chars
[256];
1578 if (*format_chars
== 0)
1580 if (format_chars
- orig_format_chars
!= format_length
)
1581 status_warning (status
, "embedded `\\0' in format");
1582 if (info
->first_arg_num
!= 0 && params
!= 0
1583 && has_operand_number
<= 0)
1585 res
->number_other
--;
1586 res
->number_extra_args
++;
1588 if (has_operand_number
> 0)
1589 finish_dollar_format_checking (status
, res
, fki
->flags
& (int) FMT_FLAG_DOLLAR_GAP_POINTER_OK
);
1592 if (*format_chars
++ != '%')
1594 if (*format_chars
== 0)
1596 status_warning (status
, "spurious trailing `%%' in format");
1599 if (*format_chars
== '%')
1606 if ((fki
->flags
& (int) FMT_FLAG_USE_DOLLAR
) && has_operand_number
!= 0)
1608 /* Possibly read a $ operand number at the start of the format.
1609 If one was previously used, one is required here. If one
1610 is not used here, we can't immediately conclude this is a
1611 format without them, since it could be printf %m or scanf %*. */
1613 opnum
= maybe_read_dollar_number (status
, &format_chars
, 0,
1615 &main_arg_params
, fki
);
1620 has_operand_number
= 1;
1621 main_arg_num
= opnum
+ info
->first_arg_num
- 1;
1625 /* Read any format flags, but do not yet validate them beyond removing
1626 duplicates, since in general validation depends on the rest of
1628 while (*format_chars
!= 0
1629 && strchr (fki
->flag_chars
, *format_chars
) != 0)
1631 const format_flag_spec
*s
= get_flag_spec (flag_specs
,
1632 *format_chars
, NULL
);
1633 if (strchr (flag_chars
, *format_chars
) != 0)
1635 status_warning (status
, "repeated %s in format", _(s
->name
));
1639 i
= strlen (flag_chars
);
1640 flag_chars
[i
++] = *format_chars
;
1643 if (s
->skip_next_char
)
1646 if (*format_chars
== 0)
1648 status_warning (status
, "missing fill character at end of strfmon format");
1655 /* Read any format width, possibly * or *m$. */
1656 if (fki
->width_char
!= 0)
1658 if (fki
->width_type
!= NULL
&& *format_chars
== '*')
1660 i
= strlen (flag_chars
);
1661 flag_chars
[i
++] = fki
->width_char
;
1663 /* "...a field width...may be indicated by an asterisk.
1664 In this case, an int argument supplies the field width..." */
1666 if (has_operand_number
!= 0)
1669 opnum
= maybe_read_dollar_number (status
, &format_chars
,
1670 has_operand_number
== 1,
1677 has_operand_number
= 1;
1678 arg_num
= opnum
+ info
->first_arg_num
- 1;
1681 has_operand_number
= 0;
1683 if (info
->first_arg_num
!= 0)
1687 status_warning (status
, "too few arguments for format");
1690 cur_param
= TREE_VALUE (params
);
1691 if (has_operand_number
<= 0)
1693 params
= TREE_CHAIN (params
);
1696 width_wanted_type
.wanted_type
= *fki
->width_type
;
1697 width_wanted_type
.wanted_type_name
= NULL
;
1698 width_wanted_type
.pointer_count
= 0;
1699 width_wanted_type
.char_lenient_flag
= 0;
1700 width_wanted_type
.writing_in_flag
= 0;
1701 width_wanted_type
.reading_from_flag
= 0;
1702 width_wanted_type
.name
= _("field width");
1703 width_wanted_type
.param
= cur_param
;
1704 width_wanted_type
.arg_num
= arg_num
;
1705 width_wanted_type
.next
= NULL
;
1706 if (last_wanted_type
!= 0)
1707 last_wanted_type
->next
= &width_wanted_type
;
1708 if (first_wanted_type
== 0)
1709 first_wanted_type
= &width_wanted_type
;
1710 last_wanted_type
= &width_wanted_type
;
1715 /* Possibly read a numeric width. If the width is zero,
1716 we complain if appropriate. */
1717 int non_zero_width_char
= FALSE
;
1718 int found_width
= FALSE
;
1719 while (ISDIGIT (*format_chars
))
1722 if (*format_chars
!= '0')
1723 non_zero_width_char
= TRUE
;
1726 if (found_width
&& !non_zero_width_char
&&
1727 (fki
->flags
& (int) FMT_FLAG_ZERO_WIDTH_BAD
))
1728 status_warning (status
, "zero width in %s format",
1732 i
= strlen (flag_chars
);
1733 flag_chars
[i
++] = fki
->width_char
;
1739 /* Read any format left precision (must be a number, not *). */
1740 if (fki
->left_precision_char
!= 0 && *format_chars
== '#')
1743 i
= strlen (flag_chars
);
1744 flag_chars
[i
++] = fki
->left_precision_char
;
1746 if (!ISDIGIT (*format_chars
))
1747 status_warning (status
, "empty left precision in %s format",
1749 while (ISDIGIT (*format_chars
))
1753 /* Read any format precision, possibly * or *m$. */
1754 if (fki
->precision_char
!= 0 && *format_chars
== '.')
1757 i
= strlen (flag_chars
);
1758 flag_chars
[i
++] = fki
->precision_char
;
1760 if (fki
->precision_type
!= NULL
&& *format_chars
== '*')
1762 /* "...a...precision...may be indicated by an asterisk.
1763 In this case, an int argument supplies the...precision." */
1765 if (has_operand_number
!= 0)
1768 opnum
= maybe_read_dollar_number (status
, &format_chars
,
1769 has_operand_number
== 1,
1776 has_operand_number
= 1;
1777 arg_num
= opnum
+ info
->first_arg_num
- 1;
1780 has_operand_number
= 0;
1782 if (info
->first_arg_num
!= 0)
1786 status_warning (status
, "too few arguments for format");
1789 cur_param
= TREE_VALUE (params
);
1790 if (has_operand_number
<= 0)
1792 params
= TREE_CHAIN (params
);
1795 precision_wanted_type
.wanted_type
= *fki
->precision_type
;
1796 precision_wanted_type
.wanted_type_name
= NULL
;
1797 precision_wanted_type
.pointer_count
= 0;
1798 precision_wanted_type
.char_lenient_flag
= 0;
1799 precision_wanted_type
.writing_in_flag
= 0;
1800 precision_wanted_type
.reading_from_flag
= 0;
1801 precision_wanted_type
.name
= _("field precision");
1802 precision_wanted_type
.param
= cur_param
;
1803 precision_wanted_type
.arg_num
= arg_num
;
1804 precision_wanted_type
.next
= NULL
;
1805 if (last_wanted_type
!= 0)
1806 last_wanted_type
->next
= &precision_wanted_type
;
1807 if (first_wanted_type
== 0)
1808 first_wanted_type
= &precision_wanted_type
;
1809 last_wanted_type
= &precision_wanted_type
;
1814 if (!(fki
->flags
& (int) FMT_FLAG_EMPTY_PREC_OK
)
1815 && !ISDIGIT (*format_chars
))
1816 status_warning (status
, "empty precision in %s format",
1818 while (ISDIGIT (*format_chars
))
1823 /* Read any length modifier, if this kind of format has them. */
1824 fli
= fki
->length_char_specs
;
1825 length_chars
= NULL
;
1826 length_chars_val
= FMT_LEN_none
;
1827 length_chars_std
= STD_C89
;
1830 while (fli
->name
!= 0 && fli
->name
[0] != *format_chars
)
1835 if (fli
->double_name
!= 0 && fli
->name
[0] == *format_chars
)
1838 length_chars
= fli
->double_name
;
1839 length_chars_val
= fli
->double_index
;
1840 length_chars_std
= fli
->double_std
;
1844 length_chars
= fli
->name
;
1845 length_chars_val
= fli
->index
;
1846 length_chars_std
= fli
->std
;
1848 i
= strlen (flag_chars
);
1849 flag_chars
[i
++] = fki
->length_code_char
;
1854 /* Warn if the length modifier is non-standard. */
1855 if (ADJ_STD (length_chars_std
) > C_STD_VER
)
1856 status_warning (status
, "%s does not support the `%s' %s length modifier",
1857 C_STD_NAME (length_chars_std
), length_chars
,
1862 /* Read any modifier (strftime E/O). */
1863 if (fki
->modifier_chars
!= NULL
)
1865 while (*format_chars
!= 0
1866 && strchr (fki
->modifier_chars
, *format_chars
) != 0)
1868 if (strchr (flag_chars
, *format_chars
) != 0)
1870 const format_flag_spec
*s
= get_flag_spec (flag_specs
,
1871 *format_chars
, NULL
);
1872 status_warning (status
, "repeated %s in format", _(s
->name
));
1876 i
= strlen (flag_chars
);
1877 flag_chars
[i
++] = *format_chars
;
1884 /* Handle the scanf allocation kludge. */
1885 if (fki
->flags
& (int) FMT_FLAG_SCANF_A_KLUDGE
)
1887 if (*format_chars
== 'a' && !flag_isoc99
)
1889 if (format_chars
[1] == 's' || format_chars
[1] == 'S'
1890 || format_chars
[1] == '[')
1892 /* `a' is used as a flag. */
1893 i
= strlen (flag_chars
);
1894 flag_chars
[i
++] = 'a';
1901 format_char
= *format_chars
;
1902 if (format_char
== 0
1903 || (!(fki
->flags
& (int) FMT_FLAG_FANCY_PERCENT_OK
)
1904 && format_char
== '%'))
1906 status_warning (status
, "conversion lacks type at end of format");
1910 fci
= fki
->conversion_specs
;
1911 while (fci
->format_chars
!= 0
1912 && strchr (fci
->format_chars
, format_char
) == 0)
1914 if (fci
->format_chars
== 0)
1916 if (ISGRAPH(format_char
))
1917 status_warning (status
, "unknown conversion type character `%c' in format",
1920 status_warning (status
, "unknown conversion type character 0x%x in format",
1926 if (ADJ_STD (fci
->std
) > C_STD_VER
)
1927 status_warning (status
, "%s does not support the `%%%c' %s format",
1928 C_STD_NAME (fci
->std
), format_char
, fki
->name
);
1931 /* Validate the individual flags used, removing any that are invalid. */
1934 for (i
= 0; flag_chars
[i
] != 0; i
++)
1936 const format_flag_spec
*s
= get_flag_spec (flag_specs
,
1937 flag_chars
[i
], NULL
);
1938 flag_chars
[i
- d
] = flag_chars
[i
];
1939 if (flag_chars
[i
] == fki
->length_code_char
)
1941 if (strchr (fci
->flag_chars
, flag_chars
[i
]) == 0)
1943 status_warning (status
, "%s used with `%%%c' %s format",
1944 _(s
->name
), format_char
, fki
->name
);
1950 const format_flag_spec
*t
;
1951 if (ADJ_STD (s
->std
) > C_STD_VER
)
1952 status_warning (status
, "%s does not support %s",
1953 C_STD_NAME (s
->std
), _(s
->long_name
));
1954 t
= get_flag_spec (flag_specs
, flag_chars
[i
], fci
->flags2
);
1955 if (t
!= NULL
&& ADJ_STD (t
->std
) > ADJ_STD (s
->std
))
1957 const char *long_name
= (t
->long_name
!= NULL
1960 if (ADJ_STD (t
->std
) > C_STD_VER
)
1961 status_warning (status
, "%s does not support %s with the `%%%c' %s format",
1962 C_STD_NAME (t
->std
), _(long_name
),
1963 format_char
, fki
->name
);
1967 flag_chars
[i
- d
] = 0;
1970 if ((fki
->flags
& (int) FMT_FLAG_SCANF_A_KLUDGE
)
1971 && strchr (flag_chars
, 'a') != 0)
1974 if (fki
->suppression_char
1975 && strchr (flag_chars
, fki
->suppression_char
) != 0)
1978 /* Validate the pairs of flags used. */
1979 for (i
= 0; bad_flag_pairs
[i
].flag_char1
!= 0; i
++)
1981 const format_flag_spec
*s
, *t
;
1982 if (strchr (flag_chars
, bad_flag_pairs
[i
].flag_char1
) == 0)
1984 if (strchr (flag_chars
, bad_flag_pairs
[i
].flag_char2
) == 0)
1986 if (bad_flag_pairs
[i
].predicate
!= 0
1987 && strchr (fci
->flags2
, bad_flag_pairs
[i
].predicate
) == 0)
1989 s
= get_flag_spec (flag_specs
, bad_flag_pairs
[i
].flag_char1
, NULL
);
1990 t
= get_flag_spec (flag_specs
, bad_flag_pairs
[i
].flag_char2
, NULL
);
1991 if (bad_flag_pairs
[i
].ignored
)
1993 if (bad_flag_pairs
[i
].predicate
!= 0)
1994 status_warning (status
, "%s ignored with %s and `%%%c' %s format",
1995 _(s
->name
), _(t
->name
), format_char
,
1998 status_warning (status
, "%s ignored with %s in %s format",
1999 _(s
->name
), _(t
->name
), fki
->name
);
2003 if (bad_flag_pairs
[i
].predicate
!= 0)
2004 status_warning (status
, "use of %s and %s together with `%%%c' %s format",
2005 _(s
->name
), _(t
->name
), format_char
,
2008 status_warning (status
, "use of %s and %s together in %s format",
2009 _(s
->name
), _(t
->name
), fki
->name
);
2013 /* Give Y2K warnings. */
2014 if (warn_format_y2k
)
2017 if (strchr (fci
->flags2
, '4') != 0)
2018 if (strchr (flag_chars
, 'E') != 0)
2022 else if (strchr (fci
->flags2
, '3') != 0)
2024 else if (strchr (fci
->flags2
, '2') != 0)
2027 status_warning (status
, "`%%%c' yields only last 2 digits of year in some locales",
2029 else if (y2k_level
== 2)
2030 status_warning (status
, "`%%%c' yields only last 2 digits of year", format_char
);
2033 if (strchr (fci
->flags2
, '[') != 0)
2035 /* Skip over scan set, in case it happens to have '%' in it. */
2036 if (*format_chars
== '^')
2038 /* Find closing bracket; if one is hit immediately, then
2039 it's part of the scan set rather than a terminator. */
2040 if (*format_chars
== ']')
2042 while (*format_chars
&& *format_chars
!= ']')
2044 if (*format_chars
!= ']')
2045 /* The end of the format string was reached. */
2046 status_warning (status
, "no closing `]' for `%%[' format");
2050 wanted_type_name
= 0;
2051 if (fki
->flags
& (int) FMT_FLAG_ARG_CONVERT
)
2053 wanted_type
= (fci
->types
[length_chars_val
].type
2054 ? *fci
->types
[length_chars_val
].type
: 0);
2055 wanted_type_name
= fci
->types
[length_chars_val
].name
;
2056 wanted_type_std
= fci
->types
[length_chars_val
].std
;
2057 if (wanted_type
== 0)
2059 status_warning (status
, "use of `%s' length modifier with `%c' type character",
2060 length_chars
, format_char
);
2061 /* Heuristic: skip one argument when an invalid length/type
2062 combination is encountered. */
2066 status_warning (status
, "too few arguments for format");
2069 params
= TREE_CHAIN (params
);
2073 /* Warn if non-standard, provided it is more non-standard
2074 than the length and type characters that may already
2075 have been warned for. */
2076 && ADJ_STD (wanted_type_std
) > ADJ_STD (length_chars_std
)
2077 && ADJ_STD (wanted_type_std
) > ADJ_STD (fci
->std
))
2079 if (ADJ_STD (wanted_type_std
) > C_STD_VER
)
2080 status_warning (status
, "%s does not support the `%%%s%c' %s format",
2081 C_STD_NAME (wanted_type_std
), length_chars
,
2082 format_char
, fki
->name
);
2086 /* Finally. . .check type of argument against desired type! */
2087 if (info
->first_arg_num
== 0)
2089 if ((fci
->pointer_count
== 0 && wanted_type
== void_type_node
)
2092 if (main_arg_num
!= 0)
2095 status_warning (status
, "operand number specified with suppressed assignment");
2097 status_warning (status
, "operand number specified for format taking no argument");
2102 if (main_arg_num
!= 0)
2104 arg_num
= main_arg_num
;
2105 params
= main_arg_params
;
2110 if (has_operand_number
> 0)
2112 status_warning (status
, "missing $ operand number in format");
2116 has_operand_number
= 0;
2119 status_warning (status
, "too few arguments for format");
2123 cur_param
= TREE_VALUE (params
);
2124 params
= TREE_CHAIN (params
);
2125 main_wanted_type
.wanted_type
= wanted_type
;
2126 main_wanted_type
.wanted_type_name
= wanted_type_name
;
2127 main_wanted_type
.pointer_count
= fci
->pointer_count
+ aflag
;
2128 main_wanted_type
.char_lenient_flag
= 0;
2129 if (strchr (fci
->flags2
, 'c') != 0)
2130 main_wanted_type
.char_lenient_flag
= 1;
2131 main_wanted_type
.writing_in_flag
= 0;
2132 main_wanted_type
.reading_from_flag
= 0;
2134 main_wanted_type
.writing_in_flag
= 1;
2137 if (strchr (fci
->flags2
, 'W') != 0)
2138 main_wanted_type
.writing_in_flag
= 1;
2139 if (strchr (fci
->flags2
, 'R') != 0)
2140 main_wanted_type
.reading_from_flag
= 1;
2142 main_wanted_type
.name
= NULL
;
2143 main_wanted_type
.param
= cur_param
;
2144 main_wanted_type
.arg_num
= arg_num
;
2145 main_wanted_type
.next
= NULL
;
2146 if (last_wanted_type
!= 0)
2147 last_wanted_type
->next
= &main_wanted_type
;
2148 if (first_wanted_type
== 0)
2149 first_wanted_type
= &main_wanted_type
;
2150 last_wanted_type
= &main_wanted_type
;
2153 if (first_wanted_type
!= 0)
2154 check_format_types (status
, first_wanted_type
);
2160 /* Check the argument types from a single format conversion (possibly
2161 including width and precision arguments). */
2163 check_format_types (status
, types
)
2165 format_wanted_type
*types
;
2167 for (; types
!= 0; types
= types
->next
)
2176 cur_param
= types
->param
;
2177 cur_type
= TREE_TYPE (cur_param
);
2178 if (cur_type
== error_mark_node
)
2181 wanted_type
= types
->wanted_type
;
2182 arg_num
= types
->arg_num
;
2184 /* The following should not occur here. */
2185 if (wanted_type
== 0)
2187 if (wanted_type
== void_type_node
&& types
->pointer_count
== 0)
2190 if (types
->pointer_count
== 0)
2191 wanted_type
= (*lang_hooks
.types
.type_promotes_to
) (wanted_type
);
2193 STRIP_NOPS (cur_param
);
2195 /* Check the types of any additional pointer arguments
2196 that precede the "real" argument. */
2197 for (i
= 0; i
< types
->pointer_count
; ++i
)
2199 if (TREE_CODE (cur_type
) == POINTER_TYPE
)
2201 cur_type
= TREE_TYPE (cur_type
);
2202 if (cur_type
== error_mark_node
)
2205 /* Check for writing through a NULL pointer. */
2206 if (types
->writing_in_flag
2209 && integer_zerop (cur_param
))
2210 status_warning (status
,
2211 "writing through null pointer (arg %d)",
2214 /* Check for reading through a NULL pointer. */
2215 if (types
->reading_from_flag
2218 && integer_zerop (cur_param
))
2219 status_warning (status
,
2220 "reading through null pointer (arg %d)",
2223 if (cur_param
!= 0 && TREE_CODE (cur_param
) == ADDR_EXPR
)
2224 cur_param
= TREE_OPERAND (cur_param
, 0);
2228 /* See if this is an attempt to write into a const type with
2229 scanf or with printf "%n". Note: the writing in happens
2230 at the first indirection only, if for example
2231 void * const * is passed to scanf %p; passing
2232 const void ** is simply passing an incompatible type. */
2233 if (types
->writing_in_flag
2235 && (TYPE_READONLY (cur_type
)
2237 && (TREE_CODE_CLASS (TREE_CODE (cur_param
)) == 'c'
2238 || (DECL_P (cur_param
)
2239 && TREE_READONLY (cur_param
))))))
2240 status_warning (status
, "writing into constant object (arg %d)", arg_num
);
2242 /* If there are extra type qualifiers beyond the first
2243 indirection, then this makes the types technically
2247 && (TYPE_READONLY (cur_type
)
2248 || TYPE_VOLATILE (cur_type
)
2249 || TYPE_RESTRICT (cur_type
)))
2250 status_warning (status
, "extra type qualifiers in format argument (arg %d)",
2256 if (types
->pointer_count
== 1)
2257 status_warning (status
, "format argument is not a pointer (arg %d)", arg_num
);
2259 status_warning (status
, "format argument is not a pointer to a pointer (arg %d)", arg_num
);
2264 if (i
< types
->pointer_count
)
2267 orig_cur_type
= cur_type
;
2268 cur_type
= TYPE_MAIN_VARIANT (cur_type
);
2270 /* Check whether the argument type is a character type. This leniency
2271 only applies to certain formats, flagged with 'c'.
2273 if (types
->char_lenient_flag
)
2274 char_type_flag
= (cur_type
== char_type_node
2275 || cur_type
== signed_char_type_node
2276 || cur_type
== unsigned_char_type_node
);
2278 /* Check the type of the "real" argument, if there's a type we want. */
2279 if (wanted_type
== cur_type
)
2281 /* If we want `void *', allow any pointer type.
2282 (Anything else would already have got a warning.)
2283 With -pedantic, only allow pointers to void and to character
2285 if (wanted_type
== void_type_node
2286 && (!pedantic
|| (i
== 1 && char_type_flag
)))
2288 /* Don't warn about differences merely in signedness, unless
2289 -pedantic. With -pedantic, warn if the type is a pointer
2290 target and not a character type, and for character types at
2291 a second level of indirection. */
2292 if (TREE_CODE (wanted_type
) == INTEGER_TYPE
2293 && TREE_CODE (cur_type
) == INTEGER_TYPE
2294 && (! pedantic
|| i
== 0 || (i
== 1 && char_type_flag
))
2295 && (TREE_UNSIGNED (wanted_type
)
2296 ? wanted_type
== c_common_unsigned_type (cur_type
)
2297 : wanted_type
== c_common_signed_type (cur_type
)))
2299 /* Likewise, "signed char", "unsigned char" and "char" are
2300 equivalent but the above test won't consider them equivalent. */
2301 if (wanted_type
== char_type_node
2302 && (! pedantic
|| i
< 2)
2305 /* Now we have a type mismatch. */
2310 this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type
)));
2312 if (TYPE_NAME (orig_cur_type
) != 0
2313 && TREE_CODE (orig_cur_type
) != INTEGER_TYPE
2314 && !(TREE_CODE (orig_cur_type
) == POINTER_TYPE
2315 && TREE_CODE (TREE_TYPE (orig_cur_type
)) == INTEGER_TYPE
))
2317 if (TREE_CODE (TYPE_NAME (orig_cur_type
)) == TYPE_DECL
2318 && DECL_NAME (TYPE_NAME (orig_cur_type
)) != 0)
2319 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type
)));
2321 that
= IDENTIFIER_POINTER (TYPE_NAME (orig_cur_type
));
2324 /* A nameless type can't possibly match what the format wants.
2325 So there will be a warning for it.
2326 Make up a string to describe vaguely what it is. */
2329 if (TREE_CODE (orig_cur_type
) == POINTER_TYPE
)
2330 that
= _("pointer");
2332 that
= _("different type");
2335 /* Make the warning better in case of mismatch of int vs long. */
2336 if (TREE_CODE (orig_cur_type
) == INTEGER_TYPE
2337 && TREE_CODE (wanted_type
) == INTEGER_TYPE
2338 && TYPE_PRECISION (orig_cur_type
) == TYPE_PRECISION (wanted_type
)
2339 && TYPE_NAME (orig_cur_type
) != 0
2340 && TREE_CODE (TYPE_NAME (orig_cur_type
)) == TYPE_DECL
)
2341 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type
)));
2343 if (strcmp (this, that
) != 0)
2345 /* There may be a better name for the format, e.g. size_t,
2346 but we should allow for programs with a perverse typedef
2347 making size_t something other than what the compiler
2349 if (types
->wanted_type_name
!= 0
2350 && strcmp (types
->wanted_type_name
, that
) != 0)
2351 this = types
->wanted_type_name
;
2352 if (types
->name
!= 0)
2353 status_warning (status
, "%s is not type %s (arg %d)", types
->name
, this,
2356 status_warning (status
, "%s format, %s arg (arg %d)", this, that
, arg_num
);