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