/* Generate information regarding function declarations and definitions based
on information stored in GCC's tree structure. This code implements the
- -fgen-aux-info option.
-
- This code was written by Ron Guilmette (rfg@mcc.com).
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ -aux-info option.
+ Copyright (C) 1989, 1991, 1994, 1995, 1997, 1998,
+ 1999, 2000 Free Software Foundation, Inc.
+ Contributed by Ron Guilmette (rfg@segfault.us.com).
This file is part of GNU CC.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
-#include <stdio.h>
-#include <sys/param.h>
-#include <errno.h>
#include "config.h"
+#include "system.h"
+#include "toplev.h"
#include "flags.h"
#include "tree.h"
#include "c-tree.h"
-#ifndef errno
-extern int errno;
-#endif
-
-extern char* xmalloc ();
-
enum formals_style_enum {
ansi,
k_and_r_names,
typedef enum formals_style_enum formals_style;
-static char* data_type;
-
-static char * concat ();
-static char * concat3 ();
-static char * gen_formal_list_for_type ();
-static int deserves_ellipsis ();
-static char * gen_formal_list_for_func_def ();
-static char * gen_type ();
-static char * gen_decl ();
-void gen_aux_info_record ();
-
-/* Virtually every UN*X system now in common use (except for pre-4.3-tahoe
- BSD systems) now provides getcwd as called for by POSIX. Allow for
- the few exceptions to the general rule here. */
-
-#if !(defined (USG) || defined (VMS))
-extern char *getwd ();
-#define getcwd(buf,len) getwd(buf)
-#define GUESSPATHLEN (MAXPATHLEN + 1)
-#else /* (defined (USG) || defined (VMS)) */
-extern char *getcwd ();
-/* We actually use this as a starting point, not a limit. */
-#define GUESSPATHLEN 100
-#endif /* (defined (USG) || defined (VMS)) */
-\f
-/* Take two strings and mash them together into a newly allocated area. */
-
-static char*
-concat (s1, s2)
- char* s1;
- char* s2;
-{
- int size1, size2;
- char* ret_val;
-
- if (!s1)
- s1 = "";
- if (!s2)
- s2 = "";
-
- size1 = strlen (s1);
- size2 = strlen (s2);
- ret_val = xmalloc (size1 + size2 + 1);
- strcpy (ret_val, s1);
- strcpy (&ret_val[size1], s2);
- return ret_val;
-}
-
-/* Take three strings and mash them together into a newly allocated area. */
-
-static char*
-concat3 (s1, s2, s3)
- char* s1;
- char* s2;
- char* s3;
-{
- int size1, size2, size3;
- char* ret_val;
-
- if (!s1)
- s1 = "";
- if (!s2)
- s2 = "";
- if (!s3)
- s3 = "";
-
- size1 = strlen (s1);
- size2 = strlen (s2);
- size3 = strlen (s3);
- ret_val = xmalloc (size1 + size2 + size3 + 1);
- strcpy (ret_val, s1);
- strcpy (&ret_val[size1], s2);
- strcpy (&ret_val[size1+size2], s3);
- return ret_val;
-}
+static const char *data_type;
+static char *affix_data_type PARAMS ((const char *));
+static const char *gen_formal_list_for_type PARAMS ((tree, formals_style));
+static int deserves_ellipsis PARAMS ((tree));
+static const char *gen_formal_list_for_func_def PARAMS ((tree, formals_style));
+static const char *gen_type PARAMS ((const char *, tree, formals_style));
+static const char *gen_decl PARAMS ((tree, int, formals_style));
+\f
/* Given a string representing an entire type or an entire declaration
which only lacks the actual "data-type" specifier (at its left end),
affix the data-type specifier to the left end of the given type
`const char *foo;' and *not* `char const *foo;' so we try to create types
that look as expected. */
-static char*
-affix_data_type (type_or_decl)
- char *type_or_decl;
+static char *
+affix_data_type (param)
+ const char *param;
{
+ char *type_or_decl = (char *) alloca (strlen (param) + 1);
char *p = type_or_decl;
char *qualifiers_then_data_type;
char saved;
+ strcpy (type_or_decl, param);
+
/* Skip as many leading const's or volatile's as there are. */
for (;;)
{
- if (!strncmp (p, "volatile", 8))
+ if (!strncmp (p, "volatile ", 9))
{
p += 9;
continue;
}
- if (!strncmp (p, "const", 5))
+ if (!strncmp (p, "const ", 6))
{
p += 6;
continue;
add a blank after the data-type of course. */
if (p == type_or_decl)
- return concat3 (data_type, " ", type_or_decl);
+ return concat (data_type, " ", type_or_decl, NULL_PTR);
saved = *p;
*p = '\0';
- qualifiers_then_data_type = concat (type_or_decl, data_type);
+ qualifiers_then_data_type = concat (type_or_decl, data_type, NULL_PTR);
*p = saved;
- return concat3 (qualifiers_then_data_type, " ", p);
+ return concat (qualifiers_then_data_type, " ", p, NULL_PTR);
}
/* Given a tree node which represents some "function type", generate the
this function type. Return the whole formal parameter list (including
a pair of surrounding parens) as a string. Note that if the style
we are currently aiming for is non-ansi, then we just return a pair
- of empty parens here. */
+ of empty parens here. */
-static char*
+static const char *
gen_formal_list_for_type (fntype, style)
tree fntype;
formals_style style;
{
- char* formal_list = "";
+ const char *formal_list = "";
tree formal_type;
if (style != ansi)
formal_type = TYPE_ARG_TYPES (fntype);
while (formal_type && TREE_VALUE (formal_type) != void_type_node)
{
- char* this_type;
+ const char *this_type;
if (*formal_list)
- formal_list = concat (formal_list, ", ");
+ formal_list = concat (formal_list, ", ", NULL_PTR);
this_type = gen_type ("", TREE_VALUE (formal_type), ansi);
- formal_list =
- (strlen (this_type))
- ? concat (formal_list, affix_data_type (this_type))
- : concat (formal_list, data_type);
+ formal_list
+ = ((strlen (this_type))
+ ? concat (formal_list, affix_data_type (this_type), NULL_PTR)
+ : concat (formal_list, data_type, NULL_PTR));
formal_type = TREE_CHAIN (formal_type);
}
to output the "void" verbatim, and that what we do. In the former case,
we do our best to give protoize something nice to insert.
- This "something nice" should be something that is still legal (when
+ This "something nice" should be something that is still valid (when
re-compiled) but something that can clearly indicate to the user that
more typing information (for the parameter list) should be added (by
hand) at some convenient moment.
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, ", ...");
+ formal_list = concat (formal_list, ", ...", NULL_PTR);
}
- return concat3 (" (", formal_list, ")");
+ return concat (" (", formal_list, ")", NULL_PTR);
}
/* For the generation of an ANSI prototype for a function definition, we have
This routine returns a string which is the source form for the entire
function formal parameter list. */
-static char*
+static const char *
gen_formal_list_for_func_def (fndecl, style)
tree fndecl;
formals_style style;
{
- char* formal_list = "";
+ const char *formal_list = "";
tree formal_decl;
formal_decl = DECL_ARGUMENTS (fndecl);
while (formal_decl)
{
- char *this_formal;
+ const char *this_formal;
if (*formal_list && ((style == ansi) || (style == k_and_r_names)))
- formal_list = concat (formal_list, ", ");
+ formal_list = concat (formal_list, ", ", NULL_PTR);
this_formal = gen_decl (formal_decl, 0, style);
if (style == k_and_r_decls)
- formal_list = concat3 (formal_list, this_formal, "; ");
+ formal_list = concat (formal_list, this_formal, "; ", NULL_PTR);
else
- formal_list = concat (formal_list, this_formal);
+ formal_list = concat (formal_list, this_formal, NULL_PTR);
formal_decl = TREE_CHAIN (formal_decl);
}
if (style == ansi)
{
if (!DECL_ARGUMENTS (fndecl))
- formal_list = concat (formal_list, "void");
+ formal_list = concat (formal_list, "void", NULL_PTR);
if (deserves_ellipsis (TREE_TYPE (fndecl)))
- formal_list = concat (formal_list, ", ...");
+ formal_list = concat (formal_list, ", ...", NULL_PTR);
}
if ((style == ansi) || (style == k_and_r_names))
- formal_list = concat3 (" (", formal_list, ")");
+ formal_list = concat (" (", formal_list, ")", NULL_PTR);
return formal_list;
}
to do at this point is for the initial caller to prepend the "data_type"
string onto the returned "seed". */
-static char*
+static const char *
gen_type (ret_val, t, style)
- char* ret_val;
+ const char *ret_val;
tree t;
formals_style style;
{
tree chain_p;
- if (TYPE_NAME (t) && DECL_NAME (TYPE_NAME (t)))
+ /* If there is a typedef name for this type, use it. */
+ if (TYPE_NAME (t) && TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
else
{
{
case POINTER_TYPE:
if (TYPE_READONLY (t))
- ret_val = concat ("const ", ret_val);
+ ret_val = concat ("const ", ret_val, NULL_PTR);
if (TYPE_VOLATILE (t))
- ret_val = concat ("volatile ", ret_val);
+ ret_val = concat ("volatile ", ret_val, NULL_PTR);
- ret_val = concat ("*", ret_val);
+ ret_val = concat ("*", ret_val, NULL_PTR);
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
- ret_val = concat3 ("(", ret_val, ")");
+ ret_val = concat ("(", ret_val, ")", NULL_PTR);
ret_val = gen_type (ret_val, TREE_TYPE (t), style);
return ret_val;
case ARRAY_TYPE:
- ret_val = gen_type (concat (ret_val, "[]"), TREE_TYPE (t), style);
+ if (!COMPLETE_TYPE_P (t) || TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
+ ret_val = gen_type (concat (ret_val, "[]", NULL_PTR),
+ TREE_TYPE (t), style);
+ else if (int_size_in_bytes (t) == 0)
+ ret_val = gen_type (concat (ret_val, "[0]", NULL_PTR),
+ TREE_TYPE (t), style);
+ else
+ {
+ int size = (int_size_in_bytes (t) / int_size_in_bytes (TREE_TYPE (t)));
+ char buff[10];
+ sprintf (buff, "[%d]", size);
+ ret_val = gen_type (concat (ret_val, buff, NULL_PTR),
+ TREE_TYPE (t), style);
+ }
break;
case FUNCTION_TYPE:
- ret_val = gen_type (concat (ret_val, gen_formal_list_for_type (t, style)), TREE_TYPE (t), style);
+ ret_val = gen_type (concat (ret_val,
+ gen_formal_list_for_type (t, style),
+ NULL_PTR),
+ TREE_TYPE (t), style);
break;
case IDENTIFIER_NODE:
chain_p = TYPE_FIELDS (t);
while (chain_p)
{
- data_type = concat (data_type, gen_decl (chain_p, 0, ansi));
+ data_type = concat (data_type, gen_decl (chain_p, 0, ansi),
+ NULL_PTR);
chain_p = TREE_CHAIN (chain_p);
- data_type = concat (data_type, "; ");
+ data_type = concat (data_type, "; ", NULL_PTR);
}
- data_type = concat3 ("{ ", data_type, "}");
+ data_type = concat ("{ ", data_type, "}", NULL_PTR);
}
- data_type = concat ("struct ", data_type);
+ data_type = concat ("struct ", data_type, NULL_PTR);
break;
case UNION_TYPE:
chain_p = TYPE_FIELDS (t);
while (chain_p)
{
- data_type = concat (data_type, gen_decl (chain_p, 0, ansi));
+ data_type = concat (data_type, gen_decl (chain_p, 0, ansi),
+ NULL_PTR);
chain_p = TREE_CHAIN (chain_p);
- data_type = concat (data_type, "; ");
+ data_type = concat (data_type, "; ", NULL_PTR);
}
- data_type = concat3 ("{ ", data_type, "}");
+ data_type = concat ("{ ", data_type, "}", NULL_PTR);
}
- data_type = concat ("union ", data_type);
+ data_type = concat ("union ", data_type, NULL_PTR);
break;
case ENUMERAL_TYPE:
while (chain_p)
{
data_type = concat (data_type,
- IDENTIFIER_POINTER (TREE_PURPOSE (chain_p)));
+ IDENTIFIER_POINTER (TREE_PURPOSE (chain_p)), NULL_PTR);
chain_p = TREE_CHAIN (chain_p);
if (chain_p)
- data_type = concat (data_type, ", ");
+ data_type = concat (data_type, ", ", NULL_PTR);
}
- data_type = concat3 ("{ ", data_type, " }");
+ data_type = concat ("{ ", data_type, " }", NULL_PTR);
}
- data_type = concat ("enum ", data_type);
+ data_type = concat ("enum ", data_type, NULL_PTR);
break;
case TYPE_DECL:
case INTEGER_TYPE:
data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
/* Normally, `unsigned' is part of the deal. Not so if it comes
- with `const' or `volatile'. */
- if (TREE_UNSIGNED (t) && (TYPE_READONLY (t) || TYPE_VOLATILE (t)))
- data_type = concat ("unsigned ", data_type);
+ with a type qualifier. */
+ if (TREE_UNSIGNED (t) && TYPE_QUALS (t))
+ data_type = concat ("unsigned ", data_type, NULL_PTR);
break;
case REAL_TYPE:
data_type = "void";
break;
+ case ERROR_MARK:
+ data_type = "[ERROR]";
+ break;
+
default:
abort ();
}
}
if (TYPE_READONLY (t))
- ret_val = concat ("const ", ret_val);
+ ret_val = concat ("const ", ret_val, NULL_PTR);
if (TYPE_VOLATILE (t))
- ret_val = concat ("volatile ", ret_val);
+ ret_val = concat ("volatile ", ret_val, NULL_PTR);
+ if (TYPE_RESTRICT (t))
+ ret_val = concat ("restrict ", ret_val, NULL_PTR);
return ret_val;
}
associated with a function definition. In this case, we can assume that
an attached list of DECL nodes for function formal arguments is present. */
-static char*
+static const char *
gen_decl (decl, is_func_definition, style)
tree decl;
int is_func_definition;
formals_style style;
{
- char* ret_val;
- char* outer_modifier = "";
+ const char *ret_val;
if (DECL_NAME (decl))
ret_val = IDENTIFIER_POINTER (DECL_NAME (decl));
generate the qualifiers here. */
if (TREE_THIS_VOLATILE (decl))
- ret_val = concat ("volatile ", ret_val);
+ ret_val = concat ("volatile ", ret_val, NULL_PTR);
if (TREE_READONLY (decl))
- ret_val = concat ("const ", ret_val);
+ ret_val = concat ("const ", ret_val, NULL_PTR);
data_type = "";
if (TREE_CODE (decl) == FUNCTION_DECL && is_func_definition)
{
- ret_val = concat (ret_val, gen_formal_list_for_func_def (decl, ansi));
+ ret_val = concat (ret_val, gen_formal_list_for_func_def (decl, ansi),
+ NULL_PTR);
/* 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
ret_val = affix_data_type (ret_val);
- if (TREE_REGDECL (decl))
- ret_val = concat ("register ", ret_val);
+ if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
+ ret_val = concat ("register ", ret_val, NULL_PTR);
if (TREE_PUBLIC (decl))
- ret_val = concat ("extern ", ret_val);
+ ret_val = concat ("extern ", ret_val, NULL_PTR);
if (TREE_CODE (decl) == FUNCTION_DECL && !TREE_PUBLIC (decl))
- ret_val = concat ("static ", ret_val);
+ ret_val = concat ("static ", ret_val, NULL_PTR);
return ret_val;
}
-extern FILE* aux_info_file;
+extern FILE *aux_info_file;
/* Generate and write a new line of info to the aux-info (.X) file. This
routine is called once for each function declaration, and once for each
if (! compiled_from_record++)
{
- int size;
- char *wd;
- char *value;
-
- /* Read the working directory, avoiding arbitrary limit. */
- size = GUESSPATHLEN;
- while (1)
- {
- wd = (char *) xmalloc (size);
- value = getcwd (wd, size);
- if (value != 0 || errno != ERANGE)
- break;
- free (wd);
- size *= 2;
- }
-
- if (value != 0)
- fprintf (aux_info_file, "/* compiled from: %s */\n", wd);
+ /* The first line tells which directory file names are relative to.
+ Currently, -aux-info works only for files in the working
+ directory, so just use a `.' as a placeholder for now. */
+ fprintf (aux_info_file, "/* compiled from: . */\n");
}
/* Write the actual line of auxiliary info. */