2003-06-22 Andreas Jaeger <aj@suse.de>
+ * c-lex.c: Convert to ISO C90.
+ * c-objc-common.c: Likewise.
+ * c-opts.c: Likewise.
+ * c-pch.c: Likewise.
+ * c-ppoutput.c: Likewise.
+ * c-pragma.h: Likewise.
+ * c-pretty-print.c: Likewise.
+ * c-pretty-print.h: Likewise.
+ * c-semantics.c: Likewise.
+ * c-tree.h: Likewise.
+ * c-typeck.c: Likewise.
+
* c-lang.c: Convert to ISO C90.
2003-06-22 Neil Booth <neil@daikokuya.co.uk>
/* Nonzero tells yylex to ignore \ in string constants. */
static int ignore_escape_flag;
-static tree interpret_integer PARAMS ((const cpp_token *, unsigned int));
-static tree interpret_float PARAMS ((const cpp_token *, unsigned int));
+static tree interpret_integer (const cpp_token *, unsigned int);
+static tree interpret_float (const cpp_token *, unsigned int);
static enum integer_type_kind
- narrowest_unsigned_type PARAMS ((tree, unsigned int));
+ narrowest_unsigned_type (tree, unsigned int);
static enum integer_type_kind
- narrowest_signed_type PARAMS ((tree, unsigned int));
-static tree lex_string PARAMS ((const cpp_string *));
-static tree lex_charconst PARAMS ((const cpp_token *));
-static void update_header_times PARAMS ((const char *));
-static int dump_one_header PARAMS ((splay_tree_node, void *));
-static void cb_line_change PARAMS ((cpp_reader *, const cpp_token *, int));
-static void cb_ident PARAMS ((cpp_reader *, unsigned int,
- const cpp_string *));
-static void cb_def_pragma PARAMS ((cpp_reader *, unsigned int));
-static void cb_define PARAMS ((cpp_reader *, unsigned int,
- cpp_hashnode *));
-static void cb_undef PARAMS ((cpp_reader *, unsigned int,
- cpp_hashnode *));
+ narrowest_signed_type (tree, unsigned int);
+static tree lex_string (const cpp_string *);
+static tree lex_charconst (const cpp_token *);
+static void update_header_times (const char *);
+static int dump_one_header (splay_tree_node, void *);
+static void cb_line_change (cpp_reader *, const cpp_token *, int);
+static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
+static void cb_def_pragma (cpp_reader *, unsigned int);
+static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
+static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
\f
void
-init_c_lex ()
+init_c_lex (void)
{
struct cpp_callbacks *cb;
struct c_fileinfo *toplevel;
body_time = get_run_time ();
toplevel->time = body_time;
}
-
+
cb = cpp_get_callbacks (parse_in);
cb->line_change = cb_line_change;
}
struct c_fileinfo *
-get_fileinfo (name)
- const char *name;
+get_fileinfo (const char *name)
{
splay_tree_node n;
struct c_fileinfo *fi;
}
static void
-update_header_times (name)
- const char *name;
+update_header_times (const char *name)
{
/* Changing files again. This means currently collected time
is charged against header time, and body time starts back at 0. */
}
static int
-dump_one_header (n, dummy)
- splay_tree_node n;
- void *dummy ATTRIBUTE_UNUSED;
+dump_one_header (splay_tree_node n, void *dummy ATTRIBUTE_UNUSED)
{
print_time ((const char *) n->key,
((struct c_fileinfo *) n->value)->time);
}
void
-dump_time_statistics ()
+dump_time_statistics (void)
{
struct c_fileinfo *file = get_fileinfo (input_filename);
int this_time = get_run_time ();
}
static void
-cb_ident (pfile, line, str)
- cpp_reader *pfile ATTRIBUTE_UNUSED;
- unsigned int line ATTRIBUTE_UNUSED;
- const cpp_string *str ATTRIBUTE_UNUSED;
+cb_ident (cpp_reader *pfile ATTRIBUTE_UNUSED,
+ unsigned int line ATTRIBUTE_UNUSED,
+ const cpp_string *str ATTRIBUTE_UNUSED)
{
#ifdef ASM_OUTPUT_IDENT
if (! flag_no_ident)
/* Called at the start of every non-empty line. TOKEN is the first
lexed token on the line. Used for diagnostic line numbers. */
static void
-cb_line_change (pfile, token, parsing_args)
- cpp_reader *pfile ATTRIBUTE_UNUSED;
- const cpp_token *token;
- int parsing_args ATTRIBUTE_UNUSED;
+cb_line_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const cpp_token *token,
+ int parsing_args ATTRIBUTE_UNUSED)
{
src_lineno = SOURCE_LINE (map, token->line);
}
void
-fe_file_change (new_map)
- const struct line_map *new_map;
+fe_file_change (const struct line_map *new_map)
{
unsigned int to_line = SOURCE_LINE (new_map, new_map->to_line);
}
#endif
pop_srcloc ();
-
+
(*debug_hooks->end_source_file) (to_line);
}
}
static void
-cb_def_pragma (pfile, line)
- cpp_reader *pfile;
- unsigned int line;
+cb_def_pragma (cpp_reader *pfile, unsigned int line)
{
/* Issue a warning message if we have been asked to do so. Ignore
unknown pragmas in system headers unless an explicit
/* #define callback for DWARF and DWARF2 debug info. */
static void
-cb_define (pfile, line, node)
- cpp_reader *pfile;
- unsigned int line;
- cpp_hashnode *node;
+cb_define (cpp_reader *pfile, unsigned int line, cpp_hashnode *node)
{
(*debug_hooks->define) (SOURCE_LINE (map, line),
(const char *) cpp_macro_definition (pfile, node));
/* #undef callback for DWARF and DWARF2 debug info. */
static void
-cb_undef (pfile, line, node)
- cpp_reader *pfile ATTRIBUTE_UNUSED;
- unsigned int line;
- cpp_hashnode *node;
+cb_undef (cpp_reader *pfile ATTRIBUTE_UNUSED, unsigned int line,
+ cpp_hashnode *node)
{
(*debug_hooks->undef) (SOURCE_LINE (map, line),
(const char *) NODE_NAME (node));
}
\f
int
-c_lex (value)
- tree *value;
+c_lex (tree *value)
{
const cpp_token *tok;
minimum specified by FLAGS, that can fit VALUE, or itk_none if
there isn't one. */
static enum integer_type_kind
-narrowest_unsigned_type (value, flags)
- tree value;
- unsigned int flags;
+narrowest_unsigned_type (tree value, unsigned int flags)
{
enum integer_type_kind itk;
/* Ditto, but narrowest signed type. */
static enum integer_type_kind
-narrowest_signed_type (value, flags)
- tree value;
- unsigned int flags;
+narrowest_signed_type (tree value, unsigned int flags)
{
enum integer_type_kind itk;
/* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
static tree
-interpret_integer (token, flags)
- const cpp_token *token;
- unsigned int flags;
+interpret_integer (const cpp_token *token, unsigned int flags)
{
tree value, type;
enum integer_type_kind itk;
/* Interpret TOKEN, a floating point number with FLAGS as classified
by cpplib. */
static tree
-interpret_float (token, flags)
- const cpp_token *token;
- unsigned int flags;
+interpret_float (const cpp_token *token, unsigned int flags)
{
tree type;
tree value;
}
static tree
-lex_string (str)
- const cpp_string *str;
+lex_string (const cpp_string *str)
{
bool wide;
tree value;
char *buf, *q;
cppchar_t c;
const unsigned char *p, *limit;
-
+
wide = str->text[0] == 'L';
p = str->text + 1 + wide;
limit = str->text + str->len - 1;
if (c == '\\' && !ignore_escape_flag)
c = cpp_parse_escape (parse_in, &p, limit, wide);
-
+
/* Add this single character into the buffer either as a wchar_t,
a multibyte sequence, or as a single byte. */
if (wide)
/* Converts a (possibly wide) character constant token into a tree. */
static tree
-lex_charconst (token)
- const cpp_token *token;
+lex_charconst (const cpp_token *token)
{
cppchar_t result;
tree type, value;
int unsignedp;
result = cpp_interpret_charconst (parse_in, token,
- &chars_seen, &unsignedp);
+ &chars_seen, &unsignedp);
/* Cast to cppchar_signed_t to get correct sign-extension of RESULT
before possibly widening to HOST_WIDE_INT for build_int_2. */
/* Some code common to C and ObjC front ends.
- Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
#include "target.h"
#include "cgraph.h"
-static bool c_tree_printer PARAMS ((output_buffer *, text_info *));
-static tree inline_forbidden_p PARAMS ((tree *, int *, void *));
-static void expand_deferred_fns PARAMS ((void));
-static tree start_cdtor PARAMS ((int));
-static void finish_cdtor PARAMS ((tree));
+static bool c_tree_printer (output_buffer *, text_info *);
+static tree inline_forbidden_p (tree *, int *, void *);
+static void expand_deferred_fns (void);
+static tree start_cdtor (int);
+static void finish_cdtor (tree);
static GTY(()) varray_type deferred_fns;
int
-c_missing_noreturn_ok_p (decl)
- tree decl;
+c_missing_noreturn_ok_p (tree decl)
{
/* A missing noreturn is not ok for freestanding implementations and
ok for the `main' function in hosted implementations. */
such functions always being inlined when optimizing. */
int
-c_disregard_inline_limits (fn)
- tree fn;
+c_disregard_inline_limits (tree fn)
{
if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
return 1;
}
static tree
-inline_forbidden_p (nodep, walk_subtrees, fn)
- tree *nodep;
- int *walk_subtrees ATTRIBUTE_UNUSED;
- void *fn;
+inline_forbidden_p (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
+ void *fn)
{
tree node = *nodep;
tree t;
}
int
-c_cannot_inline_tree_fn (fnp)
- tree *fnp;
+c_cannot_inline_tree_fn (tree *fnp)
{
tree fn = *fnp;
tree t;
&& lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL)
return 1;
- /* Don't auto-inline anything that might not be bound within
+ /* Don't auto-inline anything that might not be bound within
this unit of translation. */
if (!DECL_DECLARED_INLINE_P (fn) && !(*targetm.binds_local_p) (fn))
goto cannot_inline;
if (! t)
return 0;
}
-
+
if (walk_tree (&DECL_SAVED_TREE (fn), inline_forbidden_p, fn, NULL))
goto cannot_inline;
/* Called from check_global_declarations. */
bool
-c_warn_unused_global_decl (decl)
- tree decl;
+c_warn_unused_global_decl (tree decl)
{
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
return false;
/* Initialization common to C and Objective-C front ends. */
bool
-c_objc_common_init ()
+c_objc_common_init (void)
{
static const enum tree_code stmt_codes[] = {
c_common_stmt_codes
to RTL is only done at the end of the compilation. */
int
-defer_fn (fn)
- tree fn;
+defer_fn (tree fn)
{
VARRAY_PUSH_TREE (deferred_fns, fn);
/* Expand deferred functions for C and ObjC. */
static void
-expand_deferred_fns ()
+expand_deferred_fns (void)
{
unsigned int i;
}
static tree
-start_cdtor (method_type)
- int method_type;
+start_cdtor (int method_type)
{
tree fnname = get_file_function_name (method_type);
tree void_list_node_1 = build_tree_list (NULL_TREE, void_type_node);
}
static void
-finish_cdtor (body)
- tree body;
+finish_cdtor (tree body)
{
tree scope;
tree block;
/* Called at end of parsing, but before end-of-file processing. */
void
-c_objc_common_finish_file ()
+c_objc_common_finish_file (void)
{
if (pch_file)
c_common_write_pch ();
Please notice when called, the `%' part was already skipped by the
diagnostic machinery. */
static bool
-c_tree_printer (buffer, text)
- output_buffer *buffer;
- text_info *text;
+c_tree_printer (output_buffer *buffer, text_info *text)
{
tree t = va_arg (*text->args_ptr, tree);
/* Number of deferred options scanned for -include. */
static size_t include_cursor;
-static void missing_arg PARAMS ((enum opt_code));
-static void set_Wimplicit PARAMS ((int));
-static void complain_wrong_lang PARAMS ((size_t, int));
-static void write_langs PARAMS ((char *, int));
-static void print_help PARAMS ((void));
-static void handle_OPT_d PARAMS ((const char *));
-static void set_std_cxx98 PARAMS ((int));
-static void set_std_c89 PARAMS ((int, int));
-static void set_std_c99 PARAMS ((int));
-static void check_deps_environment_vars PARAMS ((void));
-static void handle_deferred_opts PARAMS ((void));
-static void sanitize_cpp_opts PARAMS ((void));
-static void add_prefixed_path PARAMS ((const char *, size_t));
-static void push_command_line_include PARAMS ((void));
-static void cb_file_change PARAMS ((cpp_reader *, const struct line_map *));
-static void finish_options PARAMS ((void));
+static void missing_arg (enum opt_code);
+static void set_Wimplicit (int);
+static void complain_wrong_lang (size_t, int);
+static void write_langs (char *, int);
+static void print_help (void);
+static void handle_OPT_d (const char *);
+static void set_std_cxx98 (int);
+static void set_std_c89 (int, int);
+static void set_std_c99 (int);
+static void check_deps_environment_vars (void);
+static void handle_deferred_opts (void);
+static void sanitize_cpp_opts (void);
+static void add_prefixed_path (const char *, size_t);
+static void push_command_line_include (void);
+static void cb_file_change (cpp_reader *, const struct line_map *);
+static void finish_options (void);
#ifndef STDC_0_IN_SYSTEM_HEADERS
#define STDC_0_IN_SYSTEM_HEADERS 0
/* Holds switches parsed by c_common_handle_option (), but whose
handling is deferred to c_common_post_options (). */
-static void defer_opt PARAMS ((enum opt_code, const char *));
+static void defer_opt (enum opt_code, const char *);
static struct deferred_opt
{
enum opt_code code;
/* Defer option CODE with argument ARG. */
static void
-defer_opt (code, arg)
- enum opt_code code;
- const char *arg;
+defer_opt (enum opt_code code, const char *arg)
{
/* FIXME: this should be in c_common_init_options, which should take
argc and argv. */
/* Common initialization before parsing options. */
int
-c_common_init_options (lang)
- enum c_language_kind lang;
+c_common_init_options (enum c_language_kind lang)
{
c_language = lang;
parse_in = cpp_create_reader (lang == clk_c ? CLK_GNUC89 : CLK_GNUCXX,
warn_sign_compare = value;
warn_switch = value;
warn_strict_aliasing = value;
-
+
/* Only warn about unknown pragmas that are not in system
- headers. */
+ headers. */
warn_unknown_pragmas = value;
/* We save the value of warn_uninitialized, since if they put
case OPT_Wunknown_pragmas:
/* Set to greater than 1, so that even unknown pragmas in
- system headers will be warned about. */
+ system headers will be warned about. */
warn_unknown_pragmas = value * 2;
break;
else
warn_write_strings = value;
break;
-
+
case OPT_ansi:
if (c_language == clk_c)
set_std_c89 (false, true);
/* Post-switch processing. */
bool
-c_common_post_options (pfilename)
- const char **pfilename;
+c_common_post_options (const char **pfilename)
{
/* Canonicalize the input and output filenames. */
if (in_fname == NULL || !strcmp (in_fname, "-"))
/* Front end initialization common to C, ObjC and C++. */
bool
-c_common_init ()
+c_common_init (void)
{
input_line = saved_lineno;
return true;
}
-/* A thin wrapper around the real parser that initializes the
+/* A thin wrapper around the real parser that initializes the
integrated preprocessor after debug output has been initialized.
Also, make sure the start_source_file debug hook gets called for
the primary source file. */
void
-c_common_parse_file (set_yydebug)
- int set_yydebug ATTRIBUTE_UNUSED;
+c_common_parse_file (int set_yydebug ATTRIBUTE_UNUSED)
{
#if YYDEBUG != 0
yydebug = set_yydebug;
/* Common finish hook for the C, ObjC and C++ front ends. */
void
-c_common_finish ()
+c_common_finish (void)
{
FILE *deps_stream = NULL;
rather than overwriting it, and like Sun's compiler
SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */
static void
-check_deps_environment_vars ()
+check_deps_environment_vars (void)
{
char *spec;
/* Handle deferred command line switches. */
static void
-handle_deferred_opts ()
+handle_deferred_opts (void)
{
size_t i;
/* These settings are appropriate for GCC, but not necessarily so for
cpplib as a library. */
static void
-sanitize_cpp_opts ()
+sanitize_cpp_opts (void)
{
/* If we don't know what style of dependencies to output, complain
if any other dependency switches have been given. */
/* Add include path with a prefix at the front of its name. */
static void
-add_prefixed_path (suffix, chain)
- const char *suffix;
- size_t chain;
+add_prefixed_path (const char *suffix, size_t chain)
{
char *path;
const char *prefix;
/* Handle -D, -U, -A, -imacros, and the first -include. */
static void
-finish_options ()
+finish_options (void)
{
if (!cpp_opts->preprocessed)
{
/* Give CPP the next file given by -include, if any. */
static void
-push_command_line_include ()
+push_command_line_include (void)
{
if (cpp_opts->preprocessed)
return;
-
+
while (include_cursor < deferred_count)
{
struct deferred_opt *opt = &deferred_opts[include_cursor++];
-
+
if (opt->code == OPT_include && cpp_push_include (parse_in, opt->arg))
return;
}
/* File change callback. Has to handle -include files. */
static void
-cb_file_change (pfile, new_map)
- cpp_reader *pfile ATTRIBUTE_UNUSED;
- const struct line_map *new_map;
+cb_file_change (cpp_reader *pfile ATTRIBUTE_UNUSED,
+ const struct line_map *new_map)
{
if (flag_preprocess_only)
pp_file_change (new_map);
/* Set the C 89 standard (with 1994 amendments if C94, without GNU
extensions if ISO). There is no concept of gnu94. */
static void
-set_std_c89 (c94, iso)
- int c94, iso;
+set_std_c89 (int c94, int iso)
{
cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
flag_iso = iso;
/* Set the C 99 standard (without GNU extensions if ISO). */
static void
-set_std_c99 (iso)
- int iso;
+set_std_c99 (int iso)
{
cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
flag_no_asm = iso;
/* Set the C++ 98 standard (without GNU extensions if ISO). */
static void
-set_std_cxx98 (iso)
- int iso;
+set_std_cxx98 (int iso)
{
cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
flag_no_gnu_keywords = iso;
/* Handle setting implicit to ON. */
static void
-set_Wimplicit (on)
- int on;
+set_Wimplicit (int on)
{
warn_implicit = on;
warn_implicit_int = on;
/* Args to -d specify what to dump. Silently ignore
unrecognized options; they may be aimed at toplev.c. */
static void
-handle_OPT_d (arg)
- const char *arg;
+handle_OPT_d (const char *arg)
{
char c;
/* Write a slash-separated list of languages in FLAGS to BUF. */
static void
-write_langs (buf, flags)
- char *buf;
- int flags;
+write_langs (char *buf, int flags)
{
*buf = '\0';
if (flags & CL_C)
/* Complain that switch OPT_INDEX does not apply to this front end. */
static void
-complain_wrong_lang (opt_index, on)
- size_t opt_index;
- int on;
+complain_wrong_lang (size_t opt_index, int on)
{
char ok_langs[60], bad_langs[60];
int ok_flags = cl_options[opt_index].flags;
/* Handle --help output. */
static void
-print_help ()
+print_help (void)
{
/* To keep the lines from getting too long for some compilers, limit
to about 500 characters (6 lines) per chunk. */
/* Precompiled header implementation for the C languages.
- Copyright (C) 2000, 2002 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
static long asm_file_startpos;
-static const char * get_ident PARAMS((void));
+static const char *get_ident (void);
/* Compute an appropriate 8-byte magic number for the PCH file, so that
utilities like file(1) can identify it, and so that GCC can quickly
format. */
static const char *
-get_ident()
+get_ident(void)
{
static char result[IDENT_LENGTH];
static const char template[IDENT_LENGTH] = "gpch.011";
compilation. */
void
-pch_init ()
+pch_init (void)
{
FILE *f;
struct c_pch_validity v;
will produce a PCH file. */
void
-c_common_write_pch ()
+c_common_write_pch (void)
{
char *buf;
long asm_file_end;
in this compilation. */
int
-c_common_valid_pch (pfile, name, fd)
- cpp_reader *pfile;
- const char *name;
- int fd;
+c_common_valid_pch (cpp_reader *pfile, const char *name, int fd)
{
int sizeread;
int result;
by ORIG_NAME. */
void
-c_common_read_pch (pfile, name, fd, orig_name)
- cpp_reader *pfile;
- const char *name;
- int fd;
- const char *orig_name ATTRIBUTE_UNUSED;
+c_common_read_pch (cpp_reader *pfile, const char *name,
+ int fd, const char *orig_name ATTRIBUTE_UNUSED)
{
FILE *f;
struct c_pch_header h;
} print;
/* General output routines. */
-static void scan_translation_unit PARAMS ((cpp_reader *));
-static void scan_translation_unit_trad PARAMS ((cpp_reader *));
-static void account_for_newlines PARAMS ((const uchar *, size_t));
-static int dump_macro PARAMS ((cpp_reader *, cpp_hashnode *, void *));
+static void scan_translation_unit (cpp_reader *);
+static void scan_translation_unit_trad (cpp_reader *);
+static void account_for_newlines (const uchar *, size_t);
+static int dump_macro (cpp_reader *, cpp_hashnode *, void *);
-static void print_line PARAMS ((const struct line_map *, unsigned int,
- const char *));
-static void maybe_print_line PARAMS ((const struct line_map *, unsigned int));
+static void print_line (const struct line_map *, unsigned int,
+ const char *);
+static void maybe_print_line (const struct line_map *, unsigned int);
/* Callback routines for the parser. Most of these are active only
in specific modes. */
-static void cb_line_change PARAMS ((cpp_reader *, const cpp_token *, int));
-static void cb_define PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
-static void cb_undef PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
-static void cb_include PARAMS ((cpp_reader *, unsigned int,
- const unsigned char *, const char *, int));
-static void cb_ident PARAMS ((cpp_reader *, unsigned int,
- const cpp_string *));
-static void cb_def_pragma PARAMS ((cpp_reader *, unsigned int));
+static void cb_line_change (cpp_reader *, const cpp_token *, int);
+static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
+static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
+static void cb_include (cpp_reader *, unsigned int, const unsigned char *,
+ const char *, int);
+static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
+static void cb_def_pragma (cpp_reader *, unsigned int);
/* Preprocess and output. */
void
-preprocess_file (pfile)
- cpp_reader *pfile;
+preprocess_file (cpp_reader *pfile)
{
/* A successful cpp_read_main_file guarantees that we can call
cpp_scan_nooutput or cpp_get_token next. */
/* Set up the callbacks as appropriate. */
void
-init_pp_output (out_stream)
- FILE *out_stream;
+init_pp_output (FILE *out_stream)
{
cpp_callbacks *cb = cpp_get_callbacks (parse_in);
/* Writes out the preprocessed file, handling spacing and paste
avoidance issues. */
static void
-scan_translation_unit (pfile)
- cpp_reader *pfile;
+scan_translation_unit (cpp_reader *pfile)
{
bool avoid_paste = false;
/* Adjust print.line for newlines embedded in output. */
static void
-account_for_newlines (str, len)
- const uchar *str;
- size_t len;
+account_for_newlines (const uchar *str, size_t len)
{
while (len--)
if (*str++ == '\n')
/* Writes out a traditionally preprocessed file. */
static void
-scan_translation_unit_trad (pfile)
- cpp_reader *pfile;
+scan_translation_unit_trad (cpp_reader *pfile)
{
while (_cpp_read_logical_line_trad (pfile))
{
different line to the current one, output the required newlines or
a line marker, and return 1. Otherwise return 0. */
static void
-maybe_print_line (map, line)
- const struct line_map *map;
- unsigned int line;
+maybe_print_line (const struct line_map *map, unsigned int line)
{
/* End the previous line of text. */
if (print.printed)
/* Output a line marker for logical line LINE. Special flags are "1"
or "2" indicating entering or leaving a file. */
static void
-print_line (map, line, special_flags)
- const struct line_map *map;
- unsigned int line;
- const char *special_flags;
+print_line (const struct line_map *map, unsigned int line, const char *special_flags)
{
/* End any previous line of text. */
if (print.printed)
/* Called when a line of output is started. TOKEN is the first token
of the line, and at end of file will be CPP_EOF. */
static void
-cb_line_change (pfile, token, parsing_args)
- cpp_reader *pfile;
- const cpp_token *token;
- int parsing_args;
+cb_line_change (cpp_reader *pfile, const cpp_token *token, int parsing_args)
{
if (token->type == CPP_EOF || parsing_args)
return;
}
static void
-cb_ident (pfile, line, str)
- cpp_reader *pfile ATTRIBUTE_UNUSED;
- unsigned int line;
- const cpp_string * str;
+cb_ident (cpp_reader *pfile ATTRIBUTE_UNUSED, unsigned int line,
+ const cpp_string *str)
{
maybe_print_line (print.map, line);
fprintf (print.outf, "#ident \"%s\"\n", str->text);
}
static void
-cb_define (pfile, line, node)
- cpp_reader *pfile;
- unsigned int line;
- cpp_hashnode *node;
+cb_define (cpp_reader *pfile, unsigned int line, cpp_hashnode *node)
{
maybe_print_line (print.map, line);
fputs ("#define ", print.outf);
}
static void
-cb_undef (pfile, line, node)
- cpp_reader *pfile ATTRIBUTE_UNUSED;
- unsigned int line;
- cpp_hashnode *node;
+cb_undef (cpp_reader *pfile ATTRIBUTE_UNUSED, unsigned int line,
+ cpp_hashnode *node)
{
maybe_print_line (print.map, line);
fprintf (print.outf, "#undef %s\n", NODE_NAME (node));
}
static void
-cb_include (pfile, line, dir, header, angle_brackets)
- cpp_reader *pfile ATTRIBUTE_UNUSED;
- unsigned int line;
- const unsigned char *dir;
- const char *header;
- int angle_brackets;
+cb_include (cpp_reader *pfile ATTRIBUTE_UNUSED, unsigned int line,
+ const unsigned char *dir, const char *header, int angle_brackets)
{
maybe_print_line (print.map, line);
if (angle_brackets)
pointing to freed memory, and so must not be dereferenced. */
void
-pp_file_change (map)
- const struct line_map *map;
+pp_file_change (const struct line_map *map)
{
const char *flags = "";
/* Copy a #pragma directive to the preprocessed output. */
static void
-cb_def_pragma (pfile, line)
- cpp_reader *pfile;
- unsigned int line;
+cb_def_pragma (cpp_reader *pfile, unsigned int line)
{
maybe_print_line (print.map, line);
fputs ("#pragma ", print.outf);
/* Dump out the hash table. */
static int
-dump_macro (pfile, node, v)
- cpp_reader *pfile;
- cpp_hashnode *node;
- void *v ATTRIBUTE_UNUSED;
+dump_macro (cpp_reader *pfile, cpp_hashnode *node, void *v ATTRIBUTE_UNUSED)
{
if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
{
/* Subroutines common to both C and C++ pretty-printers.
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003 Free Software Foundation, Inc.
Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
This file is part of GCC.
#include "c-tree.h"
/* literal */
-static void pp_c_char PARAMS ((c_pretty_printer, int));
-static void pp_c_character_literal PARAMS ((c_pretty_printer, tree));
-static void pp_c_bool_literal PARAMS ((c_pretty_printer, tree));
-static bool pp_c_enumerator PARAMS ((c_pretty_printer, tree));
-static void pp_c_integer_literal PARAMS ((c_pretty_printer, tree));
-static void pp_c_real_literal PARAMS ((c_pretty_printer, tree));
-static void pp_c_string_literal PARAMS ((c_pretty_printer, tree));
+static void pp_c_char (c_pretty_printer, int);
+static void pp_c_character_literal (c_pretty_printer, tree);
+static void pp_c_bool_literal (c_pretty_printer, tree);
+static bool pp_c_enumerator (c_pretty_printer, tree);
+static void pp_c_integer_literal (c_pretty_printer, tree);
+static void pp_c_real_literal (c_pretty_printer, tree);
+static void pp_c_string_literal (c_pretty_printer, tree);
-static void pp_c_primary_expression PARAMS ((c_pretty_printer, tree));
+static void pp_c_primary_expression (c_pretty_printer, tree);
/* postfix-expression */
-static void pp_c_initializer_list PARAMS ((c_pretty_printer, tree));
-
-static void pp_c_unary_expression PARAMS ((c_pretty_printer, tree));
-static void pp_c_multiplicative_expression PARAMS ((c_pretty_printer, tree));
-static void pp_c_additive_expression PARAMS ((c_pretty_printer, tree));
-static void pp_c_shift_expression PARAMS ((c_pretty_printer, tree));
-static void pp_c_relational_expression PARAMS ((c_pretty_printer, tree));
-static void pp_c_equality_expression PARAMS ((c_pretty_printer, tree));
-static void pp_c_and_expression PARAMS ((c_pretty_printer, tree));
-static void pp_c_exclusive_or_expression PARAMS ((c_pretty_printer,
- tree));
-static void pp_c_inclusive_or_expression PARAMS ((c_pretty_printer,
- tree));
-static void pp_c_logical_and_expression PARAMS ((c_pretty_printer, tree));
-static void pp_c_conditional_expression PARAMS ((c_pretty_printer, tree));
-static void pp_c_assignment_expression PARAMS ((c_pretty_printer, tree));
+static void pp_c_initializer_list (c_pretty_printer, tree);
+
+static void pp_c_unary_expression (c_pretty_printer, tree);
+static void pp_c_multiplicative_expression (c_pretty_printer, tree);
+static void pp_c_additive_expression (c_pretty_printer, tree);
+static void pp_c_shift_expression (c_pretty_printer, tree);
+static void pp_c_relational_expression (c_pretty_printer, tree);
+static void pp_c_equality_expression (c_pretty_printer, tree);
+static void pp_c_and_expression (c_pretty_printer, tree);
+static void pp_c_exclusive_or_expression (c_pretty_printer, tree);
+static void pp_c_inclusive_or_expression (c_pretty_printer, tree);
+static void pp_c_logical_and_expression (c_pretty_printer, tree);
+static void pp_c_conditional_expression (c_pretty_printer, tree);
+static void pp_c_assignment_expression (c_pretty_printer, tree);
/* declarations. */
-static void pp_c_declaration_specifiers PARAMS ((c_pretty_printer, tree));
-static void pp_c_init_declarator PARAMS ((c_pretty_printer, tree));
-static void pp_c_declarator PARAMS ((c_pretty_printer, tree));
-static void pp_c_direct_declarator PARAMS ((c_pretty_printer, tree));
-static void pp_c_abstract_declarator PARAMS ((c_pretty_printer, tree));
-static void pp_c_specifier_qualifier_list PARAMS ((c_pretty_printer, tree));
-static void pp_c_simple_type_specifier PARAMS ((c_pretty_printer, tree));
-static void pp_c_parameter_declaration PARAMS ((c_pretty_printer, tree));
-static void pp_c_type_id PARAMS ((c_pretty_printer, tree));
-static void pp_c_storage_class_specifier PARAMS ((c_pretty_printer, tree));
-static void pp_c_function_specifier PARAMS ((c_pretty_printer, tree));
+static void pp_c_declaration_specifiers (c_pretty_printer, tree);
+static void pp_c_init_declarator (c_pretty_printer, tree);
+static void pp_c_declarator (c_pretty_printer, tree);
+static void pp_c_direct_declarator (c_pretty_printer, tree);
+static void pp_c_abstract_declarator (c_pretty_printer, tree);
+static void pp_c_specifier_qualifier_list (c_pretty_printer, tree);
+static void pp_c_simple_type_specifier (c_pretty_printer, tree);
+static void pp_c_parameter_declaration (c_pretty_printer, tree);
+static void pp_c_type_id (c_pretty_printer, tree);
+static void pp_c_storage_class_specifier (c_pretty_printer, tree);
+static void pp_c_function_specifier (c_pretty_printer, tree);
\f
/* Declarations. */
/* Print out CV-qualifiers. Take care of possible extensions. */
void
-pp_c_cv_qualifier (ppi, cv)
- c_pretty_printer ppi;
- int cv;
+pp_c_cv_qualifier (c_pretty_printer ppi, int cv)
{
if (cv & TYPE_QUAL_CONST)
pp_c_identifier (ppi, "const");
}
static void
-pp_c_simple_type_specifier (ppi, t)
- c_pretty_printer ppi;
- tree t;
+pp_c_simple_type_specifier (c_pretty_printer ppi, tree t)
{
const enum tree_code code = TREE_CODE (t);
switch (code)
case IDENTIFIER_NODE:
pp_c_tree_identifier (ppi, t);
break;
-
+
case VOID_TYPE:
case BOOLEAN_TYPE:
case CHAR_TYPE:
case REAL_TYPE:
pp_c_tree_identifier (ppi, DECL_NAME (t));
break;
-
+
case COMPLEX_TYPE:
case VECTOR_TYPE:
pp_c_simple_type_specifier (ppi, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
pp_c_identifier (ppi, "enum");
else
pp_c_identifier (ppi, "<tag-error>");
-
+
if (TYPE_NAME (t))
pp_c_tree_identifier (ppi, TYPE_NAME (t));
else
}
static inline void
-pp_c_specifier_qualifier_list (ppi, t)
- c_pretty_printer ppi;
- tree t;
+pp_c_specifier_qualifier_list (c_pretty_printer ppi, tree t)
{
pp_c_simple_type_specifier (ppi, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
pp_c_cv_qualifier (ppi, TYPE_QUALS (t));
}
static void
-pp_c_abstract_declarator (ppi, t)
- c_pretty_printer ppi;
- tree t;
+pp_c_abstract_declarator (c_pretty_printer ppi, tree t)
{
pp_unsupported_tree (ppi, t);
}
static inline void
-pp_c_type_id (ppi, t)
- c_pretty_printer ppi;
- tree t;
+pp_c_type_id (c_pretty_printer ppi, tree t)
{
pp_c_specifier_qualifier_list (ppi, t);
pp_c_abstract_declarator (ppi, t);
}
static inline void
-pp_c_storage_class_specifier (pp, t)
- c_pretty_printer pp;
- tree t;
+pp_c_storage_class_specifier (c_pretty_printer pp, tree t)
{
if (TREE_CODE (t) == TYPE_DECL)
pp_c_identifier (pp, "typedef");
}
static inline void
-pp_c_function_specifier (pp, t)
- c_pretty_printer pp;
- tree t;
+pp_c_function_specifier (c_pretty_printer pp, tree t)
{
if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
pp_c_identifier (pp, "inline");
}
static inline void
-pp_c_declaration_specifiers (pp, t)
- c_pretty_printer pp;
- tree t;
+pp_c_declaration_specifiers (c_pretty_printer pp, tree t)
{
pp_c_storage_class_specifier (pp, t);
pp_c_function_specifier (pp, t);
}
static inline void
-pp_c_direct_declarator (pp, t)
- c_pretty_printer pp;
- tree t;
+pp_c_direct_declarator (c_pretty_printer pp, tree t)
{
pp_unsupported_tree (pp, t);
}
static inline void
-pp_c_declarator (pp, t)
- c_pretty_printer pp;
- tree t;
+pp_c_declarator (c_pretty_printer pp, tree t)
{
pp_unsupported_tree (pp, t);
}
static inline void
-pp_c_init_declarator (pp, t)
- c_pretty_printer pp;
- tree t;
+pp_c_init_declarator (c_pretty_printer pp, tree t)
{
pp_declarator (pp, t);
if (DECL_INITIAL (t))
}
void
-pp_c_declaration (pp, t)
- c_pretty_printer pp;
- tree t;
+pp_c_declaration (c_pretty_printer pp, tree t)
{
pp_declaration_specifiers (pp, t);
pp_c_init_declarator (pp, t);
}
static void
-pp_c_parameter_declaration (pp, t)
- c_pretty_printer pp;
- tree t;
+pp_c_parameter_declaration (c_pretty_printer pp, tree t)
{
pp_unsupported_tree (pp, t);
}
/* Pretty-print ATTRIBUTES using GNU C extension syntax. */
-void
-pp_c_attributes (pp, attributes)
- c_pretty_printer pp;
- tree attributes;
+void
+pp_c_attributes (c_pretty_printer pp, tree attributes)
{
if (attributes == NULL_TREE)
return;
-
+
pp_c_identifier (pp, "__attribute__");
- pp_c_left_paren (pp);
+ pp_c_left_paren (pp);
pp_c_left_paren (pp);
for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
{
pp_c_expression_list (pp, TREE_VALUE (attributes));
pp_c_right_paren (pp);
}
-
+
if (TREE_CHAIN (attributes))
pp_separate_with (pp, ',');
}
/* Print out a c-char. */
static void
-pp_c_char (ppi, c)
- c_pretty_printer ppi;
- int c;
+pp_c_char (c_pretty_printer ppi, int c)
{
switch (c)
{
/* Print out a STRING literal. */
static inline void
-pp_c_string_literal (ppi, s)
- c_pretty_printer ppi;
- tree s;
+pp_c_string_literal (c_pretty_printer ppi, tree s)
{
const char *p = TREE_STRING_POINTER (s);
int n = TREE_STRING_LENGTH (s) - 1;
/* Print out a CHARACTER literal. */
static inline void
-pp_c_character_literal (ppi, c)
- c_pretty_printer ppi;
- tree c;
+pp_c_character_literal (c_pretty_printer ppi, tree c)
{
pp_quote (ppi);
pp_c_char (ppi, tree_low_cst (c, 0));
/* Print out a BOOLEAN literal. */
static inline void
-pp_c_bool_literal (ppi, b)
- c_pretty_printer ppi;
- tree b;
+pp_c_bool_literal (c_pretty_printer ppi, tree b)
{
if (b == boolean_false_node || integer_zerop (b))
{
pp_unsupported_tree (ppi, b);
}
-/* Attempt to print out an ENUMERATOR. Return true on success. Else return
+/* Attempt to print out an ENUMERATOR. Return true on success. Else return
false; that means the value was obtained by a cast, in which case
print out the type-id part of the cast-expression -- the casted value
is then printed by pp_c_integer_literal. */
static bool
-pp_c_enumerator (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_enumerator (c_pretty_printer ppi, tree e)
{
tree type = TREE_TYPE (e);
tree value;
/* Find the name of this constant. */
- for (value = TYPE_VALUES (type);
+ for (value = TYPE_VALUES (type);
value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
value = TREE_CHAIN (value))
;
-
+
if (value != NULL_TREE)
pp_c_tree_identifier (ppi, TREE_PURPOSE (value));
else
pp_c_right_paren (ppi);
return false;
}
-
+
return true;
}
/* Print out an INTEGER constant value. */
static void
-pp_c_integer_literal (ppi, i)
- c_pretty_printer ppi;
- tree i;
+pp_c_integer_literal (c_pretty_printer ppi, tree i)
{
tree type = TREE_TYPE (i);
-
+
if (type == boolean_type_node)
pp_c_bool_literal (ppi, i);
else if (type == char_type_node)
i = build_int_2 (-TREE_INT_CST_LOW (i),
~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
sprintf (pp_buffer (ppi)->digit_buffer,
- HOST_WIDE_INT_PRINT_DOUBLE_HEX,
+ HOST_WIDE_INT_PRINT_DOUBLE_HEX,
TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
pp_identifier (ppi, pp_buffer (ppi)->digit_buffer);
/* Print out a REAL value. */
static inline void
-pp_c_real_literal (ppi, r)
- c_pretty_printer ppi;
- tree r;
+pp_c_real_literal (c_pretty_printer ppi, tree r)
{
real_to_decimal (pp_buffer (ppi)->digit_buffer, &TREE_REAL_CST (r),
sizeof (pp_buffer (ppi)->digit_buffer), 0, 1);
void
-pp_c_literal (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_literal (c_pretty_printer ppi, tree e)
{
switch (TREE_CODE (e))
{
case INTEGER_CST:
pp_c_integer_literal (ppi, e);
break;
-
+
case REAL_CST:
pp_c_real_literal (ppi, e);
break;
-
+
case STRING_CST:
pp_c_string_literal (ppi, e);
- break;
+ break;
default:
pp_unsupported_tree (ppi, e);
/* Pretty-print a C primary-expression. */
static void
-pp_c_primary_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_primary_expression (c_pretty_printer ppi, tree e)
{
switch (TREE_CODE (e))
{
case ERROR_MARK:
pp_c_identifier (ppi, "<erroneous-expression>");
break;
-
+
case RESULT_DECL:
pp_c_identifier (ppi, "<return-value>");
break;
/* Print out a C initializer -- also support C compound-literals. */
void
-pp_c_initializer (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_initializer (c_pretty_printer ppi, tree e)
{
if (TREE_CODE (e) == CONSTRUCTOR)
{
}
static void
-pp_c_initializer_list (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_initializer_list (c_pretty_printer ppi, tree e)
{
tree type = TREE_TYPE (e);
const enum tree_code code = TREE_CODE (type);
}
void
-pp_c_postfix_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_postfix_expression (c_pretty_printer ppi, tree e)
{
enum tree_code code = TREE_CODE (e);
switch (code)
pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
pp_identifier (ppi, code == POSTINCREMENT_EXPR ? "++" : "--");
break;
-
+
case ARROW_EXPR:
pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
pp_arrow (ppi);
case ABS_EXPR:
case FFS_EXPR:
- pp_c_identifier (ppi,
+ pp_c_identifier (ppi,
code == ABS_EXPR ? "__builtin_abs" : "__builtin_ffs");
pp_c_left_paren (ppi);
pp_c_expression (ppi, TREE_OPERAND (e, 0));
pp_type_id (ppi, TREE_TYPE (e));
pp_c_right_paren (ppi);
pp_left_brace (ppi);
-
+
if (code == COMPLEX_CST)
{
pp_c_expression (ppi, TREE_REALPART (e));
pp_separate_with (ppi, ',');
pp_c_expression (ppi, TREE_OPERAND (e, 1));
}
-
+
pp_right_brace (ppi);
break;
case CONSTRUCTOR:
pp_initializer (ppi, e);
break;
-
+
case VA_ARG_EXPR:
pp_c_identifier (ppi, "__builtin_va_arg");
pp_c_left_paren (ppi);
/* Print out an expression-list; E is expected to be a TREE_LIST */
void
-pp_c_expression_list (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_expression_list (c_pretty_printer ppi, tree e)
{
for (; e != NULL_TREE; e = TREE_CHAIN (e))
{
}
static void
-pp_c_unary_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_unary_expression (c_pretty_printer ppi, tree e)
{
enum tree_code code = TREE_CODE (e);
switch (code)
pp_identifier (ppi, code == PREINCREMENT_EXPR ? "++" : "--");
pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
break;
-
+
case ADDR_EXPR:
case INDIRECT_REF:
case CONVERT_EXPR:
pp_c_whitespace (ppi);
pp_unary_expression (ppi, TREE_OPERAND (e, 0));
break;
-
+
default:
pp_postfix_expression (ppi, e);
break;
}
void
-pp_c_cast_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_cast_expression (c_pretty_printer ppi, tree e)
{
if (TREE_CODE (e) == CONVERT_EXPR || TREE_CODE (e) == FLOAT_EXPR)
{
}
static void
-pp_c_multiplicative_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_multiplicative_expression (c_pretty_printer ppi, tree e)
{
enum tree_code code = TREE_CODE (e);
switch (code)
}
static inline void
-pp_c_additive_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_additive_expression (c_pretty_printer ppi, tree e)
{
enum tree_code code = TREE_CODE (e);
switch (code)
}
static inline void
-pp_c_shift_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_shift_expression (c_pretty_printer ppi, tree e)
{
enum tree_code code = TREE_CODE (e);
switch (code)
}
static void
-pp_c_relational_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_relational_expression (c_pretty_printer ppi, tree e)
{
enum tree_code code = TREE_CODE (e);
switch (code)
}
static inline void
-pp_c_equality_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_equality_expression (c_pretty_printer ppi, tree e)
{
enum tree_code code = TREE_CODE (e);
switch (code)
pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
pp_c_whitespace (ppi);
pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
- break;
-
+ break;
+
default:
pp_c_relational_expression (ppi, e);
break;
}
static inline void
-pp_c_and_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_and_expression (c_pretty_printer ppi, tree e)
{
if (TREE_CODE (e) == BIT_AND_EXPR)
{
}
static inline void
-pp_c_exclusive_or_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_exclusive_or_expression (c_pretty_printer ppi, tree e)
{
if (TREE_CODE (e) == BIT_XOR_EXPR)
{
}
static inline void
-pp_c_inclusive_or_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_inclusive_or_expression (c_pretty_printer ppi, tree e)
{
if (TREE_CODE (e) == BIT_IOR_EXPR)
{
}
static inline void
-pp_c_logical_and_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_logical_and_expression (c_pretty_printer ppi, tree e)
{
if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
{
}
void
-pp_c_logical_or_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_logical_or_expression (c_pretty_printer ppi, tree e)
{
if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
{
}
static void
-pp_c_conditional_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_conditional_expression (c_pretty_printer ppi, tree e)
{
if (TREE_CODE (e) == COND_EXPR)
{
/* Pretty-print a C assignment-expression. */
static void
-pp_c_assignment_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_assignment_expression (c_pretty_printer ppi, tree e)
{
if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
{
/* Pretty-print an expression. */
void
-pp_c_expression (ppi, e)
- c_pretty_printer ppi;
- tree e;
+pp_c_expression (c_pretty_printer ppi, tree e)
{
switch (TREE_CODE (e))
{
case INTEGER_CST:
pp_c_integer_literal (ppi, e);
break;
-
+
case REAL_CST:
pp_c_real_literal (ppi, e);
break;
case STRING_CST:
pp_c_string_literal (ppi, e);
break;
-
+
case FUNCTION_DECL:
case VAR_DECL:
case CONST_DECL:
pp_assignment_expression (ppi, TREE_OPERAND (e, 1));
pp_c_right_paren (ppi);
break;
-
+
default:
pp_unsupported_tree (ppi, e);
\f
/* Statements. */
void
-pp_c_statement (ppi, stmt)
- c_pretty_printer ppi;
- tree stmt;
+pp_c_statement (c_pretty_printer ppi, tree stmt)
{
const enum tree_code code = TREE_CODE (stmt);
switch (code)
case EXPR_STMT:
case CLEANUP_STMT:
pp_newline (ppi);
- pp_c_expression (ppi, code == EXPR_STMT
+ pp_c_expression (ppi, code == EXPR_STMT
? EXPR_STMT_EXPR (stmt)
: CLEANUP_EXPR (stmt));
pp_semicolon (ppi);
pp_statement (ppi, FOR_BODY (stmt));
pp_newline_and_indent (ppi, -3);
break;
-
+
case BREAK_STMT:
case CONTINUE_STMT:
pp_newline (ppi);
case RETURN_STMT:
case GOTO_STMT:
{
- tree e = code == RETURN_STMT
+ tree e = code == RETURN_STMT
? RETURN_STMT_EXPR (stmt)
: GOTO_DESTINATION (stmt);
case ASM_STMT:
{
bool has_volatile_p = ASM_VOLATILE_P (stmt);
- bool is_extended = has_volatile_p || ASM_INPUTS (stmt)
+ bool is_extended = has_volatile_p || ASM_INPUTS (stmt)
|| ASM_OUTPUTS (stmt) || ASM_CLOBBERS (stmt);
pp_c_identifier (ppi, is_extended ? "__asm__" : "asm");
if (has_volatile_p)
\f
/* Initialize the PRETTY-PRINTER for handling C codes. */
void
-pp_c_pretty_printer_init (pp)
- c_pretty_printer pp;
+pp_c_pretty_printer_init (c_pretty_printer pp)
{
pp->offset_list = 0;
/* Various declarations for the C and C++ pretty-printers.
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003 Free Software Foundation, Inc.
Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
This file is part of GCC.
typedef struct c_pretty_print_info *c_pretty_printer;
/* The type of a C pretty-printer 'member' function. */
-typedef void (*c_pretty_print_fn) PARAMS ((c_pretty_printer, tree));
+typedef void (*c_pretty_print_fn) (c_pretty_printer, tree);
struct c_pretty_print_info
{
macro must be overridden by any subclass of c_pretty_print_info. */
#define pp_c_base(PP) (PP)
-extern void pp_c_pretty_printer_init PARAMS ((c_pretty_printer));
+extern void pp_c_pretty_printer_init (c_pretty_printer);
/* Declarations. */
-void pp_c_attributes PARAMS ((c_pretty_printer, tree));
-void pp_c_cv_qualifier PARAMS ((c_pretty_printer, int));
-void pp_c_parameter_declaration_clause PARAMS ((c_pretty_printer, tree));
-void pp_c_declaration PARAMS ((c_pretty_printer, tree));
+void pp_c_attributes (c_pretty_printer, tree);
+void pp_c_cv_qualifier (c_pretty_printer, int);
+void pp_c_parameter_declaration_clause (c_pretty_printer, tree);
+void pp_c_declaration (c_pretty_printer, tree);
/* Statements. */
-void pp_c_statement PARAMS ((c_pretty_printer, tree));
+void pp_c_statement (c_pretty_printer, tree);
/* Expressions. */
-void pp_c_expression PARAMS ((c_pretty_printer, tree));
-void pp_c_logical_or_expression PARAMS ((c_pretty_printer, tree));
-void pp_c_expression_list PARAMS ((c_pretty_printer, tree));
-void pp_c_cast_expression PARAMS ((c_pretty_printer, tree));
-void pp_c_postfix_expression PARAMS ((c_pretty_printer, tree));
-void pp_c_initializer PARAMS ((c_pretty_printer, tree));
-void pp_c_literal PARAMS ((c_pretty_printer, tree));
+void pp_c_expression (c_pretty_printer, tree);
+void pp_c_logical_or_expression (c_pretty_printer, tree);
+void pp_c_expression_list (c_pretty_printer, tree);
+void pp_c_cast_expression (c_pretty_printer, tree);
+void pp_c_postfix_expression (c_pretty_printer, tree);
+void pp_c_initializer (c_pretty_printer, tree);
+void pp_c_literal (c_pretty_printer, tree);
#endif /* GCC_C_PRETTY_PRINTER */
/* This file contains the definitions and documentation for the common
tree codes used in the GNU C and C++ compilers (see c-common.def
- for the standard codes).
+ for the standard codes).
Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
Written by Benjamin Chelf (chelf@codesourcery.com).
/* If non-NULL, the address of a language-specific function for
expanding statements. */
-void (*lang_expand_stmt) PARAMS ((tree));
+void (*lang_expand_stmt) (tree);
/* If non-NULL, the address of a language-specific function for
expanding a DECL_STMT. After the language-independent cases are
handled, this function will be called. If this function is not
defined, it is assumed that declarations other than those for
variables and labels do not require any RTL generation. */
-void (*lang_expand_decl_stmt) PARAMS ((tree));
+void (*lang_expand_decl_stmt) (tree);
-static tree find_reachable_label_1 PARAMS ((tree *, int *, void *));
-static tree find_reachable_label PARAMS ((tree));
-static bool expand_unreachable_if_stmt PARAMS ((tree));
-static tree expand_unreachable_stmt PARAMS ((tree, int));
-static void genrtl_do_stmt_1 PARAMS ((tree, tree));
+static tree find_reachable_label_1 (tree *, int *, void *);
+static tree find_reachable_label (tree);
+static bool expand_unreachable_if_stmt (tree);
+static tree expand_unreachable_stmt (tree, int);
+static void genrtl_do_stmt_1 (tree, tree);
/* Create an empty statement tree rooted at T. */
void
-begin_stmt_tree (t)
- tree *t;
+begin_stmt_tree (tree *t)
{
/* We create a trivial EXPR_STMT so that last_tree is never NULL in
what follows. We remove the extraneous statement in
/* T is a statement. Add it to the statement-tree. */
tree
-add_stmt (t)
- tree t;
+add_stmt (tree t)
{
if (input_filename != last_expr_filename)
{
/* Add T to the statement-tree. */
TREE_CHAIN (last_tree) = t;
last_tree = t;
-
+
/* When we expand a statement-tree, we must know whether or not the
statements are full-expressions. We record that fact here. */
STMT_IS_FULL_EXPR_P (last_tree) = stmts_are_full_exprs_p ();
DECL. */
void
-add_decl_stmt (decl)
- tree decl;
+add_decl_stmt (tree decl)
{
tree decl_stmt;
/* We need the type to last until instantiation time. */
decl_stmt = build_stmt (DECL_STMT, decl);
- add_stmt (decl_stmt);
+ add_stmt (decl_stmt);
}
/* Add a scope-statement to the statement-tree. BEGIN_P indicates
SCOPE_BEGIN_P set. */
tree
-add_scope_stmt (begin_p, partial_p)
- int begin_p;
- int partial_p;
+add_scope_stmt (int begin_p, int partial_p)
{
tree *stack_ptr = current_scope_stmt_stack ();
tree ss;
/* Finish the statement tree rooted at T. */
void
-finish_stmt_tree (t)
- tree *t;
+finish_stmt_tree (tree *t)
{
tree stmt;
-
+
/* Remove the fake extra statement added in begin_stmt_tree. */
stmt = TREE_CHAIN (*t);
*t = stmt;
int length;
int i;
va_list p;
-
+
va_start (p, code);
t = make_node (code);
as the condition is returned. Otherwise, T itself is returned. */
tree
-expand_cond (t)
- tree t;
+expand_cond (tree t)
{
if (t && TREE_CODE (t) == TREE_LIST)
{
expand_stmt (TREE_PURPOSE (t));
return TREE_VALUE (t);
}
- else
+ else
return t;
}
/* Create RTL for the local static variable DECL. */
void
-make_rtl_for_local_static (decl)
- tree decl;
+make_rtl_for_local_static (tree decl)
{
const char *asmspec = NULL;
/* Let the back-end know about DECL. */
void
-emit_local_var (decl)
- tree decl;
+emit_local_var (tree decl)
{
/* Create RTL for this variable. */
if (!DECL_RTL_SET_P (decl))
/* Helper for generating the RTL at the beginning of a scope. */
void
-genrtl_do_pushlevel ()
+genrtl_do_pushlevel (void)
{
emit_line_note (input_filename, input_line);
clear_last_expr ();
/* Generate the RTL for DESTINATION, which is a GOTO_STMT. */
void
-genrtl_goto_stmt (destination)
- tree destination;
+genrtl_goto_stmt (tree destination)
{
if (TREE_CODE (destination) == IDENTIFIER_NODE)
abort ();
-
+
/* We warn about unused labels with -Wunused. That means we have to
mark the used labels as used. */
if (TREE_CODE (destination) == LABEL_DECL)
TREE_USED (destination) = 1;
-
+
emit_line_note (input_filename, input_line);
-
+
if (TREE_CODE (destination) == LABEL_DECL)
{
label_rtx (destination);
- expand_goto (destination);
+ expand_goto (destination);
}
else
expand_computed_goto (destination);
used for new code. */
void
-genrtl_expr_stmt (expr)
- tree expr;
+genrtl_expr_stmt (tree expr)
{
genrtl_expr_stmt_value (expr, -1, 1);
}
MAYBE_LAST is nonzero if this EXPR_STMT might be the last statement
in expression statement. */
-void
-genrtl_expr_stmt_value (expr, want_value, maybe_last)
- tree expr;
- int want_value, maybe_last;
+void
+genrtl_expr_stmt_value (tree expr, int want_value, int maybe_last)
{
if (expr != NULL_TREE)
{
emit_line_note (input_filename, input_line);
-
+
if (stmts_are_full_exprs_p ())
expand_start_target_temps ();
-
+
if (expr != error_mark_node)
expand_expr_stmt_value (expr, want_value, maybe_last);
-
+
if (stmts_are_full_exprs_p ())
expand_end_target_temps ();
}
/* Generate the RTL for T, which is a DECL_STMT. */
void
-genrtl_decl_stmt (t)
- tree t;
+genrtl_decl_stmt (tree t)
{
tree decl;
emit_line_note (input_filename, input_line);
`extern'). We don't have to handle the initialization
of those objects here; they can only be declarations,
rather than definitions. */
- if (TREE_CODE (decl) == VAR_DECL
+ if (TREE_CODE (decl) == VAR_DECL
&& !TREE_STATIC (decl)
&& !DECL_EXTERNAL (decl))
{
if (!anon_aggr_type_p (TREE_TYPE (decl)))
emit_local_var (decl);
else
- expand_anon_union_decl (decl, NULL_TREE,
+ expand_anon_union_decl (decl, NULL_TREE,
DECL_ANON_UNION_ELEMS (decl));
}
else if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
make_rtl_for_local_static (decl);
- else if (TREE_CODE (decl) == LABEL_DECL
+ else if (TREE_CODE (decl) == LABEL_DECL
&& C_DECLARED_LABEL_FLAG (decl))
declare_nonlocal_label (decl);
else if (lang_expand_decl_stmt)
/* Generate the RTL for T, which is an IF_STMT. */
void
-genrtl_if_stmt (t)
- tree t;
+genrtl_if_stmt (tree t)
{
tree cond;
genrtl_do_pushlevel ();
if (THEN_CLAUSE (t))
{
tree nextt = THEN_CLAUSE (t);
-
+
if (cond && integer_zerop (cond))
nextt = expand_unreachable_stmt (nextt, warn_notreached);
expand_stmt (nextt);
/* Generate the RTL for T, which is a WHILE_STMT. */
void
-genrtl_while_stmt (t)
- tree t;
+genrtl_while_stmt (tree t)
{
tree cond = WHILE_COND (t);
emit_nop ();
emit_line_note (input_filename, input_line);
- expand_start_loop (1);
+ expand_start_loop (1);
genrtl_do_pushlevel ();
if (cond && !integer_nonzerop (cond))
expand_exit_loop_top_cond (0, cond);
genrtl_do_pushlevel ();
}
-
+
expand_stmt (WHILE_BODY (t));
expand_end_loop ();
body. This is reused for expanding unreachable WHILE_STMTS. */
static void
-genrtl_do_stmt_1 (cond, body)
- tree cond, body;
+genrtl_do_stmt_1 (tree cond, tree body)
{
/* Recognize the common special-case of do { ... } while (0) and do
not emit the loop widgetry in this case. In particular this
/* Generate the RTL for T, which is a DO_STMT. */
void
-genrtl_do_stmt (t)
- tree t;
+genrtl_do_stmt (tree t)
{
genrtl_do_stmt_1 (DO_COND (t), DO_BODY (t));
}
/* Build the node for a return statement and return it. */
tree
-build_return_stmt (expr)
- tree expr;
+build_return_stmt (tree expr)
{
return (build_stmt (RETURN_STMT, expr));
}
/* Generate the RTL for STMT, which is a RETURN_STMT. */
void
-genrtl_return_stmt (stmt)
- tree stmt;
+genrtl_return_stmt (tree stmt)
{
tree expr;
/* Generate the RTL for T, which is a FOR_STMT. */
void
-genrtl_for_stmt (t)
- tree t;
+genrtl_for_stmt (tree t)
{
tree cond = FOR_COND (t);
location_t saved_loc;
emit_nop ();
emit_line_note (input_filename, input_line);
if (FOR_EXPR (t))
- expand_start_loop_continue_elsewhere (1);
+ expand_start_loop_continue_elsewhere (1);
else
expand_start_loop (1);
genrtl_do_pushlevel ();
/* Build a break statement node and return it. */
tree
-build_break_stmt ()
+build_break_stmt (void)
{
return (build_stmt (BREAK_STMT));
}
/* Generate the RTL for a BREAK_STMT. */
void
-genrtl_break_stmt ()
+genrtl_break_stmt (void)
{
emit_line_note (input_filename, input_line);
if ( ! expand_exit_something ())
/* Build a continue statement node and return it. */
tree
-build_continue_stmt ()
+build_continue_stmt (void)
{
return (build_stmt (CONTINUE_STMT));
}
/* Generate the RTL for a CONTINUE_STMT. */
void
-genrtl_continue_stmt ()
+genrtl_continue_stmt (void)
{
emit_line_note (input_filename, input_line);
if (! expand_continue_loop (0))
- error ("continue statement not within a loop");
+ error ("continue statement not within a loop");
}
/* Generate the RTL for T, which is a SCOPE_STMT. */
void
-genrtl_scope_stmt (t)
- tree t;
+genrtl_scope_stmt (tree t)
{
tree block = SCOPE_STMT_BLOCK (t);
else if (!SCOPE_NULLIFIED_P (t))
{
rtx note = emit_note (NULL,
- (SCOPE_BEGIN_P (t)
+ (SCOPE_BEGIN_P (t)
? NOTE_INSN_BLOCK_BEG
: NOTE_INSN_BLOCK_END));
NOTE_BLOCK (note) = block;
for (fn = BLOCK_VARS (block); fn; fn = TREE_CHAIN (fn))
{
- if (TREE_CODE (fn) == FUNCTION_DECL
+ if (TREE_CODE (fn) == FUNCTION_DECL
&& DECL_CONTEXT (fn) == current_function_decl
&& DECL_SAVED_INSNS (fn)
&& !TREE_ASM_WRITTEN (fn)
/* Generate the RTL for T, which is a SWITCH_STMT. */
void
-genrtl_switch_stmt (t)
- tree t;
+genrtl_switch_stmt (tree t)
{
tree cond;
genrtl_do_pushlevel ();
-
+
cond = expand_cond (SWITCH_COND (t));
if (cond == error_mark_node)
/* The code is in error, but we don't want expand_end_case to
/* Create a CASE_LABEL tree node and return it. */
tree
-build_case_label (low_value, high_value, label_decl)
- tree low_value;
- tree high_value;
- tree label_decl;
+build_case_label (tree low_value, tree high_value, tree label_decl)
{
return build_stmt (CASE_LABEL, low_value, high_value, label_decl);
}
/* Generate the RTL for a CASE_LABEL. */
-void
-genrtl_case_label (case_label)
- tree case_label;
+void
+genrtl_case_label (tree case_label)
{
tree duplicate;
tree cleanup;
}
}
- add_case_node (CASE_LOW (case_label), CASE_HIGH (case_label),
+ add_case_node (CASE_LOW (case_label), CASE_HIGH (case_label),
CASE_LABEL_DECL (case_label), &duplicate);
}
/* Generate the RTL for T, which is a COMPOUND_STMT. */
void
-genrtl_compound_stmt (t)
- tree t;
+genrtl_compound_stmt (tree t)
{
#ifdef ENABLE_CHECKING
struct nesting *n = current_nesting_level ();
/* Generate the RTL for an ASM_STMT. */
void
-genrtl_asm_stmt (cv_qualifier, string, output_operands,
- input_operands, clobbers, asm_input_p)
- tree cv_qualifier;
- tree string;
- tree output_operands;
- tree input_operands;
- tree clobbers;
- int asm_input_p;
+genrtl_asm_stmt (tree cv_qualifier, tree string, tree output_operands,
+ tree input_operands, tree clobbers, int asm_input_p)
{
if (cv_qualifier != NULL_TREE
&& cv_qualifier != ridpointers[(int) RID_VOLATILE])
if (asm_input_p)
expand_asm (string, cv_qualifier != NULL_TREE);
else
- c_expand_asm_operands (string, output_operands, input_operands,
+ c_expand_asm_operands (string, output_operands, input_operands,
clobbers, cv_qualifier != NULL_TREE,
input_filename, input_line);
}
/* Generate the RTL for a CLEANUP_STMT. */
-void
-genrtl_cleanup_stmt (t)
- tree t;
+void
+genrtl_cleanup_stmt (tree t)
{
tree decl = CLEANUP_DECL (t);
if (!decl || (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node))
for the substitution. */
void
-prep_stmt (t)
- tree t;
+prep_stmt (tree t)
{
if (!STMT_LINENO_FOR_FN_P (t))
input_line = STMT_LINENO (t);
other statements at its nesting level. */
void
-expand_stmt (t)
- tree t;
+expand_stmt (tree t)
{
while (t && t != error_mark_node)
{
default:
if (lang_expand_stmt)
(*lang_expand_stmt) (t);
- else
+ else
abort ();
break;
}
/* If *TP is a potentially reachable label, return nonzero. */
static tree
-find_reachable_label_1 (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
+find_reachable_label_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
{
switch (TREE_CODE (*tp))
{
/* Determine whether expression EXP contains a potentially
reachable label. */
static tree
-find_reachable_label (exp)
- tree exp;
+find_reachable_label (tree exp)
{
location_t saved_loc = input_location;
tree ret = walk_tree (&exp, find_reachable_label_1, NULL, NULL);
/* Expand an unreachable if statement, T. This function returns
true if the IF_STMT contains a potentially reachable code_label. */
static bool
-expand_unreachable_if_stmt (t)
- tree t;
+expand_unreachable_if_stmt (tree t)
{
tree n;
-
+
if (find_reachable_label (IF_COND (t)) != NULL_TREE)
{
genrtl_if_stmt (t);
if (THEN_CLAUSE (t) && ELSE_CLAUSE (t))
{
n = expand_unreachable_stmt (THEN_CLAUSE (t), 0);
-
+
if (n != NULL_TREE)
{
rtx label;
n = expand_unreachable_stmt (ELSE_CLAUSE (t), 0);
else
n = NULL_TREE;
-
+
expand_stmt (n);
-
+
return n != NULL_TREE;
}
then returns the label (or, in same cases, the statement after
one containing the label). */
static tree
-expand_unreachable_stmt (t, warn)
- tree t;
- int warn;
+expand_unreachable_stmt (tree t, int warn)
{
int saved;
}
return NULL_TREE;
}
-
\f
/* in c-lang.c and objc-act.c */
-extern tree lookup_interface PARAMS ((tree));
-extern tree is_class_name PARAMS ((tree));
-extern tree objc_is_id PARAMS ((tree));
-extern void objc_check_decl PARAMS ((tree));
-extern void finish_file PARAMS ((void));
-extern int objc_comptypes PARAMS ((tree, tree, int));
-extern tree objc_message_selector PARAMS ((void));
-extern tree lookup_objc_ivar PARAMS ((tree));
-extern void c_expand_body PARAMS ((tree));
+extern tree lookup_interface (tree);
+extern tree is_class_name (tree);
+extern tree objc_is_id (tree);
+extern void objc_check_decl (tree);
+extern void finish_file (void);
+extern int objc_comptypes (tree, tree, int);
+extern tree objc_message_selector (void);
+extern tree lookup_objc_ivar (tree);
+extern void c_expand_body (tree);
\f
/* in c-parse.in */
-extern void c_parse_init PARAMS ((void));
+extern void c_parse_init (void);
/* in c-aux-info.c */
-extern void gen_aux_info_record PARAMS ((tree, int, int, int));
+extern void gen_aux_info_record (tree, int, int, int);
/* in c-decl.c */
-extern int global_bindings_p PARAMS ((void));
-extern int kept_level_p PARAMS ((void));
-extern tree getdecls PARAMS ((void));
-extern void pushlevel PARAMS ((int));
-extern void insert_block PARAMS ((tree));
-extern void set_block PARAMS ((tree));
-extern tree pushdecl PARAMS ((tree));
-
-extern void c_insert_default_attributes PARAMS ((tree));
-extern void c_init_decl_processing PARAMS ((void));
-extern void c_dup_lang_specific_decl PARAMS ((tree));
-extern void c_print_identifier PARAMS ((FILE *, tree, int));
-extern tree build_array_declarator PARAMS ((tree, tree, int, int));
-extern tree build_enumerator PARAMS ((tree, tree));
-extern void check_for_loop_decls PARAMS ((void));
-extern void clear_parm_order PARAMS ((void));
-extern int complete_array_type PARAMS ((tree, tree, int));
-extern void declare_parm_level PARAMS ((int));
-extern tree define_label PARAMS ((const char *, int,
- tree));
-extern void finish_decl PARAMS ((tree, tree, tree));
-extern tree finish_enum PARAMS ((tree, tree, tree));
-extern void finish_function PARAMS ((int, int));
-extern tree finish_struct PARAMS ((tree, tree, tree));
-extern tree get_parm_info PARAMS ((int));
-extern tree grokfield PARAMS ((const char *, int, tree, tree, tree));
-extern tree groktypename PARAMS ((tree));
-extern tree groktypename_in_parm_context PARAMS ((tree));
-extern tree implicitly_declare PARAMS ((tree));
-extern int in_parm_level_p PARAMS ((void));
-extern void keep_next_level PARAMS ((void));
-extern tree lookup_name PARAMS ((tree));
-extern void parmlist_tags_warning PARAMS ((void));
-extern void pending_xref_error PARAMS ((void));
-extern void c_push_function_context PARAMS ((struct function *));
-extern void c_pop_function_context PARAMS ((struct function *));
-extern void pop_label_level PARAMS ((void));
-extern void push_label_level PARAMS ((void));
-extern void push_parm_decl PARAMS ((tree));
-extern tree pushdecl_top_level PARAMS ((tree));
-extern tree pushdecl_function_level PARAMS ((tree, tree));
-extern void pushtag PARAMS ((tree, tree));
-extern tree set_array_declarator_type PARAMS ((tree, tree, int));
-extern tree shadow_label PARAMS ((tree));
-extern void shadow_tag PARAMS ((tree));
-extern void shadow_tag_warned PARAMS ((tree, int));
-extern tree start_enum PARAMS ((tree));
-extern int start_function PARAMS ((tree, tree, tree));
-extern tree start_decl PARAMS ((tree, tree, int,
- tree));
-extern tree start_struct PARAMS ((enum tree_code, tree));
-extern void store_parm_decls PARAMS ((void));
-extern tree xref_tag PARAMS ((enum tree_code, tree));
-extern tree c_begin_compound_stmt PARAMS ((void));
-extern void c_expand_deferred_function PARAMS ((tree));
-extern void c_expand_decl_stmt PARAMS ((tree));
-extern tree make_pointer_declarator PARAMS ((tree, tree));
+extern int global_bindings_p (void);
+extern int kept_level_p (void);
+extern tree getdecls (void);
+extern void pushlevel (int);
+extern void insert_block (tree);
+extern void set_block (tree);
+extern tree pushdecl (tree);
+
+extern void c_insert_default_attributes (tree);
+extern void c_init_decl_processing (void);
+extern void c_dup_lang_specific_decl (tree);
+extern void c_print_identifier (FILE *, tree, int);
+extern tree build_array_declarator (tree, tree, int, int);
+extern tree build_enumerator (tree, tree);
+extern void check_for_loop_decls (void);
+extern void clear_parm_order (void);
+extern int complete_array_type (tree, tree, int);
+extern void declare_parm_level (int);
+extern tree define_label (const char *, int, tree);
+extern void finish_decl (tree, tree, tree);
+extern tree finish_enum (tree, tree, tree);
+extern void finish_function (int, int);
+extern tree finish_struct (tree, tree, tree);
+extern tree get_parm_info (int);
+extern tree grokfield (const char *, int, tree, tree, tree);
+extern tree groktypename (tree);
+extern tree groktypename_in_parm_context (tree);
+extern tree implicitly_declare (tree);
+extern int in_parm_level_p (void);
+extern void keep_next_level (void);
+extern tree lookup_name (tree);
+extern void parmlist_tags_warning (void);
+extern void pending_xref_error (void);
+extern void c_push_function_context (struct function *);
+extern void c_pop_function_context (struct function *);
+extern void pop_label_level (void);
+extern void push_label_level (void);
+extern void push_parm_decl (tree);
+extern tree pushdecl_top_level (tree);
+extern tree pushdecl_function_level (tree, tree);
+extern void pushtag (tree, tree);
+extern tree set_array_declarator_type (tree, tree, int);
+extern tree shadow_label (tree);
+extern void shadow_tag (tree);
+extern void shadow_tag_warned (tree, int);
+extern tree start_enum (tree);
+extern int start_function (tree, tree, tree);
+extern tree start_decl (tree, tree, int, tree);
+extern tree start_struct (enum tree_code, tree);
+extern void store_parm_decls (void);
+extern tree xref_tag (enum tree_code, tree);
+extern tree c_begin_compound_stmt (void);
+extern void c_expand_deferred_function (tree);
+extern void c_expand_decl_stmt (tree);
+extern tree make_pointer_declarator (tree, tree);
/* in c-objc-common.c */
-extern int c_disregard_inline_limits PARAMS ((tree));
-extern int c_cannot_inline_tree_fn PARAMS ((tree *));
-extern bool c_objc_common_init PARAMS ((void));
-extern int c_missing_noreturn_ok_p PARAMS ((tree));
-extern void c_objc_common_finish_file PARAMS ((void));
-extern int defer_fn PARAMS ((tree));
-extern bool c_warn_unused_global_decl PARAMS ((tree));
+extern int c_disregard_inline_limits (tree);
+extern int c_cannot_inline_tree_fn (tree *);
+extern bool c_objc_common_init (void);
+extern int c_missing_noreturn_ok_p (tree);
+extern void c_objc_common_finish_file (void);
+extern int defer_fn (tree);
+extern bool c_warn_unused_global_decl (tree);
#define c_build_type_variant(TYPE, CONST_P, VOLATILE_P) \
c_build_qualified_type ((TYPE), \
#define c_sizeof_nowarn(T) c_sizeof_or_alignof_type (T, SIZEOF_EXPR, 0)
/* in c-typeck.c */
-extern tree require_complete_type PARAMS ((tree));
-extern int comptypes PARAMS ((tree, tree));
-extern tree c_size_in_bytes PARAMS ((tree));
-extern bool c_mark_addressable PARAMS ((tree));
-extern void c_incomplete_type_error PARAMS ((tree, tree));
-extern tree c_type_promotes_to PARAMS ((tree));
-extern tree build_component_ref PARAMS ((tree, tree));
-extern tree build_indirect_ref PARAMS ((tree, const char *));
-extern tree build_array_ref PARAMS ((tree, tree));
-extern tree build_external_ref PARAMS ((tree, int));
-extern tree parser_build_binary_op PARAMS ((enum tree_code,
- tree, tree));
-extern int c_tree_expr_nonnegative_p PARAMS ((tree));
-extern void readonly_warning PARAMS ((tree, const char *));
-extern tree build_conditional_expr PARAMS ((tree, tree, tree));
-extern tree build_compound_expr PARAMS ((tree));
-extern tree c_cast_expr PARAMS ((tree, tree));
-extern tree build_c_cast PARAMS ((tree, tree));
-extern tree build_modify_expr PARAMS ((tree, enum tree_code,
- tree));
-extern void store_init_value PARAMS ((tree, tree));
-extern void error_init PARAMS ((const char *));
-extern void pedwarn_init PARAMS ((const char *));
-extern void start_init PARAMS ((tree, tree, int));
-extern void finish_init PARAMS ((void));
-extern void really_start_incremental_init PARAMS ((tree));
-extern void push_init_level PARAMS ((int));
-extern tree pop_init_level PARAMS ((int));
-extern void set_init_index PARAMS ((tree, tree));
-extern void set_init_label PARAMS ((tree));
-extern void process_init_element PARAMS ((tree));
-extern tree build_compound_literal PARAMS ((tree, tree));
-extern void pedwarn_c99 PARAMS ((const char *, ...))
- ATTRIBUTE_PRINTF_1;
-extern tree c_start_case PARAMS ((tree));
-extern void c_finish_case PARAMS ((void));
-extern tree simple_asm_stmt PARAMS ((tree));
-extern tree build_asm_stmt PARAMS ((tree, tree, tree,
- tree, tree));
-extern tree c_convert_parm_for_inlining PARAMS ((tree, tree, tree));
+extern tree require_complete_type (tree);
+extern int comptypes (tree, tree);
+extern tree c_size_in_bytes (tree);
+extern bool c_mark_addressable (tree);
+extern void c_incomplete_type_error (tree, tree);
+extern tree c_type_promotes_to (tree);
+extern tree build_component_ref (tree, tree);
+extern tree build_indirect_ref (tree, const char *);
+extern tree build_array_ref (tree, tree);
+extern tree build_external_ref (tree, int);
+extern tree parser_build_binary_op (enum tree_code, tree, tree);
+extern int c_tree_expr_nonnegative_p (tree);
+extern void readonly_warning (tree, const char *);
+extern tree build_conditional_expr (tree, tree, tree);
+extern tree build_compound_expr (tree);
+extern tree c_cast_expr (tree, tree);
+extern tree build_c_cast (tree, tree);
+extern tree build_modify_expr (tree, enum tree_code, tree);
+extern void store_init_value (tree, tree);
+extern void error_init (const char *);
+extern void pedwarn_init (const char *);
+extern void start_init (tree, tree, int);
+extern void finish_init (void);
+extern void really_start_incremental_init (tree);
+extern void push_init_level (int);
+extern tree pop_init_level (int);
+extern void set_init_index (tree, tree);
+extern void set_init_label (tree);
+extern void process_init_element (tree);
+extern tree build_compound_literal (tree, tree);
+extern void pedwarn_c99 (const char *, ...) ATTRIBUTE_PRINTF_1;
+extern tree c_start_case (tree);
+extern void c_finish_case (void);
+extern tree simple_asm_stmt (tree);
+extern tree build_asm_stmt (tree, tree, tree, tree, tree);
+extern tree c_convert_parm_for_inlining (tree, tree, tree);
/* Set to 0 at beginning of a function definition, set to 1 if
a return statement that specifies a return value is seen. */
extern int system_header_p;
/* In c-decl.c */
-extern void c_finish_incomplete_decl PARAMS ((tree));
+extern void c_finish_incomplete_decl (tree);
extern GTY(()) tree static_ctors;
extern GTY(()) tree static_dtors;
does not have an incomplete type. (That includes void types.) */
tree
-require_complete_type (value)
- tree value;
+require_complete_type (tree value)
{
tree type = TREE_TYPE (value);
and TYPE is the type that was invalid. */
void
-c_incomplete_type_error (value, type)
- tree value;
- tree type;
+c_incomplete_type_error (tree value, tree type)
{
const char *type_code_string;
arguments and return the new type. */
tree
-c_type_promotes_to (type)
- tree type;
+c_type_promotes_to (tree type)
{
if (TYPE_MAIN_VARIANT (type) == float_type_node)
return double_type_node;
as well as those of TYPE. */
static tree
-qualify_type (type, like)
- tree type, like;
+qualify_type (tree type, tree like)
{
- return c_build_qualified_type (type,
+ return c_build_qualified_type (type,
TYPE_QUALS (type) | TYPE_QUALS (like));
}
\f
if the operands have the given two types. */
tree
-common_type (t1, t2)
- tree t1, t2;
+common_type (tree t1, tree t2)
{
enum tree_code code1;
enum tree_code code2;
tree pointed_to_2 = TREE_TYPE (t2);
tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
TYPE_MAIN_VARIANT (pointed_to_2));
- t1 = build_pointer_type (c_build_qualified_type
- (target,
- TYPE_QUALS (pointed_to_1) |
+ t1 = build_pointer_type (c_build_qualified_type
+ (target,
+ TYPE_QUALS (pointed_to_1) |
TYPE_QUALS (pointed_to_2)));
return build_type_attribute_variant (t1, attributes);
}
TREE_VALUE (n) = TREE_VALUE (p1);
goto parm_done;
}
-
+
/* Given wait (union {union wait *u; int *i} *)
and wait (union wait *),
prefer union wait * as type of parm. */
but a warning may be needed if you use them together. */
int
-comptypes (type1, type2)
- tree type1, type2;
+comptypes (tree type1, tree type2)
{
tree t1 = type1;
tree t2 = type2;
&& TYPE_DOMAIN (t2) != 0)
t2 = TYPE_DOMAIN (t2);
- /* Treat an enum type as the integer type of the same width and
+ /* Treat an enum type as the integer type of the same width and
signedness. */
if (TREE_CODE (t1) == ENUMERAL_TYPE)
*/
static int
-comp_target_types (ttl, ttr, reflexive)
- tree ttl, ttr;
- int reflexive;
+comp_target_types (tree ttl, tree ttr, int reflexive)
{
int val;
/* Return 1 if two function types F1 and F2 are compatible.
If either type specifies no argument types,
the other must specify a fixed number of self-promoting arg types.
- Otherwise, if one type specifies only the number of arguments,
+ Otherwise, if one type specifies only the number of arguments,
the other must specify that number of self-promoting arg types.
Otherwise, the argument types must match. */
static int
-function_types_compatible_p (f1, f2)
- tree f1, f2;
+function_types_compatible_p (tree f1, tree f2)
{
tree args1, args2;
/* 1 if no need for warning yet, 2 if warning cause has been seen. */
or 2 for compatible with warning. */
static int
-type_lists_compatible_p (args1, args2)
- tree args1, args2;
+type_lists_compatible_p (tree args1, tree args2)
{
/* 1 if no need for warning yet, 2 if warning cause has been seen. */
int val = 1;
if (c_type_promotes_to (TREE_VALUE (args1)) != TREE_VALUE (args1))
return 0;
}
- else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
+ else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
{
/* Allow wait (union {union wait *u; int *i} *)
/* Compute the size to increment a pointer by. */
tree
-c_size_in_bytes (type)
- tree type;
+c_size_in_bytes (tree type)
{
enum tree_code code = TREE_CODE (type);
/* Return either DECL or its known constant value (if it has one). */
tree
-decl_constant_value (decl)
- tree decl;
+decl_constant_value (tree decl)
{
if (/* Don't change a variable array bound or initial value to a constant
in a place where a variable is invalid. */
right test for avoiding misoptimizations either. */
static tree
-decl_constant_value_for_broken_optimization (decl)
- tree decl;
+decl_constant_value_for_broken_optimization (tree decl)
{
if (pedantic || DECL_MODE (decl) == BLKmode)
return decl;
return EXP. */
static tree
-default_function_array_conversion (exp)
- tree exp;
+default_function_array_conversion (tree exp)
{
tree orig_exp;
tree type = TREE_TYPE (exp);
int not_lvalue = 0;
/* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
- an lvalue.
+ an lvalue.
Do not use STRIP_NOPS here! It will remove conversions from pointer
to integer and cause infinite recursion. */
}
if (TYPE_QUALS (type) || constp || volatilep)
- restype
+ restype
= c_build_qualified_type (restype,
- TYPE_QUALS (type)
+ TYPE_QUALS (type)
| (constp * TYPE_QUAL_CONST)
| (volatilep * TYPE_QUAL_VOLATILE));
In addition, manifest constants symbols are replaced by their values. */
tree
-default_conversion (exp)
- tree exp;
+default_conversion (tree exp)
{
tree orig_exp;
tree type = TREE_TYPE (exp);
}
/* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
- an lvalue.
+ an lvalue.
Do not use STRIP_NOPS here! It will remove conversions from pointer
to integer and cause infinite recursion. */
TREE_VALUE of the list. Normally the list is of length one, but if
the component is embedded within (nested) anonymous structures or
unions, the list steps down the chain to the component. */
-
+
static tree
-lookup_field (decl, component)
- tree decl, component;
+lookup_field (tree decl, tree component)
{
tree type = TREE_TYPE (decl);
tree field;
if (anon)
return tree_cons (NULL_TREE, field, anon);
- }
+ }
}
/* Entire record is only anon unions. */
structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
tree
-build_component_ref (datum, component)
- tree datum, component;
+build_component_ref (tree datum, tree component)
{
tree type = TREE_TYPE (datum);
enum tree_code code = TREE_CODE (type);
ERRORSTRING is the name of the operator to appear in error messages. */
tree
-build_indirect_ref (ptr, errorstring)
- tree ptr;
- const char *errorstring;
+build_indirect_ref (tree ptr, const char *errorstring)
{
tree pointer = default_conversion (ptr);
tree type = TREE_TYPE (pointer);
by functions). */
tree
-build_array_ref (array, index)
- tree array, index;
+build_array_ref (tree array, tree index)
{
if (index == 0)
{
TREE_THIS_VOLATILE (rval)
|= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
/* This was added by rms on 16 Nov 91.
- It fixes vol struct foo *a; a->elts[1]
+ It fixes vol struct foo *a; a->elts[1]
in an inline function.
Hope it doesn't break something else. */
| TREE_THIS_VOLATILE (array));
including a reference to a builtin outside of function-call context.
Arrange to suppress further errors for the same identifier. */
static void
-undeclared_variable (id)
- tree id;
+undeclared_variable (tree id)
{
if (current_function_decl == 0)
{
/* Build an external reference to identifier ID. FUN indicates
whether this will be used for a function call. */
tree
-build_external_ref (id, fun)
- tree id;
- int fun;
+build_external_ref (tree id, int fun)
{
tree ref;
tree decl = lookup_name (id);
|| TREE_CODE (ref) == FUNCTION_DECL))
{
tree context = decl_function_context (ref);
-
+
if (context != 0 && context != current_function_decl)
DECL_NONLOCAL (ref) = 1;
}
FUNCTION's data type may be a function type or a pointer-to-function. */
tree
-build_function_call (function, params)
- tree function, params;
+build_function_call (tree function, tree params)
{
tree fntype, fundecl = 0;
tree coerced_params;
with the elements of the list in the TREE_VALUE slots of those nodes. */
static tree
-convert_arguments (typelist, values, name, fundecl)
- tree typelist, values, name, fundecl;
+convert_arguments (tree typelist, tree values, tree name, tree fundecl)
{
tree typetail, valtail;
tree result = NULL;
}
}
- parmval = convert_for_assignment (type, val,
+ parmval = convert_for_assignment (type, val,
(char *) 0, /* arg passing */
fundecl, name, parmnum + 1);
-
+
if (PROMOTE_PROTOTYPES
&& INTEGRAL_TYPE_P (type)
&& (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
in a way that is likely to confuse the user. */
tree
-parser_build_binary_op (code, arg1, arg2)
- enum tree_code code;
- tree arg1, arg2;
+parser_build_binary_op (enum tree_code code, tree arg1, tree arg2)
{
tree result = build_binary_op (code, arg1, arg2, 1);
the arithmetic is to be done. */
tree
-build_binary_op (code, orig_op0, orig_op1, convert_p)
- enum tree_code code;
- tree orig_op0, orig_op1;
- int convert_p;
+build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, int convert_p)
{
tree type0, type1;
enum tree_code code0, code1;
if (comp_target_types (type0, type1, 1))
{
result_type = common_type (type0, type1);
- if (pedantic
+ if (pedantic
&& TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
}
if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
!= !COMPLETE_TYPE_P (TREE_TYPE (type1)))
pedwarn ("comparison of complete and incomplete pointers");
- else if (pedantic
+ else if (pedantic
&& TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
}
pass the copies by reference, then copy them back afterward. */
tree xop0 = op0, xop1 = op1, xresult_type = result_type;
enum tree_code xresultcode = resultcode;
- tree val
+ tree val
= shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
if (val != 0)
STRIP_TYPE_NOPS (xop1);
/* Give warnings for comparisons between signed and unsigned
- quantities that may fail.
+ quantities that may fail.
Do the checking based on the original operand trees, so that
casts will be considered, but default promotions won't be.
else
primop1 = get_narrower (TREE_OPERAND (primop1, 0),
&unsignedp1);
-
+
if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
{
tree primop;
if (! converted)
{
if (TREE_TYPE (op0) != result_type)
- op0 = convert (result_type, op0);
+ op0 = convert (result_type, op0);
if (TREE_TYPE (op1) != result_type)
- op1 = convert (result_type, op1);
+ op1 = convert (result_type, op1);
}
if (build_type == NULL_TREE)
/* Return true if `t' is known to be non-negative. */
int
-c_tree_expr_nonnegative_p (t)
- tree t;
+c_tree_expr_nonnegative_p (tree t)
{
if (TREE_CODE (t) == STMT_EXPR)
{
/* Find the last statement in the chain, ignoring the final
* scope statement */
- while (TREE_CHAIN (t) != NULL_TREE
+ while (TREE_CHAIN (t) != NULL_TREE
&& TREE_CODE (TREE_CHAIN (t)) != SCOPE_STMT)
t = TREE_CHAIN (t);
return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
The resulting tree has type int. */
static tree
-pointer_diff (op0, op1)
- tree op0, op1;
+pointer_diff (tree op0, tree op1)
{
tree result, folded;
tree restype = ptrdiff_type_node;
arrays to pointers in C99. */
tree
-build_unary_op (code, xarg, flag)
- enum tree_code code;
- tree xarg;
- int flag;
+build_unary_op (enum tree_code code, tree xarg, int flag)
{
/* No default_conversion here. It causes trouble for ADDR_EXPR. */
tree arg = xarg;
return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
else
return convert (TREE_TYPE (arg), integer_zero_node);
-
+
case PREINCREMENT_EXPR:
case POSTINCREMENT_EXPR:
case PREDECREMENT_EXPR:
/* Report a read-only lvalue. */
if (TREE_READONLY (arg))
- readonly_warning (arg,
+ readonly_warning (arg,
((code == PREINCREMENT_EXPR
|| code == POSTINCREMENT_EXPR)
? "increment" : "decrement"));
Lvalues can have their address taken, unless they have DECL_REGISTER. */
int
-lvalue_p (ref)
- tree ref;
+lvalue_p (tree ref)
{
enum tree_code code = TREE_CODE (ref);
otherwise, print an error message and return zero. */
int
-lvalue_or_else (ref, msgid)
- tree ref;
- const char *msgid;
+lvalue_or_else (tree ref, const char *msgid)
{
int win = lvalue_p (ref);
a pointer in C99.
If ARG is not a kind of expression we can handle, return zero. */
-
+
static tree
-unary_complex_lvalue (code, arg, flag)
- enum tree_code code;
- tree arg;
- int flag;
+unary_complex_lvalue (enum tree_code code, tree arg, int flag)
{
/* Handle (a, b) used as an "lvalue". */
if (TREE_CODE (arg) == COMPOUND_EXPR)
COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
static void
-pedantic_lvalue_warning (code)
- enum tree_code code;
+pedantic_lvalue_warning (enum tree_code code)
{
if (pedantic)
switch (code)
/* Warn about storing in something that is `const'. */
void
-readonly_warning (arg, msgid)
- tree arg;
- const char *msgid;
+readonly_warning (tree arg, const char *msgid)
{
if (TREE_CODE (arg) == COMPONENT_REF)
{
Returns true if successful. */
bool
-c_mark_addressable (exp)
- tree exp;
+c_mark_addressable (tree exp)
{
tree x = exp;
/* Build and return a conditional expression IFEXP ? OP1 : OP2. */
tree
-build_conditional_expr (ifexp, op1, op2)
- tree ifexp, op1, op2;
+build_conditional_expr (tree ifexp, tree op1, tree op2)
{
tree type1;
tree type2;
code1 = TREE_CODE (type1);
type2 = TREE_TYPE (op2);
code2 = TREE_CODE (type2);
-
+
/* Quickly detect the usual case where op1 and op2 have the same type
after promotion. */
if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
op1 = convert_and_check (result_type, op1);
if (result_type != TREE_TYPE (op2))
op2 = convert_and_check (result_type, op2);
-
+
if (TREE_CODE (ifexp) == INTEGER_CST)
return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
that performs them all and returns the value of the last of them. */
tree
-build_compound_expr (list)
- tree list;
+build_compound_expr (tree list)
{
return internal_build_compound_expr (list, TRUE);
}
static tree
-internal_build_compound_expr (list, first_p)
- tree list;
- int first_p;
+internal_build_compound_expr (tree list, int first_p)
{
tree rest;
/* Build an expression representing a cast to type TYPE of expression EXPR. */
tree
-build_c_cast (type, expr)
- tree type;
- tree expr;
+build_c_cast (tree type, tree expr)
{
tree value = expr;
-
+
if (type == error_mark_node || expr == error_mark_node)
return error_mark_node;
&& flag_strict_aliasing && warn_strict_aliasing
&& !VOID_TYPE_P (TREE_TYPE (type)))
{
- /* Casting the address of a decl to non void pointer. Warn
+ /* Casting the address of a decl to non void pointer. Warn
if the cast breaks type based aliasing. */
if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
warning ("type-punning to incomplete type might break strict-aliasing rules");
/* Interpret a cast of expression EXPR to type TYPE. */
tree
-c_cast_expr (type, expr)
- tree type, expr;
+c_cast_expr (tree type, tree expr)
{
int saved_wsp = warn_strict_prototypes;
Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
tree
-build_modify_expr (lhs, modifycode, rhs)
- tree lhs, rhs;
- enum tree_code modifycode;
+build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
{
tree result;
tree newrhs;
return error_mark_node;
return build (COMPOUND_EXPR, lhstype,
TREE_OPERAND (lhs, 0), newrhs);
-
+
/* Handle (a ? b : c) used as an "lvalue". */
case COND_EXPR:
pedantic_lvalue_warning (COND_EXPR);
pedantic_lvalue_warning (CONVERT_EXPR);
return convert (TREE_TYPE (lhs), result);
}
-
+
default:
break;
}
PARMNUM is the number of the argument, for printing in error messages. */
static tree
-convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
- tree type, rhs;
- const char *errtype;
- tree fundecl, funname;
- int parmnum;
+convert_for_assignment (tree type, tree rhs, const char *errtype, tree fundecl, tree funname, int parmnum)
{
enum tree_code codel = TREE_CODE (type);
tree rhstype;
error ("void value not ignored as it ought to be");
return error_mark_node;
}
- /* A type converts to a reference to it.
+ /* A type converts to a reference to it.
This code doesn't fully support references, it's just for the
special case of va_start and va_copy. */
if (codel == REFERENCE_TYPE
|| (*targetm.vector_opaque_p) (rhstype)))
return convert (type, rhs);
/* Arithmetic types all interconvert, and enum is treated like int. */
- else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
+ else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
|| codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
|| codel == BOOLEAN_TYPE)
&& (coder == INTEGER_TYPE || coder == REAL_TYPE
errtype, funname,
parmnum);
}
-
+
if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
pedwarn ("ISO C prohibits argument conversion to union type");
if (!errtype)
{
if (funname)
- {
- tree selector = objc_message_selector ();
-
- if (selector && parmnum > 2)
- error ("incompatible type for argument %d of `%s'",
+ {
+ tree selector = objc_message_selector ();
+
+ if (selector && parmnum > 2)
+ error ("incompatible type for argument %d of `%s'",
parmnum - 2, IDENTIFIER_POINTER (selector));
- else
+ else
error ("incompatible type for argument %d of `%s'",
parmnum, IDENTIFIER_POINTER (funname));
}
/* Convert VALUE for assignment into inlined parameter PARM. */
tree
-c_convert_parm_for_inlining (parm, value, fn)
- tree parm, value, fn;
+c_convert_parm_for_inlining (tree parm, tree value, tree fn)
{
tree ret, type;
return value;
type = TREE_TYPE (parm);
- ret = convert_for_assignment (type, value,
+ ret = convert_for_assignment (type, value,
(char *) 0 /* arg passing */, fn,
DECL_NAME (fn), 0);
if (PROMOTE_PROTOTYPES
Objective-C selector. */
static void
-warn_for_assignment (msgid, opname, function, argnum)
- const char *msgid;
- const char *opname;
- tree function;
- int argnum;
+warn_for_assignment (const char *msgid, const char *opname, tree function, int argnum)
{
if (opname == 0)
{
tree selector = objc_message_selector ();
char * new_opname;
-
+
if (selector && argnum > 2)
{
function = selector;
if (argnum == 0)
{
if (function)
- {
+ {
/* Function name is known; supply it. */
const char *const argstring = _("passing arg of `%s'");
new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
which is allowed with a warning when -pedantic is specified. */
static tree
-valid_compound_expr_initializer (value, endtype)
- tree value;
- tree endtype;
+valid_compound_expr_initializer (tree value, tree endtype)
{
if (TREE_CODE (value) == COMPOUND_EXPR)
{
If the init is invalid, store an ERROR_MARK. */
void
-store_init_value (decl, init)
- tree decl, init;
+store_init_value (tree decl, tree init)
{
tree value, type;
/* Push STRING on the stack. Printed literally. */
static void
-push_string (string)
- const char *string;
+push_string (const char *string)
{
PUSH_SPELLING (SPELLING_STRING, string, u.s);
}
/* Push a member name on the stack. Printed as '.' STRING. */
static void
-push_member_name (decl)
- tree decl;
-
+push_member_name (tree decl)
{
const char *const string
= DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
/* Push an array bounds on the stack. Printed as [BOUNDS]. */
static void
-push_array_bounds (bounds)
- int bounds;
+push_array_bounds (int bounds)
{
PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
}
/* Compute the maximum size in bytes of the printed spelling. */
static int
-spelling_length ()
+spelling_length (void)
{
int size = 0;
struct spelling *p;
/* Print the spelling to BUFFER and return it. */
static char *
-print_spelling (buffer)
- char *buffer;
+print_spelling (char *buffer)
{
char *d = buffer;
struct spelling *p;
The component name is taken from the spelling stack. */
void
-error_init (msgid)
- const char *msgid;
+error_init (const char *msgid)
{
char *ofwhat;
The component name is taken from the spelling stack. */
void
-pedwarn_init (msgid)
- const char *msgid;
+pedwarn_init (const char *msgid)
{
char *ofwhat;
The component name is taken from the spelling stack. */
static void
-warning_init (msgid)
- const char *msgid;
+warning_init (const char *msgid)
{
char *ofwhat;
elements are seen. */
static tree
-digest_init (type, init, require_constant)
- tree type, init;
- int require_constant;
+digest_init (tree type, tree init, int require_constant)
{
enum tree_code code = TREE_CODE (type);
tree inside_init = init;
if (flag_pedantic_errors)
inside_init = error_mark_node;
}
- else if (require_constant
+ else if (require_constant
&& (!TREE_CONSTANT (inside_init)
/* This test catches things like `7 / 0' which
result in an expression for which TREE_CONSTANT
/* Prepare to parse and output the initializer for variable DECL. */
void
-start_init (decl, asmspec_tree, top_level)
- tree decl;
- tree asmspec_tree;
- int top_level;
+start_init (tree decl, tree asmspec_tree, int top_level)
{
const char *locus;
struct initializer_stack *p
}
void
-finish_init ()
+finish_init (void)
{
struct initializer_stack *p = initializer_stack;
For an initializer for a decl, TYPE is zero. */
void
-really_start_incremental_init (type)
- tree type;
+really_start_incremental_init (tree type)
{
struct constructor_stack *p
= (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
IMPLICIT is 1 (or 2 if the push is because of designator list). */
void
-push_init_level (implicit)
- int implicit;
+push_init_level (int implicit)
{
struct constructor_stack *p;
tree value = NULL_TREE;
&& constructor_fields == 0)
process_init_element (pop_init_level (1));
else if (TREE_CODE (constructor_type) == ARRAY_TYPE
- && constructor_max_index
+ && constructor_max_index
&& tree_int_cst_lt (constructor_max_index, constructor_index))
process_init_element (pop_init_level (1));
else
constructor_max_index = build_int_2 (-1, -1);
constructor_index
- = convert (bitsizetype,
+ = convert (bitsizetype,
TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
}
else
}
}
-/* At the end of an implicit or explicit brace level,
+/* At the end of an implicit or explicit brace level,
finish up that level of constructor.
If we were outputting the elements as they are read, return 0
from inner levels (process_init_element ignores that),
Otherwise, return a CONSTRUCTOR expression. */
tree
-pop_init_level (implicit)
- int implicit;
+pop_init_level (int implicit)
{
struct constructor_stack *p;
tree constructor = 0;
ARRAY argument is nonzero for array ranges. Returns zero for success. */
static int
-set_designator (array)
- int array;
+set_designator (int array)
{
tree subtype;
enum tree_code subcode;
NULL_TREE if there is no range designator at this level. */
static void
-push_range_stack (range_end)
- tree range_end;
+push_range_stack (tree range_end)
{
struct constructor_range_stack *p;
of indices, running from FIRST through LAST. */
void
-set_init_index (first, last)
- tree first, last;
+set_init_index (tree first, tree last)
{
if (set_designator (1))
return;
/* Within a struct initializer, specify the next field to be initialized. */
void
-set_init_label (fieldname)
- tree fieldname;
+set_init_label (tree fieldname)
{
tree tail;
error_init ("field name not in record or union initializer");
return;
}
-
+
for (tail = TYPE_FIELDS (constructor_type); tail;
tail = TREE_CHAIN (tail))
{
}
\f
/* Add a new initializer to the tree of pending initializers. PURPOSE
- identifies the initializer, either array index or field in a structure.
+ identifies the initializer, either array index or field in a structure.
VALUE is the value of that index or field. */
static void
-add_pending_init (purpose, value)
- tree purpose, value;
+add_pending_init (tree purpose, tree value)
{
struct init_node *p, **q, *r;
/* Build AVL tree from a sorted chain. */
static void
-set_nonincremental_init ()
+set_nonincremental_init (void)
{
tree chain;
&& DECL_C_BIT_FIELD (constructor_unfilled_fields)
&& DECL_NAME (constructor_unfilled_fields) == 0)
constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
-
+
}
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
/* Build AVL tree from a string constant. */
static void
-set_nonincremental_init_from_string (str)
- tree str;
+set_nonincremental_init_from_string (tree str)
{
tree value, purpose, type;
HOST_WIDE_INT val[2];
not initialized yet. */
static tree
-find_init_member (field)
- tree field;
+find_init_member (tree field)
{
struct init_node *p;
it is 0 while outputting pending elements, to avoid recursion.) */
static void
-output_init_element (value, type, field, pending)
- tree value, type, field;
- int pending;
+output_init_element (tree value, tree type, tree field, int pending)
{
if (type == error_mark_node)
{
we can output all the pending elements. */
static void
-output_pending_init_elements (all)
- int all;
+output_pending_init_elements (int all)
{
struct init_node *elt = constructor_pending_elts;
tree next;
If we find an element that should be output now,
output it. Otherwise, set NEXT to the element
that comes first among those still pending. */
-
+
next = 0;
while (elt)
{
it calls output_init_element. */
void
-process_init_element (value)
- tree value;
+process_init_element (tree value)
{
tree orig_value = value;
int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
\f
/* Build a simple asm-statement, from one string literal. */
tree
-simple_asm_stmt (expr)
- tree expr;
+simple_asm_stmt (tree expr)
{
STRIP_NOPS (expr);
STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */
tree
-build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers)
- tree cv_qualifier;
- tree string;
- tree outputs;
- tree inputs;
- tree clobbers;
+build_asm_stmt (tree cv_qualifier, tree string, tree outputs, tree inputs, tree clobbers)
{
tree tail;
TREE_VALUE (tail) = output;
}
- /* Perform default conversions on array and function inputs.
+ /* Perform default conversions on array and function inputs.
Don't do this for other types as it would screw up operands
expected to be in memory. */
for (tail = inputs; tail; tail = TREE_CHAIN (tail))
Arguments are same as for expand_asm_operands. */
void
-c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
- tree string, outputs, inputs, clobbers;
- int vol;
- const char *filename;
- int line;
+c_expand_asm_operands (tree string, tree outputs, tree inputs,
+ tree clobbers, int vol, const char *filename,
+ int line)
{
int noutputs = list_length (outputs);
int i;
or a null pointer for `return;' with no value. */
tree
-c_expand_return (retval)
- tree retval;
+c_expand_return (tree retval)
{
tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
inner = TREE_OPERAND (inner, 0);
continue;
}
-
+
case ADDR_EXPR:
inner = TREE_OPERAND (inner, 0);
SWITCH_STMT. */
tree
-c_start_case (exp)
- tree exp;
+c_start_case (tree exp)
{
enum tree_code code;
tree type, orig_type = error_mark_node;
/* Process a case label. */
tree
-do_case (low_value, high_value)
- tree low_value;
- tree high_value;
+do_case (tree low_value, tree high_value)
{
tree label = NULL_TREE;
{
bool switch_was_empty_p = (SWITCH_BODY (switch_stack->switch_stmt) == NULL_TREE);
- label = c_add_case_label (switch_stack->cases,
- SWITCH_COND (switch_stack->switch_stmt),
+ label = c_add_case_label (switch_stack->cases,
+ SWITCH_COND (switch_stack->switch_stmt),
low_value, high_value);
if (label == error_mark_node)
label = NULL_TREE;
/* Finish the switch statement. */
void
-c_finish_case ()
+c_finish_case (void)
{
struct c_switch *cs = switch_stack;
projects / platform / upstream / linaro-gcc.git / commitdiff