2002-12-28 Gabriel Dos Reis <gdr@integrable-solutions.net>
+ Remove traditional C constructs 4/n.
+ * decl2.c (grok_method_quals, warn_if_unknown_interface,
+ grok_x_components, cp_build_parm_decl, build_artificial_parm,
+ maybe_retrofit_in_chrg, grokclassfn, grok_array_decl,
+ delete_sanity, check_member_template, check_java_method,
+ check_classfn, finish_static_data_member_decl, grokfield,
+ grokbitfield, grokoptypename, grok_function_init,
+ cplus_decl_attributes, constructor_name, defer_fn,
+ build_anon_union_vars, finish_anon_union, coerce_new_type,
+ coerce_delete_type, comdat_linkage, maybe_make_one_only,
+ key_method, import_export_vtable, import_export_class,
+ output_vtable_inherit, import_export_decl, import_export_tinfo,
+ build_cleanup, get_guard, get_guard_bits, get_guard_cond,
+ set_guard, start_objects, finish_objects,
+ start_static_storage_duration_function,
+ finish_static_storage_duration_function, get_priority_info,
+ start_static_initialization_or_destruction,
+ finish_static_initialization_or_destruction,
+ do_static_initialization, do_static_destruction,
+ prune_vars_needing_no_initialization, write_out_vars,
+ reparse_decl_as_expr, finish_decl_parsing, namespace_ancestor,
+ add_using_namespace, merge_functions, ambiguous_decl,
+ lookup_using_namespace, lookup_using_namespace,
+ qualified_lookup_using_namespace, set_decl_namespace,
+ decl_namespace, current_decl_namespace, push_decl_namespace,
+ pop_decl_namespace, push_scope, pop_scope, add_function,
+ arg_assoc_namespace, arg_assoc_template_arg, arg_assoc,
+ lookup_arg_dependent, do_namespace_alias,
+ validate_nonmember_using_decl, do_nonmember_using_decl,
+ do_toplevel_using_decl, do_local_using_decl,
+ do_class_using_decl, do_using_directive, check_default_args,
+ mark_used, handle_class_head): Use C90 prototypings. Use booleans.
+ * parser.c (cp_parser_class_head): Use booleanss.
+ * decl.c (walk_globals, walk_vtables): Likewise.
+ * cp-tree.h (walk_globals_pred, walk_globals_fn, walk_vtables,
+ walk_globals): Change return type from 'int' to 'bool'.
+ * rtti.c (init_rtti_processing, build_headof, throw_bad_cast
+ throw_bad_typeid, get_tinfo_decl_dynamic, typeid_ok_p,
+ build_typeid, tinfo_name, get_tinfo_decl, get_tinfo_ptr,
+ get_typeid, ifnonnull, build_dynamic_cast_1, build_dynamic_cast,
+ qualifier_flags, tinfo_base_init, generic_initializer,
+ ptr_initializer, dfs_class_hint_mark, ptm_initializer,
+ dfs_class_hint_unmark, class_hint_flags, class_initializer,
+ typeinfo_in_lib_p, get_pseudo_ti_init, create_pseudo_type_info,
+ get_pseudo_ti_desc, create_tinfo_types, emit_support_tinfos,
+ unemitted_tinfo_decl_p, emit_tinfo_decl): Likewise.
+ * repo.c (repo_compile_flags, repo_template_declared,
+ repo_template_defined, repo_class_defined, repo_get_id,
+ repo_template_used, repo_vtable_used, repo_inline_used,
+ repo_tinfo_used, repo_template_instantiated, extract_string,
+ open_repo_file, afgets, init_repo, reopen_repo_file_for_write,
+ finish_repo): Likewise.
+ * ptree.c (cxx_print_decl, cxx_print_type, cxx_print_identifier,
+ cxx_print_xnode): Likewise..
+ * cp-lang.c (ok_to_generate_alias_set_for_type, cxx_get_alias_set,
+ cxx_warn_unused_global_decl, cp_expr_size): Likewise.
+ * cxxfilt.c (demangle_it, print_demangler_list, usage,
+ standard_symbol_characters, hp_symbol_characters, main, fatal):
+ Likewise.
+ (strip_underscore): Change type from 'int' to 'bool'.
+ (main): Use boolean constants.
+
+2002-12-28 Gabriel Dos Reis <gdr@integrable-solutions.net>
+
Remove traditional C constructs 3/n.
* cvt.c (cp_convert_to_pointer, convert_to_pointer_force,
build_up_reference, warn_ref_binding, convert_to_reference,
#include "langhooks.h"
#include "langhooks-def.h"
-static HOST_WIDE_INT cxx_get_alias_set PARAMS ((tree));
-static bool ok_to_generate_alias_set_for_type PARAMS ((tree));
-static bool cxx_warn_unused_global_decl PARAMS ((tree));
-static tree cp_expr_size PARAMS ((tree));
-static bool cp_var_mod_type_p PARAMS ((tree));
+static HOST_WIDE_INT cxx_get_alias_set (tree);
+static bool ok_to_generate_alias_set_for_type (tree);
+static bool cxx_warn_unused_global_decl (tree);
+static tree cp_expr_size (tree);
+static bool cp_var_mod_type_p (tree);
#undef LANG_HOOKS_NAME
#define LANG_HOOKS_NAME "GNU C++"
Return TRUE if T safe for aliasing FALSE otherwise. */
static bool
-ok_to_generate_alias_set_for_type (t)
- tree t;
+ok_to_generate_alias_set_for_type (tree t)
{
if (TYPE_PTRMEMFUNC_P (t))
return true;
/* Special routine to get the alias set for C++. */
static HOST_WIDE_INT
-cxx_get_alias_set (t)
- tree t;
+cxx_get_alias_set (tree t)
{
/* It's not yet safe to use alias sets for classes in C++. */
if (!ok_to_generate_alias_set_for_type(t))
/* Called from check_global_declarations. */
static bool
-cxx_warn_unused_global_decl (decl)
- tree decl;
+cxx_warn_unused_global_decl (tree decl)
{
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
return false;
might have allocated something there. */
static tree
-cp_expr_size (exp)
- tree exp;
+cp_expr_size (tree exp)
{
if (CLASS_TYPE_P (TREE_TYPE (exp)))
{
extern tree instantiate_type PARAMS ((tree, tree, tsubst_flags_t));
extern void print_class_statistics PARAMS ((void));
extern void cxx_print_statistics PARAMS ((void));
-extern void cxx_print_xnode PARAMS ((FILE *, tree, int));
-extern void cxx_print_decl PARAMS ((FILE *, tree, int));
-extern void cxx_print_type PARAMS ((FILE *, tree, int));
-extern void cxx_print_identifier PARAMS ((FILE *, tree, int));
+extern void cxx_print_xnode (FILE *, tree, int);
+extern void cxx_print_decl (FILE *, tree, int);
+extern void cxx_print_type (FILE *, tree, int);
+extern void cxx_print_identifier (FILE *, tree, int);
extern void cxx_print_error_function PARAMS ((struct diagnostic_context *,
const char *));
extern void build_self_reference PARAMS ((void));
extern tree namespace_ancestor PARAMS ((tree, tree));
extern tree unqualified_namespace_lookup PARAMS ((tree, int, tree *));
extern tree check_for_out_of_scope_variable (tree);
-extern int lookup_using_namespace PARAMS ((tree, tree, tree, tree, int, tree *));
-extern int qualified_lookup_using_namespace PARAMS ((tree, tree, tree, int));
+extern bool lookup_using_namespace (tree, tree, tree, tree, int, tree *);
+extern bool qualified_lookup_using_namespace (tree, tree, tree, int);
extern tree build_library_fn PARAMS ((tree, tree));
extern tree build_library_fn_ptr PARAMS ((const char *, tree));
extern tree build_cp_library_fn_ptr PARAMS ((const char *, tree));
extern int vtable_decl_p PARAMS ((tree, void *));
extern int vtype_decl_p PARAMS ((tree, void *));
extern int sigtable_decl_p PARAMS ((tree, void *));
-typedef int (*walk_globals_pred) PARAMS ((tree, void *));
-typedef int (*walk_globals_fn) PARAMS ((tree *, void *));
-extern int walk_globals PARAMS ((walk_globals_pred,
- walk_globals_fn,
- void *));
-extern int walk_vtables PARAMS ((walk_globals_pred,
- walk_globals_fn,
- void *));
+typedef bool (*walk_globals_pred) (tree, void *);
+typedef bool (*walk_globals_fn) (tree *, void *);
+extern bool walk_globals (walk_globals_pred, walk_globals_fn, void *);
+extern bool walk_vtables (walk_globals_pred, walk_globals_fn, void *);
typedef int (*walk_namespaces_fn) PARAMS ((tree, void *));
extern int walk_namespaces PARAMS ((walk_namespaces_fn,
void *));
extern bool have_extern_spec;
/* in decl2.c */
-extern int check_java_method PARAMS ((tree));
-extern int grok_method_quals PARAMS ((tree, tree, tree));
-extern void warn_if_unknown_interface PARAMS ((tree));
-extern void grok_x_components PARAMS ((tree));
-extern void maybe_retrofit_in_chrg PARAMS ((tree));
-extern void maybe_make_one_only PARAMS ((tree));
-extern void grokclassfn PARAMS ((tree, tree, enum overload_flags, tree));
-extern tree grok_array_decl PARAMS ((tree, tree));
-extern tree delete_sanity PARAMS ((tree, tree, int, int));
-extern tree check_classfn PARAMS ((tree, tree));
-extern void check_member_template PARAMS ((tree));
-extern tree grokfield PARAMS ((tree, tree, tree, tree, tree));
-extern tree grokbitfield PARAMS ((tree, tree, tree));
+extern bool check_java_method (tree);
+extern int grok_method_quals (tree, tree, tree);
+extern void warn_if_unknown_interface (tree);
+extern void grok_x_components (tree);
+extern void maybe_retrofit_in_chrg (tree);
+extern void maybe_make_one_only (tree);
+extern void grokclassfn (tree, tree, enum overload_flags, tree);
+extern tree grok_array_decl (tree, tree);
+extern tree delete_sanity (tree, tree, int, int);
+extern tree check_classfn (tree, tree);
+extern void check_member_template (tree);
+extern tree grokfield (tree, tree, tree, tree, tree);
+extern tree grokbitfield (tree, tree, tree);
extern tree groktypefield PARAMS ((tree, tree));
-extern tree grokoptypename PARAMS ((tree, tree, tree));
-extern void cplus_decl_attributes PARAMS ((tree *, tree, int));
+extern tree grokoptypename (tree, tree, tree);
+extern void cplus_decl_attributes (tree *, tree, int);
extern tree constructor_name_full PARAMS ((tree));
-extern tree constructor_name PARAMS ((tree));
+extern tree constructor_name (tree);
extern bool constructor_name_p (tree, tree);
-extern void defer_fn PARAMS ((tree));
-extern void finish_anon_union PARAMS ((tree));
-extern tree finish_table PARAMS ((tree, tree, tree, int));
-extern tree coerce_new_type PARAMS ((tree));
-extern tree coerce_delete_type PARAMS ((tree));
-extern void comdat_linkage PARAMS ((tree));
-extern void import_export_vtable PARAMS ((tree, tree, int));
-extern void import_export_decl PARAMS ((tree));
-extern void import_export_tinfo PARAMS ((tree, tree, int));
+extern void defer_fn (tree);
+extern void finish_anon_union (tree);
+extern tree finish_table (tree, tree, tree, int);
+extern tree coerce_new_type (tree);
+extern tree coerce_delete_type (tree);
+extern void comdat_linkage (tree);
+extern void import_export_vtable (tree, tree, int);
+extern void import_export_decl (tree);
+extern void import_export_tinfo (tree, tree, bool);
extern tree build_cleanup PARAMS ((tree));
extern void finish_file PARAMS ((void));
extern tree reparse_absdcl_as_expr PARAMS ((tree, tree));
extern tree build_expr_from_tree PARAMS ((tree));
extern tree build_offset_ref_call_from_tree (tree, tree);
extern tree build_call_from_tree (tree, tree, bool);
-extern tree reparse_decl_as_expr PARAMS ((tree, tree));
-extern tree finish_decl_parsing PARAMS ((tree));
-extern void set_decl_namespace PARAMS ((tree, tree, int));
+extern tree reparse_decl_as_expr (tree, tree);
+extern tree finish_decl_parsing (tree);
+extern void set_decl_namespace (tree, tree, bool);
extern tree current_decl_namespace PARAMS ((void));
extern void push_decl_namespace PARAMS ((tree));
extern void pop_decl_namespace PARAMS ((void));
extern void push_scope PARAMS ((tree));
extern void pop_scope PARAMS ((tree));
-extern void do_namespace_alias PARAMS ((tree, tree));
-extern void do_toplevel_using_decl PARAMS ((tree));
-extern void do_local_using_decl PARAMS ((tree));
-extern tree do_class_using_decl PARAMS ((tree));
-extern void do_using_directive PARAMS ((tree));
-extern void check_default_args PARAMS ((tree));
-extern void mark_used PARAMS ((tree));
-extern tree handle_class_head (enum tag_types, tree, tree, tree, int, int *);
-extern tree lookup_arg_dependent PARAMS ((tree, tree, tree));
-extern void finish_static_data_member_decl PARAMS ((tree, tree, tree, int));
-extern tree cp_build_parm_decl PARAMS ((tree, tree));
-extern tree build_artificial_parm PARAMS ((tree, tree));
-extern tree get_guard PARAMS ((tree));
-extern tree get_guard_cond PARAMS ((tree));
-extern tree set_guard PARAMS ((tree));
+extern void do_namespace_alias (tree, tree);
+extern void do_toplevel_using_decl (tree);
+extern void do_local_using_decl (tree);
+extern tree do_class_using_decl (tree);
+extern void do_using_directive (tree);
+extern void check_default_args (tree);
+extern void mark_used (tree);
+extern tree handle_class_head (enum tag_types, tree, tree, tree, bool, bool *);
+extern tree lookup_arg_dependent (tree, tree, tree);
+extern void finish_static_data_member_decl (tree, tree, tree, int);
+extern tree cp_build_parm_decl (tree, tree);
+extern tree build_artificial_parm (tree, tree);
+extern tree get_guard (tree);
+extern tree get_guard_cond (tree);
+extern tree set_guard (tree);
extern void cp_error_at PARAMS ((const char *msgid, ...));
extern void cp_warning_at PARAMS ((const char *msgid, ...));
extern int processing_template_parmlist;
/* in repo.c */
-extern void repo_template_used PARAMS ((tree));
-extern void repo_template_instantiated PARAMS ((tree, int));
-extern void init_repo PARAMS ((const char *));
-extern void finish_repo PARAMS ((void));
+extern void repo_template_used (tree);
+extern void repo_template_instantiated (tree, bool);
+extern void init_repo (const char *);
+extern void finish_repo (void);
/* in rtti.c */
-extern void init_rtti_processing PARAMS((void));
-extern tree build_typeid PARAMS((tree));
-extern tree get_tinfo_decl PARAMS((tree));
-extern tree get_typeid PARAMS((tree));
-extern tree build_dynamic_cast PARAMS((tree, tree));
-extern void emit_support_tinfos PARAMS((void));
-extern int unemitted_tinfo_decl_p PARAMS((tree, void *));
-extern int emit_tinfo_decl PARAMS((tree *, void *));
+extern void init_rtti_processing (void);
+extern tree build_typeid (tree);
+extern tree get_tinfo_decl (tree);
+extern tree get_typeid (tree);
+extern tree build_dynamic_cast (tree, tree);
+extern void emit_support_tinfos (void);
+extern bool unemitted_tinfo_decl_p (tree, void *);
+extern bool emit_tinfo_decl (tree *, void *);
/* in search.c */
extern tree lookup_base PARAMS ((tree, tree, base_access, base_kind *));
static const char *program_name;
static int flags = DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE;
-static void demangle_it PARAMS ((char *));
-static void usage PARAMS ((FILE *, int)) ATTRIBUTE_NORETURN;
-static void fatal PARAMS ((const char *)) ATTRIBUTE_NORETURN;
-static void print_demangler_list PARAMS ((FILE *));
+static void demangle_it (char *);
+static void usage (FILE *, int) ATTRIBUTE_NORETURN;
+static void fatal (const char *) ATTRIBUTE_NORETURN;
+static void print_demangler_list (FILE *);
static void
-demangle_it (mangled_name)
- char *mangled_name;
+demangle_it (char *mangled_name)
{
char *result;
}
static void
-print_demangler_list (stream)
- FILE *stream;
+print_demangler_list (FILE *stream)
{
const struct demangler_engine *demangler;
}
static void
-usage (stream, status)
- FILE *stream;
- int status;
+usage (FILE *stream, int status)
{
fprintf (stream, "\
Usage: %s [-_] [-n] [--strip-underscores] [--no-strip-underscores] \n",
#define MBUF_SIZE 32767
char mbuffer[MBUF_SIZE];
-int strip_underscore = 0;
+bool strip_underscore = false;
static const struct option long_options[] = {
{"strip-underscores", no_argument, 0, '_'},
{0, no_argument, 0, 0}
};
-static const char *
-standard_symbol_characters PARAMS ((void));
+static const char *standard_symbol_characters (void);
-static const char *
-hp_symbol_characters PARAMS ((void));
+static const char *hp_symbol_characters (void);
/* Return the string of non-alnum characters that may occur
as a valid symbol component, in the standard assembler symbol
syntax. */
static const char *
-standard_symbol_characters ()
+standard_symbol_characters (void)
{
return "_$.";
}
So have fun. */
static const char *
-hp_symbol_characters ()
+hp_symbol_characters (void)
{
return "_$.<>#,*&[]:(){}";
}
-extern int main PARAMS ((int, char **));
+extern int main (int, char **);
int
-main (argc, argv)
- int argc;
- char **argv;
+main (int argc, char **argv)
{
char *result;
int c;
case 'h':
usage (stdout, 0);
case 'n':
- strip_underscore = 0;
+ strip_underscore = false;
break;
case 'v':
printf ("GNU %s (C++ demangler), version %s\n",
program_name, version_string);
return (0);
case '_':
- strip_underscore = 1;
+ strip_underscore = true;
break;
case 's':
{
}
static void
-fatal (str)
- const char *str;
+fatal (const char *str)
{
fprintf (stderr, "%s: %s\n", program_name, str);
exit (1);
/* Walk the vtable declarations. Whenever one is found for which P
returns nonzero, call F with its address. If any call to F
returns a nonzero value, return a nonzero value. */
-int
-walk_vtables (p, f, data)
- walk_globals_pred p;
- walk_globals_fn f;
- void *data;
+bool
+walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data)
{
struct walk_globals_data wgd;
wgd.p = p;
}
/* Walk the global declarations. Whenever one is found for which P
- returns nonzero, call F with its address. If any call to F
- returns a nonzero value, return a nonzero value. */
+ returns true, call F with its address. If any call to F
+ returns true, return true. */
-int
-walk_globals (p, f, data)
- walk_globals_pred p;
- walk_globals_fn f;
- void *data;
+bool
+walk_globals (walk_globals_pred p, walk_globals_fn f, void *data)
{
struct walk_globals_data wgd;
wgd.p = p;
int destructions_p;
} *priority_info;
-static void mark_vtable_entries PARAMS ((tree));
-static void grok_function_init PARAMS ((tree, tree));
-static int maybe_emit_vtables (tree);
-static int is_namespace_ancestor PARAMS ((tree, tree));
-static void add_using_namespace PARAMS ((tree, tree, int));
-static tree ambiguous_decl PARAMS ((tree, tree, tree,int));
-static tree build_anon_union_vars PARAMS ((tree));
-static int acceptable_java_type PARAMS ((tree));
-static void output_vtable_inherit PARAMS ((tree));
-static tree start_objects PARAMS ((int, int));
-static void finish_objects PARAMS ((int, int, tree));
-static tree merge_functions PARAMS ((tree, tree));
-static tree decl_namespace PARAMS ((tree));
-static tree validate_nonmember_using_decl PARAMS ((tree, tree *, tree *));
-static void do_nonmember_using_decl PARAMS ((tree, tree, tree, tree,
- tree *, tree *));
-static tree start_static_storage_duration_function PARAMS ((void));
-static void finish_static_storage_duration_function PARAMS ((tree));
-static priority_info get_priority_info PARAMS ((int));
-static void do_static_initialization PARAMS ((tree, tree));
-static void do_static_destruction PARAMS ((tree));
-static tree start_static_initialization_or_destruction PARAMS ((tree, int));
-static void finish_static_initialization_or_destruction PARAMS ((tree));
-static void generate_ctor_or_dtor_function PARAMS ((int, int));
-static int generate_ctor_and_dtor_functions_for_priority
- PARAMS ((splay_tree_node, void *));
-static tree prune_vars_needing_no_initialization PARAMS ((tree));
-static void write_out_vars PARAMS ((tree));
-static void import_export_class PARAMS ((tree));
-static tree key_method PARAMS ((tree));
-static tree get_guard_bits PARAMS ((tree));
+static void mark_vtable_entries (tree);
+static void grok_function_init (tree, tree);
+static bool maybe_emit_vtables (tree);
+static bool is_namespace_ancestor (tree, tree);
+static void add_using_namespace (tree, tree, bool);
+static tree ambiguous_decl (tree, tree, tree,int);
+static tree build_anon_union_vars (tree);
+static bool acceptable_java_type (tree);
+static void output_vtable_inherit (tree);
+static tree start_objects (int, int);
+static void finish_objects (int, int, tree);
+static tree merge_functions (tree, tree);
+static tree decl_namespace (tree);
+static tree validate_nonmember_using_decl (tree, tree *, tree *);
+static void do_nonmember_using_decl (tree, tree, tree, tree, tree *, tree *);
+static tree start_static_storage_duration_function (void);
+static void finish_static_storage_duration_function (tree);
+static priority_info get_priority_info (int);
+static void do_static_initialization (tree, tree);
+static void do_static_destruction (tree);
+static tree start_static_initialization_or_destruction (tree, int);
+static void finish_static_initialization_or_destruction (tree);
+static void generate_ctor_or_dtor_function (bool, int);
+static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,
+ void *);
+static tree prune_vars_needing_no_initialization (tree);
+static void write_out_vars (tree);
+static void import_export_class (tree);
+static tree key_method (tree);
+static tree get_guard_bits (tree);
/* A list of static class variables. This is needed, because a
static class variable can be declared inside the class without
TYPE_UNQUALIFIED will be an extension. */
int
-grok_method_quals (ctype, function, quals)
- tree ctype, function, quals;
+grok_method_quals (tree ctype, tree function, tree quals)
{
tree fntype = TREE_TYPE (function);
tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
inform the user. */
void
-warn_if_unknown_interface (decl)
- tree decl;
+warn_if_unknown_interface (tree decl)
{
static int already_warned = 0;
if (already_warned++)
/* A subroutine of the parser, to handle a component list. */
void
-grok_x_components (specs)
- tree specs;
+grok_x_components (tree specs)
{
tree t;
appropriately. */
tree
-cp_build_parm_decl (name, type)
- tree name;
- tree type;
+cp_build_parm_decl (tree name, tree type)
{
tree parm = build_decl (PARM_DECL, name, type);
DECL_ARG_TYPE (parm) = type_passed_as (type);
indicated NAME. */
tree
-build_artificial_parm (name, type)
- tree name;
- tree type;
+build_artificial_parm (tree name, tree type)
{
tree parm = cp_build_parm_decl (name, type);
DECL_ARTIFICIAL (parm) = 1;
VTT parm (if any), then the user-written parms. */
void
-maybe_retrofit_in_chrg (fn)
- tree fn;
+maybe_retrofit_in_chrg (tree fn)
{
tree basetype, arg_types, parms, parm, fntype;
QUALS are the qualifiers for the this pointer. */
void
-grokclassfn (ctype, function, flags, quals)
- tree ctype, function;
- enum overload_flags flags;
- tree quals;
+grokclassfn (tree ctype, tree function, enum overload_flags flags, tree quals)
{
tree fn_name = DECL_NAME (function);
int this_quals = TYPE_UNQUALIFIED;
along the way. */
tree
-grok_array_decl (array_expr, index_exp)
- tree array_expr, index_exp;
+grok_array_decl (tree array_expr, tree index_exp)
{
tree type = TREE_TYPE (array_expr);
tree p1, p2, i1, i2;
Implements ARM $5.3.4. This is called from the parser. */
tree
-delete_sanity (exp, size, doing_vec, use_global_delete)
- tree exp, size;
- int doing_vec, use_global_delete;
+delete_sanity (tree exp, tree size, int doing_vec, int use_global_delete)
{
tree t, type;
/* For a regular vector delete (aka, no size argument) we will pass
sort of thing that should be a member template. */
void
-check_member_template (tmpl)
- tree tmpl;
+check_member_template (tree tmpl)
{
tree decl;
/* Return true iff TYPE is a valid Java parameter or return type. */
-static int
-acceptable_java_type (type)
- tree type;
+static bool
+acceptable_java_type (tree type)
{
if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
return 1;
{
tree args; int i;
if (! TYPE_FOR_JAVA (type))
- return 0;
+ return false;
if (! CLASSTYPE_TEMPLATE_INFO (type))
- return 1;
+ return true;
args = CLASSTYPE_TI_ARGS (type);
i = TREE_VEC_LENGTH (args);
while (--i >= 0)
if (TREE_CODE (type) == POINTER_TYPE)
type = TREE_TYPE (type);
if (! TYPE_FOR_JAVA (type))
- return 0;
+ return false;
}
- return 1;
+ return true;
}
}
- return 0;
+ return false;
}
-/* For a METHOD in a Java class CTYPE, return 1 if
+/* For a METHOD in a Java class CTYPE, return true if
the parameter and return types are valid Java types.
- Otherwise, print appropriate error messages, and return 0. */
+ Otherwise, print appropriate error messages, and return false. */
-int
-check_java_method (method)
- tree method;
+bool
+check_java_method (tree method)
{
- int jerr = 0;
+ bool jerr = false;
tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
tree ret_type = TREE_TYPE (TREE_TYPE (method));
- if (! acceptable_java_type (ret_type))
+ if (!acceptable_java_type (ret_type))
{
error ("Java method '%D' has non-Java return type `%T'",
method, ret_type);
- jerr++;
+ jerr = true;
}
for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
{
tree type = TREE_VALUE (arg_types);
- if (! acceptable_java_type (type))
+ if (!acceptable_java_type (type))
{
error ("Java method '%D' has non-Java parameter type `%T'",
method, type);
- jerr++;
+ jerr = true;
}
}
- return jerr ? 0 : 1;
+ return !jerr;
}
/* Sanity check: report error if this function FUNCTION is not
CNAME is the same here as it is for grokclassfn above. */
tree
-check_classfn (ctype, function)
- tree ctype, function;
+check_classfn (tree ctype, tree function)
{
int ix;
FLAGS is as for cp_finish_decl. */
void
-finish_static_data_member_decl (decl, init, asmspec_tree, flags)
- tree decl;
- tree init;
- tree asmspec_tree;
- int flags;
+finish_static_data_member_decl (tree decl, tree init, tree asmspec_tree,
+ int flags)
{
my_friendly_assert (TREE_PUBLIC (decl), 0);
CHANGES TO CODE IN `start_method'. */
tree
-grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
- tree declarator, declspecs, init, asmspec_tree, attrlist;
+grokfield (tree declarator, tree declspecs, tree init, tree asmspec_tree,
+ tree attrlist)
{
tree value;
const char *asmspec = 0;
WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
tree
-grokbitfield (declarator, declspecs, width)
- tree declarator, declspecs, width;
+grokbitfield (tree declarator, tree declspecs, tree width)
{
register tree value = grokdeclarator (declarator, declspecs, BITFIELD,
0, NULL);
scope of the conversion operator, if explicit. */
tree
-grokoptypename (declspecs, declarator, scope)
- tree declspecs, declarator;
- tree scope;
+grokoptypename (tree declspecs, tree declarator, tree scope)
{
tree t = grokdeclarator (declarator, declspecs, TYPENAME, 0, NULL);
*/
static void
-grok_function_init (decl, init)
- tree decl;
- tree init;
+grok_function_init (tree decl, tree init)
{
/* An initializer for a function tells how this function should
be inherited. */
}
\f
void
-cplus_decl_attributes (decl, attributes, flags)
- tree *decl, attributes;
- int flags;
+cplus_decl_attributes (tree *decl, tree attributes, int flags)
{
if (*decl == NULL_TREE || *decl == void_type_node)
return;
unspecialized name. */
tree
-constructor_name (type)
- tree type;
+constructor_name (tree type)
{
tree name;
name = constructor_name_full (type);
/* Defer the compilation of the FN until the end of compilation. */
void
-defer_fn (fn)
- tree fn;
+defer_fn (tree fn)
{
if (DECL_DEFERRED_FN (fn))
return;
the mangled name. */
static tree
-build_anon_union_vars (object)
- tree object;
+build_anon_union_vars (tree object)
{
tree type = TREE_TYPE (object);
tree main_decl = NULL_TREE;
is nonzero if this union is not declared static. */
void
-finish_anon_union (anon_union_decl)
- tree anon_union_decl;
+finish_anon_union (tree anon_union_decl)
{
tree type = TREE_TYPE (anon_union_decl);
tree main_decl;
- int public_p = TREE_PUBLIC (anon_union_decl);
+ bool public_p = TREE_PUBLIC (anon_union_decl);
/* The VAR_DECL's context is the same as the TYPE's context. */
DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
what compiler will be expecting. */
tree
-coerce_new_type (type)
- tree type;
+coerce_new_type (tree type)
{
int e = 0;
tree args = TYPE_ARG_TYPES (type);
}
tree
-coerce_delete_type (type)
- tree type;
+coerce_delete_type (tree type)
{
int e = 0;
tree args = TYPE_ARG_TYPES (type);
}
\f
static void
-mark_vtable_entries (decl)
- tree decl;
+mark_vtable_entries (tree decl)
{
tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
linkage available. */
void
-comdat_linkage (decl)
- tree decl;
+comdat_linkage (tree decl)
{
if (flag_weak)
make_decl_one_only (decl);
instantiations; otherwise we get duplicate symbol errors. */
void
-maybe_make_one_only (decl)
- tree decl;
+maybe_make_one_only (tree decl)
{
/* We used to say that this was not necessary on targets that support weak
symbols, because the implicit instantiations will defer to the explicit
emitted, or NULL_TREE if that heuristic is not applicable to TYPE. */
static tree
-key_method (type)
- tree type;
+key_method (tree type)
{
tree method;
it's public in this file or in another one. */
void
-import_export_vtable (decl, type, final)
- tree decl, type;
- int final;
+import_export_vtable (tree decl, tree type, int final)
{
if (DECL_INTERFACE_KNOWN (decl))
return;
using various heuristics. */
static void
-import_export_class (ctype)
- tree ctype;
+import_export_class (tree ctype)
{
/* -1 for imported, 1 for exported. */
int import_export = 0;
a vtable and the vtable of the parent class. */
static void
-output_vtable_inherit (vars)
- tree vars;
+output_vtable_inherit (tree vars)
{
tree parent;
rtx child_rtx, parent_rtx;
}
/* If necessary, write out the vtables for the dynamic class CTYPE.
- Returns nonzero if any vtables were emitted. */
+ Returns true if any vtables were emitted. */
-static int
+static bool
maybe_emit_vtables (tree ctype)
{
tree vtbl;
nothing more to do. */
primary_vtbl = CLASSTYPE_VTABLES (ctype);
if (TREE_ASM_WRITTEN (primary_vtbl))
- return 0;
+ return false;
/* Ignore dummy vtables made by get_vtable_decl. */
if (TREE_TYPE (primary_vtbl) == void_type_node)
- return 0;
+ return false;
import_export_class (ctype);
import_export_vtable (primary_vtbl, ctype, 1);
if (DECL_COMDAT (primary_vtbl)
&& CLASSTYPE_DEBUG_REQUESTED (ctype))
note_debug_info_needed (ctype);
- return 0;
+ return false;
}
/* The ABI requires that we emit all of the vtables if we emit any
info. */
note_debug_info_needed (ctype);
- return 1;
+ return true;
}
/* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
inline function or template instantiation at end-of-file. */
void
-import_export_decl (decl)
- tree decl;
+import_export_decl (tree decl)
{
if (DECL_INTERFACE_KNOWN (decl))
return;
typeinfo for TYPE should be in the runtime library. */
void
-import_export_tinfo (decl, type, is_in_library)
- tree decl;
- tree type;
- int is_in_library;
+import_export_tinfo (tree decl, tree type, bool is_in_library)
{
if (DECL_INTERFACE_KNOWN (decl))
return;
}
tree
-build_cleanup (decl)
- tree decl;
+build_cleanup (tree decl)
{
tree temp;
tree type = TREE_TYPE (decl);
which has static storage duration. */
tree
-get_guard (decl)
- tree decl;
+get_guard (tree decl)
{
tree sname;
tree guard;
guarded entity is actually initialized. */
static tree
-get_guard_bits (guard)
- tree guard;
+get_guard_bits (tree guard)
{
/* We only set the first byte of the guard, in order to leave room
for a mutex in the high-order bits. */
variable has already been initialized. */
tree
-get_guard_cond (guard)
- tree guard;
+get_guard_cond (tree guard)
{
tree guard_value;
the variable being guarded has been initialized. */
tree
-set_guard (guard)
- tree guard;
+set_guard (tree guard)
{
tree guard_init;
or destructors. Subroutine of do_[cd]tors. */
static tree
-start_objects (method_type, initp)
- int method_type, initp;
+start_objects (int method_type, int initp)
{
tree fnname;
tree body;
or destructors. Subroutine of do_[cd]tors. */
static void
-finish_objects (method_type, initp, body)
- int method_type, initp;
- tree body;
+finish_objects (int method_type, int initp, tree body)
{
tree fn;
translation unit. */
static tree
-start_static_storage_duration_function ()
+start_static_storage_duration_function (void)
{
static unsigned ssdf_number;
this point, no more such objects can be created. */
static void
-finish_static_storage_duration_function (body)
- tree body;
+finish_static_storage_duration_function (tree body)
{
/* Close out the function. */
finish_compound_stmt (/*has_no_scope=*/0, body);
appropriate prologue. */
static priority_info
-get_priority_info (priority)
- int priority;
+get_priority_info (int priority)
{
priority_info pi;
splay_tree_node n;
are destroying it. */
static tree
-start_static_initialization_or_destruction (decl, initp)
- tree decl;
- int initp;
+start_static_initialization_or_destruction (tree decl, int initp)
{
tree guard_if_stmt = NULL_TREE;
int priority;
the initialization. */
static void
-finish_static_initialization_or_destruction (guard_if_stmt)
- tree guard_if_stmt;
+finish_static_initialization_or_destruction (tree guard_if_stmt)
{
finish_then_clause (guard_if_stmt);
finish_if_stmt ();
static storage duration. The initialization is INIT. */
static void
-do_static_initialization (decl, init)
- tree decl;
- tree init;
+do_static_initialization (tree decl, tree init)
{
tree guard_if_stmt;
destruction. */
static void
-do_static_destruction (decl)
- tree decl;
+do_static_destruction (tree decl)
{
tree guard_if_stmt;
i.e., the first variable should be initialized first. */
static tree
-prune_vars_needing_no_initialization (vars)
- tree vars;
+prune_vars_needing_no_initialization (tree vars)
{
tree var;
tree result;
VARS. */
static void
-write_out_vars (vars)
- tree vars;
+write_out_vars (tree vars)
{
tree v;
storage duration having the indicated PRIORITY. */
static void
-generate_ctor_or_dtor_function (constructor_p, priority)
- int constructor_p;
- int priority;
+generate_ctor_or_dtor_function (bool constructor_p, int priority)
{
char function_key;
tree arguments;
indicated by N. */
static int
-generate_ctor_and_dtor_functions_for_priority (n, data)
- splay_tree_node n;
- void *data ATTRIBUTE_UNUSED;
+generate_ctor_and_dtor_functions_for_priority (splay_tree_node n,
+ void * data ATTRIBUTE_UNUSED)
{
int priority = (int) n->key;
priority_info pi = (priority_info) n->value;
needed. */
if (pi->initializations_p
|| (priority == DEFAULT_INIT_PRIORITY && static_ctors))
- generate_ctor_or_dtor_function (/*constructor_p=*/1,
- priority);
+ generate_ctor_or_dtor_function (/*constructor_p=*/true, priority);
if (pi->destructions_p
|| (priority == DEFAULT_INIT_PRIORITY && static_dtors))
- generate_ctor_or_dtor_function (/*constructor_p=*/0,
- priority);
+ generate_ctor_or_dtor_function (/*constructor_p=*/false, priority);
/* Keep iterating. */
return 0;
finish_file ()
{
tree vars;
- int reconsider;
+ bool reconsider;
size_t i;
at_eof = 1;
{
tree t;
- reconsider = 0;
+ reconsider = false;
/* If there are templates that we've put off instantiating, do
them now. */
instantiation of members of that class. */
for (t = dynamic_classes; t; t = TREE_CHAIN (t))
if (maybe_emit_vtables (TREE_VALUE (t)))
- reconsider = 1;
+ reconsider = true;
/* Write out needed type info variables. Writing out one variable
might cause others to be needed. */
if (walk_globals (unemitted_tinfo_decl_p, emit_tinfo_decl, /*data=*/0))
- reconsider = 1;
+ reconsider = true;
/* The list of objects with static storage duration is built up
in reverse order. We clear STATIC_AGGREGATES so that any new
/* All those initializations and finalizations might cause
us to need more inline functions, more template
instantiations, etc. */
- reconsider = 1;
+ reconsider = true;
}
for (i = 0; i < deferred_fns_used; ++i)
push_to_top_level ();
synthesize_method (decl);
pop_from_top_level ();
- reconsider = 1;
+ reconsider = true;
}
/* We lie to the back-end, pretending that some functions
expand it again. */
if (flag_syntax_only)
TREE_ASM_WRITTEN (decl) = 1;
- reconsider = 1;
+ reconsider = true;
}
}
if (deferred_fns_used
&& wrapup_global_declarations (&VARRAY_TREE (deferred_fns, 0),
deferred_fns_used))
- reconsider = 1;
+ reconsider = true;
if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
- reconsider = 1;
+ reconsider = true;
/* Static data members are just like namespace-scope globals. */
for (i = 0; i < pending_statics_used; ++i)
if (pending_statics
&& wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
pending_statics_used))
- reconsider = 1;
+ reconsider = true;
}
while (reconsider);
In the above example, TYPE is `int' and DECL is `*a'. */
tree
-reparse_decl_as_expr (type, decl)
- tree type, decl;
+reparse_decl_as_expr (tree type, tree decl)
{
decl = build_expr_from_tree (decl);
if (type)
checking that make_{pointer,reference}_declarator do. */
tree
-finish_decl_parsing (decl)
- tree decl;
+finish_decl_parsing (tree decl)
{
switch (TREE_CODE (decl))
{
/* Return 1 if root encloses child. */
-static int
-is_namespace_ancestor (root, child)
- tree root, child;
+static bool
+is_namespace_ancestor (tree root, tree child)
{
if (root == child)
- return 1;
+ return true;
if (root == global_namespace)
- return 1;
+ return true;
if (child == global_namespace)
- return 0;
+ return false;
return is_namespace_ancestor (root, CP_DECL_CONTEXT (child));
}
of two given namespaces. */
tree
-namespace_ancestor (ns1, ns2)
- tree ns1, ns2;
+namespace_ancestor (tree ns1, tree ns2)
{
if (is_namespace_ancestor (ns1, ns2))
return ns1;
return namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2);
}
-/* Insert used into the using list of user. Set indirect_flag if this
+/* Insert USED into the using list of USER. Set INDIRECT_flag if this
directive is not directly from the source. Also find the common
ancestor and let our users know about the new namespace */
static void
-add_using_namespace (user, used, indirect)
- tree user;
- tree used;
- int indirect;
+add_using_namespace (tree user, tree used, bool indirect)
{
tree t;
/* Using oneself is a no-op. */
necessary. */
static tree
-merge_functions (s1, s2)
- tree s1;
- tree s2;
+merge_functions (tree s1, tree s2)
{
for (; s2; s2 = OVL_NEXT (s2))
{
XXX I don't want to repeat the entire duplicate_decls here */
static tree
-ambiguous_decl (name, old, new, flags)
- tree name;
- tree old;
- tree new;
- int flags;
+ambiguous_decl (tree name, tree old, tree new, int flags)
{
tree val, type;
my_friendly_assert (old != NULL_TREE, 393);
We are currently looking for names in namespace SCOPE, so we
look through USINGS for using-directives of namespaces
which have SCOPE as a common ancestor with the current scope.
- Returns zero on errors. */
+ Returns false on errors. */
-int
-lookup_using_namespace (name, val, usings, scope, flags, spacesp)
- tree name, val, usings, scope;
- int flags;
- tree *spacesp;
+bool
+lookup_using_namespace (tree name, tree val, tree usings, tree scope,
+ int flags, tree *spacesp)
{
tree iter;
tree val1;
/* [namespace.qual]
Accepts the NAME to lookup and its qualifying SCOPE.
Returns the name/type pair found into the CPLUS_BINDING RESULT,
- or 0 on error. */
+ or false on error. */
-int
-qualified_lookup_using_namespace (name, scope, result, flags)
- tree name;
- tree scope;
- tree result;
- int flags;
+bool
+qualified_lookup_using_namespace (tree name, tree scope, tree result,
+ int flags)
{
/* Maintain a list of namespaces visited... */
tree seen = NULL_TREE;
outside scope. */
void
-set_decl_namespace (decl, scope, friendp)
- tree decl;
- tree scope;
- int friendp;
+set_decl_namespace (tree decl, tree scope, bool friendp)
{
tree old;
/* Compute the namespace where a declaration is defined. */
static tree
-decl_namespace (decl)
- tree decl;
+decl_namespace (tree decl)
{
if (TYPE_P (decl))
decl = TYPE_STUB_DECL (decl);
/* Return the namespace where the current declaration is declared. */
tree
-current_decl_namespace ()
+current_decl_namespace (void)
{
tree result;
/* If we have been pushed into a different namespace, use it. */
/* Temporarily set the namespace for the current declaration. */
void
-push_decl_namespace (decl)
- tree decl;
+push_decl_namespace (tree decl)
{
if (TREE_CODE (decl) != NAMESPACE_DECL)
decl = decl_namespace (decl);
}
void
-pop_decl_namespace ()
+pop_decl_namespace (void)
{
decl_namespace_list = TREE_CHAIN (decl_namespace_list);
}
/* Enter a class or namespace scope. */
void
-push_scope (t)
- tree t;
+push_scope (tree t)
{
if (TREE_CODE (t) == NAMESPACE_DECL)
push_decl_namespace (t);
/* Leave scope pushed by push_scope. */
void
-pop_scope (t)
- tree t;
+pop_scope (tree t)
{
if (TREE_CODE (t) == NAMESPACE_DECL)
pop_decl_namespace ();
tree functions;
};
-static int arg_assoc PARAMS ((struct arg_lookup*, tree));
-static int arg_assoc_args PARAMS ((struct arg_lookup*, tree));
-static int arg_assoc_type PARAMS ((struct arg_lookup*, tree));
-static int add_function PARAMS ((struct arg_lookup *, tree));
-static int arg_assoc_namespace PARAMS ((struct arg_lookup *, tree));
-static int arg_assoc_class PARAMS ((struct arg_lookup *, tree));
-static int arg_assoc_template_arg PARAMS ((struct arg_lookup*, tree));
+static bool arg_assoc (struct arg_lookup*, tree);
+static bool arg_assoc_args (struct arg_lookup*, tree);
+static bool arg_assoc_type (struct arg_lookup*, tree);
+static bool add_function (struct arg_lookup *, tree);
+static bool arg_assoc_namespace (struct arg_lookup *, tree);
+static bool arg_assoc_class (struct arg_lookup *, tree);
+static bool arg_assoc_template_arg (struct arg_lookup*, tree);
/* Add a function to the lookup structure.
- Returns 1 on error. */
+ Returns true on error. */
-static int
-add_function (k, fn)
- struct arg_lookup *k;
- tree fn;
+static bool
+add_function (struct arg_lookup *k, tree fn)
{
/* We used to check here to see if the function was already in the list,
but that's O(n^2), which is just too expensive for function lookup.
cp_error_at ("`%D' is not a function,", f1);
cp_error_at (" conflict with `%D'", f2);
error (" in call to `%D'", k->name);
- return 1;
+ return true;
}
- return 0;
+ return false;
}
/* Add functions of a namespace to the lookup structure.
- Returns 1 on error. */
+ Returns true on error. */
-static int
-arg_assoc_namespace (k, scope)
- struct arg_lookup *k;
- tree scope;
+static bool
+arg_assoc_namespace (struct arg_lookup *k, tree scope)
{
tree value;
value = namespace_binding (k->name, scope);
if (!value)
- return 0;
+ return false;
for (; value; value = OVL_NEXT (value))
if (add_function (k, OVL_CURRENT (value)))
- return 1;
+ return true;
- return 0;
+ return false;
}
/* Adds everything associated with a template argument to the lookup
- structure. Returns 1 on error. */
+ structure. Returns true on error. */
-static int
-arg_assoc_template_arg (k, arg)
- struct arg_lookup* k;
- tree arg;
+static bool
+arg_assoc_template_arg (struct arg_lookup *k, tree arg)
{
/* [basic.lookup.koenig]
/* Consider first template template arguments. */
if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
|| TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
- return 0;
+ return false;
else if (TREE_CODE (arg) == TEMPLATE_DECL)
{
tree ctx = CP_DECL_CONTEXT (arg);
return arg_assoc_type (k, arg);
/* It's a non-type template argument. */
else
- return 0;
+ return false;
}
/* Adds everything associated with class to the lookup structure.
- Returns 1 on error. */
+ Returns true on error. */
-static int
-arg_assoc_class (k, type)
- struct arg_lookup* k;
- tree type;
+static bool
+arg_assoc_class (struct arg_lookup *k, tree type)
{
tree list, friends, context;
int i;
/* Backend build structures, such as __builtin_va_list, aren't
affected by all this. */
if (!CLASS_TYPE_P (type))
- return 0;
+ return false;
if (purpose_member (type, k->classes))
- return 0;
+ return false;
k->classes = tree_cons (type, NULL_TREE, k->classes);
context = decl_namespace (TYPE_MAIN_DECL (type));
if (arg_assoc_namespace (k, context))
- return 1;
+ return true;
/* Process baseclasses. */
for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); i++)
if (arg_assoc_class (k, TYPE_BINFO_BASETYPE (type, i)))
- return 1;
+ return true;
/* Process friends. */
for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
if (TREE_PURPOSE (friends) == error_mark_node && TREE_VALUE (friends)
&& decl_namespace (TREE_VALUE (friends)) == context)
if (add_function (k, TREE_VALUE (friends)))
- return 1;
+ return true;
/* Process template arguments. */
if (CLASSTYPE_TEMPLATE_INFO (type))
arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
}
- return 0;
+ return false;
}
/* Adds everything associated with a given type.
Returns 1 on error. */
-static int
-arg_assoc_type (k, type)
- struct arg_lookup *k;
- tree type;
+static bool
+arg_assoc_type (struct arg_lookup *k, tree type)
{
switch (TREE_CODE (type))
{
case VECTOR_TYPE:
case CHAR_TYPE:
case BOOLEAN_TYPE:
- return 0;
+ return false;
case RECORD_TYPE:
if (TYPE_PTRMEMFUNC_P (type))
return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
case OFFSET_TYPE:
/* Pointer to member: associate class type and value type. */
if (arg_assoc_type (k, TYPE_OFFSET_BASETYPE (type)))
- return 1;
+ return true;
return arg_assoc_type (k, TREE_TYPE (type));
case METHOD_TYPE:
/* The basetype is referenced in the first arg type, so just
case FUNCTION_TYPE:
/* Associate the parameter types. */
if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
- return 1;
+ return true;
/* Associate the return type. */
return arg_assoc_type (k, TREE_TYPE (type));
case TEMPLATE_TYPE_PARM:
case BOUND_TEMPLATE_TEMPLATE_PARM:
- return 0;
+ return false;
case TYPENAME_TYPE:
- return 0;
+ return false;
case LANG_TYPE:
if (type == unknown_type_node)
- return 0;
+ return false;
/* else fall through */
default:
abort ();
}
- return 0;
+ return false;
}
-/* Adds everything associated with arguments. Returns 1 on error. */
+/* Adds everything associated with arguments. Returns true on error. */
-static int
-arg_assoc_args (k, args)
- struct arg_lookup* k;
- tree args;
+static bool
+arg_assoc_args (struct arg_lookup *k, tree args)
{
for (; args; args = TREE_CHAIN (args))
if (arg_assoc (k, TREE_VALUE (args)))
- return 1;
- return 0;
+ return true;
+ return false;
}
/* Adds everything associated with a given tree_node. Returns 1 on error. */
-static int
-arg_assoc (k, n)
- struct arg_lookup* k;
- tree n;
+static bool
+arg_assoc (struct arg_lookup *k, tree n)
{
if (n == error_mark_node)
- return 0;
+ return false;
if (TYPE_P (n))
return arg_assoc_type (k, n);
if (TREE_CODE (ctx) == NAMESPACE_DECL)
{
if (arg_assoc_namespace (k, ctx) == 1)
- return 1;
+ return true;
}
/* It must be a member template. */
else if (arg_assoc_class (k, ctx) == 1)
- return 1;
+ return true;
/* Now the arguments. */
for (arg = args; arg != NULL_TREE; arg = TREE_CHAIN (arg))
if (arg_assoc_template_arg (k, TREE_VALUE (arg)) == 1)
- return 1;
+ return true;
}
else
{
for (; n; n = OVL_CHAIN (n))
if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
- return 1;
+ return true;
}
- return 0;
+ return false;
}
/* Performs Koenig lookup depending on arguments, where fns
are the functions found in normal lookup. */
tree
-lookup_arg_dependent (name, fns, args)
- tree name;
- tree fns;
- tree args;
+lookup_arg_dependent (tree name, tree fns, tree args)
{
struct arg_lookup k;
tree fn = NULL_TREE;
/* Process a namespace-alias declaration. */
void
-do_namespace_alias (alias, namespace)
- tree alias, namespace;
+do_namespace_alias (tree alias, tree namespace)
{
if (TREE_CODE (namespace) != NAMESPACE_DECL)
{
being used, and the USING_DECL, or NULL_TREE on failure. */
static tree
-validate_nonmember_using_decl (decl, scope, name)
- tree decl;
- tree *scope;
- tree *name;
+validate_nonmember_using_decl (tree decl, tree *scope, tree *name)
{
*scope = global_namespace;
*name = NULL_TREE;
/* Process local and global using-declarations. */
static void
-do_nonmember_using_decl (scope, name, oldval, oldtype, newval, newtype)
- tree scope, name;
- tree oldval, oldtype;
- tree *newval, *newtype;
+do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
+ tree *newval, tree *newtype)
{
tree decls;
/* Process a using-declaration not appearing in class or local scope. */
void
-do_toplevel_using_decl (decl)
- tree decl;
+do_toplevel_using_decl (tree decl)
{
tree scope, name, binding;
tree oldval, oldtype, newval, newtype;
/* Process a using-declaration at function scope. */
void
-do_local_using_decl (decl)
- tree decl;
+do_local_using_decl (tree decl)
{
tree scope, name;
tree oldval, oldtype, newval, newtype;
}
tree
-do_class_using_decl (decl)
- tree decl;
+do_class_using_decl (tree decl)
{
tree name, value;
/* Process a using-directive. */
void
-do_using_directive (namespace)
- tree namespace;
+do_using_directive (tree namespace)
{
if (building_stmt_tree ())
add_stmt (build_stmt (USING_STMT, namespace));
}
void
-check_default_args (x)
- tree x;
+check_default_args (tree x)
{
tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
- int saw_def = 0, i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
+ bool saw_def = false;
+ int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
{
if (TREE_PURPOSE (arg))
- saw_def = 1;
+ saw_def = true;
else if (saw_def)
{
cp_error_at ("default argument missing for parameter %P of `%+#D'",
}
void
-mark_used (decl)
- tree decl;
+mark_used (tree decl)
{
TREE_USED (decl) = 1;
if (processing_template_decl)
Return a TYPE_DECL for the type declared by ID in SCOPE. */
tree
-handle_class_head (tag_kind, scope, id, attributes, defn_p, new_type_p)
- enum tag_types tag_kind;
- tree scope, id, attributes;
- int defn_p;
- int *new_type_p;
+handle_class_head (enum tag_types tag_kind, tree scope, tree id,
+ tree attributes, bool defn_p, bool *new_type_p)
{
tree decl = NULL_TREE;
tree current = current_scope ();
if (current == NULL_TREE)
current = current_namespace;
- *new_type_p = 0;
+ *new_type_p = false;
if (scope)
{
}
else
{
- int new_type_p;
+ bool new_type_p;
tree class_type;
/* Given:
nested_name_specifier,
type,
attributes,
- /*defn_p=*/1,
+ /*defn_p=*/true,
&new_type_p));
if (type != error_mark_node)
{
#include "cp-tree.h"
void
-cxx_print_decl (file, node, indent)
- FILE *file;
- tree node;
- int indent;
+cxx_print_decl (FILE *file, tree node, int indent)
{
if (TREE_CODE (node) == FIELD_DECL)
{
}
void
-cxx_print_type (file, node, indent)
- FILE *file;
- register tree node;
- int indent;
+cxx_print_type (FILE *file, tree node, int indent)
{
switch (TREE_CODE (node))
{
}
void
-cxx_print_identifier (file, node, indent)
- FILE *file;
- tree node;
- int indent;
+cxx_print_identifier (FILE *file, tree node, int indent)
{
print_node (file, "bindings", IDENTIFIER_NAMESPACE_BINDINGS (node), indent + 4);
print_node (file, "class", IDENTIFIER_CLASS_VALUE (node), indent + 4);
}
void
-cxx_print_xnode (file, node, indent)
- FILE *file;
- tree node;
- int indent;
+cxx_print_xnode (FILE *file, tree node, int indent)
{
switch (TREE_CODE (node))
{
#include "ggc.h"
#include "diagnostic.h"
-static tree repo_get_id PARAMS ((tree));
-static char *extract_string PARAMS ((char **));
-static const char *get_base_filename PARAMS ((const char *));
-static void open_repo_file PARAMS ((const char *));
-static char *afgets PARAMS ((FILE *));
-static void reopen_repo_file_for_write PARAMS ((void));
+static tree repo_get_id (tree);
+static char *extract_string (char **);
+static const char *get_base_filename (const char *);
+static void open_repo_file (const char *);
+static char *afgets (FILE *);
+static void reopen_repo_file_for_write (void);
static GTY(()) tree pending_repo;
static GTY(()) tree original_repo;
/* Record the flags used to compile this translation unit. */
void
-repo_compile_flags (argc, argv)
- int argc;
- char **argv;
+repo_compile_flags (int argc, char **argv)
{
}
definition at link time. */
void
-repo_template_declared (t)
- tree t;
+repo_template_declared (tree t)
{}
/* Note where the definition of a template lives so that instantiations can
be generated later. */
void
-repo_template_defined (t)
- tree t;
+repo_template_defined (tree t)
{}
/* Note where the definition of a class lives to that template
instantiations can use it. */
void
-repo_class_defined (t)
- tree t;
+repo_class_defined (tree t)
{}
#endif
static tree
-repo_get_id (t)
- tree t;
+repo_get_id (tree t)
{
if (TYPE_P (t))
{
to emit it. */
void
-repo_template_used (t)
- tree t;
+repo_template_used (tree t)
{
tree id;
/* Note that the vtable for a class has been used, and offer to emit it. */
static void
-repo_vtable_used (t)
- tree t;
+repo_vtable_used (tree t)
{
if (! flag_use_repository)
return;
emit it. */
void
-repo_inline_used (fn)
- tree fn;
+repo_inline_used (tree fn)
{
if (! flag_use_repository)
return;
emit it. */
void
-repo_tinfo_used (ti)
- tree ti;
+repo_tinfo_used (tree ti)
{
}
#endif
void
-repo_template_instantiated (t, extern_p)
- tree t;
- int extern_p;
+repo_template_instantiated (tree t, bool extern_p)
{
if (! extern_p)
{
/* Parse a reasonable subset of shell quoting syntax. */
static char *
-extract_string (pp)
- char **pp;
+extract_string (char **pp)
{
char *p = *pp;
int backquote = 0;
}
const char *
-get_base_filename (filename)
- const char *filename;
+get_base_filename (const char *filename)
{
char *p = getenv ("COLLECT_GCC_OPTIONS");
char *output = NULL;
}
static void
-open_repo_file (filename)
- const char *filename;
+open_repo_file (const char *filename)
{
register const char *p;
const char *s = get_base_filename (filename);
}
static char *
-afgets (stream)
- FILE *stream;
+afgets (FILE *stream)
{
int c;
while ((c = getc (stream)) != EOF && c != '\n')
}
void
-init_repo (filename)
- const char *filename;
+init_repo (const char *filename)
{
char *buf;
}
static void
-reopen_repo_file_for_write ()
+reopen_repo_file_for_write (void)
{
if (repo_file)
fclose (repo_file);
/* Emit any pending repos. */
void
-finish_repo ()
+finish_repo (void)
{
tree t;
- int repo_changed = 0;
+ bool repo_changed = false;
char *dir, *args;
- if (! flag_use_repository)
+ if (!flag_use_repository)
return;
/* Do we have to write out a new info file? */
for (t = original_repo; t; t = TREE_CHAIN (t))
{
- if (! IDENTIFIER_REPO_USED (TREE_VALUE (t))
- || (! TREE_PURPOSE (t) && IDENTIFIER_REPO_CHOSEN (TREE_VALUE (t))))
+ if (!IDENTIFIER_REPO_USED (TREE_VALUE (t))
+ || (!TREE_PURPOSE (t) && IDENTIFIER_REPO_CHOSEN (TREE_VALUE (t))))
{
- repo_changed = 1;
+ repo_changed = true;
break;
}
IDENTIFIER_REPO_USED (TREE_VALUE (t)) = 0;
/* Are there any templates that are newly used? */
- if (! repo_changed)
+ if (!repo_changed)
for (t = pending_repo; t; t = TREE_CHAIN (t))
{
if (IDENTIFIER_REPO_USED (TREE_VALUE (t)))
{
- repo_changed = 1;
+ repo_changed = true;
break;
}
}
dir = getpwd ();
args = getenv ("COLLECT_GCC_OPTIONS");
- if (! repo_changed && pending_repo)
+ if (!repo_changed && pending_repo)
if (strcmp (old_main, main_input_filename) != 0
|| strcmp (old_dir, dir) != 0
|| (args == NULL) != (old_args == NULL)
|| (args && strcmp (old_args, args) != 0))
- repo_changed = 1;
+ repo_changed = true;
- if (! repo_changed || errorcount || sorrycount)
+ if (!repo_changed || errorcount || sorrycount)
goto out;
reopen_repo_file_for_write ();
static tree get_tinfo_ptr PARAMS((tree));
static bool typeid_ok_p PARAMS((void));
static int qualifier_flags PARAMS((tree));
-static int target_incomplete_p PARAMS((tree));
+static bool target_incomplete_p (tree);
static tree tinfo_base_init PARAMS((tree, tree));
static tree generic_initializer PARAMS((tree, tree));
-static tree ptr_initializer PARAMS((tree, tree, int *));
-static tree ptm_initializer PARAMS((tree, tree, int *));
+static tree ptr_initializer (tree, tree, bool *);
+static tree ptm_initializer (tree, tree, bool *);
static tree dfs_class_hint_mark PARAMS ((tree, void *));
static tree dfs_class_hint_unmark PARAMS ((tree, void *));
static int class_hint_flags PARAMS((tree));
static tree class_initializer PARAMS((tree, tree, tree));
static tree create_pseudo_type_info PARAMS((const char *, int, ...));
-static tree get_pseudo_ti_init PARAMS ((tree, tree, int *));
+static tree get_pseudo_ti_init PARAMS ((tree, tree, bool *));
static tree get_pseudo_ti_desc PARAMS((tree));
static void create_tinfo_types PARAMS((void));
-static int typeinfo_in_lib_p PARAMS((tree));
+static bool typeinfo_in_lib_p (tree);
static int doing_runtime = 0;
\f
the internal versions of the ABI types. */
void
-init_rtti_processing ()
+init_rtti_processing (void)
{
tree const_type_info_type;
expression. */
static tree
-build_headof (exp)
- tree exp;
+build_headof (tree exp)
{
tree type = TREE_TYPE (exp);
tree offset;
See libstdc++/exception.cc for __throw_bad_cast */
static tree
-throw_bad_cast ()
+throw_bad_cast (void)
{
tree fn = get_identifier ("__cxa_bad_cast");
if (IDENTIFIER_GLOBAL_VALUE (fn))
}
static tree
-throw_bad_typeid ()
+throw_bad_typeid (void)
{
tree fn = get_identifier ("__cxa_bad_typeid");
if (IDENTIFIER_GLOBAL_VALUE (fn))
otherwise return the static type of the expression. */
static tree
-get_tinfo_decl_dynamic (exp)
- tree exp;
+get_tinfo_decl_dynamic (tree exp)
{
tree type;
}
static bool
-typeid_ok_p ()
+typeid_ok_p (void)
{
if (! flag_rtti)
{
}
tree
-build_typeid (exp)
- tree exp;
+build_typeid (tree exp)
{
tree cond = NULL_TREE;
int nonnull = 0;
/* Generate the NTBS name of a type. */
static tree
-tinfo_name (type)
- tree type;
+tinfo_name (tree type)
{
const char *name;
tree name_string;
it --- decls in vtables are only used if the vtable is output. */
tree
-get_tinfo_decl (type)
- tree type;
+get_tinfo_decl (tree type)
{
tree name;
tree d;
cast to the language defined type. */
static tree
-get_tinfo_ptr (type)
- tree type;
+get_tinfo_ptr (tree type)
{
tree exp = get_tinfo_decl (type);
/* Return the type_info object for TYPE. */
tree
-get_typeid (type)
- tree type;
+get_typeid (tree type)
{
if (type == error_mark_node || !typeid_ok_p ())
return error_mark_node;
RESULT, it must have previously had a save_expr applied to it. */
static tree
-ifnonnull (test, result)
- tree test, result;
+ifnonnull (tree test, tree result)
{
return build (COND_EXPR, TREE_TYPE (result),
build (EQ_EXPR, boolean_type_node, test, integer_zero_node),
paper. */
static tree
-build_dynamic_cast_1 (type, expr)
- tree type, expr;
+build_dynamic_cast_1 (tree type, tree expr)
{
enum tree_code tc = TREE_CODE (type);
tree exprtype = TREE_TYPE (expr);
}
tree
-build_dynamic_cast (type, expr)
- tree type, expr;
+build_dynamic_cast (tree type, tree expr)
{
if (type == error_mark_node || expr == error_mark_node)
return error_mark_node;
/* Return the runtime bit mask encoding the qualifiers of TYPE. */
static int
-qualifier_flags (type)
- tree type;
+qualifier_flags (tree type)
{
int flags = 0;
int quals = cp_type_quals (type);
return flags;
}
-/* Return nonzero, if the pointer chain TYPE ends at an incomplete type, or
+/* Return true, if the pointer chain TYPE ends at an incomplete type, or
contains a pointer to member of an incomplete class. */
-static int
-target_incomplete_p (type)
- tree type;
+static bool
+target_incomplete_p (tree type)
{
while (TREE_CODE (type) == POINTER_TYPE)
if (TYPE_PTRMEM_P (type))
{
if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
- return 1;
+ return true;
type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
}
else
type = TREE_TYPE (type);
if (!COMPLETE_OR_VOID_TYPE_P (type))
- return 1;
+ return true;
- return 0;
+ return false;
}
/* Return a CONSTRUCTOR for the common part of the type_info objects. This
as comdat, because of pointers to incomplete.) */
static tree
-tinfo_base_init (desc, target)
- tree desc;
- tree target;
+tinfo_base_init (tree desc, tree target)
{
tree init = NULL_TREE;
tree name_decl;
additional fields to the type_info base. */
static tree
-generic_initializer (desc, target)
- tree desc;
- tree target;
+generic_initializer (tree desc, tree target)
{
tree init = tinfo_base_init (desc, target);
which adds target type and qualifier flags members to the type_info base. */
static tree
-ptr_initializer (desc, target, non_public_ptr)
- tree desc;
- tree target;
- int *non_public_ptr;
+ptr_initializer (tree desc, tree target, bool *non_public_ptr)
{
tree init = tinfo_base_init (desc, target);
tree to = TREE_TYPE (target);
int flags = qualifier_flags (to);
- int incomplete = target_incomplete_p (to);
+ bool incomplete = target_incomplete_p (to);
if (incomplete)
{
flags |= 8;
- *non_public_ptr = 1;
+ *non_public_ptr = true;
}
init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
init = tree_cons (NULL_TREE,
base. */
static tree
-ptm_initializer (desc, target, non_public_ptr)
- tree desc;
- tree target;
- int *non_public_ptr;
+ptm_initializer (tree desc, tree target, bool *non_public_ptr)
{
tree init = tinfo_base_init (desc, target);
tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
int flags = qualifier_flags (to);
- int incomplete = target_incomplete_p (to);
+ bool incomplete = target_incomplete_p (to);
if (incomplete)
{
flags |= 0x8;
- *non_public_ptr = 1;
+ *non_public_ptr = true;
}
if (!COMPLETE_TYPE_P (klass))
{
flags |= 0x10;
- *non_public_ptr = 1;
+ *non_public_ptr = true;
}
init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
init = tree_cons (NULL_TREE,
possible for a type to be both a virtual and non-virtual base. */
static tree
-dfs_class_hint_mark (binfo, data)
- tree binfo;
- void *data;
+dfs_class_hint_mark (tree binfo, void *data)
{
tree basetype = BINFO_TYPE (binfo);
int *hint = (int *) data;
/* Clear the base's dfs marks, after searching for duplicate bases. */
static tree
-dfs_class_hint_unmark (binfo, data)
- tree binfo;
- void *data ATTRIBUTE_UNUSED;
+dfs_class_hint_unmark (tree binfo, void *data ATTRIBUTE_UNUSED)
{
tree basetype = BINFO_TYPE (binfo);
/* Determine the hint flags describing the features of a class's hierarchy. */
static int
-class_hint_flags (type)
- tree type;
+class_hint_flags (tree type)
{
int hint_flags = 0;
int i;
which adds hint flags and TRAIL initializers to the type_info base. */
static tree
-class_initializer (desc, target, trail)
- tree desc;
- tree target;
- tree trail;
+class_initializer (tree desc, tree target, tree trail)
{
tree init = tinfo_base_init (desc, target);
return init;
}
-/* Returns nonzero if the typeinfo for type should be placed in
+/* Returns true if the typeinfo for type should be placed in
the runtime library. */
-static int
-typeinfo_in_lib_p (type)
- tree type;
+static bool
+typeinfo_in_lib_p (tree type)
{
/* The typeinfo objects for `T*' and `const T*' are in the runtime
library for simple types T. */
case CHAR_TYPE:
case REAL_TYPE:
case VOID_TYPE:
- return 1;
+ return true;
default:
- return 0;
+ return false;
}
}
types will be completed. */
static tree
-get_pseudo_ti_init (type, var_desc, non_public_p)
- tree type;
- tree var_desc;
- int *non_public_p;
+get_pseudo_ti_init (tree type, tree var_desc, bool *non_public_p)
{
my_friendly_assert (at_eof, 20021120);
switch (TREE_CODE (type))
{
if (!COMPLETE_TYPE_P (type))
/* Emit a non-public class_type_info. */
- *non_public_p = 1;
+ *non_public_p = true;
return class_initializer (var_desc, type, NULL_TREE);
}
else if (var_desc == si_class_desc_type_node)
NULL. */
static tree
-create_pseudo_type_info VPARAMS((const char *real_name, int ident, ...))
+create_pseudo_type_info (const char *real_name, int ident, ...)
{
tree pseudo_type;
char *pseudo_name;
translation unit. */
static tree
-get_pseudo_ti_desc (type)
- tree type;
+get_pseudo_ti_desc (tree type)
{
switch (TREE_CODE (type))
{
varable definitions. */
static void
-create_tinfo_types ()
+create_tinfo_types (void)
{
my_friendly_assert (!ti_desc_type_node, 20020609);
destructor is defined, then the runtime is being built. */
void
-emit_support_tinfos ()
+emit_support_tinfos (void)
{
static tree *const fundamentals[] =
{
}
}
-/* Return nonzero, iff T is a type_info variable which has not had a
+/* Return true, iff T is a type_info variable which has not had a
definition emitted for it. */
-int
-unemitted_tinfo_decl_p (t, data)
- tree t;
- void *data ATTRIBUTE_UNUSED;
+bool
+unemitted_tinfo_decl_p (tree t, void *data ATTRIBUTE_UNUSED)
{
if (/* It's a var decl */
TREE_CODE (t) == VAR_DECL
&& TYPE_FIELDS (TREE_TYPE (t))
/* which is our pseudo type info */
&& TREE_TYPE (TYPE_FIELDS (TREE_TYPE (t))) == ti_desc_type_node)
- return 1;
- return 0;
+ return true;
+ return false;
}
/* Finish a type info decl. DECL_PTR is a pointer to an unemitted
tinfo decl. Determine whether it needs emitting, and if so
generate the initializer. */
-int
-emit_tinfo_decl (decl_ptr, data)
- tree *decl_ptr;
- void *data ATTRIBUTE_UNUSED;
+bool
+emit_tinfo_decl (tree *decl_ptr, void *data ATTRIBUTE_UNUSED)
{
tree decl = *decl_ptr;
tree type = TREE_TYPE (DECL_NAME (decl));
- int non_public;
+ bool non_public;
int in_library = typeinfo_in_lib_p (type);
tree var_desc, var_init;
import_export_tinfo (decl, type, in_library);
if (DECL_REALLY_EXTERN (decl) || !DECL_NEEDED_P (decl))
- return 0;
+ return false;
if (!doing_runtime && in_library)
- return 0;
+ return false;
- non_public = 0;
+ non_public = false;
var_desc = get_pseudo_ti_desc (type);
var_init = get_pseudo_ti_init (type, var_desc, &non_public);
/* Say we've dealt with it. */
TREE_TYPE (DECL_NAME (decl)) = NULL_TREE;
- return 1;
+ return true;
}
projects / platform / upstream / gcc.git / commitdiff