1 /* Check calls to formatted I/O functions (-Wformat).
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 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"
32 /* Command line options and their associated flags. */
34 /* Warn about format/argument anomalies in calls to formatted I/O functions
35 (*printf, *scanf, strftime, strfmon, etc.). */
39 /* Warn about Y2K problems with strftime formats. */
43 /* Warn about excess arguments to formats. */
45 int warn_format_extra_args
;
47 /* Warn about non-literal format arguments. */
49 int warn_format_nonliteral
;
51 /* Warn about possible security problems with calls to format functions. */
53 int warn_format_security
;
55 /* Set format warning options according to a -Wformat=n option. */
61 warn_format
= setting
;
62 warn_format_y2k
= setting
;
63 warn_format_extra_args
= setting
;
66 warn_format_nonliteral
= setting
;
67 warn_format_security
= setting
;
72 /* Handle attributes associated with format checking. */
74 /* This must be in the same order as format_types, with format_type_error
76 enum format_type
{ printf_format_type
, scanf_format_type
,
77 strftime_format_type
, strfmon_format_type
,
80 static enum format_type decode_format_type
PARAMS ((const char *));
81 static void record_function_format
PARAMS ((tree
, tree
, enum format_type
,
83 static void record_international_format
PARAMS ((tree
, tree
, int));
85 /* Handle a "format" attribute; arguments as in
86 struct attribute_spec.handler. */
88 handle_format_attribute (node
, name
, args
, flags
, no_add_attrs
)
90 tree name ATTRIBUTE_UNUSED
;
92 int flags ATTRIBUTE_UNUSED
;
96 tree type
= TREE_TYPE (decl
);
97 tree format_type_id
= TREE_VALUE (args
);
98 tree format_num_expr
= TREE_VALUE (TREE_CHAIN (args
));
99 tree first_arg_num_expr
100 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args
)));
101 unsigned HOST_WIDE_INT format_num
, first_arg_num
;
102 enum format_type format_type
;
104 unsigned int arg_num
;
106 if (TREE_CODE (decl
) != FUNCTION_DECL
)
108 error_with_decl (decl
,
109 "argument format specified for non-function `%s'");
110 *no_add_attrs
= true;
114 if (TREE_CODE (format_type_id
) != IDENTIFIER_NODE
)
116 error ("unrecognized format specifier");
117 *no_add_attrs
= true;
122 const char *p
= IDENTIFIER_POINTER (format_type_id
);
124 format_type
= decode_format_type (p
);
126 if (format_type
== format_type_error
)
128 warning ("`%s' is an unrecognized format function type", p
);
129 *no_add_attrs
= true;
134 /* Strip any conversions from the string index and first arg number
135 and verify they are constants. */
136 while (TREE_CODE (format_num_expr
) == NOP_EXPR
137 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
138 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
139 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
141 while (TREE_CODE (first_arg_num_expr
) == NOP_EXPR
142 || TREE_CODE (first_arg_num_expr
) == CONVERT_EXPR
143 || TREE_CODE (first_arg_num_expr
) == NON_LVALUE_EXPR
)
144 first_arg_num_expr
= TREE_OPERAND (first_arg_num_expr
, 0);
146 if (TREE_CODE (format_num_expr
) != INTEGER_CST
147 || TREE_INT_CST_HIGH (format_num_expr
) != 0
148 || TREE_CODE (first_arg_num_expr
) != INTEGER_CST
149 || TREE_INT_CST_HIGH (first_arg_num_expr
) != 0)
151 error ("format string has invalid operand number");
152 *no_add_attrs
= true;
156 format_num
= TREE_INT_CST_LOW (format_num_expr
);
157 first_arg_num
= TREE_INT_CST_LOW (first_arg_num_expr
);
158 if (first_arg_num
!= 0 && first_arg_num
<= format_num
)
160 error ("format string arg follows the args to be formatted");
161 *no_add_attrs
= true;
165 /* If a parameter list is specified, verify that the format_num
166 argument is actually a string, in case the format attribute
168 argument
= TYPE_ARG_TYPES (type
);
171 for (arg_num
= 1; argument
!= 0 && arg_num
!= format_num
;
172 ++arg_num
, argument
= TREE_CHAIN (argument
))
176 || TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
177 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument
)))
180 error ("format string arg not a string type");
181 *no_add_attrs
= true;
185 else if (first_arg_num
!= 0)
187 /* Verify that first_arg_num points to the last arg,
190 arg_num
++, argument
= TREE_CHAIN (argument
);
192 if (arg_num
!= first_arg_num
)
194 error ("args to be formatted is not '...'");
195 *no_add_attrs
= true;
201 if (format_type
== strftime_format_type
&& first_arg_num
!= 0)
203 error ("strftime formats cannot format arguments");
204 *no_add_attrs
= true;
208 record_function_format (DECL_NAME (decl
), DECL_ASSEMBLER_NAME (decl
),
209 format_type
, format_num
, first_arg_num
);
214 /* Handle a "format" attribute; arguments as in
215 struct attribute_spec.handler. */
217 handle_format_arg_attribute (node
, name
, args
, flags
, no_add_attrs
)
219 tree name ATTRIBUTE_UNUSED
;
221 int flags ATTRIBUTE_UNUSED
;
225 tree type
= TREE_TYPE (decl
);
226 tree format_num_expr
= TREE_VALUE (args
);
227 unsigned HOST_WIDE_INT format_num
;
228 unsigned int arg_num
;
231 if (TREE_CODE (decl
) != FUNCTION_DECL
)
233 error_with_decl (decl
,
234 "argument format specified for non-function `%s'");
235 *no_add_attrs
= true;
239 /* Strip any conversions from the first arg number and verify it
241 while (TREE_CODE (format_num_expr
) == NOP_EXPR
242 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
243 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
244 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
246 if (TREE_CODE (format_num_expr
) != INTEGER_CST
247 || TREE_INT_CST_HIGH (format_num_expr
) != 0)
249 error ("format string has invalid operand number");
250 *no_add_attrs
= true;
254 format_num
= TREE_INT_CST_LOW (format_num_expr
);
256 /* If a parameter list is specified, verify that the format_num
257 argument is actually a string, in case the format attribute
259 argument
= TYPE_ARG_TYPES (type
);
262 for (arg_num
= 1; argument
!= 0 && arg_num
!= format_num
;
263 ++arg_num
, argument
= TREE_CHAIN (argument
))
267 || TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
268 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument
)))
271 error ("format string arg not a string type");
272 *no_add_attrs
= true;
277 if (TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) != POINTER_TYPE
278 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (TREE_TYPE (decl
))))
281 error ("function does not return string type");
282 *no_add_attrs
= true;
286 record_international_format (DECL_NAME (decl
), DECL_ASSEMBLER_NAME (decl
),
291 typedef struct function_format_info
293 struct function_format_info
*next
; /* next structure on the list */
294 tree name
; /* identifier such as "printf" */
295 tree assembler_name
; /* optional mangled identifier (for C++) */
296 enum format_type format_type
; /* type of format (printf, scanf, etc.) */
297 int format_num
; /* number of format argument */
298 int first_arg_num
; /* number of first arg (zero for varargs) */
299 } function_format_info
;
301 static function_format_info
*function_format_list
= NULL
;
303 typedef struct international_format_info
305 struct international_format_info
*next
; /* next structure on the list */
306 tree name
; /* identifier such as "gettext" */
307 tree assembler_name
; /* optional mangled identifier (for C++) */
308 int format_num
; /* number of format argument */
309 } international_format_info
;
311 static international_format_info
*international_format_list
= NULL
;
313 /* Initialize the table of functions to perform format checking on.
314 The ISO C functions are always checked (whether <stdio.h> is
315 included or not), since it is common to call printf without
316 including <stdio.h>. There shouldn't be a problem with this,
317 since ISO C reserves these function names whether you include the
318 header file or not. In any case, the checking is harmless. With
319 -ffreestanding, these default attributes are disabled, and must be
320 specified manually if desired.
322 Also initialize the name of function that modify the format string for
323 internationalization purposes. */
326 init_function_format_info ()
330 /* Functions from ISO/IEC 9899:1990. */
331 record_function_format (get_identifier ("printf"), NULL_TREE
,
332 printf_format_type
, 1, 2);
333 record_function_format (get_identifier ("__builtin_printf"), NULL_TREE
,
334 printf_format_type
, 1, 2);
335 record_function_format (get_identifier ("fprintf"), NULL_TREE
,
336 printf_format_type
, 2, 3);
337 record_function_format (get_identifier ("__builtin_fprintf"), NULL_TREE
,
338 printf_format_type
, 2, 3);
339 record_function_format (get_identifier ("sprintf"), NULL_TREE
,
340 printf_format_type
, 2, 3);
341 record_function_format (get_identifier ("scanf"), NULL_TREE
,
342 scanf_format_type
, 1, 2);
343 record_function_format (get_identifier ("fscanf"), NULL_TREE
,
344 scanf_format_type
, 2, 3);
345 record_function_format (get_identifier ("sscanf"), NULL_TREE
,
346 scanf_format_type
, 2, 3);
347 record_function_format (get_identifier ("vprintf"), NULL_TREE
,
348 printf_format_type
, 1, 0);
349 record_function_format (get_identifier ("vfprintf"), NULL_TREE
,
350 printf_format_type
, 2, 0);
351 record_function_format (get_identifier ("vsprintf"), NULL_TREE
,
352 printf_format_type
, 2, 0);
353 record_function_format (get_identifier ("strftime"), NULL_TREE
,
354 strftime_format_type
, 3, 0);
357 if (flag_hosted
&& flag_isoc99
)
359 /* ISO C99 adds the snprintf and vscanf family functions. */
360 record_function_format (get_identifier ("snprintf"), NULL_TREE
,
361 printf_format_type
, 3, 4);
362 record_function_format (get_identifier ("vsnprintf"), NULL_TREE
,
363 printf_format_type
, 3, 0);
364 record_function_format (get_identifier ("vscanf"), NULL_TREE
,
365 scanf_format_type
, 1, 0);
366 record_function_format (get_identifier ("vfscanf"), NULL_TREE
,
367 scanf_format_type
, 2, 0);
368 record_function_format (get_identifier ("vsscanf"), NULL_TREE
,
369 scanf_format_type
, 2, 0);
372 if (flag_hosted
&& flag_noniso_default_format_attributes
)
374 /* Uniforum/GNU gettext functions, not in ISO C. */
375 record_international_format (get_identifier ("gettext"), NULL_TREE
, 1);
376 record_international_format (get_identifier ("dgettext"), NULL_TREE
, 2);
377 record_international_format (get_identifier ("dcgettext"), NULL_TREE
, 2);
378 /* X/Open strfmon function. */
379 record_function_format (get_identifier ("strfmon"), NULL_TREE
,
380 strfmon_format_type
, 3, 4);
384 /* Record information for argument format checking. FUNCTION_IDENT is
385 the identifier node for the name of the function to check (its decl
387 FORMAT_TYPE specifies the type of format checking. FORMAT_NUM is the number
388 of the argument which is the format control string (starting from 1).
389 FIRST_ARG_NUM is the number of the first actual argument to check
390 against the format string, or zero if no checking is not be done
391 (e.g. for varargs such as vfprintf). */
394 record_function_format (name
, assembler_name
, format_type
,
395 format_num
, first_arg_num
)
398 enum format_type format_type
;
402 function_format_info
*info
;
404 /* Re-use existing structure if it's there. */
406 for (info
= function_format_list
; info
; info
= info
->next
)
408 if (info
->name
== name
&& info
->assembler_name
== assembler_name
)
413 info
= (function_format_info
*) xmalloc (sizeof (function_format_info
));
414 info
->next
= function_format_list
;
415 function_format_list
= info
;
418 info
->assembler_name
= assembler_name
;
421 info
->format_type
= format_type
;
422 info
->format_num
= format_num
;
423 info
->first_arg_num
= first_arg_num
;
426 /* Record information for the names of function that modify the format
427 argument to format functions. FUNCTION_IDENT is the identifier node for
428 the name of the function (its decl need not exist yet) and FORMAT_NUM is
429 the number of the argument which is the format control string (starting
433 record_international_format (name
, assembler_name
, format_num
)
438 international_format_info
*info
;
440 /* Re-use existing structure if it's there. */
442 for (info
= international_format_list
; info
; info
= info
->next
)
444 if (info
->name
== name
&& info
->assembler_name
== assembler_name
)
451 = (international_format_info
*)
452 xmalloc (sizeof (international_format_info
));
453 info
->next
= international_format_list
;
454 international_format_list
= info
;
457 info
->assembler_name
= assembler_name
;
460 info
->format_num
= format_num
;
466 /* Check a call to a format function against a parameter list. */
468 /* The meaningfully distinct length modifiers for format checking recognised
485 /* The standard versions in which various format features appeared. */
486 enum format_std_version
490 STD_C9L
, /* C99, but treat as C89 if -Wno-long-long. */
495 /* The C standard version C++ is treated as equivalent to
496 or inheriting from, for the purpose of format features supported. */
497 #define CPLUSPLUS_STD_VER STD_C89
498 /* The C standard version we are checking formats against when pedantic. */
499 #define C_STD_VER ((int)(c_language == clk_cplusplus \
500 ? CPLUSPLUS_STD_VER \
503 : (flag_isoc94 ? STD_C94 : STD_C89))))
504 /* The name to give to the standard version we are warning about when
505 pedantic. FEATURE_VER is the version in which the feature warned out
506 appeared, which is higher than C_STD_VER. */
507 #define C_STD_NAME(FEATURE_VER) (c_language == clk_cplusplus \
509 : ((FEATURE_VER) == STD_EXT \
512 /* Adjust a C standard version, which may be STD_C9L, to account for
513 -Wno-long-long. Returns other standard versions unchanged. */
514 #define ADJ_STD(VER) ((int)((VER) == STD_C9L \
515 ? (warn_long_long ? STD_C99 : STD_C89) \
518 /* Flags that may apply to a particular kind of format checked by GCC. */
521 /* This format converts arguments of types determined by the
523 FMT_FLAG_ARG_CONVERT
= 1,
524 /* The scanf allocation 'a' kludge applies to this format kind. */
525 FMT_FLAG_SCANF_A_KLUDGE
= 2,
526 /* A % during parsing a specifier is allowed to be a modified % rather
527 that indicating the format is broken and we are out-of-sync. */
528 FMT_FLAG_FANCY_PERCENT_OK
= 4,
529 /* With $ operand numbers, it is OK to reference the same argument more
531 FMT_FLAG_DOLLAR_MULTIPLE
= 8,
532 /* This format type uses $ operand numbers (strfmon doesn't). */
533 FMT_FLAG_USE_DOLLAR
= 16,
534 /* Zero width is bad in this type of format (scanf). */
535 FMT_FLAG_ZERO_WIDTH_BAD
= 32,
536 /* Empty precision specification is OK in this type of format (printf). */
537 FMT_FLAG_EMPTY_PREC_OK
= 64
538 /* Not included here: details of whether width or precision may occur
539 (controlled by width_char and precision_char); details of whether
540 '*' can be used for these (width_type and precision_type); details
541 of whether length modifiers can occur (length_char_specs). */
545 /* Structure describing a length modifier supported in format checking, and
546 possibly a doubled version such as "hh". */
549 /* Name of the single-character length modifier. */
551 /* Index into a format_char_info.types array. */
552 enum format_lengths index
;
553 /* Standard version this length appears in. */
554 enum format_std_version std
;
555 /* Same, if the modifier can be repeated, or NULL if it can't. */
556 const char *double_name
;
557 enum format_lengths double_index
;
558 enum format_std_version double_std
;
559 } format_length_info
;
562 /* Structure desribing the combination of a conversion specifier
563 (or a set of specifiers which act identically) and a length modifier. */
566 /* The standard version this combination of length and type appeared in.
567 This is only relevant if greater than those for length and type
568 individually; otherwise it is ignored. */
569 enum format_std_version std
;
570 /* The name to use for the type, if different from that generated internally
571 (e.g., "signed size_t"). */
573 /* The type itself. */
575 } format_type_detail
;
578 /* Macros to fill out tables of these. */
579 #define BADLEN { 0, NULL, NULL }
580 #define NOLENGTHS { BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
583 /* Structure desribing a format conversion specifier (or a set of specifiers
584 which act identically), and the length modifiers used with it. */
587 const char *format_chars
;
589 enum format_std_version std
;
590 /* Types accepted for each length modifier. */
591 format_type_detail types
[FMT_LEN_MAX
];
592 /* List of other modifier characters allowed with these specifiers.
593 This lists flags, and additionally "w" for width, "p" for precision
594 (right precision, for strfmon), "#" for left precision (strfmon),
595 "a" for scanf "a" allocation extension (not applicable in C99 mode),
596 "*" for scanf suppression, and "E" and "O" for those strftime
598 const char *flag_chars
;
599 /* List of additional flags describing these conversion specifiers.
600 "c" for generic character pointers being allowed, "2" for strftime
601 two digit year formats, "3" for strftime formats giving two digit
602 years in some locales, "4" for "2" which becomes "3" with an "E" modifier,
603 "o" if use of strftime "O" is a GNU extension beyond C99,
604 "W" if the argument is a pointer which is dereferenced and written into,
605 "R" if the argument is a pointer which is dereferenced and read from,
606 "i" for printf integer formats where the '0' flag is ignored with
607 precision, and "[" for the starting character of a scanf scanset. */
612 /* Structure describing a flag accepted by some kind of format. */
615 /* The flag character in question (0 for end of array). */
617 /* Zero if this entry describes the flag character in general, or a
618 non-zero character that may be found in flags2 if it describes the
619 flag when used with certain formats only. If the latter, only
620 the first such entry found that applies to the current conversion
621 specifier is used; the values of `name' and `long_name' it supplies
622 will be used, if non-NULL and the standard version is higher than
623 the unpredicated one, for any pedantic warning. For example, 'o'
624 for strftime formats (meaning 'O' is an extension over C99). */
626 /* Nonzero if the next character after this flag in the format should
627 be skipped ('=' in strfmon), zero otherwise. */
629 /* The name to use for this flag in diagnostic messages. For example,
630 N_("`0' flag"), N_("field width"). */
632 /* Long name for this flag in diagnostic messages; currently only used for
633 "ISO C does not support ...". For example, N_("the `I' printf flag"). */
634 const char *long_name
;
635 /* The standard version in which it appeared. */
636 enum format_std_version std
;
640 /* Structure describing a combination of flags that is bad for some kind
644 /* The first flag character in question (0 for end of array). */
646 /* The second flag character. */
648 /* Non-zero if the message should say that the first flag is ignored with
649 the second, zero if the combination should simply be objected to. */
651 /* Zero if this entry applies whenever this flag combination occurs,
652 a non-zero character from flags2 if it only applies in some
653 circumstances (e.g. 'i' for printf formats ignoring 0 with precision). */
658 /* Structure describing a particular kind of format processed by GCC. */
661 /* The name of this kind of format, for use in diagnostics. Also
662 the name of the attribute (without preceding and following __). */
664 /* Specifications of the length modifiers accepted; possibly NULL. */
665 const format_length_info
*length_char_specs
;
666 /* Details of the conversion specification characters accepted. */
667 const format_char_info
*conversion_specs
;
668 /* String listing the flag characters that are accepted. */
669 const char *flag_chars
;
670 /* String listing modifier characters (strftime) accepted. May be NULL. */
671 const char *modifier_chars
;
672 /* Details of the flag characters, including pseudo-flags. */
673 const format_flag_spec
*flag_specs
;
674 /* Details of bad combinations of flags. */
675 const format_flag_pair
*bad_flag_pairs
;
676 /* Flags applicable to this kind of format. */
678 /* Flag character to treat a width as, or 0 if width not used. */
680 /* Flag character to treat a left precision (strfmon) as,
681 or 0 if left precision not used. */
682 int left_precision_char
;
683 /* Flag character to treat a precision (for strfmon, right precision) as,
684 or 0 if precision not used. */
686 /* If a flag character has the effect of suppressing the conversion of
687 an argument ('*' in scanf), that flag character, otherwise 0. */
688 int suppression_char
;
689 /* Flag character to treat a length modifier as (ignored if length
690 modifiers not used). Need not be placed in flag_chars for conversion
691 specifiers, but is used to check for bad combinations such as length
692 modifier with assignment suppression in scanf. */
693 int length_code_char
;
694 /* Pointer to type of argument expected if '*' is used for a width,
695 or NULL if '*' not used for widths. */
697 /* Pointer to type of argument expected if '*' is used for a precision,
698 or NULL if '*' not used for precisions. */
699 tree
*precision_type
;
703 /* Structure describing details of a type expected in format checking,
704 and the type to check against it. */
705 typedef struct format_wanted_type
707 /* The type wanted. */
709 /* The name of this type to use in diagnostics. */
710 const char *wanted_type_name
;
711 /* The level of indirection through pointers at which this type occurs. */
713 /* Whether, when pointer_count is 1, to allow any character type when
714 pedantic, rather than just the character or void type specified. */
715 int char_lenient_flag
;
716 /* Whether the argument, dereferenced once, is written into and so the
717 argument must not be a pointer to a const-qualified type. */
719 /* Whether the argument, dereferenced once, is read from and so
720 must not be a NULL pointer. */
721 int reading_from_flag
;
722 /* If warnings should be of the form "field precision is not type int",
723 the name to use (in this case "field precision"), otherwise NULL,
724 for "%s format, %s arg" type messages. If (in an extension), this
725 is a pointer type, wanted_type_name should be set to include the
726 terminating '*' characters of the type name to give a correct
729 /* The actual parameter to check against the wanted type. */
731 /* The argument number of that parameter. */
733 /* The next type to check for this format conversion, or NULL if none. */
734 struct format_wanted_type
*next
;
735 } format_wanted_type
;
738 static const format_length_info printf_length_specs
[] =
740 { "h", FMT_LEN_h
, STD_C89
, "hh", FMT_LEN_hh
, STD_C99
},
741 { "l", FMT_LEN_l
, STD_C89
, "ll", FMT_LEN_ll
, STD_C9L
},
742 { "q", FMT_LEN_ll
, STD_EXT
, NULL
, 0, 0 },
743 { "L", FMT_LEN_L
, STD_C89
, NULL
, 0, 0 },
744 { "z", FMT_LEN_z
, STD_C99
, NULL
, 0, 0 },
745 { "Z", FMT_LEN_z
, STD_EXT
, NULL
, 0, 0 },
746 { "t", FMT_LEN_t
, STD_C99
, NULL
, 0, 0 },
747 { "j", FMT_LEN_j
, STD_C99
, NULL
, 0, 0 },
748 { NULL
, 0, 0, NULL
, 0, 0 }
752 /* This differs from printf_length_specs only in that "Z" is not accepted. */
753 static const format_length_info scanf_length_specs
[] =
755 { "h", FMT_LEN_h
, STD_C89
, "hh", FMT_LEN_hh
, STD_C99
},
756 { "l", FMT_LEN_l
, STD_C89
, "ll", FMT_LEN_ll
, STD_C9L
},
757 { "q", FMT_LEN_ll
, STD_EXT
, NULL
, 0, 0 },
758 { "L", FMT_LEN_L
, STD_C89
, NULL
, 0, 0 },
759 { "z", FMT_LEN_z
, STD_C99
, NULL
, 0, 0 },
760 { "t", FMT_LEN_t
, STD_C99
, NULL
, 0, 0 },
761 { "j", FMT_LEN_j
, STD_C99
, NULL
, 0, 0 },
762 { NULL
, 0, 0, NULL
, 0, 0 }
766 /* All tables for strfmon use STD_C89 everywhere, since -pedantic warnings
767 make no sense for a format type not part of any C standard version. */
768 static const format_length_info strfmon_length_specs
[] =
770 /* A GNU extension. */
771 { "L", FMT_LEN_L
, STD_C89
, NULL
, 0, 0 },
772 { NULL
, 0, 0, NULL
, 0, 0 }
775 static const format_flag_spec printf_flag_specs
[] =
777 { ' ', 0, 0, N_("` ' flag"), N_("the ` ' printf flag"), STD_C89
},
778 { '+', 0, 0, N_("`+' flag"), N_("the `+' printf flag"), STD_C89
},
779 { '#', 0, 0, N_("`#' flag"), N_("the `#' printf flag"), STD_C89
},
780 { '0', 0, 0, N_("`0' flag"), N_("the `0' printf flag"), STD_C89
},
781 { '-', 0, 0, N_("`-' flag"), N_("the `-' printf flag"), STD_C89
},
782 { '\'', 0, 0, N_("`'' flag"), N_("the `'' printf flag"), STD_EXT
},
783 { 'I', 0, 0, N_("`I' flag"), N_("the `I' printf flag"), STD_EXT
},
784 { 'w', 0, 0, N_("field width"), N_("field width in printf format"), STD_C89
},
785 { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89
},
786 { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89
},
787 { 0, 0, 0, NULL
, NULL
, 0 }
791 static const format_flag_pair printf_flag_pairs
[] =
795 { '0', 'p', 1, 'i' },
800 static const format_flag_spec scanf_flag_specs
[] =
802 { '*', 0, 0, N_("assignment suppression"), N_("assignment suppression"), STD_C89
},
803 { 'a', 0, 0, N_("`a' flag"), N_("the `a' scanf flag"), STD_EXT
},
804 { 'w', 0, 0, N_("field width"), N_("field width in scanf format"), STD_C89
},
805 { 'L', 0, 0, N_("length modifier"), N_("length modifier in scanf format"), STD_C89
},
806 { '\'', 0, 0, N_("`'' flag"), N_("the `'' scanf flag"), STD_EXT
},
807 { 'I', 0, 0, N_("`I' flag"), N_("the `I' scanf flag"), STD_EXT
},
808 { 0, 0, 0, NULL
, NULL
, 0 }
812 static const format_flag_pair scanf_flag_pairs
[] =
819 static const format_flag_spec strftime_flag_specs
[] =
821 { '_', 0, 0, N_("`_' flag"), N_("the `_' strftime flag"), STD_EXT
},
822 { '-', 0, 0, N_("`-' flag"), N_("the `-' strftime flag"), STD_EXT
},
823 { '0', 0, 0, N_("`0' flag"), N_("the `0' strftime flag"), STD_EXT
},
824 { '^', 0, 0, N_("`^' flag"), N_("the `^' strftime flag"), STD_EXT
},
825 { '#', 0, 0, N_("`#' flag"), N_("the `#' strftime flag"), STD_EXT
},
826 { 'w', 0, 0, N_("field width"), N_("field width in strftime format"), STD_EXT
},
827 { 'E', 0, 0, N_("`E' modifier"), N_("the `E' strftime modifier"), STD_C99
},
828 { 'O', 0, 0, N_("`O' modifier"), N_("the `O' strftime modifier"), STD_C99
},
829 { 'O', 'o', 0, NULL
, N_("the `O' modifier"), STD_EXT
},
830 { 0, 0, 0, NULL
, NULL
, 0 }
834 static const format_flag_pair strftime_flag_pairs
[] =
845 static const format_flag_spec strfmon_flag_specs
[] =
847 { '=', 0, 1, N_("fill character"), N_("fill character in strfmon format"), STD_C89
},
848 { '^', 0, 0, N_("`^' flag"), N_("the `^' strfmon flag"), STD_C89
},
849 { '+', 0, 0, N_("`+' flag"), N_("the `+' strfmon flag"), STD_C89
},
850 { '(', 0, 0, N_("`(' flag"), N_("the `(' strfmon flag"), STD_C89
},
851 { '!', 0, 0, N_("`!' flag"), N_("the `!' strfmon flag"), STD_C89
},
852 { '-', 0, 0, N_("`-' flag"), N_("the `-' strfmon flag"), STD_C89
},
853 { 'w', 0, 0, N_("field width"), N_("field width in strfmon format"), STD_C89
},
854 { '#', 0, 0, N_("left precision"), N_("left precision in strfmon format"), STD_C89
},
855 { 'p', 0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89
},
856 { 'L', 0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89
},
857 { 0, 0, 0, NULL
, NULL
, 0 }
860 static const format_flag_pair strfmon_flag_pairs
[] =
867 #define T_I &integer_type_node
868 #define T89_I { STD_C89, NULL, T_I }
869 #define T99_I { STD_C99, NULL, T_I }
870 #define T_L &long_integer_type_node
871 #define T89_L { STD_C89, NULL, T_L }
872 #define T_LL &long_long_integer_type_node
873 #define T9L_LL { STD_C9L, NULL, T_LL }
874 #define TEX_LL { STD_EXT, NULL, T_LL }
875 #define T_S &short_integer_type_node
876 #define T89_S { STD_C89, NULL, T_S }
877 #define T_UI &unsigned_type_node
878 #define T89_UI { STD_C89, NULL, T_UI }
879 #define T99_UI { STD_C99, NULL, T_UI }
880 #define T_UL &long_unsigned_type_node
881 #define T89_UL { STD_C89, NULL, T_UL }
882 #define T_ULL &long_long_unsigned_type_node
883 #define T9L_ULL { STD_C9L, NULL, T_ULL }
884 #define TEX_ULL { STD_EXT, NULL, T_ULL }
885 #define T_US &short_unsigned_type_node
886 #define T89_US { STD_C89, NULL, T_US }
887 #define T_F &float_type_node
888 #define T89_F { STD_C89, NULL, T_F }
889 #define T99_F { STD_C99, NULL, T_F }
890 #define T_D &double_type_node
891 #define T89_D { STD_C89, NULL, T_D }
892 #define T99_D { STD_C99, NULL, T_D }
893 #define T_LD &long_double_type_node
894 #define T89_LD { STD_C89, NULL, T_LD }
895 #define T99_LD { STD_C99, NULL, T_LD }
896 #define T_C &char_type_node
897 #define T89_C { STD_C89, NULL, T_C }
898 #define T_SC &signed_char_type_node
899 #define T99_SC { STD_C99, NULL, T_SC }
900 #define T_UC &unsigned_char_type_node
901 #define T99_UC { STD_C99, NULL, T_UC }
902 #define T_V &void_type_node
903 #define T89_V { STD_C89, NULL, T_V }
904 #define T_W &wchar_type_node
905 #define T94_W { STD_C94, "wchar_t", T_W }
906 #define TEX_W { STD_EXT, "wchar_t", T_W }
907 #define T_WI &wint_type_node
908 #define T94_WI { STD_C94, "wint_t", T_WI }
909 #define TEX_WI { STD_EXT, "wint_t", T_WI }
910 #define T_ST &c_size_type_node
911 #define T99_ST { STD_C99, "size_t", T_ST }
912 #define T_SST &signed_size_type_node
913 #define T99_SST { STD_C99, "signed size_t", T_SST }
914 #define T_PD &ptrdiff_type_node
915 #define T99_PD { STD_C99, "ptrdiff_t", T_PD }
916 #define T_UPD &unsigned_ptrdiff_type_node
917 #define T99_UPD { STD_C99, "unsigned ptrdiff_t", T_UPD }
918 #define T_IM &intmax_type_node
919 #define T99_IM { STD_C99, "intmax_t", T_IM }
920 #define T_UIM &uintmax_type_node
921 #define T99_UIM { STD_C99, "uintmax_t", T_UIM }
923 static const format_char_info print_char_table
[] =
925 /* C89 conversion specifiers. */
926 { "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" },
927 { "oxX", 0, STD_C89
, { T89_UI
, T99_UC
, T89_US
, T89_UL
, T9L_ULL
, TEX_ULL
, T99_ST
, T99_UPD
, T99_UIM
}, "-wp0#", "i" },
928 { "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" },
929 { "fgG", 0, STD_C89
, { T89_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T89_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#'", "" },
930 { "eE", 0, STD_C89
, { T89_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T89_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#", "" },
931 { "c", 0, STD_C89
, { T89_I
, BADLEN
, BADLEN
, T94_WI
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-w", "" },
932 { "s", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-wp", "cR" },
933 { "p", 1, STD_C89
, { T89_V
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-w", "c" },
934 { "n", 1, STD_C89
, { T89_I
, T99_SC
, T89_S
, T89_L
, T9L_LL
, BADLEN
, T99_SST
, T99_PD
, T99_IM
}, "", "W" },
935 /* C99 conversion specifiers. */
936 { "F", 0, STD_C99
, { T99_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T99_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#'", "" },
937 { "aA", 0, STD_C99
, { T99_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T99_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#", "" },
938 /* X/Open conversion specifiers. */
939 { "C", 0, STD_EXT
, { TEX_WI
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-w", "" },
940 { "S", 1, STD_EXT
, { TEX_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-wp", "R" },
941 /* GNU conversion specifiers. */
942 { "m", 0, STD_EXT
, { T89_V
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-wp", "" },
943 { NULL
, 0, 0, NOLENGTHS
, NULL
, NULL
}
946 static const format_char_info scan_char_table
[] =
948 /* C89 conversion specifiers. */
949 { "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" },
950 { "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" },
951 { "oxX", 1, STD_C89
, { T89_UI
, T99_UC
, T89_US
, T89_UL
, T9L_ULL
, TEX_ULL
, T99_ST
, T99_UPD
, T99_UIM
}, "*w", "W" },
952 { "efgEG", 1, STD_C89
, { T89_F
, BADLEN
, BADLEN
, T89_D
, BADLEN
, T89_LD
, BADLEN
, BADLEN
, BADLEN
}, "*w'", "W" },
953 { "c", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*w", "cW" },
954 { "s", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*aw", "cW" },
955 { "[", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*aw", "cW[" },
956 { "p", 2, STD_C89
, { T89_V
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*w", "W" },
957 { "n", 1, STD_C89
, { T89_I
, T99_SC
, T89_S
, T89_L
, T9L_LL
, BADLEN
, T99_SST
, T99_PD
, T99_IM
}, "", "W" },
958 /* C99 conversion specifiers. */
959 { "FaA", 1, STD_C99
, { T99_F
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T99_LD
, BADLEN
, BADLEN
, BADLEN
}, "*w'", "W" },
960 /* X/Open conversion specifiers. */
961 { "C", 1, STD_EXT
, { TEX_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*w", "W" },
962 { "S", 1, STD_EXT
, { TEX_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*aw", "W" },
963 { NULL
, 0, 0, NOLENGTHS
, NULL
, NULL
}
966 static const format_char_info time_char_table
[] =
968 /* C89 conversion specifiers. */
969 { "ABZab", 0, STD_C89
, NOLENGTHS
, "^#", "" },
970 { "cx", 0, STD_C89
, NOLENGTHS
, "E", "3" },
971 { "HIMSUWdmw", 0, STD_C89
, NOLENGTHS
, "-_0Ow", "" },
972 { "j", 0, STD_C89
, NOLENGTHS
, "-_0Ow", "o" },
973 { "p", 0, STD_C89
, NOLENGTHS
, "#", "" },
974 { "X", 0, STD_C89
, NOLENGTHS
, "E", "" },
975 { "y", 0, STD_C89
, NOLENGTHS
, "EO-_0w", "4" },
976 { "Y", 0, STD_C89
, NOLENGTHS
, "-_0EOw", "o" },
977 { "%", 0, STD_C89
, NOLENGTHS
, "", "" },
978 /* C99 conversion specifiers. */
979 { "C", 0, STD_C99
, NOLENGTHS
, "-_0EOw", "o" },
980 { "D", 0, STD_C99
, NOLENGTHS
, "", "2" },
981 { "eVu", 0, STD_C99
, NOLENGTHS
, "-_0Ow", "" },
982 { "FRTnrt", 0, STD_C99
, NOLENGTHS
, "", "" },
983 { "g", 0, STD_C99
, NOLENGTHS
, "O-_0w", "2o" },
984 { "G", 0, STD_C99
, NOLENGTHS
, "-_0Ow", "o" },
985 { "h", 0, STD_C99
, NOLENGTHS
, "^#", "" },
986 { "z", 0, STD_C99
, NOLENGTHS
, "O", "o" },
987 /* GNU conversion specifiers. */
988 { "kls", 0, STD_EXT
, NOLENGTHS
, "-_0Ow", "" },
989 { "P", 0, STD_EXT
, NOLENGTHS
, "", "" },
990 { NULL
, 0, 0, NOLENGTHS
, NULL
, NULL
}
993 static const format_char_info monetary_char_table
[] =
995 { "in", 0, STD_C89
, { T89_D
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, T89_LD
, BADLEN
, BADLEN
, BADLEN
}, "=^+(!-w#p", "" },
996 { NULL
, 0, 0, NOLENGTHS
, NULL
, NULL
}
1000 /* This must be in the same order as enum format_type. */
1001 static const format_kind_info format_types
[] =
1003 { "printf", printf_length_specs
, print_char_table
, " +#0-'I", NULL
,
1004 printf_flag_specs
, printf_flag_pairs
,
1005 FMT_FLAG_ARG_CONVERT
|FMT_FLAG_DOLLAR_MULTIPLE
|FMT_FLAG_USE_DOLLAR
|FMT_FLAG_EMPTY_PREC_OK
,
1006 'w', 0, 'p', 0, 'L',
1007 &integer_type_node
, &integer_type_node
1009 { "scanf", scanf_length_specs
, scan_char_table
, "*'I", NULL
,
1010 scanf_flag_specs
, scanf_flag_pairs
,
1011 FMT_FLAG_ARG_CONVERT
|FMT_FLAG_SCANF_A_KLUDGE
|FMT_FLAG_USE_DOLLAR
|FMT_FLAG_ZERO_WIDTH_BAD
,
1012 'w', 0, 0, '*', 'L',
1015 { "strftime", NULL
, time_char_table
, "_-0^#", "EO",
1016 strftime_flag_specs
, strftime_flag_pairs
,
1017 FMT_FLAG_FANCY_PERCENT_OK
, 'w', 0, 0, 0, 0,
1020 { "strfmon", strfmon_length_specs
, monetary_char_table
, "=^+(!-", NULL
,
1021 strfmon_flag_specs
, strfmon_flag_pairs
,
1022 FMT_FLAG_ARG_CONVERT
, 'w', '#', 'p', 0, 'L',
1028 /* Structure detailing the results of checking a format function call
1029 where the format expression may be a conditional expression with
1030 many leaves resulting from nested conditional expressions. */
1033 /* Number of leaves of the format argument that could not be checked
1034 as they were not string literals. */
1035 int number_non_literal
;
1036 /* Number of leaves of the format argument that were null pointers or
1037 string literals, but had extra format arguments. */
1038 int number_extra_args
;
1039 /* Number of leaves of the format argument that were null pointers or
1040 string literals, but had extra format arguments and used $ operand
1042 int number_dollar_extra_args
;
1043 /* Number of leaves of the format argument that were wide string
1046 /* Number of leaves of the format argument that were empty strings. */
1048 /* Number of leaves of the format argument that were unterminated
1050 int number_unterminated
;
1051 /* Number of leaves of the format argument that were not counted above. */
1053 } format_check_results
;
1055 static void check_format_info
PARAMS ((int *, function_format_info
*, tree
));
1056 static void check_format_info_recurse
PARAMS ((int *, format_check_results
*,
1057 function_format_info
*, tree
,
1059 static void check_format_info_main
PARAMS ((int *, format_check_results
*,
1060 function_format_info
*,
1061 const char *, int, tree
, int));
1062 static void status_warning
PARAMS ((int *, const char *, ...))
1065 static void init_dollar_format_checking
PARAMS ((int, tree
));
1066 static int maybe_read_dollar_number
PARAMS ((int *, const char **, int,
1068 const format_kind_info
*));
1069 static void finish_dollar_format_checking
PARAMS ((int *, format_check_results
*));
1071 static const format_flag_spec
*get_flag_spec
PARAMS ((const format_flag_spec
*,
1072 int, const char *));
1074 static void check_format_types
PARAMS ((int *, format_wanted_type
*));
1076 /* Decode a format type from a string, returning the type, or
1077 format_type_error if not valid, in which case the caller should print an
1079 static enum format_type
1080 decode_format_type (s
)
1086 for (i
= 0; i
< (int) format_type_error
; i
++)
1089 if (!strcmp (s
, format_types
[i
].name
))
1091 alen
= strlen (format_types
[i
].name
);
1092 if (slen
== alen
+ 4 && s
[0] == '_' && s
[1] == '_'
1093 && s
[slen
- 1] == '_' && s
[slen
- 2] == '_'
1094 && !strncmp (s
+ 2, format_types
[i
].name
, alen
))
1097 return ((enum format_type
) i
);
1101 /* Check the argument list of a call to printf, scanf, etc.
1102 NAME is the function identifier.
1103 ASSEMBLER_NAME is the function's assembler identifier.
1104 (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
1105 PARAMS is the list of argument values. Also, if -Wmissing-format-attribute,
1106 warn for calls to vprintf or vscanf in functions with no such format
1107 attribute themselves. */
1110 check_function_format (status
, name
, assembler_name
, params
)
1113 tree assembler_name
;
1116 function_format_info
*info
;
1118 /* See if this function is a format function. */
1119 for (info
= function_format_list
; info
; info
= info
->next
)
1121 if (info
->assembler_name
1122 ? (info
->assembler_name
== assembler_name
)
1123 : (info
->name
== name
))
1125 /* Yup; check it. */
1126 check_format_info (status
, info
, params
);
1127 if (warn_missing_format_attribute
&& info
->first_arg_num
== 0
1128 && (format_types
[info
->format_type
].flags
1129 & (int) FMT_FLAG_ARG_CONVERT
))
1131 function_format_info
*info2
;
1132 for (info2
= function_format_list
; info2
; info2
= info2
->next
)
1133 if ((info2
->assembler_name
1134 ? (info2
->assembler_name
== DECL_ASSEMBLER_NAME (current_function_decl
))
1135 : (info2
->name
== DECL_NAME (current_function_decl
)))
1136 && info2
->format_type
== info
->format_type
)
1140 /* Check if the current function has a parameter to which
1141 the format attribute could be attached; if not, it
1142 can't be a candidate for a format attribute, despite
1143 the vprintf-like or vscanf-like call. */
1145 for (args
= DECL_ARGUMENTS (current_function_decl
);
1147 args
= TREE_CHAIN (args
))
1149 if (TREE_CODE (TREE_TYPE (args
)) == POINTER_TYPE
1150 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (args
)))
1155 warning ("function might be possible candidate for `%s' format attribute",
1156 format_types
[info
->format_type
].name
);
1164 /* This function replaces `warning' inside the printf format checking
1165 functions. If the `status' parameter is non-NULL, then it is
1166 dereferenced and set to 1 whenever a warning is caught. Otherwise
1167 it warns as usual by replicating the innards of the warning
1168 function from diagnostic.c. */
1170 status_warning
VPARAMS ((int *status
, const char *msgid
, ...))
1172 diagnostic_context dc
;
1174 VA_OPEN (ap
, msgid
);
1175 VA_FIXEDARG (ap
, int *, status
);
1176 VA_FIXEDARG (ap
, const char *, msgid
);
1182 /* This duplicates the warning function behavior. */
1183 set_diagnostic_context
1184 (&dc
, msgid
, &ap
, input_filename
, lineno
, /* warn = */ 1);
1185 report_diagnostic (&dc
);
1191 /* Variables used by the checking of $ operand number formats. */
1192 static char *dollar_arguments_used
= NULL
;
1193 static int dollar_arguments_alloc
= 0;
1194 static int dollar_arguments_count
;
1195 static int dollar_first_arg_num
;
1196 static int dollar_max_arg_used
;
1197 static int dollar_format_warned
;
1199 /* Initialize the checking for a format string that may contain $
1200 parameter number specifications; we will need to keep track of whether
1201 each parameter has been used. FIRST_ARG_NUM is the number of the first
1202 argument that is a parameter to the format, or 0 for a vprintf-style
1203 function; PARAMS is the list of arguments starting at this argument. */
1206 init_dollar_format_checking (first_arg_num
, params
)
1210 dollar_first_arg_num
= first_arg_num
;
1211 dollar_arguments_count
= 0;
1212 dollar_max_arg_used
= 0;
1213 dollar_format_warned
= 0;
1214 if (first_arg_num
> 0)
1218 dollar_arguments_count
++;
1219 params
= TREE_CHAIN (params
);
1222 if (dollar_arguments_alloc
< dollar_arguments_count
)
1224 if (dollar_arguments_used
)
1225 free (dollar_arguments_used
);
1226 dollar_arguments_alloc
= dollar_arguments_count
;
1227 dollar_arguments_used
= xmalloc (dollar_arguments_alloc
);
1229 if (dollar_arguments_alloc
)
1230 memset (dollar_arguments_used
, 0, dollar_arguments_alloc
);
1234 /* Look for a decimal number followed by a $ in *FORMAT. If DOLLAR_NEEDED
1235 is set, it is an error if one is not found; otherwise, it is OK. If
1236 such a number is found, check whether it is within range and mark that
1237 numbered operand as being used for later checking. Returns the operand
1238 number if found and within range, zero if no such number was found and
1239 this is OK, or -1 on error. PARAMS points to the first operand of the
1240 format; PARAM_PTR is made to point to the parameter referred to. If
1241 a $ format is found, *FORMAT is updated to point just after it. */
1244 maybe_read_dollar_number (status
, format
, dollar_needed
, params
, param_ptr
,
1247 const char **format
;
1251 const format_kind_info
*fki
;
1255 const char *fcp
= *format
;
1256 if (*fcp
< '0' || *fcp
> '9')
1260 status_warning (status
, "missing $ operand number in format");
1268 while (*fcp
>= '0' && *fcp
<= '9')
1271 nargnum
= 10 * argnum
+ (*fcp
- '0');
1272 if (nargnum
< 0 || nargnum
/ 10 != argnum
)
1281 status_warning (status
, "missing $ operand number in format");
1288 if (pedantic
&& !dollar_format_warned
)
1290 status_warning (status
,
1291 "%s does not support %%n$ operand number formats",
1292 C_STD_NAME (STD_EXT
));
1293 dollar_format_warned
= 1;
1295 if (overflow_flag
|| argnum
== 0
1296 || (dollar_first_arg_num
&& argnum
> dollar_arguments_count
))
1298 status_warning (status
, "operand number out of range in format");
1301 if (argnum
> dollar_max_arg_used
)
1302 dollar_max_arg_used
= argnum
;
1303 /* For vprintf-style functions we may need to allocate more memory to
1304 track which arguments are used. */
1305 while (dollar_arguments_alloc
< dollar_max_arg_used
)
1308 nalloc
= 2 * dollar_arguments_alloc
+ 16;
1309 dollar_arguments_used
= xrealloc (dollar_arguments_used
, nalloc
);
1310 memset (dollar_arguments_used
+ dollar_arguments_alloc
, 0,
1311 nalloc
- dollar_arguments_alloc
);
1312 dollar_arguments_alloc
= nalloc
;
1314 if (!(fki
->flags
& (int) FMT_FLAG_DOLLAR_MULTIPLE
)
1315 && dollar_arguments_used
[argnum
- 1] == 1)
1317 dollar_arguments_used
[argnum
- 1] = 2;
1318 status_warning (status
,
1319 "format argument %d used more than once in %s format",
1323 dollar_arguments_used
[argnum
- 1] = 1;
1324 if (dollar_first_arg_num
)
1327 *param_ptr
= params
;
1328 for (i
= 1; i
< argnum
&& *param_ptr
!= 0; i
++)
1329 *param_ptr
= TREE_CHAIN (*param_ptr
);
1331 if (*param_ptr
== 0)
1333 /* This case shouldn't be caught here. */
1343 /* Finish the checking for a format string that used $ operand number formats
1344 instead of non-$ formats. We check for unused operands before used ones
1345 (a serious error, since the implementation of the format function
1346 can't know what types to pass to va_arg to find the later arguments).
1347 and for unused operands at the end of the format (if we know how many
1348 arguments the format had, so not for vprintf). If there were operand
1349 numbers out of range on a non-vprintf-style format, we won't have reached
1353 finish_dollar_format_checking (status
, res
)
1355 format_check_results
*res
;
1358 for (i
= 0; i
< dollar_max_arg_used
; i
++)
1360 if (!dollar_arguments_used
[i
])
1361 status_warning (status
, "format argument %d unused before used argument %d in $-style format",
1362 i
+ 1, dollar_max_arg_used
);
1364 if (dollar_first_arg_num
&& dollar_max_arg_used
< dollar_arguments_count
)
1366 res
->number_other
--;
1367 res
->number_dollar_extra_args
++;
1372 /* Retrieve the specification for a format flag. SPEC contains the
1373 specifications for format flags for the applicable kind of format.
1374 FLAG is the flag in question. If PREDICATES is NULL, the basic
1375 spec for that flag must be retrieved and this function aborts if
1376 it cannot be found. If PREDICATES is not NULL, it is a string listing
1377 possible predicates for the spec entry; if an entry predicated on any
1378 of these is found, it is returned, otherwise NULL is returned. */
1380 static const format_flag_spec
*
1381 get_flag_spec (spec
, flag
, predicates
)
1382 const format_flag_spec
*spec
;
1384 const char *predicates
;
1387 for (i
= 0; spec
[i
].flag_char
!= 0; i
++)
1389 if (spec
[i
].flag_char
!= flag
)
1391 if (predicates
!= NULL
)
1393 if (spec
[i
].predicate
!= 0
1394 && strchr (predicates
, spec
[i
].predicate
) != 0)
1397 else if (spec
[i
].predicate
== 0)
1400 if (predicates
== NULL
)
1407 /* Check the argument list of a call to printf, scanf, etc.
1408 INFO points to the function_format_info structure.
1409 PARAMS is the list of argument values. */
1412 check_format_info (status
, info
, params
)
1414 function_format_info
*info
;
1419 format_check_results res
;
1420 /* Skip to format argument. If the argument isn't available, there's
1421 no work for us to do; prototype checking will catch the problem. */
1422 for (arg_num
= 1; ; ++arg_num
)
1426 if (arg_num
== info
->format_num
)
1428 params
= TREE_CHAIN (params
);
1430 format_tree
= TREE_VALUE (params
);
1431 params
= TREE_CHAIN (params
);
1432 if (format_tree
== 0)
1435 res
.number_non_literal
= 0;
1436 res
.number_extra_args
= 0;
1437 res
.number_dollar_extra_args
= 0;
1438 res
.number_wide
= 0;
1439 res
.number_empty
= 0;
1440 res
.number_unterminated
= 0;
1441 res
.number_other
= 0;
1443 check_format_info_recurse (status
, &res
, info
, format_tree
, params
, arg_num
);
1445 if (res
.number_non_literal
> 0)
1447 /* Functions taking a va_list normally pass a non-literal format
1448 string. These functions typically are declared with
1449 first_arg_num == 0, so avoid warning in those cases. */
1450 if (!(format_types
[info
->format_type
].flags
& (int) FMT_FLAG_ARG_CONVERT
))
1452 /* For strftime-like formats, warn for not checking the format
1453 string; but there are no arguments to check. */
1454 if (warn_format_nonliteral
)
1455 status_warning (status
, "format not a string literal, format string not checked");
1457 else if (info
->first_arg_num
!= 0)
1459 /* If there are no arguments for the format at all, we may have
1460 printf (foo) which is likely to be a security hole. */
1461 while (arg_num
+ 1 < info
->first_arg_num
)
1465 params
= TREE_CHAIN (params
);
1468 if (params
== 0 && (warn_format_nonliteral
|| warn_format_security
))
1469 status_warning (status
, "format not a string literal and no format arguments");
1470 else if (warn_format_nonliteral
)
1471 status_warning (status
, "format not a string literal, argument types not checked");
1475 /* If there were extra arguments to the format, normally warn. However,
1476 the standard does say extra arguments are ignored, so in the specific
1477 case where we have multiple leaves (conditional expressions or
1478 ngettext) allow extra arguments if at least one leaf didn't have extra
1479 arguments, but was otherwise OK (either non-literal or checked OK).
1480 If the format is an empty string, this should be counted similarly to the
1481 case of extra format arguments. */
1482 if (res
.number_extra_args
> 0 && res
.number_non_literal
== 0
1483 && res
.number_other
== 0 && warn_format_extra_args
)
1484 status_warning (status
, "too many arguments for format");
1485 if (res
.number_dollar_extra_args
> 0 && res
.number_non_literal
== 0
1486 && res
.number_other
== 0 && warn_format_extra_args
)
1487 status_warning (status
, "unused arguments in $-style format");
1488 if (res
.number_empty
> 0 && res
.number_non_literal
== 0
1489 && res
.number_other
== 0)
1490 status_warning (status
, "zero-length format string");
1492 if (res
.number_wide
> 0)
1493 status_warning (status
, "format is a wide character string");
1495 if (res
.number_unterminated
> 0)
1496 status_warning (status
, "unterminated format string");
1500 /* Recursively check a call to a format function. FORMAT_TREE is the
1501 format parameter, which may be a conditional expression in which
1502 both halves should be checked. ARG_NUM is the number of the
1503 format argument; PARAMS points just after it in the argument list. */
1506 check_format_info_recurse (status
, res
, info
, format_tree
, params
, arg_num
)
1508 format_check_results
*res
;
1509 function_format_info
*info
;
1515 HOST_WIDE_INT offset
;
1516 const char *format_chars
;
1517 tree array_size
= 0;
1520 if (TREE_CODE (format_tree
) == NOP_EXPR
)
1522 /* Strip coercion. */
1523 check_format_info_recurse (status
, res
, info
,
1524 TREE_OPERAND (format_tree
, 0), params
,
1529 if (TREE_CODE (format_tree
) == CALL_EXPR
1530 && TREE_CODE (TREE_OPERAND (format_tree
, 0)) == ADDR_EXPR
1531 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (format_tree
, 0), 0))
1534 tree function
= TREE_OPERAND (TREE_OPERAND (format_tree
, 0), 0);
1536 /* See if this is a call to a known internationalization function
1537 that modifies the format arg. */
1538 international_format_info
*iinfo
;
1540 for (iinfo
= international_format_list
; iinfo
; iinfo
= iinfo
->next
)
1541 if (iinfo
->assembler_name
1542 ? (iinfo
->assembler_name
== DECL_ASSEMBLER_NAME (function
))
1543 : (iinfo
->name
== DECL_NAME (function
)))
1548 for (inner_args
= TREE_OPERAND (format_tree
, 1), i
= 1;
1550 inner_args
= TREE_CHAIN (inner_args
), i
++)
1551 if (i
== iinfo
->format_num
)
1553 /* FIXME: with Marc Espie's __attribute__((nonnull))
1554 patch in GCC, we will have chained attributes,
1555 and be able to handle functions like ngettext
1556 with multiple format_arg attributes properly. */
1557 check_format_info_recurse (status
, res
, info
,
1558 TREE_VALUE (inner_args
), params
,
1565 if (TREE_CODE (format_tree
) == COND_EXPR
)
1567 /* Check both halves of the conditional expression. */
1568 check_format_info_recurse (status
, res
, info
,
1569 TREE_OPERAND (format_tree
, 1), params
,
1571 check_format_info_recurse (status
, res
, info
,
1572 TREE_OPERAND (format_tree
, 2), params
,
1577 if (integer_zerop (format_tree
))
1579 /* FIXME: this warning should go away once Marc Espie's
1580 __attribute__((nonnull)) patch is in. Instead, checking for
1581 nonnull attributes should probably change this function to act
1582 specially if info == NULL and add a res->number_null entry for
1583 that case, or maybe add a function pointer to be called at
1584 the end instead of hardcoding check_format_info_main. */
1585 status_warning (status
, "null format string");
1587 /* Skip to first argument to check, so we can see if this format
1588 has any arguments (it shouldn't). */
1589 while (arg_num
+ 1 < info
->first_arg_num
)
1593 params
= TREE_CHAIN (params
);
1598 res
->number_other
++;
1600 res
->number_extra_args
++;
1606 if (TREE_CODE (format_tree
) == PLUS_EXPR
)
1610 arg0
= TREE_OPERAND (format_tree
, 0);
1611 arg1
= TREE_OPERAND (format_tree
, 1);
1614 if (TREE_CODE (arg1
) == INTEGER_CST
)
1616 else if (TREE_CODE (arg0
) == INTEGER_CST
)
1623 res
->number_non_literal
++;
1626 if (!host_integerp (arg1
, 1))
1628 res
->number_non_literal
++;
1632 offset
= TREE_INT_CST_LOW (arg1
);
1634 if (TREE_CODE (format_tree
) != ADDR_EXPR
)
1636 res
->number_non_literal
++;
1639 format_tree
= TREE_OPERAND (format_tree
, 0);
1640 if (TREE_CODE (format_tree
) == VAR_DECL
1641 && TREE_CODE (TREE_TYPE (format_tree
)) == ARRAY_TYPE
1642 && (array_init
= decl_constant_value (format_tree
)) != format_tree
1643 && TREE_CODE (array_init
) == STRING_CST
)
1645 /* Extract the string constant initializer. Note that this may include
1646 a trailing NUL character that is not in the array (e.g.
1647 const char a[3] = "foo";). */
1648 array_size
= DECL_SIZE_UNIT (format_tree
);
1649 format_tree
= array_init
;
1651 if (TREE_CODE (format_tree
) != STRING_CST
)
1653 res
->number_non_literal
++;
1656 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree
))) != char_type_node
)
1661 format_chars
= TREE_STRING_POINTER (format_tree
);
1662 format_length
= TREE_STRING_LENGTH (format_tree
);
1663 if (array_size
!= 0)
1665 /* Variable length arrays can't be initialized. */
1666 if (TREE_CODE (array_size
) != INTEGER_CST
)
1668 if (host_integerp (array_size
, 0))
1670 HOST_WIDE_INT array_size_value
= TREE_INT_CST_LOW (array_size
);
1671 if (array_size_value
> 0
1672 && array_size_value
== (int) array_size_value
1673 && format_length
> array_size_value
)
1674 format_length
= array_size_value
;
1679 if (offset
>= format_length
)
1681 res
->number_non_literal
++;
1684 format_chars
+= offset
;
1685 format_length
-= offset
;
1687 if (format_length
< 1)
1689 res
->number_unterminated
++;
1692 if (format_length
== 1)
1694 res
->number_empty
++;
1697 if (format_chars
[--format_length
] != 0)
1699 res
->number_unterminated
++;
1703 /* Skip to first argument to check. */
1704 while (arg_num
+ 1 < info
->first_arg_num
)
1708 params
= TREE_CHAIN (params
);
1711 /* Provisionally increment res->number_other; check_format_info_main
1712 will decrement it if it finds there are extra arguments, but this way
1713 need not adjust it for every return. */
1714 res
->number_other
++;
1715 check_format_info_main (status
, res
, info
, format_chars
, format_length
,
1720 /* Do the main part of checking a call to a format function. FORMAT_CHARS
1721 is the NUL-terminated format string (which at this point may contain
1722 internal NUL characters); FORMAT_LENGTH is its length (excluding the
1723 terminating NUL character). ARG_NUM is one less than the number of
1724 the first format argument to check; PARAMS points to that format
1725 argument in the list of arguments. */
1728 check_format_info_main (status
, res
, info
, format_chars
, format_length
,
1731 format_check_results
*res
;
1732 function_format_info
*info
;
1733 const char *format_chars
;
1738 const char *orig_format_chars
= format_chars
;
1739 tree first_fillin_param
= params
;
1741 const format_kind_info
*fki
= &format_types
[info
->format_type
];
1742 const format_flag_spec
*flag_specs
= fki
->flag_specs
;
1743 const format_flag_pair
*bad_flag_pairs
= fki
->bad_flag_pairs
;
1745 /* -1 if no conversions taking an operand have been found; 0 if one has
1746 and it didn't use $; 1 if $ formats are in use. */
1747 int has_operand_number
= -1;
1749 init_dollar_format_checking (info
->first_arg_num
, first_fillin_param
);
1754 int suppressed
= FALSE
;
1755 const char *length_chars
= NULL
;
1756 enum format_lengths length_chars_val
= FMT_LEN_none
;
1757 enum format_std_version length_chars_std
= STD_C89
;
1761 int main_arg_num
= 0;
1762 tree main_arg_params
= 0;
1763 enum format_std_version wanted_type_std
;
1764 const char *wanted_type_name
;
1765 format_wanted_type width_wanted_type
;
1766 format_wanted_type precision_wanted_type
;
1767 format_wanted_type main_wanted_type
;
1768 format_wanted_type
*first_wanted_type
= NULL
;
1769 format_wanted_type
*last_wanted_type
= NULL
;
1770 const format_length_info
*fli
= NULL
;
1771 const format_char_info
*fci
= NULL
;
1772 char flag_chars
[256];
1774 if (*format_chars
== 0)
1776 if (format_chars
- orig_format_chars
!= format_length
)
1777 status_warning (status
, "embedded `\\0' in format");
1778 if (info
->first_arg_num
!= 0 && params
!= 0
1779 && has_operand_number
<= 0)
1781 res
->number_other
--;
1782 res
->number_extra_args
++;
1784 if (has_operand_number
> 0)
1785 finish_dollar_format_checking (status
, res
);
1788 if (*format_chars
++ != '%')
1790 if (*format_chars
== 0)
1792 status_warning (status
, "spurious trailing `%%' in format");
1795 if (*format_chars
== '%')
1802 if ((fki
->flags
& (int) FMT_FLAG_USE_DOLLAR
) && has_operand_number
!= 0)
1804 /* Possibly read a $ operand number at the start of the format.
1805 If one was previously used, one is required here. If one
1806 is not used here, we can't immediately conclude this is a
1807 format without them, since it could be printf %m or scanf %*. */
1809 opnum
= maybe_read_dollar_number (status
, &format_chars
, 0,
1811 &main_arg_params
, fki
);
1816 has_operand_number
= 1;
1817 main_arg_num
= opnum
+ info
->first_arg_num
- 1;
1821 /* Read any format flags, but do not yet validate them beyond removing
1822 duplicates, since in general validation depends on the rest of
1824 while (*format_chars
!= 0
1825 && strchr (fki
->flag_chars
, *format_chars
) != 0)
1827 const format_flag_spec
*s
= get_flag_spec (flag_specs
,
1828 *format_chars
, NULL
);
1829 if (strchr (flag_chars
, *format_chars
) != 0)
1831 status_warning (status
, "repeated %s in format", _(s
->name
));
1835 i
= strlen (flag_chars
);
1836 flag_chars
[i
++] = *format_chars
;
1839 if (s
->skip_next_char
)
1842 if (*format_chars
== 0)
1844 status_warning (status
, "missing fill character at end of strfmon format");
1851 /* Read any format width, possibly * or *m$. */
1852 if (fki
->width_char
!= 0)
1854 if (fki
->width_type
!= NULL
&& *format_chars
== '*')
1856 i
= strlen (flag_chars
);
1857 flag_chars
[i
++] = fki
->width_char
;
1859 /* "...a field width...may be indicated by an asterisk.
1860 In this case, an int argument supplies the field width..." */
1864 status_warning (status
, "too few arguments for format");
1867 if (has_operand_number
!= 0)
1870 opnum
= maybe_read_dollar_number (status
, &format_chars
,
1871 has_operand_number
== 1,
1878 has_operand_number
= 1;
1879 arg_num
= opnum
+ info
->first_arg_num
- 1;
1882 has_operand_number
= 0;
1884 if (info
->first_arg_num
!= 0)
1886 cur_param
= TREE_VALUE (params
);
1887 if (has_operand_number
<= 0)
1889 params
= TREE_CHAIN (params
);
1892 width_wanted_type
.wanted_type
= *fki
->width_type
;
1893 width_wanted_type
.wanted_type_name
= NULL
;
1894 width_wanted_type
.pointer_count
= 0;
1895 width_wanted_type
.char_lenient_flag
= 0;
1896 width_wanted_type
.writing_in_flag
= 0;
1897 width_wanted_type
.reading_from_flag
= 0;
1898 width_wanted_type
.name
= _("field width");
1899 width_wanted_type
.param
= cur_param
;
1900 width_wanted_type
.arg_num
= arg_num
;
1901 width_wanted_type
.next
= NULL
;
1902 if (last_wanted_type
!= 0)
1903 last_wanted_type
->next
= &width_wanted_type
;
1904 if (first_wanted_type
== 0)
1905 first_wanted_type
= &width_wanted_type
;
1906 last_wanted_type
= &width_wanted_type
;
1911 /* Possibly read a numeric width. If the width is zero,
1912 we complain if appropriate. */
1913 int non_zero_width_char
= FALSE
;
1914 int found_width
= FALSE
;
1915 while (ISDIGIT (*format_chars
))
1918 if (*format_chars
!= '0')
1919 non_zero_width_char
= TRUE
;
1922 if (found_width
&& !non_zero_width_char
&&
1923 (fki
->flags
& (int) FMT_FLAG_ZERO_WIDTH_BAD
))
1924 status_warning (status
, "zero width in %s format",
1928 i
= strlen (flag_chars
);
1929 flag_chars
[i
++] = fki
->width_char
;
1935 /* Read any format left precision (must be a number, not *). */
1936 if (fki
->left_precision_char
!= 0 && *format_chars
== '#')
1939 i
= strlen (flag_chars
);
1940 flag_chars
[i
++] = fki
->left_precision_char
;
1942 if (!ISDIGIT (*format_chars
))
1943 status_warning (status
, "empty left precision in %s format",
1945 while (ISDIGIT (*format_chars
))
1949 /* Read any format precision, possibly * or *m$. */
1950 if (fki
->precision_char
!= 0 && *format_chars
== '.')
1953 i
= strlen (flag_chars
);
1954 flag_chars
[i
++] = fki
->precision_char
;
1956 if (fki
->precision_type
!= NULL
&& *format_chars
== '*')
1958 /* "...a...precision...may be indicated by an asterisk.
1959 In this case, an int argument supplies the...precision." */
1961 if (has_operand_number
!= 0)
1964 opnum
= maybe_read_dollar_number (status
, &format_chars
,
1965 has_operand_number
== 1,
1972 has_operand_number
= 1;
1973 arg_num
= opnum
+ info
->first_arg_num
- 1;
1976 has_operand_number
= 0;
1978 if (info
->first_arg_num
!= 0)
1982 status_warning (status
, "too few arguments for format");
1985 cur_param
= TREE_VALUE (params
);
1986 if (has_operand_number
<= 0)
1988 params
= TREE_CHAIN (params
);
1991 precision_wanted_type
.wanted_type
= *fki
->precision_type
;
1992 precision_wanted_type
.wanted_type_name
= NULL
;
1993 precision_wanted_type
.pointer_count
= 0;
1994 precision_wanted_type
.char_lenient_flag
= 0;
1995 precision_wanted_type
.writing_in_flag
= 0;
1996 precision_wanted_type
.reading_from_flag
= 0;
1997 precision_wanted_type
.name
= _("field precision");
1998 precision_wanted_type
.param
= cur_param
;
1999 precision_wanted_type
.arg_num
= arg_num
;
2000 precision_wanted_type
.next
= NULL
;
2001 if (last_wanted_type
!= 0)
2002 last_wanted_type
->next
= &precision_wanted_type
;
2003 if (first_wanted_type
== 0)
2004 first_wanted_type
= &precision_wanted_type
;
2005 last_wanted_type
= &precision_wanted_type
;
2010 if (!(fki
->flags
& (int) FMT_FLAG_EMPTY_PREC_OK
)
2011 && !ISDIGIT (*format_chars
))
2012 status_warning (status
, "empty precision in %s format",
2014 while (ISDIGIT (*format_chars
))
2019 /* Read any length modifier, if this kind of format has them. */
2020 fli
= fki
->length_char_specs
;
2021 length_chars
= NULL
;
2022 length_chars_val
= FMT_LEN_none
;
2023 length_chars_std
= STD_C89
;
2026 while (fli
->name
!= 0 && fli
->name
[0] != *format_chars
)
2031 if (fli
->double_name
!= 0 && fli
->name
[0] == *format_chars
)
2034 length_chars
= fli
->double_name
;
2035 length_chars_val
= fli
->double_index
;
2036 length_chars_std
= fli
->double_std
;
2040 length_chars
= fli
->name
;
2041 length_chars_val
= fli
->index
;
2042 length_chars_std
= fli
->std
;
2044 i
= strlen (flag_chars
);
2045 flag_chars
[i
++] = fki
->length_code_char
;
2050 /* Warn if the length modifier is non-standard. */
2051 if (ADJ_STD (length_chars_std
) > C_STD_VER
)
2052 status_warning (status
, "%s does not support the `%s' %s length modifier",
2053 C_STD_NAME (length_chars_std
), length_chars
,
2058 /* Read any modifier (strftime E/O). */
2059 if (fki
->modifier_chars
!= NULL
)
2061 while (*format_chars
!= 0
2062 && strchr (fki
->modifier_chars
, *format_chars
) != 0)
2064 if (strchr (flag_chars
, *format_chars
) != 0)
2066 const format_flag_spec
*s
= get_flag_spec (flag_specs
,
2067 *format_chars
, NULL
);
2068 status_warning (status
, "repeated %s in format", _(s
->name
));
2072 i
= strlen (flag_chars
);
2073 flag_chars
[i
++] = *format_chars
;
2080 /* Handle the scanf allocation kludge. */
2081 if (fki
->flags
& (int) FMT_FLAG_SCANF_A_KLUDGE
)
2083 if (*format_chars
== 'a' && !flag_isoc99
)
2085 if (format_chars
[1] == 's' || format_chars
[1] == 'S'
2086 || format_chars
[1] == '[')
2088 /* `a' is used as a flag. */
2089 i
= strlen (flag_chars
);
2090 flag_chars
[i
++] = 'a';
2097 format_char
= *format_chars
;
2098 if (format_char
== 0
2099 || (!(fki
->flags
& (int) FMT_FLAG_FANCY_PERCENT_OK
)
2100 && format_char
== '%'))
2102 status_warning (status
, "conversion lacks type at end of format");
2106 fci
= fki
->conversion_specs
;
2107 while (fci
->format_chars
!= 0
2108 && strchr (fci
->format_chars
, format_char
) == 0)
2110 if (fci
->format_chars
== 0)
2112 if (ISGRAPH(format_char
))
2113 status_warning (status
, "unknown conversion type character `%c' in format",
2116 status_warning (status
, "unknown conversion type character 0x%x in format",
2122 if (ADJ_STD (fci
->std
) > C_STD_VER
)
2123 status_warning (status
, "%s does not support the `%%%c' %s format",
2124 C_STD_NAME (fci
->std
), format_char
, fki
->name
);
2127 /* Validate the individual flags used, removing any that are invalid. */
2130 for (i
= 0; flag_chars
[i
] != 0; i
++)
2132 const format_flag_spec
*s
= get_flag_spec (flag_specs
,
2133 flag_chars
[i
], NULL
);
2134 flag_chars
[i
- d
] = flag_chars
[i
];
2135 if (flag_chars
[i
] == fki
->length_code_char
)
2137 if (strchr (fci
->flag_chars
, flag_chars
[i
]) == 0)
2139 status_warning (status
, "%s used with `%%%c' %s format",
2140 _(s
->name
), format_char
, fki
->name
);
2146 const format_flag_spec
*t
;
2147 if (ADJ_STD (s
->std
) > C_STD_VER
)
2148 status_warning (status
, "%s does not support %s",
2149 C_STD_NAME (s
->std
), _(s
->long_name
));
2150 t
= get_flag_spec (flag_specs
, flag_chars
[i
], fci
->flags2
);
2151 if (t
!= NULL
&& ADJ_STD (t
->std
) > ADJ_STD (s
->std
))
2153 const char *long_name
= (t
->long_name
!= NULL
2156 if (ADJ_STD (t
->std
) > C_STD_VER
)
2157 status_warning (status
, "%s does not support %s with the `%%%c' %s format",
2158 C_STD_NAME (t
->std
), _(long_name
),
2159 format_char
, fki
->name
);
2163 flag_chars
[i
- d
] = 0;
2166 if ((fki
->flags
& (int) FMT_FLAG_SCANF_A_KLUDGE
)
2167 && strchr (flag_chars
, 'a') != 0)
2170 if (fki
->suppression_char
2171 && strchr (flag_chars
, fki
->suppression_char
) != 0)
2174 /* Validate the pairs of flags used. */
2175 for (i
= 0; bad_flag_pairs
[i
].flag_char1
!= 0; i
++)
2177 const format_flag_spec
*s
, *t
;
2178 if (strchr (flag_chars
, bad_flag_pairs
[i
].flag_char1
) == 0)
2180 if (strchr (flag_chars
, bad_flag_pairs
[i
].flag_char2
) == 0)
2182 if (bad_flag_pairs
[i
].predicate
!= 0
2183 && strchr (fci
->flags2
, bad_flag_pairs
[i
].predicate
) == 0)
2185 s
= get_flag_spec (flag_specs
, bad_flag_pairs
[i
].flag_char1
, NULL
);
2186 t
= get_flag_spec (flag_specs
, bad_flag_pairs
[i
].flag_char2
, NULL
);
2187 if (bad_flag_pairs
[i
].ignored
)
2189 if (bad_flag_pairs
[i
].predicate
!= 0)
2190 status_warning (status
, "%s ignored with %s and `%%%c' %s format",
2191 _(s
->name
), _(t
->name
), format_char
,
2194 status_warning (status
, "%s ignored with %s in %s format",
2195 _(s
->name
), _(t
->name
), fki
->name
);
2199 if (bad_flag_pairs
[i
].predicate
!= 0)
2200 status_warning (status
, "use of %s and %s together with `%%%c' %s format",
2201 _(s
->name
), _(t
->name
), format_char
,
2204 status_warning (status
, "use of %s and %s together in %s format",
2205 _(s
->name
), _(t
->name
), fki
->name
);
2209 /* Give Y2K warnings. */
2210 if (warn_format_y2k
)
2213 if (strchr (fci
->flags2
, '4') != 0)
2214 if (strchr (flag_chars
, 'E') != 0)
2218 else if (strchr (fci
->flags2
, '3') != 0)
2220 else if (strchr (fci
->flags2
, '2') != 0)
2223 status_warning (status
, "`%%%c' yields only last 2 digits of year in some locales",
2225 else if (y2k_level
== 2)
2226 status_warning (status
, "`%%%c' yields only last 2 digits of year", format_char
);
2229 if (strchr (fci
->flags2
, '[') != 0)
2231 /* Skip over scan set, in case it happens to have '%' in it. */
2232 if (*format_chars
== '^')
2234 /* Find closing bracket; if one is hit immediately, then
2235 it's part of the scan set rather than a terminator. */
2236 if (*format_chars
== ']')
2238 while (*format_chars
&& *format_chars
!= ']')
2240 if (*format_chars
!= ']')
2241 /* The end of the format string was reached. */
2242 status_warning (status
, "no closing `]' for `%%[' format");
2246 wanted_type_name
= 0;
2247 if (fki
->flags
& (int) FMT_FLAG_ARG_CONVERT
)
2249 wanted_type
= (fci
->types
[length_chars_val
].type
2250 ? *fci
->types
[length_chars_val
].type
: 0);
2251 wanted_type_name
= fci
->types
[length_chars_val
].name
;
2252 wanted_type_std
= fci
->types
[length_chars_val
].std
;
2253 if (wanted_type
== 0)
2255 status_warning (status
, "use of `%s' length modifier with `%c' type character",
2256 length_chars
, format_char
);
2257 /* Heuristic: skip one argument when an invalid length/type
2258 combination is encountered. */
2262 status_warning (status
, "too few arguments for format");
2265 params
= TREE_CHAIN (params
);
2269 /* Warn if non-standard, provided it is more non-standard
2270 than the length and type characters that may already
2271 have been warned for. */
2272 && ADJ_STD (wanted_type_std
) > ADJ_STD (length_chars_std
)
2273 && ADJ_STD (wanted_type_std
) > ADJ_STD (fci
->std
))
2275 if (ADJ_STD (wanted_type_std
) > C_STD_VER
)
2276 status_warning (status
, "%s does not support the `%%%s%c' %s format",
2277 C_STD_NAME (wanted_type_std
), length_chars
,
2278 format_char
, fki
->name
);
2282 /* Finally. . .check type of argument against desired type! */
2283 if (info
->first_arg_num
== 0)
2285 if ((fci
->pointer_count
== 0 && wanted_type
== void_type_node
)
2288 if (main_arg_num
!= 0)
2291 status_warning (status
, "operand number specified with suppressed assignment");
2293 status_warning (status
, "operand number specified for format taking no argument");
2298 if (main_arg_num
!= 0)
2300 arg_num
= main_arg_num
;
2301 params
= main_arg_params
;
2306 if (has_operand_number
> 0)
2308 status_warning (status
, "missing $ operand number in format");
2312 has_operand_number
= 0;
2315 status_warning (status
, "too few arguments for format");
2319 cur_param
= TREE_VALUE (params
);
2320 params
= TREE_CHAIN (params
);
2321 main_wanted_type
.wanted_type
= wanted_type
;
2322 main_wanted_type
.wanted_type_name
= wanted_type_name
;
2323 main_wanted_type
.pointer_count
= fci
->pointer_count
+ aflag
;
2324 main_wanted_type
.char_lenient_flag
= 0;
2325 if (strchr (fci
->flags2
, 'c') != 0)
2326 main_wanted_type
.char_lenient_flag
= 1;
2327 main_wanted_type
.writing_in_flag
= 0;
2328 main_wanted_type
.reading_from_flag
= 0;
2330 main_wanted_type
.writing_in_flag
= 1;
2333 if (strchr (fci
->flags2
, 'W') != 0)
2334 main_wanted_type
.writing_in_flag
= 1;
2335 if (strchr (fci
->flags2
, 'R') != 0)
2336 main_wanted_type
.reading_from_flag
= 1;
2338 main_wanted_type
.name
= NULL
;
2339 main_wanted_type
.param
= cur_param
;
2340 main_wanted_type
.arg_num
= arg_num
;
2341 main_wanted_type
.next
= NULL
;
2342 if (last_wanted_type
!= 0)
2343 last_wanted_type
->next
= &main_wanted_type
;
2344 if (first_wanted_type
== 0)
2345 first_wanted_type
= &main_wanted_type
;
2346 last_wanted_type
= &main_wanted_type
;
2349 if (first_wanted_type
!= 0)
2350 check_format_types (status
, first_wanted_type
);
2356 /* Check the argument types from a single format conversion (possibly
2357 including width and precision arguments). */
2359 check_format_types (status
, types
)
2361 format_wanted_type
*types
;
2363 for (; types
!= 0; types
= types
->next
)
2373 cur_param
= types
->param
;
2374 cur_type
= TREE_TYPE (cur_param
);
2375 if (cur_type
== error_mark_node
)
2378 wanted_type
= types
->wanted_type
;
2379 arg_num
= types
->arg_num
;
2381 /* The following should not occur here. */
2382 if (wanted_type
== 0)
2384 if (wanted_type
== void_type_node
&& types
->pointer_count
== 0)
2387 if (types
->pointer_count
== 0)
2389 promoted_type
= simple_type_promotes_to (wanted_type
);
2390 if (promoted_type
!= NULL_TREE
)
2391 wanted_type
= promoted_type
;
2394 STRIP_NOPS (cur_param
);
2396 /* Check the types of any additional pointer arguments
2397 that precede the "real" argument. */
2398 for (i
= 0; i
< types
->pointer_count
; ++i
)
2400 if (TREE_CODE (cur_type
) == POINTER_TYPE
)
2402 cur_type
= TREE_TYPE (cur_type
);
2403 if (cur_type
== error_mark_node
)
2406 /* Check for writing through a NULL pointer. */
2407 if (types
->writing_in_flag
2410 && integer_zerop (cur_param
))
2411 status_warning (status
,
2412 "writing through null pointer (arg %d)",
2415 /* Check for reading through a NULL pointer. */
2416 if (types
->reading_from_flag
2419 && integer_zerop (cur_param
))
2420 status_warning (status
,
2421 "reading through null pointer (arg %d)",
2424 if (cur_param
!= 0 && TREE_CODE (cur_param
) == ADDR_EXPR
)
2425 cur_param
= TREE_OPERAND (cur_param
, 0);
2429 /* See if this is an attempt to write into a const type with
2430 scanf or with printf "%n". Note: the writing in happens
2431 at the first indirection only, if for example
2432 void * const * is passed to scanf %p; passing
2433 const void ** is simply passing an incompatible type. */
2434 if (types
->writing_in_flag
2436 && (TYPE_READONLY (cur_type
)
2438 && (TREE_CODE_CLASS (TREE_CODE (cur_param
)) == 'c'
2439 || (DECL_P (cur_param
)
2440 && TREE_READONLY (cur_param
))))))
2441 status_warning (status
, "writing into constant object (arg %d)", arg_num
);
2443 /* If there are extra type qualifiers beyond the first
2444 indirection, then this makes the types technically
2448 && (TYPE_READONLY (cur_type
)
2449 || TYPE_VOLATILE (cur_type
)
2450 || TYPE_RESTRICT (cur_type
)))
2451 status_warning (status
, "extra type qualifiers in format argument (arg %d)",
2457 if (types
->pointer_count
== 1)
2458 status_warning (status
, "format argument is not a pointer (arg %d)", arg_num
);
2460 status_warning (status
, "format argument is not a pointer to a pointer (arg %d)", arg_num
);
2465 if (i
< types
->pointer_count
)
2468 orig_cur_type
= cur_type
;
2469 cur_type
= TYPE_MAIN_VARIANT (cur_type
);
2471 /* Check whether the argument type is a character type. This leniency
2472 only applies to certain formats, flagged with 'c'.
2474 if (types
->char_lenient_flag
)
2475 char_type_flag
= (cur_type
== char_type_node
2476 || cur_type
== signed_char_type_node
2477 || cur_type
== unsigned_char_type_node
);
2479 /* Check the type of the "real" argument, if there's a type we want. */
2480 if (wanted_type
== cur_type
)
2482 /* If we want `void *', allow any pointer type.
2483 (Anything else would already have got a warning.)
2484 With -pedantic, only allow pointers to void and to character
2486 if (wanted_type
== void_type_node
2487 && (!pedantic
|| (i
== 1 && char_type_flag
)))
2489 /* Don't warn about differences merely in signedness, unless
2490 -pedantic. With -pedantic, warn if the type is a pointer
2491 target and not a character type, and for character types at
2492 a second level of indirection. */
2493 if (TREE_CODE (wanted_type
) == INTEGER_TYPE
2494 && TREE_CODE (cur_type
) == INTEGER_TYPE
2495 && (! pedantic
|| i
== 0 || (i
== 1 && char_type_flag
))
2496 && (TREE_UNSIGNED (wanted_type
)
2497 ? wanted_type
== unsigned_type (cur_type
)
2498 : wanted_type
== signed_type (cur_type
)))
2500 /* Likewise, "signed char", "unsigned char" and "char" are
2501 equivalent but the above test won't consider them equivalent. */
2502 if (wanted_type
== char_type_node
2503 && (! pedantic
|| i
< 2)
2506 /* Now we have a type mismatch. */
2508 register const char *this;
2509 register const char *that
;
2511 this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type
)));
2513 if (TYPE_NAME (orig_cur_type
) != 0
2514 && TREE_CODE (orig_cur_type
) != INTEGER_TYPE
2515 && !(TREE_CODE (orig_cur_type
) == POINTER_TYPE
2516 && TREE_CODE (TREE_TYPE (orig_cur_type
)) == INTEGER_TYPE
))
2518 if (TREE_CODE (TYPE_NAME (orig_cur_type
)) == TYPE_DECL
2519 && DECL_NAME (TYPE_NAME (orig_cur_type
)) != 0)
2520 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type
)));
2522 that
= IDENTIFIER_POINTER (TYPE_NAME (orig_cur_type
));
2525 /* A nameless type can't possibly match what the format wants.
2526 So there will be a warning for it.
2527 Make up a string to describe vaguely what it is. */
2530 if (TREE_CODE (orig_cur_type
) == POINTER_TYPE
)
2533 that
= "different type";
2536 /* Make the warning better in case of mismatch of int vs long. */
2537 if (TREE_CODE (orig_cur_type
) == INTEGER_TYPE
2538 && TREE_CODE (wanted_type
) == INTEGER_TYPE
2539 && TYPE_PRECISION (orig_cur_type
) == TYPE_PRECISION (wanted_type
)
2540 && TYPE_NAME (orig_cur_type
) != 0
2541 && TREE_CODE (TYPE_NAME (orig_cur_type
)) == TYPE_DECL
)
2542 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type
)));
2544 if (strcmp (this, that
) != 0)
2546 /* There may be a better name for the format, e.g. size_t,
2547 but we should allow for programs with a perverse typedef
2548 making size_t something other than what the compiler
2550 if (types
->wanted_type_name
!= 0
2551 && strcmp (types
->wanted_type_name
, that
) != 0)
2552 this = types
->wanted_type_name
;
2553 if (types
->name
!= 0)
2554 status_warning (status
, "%s is not type %s (arg %d)", types
->name
, this,
2557 status_warning (status
, "%s format, %s arg (arg %d)", this, that
, arg_num
);