on information stored in GCC's tree structure. This code implements the
-aux-info option.
Copyright (C) 1989, 1991, 1994, 1995, 1997, 1998,
- 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
+ 1999, 2000, 2003, 2004, 2007, 2010 Free Software Foundation, Inc.
Contributed by Ron Guilmette (rfg@segfault.us.com).
This file is part of GCC.
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
-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
for more details.
You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "flags.h"
#include "tree.h"
#include "c-tree.h"
-#include "toplev.h"
enum formals_style_enum {
ansi,
static char *affix_data_type (const char *) ATTRIBUTE_MALLOC;
static const char *gen_formal_list_for_type (tree, formals_style);
-static int deserves_ellipsis (tree);
static const char *gen_formal_list_for_func_def (tree, formals_style);
static const char *gen_type (const char *, tree, formals_style);
static const char *gen_decl (tree, int, formals_style);
for (;;)
{
if (!strncmp (p, "volatile ", 9))
- {
- p += 9;
- continue;
- }
+ {
+ p += 9;
+ continue;
+ }
if (!strncmp (p, "const ", 6))
- {
- p += 6;
- continue;
- }
+ {
+ p += 6;
+ continue;
+ }
break;
}
const char *this_type;
if (*formal_list)
- formal_list = concat (formal_list, ", ", NULL);
+ formal_list = concat (formal_list, ", ", NULL);
this_type = gen_type ("", TREE_VALUE (formal_type), ansi);
formal_list
if (!*formal_list)
{
- if (TYPE_ARG_TYPES (fntype))
- /* assert (TREE_VALUE (TYPE_ARG_TYPES (fntype)) == void_type_node); */
- formal_list = "void";
+ if (prototype_p (fntype))
+ /* assert (TREE_VALUE (TYPE_ARG_TYPES (fntype)) == void_type_node); */
+ formal_list = "void";
else
- formal_list = "/* ??? */";
+ formal_list = "/* ??? */";
}
else
{
/* If there were at least some parameters, and if the formals-types-list
- petered out to a NULL (i.e. without being terminated by a
- void_type_node) then we need to tack on an ellipsis. */
+ petered out to a NULL (i.e. without being terminated by a
+ void_type_node) then we need to tack on an ellipsis. */
if (!formal_type)
- formal_list = concat (formal_list, ", ...", NULL);
+ formal_list = concat (formal_list, ", ...", NULL);
}
return concat (" (", formal_list, ")", NULL);
}
-/* For the generation of an ANSI prototype for a function definition, we have
- to look at the formal parameter list of the function's own "type" to
- determine if the function's formal parameter list should end with an
- ellipsis. Given a tree node, the following function will return nonzero
- if the "function type" parameter list should end with an ellipsis. */
-
-static int
-deserves_ellipsis (tree fntype)
-{
- tree formal_type;
-
- formal_type = TYPE_ARG_TYPES (fntype);
- while (formal_type && TREE_VALUE (formal_type) != void_type_node)
- formal_type = TREE_CHAIN (formal_type);
-
- /* If there were at least some parameters, and if the formals-types-list
- petered out to a NULL (i.e. without being terminated by a void_type_node)
- then we need to tack on an ellipsis. */
-
- return (!formal_type && TYPE_ARG_TYPES (fntype));
-}
-
/* Generate a parameter list for a function definition (in some given style).
Note that this routine has to be separate (and different) from the code that
const char *this_formal;
if (*formal_list && ((style == ansi) || (style == k_and_r_names)))
- formal_list = concat (formal_list, ", ", NULL);
+ formal_list = concat (formal_list, ", ", NULL);
this_formal = gen_decl (formal_decl, 0, style);
if (style == k_and_r_decls)
- formal_list = concat (formal_list, this_formal, "; ", NULL);
+ formal_list = concat (formal_list, this_formal, "; ", NULL);
else
- formal_list = concat (formal_list, this_formal, NULL);
+ formal_list = concat (formal_list, this_formal, NULL);
formal_decl = TREE_CHAIN (formal_decl);
}
if (style == ansi)
{
if (!DECL_ARGUMENTS (fndecl))
- formal_list = concat (formal_list, "void", NULL);
- if (deserves_ellipsis (TREE_TYPE (fndecl)))
- formal_list = concat (formal_list, ", ...", NULL);
+ formal_list = concat (formal_list, "void", NULL);
+ if (stdarg_p (TREE_TYPE (fndecl)))
+ formal_list = concat (formal_list, ", ...", NULL);
}
if ((style == ansi) || (style == k_and_r_names))
formal_list = concat (" (", formal_list, ")", NULL);
else
{
switch (TREE_CODE (t))
- {
- case POINTER_TYPE:
- if (TYPE_READONLY (t))
- ret_val = concat ("const ", ret_val, NULL);
- if (TYPE_VOLATILE (t))
- ret_val = concat ("volatile ", ret_val, NULL);
+ {
+ case POINTER_TYPE:
+ if (TYPE_READONLY (t))
+ ret_val = concat ("const ", ret_val, NULL);
+ if (TYPE_VOLATILE (t))
+ ret_val = concat ("volatile ", ret_val, NULL);
- ret_val = concat ("*", ret_val, NULL);
+ ret_val = concat ("*", ret_val, NULL);
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
ret_val = concat ("(", ret_val, ")", NULL);
- ret_val = gen_type (ret_val, TREE_TYPE (t), style);
+ ret_val = gen_type (ret_val, TREE_TYPE (t), style);
- return ret_val;
+ return ret_val;
- case ARRAY_TYPE:
+ case ARRAY_TYPE:
if (!COMPLETE_TYPE_P (t) || TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
ret_val = gen_type (concat (ret_val, "[]", NULL),
TREE_TYPE (t), style);
ret_val = gen_type (concat (ret_val, buff, NULL),
TREE_TYPE (t), style);
}
- break;
+ break;
- case FUNCTION_TYPE:
- ret_val = gen_type (concat (ret_val,
+ case FUNCTION_TYPE:
+ ret_val = gen_type (concat (ret_val,
gen_formal_list_for_type (t, style),
NULL),
TREE_TYPE (t), style);
- break;
+ break;
- case IDENTIFIER_NODE:
- data_type = IDENTIFIER_POINTER (t);
- break;
+ case IDENTIFIER_NODE:
+ data_type = IDENTIFIER_POINTER (t);
+ break;
/* The following three cases are complicated by the fact that a
- user may do something really stupid, like creating a brand new
- "anonymous" type specification in a formal argument list (or as
- part of a function return type specification). For example:
+ user may do something really stupid, like creating a brand new
+ "anonymous" type specification in a formal argument list (or as
+ part of a function return type specification). For example:
int f (enum { red, green, blue } color);
to represent the (anonymous) type. Thus, we have to generate the
whole darn type specification. Yuck! */
- case RECORD_TYPE:
+ case RECORD_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
data_type = concat ("struct ", data_type, NULL);
break;
- case UNION_TYPE:
+ case UNION_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
data_type = concat ("union ", data_type, NULL);
break;
- case ENUMERAL_TYPE:
+ case ENUMERAL_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
data_type = concat ("enum ", data_type, NULL);
break;
- case TYPE_DECL:
- data_type = IDENTIFIER_POINTER (DECL_NAME (t));
- break;
+ case TYPE_DECL:
+ data_type = IDENTIFIER_POINTER (DECL_NAME (t));
+ break;
- case INTEGER_TYPE:
- data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
- /* Normally, `unsigned' is part of the deal. Not so if it comes
+ case INTEGER_TYPE:
+ case FIXED_POINT_TYPE:
+ data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
+ /* Normally, `unsigned' is part of the deal. Not so if it comes
with a type qualifier. */
- if (TYPE_UNSIGNED (t) && TYPE_QUALS (t))
+ if (TYPE_UNSIGNED (t) && TYPE_QUALS (t))
data_type = concat ("unsigned ", data_type, NULL);
break;
- case REAL_TYPE:
- data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
- break;
+ case REAL_TYPE:
+ data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
+ break;
- case VOID_TYPE:
- data_type = "void";
- break;
+ case VOID_TYPE:
+ data_type = "void";
+ break;
case ERROR_MARK:
data_type = "[ERROR]";
break;
- default:
- abort ();
- }
+ default:
+ gcc_unreachable ();
+ }
}
if (TYPE_READONLY (t))
ret_val = concat ("const ", ret_val, NULL);
NULL);
/* Since we have already added in the formals list stuff, here we don't
- add the whole "type" of the function we are considering (which
- would include its parameter-list info), rather, we only add in
- the "type" of the "type" of the function, which is really just
- the return-type of the function (and does not include the parameter
- list info). */
+ add the whole "type" of the function we are considering (which
+ would include its parameter-list info), rather, we only add in
+ the "type" of the "type" of the function, which is really just
+ the return-type of the function (and does not include the parameter
+ list info). */
ret_val = gen_type (ret_val, TREE_TYPE (TREE_TYPE (decl)), style);
}
/* Each output .X file must have a header line. Write one now if we
have not yet done so. */
- if (! compiled_from_record++)
+ if (!compiled_from_record++)
{
/* The first line tells which directory file names are relative to.
Currently, -aux-info works only for files in the working
OSDN Git Service
