/* Check calls to formatted I/O functions (-Wformat).
|
/* Check calls to formatted I/O functions (-Wformat).
|
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
|
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
|
2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
|
2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "c-common.h"
|
#include "c-common.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "intl.h"
|
#include "intl.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "c-format.h"
|
#include "c-format.h"
|
|
|
/* Set format warning options according to a -Wformat=n option. */
|
/* Set format warning options according to a -Wformat=n option. */
|
|
|
void
|
void
|
set_Wformat (int setting)
|
set_Wformat (int setting)
|
{
|
{
|
warn_format = setting;
|
warn_format = setting;
|
warn_format_extra_args = setting;
|
warn_format_extra_args = setting;
|
warn_format_zero_length = setting;
|
warn_format_zero_length = setting;
|
if (setting != 1)
|
if (setting != 1)
|
{
|
{
|
warn_format_nonliteral = setting;
|
warn_format_nonliteral = setting;
|
warn_format_security = setting;
|
warn_format_security = setting;
|
warn_format_y2k = setting;
|
warn_format_y2k = setting;
|
}
|
}
|
/* Make sure not to disable -Wnonnull if -Wformat=0 is specified. */
|
/* Make sure not to disable -Wnonnull if -Wformat=0 is specified. */
|
if (setting)
|
if (setting)
|
warn_nonnull = setting;
|
warn_nonnull = setting;
|
}
|
}
|
|
|
|
|
/* Handle attributes associated with format checking. */
|
/* Handle attributes associated with format checking. */
|
|
|
/* This must be in the same order as format_types, except for
|
/* This must be in the same order as format_types, except for
|
format_type_error. Target-specific format types do not have
|
format_type_error. Target-specific format types do not have
|
matching enum values. */
|
matching enum values. */
|
enum format_type { printf_format_type, asm_fprintf_format_type,
|
enum format_type { printf_format_type, asm_fprintf_format_type,
|
gcc_diag_format_type, gcc_tdiag_format_type,
|
gcc_diag_format_type, gcc_tdiag_format_type,
|
gcc_cdiag_format_type,
|
gcc_cdiag_format_type,
|
gcc_cxxdiag_format_type, gcc_gfc_format_type,
|
gcc_cxxdiag_format_type, gcc_gfc_format_type,
|
scanf_format_type, strftime_format_type,
|
scanf_format_type, strftime_format_type,
|
strfmon_format_type, format_type_error = -1};
|
strfmon_format_type, format_type_error = -1};
|
|
|
typedef struct function_format_info
|
typedef struct function_format_info
|
{
|
{
|
int 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 format_num; /* number of format argument */
|
unsigned HOST_WIDE_INT first_arg_num; /* number of first arg (zero for varargs) */
|
unsigned HOST_WIDE_INT first_arg_num; /* number of first arg (zero for varargs) */
|
} function_format_info;
|
} function_format_info;
|
|
|
static bool decode_format_attr (tree, function_format_info *, int);
|
static bool decode_format_attr (tree, function_format_info *, int);
|
static int decode_format_type (const char *);
|
static int decode_format_type (const char *);
|
|
|
static bool check_format_string (tree argument,
|
static bool check_format_string (tree argument,
|
unsigned HOST_WIDE_INT format_num,
|
unsigned HOST_WIDE_INT format_num,
|
int flags, bool *no_add_attrs);
|
int flags, bool *no_add_attrs);
|
static bool get_constant (tree expr, unsigned HOST_WIDE_INT *value,
|
static bool get_constant (tree expr, unsigned HOST_WIDE_INT *value,
|
int validated_p);
|
int validated_p);
|
|
|
|
|
/* Handle a "format_arg" attribute; arguments as in
|
/* Handle a "format_arg" attribute; arguments as in
|
struct attribute_spec.handler. */
|
struct attribute_spec.handler. */
|
tree
|
tree
|
handle_format_arg_attribute (tree *node, tree ARG_UNUSED (name),
|
handle_format_arg_attribute (tree *node, tree ARG_UNUSED (name),
|
tree args, int flags, bool *no_add_attrs)
|
tree args, int flags, bool *no_add_attrs)
|
{
|
{
|
tree type = *node;
|
tree type = *node;
|
tree format_num_expr = TREE_VALUE (args);
|
tree format_num_expr = TREE_VALUE (args);
|
unsigned HOST_WIDE_INT format_num = 0;
|
unsigned HOST_WIDE_INT format_num = 0;
|
tree argument;
|
tree argument;
|
|
|
if (!get_constant (format_num_expr, &format_num, 0))
|
if (!get_constant (format_num_expr, &format_num, 0))
|
{
|
{
|
error ("format string has invalid operand number");
|
error ("format string has invalid operand number");
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
argument = TYPE_ARG_TYPES (type);
|
argument = TYPE_ARG_TYPES (type);
|
if (argument)
|
if (argument)
|
{
|
{
|
if (!check_format_string (argument, format_num, flags, no_add_attrs))
|
if (!check_format_string (argument, format_num, flags, no_add_attrs))
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
|
if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
|
|| (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
|
|| (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
|
!= char_type_node))
|
!= char_type_node))
|
{
|
{
|
if (!(flags & (int) ATTR_FLAG_BUILT_IN))
|
if (!(flags & (int) ATTR_FLAG_BUILT_IN))
|
error ("function does not return string type");
|
error ("function does not return string type");
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Verify that the format_num argument is actually a string, in case
|
/* Verify that the format_num argument is actually a string, in case
|
the format attribute is in error. */
|
the format attribute is in error. */
|
static bool
|
static bool
|
check_format_string (tree argument, unsigned HOST_WIDE_INT format_num,
|
check_format_string (tree argument, unsigned HOST_WIDE_INT format_num,
|
int flags, bool *no_add_attrs)
|
int flags, bool *no_add_attrs)
|
{
|
{
|
unsigned HOST_WIDE_INT i;
|
unsigned HOST_WIDE_INT i;
|
|
|
for (i = 1; i != format_num; i++)
|
for (i = 1; i != format_num; i++)
|
{
|
{
|
if (argument == 0)
|
if (argument == 0)
|
break;
|
break;
|
argument = TREE_CHAIN (argument);
|
argument = TREE_CHAIN (argument);
|
}
|
}
|
|
|
if (!argument
|
if (!argument
|
|| TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
|
|| TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
|
|| (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
|
|| (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
|
!= char_type_node))
|
!= char_type_node))
|
{
|
{
|
if (!(flags & (int) ATTR_FLAG_BUILT_IN))
|
if (!(flags & (int) ATTR_FLAG_BUILT_IN))
|
error ("format string argument not a string type");
|
error ("format string argument not a string type");
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
return false;
|
return false;
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Verify EXPR is a constant, and store its value.
|
/* Verify EXPR is a constant, and store its value.
|
If validated_p is true there should be no errors.
|
If validated_p is true there should be no errors.
|
Returns true on success, false otherwise. */
|
Returns true on success, false otherwise. */
|
static bool
|
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)
|
{
|
{
|
if (TREE_CODE (expr) != INTEGER_CST || TREE_INT_CST_HIGH (expr) != 0)
|
if (TREE_CODE (expr) != INTEGER_CST || TREE_INT_CST_HIGH (expr) != 0)
|
{
|
{
|
gcc_assert (!validated_p);
|
gcc_assert (!validated_p);
|
return false;
|
return false;
|
}
|
}
|
|
|
*value = TREE_INT_CST_LOW (expr);
|
*value = TREE_INT_CST_LOW (expr);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Decode the arguments to a "format" attribute into a
|
/* Decode the arguments to a "format" attribute into a
|
function_format_info structure. It is already known that the list
|
function_format_info structure. It is already known that the list
|
is of the right length. If VALIDATED_P is true, then these
|
is of the right length. If VALIDATED_P is true, then these
|
attributes have already been validated and must not be erroneous;
|
attributes have already been validated and must not be erroneous;
|
if false, it will give an error message. Returns true if the
|
if false, it will give an error message. Returns true if the
|
attributes are successfully decoded, false otherwise. */
|
attributes are successfully decoded, false otherwise. */
|
|
|
static bool
|
static bool
|
decode_format_attr (tree args, function_format_info *info, int validated_p)
|
decode_format_attr (tree args, function_format_info *info, int validated_p)
|
{
|
{
|
tree format_type_id = TREE_VALUE (args);
|
tree format_type_id = TREE_VALUE (args);
|
tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
|
tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
|
tree first_arg_num_expr
|
tree first_arg_num_expr
|
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
|
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
|
|
|
if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
|
if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
|
{
|
{
|
gcc_assert (!validated_p);
|
gcc_assert (!validated_p);
|
error ("unrecognized format specifier");
|
error ("unrecognized format specifier");
|
return false;
|
return false;
|
}
|
}
|
else
|
else
|
{
|
{
|
const char *p = IDENTIFIER_POINTER (format_type_id);
|
const char *p = IDENTIFIER_POINTER (format_type_id);
|
|
|
info->format_type = decode_format_type (p);
|
info->format_type = decode_format_type (p);
|
|
|
if (info->format_type == format_type_error)
|
if (info->format_type == format_type_error)
|
{
|
{
|
gcc_assert (!validated_p);
|
gcc_assert (!validated_p);
|
warning (OPT_Wformat, "%qE is an unrecognized format function type",
|
warning (OPT_Wformat, "%qE is an unrecognized format function type",
|
format_type_id);
|
format_type_id);
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
if (!get_constant (format_num_expr, &info->format_num, validated_p))
|
if (!get_constant (format_num_expr, &info->format_num, validated_p))
|
{
|
{
|
error ("format string has invalid operand number");
|
error ("format string has invalid operand number");
|
return false;
|
return false;
|
}
|
}
|
|
|
if (!get_constant (first_arg_num_expr, &info->first_arg_num, 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;
|
return false;
|
}
|
}
|
|
|
if (info->first_arg_num != 0 && info->first_arg_num <= info->format_num)
|
if (info->first_arg_num != 0 && info->first_arg_num <= info->format_num)
|
{
|
{
|
gcc_assert (!validated_p);
|
gcc_assert (!validated_p);
|
error ("format string argument follows the args to be formatted");
|
error ("format string argument follows the args to be formatted");
|
return false;
|
return false;
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Check a call to a format function against a parameter list. */
|
/* Check a call to a format function against a parameter list. */
|
|
|
/* The C standard version C++ is treated as equivalent to
|
/* The C standard version C++ is treated as equivalent to
|
or inheriting from, for the purpose of format features supported. */
|
or inheriting from, for the purpose of format features supported. */
|
#define CPLUSPLUS_STD_VER STD_C94
|
#define CPLUSPLUS_STD_VER STD_C94
|
/* The C standard version we are checking formats against when pedantic. */
|
/* The C standard version we are checking formats against when pedantic. */
|
#define C_STD_VER ((int) (c_dialect_cxx () \
|
#define C_STD_VER ((int) (c_dialect_cxx () \
|
? CPLUSPLUS_STD_VER \
|
? CPLUSPLUS_STD_VER \
|
: (flag_isoc99 \
|
: (flag_isoc99 \
|
? STD_C99 \
|
? STD_C99 \
|
: (flag_isoc94 ? STD_C94 : STD_C89))))
|
: (flag_isoc94 ? STD_C94 : STD_C89))))
|
/* The name to give to the standard version we are warning about when
|
/* 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
|
pedantic. FEATURE_VER is the version in which the feature warned out
|
appeared, which is higher than C_STD_VER. */
|
appeared, which is higher than C_STD_VER. */
|
#define C_STD_NAME(FEATURE_VER) (c_dialect_cxx () \
|
#define C_STD_NAME(FEATURE_VER) (c_dialect_cxx () \
|
? "ISO C++" \
|
? "ISO C++" \
|
: ((FEATURE_VER) == STD_EXT \
|
: ((FEATURE_VER) == STD_EXT \
|
? "ISO C" \
|
? "ISO C" \
|
: "ISO C90"))
|
: "ISO C90"))
|
/* Adjust a C standard version, which may be STD_C9L, to account for
|
/* Adjust a C standard version, which may be STD_C9L, to account for
|
-Wno-long-long. Returns other standard versions unchanged. */
|
-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) \
|
? (warn_long_long ? STD_C99 : STD_C89) \
|
: (VER)))
|
: (VER)))
|
|
|
/* Structure describing details of a type expected in format checking,
|
/* Structure describing details of a type expected in format checking,
|
and the type to check against it. */
|
and the type to check against it. */
|
typedef struct format_wanted_type
|
typedef struct format_wanted_type
|
{
|
{
|
/* The type wanted. */
|
/* The type wanted. */
|
tree wanted_type;
|
tree wanted_type;
|
/* The name of this type to use in diagnostics. */
|
/* The name of this type to use in diagnostics. */
|
const char *wanted_type_name;
|
const char *wanted_type_name;
|
/* The level of indirection through pointers at which this type occurs. */
|
/* The level of indirection through pointers at which this type occurs. */
|
int pointer_count;
|
int pointer_count;
|
/* Whether, when pointer_count is 1, to allow any character type when
|
/* Whether, when pointer_count is 1, to allow any character type when
|
pedantic, rather than just the character or void type specified. */
|
pedantic, rather than just the character or void type specified. */
|
int char_lenient_flag;
|
int char_lenient_flag;
|
/* Whether the argument, dereferenced once, is written into and so the
|
/* Whether the argument, dereferenced once, is written into and so the
|
argument must not be a pointer to a const-qualified type. */
|
argument must not be a pointer to a const-qualified type. */
|
int writing_in_flag;
|
int writing_in_flag;
|
/* Whether the argument, dereferenced once, is read from and so
|
/* Whether the argument, dereferenced once, is read from and so
|
must not be a NULL pointer. */
|
must not be a NULL pointer. */
|
int reading_from_flag;
|
int reading_from_flag;
|
/* If warnings should be of the form "field precision should have
|
/* If warnings should be of the form "field precision should have
|
type 'int'", the name to use (in this case "field precision"),
|
type 'int'", the name to use (in this case "field precision"),
|
otherwise NULL, for "format expects type 'long'" type
|
otherwise NULL, for "format expects type 'long'" type
|
messages. */
|
messages. */
|
const char *name;
|
const char *name;
|
/* The actual parameter to check against the wanted type. */
|
/* The actual parameter to check against the wanted type. */
|
tree param;
|
tree param;
|
/* The argument number of that parameter. */
|
/* The argument number of that parameter. */
|
int arg_num;
|
int arg_num;
|
/* The next type to check for this format conversion, or NULL if none. */
|
/* The next type to check for this format conversion, or NULL if none. */
|
struct format_wanted_type *next;
|
struct format_wanted_type *next;
|
} format_wanted_type;
|
} format_wanted_type;
|
|
|
|
|
static const format_length_info printf_length_specs[] =
|
static const format_length_info printf_length_specs[] =
|
{
|
{
|
{ "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
|
{ "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
|
{ "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
|
{ "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
|
{ "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
|
{ "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
|
{ "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
|
{ "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
|
{ "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
|
{ "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
|
{ "Z", FMT_LEN_z, STD_EXT, NULL, 0, 0 },
|
{ "Z", FMT_LEN_z, STD_EXT, NULL, 0, 0 },
|
{ "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
|
{ "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
|
{ "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
|
{ "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
|
{ "H", FMT_LEN_H, STD_EXT, NULL, 0, 0 },
|
{ "H", FMT_LEN_H, STD_EXT, NULL, 0, 0 },
|
{ "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT },
|
{ "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT },
|
{ NULL, 0, 0, NULL, 0, 0 }
|
{ NULL, 0, 0, NULL, 0, 0 }
|
};
|
};
|
|
|
/* Length specifiers valid for asm_fprintf. */
|
/* Length specifiers valid for asm_fprintf. */
|
static const format_length_info asm_fprintf_length_specs[] =
|
static const format_length_info asm_fprintf_length_specs[] =
|
{
|
{
|
{ "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
|
{ "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
|
{ "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
|
{ "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
|
{ NULL, 0, 0, NULL, 0, 0 }
|
{ NULL, 0, 0, NULL, 0, 0 }
|
};
|
};
|
|
|
/* Length specifiers valid for GCC diagnostics. */
|
/* Length specifiers valid for GCC diagnostics. */
|
static const format_length_info gcc_diag_length_specs[] =
|
static const format_length_info gcc_diag_length_specs[] =
|
{
|
{
|
{ "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
|
{ "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
|
{ "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
|
{ "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
|
{ NULL, 0, 0, NULL, 0, 0 }
|
{ NULL, 0, 0, NULL, 0, 0 }
|
};
|
};
|
|
|
/* The custom diagnostics all accept the same length specifiers. */
|
/* The custom diagnostics all accept the same length specifiers. */
|
#define gcc_tdiag_length_specs gcc_diag_length_specs
|
#define gcc_tdiag_length_specs gcc_diag_length_specs
|
#define gcc_cdiag_length_specs gcc_diag_length_specs
|
#define gcc_cdiag_length_specs gcc_diag_length_specs
|
#define gcc_cxxdiag_length_specs gcc_diag_length_specs
|
#define gcc_cxxdiag_length_specs gcc_diag_length_specs
|
|
|
/* This differs from printf_length_specs only in that "Z" is not accepted. */
|
/* This differs from printf_length_specs only in that "Z" is not accepted. */
|
static const format_length_info scanf_length_specs[] =
|
static const format_length_info scanf_length_specs[] =
|
{
|
{
|
{ "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
|
{ "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
|
{ "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
|
{ "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
|
{ "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
|
{ "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
|
{ "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
|
{ "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
|
{ "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
|
{ "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
|
{ "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
|
{ "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
|
{ "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
|
{ "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
|
{ "H", FMT_LEN_H, STD_EXT, NULL, 0, 0 },
|
{ "H", FMT_LEN_H, STD_EXT, NULL, 0, 0 },
|
{ "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT },
|
{ "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT },
|
{ NULL, 0, 0, NULL, 0, 0 }
|
{ NULL, 0, 0, NULL, 0, 0 }
|
};
|
};
|
|
|
|
|
/* All tables for strfmon use STD_C89 everywhere, since -pedantic warnings
|
/* All tables for strfmon use STD_C89 everywhere, since -pedantic warnings
|
make no sense for a format type not part of any C standard version. */
|
make no sense for a format type not part of any C standard version. */
|
static const format_length_info strfmon_length_specs[] =
|
static const format_length_info strfmon_length_specs[] =
|
{
|
{
|
/* A GNU extension. */
|
/* A GNU extension. */
|
{ "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
|
{ "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
|
{ NULL, 0, 0, NULL, 0, 0 }
|
{ NULL, 0, 0, NULL, 0, 0 }
|
};
|
};
|
|
|
static const format_flag_spec printf_flag_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, 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, 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_EXT },
|
{ '\'', 0, 0, N_("''' flag"), N_("the ''' printf flag"), STD_EXT },
|
{ 'I', 0, 0, N_("'I' flag"), N_("the 'I' 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 },
|
{ '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 },
|
{ '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 },
|
{ 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
|
{ 0, 0, 0, NULL, NULL, 0 }
|
{ 0, 0, 0, NULL, NULL, 0 }
|
};
|
};
|
|
|
|
|
static const format_flag_pair printf_flag_pairs[] =
|
static const format_flag_pair printf_flag_pairs[] =
|
{
|
{
|
{ ' ', '+', 1, 0 },
|
{ ' ', '+', 1, 0 },
|
{ '0', '-', 1, 0 },
|
{ '0', '-', 1, 0 },
|
{ '0', 'p', 1, 'i' },
|
{ '0', 'p', 1, 'i' },
|
{ 0, 0, 0, 0 }
|
{ 0, 0, 0, 0 }
|
};
|
};
|
|
|
static const format_flag_spec asm_fprintf_flag_specs[] =
|
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, 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, 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 },
|
{ 'w', 0, 0, N_("field width"), N_("field width in printf format"), 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 },
|
{ '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 },
|
{ 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
|
{ 0, 0, 0, NULL, NULL, 0 }
|
{ 0, 0, 0, NULL, NULL, 0 }
|
};
|
};
|
|
|
static const format_flag_pair asm_fprintf_flag_pairs[] =
|
static const format_flag_pair asm_fprintf_flag_pairs[] =
|
{
|
{
|
{ ' ', '+', 1, 0 },
|
{ ' ', '+', 1, 0 },
|
{ '0', '-', 1, 0 },
|
{ '0', '-', 1, 0 },
|
{ '0', 'p', 1, 'i' },
|
{ '0', 'p', 1, 'i' },
|
{ 0, 0, 0, 0 }
|
{ 0, 0, 0, 0 }
|
};
|
};
|
|
|
static const format_flag_pair gcc_diag_flag_pairs[] =
|
static const format_flag_pair gcc_diag_flag_pairs[] =
|
{
|
{
|
{ 0, 0, 0, 0 }
|
{ 0, 0, 0, 0 }
|
};
|
};
|
|
|
#define gcc_tdiag_flag_pairs gcc_diag_flag_pairs
|
#define gcc_tdiag_flag_pairs gcc_diag_flag_pairs
|
#define gcc_cdiag_flag_pairs gcc_diag_flag_pairs
|
#define gcc_cdiag_flag_pairs gcc_diag_flag_pairs
|
#define gcc_cxxdiag_flag_pairs gcc_diag_flag_pairs
|
#define gcc_cxxdiag_flag_pairs gcc_diag_flag_pairs
|
|
|
static const format_flag_pair gcc_gfc_flag_pairs[] =
|
static const format_flag_pair gcc_gfc_flag_pairs[] =
|
{
|
{
|
{ 0, 0, 0, 0 }
|
{ 0, 0, 0, 0 }
|
};
|
};
|
|
|
static const format_flag_spec gcc_diag_flag_specs[] =
|
static const format_flag_spec gcc_diag_flag_specs[] =
|
{
|
{
|
{ '+', 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 },
|
{ '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 },
|
{ '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 },
|
{ 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
|
{ 0, 0, 0, NULL, NULL, 0 }
|
{ 0, 0, 0, NULL, NULL, 0 }
|
};
|
};
|
|
|
#define gcc_tdiag_flag_specs gcc_diag_flag_specs
|
#define gcc_tdiag_flag_specs gcc_diag_flag_specs
|
#define gcc_cdiag_flag_specs gcc_diag_flag_specs
|
#define gcc_cdiag_flag_specs gcc_diag_flag_specs
|
|
|
static const format_flag_spec gcc_cxxdiag_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 },
|
{ '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 },
|
{ '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 },
|
{ 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
|
{ 0, 0, 0, NULL, NULL, 0 }
|
{ 0, 0, 0, NULL, NULL, 0 }
|
};
|
};
|
|
|
static const format_flag_spec scanf_flag_specs[] =
|
static const format_flag_spec scanf_flag_specs[] =
|
{
|
{
|
{ '*', 0, 0, N_("assignment suppression"), N_("the assignment suppression scanf feature"), STD_C89 },
|
{ '*', 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 },
|
{ '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 },
|
{ 'L', 0, 0, N_("length modifier"), N_("length modifier in scanf format"), STD_C89 },
|
{ '\'', 0, 0, N_("''' flag"), N_("the ''' 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 },
|
{ 'I', 0, 0, N_("'I' flag"), N_("the 'I' scanf flag"), STD_EXT },
|
{ 0, 0, 0, NULL, NULL, 0 }
|
{ 0, 0, 0, NULL, NULL, 0 }
|
};
|
};
|
|
|
|
|
static const format_flag_pair scanf_flag_pairs[] =
|
static const format_flag_pair scanf_flag_pairs[] =
|
{
|
{
|
{ '*', 'L', 0, 0 },
|
{ '*', 'L', 0, 0 },
|
{ 0, 0, 0, 0 }
|
{ 0, 0, 0, 0 }
|
};
|
};
|
|
|
|
|
static const format_flag_spec strftime_flag_specs[] =
|
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, 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, 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 },
|
{ 'w', 0, 0, N_("field width"), N_("field width in strftime format"), 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 },
|
{ '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', 0, 0, N_("'O' modifier"), N_("the 'O' strftime modifier"), STD_C99 },
|
{ 'O', 'o', 0, NULL, N_("the 'O' modifier"), STD_EXT },
|
{ 'O', 'o', 0, NULL, N_("the 'O' modifier"), STD_EXT },
|
{ 0, 0, 0, NULL, NULL, 0 }
|
{ 0, 0, 0, NULL, NULL, 0 }
|
};
|
};
|
|
|
|
|
static const format_flag_pair strftime_flag_pairs[] =
|
static const format_flag_pair strftime_flag_pairs[] =
|
{
|
{
|
{ 'E', 'O', 0, 0 },
|
{ 'E', 'O', 0, 0 },
|
{ '_', '-', 0, 0 },
|
{ '_', '-', 0, 0 },
|
{ '_', '0', 0, 0 },
|
{ '_', '0', 0, 0 },
|
{ '-', '0', 0, 0 },
|
{ '-', '0', 0, 0 },
|
{ '^', '#', 0, 0 },
|
{ '^', '#', 0, 0 },
|
{ 0, 0, 0, 0 }
|
{ 0, 0, 0, 0 }
|
};
|
};
|
|
|
|
|
static const format_flag_spec strfmon_flag_specs[] =
|
static const format_flag_spec strfmon_flag_specs[] =
|
{
|
{
|
{ '=', 0, 1, N_("fill character"), N_("fill character in strfmon format"), STD_C89 },
|
{ '=', 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 },
|
{ '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 },
|
{ '#', 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 },
|
{ 'p', 0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89 },
|
{ 'L', 0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89 },
|
{ 'L', 0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89 },
|
{ 0, 0, 0, NULL, NULL, 0 }
|
{ 0, 0, 0, NULL, NULL, 0 }
|
};
|
};
|
|
|
static const format_flag_pair strfmon_flag_pairs[] =
|
static const format_flag_pair strfmon_flag_pairs[] =
|
{
|
{
|
{ '+', '(', 0, 0 },
|
{ '+', '(', 0, 0 },
|
{ 0, 0, 0, 0 }
|
{ 0, 0, 0, 0 }
|
};
|
};
|
|
|
|
|
static const format_char_info print_char_table[] =
|
static const format_char_info print_char_table[] =
|
{
|
{
|
/* C89 conversion specifiers. */
|
/* 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, BADLEN, BADLEN, BADLEN }, "-wp0 +'I", "i", NULL },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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. */
|
/* C99 conversion specifiers. */
|
{ "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 },
|
{ "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 },
|
{ "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. */
|
/* X/Open conversion specifiers. */
|
{ "C", 0, STD_EXT, { TEX_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "", NULL },
|
{ "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 },
|
{ "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "R", NULL },
|
/* GNU conversion specifiers. */
|
/* GNU conversion specifiers. */
|
{ "m", 0, STD_EXT, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "", NULL },
|
{ "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 }
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
};
|
};
|
|
|
static const format_char_info asm_fprintf_char_table[] =
|
static const format_char_info asm_fprintf_char_table[] =
|
{
|
{
|
/* C89 conversion specifiers. */
|
/* C89 conversion specifiers. */
|
{ "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0 +", "i", NULL },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "cR", NULL },
|
|
|
/* asm_fprintf conversion specifiers. */
|
/* asm_fprintf conversion specifiers. */
|
{ "O", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "O", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "R", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "R", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "I", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "I", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "L", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "L", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "U", 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 },
|
{ "r", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "", NULL },
|
{ "@", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "@", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
};
|
};
|
|
|
static const format_char_info gcc_diag_char_table[] =
|
static const format_char_info gcc_diag_char_table[] =
|
{
|
{
|
/* C89 conversion specifiers. */
|
/* C89 conversion specifiers. */
|
{ "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "c", NULL },
|
|
|
/* Custom conversion specifiers. */
|
/* Custom conversion specifiers. */
|
|
|
/* %H will require "location_t" at runtime. */
|
/* %H will require "location_t" at runtime. */
|
{ "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
{ "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. */
|
/* These will require a "tree" at runtime. */
|
{ "J", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
{ "J", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
|
|
{ "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL },
|
{ "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL },
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
};
|
};
|
|
|
static const format_char_info gcc_tdiag_char_table[] =
|
static const format_char_info gcc_tdiag_char_table[] =
|
{
|
{
|
/* C89 conversion specifiers. */
|
/* C89 conversion specifiers. */
|
{ "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "c", NULL },
|
|
|
/* Custom conversion specifiers. */
|
/* Custom conversion specifiers. */
|
|
|
/* %H will require "location_t" at runtime. */
|
/* %H will require "location_t" at runtime. */
|
{ "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
{ "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
|
|
/* These will require a "tree" at runtime. */
|
/* These will require a "tree" at runtime. */
|
{ "DFJT", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q+", "", NULL },
|
{ "DFJT", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q+", "", NULL },
|
|
|
{ "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL },
|
{ "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL },
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
};
|
};
|
|
|
static const format_char_info gcc_cdiag_char_table[] =
|
static const format_char_info gcc_cdiag_char_table[] =
|
{
|
{
|
/* C89 conversion specifiers. */
|
/* C89 conversion specifiers. */
|
{ "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "c", NULL },
|
|
|
/* Custom conversion specifiers. */
|
/* Custom conversion specifiers. */
|
|
|
/* %H will require "location_t" at runtime. */
|
/* %H will require "location_t" at runtime. */
|
{ "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
{ "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. */
|
/* These will require a "tree" at runtime. */
|
{ "DEFJT", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q+", "", NULL },
|
{ "DEFJT", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q+", "", NULL },
|
|
|
{ "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL },
|
{ "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL },
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
};
|
};
|
|
|
static const format_char_info gcc_cxxdiag_char_table[] =
|
static const format_char_info gcc_cxxdiag_char_table[] =
|
{
|
{
|
/* C89 conversion specifiers. */
|
/* C89 conversion specifiers. */
|
{ "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "c", NULL },
|
|
|
/* Custom conversion specifiers. */
|
/* Custom conversion specifiers. */
|
|
|
/* %H will require "location_t" at runtime. */
|
/* %H will require "location_t" at runtime. */
|
{ "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
{ "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. */
|
/* These will require a "tree" at runtime. */
|
{ "ADEFJTV",0,STD_C89,{ T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q+#", "", NULL },
|
{ "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'.) */
|
/* 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 },
|
{ "CLOPQ",0,STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
|
|
|
{ "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL },
|
{ "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL },
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
};
|
};
|
|
|
static const format_char_info gcc_gfc_char_table[] =
|
static const format_char_info gcc_gfc_char_table[] =
|
{
|
{
|
/* C89 conversion specifiers. */
|
/* C89 conversion specifiers. */
|
{ "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "", NULL },
|
{ "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 },
|
{ "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 },
|
{ "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "cR", NULL },
|
|
|
/* gfc conversion specifiers. */
|
/* gfc conversion specifiers. */
|
|
|
{ "C", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
{ "C", 0, STD_C89, NOARGUMENTS, "", "", NULL },
|
|
|
/* This will require a "locus" at runtime. */
|
/* This will require a "locus" at runtime. */
|
{ "L", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "R", NULL },
|
{ "L", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "R", NULL },
|
|
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
};
|
};
|
|
|
static const format_char_info scan_char_table[] =
|
static const format_char_info scan_char_table[] =
|
{
|
{
|
/* C89 conversion specifiers. */
|
/* 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, BADLEN, BADLEN, BADLEN }, "*w'I", "W", NULL },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "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 },
|
{ "[", 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 },
|
{ "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 },
|
{ "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. */
|
/* C99 conversion specifiers. */
|
{ "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 },
|
{ "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 },
|
{ "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. */
|
/* X/Open conversion specifiers. */
|
{ "C", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W", 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 },
|
{ "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 }
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
};
|
};
|
|
|
static const format_char_info time_char_table[] =
|
static const format_char_info time_char_table[] =
|
{
|
{
|
/* C89 conversion specifiers. */
|
/* C89 conversion specifiers. */
|
{ "ABZab", 0, STD_C89, NOLENGTHS, "^#", "", NULL },
|
{ "ABZab", 0, STD_C89, NOLENGTHS, "^#", "", NULL },
|
{ "cx", 0, STD_C89, NOLENGTHS, "E", "3", NULL },
|
{ "cx", 0, STD_C89, NOLENGTHS, "E", "3", NULL },
|
{ "HIMSUWdmw", 0, STD_C89, NOLENGTHS, "-_0Ow", "", NULL },
|
{ "HIMSUWdmw", 0, STD_C89, NOLENGTHS, "-_0Ow", "", NULL },
|
{ "j", 0, STD_C89, NOLENGTHS, "-_0Ow", "o", NULL },
|
{ "j", 0, STD_C89, NOLENGTHS, "-_0Ow", "o", NULL },
|
{ "p", 0, STD_C89, NOLENGTHS, "#", "", NULL },
|
{ "p", 0, STD_C89, NOLENGTHS, "#", "", NULL },
|
{ "X", 0, STD_C89, NOLENGTHS, "E", "", NULL },
|
{ "X", 0, STD_C89, NOLENGTHS, "E", "", NULL },
|
{ "y", 0, STD_C89, NOLENGTHS, "EO-_0w", "4", NULL },
|
{ "y", 0, STD_C89, NOLENGTHS, "EO-_0w", "4", NULL },
|
{ "Y", 0, STD_C89, NOLENGTHS, "-_0EOw", "o", NULL },
|
{ "Y", 0, STD_C89, NOLENGTHS, "-_0EOw", "o", NULL },
|
{ "%", 0, STD_C89, NOLENGTHS, "", "", NULL },
|
{ "%", 0, STD_C89, NOLENGTHS, "", "", NULL },
|
/* C99 conversion specifiers. */
|
/* C99 conversion specifiers. */
|
{ "C", 0, STD_C99, NOLENGTHS, "-_0EOw", "o", NULL },
|
{ "C", 0, STD_C99, NOLENGTHS, "-_0EOw", "o", NULL },
|
{ "D", 0, STD_C99, NOLENGTHS, "", "2", NULL },
|
{ "D", 0, STD_C99, NOLENGTHS, "", "2", NULL },
|
{ "eVu", 0, STD_C99, NOLENGTHS, "-_0Ow", "", NULL },
|
{ "eVu", 0, STD_C99, NOLENGTHS, "-_0Ow", "", NULL },
|
{ "FRTnrt", 0, STD_C99, NOLENGTHS, "", "", NULL },
|
{ "FRTnrt", 0, STD_C99, NOLENGTHS, "", "", NULL },
|
{ "g", 0, STD_C99, NOLENGTHS, "O-_0w", "2o", NULL },
|
{ "g", 0, STD_C99, NOLENGTHS, "O-_0w", "2o", NULL },
|
{ "G", 0, STD_C99, NOLENGTHS, "-_0Ow", "o", NULL },
|
{ "G", 0, STD_C99, NOLENGTHS, "-_0Ow", "o", NULL },
|
{ "h", 0, STD_C99, NOLENGTHS, "^#", "", NULL },
|
{ "h", 0, STD_C99, NOLENGTHS, "^#", "", NULL },
|
{ "z", 0, STD_C99, NOLENGTHS, "O", "o", NULL },
|
{ "z", 0, STD_C99, NOLENGTHS, "O", "o", NULL },
|
/* GNU conversion specifiers. */
|
/* GNU conversion specifiers. */
|
{ "kls", 0, STD_EXT, NOLENGTHS, "-_0Ow", "", NULL },
|
{ "kls", 0, STD_EXT, NOLENGTHS, "-_0Ow", "", NULL },
|
{ "P", 0, STD_EXT, NOLENGTHS, "", "", NULL },
|
{ "P", 0, STD_EXT, NOLENGTHS, "", "", NULL },
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
};
|
};
|
|
|
static const format_char_info monetary_char_table[] =
|
static const format_char_info monetary_char_table[] =
|
{
|
{
|
{ "in", 0, STD_C89, { T89_D, BADLEN, BADLEN, BADLEN, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "=^+(!-w#p", "", 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 }
|
{ NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
|
};
|
};
|
|
|
/* This must be in the same order as enum format_type. */
|
/* This must be in the same order as enum format_type. */
|
static const format_kind_info format_types_orig[] =
|
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,
|
printf_flag_specs, printf_flag_pairs,
|
FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_EMPTY_PREC_OK,
|
FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_EMPTY_PREC_OK,
|
'w', 0, 'p', 0, 'L',
|
'w', 0, 'p', 0, 'L',
|
&integer_type_node, &integer_type_node
|
&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,
|
asm_fprintf_flag_specs, asm_fprintf_flag_pairs,
|
FMT_FLAG_ARG_CONVERT|FMT_FLAG_EMPTY_PREC_OK,
|
FMT_FLAG_ARG_CONVERT|FMT_FLAG_EMPTY_PREC_OK,
|
'w', 0, 'p', 0, 'L',
|
'w', 0, 'p', 0, 'L',
|
NULL, NULL
|
NULL, NULL
|
},
|
},
|
{ "gcc_diag", gcc_diag_length_specs, gcc_diag_char_table, "q+", NULL,
|
{ "gcc_diag", gcc_diag_length_specs, gcc_diag_char_table, "q+", NULL,
|
gcc_diag_flag_specs, gcc_diag_flag_pairs,
|
gcc_diag_flag_specs, gcc_diag_flag_pairs,
|
FMT_FLAG_ARG_CONVERT,
|
FMT_FLAG_ARG_CONVERT,
|
0, 0, 'p', 0, 'L',
|
0, 0, 'p', 0, 'L',
|
NULL, &integer_type_node
|
NULL, &integer_type_node
|
},
|
},
|
{ "gcc_tdiag", gcc_tdiag_length_specs, gcc_tdiag_char_table, "q+", NULL,
|
{ "gcc_tdiag", gcc_tdiag_length_specs, gcc_tdiag_char_table, "q+", NULL,
|
gcc_tdiag_flag_specs, gcc_tdiag_flag_pairs,
|
gcc_tdiag_flag_specs, gcc_tdiag_flag_pairs,
|
FMT_FLAG_ARG_CONVERT,
|
FMT_FLAG_ARG_CONVERT,
|
0, 0, 'p', 0, 'L',
|
0, 0, 'p', 0, 'L',
|
NULL, &integer_type_node
|
NULL, &integer_type_node
|
},
|
},
|
{ "gcc_cdiag", gcc_cdiag_length_specs, gcc_cdiag_char_table, "q+", NULL,
|
{ "gcc_cdiag", gcc_cdiag_length_specs, gcc_cdiag_char_table, "q+", NULL,
|
gcc_cdiag_flag_specs, gcc_cdiag_flag_pairs,
|
gcc_cdiag_flag_specs, gcc_cdiag_flag_pairs,
|
FMT_FLAG_ARG_CONVERT,
|
FMT_FLAG_ARG_CONVERT,
|
0, 0, 'p', 0, 'L',
|
0, 0, 'p', 0, 'L',
|
NULL, &integer_type_node
|
NULL, &integer_type_node
|
},
|
},
|
{ "gcc_cxxdiag", gcc_cxxdiag_length_specs, gcc_cxxdiag_char_table, "q+#", NULL,
|
{ "gcc_cxxdiag", gcc_cxxdiag_length_specs, gcc_cxxdiag_char_table, "q+#", NULL,
|
gcc_cxxdiag_flag_specs, gcc_cxxdiag_flag_pairs,
|
gcc_cxxdiag_flag_specs, gcc_cxxdiag_flag_pairs,
|
FMT_FLAG_ARG_CONVERT,
|
FMT_FLAG_ARG_CONVERT,
|
0, 0, 'p', 0, 'L',
|
0, 0, 'p', 0, 'L',
|
NULL, &integer_type_node
|
NULL, &integer_type_node
|
},
|
},
|
{ "gcc_gfc", NULL, gcc_gfc_char_table, "", NULL,
|
{ "gcc_gfc", NULL, gcc_gfc_char_table, "", NULL,
|
NULL, gcc_gfc_flag_pairs,
|
NULL, gcc_gfc_flag_pairs,
|
FMT_FLAG_ARG_CONVERT,
|
FMT_FLAG_ARG_CONVERT,
|
0, 0, 0, 0, 0,
|
0, 0, 0, 0, 0,
|
NULL, NULL
|
NULL, NULL
|
},
|
},
|
{ "scanf", scanf_length_specs, scan_char_table, "*'I", NULL,
|
{ "scanf", scanf_length_specs, scan_char_table, "*'I", NULL,
|
scanf_flag_specs, scanf_flag_pairs,
|
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,
|
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',
|
'w', 0, 0, '*', 'L',
|
NULL, NULL
|
NULL, NULL
|
},
|
},
|
{ "strftime", NULL, time_char_table, "_-0^#", "EO",
|
{ "strftime", NULL, time_char_table, "_-0^#", "EO",
|
strftime_flag_specs, strftime_flag_pairs,
|
strftime_flag_specs, strftime_flag_pairs,
|
FMT_FLAG_FANCY_PERCENT_OK, 'w', 0, 0, 0, 0,
|
FMT_FLAG_FANCY_PERCENT_OK, 'w', 0, 0, 0, 0,
|
NULL, NULL
|
NULL, NULL
|
},
|
},
|
{ "strfmon", strfmon_length_specs, monetary_char_table, "=^+(!-", NULL,
|
{ "strfmon", strfmon_length_specs, monetary_char_table, "=^+(!-", NULL,
|
strfmon_flag_specs, strfmon_flag_pairs,
|
strfmon_flag_specs, strfmon_flag_pairs,
|
FMT_FLAG_ARG_CONVERT, 'w', '#', 'p', 0, 'L',
|
FMT_FLAG_ARG_CONVERT, 'w', '#', 'p', 0, 'L',
|
NULL, NULL
|
NULL, NULL
|
}
|
}
|
};
|
};
|
|
|
/* This layer of indirection allows GCC to reassign format_types with
|
/* This layer of indirection allows GCC to reassign format_types with
|
new data if necessary, while still allowing the original data to be
|
new data if necessary, while still allowing the original data to be
|
const. */
|
const. */
|
static const format_kind_info *format_types = format_types_orig;
|
static const format_kind_info *format_types = format_types_orig;
|
/* We can modify this one. We also add target-specific format types
|
/* We can modify this one. We also add target-specific format types
|
to the end of the array. */
|
to the end of the array. */
|
static format_kind_info *dynamic_format_types;
|
static format_kind_info *dynamic_format_types;
|
|
|
static int n_format_types = ARRAY_SIZE (format_types_orig);
|
static int n_format_types = ARRAY_SIZE (format_types_orig);
|
|
|
/* Structure detailing the results of checking a format function call
|
/* Structure detailing the results of checking a format function call
|
where the format expression may be a conditional expression with
|
where the format expression may be a conditional expression with
|
many leaves resulting from nested conditional expressions. */
|
many leaves resulting from nested conditional expressions. */
|
typedef struct
|
typedef struct
|
{
|
{
|
/* Number of leaves of the format argument that could not be checked
|
/* Number of leaves of the format argument that could not be checked
|
as they were not string literals. */
|
as they were not string literals. */
|
int number_non_literal;
|
int number_non_literal;
|
/* Number of leaves of the format argument that were null pointers or
|
/* Number of leaves of the format argument that were null pointers or
|
string literals, but had extra format arguments. */
|
string literals, but had extra format arguments. */
|
int number_extra_args;
|
int number_extra_args;
|
/* Number of leaves of the format argument that were null pointers or
|
/* Number of leaves of the format argument that were null pointers or
|
string literals, but had extra format arguments and used $ operand
|
string literals, but had extra format arguments and used $ operand
|
numbers. */
|
numbers. */
|
int number_dollar_extra_args;
|
int number_dollar_extra_args;
|
/* Number of leaves of the format argument that were wide string
|
/* Number of leaves of the format argument that were wide string
|
literals. */
|
literals. */
|
int number_wide;
|
int number_wide;
|
/* Number of leaves of the format argument that were empty strings. */
|
/* Number of leaves of the format argument that were empty strings. */
|
int number_empty;
|
int number_empty;
|
/* Number of leaves of the format argument that were unterminated
|
/* Number of leaves of the format argument that were unterminated
|
strings. */
|
strings. */
|
int number_unterminated;
|
int number_unterminated;
|
/* Number of leaves of the format argument that were not counted above. */
|
/* Number of leaves of the format argument that were not counted above. */
|
int number_other;
|
int number_other;
|
} format_check_results;
|
} format_check_results;
|
|
|
typedef struct
|
typedef struct
|
{
|
{
|
format_check_results *res;
|
format_check_results *res;
|
function_format_info *info;
|
function_format_info *info;
|
tree params;
|
tree params;
|
} format_check_context;
|
} format_check_context;
|
|
|
static void check_format_info (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_arg (void *, tree, unsigned HOST_WIDE_INT);
|
static void check_format_info_main (format_check_results *,
|
static void check_format_info_main (format_check_results *,
|
function_format_info *,
|
function_format_info *,
|
const char *, int, tree,
|
const char *, int, tree,
|
unsigned HOST_WIDE_INT);
|
unsigned HOST_WIDE_INT);
|
|
|
static void init_dollar_format_checking (int, tree);
|
static void init_dollar_format_checking (int, tree);
|
static int maybe_read_dollar_number (const char **, int,
|
static int maybe_read_dollar_number (const char **, int,
|
tree, tree *, const format_kind_info *);
|
tree, tree *, const format_kind_info *);
|
static bool avoid_dollar_number (const char *);
|
static bool avoid_dollar_number (const char *);
|
static void finish_dollar_format_checking (format_check_results *, int);
|
static void finish_dollar_format_checking (format_check_results *, int);
|
|
|
static const format_flag_spec *get_flag_spec (const format_flag_spec *,
|
static const format_flag_spec *get_flag_spec (const format_flag_spec *,
|
int, const char *);
|
int, const char *);
|
|
|
static void check_format_types (format_wanted_type *, const char *, int);
|
static void check_format_types (format_wanted_type *, const char *, int);
|
static void format_type_warning (const char *, const char *, int, tree,
|
static void format_type_warning (const char *, const char *, int, tree,
|
int, const char *, tree, int);
|
int, const char *, tree, int);
|
|
|
/* Decode a format type from a string, returning the type, or
|
/* 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
|
format_type_error if not valid, in which case the caller should print an
|
error message. */
|
error message. */
|
static int
|
static int
|
decode_format_type (const char *s)
|
decode_format_type (const char *s)
|
{
|
{
|
int i;
|
int i;
|
int slen;
|
int slen;
|
slen = strlen (s);
|
slen = strlen (s);
|
for (i = 0; i < n_format_types; i++)
|
for (i = 0; i < n_format_types; i++)
|
{
|
{
|
int alen;
|
int alen;
|
if (!strcmp (s, format_types[i].name))
|
if (!strcmp (s, format_types[i].name))
|
return i;
|
return i;
|
alen = strlen (format_types[i].name);
|
alen = strlen (format_types[i].name);
|
if (slen == alen + 4 && s[0] == '_' && s[1] == '_'
|
if (slen == alen + 4 && s[0] == '_' && s[1] == '_'
|
&& s[slen - 1] == '_' && s[slen - 2] == '_'
|
&& s[slen - 1] == '_' && s[slen - 2] == '_'
|
&& !strncmp (s + 2, format_types[i].name, alen))
|
&& !strncmp (s + 2, format_types[i].name, alen))
|
return i;
|
return i;
|
}
|
}
|
return format_type_error;
|
return format_type_error;
|
}
|
}
|
|
|
|
|
/* Check the argument list of a call to printf, scanf, etc.
|
/* Check the argument list of a call to printf, scanf, etc.
|
ATTRS are the attributes on the function type.
|
ATTRS are the attributes on the function type.
|
PARAMS is the list of argument values. Also, if -Wmissing-format-attribute,
|
PARAMS is the list of argument values. Also, if -Wmissing-format-attribute,
|
warn for calls to vprintf or vscanf in functions with no such format
|
warn for calls to vprintf or vscanf in functions with no such format
|
attribute themselves. */
|
attribute themselves. */
|
|
|
void
|
void
|
check_function_format (tree attrs, tree params)
|
check_function_format (tree attrs, tree params)
|
{
|
{
|
tree a;
|
tree a;
|
|
|
/* See if this function has any format attributes. */
|
/* See if this function has any format attributes. */
|
for (a = attrs; a; a = TREE_CHAIN (a))
|
for (a = attrs; a; a = TREE_CHAIN (a))
|
{
|
{
|
if (is_attribute_p ("format", TREE_PURPOSE (a)))
|
if (is_attribute_p ("format", TREE_PURPOSE (a)))
|
{
|
{
|
/* Yup; check it. */
|
/* Yup; check it. */
|
function_format_info info;
|
function_format_info info;
|
decode_format_attr (TREE_VALUE (a), &info, 1);
|
decode_format_attr (TREE_VALUE (a), &info, 1);
|
if (warn_format)
|
if (warn_format)
|
check_format_info (&info, params);
|
check_format_info (&info, params);
|
if (warn_missing_format_attribute && info.first_arg_num == 0
|
if (warn_missing_format_attribute && info.first_arg_num == 0
|
&& (format_types[info.format_type].flags
|
&& (format_types[info.format_type].flags
|
& (int) FMT_FLAG_ARG_CONVERT))
|
& (int) FMT_FLAG_ARG_CONVERT))
|
{
|
{
|
tree c;
|
tree c;
|
for (c = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
|
for (c = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
|
c;
|
c;
|
c = TREE_CHAIN (c))
|
c = TREE_CHAIN (c))
|
if (is_attribute_p ("format", TREE_PURPOSE (c))
|
if (is_attribute_p ("format", TREE_PURPOSE (c))
|
&& (decode_format_type (IDENTIFIER_POINTER
|
&& (decode_format_type (IDENTIFIER_POINTER
|
(TREE_VALUE (TREE_VALUE (c))))
|
(TREE_VALUE (TREE_VALUE (c))))
|
== info.format_type))
|
== info.format_type))
|
break;
|
break;
|
if (c == NULL_TREE)
|
if (c == NULL_TREE)
|
{
|
{
|
/* Check if the current function has a parameter to which
|
/* Check if the current function has a parameter to which
|
the format attribute could be attached; if not, it
|
the format attribute could be attached; if not, it
|
can't be a candidate for a format attribute, despite
|
can't be a candidate for a format attribute, despite
|
the vprintf-like or vscanf-like call. */
|
the vprintf-like or vscanf-like call. */
|
tree args;
|
tree args;
|
for (args = DECL_ARGUMENTS (current_function_decl);
|
for (args = DECL_ARGUMENTS (current_function_decl);
|
args != 0;
|
args != 0;
|
args = TREE_CHAIN (args))
|
args = TREE_CHAIN (args))
|
{
|
{
|
if (TREE_CODE (TREE_TYPE (args)) == POINTER_TYPE
|
if (TREE_CODE (TREE_TYPE (args)) == POINTER_TYPE
|
&& (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (args)))
|
&& (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (args)))
|
== char_type_node))
|
== char_type_node))
|
break;
|
break;
|
}
|
}
|
if (args != 0)
|
if (args != 0)
|
warning (OPT_Wmissing_format_attribute, "function might "
|
warning (OPT_Wmissing_format_attribute, "function might "
|
"be possible candidate for %qs format attribute",
|
"be possible candidate for %qs format attribute",
|
format_types[info.format_type].name);
|
format_types[info.format_type].name);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Variables used by the checking of $ operand number formats. */
|
/* Variables used by the checking of $ operand number formats. */
|
static char *dollar_arguments_used = NULL;
|
static char *dollar_arguments_used = NULL;
|
static char *dollar_arguments_pointer_p = NULL;
|
static char *dollar_arguments_pointer_p = NULL;
|
static int dollar_arguments_alloc = 0;
|
static int dollar_arguments_alloc = 0;
|
static int dollar_arguments_count;
|
static int dollar_arguments_count;
|
static int dollar_first_arg_num;
|
static int dollar_first_arg_num;
|
static int dollar_max_arg_used;
|
static int dollar_max_arg_used;
|
static int dollar_format_warned;
|
static int dollar_format_warned;
|
|
|
/* Initialize the checking for a format string that may contain $
|
/* Initialize the checking for a format string that may contain $
|
parameter number specifications; we will need to keep track of whether
|
parameter number specifications; we will need to keep track of whether
|
each parameter has been used. FIRST_ARG_NUM is the number of the first
|
each parameter has been used. FIRST_ARG_NUM is the number of the first
|
argument that is a parameter to the format, or 0 for a vprintf-style
|
argument that is a parameter to the format, or 0 for a vprintf-style
|
function; PARAMS is the list of arguments starting at this argument. */
|
function; PARAMS is the list of arguments starting at this argument. */
|
|
|
static void
|
static void
|
init_dollar_format_checking (int first_arg_num, tree params)
|
init_dollar_format_checking (int first_arg_num, tree params)
|
{
|
{
|
tree oparams = params;
|
tree oparams = params;
|
|
|
dollar_first_arg_num = first_arg_num;
|
dollar_first_arg_num = first_arg_num;
|
dollar_arguments_count = 0;
|
dollar_arguments_count = 0;
|
dollar_max_arg_used = 0;
|
dollar_max_arg_used = 0;
|
dollar_format_warned = 0;
|
dollar_format_warned = 0;
|
if (first_arg_num > 0)
|
if (first_arg_num > 0)
|
{
|
{
|
while (params)
|
while (params)
|
{
|
{
|
dollar_arguments_count++;
|
dollar_arguments_count++;
|
params = TREE_CHAIN (params);
|
params = TREE_CHAIN (params);
|
}
|
}
|
}
|
}
|
if (dollar_arguments_alloc < dollar_arguments_count)
|
if (dollar_arguments_alloc < dollar_arguments_count)
|
{
|
{
|
if (dollar_arguments_used)
|
if (dollar_arguments_used)
|
free (dollar_arguments_used);
|
free (dollar_arguments_used);
|
if (dollar_arguments_pointer_p)
|
if (dollar_arguments_pointer_p)
|
free (dollar_arguments_pointer_p);
|
free (dollar_arguments_pointer_p);
|
dollar_arguments_alloc = dollar_arguments_count;
|
dollar_arguments_alloc = dollar_arguments_count;
|
dollar_arguments_used = XNEWVEC (char, dollar_arguments_alloc);
|
dollar_arguments_used = XNEWVEC (char, dollar_arguments_alloc);
|
dollar_arguments_pointer_p = XNEWVEC (char, dollar_arguments_alloc);
|
dollar_arguments_pointer_p = XNEWVEC (char, dollar_arguments_alloc);
|
}
|
}
|
if (dollar_arguments_alloc)
|
if (dollar_arguments_alloc)
|
{
|
{
|
memset (dollar_arguments_used, 0, dollar_arguments_alloc);
|
memset (dollar_arguments_used, 0, dollar_arguments_alloc);
|
if (first_arg_num > 0)
|
if (first_arg_num > 0)
|
{
|
{
|
int i = 0;
|
int i = 0;
|
params = oparams;
|
params = oparams;
|
while (params)
|
while (params)
|
{
|
{
|
dollar_arguments_pointer_p[i] = (TREE_CODE (TREE_TYPE (TREE_VALUE (params)))
|
dollar_arguments_pointer_p[i] = (TREE_CODE (TREE_TYPE (TREE_VALUE (params)))
|
== POINTER_TYPE);
|
== POINTER_TYPE);
|
params = TREE_CHAIN (params);
|
params = TREE_CHAIN (params);
|
i++;
|
i++;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Look for a decimal number followed by a $ in *FORMAT. If DOLLAR_NEEDED
|
/* Look for a decimal number followed by a $ in *FORMAT. If DOLLAR_NEEDED
|
is set, it is an error if one is not found; otherwise, it is OK. If
|
is set, it is an error if one is not found; otherwise, it is OK. If
|
such a number is found, check whether it is within range and mark that
|
such a number is found, check whether it is within range and mark that
|
numbered operand as being used for later checking. Returns the operand
|
numbered operand as being used for later checking. Returns the operand
|
number if found and within range, zero if no such number was found and
|
number if found and within range, zero if no such number was found and
|
this is OK, or -1 on error. PARAMS points to the first operand of the
|
this is OK, or -1 on error. PARAMS points to the first operand of the
|
format; PARAM_PTR is made to point to the parameter referred to. If
|
format; PARAM_PTR is made to point to the parameter referred to. If
|
a $ format is found, *FORMAT is updated to point just after it. */
|
a $ format is found, *FORMAT is updated to point just after it. */
|
|
|
static int
|
static int
|
maybe_read_dollar_number (const char **format,
|
maybe_read_dollar_number (const char **format,
|
int dollar_needed, tree params, tree *param_ptr,
|
int dollar_needed, tree params, tree *param_ptr,
|
const format_kind_info *fki)
|
const format_kind_info *fki)
|
{
|
{
|
int argnum;
|
int argnum;
|
int overflow_flag;
|
int overflow_flag;
|
const char *fcp = *format;
|
const char *fcp = *format;
|
if (!ISDIGIT (*fcp))
|
if (!ISDIGIT (*fcp))
|
{
|
{
|
if (dollar_needed)
|
if (dollar_needed)
|
{
|
{
|
warning (OPT_Wformat, "missing $ operand number in format");
|
warning (OPT_Wformat, "missing $ operand number in format");
|
return -1;
|
return -1;
|
}
|
}
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
argnum = 0;
|
argnum = 0;
|
overflow_flag = 0;
|
overflow_flag = 0;
|
while (ISDIGIT (*fcp))
|
while (ISDIGIT (*fcp))
|
{
|
{
|
int nargnum;
|
int nargnum;
|
nargnum = 10 * argnum + (*fcp - '0');
|
nargnum = 10 * argnum + (*fcp - '0');
|
if (nargnum < 0 || nargnum / 10 != argnum)
|
if (nargnum < 0 || nargnum / 10 != argnum)
|
overflow_flag = 1;
|
overflow_flag = 1;
|
argnum = nargnum;
|
argnum = nargnum;
|
fcp++;
|
fcp++;
|
}
|
}
|
if (*fcp != '$')
|
if (*fcp != '$')
|
{
|
{
|
if (dollar_needed)
|
if (dollar_needed)
|
{
|
{
|
warning (OPT_Wformat, "missing $ operand number in format");
|
warning (OPT_Wformat, "missing $ operand number in format");
|
return -1;
|
return -1;
|
}
|
}
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
*format = fcp + 1;
|
*format = fcp + 1;
|
if (pedantic && !dollar_format_warned)
|
if (pedantic && !dollar_format_warned)
|
{
|
{
|
warning (OPT_Wformat, "%s does not support %%n$ operand number formats",
|
warning (OPT_Wformat, "%s does not support %%n$ operand number formats",
|
C_STD_NAME (STD_EXT));
|
C_STD_NAME (STD_EXT));
|
dollar_format_warned = 1;
|
dollar_format_warned = 1;
|
}
|
}
|
if (overflow_flag || argnum == 0
|
if (overflow_flag || argnum == 0
|
|| (dollar_first_arg_num && argnum > dollar_arguments_count))
|
|| (dollar_first_arg_num && argnum > dollar_arguments_count))
|
{
|
{
|
warning (OPT_Wformat, "operand number out of range in format");
|
warning (OPT_Wformat, "operand number out of range in format");
|
return -1;
|
return -1;
|
}
|
}
|
if (argnum > dollar_max_arg_used)
|
if (argnum > dollar_max_arg_used)
|
dollar_max_arg_used = argnum;
|
dollar_max_arg_used = argnum;
|
/* For vprintf-style functions we may need to allocate more memory to
|
/* For vprintf-style functions we may need to allocate more memory to
|
track which arguments are used. */
|
track which arguments are used. */
|
while (dollar_arguments_alloc < dollar_max_arg_used)
|
while (dollar_arguments_alloc < dollar_max_arg_used)
|
{
|
{
|
int nalloc;
|
int nalloc;
|
nalloc = 2 * dollar_arguments_alloc + 16;
|
nalloc = 2 * dollar_arguments_alloc + 16;
|
dollar_arguments_used = XRESIZEVEC (char, dollar_arguments_used,
|
dollar_arguments_used = XRESIZEVEC (char, dollar_arguments_used,
|
nalloc);
|
nalloc);
|
dollar_arguments_pointer_p = XRESIZEVEC (char, dollar_arguments_pointer_p,
|
dollar_arguments_pointer_p = XRESIZEVEC (char, dollar_arguments_pointer_p,
|
nalloc);
|
nalloc);
|
memset (dollar_arguments_used + dollar_arguments_alloc, 0,
|
memset (dollar_arguments_used + dollar_arguments_alloc, 0,
|
nalloc - dollar_arguments_alloc);
|
nalloc - dollar_arguments_alloc);
|
dollar_arguments_alloc = nalloc;
|
dollar_arguments_alloc = nalloc;
|
}
|
}
|
if (!(fki->flags & (int) FMT_FLAG_DOLLAR_MULTIPLE)
|
if (!(fki->flags & (int) FMT_FLAG_DOLLAR_MULTIPLE)
|
&& dollar_arguments_used[argnum - 1] == 1)
|
&& dollar_arguments_used[argnum - 1] == 1)
|
{
|
{
|
dollar_arguments_used[argnum - 1] = 2;
|
dollar_arguments_used[argnum - 1] = 2;
|
warning (OPT_Wformat, "format argument %d used more than once in %s format",
|
warning (OPT_Wformat, "format argument %d used more than once in %s format",
|
argnum, fki->name);
|
argnum, fki->name);
|
}
|
}
|
else
|
else
|
dollar_arguments_used[argnum - 1] = 1;
|
dollar_arguments_used[argnum - 1] = 1;
|
if (dollar_first_arg_num)
|
if (dollar_first_arg_num)
|
{
|
{
|
int i;
|
int i;
|
*param_ptr = params;
|
*param_ptr = params;
|
for (i = 1; i < argnum && *param_ptr != 0; i++)
|
for (i = 1; i < argnum && *param_ptr != 0; i++)
|
*param_ptr = TREE_CHAIN (*param_ptr);
|
*param_ptr = TREE_CHAIN (*param_ptr);
|
|
|
/* This case shouldn't be caught here. */
|
/* This case shouldn't be caught here. */
|
gcc_assert (*param_ptr);
|
gcc_assert (*param_ptr);
|
}
|
}
|
else
|
else
|
*param_ptr = 0;
|
*param_ptr = 0;
|
return argnum;
|
return argnum;
|
}
|
}
|
|
|
/* Ensure that FORMAT does not start with a decimal number followed by
|
/* Ensure that FORMAT does not start with a decimal number followed by
|
a $; give a diagnostic and return true if it does, false otherwise. */
|
a $; give a diagnostic and return true if it does, false otherwise. */
|
|
|
static bool
|
static bool
|
avoid_dollar_number (const char *format)
|
avoid_dollar_number (const char *format)
|
{
|
{
|
if (!ISDIGIT (*format))
|
if (!ISDIGIT (*format))
|
return false;
|
return false;
|
while (ISDIGIT (*format))
|
while (ISDIGIT (*format))
|
format++;
|
format++;
|
if (*format == '$')
|
if (*format == '$')
|
{
|
{
|
warning (OPT_Wformat, "$ operand number used after format without operand number");
|
warning (OPT_Wformat, "$ operand number used after format without operand number");
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Finish the checking for a format string that used $ operand number formats
|
/* Finish the checking for a format string that used $ operand number formats
|
instead of non-$ formats. We check for unused operands before used ones
|
instead of non-$ formats. We check for unused operands before used ones
|
(a serious error, since the implementation of the format function
|
(a serious error, since the implementation of the format function
|
can't know what types to pass to va_arg to find the later arguments).
|
can't know what types to pass to va_arg to find the later arguments).
|
and for unused operands at the end of the format (if we know how many
|
and for unused operands at the end of the format (if we know how many
|
arguments the format had, so not for vprintf). If there were operand
|
arguments the format had, so not for vprintf). If there were operand
|
numbers out of range on a non-vprintf-style format, we won't have reached
|
numbers out of range on a non-vprintf-style format, we won't have reached
|
here. If POINTER_GAP_OK, unused arguments are OK if all arguments are
|
here. If POINTER_GAP_OK, unused arguments are OK if all arguments are
|
pointers. */
|
pointers. */
|
|
|
static void
|
static void
|
finish_dollar_format_checking (format_check_results *res, int pointer_gap_ok)
|
finish_dollar_format_checking (format_check_results *res, int pointer_gap_ok)
|
{
|
{
|
int i;
|
int i;
|
bool found_pointer_gap = false;
|
bool found_pointer_gap = false;
|
for (i = 0; i < dollar_max_arg_used; i++)
|
for (i = 0; i < dollar_max_arg_used; i++)
|
{
|
{
|
if (!dollar_arguments_used[i])
|
if (!dollar_arguments_used[i])
|
{
|
{
|
if (pointer_gap_ok && (dollar_first_arg_num == 0
|
if (pointer_gap_ok && (dollar_first_arg_num == 0
|
|| dollar_arguments_pointer_p[i]))
|
|| dollar_arguments_pointer_p[i]))
|
found_pointer_gap = true;
|
found_pointer_gap = true;
|
else
|
else
|
warning (OPT_Wformat,
|
warning (OPT_Wformat,
|
"format argument %d unused before used argument %d in $-style format",
|
"format argument %d unused before used argument %d in $-style format",
|
i + 1, dollar_max_arg_used);
|
i + 1, dollar_max_arg_used);
|
}
|
}
|
}
|
}
|
if (found_pointer_gap
|
if (found_pointer_gap
|
|| (dollar_first_arg_num
|
|| (dollar_first_arg_num
|
&& dollar_max_arg_used < dollar_arguments_count))
|
&& dollar_max_arg_used < dollar_arguments_count))
|
{
|
{
|
res->number_other--;
|
res->number_other--;
|
res->number_dollar_extra_args++;
|
res->number_dollar_extra_args++;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Retrieve the specification for a format flag. SPEC contains the
|
/* Retrieve the specification for a format flag. SPEC contains the
|
specifications for format flags for the applicable kind of format.
|
specifications for format flags for the applicable kind of format.
|
FLAG is the flag in question. If PREDICATES is NULL, the basic
|
FLAG is the flag in question. If PREDICATES is NULL, the basic
|
spec for that flag must be retrieved and must exist. If
|
spec for that flag must be retrieved and must exist. If
|
PREDICATES is not NULL, it is a string listing possible predicates
|
PREDICATES is not NULL, it is a string listing possible predicates
|
for the spec entry; if an entry predicated on any of these is
|
for the spec entry; if an entry predicated on any of these is
|
found, it is returned, otherwise NULL is returned. */
|
found, it is returned, otherwise NULL is returned. */
|
|
|
static const format_flag_spec *
|
static const format_flag_spec *
|
get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
|
get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
|
{
|
{
|
int i;
|
int i;
|
for (i = 0; spec[i].flag_char != 0; i++)
|
for (i = 0; spec[i].flag_char != 0; i++)
|
{
|
{
|
if (spec[i].flag_char != flag)
|
if (spec[i].flag_char != flag)
|
continue;
|
continue;
|
if (predicates != NULL)
|
if (predicates != NULL)
|
{
|
{
|
if (spec[i].predicate != 0
|
if (spec[i].predicate != 0
|
&& strchr (predicates, spec[i].predicate) != 0)
|
&& strchr (predicates, spec[i].predicate) != 0)
|
return &spec[i];
|
return &spec[i];
|
}
|
}
|
else if (spec[i].predicate == 0)
|
else if (spec[i].predicate == 0)
|
return &spec[i];
|
return &spec[i];
|
}
|
}
|
gcc_assert (predicates);
|
gcc_assert (predicates);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
|
|
/* Check the argument list of a call to printf, scanf, etc.
|
/* Check the argument list of a call to printf, scanf, etc.
|
INFO points to the function_format_info structure.
|
INFO points to the function_format_info structure.
|
PARAMS is the list of argument values. */
|
PARAMS is the list of argument values. */
|
|
|
static void
|
static void
|
check_format_info (function_format_info *info, tree params)
|
check_format_info (function_format_info *info, tree params)
|
{
|
{
|
format_check_context format_ctx;
|
format_check_context format_ctx;
|
unsigned HOST_WIDE_INT arg_num;
|
unsigned HOST_WIDE_INT arg_num;
|
tree format_tree;
|
tree format_tree;
|
format_check_results res;
|
format_check_results res;
|
/* Skip to format argument. If the argument isn't available, there's
|
/* Skip to format argument. If the argument isn't available, there's
|
no work for us to do; prototype checking will catch the problem. */
|
no work for us to do; prototype checking will catch the problem. */
|
for (arg_num = 1; ; ++arg_num)
|
for (arg_num = 1; ; ++arg_num)
|
{
|
{
|
if (params == 0)
|
if (params == 0)
|
return;
|
return;
|
if (arg_num == info->format_num)
|
if (arg_num == info->format_num)
|
break;
|
break;
|
params = TREE_CHAIN (params);
|
params = TREE_CHAIN (params);
|
}
|
}
|
format_tree = TREE_VALUE (params);
|
format_tree = TREE_VALUE (params);
|
params = TREE_CHAIN (params);
|
params = TREE_CHAIN (params);
|
if (format_tree == 0)
|
if (format_tree == 0)
|
return;
|
return;
|
|
|
res.number_non_literal = 0;
|
res.number_non_literal = 0;
|
res.number_extra_args = 0;
|
res.number_extra_args = 0;
|
res.number_dollar_extra_args = 0;
|
res.number_dollar_extra_args = 0;
|
res.number_wide = 0;
|
res.number_wide = 0;
|
res.number_empty = 0;
|
res.number_empty = 0;
|
res.number_unterminated = 0;
|
res.number_unterminated = 0;
|
res.number_other = 0;
|
res.number_other = 0;
|
|
|
format_ctx.res = &res;
|
format_ctx.res = &res;
|
format_ctx.info = info;
|
format_ctx.info = info;
|
format_ctx.params = params;
|
format_ctx.params = params;
|
|
|
check_function_arguments_recurse (check_format_arg, &format_ctx,
|
check_function_arguments_recurse (check_format_arg, &format_ctx,
|
format_tree, arg_num);
|
format_tree, arg_num);
|
|
|
if (res.number_non_literal > 0)
|
if (res.number_non_literal > 0)
|
{
|
{
|
/* Functions taking a va_list normally pass a non-literal format
|
/* Functions taking a va_list normally pass a non-literal format
|
string. These functions typically are declared with
|
string. These functions typically are declared with
|
first_arg_num == 0, so avoid warning in those cases. */
|
first_arg_num == 0, so avoid warning in those cases. */
|
if (!(format_types[info->format_type].flags & (int) FMT_FLAG_ARG_CONVERT))
|
if (!(format_types[info->format_type].flags & (int) FMT_FLAG_ARG_CONVERT))
|
{
|
{
|
/* For strftime-like formats, warn for not checking the format
|
/* For strftime-like formats, warn for not checking the format
|
string; but there are no arguments to check. */
|
string; but there are no arguments to check. */
|
warning (OPT_Wformat_nonliteral,
|
warning (OPT_Wformat_nonliteral,
|
"format not a string literal, format string not checked");
|
"format not a string literal, format string not checked");
|
}
|
}
|
else if (info->first_arg_num != 0)
|
else if (info->first_arg_num != 0)
|
{
|
{
|
/* If there are no arguments for the format at all, we may have
|
/* If there are no arguments for the format at all, we may have
|
printf (foo) which is likely to be a security hole. */
|
printf (foo) which is likely to be a security hole. */
|
while (arg_num + 1 < info->first_arg_num)
|
while (arg_num + 1 < info->first_arg_num)
|
{
|
{
|
if (params == 0)
|
if (params == 0)
|
break;
|
break;
|
params = TREE_CHAIN (params);
|
params = TREE_CHAIN (params);
|
++arg_num;
|
++arg_num;
|
}
|
}
|
if (params == 0 && warn_format_security)
|
if (params == 0 && warn_format_security)
|
warning (OPT_Wformat_security,
|
warning (OPT_Wformat_security,
|
"format not a string literal and no format arguments");
|
"format not a string literal and no format arguments");
|
else if (params == 0 && warn_format_nonliteral)
|
else if (params == 0 && warn_format_nonliteral)
|
warning (OPT_Wformat_nonliteral,
|
warning (OPT_Wformat_nonliteral,
|
"format not a string literal and no format arguments");
|
"format not a string literal and no format arguments");
|
else
|
else
|
warning (OPT_Wformat_nonliteral,
|
warning (OPT_Wformat_nonliteral,
|
"format not a string literal, argument types not checked");
|
"format not a string literal, argument types not checked");
|
}
|
}
|
}
|
}
|
|
|
/* If there were extra arguments to the format, normally warn. However,
|
/* If there were extra arguments to the format, normally warn. However,
|
the standard does say extra arguments are ignored, so in the specific
|
the standard does say extra arguments are ignored, so in the specific
|
case where we have multiple leaves (conditional expressions or
|
case where we have multiple leaves (conditional expressions or
|
ngettext) allow extra arguments if at least one leaf didn't have extra
|
ngettext) allow extra arguments if at least one leaf didn't have extra
|
arguments, but was otherwise OK (either non-literal or checked OK).
|
arguments, but was otherwise OK (either non-literal or checked OK).
|
If the format is an empty string, this should be counted similarly to the
|
If the format is an empty string, this should be counted similarly to the
|
case of extra format arguments. */
|
case of extra format arguments. */
|
if (res.number_extra_args > 0 && res.number_non_literal == 0
|
if (res.number_extra_args > 0 && res.number_non_literal == 0
|
&& res.number_other == 0)
|
&& res.number_other == 0)
|
warning (OPT_Wformat_extra_args, "too many arguments for format");
|
warning (OPT_Wformat_extra_args, "too many arguments for format");
|
if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
|
if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
|
&& res.number_other == 0)
|
&& res.number_other == 0)
|
warning (OPT_Wformat_extra_args, "unused arguments in $-style format");
|
warning (OPT_Wformat_extra_args, "unused arguments in $-style format");
|
if (res.number_empty > 0 && res.number_non_literal == 0
|
if (res.number_empty > 0 && res.number_non_literal == 0
|
&& res.number_other == 0)
|
&& res.number_other == 0)
|
warning (OPT_Wformat_zero_length, "zero-length %s format string",
|
warning (OPT_Wformat_zero_length, "zero-length %s format string",
|
format_types[info->format_type].name);
|
format_types[info->format_type].name);
|
|
|
if (res.number_wide > 0)
|
if (res.number_wide > 0)
|
warning (OPT_Wformat, "format is a wide character string");
|
warning (OPT_Wformat, "format is a wide character string");
|
|
|
if (res.number_unterminated > 0)
|
if (res.number_unterminated > 0)
|
warning (OPT_Wformat, "unterminated format string");
|
warning (OPT_Wformat, "unterminated format string");
|
}
|
}
|
|
|
/* Callback from check_function_arguments_recurse to check a
|
/* Callback from check_function_arguments_recurse to check a
|
format string. FORMAT_TREE is the format parameter. ARG_NUM
|
format string. FORMAT_TREE is the format parameter. ARG_NUM
|
is the number of the format argument. CTX points to a
|
is the number of the format argument. CTX points to a
|
format_check_context. */
|
format_check_context. */
|
|
|
static void
|
static void
|
check_format_arg (void *ctx, tree format_tree,
|
check_format_arg (void *ctx, tree format_tree,
|
unsigned HOST_WIDE_INT arg_num)
|
unsigned HOST_WIDE_INT arg_num)
|
{
|
{
|
format_check_context *format_ctx = (format_check_context *) ctx;
|
format_check_context *format_ctx = (format_check_context *) ctx;
|
format_check_results *res = format_ctx->res;
|
format_check_results *res = format_ctx->res;
|
function_format_info *info = format_ctx->info;
|
function_format_info *info = format_ctx->info;
|
tree params = format_ctx->params;
|
tree params = format_ctx->params;
|
|
|
int format_length;
|
int format_length;
|
HOST_WIDE_INT offset;
|
HOST_WIDE_INT offset;
|
const char *format_chars;
|
const char *format_chars;
|
tree array_size = 0;
|
tree array_size = 0;
|
tree array_init;
|
tree array_init;
|
|
|
if (integer_zerop (format_tree))
|
if (integer_zerop (format_tree))
|
{
|
{
|
/* Skip to first argument to check, so we can see if this format
|
/* Skip to first argument to check, so we can see if this format
|
has any arguments (it shouldn't). */
|
has any arguments (it shouldn't). */
|
while (arg_num + 1 < info->first_arg_num)
|
while (arg_num + 1 < info->first_arg_num)
|
{
|
{
|
if (params == 0)
|
if (params == 0)
|
return;
|
return;
|
params = TREE_CHAIN (params);
|
params = TREE_CHAIN (params);
|
++arg_num;
|
++arg_num;
|
}
|
}
|
|
|
if (params == 0)
|
if (params == 0)
|
res->number_other++;
|
res->number_other++;
|
else
|
else
|
res->number_extra_args++;
|
res->number_extra_args++;
|
|
|
return;
|
return;
|
}
|
}
|
|
|
offset = 0;
|
offset = 0;
|
if (TREE_CODE (format_tree) == PLUS_EXPR)
|
if (TREE_CODE (format_tree) == PLUS_EXPR)
|
{
|
{
|
tree arg0, arg1;
|
tree arg0, arg1;
|
|
|
arg0 = TREE_OPERAND (format_tree, 0);
|
arg0 = TREE_OPERAND (format_tree, 0);
|
arg1 = TREE_OPERAND (format_tree, 1);
|
arg1 = TREE_OPERAND (format_tree, 1);
|
STRIP_NOPS (arg0);
|
STRIP_NOPS (arg0);
|
STRIP_NOPS (arg1);
|
STRIP_NOPS (arg1);
|
if (TREE_CODE (arg1) == INTEGER_CST)
|
if (TREE_CODE (arg1) == INTEGER_CST)
|
format_tree = arg0;
|
format_tree = arg0;
|
else if (TREE_CODE (arg0) == INTEGER_CST)
|
else if (TREE_CODE (arg0) == INTEGER_CST)
|
{
|
{
|
format_tree = arg1;
|
format_tree = arg1;
|
arg1 = arg0;
|
arg1 = arg0;
|
}
|
}
|
else
|
else
|
{
|
{
|
res->number_non_literal++;
|
res->number_non_literal++;
|
return;
|
return;
|
}
|
}
|
if (!host_integerp (arg1, 0)
|
if (!host_integerp (arg1, 0)
|
|| (offset = tree_low_cst (arg1, 0)) < 0)
|
|| (offset = tree_low_cst (arg1, 0)) < 0)
|
{
|
{
|
res->number_non_literal++;
|
res->number_non_literal++;
|
return;
|
return;
|
}
|
}
|
}
|
}
|
if (TREE_CODE (format_tree) != ADDR_EXPR)
|
if (TREE_CODE (format_tree) != ADDR_EXPR)
|
{
|
{
|
res->number_non_literal++;
|
res->number_non_literal++;
|
return;
|
return;
|
}
|
}
|
format_tree = TREE_OPERAND (format_tree, 0);
|
format_tree = TREE_OPERAND (format_tree, 0);
|
if (TREE_CODE (format_tree) == ARRAY_REF
|
if (TREE_CODE (format_tree) == ARRAY_REF
|
&& host_integerp (TREE_OPERAND (format_tree, 1), 0)
|
&& host_integerp (TREE_OPERAND (format_tree, 1), 0)
|
&& (offset += tree_low_cst (TREE_OPERAND (format_tree, 1), 0)) >= 0)
|
&& (offset += tree_low_cst (TREE_OPERAND (format_tree, 1), 0)) >= 0)
|
format_tree = TREE_OPERAND (format_tree, 0);
|
format_tree = TREE_OPERAND (format_tree, 0);
|
if (TREE_CODE (format_tree) == VAR_DECL
|
if (TREE_CODE (format_tree) == VAR_DECL
|
&& TREE_CODE (TREE_TYPE (format_tree)) == ARRAY_TYPE
|
&& TREE_CODE (TREE_TYPE (format_tree)) == ARRAY_TYPE
|
&& (array_init = decl_constant_value (format_tree)) != format_tree
|
&& (array_init = decl_constant_value (format_tree)) != format_tree
|
&& TREE_CODE (array_init) == STRING_CST)
|
&& TREE_CODE (array_init) == STRING_CST)
|
{
|
{
|
/* Extract the string constant initializer. Note that this may include
|
/* Extract the string constant initializer. Note that this may include
|
a trailing NUL character that is not in the array (e.g.
|
a trailing NUL character that is not in the array (e.g.
|
const char a[3] = "foo";). */
|
const char a[3] = "foo";). */
|
array_size = DECL_SIZE_UNIT (format_tree);
|
array_size = DECL_SIZE_UNIT (format_tree);
|
format_tree = array_init;
|
format_tree = array_init;
|
}
|
}
|
if (TREE_CODE (format_tree) != STRING_CST)
|
if (TREE_CODE (format_tree) != STRING_CST)
|
{
|
{
|
res->number_non_literal++;
|
res->number_non_literal++;
|
return;
|
return;
|
}
|
}
|
if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree))) != char_type_node)
|
if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree))) != char_type_node)
|
{
|
{
|
res->number_wide++;
|
res->number_wide++;
|
return;
|
return;
|
}
|
}
|
format_chars = TREE_STRING_POINTER (format_tree);
|
format_chars = TREE_STRING_POINTER (format_tree);
|
format_length = TREE_STRING_LENGTH (format_tree);
|
format_length = TREE_STRING_LENGTH (format_tree);
|
if (array_size != 0)
|
if (array_size != 0)
|
{
|
{
|
/* Variable length arrays can't be initialized. */
|
/* Variable length arrays can't be initialized. */
|
gcc_assert (TREE_CODE (array_size) == INTEGER_CST);
|
gcc_assert (TREE_CODE (array_size) == INTEGER_CST);
|
|
|
if (host_integerp (array_size, 0))
|
if (host_integerp (array_size, 0))
|
{
|
{
|
HOST_WIDE_INT array_size_value = TREE_INT_CST_LOW (array_size);
|
HOST_WIDE_INT array_size_value = TREE_INT_CST_LOW (array_size);
|
if (array_size_value > 0
|
if (array_size_value > 0
|
&& array_size_value == (int) array_size_value
|
&& array_size_value == (int) array_size_value
|
&& format_length > array_size_value)
|
&& format_length > array_size_value)
|
format_length = array_size_value;
|
format_length = array_size_value;
|
}
|
}
|
}
|
}
|
if (offset)
|
if (offset)
|
{
|
{
|
if (offset >= format_length)
|
if (offset >= format_length)
|
{
|
{
|
res->number_non_literal++;
|
res->number_non_literal++;
|
return;
|
return;
|
}
|
}
|
format_chars += offset;
|
format_chars += offset;
|
format_length -= offset;
|
format_length -= offset;
|
}
|
}
|
if (format_length < 1)
|
if (format_length < 1)
|
{
|
{
|
res->number_unterminated++;
|
res->number_unterminated++;
|
return;
|
return;
|
}
|
}
|
if (format_length == 1)
|
if (format_length == 1)
|
{
|
{
|
res->number_empty++;
|
res->number_empty++;
|
return;
|
return;
|
}
|
}
|
if (format_chars[--format_length] != 0)
|
if (format_chars[--format_length] != 0)
|
{
|
{
|
res->number_unterminated++;
|
res->number_unterminated++;
|
return;
|
return;
|
}
|
}
|
|
|
/* Skip to first argument to check. */
|
/* Skip to first argument to check. */
|
while (arg_num + 1 < info->first_arg_num)
|
while (arg_num + 1 < info->first_arg_num)
|
{
|
{
|
if (params == 0)
|
if (params == 0)
|
return;
|
return;
|
params = TREE_CHAIN (params);
|
params = TREE_CHAIN (params);
|
++arg_num;
|
++arg_num;
|
}
|
}
|
/* Provisionally increment res->number_other; check_format_info_main
|
/* Provisionally increment res->number_other; check_format_info_main
|
will decrement it if it finds there are extra arguments, but this way
|
will decrement it if it finds there are extra arguments, but this way
|
need not adjust it for every return. */
|
need not adjust it for every return. */
|
res->number_other++;
|
res->number_other++;
|
check_format_info_main (res, info, format_chars, format_length,
|
check_format_info_main (res, info, format_chars, format_length,
|
params, arg_num);
|
params, arg_num);
|
}
|
}
|
|
|
|
|
/* Do the main part of checking a call to a format function. FORMAT_CHARS
|
/* Do the main part of checking a call to a format function. FORMAT_CHARS
|
is the NUL-terminated format string (which at this point may contain
|
is the NUL-terminated format string (which at this point may contain
|
internal NUL characters); FORMAT_LENGTH is its length (excluding the
|
internal NUL characters); FORMAT_LENGTH is its length (excluding the
|
terminating NUL character). ARG_NUM is one less than the number of
|
terminating NUL character). ARG_NUM is one less than the number of
|
the first format argument to check; PARAMS points to that format
|
the first format argument to check; PARAMS points to that format
|
argument in the list of arguments. */
|
argument in the list of arguments. */
|
|
|
static void
|
static void
|
check_format_info_main (format_check_results *res,
|
check_format_info_main (format_check_results *res,
|
function_format_info *info, const char *format_chars,
|
function_format_info *info, const char *format_chars,
|
int format_length, tree params,
|
int format_length, tree params,
|
unsigned HOST_WIDE_INT arg_num)
|
unsigned HOST_WIDE_INT arg_num)
|
{
|
{
|
const char *orig_format_chars = format_chars;
|
const char *orig_format_chars = format_chars;
|
tree first_fillin_param = params;
|
tree first_fillin_param = params;
|
|
|
const format_kind_info *fki = &format_types[info->format_type];
|
const format_kind_info *fki = &format_types[info->format_type];
|
const format_flag_spec *flag_specs = fki->flag_specs;
|
const format_flag_spec *flag_specs = fki->flag_specs;
|
const format_flag_pair *bad_flag_pairs = fki->bad_flag_pairs;
|
const format_flag_pair *bad_flag_pairs = fki->bad_flag_pairs;
|
|
|
/* -1 if no conversions taking an operand have been found; 0 if one has
|
/* -1 if no conversions taking an operand have been found; 0 if one has
|
and it didn't use $; 1 if $ formats are in use. */
|
and it didn't use $; 1 if $ formats are in use. */
|
int has_operand_number = -1;
|
int has_operand_number = -1;
|
|
|
init_dollar_format_checking (info->first_arg_num, first_fillin_param);
|
init_dollar_format_checking (info->first_arg_num, first_fillin_param);
|
|
|
while (1)
|
while (1)
|
{
|
{
|
int i;
|
int i;
|
int suppressed = FALSE;
|
int suppressed = FALSE;
|
const char *length_chars = NULL;
|
const char *length_chars = NULL;
|
enum format_lengths length_chars_val = FMT_LEN_none;
|
enum format_lengths length_chars_val = FMT_LEN_none;
|
enum format_std_version length_chars_std = STD_C89;
|
enum format_std_version length_chars_std = STD_C89;
|
int format_char;
|
int format_char;
|
tree cur_param;
|
tree cur_param;
|
tree wanted_type;
|
tree wanted_type;
|
int main_arg_num = 0;
|
int main_arg_num = 0;
|
tree main_arg_params = 0;
|
tree main_arg_params = 0;
|
enum format_std_version wanted_type_std;
|
enum format_std_version wanted_type_std;
|
const char *wanted_type_name;
|
const char *wanted_type_name;
|
format_wanted_type width_wanted_type;
|
format_wanted_type width_wanted_type;
|
format_wanted_type precision_wanted_type;
|
format_wanted_type precision_wanted_type;
|
format_wanted_type main_wanted_type;
|
format_wanted_type main_wanted_type;
|
format_wanted_type *first_wanted_type = NULL;
|
format_wanted_type *first_wanted_type = NULL;
|
format_wanted_type *last_wanted_type = NULL;
|
format_wanted_type *last_wanted_type = NULL;
|
const format_length_info *fli = NULL;
|
const format_length_info *fli = NULL;
|
const format_char_info *fci = NULL;
|
const format_char_info *fci = NULL;
|
char flag_chars[256];
|
char flag_chars[256];
|
int aflag = 0;
|
int aflag = 0;
|
const char *format_start = format_chars;
|
const char *format_start = format_chars;
|
if (*format_chars == 0)
|
if (*format_chars == 0)
|
{
|
{
|
if (format_chars - orig_format_chars != format_length)
|
if (format_chars - orig_format_chars != format_length)
|
warning (OPT_Wformat, "embedded %<\\0%> in format");
|
warning (OPT_Wformat, "embedded %<\\0%> in format");
|
if (info->first_arg_num != 0 && params != 0
|
if (info->first_arg_num != 0 && params != 0
|
&& has_operand_number <= 0)
|
&& has_operand_number <= 0)
|
{
|
{
|
res->number_other--;
|
res->number_other--;
|
res->number_extra_args++;
|
res->number_extra_args++;
|
}
|
}
|
if (has_operand_number > 0)
|
if (has_operand_number > 0)
|
finish_dollar_format_checking (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;
|
return;
|
}
|
}
|
if (*format_chars++ != '%')
|
if (*format_chars++ != '%')
|
continue;
|
continue;
|
if (*format_chars == 0)
|
if (*format_chars == 0)
|
{
|
{
|
warning (OPT_Wformat, "spurious trailing %<%%%> in format");
|
warning (OPT_Wformat, "spurious trailing %<%%%> in format");
|
continue;
|
continue;
|
}
|
}
|
if (*format_chars == '%')
|
if (*format_chars == '%')
|
{
|
{
|
++format_chars;
|
++format_chars;
|
continue;
|
continue;
|
}
|
}
|
flag_chars[0] = 0;
|
flag_chars[0] = 0;
|
|
|
if ((fki->flags & (int) FMT_FLAG_USE_DOLLAR) && has_operand_number != 0)
|
if ((fki->flags & (int) FMT_FLAG_USE_DOLLAR) && has_operand_number != 0)
|
{
|
{
|
/* Possibly read a $ operand number at the start of the format.
|
/* Possibly read a $ operand number at the start of the format.
|
If one was previously used, one is required here. If one
|
If one was previously used, one is required here. If one
|
is not used here, we can't immediately conclude this is a
|
is not used here, we can't immediately conclude this is a
|
format without them, since it could be printf %m or scanf %*. */
|
format without them, since it could be printf %m or scanf %*. */
|
int opnum;
|
int opnum;
|
opnum = maybe_read_dollar_number (&format_chars, 0,
|
opnum = maybe_read_dollar_number (&format_chars, 0,
|
first_fillin_param,
|
first_fillin_param,
|
&main_arg_params, fki);
|
&main_arg_params, fki);
|
if (opnum == -1)
|
if (opnum == -1)
|
return;
|
return;
|
else if (opnum > 0)
|
else if (opnum > 0)
|
{
|
{
|
has_operand_number = 1;
|
has_operand_number = 1;
|
main_arg_num = opnum + info->first_arg_num - 1;
|
main_arg_num = opnum + info->first_arg_num - 1;
|
}
|
}
|
}
|
}
|
else if (fki->flags & FMT_FLAG_USE_DOLLAR)
|
else if (fki->flags & FMT_FLAG_USE_DOLLAR)
|
{
|
{
|
if (avoid_dollar_number (format_chars))
|
if (avoid_dollar_number (format_chars))
|
return;
|
return;
|
}
|
}
|
|
|
/* Read any format flags, but do not yet validate them beyond removing
|
/* Read any format flags, but do not yet validate them beyond removing
|
duplicates, since in general validation depends on the rest of
|
duplicates, since in general validation depends on the rest of
|
the format. */
|
the format. */
|
while (*format_chars != 0
|
while (*format_chars != 0
|
&& strchr (fki->flag_chars, *format_chars) != 0)
|
&& strchr (fki->flag_chars, *format_chars) != 0)
|
{
|
{
|
const format_flag_spec *s = get_flag_spec (flag_specs,
|
const format_flag_spec *s = get_flag_spec (flag_specs,
|
*format_chars, NULL);
|
*format_chars, NULL);
|
if (strchr (flag_chars, *format_chars) != 0)
|
if (strchr (flag_chars, *format_chars) != 0)
|
{
|
{
|
warning (OPT_Wformat, "repeated %s in format", _(s->name));
|
warning (OPT_Wformat, "repeated %s in format", _(s->name));
|
}
|
}
|
else
|
else
|
{
|
{
|
i = strlen (flag_chars);
|
i = strlen (flag_chars);
|
flag_chars[i++] = *format_chars;
|
flag_chars[i++] = *format_chars;
|
flag_chars[i] = 0;
|
flag_chars[i] = 0;
|
}
|
}
|
if (s->skip_next_char)
|
if (s->skip_next_char)
|
{
|
{
|
++format_chars;
|
++format_chars;
|
if (*format_chars == 0)
|
if (*format_chars == 0)
|
{
|
{
|
warning (OPT_Wformat, "missing fill character at end of strfmon format");
|
warning (OPT_Wformat, "missing fill character at end of strfmon format");
|
return;
|
return;
|
}
|
}
|
}
|
}
|
++format_chars;
|
++format_chars;
|
}
|
}
|
|
|
/* Read any format width, possibly * or *m$. */
|
/* Read any format width, possibly * or *m$. */
|
if (fki->width_char != 0)
|
if (fki->width_char != 0)
|
{
|
{
|
if (fki->width_type != NULL && *format_chars == '*')
|
if (fki->width_type != NULL && *format_chars == '*')
|
{
|
{
|
i = strlen (flag_chars);
|
i = strlen (flag_chars);
|
flag_chars[i++] = fki->width_char;
|
flag_chars[i++] = fki->width_char;
|
flag_chars[i] = 0;
|
flag_chars[i] = 0;
|
/* "...a field width...may be indicated by an asterisk.
|
/* "...a field width...may be indicated by an asterisk.
|
In this case, an int argument supplies the field width..." */
|
In this case, an int argument supplies the field width..." */
|
++format_chars;
|
++format_chars;
|
if (has_operand_number != 0)
|
if (has_operand_number != 0)
|
{
|
{
|
int opnum;
|
int opnum;
|
opnum = maybe_read_dollar_number (&format_chars,
|
opnum = maybe_read_dollar_number (&format_chars,
|
has_operand_number == 1,
|
has_operand_number == 1,
|
first_fillin_param,
|
first_fillin_param,
|
¶ms, fki);
|
¶ms, fki);
|
if (opnum == -1)
|
if (opnum == -1)
|
return;
|
return;
|
else if (opnum > 0)
|
else if (opnum > 0)
|
{
|
{
|
has_operand_number = 1;
|
has_operand_number = 1;
|
arg_num = opnum + info->first_arg_num - 1;
|
arg_num = opnum + info->first_arg_num - 1;
|
}
|
}
|
else
|
else
|
has_operand_number = 0;
|
has_operand_number = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (avoid_dollar_number (format_chars))
|
if (avoid_dollar_number (format_chars))
|
return;
|
return;
|
}
|
}
|
if (info->first_arg_num != 0)
|
if (info->first_arg_num != 0)
|
{
|
{
|
if (params == 0)
|
if (params == 0)
|
{
|
{
|
warning (OPT_Wformat, "too few arguments for format");
|
warning (OPT_Wformat, "too few arguments for format");
|
return;
|
return;
|
}
|
}
|
cur_param = TREE_VALUE (params);
|
cur_param = TREE_VALUE (params);
|
if (has_operand_number <= 0)
|
if (has_operand_number <= 0)
|
{
|
{
|
params = TREE_CHAIN (params);
|
params = TREE_CHAIN (params);
|
++arg_num;
|
++arg_num;
|
}
|
}
|
width_wanted_type.wanted_type = *fki->width_type;
|
width_wanted_type.wanted_type = *fki->width_type;
|
width_wanted_type.wanted_type_name = NULL;
|
width_wanted_type.wanted_type_name = NULL;
|
width_wanted_type.pointer_count = 0;
|
width_wanted_type.pointer_count = 0;
|
width_wanted_type.char_lenient_flag = 0;
|
width_wanted_type.char_lenient_flag = 0;
|
width_wanted_type.writing_in_flag = 0;
|
width_wanted_type.writing_in_flag = 0;
|
width_wanted_type.reading_from_flag = 0;
|
width_wanted_type.reading_from_flag = 0;
|
width_wanted_type.name = _("field width");
|
width_wanted_type.name = _("field width");
|
width_wanted_type.param = cur_param;
|
width_wanted_type.param = cur_param;
|
width_wanted_type.arg_num = arg_num;
|
width_wanted_type.arg_num = arg_num;
|
width_wanted_type.next = NULL;
|
width_wanted_type.next = NULL;
|
if (last_wanted_type != 0)
|
if (last_wanted_type != 0)
|
last_wanted_type->next = &width_wanted_type;
|
last_wanted_type->next = &width_wanted_type;
|
if (first_wanted_type == 0)
|
if (first_wanted_type == 0)
|
first_wanted_type = &width_wanted_type;
|
first_wanted_type = &width_wanted_type;
|
last_wanted_type = &width_wanted_type;
|
last_wanted_type = &width_wanted_type;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Possibly read a numeric width. If the width is zero,
|
/* Possibly read a numeric width. If the width is zero,
|
we complain if appropriate. */
|
we complain if appropriate. */
|
int non_zero_width_char = FALSE;
|
int non_zero_width_char = FALSE;
|
int found_width = FALSE;
|
int found_width = FALSE;
|
while (ISDIGIT (*format_chars))
|
while (ISDIGIT (*format_chars))
|
{
|
{
|
found_width = TRUE;
|
found_width = TRUE;
|
if (*format_chars != '0')
|
if (*format_chars != '0')
|
non_zero_width_char = TRUE;
|
non_zero_width_char = TRUE;
|
++format_chars;
|
++format_chars;
|
}
|
}
|
if (found_width && !non_zero_width_char &&
|
if (found_width && !non_zero_width_char &&
|
(fki->flags & (int) FMT_FLAG_ZERO_WIDTH_BAD))
|
(fki->flags & (int) FMT_FLAG_ZERO_WIDTH_BAD))
|
warning (OPT_Wformat, "zero width in %s format", fki->name);
|
warning (OPT_Wformat, "zero width in %s format", fki->name);
|
if (found_width)
|
if (found_width)
|
{
|
{
|
i = strlen (flag_chars);
|
i = strlen (flag_chars);
|
flag_chars[i++] = fki->width_char;
|
flag_chars[i++] = fki->width_char;
|
flag_chars[i] = 0;
|
flag_chars[i] = 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Read any format left precision (must be a number, not *). */
|
/* Read any format left precision (must be a number, not *). */
|
if (fki->left_precision_char != 0 && *format_chars == '#')
|
if (fki->left_precision_char != 0 && *format_chars == '#')
|
{
|
{
|
++format_chars;
|
++format_chars;
|
i = strlen (flag_chars);
|
i = strlen (flag_chars);
|
flag_chars[i++] = fki->left_precision_char;
|
flag_chars[i++] = fki->left_precision_char;
|
flag_chars[i] = 0;
|
flag_chars[i] = 0;
|
if (!ISDIGIT (*format_chars))
|
if (!ISDIGIT (*format_chars))
|
warning (OPT_Wformat, "empty left precision in %s format", fki->name);
|
warning (OPT_Wformat, "empty left precision in %s format", fki->name);
|
while (ISDIGIT (*format_chars))
|
while (ISDIGIT (*format_chars))
|
++format_chars;
|
++format_chars;
|
}
|
}
|
|
|
/* Read any format precision, possibly * or *m$. */
|
/* Read any format precision, possibly * or *m$. */
|
if (fki->precision_char != 0 && *format_chars == '.')
|
if (fki->precision_char != 0 && *format_chars == '.')
|
{
|
{
|
++format_chars;
|
++format_chars;
|
i = strlen (flag_chars);
|
i = strlen (flag_chars);
|
flag_chars[i++] = fki->precision_char;
|
flag_chars[i++] = fki->precision_char;
|
flag_chars[i] = 0;
|
flag_chars[i] = 0;
|
if (fki->precision_type != NULL && *format_chars == '*')
|
if (fki->precision_type != NULL && *format_chars == '*')
|
{
|
{
|
/* "...a...precision...may be indicated by an asterisk.
|
/* "...a...precision...may be indicated by an asterisk.
|
In this case, an int argument supplies the...precision." */
|
In this case, an int argument supplies the...precision." */
|
++format_chars;
|
++format_chars;
|
if (has_operand_number != 0)
|
if (has_operand_number != 0)
|
{
|
{
|
int opnum;
|
int opnum;
|
opnum = maybe_read_dollar_number (&format_chars,
|
opnum = maybe_read_dollar_number (&format_chars,
|
has_operand_number == 1,
|
has_operand_number == 1,
|
first_fillin_param,
|
first_fillin_param,
|
¶ms, fki);
|
¶ms, fki);
|
if (opnum == -1)
|
if (opnum == -1)
|
return;
|
return;
|
else if (opnum > 0)
|
else if (opnum > 0)
|
{
|
{
|
has_operand_number = 1;
|
has_operand_number = 1;
|
arg_num = opnum + info->first_arg_num - 1;
|
arg_num = opnum + info->first_arg_num - 1;
|
}
|
}
|
else
|
else
|
has_operand_number = 0;
|
has_operand_number = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (avoid_dollar_number (format_chars))
|
if (avoid_dollar_number (format_chars))
|
return;
|
return;
|
}
|
}
|
if (info->first_arg_num != 0)
|
if (info->first_arg_num != 0)
|
{
|
{
|
if (params == 0)
|
if (params == 0)
|
{
|
{
|
warning (OPT_Wformat, "too few arguments for format");
|
warning (OPT_Wformat, "too few arguments for format");
|
return;
|
return;
|
}
|
}
|
cur_param = TREE_VALUE (params);
|
cur_param = TREE_VALUE (params);
|
if (has_operand_number <= 0)
|
if (has_operand_number <= 0)
|
{
|
{
|
params = TREE_CHAIN (params);
|
params = TREE_CHAIN (params);
|
++arg_num;
|
++arg_num;
|
}
|
}
|
precision_wanted_type.wanted_type = *fki->precision_type;
|
precision_wanted_type.wanted_type = *fki->precision_type;
|
precision_wanted_type.wanted_type_name = NULL;
|
precision_wanted_type.wanted_type_name = NULL;
|
precision_wanted_type.pointer_count = 0;
|
precision_wanted_type.pointer_count = 0;
|
precision_wanted_type.char_lenient_flag = 0;
|
precision_wanted_type.char_lenient_flag = 0;
|
precision_wanted_type.writing_in_flag = 0;
|
precision_wanted_type.writing_in_flag = 0;
|
precision_wanted_type.reading_from_flag = 0;
|
precision_wanted_type.reading_from_flag = 0;
|
precision_wanted_type.name = _("field precision");
|
precision_wanted_type.name = _("field precision");
|
precision_wanted_type.param = cur_param;
|
precision_wanted_type.param = cur_param;
|
precision_wanted_type.arg_num = arg_num;
|
precision_wanted_type.arg_num = arg_num;
|
precision_wanted_type.next = NULL;
|
precision_wanted_type.next = NULL;
|
if (last_wanted_type != 0)
|
if (last_wanted_type != 0)
|
last_wanted_type->next = &precision_wanted_type;
|
last_wanted_type->next = &precision_wanted_type;
|
if (first_wanted_type == 0)
|
if (first_wanted_type == 0)
|
first_wanted_type = &precision_wanted_type;
|
first_wanted_type = &precision_wanted_type;
|
last_wanted_type = &precision_wanted_type;
|
last_wanted_type = &precision_wanted_type;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (!(fki->flags & (int) FMT_FLAG_EMPTY_PREC_OK)
|
if (!(fki->flags & (int) FMT_FLAG_EMPTY_PREC_OK)
|
&& !ISDIGIT (*format_chars))
|
&& !ISDIGIT (*format_chars))
|
warning (OPT_Wformat, "empty precision in %s format", fki->name);
|
warning (OPT_Wformat, "empty precision in %s format", fki->name);
|
while (ISDIGIT (*format_chars))
|
while (ISDIGIT (*format_chars))
|
++format_chars;
|
++format_chars;
|
}
|
}
|
}
|
}
|
|
|
/* Read any length modifier, if this kind of format has them. */
|
/* Read any length modifier, if this kind of format has them. */
|
fli = fki->length_char_specs;
|
fli = fki->length_char_specs;
|
length_chars = NULL;
|
length_chars = NULL;
|
length_chars_val = FMT_LEN_none;
|
length_chars_val = FMT_LEN_none;
|
length_chars_std = STD_C89;
|
length_chars_std = STD_C89;
|
if (fli)
|
if (fli)
|
{
|
{
|
while (fli->name != 0 && fli->name[0] != *format_chars)
|
while (fli->name != 0 && fli->name[0] != *format_chars)
|
fli++;
|
fli++;
|
if (fli->name != 0)
|
if (fli->name != 0)
|
{
|
{
|
format_chars++;
|
format_chars++;
|
if (fli->double_name != 0 && fli->name[0] == *format_chars)
|
if (fli->double_name != 0 && fli->name[0] == *format_chars)
|
{
|
{
|
format_chars++;
|
format_chars++;
|
length_chars = fli->double_name;
|
length_chars = fli->double_name;
|
length_chars_val = fli->double_index;
|
length_chars_val = fli->double_index;
|
length_chars_std = fli->double_std;
|
length_chars_std = fli->double_std;
|
}
|
}
|
else
|
else
|
{
|
{
|
length_chars = fli->name;
|
length_chars = fli->name;
|
length_chars_val = fli->index;
|
length_chars_val = fli->index;
|
length_chars_std = fli->std;
|
length_chars_std = fli->std;
|
}
|
}
|
i = strlen (flag_chars);
|
i = strlen (flag_chars);
|
flag_chars[i++] = fki->length_code_char;
|
flag_chars[i++] = fki->length_code_char;
|
flag_chars[i] = 0;
|
flag_chars[i] = 0;
|
}
|
}
|
if (pedantic)
|
if (pedantic)
|
{
|
{
|
/* Warn if the length modifier is non-standard. */
|
/* Warn if the length modifier is non-standard. */
|
if (ADJ_STD (length_chars_std) > C_STD_VER)
|
if (ADJ_STD (length_chars_std) > C_STD_VER)
|
warning (OPT_Wformat,
|
warning (OPT_Wformat,
|
"%s does not support the %qs %s length modifier",
|
"%s does not support the %qs %s length modifier",
|
C_STD_NAME (length_chars_std), length_chars,
|
C_STD_NAME (length_chars_std), length_chars,
|
fki->name);
|
fki->name);
|
}
|
}
|
}
|
}
|
|
|
/* Read any modifier (strftime E/O). */
|
/* Read any modifier (strftime E/O). */
|
if (fki->modifier_chars != NULL)
|
if (fki->modifier_chars != NULL)
|
{
|
{
|
while (*format_chars != 0
|
while (*format_chars != 0
|
&& strchr (fki->modifier_chars, *format_chars) != 0)
|
&& strchr (fki->modifier_chars, *format_chars) != 0)
|
{
|
{
|
if (strchr (flag_chars, *format_chars) != 0)
|
if (strchr (flag_chars, *format_chars) != 0)
|
{
|
{
|
const format_flag_spec *s = get_flag_spec (flag_specs,
|
const format_flag_spec *s = get_flag_spec (flag_specs,
|
*format_chars, NULL);
|
*format_chars, NULL);
|
warning (OPT_Wformat, "repeated %s in format", _(s->name));
|
warning (OPT_Wformat, "repeated %s in format", _(s->name));
|
}
|
}
|
else
|
else
|
{
|
{
|
i = strlen (flag_chars);
|
i = strlen (flag_chars);
|
flag_chars[i++] = *format_chars;
|
flag_chars[i++] = *format_chars;
|
flag_chars[i] = 0;
|
flag_chars[i] = 0;
|
}
|
}
|
++format_chars;
|
++format_chars;
|
}
|
}
|
}
|
}
|
|
|
/* Handle the scanf allocation kludge. */
|
/* Handle the scanf allocation kludge. */
|
if (fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
|
if (fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
|
{
|
{
|
if (*format_chars == 'a' && !flag_isoc99)
|
if (*format_chars == 'a' && !flag_isoc99)
|
{
|
{
|
if (format_chars[1] == 's' || format_chars[1] == 'S'
|
if (format_chars[1] == 's' || format_chars[1] == 'S'
|
|| format_chars[1] == '[')
|
|| format_chars[1] == '[')
|
{
|
{
|
/* 'a' is used as a flag. */
|
/* 'a' is used as a flag. */
|
i = strlen (flag_chars);
|
i = strlen (flag_chars);
|
flag_chars[i++] = 'a';
|
flag_chars[i++] = 'a';
|
flag_chars[i] = 0;
|
flag_chars[i] = 0;
|
format_chars++;
|
format_chars++;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
format_char = *format_chars;
|
format_char = *format_chars;
|
if (format_char == 0
|
if (format_char == 0
|
|| (!(fki->flags & (int) FMT_FLAG_FANCY_PERCENT_OK)
|
|| (!(fki->flags & (int) FMT_FLAG_FANCY_PERCENT_OK)
|
&& format_char == '%'))
|
&& format_char == '%'))
|
{
|
{
|
warning (OPT_Wformat, "conversion lacks type at end of format");
|
warning (OPT_Wformat, "conversion lacks type at end of format");
|
continue;
|
continue;
|
}
|
}
|
format_chars++;
|
format_chars++;
|
fci = fki->conversion_specs;
|
fci = fki->conversion_specs;
|
while (fci->format_chars != 0
|
while (fci->format_chars != 0
|
&& strchr (fci->format_chars, format_char) == 0)
|
&& strchr (fci->format_chars, format_char) == 0)
|
++fci;
|
++fci;
|
if (fci->format_chars == 0)
|
if (fci->format_chars == 0)
|
{
|
{
|
if (ISGRAPH (format_char))
|
if (ISGRAPH (format_char))
|
warning (OPT_Wformat, "unknown conversion type character %qc in format",
|
warning (OPT_Wformat, "unknown conversion type character %qc in format",
|
format_char);
|
format_char);
|
else
|
else
|
warning (OPT_Wformat, "unknown conversion type character 0x%x in format",
|
warning (OPT_Wformat, "unknown conversion type character 0x%x in format",
|
format_char);
|
format_char);
|
continue;
|
continue;
|
}
|
}
|
if (pedantic)
|
if (pedantic)
|
{
|
{
|
if (ADJ_STD (fci->std) > C_STD_VER)
|
if (ADJ_STD (fci->std) > C_STD_VER)
|
warning (OPT_Wformat, "%s does not support the %<%%%c%> %s format",
|
warning (OPT_Wformat, "%s does not support the %<%%%c%> %s format",
|
C_STD_NAME (fci->std), format_char, fki->name);
|
C_STD_NAME (fci->std), format_char, fki->name);
|
}
|
}
|
|
|
/* Validate the individual flags used, removing any that are invalid. */
|
/* Validate the individual flags used, removing any that are invalid. */
|
{
|
{
|
int d = 0;
|
int d = 0;
|
for (i = 0; flag_chars[i] != 0; i++)
|
for (i = 0; flag_chars[i] != 0; i++)
|
{
|
{
|
const format_flag_spec *s = get_flag_spec (flag_specs,
|
const format_flag_spec *s = get_flag_spec (flag_specs,
|
flag_chars[i], NULL);
|
flag_chars[i], NULL);
|
flag_chars[i - d] = flag_chars[i];
|
flag_chars[i - d] = flag_chars[i];
|
if (flag_chars[i] == fki->length_code_char)
|
if (flag_chars[i] == fki->length_code_char)
|
continue;
|
continue;
|
if (strchr (fci->flag_chars, flag_chars[i]) == 0)
|
if (strchr (fci->flag_chars, flag_chars[i]) == 0)
|
{
|
{
|
warning (OPT_Wformat, "%s used with %<%%%c%> %s format",
|
warning (OPT_Wformat, "%s used with %<%%%c%> %s format",
|
_(s->name), format_char, fki->name);
|
_(s->name), format_char, fki->name);
|
d++;
|
d++;
|
continue;
|
continue;
|
}
|
}
|
if (pedantic)
|
if (pedantic)
|
{
|
{
|
const format_flag_spec *t;
|
const format_flag_spec *t;
|
if (ADJ_STD (s->std) > C_STD_VER)
|
if (ADJ_STD (s->std) > C_STD_VER)
|
warning (OPT_Wformat, "%s does not support %s",
|
warning (OPT_Wformat, "%s does not support %s",
|
C_STD_NAME (s->std), _(s->long_name));
|
C_STD_NAME (s->std), _(s->long_name));
|
t = get_flag_spec (flag_specs, flag_chars[i], fci->flags2);
|
t = get_flag_spec (flag_specs, flag_chars[i], fci->flags2);
|
if (t != NULL && ADJ_STD (t->std) > ADJ_STD (s->std))
|
if (t != NULL && ADJ_STD (t->std) > ADJ_STD (s->std))
|
{
|
{
|
const char *long_name = (t->long_name != NULL
|
const char *long_name = (t->long_name != NULL
|
? t->long_name
|
? t->long_name
|
: s->long_name);
|
: s->long_name);
|
if (ADJ_STD (t->std) > C_STD_VER)
|
if (ADJ_STD (t->std) > C_STD_VER)
|
warning (OPT_Wformat,
|
warning (OPT_Wformat,
|
"%s does not support %s with the %<%%%c%> %s format",
|
"%s does not support %s with the %<%%%c%> %s format",
|
C_STD_NAME (t->std), _(long_name),
|
C_STD_NAME (t->std), _(long_name),
|
format_char, fki->name);
|
format_char, fki->name);
|
}
|
}
|
}
|
}
|
}
|
}
|
flag_chars[i - d] = 0;
|
flag_chars[i - d] = 0;
|
}
|
}
|
|
|
if ((fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
|
if ((fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
|
&& strchr (flag_chars, 'a') != 0)
|
&& strchr (flag_chars, 'a') != 0)
|
aflag = 1;
|
aflag = 1;
|
|
|
if (fki->suppression_char
|
if (fki->suppression_char
|
&& strchr (flag_chars, fki->suppression_char) != 0)
|
&& strchr (flag_chars, fki->suppression_char) != 0)
|
suppressed = 1;
|
suppressed = 1;
|
|
|
/* Validate the pairs of flags used. */
|
/* Validate the pairs of flags used. */
|
for (i = 0; bad_flag_pairs[i].flag_char1 != 0; i++)
|
for (i = 0; bad_flag_pairs[i].flag_char1 != 0; i++)
|
{
|
{
|
const format_flag_spec *s, *t;
|
const format_flag_spec *s, *t;
|
if (strchr (flag_chars, bad_flag_pairs[i].flag_char1) == 0)
|
if (strchr (flag_chars, bad_flag_pairs[i].flag_char1) == 0)
|
continue;
|
continue;
|
if (strchr (flag_chars, bad_flag_pairs[i].flag_char2) == 0)
|
if (strchr (flag_chars, bad_flag_pairs[i].flag_char2) == 0)
|
continue;
|
continue;
|
if (bad_flag_pairs[i].predicate != 0
|
if (bad_flag_pairs[i].predicate != 0
|
&& strchr (fci->flags2, bad_flag_pairs[i].predicate) == 0)
|
&& strchr (fci->flags2, bad_flag_pairs[i].predicate) == 0)
|
continue;
|
continue;
|
s = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char1, NULL);
|
s = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char1, NULL);
|
t = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char2, NULL);
|
t = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char2, NULL);
|
if (bad_flag_pairs[i].ignored)
|
if (bad_flag_pairs[i].ignored)
|
{
|
{
|
if (bad_flag_pairs[i].predicate != 0)
|
if (bad_flag_pairs[i].predicate != 0)
|
warning (OPT_Wformat,
|
warning (OPT_Wformat,
|
"%s ignored with %s and %<%%%c%> %s format",
|
"%s ignored with %s and %<%%%c%> %s format",
|
_(s->name), _(t->name), format_char,
|
_(s->name), _(t->name), format_char,
|
fki->name);
|
fki->name);
|
else
|
else
|
warning (OPT_Wformat, "%s ignored with %s in %s format",
|
warning (OPT_Wformat, "%s ignored with %s in %s format",
|
_(s->name), _(t->name), fki->name);
|
_(s->name), _(t->name), fki->name);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (bad_flag_pairs[i].predicate != 0)
|
if (bad_flag_pairs[i].predicate != 0)
|
warning (OPT_Wformat,
|
warning (OPT_Wformat,
|
"use of %s and %s together with %<%%%c%> %s format",
|
"use of %s and %s together with %<%%%c%> %s format",
|
_(s->name), _(t->name), format_char,
|
_(s->name), _(t->name), format_char,
|
fki->name);
|
fki->name);
|
else
|
else
|
warning (OPT_Wformat, "use of %s and %s together in %s format",
|
warning (OPT_Wformat, "use of %s and %s together in %s format",
|
_(s->name), _(t->name), fki->name);
|
_(s->name), _(t->name), fki->name);
|
}
|
}
|
}
|
}
|
|
|
/* Give Y2K warnings. */
|
/* Give Y2K warnings. */
|
if (warn_format_y2k)
|
if (warn_format_y2k)
|
{
|
{
|
int y2k_level = 0;
|
int y2k_level = 0;
|
if (strchr (fci->flags2, '4') != 0)
|
if (strchr (fci->flags2, '4') != 0)
|
if (strchr (flag_chars, 'E') != 0)
|
if (strchr (flag_chars, 'E') != 0)
|
y2k_level = 3;
|
y2k_level = 3;
|
else
|
else
|
y2k_level = 2;
|
y2k_level = 2;
|
else if (strchr (fci->flags2, '3') != 0)
|
else if (strchr (fci->flags2, '3') != 0)
|
y2k_level = 3;
|
y2k_level = 3;
|
else if (strchr (fci->flags2, '2') != 0)
|
else if (strchr (fci->flags2, '2') != 0)
|
y2k_level = 2;
|
y2k_level = 2;
|
if (y2k_level == 3)
|
if (y2k_level == 3)
|
warning (OPT_Wformat_y2k, "%<%%%c%> yields only last 2 digits of "
|
warning (OPT_Wformat_y2k, "%<%%%c%> yields only last 2 digits of "
|
"year in some locales", format_char);
|
"year in some locales", format_char);
|
else if (y2k_level == 2)
|
else if (y2k_level == 2)
|
warning (OPT_Wformat_y2k, "%<%%%c%> yields only last 2 digits of "
|
warning (OPT_Wformat_y2k, "%<%%%c%> yields only last 2 digits of "
|
"year", format_char);
|
"year", format_char);
|
}
|
}
|
|
|
if (strchr (fci->flags2, '[') != 0)
|
if (strchr (fci->flags2, '[') != 0)
|
{
|
{
|
/* Skip over scan set, in case it happens to have '%' in it. */
|
/* Skip over scan set, in case it happens to have '%' in it. */
|
if (*format_chars == '^')
|
if (*format_chars == '^')
|
++format_chars;
|
++format_chars;
|
/* Find closing bracket; if one is hit immediately, then
|
/* Find closing bracket; if one is hit immediately, then
|
it's part of the scan set rather than a terminator. */
|
it's part of the scan set rather than a terminator. */
|
if (*format_chars == ']')
|
if (*format_chars == ']')
|
++format_chars;
|
++format_chars;
|
while (*format_chars && *format_chars != ']')
|
while (*format_chars && *format_chars != ']')
|
++format_chars;
|
++format_chars;
|
if (*format_chars != ']')
|
if (*format_chars != ']')
|
/* The end of the format string was reached. */
|
/* The end of the format string was reached. */
|
warning (OPT_Wformat, "no closing %<]%> for %<%%[%> format");
|
warning (OPT_Wformat, "no closing %<]%> for %<%%[%> format");
|
}
|
}
|
|
|
wanted_type = 0;
|
wanted_type = 0;
|
wanted_type_name = 0;
|
wanted_type_name = 0;
|
if (fki->flags & (int) FMT_FLAG_ARG_CONVERT)
|
if (fki->flags & (int) FMT_FLAG_ARG_CONVERT)
|
{
|
{
|
wanted_type = (fci->types[length_chars_val].type
|
wanted_type = (fci->types[length_chars_val].type
|
? *fci->types[length_chars_val].type : 0);
|
? *fci->types[length_chars_val].type : 0);
|
wanted_type_name = fci->types[length_chars_val].name;
|
wanted_type_name = fci->types[length_chars_val].name;
|
wanted_type_std = fci->types[length_chars_val].std;
|
wanted_type_std = fci->types[length_chars_val].std;
|
if (wanted_type == 0)
|
if (wanted_type == 0)
|
{
|
{
|
warning (OPT_Wformat,
|
warning (OPT_Wformat,
|
"use of %qs length modifier with %qc type character",
|
"use of %qs length modifier with %qc type character",
|
length_chars, format_char);
|
length_chars, format_char);
|
/* Heuristic: skip one argument when an invalid length/type
|
/* Heuristic: skip one argument when an invalid length/type
|
combination is encountered. */
|
combination is encountered. */
|
arg_num++;
|
arg_num++;
|
if (params == 0)
|
if (params == 0)
|
{
|
{
|
warning (OPT_Wformat, "too few arguments for format");
|
warning (OPT_Wformat, "too few arguments for format");
|
return;
|
return;
|
}
|
}
|
params = TREE_CHAIN (params);
|
params = TREE_CHAIN (params);
|
continue;
|
continue;
|
}
|
}
|
else if (pedantic
|
else if (pedantic
|
/* Warn if non-standard, provided it is more non-standard
|
/* Warn if non-standard, provided it is more non-standard
|
than the length and type characters that may already
|
than the length and type characters that may already
|
have been warned for. */
|
have been warned for. */
|
&& ADJ_STD (wanted_type_std) > ADJ_STD (length_chars_std)
|
&& ADJ_STD (wanted_type_std) > ADJ_STD (length_chars_std)
|
&& ADJ_STD (wanted_type_std) > ADJ_STD (fci->std))
|
&& ADJ_STD (wanted_type_std) > ADJ_STD (fci->std))
|
{
|
{
|
if (ADJ_STD (wanted_type_std) > C_STD_VER)
|
if (ADJ_STD (wanted_type_std) > C_STD_VER)
|
warning (OPT_Wformat,
|
warning (OPT_Wformat,
|
"%s does not support the %<%%%s%c%> %s format",
|
"%s does not support the %<%%%s%c%> %s format",
|
C_STD_NAME (wanted_type_std), length_chars,
|
C_STD_NAME (wanted_type_std), length_chars,
|
format_char, fki->name);
|
format_char, fki->name);
|
}
|
}
|
}
|
}
|
|
|
main_wanted_type.next = NULL;
|
main_wanted_type.next = NULL;
|
|
|
/* Finally. . .check type of argument against desired type! */
|
/* Finally. . .check type of argument against desired type! */
|
if (info->first_arg_num == 0)
|
if (info->first_arg_num == 0)
|
continue;
|
continue;
|
if ((fci->pointer_count == 0 && wanted_type == void_type_node)
|
if ((fci->pointer_count == 0 && wanted_type == void_type_node)
|
|| suppressed)
|
|| suppressed)
|
{
|
{
|
if (main_arg_num != 0)
|
if (main_arg_num != 0)
|
{
|
{
|
if (suppressed)
|
if (suppressed)
|
warning (OPT_Wformat, "operand number specified with "
|
warning (OPT_Wformat, "operand number specified with "
|
"suppressed assignment");
|
"suppressed assignment");
|
else
|
else
|
warning (OPT_Wformat, "operand number specified for format "
|
warning (OPT_Wformat, "operand number specified for format "
|
"taking no argument");
|
"taking no argument");
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
format_wanted_type *wanted_type_ptr;
|
format_wanted_type *wanted_type_ptr;
|
|
|
if (main_arg_num != 0)
|
if (main_arg_num != 0)
|
{
|
{
|
arg_num = main_arg_num;
|
arg_num = main_arg_num;
|
params = main_arg_params;
|
params = main_arg_params;
|
}
|
}
|
else
|
else
|
{
|
{
|
++arg_num;
|
++arg_num;
|
if (has_operand_number > 0)
|
if (has_operand_number > 0)
|
{
|
{
|
warning (OPT_Wformat, "missing $ operand number in format");
|
warning (OPT_Wformat, "missing $ operand number in format");
|
return;
|
return;
|
}
|
}
|
else
|
else
|
has_operand_number = 0;
|
has_operand_number = 0;
|
}
|
}
|
|
|
wanted_type_ptr = &main_wanted_type;
|
wanted_type_ptr = &main_wanted_type;
|
while (fci)
|
while (fci)
|
{
|
{
|
if (params == 0)
|
if (params == 0)
|
{
|
{
|
warning (OPT_Wformat, "too few arguments for format");
|
warning (OPT_Wformat, "too few arguments for format");
|
return;
|
return;
|
}
|
}
|
|
|
cur_param = TREE_VALUE (params);
|
cur_param = TREE_VALUE (params);
|
params = TREE_CHAIN (params);
|
params = TREE_CHAIN (params);
|
|
|
wanted_type_ptr->wanted_type = wanted_type;
|
wanted_type_ptr->wanted_type = wanted_type;
|
wanted_type_ptr->wanted_type_name = wanted_type_name;
|
wanted_type_ptr->wanted_type_name = wanted_type_name;
|
wanted_type_ptr->pointer_count = fci->pointer_count + aflag;
|
wanted_type_ptr->pointer_count = fci->pointer_count + aflag;
|
wanted_type_ptr->char_lenient_flag = 0;
|
wanted_type_ptr->char_lenient_flag = 0;
|
if (strchr (fci->flags2, 'c') != 0)
|
if (strchr (fci->flags2, 'c') != 0)
|
wanted_type_ptr->char_lenient_flag = 1;
|
wanted_type_ptr->char_lenient_flag = 1;
|
wanted_type_ptr->writing_in_flag = 0;
|
wanted_type_ptr->writing_in_flag = 0;
|
wanted_type_ptr->reading_from_flag = 0;
|
wanted_type_ptr->reading_from_flag = 0;
|
if (aflag)
|
if (aflag)
|
wanted_type_ptr->writing_in_flag = 1;
|
wanted_type_ptr->writing_in_flag = 1;
|
else
|
else
|
{
|
{
|
if (strchr (fci->flags2, 'W') != 0)
|
if (strchr (fci->flags2, 'W') != 0)
|
wanted_type_ptr->writing_in_flag = 1;
|
wanted_type_ptr->writing_in_flag = 1;
|
if (strchr (fci->flags2, 'R') != 0)
|
if (strchr (fci->flags2, 'R') != 0)
|
wanted_type_ptr->reading_from_flag = 1;
|
wanted_type_ptr->reading_from_flag = 1;
|
}
|
}
|
wanted_type_ptr->name = NULL;
|
wanted_type_ptr->name = NULL;
|
wanted_type_ptr->param = cur_param;
|
wanted_type_ptr->param = cur_param;
|
wanted_type_ptr->arg_num = arg_num;
|
wanted_type_ptr->arg_num = arg_num;
|
wanted_type_ptr->next = NULL;
|
wanted_type_ptr->next = NULL;
|
if (last_wanted_type != 0)
|
if (last_wanted_type != 0)
|
last_wanted_type->next = wanted_type_ptr;
|
last_wanted_type->next = wanted_type_ptr;
|
if (first_wanted_type == 0)
|
if (first_wanted_type == 0)
|
first_wanted_type = wanted_type_ptr;
|
first_wanted_type = wanted_type_ptr;
|
last_wanted_type = wanted_type_ptr;
|
last_wanted_type = wanted_type_ptr;
|
|
|
fci = fci->chain;
|
fci = fci->chain;
|
if (fci)
|
if (fci)
|
{
|
{
|
wanted_type_ptr = GGC_NEW (format_wanted_type);
|
wanted_type_ptr = GGC_NEW (format_wanted_type);
|
arg_num++;
|
arg_num++;
|
wanted_type = *fci->types[length_chars_val].type;
|
wanted_type = *fci->types[length_chars_val].type;
|
wanted_type_name = fci->types[length_chars_val].name;
|
wanted_type_name = fci->types[length_chars_val].name;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (first_wanted_type != 0)
|
if (first_wanted_type != 0)
|
check_format_types (first_wanted_type, format_start,
|
check_format_types (first_wanted_type, format_start,
|
format_chars - format_start);
|
format_chars - format_start);
|
|
|
if (main_wanted_type.next != NULL)
|
if (main_wanted_type.next != NULL)
|
{
|
{
|
format_wanted_type *wanted_type_ptr = main_wanted_type.next;
|
format_wanted_type *wanted_type_ptr = main_wanted_type.next;
|
while (wanted_type_ptr)
|
while (wanted_type_ptr)
|
{
|
{
|
format_wanted_type *next = wanted_type_ptr->next;
|
format_wanted_type *next = wanted_type_ptr->next;
|
ggc_free (wanted_type_ptr);
|
ggc_free (wanted_type_ptr);
|
wanted_type_ptr = next;
|
wanted_type_ptr = next;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Check the argument types from a single format conversion (possibly
|
/* Check the argument types from a single format conversion (possibly
|
including width and precision arguments). */
|
including width and precision arguments). */
|
static void
|
static void
|
check_format_types (format_wanted_type *types, const char *format_start,
|
check_format_types (format_wanted_type *types, const char *format_start,
|
int format_length)
|
int format_length)
|
{
|
{
|
for (; types != 0; types = types->next)
|
for (; types != 0; types = types->next)
|
{
|
{
|
tree cur_param;
|
tree cur_param;
|
tree cur_type;
|
tree cur_type;
|
tree orig_cur_type;
|
tree orig_cur_type;
|
tree wanted_type;
|
tree wanted_type;
|
int arg_num;
|
int arg_num;
|
int i;
|
int i;
|
int char_type_flag;
|
int char_type_flag;
|
cur_param = types->param;
|
cur_param = types->param;
|
cur_type = TREE_TYPE (cur_param);
|
cur_type = TREE_TYPE (cur_param);
|
if (cur_type == error_mark_node)
|
if (cur_type == error_mark_node)
|
continue;
|
continue;
|
orig_cur_type = cur_type;
|
orig_cur_type = cur_type;
|
char_type_flag = 0;
|
char_type_flag = 0;
|
wanted_type = types->wanted_type;
|
wanted_type = types->wanted_type;
|
arg_num = types->arg_num;
|
arg_num = types->arg_num;
|
|
|
/* The following should not occur here. */
|
/* The following should not occur here. */
|
gcc_assert (wanted_type);
|
gcc_assert (wanted_type);
|
gcc_assert (wanted_type != void_type_node || types->pointer_count);
|
gcc_assert (wanted_type != void_type_node || types->pointer_count);
|
|
|
if (types->pointer_count == 0)
|
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);
|
wanted_type = TYPE_MAIN_VARIANT (wanted_type);
|
|
|
STRIP_NOPS (cur_param);
|
STRIP_NOPS (cur_param);
|
|
|
/* Check the types of any additional pointer arguments
|
/* Check the types of any additional pointer arguments
|
that precede the "real" argument. */
|
that precede the "real" argument. */
|
for (i = 0; i < types->pointer_count; ++i)
|
for (i = 0; i < types->pointer_count; ++i)
|
{
|
{
|
if (TREE_CODE (cur_type) == POINTER_TYPE)
|
if (TREE_CODE (cur_type) == POINTER_TYPE)
|
{
|
{
|
cur_type = TREE_TYPE (cur_type);
|
cur_type = TREE_TYPE (cur_type);
|
if (cur_type == error_mark_node)
|
if (cur_type == error_mark_node)
|
break;
|
break;
|
|
|
/* Check for writing through a NULL pointer. */
|
/* Check for writing through a NULL pointer. */
|
if (types->writing_in_flag
|
if (types->writing_in_flag
|
&& i == 0
|
&& i == 0
|
&& cur_param != 0
|
&& cur_param != 0
|
&& integer_zerop (cur_param))
|
&& integer_zerop (cur_param))
|
warning (OPT_Wformat, "writing through null pointer "
|
warning (OPT_Wformat, "writing through null pointer "
|
"(argument %d)", arg_num);
|
"(argument %d)", arg_num);
|
|
|
/* Check for reading through a NULL pointer. */
|
/* Check for reading through a NULL pointer. */
|
if (types->reading_from_flag
|
if (types->reading_from_flag
|
&& i == 0
|
&& i == 0
|
&& cur_param != 0
|
&& cur_param != 0
|
&& integer_zerop (cur_param))
|
&& integer_zerop (cur_param))
|
warning (OPT_Wformat, "reading through null pointer "
|
warning (OPT_Wformat, "reading through null pointer "
|
"(argument %d)", arg_num);
|
"(argument %d)", arg_num);
|
|
|
if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
|
if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
|
cur_param = TREE_OPERAND (cur_param, 0);
|
cur_param = TREE_OPERAND (cur_param, 0);
|
else
|
else
|
cur_param = 0;
|
cur_param = 0;
|
|
|
/* See if this is an attempt to write into a const type with
|
/* See if this is an attempt to write into a const type with
|
scanf or with printf "%n". Note: the writing in happens
|
scanf or with printf "%n". Note: the writing in happens
|
at the first indirection only, if for example
|
at the first indirection only, if for example
|
void * const * is passed to scanf %p; passing
|
void * const * is passed to scanf %p; passing
|
const void ** is simply passing an incompatible type. */
|
const void ** is simply passing an incompatible type. */
|
if (types->writing_in_flag
|
if (types->writing_in_flag
|
&& i == 0
|
&& i == 0
|
&& (TYPE_READONLY (cur_type)
|
&& (TYPE_READONLY (cur_type)
|
|| (cur_param != 0
|
|| (cur_param != 0
|
&& (CONSTANT_CLASS_P (cur_param)
|
&& (CONSTANT_CLASS_P (cur_param)
|
|| (DECL_P (cur_param)
|
|| (DECL_P (cur_param)
|
&& TREE_READONLY (cur_param))))))
|
&& TREE_READONLY (cur_param))))))
|
warning (OPT_Wformat, "writing into constant object "
|
warning (OPT_Wformat, "writing into constant object "
|
"(argument %d)", arg_num);
|
"(argument %d)", arg_num);
|
|
|
/* If there are extra type qualifiers beyond the first
|
/* If there are extra type qualifiers beyond the first
|
indirection, then this makes the types technically
|
indirection, then this makes the types technically
|
incompatible. */
|
incompatible. */
|
if (i > 0
|
if (i > 0
|
&& pedantic
|
&& pedantic
|
&& (TYPE_READONLY (cur_type)
|
&& (TYPE_READONLY (cur_type)
|
|| TYPE_VOLATILE (cur_type)
|
|| TYPE_VOLATILE (cur_type)
|
|| TYPE_RESTRICT (cur_type)))
|
|| TYPE_RESTRICT (cur_type)))
|
warning (OPT_Wformat, "extra type qualifiers in format "
|
warning (OPT_Wformat, "extra type qualifiers in format "
|
"argument (argument %d)",
|
"argument (argument %d)",
|
arg_num);
|
arg_num);
|
|
|
}
|
}
|
else
|
else
|
{
|
{
|
format_type_warning (types->name, format_start, format_length,
|
format_type_warning (types->name, format_start, format_length,
|
wanted_type, types->pointer_count,
|
wanted_type, types->pointer_count,
|
types->wanted_type_name, orig_cur_type,
|
types->wanted_type_name, orig_cur_type,
|
arg_num);
|
arg_num);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (i < types->pointer_count)
|
if (i < types->pointer_count)
|
continue;
|
continue;
|
|
|
cur_type = TYPE_MAIN_VARIANT (cur_type);
|
cur_type = TYPE_MAIN_VARIANT (cur_type);
|
|
|
/* Check whether the argument type is a character type. This leniency
|
/* Check whether the argument type is a character type. This leniency
|
only applies to certain formats, flagged with 'c'.
|
only applies to certain formats, flagged with 'c'.
|
*/
|
*/
|
if (types->char_lenient_flag)
|
if (types->char_lenient_flag)
|
char_type_flag = (cur_type == char_type_node
|
char_type_flag = (cur_type == char_type_node
|
|| cur_type == signed_char_type_node
|
|| cur_type == signed_char_type_node
|
|| cur_type == unsigned_char_type_node);
|
|| cur_type == unsigned_char_type_node);
|
|
|
/* Check the type of the "real" argument, if there's a type we want. */
|
/* Check the type of the "real" argument, if there's a type we want. */
|
if (lang_hooks.types_compatible_p (wanted_type, cur_type))
|
if (lang_hooks.types_compatible_p (wanted_type, cur_type))
|
continue;
|
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.)
|
(Anything else would already have got a warning.)
|
With -pedantic, only allow pointers to void and to character
|
With -pedantic, only allow pointers to void and to character
|
types. */
|
types. */
|
if (wanted_type == void_type_node
|
if (wanted_type == void_type_node
|
&& (!pedantic || (i == 1 && char_type_flag)))
|
&& (!pedantic || (i == 1 && char_type_flag)))
|
continue;
|
continue;
|
/* Don't warn about differences merely in signedness, unless
|
/* Don't warn about differences merely in signedness, unless
|
-pedantic. With -pedantic, warn if the type is a pointer
|
-pedantic. With -pedantic, warn if the type is a pointer
|
target and not a character type, and for character types at
|
target and not a character type, and for character types at
|
a second level of indirection. */
|
a second level of indirection. */
|
if (TREE_CODE (wanted_type) == INTEGER_TYPE
|
if (TREE_CODE (wanted_type) == INTEGER_TYPE
|
&& TREE_CODE (cur_type) == INTEGER_TYPE
|
&& TREE_CODE (cur_type) == INTEGER_TYPE
|
&& (!pedantic || i == 0 || (i == 1 && char_type_flag))
|
&& (!pedantic || i == 0 || (i == 1 && char_type_flag))
|
&& (TYPE_UNSIGNED (wanted_type)
|
&& (TYPE_UNSIGNED (wanted_type)
|
? wanted_type == c_common_unsigned_type (cur_type)
|
? wanted_type == c_common_unsigned_type (cur_type)
|
: wanted_type == c_common_signed_type (cur_type)))
|
: wanted_type == c_common_signed_type (cur_type)))
|
continue;
|
continue;
|
/* Likewise, "signed char", "unsigned char" and "char" are
|
/* Likewise, "signed char", "unsigned char" and "char" are
|
equivalent but the above test won't consider them equivalent. */
|
equivalent but the above test won't consider them equivalent. */
|
if (wanted_type == char_type_node
|
if (wanted_type == char_type_node
|
&& (!pedantic || i < 2)
|
&& (!pedantic || i < 2)
|
&& char_type_flag)
|
&& char_type_flag)
|
continue;
|
continue;
|
/* Now we have a type mismatch. */
|
/* Now we have a type mismatch. */
|
format_type_warning (types->name, format_start, format_length,
|
format_type_warning (types->name, format_start, format_length,
|
wanted_type, types->pointer_count,
|
wanted_type, types->pointer_count,
|
types->wanted_type_name, orig_cur_type, arg_num);
|
types->wanted_type_name, orig_cur_type, arg_num);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Give a warning about a format argument of different type from that
|
/* Give a warning about a format argument of different type from that
|
expected. DESCR is a description such as "field precision", or
|
expected. DESCR is a description such as "field precision", or
|
NULL for an ordinary format. For an ordinary format, FORMAT_START
|
NULL for an ordinary format. For an ordinary format, FORMAT_START
|
points to where the format starts in the format string and
|
points to where the format starts in the format string and
|
FORMAT_LENGTH is its length. WANTED_TYPE is the type the argument
|
FORMAT_LENGTH is its length. WANTED_TYPE is the type the argument
|
should have after POINTER_COUNT pointer dereferences.
|
should have after POINTER_COUNT pointer dereferences.
|
WANTED_NAME_NAME is a possibly more friendly name of WANTED_TYPE,
|
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
|
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
|
is the type of the actual argument. ARG_NUM is the number of that
|
argument. */
|
argument. */
|
static void
|
static void
|
format_type_warning (const char *descr, const char *format_start,
|
format_type_warning (const char *descr, const char *format_start,
|
int format_length, tree wanted_type, int pointer_count,
|
int format_length, tree wanted_type, int pointer_count,
|
const char *wanted_type_name, tree arg_type, int arg_num)
|
const char *wanted_type_name, tree arg_type, int arg_num)
|
{
|
{
|
char *p;
|
char *p;
|
/* If ARG_TYPE is a typedef with a misleading name (for example,
|
/* 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
|
size_t but not the standard size_t expected by printf %zu), avoid
|
printing the typedef name. */
|
printing the typedef name. */
|
if (wanted_type_name
|
if (wanted_type_name
|
&& TYPE_NAME (arg_type)
|
&& TYPE_NAME (arg_type)
|
&& TREE_CODE (TYPE_NAME (arg_type)) == TYPE_DECL
|
&& TREE_CODE (TYPE_NAME (arg_type)) == TYPE_DECL
|
&& DECL_NAME (TYPE_NAME (arg_type))
|
&& DECL_NAME (TYPE_NAME (arg_type))
|
&& !strcmp (wanted_type_name,
|
&& !strcmp (wanted_type_name,
|
lang_hooks.decl_printable_name (TYPE_NAME (arg_type), 2)))
|
lang_hooks.decl_printable_name (TYPE_NAME (arg_type), 2)))
|
arg_type = TYPE_MAIN_VARIANT (arg_type);
|
arg_type = TYPE_MAIN_VARIANT (arg_type);
|
/* The format type and name exclude any '*' for pointers, so those
|
/* The format type and name exclude any '*' for pointers, so those
|
must be formatted manually. For all the types we currently have,
|
must be formatted manually. For all the types we currently have,
|
this is adequate, but formats taking pointers to functions or
|
this is adequate, but formats taking pointers to functions or
|
arrays would require the full type to be built up in order to
|
arrays would require the full type to be built up in order to
|
print it with %T. */
|
print it with %T. */
|
p = (char *) alloca (pointer_count + 2);
|
p = (char *) alloca (pointer_count + 2);
|
if (pointer_count == 0)
|
if (pointer_count == 0)
|
p[0] = 0;
|
p[0] = 0;
|
else if (c_dialect_cxx ())
|
else if (c_dialect_cxx ())
|
{
|
{
|
memset (p, '*', pointer_count);
|
memset (p, '*', pointer_count);
|
p[pointer_count] = 0;
|
p[pointer_count] = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
p[0] = ' ';
|
p[0] = ' ';
|
memset (p + 1, '*', pointer_count);
|
memset (p + 1, '*', pointer_count);
|
p[pointer_count + 1] = 0;
|
p[pointer_count + 1] = 0;
|
}
|
}
|
if (wanted_type_name)
|
if (wanted_type_name)
|
{
|
{
|
if (descr)
|
if (descr)
|
warning (OPT_Wformat, "%s should have type %<%s%s%>, "
|
warning (OPT_Wformat, "%s should have type %<%s%s%>, "
|
"but argument %d has type %qT",
|
"but argument %d has type %qT",
|
descr, wanted_type_name, p, arg_num, arg_type);
|
descr, wanted_type_name, p, arg_num, arg_type);
|
else
|
else
|
warning (OPT_Wformat, "format %q.*s expects type %<%s%s%>, "
|
warning (OPT_Wformat, "format %q.*s expects type %<%s%s%>, "
|
"but argument %d has type %qT",
|
"but argument %d has type %qT",
|
format_length, format_start, wanted_type_name, p,
|
format_length, format_start, wanted_type_name, p,
|
arg_num, arg_type);
|
arg_num, arg_type);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (descr)
|
if (descr)
|
warning (OPT_Wformat, "%s should have type %<%T%s%>, "
|
warning (OPT_Wformat, "%s should have type %<%T%s%>, "
|
"but argument %d has type %qT",
|
"but argument %d has type %qT",
|
descr, wanted_type, p, arg_num, arg_type);
|
descr, wanted_type, p, arg_num, arg_type);
|
else
|
else
|
warning (OPT_Wformat, "format %q.*s expects type %<%T%s%>, "
|
warning (OPT_Wformat, "format %q.*s expects type %<%T%s%>, "
|
"but argument %d has type %qT",
|
"but argument %d has type %qT",
|
format_length, format_start, wanted_type, p, arg_num, arg_type);
|
format_length, format_start, wanted_type, p, arg_num, arg_type);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Given a format_char_info array FCI, and a character C, this function
|
/* Given a format_char_info array FCI, and a character C, this function
|
returns the index into the conversion_specs where that specifier's
|
returns the index into the conversion_specs where that specifier's
|
data is located. The character must exist. */
|
data is located. The character must exist. */
|
static unsigned int
|
static unsigned int
|
find_char_info_specifier_index (const format_char_info *fci, int c)
|
find_char_info_specifier_index (const format_char_info *fci, int c)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
|
|
for (i = 0; fci->format_chars; i++, fci++)
|
for (i = 0; fci->format_chars; i++, fci++)
|
if (strchr (fci->format_chars, c))
|
if (strchr (fci->format_chars, c))
|
return i;
|
return i;
|
|
|
/* We shouldn't be looking for a non-existent specifier. */
|
/* We shouldn't be looking for a non-existent specifier. */
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* Given a format_length_info array FLI, and a character C, this
|
/* Given a format_length_info array FLI, and a character C, this
|
function returns the index into the conversion_specs where that
|
function returns the index into the conversion_specs where that
|
modifier's data is located. The character must exist. */
|
modifier's data is located. The character must exist. */
|
static unsigned int
|
static unsigned int
|
find_length_info_modifier_index (const format_length_info *fli, int c)
|
find_length_info_modifier_index (const format_length_info *fli, int c)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
|
|
for (i = 0; fli->name; i++, fli++)
|
for (i = 0; fli->name; i++, fli++)
|
if (strchr (fli->name, c))
|
if (strchr (fli->name, c))
|
return i;
|
return i;
|
|
|
/* We shouldn't be looking for a non-existent modifier. */
|
/* We shouldn't be looking for a non-existent modifier. */
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* Determine the type of HOST_WIDE_INT in the code being compiled for
|
/* Determine the type of HOST_WIDE_INT in the code being compiled for
|
use in GCC's __asm_fprintf__ custom format attribute. You must
|
use in GCC's __asm_fprintf__ custom format attribute. You must
|
have set dynamic_format_types before calling this function. */
|
have set dynamic_format_types before calling this function. */
|
static void
|
static void
|
init_dynamic_asm_fprintf_info (void)
|
init_dynamic_asm_fprintf_info (void)
|
{
|
{
|
static tree hwi;
|
static tree hwi;
|
|
|
if (!hwi)
|
if (!hwi)
|
{
|
{
|
format_length_info *new_asm_fprintf_length_specs;
|
format_length_info *new_asm_fprintf_length_specs;
|
unsigned int i;
|
unsigned int i;
|
|
|
/* Find the underlying type for HOST_WIDE_INT. For the %w
|
/* Find the underlying type for HOST_WIDE_INT. For the %w
|
length modifier to work, one must have issued: "typedef
|
length modifier to work, one must have issued: "typedef
|
HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
|
HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
|
prior to using that modifier. */
|
prior to using that modifier. */
|
hwi = maybe_get_identifier ("__gcc_host_wide_int__");
|
hwi = maybe_get_identifier ("__gcc_host_wide_int__");
|
if (!hwi)
|
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;
|
return;
|
}
|
}
|
hwi = identifier_global_value (hwi);
|
hwi = identifier_global_value (hwi);
|
if (!hwi || TREE_CODE (hwi) != TYPE_DECL)
|
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;
|
return;
|
}
|
}
|
hwi = DECL_ORIGINAL_TYPE (hwi);
|
hwi = DECL_ORIGINAL_TYPE (hwi);
|
gcc_assert (hwi);
|
gcc_assert (hwi);
|
if (hwi != long_integer_type_node && hwi != long_long_integer_type_node)
|
if (hwi != long_integer_type_node && hwi != long_long_integer_type_node)
|
{
|
{
|
error ("%<__gcc_host_wide_int__%> is not defined as %<long%>"
|
error ("%<__gcc_host_wide_int__%> is not defined as %<long%>"
|
" or %<long long%>");
|
" or %<long long%>");
|
return;
|
return;
|
}
|
}
|
|
|
/* Create a new (writable) copy of asm_fprintf_length_specs. */
|
/* Create a new (writable) copy of asm_fprintf_length_specs. */
|
new_asm_fprintf_length_specs = (format_length_info *)
|
new_asm_fprintf_length_specs = (format_length_info *)
|
xmemdup (asm_fprintf_length_specs,
|
xmemdup (asm_fprintf_length_specs,
|
sizeof (asm_fprintf_length_specs),
|
sizeof (asm_fprintf_length_specs),
|
sizeof (asm_fprintf_length_specs));
|
sizeof (asm_fprintf_length_specs));
|
|
|
/* HOST_WIDE_INT must be one of 'long' or 'long long'. */
|
/* HOST_WIDE_INT must be one of 'long' or 'long long'. */
|
i = find_length_info_modifier_index (new_asm_fprintf_length_specs, 'w');
|
i = find_length_info_modifier_index (new_asm_fprintf_length_specs, 'w');
|
if (hwi == long_integer_type_node)
|
if (hwi == long_integer_type_node)
|
new_asm_fprintf_length_specs[i].index = FMT_LEN_l;
|
new_asm_fprintf_length_specs[i].index = FMT_LEN_l;
|
else if (hwi == long_long_integer_type_node)
|
else if (hwi == long_long_integer_type_node)
|
new_asm_fprintf_length_specs[i].index = FMT_LEN_ll;
|
new_asm_fprintf_length_specs[i].index = FMT_LEN_ll;
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
|
|
/* Assign the new data for use. */
|
/* Assign the new data for use. */
|
dynamic_format_types[asm_fprintf_format_type].length_char_specs =
|
dynamic_format_types[asm_fprintf_format_type].length_char_specs =
|
new_asm_fprintf_length_specs;
|
new_asm_fprintf_length_specs;
|
}
|
}
|
}
|
}
|
|
|
/* Determine the type of a "locus" in the code being compiled for use
|
/* 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
|
in GCC's __gcc_gfc__ custom format attribute. You must have set
|
dynamic_format_types before calling this function. */
|
dynamic_format_types before calling this function. */
|
static void
|
static void
|
init_dynamic_gfc_info (void)
|
init_dynamic_gfc_info (void)
|
{
|
{
|
static tree locus;
|
static tree locus;
|
|
|
if (!locus)
|
if (!locus)
|
{
|
{
|
static format_char_info *gfc_fci;
|
static format_char_info *gfc_fci;
|
|
|
/* For the GCC __gcc_gfc__ custom format specifier to work, one
|
/* For the GCC __gcc_gfc__ custom format specifier to work, one
|
must have declared 'locus' prior to using this attribute. If
|
must have declared 'locus' prior to using this attribute. If
|
we haven't seen this declarations then you shouldn't use the
|
we haven't seen this declarations then you shouldn't use the
|
specifier requiring that type. */
|
specifier requiring that type. */
|
if ((locus = maybe_get_identifier ("locus")))
|
if ((locus = maybe_get_identifier ("locus")))
|
{
|
{
|
locus = identifier_global_value (locus);
|
locus = identifier_global_value (locus);
|
if (locus)
|
if (locus)
|
{
|
{
|
if (TREE_CODE (locus) != TYPE_DECL)
|
if (TREE_CODE (locus) != TYPE_DECL)
|
{
|
{
|
error ("%<locus%> is not defined as a type");
|
error ("%<locus%> is not defined as a type");
|
locus = 0;
|
locus = 0;
|
}
|
}
|
else
|
else
|
locus = TREE_TYPE (locus);
|
locus = TREE_TYPE (locus);
|
}
|
}
|
}
|
}
|
|
|
/* Assign the new data for use. */
|
/* Assign the new data for use. */
|
|
|
/* Handle the __gcc_gfc__ format specifics. */
|
/* Handle the __gcc_gfc__ format specifics. */
|
if (!gfc_fci)
|
if (!gfc_fci)
|
dynamic_format_types[gcc_gfc_format_type].conversion_specs =
|
dynamic_format_types[gcc_gfc_format_type].conversion_specs =
|
gfc_fci = (format_char_info *)
|
gfc_fci = (format_char_info *)
|
xmemdup (gcc_gfc_char_table,
|
xmemdup (gcc_gfc_char_table,
|
sizeof (gcc_gfc_char_table),
|
sizeof (gcc_gfc_char_table),
|
sizeof (gcc_gfc_char_table));
|
sizeof (gcc_gfc_char_table));
|
if (locus)
|
if (locus)
|
{
|
{
|
const unsigned i = find_char_info_specifier_index (gfc_fci, 'L');
|
const unsigned i = find_char_info_specifier_index (gfc_fci, 'L');
|
gfc_fci[i].types[0].type = &locus;
|
gfc_fci[i].types[0].type = &locus;
|
gfc_fci[i].pointer_count = 1;
|
gfc_fci[i].pointer_count = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Determine the types of "tree" and "location_t" in the code being
|
/* Determine the types of "tree" and "location_t" in the code being
|
compiled for use in GCC's diagnostic custom format attributes. You
|
compiled for use in GCC's diagnostic custom format attributes. You
|
must have set dynamic_format_types before calling this function. */
|
must have set dynamic_format_types before calling this function. */
|
static void
|
static void
|
init_dynamic_diag_info (void)
|
init_dynamic_diag_info (void)
|
{
|
{
|
static tree t, loc, hwi;
|
static tree t, loc, hwi;
|
|
|
if (!loc || !t || !hwi)
|
if (!loc || !t || !hwi)
|
{
|
{
|
static format_char_info *diag_fci, *tdiag_fci, *cdiag_fci, *cxxdiag_fci;
|
static format_char_info *diag_fci, *tdiag_fci, *cdiag_fci, *cxxdiag_fci;
|
static format_length_info *diag_ls;
|
static format_length_info *diag_ls;
|
unsigned int i;
|
unsigned int i;
|
|
|
/* For the GCC-diagnostics custom format specifiers to work, one
|
/* 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
|
those attributes. If we haven't seen these declarations then
|
you shouldn't use the specifiers requiring these types.
|
you shouldn't use the specifiers requiring these types.
|
However we don't force a hard ICE because we may see only one
|
However we don't force a hard ICE because we may see only one
|
or the other type. */
|
or the other type. */
|
if ((loc = maybe_get_identifier ("location_t")))
|
if ((loc = maybe_get_identifier ("location_t")))
|
{
|
{
|
loc = identifier_global_value (loc);
|
loc = identifier_global_value (loc);
|
if (loc)
|
if (loc)
|
{
|
{
|
if (TREE_CODE (loc) != TYPE_DECL)
|
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;
|
loc = 0;
|
}
|
}
|
else
|
else
|
loc = TREE_TYPE (loc);
|
loc = TREE_TYPE (loc);
|
}
|
}
|
}
|
}
|
|
|
/* 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. */
|
an extra type level. */
|
if ((t = maybe_get_identifier ("tree")))
|
if ((t = maybe_get_identifier ("tree")))
|
{
|
{
|
t = identifier_global_value (t);
|
t = identifier_global_value (t);
|
if (t)
|
if (t)
|
{
|
{
|
if (TREE_CODE (t) != TYPE_DECL)
|
if (TREE_CODE (t) != TYPE_DECL)
|
{
|
{
|
error ("%<tree%> is not defined as a type");
|
error ("%<tree%> is not defined as a type");
|
t = 0;
|
t = 0;
|
}
|
}
|
else if (TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE)
|
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;
|
t = 0;
|
}
|
}
|
else
|
else
|
t = TREE_TYPE (TREE_TYPE (t));
|
t = TREE_TYPE (TREE_TYPE (t));
|
}
|
}
|
}
|
}
|
|
|
/* Find the underlying type for HOST_WIDE_INT. For the %w
|
/* Find the underlying type for HOST_WIDE_INT. For the %w
|
length modifier to work, one must have issued: "typedef
|
length modifier to work, one must have issued: "typedef
|
HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
|
HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
|
prior to using that modifier. */
|
prior to using that modifier. */
|
if ((hwi = maybe_get_identifier ("__gcc_host_wide_int__")))
|
if ((hwi = maybe_get_identifier ("__gcc_host_wide_int__")))
|
{
|
{
|
hwi = identifier_global_value (hwi);
|
hwi = identifier_global_value (hwi);
|
if (hwi)
|
if (hwi)
|
{
|
{
|
if (TREE_CODE (hwi) != TYPE_DECL)
|
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;
|
hwi = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
hwi = DECL_ORIGINAL_TYPE (hwi);
|
hwi = DECL_ORIGINAL_TYPE (hwi);
|
gcc_assert (hwi);
|
gcc_assert (hwi);
|
if (hwi != long_integer_type_node
|
if (hwi != long_integer_type_node
|
&& hwi != long_long_integer_type_node)
|
&& hwi != long_long_integer_type_node)
|
{
|
{
|
error ("%<__gcc_host_wide_int__%> is not defined"
|
error ("%<__gcc_host_wide_int__%> is not defined"
|
" as %<long%> or %<long long%>");
|
" as %<long%> or %<long long%>");
|
hwi = 0;
|
hwi = 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Assign the new data for use. */
|
/* Assign the new data for use. */
|
|
|
/* All the GCC diag formats use the same length specs. */
|
/* 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_diag_format_type].length_char_specs =
|
dynamic_format_types[gcc_tdiag_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_cdiag_format_type].length_char_specs =
|
dynamic_format_types[gcc_cxxdiag_format_type].length_char_specs =
|
dynamic_format_types[gcc_cxxdiag_format_type].length_char_specs =
|
diag_ls = (format_length_info *)
|
diag_ls = (format_length_info *)
|
xmemdup (gcc_diag_length_specs,
|
xmemdup (gcc_diag_length_specs,
|
sizeof (gcc_diag_length_specs),
|
sizeof (gcc_diag_length_specs),
|
sizeof (gcc_diag_length_specs));
|
sizeof (gcc_diag_length_specs));
|
if (hwi)
|
if (hwi)
|
{
|
{
|
/* HOST_WIDE_INT must be one of 'long' or 'long long'. */
|
/* HOST_WIDE_INT must be one of 'long' or 'long long'. */
|
i = find_length_info_modifier_index (diag_ls, 'w');
|
i = find_length_info_modifier_index (diag_ls, 'w');
|
if (hwi == long_integer_type_node)
|
if (hwi == long_integer_type_node)
|
diag_ls[i].index = FMT_LEN_l;
|
diag_ls[i].index = FMT_LEN_l;
|
else if (hwi == long_long_integer_type_node)
|
else if (hwi == long_long_integer_type_node)
|
diag_ls[i].index = FMT_LEN_ll;
|
diag_ls[i].index = FMT_LEN_ll;
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* Handle the __gcc_diag__ format specifics. */
|
/* Handle the __gcc_diag__ format specifics. */
|
if (!diag_fci)
|
if (!diag_fci)
|
dynamic_format_types[gcc_diag_format_type].conversion_specs =
|
dynamic_format_types[gcc_diag_format_type].conversion_specs =
|
diag_fci = (format_char_info *)
|
diag_fci = (format_char_info *)
|
xmemdup (gcc_diag_char_table,
|
xmemdup (gcc_diag_char_table,
|
sizeof (gcc_diag_char_table),
|
sizeof (gcc_diag_char_table),
|
sizeof (gcc_diag_char_table));
|
sizeof (gcc_diag_char_table));
|
if (loc)
|
if (loc)
|
{
|
{
|
i = find_char_info_specifier_index (diag_fci, 'H');
|
i = find_char_info_specifier_index (diag_fci, 'H');
|
diag_fci[i].types[0].type = &loc;
|
diag_fci[i].types[0].type = &loc;
|
diag_fci[i].pointer_count = 1;
|
diag_fci[i].pointer_count = 1;
|
}
|
}
|
if (t)
|
if (t)
|
{
|
{
|
i = find_char_info_specifier_index (diag_fci, 'J');
|
i = find_char_info_specifier_index (diag_fci, 'J');
|
diag_fci[i].types[0].type = &t;
|
diag_fci[i].types[0].type = &t;
|
diag_fci[i].pointer_count = 1;
|
diag_fci[i].pointer_count = 1;
|
}
|
}
|
|
|
/* Handle the __gcc_tdiag__ format specifics. */
|
/* Handle the __gcc_tdiag__ format specifics. */
|
if (!tdiag_fci)
|
if (!tdiag_fci)
|
dynamic_format_types[gcc_tdiag_format_type].conversion_specs =
|
dynamic_format_types[gcc_tdiag_format_type].conversion_specs =
|
tdiag_fci = (format_char_info *)
|
tdiag_fci = (format_char_info *)
|
xmemdup (gcc_tdiag_char_table,
|
xmemdup (gcc_tdiag_char_table,
|
sizeof (gcc_tdiag_char_table),
|
sizeof (gcc_tdiag_char_table),
|
sizeof (gcc_tdiag_char_table));
|
sizeof (gcc_tdiag_char_table));
|
if (loc)
|
if (loc)
|
{
|
{
|
i = find_char_info_specifier_index (tdiag_fci, 'H');
|
i = find_char_info_specifier_index (tdiag_fci, 'H');
|
tdiag_fci[i].types[0].type = &loc;
|
tdiag_fci[i].types[0].type = &loc;
|
tdiag_fci[i].pointer_count = 1;
|
tdiag_fci[i].pointer_count = 1;
|
}
|
}
|
if (t)
|
if (t)
|
{
|
{
|
/* All specifiers taking a tree share the same struct. */
|
/* All specifiers taking a tree share the same struct. */
|
i = find_char_info_specifier_index (tdiag_fci, 'D');
|
i = find_char_info_specifier_index (tdiag_fci, 'D');
|
tdiag_fci[i].types[0].type = &t;
|
tdiag_fci[i].types[0].type = &t;
|
tdiag_fci[i].pointer_count = 1;
|
tdiag_fci[i].pointer_count = 1;
|
i = find_char_info_specifier_index (tdiag_fci, 'J');
|
i = find_char_info_specifier_index (tdiag_fci, 'J');
|
tdiag_fci[i].types[0].type = &t;
|
tdiag_fci[i].types[0].type = &t;
|
tdiag_fci[i].pointer_count = 1;
|
tdiag_fci[i].pointer_count = 1;
|
}
|
}
|
|
|
/* Handle the __gcc_cdiag__ format specifics. */
|
/* Handle the __gcc_cdiag__ format specifics. */
|
if (!cdiag_fci)
|
if (!cdiag_fci)
|
dynamic_format_types[gcc_cdiag_format_type].conversion_specs =
|
dynamic_format_types[gcc_cdiag_format_type].conversion_specs =
|
cdiag_fci = (format_char_info *)
|
cdiag_fci = (format_char_info *)
|
xmemdup (gcc_cdiag_char_table,
|
xmemdup (gcc_cdiag_char_table,
|
sizeof (gcc_cdiag_char_table),
|
sizeof (gcc_cdiag_char_table),
|
sizeof (gcc_cdiag_char_table));
|
sizeof (gcc_cdiag_char_table));
|
if (loc)
|
if (loc)
|
{
|
{
|
i = find_char_info_specifier_index (cdiag_fci, 'H');
|
i = find_char_info_specifier_index (cdiag_fci, 'H');
|
cdiag_fci[i].types[0].type = &loc;
|
cdiag_fci[i].types[0].type = &loc;
|
cdiag_fci[i].pointer_count = 1;
|
cdiag_fci[i].pointer_count = 1;
|
}
|
}
|
if (t)
|
if (t)
|
{
|
{
|
/* All specifiers taking a tree share the same struct. */
|
/* All specifiers taking a tree share the same struct. */
|
i = find_char_info_specifier_index (cdiag_fci, 'D');
|
i = find_char_info_specifier_index (cdiag_fci, 'D');
|
cdiag_fci[i].types[0].type = &t;
|
cdiag_fci[i].types[0].type = &t;
|
cdiag_fci[i].pointer_count = 1;
|
cdiag_fci[i].pointer_count = 1;
|
i = find_char_info_specifier_index (cdiag_fci, 'J');
|
i = find_char_info_specifier_index (cdiag_fci, 'J');
|
cdiag_fci[i].types[0].type = &t;
|
cdiag_fci[i].types[0].type = &t;
|
cdiag_fci[i].pointer_count = 1;
|
cdiag_fci[i].pointer_count = 1;
|
}
|
}
|
|
|
/* Handle the __gcc_cxxdiag__ format specifics. */
|
/* Handle the __gcc_cxxdiag__ format specifics. */
|
if (!cxxdiag_fci)
|
if (!cxxdiag_fci)
|
dynamic_format_types[gcc_cxxdiag_format_type].conversion_specs =
|
dynamic_format_types[gcc_cxxdiag_format_type].conversion_specs =
|
cxxdiag_fci = (format_char_info *)
|
cxxdiag_fci = (format_char_info *)
|
xmemdup (gcc_cxxdiag_char_table,
|
xmemdup (gcc_cxxdiag_char_table,
|
sizeof (gcc_cxxdiag_char_table),
|
sizeof (gcc_cxxdiag_char_table),
|
sizeof (gcc_cxxdiag_char_table));
|
sizeof (gcc_cxxdiag_char_table));
|
if (loc)
|
if (loc)
|
{
|
{
|
i = find_char_info_specifier_index (cxxdiag_fci, 'H');
|
i = find_char_info_specifier_index (cxxdiag_fci, 'H');
|
cxxdiag_fci[i].types[0].type = &loc;
|
cxxdiag_fci[i].types[0].type = &loc;
|
cxxdiag_fci[i].pointer_count = 1;
|
cxxdiag_fci[i].pointer_count = 1;
|
}
|
}
|
if (t)
|
if (t)
|
{
|
{
|
/* All specifiers taking a tree share the same struct. */
|
/* All specifiers taking a tree share the same struct. */
|
i = find_char_info_specifier_index (cxxdiag_fci, 'D');
|
i = find_char_info_specifier_index (cxxdiag_fci, 'D');
|
cxxdiag_fci[i].types[0].type = &t;
|
cxxdiag_fci[i].types[0].type = &t;
|
cxxdiag_fci[i].pointer_count = 1;
|
cxxdiag_fci[i].pointer_count = 1;
|
i = find_char_info_specifier_index (cxxdiag_fci, 'J');
|
i = find_char_info_specifier_index (cxxdiag_fci, 'J');
|
cxxdiag_fci[i].types[0].type = &t;
|
cxxdiag_fci[i].types[0].type = &t;
|
cxxdiag_fci[i].pointer_count = 1;
|
cxxdiag_fci[i].pointer_count = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
#ifdef TARGET_FORMAT_TYPES
|
#ifdef TARGET_FORMAT_TYPES
|
extern const format_kind_info TARGET_FORMAT_TYPES[];
|
extern const format_kind_info TARGET_FORMAT_TYPES[];
|
#endif
|
#endif
|
|
|
/* Handle a "format" attribute; arguments as in
|
/* Handle a "format" attribute; arguments as in
|
struct attribute_spec.handler. */
|
struct attribute_spec.handler. */
|
tree
|
tree
|
handle_format_attribute (tree *node, tree ARG_UNUSED (name), tree args,
|
handle_format_attribute (tree *node, tree ARG_UNUSED (name), tree args,
|
int flags, bool *no_add_attrs)
|
int flags, bool *no_add_attrs)
|
{
|
{
|
tree type = *node;
|
tree type = *node;
|
function_format_info info;
|
function_format_info info;
|
tree argument;
|
tree argument;
|
|
|
#ifdef TARGET_FORMAT_TYPES
|
#ifdef TARGET_FORMAT_TYPES
|
/* If the target provides additional format types, we need to
|
/* If the target provides additional format types, we need to
|
add them to FORMAT_TYPES at first use. */
|
add them to FORMAT_TYPES at first use. */
|
if (TARGET_FORMAT_TYPES != NULL && !dynamic_format_types)
|
if (TARGET_FORMAT_TYPES != NULL && !dynamic_format_types)
|
{
|
{
|
dynamic_format_types = xmalloc ((n_format_types + TARGET_N_FORMAT_TYPES)
|
dynamic_format_types = xmalloc ((n_format_types + TARGET_N_FORMAT_TYPES)
|
* sizeof (dynamic_format_types[0]));
|
* sizeof (dynamic_format_types[0]));
|
memcpy (dynamic_format_types, format_types_orig,
|
memcpy (dynamic_format_types, format_types_orig,
|
sizeof (format_types_orig));
|
sizeof (format_types_orig));
|
memcpy (&dynamic_format_types[n_format_types], TARGET_FORMAT_TYPES,
|
memcpy (&dynamic_format_types[n_format_types], TARGET_FORMAT_TYPES,
|
TARGET_N_FORMAT_TYPES * sizeof (dynamic_format_types[0]));
|
TARGET_N_FORMAT_TYPES * sizeof (dynamic_format_types[0]));
|
|
|
format_types = dynamic_format_types;
|
format_types = dynamic_format_types;
|
n_format_types += TARGET_N_FORMAT_TYPES;
|
n_format_types += TARGET_N_FORMAT_TYPES;
|
}
|
}
|
#endif
|
#endif
|
|
|
if (!decode_format_attr (args, &info, 0))
|
if (!decode_format_attr (args, &info, 0))
|
{
|
{
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
argument = TYPE_ARG_TYPES (type);
|
argument = TYPE_ARG_TYPES (type);
|
if (argument)
|
if (argument)
|
{
|
{
|
if (!check_format_string (argument, info.format_num, flags,
|
if (!check_format_string (argument, info.format_num, flags,
|
no_add_attrs))
|
no_add_attrs))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
if (info.first_arg_num != 0)
|
if (info.first_arg_num != 0)
|
{
|
{
|
unsigned HOST_WIDE_INT arg_num = 1;
|
unsigned HOST_WIDE_INT arg_num = 1;
|
|
|
/* Verify that first_arg_num points to the last arg,
|
/* Verify that first_arg_num points to the last arg,
|
the ... */
|
the ... */
|
while (argument)
|
while (argument)
|
arg_num++, argument = TREE_CHAIN (argument);
|
arg_num++, argument = TREE_CHAIN (argument);
|
|
|
if (arg_num != info.first_arg_num)
|
if (arg_num != info.first_arg_num)
|
{
|
{
|
if (!(flags & (int) ATTR_FLAG_BUILT_IN))
|
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;
|
*no_add_attrs = true;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (info.format_type == strftime_format_type && info.first_arg_num != 0)
|
if (info.format_type == strftime_format_type && info.first_arg_num != 0)
|
{
|
{
|
error ("strftime formats cannot format arguments");
|
error ("strftime formats cannot format arguments");
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* If this is a custom GCC-internal format type, we have to
|
/* If this is a custom GCC-internal format type, we have to
|
initialize certain bits a runtime. */
|
initialize certain bits a runtime. */
|
if (info.format_type == asm_fprintf_format_type
|
if (info.format_type == asm_fprintf_format_type
|
|| info.format_type == gcc_gfc_format_type
|
|| info.format_type == gcc_gfc_format_type
|
|| info.format_type == gcc_diag_format_type
|
|| info.format_type == gcc_diag_format_type
|
|| info.format_type == gcc_tdiag_format_type
|
|| info.format_type == gcc_tdiag_format_type
|
|| info.format_type == gcc_cdiag_format_type
|
|| info.format_type == gcc_cdiag_format_type
|
|| info.format_type == gcc_cxxdiag_format_type)
|
|| info.format_type == gcc_cxxdiag_format_type)
|
{
|
{
|
/* Our first time through, we have to make sure that our
|
/* 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)
|
if (!dynamic_format_types)
|
format_types = dynamic_format_types = (format_kind_info *)
|
format_types = dynamic_format_types = (format_kind_info *)
|
xmemdup (format_types_orig, sizeof (format_types_orig),
|
xmemdup (format_types_orig, sizeof (format_types_orig),
|
sizeof (format_types_orig));
|
sizeof (format_types_orig));
|
|
|
/* If this is format __asm_fprintf__, we have to initialize
|
/* 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)
|
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
|
/* If this is format __gcc_gfc__, we have to initialize GCC's
|
notion of 'locus' at runtime for %L. */
|
notion of 'locus' at runtime for %L. */
|
else if (info.format_type == gcc_gfc_format_type)
|
else if (info.format_type == gcc_gfc_format_type)
|
init_dynamic_gfc_info ();
|
init_dynamic_gfc_info ();
|
/* If this is one of the diagnostic attributes, then we have to
|
/* 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
|
else if (info.format_type == gcc_diag_format_type
|
|| info.format_type == gcc_tdiag_format_type
|
|| info.format_type == gcc_tdiag_format_type
|
|| info.format_type == gcc_cdiag_format_type
|
|| info.format_type == gcc_cdiag_format_type
|
|| info.format_type == gcc_cxxdiag_format_type)
|
|| info.format_type == gcc_cxxdiag_format_type)
|
init_dynamic_diag_info ();
|
init_dynamic_diag_info ();
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
