OSDN Git Service

* c-common.h (check_function_format): Remove first parameter.
[pf3gnuchains/gcc-fork.git] / gcc / c-format.c
1 /* Check calls to formatted I/O functions (-Wformat).
2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3    2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
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
10 version.
11
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
15 for more details.
16
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
20 02111-1307, USA.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "tree.h"
27 #include "flags.h"
28 #include "toplev.h"
29 #include "c-common.h"
30 #include "intl.h"
31 #include "diagnostic.h"
32 #include "langhooks.h"
33 \f
34 /* Set format warning options according to a -Wformat=n option.  */
35
36 void
37 set_Wformat (int setting)
38 {
39   warn_format = setting;
40   warn_format_extra_args = setting;
41   warn_format_zero_length = setting;
42   if (setting != 1)
43     {
44       warn_format_nonliteral = setting;
45       warn_format_security = setting;
46       warn_format_y2k = setting;
47     }
48   /* Make sure not to disable -Wnonnull if -Wformat=0 is specified.  */
49   if (setting)
50     warn_nonnull = setting;
51 }
52
53 \f
54 /* Handle attributes associated with format checking.  */
55
56 /* This must be in the same order as format_types, with format_type_error
57    last.  */
58 enum format_type { printf_format_type, asm_fprintf_format_type,
59                    gcc_diag_format_type, gcc_cdiag_format_type,
60                    gcc_cxxdiag_format_type,
61                    scanf_format_type, strftime_format_type,
62                    strfmon_format_type, format_type_error };
63
64 typedef struct function_format_info
65 {
66   enum format_type format_type; /* type of format (printf, scanf, etc.) */
67   unsigned HOST_WIDE_INT format_num;    /* number of format argument */
68   unsigned HOST_WIDE_INT first_arg_num; /* number of first arg (zero for varargs) */
69 } function_format_info;
70
71 static bool decode_format_attr (tree, function_format_info *, int);
72 static enum format_type decode_format_type (const char *);
73
74 static bool check_format_string (tree argument,
75                                  unsigned HOST_WIDE_INT format_num,
76                                  int flags, bool *no_add_attrs);
77 static bool get_constant (tree expr, unsigned HOST_WIDE_INT *value,
78                           int validated_p);
79
80
81 /* Handle a "format_arg" attribute; arguments as in
82    struct attribute_spec.handler.  */
83 tree
84 handle_format_arg_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
85                              tree args, int flags, bool *no_add_attrs)
86 {
87   tree type = *node;
88   tree format_num_expr = TREE_VALUE (args);
89   unsigned HOST_WIDE_INT format_num = 0;
90   tree argument;
91
92   if (!get_constant (format_num_expr, &format_num, 0))
93     {
94       error ("format string has invalid operand number");
95       *no_add_attrs = true;
96       return NULL_TREE;
97     }
98
99   argument = TYPE_ARG_TYPES (type);
100   if (argument)
101     {
102       if (!check_format_string (argument, format_num, flags, no_add_attrs))
103         return NULL_TREE;
104     }
105
106   if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
107       || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
108           != char_type_node))
109     {
110       if (!(flags & (int) ATTR_FLAG_BUILT_IN))
111         error ("function does not return string type");
112       *no_add_attrs = true;
113       return NULL_TREE;
114     }
115
116   return NULL_TREE;
117 }
118
119 /* Verify that the format_num argument is actually a string, in case
120    the format attribute is in error.  */
121 static bool
122 check_format_string (tree argument, unsigned HOST_WIDE_INT format_num,
123                      int flags, bool *no_add_attrs)
124 {
125   unsigned HOST_WIDE_INT i;
126
127   for (i = 1; i != format_num; i++)
128     {
129       if (argument == 0)
130         break;
131       argument = TREE_CHAIN (argument);
132     }
133
134   if (!argument
135       || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
136       || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
137           != char_type_node))
138     {
139       if (!(flags & (int) ATTR_FLAG_BUILT_IN))
140         error ("format string arg not a string type");
141       *no_add_attrs = true;
142       return false;
143     }
144
145   return true;
146 }
147
148 /* Strip any conversions from the expression, verify it is a constant,
149    and store its value. If validated_p is true, abort on errors.
150    Returns true on success, false otherwise.  */
151 static bool
152 get_constant(tree expr, unsigned HOST_WIDE_INT *value, int validated_p)
153 {
154   while (TREE_CODE (expr) == NOP_EXPR
155          || TREE_CODE (expr) == CONVERT_EXPR
156          || TREE_CODE (expr) == NON_LVALUE_EXPR)
157     expr = TREE_OPERAND (expr, 0);
158
159   if (TREE_CODE (expr) != INTEGER_CST || TREE_INT_CST_HIGH (expr) != 0)
160     {
161       if (validated_p)
162         abort ();
163       return false;
164     }
165
166   *value = TREE_INT_CST_LOW (expr);
167
168   return true;
169 }
170
171 /* Decode the arguments to a "format" attribute into a function_format_info
172    structure.  It is already known that the list is of the right length.
173    If VALIDATED_P is true, then these attributes have already been validated
174    and this function will abort if they are erroneous; if false, it
175    will give an error message.  Returns true if the attributes are
176    successfully decoded, false otherwise.  */
177
178 static bool
179 decode_format_attr (tree args, function_format_info *info, int validated_p)
180 {
181   tree format_type_id = TREE_VALUE (args);
182   tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
183   tree first_arg_num_expr
184     = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
185
186   if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
187     {
188       if (validated_p)
189         abort ();
190       error ("unrecognized format specifier");
191       return false;
192     }
193   else
194     {
195       const char *p = IDENTIFIER_POINTER (format_type_id);
196
197       info->format_type = decode_format_type (p);
198
199       if (info->format_type == format_type_error)
200         {
201           if (validated_p)
202             abort ();
203           warning ("%qs is an unrecognized format function type", p);
204           return false;
205         }
206     }
207
208   if (!get_constant (format_num_expr, &info->format_num, validated_p))
209     {
210       error ("format string has invalid operand number");
211       return false;
212     }
213
214   if (!get_constant (first_arg_num_expr, &info->first_arg_num, validated_p))
215     {
216       error ("'...' has invalid operand number");
217       return false;
218     }
219
220   if (info->first_arg_num != 0 && info->first_arg_num <= info->format_num)
221     {
222       if (validated_p)
223         abort ();
224       error ("format string arg follows the args to be formatted");
225       return false;
226     }
227
228   return true;
229 }
230 \f
231 /* Check a call to a format function against a parameter list.  */
232
233 /* The meaningfully distinct length modifiers for format checking recognized
234    by GCC.  */
235 enum format_lengths
236 {
237   FMT_LEN_none,
238   FMT_LEN_hh,
239   FMT_LEN_h,
240   FMT_LEN_l,
241   FMT_LEN_ll,
242   FMT_LEN_L,
243   FMT_LEN_z,
244   FMT_LEN_t,
245   FMT_LEN_j,
246   FMT_LEN_MAX
247 };
248
249
250 /* The standard versions in which various format features appeared.  */
251 enum format_std_version
252 {
253   STD_C89,
254   STD_C94,
255   STD_C9L, /* C99, but treat as C89 if -Wno-long-long.  */
256   STD_C99,
257   STD_EXT
258 };
259
260 /* The C standard version C++ is treated as equivalent to
261    or inheriting from, for the purpose of format features supported.  */
262 #define CPLUSPLUS_STD_VER       STD_C94
263 /* The C standard version we are checking formats against when pedantic.  */
264 #define C_STD_VER               ((int)(c_dialect_cxx ()                   \
265                                  ? CPLUSPLUS_STD_VER                      \
266                                  : (flag_isoc99                           \
267                                     ? STD_C99                             \
268                                     : (flag_isoc94 ? STD_C94 : STD_C89))))
269 /* The name to give to the standard version we are warning about when
270    pedantic.  FEATURE_VER is the version in which the feature warned out
271    appeared, which is higher than C_STD_VER.  */
272 #define C_STD_NAME(FEATURE_VER) (c_dialect_cxx ()               \
273                                  ? "ISO C++"                    \
274                                  : ((FEATURE_VER) == STD_EXT    \
275                                     ? "ISO C"                   \
276                                     : "ISO C90"))
277 /* Adjust a C standard version, which may be STD_C9L, to account for
278    -Wno-long-long.  Returns other standard versions unchanged.  */
279 #define ADJ_STD(VER)            ((int)((VER) == STD_C9L                       \
280                                        ? (warn_long_long ? STD_C99 : STD_C89) \
281                                        : (VER)))
282
283 /* Flags that may apply to a particular kind of format checked by GCC.  */
284 enum
285 {
286   /* This format converts arguments of types determined by the
287      format string.  */
288   FMT_FLAG_ARG_CONVERT = 1,
289   /* The scanf allocation 'a' kludge applies to this format kind.  */
290   FMT_FLAG_SCANF_A_KLUDGE = 2,
291   /* A % during parsing a specifier is allowed to be a modified % rather
292      that indicating the format is broken and we are out-of-sync.  */
293   FMT_FLAG_FANCY_PERCENT_OK = 4,
294   /* With $ operand numbers, it is OK to reference the same argument more
295      than once.  */
296   FMT_FLAG_DOLLAR_MULTIPLE = 8,
297   /* This format type uses $ operand numbers (strfmon doesn't).  */
298   FMT_FLAG_USE_DOLLAR = 16,
299   /* Zero width is bad in this type of format (scanf).  */
300   FMT_FLAG_ZERO_WIDTH_BAD = 32,
301   /* Empty precision specification is OK in this type of format (printf).  */
302   FMT_FLAG_EMPTY_PREC_OK = 64,
303   /* Gaps are allowed in the arguments with $ operand numbers if all
304      arguments are pointers (scanf).  */
305   FMT_FLAG_DOLLAR_GAP_POINTER_OK = 128
306   /* Not included here: details of whether width or precision may occur
307      (controlled by width_char and precision_char); details of whether
308      '*' can be used for these (width_type and precision_type); details
309      of whether length modifiers can occur (length_char_specs).  */
310 };
311
312
313 /* Structure describing a length modifier supported in format checking, and
314    possibly a doubled version such as "hh".  */
315 typedef struct
316 {
317   /* Name of the single-character length modifier.  */
318   const char *name;
319   /* Index into a format_char_info.types array.  */
320   enum format_lengths index;
321   /* Standard version this length appears in.  */
322   enum format_std_version std;
323   /* Same, if the modifier can be repeated, or NULL if it can't.  */
324   const char *double_name;
325   enum format_lengths double_index;
326   enum format_std_version double_std;
327 } format_length_info;
328
329
330 /* Structure describing the combination of a conversion specifier
331    (or a set of specifiers which act identically) and a length modifier.  */
332 typedef struct
333 {
334   /* The standard version this combination of length and type appeared in.
335      This is only relevant if greater than those for length and type
336      individually; otherwise it is ignored.  */
337   enum format_std_version std;
338   /* The name to use for the type, if different from that generated internally
339      (e.g., "signed size_t").  */
340   const char *name;
341   /* The type itself.  */
342   tree *type;
343 } format_type_detail;
344
345
346 /* Macros to fill out tables of these.  */
347 #define NOARGUMENTS     { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
348 #define BADLEN  { 0, NULL, NULL }
349 #define NOLENGTHS       { BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
350
351
352 /* Structure describing a format conversion specifier (or a set of specifiers
353    which act identically), and the length modifiers used with it.  */
354 typedef struct
355 {
356   const char *format_chars;
357   int pointer_count;
358   enum format_std_version std;
359   /* Types accepted for each length modifier.  */
360   format_type_detail types[FMT_LEN_MAX];
361   /* List of other modifier characters allowed with these specifiers.
362      This lists flags, and additionally "w" for width, "p" for precision
363      (right precision, for strfmon), "#" for left precision (strfmon),
364      "a" for scanf "a" allocation extension (not applicable in C99 mode),
365      "*" for scanf suppression, and "E" and "O" for those strftime
366      modifiers.  */
367   const char *flag_chars;
368   /* List of additional flags describing these conversion specifiers.
369      "c" for generic character pointers being allowed, "2" for strftime
370      two digit year formats, "3" for strftime formats giving two digit
371      years in some locales, "4" for "2" which becomes "3" with an "E" modifier,
372      "o" if use of strftime "O" is a GNU extension beyond C99,
373      "W" if the argument is a pointer which is dereferenced and written into,
374      "R" if the argument is a pointer which is dereferenced and read from,
375      "i" for printf integer formats where the '0' flag is ignored with
376      precision, and "[" for the starting character of a scanf scanset.  */
377   const char *flags2;
378 } format_char_info;
379
380
381 /* Structure describing a flag accepted by some kind of format.  */
382 typedef struct
383 {
384   /* The flag character in question (0 for end of array).  */
385   int flag_char;
386   /* Zero if this entry describes the flag character in general, or a
387      nonzero character that may be found in flags2 if it describes the
388      flag when used with certain formats only.  If the latter, only
389      the first such entry found that applies to the current conversion
390      specifier is used; the values of `name' and `long_name' it supplies
391      will be used, if non-NULL and the standard version is higher than
392      the unpredicated one, for any pedantic warning.  For example, 'o'
393      for strftime formats (meaning 'O' is an extension over C99).  */
394   int predicate;
395   /* Nonzero if the next character after this flag in the format should
396      be skipped ('=' in strfmon), zero otherwise.  */
397   int skip_next_char;
398   /* The name to use for this flag in diagnostic messages.  For example,
399      N_("`0' flag"), N_("field width").  */
400   const char *name;
401   /* Long name for this flag in diagnostic messages; currently only used for
402      "ISO C does not support ...".  For example, N_("the `I' printf flag").  */
403   const char *long_name;
404   /* The standard version in which it appeared.  */
405   enum format_std_version std;
406 } format_flag_spec;
407
408
409 /* Structure describing a combination of flags that is bad for some kind
410    of format.  */
411 typedef struct
412 {
413   /* The first flag character in question (0 for end of array).  */
414   int flag_char1;
415   /* The second flag character.  */
416   int flag_char2;
417   /* Nonzero if the message should say that the first flag is ignored with
418      the second, zero if the combination should simply be objected to.  */
419   int ignored;
420   /* Zero if this entry applies whenever this flag combination occurs,
421      a nonzero character from flags2 if it only applies in some
422      circumstances (e.g. 'i' for printf formats ignoring 0 with precision).  */
423   int predicate;
424 } format_flag_pair;
425
426
427 /* Structure describing a particular kind of format processed by GCC.  */
428 typedef struct
429 {
430   /* The name of this kind of format, for use in diagnostics.  Also
431      the name of the attribute (without preceding and following __).  */
432   const char *name;
433   /* Specifications of the length modifiers accepted; possibly NULL.  */
434   const format_length_info *length_char_specs;
435   /* Details of the conversion specification characters accepted.  */
436   const format_char_info *conversion_specs;
437   /* String listing the flag characters that are accepted.  */
438   const char *flag_chars;
439   /* String listing modifier characters (strftime) accepted.  May be NULL.  */
440   const char *modifier_chars;
441   /* Details of the flag characters, including pseudo-flags.  */
442   const format_flag_spec *flag_specs;
443   /* Details of bad combinations of flags.  */
444   const format_flag_pair *bad_flag_pairs;
445   /* Flags applicable to this kind of format.  */
446   int flags;
447   /* Flag character to treat a width as, or 0 if width not used.  */
448   int width_char;
449   /* Flag character to treat a left precision (strfmon) as,
450      or 0 if left precision not used.  */
451   int left_precision_char;
452   /* Flag character to treat a precision (for strfmon, right precision) as,
453      or 0 if precision not used.  */
454   int precision_char;
455   /* If a flag character has the effect of suppressing the conversion of
456      an argument ('*' in scanf), that flag character, otherwise 0.  */
457   int suppression_char;
458   /* Flag character to treat a length modifier as (ignored if length
459      modifiers not used).  Need not be placed in flag_chars for conversion
460      specifiers, but is used to check for bad combinations such as length
461      modifier with assignment suppression in scanf.  */
462   int length_code_char;
463   /* Pointer to type of argument expected if '*' is used for a width,
464      or NULL if '*' not used for widths.  */
465   tree *width_type;
466   /* Pointer to type of argument expected if '*' is used for a precision,
467      or NULL if '*' not used for precisions.  */
468   tree *precision_type;
469 } format_kind_info;
470
471
472 /* Structure describing details of a type expected in format checking,
473    and the type to check against it.  */
474 typedef struct format_wanted_type
475 {
476   /* The type wanted.  */
477   tree wanted_type;
478   /* The name of this type to use in diagnostics.  */
479   const char *wanted_type_name;
480   /* The level of indirection through pointers at which this type occurs.  */
481   int pointer_count;
482   /* Whether, when pointer_count is 1, to allow any character type when
483      pedantic, rather than just the character or void type specified.  */
484   int char_lenient_flag;
485   /* Whether the argument, dereferenced once, is written into and so the
486      argument must not be a pointer to a const-qualified type.  */
487   int writing_in_flag;
488   /* Whether the argument, dereferenced once, is read from and so
489      must not be a NULL pointer.  */
490   int reading_from_flag;
491   /* If warnings should be of the form "field precision is not type int",
492      the name to use (in this case "field precision"), otherwise NULL,
493      for "%s format, %s arg" type messages.  If (in an extension), this
494      is a pointer type, wanted_type_name should be set to include the
495      terminating '*' characters of the type name to give a correct
496      message.  */
497   const char *name;
498   /* The actual parameter to check against the wanted type.  */
499   tree param;
500   /* The argument number of that parameter.  */
501   int arg_num;
502   /* The next type to check for this format conversion, or NULL if none.  */
503   struct format_wanted_type *next;
504 } format_wanted_type;
505
506
507 static const format_length_info printf_length_specs[] =
508 {
509   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
510   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
511   { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
512   { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
513   { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
514   { "Z", FMT_LEN_z, STD_EXT, NULL, 0, 0 },
515   { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
516   { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
517   { NULL, 0, 0, NULL, 0, 0 }
518 };
519
520 /* Length specifiers valid for asm_fprintf.  */
521 static const format_length_info asm_fprintf_length_specs[] =
522 {
523   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
524   { "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
525   { NULL, 0, 0, NULL, 0, 0 }
526 };
527
528 /* Length specifiers valid for GCC diagnostics.  */
529 static const format_length_info gcc_diag_length_specs[] =
530 {
531   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
532   { "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
533   { NULL, 0, 0, NULL, 0, 0 }
534 };
535
536 /* The custom diagnostics all accept the same length specifiers.  */
537 #define gcc_cdiag_length_specs gcc_diag_length_specs
538 #define gcc_cxxdiag_length_specs gcc_diag_length_specs
539
540 /* This differs from printf_length_specs only in that "Z" is not accepted.  */
541 static const format_length_info scanf_length_specs[] =
542 {
543   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
544   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
545   { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
546   { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
547   { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
548   { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
549   { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
550   { NULL, 0, 0, NULL, 0, 0 }
551 };
552
553
554 /* All tables for strfmon use STD_C89 everywhere, since -pedantic warnings
555    make no sense for a format type not part of any C standard version.  */
556 static const format_length_info strfmon_length_specs[] =
557 {
558   /* A GNU extension.  */
559   { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
560   { NULL, 0, 0, NULL, 0, 0 }
561 };
562
563 static const format_flag_spec printf_flag_specs[] =
564 {
565   { ' ',  0, 0, N_("` ' flag"),        N_("the ` ' printf flag"),              STD_C89 },
566   { '+',  0, 0, N_("`+' flag"),        N_("the `+' printf flag"),              STD_C89 },
567   { '#',  0, 0, N_("`#' flag"),        N_("the `#' printf flag"),              STD_C89 },
568   { '0',  0, 0, N_("`0' flag"),        N_("the `0' printf flag"),              STD_C89 },
569   { '-',  0, 0, N_("`-' flag"),        N_("the `-' printf flag"),              STD_C89 },
570   { '\'', 0, 0, N_("`'' flag"),        N_("the `'' printf flag"),              STD_EXT },
571   { 'I',  0, 0, N_("`I' flag"),        N_("the `I' printf flag"),              STD_EXT },
572   { 'w',  0, 0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
573   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
574   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
575   { 0, 0, 0, NULL, NULL, 0 }
576 };
577
578
579 static const format_flag_pair printf_flag_pairs[] =
580 {
581   { ' ', '+', 1, 0   },
582   { '0', '-', 1, 0   },
583   { '0', 'p', 1, 'i' },
584   { 0, 0, 0, 0 }
585 };
586
587 static const format_flag_spec asm_fprintf_flag_specs[] =
588 {
589   { ' ',  0, 0, N_("` ' flag"),        N_("the ` ' printf flag"),              STD_C89 },
590   { '+',  0, 0, N_("`+' flag"),        N_("the `+' printf flag"),              STD_C89 },
591   { '#',  0, 0, N_("`#' flag"),        N_("the `#' printf flag"),              STD_C89 },
592   { '0',  0, 0, N_("`0' flag"),        N_("the `0' printf flag"),              STD_C89 },
593   { '-',  0, 0, N_("`-' flag"),        N_("the `-' printf flag"),              STD_C89 },
594   { 'w',  0, 0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
595   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
596   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
597   { 0, 0, 0, NULL, NULL, 0 }
598 };
599
600 static const format_flag_pair asm_fprintf_flag_pairs[] =
601 {
602   { ' ', '+', 1, 0   },
603   { '0', '-', 1, 0   },
604   { '0', 'p', 1, 'i' },
605   { 0, 0, 0, 0 }
606 };
607
608 static const format_flag_pair gcc_diag_flag_pairs[] =
609 {
610   { 0, 0, 0, 0 }
611 };
612
613 #define gcc_cdiag_flag_pairs gcc_diag_flag_pairs
614 #define gcc_cxxdiag_flag_pairs gcc_diag_flag_pairs
615
616 static const format_flag_spec gcc_diag_flag_specs[] =
617 {
618   { 'q',  0, 0, N_("`q' flag"),        N_("the `q' diagnostic flag"),          STD_C89 },
619   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
620   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
621   { 0, 0, 0, NULL, NULL, 0 }
622 };
623
624 #define gcc_cdiag_flag_specs gcc_diag_flag_specs
625
626 static const format_flag_spec gcc_cxxdiag_flag_specs[] =
627 {
628   { '+',  0, 0, N_("`+' flag"),        N_("the `+' printf flag"),              STD_C89 },
629   { '#',  0, 0, N_("`#' flag"),        N_("the `#' printf flag"),              STD_C89 },
630   { 'q',  0, 0, N_("`q' flag"),        N_("the `q' diagnostic flag"),          STD_C89 },
631   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
632   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
633   { 0, 0, 0, NULL, NULL, 0 }
634 };
635
636 static const format_flag_spec scanf_flag_specs[] =
637 {
638   { '*',  0, 0, N_("assignment suppression"), N_("the assignment suppression scanf feature"), STD_C89 },
639   { 'a',  0, 0, N_("`a' flag"),               N_("the `a' scanf flag"),                       STD_EXT },
640   { 'w',  0, 0, N_("field width"),            N_("field width in scanf format"),              STD_C89 },
641   { 'L',  0, 0, N_("length modifier"),        N_("length modifier in scanf format"),          STD_C89 },
642   { '\'', 0, 0, N_("`'' flag"),               N_("the `'' scanf flag"),                       STD_EXT },
643   { 'I',  0, 0, N_("`I' flag"),               N_("the `I' scanf flag"),                       STD_EXT },
644   { 0, 0, 0, NULL, NULL, 0 }
645 };
646
647
648 static const format_flag_pair scanf_flag_pairs[] =
649 {
650   { '*', 'L', 0, 0 },
651   { 0, 0, 0, 0 }
652 };
653
654
655 static const format_flag_spec strftime_flag_specs[] =
656 {
657   { '_', 0,   0, N_("`_' flag"),     N_("the `_' strftime flag"),          STD_EXT },
658   { '-', 0,   0, N_("`-' flag"),     N_("the `-' strftime flag"),          STD_EXT },
659   { '0', 0,   0, N_("`0' flag"),     N_("the `0' strftime flag"),          STD_EXT },
660   { '^', 0,   0, N_("`^' flag"),     N_("the `^' strftime flag"),          STD_EXT },
661   { '#', 0,   0, N_("`#' flag"),     N_("the `#' strftime flag"),          STD_EXT },
662   { 'w', 0,   0, N_("field width"),  N_("field width in strftime format"), STD_EXT },
663   { 'E', 0,   0, N_("`E' modifier"), N_("the `E' strftime modifier"),      STD_C99 },
664   { 'O', 0,   0, N_("`O' modifier"), N_("the `O' strftime modifier"),      STD_C99 },
665   { 'O', 'o', 0, NULL,               N_("the `O' modifier"),               STD_EXT },
666   { 0, 0, 0, NULL, NULL, 0 }
667 };
668
669
670 static const format_flag_pair strftime_flag_pairs[] =
671 {
672   { 'E', 'O', 0, 0 },
673   { '_', '-', 0, 0 },
674   { '_', '0', 0, 0 },
675   { '-', '0', 0, 0 },
676   { '^', '#', 0, 0 },
677   { 0, 0, 0, 0 }
678 };
679
680
681 static const format_flag_spec strfmon_flag_specs[] =
682 {
683   { '=',  0, 1, N_("fill character"),  N_("fill character in strfmon format"),  STD_C89 },
684   { '^',  0, 0, N_("`^' flag"),        N_("the `^' strfmon flag"),              STD_C89 },
685   { '+',  0, 0, N_("`+' flag"),        N_("the `+' strfmon flag"),              STD_C89 },
686   { '(',  0, 0, N_("`(' flag"),        N_("the `(' strfmon flag"),              STD_C89 },
687   { '!',  0, 0, N_("`!' flag"),        N_("the `!' strfmon flag"),              STD_C89 },
688   { '-',  0, 0, N_("`-' flag"),        N_("the `-' strfmon flag"),              STD_C89 },
689   { 'w',  0, 0, N_("field width"),     N_("field width in strfmon format"),     STD_C89 },
690   { '#',  0, 0, N_("left precision"),  N_("left precision in strfmon format"),  STD_C89 },
691   { 'p',  0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89 },
692   { 'L',  0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89 },
693   { 0, 0, 0, NULL, NULL, 0 }
694 };
695
696 static const format_flag_pair strfmon_flag_pairs[] =
697 {
698   { '+', '(', 0, 0 },
699   { 0, 0, 0, 0 }
700 };
701
702
703 #define T_I     &integer_type_node
704 #define T89_I   { STD_C89, NULL, T_I }
705 #define T_L     &long_integer_type_node
706 #define T89_L   { STD_C89, NULL, T_L }
707 #define T_LL    &long_long_integer_type_node
708 #define T9L_LL  { STD_C9L, NULL, T_LL }
709 #define TEX_LL  { STD_EXT, NULL, T_LL }
710 #define T_S     &short_integer_type_node
711 #define T89_S   { STD_C89, NULL, T_S }
712 #define T_UI    &unsigned_type_node
713 #define T89_UI  { STD_C89, NULL, T_UI }
714 #define T_UL    &long_unsigned_type_node
715 #define T89_UL  { STD_C89, NULL, T_UL }
716 #define T_ULL   &long_long_unsigned_type_node
717 #define T9L_ULL { STD_C9L, NULL, T_ULL }
718 #define TEX_ULL { STD_EXT, NULL, T_ULL }
719 #define T_US    &short_unsigned_type_node
720 #define T89_US  { STD_C89, NULL, T_US }
721 #define T_F     &float_type_node
722 #define T89_F   { STD_C89, NULL, T_F }
723 #define T99_F   { STD_C99, NULL, T_F }
724 #define T_D     &double_type_node
725 #define T89_D   { STD_C89, NULL, T_D }
726 #define T99_D   { STD_C99, NULL, T_D }
727 #define T_LD    &long_double_type_node
728 #define T89_LD  { STD_C89, NULL, T_LD }
729 #define T99_LD  { STD_C99, NULL, T_LD }
730 #define T_C     &char_type_node
731 #define T89_C   { STD_C89, NULL, T_C }
732 #define T_SC    &signed_char_type_node
733 #define T99_SC  { STD_C99, NULL, T_SC }
734 #define T_UC    &unsigned_char_type_node
735 #define T99_UC  { STD_C99, NULL, T_UC }
736 #define T_V     &void_type_node
737 #define T89_V   { STD_C89, NULL, T_V }
738 #define T_W     &wchar_type_node
739 #define T94_W   { STD_C94, "wchar_t", T_W }
740 #define TEX_W   { STD_EXT, "wchar_t", T_W }
741 #define T_WI    &wint_type_node
742 #define T94_WI  { STD_C94, "wint_t", T_WI }
743 #define TEX_WI  { STD_EXT, "wint_t", T_WI }
744 #define T_ST    &size_type_node
745 #define T99_ST  { STD_C99, "size_t", T_ST }
746 #define T_SST   &signed_size_type_node
747 #define T99_SST { STD_C99, "signed size_t", T_SST }
748 #define T_PD    &ptrdiff_type_node
749 #define T99_PD  { STD_C99, "ptrdiff_t", T_PD }
750 #define T_UPD   &unsigned_ptrdiff_type_node
751 #define T99_UPD { STD_C99, "unsigned ptrdiff_t", T_UPD }
752 #define T_IM    &intmax_type_node
753 #define T99_IM  { STD_C99, "intmax_t", T_IM }
754 #define T_UIM   &uintmax_type_node
755 #define T99_UIM { STD_C99, "uintmax_t", T_UIM }
756
757 static const format_char_info print_char_table[] =
758 {
759   /* C89 conversion specifiers.  */
760   { "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"  },
761   { "oxX", 0, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM }, "-wp0#",     "i"  },
762   { "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"  },
763   { "fgG", 0, STD_C89, { T89_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#'I", ""   },
764   { "eE",  0, STD_C89, { T89_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#I",  ""   },
765   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T94_WI,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",        ""   },
766   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",       "cR" },
767   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",        "c"  },
768   { "n",   1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  BADLEN,  T99_SST, T99_PD,  T99_IM  }, "",          "W"  },
769   /* C99 conversion specifiers.  */
770   { "F",   0, STD_C99, { T99_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#'I", ""   },
771   { "aA",  0, STD_C99, { T99_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#",   ""   },
772   /* X/Open conversion specifiers.  */
773   { "C",   0, STD_EXT, { TEX_WI,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",        ""   },
774   { "S",   1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",       "R"  },
775   /* GNU conversion specifiers.  */
776   { "m",   0, STD_EXT, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",       ""   },
777   { NULL,  0, 0, NOLENGTHS, NULL, NULL }
778 };
779
780 static const format_char_info asm_fprintf_char_table[] =
781 {
782   /* C89 conversion specifiers.  */
783   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +",  "i" },
784   { "oxX", 0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0#",   "i" },
785   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0",    "i" },
786   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",       "" },
787   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",    "cR" },
788
789   /* asm_fprintf conversion specifiers.  */
790   { "O",   0, STD_C89, NOARGUMENTS, "",      ""   },
791   { "R",   0, STD_C89, NOARGUMENTS, "",      ""   },
792   { "I",   0, STD_C89, NOARGUMENTS, "",      ""   },
793   { "L",   0, STD_C89, NOARGUMENTS, "",      ""   },
794   { "U",   0, STD_C89, NOARGUMENTS, "",      ""   },
795   { "r",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",  "" },
796   { "@",   0, STD_C89, NOARGUMENTS, "",      ""   },
797   { NULL,  0, 0, NOLENGTHS, NULL, NULL }
798 };
799
800 static const format_char_info gcc_diag_char_table[] =
801 {
802   /* C89 conversion specifiers.  */
803   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
804   { "ox",  0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
805   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
806   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
807   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "pq", "cR" },
808   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "c"  },
809
810   /* Custom conversion specifiers.  */
811
812   /* %H will require "location_t" at runtime.  */
813   { "H",   0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
814
815   /* These will require a "tree" at runtime.  */
816   { "J", 0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",    ""   },
817
818   { "<>'", 0, STD_C89, NOARGUMENTS, "",      ""   },
819   { "m",   0, STD_C89, NOARGUMENTS, "q",     ""   },
820   { NULL,  0, 0, NOLENGTHS, NULL, NULL }
821 };
822
823 static const format_char_info gcc_cdiag_char_table[] =
824 {
825   /* C89 conversion specifiers.  */
826   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
827   { "ox",  0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
828   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
829   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
830   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "pq", "cR" },
831   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "c"  },
832
833   /* Custom conversion specifiers.  */
834
835   /* %H will require "location_t" at runtime.  */
836   { "H",   0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
837
838   /* These will require a "tree" at runtime.  */
839   { "DEFJT", 0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q", ""   },
840
841   { "<>'", 0, STD_C89, NOARGUMENTS, "",      ""   },
842   { "m",   0, STD_C89, NOARGUMENTS, "q",     ""   },
843   { NULL,  0, 0, NOLENGTHS, NULL, NULL }
844 };
845
846 static const format_char_info gcc_cxxdiag_char_table[] =
847 {
848   /* C89 conversion specifiers.  */
849   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
850   { "ox",  0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
851   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
852   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
853   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "pq", "cR" },
854   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "c"  },
855
856   /* Custom conversion specifiers.  */
857
858   /* %H will require "location_t" at runtime.  */
859   { "H",   0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
860
861   /* These will require a "tree" at runtime.  */
862   { "ADEFJTV",0,STD_C89,{ T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+#",   ""   },
863
864   /* These accept either an `int' or an `enum tree_code' (which is handled as an `int'.)  */
865   { "CLOPQ",0,STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  ""   },
866
867   { "<>'", 0, STD_C89, NOARGUMENTS, "",      ""   },
868   { "m",   0, STD_C89, NOARGUMENTS, "q",     ""   },
869   { NULL,  0, 0, NOLENGTHS, NULL, NULL }
870 };
871
872 static const format_char_info scan_char_table[] =
873 {
874   /* C89 conversion specifiers.  */
875   { "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"   },
876   { "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"   },
877   { "oxX",   1, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM }, "*w",   "W"   },
878   { "efgEG", 1, STD_C89, { T89_F,   BADLEN,  BADLEN,  T89_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN  }, "*w'",  "W"   },
879   { "c",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*w",   "cW"  },
880   { "s",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*aw",  "cW"  },
881   { "[",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*aw",  "cW[" },
882   { "p",     2, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*w",   "W"   },
883   { "n",     1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  BADLEN,  T99_SST, T99_PD,  T99_IM  }, "",     "W"   },
884   /* C99 conversion specifiers.  */
885   { "FaA",   1, STD_C99, { T99_F,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN  }, "*w'",  "W"   },
886   /* X/Open conversion specifiers.  */
887   { "C",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*w",   "W"   },
888   { "S",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*aw",  "W"   },
889   { NULL, 0, 0, NOLENGTHS, NULL, NULL }
890 };
891
892 static const format_char_info time_char_table[] =
893 {
894   /* C89 conversion specifiers.  */
895   { "ABZab",            0, STD_C89, NOLENGTHS, "^#",     ""   },
896   { "cx",               0, STD_C89, NOLENGTHS, "E",      "3"  },
897   { "HIMSUWdmw",        0, STD_C89, NOLENGTHS, "-_0Ow",  ""   },
898   { "j",                0, STD_C89, NOLENGTHS, "-_0Ow",  "o"  },
899   { "p",                0, STD_C89, NOLENGTHS, "#",      ""   },
900   { "X",                0, STD_C89, NOLENGTHS, "E",      ""   },
901   { "y",                0, STD_C89, NOLENGTHS, "EO-_0w", "4"  },
902   { "Y",                0, STD_C89, NOLENGTHS, "-_0EOw", "o"  },
903   { "%",                0, STD_C89, NOLENGTHS, "",       ""   },
904   /* C99 conversion specifiers.  */
905   { "C",                0, STD_C99, NOLENGTHS, "-_0EOw", "o"  },
906   { "D",                0, STD_C99, NOLENGTHS, "",       "2"  },
907   { "eVu",              0, STD_C99, NOLENGTHS, "-_0Ow",  ""   },
908   { "FRTnrt",           0, STD_C99, NOLENGTHS, "",       ""   },
909   { "g",                0, STD_C99, NOLENGTHS, "O-_0w",  "2o" },
910   { "G",                0, STD_C99, NOLENGTHS, "-_0Ow",  "o"  },
911   { "h",                0, STD_C99, NOLENGTHS, "^#",     ""   },
912   { "z",                0, STD_C99, NOLENGTHS, "O",      "o"  },
913   /* GNU conversion specifiers.  */
914   { "kls",              0, STD_EXT, NOLENGTHS, "-_0Ow",  ""   },
915   { "P",                0, STD_EXT, NOLENGTHS, "",       ""   },
916   { NULL,               0, 0, NOLENGTHS, NULL, NULL }
917 };
918
919 static const format_char_info monetary_char_table[] =
920 {
921   { "in", 0, STD_C89, { T89_D, BADLEN, BADLEN, BADLEN, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "=^+(!-w#p", "" },
922   { NULL, 0, 0, NOLENGTHS, NULL, NULL }
923 };
924
925
926 /* This must be in the same order as enum format_type.  */
927 static const format_kind_info format_types_orig[] =
928 {
929   { "printf",   printf_length_specs,  print_char_table, " +#0-'I", NULL, 
930     printf_flag_specs, printf_flag_pairs,
931     FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_EMPTY_PREC_OK,
932     'w', 0, 'p', 0, 'L',
933     &integer_type_node, &integer_type_node
934   },
935   { "asm_fprintf",   asm_fprintf_length_specs,  asm_fprintf_char_table, " +#0-", NULL, 
936     asm_fprintf_flag_specs, asm_fprintf_flag_pairs,
937     FMT_FLAG_ARG_CONVERT|FMT_FLAG_EMPTY_PREC_OK,
938     'w', 0, 'p', 0, 'L',
939     NULL, NULL
940   },
941   { "gcc_diag",   gcc_diag_length_specs,  gcc_diag_char_table, "q", NULL, 
942     gcc_diag_flag_specs, gcc_diag_flag_pairs,
943     FMT_FLAG_ARG_CONVERT,
944     0, 0, 'p', 0, 'L',
945     NULL, &integer_type_node
946   },
947   { "gcc_cdiag",   gcc_cdiag_length_specs,  gcc_cdiag_char_table, "q", NULL, 
948     gcc_cdiag_flag_specs, gcc_cdiag_flag_pairs,
949     FMT_FLAG_ARG_CONVERT,
950     0, 0, 'p', 0, 'L',
951     NULL, &integer_type_node
952   },
953   { "gcc_cxxdiag",   gcc_cxxdiag_length_specs,  gcc_cxxdiag_char_table, "q+#", NULL, 
954     gcc_cxxdiag_flag_specs, gcc_cxxdiag_flag_pairs,
955     FMT_FLAG_ARG_CONVERT,
956     0, 0, 'p', 0, 'L',
957     NULL, &integer_type_node
958   },
959   { "scanf",    scanf_length_specs,   scan_char_table,  "*'I", NULL, 
960     scanf_flag_specs, scanf_flag_pairs,
961     FMT_FLAG_ARG_CONVERT|FMT_FLAG_SCANF_A_KLUDGE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_ZERO_WIDTH_BAD|FMT_FLAG_DOLLAR_GAP_POINTER_OK,
962     'w', 0, 0, '*', 'L',
963     NULL, NULL
964   },
965   { "strftime", NULL,                 time_char_table,  "_-0^#", "EO",
966     strftime_flag_specs, strftime_flag_pairs,
967     FMT_FLAG_FANCY_PERCENT_OK, 'w', 0, 0, 0, 0,
968     NULL, NULL
969   },
970   { "strfmon",  strfmon_length_specs, monetary_char_table, "=^+(!-", NULL, 
971     strfmon_flag_specs, strfmon_flag_pairs,
972     FMT_FLAG_ARG_CONVERT, 'w', '#', 'p', 0, 'L',
973     NULL, NULL
974   }
975 };
976
977 /* This layer of indirection allows GCC to reassign format_types with
978    new data if necessary, while still allowing the original data to be
979    const.  */
980 static const format_kind_info *format_types = format_types_orig;
981 /* We can modify this one.  */
982 static format_kind_info *dynamic_format_types;
983
984 /* Structure detailing the results of checking a format function call
985    where the format expression may be a conditional expression with
986    many leaves resulting from nested conditional expressions.  */
987 typedef struct
988 {
989   /* Number of leaves of the format argument that could not be checked
990      as they were not string literals.  */
991   int number_non_literal;
992   /* Number of leaves of the format argument that were null pointers or
993      string literals, but had extra format arguments.  */
994   int number_extra_args;
995   /* Number of leaves of the format argument that were null pointers or
996      string literals, but had extra format arguments and used $ operand
997      numbers.  */
998   int number_dollar_extra_args;
999   /* Number of leaves of the format argument that were wide string
1000      literals.  */
1001   int number_wide;
1002   /* Number of leaves of the format argument that were empty strings.  */
1003   int number_empty;
1004   /* Number of leaves of the format argument that were unterminated
1005      strings.  */
1006   int number_unterminated;
1007   /* Number of leaves of the format argument that were not counted above.  */
1008   int number_other;
1009 } format_check_results;
1010
1011 typedef struct
1012 {
1013   format_check_results *res;
1014   function_format_info *info;
1015   tree params;
1016 } format_check_context;
1017
1018 static void check_format_info (function_format_info *, tree);
1019 static void check_format_arg (void *, tree, unsigned HOST_WIDE_INT);
1020 static void check_format_info_main (format_check_results *,
1021                                     function_format_info *,
1022                                     const char *, int, tree,
1023                                     unsigned HOST_WIDE_INT);
1024
1025 static void init_dollar_format_checking (int, tree);
1026 static int maybe_read_dollar_number (const char **, int,
1027                                      tree, tree *, const format_kind_info *);
1028 static bool avoid_dollar_number (const char *);
1029 static void finish_dollar_format_checking (format_check_results *, int);
1030
1031 static const format_flag_spec *get_flag_spec (const format_flag_spec *,
1032                                               int, const char *);
1033
1034 static void check_format_types (format_wanted_type *);
1035
1036 /* Decode a format type from a string, returning the type, or
1037    format_type_error if not valid, in which case the caller should print an
1038    error message.  */
1039 static enum format_type
1040 decode_format_type (const char *s)
1041 {
1042   int i;
1043   int slen;
1044   slen = strlen (s);
1045   for (i = 0; i < (int) format_type_error; i++)
1046     {
1047       int alen;
1048       if (!strcmp (s, format_types[i].name))
1049         break;
1050       alen = strlen (format_types[i].name);
1051       if (slen == alen + 4 && s[0] == '_' && s[1] == '_'
1052           && s[slen - 1] == '_' && s[slen - 2] == '_'
1053           && !strncmp (s + 2, format_types[i].name, alen))
1054         break;
1055     }
1056   return ((enum format_type) i);
1057 }
1058
1059 \f
1060 /* Check the argument list of a call to printf, scanf, etc.
1061    ATTRS are the attributes on the function type.
1062    PARAMS is the list of argument values.  Also, if -Wmissing-format-attribute,
1063    warn for calls to vprintf or vscanf in functions with no such format
1064    attribute themselves.  */
1065
1066 void
1067 check_function_format (tree attrs, tree params)
1068 {
1069   tree a;
1070
1071   /* See if this function has any format attributes.  */
1072   for (a = attrs; a; a = TREE_CHAIN (a))
1073     {
1074       if (is_attribute_p ("format", TREE_PURPOSE (a)))
1075         {
1076           /* Yup; check it.  */
1077           function_format_info info;
1078           decode_format_attr (TREE_VALUE (a), &info, 1);
1079           check_format_info (&info, params);
1080           if (warn_missing_format_attribute && info.first_arg_num == 0
1081               && (format_types[info.format_type].flags
1082                   & (int) FMT_FLAG_ARG_CONVERT))
1083             {
1084               tree c;
1085               for (c = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
1086                    c;
1087                    c = TREE_CHAIN (c))
1088                 if (is_attribute_p ("format", TREE_PURPOSE (c))
1089                     && (decode_format_type (IDENTIFIER_POINTER
1090                                             (TREE_VALUE (TREE_VALUE (c))))
1091                         == info.format_type))
1092                   break;
1093               if (c == NULL_TREE)
1094                 {
1095                   /* Check if the current function has a parameter to which
1096                      the format attribute could be attached; if not, it
1097                      can't be a candidate for a format attribute, despite
1098                      the vprintf-like or vscanf-like call.  */
1099                   tree args;
1100                   for (args = DECL_ARGUMENTS (current_function_decl);
1101                        args != 0;
1102                        args = TREE_CHAIN (args))
1103                     {
1104                       if (TREE_CODE (TREE_TYPE (args)) == POINTER_TYPE
1105                           && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (args)))
1106                               == char_type_node))
1107                         break;
1108                     }
1109                   if (args != 0)
1110                     warning ("function might be possible candidate for %qs format attribute",
1111                              format_types[info.format_type].name);
1112                 }
1113             }
1114         }
1115     }
1116 }
1117
1118
1119 /* Variables used by the checking of $ operand number formats.  */
1120 static char *dollar_arguments_used = NULL;
1121 static char *dollar_arguments_pointer_p = NULL;
1122 static int dollar_arguments_alloc = 0;
1123 static int dollar_arguments_count;
1124 static int dollar_first_arg_num;
1125 static int dollar_max_arg_used;
1126 static int dollar_format_warned;
1127
1128 /* Initialize the checking for a format string that may contain $
1129    parameter number specifications; we will need to keep track of whether
1130    each parameter has been used.  FIRST_ARG_NUM is the number of the first
1131    argument that is a parameter to the format, or 0 for a vprintf-style
1132    function; PARAMS is the list of arguments starting at this argument.  */
1133
1134 static void
1135 init_dollar_format_checking (int first_arg_num, tree params)
1136 {
1137   tree oparams = params;
1138
1139   dollar_first_arg_num = first_arg_num;
1140   dollar_arguments_count = 0;
1141   dollar_max_arg_used = 0;
1142   dollar_format_warned = 0;
1143   if (first_arg_num > 0)
1144     {
1145       while (params)
1146         {
1147           dollar_arguments_count++;
1148           params = TREE_CHAIN (params);
1149         }
1150     }
1151   if (dollar_arguments_alloc < dollar_arguments_count)
1152     {
1153       if (dollar_arguments_used)
1154         free (dollar_arguments_used);
1155       if (dollar_arguments_pointer_p)
1156         free (dollar_arguments_pointer_p);
1157       dollar_arguments_alloc = dollar_arguments_count;
1158       dollar_arguments_used = xmalloc (dollar_arguments_alloc);
1159       dollar_arguments_pointer_p = xmalloc (dollar_arguments_alloc);
1160     }
1161   if (dollar_arguments_alloc)
1162     {
1163       memset (dollar_arguments_used, 0, dollar_arguments_alloc);
1164       if (first_arg_num > 0)
1165         {
1166           int i = 0;
1167           params = oparams;
1168           while (params)
1169             {
1170               dollar_arguments_pointer_p[i] = (TREE_CODE (TREE_TYPE (TREE_VALUE (params)))
1171                                                == POINTER_TYPE);
1172               params = TREE_CHAIN (params);
1173               i++;
1174             }
1175         }
1176     }
1177 }
1178
1179
1180 /* Look for a decimal number followed by a $ in *FORMAT.  If DOLLAR_NEEDED
1181    is set, it is an error if one is not found; otherwise, it is OK.  If
1182    such a number is found, check whether it is within range and mark that
1183    numbered operand as being used for later checking.  Returns the operand
1184    number if found and within range, zero if no such number was found and
1185    this is OK, or -1 on error.  PARAMS points to the first operand of the
1186    format; PARAM_PTR is made to point to the parameter referred to.  If
1187    a $ format is found, *FORMAT is updated to point just after it.  */
1188
1189 static int
1190 maybe_read_dollar_number (const char **format,
1191                           int dollar_needed, tree params, tree *param_ptr,
1192                           const format_kind_info *fki)
1193 {
1194   int argnum;
1195   int overflow_flag;
1196   const char *fcp = *format;
1197   if (! ISDIGIT (*fcp))
1198     {
1199       if (dollar_needed)
1200         {
1201           warning ("missing $ operand number in format");
1202           return -1;
1203         }
1204       else
1205         return 0;
1206     }
1207   argnum = 0;
1208   overflow_flag = 0;
1209   while (ISDIGIT (*fcp))
1210     {
1211       int nargnum;
1212       nargnum = 10 * argnum + (*fcp - '0');
1213       if (nargnum < 0 || nargnum / 10 != argnum)
1214         overflow_flag = 1;
1215       argnum = nargnum;
1216       fcp++;
1217     }
1218   if (*fcp != '$')
1219     {
1220       if (dollar_needed)
1221         {
1222           warning ("missing $ operand number in format");
1223           return -1;
1224         }
1225       else
1226         return 0;
1227     }
1228   *format = fcp + 1;
1229   if (pedantic && !dollar_format_warned)
1230     {
1231       warning ("%s does not support %%n$ operand number formats",
1232                C_STD_NAME (STD_EXT));
1233       dollar_format_warned = 1;
1234     }
1235   if (overflow_flag || argnum == 0
1236       || (dollar_first_arg_num && argnum > dollar_arguments_count))
1237     {
1238       warning ("operand number out of range in format");
1239       return -1;
1240     }
1241   if (argnum > dollar_max_arg_used)
1242     dollar_max_arg_used = argnum;
1243   /* For vprintf-style functions we may need to allocate more memory to
1244      track which arguments are used.  */
1245   while (dollar_arguments_alloc < dollar_max_arg_used)
1246     {
1247       int nalloc;
1248       nalloc = 2 * dollar_arguments_alloc + 16;
1249       dollar_arguments_used = xrealloc (dollar_arguments_used, nalloc);
1250       dollar_arguments_pointer_p = xrealloc (dollar_arguments_pointer_p,
1251                                              nalloc);
1252       memset (dollar_arguments_used + dollar_arguments_alloc, 0,
1253               nalloc - dollar_arguments_alloc);
1254       dollar_arguments_alloc = nalloc;
1255     }
1256   if (!(fki->flags & (int) FMT_FLAG_DOLLAR_MULTIPLE)
1257       && dollar_arguments_used[argnum - 1] == 1)
1258     {
1259       dollar_arguments_used[argnum - 1] = 2;
1260       warning ("format argument %d used more than once in %s format",
1261                argnum, fki->name);
1262     }
1263   else
1264     dollar_arguments_used[argnum - 1] = 1;
1265   if (dollar_first_arg_num)
1266     {
1267       int i;
1268       *param_ptr = params;
1269       for (i = 1; i < argnum && *param_ptr != 0; i++)
1270         *param_ptr = TREE_CHAIN (*param_ptr);
1271
1272       if (*param_ptr == 0)
1273         {
1274           /* This case shouldn't be caught here.  */
1275           abort ();
1276         }
1277     }
1278   else
1279     *param_ptr = 0;
1280   return argnum;
1281 }
1282
1283 /* Ensure that FORMAT does not start with a decimal number followed by
1284    a $; give a diagnostic and return true if it does, false otherwise.  */
1285
1286 static bool
1287 avoid_dollar_number (const char *format)
1288 {
1289   if (!ISDIGIT (*format))
1290     return false;
1291   while (ISDIGIT (*format))
1292     format++;
1293   if (*format == '$')
1294     {
1295       warning ("$ operand number used after format without operand number");
1296       return true;
1297     }
1298   return false;
1299 }
1300
1301
1302 /* Finish the checking for a format string that used $ operand number formats
1303    instead of non-$ formats.  We check for unused operands before used ones
1304    (a serious error, since the implementation of the format function
1305    can't know what types to pass to va_arg to find the later arguments).
1306    and for unused operands at the end of the format (if we know how many
1307    arguments the format had, so not for vprintf).  If there were operand
1308    numbers out of range on a non-vprintf-style format, we won't have reached
1309    here.  If POINTER_GAP_OK, unused arguments are OK if all arguments are
1310    pointers.  */
1311
1312 static void
1313 finish_dollar_format_checking (format_check_results *res, int pointer_gap_ok)
1314 {
1315   int i;
1316   bool found_pointer_gap = false;
1317   for (i = 0; i < dollar_max_arg_used; i++)
1318     {
1319       if (!dollar_arguments_used[i])
1320         {
1321           if (pointer_gap_ok && (dollar_first_arg_num == 0
1322                                  || dollar_arguments_pointer_p[i]))
1323             found_pointer_gap = true;
1324           else
1325             warning ("format argument %d unused before used argument %d in $-style format",
1326                      i + 1, dollar_max_arg_used);
1327         }
1328     }
1329   if (found_pointer_gap
1330       || (dollar_first_arg_num
1331           && dollar_max_arg_used < dollar_arguments_count))
1332     {
1333       res->number_other--;
1334       res->number_dollar_extra_args++;
1335     }
1336 }
1337
1338
1339 /* Retrieve the specification for a format flag.  SPEC contains the
1340    specifications for format flags for the applicable kind of format.
1341    FLAG is the flag in question.  If PREDICATES is NULL, the basic
1342    spec for that flag must be retrieved and this function aborts if
1343    it cannot be found.  If PREDICATES is not NULL, it is a string listing
1344    possible predicates for the spec entry; if an entry predicated on any
1345    of these is found, it is returned, otherwise NULL is returned.  */
1346
1347 static const format_flag_spec *
1348 get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
1349 {
1350   int i;
1351   for (i = 0; spec[i].flag_char != 0; i++)
1352     {
1353       if (spec[i].flag_char != flag)
1354         continue;
1355       if (predicates != NULL)
1356         {
1357           if (spec[i].predicate != 0
1358               && strchr (predicates, spec[i].predicate) != 0)
1359             return &spec[i];
1360         }
1361       else if (spec[i].predicate == 0)
1362         return &spec[i];
1363     }
1364   if (predicates == NULL)
1365     abort ();
1366   else
1367     return NULL;
1368 }
1369
1370
1371 /* Check the argument list of a call to printf, scanf, etc.
1372    INFO points to the function_format_info structure.
1373    PARAMS is the list of argument values.  */
1374
1375 static void
1376 check_format_info (function_format_info *info, tree params)
1377 {
1378   format_check_context format_ctx;
1379   unsigned HOST_WIDE_INT arg_num;
1380   tree format_tree;
1381   format_check_results res;
1382   /* Skip to format argument.  If the argument isn't available, there's
1383      no work for us to do; prototype checking will catch the problem.  */
1384   for (arg_num = 1; ; ++arg_num)
1385     {
1386       if (params == 0)
1387         return;
1388       if (arg_num == info->format_num)
1389         break;
1390       params = TREE_CHAIN (params);
1391     }
1392   format_tree = TREE_VALUE (params);
1393   params = TREE_CHAIN (params);
1394   if (format_tree == 0)
1395     return;
1396
1397   res.number_non_literal = 0;
1398   res.number_extra_args = 0;
1399   res.number_dollar_extra_args = 0;
1400   res.number_wide = 0;
1401   res.number_empty = 0;
1402   res.number_unterminated = 0;
1403   res.number_other = 0;
1404
1405   format_ctx.res = &res;
1406   format_ctx.info = info;
1407   format_ctx.params = params;
1408
1409   check_function_arguments_recurse (check_format_arg, &format_ctx,
1410                                     format_tree, arg_num);
1411
1412   if (res.number_non_literal > 0)
1413     {
1414       /* Functions taking a va_list normally pass a non-literal format
1415          string.  These functions typically are declared with
1416          first_arg_num == 0, so avoid warning in those cases.  */
1417       if (!(format_types[info->format_type].flags & (int) FMT_FLAG_ARG_CONVERT))
1418         {
1419           /* For strftime-like formats, warn for not checking the format
1420              string; but there are no arguments to check.  */
1421           if (warn_format_nonliteral)
1422             warning ("format not a string literal, format string not checked");
1423         }
1424       else if (info->first_arg_num != 0)
1425         {
1426           /* If there are no arguments for the format at all, we may have
1427              printf (foo) which is likely to be a security hole.  */
1428           while (arg_num + 1 < info->first_arg_num)
1429             {
1430               if (params == 0)
1431                 break;
1432               params = TREE_CHAIN (params);
1433               ++arg_num;
1434             }
1435           if (params == 0 && (warn_format_nonliteral || warn_format_security))
1436             warning ("format not a string literal and no format arguments");
1437           else if (warn_format_nonliteral)
1438             warning ("format not a string literal, argument types not checked");
1439         }
1440     }
1441
1442   /* If there were extra arguments to the format, normally warn.  However,
1443      the standard does say extra arguments are ignored, so in the specific
1444      case where we have multiple leaves (conditional expressions or
1445      ngettext) allow extra arguments if at least one leaf didn't have extra
1446      arguments, but was otherwise OK (either non-literal or checked OK).
1447      If the format is an empty string, this should be counted similarly to the
1448      case of extra format arguments.  */
1449   if (res.number_extra_args > 0 && res.number_non_literal == 0
1450       && res.number_other == 0 && warn_format_extra_args)
1451     warning ("too many arguments for format");
1452   if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
1453       && res.number_other == 0 && warn_format_extra_args)
1454     warning ("unused arguments in $-style format");
1455   if (res.number_empty > 0 && res.number_non_literal == 0
1456       && res.number_other == 0 && warn_format_zero_length)
1457     warning ("zero-length %s format string",
1458              format_types[info->format_type].name);
1459
1460   if (res.number_wide > 0)
1461     warning ("format is a wide character string");
1462
1463   if (res.number_unterminated > 0)
1464     warning ("unterminated format string");
1465 }
1466
1467 /* Callback from check_function_arguments_recurse to check a
1468    format string.  FORMAT_TREE is the format parameter.  ARG_NUM
1469    is the number of the format argument.  CTX points to a
1470    format_check_context.  */
1471
1472 static void
1473 check_format_arg (void *ctx, tree format_tree,
1474                   unsigned HOST_WIDE_INT arg_num)
1475 {
1476   format_check_context *format_ctx = ctx;
1477   format_check_results *res = format_ctx->res;
1478   function_format_info *info = format_ctx->info;
1479   tree params = format_ctx->params;
1480
1481   int format_length;
1482   HOST_WIDE_INT offset;
1483   const char *format_chars;
1484   tree array_size = 0;
1485   tree array_init;
1486
1487   if (integer_zerop (format_tree))
1488     {
1489       /* Skip to first argument to check, so we can see if this format
1490          has any arguments (it shouldn't).  */
1491       while (arg_num + 1 < info->first_arg_num)
1492         {
1493           if (params == 0)
1494             return;
1495           params = TREE_CHAIN (params);
1496           ++arg_num;
1497         }
1498
1499       if (params == 0)
1500         res->number_other++;
1501       else
1502         res->number_extra_args++;
1503
1504       return;
1505     }
1506
1507   offset = 0;
1508   if (TREE_CODE (format_tree) == PLUS_EXPR)
1509     {
1510       tree arg0, arg1;
1511
1512       arg0 = TREE_OPERAND (format_tree, 0);
1513       arg1 = TREE_OPERAND (format_tree, 1);
1514       STRIP_NOPS (arg0);
1515       STRIP_NOPS (arg1);
1516       if (TREE_CODE (arg1) == INTEGER_CST)
1517         format_tree = arg0;
1518       else if (TREE_CODE (arg0) == INTEGER_CST)
1519         {
1520           format_tree = arg1;
1521           arg1 = arg0;
1522         }
1523       else
1524         {
1525           res->number_non_literal++;
1526           return;
1527         }
1528       if (!host_integerp (arg1, 0)
1529           || (offset = tree_low_cst (arg1, 0)) < 0)
1530         {
1531           res->number_non_literal++;
1532           return;
1533         }
1534     }
1535   if (TREE_CODE (format_tree) != ADDR_EXPR)
1536     {
1537       res->number_non_literal++;
1538       return;
1539     }
1540   format_tree = TREE_OPERAND (format_tree, 0);
1541   if (TREE_CODE (format_tree) == VAR_DECL
1542       && TREE_CODE (TREE_TYPE (format_tree)) == ARRAY_TYPE
1543       && (array_init = decl_constant_value (format_tree)) != format_tree
1544       && TREE_CODE (array_init) == STRING_CST)
1545     {
1546       /* Extract the string constant initializer.  Note that this may include
1547          a trailing NUL character that is not in the array (e.g.
1548          const char a[3] = "foo";).  */
1549       array_size = DECL_SIZE_UNIT (format_tree);
1550       format_tree = array_init;
1551     }
1552   if (TREE_CODE (format_tree) != STRING_CST)
1553     {
1554       res->number_non_literal++;
1555       return;
1556     }
1557   if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree))) != char_type_node)
1558     {
1559       res->number_wide++;
1560       return;
1561     }
1562   format_chars = TREE_STRING_POINTER (format_tree);
1563   format_length = TREE_STRING_LENGTH (format_tree);
1564   if (array_size != 0)
1565     {
1566       /* Variable length arrays can't be initialized.  */
1567       if (TREE_CODE (array_size) != INTEGER_CST)
1568         abort ();
1569       if (host_integerp (array_size, 0))
1570         {
1571           HOST_WIDE_INT array_size_value = TREE_INT_CST_LOW (array_size);
1572           if (array_size_value > 0
1573               && array_size_value == (int) array_size_value
1574               && format_length > array_size_value)
1575             format_length = array_size_value;
1576         }
1577     }
1578   if (offset)
1579     {
1580       if (offset >= format_length)
1581         {
1582           res->number_non_literal++;
1583           return;
1584         }
1585       format_chars += offset;
1586       format_length -= offset;
1587     }
1588   if (format_length < 1)
1589     {
1590       res->number_unterminated++;
1591       return;
1592     }
1593   if (format_length == 1)
1594     {
1595       res->number_empty++;
1596       return;
1597     }
1598   if (format_chars[--format_length] != 0)
1599     {
1600       res->number_unterminated++;
1601       return;
1602     }
1603
1604   /* Skip to first argument to check.  */
1605   while (arg_num + 1 < info->first_arg_num)
1606     {
1607       if (params == 0)
1608         return;
1609       params = TREE_CHAIN (params);
1610       ++arg_num;
1611     }
1612   /* Provisionally increment res->number_other; check_format_info_main
1613      will decrement it if it finds there are extra arguments, but this way
1614      need not adjust it for every return.  */
1615   res->number_other++;
1616   check_format_info_main (res, info, format_chars, format_length,
1617                           params, arg_num);
1618 }
1619
1620
1621 /* Do the main part of checking a call to a format function.  FORMAT_CHARS
1622    is the NUL-terminated format string (which at this point may contain
1623    internal NUL characters); FORMAT_LENGTH is its length (excluding the
1624    terminating NUL character).  ARG_NUM is one less than the number of
1625    the first format argument to check; PARAMS points to that format
1626    argument in the list of arguments.  */
1627
1628 static void
1629 check_format_info_main (format_check_results *res,
1630                         function_format_info *info, const char *format_chars,
1631                         int format_length, tree params,
1632                         unsigned HOST_WIDE_INT arg_num)
1633 {
1634   const char *orig_format_chars = format_chars;
1635   tree first_fillin_param = params;
1636
1637   const format_kind_info *fki = &format_types[info->format_type];
1638   const format_flag_spec *flag_specs = fki->flag_specs;
1639   const format_flag_pair *bad_flag_pairs = fki->bad_flag_pairs;
1640
1641   /* -1 if no conversions taking an operand have been found; 0 if one has
1642      and it didn't use $; 1 if $ formats are in use.  */
1643   int has_operand_number = -1;
1644
1645   init_dollar_format_checking (info->first_arg_num, first_fillin_param);
1646
1647   while (1)
1648     {
1649       int i;
1650       int suppressed = FALSE;
1651       const char *length_chars = NULL;
1652       enum format_lengths length_chars_val = FMT_LEN_none;
1653       enum format_std_version length_chars_std = STD_C89;
1654       int format_char;
1655       tree cur_param;
1656       tree wanted_type;
1657       int main_arg_num = 0;
1658       tree main_arg_params = 0;
1659       enum format_std_version wanted_type_std;
1660       const char *wanted_type_name;
1661       format_wanted_type width_wanted_type;
1662       format_wanted_type precision_wanted_type;
1663       format_wanted_type main_wanted_type;
1664       format_wanted_type *first_wanted_type = NULL;
1665       format_wanted_type *last_wanted_type = NULL;
1666       const format_length_info *fli = NULL;
1667       const format_char_info *fci = NULL;
1668       char flag_chars[256];
1669       int aflag = 0;
1670       if (*format_chars == 0)
1671         {
1672           if (format_chars - orig_format_chars != format_length)
1673             warning ("embedded %<\\0%> in format");
1674           if (info->first_arg_num != 0 && params != 0
1675               && has_operand_number <= 0)
1676             {
1677               res->number_other--;
1678               res->number_extra_args++;
1679             }
1680           if (has_operand_number > 0)
1681             finish_dollar_format_checking (res, fki->flags & (int) FMT_FLAG_DOLLAR_GAP_POINTER_OK);
1682           return;
1683         }
1684       if (*format_chars++ != '%')
1685         continue;
1686       if (*format_chars == 0)
1687         {
1688           warning ("spurious trailing %<%%%> in format");
1689           continue;
1690         }
1691       if (*format_chars == '%')
1692         {
1693           ++format_chars;
1694           continue;
1695         }
1696       flag_chars[0] = 0;
1697
1698       if ((fki->flags & (int) FMT_FLAG_USE_DOLLAR) && has_operand_number != 0)
1699         {
1700           /* Possibly read a $ operand number at the start of the format.
1701              If one was previously used, one is required here.  If one
1702              is not used here, we can't immediately conclude this is a
1703              format without them, since it could be printf %m or scanf %*.  */
1704           int opnum;
1705           opnum = maybe_read_dollar_number (&format_chars, 0,
1706                                             first_fillin_param,
1707                                             &main_arg_params, fki);
1708           if (opnum == -1)
1709             return;
1710           else if (opnum > 0)
1711             {
1712               has_operand_number = 1;
1713               main_arg_num = opnum + info->first_arg_num - 1;
1714             }
1715         }
1716       else if (fki->flags & FMT_FLAG_USE_DOLLAR)
1717         {
1718           if (avoid_dollar_number (format_chars))
1719             return;
1720         }
1721
1722       /* Read any format flags, but do not yet validate them beyond removing
1723          duplicates, since in general validation depends on the rest of
1724          the format.  */
1725       while (*format_chars != 0
1726              && strchr (fki->flag_chars, *format_chars) != 0)
1727         {
1728           const format_flag_spec *s = get_flag_spec (flag_specs,
1729                                                      *format_chars, NULL);
1730           if (strchr (flag_chars, *format_chars) != 0)
1731             {
1732               warning ("repeated %s in format", _(s->name));
1733             }
1734           else
1735             {
1736               i = strlen (flag_chars);
1737               flag_chars[i++] = *format_chars;
1738               flag_chars[i] = 0;
1739             }
1740           if (s->skip_next_char)
1741             {
1742               ++format_chars;
1743               if (*format_chars == 0)
1744                 {
1745                   warning ("missing fill character at end of strfmon format");
1746                   return;
1747                 }
1748             }
1749           ++format_chars;
1750         }
1751
1752       /* Read any format width, possibly * or *m$.  */
1753       if (fki->width_char != 0)
1754         {
1755           if (fki->width_type != NULL && *format_chars == '*')
1756             {
1757               i = strlen (flag_chars);
1758               flag_chars[i++] = fki->width_char;
1759               flag_chars[i] = 0;
1760               /* "...a field width...may be indicated by an asterisk.
1761                  In this case, an int argument supplies the field width..."  */
1762               ++format_chars;
1763               if (has_operand_number != 0)
1764                 {
1765                   int opnum;
1766                   opnum = maybe_read_dollar_number (&format_chars,
1767                                                     has_operand_number == 1,
1768                                                     first_fillin_param,
1769                                                     &params, fki);
1770                   if (opnum == -1)
1771                     return;
1772                   else if (opnum > 0)
1773                     {
1774                       has_operand_number = 1;
1775                       arg_num = opnum + info->first_arg_num - 1;
1776                     }
1777                   else
1778                     has_operand_number = 0;
1779                 }
1780               else
1781                 {
1782                   if (avoid_dollar_number (format_chars))
1783                     return;
1784                 }
1785               if (info->first_arg_num != 0)
1786                 {
1787                   if (params == 0)
1788                     {
1789                       warning ("too few arguments for format");
1790                       return;
1791                     }
1792                   cur_param = TREE_VALUE (params);
1793                   if (has_operand_number <= 0)
1794                     {
1795                       params = TREE_CHAIN (params);
1796                       ++arg_num;
1797                     }
1798                   width_wanted_type.wanted_type = *fki->width_type;
1799                   width_wanted_type.wanted_type_name = NULL;
1800                   width_wanted_type.pointer_count = 0;
1801                   width_wanted_type.char_lenient_flag = 0;
1802                   width_wanted_type.writing_in_flag = 0;
1803                   width_wanted_type.reading_from_flag = 0;
1804                   width_wanted_type.name = _("field width");
1805                   width_wanted_type.param = cur_param;
1806                   width_wanted_type.arg_num = arg_num;
1807                   width_wanted_type.next = NULL;
1808                   if (last_wanted_type != 0)
1809                     last_wanted_type->next = &width_wanted_type;
1810                   if (first_wanted_type == 0)
1811                     first_wanted_type = &width_wanted_type;
1812                   last_wanted_type = &width_wanted_type;
1813                 }
1814             }
1815           else
1816             {
1817               /* Possibly read a numeric width.  If the width is zero,
1818                  we complain if appropriate.  */
1819               int non_zero_width_char = FALSE;
1820               int found_width = FALSE;
1821               while (ISDIGIT (*format_chars))
1822                 {
1823                   found_width = TRUE;
1824                   if (*format_chars != '0')
1825                     non_zero_width_char = TRUE;
1826                   ++format_chars;
1827                 }
1828               if (found_width && !non_zero_width_char &&
1829                   (fki->flags & (int) FMT_FLAG_ZERO_WIDTH_BAD))
1830                 warning ("zero width in %s format", fki->name);
1831               if (found_width)
1832                 {
1833                   i = strlen (flag_chars);
1834                   flag_chars[i++] = fki->width_char;
1835                   flag_chars[i] = 0;
1836                 }
1837             }
1838         }
1839
1840       /* Read any format left precision (must be a number, not *).  */
1841       if (fki->left_precision_char != 0 && *format_chars == '#')
1842         {
1843           ++format_chars;
1844           i = strlen (flag_chars);
1845           flag_chars[i++] = fki->left_precision_char;
1846           flag_chars[i] = 0;
1847           if (!ISDIGIT (*format_chars))
1848             warning ("empty left precision in %s format", fki->name);
1849           while (ISDIGIT (*format_chars))
1850             ++format_chars;
1851         }
1852
1853       /* Read any format precision, possibly * or *m$.  */
1854       if (fki->precision_char != 0 && *format_chars == '.')
1855         {
1856           ++format_chars;
1857           i = strlen (flag_chars);
1858           flag_chars[i++] = fki->precision_char;
1859           flag_chars[i] = 0;
1860           if (fki->precision_type != NULL && *format_chars == '*')
1861             {
1862               /* "...a...precision...may be indicated by an asterisk.
1863                  In this case, an int argument supplies the...precision."  */
1864               ++format_chars;
1865               if (has_operand_number != 0)
1866                 {
1867                   int opnum;
1868                   opnum = maybe_read_dollar_number (&format_chars,
1869                                                     has_operand_number == 1,
1870                                                     first_fillin_param,
1871                                                     &params, fki);
1872                   if (opnum == -1)
1873                     return;
1874                   else if (opnum > 0)
1875                     {
1876                       has_operand_number = 1;
1877                       arg_num = opnum + info->first_arg_num - 1;
1878                     }
1879                   else
1880                     has_operand_number = 0;
1881                 }
1882               else
1883                 {
1884                   if (avoid_dollar_number (format_chars))
1885                     return;
1886                 }
1887               if (info->first_arg_num != 0)
1888                 {
1889                   if (params == 0)
1890                     {
1891                       warning ("too few arguments for format");
1892                       return;
1893                     }
1894                   cur_param = TREE_VALUE (params);
1895                   if (has_operand_number <= 0)
1896                     {
1897                       params = TREE_CHAIN (params);
1898                       ++arg_num;
1899                     }
1900                   precision_wanted_type.wanted_type = *fki->precision_type;
1901                   precision_wanted_type.wanted_type_name = NULL;
1902                   precision_wanted_type.pointer_count = 0;
1903                   precision_wanted_type.char_lenient_flag = 0;
1904                   precision_wanted_type.writing_in_flag = 0;
1905                   precision_wanted_type.reading_from_flag = 0;
1906                   precision_wanted_type.name = _("field precision");
1907                   precision_wanted_type.param = cur_param;
1908                   precision_wanted_type.arg_num = arg_num;
1909                   precision_wanted_type.next = NULL;
1910                   if (last_wanted_type != 0)
1911                     last_wanted_type->next = &precision_wanted_type;
1912                   if (first_wanted_type == 0)
1913                     first_wanted_type = &precision_wanted_type;
1914                   last_wanted_type = &precision_wanted_type;
1915                 }
1916             }
1917           else
1918             {
1919               if (!(fki->flags & (int) FMT_FLAG_EMPTY_PREC_OK)
1920                   && !ISDIGIT (*format_chars))
1921                 warning ("empty precision in %s format", fki->name);
1922               while (ISDIGIT (*format_chars))
1923                 ++format_chars;
1924             }
1925         }
1926
1927       /* Read any length modifier, if this kind of format has them.  */
1928       fli = fki->length_char_specs;
1929       length_chars = NULL;
1930       length_chars_val = FMT_LEN_none;
1931       length_chars_std = STD_C89;
1932       if (fli)
1933         {
1934           while (fli->name != 0 && fli->name[0] != *format_chars)
1935             fli++;
1936           if (fli->name != 0)
1937             {
1938               format_chars++;
1939               if (fli->double_name != 0 && fli->name[0] == *format_chars)
1940                 {
1941                   format_chars++;
1942                   length_chars = fli->double_name;
1943                   length_chars_val = fli->double_index;
1944                   length_chars_std = fli->double_std;
1945                 }
1946               else
1947                 {
1948                   length_chars = fli->name;
1949                   length_chars_val = fli->index;
1950                   length_chars_std = fli->std;
1951                 }
1952               i = strlen (flag_chars);
1953               flag_chars[i++] = fki->length_code_char;
1954               flag_chars[i] = 0;
1955             }
1956           if (pedantic)
1957             {
1958               /* Warn if the length modifier is non-standard.  */
1959               if (ADJ_STD (length_chars_std) > C_STD_VER)
1960                 warning ("%s does not support the %qs %s length modifier",
1961                          C_STD_NAME (length_chars_std), length_chars,
1962                          fki->name);
1963             }
1964         }
1965
1966       /* Read any modifier (strftime E/O).  */
1967       if (fki->modifier_chars != NULL)
1968         {
1969           while (*format_chars != 0
1970                  && strchr (fki->modifier_chars, *format_chars) != 0)
1971             {
1972               if (strchr (flag_chars, *format_chars) != 0)
1973                 {
1974                   const format_flag_spec *s = get_flag_spec (flag_specs,
1975                                                              *format_chars, NULL);
1976                   warning ("repeated %s in format", _(s->name));
1977                 }
1978               else
1979                 {
1980                   i = strlen (flag_chars);
1981                   flag_chars[i++] = *format_chars;
1982                   flag_chars[i] = 0;
1983                 }
1984               ++format_chars;
1985             }
1986         }
1987
1988       /* Handle the scanf allocation kludge.  */
1989       if (fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
1990         {
1991           if (*format_chars == 'a' && !flag_isoc99)
1992             {
1993               if (format_chars[1] == 's' || format_chars[1] == 'S'
1994                   || format_chars[1] == '[')
1995                 {
1996                   /* `a' is used as a flag.  */
1997                   i = strlen (flag_chars);
1998                   flag_chars[i++] = 'a';
1999                   flag_chars[i] = 0;
2000                   format_chars++;
2001                 }
2002             }
2003         }
2004
2005       format_char = *format_chars;
2006       if (format_char == 0
2007           || (!(fki->flags & (int) FMT_FLAG_FANCY_PERCENT_OK)
2008               && format_char == '%'))
2009         {
2010           warning ("conversion lacks type at end of format");
2011           continue;
2012         }
2013       format_chars++;
2014       fci = fki->conversion_specs;
2015       while (fci->format_chars != 0
2016              && strchr (fci->format_chars, format_char) == 0)
2017           ++fci;
2018       if (fci->format_chars == 0)
2019         {
2020           if (ISGRAPH(format_char))
2021             warning ("unknown conversion type character %qc in format",
2022                      format_char);
2023           else
2024             warning ("unknown conversion type character 0x%x in format",
2025                      format_char);
2026           continue;
2027         }
2028       if (pedantic)
2029         {
2030           if (ADJ_STD (fci->std) > C_STD_VER)
2031             warning ("%s does not support the %<%%%c%> %s format",
2032                      C_STD_NAME (fci->std), format_char, fki->name);
2033         }
2034
2035       /* Validate the individual flags used, removing any that are invalid.  */
2036       {
2037         int d = 0;
2038         for (i = 0; flag_chars[i] != 0; i++)
2039           {
2040             const format_flag_spec *s = get_flag_spec (flag_specs,
2041                                                        flag_chars[i], NULL);
2042             flag_chars[i - d] = flag_chars[i];
2043             if (flag_chars[i] == fki->length_code_char)
2044               continue;
2045             if (strchr (fci->flag_chars, flag_chars[i]) == 0)
2046               {
2047                 warning ("%s used with %<%%%c%> %s format",
2048                          _(s->name), format_char, fki->name);
2049                 d++;
2050                 continue;
2051               }
2052             if (pedantic)
2053               {
2054                 const format_flag_spec *t;
2055                 if (ADJ_STD (s->std) > C_STD_VER)
2056                   warning ("%s does not support %s",
2057                            C_STD_NAME (s->std), _(s->long_name));
2058                 t = get_flag_spec (flag_specs, flag_chars[i], fci->flags2);
2059                 if (t != NULL && ADJ_STD (t->std) > ADJ_STD (s->std))
2060                   {
2061                     const char *long_name = (t->long_name != NULL
2062                                              ? t->long_name
2063                                              : s->long_name);
2064                     if (ADJ_STD (t->std) > C_STD_VER)
2065                       warning ("%s does not support %s with the %<%%%c%> %s format",
2066                                C_STD_NAME (t->std), _(long_name),
2067                                format_char, fki->name);
2068                   }
2069               }
2070           }
2071         flag_chars[i - d] = 0;
2072       }
2073
2074       if ((fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
2075           && strchr (flag_chars, 'a') != 0)
2076         aflag = 1;
2077
2078       if (fki->suppression_char
2079           && strchr (flag_chars, fki->suppression_char) != 0)
2080         suppressed = 1;
2081
2082       /* Validate the pairs of flags used.  */
2083       for (i = 0; bad_flag_pairs[i].flag_char1 != 0; i++)
2084         {
2085           const format_flag_spec *s, *t;
2086           if (strchr (flag_chars, bad_flag_pairs[i].flag_char1) == 0)
2087             continue;
2088           if (strchr (flag_chars, bad_flag_pairs[i].flag_char2) == 0)
2089             continue;
2090           if (bad_flag_pairs[i].predicate != 0
2091               && strchr (fci->flags2, bad_flag_pairs[i].predicate) == 0)
2092             continue;
2093           s = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char1, NULL);
2094           t = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char2, NULL);
2095           if (bad_flag_pairs[i].ignored)
2096             {
2097               if (bad_flag_pairs[i].predicate != 0)
2098                 warning ("%s ignored with %s and %<%%%c%> %s format",
2099                          _(s->name), _(t->name), format_char,
2100                          fki->name);
2101               else
2102                 warning ("%s ignored with %s in %s format",
2103                          _(s->name), _(t->name), fki->name);
2104             }
2105           else
2106             {
2107               if (bad_flag_pairs[i].predicate != 0)
2108                 warning ("use of %s and %s together with %<%%%c%> %s format",
2109                          _(s->name), _(t->name), format_char,
2110                          fki->name);
2111               else
2112                 warning ("use of %s and %s together in %s format",
2113                          _(s->name), _(t->name), fki->name);
2114             }
2115         }
2116
2117       /* Give Y2K warnings.  */
2118       if (warn_format_y2k)
2119         {
2120           int y2k_level = 0;
2121           if (strchr (fci->flags2, '4') != 0)
2122             if (strchr (flag_chars, 'E') != 0)
2123               y2k_level = 3;
2124             else
2125               y2k_level = 2;
2126           else if (strchr (fci->flags2, '3') != 0)
2127             y2k_level = 3;
2128           else if (strchr (fci->flags2, '2') != 0)
2129             y2k_level = 2;
2130           if (y2k_level == 3)
2131             warning ("%<%%%c%> yields only last 2 digits of year in some locales",
2132                      format_char);
2133           else if (y2k_level == 2)
2134             warning ("%<%%%c%> yields only last 2 digits of year", format_char);
2135         }
2136
2137       if (strchr (fci->flags2, '[') != 0)
2138         {
2139           /* Skip over scan set, in case it happens to have '%' in it.  */
2140           if (*format_chars == '^')
2141             ++format_chars;
2142           /* Find closing bracket; if one is hit immediately, then
2143              it's part of the scan set rather than a terminator.  */
2144           if (*format_chars == ']')
2145             ++format_chars;
2146           while (*format_chars && *format_chars != ']')
2147             ++format_chars;
2148           if (*format_chars != ']')
2149             /* The end of the format string was reached.  */
2150             warning ("no closing %<]%> for %<%%[%> format");
2151         }
2152
2153       wanted_type = 0;
2154       wanted_type_name = 0;
2155       if (fki->flags & (int) FMT_FLAG_ARG_CONVERT)
2156         {
2157           wanted_type = (fci->types[length_chars_val].type
2158                          ? *fci->types[length_chars_val].type : 0);
2159           wanted_type_name = fci->types[length_chars_val].name;
2160           wanted_type_std = fci->types[length_chars_val].std;
2161           if (wanted_type == 0)
2162             {
2163               warning ("use of %qs length modifier with %qc type character",
2164                        length_chars, format_char);
2165               /* Heuristic: skip one argument when an invalid length/type
2166                  combination is encountered.  */
2167               arg_num++;
2168               if (params == 0)
2169                 {
2170                   warning ("too few arguments for format");
2171                   return;
2172                 }
2173               params = TREE_CHAIN (params);
2174               continue;
2175             }
2176           else if (pedantic
2177                    /* Warn if non-standard, provided it is more non-standard
2178                       than the length and type characters that may already
2179                       have been warned for.  */
2180                    && ADJ_STD (wanted_type_std) > ADJ_STD (length_chars_std)
2181                    && ADJ_STD (wanted_type_std) > ADJ_STD (fci->std))
2182             {
2183               if (ADJ_STD (wanted_type_std) > C_STD_VER)
2184                 warning ("%s does not support the %<%%%s%c%> %s format",
2185                          C_STD_NAME (wanted_type_std), length_chars,
2186                          format_char, fki->name);
2187             }
2188         }
2189
2190       /* Finally. . .check type of argument against desired type!  */
2191       if (info->first_arg_num == 0)
2192         continue;
2193       if ((fci->pointer_count == 0 && wanted_type == void_type_node)
2194           || suppressed)
2195         {
2196           if (main_arg_num != 0)
2197             {
2198               if (suppressed)
2199                 warning ("operand number specified with suppressed assignment");
2200               else
2201                 warning ("operand number specified for format taking no argument");
2202             }
2203         }
2204       else
2205         {
2206           if (main_arg_num != 0)
2207             {
2208               arg_num = main_arg_num;
2209               params = main_arg_params;
2210             }
2211           else
2212             {
2213               ++arg_num;
2214               if (has_operand_number > 0)
2215                 {
2216                   warning ("missing $ operand number in format");
2217                   return;
2218                 }
2219               else
2220                 has_operand_number = 0;
2221               if (params == 0)
2222                 {
2223                   warning ("too few arguments for format");
2224                   return;
2225                 }
2226             }
2227           cur_param = TREE_VALUE (params);
2228           params = TREE_CHAIN (params);
2229           main_wanted_type.wanted_type = wanted_type;
2230           main_wanted_type.wanted_type_name = wanted_type_name;
2231           main_wanted_type.pointer_count = fci->pointer_count + aflag;
2232           main_wanted_type.char_lenient_flag = 0;
2233           if (strchr (fci->flags2, 'c') != 0)
2234             main_wanted_type.char_lenient_flag = 1;
2235           main_wanted_type.writing_in_flag = 0;
2236           main_wanted_type.reading_from_flag = 0;
2237           if (aflag)
2238             main_wanted_type.writing_in_flag = 1;
2239           else
2240             {
2241               if (strchr (fci->flags2, 'W') != 0)
2242                 main_wanted_type.writing_in_flag = 1;
2243               if (strchr (fci->flags2, 'R') != 0)
2244                 main_wanted_type.reading_from_flag = 1;
2245             }
2246           main_wanted_type.name = NULL;
2247           main_wanted_type.param = cur_param;
2248           main_wanted_type.arg_num = arg_num;
2249           main_wanted_type.next = NULL;
2250           if (last_wanted_type != 0)
2251             last_wanted_type->next = &main_wanted_type;
2252           if (first_wanted_type == 0)
2253             first_wanted_type = &main_wanted_type;
2254           last_wanted_type = &main_wanted_type;
2255         }
2256
2257       if (first_wanted_type != 0)
2258         check_format_types (first_wanted_type);
2259
2260     }
2261 }
2262
2263
2264 /* Check the argument types from a single format conversion (possibly
2265    including width and precision arguments).  */
2266 static void
2267 check_format_types (format_wanted_type *types)
2268 {
2269   for (; types != 0; types = types->next)
2270     {
2271       tree cur_param;
2272       tree cur_type;
2273       tree orig_cur_type;
2274       tree wanted_type;
2275       int arg_num;
2276       int i;
2277       int char_type_flag;
2278       cur_param = types->param;
2279       cur_type = TREE_TYPE (cur_param);
2280       if (cur_type == error_mark_node)
2281         continue;
2282       char_type_flag = 0;
2283       wanted_type = types->wanted_type;
2284       arg_num = types->arg_num;
2285
2286       /* The following should not occur here.  */
2287       if (wanted_type == 0)
2288         abort ();
2289       if (wanted_type == void_type_node && types->pointer_count == 0)
2290         abort ();
2291
2292       if (types->pointer_count == 0)
2293         wanted_type = lang_hooks.types.type_promotes_to (wanted_type);
2294
2295       STRIP_NOPS (cur_param);
2296
2297       /* Check the types of any additional pointer arguments
2298          that precede the "real" argument.  */
2299       for (i = 0; i < types->pointer_count; ++i)
2300         {
2301           if (TREE_CODE (cur_type) == POINTER_TYPE)
2302             {
2303               cur_type = TREE_TYPE (cur_type);
2304               if (cur_type == error_mark_node)
2305                 break;
2306
2307               /* Check for writing through a NULL pointer.  */
2308               if (types->writing_in_flag
2309                   && i == 0
2310                   && cur_param != 0
2311                   && integer_zerop (cur_param))
2312                 warning ("writing through null pointer (arg %d)",
2313                          arg_num);
2314
2315               /* Check for reading through a NULL pointer.  */
2316               if (types->reading_from_flag
2317                   && i == 0
2318                   && cur_param != 0
2319                   && integer_zerop (cur_param))
2320                 warning ("reading through null pointer (arg %d)",
2321                          arg_num);
2322
2323               if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
2324                 cur_param = TREE_OPERAND (cur_param, 0);
2325               else
2326                 cur_param = 0;
2327
2328               /* See if this is an attempt to write into a const type with
2329                  scanf or with printf "%n".  Note: the writing in happens
2330                  at the first indirection only, if for example
2331                  void * const * is passed to scanf %p; passing
2332                  const void ** is simply passing an incompatible type.  */
2333               if (types->writing_in_flag
2334                   && i == 0
2335                   && (TYPE_READONLY (cur_type)
2336                       || (cur_param != 0
2337                           && (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c'
2338                               || (DECL_P (cur_param)
2339                                   && TREE_READONLY (cur_param))))))
2340                 warning ("writing into constant object (arg %d)", arg_num);
2341
2342               /* If there are extra type qualifiers beyond the first
2343                  indirection, then this makes the types technically
2344                  incompatible.  */
2345               if (i > 0
2346                   && pedantic
2347                   && (TYPE_READONLY (cur_type)
2348                       || TYPE_VOLATILE (cur_type)
2349                       || TYPE_RESTRICT (cur_type)))
2350                 warning ("extra type qualifiers in format argument (arg %d)",
2351                          arg_num);
2352
2353             }
2354           else
2355             {
2356               if (types->pointer_count == 1)
2357                 warning ("format argument is not a pointer (arg %d)", arg_num);
2358               else
2359                 warning ("format argument is not a pointer to a pointer (arg %d)", arg_num);
2360               break;
2361             }
2362         }
2363
2364       if (i < types->pointer_count)
2365         continue;
2366
2367       orig_cur_type = cur_type;
2368       cur_type = TYPE_MAIN_VARIANT (cur_type);
2369
2370       /* Check whether the argument type is a character type.  This leniency
2371          only applies to certain formats, flagged with 'c'.
2372       */
2373       if (types->char_lenient_flag)
2374         char_type_flag = (cur_type == char_type_node
2375                           || cur_type == signed_char_type_node
2376                           || cur_type == unsigned_char_type_node);
2377
2378       /* Check the type of the "real" argument, if there's a type we want.  */
2379       if (wanted_type == cur_type)
2380         continue;
2381       /* If we want `void *', allow any pointer type.
2382          (Anything else would already have got a warning.)
2383          With -pedantic, only allow pointers to void and to character
2384          types.  */
2385       if (wanted_type == void_type_node
2386           && (!pedantic || (i == 1 && char_type_flag)))
2387         continue;
2388       /* Don't warn about differences merely in signedness, unless
2389          -pedantic.  With -pedantic, warn if the type is a pointer
2390          target and not a character type, and for character types at
2391          a second level of indirection.  */
2392       if (TREE_CODE (wanted_type) == INTEGER_TYPE
2393           && TREE_CODE (cur_type) == INTEGER_TYPE
2394           && (! pedantic || i == 0 || (i == 1 && char_type_flag))
2395           && (TYPE_UNSIGNED (wanted_type)
2396               ? wanted_type == c_common_unsigned_type (cur_type)
2397               : wanted_type == c_common_signed_type (cur_type)))
2398         continue;
2399       /* Likewise, "signed char", "unsigned char" and "char" are
2400          equivalent but the above test won't consider them equivalent.  */
2401       if (wanted_type == char_type_node
2402           && (! pedantic || i < 2)
2403           && char_type_flag)
2404         continue;
2405       /* Now we have a type mismatch.  */
2406       {
2407         const char *this;
2408         const char *that;
2409         tree tmp;
2410
2411         tmp = TYPE_NAME (wanted_type);
2412         if (TREE_CODE (tmp) == TYPE_DECL)
2413           tmp = DECL_NAME (tmp);
2414         this = IDENTIFIER_POINTER (tmp);
2415
2416         that = 0;
2417         if (TYPE_NAME (orig_cur_type) != 0
2418             && TREE_CODE (orig_cur_type) != INTEGER_TYPE
2419             && !(TREE_CODE (orig_cur_type) == POINTER_TYPE
2420                  && TREE_CODE (TREE_TYPE (orig_cur_type)) == INTEGER_TYPE))
2421           {
2422             tmp = TYPE_NAME (orig_cur_type);
2423             if (TREE_CODE (tmp) == TYPE_DECL)
2424               tmp = DECL_NAME (tmp);
2425             if (tmp)
2426               that = IDENTIFIER_POINTER (tmp);
2427           }
2428
2429         /* A nameless type can't possibly match what the format wants.
2430            So there will be a warning for it.
2431            Make up a string to describe vaguely what it is.  */
2432         if (that == 0)
2433           {
2434             if (TREE_CODE (orig_cur_type) == POINTER_TYPE)
2435               that = _("pointer");
2436             else
2437               that = _("different type");
2438           }
2439
2440         /* Make the warning better in case of mismatch of int vs long.  */
2441         if (TREE_CODE (orig_cur_type) == INTEGER_TYPE
2442             && TREE_CODE (wanted_type) == INTEGER_TYPE
2443             && TYPE_PRECISION (orig_cur_type) == TYPE_PRECISION (wanted_type)
2444             && TYPE_NAME (orig_cur_type) != 0
2445             && TREE_CODE (TYPE_NAME (orig_cur_type)) == TYPE_DECL)
2446           that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type)));
2447
2448         if (strcmp (this, that) != 0)
2449           {
2450             /* There may be a better name for the format, e.g. size_t,
2451                but we should allow for programs with a perverse typedef
2452                making size_t something other than what the compiler
2453                thinks.  */
2454             if (types->wanted_type_name != 0
2455                 && strcmp (types->wanted_type_name, that) != 0)
2456               this = types->wanted_type_name;
2457             if (types->name != 0)
2458               warning ("%s is not type %s (arg %d)", types->name, this,
2459                        arg_num);
2460             else
2461               warning ("%s format, %s arg (arg %d)", this, that, arg_num);
2462           }
2463       }
2464     }
2465 }
2466
2467 /* Given a format_char_info array FCI, and a character C, this function
2468    returns the index into the conversion_specs where that specifier's
2469    data is located.  If the character isn't found it aborts.  */
2470 static unsigned int
2471 find_char_info_specifier_index (const format_char_info *fci, int c)
2472 {
2473   unsigned int i = 0;
2474   
2475   while (fci->format_chars)
2476     {
2477       if (strchr (fci->format_chars, c))
2478         return i;
2479       i++; fci++;
2480     }
2481   
2482   /* We shouldn't be looking for a non-existent specifier.  */
2483   abort ();
2484 }
2485
2486 /* Given a format_length_info array FLI, and a character C, this
2487    function returns the index into the conversion_specs where that
2488    modifier's data is located.  If the character isn't found it
2489    aborts.  */
2490 static unsigned int
2491 find_length_info_modifier_index (const format_length_info *fli, int c)
2492 {
2493   unsigned int i = 0;
2494   
2495   while (fli->name)
2496     {
2497       if (strchr (fli->name, c))
2498         return i;
2499       i++; fli++;
2500     }
2501   
2502   /* We shouldn't be looking for a non-existent modifier.  */
2503   abort ();
2504 }
2505
2506 /* Determine the type of HOST_WIDE_INT in the code being compiled for
2507    use in GCC's __asm_fprintf__ custom format attribute.  You must
2508    have set dynamic_format_types before calling this function.  */
2509 static void
2510 init_dynamic_asm_fprintf_info (void)
2511 {
2512   static tree hwi;
2513       
2514   if (!hwi)
2515     {
2516       format_length_info *new_asm_fprintf_length_specs;
2517       unsigned int i;
2518           
2519       /* Find the underlying type for HOST_WIDE_INT.  For the %w
2520          length modifier to work, one must have issued: "typedef
2521          HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
2522          prior to using that modifier.  */
2523       if (!(hwi = maybe_get_identifier ("__gcc_host_wide_int__"))
2524           || !(hwi = DECL_ORIGINAL_TYPE (identifier_global_value (hwi))))
2525         abort ();
2526
2527       /* Create a new (writable) copy of asm_fprintf_length_specs.  */
2528       new_asm_fprintf_length_specs = xmemdup (asm_fprintf_length_specs,
2529                                               sizeof (asm_fprintf_length_specs),
2530                                               sizeof (asm_fprintf_length_specs));
2531
2532       /* HOST_WIDE_INT must be one of 'long' or 'long long'.  */
2533       i = find_length_info_modifier_index (new_asm_fprintf_length_specs, 'w');
2534       if (hwi == long_integer_type_node)
2535         new_asm_fprintf_length_specs[i].index = FMT_LEN_l;
2536       else if (hwi == long_long_integer_type_node)
2537         new_asm_fprintf_length_specs[i].index = FMT_LEN_ll;
2538       else
2539         abort ();
2540
2541       /* Assign the new data for use.  */
2542       dynamic_format_types[asm_fprintf_format_type].length_char_specs =
2543         new_asm_fprintf_length_specs;
2544     }
2545 }
2546
2547 /* Determine the types of "tree" and "location_t" in the code being
2548    compiled for use in GCC's diagnostic custom format attributes.  You
2549    must have set dynamic_format_types before calling this function.  */
2550 static void
2551 init_dynamic_diag_info (void)
2552 {
2553   static tree t, loc, hwi;
2554       
2555   if (!loc || !t || !hwi)
2556     {
2557       static format_char_info *diag_fci, *cdiag_fci, *cxxdiag_fci;
2558       static format_length_info *diag_ls;
2559       unsigned int i;
2560
2561       /* For the GCC-diagnostics custom format specifiers to work, one
2562          must have declared `tree' and/or `location_t' prior to using
2563          those attributes.  If we haven't seen these declarations then
2564          you shouldn't use the specifiers requiring these types.
2565          However we don't force a hard ICE because we may see only one
2566          or the other type.  */
2567       if ((loc = maybe_get_identifier ("location_t")))
2568         loc = TREE_TYPE (identifier_global_value (loc));
2569
2570       /* We need to grab the underlying `union tree_node' so peek into
2571          an extra type level.  */
2572       if ((t = maybe_get_identifier ("tree")))
2573         t = TREE_TYPE (TREE_TYPE (identifier_global_value (t)));
2574     
2575       /* Find the underlying type for HOST_WIDE_INT.  For the %w
2576          length modifier to work, one must have issued: "typedef
2577          HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
2578          prior to using that modifier.  */
2579       if ((hwi = maybe_get_identifier ("__gcc_host_wide_int__")))
2580         hwi = DECL_ORIGINAL_TYPE (identifier_global_value (hwi));
2581       
2582       /* Assign the new data for use.  */
2583
2584       /* All the GCC diag formats use the same length specs.  */
2585       if (! diag_ls)
2586         dynamic_format_types[gcc_diag_format_type].length_char_specs =
2587           dynamic_format_types[gcc_cdiag_format_type].length_char_specs =
2588           dynamic_format_types[gcc_cxxdiag_format_type].length_char_specs =
2589           diag_ls = xmemdup (gcc_diag_length_specs,
2590                              sizeof (gcc_diag_length_specs),
2591                              sizeof (gcc_diag_length_specs)); 
2592       if (hwi)
2593         {
2594           /* HOST_WIDE_INT must be one of 'long' or 'long long'.  */
2595           i = find_length_info_modifier_index (diag_ls, 'w');
2596           if (hwi == long_integer_type_node)
2597             diag_ls[i].index = FMT_LEN_l;
2598           else if (hwi == long_long_integer_type_node)
2599             diag_ls[i].index = FMT_LEN_ll;
2600           else
2601             abort ();
2602         }
2603
2604       /* Handle the __gcc_diag__ format specifics.  */
2605       if (! diag_fci)
2606         dynamic_format_types[gcc_diag_format_type].conversion_specs =
2607           diag_fci = xmemdup (gcc_diag_char_table,
2608                               sizeof(gcc_diag_char_table),
2609                               sizeof(gcc_diag_char_table));
2610       if (loc)
2611         {
2612           i = find_char_info_specifier_index (diag_fci, 'H');
2613           diag_fci[i].types[0].type = &loc;
2614           diag_fci[i].pointer_count = 1;
2615         }
2616       if (t)
2617         {
2618           i = find_char_info_specifier_index (diag_fci, 'J');
2619           diag_fci[i].types[0].type = &t;
2620           diag_fci[i].pointer_count = 1;
2621         }
2622
2623       /* Handle the __gcc_cdiag__ format specifics.  */
2624       if (! cdiag_fci)
2625         dynamic_format_types[gcc_cdiag_format_type].conversion_specs =
2626           cdiag_fci = xmemdup (gcc_cdiag_char_table,
2627                                sizeof(gcc_cdiag_char_table),
2628                                sizeof(gcc_cdiag_char_table));
2629       if (loc)
2630         {
2631           i = find_char_info_specifier_index (cdiag_fci, 'H');
2632           cdiag_fci[i].types[0].type = &loc;
2633           cdiag_fci[i].pointer_count = 1;
2634         }
2635       if (t)
2636         {
2637           /* All specifiers taking a tree share the same struct.  */
2638           i = find_char_info_specifier_index (cdiag_fci, 'D');
2639           cdiag_fci[i].types[0].type = &t;
2640           cdiag_fci[i].pointer_count = 1;
2641           i = find_char_info_specifier_index (cdiag_fci, 'J');
2642           cdiag_fci[i].types[0].type = &t;
2643           cdiag_fci[i].pointer_count = 1;
2644         }
2645
2646       /* Handle the __gcc_cxxdiag__ format specifics.  */
2647       if (! cxxdiag_fci)
2648         dynamic_format_types[gcc_cxxdiag_format_type].conversion_specs =
2649           cxxdiag_fci = xmemdup (gcc_cxxdiag_char_table,
2650                                  sizeof(gcc_cxxdiag_char_table),
2651                                  sizeof(gcc_cxxdiag_char_table));
2652       if (loc)
2653         {
2654           i = find_char_info_specifier_index (cxxdiag_fci, 'H');
2655           cxxdiag_fci[i].types[0].type = &loc;
2656           cxxdiag_fci[i].pointer_count = 1;
2657         }
2658       if (t)
2659         {
2660           /* All specifiers taking a tree share the same struct.  */
2661           i = find_char_info_specifier_index (cxxdiag_fci, 'D');
2662           cxxdiag_fci[i].types[0].type = &t;
2663           cxxdiag_fci[i].pointer_count = 1;
2664           i = find_char_info_specifier_index (cxxdiag_fci, 'J');
2665           cxxdiag_fci[i].types[0].type = &t;
2666           cxxdiag_fci[i].pointer_count = 1;
2667         }
2668     }
2669 }
2670
2671 /* Handle a "format" attribute; arguments as in
2672    struct attribute_spec.handler.  */
2673 tree
2674 handle_format_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
2675                          int flags, bool *no_add_attrs)
2676 {
2677   tree type = *node;
2678   function_format_info info;
2679   tree argument;
2680
2681   if (!decode_format_attr (args, &info, 0))
2682     {
2683       *no_add_attrs = true;
2684       return NULL_TREE;
2685     }
2686
2687   argument = TYPE_ARG_TYPES (type);
2688   if (argument)
2689     {
2690       if (!check_format_string (argument, info.format_num, flags,
2691                                 no_add_attrs))
2692         return NULL_TREE;
2693
2694       if (info.first_arg_num != 0)
2695         {
2696           unsigned HOST_WIDE_INT arg_num = 1;
2697
2698           /* Verify that first_arg_num points to the last arg,
2699              the ...  */
2700           while (argument)
2701             arg_num++, argument = TREE_CHAIN (argument);
2702
2703           if (arg_num != info.first_arg_num)
2704             {
2705               if (!(flags & (int) ATTR_FLAG_BUILT_IN))
2706                 error ("args to be formatted is not '...'");
2707               *no_add_attrs = true;
2708               return NULL_TREE;
2709             }
2710         }
2711     }
2712
2713   if (info.format_type == strftime_format_type && info.first_arg_num != 0)
2714     {
2715       error ("strftime formats cannot format arguments");
2716       *no_add_attrs = true;
2717       return NULL_TREE;
2718     }
2719
2720   /* If this is a custom GCC-internal format type, we have to
2721      initialize certain bits a runtime.  */
2722   if (info.format_type == asm_fprintf_format_type
2723       || info.format_type == gcc_diag_format_type
2724       || info.format_type == gcc_cdiag_format_type
2725       || info.format_type == gcc_cxxdiag_format_type)
2726     {
2727       /* Our first time through, we have to make sure that our
2728          format_type data is allocated dynamically and is modifiable.  */
2729       if (!dynamic_format_types)
2730         format_types = dynamic_format_types =
2731           xmemdup (format_types_orig, sizeof (format_types_orig),
2732                    sizeof (format_types_orig));
2733
2734       /* If this is format __asm_fprintf__, we have to initialize
2735          GCC's notion of HOST_WIDE_INT for checking %wd.  */
2736       if (info.format_type == asm_fprintf_format_type)
2737         init_dynamic_asm_fprintf_info();
2738       /* If this is one of the diagnostic attributes, then we have to
2739          initialize `location_t' and `tree' at runtime.  */
2740       else if (info.format_type == gcc_diag_format_type
2741                || info.format_type == gcc_cdiag_format_type
2742                || info.format_type == gcc_cxxdiag_format_type)
2743         init_dynamic_diag_info();
2744       else
2745         abort();
2746     }
2747
2748   return NULL_TREE;
2749 }