gcc/c-family/c-format.h

   1 /* Check calls to formatted I/O functions (-Wformat).
   2    Copyright (C) 1992-2013 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef GCC_C_FORMAT_H
  21 #define GCC_C_FORMAT_H
  22
  23 /* The meaningfully distinct length modifiers for format checking recognized
  24    by GCC.  */
  25 enum format_lengths
  26 {
  27   FMT_LEN_none,
  28   FMT_LEN_hh,
  29   FMT_LEN_h,
  30   FMT_LEN_l,
  31   FMT_LEN_ll,
  32   FMT_LEN_L,
  33   FMT_LEN_z,
  34   FMT_LEN_t,
  35   FMT_LEN_j,
  36   FMT_LEN_H,
  37   FMT_LEN_D,
  38   FMT_LEN_DD,
  39   FMT_LEN_MAX
  40 };
  41
  42
  43 /* The standard versions in which various format features appeared.  */
  44 enum format_std_version
  45 {
  46   STD_C89,
  47   STD_C94,
  48   STD_C9L, /* C99, but treat as C89 if -Wno-long-long.  */
  49   STD_C99,
  50   STD_EXT
  51 };
  52
  53 /* Flags that may apply to a particular kind of format checked by GCC.  */
  54 enum
  55 {
  56   /* This format converts arguments of types determined by the
  57      format string.  */
  58   FMT_FLAG_ARG_CONVERT = 1,
  59   /* The scanf allocation 'a' kludge applies to this format kind.  */
  60   FMT_FLAG_SCANF_A_KLUDGE = 2,
  61   /* A % during parsing a specifier is allowed to be a modified % rather
  62      that indicating the format is broken and we are out-of-sync.  */
  63   FMT_FLAG_FANCY_PERCENT_OK = 4,
  64   /* With $ operand numbers, it is OK to reference the same argument more
  65      than once.  */
  66   FMT_FLAG_DOLLAR_MULTIPLE = 8,
  67   /* This format type uses $ operand numbers (strfmon doesn't).  */
  68   FMT_FLAG_USE_DOLLAR = 16,
  69   /* Zero width is bad in this type of format (scanf).  */
  70   FMT_FLAG_ZERO_WIDTH_BAD = 32,
  71   /* Empty precision specification is OK in this type of format (printf).  */
  72   FMT_FLAG_EMPTY_PREC_OK = 64,
  73   /* Gaps are allowed in the arguments with $ operand numbers if all
  74      arguments are pointers (scanf).  */
  75   FMT_FLAG_DOLLAR_GAP_POINTER_OK = 128,
  76   /* The format arg is an opaque object that will be parsed by an external
  77      facility.  */
  78   FMT_FLAG_PARSE_ARG_CONVERT_EXTERNAL = 256
  79   /* Not included here: details of whether width or precision may occur
  80      (controlled by width_char and precision_char); details of whether
  81      '*' can be used for these (width_type and precision_type); details
  82      of whether length modifiers can occur (length_char_specs).  */
  83 };
  84
  85 /* Structure describing a length modifier supported in format checking, and
  86    possibly a doubled version such as "hh".  */
  87 typedef struct
  88 {
  89   /* Name of the single-character length modifier. If prefixed by
  90      a zero character, it describes a multi character length
  91      modifier, like I64, I32, etc.  */
  92   const char *name;
  93   /* Index into a format_char_info.types array.  */
  94   enum format_lengths index;
  95   /* Standard version this length appears in.  */
  96   enum format_std_version std;
  97   /* Same, if the modifier can be repeated, or NULL if it can't.  */
  98   const char *double_name;
  99   enum format_lengths double_index;
 100   enum format_std_version double_std;
 101
 102   /* If this flag is set, just scalar width identity is checked, and
 103      not the type identity itself.  */
 104   int scalar_identity_flag;
 105 } format_length_info;
 106
 107
 108 /* Structure describing the combination of a conversion specifier
 109    (or a set of specifiers which act identically) and a length modifier.  */
 110 typedef struct
 111 {
 112   /* The standard version this combination of length and type appeared in.
 113      This is only relevant if greater than those for length and type
 114      individually; otherwise it is ignored.  */
 115   enum format_std_version std;
 116   /* The name to use for the type, if different from that generated internally
 117      (e.g., "signed size_t").  */
 118   const char *name;
 119   /* The type itself.  */
 120   tree *type;
 121 } format_type_detail;
 122
 123
 124 /* Macros to fill out tables of these.  */
 125 #define NOARGUMENTS     { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
 126 #define BADLEN  { STD_C89, NULL, NULL }
 127 #define NOLENGTHS       { BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
 128
 129
 130 /* Structure describing a format conversion specifier (or a set of specifiers
 131    which act identically), and the length modifiers used with it.  */
 132 typedef struct format_char_info
 133 {
 134   const char *format_chars;
 135   int pointer_count;
 136   enum format_std_version std;
 137   /* Types accepted for each length modifier.  */
 138   format_type_detail types[FMT_LEN_MAX];
 139   /* List of other modifier characters allowed with these specifiers.
 140      This lists flags, and additionally "w" for width, "p" for precision
 141      (right precision, for strfmon), "#" for left precision (strfmon),
 142      "a" for scanf "a" allocation extension (not applicable in C99 mode),
 143      "*" for scanf suppression, and "E" and "O" for those strftime
 144      modifiers.  */
 145   const char *flag_chars;
 146   /* List of additional flags describing these conversion specifiers.
 147      "c" for generic character pointers being allowed, "2" for strftime
 148      two digit year formats, "3" for strftime formats giving two digit
 149      years in some locales, "4" for "2" which becomes "3" with an "E" modifier,
 150      "o" if use of strftime "O" is a GNU extension beyond C99,
 151      "W" if the argument is a pointer which is dereferenced and written into,
 152      "R" if the argument is a pointer which is dereferenced and read from,
 153      "i" for printf integer formats where the '0' flag is ignored with
 154      precision, and "[" for the starting character of a scanf scanset.  */
 155   const char *flags2;
 156   /* If this format conversion character consumes more than one argument,
 157      CHAIN points to information about the next argument.  For later
 158      arguments, only POINTER_COUNT, TYPES, and the "c", "R", and "W" flags
 159      in FLAGS2 are used.  */
 160   const struct format_char_info *chain;
 161 } format_char_info;
 162
 163
 164 /* Structure describing a flag accepted by some kind of format.  */
 165 typedef struct
 166 {
 167   /* The flag character in question (0 for end of array).  */
 168   int flag_char;
 169   /* Zero if this entry describes the flag character in general, or a
 170      nonzero character that may be found in flags2 if it describes the
 171      flag when used with certain formats only.  If the latter, only
 172      the first such entry found that applies to the current conversion
 173      specifier is used; the values of 'name' and 'long_name' it supplies
 174      will be used, if non-NULL and the standard version is higher than
 175      the unpredicated one, for any pedantic warning.  For example, 'o'
 176      for strftime formats (meaning 'O' is an extension over C99).  */
 177   int predicate;
 178   /* Nonzero if the next character after this flag in the format should
 179      be skipped ('=' in strfmon), zero otherwise.  */
 180   int skip_next_char;
 181   /* The name to use for this flag in diagnostic messages.  For example,
 182      N_("'0' flag"), N_("field width").  */
 183   const char *name;
 184   /* Long name for this flag in diagnostic messages; currently only used for
 185      "ISO C does not support ...".  For example, N_("the 'I' printf flag").  */
 186   const char *long_name;
 187   /* The standard version in which it appeared.  */
 188   enum format_std_version std;
 189 } format_flag_spec;
 190
 191
 192 /* Structure describing a combination of flags that is bad for some kind
 193    of format.  */
 194 typedef struct
 195 {
 196   /* The first flag character in question (0 for end of array).  */
 197   int flag_char1;
 198   /* The second flag character.  */
 199   int flag_char2;
 200   /* Nonzero if the message should say that the first flag is ignored with
 201      the second, zero if the combination should simply be objected to.  */
 202   int ignored;
 203   /* Zero if this entry applies whenever this flag combination occurs,
 204      a nonzero character from flags2 if it only applies in some
 205      circumstances (e.g. 'i' for printf formats ignoring 0 with precision).  */
 206   int predicate;
 207 } format_flag_pair;
 208
 209
 210 /* Structure describing a particular kind of format processed by GCC.  */
 211 typedef struct
 212 {
 213   /* The name of this kind of format, for use in diagnostics.  Also
 214      the name of the attribute (without preceding and following __).  */
 215   const char *name;
 216   /* Specifications of the length modifiers accepted; possibly NULL.  */
 217   const format_length_info *length_char_specs;
 218   /* Details of the conversion specification characters accepted.  */
 219   const format_char_info *conversion_specs;
 220   /* String listing the flag characters that are accepted.  */
 221   const char *flag_chars;
 222   /* String listing modifier characters (strftime) accepted.  May be NULL.  */
 223   const char *modifier_chars;
 224   /* Details of the flag characters, including pseudo-flags.  */
 225   const format_flag_spec *flag_specs;
 226   /* Details of bad combinations of flags.  */
 227   const format_flag_pair *bad_flag_pairs;
 228   /* Flags applicable to this kind of format.  */
 229   int flags;
 230   /* Flag character to treat a width as, or 0 if width not used.  */
 231   int width_char;
 232   /* Flag character to treat a left precision (strfmon) as,
 233      or 0 if left precision not used.  */
 234   int left_precision_char;
 235   /* Flag character to treat a precision (for strfmon, right precision) as,
 236      or 0 if precision not used.  */
 237   int precision_char;
 238   /* If a flag character has the effect of suppressing the conversion of
 239      an argument ('*' in scanf), that flag character, otherwise 0.  */
 240   int suppression_char;
 241   /* Flag character to treat a length modifier as (ignored if length
 242      modifiers not used).  Need not be placed in flag_chars for conversion
 243      specifiers, but is used to check for bad combinations such as length
 244      modifier with assignment suppression in scanf.  */
 245   int length_code_char;
 246   /* Assignment-allocation flag character ('m' in scanf), otherwise 0.  */
 247   int alloc_char;
 248   /* Pointer to type of argument expected if '*' is used for a width,
 249      or NULL if '*' not used for widths.  */
 250   tree *width_type;
 251   /* Pointer to type of argument expected if '*' is used for a precision,
 252      or NULL if '*' not used for precisions.  */
 253   tree *precision_type;
 254 } format_kind_info;
 255
 256 #define T_I     &integer_type_node
 257 #define T89_I   { STD_C89, NULL, T_I }
 258 #define T_L     &long_integer_type_node
 259 #define T89_L   { STD_C89, NULL, T_L }
 260 #define T_LL    &long_long_integer_type_node
 261 #define T9L_LL  { STD_C9L, NULL, T_LL }
 262 #define TEX_LL  { STD_EXT, NULL, T_LL }
 263 #define T_S     &short_integer_type_node
 264 #define T89_S   { STD_C89, NULL, T_S }
 265 #define T_UI    &unsigned_type_node
 266 #define T89_UI  { STD_C89, NULL, T_UI }
 267 #define T_UL    &long_unsigned_type_node
 268 #define T89_UL  { STD_C89, NULL, T_UL }
 269 #define T_ULL   &long_long_unsigned_type_node
 270 #define T9L_ULL { STD_C9L, NULL, T_ULL }
 271 #define TEX_ULL { STD_EXT, NULL, T_ULL }
 272 #define T_US    &short_unsigned_type_node
 273 #define T89_US  { STD_C89, NULL, T_US }
 274 #define T_F     &float_type_node
 275 #define T89_F   { STD_C89, NULL, T_F }
 276 #define T99_F   { STD_C99, NULL, T_F }
 277 #define T_D     &double_type_node
 278 #define T89_D   { STD_C89, NULL, T_D }
 279 #define T99_D   { STD_C99, NULL, T_D }
 280 #define T_LD    &long_double_type_node
 281 #define T89_LD  { STD_C89, NULL, T_LD }
 282 #define T99_LD  { STD_C99, NULL, T_LD }
 283 #define T_C     &char_type_node
 284 #define T89_C   { STD_C89, NULL, T_C }
 285 #define T_SC    &signed_char_type_node
 286 #define T99_SC  { STD_C99, NULL, T_SC }
 287 #define T_UC    &unsigned_char_type_node
 288 #define T99_UC  { STD_C99, NULL, T_UC }
 289 #define T_V     &void_type_node
 290 #define T89_V   { STD_C89, NULL, T_V }
 291 #define T_W     &wchar_type_node
 292 #define T94_W   { STD_C94, "wchar_t", T_W }
 293 #define TEX_W   { STD_EXT, "wchar_t", T_W }
 294 #define T_WI    &wint_type_node
 295 #define T94_WI  { STD_C94, "wint_t", T_WI }
 296 #define TEX_WI  { STD_EXT, "wint_t", T_WI }
 297 #define T_ST    &size_type_node
 298 #define T99_ST  { STD_C99, "size_t", T_ST }
 299 #define T_SST   &signed_size_type_node
 300 #define T99_SST { STD_C99, "signed size_t", T_SST }
 301 #define T_PD    &ptrdiff_type_node
 302 #define T99_PD  { STD_C99, "ptrdiff_t", T_PD }
 303 #define T_UPD   &unsigned_ptrdiff_type_node
 304 #define T99_UPD { STD_C99, "unsigned ptrdiff_t", T_UPD }
 305 #define T_IM    &intmax_type_node
 306 #define T99_IM  { STD_C99, "intmax_t", T_IM }
 307 #define T_UIM   &uintmax_type_node
 308 #define T99_UIM { STD_C99, "uintmax_t", T_UIM }
 309 #define T_D32   &dfloat32_type_node
 310 #define TEX_D32 { STD_EXT, "_Decimal32", T_D32 }
 311 #define T_D64   &dfloat64_type_node
 312 #define TEX_D64 { STD_EXT, "_Decimal64", T_D64 }
 313 #define T_D128  &dfloat128_type_node
 314 #define TEX_D128 { STD_EXT, "_Decimal128", T_D128 }
 315
 316 /* Structure describing how format attributes such as "printf" are
 317    interpreted as "gnu_printf" or "ms_printf" on a particular system.
 318    TARGET_OVERRIDES_FORMAT_ATTRIBUTES is used to specify target-specific
 319    defaults.  */
 320 typedef struct
 321 {
 322   /* The name of the to be copied format attribute. */
 323   const char *named_attr_src;
 324   /* The name of the to be overridden format attribute. */
 325   const char *named_attr_dst;
 326 } target_ovr_attr;
 327
 328 #endif /* GCC_C_FORMAT_H */