`dims:' rule is being used. */
static int
-pop_current_osb (ctxp)
- struct parser_ctxt *ctxp;
+pop_current_osb (struct parser_ctxt *ctxp)
{
int to_return;
created context becomes the current one. */
static void
-create_new_parser_context (copy_from_previous)
- int copy_from_previous;
+create_new_parser_context (int copy_from_previous)
{
struct parser_ctxt *new;
/* Create a new parser context and make it the current one. */
void
-java_push_parser_context ()
+java_push_parser_context (void)
{
create_new_parser_context (0);
}
void
-java_pop_parser_context (generate)
- int generate;
+java_pop_parser_context (int generate)
{
tree current;
struct parser_ctxt *toFree, *next;
variables. */
void
-java_parser_context_save_global ()
+java_parser_context_save_global (void)
{
if (!ctxp)
{
previous context the current one. */
void
-java_parser_context_restore_global ()
+java_parser_context_restore_global (void)
{
lineno = ctxp->lineno;
current_class = ctxp->class_type;
classes be parsed. */
static void
-java_parser_context_suspend ()
+java_parser_context_suspend (void)
{
/* This makes debugging through java_debug_context easier */
static const char *const name = "<inner buffer context>";
can resume as if no context was ever saved. */
static void
-java_parser_context_resume ()
+java_parser_context_resume (void)
{
struct parser_ctxt *old = ctxp; /* This one is to be discarded */
struct parser_ctxt *saver = old->next; /* This one contain saved info */
linked. */
static void
-java_parser_context_push_initialized_field ()
+java_parser_context_push_initialized_field (void)
{
tree node;
or <clinit> functions. */
static void
-java_parser_context_pop_initialized_field ()
+java_parser_context_pop_initialized_field (void)
{
tree stmts;
tree class_type = TREE_TYPE (GET_CPC ());
}
static tree
-reorder_static_initialized (list)
- tree list;
+reorder_static_initialized (tree list)
{
/* We have to keep things in order. The alias initializer have to
come first, then the initialized regular field, in reverse to
{int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
static void
-java_debug_context_do (tab)
- int tab;
+java_debug_context_do (int tab)
{
struct parser_ctxt *copy = ctxp;
while (copy)
debugger. */
void
-java_debug_context ()
+java_debug_context (void)
{
java_debug_context_do (0);
}
/* Reporting an constructor invocation error. */
static void
-parse_ctor_invocation_error ()
+parse_ctor_invocation_error (void)
{
if (DECL_CONSTRUCTOR_P (current_function_decl))
yyerror ("Constructor invocation must be first thing in a constructor");
/* Reporting JDK1.1 features not implemented. */
static tree
-parse_jdk1_1_error (msg)
- const char *msg;
+parse_jdk1_1_error (const char *msg)
{
sorry (": `%s' JDK1.1(TM) feature", msg);
java_error_count++;
static int do_warning = 0;
void
-yyerror (msg)
- const char *msg;
+yyerror (const char *msg)
{
static java_lc elc;
static int prev_lineno;
}
static void
-issue_warning_error_from_context (cl, msg, ap)
- tree cl;
- const char *msg;
- va_list ap;
+issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
{
const char *saved, *saved_input_filename;
char buffer [4096];
}
static tree
-find_expr_with_wfl (node)
- tree node;
+find_expr_with_wfl (tree node)
{
while (node)
{
last line of the method the error occurs in. */
static void
-missing_return_error (method)
- tree method;
+missing_return_error (tree method)
{
EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
parse_error_context (wfl_operator, "Missing return statement");
/* Issue an unreachable statement error. From NODE, find the next
statement to report appropriately. */
static void
-unreachable_stmt_error (node)
- tree node;
+unreachable_stmt_error (tree node)
{
/* Browse node to find the next expression node that has a WFL. Use
the location to report the error */
}
int
-java_report_errors ()
+java_report_errors (void)
{
if (java_error_count)
fprintf (stderr, "%d error%s",
}
static char *
-java_accstring_lookup (flags)
- int flags;
+java_accstring_lookup (int flags)
{
static char buffer [80];
#define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
variables. */
static void
-classitf_redefinition_error (context, id, decl, cl)
- const char *context;
- tree id, decl, cl;
+classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
{
parse_error_context (cl, "%s `%s' already defined in %s:%d",
context, IDENTIFIER_POINTER (id),
}
static void
-variable_redefinition_error (context, name, type, line)
- tree context, name, type;
- int line;
+variable_redefinition_error (tree context, tree name, tree type, int line)
{
const char *type_name;
the node pointed to by TRIMMED unless TRIMMED is null. */
static int
-build_type_name_from_array_name (aname, trimmed)
- tree aname;
- tree *trimmed;
+build_type_name_from_array_name (tree aname, tree *trimmed)
{
const char *name = IDENTIFIER_POINTER (aname);
int len = IDENTIFIER_LENGTH (aname);
}
static tree
-build_array_from_name (type, type_wfl, name, ret_name)
- tree type, type_wfl, name, *ret_name;
+build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
{
int more_dims = 0;
identifier. */
static tree
-build_unresolved_array_type (type_or_wfl)
- tree type_or_wfl;
+build_unresolved_array_type (tree type_or_wfl)
{
const char *ptr;
tree wfl;
}
static void
-parser_add_interface (class_decl, interface_decl, wfl)
- tree class_decl, interface_decl, wfl;
+parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
{
if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
parse_error_context (wfl, "Interface `%s' repeated",
encountered. TAG is 0 for a class, 1 for an interface. */
static int
-check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
- int is_interface, flags;
- tree raw_name, qualified_name, decl, cl;
+check_class_interface_creation (int is_interface, int flags, tree raw_name,
+ tree qualified_name, tree decl, tree cl)
{
tree node;
int sca = 0; /* Static class allowed */
/* Construct a nested class name. If the final component starts with
a digit, return true. Otherwise return false. */
static int
-make_nested_class_name (cpc_list)
- tree cpc_list;
+make_nested_class_name (tree cpc_list)
{
tree name;
/* Can't redefine a class already defined in an earlier scope. */
static int
-check_inner_class_redefinition (raw_name, cl)
- tree raw_name, cl;
+check_inner_class_redefinition (tree raw_name, tree cl)
{
tree scope_list;
we remember ENCLOSING and SUPER. */
static tree
-resolve_inner_class (circularity_hash, cl, enclosing, super, class_type)
- htab_t circularity_hash;
- tree cl, *enclosing, *super, class_type;
+resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
+ tree *super, tree class_type)
{
tree local_enclosing = *enclosing;
tree local_super = NULL_TREE;
qualified. */
static tree
-find_as_inner_class (enclosing, name, cl)
- tree enclosing, name, cl;
+find_as_inner_class (tree enclosing, tree name, tree cl)
{
tree qual, to_return;
if (!enclosing)
through. */
static tree
-find_as_inner_class_do (qual, enclosing)
- tree qual, enclosing;
+find_as_inner_class_do (tree qual, tree enclosing)
{
if (!qual)
return NULL_TREE;
DECL. */
static void
-set_nested_class_simple_name_value (outer, set)
- tree outer;
- int set;
+set_nested_class_simple_name_value (tree outer, int set)
{
tree l;
}
static void
-link_nested_class_to_enclosing ()
+link_nested_class_to_enclosing (void)
{
if (GET_ENCLOSING_CPC ())
{
}
static tree
-maybe_make_nested_class_name (name)
- tree name;
+maybe_make_nested_class_name (tree name)
{
tree id = NULL_TREE;
line CL and do other maintenance things. */
static tree
-maybe_create_class_interface_decl (decl, raw_name, qualified_name, cl)
- tree decl, raw_name, qualified_name, cl;
+maybe_create_class_interface_decl (tree decl, tree raw_name,
+ tree qualified_name, tree cl)
{
if (!decl)
decl = push_class (make_class (), qualified_name);
}
static void
-add_superinterfaces (decl, interface_list)
- tree decl, interface_list;
+add_superinterfaces (tree decl, tree interface_list)
{
tree node;
/* Superinterface(s): if present and defined, parser_check_super_interface ()
interface's decl in pass 2. */
static tree
-create_interface (flags, id, super)
- int flags;
- tree id, super;
+create_interface (int flags, tree id, tree super)
{
tree raw_name = EXPR_WFL_NODE (id);
tree q_name = parser_qualified_classname (raw_name);
DEP. */
static void
-patch_anonymous_class (type_decl, class_decl, wfl)
- tree type_decl, class_decl, wfl;
+patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
{
tree class = TREE_TYPE (class_decl);
tree type = TREE_TYPE (type_decl);
}
static tree
-create_anonymous_class (location, type_name)
- int location;
- tree type_name;
+create_anonymous_class (int location, tree type_name)
{
char buffer [80];
tree super = NULL_TREE, itf = NULL_TREE;
interface's decl in pass 2. */
static tree
-create_class (flags, id, super, interfaces)
- int flags;
- tree id, super, interfaces;
+create_class (int flags, tree id, tree super, tree interfaces)
{
tree raw_name = EXPR_WFL_NODE (id);
tree class_id, decl;
parser context if necessary. */
static void
-end_class_declaration (resume)
- int resume;
+end_class_declaration (int resume)
{
/* If an error occurred, context weren't pushed and won't need to be
popped by a resume. */
}
static void
-add_inner_class_fields (class_decl, fct_decl)
- tree class_decl;
- tree fct_decl;
+add_inner_class_fields (tree class_decl, tree fct_decl)
{
tree block, marker, f;
can't set the CLASS_LOADED_P flag */
static tree
-find_field (class, name)
- tree class;
- tree name;
+find_field (tree class, tree name)
{
tree decl;
for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
of CLASS */
static tree
-lookup_field_wrapper (class, name)
- tree class, name;
+lookup_field_wrapper (tree class, tree name)
{
tree type = class;
tree decl = NULL_TREE;
otherwise. */
static int
-duplicate_declaration_error_p (new_field_name, new_type, cl)
- tree new_field_name, new_type, cl;
+duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
{
/* This might be modified to work with method decl as well */
tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
be later resolved in java_complete_class () */
static void
-register_fields (flags, type, variable_list)
- int flags;
- tree type, variable_list;
+register_fields (int flags, tree type, tree variable_list)
{
tree current, saved_type;
tree class_type = NULL_TREE;
local(s). */
static tree
-generate_finit (class_type)
- tree class_type;
+generate_finit (tree class_type)
{
int count = 0;
tree list = TYPE_FINIT_STMT_LIST (class_type);
statements in a try/catch/rethrow sequence. */
static tree
-generate_instinit (class_type)
- tree class_type;
+generate_instinit (tree class_type)
{
tree current;
tree compound = NULL_TREE;
/* FIXME */
static tree
-build_instinit_invocation (class_type)
- tree class_type;
+build_instinit_invocation (tree class_type)
{
tree to_return = NULL_TREE;
with a constructor. */
static tree
-method_header (flags, type, mdecl, throws)
- int flags;
- tree type, mdecl, throws;
+method_header (int flags, tree type, tree mdecl, tree throws)
{
tree type_wfl = NULL_TREE;
tree meth_name = NULL_TREE;
}
static void
-fix_method_argument_names (orig_arg, meth)
- tree orig_arg, meth;
+fix_method_argument_names (tree orig_arg, tree meth)
{
tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
/* Complete the method declaration with METHOD_BODY. */
static void
-finish_method_declaration (method_body)
- tree method_body;
+finish_method_declaration (tree method_body)
{
int flags;
/* Build a an error message for constructor circularity errors. */
static char *
-constructor_circularity_msg (from, to)
- tree from, to;
+constructor_circularity_msg (tree from, tree to)
{
static char string [4096];
char *t = xstrdup (lang_printable_name (from, 0));
static GTY(()) tree vcc_list;
static int
-verify_constructor_circularity (meth, current)
- tree meth, current;
+verify_constructor_circularity (tree meth, tree current)
{
tree c;
/* Check modifiers that can be declared but exclusively */
static void
-check_modifiers_consistency (flags)
- int flags;
+check_modifiers_consistency (int flags)
{
int acc_count = 0;
tree cl = NULL_TREE;
/* Check the methode header METH for abstract specifics features */
static void
-check_abstract_method_header (meth)
- tree meth;
+check_abstract_method_header (tree meth)
{
int flags = get_access_flags_from_decl (meth);
incomplete types. */
static tree
-method_declarator (id, list)
- tree id, list;
+method_declarator (tree id, tree list)
{
tree arg_types = NULL_TREE, current, node;
tree meth = make_node (FUNCTION_TYPE);
}
static int
-unresolved_type_p (wfl, returned)
- tree wfl;
- tree *returned;
+unresolved_type_p (tree wfl, tree *returned)
{
if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
qualification from the current package definition. */
static tree
-parser_qualified_classname (name)
- tree name;
+parser_qualified_classname (tree name)
{
tree nested_class_name;
everything is OK. */
static int
-parser_check_super_interface (super_decl, this_decl, this_wfl)
- tree super_decl, this_decl, this_wfl;
+parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
{
tree super_type = TREE_TYPE (super_decl);
0 if everthing is OK. */
static int
-parser_check_super (super_decl, this_decl, wfl)
- tree super_decl, this_decl, wfl;
+parser_check_super (tree super_decl, tree this_decl, tree wfl)
{
tree super_type = TREE_TYPE (super_decl);
CTXP list of type dependency list. */
static void
-create_jdep_list (ctxp)
- struct parser_ctxt *ctxp;
+create_jdep_list (struct parser_ctxt *ctxp)
{
jdeplist *new = xmalloc (sizeof (jdeplist));
new->first = new->last = NULL;
}
static jdeplist *
-reverse_jdep_list (ctxp)
- struct parser_ctxt *ctxp;
+reverse_jdep_list (struct parser_ctxt *ctxp)
{
register jdeplist *prev = NULL, *current, *next;
for (current = ctxp->classd_list; current; current = next)
registered again. */
static tree
-obtain_incomplete_type (type_name)
- tree type_name;
+obtain_incomplete_type (tree type_name)
{
tree ptr = NULL_TREE, name;
manner. */
static tree
-register_incomplete_type (kind, wfl, decl, ptr)
- int kind;
- tree wfl, decl, ptr;
+register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
{
jdep *new = xmalloc (sizeof (jdep));
otherwise. */
static tree
-check_inner_circular_reference (source, target)
- tree source;
- tree target;
+check_inner_circular_reference (tree source, tree target)
{
tree basetype_vec = TYPE_BINFO_BASETYPES (source);
tree ctx, cl;
otherwise. TYPE can be an interface or a class. */
static tree
-check_circular_reference (type)
- tree type;
+check_circular_reference (tree type)
{
tree basetype_vec = TYPE_BINFO_BASETYPES (type);
int i;
}
void
-java_check_circular_reference ()
+java_check_circular_reference (void)
{
tree current;
for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
finit$. */
static tree
-build_alias_initializer_parameter_list (mode, class_type, parm, artificial)
- int mode;
- tree class_type, parm;
- int *artificial;
+build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
+ int *artificial)
{
tree field;
tree additional_parms = NULL_TREE;
enforced. This is the case for anonymous classes. */
static tree
-craft_constructor (class_decl, args)
- tree class_decl, args;
+craft_constructor (tree class_decl, tree args)
{
tree class_type = TREE_TYPE (class_decl);
tree parm = NULL_TREE;
compilation triggered this one to be simply loaded. */
void
-java_fix_constructors ()
+java_fix_constructors (void)
{
tree current;
about the class processed currently. */
void
-safe_layout_class (class)
- tree class;
+safe_layout_class (tree class)
{
tree save_current_class = current_class;
const char *save_input_filename = input_filename;
}
static tree
-jdep_resolve_class (dep)
- jdep *dep;
+jdep_resolve_class (jdep *dep)
{
tree decl;
/* Complete unsatisfied class declaration and their dependencies */
void
-java_complete_class ()
+java_complete_class (void)
{
tree cclass;
jdeplist *cclassd;
array. */
static tree
-resolve_class (enclosing, class_type, decl, cl)
- tree enclosing, class_type, decl, cl;
+resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
{
tree tname = TYPE_NAME (class_type);
tree resolved_type = TREE_TYPE (class_type);
qualify_and_find. */
tree
-do_resolve_class (enclosing, class_type, decl, cl)
- tree enclosing, class_type, decl, cl;
+do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
{
tree new_class_decl = NULL_TREE, super = NULL_TREE;
tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
}
static tree
-qualify_and_find (class_type, package, name)
- tree class_type, package, name;
+qualify_and_find (tree class_type, tree package, tree name)
{
tree new_qualified = merge_qualified_name (package, name);
tree new_class_decl;
called when type resolution is necessary during the walk pass. */
static tree
-resolve_and_layout (something, cl)
- tree something;
- tree cl;
+resolve_and_layout (tree something, tree cl)
{
tree decl, decl_type;
layout. The current parsing context is saved and restored */
static tree
-resolve_no_layout (name, cl)
- tree name, cl;
+resolve_no_layout (tree name, tree cl)
{
tree ptr, decl;
BUILD_PTR_FROM_NAME (ptr, name);
use an identifier tree. */
static const char *
-purify_type_name (name)
- const char *name;
+purify_type_name (const char *name)
{
int len = strlen (name);
int bracket_found;
/* The type CURRENT refers to can't be found. We print error messages. */
static void
-complete_class_report_errors (dep)
- jdep *dep;
+complete_class_report_errors (jdep *dep)
{
const char *name;
<init> */
static const char *
-get_printable_method_name (decl)
- tree decl;
+get_printable_method_name (tree decl)
{
const char *to_return;
tree name = NULL_TREE;
function it's a FWL, so we can track errors more accurately.) */
static int
-check_method_redefinition (class, method)
- tree class, method;
+check_method_redefinition (tree class, tree method)
{
tree redef, sig;
/* Return 1 if check went ok, 0 otherwise. */
static int
-check_abstract_method_definitions (do_interface, class_decl, type)
- int do_interface;
- tree class_decl, type;
+check_abstract_method_definitions (int do_interface, tree class_decl,
+ tree type)
{
tree class = TREE_TYPE (class_decl);
tree method, end_type;
methods. */
static void
-java_check_abstract_method_definitions (class_decl)
- tree class_decl;
+java_check_abstract_method_definitions (tree class_decl)
{
tree class = TREE_TYPE (class_decl);
tree super, vector;
safe to build a method signature or not. */
static int
-check_method_types_complete (decl)
- tree decl;
+check_method_types_complete (tree decl)
{
tree type = TREE_TYPE (decl);
tree args;
/* Visible interface to check methods contained in CLASS_DECL */
void
-java_check_methods (class_decl)
- tree class_decl;
+java_check_methods (tree class_decl)
{
if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
return;
declaration. */
static void
-java_check_regular_methods (class_decl)
- tree class_decl;
+java_check_regular_methods (tree class_decl)
{
int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
tree method;
is incompatible with the `throws' clause of FOUND (if any). */
static void
-check_throws_clauses (method, method_wfl, found)
- tree method, method_wfl, found;
+check_throws_clauses (tree method, tree method_wfl, tree found)
{
tree mthrows, fthrows;
/* Check abstract method of interface INTERFACE */
static void
-java_check_abstract_methods (interface_decl)
- tree interface_decl;
+java_check_abstract_methods (tree interface_decl)
{
int i, n;
tree method, basetype_vec, found;
signature. Return a matching method only if their types differ. */
static tree
-lookup_java_interface_method2 (class, method_decl)
- tree class, method_decl;
+lookup_java_interface_method2 (tree class, tree method_decl)
{
int i, n;
tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
matching method only if their types differ. */
static tree
-lookup_java_method2 (clas, method_decl, do_interface)
- tree clas, method_decl;
- int do_interface;
+lookup_java_method2 (tree clas, tree method_decl, int do_interface)
{
tree method, method_signature, method_name, method_type, name;
static GTY(()) tree cl_v;
static tree
-lookup_cl (decl)
- tree decl;
+lookup_cl (tree decl)
{
char *line, *found;
/* Look for a simple name in the single-type import list */
static tree
-find_name_in_single_imports (name)
- tree name;
+find_name_in_single_imports (tree name)
{
tree node;
/* Process all single-type import. */
static int
-process_imports ()
+process_imports (void)
{
tree import;
int error_found;
statement. */
static void
-find_in_imports (enclosing_type, class_type)
- tree enclosing_type;
- tree class_type;
+find_in_imports (tree enclosing_type, tree class_type)
{
tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
ctxp->import_list);
}
static int
-note_possible_classname (name, len)
- const char *name;
- int len;
+note_possible_classname (const char *name, int len)
{
tree node;
if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
directory. */
static void
-read_import_dir (wfl)
- tree wfl;
+read_import_dir (tree wfl)
{
tree package_id = EXPR_WFL_NODE (wfl);
const char *package_name = IDENTIFIER_POINTER (package_id);
entire list, to detected potential double definitions. */
static int
-find_in_imports_on_demand (enclosing_type, class_type)
- tree enclosing_type;
- tree class_type;
+find_in_imports_on_demand (tree enclosing_type, tree class_type)
{
tree class_type_name = TYPE_NAME (class_type);
tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
particular package is added only once. */
static void
-register_package (name)
- tree name;
+register_package (tree name)
{
static htab_t pht;
void **e;
}
static tree
-resolve_package (pkg, next, type_name)
- tree pkg, *next, *type_name;
+resolve_package (tree pkg, tree *next, tree *type_name)
{
tree current;
tree decl = NULL_TREE;
access is being attempted. */
static void
-check_inner_class_access (decl, enclosing_decl, cl)
- tree decl, enclosing_decl, cl;
+check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
{
const char *access;
tree enclosing_decl_type;
/* Local variable declaration. */
static void
-declare_local_variables (modifier, type, vlist)
- int modifier;
- tree type;
- tree vlist;
+declare_local_variables (int modifier, tree type, tree vlist)
{
tree decl, current, saved_type;
tree type_wfl = NULL_TREE;
/* Called during parsing. Build decls from argument list. */
static void
-source_start_java_method (fndecl)
- tree fndecl;
+source_start_java_method (tree fndecl)
{
tree tem;
tree parm_decl;
/* Called during parsing. Creates an artificial method declaration. */
static tree
-create_artificial_method (class, flags, type, name, args)
- tree class;
- int flags;
- tree type, name, args;
+create_artificial_method (tree class, int flags, tree type,
+ tree name, tree args)
{
tree mdecl;
/* Starts the body if an artificial method. */
static void
-start_artificial_method_body (mdecl)
- tree mdecl;
+start_artificial_method_body (tree mdecl)
{
DECL_SOURCE_LINE (mdecl) = 1;
DECL_SOURCE_LINE_MERGE (mdecl, 1);
}
static void
-end_artificial_method_body (mdecl)
- tree mdecl;
+end_artificial_method_body (tree mdecl)
{
/* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
It has to be evaluated first. (if mdecl is current_function_decl,
/* Dump a tree of some kind. This is a convenience wrapper for the
dump_* functions in tree-dump.c. */
static void
-dump_java_tree (phase, t)
- enum tree_dump_index phase;
- tree t;
+dump_java_tree (enum tree_dump_index phase, tree t)
{
FILE *stream;
int flags;
/* Terminate a function and expand its body. */
static void
-source_end_java_method ()
+source_end_java_method (void)
{
tree fndecl = current_function_decl;
expression second operand if necessary. */
tree
-java_method_add_stmt (fndecl, expr)
- tree fndecl, expr;
+java_method_add_stmt (tree fndecl, tree expr)
{
if (!GET_CURRENT_BLOCK (fndecl))
return NULL_TREE;
}
static tree
-add_stmt_to_block (b, type, stmt)
- tree b, type, stmt;
+add_stmt_to_block (tree b, tree type, tree stmt)
{
tree body = BLOCK_EXPR_BODY (b), c;
COMPOUND_EXPR and add STMT to it. */
static tree
-add_stmt_to_compound (existing, type, stmt)
- tree existing, type, stmt;
+add_stmt_to_compound (tree existing, tree type, tree stmt)
{
/* Keep track of this for inlining. */
if (current_function_decl)
return stmt;
}
-void java_layout_seen_class_methods ()
+void java_layout_seen_class_methods (void)
{
tree previous_list = all_class_list;
tree end = NULL_TREE;
static GTY(()) tree stop_reordering;
void
-java_reorder_fields ()
+java_reorder_fields (void)
{
tree current;
classes */
void
-java_layout_classes ()
+java_layout_classes (void)
{
tree current;
int save_error_count = java_error_count;
generation. */
static void
-java_complete_expand_classes ()
+java_complete_expand_classes (void)
{
tree current;
classes, if any. */
static void
-java_complete_expand_class (outer)
- tree outer;
+java_complete_expand_class (tree outer)
{
tree inner_list;
constructors and then <clinit>. */
static void
-java_complete_expand_methods (class_decl)
- tree class_decl;
+java_complete_expand_methods (tree class_decl)
{
tree clinit, decl, first_decl;
safely used in some other methods/constructors. */
static tree
-maybe_generate_pre_expand_clinit (class_type)
- tree class_type;
+maybe_generate_pre_expand_clinit (tree class_type)
{
tree current, mdecl;
MODIFY_EXPR with a constant value. */
static int
-analyze_clinit_body (this_class, bbody)
- tree this_class, bbody;
+analyze_clinit_body (tree this_class, tree bbody)
{
while (bbody)
switch (TREE_CODE (bbody))
is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
static int
-maybe_yank_clinit (mdecl)
- tree mdecl;
+maybe_yank_clinit (tree mdecl)
{
tree type, current;
tree fbody, bbody;
expansion of mdecl's body. */
static void
-start_complete_expand_method (mdecl)
- tree mdecl;
+start_complete_expand_method (tree mdecl)
{
tree tem;
/* Complete and expand a method. */
static void
-java_complete_expand_method (mdecl)
- tree mdecl;
+java_complete_expand_method (tree mdecl)
{
tree fbody, block_body, exception_copy;
/* For with each class for which there's code to generate. */
static void
-java_expand_method_bodies (class)
- tree class;
+java_expand_method_bodies (tree class)
{
tree decl;
for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
be later turned into a write by calling outer_field_access_fix. */
static tree
-build_outer_field_access (id, decl)
- tree id, decl;
+build_outer_field_access (tree id, tree decl)
{
tree access = NULL_TREE;
tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
access. */
static int
-outer_field_access_p (type, decl)
- tree type, decl;
+outer_field_access_p (tree type, tree decl)
{
if (!INNER_CLASS_TYPE_P (type)
|| TREE_CODE (decl) != FIELD_DECL
call if necessary. */
static int
-outer_field_expanded_access_p (node, name, arg_type, arg)
- tree node, *name, *arg_type, *arg;
+outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
+ tree *arg)
{
int identified = 0;
be identified. */
static tree
-outer_field_access_fix (wfl, node, rhs)
- tree wfl, node, rhs;
+outer_field_access_fix (tree wfl, tree node, tree rhs)
{
tree name, arg_type, arg;
read access. */
static tree
-build_outer_field_access_expr (lc, type, access_method_name, arg1, arg2)
- int lc;
- tree type, access_method_name, arg1, arg2;
+build_outer_field_access_expr (int lc, tree type, tree access_method_name,
+ tree arg1, tree arg2)
{
tree args, cn, access;
}
static tree
-build_new_access_id ()
+build_new_access_id (void)
{
static int access_n_counter = 1;
char buffer [128];
*/
static tree
-build_outer_field_access_methods (decl)
- tree decl;
+build_outer_field_access_methods (tree decl)
{
tree id, args, stmt, mdecl;
/* Build an field access method NAME. */
static tree
-build_outer_field_access_method (class, type, name, args, body)
- tree class, type, name, args, body;
+build_outer_field_access_method (tree class, tree type, tree name,
+ tree args, tree body)
{
tree saved_current_function_decl, mdecl;
certain kinds of method invocation from inner classes. */
static tree
-build_outer_method_access_method (decl)
- tree decl;
+build_outer_method_access_method (tree decl)
{
tree saved_current_function_decl, mdecl;
tree args = NULL_TREE, call_args = NULL_TREE;
for example build_outer_field_access). */
static tree
-build_access_to_thisn (from, to, lc)
- tree from, to;
- int lc;
+build_access_to_thisn (tree from, tree to, int lc)
{
tree access = NULL_TREE;
attribute so that they can't be referred to directly. */
static tree
-maybe_build_thisn_access_method (type)
- tree type;
+maybe_build_thisn_access_method (tree type)
{
tree mdecl, args, stmt, rtype;
tree saved_current_function_decl;
static GTY(()) tree saved_type;
static tree
-build_current_thisn (type)
- tree type;
+build_current_thisn (tree type)
{
static int saved_i = -1;
static int saved_type_i = 0;
form used is `this.this$<n> = this$<n>;'. */
static tree
-build_thisn_assign ()
+build_thisn_assign (void)
{
if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
{
static GTY(()) tree type_parm_wfl;
static tree
-build_dot_class_method (class)
- tree class;
+build_dot_class_method (tree class)
{
#define BWF(S) build_wfl_node (get_identifier ((S)))
#define MQN(X,Y) make_qualified_name ((X), (Y), 0)
}
static tree
-build_dot_class_method_invocation (type)
- tree type;
+build_dot_class_method_invocation (tree type)
{
tree sig_id, s;
necessary. */
static void
-fix_constructors (mdecl)
- tree mdecl;
+fix_constructors (tree mdecl)
{
tree iii; /* Instance Initializer Invocation */
tree body = DECL_FUNCTION_BODY (mdecl);
for something that has the same signature. */
static int
-verify_constructor_super (mdecl)
- tree mdecl;
+verify_constructor_super (tree mdecl)
{
tree class = CLASSTYPE_SUPER (current_class);
int super_inner = PURE_INNER_CLASS_TYPE_P (class);
static GTY(()) tree reversed_class_list;
void
-java_expand_classes ()
+java_expand_classes (void)
{
int save_error_count = 0;
static struct parser_ctxt *cur_ctxp = NULL;
separating `.' operator. */
static tree
-make_qualified_primary (primary, right, location)
- tree primary, right;
- int location;
+make_qualified_primary (tree primary, tree right, int location)
{
tree wfl;
/* Simple merge of two name separated by a `.' */
static tree
-merge_qualified_name (left, right)
- tree left, right;
+merge_qualified_name (tree left, tree right)
{
tree node;
if (!left && !right)
inherited from the location information of the `.' operator. */
static tree
-make_qualified_name (left, right, location)
- tree left, right;
- int location;
+make_qualified_name (tree left, tree right, int location)
{
#ifdef USE_COMPONENT_REF
tree node = build (COMPONENT_REF, NULL_TREE, left, right);
last identifier is removed from the linked list */
static tree
-cut_identifier_in_qualified (wfl)
- tree wfl;
+cut_identifier_in_qualified (tree wfl)
{
tree q;
tree previous = NULL_TREE;
/* Resolve the expression name NAME. Return its decl. */
static tree
-resolve_expression_name (id, orig)
- tree id;
- tree *orig;
+resolve_expression_name (tree id, tree *orig)
{
tree name = EXPR_WFL_NODE (id);
tree decl;
}
static void
-static_ref_err (wfl, field_id, class_type)
- tree wfl, field_id, class_type;
+static_ref_err (tree wfl, tree field_id, tree class_type)
{
parse_error_context
(wfl,
recipient's address can be null. */
static tree
-resolve_field_access (qual_wfl, field_decl, field_type)
- tree qual_wfl;
- tree *field_decl, *field_type;
+resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
{
int is_static = 0;
tree field_ref;
NODE. */
static tree
-strip_out_static_field_access_decl (node)
- tree node;
+strip_out_static_field_access_decl (tree node)
{
if (TREE_CODE (node) == COMPOUND_EXPR)
{
/* 6.5.5.2: Qualified Expression Names */
static int
-resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
- tree wfl;
- tree *found_decl, *type_found, *where_found;
+resolve_qualified_expression_name (tree wfl, tree *found_decl,
+ tree *where_found, tree *type_found)
{
int from_type = 0; /* Field search initiated from a type */
int from_super = 0, from_cast = 0, from_qualified_this = 0;
method. */
static int
-not_accessible_p (reference, member, where, from_super)
- tree reference, member;
- tree where;
- int from_super;
+not_accessible_p (tree reference, tree member, tree where, int from_super)
{
int access_flag = get_access_flags_from_decl (member);
/* Test deprecated decl access. */
static void
-check_deprecation (wfl, decl)
- tree wfl, decl;
+check_deprecation (tree wfl, tree decl)
{
const char *file = DECL_SOURCE_FILE (decl);
/* Complain if the field is deprecated and the file it was defined
static GTY(()) tree cicp_cache;
static int
-class_in_current_package (class)
- tree class;
+class_in_current_package (tree class)
{
int qualified_flag;
tree left;
done only if certain conditions meet. */
static tree
-maybe_access_field (decl, where, type)
- tree decl, where, type;
+maybe_access_field (tree decl, tree where, tree type)
{
if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
&& !FIELD_STATIC (decl))
used. IS_STATIC is set to 1 if the invoked function is static. */
static tree
-patch_method_invocation (patch, primary, where, from_super,
- is_static, ret_decl)
- tree patch, primary, where;
- int from_super;
- int *is_static;
- tree *ret_decl;
+patch_method_invocation (tree patch, tree primary, tree where, int from_super,
+ int *is_static, tree *ret_decl)
{
tree wfl = TREE_OPERAND (patch, 0);
tree args = TREE_OPERAND (patch, 1);
non static method. Return 1 if it's the case, 0 otherwise. */
static int
-check_for_static_method_reference (wfl, node, method, where, primary)
- tree wfl, node, method, where, primary;
+check_for_static_method_reference (tree wfl, tree node, tree method,
+ tree where, tree primary)
{
if (METHOD_STATIC (current_function_decl)
&& !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
returned. */
static int
-maybe_use_access_method (is_super_init, mdecl, this_arg)
- int is_super_init;
- tree *mdecl, *this_arg;
+maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
{
tree ctx;
tree md = *mdecl, ta = *this_arg;
mode. */
static tree
-patch_invoke (patch, method, args)
- tree patch, method, args;
+patch_invoke (tree patch, tree method, tree args)
{
tree dtable, func;
tree original_call, t, ta;
}
static int
-invocation_mode (method, super)
- tree method;
- int super;
+invocation_mode (tree method, int super)
{
int access = get_access_flags_from_decl (method);
15.11.2 (Compile-Time Step 2) */
static tree
-lookup_method_invoke (lc, cl, class, name, arg_list)
- int lc;
- tree cl;
- tree class, name, arg_list;
+lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
{
tree atl = end_params_node; /* Arg Type List */
tree method, signature, list, node;
when we're looking for a constructor. */
static tree
-find_applicable_accessible_methods_list (lc, class, name, arglist)
- int lc;
- tree class, name, arglist;
+find_applicable_accessible_methods_list (int lc, tree class, tree name,
+ tree arglist)
{
static htab_t searched_classes;
static int search_not_done = 0;
/* Effectively search for the appropriate method in method */
static void
-search_applicable_methods_list (lc, method, name, arglist, list, all_list)
- int lc;
- tree method, name, arglist;
- tree *list, *all_list;
+search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
+ tree *list, tree *all_list)
{
for (; method; method = TREE_CHAIN (method))
{
/* 15.11.2.2 Choose the Most Specific Method */
static tree
-find_most_specific_methods_list (list)
- tree list;
+find_most_specific_methods_list (tree list)
{
int max = 0;
int abstract, candidates;
static GTY(()) tree m2_arg_cache;
static int
-argument_types_convertible (m1, m2_or_arglist)
- tree m1, m2_or_arglist;
+argument_types_convertible (tree m1, tree m2_or_arglist)
{
register tree m1_arg, m2_arg;
/* Qualification routines */
static void
-qualify_ambiguous_name (id)
- tree id;
+qualify_ambiguous_name (tree id)
{
tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
saved_current_class;
}
static int
-breakdown_qualified (left, right, source)
- tree *left, *right, source;
+breakdown_qualified (tree *left, tree *right, tree source)
{
char *p, *base;
int l = IDENTIFIER_LENGTH (source);
/* Return TRUE if two classes are from the same package. */
static int
-in_same_package (name1, name2)
- tree name1, name2;
+in_same_package (tree name1, tree name2)
{
tree tmp;
tree pkg1;
Same as java_complete_lhs, but does resolve static finals to values. */
static tree
-java_complete_tree (node)
- tree node;
+java_complete_tree (tree node)
{
node = java_complete_lhs (node);
if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
}
static tree
-java_stabilize_reference (node)
- tree node;
+java_stabilize_reference (tree node)
{
if (TREE_CODE (node) == COMPOUND_EXPR)
{
Same as java_complete_tree, but does not resolve static finals to values. */
static tree
-java_complete_lhs (node)
- tree node;
+java_complete_lhs (tree node)
{
tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
int flag;
error was found. */
static int
-complete_function_arguments (node)
- tree node;
+complete_function_arguments (tree node)
{
int flag = 0;
tree cn;
debugable. */
static tree
-build_debugable_stmt (location, stmt)
- int location;
- tree stmt;
+build_debugable_stmt (int location, tree stmt)
{
if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
{
}
static tree
-build_expr_block (body, decls)
- tree body, decls;
+build_expr_block (tree body, tree decls)
+
{
tree node = make_node (BLOCK);
BLOCK_EXPR_DECLS (node) = decls;
function block chain */
static tree
-enter_block ()
+enter_block (void)
{
tree b = build_expr_block (NULL_TREE, NULL_TREE);
the block being exited isn't the method's top level one. */
static tree
-exit_block ()
+exit_block (void)
{
tree b;
if (current_function_decl)
scoping rules. */
static tree
-lookup_name_in_blocks (name)
- tree name;
+lookup_name_in_blocks (tree name)
{
tree b = GET_CURRENT_BLOCK (current_function_decl);
}
static void
-maybe_absorb_scoping_blocks ()
+maybe_absorb_scoping_blocks (void)
{
while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
{
/* Wrap a non WFL node around a WFL. */
static tree
-build_wfl_wrap (node, location)
- tree node;
- int location;
+build_wfl_wrap (tree node, int location)
{
tree wfl, node_to_insert = node;
we're currently dealing with the class java.lang.Object. */
static tree
-build_super_invocation (mdecl)
- tree mdecl;
+build_super_invocation (tree mdecl)
{
if (DECL_CONTEXT (mdecl) == object_type_node)
return empty_stmt_node;
/* Build a SUPER/THIS qualified method invocation. */
static tree
-build_this_super_qualified_invocation (use_this, name, args, lloc, rloc)
- int use_this;
- tree name, args;
- int lloc, rloc;
+build_this_super_qualified_invocation (int use_this, tree name, tree args,
+ int lloc, int rloc)
{
tree invok;
tree wfl =
/* Build an incomplete CALL_EXPR node. */
static tree
-build_method_invocation (name, args)
- tree name;
- tree args;
+build_method_invocation (tree name, tree args)
{
tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
TREE_SIDE_EFFECTS (call) = 1;
/* Build an incomplete new xxx(...) node. */
static tree
-build_new_invocation (name, args)
- tree name, args;
+build_new_invocation (tree name, tree args)
{
tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
TREE_SIDE_EFFECTS (call) = 1;
/* Build an incomplete assignment expression. */
static tree
-build_assignment (op, op_location, lhs, rhs)
- int op, op_location;
- tree lhs, rhs;
+build_assignment (int op, int op_location, tree lhs, tree rhs)
{
tree assignment;
/* Build the corresponding binop if we deal with a Compound
/* Print an INTEGER_CST node as decimal in a static buffer, and return
the buffer. This is used only for string conversion. */
static char *
-string_convert_int_cst (node)
- tree node;
+string_convert_int_cst (tree node)
{
static char buffer[80];
/* Print an INTEGER_CST node in a static buffer, and return the
buffer. This is used only for error handling. */
char *
-print_int_node (node)
- tree node;
+print_int_node (tree node)
{
static char buffer [80];
if (TREE_CONSTANT_OVERFLOW (node))
/* 15.25 Assignment operators. */
static tree
-patch_assignment (node, wfl_op1)
- tree node;
- tree wfl_op1;
+patch_assignment (tree node, tree wfl_op1)
{
tree rhs = TREE_OPERAND (node, 1);
tree lvalue = TREE_OPERAND (node, 0), llvalue;
modified rhs. */
static tree
-try_reference_assignconv (lhs_type, rhs)
- tree lhs_type, rhs;
+try_reference_assignconv (tree lhs_type, tree rhs)
{
tree new_rhs = NULL_TREE;
tree rhs_type = TREE_TYPE (rhs);
builtin type. Return a converted RHS if the conversion is possible. */
static tree
-try_builtin_assignconv (wfl_op1, lhs_type, rhs)
- tree wfl_op1, lhs_type, rhs;
+try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
{
tree new_rhs = NULL_TREE;
tree rhs_type = TREE_TYPE (rhs);
invocation convertion (5.3). */
static int
-valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)
- tree lhs_type, rhs_type;
+valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
{
/* 5.1.1: This is the identity conversion part. */
if (lhs_type == rhs_type)
assignment check. */
static int
-valid_ref_assignconv_cast_p (source, dest, cast)
- tree source;
- tree dest;
- int cast;
+valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
{
/* SOURCE or DEST might be null if not from a declared entity. */
if (!source || !dest)
}
static int
-valid_cast_to_p (source, dest)
- tree source;
- tree dest;
+valid_cast_to_p (tree source, tree dest)
{
if (TREE_CODE (source) == POINTER_TYPE)
source = TREE_TYPE (source);
}
static tree
-do_unary_numeric_promotion (arg)
- tree arg;
+do_unary_numeric_promotion (tree arg)
{
tree type = TREE_TYPE (arg);
if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
/* Return a nonzero value if SOURCE can be converted into DEST using
the method invocation conversion rule (5.3). */
static int
-valid_method_invocation_conversion_p (dest, source)
- tree dest, source;
+valid_method_invocation_conversion_p (tree dest, tree source)
{
return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
&& valid_builtin_assignconv_identity_widening_p (dest, source))
/* Build an incomplete binop expression. */
static tree
-build_binop (op, op_location, op1, op2)
- enum tree_code op;
- int op_location;
- tree op1, op2;
+build_binop (enum tree_code op, int op_location, tree op1, tree op2)
{
tree binop = build (op, NULL_TREE, op1, op2);
TREE_SIDE_EFFECTS (binop) = 1;
buffer. */
static char *
-operator_string (node)
- tree node;
+operator_string (tree node)
{
#define BUILD_OPERATOR_STRING(S) \
{ \
/* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
static int
-java_decl_equiv (var_acc1, var_acc2)
- tree var_acc1, var_acc2;
+java_decl_equiv (tree var_acc1, tree var_acc2)
{
if (JDECL_P (var_acc1))
return (var_acc1 == var_acc2);
used in conjunction with the `=' operator in a compound assignment. */
static int
-binop_compound_p (code)
- enum tree_code code;
+binop_compound_p (enum tree_code code)
{
int i;
for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
/* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
static tree
-java_refold (t)
- tree t;
+java_refold (tree t)
{
tree c, b, ns, decl;
of remaining nodes and detects more errors in certain cases. */
static tree
-patch_binop (node, wfl_op1, wfl_op2)
- tree node;
- tree wfl_op1;
- tree wfl_op2;
+patch_binop (tree node, tree wfl_op1, tree wfl_op2)
{
tree op1 = TREE_OPERAND (node, 0);
tree op2 = TREE_OPERAND (node, 1);
zero value, the value of CSTE comes after the valude of STRING */
static tree
-do_merge_string_cste (cste, string, string_len, after)
- tree cste;
- const char *string;
- int string_len, after;
+do_merge_string_cste (tree cste, const char *string, int string_len, int after)
{
const char *old = TREE_STRING_POINTER (cste);
int old_len = TREE_STRING_LENGTH (cste);
new STRING_CST on success, NULL_TREE on failure */
static tree
-merge_string_cste (op1, op2, after)
- tree op1, op2;
- int after;
+merge_string_cste (tree op1, tree op2, int after)
{
/* Handle two string constants right away */
if (TREE_CODE (op2) == STRING_CST)
NULL_TREE for each invocation of this routine. FIXME */
static tree
-string_constant_concatenation (op1, op2)
- tree op1, op2;
+string_constant_concatenation (tree op1, tree op2)
{
if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
{
called on it to turn it into a String object. */
static tree
-build_string_concatenation (op1, op2)
- tree op1, op2;
+build_string_concatenation (tree op1, tree op2)
{
tree result;
int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
NULL. */
static tree
-patch_string (node)
- tree node;
+patch_string (tree node)
{
if (node == error_mark_node)
return error_mark_node;
/* Build the internal representation of a string constant. */
static tree
-patch_string_cst (node)
- tree node;
+patch_string_cst (tree node)
{
int location;
if (! flag_emit_class_files)
/* Build an incomplete unary operator expression. */
static tree
-build_unaryop (op_token, op_location, op1)
- int op_token, op_location;
- tree op1;
+build_unaryop (int op_token, int op_location, tree op1)
{
enum tree_code op;
tree unaryop;
later. IS_POST_P is 1 if the operator, 0 otherwise. */
static tree
-build_incdec (op_token, op_location, op1, is_post_p)
- int op_token, op_location;
- tree op1;
- int is_post_p;
+build_incdec (int op_token, int op_location, tree op1, int is_post_p)
{
static const enum tree_code lookup [2][2] =
{
though its type is already set. */
static tree
-build_cast (location, type, exp)
- int location;
- tree type, exp;
+build_cast (int location, tree type, tree exp)
{
tree node = build1 (CONVERT_EXPR, type, exp);
EXPR_WFL_LINECOL (node) = location;
/* Build an incomplete class reference operator. */
static tree
-build_incomplete_class_ref (location, class_name)
- int location;
- tree class_name;
+build_incomplete_class_ref (int location, tree class_name)
{
tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
EXPR_WFL_LINECOL (node) = location;
/* Complete an incomplete class reference operator. */
static tree
-patch_incomplete_class_ref (node)
- tree node;
+patch_incomplete_class_ref (tree node)
{
tree type = TREE_OPERAND (node, 0);
tree ref_type;
but preserve the type of NODE if the type is fixed. */
static tree
-patch_unaryop (node, wfl_op)
- tree node;
- tree wfl_op;
+patch_unaryop (tree node, tree wfl_op)
{
tree op = TREE_OPERAND (node, 0);
tree op_type = TREE_TYPE (op);
message. Return the resolved type or NULL_TREE. */
static tree
-resolve_type_during_patch (type)
- tree type;
+resolve_type_during_patch (tree type)
{
if (unresolved_type_p (type, NULL))
{
found. Otherwise NODE or something meant to replace it is returned. */
static tree
-patch_cast (node, wfl_op)
- tree node;
- tree wfl_op;
+patch_cast (tree node, tree wfl_op)
{
tree op = TREE_OPERAND (node, 0);
tree cast_type = TREE_TYPE (node);
/* Build a null constant and give it the type TYPE. */
static tree
-build_null_of_type (type)
- tree type;
+build_null_of_type (tree type)
{
tree node = build_int_2 (0, 0);
TREE_TYPE (node) = promote_type (type);
/* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
a list of indices. */
static tree
-build_array_ref (location, array, index)
- int location;
- tree array, index;
+build_array_ref (int location, tree array, tree index)
{
tree node = build (ARRAY_REF, NULL_TREE, array, index);
EXPR_WFL_LINECOL (node) = location;
/* 15.12 Array Access Expression */
static tree
-patch_array_ref (node)
- tree node;
+patch_array_ref (tree node)
{
tree array = TREE_OPERAND (node, 0);
tree array_type = TREE_TYPE (array);
/* 15.9 Array Creation Expressions */
static tree
-build_newarray_node (type, dims, extra_dims)
- tree type;
- tree dims;
- int extra_dims;
+build_newarray_node (tree type, tree dims, int extra_dims)
{
tree node =
build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
}
static tree
-patch_newarray (node)
- tree node;
+patch_newarray (tree node)
{
tree type = TREE_OPERAND (node, 0);
tree dims = TREE_OPERAND (node, 1);
pin-point errors. */
static tree
-maybe_build_array_element_wfl (node)
- tree node;
+maybe_build_array_element_wfl (tree node)
{
if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
return build_expr_wfl (NULL_TREE, ctxp->filename,
and expansion. */
static tree
-build_new_array_init (location, values)
- int location;
- tree values;
+build_new_array_init (int location, tree values)
{
tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
appropriately. */
static tree
-patch_new_array_init (type, node)
- tree type, node;
+patch_new_array_init (tree type, tree node)
{
int error_seen = 0;
tree current, element_type;
otherwise. */
static int
-array_constructor_check_entry (type, entry)
- tree type, entry;
+array_constructor_check_entry (tree type, tree entry)
{
char *array_type_string = NULL; /* For error reports */
tree value, type_value, new_value, wfl_value, patched;
}
static tree
-build_this (location)
- int location;
+build_this (int location)
{
tree node = build_wfl_node (this_identifier_node);
TREE_SET_CODE (node, THIS_EXPR);
to be returned. */
static tree
-build_return (location, op)
- int location;
- tree op;
+build_return (int location, tree op)
{
tree node = build1 (RETURN_EXPR, NULL_TREE, op);
EXPR_WFL_LINECOL (node) = location;
}
static tree
-patch_return (node)
- tree node;
+patch_return (tree node)
{
tree return_exp = TREE_OPERAND (node, 0);
tree meth = current_function_decl;
/* 14.8 The if Statement */
static tree
-build_if_else_statement (location, expression, if_body, else_body)
- int location;
- tree expression, if_body, else_body;
+build_if_else_statement (int location, tree expression, tree if_body,
+ tree else_body)
{
tree node;
if (!else_body)
}
static tree
-patch_if_else_statement (node)
- tree node;
+patch_if_else_statement (tree node)
{
tree expression = TREE_OPERAND (node, 0);
int can_complete_normally
label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
static tree
-build_labeled_block (location, label)
- int location;
- tree label;
+build_labeled_block (int location, tree label)
{
tree label_name ;
tree label_decl, node;
/* A labeled statement LBE is attached a statement. */
static tree
-finish_labeled_statement (lbe, statement)
- tree lbe; /* Labeled block expr */
- tree statement;
+finish_labeled_statement (tree lbe, /* Labeled block expr */
+ tree statement)
{
/* In anyways, tie the loop to its statement */
LABELED_BLOCK_BODY (lbe) = statement;
list. */
static tree
-build_new_loop (loop_body)
- tree loop_body;
+build_new_loop (tree loop_body)
{
tree loop = build (LOOP_EXPR, NULL_TREE, loop_body);
TREE_SIDE_EFFECTS (loop) = 1;
<structure described above> */
static tree
-build_loop_body (location, condition, reversed)
- int location;
- tree condition;
- int reversed;
+build_loop_body (int location, tree condition, int reversed)
{
tree first, second, body;
loop list. */
static tree
-finish_loop_body (location, condition, body, reversed)
- int location;
- tree condition, body;
- int reversed;
+finish_loop_body (int location, tree condition, tree body, int reversed)
{
tree to_return = ctxp->current_loop;
tree loop_body = LOOP_EXPR_BODY (to_return);
loops feature the condition part */
static tree
-finish_for_loop (location, condition, update, body)
- int location;
- tree condition, update, body;
+finish_for_loop (int location, tree condition, tree update, tree body)
{
/* Put the condition and the loop body in place */
tree loop = finish_loop_body (location, condition, body, 0);
LABELED_BLOCK_EXPR's block. */
static tree
-search_loop (statement)
- tree statement;
+search_loop (tree statement)
{
if (TREE_CODE (statement) == LOOP_EXPR)
return statement;
returned otherwise. */
static int
-labeled_block_contains_loop_p (block, loop)
- tree block, loop;
+labeled_block_contains_loop_p (tree block, tree loop)
{
if (!block)
return 0;
insert LOOP as its body. */
static tree
-patch_loop_statement (loop)
- tree loop;
+patch_loop_statement (tree loop)
{
tree loop_label;
unlabeled break/continue statement. */
static tree
-build_bc_statement (location, is_break, name)
- int location, is_break;
- tree name;
+build_bc_statement (int location, int is_break, tree name)
{
tree break_continue, label_block_expr = NULL_TREE;
/* Verification of a break/continue statement. */
static tree
-patch_bc_statement (node)
- tree node;
+patch_bc_statement (tree node)
{
tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
tree labeled_block = ctxp->current_labeled_block;
boolean. */
static tree
-patch_exit_expr (node)
- tree node;
+patch_exit_expr (tree node)
{
tree expression = TREE_OPERAND (node, 0);
TREE_TYPE (node) = error_mark_node;
/* 14.9 Switch statement */
static tree
-patch_switch_statement (node)
- tree node;
+patch_switch_statement (tree node)
{
tree se = TREE_OPERAND (node, 0), se_type;
tree save, iter;
/* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
might be NULL_TREE. */
static tree
-build_assertion (location, condition, value)
- int location;
- tree condition, value;
+build_assertion (int location, tree condition, tree value)
{
tree node;
tree klass = GET_CPC ();
catches TYPE and executes CATCH_STMTS. */
static tree
-encapsulate_with_try_catch (location, type, try_stmts, catch_stmts)
- int location;
- tree type, try_stmts, catch_stmts;
+encapsulate_with_try_catch (int location, tree type, tree try_stmts,
+ tree catch_stmts)
{
tree try_block, catch_clause_param, catch_block, catch;
}
static tree
-build_try_statement (location, try_block, catches)
- int location;
- tree try_block, catches;
+build_try_statement (int location, tree try_block, tree catches)
{
tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
EXPR_WFL_LINECOL (node) = location;
}
static tree
-build_try_finally_statement (location, try_block, finally)
- int location;
- tree try_block, finally;
+build_try_finally_statement (int location, tree try_block, tree finally)
{
tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
EXPR_WFL_LINECOL (node) = location;
}
static tree
-patch_try_statement (node)
- tree node;
+patch_try_statement (tree node)
{
int error_found = 0;
tree try = TREE_OPERAND (node, 0);
/* 14.17 The synchronized Statement */
static tree
-patch_synchronized_statement (node, wfl_op1)
- tree node, wfl_op1;
+patch_synchronized_statement (tree node, tree wfl_op1)
{
tree expr = java_complete_tree (TREE_OPERAND (node, 0));
tree block = TREE_OPERAND (node, 1);
/* 14.16 The throw Statement */
static tree
-patch_throw_statement (node, wfl_op1)
- tree node, wfl_op1;
+patch_throw_statement (tree node, tree wfl_op1)
{
tree expr = TREE_OPERAND (node, 0);
tree type = TREE_TYPE (expr);
effectively caught from where DECL is invoked. */
static void
-check_thrown_exceptions (location, decl)
- int location;
- tree decl;
+check_thrown_exceptions (int location, tree decl)
{
tree throws;
/* For all the unchecked exceptions thrown by DECL */
current method. */
static int
-check_thrown_exceptions_do (exception)
- tree exception;
+check_thrown_exceptions_do (tree exception)
{
tree list = currently_caught_type_list;
resolve_and_layout (exception, NULL_TREE);
}
static void
-purge_unchecked_exceptions (mdecl)
- tree mdecl;
+purge_unchecked_exceptions (tree mdecl)
{
tree throws = DECL_FUNCTION_THROWS (mdecl);
tree new = NULL_TREE;
otherwise. */
static bool
-ctors_unchecked_throws_clause_p (class_type)
- tree class_type;
+ctors_unchecked_throws_clause_p (tree class_type)
{
tree current;
/* 15.24 Conditional Operator ?: */
static tree
-patch_conditional_expr (node, wfl_cond, wfl_op1)
- tree node, wfl_cond, wfl_op1;
+patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
{
tree cond = TREE_OPERAND (node, 0);
tree op1 = TREE_OPERAND (node, 1);
/* Wrap EXPR with code to initialize DECL's class, if appropriate. */
static tree
-maybe_build_class_init_for_field (decl, expr)
- tree decl, expr;
+maybe_build_class_init_for_field (tree decl, tree expr)
{
tree clas = DECL_CONTEXT (decl);
if (flag_emit_class_files || flag_emit_xref)
CONTEXT is a static final VAR_DECL whose initializer we are folding. */
static tree
-fold_constant_for_init (node, context)
- tree node;
- tree context;
+fold_constant_for_init (tree node, tree context)
{
tree op0, op1, val;
enum tree_code code = TREE_CODE (node);
'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
tree
-resolve_simple_name (name, context)
- tree name;
- int context;
+resolve_simple_name (tree name, int context)
{
}
tree
-resolve_qualified_name (name, context)
- tree name;
- int context;
+resolve_qualified_name (tree name, int context)
{
}
#endif
void
-init_src_parse ()
+init_src_parse (void)
{
/* Sanity check; we've been bit by this before. */
if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
/* Attach to PTR (a block) the declaration found in ENTRY. */
static int
-attach_init_test_initialization_flags (entry, ptr)
- void **entry;
- void *ptr;
+attach_init_test_initialization_flags (void **entry, void *ptr)
{
tree block = (tree)ptr;
struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
a new one is created. */
static int
-emit_test_initialization (entry_p, info)
- void **entry_p;
- void *info;
+emit_test_initialization (void **entry_p, void *info)
{
tree l = (tree) info;
tree decl, init;
OSDN Git Service
