diff options
Diffstat (limited to 'contrib/gcc')
| -rw-r--r-- | contrib/gcc/c-format.c | 1659 |
1 files changed, 796 insertions, 863 deletions
diff --git a/contrib/gcc/c-format.c b/contrib/gcc/c-format.c index 34327a93087c..cc3f9be7ae40 100644 --- a/contrib/gcc/c-format.c +++ b/contrib/gcc/c-format.c @@ -1,6 +1,6 @@ /* Check calls to formatted I/O functions (-Wformat). Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, - 2001, 2002, 2003 Free Software Foundation, Inc. + 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of GCC. @@ -16,8 +16,8 @@ for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ +Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301, USA. */ /* $FreeBSD$ */ @@ -27,11 +27,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "tm.h" #include "tree.h" #include "flags.h" -#include "toplev.h" #include "c-common.h" +#include "toplev.h" #include "intl.h" #include "diagnostic.h" #include "langhooks.h" +#include "c-format.h" /* Set format warning options according to a -Wformat=n option. */ @@ -55,24 +56,25 @@ set_Wformat (int setting) /* Handle attributes associated with format checking. */ -/* This must be in the same order as format_types, with format_type_error - last. */ +/* This must be in the same order as format_types, except for + format_type_error. Target-specific format types do not have + matching enum values. */ enum format_type { printf_format_type, asm_fprintf_format_type, - gcc_diag_format_type, gcc_cdiag_format_type, - gcc_cxxdiag_format_type, + gcc_diag_format_type, gcc_tdiag_format_type, + gcc_cdiag_format_type, + gcc_cxxdiag_format_type, gcc_gfc_format_type, scanf_format_type, strftime_format_type, - strfmon_format_type, rintf0_format_type, - format_type_error }; + strfmon_format_type, format_type_error = -1}; typedef struct function_format_info { - enum format_type format_type; /* type of format (printf, scanf, etc.) */ + int format_type; /* type of format (printf, scanf, etc.) */ unsigned HOST_WIDE_INT format_num; /* number of format argument */ unsigned HOST_WIDE_INT first_arg_num; /* number of first arg (zero for varargs) */ } function_format_info; static bool decode_format_attr (tree, function_format_info *, int); -static enum format_type decode_format_type (const char *); +static int decode_format_type (const char *); static bool check_format_string (tree argument, unsigned HOST_WIDE_INT format_num, @@ -84,12 +86,12 @@ static bool get_constant (tree expr, unsigned HOST_WIDE_INT *value, /* Handle a "format_arg" attribute; arguments as in struct attribute_spec.handler. */ tree -handle_format_arg_attribute (tree *node, tree name ATTRIBUTE_UNUSED, +handle_format_arg_attribute (tree *node, tree ARG_UNUSED (name), tree args, int flags, bool *no_add_attrs) { tree type = *node; tree format_num_expr = TREE_VALUE (args); - unsigned HOST_WIDE_INT format_num; + unsigned HOST_WIDE_INT format_num = 0; tree argument; if (!get_constant (format_num_expr, &format_num, 0)) @@ -140,7 +142,7 @@ check_format_string (tree argument, unsigned HOST_WIDE_INT format_num, != char_type_node)) { if (!(flags & (int) ATTR_FLAG_BUILT_IN)) - error ("format string arg not a string type"); + error ("format string argument not a string type"); *no_add_attrs = true; return false; } @@ -148,21 +150,15 @@ check_format_string (tree argument, unsigned HOST_WIDE_INT format_num, return true; } -/* Strip any conversions from the expression, verify it is a constant, - and store its value. If validated_p is true, abort on errors. +/* Verify EXPR is a constant, and store its value. + If validated_p is true there should be no errors. Returns true on success, false otherwise. */ static bool -get_constant(tree expr, unsigned HOST_WIDE_INT *value, int validated_p) +get_constant (tree expr, unsigned HOST_WIDE_INT *value, int validated_p) { - while (TREE_CODE (expr) == NOP_EXPR - || TREE_CODE (expr) == CONVERT_EXPR - || TREE_CODE (expr) == NON_LVALUE_EXPR) - expr = TREE_OPERAND (expr, 0); - if (TREE_CODE (expr) != INTEGER_CST || TREE_INT_CST_HIGH (expr) != 0) { - if (validated_p) - abort (); + gcc_assert (!validated_p); return false; } @@ -171,12 +167,12 @@ get_constant(tree expr, unsigned HOST_WIDE_INT *value, int validated_p) return true; } -/* Decode the arguments to a "format" attribute into a function_format_info - structure. It is already known that the list is of the right length. - If VALIDATED_P is true, then these attributes have already been validated - and this function will abort if they are erroneous; if false, it - will give an error message. Returns true if the attributes are - successfully decoded, false otherwise. */ +/* Decode the arguments to a "format" attribute into a + function_format_info structure. It is already known that the list + is of the right length. If VALIDATED_P is true, then these + attributes have already been validated and must not be erroneous; + if false, it will give an error message. Returns true if the + attributes are successfully decoded, false otherwise. */ static bool decode_format_attr (tree args, function_format_info *info, int validated_p) @@ -188,9 +184,8 @@ decode_format_attr (tree args, function_format_info *info, int validated_p) if (TREE_CODE (format_type_id) != IDENTIFIER_NODE) { - if (validated_p) - abort (); - error("%Junrecognized format specifier", getdecls()); + gcc_assert (!validated_p); + error ("%Junrecognized format specifier", lang_hooks.decls.getdecls ()); return false; } else @@ -201,9 +196,9 @@ decode_format_attr (tree args, function_format_info *info, int validated_p) if (info->format_type == format_type_error) { - if (validated_p) - abort (); - warning ("`%s' is an unrecognized format function type", p); + gcc_assert (!validated_p); + warning (OPT_Wformat, "%qE is an unrecognized format function type", + format_type_id); return false; } } @@ -216,15 +211,14 @@ decode_format_attr (tree args, function_format_info *info, int validated_p) if (!get_constant (first_arg_num_expr, &info->first_arg_num, validated_p)) { - error ("'...' has invalid operand number"); + error ("%<...%> has invalid operand number"); return false; } if (info->first_arg_num != 0 && info->first_arg_num <= info->format_num) { - if (validated_p) - abort (); - error ("format string arg follows the args to be formatted"); + gcc_assert (!validated_p); + error ("format string argument follows the args to be formatted"); return false; } @@ -233,41 +227,14 @@ decode_format_attr (tree args, function_format_info *info, int validated_p) /* Check a call to a format function against a parameter list. */ -/* The meaningfully distinct length modifiers for format checking recognized - by GCC. */ -enum format_lengths -{ - FMT_LEN_none, - FMT_LEN_hh, - FMT_LEN_h, - FMT_LEN_l, - FMT_LEN_ll, - FMT_LEN_L, - FMT_LEN_z, - FMT_LEN_t, - FMT_LEN_j, - FMT_LEN_MAX -}; - - -/* The standard versions in which various format features appeared. */ -enum format_std_version -{ - STD_C89, - STD_C94, - STD_C9L, /* C99, but treat as C89 if -Wno-long-long. */ - STD_C99, - STD_EXT -}; - /* The C standard version C++ is treated as equivalent to or inheriting from, for the purpose of format features supported. */ #define CPLUSPLUS_STD_VER STD_C94 /* The C standard version we are checking formats against when pedantic. */ -#define C_STD_VER ((int)(c_dialect_cxx () \ - ? CPLUSPLUS_STD_VER \ - : (flag_isoc99 \ - ? STD_C99 \ +#define C_STD_VER ((int) (c_dialect_cxx () \ + ? CPLUSPLUS_STD_VER \ + : (flag_isoc99 \ + ? STD_C99 \ : (flag_isoc94 ? STD_C94 : STD_C89)))) /* The name to give to the standard version we are warning about when pedantic. FEATURE_VER is the version in which the feature warned out @@ -279,200 +246,10 @@ enum format_std_version : "ISO C90")) /* Adjust a C standard version, which may be STD_C9L, to account for -Wno-long-long. Returns other standard versions unchanged. */ -#define ADJ_STD(VER) ((int)((VER) == STD_C9L \ +#define ADJ_STD(VER) ((int) ((VER) == STD_C9L \ ? (warn_long_long ? STD_C99 : STD_C89) \ : (VER))) -/* Flags that may apply to a particular kind of format checked by GCC. */ -enum -{ - /* This format converts arguments of types determined by the - format string. */ - FMT_FLAG_ARG_CONVERT = 1, - /* The scanf allocation 'a' kludge applies to this format kind. */ - FMT_FLAG_SCANF_A_KLUDGE = 2, - /* A % during parsing a specifier is allowed to be a modified % rather - that indicating the format is broken and we are out-of-sync. */ - FMT_FLAG_FANCY_PERCENT_OK = 4, - /* With $ operand numbers, it is OK to reference the same argument more - than once. */ - FMT_FLAG_DOLLAR_MULTIPLE = 8, - /* This format type uses $ operand numbers (strfmon doesn't). */ - FMT_FLAG_USE_DOLLAR = 16, - /* Zero width is bad in this type of format (scanf). */ - FMT_FLAG_ZERO_WIDTH_BAD = 32, - /* Empty precision specification is OK in this type of format (printf). */ - FMT_FLAG_EMPTY_PREC_OK = 64, - /* Gaps are allowed in the arguments with $ operand numbers if all - arguments are pointers (scanf). */ - FMT_FLAG_DOLLAR_GAP_POINTER_OK = 128 - /* Not included here: details of whether width or precision may occur - (controlled by width_char and precision_char); details of whether - '*' can be used for these (width_type and precision_type); details - of whether length modifiers can occur (length_char_specs). */ -}; - - -/* Structure describing a length modifier supported in format checking, and - possibly a doubled version such as "hh". */ -typedef struct -{ - /* Name of the single-character length modifier. */ - const char *name; - /* Index into a format_char_info.types array. */ - enum format_lengths index; - /* Standard version this length appears in. */ - enum format_std_version std; - /* Same, if the modifier can be repeated, or NULL if it can't. */ - const char *double_name; - enum format_lengths double_index; - enum format_std_version double_std; -} format_length_info; - - -/* Structure describing the combination of a conversion specifier - (or a set of specifiers which act identically) and a length modifier. */ -typedef struct -{ - /* The standard version this combination of length and type appeared in. - This is only relevant if greater than those for length and type - individually; otherwise it is ignored. */ - enum format_std_version std; - /* The name to use for the type, if different from that generated internally - (e.g., "signed size_t"). */ - const char *name; - /* The type itself. */ - tree *type; -} format_type_detail; - - -/* Macros to fill out tables of these. */ -#define NOARGUMENTS { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN } -#define BADLEN { 0, NULL, NULL } -#define NOLENGTHS { BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN } - - -/* Structure describing a format conversion specifier (or a set of specifiers - which act identically), and the length modifiers used with it. */ -typedef struct -{ - const char *format_chars; - int pointer_count; - enum format_std_version std; - /* Types accepted for each length modifier. */ - format_type_detail types[FMT_LEN_MAX]; - /* List of other modifier characters allowed with these specifiers. - This lists flags, and additionally "w" for width, "p" for precision - (right precision, for strfmon), "#" for left precision (strfmon), - "a" for scanf "a" allocation extension (not applicable in C99 mode), - "*" for scanf suppression, and "E" and "O" for those strftime - modifiers. */ - const char *flag_chars; - /* List of additional flags describing these conversion specifiers. - "c" for generic character pointers being allowed, "2" for strftime - two digit year formats, "3" for strftime formats giving two digit - years in some locales, "4" for "2" which becomes "3" with an "E" modifier, - "o" if use of strftime "O" is a GNU extension beyond C99, - "W" if the argument is a pointer which is dereferenced and written into, - "R" if the argument is a pointer which is dereferenced and read from, - "i" for printf integer formats where the '0' flag is ignored with - precision, and "[" for the starting character of a scanf scanset. */ - const char *flags2; -} format_char_info; - - -/* Structure describing a flag accepted by some kind of format. */ -typedef struct -{ - /* The flag character in question (0 for end of array). */ - int flag_char; - /* Zero if this entry describes the flag character in general, or a - nonzero character that may be found in flags2 if it describes the - flag when used with certain formats only. If the latter, only - the first such entry found that applies to the current conversion - specifier is used; the values of `name' and `long_name' it supplies - will be used, if non-NULL and the standard version is higher than - the unpredicated one, for any pedantic warning. For example, 'o' - for strftime formats (meaning 'O' is an extension over C99). */ - int predicate; - /* Nonzero if the next character after this flag in the format should - be skipped ('=' in strfmon), zero otherwise. */ - int skip_next_char; - /* The name to use for this flag in diagnostic messages. For example, - N_("`0' flag"), N_("field width"). */ - const char *name; - /* Long name for this flag in diagnostic messages; currently only used for - "ISO C does not support ...". For example, N_("the `I' printf flag"). */ - const char *long_name; - /* The standard version in which it appeared. */ - enum format_std_version std; -} format_flag_spec; - - -/* Structure describing a combination of flags that is bad for some kind - of format. */ -typedef struct -{ - /* The first flag character in question (0 for end of array). */ - int flag_char1; - /* The second flag character. */ - int flag_char2; - /* Nonzero if the message should say that the first flag is ignored with - the second, zero if the combination should simply be objected to. */ - int ignored; - /* Zero if this entry applies whenever this flag combination occurs, - a nonzero character from flags2 if it only applies in some - circumstances (e.g. 'i' for printf formats ignoring 0 with precision). */ - int predicate; -} format_flag_pair; - - -/* Structure describing a particular kind of format processed by GCC. */ -typedef struct -{ - /* The name of this kind of format, for use in diagnostics. Also - the name of the attribute (without preceding and following __). */ - const char *name; - /* Specifications of the length modifiers accepted; possibly NULL. */ - const format_length_info *length_char_specs; - /* Details of the conversion specification characters accepted. */ - const format_char_info *conversion_specs; - /* String listing the flag characters that are accepted. */ - const char *flag_chars; - /* String listing modifier characters (strftime) accepted. May be NULL. */ - const char *modifier_chars; - /* Details of the flag characters, including pseudo-flags. */ - const format_flag_spec *flag_specs; - /* Details of bad combinations of flags. */ - const format_flag_pair *bad_flag_pairs; - /* Flags applicable to this kind of format. */ - int flags; - /* Flag character to treat a width as, or 0 if width not used. */ - int width_char; - /* Flag character to treat a left precision (strfmon) as, - or 0 if left precision not used. */ - int left_precision_char; - /* Flag character to treat a precision (for strfmon, right precision) as, - or 0 if precision not used. */ - int precision_char; - /* If a flag character has the effect of suppressing the conversion of - an argument ('*' in scanf), that flag character, otherwise 0. */ - int suppression_char; - /* Flag character to treat a length modifier as (ignored if length - modifiers not used). Need not be placed in flag_chars for conversion - specifiers, but is used to check for bad combinations such as length - modifier with assignment suppression in scanf. */ - int length_code_char; - /* Pointer to type of argument expected if '*' is used for a width, - or NULL if '*' not used for widths. */ - tree *width_type; - /* Pointer to type of argument expected if '*' is used for a precision, - or NULL if '*' not used for precisions. */ - tree *precision_type; - const int null_format_ok; -} format_kind_info; - - /* Structure describing details of a type expected in format checking, and the type to check against it. */ typedef struct format_wanted_type @@ -492,12 +269,10 @@ typedef struct format_wanted_type /* Whether the argument, dereferenced once, is read from and so must not be a NULL pointer. */ int reading_from_flag; - /* If warnings should be of the form "field precision is not type int", - the name to use (in this case "field precision"), otherwise NULL, - for "%s format, %s arg" type messages. If (in an extension), this - is a pointer type, wanted_type_name should be set to include the - terminating '*' characters of the type name to give a correct - message. */ + /* If warnings should be of the form "field precision should have + type 'int'", the name to use (in this case "field precision"), + otherwise NULL, for "format expects type 'long'" type + messages. */ const char *name; /* The actual parameter to check against the wanted type. */ tree param; @@ -518,6 +293,8 @@ static const format_length_info printf_length_specs[] = { "Z", FMT_LEN_z, STD_EXT, NULL, 0, 0 }, { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 }, { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 }, + { "H", FMT_LEN_H, STD_EXT, NULL, 0, 0 }, + { "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT }, { NULL, 0, 0, NULL, 0, 0 } }; @@ -538,6 +315,7 @@ static const format_length_info gcc_diag_length_specs[] = }; /* The custom diagnostics all accept the same length specifiers. */ +#define gcc_tdiag_length_specs gcc_diag_length_specs #define gcc_cdiag_length_specs gcc_diag_length_specs #define gcc_cxxdiag_length_specs gcc_diag_length_specs @@ -551,6 +329,8 @@ static const format_length_info scanf_length_specs[] = { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 }, { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 }, { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 }, + { "H", FMT_LEN_H, STD_EXT, NULL, 0, 0 }, + { "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT }, { NULL, 0, 0, NULL, 0, 0 } }; @@ -566,13 +346,13 @@ static const format_length_info strfmon_length_specs[] = static const format_flag_spec printf_flag_specs[] = { - { ' ', 0, 0, N_("` ' flag"), N_("the ` ' printf flag"), STD_C89 }, - { '+', 0, 0, N_("`+' flag"), N_("the `+' printf flag"), STD_C89 }, - { '#', 0, 0, N_("`#' flag"), N_("the `#' printf flag"), STD_C89 }, - { '0', 0, 0, N_("`0' flag"), N_("the `0' printf flag"), STD_C89 }, - { '-', 0, 0, N_("`-' flag"), N_("the `-' printf flag"), STD_C89 }, - { '\'', 0, 0, N_("`'' flag"), N_("the `'' printf flag"), STD_EXT }, - { 'I', 0, 0, N_("`I' flag"), N_("the `I' printf flag"), STD_EXT }, + { ' ', 0, 0, N_("' ' flag"), N_("the ' ' printf flag"), STD_C89 }, + { '+', 0, 0, N_("'+' flag"), N_("the '+' printf flag"), STD_C89 }, + { '#', 0, 0, N_("'#' flag"), N_("the '#' printf flag"), STD_C89 }, + { '0', 0, 0, N_("'0' flag"), N_("the '0' printf flag"), STD_C89 }, + { '-', 0, 0, N_("'-' flag"), N_("the '-' printf flag"), STD_C89 }, + { '\'', 0, 0, N_("''' flag"), N_("the ''' printf flag"), STD_EXT }, + { 'I', 0, 0, N_("'I' flag"), N_("the 'I' printf flag"), STD_EXT }, { 'w', 0, 0, N_("field width"), N_("field width in printf format"), STD_C89 }, { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 }, { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 }, @@ -590,11 +370,11 @@ static const format_flag_pair printf_flag_pairs[] = static const format_flag_spec asm_fprintf_flag_specs[] = { - { ' ', 0, 0, N_("` ' flag"), N_("the ` ' printf flag"), STD_C89 }, - { '+', 0, 0, N_("`+' flag"), N_("the `+' printf flag"), STD_C89 }, - { '#', 0, 0, N_("`#' flag"), N_("the `#' printf flag"), STD_C89 }, - { '0', 0, 0, N_("`0' flag"), N_("the `0' printf flag"), STD_C89 }, - { '-', 0, 0, N_("`-' flag"), N_("the `-' printf flag"), STD_C89 }, + { ' ', 0, 0, N_("' ' flag"), N_("the ' ' printf flag"), STD_C89 }, + { '+', 0, 0, N_("'+' flag"), N_("the '+' printf flag"), STD_C89 }, + { '#', 0, 0, N_("'#' flag"), N_("the '#' printf flag"), STD_C89 }, + { '0', 0, 0, N_("'0' flag"), N_("the '0' printf flag"), STD_C89 }, + { '-', 0, 0, N_("'-' flag"), N_("the '-' printf flag"), STD_C89 }, { 'w', 0, 0, N_("field width"), N_("field width in printf format"), STD_C89 }, { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 }, { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 }, @@ -614,22 +394,32 @@ static const format_flag_pair gcc_diag_flag_pairs[] = { 0, 0, 0, 0 } }; +#define gcc_tdiag_flag_pairs gcc_diag_flag_pairs #define gcc_cdiag_flag_pairs gcc_diag_flag_pairs #define gcc_cxxdiag_flag_pairs gcc_diag_flag_pairs +static const format_flag_pair gcc_gfc_flag_pairs[] = +{ + { 0, 0, 0, 0 } +}; + static const format_flag_spec gcc_diag_flag_specs[] = { + { '+', 0, 0, N_("'+' flag"), N_("the '+' printf flag"), STD_C89 }, + { 'q', 0, 0, N_("'q' flag"), N_("the 'q' diagnostic flag"), STD_C89 }, { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 }, { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 }, { 0, 0, 0, NULL, NULL, 0 } }; +#define gcc_tdiag_flag_specs gcc_diag_flag_specs #define gcc_cdiag_flag_specs gcc_diag_flag_specs static const format_flag_spec gcc_cxxdiag_flag_specs[] = { - { '+', 0, 0, N_("`+' flag"), N_("the `+' printf flag"), STD_C89 }, - { '#', 0, 0, N_("`#' flag"), N_("the `#' printf flag"), STD_C89 }, + { '+', 0, 0, N_("'+' flag"), N_("the '+' printf flag"), STD_C89 }, + { '#', 0, 0, N_("'#' flag"), N_("the '#' printf flag"), STD_C89 }, + { 'q', 0, 0, N_("'q' flag"), N_("the 'q' diagnostic flag"), STD_C89 }, { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 }, { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 }, { 0, 0, 0, NULL, NULL, 0 } @@ -638,11 +428,11 @@ static const format_flag_spec gcc_cxxdiag_flag_specs[] = static const format_flag_spec scanf_flag_specs[] = { { '*', 0, 0, N_("assignment suppression"), N_("the assignment suppression scanf feature"), STD_C89 }, - { 'a', 0, 0, N_("`a' flag"), N_("the `a' scanf flag"), STD_EXT }, + { 'a', 0, 0, N_("'a' flag"), N_("the 'a' scanf flag"), STD_EXT }, { 'w', 0, 0, N_("field width"), N_("field width in scanf format"), STD_C89 }, { 'L', 0, 0, N_("length modifier"), N_("length modifier in scanf format"), STD_C89 }, - { '\'', 0, 0, N_("`'' flag"), N_("the `'' scanf flag"), STD_EXT }, - { 'I', 0, 0, N_("`I' flag"), N_("the `I' scanf flag"), STD_EXT }, + { '\'', 0, 0, N_("''' flag"), N_("the ''' scanf flag"), STD_EXT }, + { 'I', 0, 0, N_("'I' flag"), N_("the 'I' scanf flag"), STD_EXT }, { 0, 0, 0, NULL, NULL, 0 } }; @@ -656,15 +446,15 @@ static const format_flag_pair scanf_flag_pairs[] = static const format_flag_spec strftime_flag_specs[] = { - { '_', 0, 0, N_("`_' flag"), N_("the `_' strftime flag"), STD_EXT }, - { '-', 0, 0, N_("`-' flag"), N_("the `-' strftime flag"), STD_EXT }, - { '0', 0, 0, N_("`0' flag"), N_("the `0' strftime flag"), STD_EXT }, - { '^', 0, 0, N_("`^' flag"), N_("the `^' strftime flag"), STD_EXT }, - { '#', 0, 0, N_("`#' flag"), N_("the `#' strftime flag"), STD_EXT }, + { '_', 0, 0, N_("'_' flag"), N_("the '_' strftime flag"), STD_EXT }, + { '-', 0, 0, N_("'-' flag"), N_("the '-' strftime flag"), STD_EXT }, + { '0', 0, 0, N_("'0' flag"), N_("the '0' strftime flag"), STD_EXT }, + { '^', 0, 0, N_("'^' flag"), N_("the '^' strftime flag"), STD_EXT }, + { '#', 0, 0, N_("'#' flag"), N_("the '#' strftime flag"), STD_EXT }, { 'w', 0, 0, N_("field width"), N_("field width in strftime format"), STD_EXT }, - { 'E', 0, 0, N_("`E' modifier"), N_("the `E' strftime modifier"), STD_C99 }, - { 'O', 0, 0, N_("`O' modifier"), N_("the `O' strftime modifier"), STD_C99 }, - { 'O', 'o', 0, NULL, N_("the `O' modifier"), STD_EXT }, + { 'E', 0, 0, N_("'E' modifier"), N_("the 'E' strftime modifier"), STD_C99 }, + { 'O', 0, 0, N_("'O' modifier"), N_("the 'O' strftime modifier"), STD_C99 }, + { 'O', 'o', 0, NULL, N_("the 'O' modifier"), STD_EXT }, { 0, 0, 0, NULL, NULL, 0 } }; @@ -683,11 +473,11 @@ static const format_flag_pair strftime_flag_pairs[] = static const format_flag_spec strfmon_flag_specs[] = { { '=', 0, 1, N_("fill character"), N_("fill character in strfmon format"), STD_C89 }, - { '^', 0, 0, N_("`^' flag"), N_("the `^' strfmon flag"), STD_C89 }, - { '+', 0, 0, N_("`+' flag"), N_("the `+' strfmon flag"), STD_C89 }, - { '(', 0, 0, N_("`(' flag"), N_("the `(' strfmon flag"), STD_C89 }, - { '!', 0, 0, N_("`!' flag"), N_("the `!' strfmon flag"), STD_C89 }, - { '-', 0, 0, N_("`-' flag"), N_("the `-' strfmon flag"), STD_C89 }, + { '^', 0, 0, N_("'^' flag"), N_("the '^' strfmon flag"), STD_C89 }, + { '+', 0, 0, N_("'+' flag"), N_("the '+' strfmon flag"), STD_C89 }, + { '(', 0, 0, N_("'(' flag"), N_("the '(' strfmon flag"), STD_C89 }, + { '!', 0, 0, N_("'!' flag"), N_("the '!' strfmon flag"), STD_C89 }, + { '-', 0, 0, N_("'-' flag"), N_("the '-' strfmon flag"), STD_C89 }, { 'w', 0, 0, N_("field width"), N_("field width in strfmon format"), STD_C89 }, { '#', 0, 0, N_("left precision"), N_("left precision in strfmon format"), STD_C89 }, { 'p', 0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89 }, @@ -702,80 +492,34 @@ static const format_flag_pair strfmon_flag_pairs[] = }; -#define T_I &integer_type_node -#define T89_I { STD_C89, NULL, T_I } -#define T_L &long_integer_type_node -#define T89_L { STD_C89, NULL, T_L } -#define T_LL &long_long_integer_type_node -#define T9L_LL { STD_C9L, NULL, T_LL } -#define TEX_LL { STD_EXT, NULL, T_LL } -#define T_S &short_integer_type_node -#define T89_S { STD_C89, NULL, T_S } -#define T_UI &unsigned_type_node -#define T89_UI { STD_C89, NULL, T_UI } -#define T_UL &long_unsigned_type_node -#define T89_UL { STD_C89, NULL, T_UL } -#define T_ULL &long_long_unsigned_type_node -#define T9L_ULL { STD_C9L, NULL, T_ULL } -#define TEX_ULL { STD_EXT, NULL, T_ULL } -#define T_US &short_unsigned_type_node -#define T89_US { STD_C89, NULL, T_US } -#define T_F &float_type_node -#define T89_F { STD_C89, NULL, T_F } -#define T99_F { STD_C99, NULL, T_F } -#define T_D &double_type_node -#define T89_D { STD_C89, NULL, T_D } -#define T99_D { STD_C99, NULL, T_D } -#define T_LD &long_double_type_node -#define T89_LD { STD_C89, NULL, T_LD } -#define T99_LD { STD_C99, NULL, T_LD } -#define T_C &char_type_node -#define T89_C { STD_C89, NULL, T_C } -#define T_SC &signed_char_type_node -#define T99_SC { STD_C99, NULL, T_SC } -#define T_UC &unsigned_char_type_node -#define T99_UC { STD_C99, NULL, T_UC } -#define T_V &void_type_node -#define T89_V { STD_C89, NULL, T_V } -#define T_W &wchar_type_node -#define T94_W { STD_C94, "wchar_t", T_W } -#define TEX_W { STD_EXT, "wchar_t", T_W } -#define T_WI &wint_type_node -#define T94_WI { STD_C94, "wint_t", T_WI } -#define TEX_WI { STD_EXT, "wint_t", T_WI } -#define T_ST &size_type_node -#define T99_ST { STD_C99, "size_t", T_ST } -#define T_SST &signed_size_type_node -#define T99_SST { STD_C99, "signed size_t", T_SST } -#define T_PD &ptrdiff_type_node -#define T99_PD { STD_C99, "ptrdiff_t", T_PD } -#define T_UPD &unsigned_ptrdiff_type_node -#define T99_UPD { STD_C99, "unsigned ptrdiff_t", T_UPD } -#define T_IM &intmax_type_node -#define T99_IM { STD_C99, "intmax_t", T_IM } -#define T_UIM &uintmax_type_node -#define T99_UIM { STD_C99, "uintmax_t", T_UIM } - static const format_char_info print_char_table[] = { /* C89 conversion specifiers. */ - { "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" }, - { "oxX", 0, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "-wp0#", "i" }, - { "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" }, - { "fgG", 0, STD_C89, { T89_D, BADLEN, BADLEN, T99_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#'I", "" }, - { "eE", 0, STD_C89, { T89_D, BADLEN, BADLEN, T99_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#I", "" }, - { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, T94_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "" }, - { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "cR" }, - { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "c" }, - { "n", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, BADLEN, T99_SST, T99_PD, T99_IM }, "", "W" }, + { "di", 0, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, TEX_LL, T99_SST, T99_PD, T99_IM, BADLEN, BADLEN, BADLEN }, "-wp0 +'I", "i", NULL }, + { "oxX", 0, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM, BADLEN, BADLEN, BADLEN }, "-wp0#", "i", NULL }, + { "u", 0, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM, BADLEN, BADLEN, BADLEN }, "-wp0'I", "i", NULL }, + { "fgG", 0, STD_C89, { T89_D, BADLEN, BADLEN, T99_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN, TEX_D32, TEX_D64, TEX_D128 }, "-wp0 +#'I", "", NULL }, + { "eE", 0, STD_C89, { T89_D, BADLEN, BADLEN, T99_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN, TEX_D32, TEX_D64, TEX_D128 }, "-wp0 +#I", "", NULL }, + { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, T94_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "", NULL }, + { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "cR", NULL }, + { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "c", NULL }, + { "n", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, BADLEN, T99_SST, T99_PD, T99_IM, BADLEN, BADLEN, BADLEN }, "", "W", NULL }, /* C99 conversion specifiers. */ - { "F", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#'I", "" }, - { "aA", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#", "" }, + { "F", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN, TEX_D32, TEX_D64, TEX_D128 }, "-wp0 +#'I", "", NULL }, + { "aA", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0 +#", "", NULL }, /* X/Open conversion specifiers. */ - { "C", 0, STD_EXT, { TEX_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "" }, - { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "R" }, + { "C", 0, STD_EXT, { TEX_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "", NULL }, + { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "R", NULL }, /* GNU conversion specifiers. */ - { "m", 0, STD_EXT, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "" }, + { "m", 0, STD_EXT, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "", NULL }, + { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL } +}; + +static const format_char_info fbsd_ext_char_info = +{ NULL, 1, STD_EXT, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "cR", NULL }; + +static const format_char_info fbsd_print_char_table[] = +{ /* BSD conversion specifiers. */ /* FreeBSD kernel extensions (src/sys/kern/subr_prf.c). The format %b is supported to decode error registers. @@ -785,209 +529,264 @@ static const format_char_info print_char_table[] = ("%6D", ptr, ":") -> XX:XX:XX:XX:XX:XX ("%*D", len, ptr, " ") -> XX XX XX XX ... */ - { "D", 1, STD_EXT, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "cR" }, - { "b", 1, STD_EXT, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "" }, - { "ry", 0, STD_EXT, { T89_I, BADLEN, BADLEN, T89_L, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0 +#", "i" }, + { "D", 1, STD_EXT, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "cR", &fbsd_ext_char_info }, + { "b", 0, STD_EXT, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "", &fbsd_ext_char_info }, + { "ry", 0, STD_EXT, { T89_I, BADLEN, BADLEN, T89_L, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0 +#", "i", NULL }, { NULL, 0, 0, NOLENGTHS, NULL, NULL } }; static const format_char_info asm_fprintf_char_table[] = { /* C89 conversion specifiers. */ - { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0 +", "i" }, - { "oxX", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0#", "i" }, - { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0", "i" }, - { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "" }, - { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "cR" }, + { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0 +", "i", NULL }, + { "oxX", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0#", "i", NULL }, + { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0", "i", NULL }, + { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "", NULL }, + { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "cR", NULL }, /* asm_fprintf conversion specifiers. */ - { "O", 0, STD_C89, NOARGUMENTS, "", "" }, - { "R", 0, STD_C89, NOARGUMENTS, "", "" }, - { "I", 0, STD_C89, NOARGUMENTS, "", "" }, - { "L", 0, STD_C89, NOARGUMENTS, "", "" }, - { "U", 0, STD_C89, NOARGUMENTS, "", "" }, - { "r", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "@", 0, STD_C89, NOARGUMENTS, "", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { "O", 0, STD_C89, NOARGUMENTS, "", "", NULL }, + { "R", 0, STD_C89, NOARGUMENTS, "", "", NULL }, + { "I", 0, STD_C89, NOARGUMENTS, "", "", NULL }, + { "L", 0, STD_C89, NOARGUMENTS, "", "", NULL }, + { "U", 0, STD_C89, NOARGUMENTS, "", "", NULL }, + { "r", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "", NULL }, + { "@", 0, STD_C89, NOARGUMENTS, "", "", NULL }, + { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL } }; static const format_char_info gcc_diag_char_table[] = { /* C89 conversion specifiers. */ - { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "ox", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "p", "cR" }, - { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "c" }, + { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "ox", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "pq", "cR", NULL }, + { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "c", NULL }, /* Custom conversion specifiers. */ /* %H will require "location_t" at runtime. */ - { "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, + { "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, /* These will require a "tree" at runtime. */ - { "J", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, + { "J", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, - { "m", 0, STD_C89, NOARGUMENTS, "", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL }, + { "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL }, + { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL } +}; + +static const format_char_info gcc_tdiag_char_table[] = +{ + /* C89 conversion specifiers. */ + { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "ox", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "pq", "cR", NULL }, + { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "c", NULL }, + + /* Custom conversion specifiers. */ + + /* %H will require "location_t" at runtime. */ + { "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + + /* These will require a "tree" at runtime. */ + { "DFJT", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q+", "", NULL }, + + { "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL }, + { "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL }, + { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL } }; static const format_char_info gcc_cdiag_char_table[] = { /* C89 conversion specifiers. */ - { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "ox", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "p", "cR" }, - { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "c" }, + { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "ox", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "pq", "cR", NULL }, + { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "c", NULL }, /* Custom conversion specifiers. */ /* %H will require "location_t" at runtime. */ - { "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, + { "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, /* These will require a "tree" at runtime. */ - { "DEFJT", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, + { "DEFJT", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q+", "", NULL }, - { "m", 0, STD_C89, NOARGUMENTS, "", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL }, + { "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL }, + { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL } }; static const format_char_info gcc_cxxdiag_char_table[] = { /* C89 conversion specifiers. */ - { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "ox", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, - { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "p", "cR" }, - { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "c" }, + { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "ox", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, + { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "pq", "cR", NULL }, + { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "c", NULL }, /* Custom conversion specifiers. */ /* %H will require "location_t" at runtime. */ - { "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, + { "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, /* These will require a "tree" at runtime. */ - { "ADEFJTV",0,STD_C89,{ T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "+#", "" }, + { "ADEFJTV",0,STD_C89,{ T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q+#", "", NULL }, - /* These accept either an `int' or an `enum tree_code' (which is handled as an `int'.) */ - { "CLOPQ",0,STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" }, + /* These accept either an 'int' or an 'enum tree_code' (which is handled as an 'int'.) */ + { "CLOPQ",0,STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL }, - { "m", 0, STD_C89, NOARGUMENTS, "", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL }, + { "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL }, + { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL } +}; + +static const format_char_info gcc_gfc_char_table[] = +{ + /* C89 conversion specifiers. */ + { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "", NULL }, + { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "", NULL }, + { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "cR", NULL }, + + /* gfc conversion specifiers. */ + + { "C", 0, STD_C89, NOARGUMENTS, "", "", NULL }, + + /* This will require a "locus" at runtime. */ + { "L", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "R", NULL }, + + { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL } }; static const format_char_info scan_char_table[] = { /* C89 conversion specifiers. */ - { "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" }, - { "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" }, - { "oxX", 1, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "*w", "W" }, - { "efgEG", 1, STD_C89, { T89_F, BADLEN, BADLEN, T89_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "*w'", "W" }, - { "c", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "cW" }, - { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "cW" }, - { "[", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "cW[" }, - { "p", 2, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W" }, - { "n", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, BADLEN, T99_SST, T99_PD, T99_IM }, "", "W" }, + { "di", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, TEX_LL, T99_SST, T99_PD, T99_IM, BADLEN, BADLEN, BADLEN }, "*w'I", "W", NULL }, + { "u", 1, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM, BADLEN, BADLEN, BADLEN }, "*w'I", "W", NULL }, + { "oxX", 1, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM, BADLEN, BADLEN, BADLEN }, "*w", "W", NULL }, + { "efgEG", 1, STD_C89, { T89_F, BADLEN, BADLEN, T89_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN, TEX_D32, TEX_D64, TEX_D128 }, "*w'", "W", NULL }, + { "c", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "cW", NULL }, + { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "cW", NULL }, + { "[", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "cW[", NULL }, + { "p", 2, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W", NULL }, + { "n", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, BADLEN, T99_SST, T99_PD, T99_IM, BADLEN, BADLEN, BADLEN }, "", "W", NULL }, /* C99 conversion specifiers. */ - { "FaA", 1, STD_C99, { T99_F, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "*w'", "W" }, + { "F", 1, STD_C99, { T99_F, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN, TEX_D32, TEX_D64, TEX_D128 }, "*w'", "W", NULL }, + { "aA", 1, STD_C99, { T99_F, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w'", "W", NULL }, /* X/Open conversion specifiers. */ - { "C", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W" }, - { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "W" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { "C", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W", NULL }, + { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "W", NULL }, + { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL } }; static const format_char_info time_char_table[] = { /* C89 conversion specifiers. */ - { "ABZab", 0, STD_C89, NOLENGTHS, "^#", "" }, - { "cx", 0, STD_C89, NOLENGTHS, "E", "3" }, - { "HIMSUWdmw", 0, STD_C89, NOLENGTHS, "-_0Ow", "" }, - { "j", 0, STD_C89, NOLENGTHS, "-_0Ow", "o" }, - { "p", 0, STD_C89, NOLENGTHS, "#", "" }, - { "X", 0, STD_C89, NOLENGTHS, "E", "" }, - { "y", 0, STD_C89, NOLENGTHS, "EO-_0w", "4" }, - { "Y", 0, STD_C89, NOLENGTHS, "-_0EOw", "o" }, - { "%", 0, STD_C89, NOLENGTHS, "", "" }, + { "ABZab", 0, STD_C89, NOLENGTHS, "^#", "", NULL }, + { "cx", 0, STD_C89, NOLENGTHS, "E", "3", NULL }, + { "HIMSUWdmw", 0, STD_C89, NOLENGTHS, "-_0Ow", "", NULL }, + { "j", 0, STD_C89, NOLENGTHS, "-_0Ow", "o", NULL }, + { "p", 0, STD_C89, NOLENGTHS, "#", "", NULL }, + { "X", 0, STD_C89, NOLENGTHS, "E", "", NULL }, + { "y", 0, STD_C89, NOLENGTHS, "EO-_0w", "4", NULL }, + { "Y", 0, STD_C89, NOLENGTHS, "-_0EOw", "o", NULL }, + { "%", 0, STD_C89, NOLENGTHS, "", "", NULL }, /* C99 conversion specifiers. */ - { "C", 0, STD_C99, NOLENGTHS, "-_0EOw", "o" }, - { "D", 0, STD_C99, NOLENGTHS, "", "2" }, - { "eVu", 0, STD_C99, NOLENGTHS, "-_0Ow", "" }, - { "FRTnrt", 0, STD_C99, NOLENGTHS, "", "" }, - { "g", 0, STD_C99, NOLENGTHS, "O-_0w", "2o" }, - { "G", 0, STD_C99, NOLENGTHS, "-_0Ow", "o" }, - { "h", 0, STD_C99, NOLENGTHS, "^#", "" }, - { "z", 0, STD_C99, NOLENGTHS, "O", "o" }, + { "C", 0, STD_C99, NOLENGTHS, "-_0EOw", "o", NULL }, + { "D", 0, STD_C99, NOLENGTHS, "", "2", NULL }, + { "eVu", 0, STD_C99, NOLENGTHS, "-_0Ow", "", NULL }, + { "FRTnrt", 0, STD_C99, NOLENGTHS, "", "", NULL }, + { "g", 0, STD_C99, NOLENGTHS, "O-_0w", "2o", NULL }, + { "G", 0, STD_C99, NOLENGTHS, "-_0Ow", "o", NULL }, + { "h", 0, STD_C99, NOLENGTHS, "^#", "", NULL }, + { "z", 0, STD_C99, NOLENGTHS, "O", "o", NULL }, /* GNU conversion specifiers. */ - { "kls", 0, STD_EXT, NOLENGTHS, "-_0Ow", "" }, - { "P", 0, STD_EXT, NOLENGTHS, "", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { "kls", 0, STD_EXT, NOLENGTHS, "-_0Ow", "", NULL }, + { "P", 0, STD_EXT, NOLENGTHS, "", "", NULL }, + { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL } }; static const format_char_info monetary_char_table[] = { - { "in", 0, STD_C89, { T89_D, BADLEN, BADLEN, BADLEN, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "=^+(!-w#p", "" }, - { NULL, 0, 0, NOLENGTHS, NULL, NULL } + { "in", 0, STD_C89, { T89_D, BADLEN, BADLEN, BADLEN, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "=^+(!-w#p", "", NULL }, + { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL } }; - /* This must be in the same order as enum format_type. */ static const format_kind_info format_types_orig[] = { - { "printf", printf_length_specs, print_char_table, " +#0-'I", NULL, + { "printf", printf_length_specs, print_char_table, " +#0-'I", NULL, printf_flag_specs, printf_flag_pairs, FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_EMPTY_PREC_OK, 'w', 0, 'p', 0, 'L', - &integer_type_node, &integer_type_node, 0 + &integer_type_node, &integer_type_node }, - { "asm_fprintf", asm_fprintf_length_specs, asm_fprintf_char_table, " +#0-", NULL, + { "asm_fprintf", asm_fprintf_length_specs, asm_fprintf_char_table, " +#0-", NULL, asm_fprintf_flag_specs, asm_fprintf_flag_pairs, FMT_FLAG_ARG_CONVERT|FMT_FLAG_EMPTY_PREC_OK, 'w', 0, 'p', 0, 'L', NULL, NULL }, - { "gcc_diag", gcc_diag_length_specs, gcc_diag_char_table, "", NULL, + { "gcc_diag", gcc_diag_length_specs, gcc_diag_char_table, "q+", NULL, gcc_diag_flag_specs, gcc_diag_flag_pairs, FMT_FLAG_ARG_CONVERT, 0, 0, 'p', 0, 'L', NULL, &integer_type_node }, - { "gcc_cdiag", gcc_cdiag_length_specs, gcc_cdiag_char_table, "", NULL, + { "gcc_tdiag", gcc_tdiag_length_specs, gcc_tdiag_char_table, "q+", NULL, + gcc_tdiag_flag_specs, gcc_tdiag_flag_pairs, + FMT_FLAG_ARG_CONVERT, + 0, 0, 'p', 0, 'L', + NULL, &integer_type_node + }, + { "gcc_cdiag", gcc_cdiag_length_specs, gcc_cdiag_char_table, "q+", NULL, gcc_cdiag_flag_specs, gcc_cdiag_flag_pairs, FMT_FLAG_ARG_CONVERT, 0, 0, 'p', 0, 'L', NULL, &integer_type_node }, - { "gcc_cxxdiag", gcc_cxxdiag_length_specs, gcc_cxxdiag_char_table, "+#", NULL, + { "gcc_cxxdiag", gcc_cxxdiag_length_specs, gcc_cxxdiag_char_table, "q+#", NULL, gcc_cxxdiag_flag_specs, gcc_cxxdiag_flag_pairs, FMT_FLAG_ARG_CONVERT, 0, 0, 'p', 0, 'L', NULL, &integer_type_node }, - { "scanf", scanf_length_specs, scan_char_table, "*'I", NULL, + { "gcc_gfc", NULL, gcc_gfc_char_table, "", NULL, + NULL, gcc_gfc_flag_pairs, + FMT_FLAG_ARG_CONVERT, + 0, 0, 0, 0, 0, + NULL, NULL + }, + { "scanf", scanf_length_specs, scan_char_table, "*'I", NULL, scanf_flag_specs, scanf_flag_pairs, FMT_FLAG_ARG_CONVERT|FMT_FLAG_SCANF_A_KLUDGE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_ZERO_WIDTH_BAD|FMT_FLAG_DOLLAR_GAP_POINTER_OK, 'w', 0, 0, '*', 'L', - NULL, NULL, 0 + NULL, NULL }, { "strftime", NULL, time_char_table, "_-0^#", "EO", strftime_flag_specs, strftime_flag_pairs, FMT_FLAG_FANCY_PERCENT_OK, 'w', 0, 0, 0, 0, - NULL, NULL, 0 + NULL, NULL }, - { "strfmon", strfmon_length_specs, monetary_char_table, "=^+(!-", NULL, + { "strfmon", strfmon_length_specs, monetary_char_table, "=^+(!-", NULL, strfmon_flag_specs, strfmon_flag_pairs, FMT_FLAG_ARG_CONVERT, 'w', '#', 'p', 0, 'L', - NULL, NULL, 0 + NULL, NULL }, - { "printf0", printf_length_specs, print_char_table, " +#0-'I", NULL, + { "printf0", printf_length_specs, print_char_table, " +#0-'I", NULL, printf_flag_specs, printf_flag_pairs, - FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_EMPTY_PREC_OK, - 'w', 0, 'p', 0, 'L', - &integer_type_node, &integer_type_node, 1 + FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_EMPTY_PREC_OK|FMT_FLAG_NULL_FORMAT_OK, + 'w', 0, 'p', 0, 'L', + &integer_type_node, &integer_type_node } }; @@ -995,9 +794,12 @@ static const format_kind_info format_types_orig[] = new data if necessary, while still allowing the original data to be const. */ static const format_kind_info *format_types = format_types_orig; -/* We can modify this one. */ +/* We can modify this one. We also add target-specific format types + to the end of the array. */ static format_kind_info *dynamic_format_types; +static int n_format_types = ARRAY_SIZE (format_types_orig); + /* Structure detailing the results of checking a format function call where the format expression may be a conditional expression with many leaves resulting from nested conditional expressions. */ @@ -1030,49 +832,49 @@ typedef struct format_check_results *res; function_format_info *info; tree params; - int *status; } format_check_context; -static void check_format_info (int *, function_format_info *, tree); +static void check_format_info (function_format_info *, tree); static void check_format_arg (void *, tree, unsigned HOST_WIDE_INT); -static void check_format_info_main (int *, format_check_results *, +static void check_format_info_main (format_check_results *, function_format_info *, const char *, int, tree, unsigned HOST_WIDE_INT); -static void status_warning (int *, const char *, ...) - ATTRIBUTE_PRINTF_2; static void init_dollar_format_checking (int, tree); -static int maybe_read_dollar_number (int *, const char **, int, +static int maybe_read_dollar_number (const char **, int, tree, tree *, const format_kind_info *); -static void finish_dollar_format_checking (int *, format_check_results *, int); +static bool avoid_dollar_number (const char *); +static void finish_dollar_format_checking (format_check_results *, int); static const format_flag_spec *get_flag_spec (const format_flag_spec *, int, const char *); -static void check_format_types (int *, format_wanted_type *); +static void check_format_types (format_wanted_type *, const char *, int); +static void format_type_warning (const char *, const char *, int, tree, + int, const char *, tree, int); /* Decode a format type from a string, returning the type, or format_type_error if not valid, in which case the caller should print an error message. */ -static enum format_type +static int decode_format_type (const char *s) { int i; int slen; slen = strlen (s); - for (i = 0; i < (int) format_type_error; i++) + for (i = 0; i < n_format_types; i++) { int alen; if (!strcmp (s, format_types[i].name)) - break; + return i; alen = strlen (format_types[i].name); if (slen == alen + 4 && s[0] == '_' && s[1] == '_' && s[slen - 1] == '_' && s[slen - 2] == '_' && !strncmp (s + 2, format_types[i].name, alen)) - break; + return i; } - return ((enum format_type) i); + return format_type_error; } @@ -1083,7 +885,7 @@ decode_format_type (const char *s) attribute themselves. */ void -check_function_format (int *status, tree attrs, tree params) +check_function_format (tree attrs, tree params) { tree a; @@ -1095,7 +897,8 @@ check_function_format (int *status, tree attrs, tree params) /* Yup; check it. */ function_format_info info; decode_format_attr (TREE_VALUE (a), &info, 1); - check_format_info (status, &info, params); + if (warn_format) + check_format_info (&info, params); if (warn_missing_format_attribute && info.first_arg_num == 0 && (format_types[info.format_type].flags & (int) FMT_FLAG_ARG_CONVERT)) @@ -1126,7 +929,8 @@ check_function_format (int *status, tree attrs, tree params) break; } if (args != 0) - warning ("function might be possible candidate for `%s' format attribute", + warning (OPT_Wmissing_format_attribute, "function might " + "be possible candidate for %qs format attribute", format_types[info.format_type].name); } } @@ -1134,31 +938,6 @@ check_function_format (int *status, tree attrs, tree params) } } -/* This function replaces `warning' inside the printf format checking - functions. If the `status' parameter is non-NULL, then it is - dereferenced and set to 1 whenever a warning is caught. Otherwise - it warns as usual by replicating the innards of the warning - function from diagnostic.c. */ -static void -status_warning (int *status, const char *msgid, ...) -{ - diagnostic_info diagnostic ; - va_list ap; - - va_start (ap, msgid); - - if (status) - *status = 1; - else - { - /* This duplicates the warning function behavior. */ - diagnostic_set_info (&diagnostic, _(msgid), &ap, - input_location, DK_WARNING); - report_diagnostic (&diagnostic); - } - - va_end (ap); -} /* Variables used by the checking of $ operand number formats. */ static char *dollar_arguments_used = NULL; @@ -1199,8 +978,8 @@ init_dollar_format_checking (int first_arg_num, tree params) if (dollar_arguments_pointer_p) free (dollar_arguments_pointer_p); dollar_arguments_alloc = dollar_arguments_count; - dollar_arguments_used = xmalloc (dollar_arguments_alloc); - dollar_arguments_pointer_p = xmalloc (dollar_arguments_alloc); + dollar_arguments_used = XNEWVEC (char, dollar_arguments_alloc); + dollar_arguments_pointer_p = XNEWVEC (char, dollar_arguments_alloc); } if (dollar_arguments_alloc) { @@ -1231,18 +1010,18 @@ init_dollar_format_checking (int first_arg_num, tree params) a $ format is found, *FORMAT is updated to point just after it. */ static int -maybe_read_dollar_number (int *status, const char **format, +maybe_read_dollar_number (const char **format, int dollar_needed, tree params, tree *param_ptr, const format_kind_info *fki) { int argnum; int overflow_flag; const char *fcp = *format; - if (! ISDIGIT (*fcp)) + if (!ISDIGIT (*fcp)) { if (dollar_needed) { - status_warning (status, "missing $ operand number in format"); + warning (OPT_Wformat, "missing $ operand number in format"); return -1; } else @@ -1263,7 +1042,7 @@ maybe_read_dollar_number (int *status, const char **format, { if (dollar_needed) { - status_warning (status, "missing $ operand number in format"); + warning (OPT_Wformat, "missing $ operand number in format"); return -1; } else @@ -1272,15 +1051,14 @@ maybe_read_dollar_number (int *status, const char **format, *format = fcp + 1; if (pedantic && !dollar_format_warned) { - status_warning (status, - "%s does not support %%n$ operand number formats", - C_STD_NAME (STD_EXT)); + warning (OPT_Wformat, "%s does not support %%n$ operand number formats", + C_STD_NAME (STD_EXT)); dollar_format_warned = 1; } if (overflow_flag || argnum == 0 || (dollar_first_arg_num && argnum > dollar_arguments_count)) { - status_warning (status, "operand number out of range in format"); + warning (OPT_Wformat, "operand number out of range in format"); return -1; } if (argnum > dollar_max_arg_used) @@ -1291,9 +1069,10 @@ maybe_read_dollar_number (int *status, const char **format, { int nalloc; nalloc = 2 * dollar_arguments_alloc + 16; - dollar_arguments_used = xrealloc (dollar_arguments_used, nalloc); - dollar_arguments_pointer_p = xrealloc (dollar_arguments_pointer_p, - nalloc); + dollar_arguments_used = XRESIZEVEC (char, dollar_arguments_used, + nalloc); + dollar_arguments_pointer_p = XRESIZEVEC (char, dollar_arguments_pointer_p, + nalloc); memset (dollar_arguments_used + dollar_arguments_alloc, 0, nalloc - dollar_arguments_alloc); dollar_arguments_alloc = nalloc; @@ -1302,9 +1081,8 @@ maybe_read_dollar_number (int *status, const char **format, && dollar_arguments_used[argnum - 1] == 1) { dollar_arguments_used[argnum - 1] = 2; - status_warning (status, - "format argument %d used more than once in %s format", - argnum, fki->name); + warning (OPT_Wformat, "format argument %d used more than once in %s format", + argnum, fki->name); } else dollar_arguments_used[argnum - 1] = 1; @@ -1315,17 +1093,32 @@ maybe_read_dollar_number (int *status, const char **format, for (i = 1; i < argnum && *param_ptr != 0; i++) *param_ptr = TREE_CHAIN (*param_ptr); - if (*param_ptr == 0) - { - /* This case shouldn't be caught here. */ - abort (); - } + /* This case shouldn't be caught here. */ + gcc_assert (*param_ptr); } else *param_ptr = 0; return argnum; } +/* Ensure that FORMAT does not start with a decimal number followed by + a $; give a diagnostic and return true if it does, false otherwise. */ + +static bool +avoid_dollar_number (const char *format) +{ + if (!ISDIGIT (*format)) + return false; + while (ISDIGIT (*format)) + format++; + if (*format == '$') + { + warning (OPT_Wformat, "$ operand number used after format without operand number"); + return true; + } + return false; +} + /* Finish the checking for a format string that used $ operand number formats instead of non-$ formats. We check for unused operands before used ones @@ -1338,7 +1131,7 @@ maybe_read_dollar_number (int *status, const char **format, pointers. */ static void -finish_dollar_format_checking (int *status, format_check_results *res, int pointer_gap_ok) +finish_dollar_format_checking (format_check_results *res, int pointer_gap_ok) { int i; bool found_pointer_gap = false; @@ -1350,8 +1143,9 @@ finish_dollar_format_checking (int *status, format_check_results *res, int point || dollar_arguments_pointer_p[i])) found_pointer_gap = true; else - status_warning (status, "format argument %d unused before used argument %d in $-style format", - i + 1, dollar_max_arg_used); + warning (OPT_Wformat, + "format argument %d unused before used argument %d in $-style format", + i + 1, dollar_max_arg_used); } } if (found_pointer_gap @@ -1367,10 +1161,10 @@ finish_dollar_format_checking (int *status, format_check_results *res, int point /* Retrieve the specification for a format flag. SPEC contains the specifications for format flags for the applicable kind of format. FLAG is the flag in question. If PREDICATES is NULL, the basic - spec for that flag must be retrieved and this function aborts if - it cannot be found. If PREDICATES is not NULL, it is a string listing - possible predicates for the spec entry; if an entry predicated on any - of these is found, it is returned, otherwise NULL is returned. */ + spec for that flag must be retrieved and must exist. If + PREDICATES is not NULL, it is a string listing possible predicates + for the spec entry; if an entry predicated on any of these is + found, it is returned, otherwise NULL is returned. */ static const format_flag_spec * get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates) @@ -1389,10 +1183,8 @@ get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates) else if (spec[i].predicate == 0) return &spec[i]; } - if (predicates == NULL) - abort (); - else - return NULL; + gcc_assert (predicates); + return NULL; } @@ -1401,7 +1193,7 @@ get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates) PARAMS is the list of argument values. */ static void -check_format_info (int *status, function_format_info *info, tree params) +check_format_info (function_format_info *info, tree params) { format_check_context format_ctx; unsigned HOST_WIDE_INT arg_num; @@ -1433,7 +1225,6 @@ check_format_info (int *status, function_format_info *info, tree params) format_ctx.res = &res; format_ctx.info = info; format_ctx.params = params; - format_ctx.status = status; check_function_arguments_recurse (check_format_arg, &format_ctx, format_tree, arg_num); @@ -1447,8 +1238,8 @@ check_format_info (int *status, function_format_info *info, tree params) { /* For strftime-like formats, warn for not checking the format string; but there are no arguments to check. */ - if (warn_format_nonliteral) - status_warning (status, "format not a string literal, format string not checked"); + warning (OPT_Wformat_nonliteral, + "format not a string literal, format string not checked"); } else if (info->first_arg_num != 0) { @@ -1461,10 +1252,15 @@ check_format_info (int *status, function_format_info *info, tree params) params = TREE_CHAIN (params); ++arg_num; } - if (params == 0 && (warn_format_nonliteral || warn_format_security)) - status_warning (status, "format not a string literal and no format arguments"); - else if (warn_format_nonliteral) - status_warning (status, "format not a string literal, argument types not checked"); + if (params == 0 && warn_format_security) + warning (OPT_Wformat_security, + "format not a string literal and no format arguments"); + else if (params == 0 && warn_format_nonliteral) + warning (OPT_Wformat_nonliteral, + "format not a string literal and no format arguments"); + else + warning (OPT_Wformat_nonliteral, + "format not a string literal, argument types not checked"); } } @@ -1476,21 +1272,21 @@ check_format_info (int *status, function_format_info *info, tree params) If the format is an empty string, this should be counted similarly to the case of extra format arguments. */ if (res.number_extra_args > 0 && res.number_non_literal == 0 - && res.number_other == 0 && warn_format_extra_args) - status_warning (status, "too many arguments for format"); + && res.number_other == 0) + warning (OPT_Wformat_extra_args, "too many arguments for format"); if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0 - && res.number_other == 0 && warn_format_extra_args) - status_warning (status, "unused arguments in $-style format"); + && res.number_other == 0) + warning (OPT_Wformat_extra_args, "unused arguments in $-style format"); if (res.number_empty > 0 && res.number_non_literal == 0 - && res.number_other == 0 && warn_format_zero_length) - status_warning (status, "zero-length %s format string", - format_types[info->format_type].name); + && res.number_other == 0) + warning (OPT_Wformat_zero_length, "zero-length %s format string", + format_types[info->format_type].name); if (res.number_wide > 0) - status_warning (status, "format is a wide character string"); + warning (OPT_Wformat, "format is a wide character string"); if (res.number_unterminated > 0) - status_warning (status, "unterminated format string"); + warning (OPT_Wformat, "unterminated format string"); } /* Callback from check_function_arguments_recurse to check a @@ -1502,11 +1298,10 @@ static void check_format_arg (void *ctx, tree format_tree, unsigned HOST_WIDE_INT arg_num) { - format_check_context *format_ctx = ctx; + format_check_context *format_ctx = (format_check_context *) ctx; format_check_results *res = format_ctx->res; function_format_info *info = format_ctx->info; tree params = format_ctx->params; - int *status = format_ctx->status; int format_length; HOST_WIDE_INT offset; @@ -1522,8 +1317,8 @@ check_format_arg (void *ctx, tree format_tree, specially if info == NULL and add a res->number_null entry for that case, or maybe add a function pointer to be called at the end instead of hardcoding check_format_info_main. */ - if (!format_types[info->format_type].null_format_ok) - status_warning (status, "null format string"); + if (!(format_types[info->format_type].flags & FMT_FLAG_NULL_FORMAT_OK)) + warning (OPT_Wformat, "null format string"); /* Skip to first argument to check, so we can see if this format has any arguments (it shouldn't). */ @@ -1577,6 +1372,10 @@ check_format_arg (void *ctx, tree format_tree, return; } format_tree = TREE_OPERAND (format_tree, 0); + if (TREE_CODE (format_tree) == ARRAY_REF + && host_integerp (TREE_OPERAND (format_tree, 1), 0) + && (offset += tree_low_cst (TREE_OPERAND (format_tree, 1), 0)) >= 0) + format_tree = TREE_OPERAND (format_tree, 0); if (TREE_CODE (format_tree) == VAR_DECL && TREE_CODE (TREE_TYPE (format_tree)) == ARRAY_TYPE && (array_init = decl_constant_value (format_tree)) != format_tree @@ -1603,8 +1402,8 @@ check_format_arg (void *ctx, tree format_tree, if (array_size != 0) { /* Variable length arrays can't be initialized. */ - if (TREE_CODE (array_size) != INTEGER_CST) - abort (); + gcc_assert (TREE_CODE (array_size) == INTEGER_CST); + if (host_integerp (array_size, 0)) { HOST_WIDE_INT array_size_value = TREE_INT_CST_LOW (array_size); @@ -1652,7 +1451,7 @@ check_format_arg (void *ctx, tree format_tree, will decrement it if it finds there are extra arguments, but this way need not adjust it for every return. */ res->number_other++; - check_format_info_main (status, res, info, format_chars, format_length, + check_format_info_main (res, info, format_chars, format_length, params, arg_num); } @@ -1665,7 +1464,7 @@ check_format_arg (void *ctx, tree format_tree, argument in the list of arguments. */ static void -check_format_info_main (int *status, format_check_results *res, +check_format_info_main (format_check_results *res, function_format_info *info, const char *format_chars, int format_length, tree params, unsigned HOST_WIDE_INT arg_num) @@ -1706,10 +1505,11 @@ check_format_info_main (int *status, format_check_results *res, const format_char_info *fci = NULL; char flag_chars[256]; int aflag = 0; + const char *format_start = format_chars; if (*format_chars == 0) { if (format_chars - orig_format_chars != format_length) - status_warning (status, "embedded `\\0' in format"); + warning (OPT_Wformat, "embedded %<\\0%> in format"); if (info->first_arg_num != 0 && params != 0 && has_operand_number <= 0) { @@ -1717,14 +1517,14 @@ check_format_info_main (int *status, format_check_results *res, res->number_extra_args++; } if (has_operand_number > 0) - finish_dollar_format_checking (status, res, fki->flags & (int) FMT_FLAG_DOLLAR_GAP_POINTER_OK); + finish_dollar_format_checking (res, fki->flags & (int) FMT_FLAG_DOLLAR_GAP_POINTER_OK); return; } if (*format_chars++ != '%') continue; if (*format_chars == 0) { - status_warning (status, "spurious trailing `%%' in format"); + warning (OPT_Wformat, "spurious trailing %<%%%> in format"); continue; } if (*format_chars == '%') @@ -1741,7 +1541,7 @@ check_format_info_main (int *status, format_check_results *res, is not used here, we can't immediately conclude this is a format without them, since it could be printf %m or scanf %*. */ int opnum; - opnum = maybe_read_dollar_number (status, &format_chars, 0, + opnum = maybe_read_dollar_number (&format_chars, 0, first_fillin_param, &main_arg_params, fki); if (opnum == -1) @@ -1752,6 +1552,11 @@ check_format_info_main (int *status, format_check_results *res, main_arg_num = opnum + info->first_arg_num - 1; } } + else if (fki->flags & FMT_FLAG_USE_DOLLAR) + { + if (avoid_dollar_number (format_chars)) + return; + } /* Read any format flags, but do not yet validate them beyond removing duplicates, since in general validation depends on the rest of @@ -1763,7 +1568,7 @@ check_format_info_main (int *status, format_check_results *res, *format_chars, NULL); if (strchr (flag_chars, *format_chars) != 0) { - status_warning (status, "repeated %s in format", _(s->name)); + warning (OPT_Wformat, "repeated %s in format", _(s->name)); } else { @@ -1776,7 +1581,7 @@ check_format_info_main (int *status, format_check_results *res, ++format_chars; if (*format_chars == 0) { - status_warning (status, "missing fill character at end of strfmon format"); + warning (OPT_Wformat, "missing fill character at end of strfmon format"); return; } } @@ -1797,7 +1602,7 @@ check_format_info_main (int *status, format_check_results *res, if (has_operand_number != 0) { int opnum; - opnum = maybe_read_dollar_number (status, &format_chars, + opnum = maybe_read_dollar_number (&format_chars, has_operand_number == 1, first_fillin_param, ¶ms, fki); @@ -1811,11 +1616,16 @@ check_format_info_main (int *status, format_check_results *res, else has_operand_number = 0; } + else + { + if (avoid_dollar_number (format_chars)) + return; + } if (info->first_arg_num != 0) { if (params == 0) { - status_warning (status, "too few arguments for format"); + warning (OPT_Wformat, "too few arguments for format"); return; } cur_param = TREE_VALUE (params); @@ -1856,8 +1666,7 @@ check_format_info_main (int *status, format_check_results *res, } if (found_width && !non_zero_width_char && (fki->flags & (int) FMT_FLAG_ZERO_WIDTH_BAD)) - status_warning (status, "zero width in %s format", - fki->name); + warning (OPT_Wformat, "zero width in %s format", fki->name); if (found_width) { i = strlen (flag_chars); @@ -1875,8 +1684,7 @@ check_format_info_main (int *status, format_check_results *res, flag_chars[i++] = fki->left_precision_char; flag_chars[i] = 0; if (!ISDIGIT (*format_chars)) - status_warning (status, "empty left precision in %s format", - fki->name); + warning (OPT_Wformat, "empty left precision in %s format", fki->name); while (ISDIGIT (*format_chars)) ++format_chars; } @@ -1896,7 +1704,7 @@ check_format_info_main (int *status, format_check_results *res, if (has_operand_number != 0) { int opnum; - opnum = maybe_read_dollar_number (status, &format_chars, + opnum = maybe_read_dollar_number (&format_chars, has_operand_number == 1, first_fillin_param, ¶ms, fki); @@ -1910,11 +1718,16 @@ check_format_info_main (int *status, format_check_results *res, else has_operand_number = 0; } + else + { + if (avoid_dollar_number (format_chars)) + return; + } if (info->first_arg_num != 0) { if (params == 0) { - status_warning (status, "too few arguments for format"); + warning (OPT_Wformat, "too few arguments for format"); return; } cur_param = TREE_VALUE (params); @@ -1944,8 +1757,7 @@ check_format_info_main (int *status, format_check_results *res, { if (!(fki->flags & (int) FMT_FLAG_EMPTY_PREC_OK) && !ISDIGIT (*format_chars)) - status_warning (status, "empty precision in %s format", - fki->name); + warning (OPT_Wformat, "empty precision in %s format", fki->name); while (ISDIGIT (*format_chars)) ++format_chars; } @@ -1960,6 +1772,14 @@ check_format_info_main (int *status, format_check_results *res, { while (fli->name != 0 && fli->name[0] != *format_chars) fli++; + /* + * Make sure FreeBSD's D format char takes preference + * over new DD length specifier if FreeBSD format + * extensions are requested. + */ + if (fli->index == FMT_LEN_D && flag_format_extensions + && fki->conversion_specs == print_char_table) + while (fli->name != 0) fli++; if (fli->name != 0) { format_chars++; @@ -1984,9 +1804,10 @@ check_format_info_main (int *status, format_check_results *res, { /* Warn if the length modifier is non-standard. */ if (ADJ_STD (length_chars_std) > C_STD_VER) - status_warning (status, "%s does not support the `%s' %s length modifier", - C_STD_NAME (length_chars_std), length_chars, - fki->name); + warning (OPT_Wformat, + "%s does not support the %qs %s length modifier", + C_STD_NAME (length_chars_std), length_chars, + fki->name); } } @@ -2000,7 +1821,7 @@ check_format_info_main (int *status, format_check_results *res, { const format_flag_spec *s = get_flag_spec (flag_specs, *format_chars, NULL); - status_warning (status, "repeated %s in format", _(s->name)); + warning (OPT_Wformat, "repeated %s in format", _(s->name)); } else { @@ -2020,7 +1841,7 @@ check_format_info_main (int *status, format_check_results *res, if (format_chars[1] == 's' || format_chars[1] == 'S' || format_chars[1] == '[') { - /* `a' is used as a flag. */ + /* 'a' is used as a flag. */ i = strlen (flag_chars); flag_chars[i++] = 'a'; flag_chars[i] = 0; @@ -2029,63 +1850,12 @@ check_format_info_main (int *status, format_check_results *res, } } - if (*format_chars == 'b') - { - /* There should be an int arg to control the string arg. */ - if (params == 0) - { - status_warning (status, "too few arguments for format"); - return; - } - if (info->first_arg_num != 0) - { - cur_param = TREE_VALUE (params); - params = TREE_CHAIN (params); - ++arg_num; - if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param)) - != integer_type_node) - && - (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param)) - != unsigned_type_node)) - { - status_warning (status, "bitmap is not type int (arg %d)", - arg_num); - } - } - } - if (*format_chars == 'D') - { - /* There should be an unsigned char * arg before the string arg. */ - if (params == 0) - { - status_warning (status, "too few arguments for format"); - return; - } - if (info->first_arg_num != 0) - { - tree cur_type; - - cur_param = TREE_VALUE (params); - params = TREE_CHAIN (params); - ++arg_num; - cur_type = TREE_TYPE (cur_param); - if (TREE_CODE (cur_type) != POINTER_TYPE - || TYPE_MAIN_VARIANT (TREE_TYPE (cur_type)) - != unsigned_char_type_node) - { - status_warning (status, - "ethernet address is not type unsigned char * (arg %d)", - arg_num); - } - } - } - format_char = *format_chars; if (format_char == 0 || (!(fki->flags & (int) FMT_FLAG_FANCY_PERCENT_OK) && format_char == '%')) { - status_warning (status, "conversion lacks type at end of format"); + warning (OPT_Wformat, "conversion lacks type at end of format"); continue; } format_chars++; @@ -2093,21 +1863,29 @@ check_format_info_main (int *status, format_check_results *res, while (fci->format_chars != 0 && strchr (fci->format_chars, format_char) == 0) ++fci; + if (fci->format_chars == 0 && flag_format_extensions + && fki->conversion_specs == print_char_table) + { + fci = fbsd_print_char_table; + while (fci->format_chars != 0 + && strchr (fci->format_chars, format_char) == 0) + ++fci; + } if (fci->format_chars == 0) { - if (ISGRAPH(format_char)) - status_warning (status, "unknown conversion type character `%c' in format", + if (ISGRAPH (format_char)) + warning (OPT_Wformat, "unknown conversion type character %qc in format", format_char); else - status_warning (status, "unknown conversion type character 0x%x in format", + warning (OPT_Wformat, "unknown conversion type character 0x%x in format", format_char); continue; } if (pedantic) { if (ADJ_STD (fci->std) > C_STD_VER) - status_warning (status, "%s does not support the `%%%c' %s format", - C_STD_NAME (fci->std), format_char, fki->name); + warning (OPT_Wformat, "%s does not support the %<%%%c%> %s format", + C_STD_NAME (fci->std), format_char, fki->name); } /* Validate the individual flags used, removing any that are invalid. */ @@ -2122,8 +1900,8 @@ check_format_info_main (int *status, format_check_results *res, continue; if (strchr (fci->flag_chars, flag_chars[i]) == 0) { - status_warning (status, "%s used with `%%%c' %s format", - _(s->name), format_char, fki->name); + warning (OPT_Wformat, "%s used with %<%%%c%> %s format", + _(s->name), format_char, fki->name); d++; continue; } @@ -2131,8 +1909,8 @@ check_format_info_main (int *status, format_check_results *res, { const format_flag_spec *t; if (ADJ_STD (s->std) > C_STD_VER) - status_warning (status, "%s does not support %s", - C_STD_NAME (s->std), _(s->long_name)); + warning (OPT_Wformat, "%s does not support %s", + C_STD_NAME (s->std), _(s->long_name)); t = get_flag_spec (flag_specs, flag_chars[i], fci->flags2); if (t != NULL && ADJ_STD (t->std) > ADJ_STD (s->std)) { @@ -2140,9 +1918,10 @@ check_format_info_main (int *status, format_check_results *res, ? t->long_name : s->long_name); if (ADJ_STD (t->std) > C_STD_VER) - status_warning (status, "%s does not support %s with the `%%%c' %s format", - C_STD_NAME (t->std), _(long_name), - format_char, fki->name); + warning (OPT_Wformat, + "%s does not support %s with the %<%%%c%> %s format", + C_STD_NAME (t->std), _(long_name), + format_char, fki->name); } } } @@ -2173,22 +1952,24 @@ check_format_info_main (int *status, format_check_results *res, if (bad_flag_pairs[i].ignored) { if (bad_flag_pairs[i].predicate != 0) - status_warning (status, "%s ignored with %s and `%%%c' %s format", - _(s->name), _(t->name), format_char, - fki->name); + warning (OPT_Wformat, + "%s ignored with %s and %<%%%c%> %s format", + _(s->name), _(t->name), format_char, + fki->name); else - status_warning (status, "%s ignored with %s in %s format", - _(s->name), _(t->name), fki->name); + warning (OPT_Wformat, "%s ignored with %s in %s format", + _(s->name), _(t->name), fki->name); } else { if (bad_flag_pairs[i].predicate != 0) - status_warning (status, "use of %s and %s together with `%%%c' %s format", - _(s->name), _(t->name), format_char, - fki->name); + warning (OPT_Wformat, + "use of %s and %s together with %<%%%c%> %s format", + _(s->name), _(t->name), format_char, + fki->name); else - status_warning (status, "use of %s and %s together in %s format", - _(s->name), _(t->name), fki->name); + warning (OPT_Wformat, "use of %s and %s together in %s format", + _(s->name), _(t->name), fki->name); } } @@ -2206,10 +1987,11 @@ check_format_info_main (int *status, format_check_results *res, else if (strchr (fci->flags2, '2') != 0) y2k_level = 2; if (y2k_level == 3) - status_warning (status, "`%%%c' yields only last 2 digits of year in some locales on non-BSD systems", - format_char); + warning (OPT_Wformat_y2k, "%<%%%c%> yields only last 2 digits of " + "year in some locales on non-BSD systems", format_char); else if (y2k_level == 2) - status_warning (status, "`%%%c' yields only last 2 digits of year", format_char); + warning (OPT_Wformat_y2k, "%<%%%c%> yields only last 2 digits of " + "year", format_char); } if (strchr (fci->flags2, '[') != 0) @@ -2225,7 +2007,7 @@ check_format_info_main (int *status, format_check_results *res, ++format_chars; if (*format_chars != ']') /* The end of the format string was reached. */ - status_warning (status, "no closing `]' for `%%[' format"); + warning (OPT_Wformat, "no closing %<]%> for %<%%[%> format"); } wanted_type = 0; @@ -2238,14 +2020,15 @@ check_format_info_main (int *status, format_check_results *res, wanted_type_std = fci->types[length_chars_val].std; if (wanted_type == 0) { - status_warning (status, "use of `%s' length modifier with `%c' type character", - length_chars, format_char); + warning (OPT_Wformat, + "use of %qs length modifier with %qc type character", + length_chars, format_char); /* Heuristic: skip one argument when an invalid length/type combination is encountered. */ arg_num++; if (params == 0) { - status_warning (status, "too few arguments for format"); + warning (OPT_Wformat, "too few arguments for format"); return; } params = TREE_CHAIN (params); @@ -2259,12 +2042,15 @@ check_format_info_main (int *status, format_check_results *res, && ADJ_STD (wanted_type_std) > ADJ_STD (fci->std)) { if (ADJ_STD (wanted_type_std) > C_STD_VER) - status_warning (status, "%s does not support the `%%%s%c' %s format", - C_STD_NAME (wanted_type_std), length_chars, - format_char, fki->name); + warning (OPT_Wformat, + "%s does not support the %<%%%s%c%> %s format", + C_STD_NAME (wanted_type_std), length_chars, + format_char, fki->name); } } + main_wanted_type.next = NULL; + /* Finally. . .check type of argument against desired type! */ if (info->first_arg_num == 0) continue; @@ -2274,13 +2060,17 @@ check_format_info_main (int *status, format_check_results *res, if (main_arg_num != 0) { if (suppressed) - status_warning (status, "operand number specified with suppressed assignment"); + warning (OPT_Wformat, "operand number specified with " + "suppressed assignment"); else - status_warning (status, "operand number specified for format taking no argument"); + warning (OPT_Wformat, "operand number specified for format " + "taking no argument"); } } else { + format_wanted_type *wanted_type_ptr; + if (main_arg_num != 0) { arg_num = main_arg_num; @@ -2291,50 +2081,77 @@ check_format_info_main (int *status, format_check_results *res, ++arg_num; if (has_operand_number > 0) { - status_warning (status, "missing $ operand number in format"); + warning (OPT_Wformat, "missing $ operand number in format"); return; } else has_operand_number = 0; + } + + wanted_type_ptr = &main_wanted_type; + while (fci) + { if (params == 0) { - status_warning (status, "too few arguments for format"); + warning (OPT_Wformat, "too few arguments for format"); return; } + + cur_param = TREE_VALUE (params); + params = TREE_CHAIN (params); + + wanted_type_ptr->wanted_type = wanted_type; + wanted_type_ptr->wanted_type_name = wanted_type_name; + wanted_type_ptr->pointer_count = fci->pointer_count + aflag; + wanted_type_ptr->char_lenient_flag = 0; + if (strchr (fci->flags2, 'c') != 0) + wanted_type_ptr->char_lenient_flag = 1; + wanted_type_ptr->writing_in_flag = 0; + wanted_type_ptr->reading_from_flag = 0; + if (aflag) + wanted_type_ptr->writing_in_flag = 1; + else + { + if (strchr (fci->flags2, 'W') != 0) + wanted_type_ptr->writing_in_flag = 1; + if (strchr (fci->flags2, 'R') != 0) + wanted_type_ptr->reading_from_flag = 1; + } + wanted_type_ptr->name = NULL; + wanted_type_ptr->param = cur_param; + wanted_type_ptr->arg_num = arg_num; + wanted_type_ptr->next = NULL; + if (last_wanted_type != 0) + last_wanted_type->next = wanted_type_ptr; + if (first_wanted_type == 0) + first_wanted_type = wanted_type_ptr; + last_wanted_type = wanted_type_ptr; + + fci = fci->chain; + if (fci) + { + wanted_type_ptr = GGC_NEW (format_wanted_type); + arg_num++; + wanted_type = *fci->types[length_chars_val].type; + wanted_type_name = fci->types[length_chars_val].name; + } } - cur_param = TREE_VALUE (params); - params = TREE_CHAIN (params); - main_wanted_type.wanted_type = wanted_type; - main_wanted_type.wanted_type_name = wanted_type_name; - main_wanted_type.pointer_count = fci->pointer_count + aflag; - main_wanted_type.char_lenient_flag = 0; - if (strchr (fci->flags2, 'c') != 0) - main_wanted_type.char_lenient_flag = 1; - main_wanted_type.writing_in_flag = 0; - main_wanted_type.reading_from_flag = 0; - if (aflag) - main_wanted_type.writing_in_flag = 1; - else - { - if (strchr (fci->flags2, 'W') != 0) - main_wanted_type.writing_in_flag = 1; - if (strchr (fci->flags2, 'R') != 0) - main_wanted_type.reading_from_flag = 1; - } - main_wanted_type.name = NULL; - main_wanted_type.param = cur_param; - main_wanted_type.arg_num = arg_num; - main_wanted_type.next = NULL; - if (last_wanted_type != 0) - last_wanted_type->next = &main_wanted_type; - if (first_wanted_type == 0) - first_wanted_type = &main_wanted_type; - last_wanted_type = &main_wanted_type; } if (first_wanted_type != 0) - check_format_types (status, first_wanted_type); + check_format_types (first_wanted_type, format_start, + format_chars - format_start); + if (main_wanted_type.next != NULL) + { + format_wanted_type *wanted_type_ptr = main_wanted_type.next; + while (wanted_type_ptr) + { + format_wanted_type *next = wanted_type_ptr->next; + ggc_free (wanted_type_ptr); + wanted_type_ptr = next; + } + } } } @@ -2342,7 +2159,8 @@ check_format_info_main (int *status, format_check_results *res, /* Check the argument types from a single format conversion (possibly including width and precision arguments). */ static void -check_format_types (int *status, format_wanted_type *types) +check_format_types (format_wanted_type *types, const char *format_start, + int format_length) { for (; types != 0; types = types->next) { @@ -2357,18 +2175,19 @@ check_format_types (int *status, format_wanted_type *types) cur_type = TREE_TYPE (cur_param); if (cur_type == error_mark_node) continue; + orig_cur_type = cur_type; char_type_flag = 0; wanted_type = types->wanted_type; arg_num = types->arg_num; /* The following should not occur here. */ - if (wanted_type == 0) - abort (); - if (wanted_type == void_type_node && types->pointer_count == 0) - abort (); + gcc_assert (wanted_type); + gcc_assert (wanted_type != void_type_node || types->pointer_count); if (types->pointer_count == 0) - wanted_type = (*lang_hooks.types.type_promotes_to) (wanted_type); + wanted_type = lang_hooks.types.type_promotes_to (wanted_type); + + wanted_type = TYPE_MAIN_VARIANT (wanted_type); STRIP_NOPS (cur_param); @@ -2387,18 +2206,16 @@ check_format_types (int *status, format_wanted_type *types) && i == 0 && cur_param != 0 && integer_zerop (cur_param)) - status_warning (status, - "writing through null pointer (arg %d)", - arg_num); + warning (OPT_Wformat, "writing through null pointer " + "(argument %d)", arg_num); /* Check for reading through a NULL pointer. */ if (types->reading_from_flag && i == 0 && cur_param != 0 && integer_zerop (cur_param)) - status_warning (status, - "reading through null pointer (arg %d)", - arg_num); + warning (OPT_Wformat, "reading through null pointer " + "(argument %d)", arg_num); if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR) cur_param = TREE_OPERAND (cur_param, 0); @@ -2414,10 +2231,11 @@ check_format_types (int *status, format_wanted_type *types) && i == 0 && (TYPE_READONLY (cur_type) || (cur_param != 0 - && (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c' + && (CONSTANT_CLASS_P (cur_param) || (DECL_P (cur_param) && TREE_READONLY (cur_param)))))) - status_warning (status, "writing into constant object (arg %d)", arg_num); + warning (OPT_Wformat, "writing into constant object " + "(argument %d)", arg_num); /* If there are extra type qualifiers beyond the first indirection, then this makes the types technically @@ -2427,16 +2245,17 @@ check_format_types (int *status, format_wanted_type *types) && (TYPE_READONLY (cur_type) || TYPE_VOLATILE (cur_type) || TYPE_RESTRICT (cur_type))) - status_warning (status, "extra type qualifiers in format argument (arg %d)", + warning (OPT_Wformat, "extra type qualifiers in format " + "argument (argument %d)", arg_num); } else { - if (types->pointer_count == 1) - status_warning (status, "format argument is not a pointer (arg %d)", arg_num); - else - status_warning (status, "format argument is not a pointer to a pointer (arg %d)", arg_num); + format_type_warning (types->name, format_start, format_length, + wanted_type, types->pointer_count, + types->wanted_type_name, orig_cur_type, + arg_num); break; } } @@ -2444,7 +2263,6 @@ check_format_types (int *status, format_wanted_type *types) if (i < types->pointer_count) continue; - orig_cur_type = cur_type; cur_type = TYPE_MAIN_VARIANT (cur_type); /* Check whether the argument type is a character type. This leniency @@ -2456,9 +2274,9 @@ check_format_types (int *status, format_wanted_type *types) || cur_type == unsigned_char_type_node); /* Check the type of the "real" argument, if there's a type we want. */ - if (wanted_type == cur_type) + if (lang_hooks.types_compatible_p (wanted_type, cur_type)) continue; - /* If we want `void *', allow any pointer type. + /* If we want 'void *', allow any pointer type. (Anything else would already have got a warning.) With -pedantic, only allow pointers to void and to character types. */ @@ -2471,116 +2289,126 @@ check_format_types (int *status, format_wanted_type *types) a second level of indirection. */ if (TREE_CODE (wanted_type) == INTEGER_TYPE && TREE_CODE (cur_type) == INTEGER_TYPE - && (! pedantic || i == 0 || (i == 1 && char_type_flag)) - && (TREE_UNSIGNED (wanted_type) + && (!pedantic || i == 0 || (i == 1 && char_type_flag)) + && (TYPE_UNSIGNED (wanted_type) ? wanted_type == c_common_unsigned_type (cur_type) : wanted_type == c_common_signed_type (cur_type))) continue; /* Likewise, "signed char", "unsigned char" and "char" are equivalent but the above test won't consider them equivalent. */ if (wanted_type == char_type_node - && (! pedantic || i < 2) + && (!pedantic || i < 2) && char_type_flag) continue; /* Now we have a type mismatch. */ - { - const char *this; - const char *that; - tree tmp; - - tmp = TYPE_NAME (wanted_type); - if (TREE_CODE (tmp) == TYPE_DECL) - tmp = DECL_NAME (tmp); - this = IDENTIFIER_POINTER (tmp); - - that = 0; - if (TYPE_NAME (orig_cur_type) != 0 - && TREE_CODE (orig_cur_type) != INTEGER_TYPE - && !(TREE_CODE (orig_cur_type) == POINTER_TYPE - && TREE_CODE (TREE_TYPE (orig_cur_type)) == INTEGER_TYPE)) - { - tmp = TYPE_NAME (orig_cur_type); - if (TREE_CODE (tmp) == TYPE_DECL) - tmp = DECL_NAME (tmp); - if (tmp) - that = IDENTIFIER_POINTER (tmp); - } - - /* A nameless type can't possibly match what the format wants. - So there will be a warning for it. - Make up a string to describe vaguely what it is. */ - if (that == 0) - { - if (TREE_CODE (orig_cur_type) == POINTER_TYPE) - that = _("pointer"); - else - that = _("different type"); - } + format_type_warning (types->name, format_start, format_length, + wanted_type, types->pointer_count, + types->wanted_type_name, orig_cur_type, arg_num); + } +} - /* Make the warning better in case of mismatch of int vs long. */ - if (TREE_CODE (orig_cur_type) == INTEGER_TYPE - && TREE_CODE (wanted_type) == INTEGER_TYPE - && TYPE_PRECISION (orig_cur_type) == TYPE_PRECISION (wanted_type) - && TYPE_NAME (orig_cur_type) != 0 - && TREE_CODE (TYPE_NAME (orig_cur_type)) == TYPE_DECL) - that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type))); - if (strcmp (this, that) != 0) - { - /* There may be a better name for the format, e.g. size_t, - but we should allow for programs with a perverse typedef - making size_t something other than what the compiler - thinks. */ - if (types->wanted_type_name != 0 - && strcmp (types->wanted_type_name, that) != 0) - this = types->wanted_type_name; - if (types->name != 0) - status_warning (status, "%s is not type %s (arg %d)", types->name, this, - arg_num); - else - status_warning (status, "%s format, %s arg (arg %d)", this, that, arg_num); - } - } +/* Give a warning about a format argument of different type from that + expected. DESCR is a description such as "field precision", or + NULL for an ordinary format. For an ordinary format, FORMAT_START + points to where the format starts in the format string and + FORMAT_LENGTH is its length. WANTED_TYPE is the type the argument + should have after POINTER_COUNT pointer dereferences. + WANTED_NAME_NAME is a possibly more friendly name of WANTED_TYPE, + or NULL if the ordinary name of the type should be used. ARG_TYPE + is the type of the actual argument. ARG_NUM is the number of that + argument. */ +static void +format_type_warning (const char *descr, const char *format_start, + int format_length, tree wanted_type, int pointer_count, + const char *wanted_type_name, tree arg_type, int arg_num) +{ + char *p; + /* If ARG_TYPE is a typedef with a misleading name (for example, + size_t but not the standard size_t expected by printf %zu), avoid + printing the typedef name. */ + if (wanted_type_name + && TYPE_NAME (arg_type) + && TREE_CODE (TYPE_NAME (arg_type)) == TYPE_DECL + && DECL_NAME (TYPE_NAME (arg_type)) + && !strcmp (wanted_type_name, + lang_hooks.decl_printable_name (TYPE_NAME (arg_type), 2))) + arg_type = TYPE_MAIN_VARIANT (arg_type); + /* The format type and name exclude any '*' for pointers, so those + must be formatted manually. For all the types we currently have, + this is adequate, but formats taking pointers to functions or + arrays would require the full type to be built up in order to + print it with %T. */ + p = (char *) alloca (pointer_count + 2); + if (pointer_count == 0) + p[0] = 0; + else if (c_dialect_cxx ()) + { + memset (p, '*', pointer_count); + p[pointer_count] = 0; + } + else + { + p[0] = ' '; + memset (p + 1, '*', pointer_count); + p[pointer_count + 1] = 0; + } + if (wanted_type_name) + { + if (descr) + warning (OPT_Wformat, "%s should have type %<%s%s%>, " + "but argument %d has type %qT", + descr, wanted_type_name, p, arg_num, arg_type); + else + warning (OPT_Wformat, "format %q.*s expects type %<%s%s%>, " + "but argument %d has type %qT", + format_length, format_start, wanted_type_name, p, + arg_num, arg_type); + } + else + { + if (descr) + warning (OPT_Wformat, "%s should have type %<%T%s%>, " + "but argument %d has type %qT", + descr, wanted_type, p, arg_num, arg_type); + else + warning (OPT_Wformat, "format %q.*s expects type %<%T%s%>, " + "but argument %d has type %qT", + format_length, format_start, wanted_type, p, arg_num, arg_type); } } + /* Given a format_char_info array FCI, and a character C, this function returns the index into the conversion_specs where that specifier's - data is located. If the character isn't found it aborts. */ + data is located. The character must exist. */ static unsigned int find_char_info_specifier_index (const format_char_info *fci, int c) { - unsigned int i = 0; - - while (fci->format_chars) - { - if (strchr (fci->format_chars, c)) - return i; - i++; fci++; - } - + unsigned i; + + for (i = 0; fci->format_chars; i++, fci++) + if (strchr (fci->format_chars, c)) + return i; + /* We shouldn't be looking for a non-existent specifier. */ - abort (); + gcc_unreachable (); } /* Given a format_length_info array FLI, and a character C, this function returns the index into the conversion_specs where that - modifier's data is located. If the character isn't found it - aborts. */ + modifier's data is located. The character must exist. */ static unsigned int find_length_info_modifier_index (const format_length_info *fli, int c) { - unsigned int i = 0; - - while (fli->name) - { - if (strchr (fli->name, c)) - return i; - i++; fli++; - } - + unsigned i; + + for (i = 0; fli->name; i++, fli++) + if (strchr (fli->name, c)) + return i; + /* We shouldn't be looking for a non-existent modifier. */ - abort (); + gcc_unreachable (); } /* Determine the type of HOST_WIDE_INT in the code being compiled for @@ -2590,12 +2418,12 @@ static void init_dynamic_asm_fprintf_info (void) { static tree hwi; - + if (!hwi) { format_length_info *new_asm_fprintf_length_specs; unsigned int i; - + /* Find the underlying type for HOST_WIDE_INT. For the %w length modifier to work, one must have issued: "typedef HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code @@ -2603,27 +2431,27 @@ init_dynamic_asm_fprintf_info (void) hwi = maybe_get_identifier ("__gcc_host_wide_int__"); if (!hwi) { - error ("'__gcc_host_wide_int__' is not defined as a type"); + error ("%<__gcc_host_wide_int__%> is not defined as a type"); return; } hwi = identifier_global_value (hwi); if (!hwi || TREE_CODE (hwi) != TYPE_DECL) { - error ("'__gcc_host_wide_int__' is not defined as a type"); + error ("%<__gcc_host_wide_int__%> is not defined as a type"); return; } hwi = DECL_ORIGINAL_TYPE (hwi); - if (!hwi) - abort (); + gcc_assert (hwi); if (hwi != long_integer_type_node && hwi != long_long_integer_type_node) { - error ("'__gcc_host_wide_int__' is not defined as 'long'" - " or 'long long'"); + error ("%<__gcc_host_wide_int__%> is not defined as %<long%>" + " or %<long long%>"); return; } /* Create a new (writable) copy of asm_fprintf_length_specs. */ - new_asm_fprintf_length_specs = xmemdup (asm_fprintf_length_specs, + new_asm_fprintf_length_specs = (format_length_info *) + xmemdup (asm_fprintf_length_specs, sizeof (asm_fprintf_length_specs), sizeof (asm_fprintf_length_specs)); @@ -2634,7 +2462,7 @@ init_dynamic_asm_fprintf_info (void) else if (hwi == long_long_integer_type_node) new_asm_fprintf_length_specs[i].index = FMT_LEN_ll; else - abort (); + gcc_unreachable (); /* Assign the new data for use. */ dynamic_format_types[asm_fprintf_format_type].length_char_specs = @@ -2642,6 +2470,55 @@ init_dynamic_asm_fprintf_info (void) } } +/* Determine the type of a "locus" in the code being compiled for use + in GCC's __gcc_gfc__ custom format attribute. You must have set + dynamic_format_types before calling this function. */ +static void +init_dynamic_gfc_info (void) +{ + static tree locus; + + if (!locus) + { + static format_char_info *gfc_fci; + + /* For the GCC __gcc_gfc__ custom format specifier to work, one + must have declared 'locus' prior to using this attribute. If + we haven't seen this declarations then you shouldn't use the + specifier requiring that type. */ + if ((locus = maybe_get_identifier ("locus"))) + { + locus = identifier_global_value (locus); + if (locus) + { + if (TREE_CODE (locus) != TYPE_DECL) + { + error ("%<locus%> is not defined as a type"); + locus = 0; + } + else + locus = TREE_TYPE (locus); + } + } + + /* Assign the new data for use. */ + + /* Handle the __gcc_gfc__ format specifics. */ + if (!gfc_fci) + dynamic_format_types[gcc_gfc_format_type].conversion_specs = + gfc_fci = (format_char_info *) + xmemdup (gcc_gfc_char_table, + sizeof (gcc_gfc_char_table), + sizeof (gcc_gfc_char_table)); + if (locus) + { + const unsigned i = find_char_info_specifier_index (gfc_fci, 'L'); + gfc_fci[i].types[0].type = &locus; + gfc_fci[i].pointer_count = 1; + } + } +} + /* Determine the types of "tree" and "location_t" in the code being compiled for use in GCC's diagnostic custom format attributes. You must have set dynamic_format_types before calling this function. */ @@ -2649,15 +2526,15 @@ static void init_dynamic_diag_info (void) { static tree t, loc, hwi; - + if (!loc || !t || !hwi) { - static format_char_info *diag_fci, *cdiag_fci, *cxxdiag_fci; + static format_char_info *diag_fci, *tdiag_fci, *cdiag_fci, *cxxdiag_fci; static format_length_info *diag_ls; unsigned int i; /* For the GCC-diagnostics custom format specifiers to work, one - must have declared `tree' and/or `location_t' prior to using + must have declared 'tree' and/or 'location_t' prior to using those attributes. If we haven't seen these declarations then you shouldn't use the specifiers requiring these types. However we don't force a hard ICE because we may see only one @@ -2669,7 +2546,7 @@ init_dynamic_diag_info (void) { if (TREE_CODE (loc) != TYPE_DECL) { - error ("'location_t' is not defined as a type"); + error ("%<location_t%> is not defined as a type"); loc = 0; } else @@ -2677,7 +2554,7 @@ init_dynamic_diag_info (void) } } - /* We need to grab the underlying `union tree_node' so peek into + /* We need to grab the underlying 'union tree_node' so peek into an extra type level. */ if ((t = maybe_get_identifier ("tree"))) { @@ -2686,19 +2563,19 @@ init_dynamic_diag_info (void) { if (TREE_CODE (t) != TYPE_DECL) { - error ("'tree' is not defined as a type"); + error ("%<tree%> is not defined as a type"); t = 0; } else if (TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE) { - error ("'tree' is not defined as a pointer type"); + error ("%<tree%> is not defined as a pointer type"); t = 0; } else t = TREE_TYPE (TREE_TYPE (t)); } } - + /* Find the underlying type for HOST_WIDE_INT. For the %w length modifier to work, one must have issued: "typedef HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code @@ -2710,37 +2587,38 @@ init_dynamic_diag_info (void) { if (TREE_CODE (hwi) != TYPE_DECL) { - error ("'__gcc_host_wide_int__' is not defined as a type"); + error ("%<__gcc_host_wide_int__%> is not defined as a type"); hwi = 0; } else { hwi = DECL_ORIGINAL_TYPE (hwi); - if (!hwi) - abort (); + gcc_assert (hwi); if (hwi != long_integer_type_node && hwi != long_long_integer_type_node) { - error ("'__gcc_host_wide_int__' is not defined" - " as 'long' or 'long long'"); + error ("%<__gcc_host_wide_int__%> is not defined" + " as %<long%> or %<long long%>"); hwi = 0; } } } } - + /* Assign the new data for use. */ /* All the GCC diag formats use the same length specs. */ - if (! diag_ls) + if (!diag_ls) dynamic_format_types[gcc_diag_format_type].length_char_specs = + dynamic_format_types[gcc_tdiag_format_type].length_char_specs = dynamic_format_types[gcc_cdiag_format_type].length_char_specs = dynamic_format_types[gcc_cxxdiag_format_type].length_char_specs = - diag_ls = xmemdup (gcc_diag_length_specs, + diag_ls = (format_length_info *) + xmemdup (gcc_diag_length_specs, sizeof (gcc_diag_length_specs), - sizeof (gcc_diag_length_specs)); + sizeof (gcc_diag_length_specs)); if (hwi) - { + { /* HOST_WIDE_INT must be one of 'long' or 'long long'. */ i = find_length_info_modifier_index (diag_ls, 'w'); if (hwi == long_integer_type_node) @@ -2748,42 +2626,68 @@ init_dynamic_diag_info (void) else if (hwi == long_long_integer_type_node) diag_ls[i].index = FMT_LEN_ll; else - abort (); + gcc_unreachable (); } /* Handle the __gcc_diag__ format specifics. */ - if (! diag_fci) + if (!diag_fci) dynamic_format_types[gcc_diag_format_type].conversion_specs = - diag_fci = xmemdup (gcc_diag_char_table, - sizeof(gcc_diag_char_table), - sizeof(gcc_diag_char_table)); + diag_fci = (format_char_info *) + xmemdup (gcc_diag_char_table, + sizeof (gcc_diag_char_table), + sizeof (gcc_diag_char_table)); if (loc) - { + { i = find_char_info_specifier_index (diag_fci, 'H'); diag_fci[i].types[0].type = &loc; diag_fci[i].pointer_count = 1; } if (t) - { + { i = find_char_info_specifier_index (diag_fci, 'J'); diag_fci[i].types[0].type = &t; diag_fci[i].pointer_count = 1; } + /* Handle the __gcc_tdiag__ format specifics. */ + if (!tdiag_fci) + dynamic_format_types[gcc_tdiag_format_type].conversion_specs = + tdiag_fci = (format_char_info *) + xmemdup (gcc_tdiag_char_table, + sizeof (gcc_tdiag_char_table), + sizeof (gcc_tdiag_char_table)); + if (loc) + { + i = find_char_info_specifier_index (tdiag_fci, 'H'); + tdiag_fci[i].types[0].type = &loc; + tdiag_fci[i].pointer_count = 1; + } + if (t) + { + /* All specifiers taking a tree share the same struct. */ + i = find_char_info_specifier_index (tdiag_fci, 'D'); + tdiag_fci[i].types[0].type = &t; + tdiag_fci[i].pointer_count = 1; + i = find_char_info_specifier_index (tdiag_fci, 'J'); + tdiag_fci[i].types[0].type = &t; + tdiag_fci[i].pointer_count = 1; + } + /* Handle the __gcc_cdiag__ format specifics. */ - if (! cdiag_fci) + if (!cdiag_fci) dynamic_format_types[gcc_cdiag_format_type].conversion_specs = - cdiag_fci = xmemdup (gcc_cdiag_char_table, - sizeof(gcc_cdiag_char_table), - sizeof(gcc_cdiag_char_table)); + cdiag_fci = (format_char_info *) + xmemdup (gcc_cdiag_char_table, + sizeof (gcc_cdiag_char_table), + sizeof (gcc_cdiag_char_table)); if (loc) - { + { i = find_char_info_specifier_index (cdiag_fci, 'H'); cdiag_fci[i].types[0].type = &loc; cdiag_fci[i].pointer_count = 1; } if (t) - { + { /* All specifiers taking a tree share the same struct. */ i = find_char_info_specifier_index (cdiag_fci, 'D'); cdiag_fci[i].types[0].type = &t; @@ -2794,19 +2698,20 @@ init_dynamic_diag_info (void) } /* Handle the __gcc_cxxdiag__ format specifics. */ - if (! cxxdiag_fci) + if (!cxxdiag_fci) dynamic_format_types[gcc_cxxdiag_format_type].conversion_specs = - cxxdiag_fci = xmemdup (gcc_cxxdiag_char_table, - sizeof(gcc_cxxdiag_char_table), - sizeof(gcc_cxxdiag_char_table)); + cxxdiag_fci = (format_char_info *) + xmemdup (gcc_cxxdiag_char_table, + sizeof (gcc_cxxdiag_char_table), + sizeof (gcc_cxxdiag_char_table)); if (loc) - { + { i = find_char_info_specifier_index (cxxdiag_fci, 'H'); cxxdiag_fci[i].types[0].type = &loc; cxxdiag_fci[i].pointer_count = 1; } if (t) - { + { /* All specifiers taking a tree share the same struct. */ i = find_char_info_specifier_index (cxxdiag_fci, 'D'); cxxdiag_fci[i].types[0].type = &t; @@ -2818,16 +2723,37 @@ init_dynamic_diag_info (void) } } +#ifdef TARGET_FORMAT_TYPES +extern const format_kind_info TARGET_FORMAT_TYPES[]; +#endif + /* Handle a "format" attribute; arguments as in struct attribute_spec.handler. */ tree -handle_format_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args, +handle_format_attribute (tree *node, tree ARG_UNUSED (name), tree args, int flags, bool *no_add_attrs) { tree type = *node; function_format_info info; tree argument; +#ifdef TARGET_FORMAT_TYPES + /* If the target provides additional format types, we need to + add them to FORMAT_TYPES at first use. */ + if (TARGET_FORMAT_TYPES != NULL && !dynamic_format_types) + { + dynamic_format_types = xmalloc ((n_format_types + TARGET_N_FORMAT_TYPES) + * sizeof (dynamic_format_types[0])); + memcpy (dynamic_format_types, format_types_orig, + sizeof (format_types_orig)); + memcpy (&dynamic_format_types[n_format_types], TARGET_FORMAT_TYPES, + TARGET_N_FORMAT_TYPES * sizeof (dynamic_format_types[0])); + + format_types = dynamic_format_types; + n_format_types += TARGET_N_FORMAT_TYPES; + } +#endif + if (!decode_format_attr (args, &info, 0)) { *no_add_attrs = true; @@ -2853,7 +2779,7 @@ handle_format_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args, if (arg_num != info.first_arg_num) { if (!(flags & (int) ATTR_FLAG_BUILT_IN)) - error ("args to be formatted is not '...'"); + error ("args to be formatted is not %<...%>"); *no_add_attrs = true; return NULL_TREE; } @@ -2870,29 +2796,36 @@ handle_format_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args, /* If this is a custom GCC-internal format type, we have to initialize certain bits a runtime. */ if (info.format_type == asm_fprintf_format_type + || info.format_type == gcc_gfc_format_type || info.format_type == gcc_diag_format_type + || info.format_type == gcc_tdiag_format_type || info.format_type == gcc_cdiag_format_type || info.format_type == gcc_cxxdiag_format_type) { /* Our first time through, we have to make sure that our - format_type data is allocated dynamically and is modifiable. */ + format_type data is allocated dynamically and is modifiable. */ if (!dynamic_format_types) - format_types = dynamic_format_types = + format_types = dynamic_format_types = (format_kind_info *) xmemdup (format_types_orig, sizeof (format_types_orig), sizeof (format_types_orig)); /* If this is format __asm_fprintf__, we have to initialize - GCC's notion of HOST_WIDE_INT for checking %wd. */ + GCC's notion of HOST_WIDE_INT for checking %wd. */ if (info.format_type == asm_fprintf_format_type) - init_dynamic_asm_fprintf_info(); + init_dynamic_asm_fprintf_info (); + /* If this is format __gcc_gfc__, we have to initialize GCC's + notion of 'locus' at runtime for %L. */ + else if (info.format_type == gcc_gfc_format_type) + init_dynamic_gfc_info (); /* If this is one of the diagnostic attributes, then we have to - initialize `location_t' and `tree' at runtime. */ + initialize 'location_t' and 'tree' at runtime. */ else if (info.format_type == gcc_diag_format_type + || info.format_type == gcc_tdiag_format_type || info.format_type == gcc_cdiag_format_type || info.format_type == gcc_cxxdiag_format_type) - init_dynamic_diag_info(); + init_dynamic_diag_info (); else - abort(); + gcc_unreachable (); } return NULL_TREE; |