+Sun Mar 21 08:30:30 1999 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
+
+ * Makefile.in (jcf-dump.o): Depend on $(CONFIG_H)
+ $(srcdir)/../system.h and $(JAVA_TREE_H).
+ (jcf-io.o): Depend on $(JAVA_TREE_H).
+ (mangle.o): Likewise.
+
+ * check-init.c (check_cond_init): Add static prototype.
+
+ * class.c (build_java_method_type, hashUtf8String,
+ make_field_value, get_dispatch_vector, get_dispatch_table,
+ append_gpp_mangled_type, mangle_static_field): Likewise.
+ (strLengthUtf8): Hide unused definition.
+ (hashUtf8String): Const-ify.
+ (make_field_value): Un-ANSI-fy.
+
+ * constants.c: Move inclusion of jcf.h above java-tree.h.
+ (set_constant_entry, find_class_or_string_constant,
+ find_name_and_type_constant, get_tag_node,
+ build_constant_data_ref): Add static prototype.
+
+ * decl.c (push_jvm_slot, builtin_function,
+ lookup_name_current_level): Likewise.
+ (builtin_function): Const-ify.
+
+ * except.c (expand_start_java_handler, expand_end_java_handler):
+ Add static prototype.
+
+ * expr.c (flush_quick_stack, push_value, pop_value,
+ java_stack_swap, java_stack_dup, build_java_athrow,
+ build_java_jsr, build_java_ret, expand_java_multianewarray,
+ expand_java_arraystore, expand_java_arrayload,
+ expand_java_array_length, build_java_monitor, expand_java_pushc,
+ expand_java_return, expand_java_NEW, expand_java_INSTANCEOF,
+ expand_java_CHECKCAST, expand_iinc, expand_java_binop, note_label,
+ expand_compare, expand_test, expand_cond, expand_java_goto,
+ expand_java_call, expand_java_ret, pop_arguments, expand_invoke,
+ expand_java_field_op, java_push_constant_from_pool): Likewise.
+
+ (decode_newarray_type, expand_iinc): Un-ANSI-fy.
+ (build_java_arraynull_check): Mark parameters `node' and `type'
+ with ATTRIBUTE_UNUSED.
+ (note_label): Likewise for parameter `current_pc'.
+ (expand_java_call, expand_java_ret): Hide unused definition.
+
+ * java-tree.h (make_class, build_constants_constructor,
+ java_set_exception_lang_code, pop_labeled_block, emit_handlers,
+ init_outgoing_cpool, register_class, emit_register_classes,
+ java_layout_seen_class_methods): Prototype.
+ (unicode_mangling_length): Const-ify.
+ (append_gpp_mangled_name, append_gpp_mangled_classtype,
+ emit_unicode_mangled_name, format_int, format_uint,
+ jcf_trim_old_input, jcf_print_utf8, jcf_print_char,
+ jcf_print_utf8_replace, open_class): Prototype.
+
+ * jcf-dump.c: Include "config.h", not <config.h>. Don't include
+ <stdio.h>. Include tree.h/java-tree.h.
+ (utf8_equal_string usage, process_class): Add static prototype.
+ (open_class): Don't prototype this here.
+ (utf8_equal_string): Match arguments to format specifiers.
+ (HANDLE_CODE_ATTRIBUTE, BRANCH, JSR, RET, LOOKUP_SWITCH,
+ TABLE_SWITCH, disassemble_method): Likewise.
+
+ * jcf-io.c: Include tree.h/java-tree.h.
+ (open_class, find_classfile, jcf_print_utf8,
+ jcf_print_utf8_replace): Const-ify.
+
+ * jcf-parse.c (parse_zip_file_entries, process_zip_dir,
+ parse_class_file): Add static prototype.
+ (find_in_current_zip): Match definition to existing static
+ prototype.
+
+ * jcf-write.c: Include jcf.h before tree.h/java-tree.h.
+ (alloc_chunk, append_chunk, append_chunk_copy, gen_jcf_label,
+ finish_jcf_block, define_jcf_label, get_jcf_label_here,
+ put_linenumber, localvar_alloc, localvar_free, get_access_flags,
+ write_chunks, adjust_typed_op, generate_bytecode_conditional,
+ generate_bytecode_return, perform_relocations, init_jcf_state,
+ init_jcf_method, release_jcf_state, generate_classfile):
+ Add static prototype.
+ (emit_unop): Mark parameter `type' with ATTRIBUTE_UNUSED.
+ (make_class_file_name): Const-ify.
+
+ * jcf.h (find_classfile): Const-ify.
+
+ * jv-scan.c (reset_report): Remove prototype.
+
+ * jvgenmain.c: Include jcf.h/tree.h/java-tree.h.
+ (error): Rewrite to allow varargs.
+
+ * lang.c (lang_f_options): Const-ify.
+
+ * lex.c (java_parse_escape_sequence): Add static prototype.
+ (java_allocate_new_line): Match definition to existing static
+ prototype.
+
+ * mangle.c Include tree.h/java-tree.h.
+ (unicode_mangling_length, emit_unicode_mangled_name,
+ append_gpp_mangled_name, append_gpp_mangled_classtype): Const-ify.
+
+ * parse.h (jdep_code): Remove trailing comma in enumeration.
+ (java_get_line_col): Move prototype outside of !JC1_LITE test.
+ (reset_report): Add prototype.
+
+ * verify.c (push_pending_label, merge_types): Add static
+ prototypes.
+
+ * zipfile.h (opendir_in_zip, open_in_zip): Prototype.
+
1999-03-19 Alexandre Petit-Bianco <apbianco@cygnus.com>
* parse.y (find_applicable_accessible_methods_list): Extend the
force:
parse.o : $(PARSE_C) jcf-reader.c $(CONFIG_H) $(srcdir)/../system.h
-jcf-dump.o : jcf-dump.c jcf-reader.c jcf.h javaop.h javaop.def
+jcf-dump.o : $(CONFIG_H) $(srcdir)/../system.h $(JAVA_TREE_H) jcf-dump.c \
+ jcf-reader.c jcf.h javaop.h javaop.def
gjavah.o : $(CONFIG_H) $(srcdir)/../system.h gjavah.c \
jcf-reader.c jcf.h javaop.h
buffer.o : buffer.c $(CONFIG_H) buffer.h $(srcdir)/../gansidecl.h \
java-except.h java-except.h parse.h $(srcdir)/../toplev.h \
$(srcdir)/../system.h
jcf-depend.o : jcf-depend.c $(CONFIG_H) $(srcdir)/../system.h jcf.h
-jcf-io.o : jcf-io.c $(CONFIG_H) $(srcdir)/../system.h
+jcf-io.o : jcf-io.c $(CONFIG_H) $(srcdir)/../system.h $(JAVA_TREE_H)
jcf-parse.o : jcf-parse.c $(CONFIG_H) $(JAVA_TREE_H) $(srcdir)/../flags.h \
$(srcdir)/../input.h java-except.h $(srcdir)/../system.h \
$(srcdir)/../toplev.h $(PARSE_H)
jvgenmain.o : jvgenmain.c $(CONFIG_H) $(srcdir)/../system.h
lang.o : lang.c $(CONFIG_H) $(JAVA_TREE_H) jcf.h $(srcdir)/../input.h \
$(srcdir)/../toplev.h $(srcdir)/../system.h
-mangle.o : mangle.c $(CONFIG_H) jcf.h $(srcdir)/../system.h \
+mangle.o : mangle.c $(CONFIG_H) jcf.h $(JAVA_TREE_H) $(srcdir)/../system.h \
$(srcdir)/../toplev.h
parse-scan.o : $(CONFIG_H) $(srcdir)/../system.h $(srcdir)/../toplev.h
typeck.o : typeck.c $(CONFIG_H) $(JAVA_TREE_H) jcf.h convert.h \
static void check_bool_init PROTO ((tree, words, words, words));
static void check_init PROTO ((tree, words));
+static void check_cond_init PROTO ((tree, tree, tree, words, words, words));
#if 0
#define ALLOC_WORDS(NUM) ((word*) xmalloc ((NUM) * sizeof (word)))
definite assignment.
BEFORE, WHEN_FALSE, and WHEN_TRUE are as in check_bool_init. */
-void
+static void
check_cond_init (test_exp, then_exp, else_exp,
before, when_false, when_true)
tree test_exp, then_exp, else_exp;
static tree mangle_class_field PROTO ((tree class));
static tree make_method_value PROTO ((tree));
+static tree build_java_method_type PROTO ((tree, tree, int));
+static int32 hashUtf8String PROTO ((const char *, int));
+static tree make_field_value PROTO ((tree));
+static tree get_dispatch_vector PROTO ((tree));
+static tree get_dispatch_table PROTO ((tree, tree));
+static void append_gpp_mangled_type PROTO ((struct obstack *, tree));
+static tree mangle_static_field PROTO ((tree));
static rtx registerClass_libfunc;
}
#endif
-tree
+static tree
build_java_method_type (fntype, this_class, access_flags)
tree fntype;
tree this_class;
/* Count the number of Unicode chars encoded in a given Ut8 string. */
+#if 0
int
strLengthUtf8 (str, len)
char *str;
}
return str_length;
}
+#endif
/* Calculate a hash value for a string encoded in Utf8 format.
* This returns the same hash value as specified for java.lang.String.hashCode.
*/
-int32
+static int32
hashUtf8String (str, len)
- char *str;
+ const char *str;
int len;
{
- register unsigned char* ptr = (unsigned char*) str;
- register unsigned char *limit = ptr + len;
+ register const unsigned char* ptr = (const unsigned char*) str;
+ register const unsigned char *limit = ptr + len;
int32 hash = 0;
for (; ptr < limit;)
{
abort ();
}
-tree
-make_field_value (tree fdecl)
+static tree
+make_field_value (fdecl)
+ tree fdecl;
{
tree finit, info;
int bsize, flags;
return minit;
}
-tree
+static tree
get_dispatch_vector (type)
tree type;
{
return vtable;
}
-tree
+static tree
get_dispatch_table (type, this_class_addr)
tree type, this_class_addr;
{
/* Append the mangled name of TYPE onto OBSTACK. */
-void
+static void
append_gpp_mangled_type (obstack, type)
struct obstack *obstack;
tree type;
/* Build the mangled (assembly-level) name of the static field FIELD. */
-tree
+static tree
mangle_static_field (field)
tree field;
{
#include "config.h"
#include "system.h"
+#include "jcf.h"
#include "tree.h"
#include "java-tree.h"
-#include "jcf.h"
#include "toplev.h"
extern struct obstack permanent_obstack;
+static void set_constant_entry PROTO ((CPool *, int, int, jword));
+static int find_class_or_string_constant PROTO ((CPool *, int, tree));
+static int find_name_and_type_constant PROTO ((CPool *, tree, tree));
+static tree get_tag_node PROTO ((int));
+static tree build_constant_data_ref PROTO ((void));
+
/* Set the INDEX'th constant in CPOOL to have the given TAG and VALUE. */
-void
+static void
set_constant_entry (cpool, index, tag, value)
CPool *cpool;
int index;
return find_constant1 (cpool, CONSTANT_Utf8, (jword) name);
}
-int
+static int
find_class_or_string_constant (cpool, tag, name)
CPool *cpool;
int tag;
/* Find (or create) a CONSTANT_NameAndType matching NAME and TYPE.
Return its index in the constant pool CPOOL. */
-int
+static int
find_name_and_type_constant (cpool, name, type)
CPool *cpool;
tree name;
/* A Cache for build_int_2 (CONSTANT_XXX, 0). */
static tree tag_nodes[13];
-tree
+static tree
get_tag_node (tag)
int tag;
{
/* Return a reference to the data array of the current constant pool. */
-tree
+static tree
build_constant_data_ref ()
{
if (current_constant_pool_data_ref == NULL_TREE)
#include "jcf.h"
#include "toplev.h"
+static tree push_jvm_slot PROTO ((int, tree));
+static tree builtin_function PROTO ((const char *, tree,
+ enum built_in_function, const char *));
+static tree lookup_name_current_level PROTO ((tree));
+
#ifndef INT_TYPE_SIZE
#define INT_TYPE_SIZE BITS_PER_WORD
#endif
/* Push a local variable or stack slot into the decl_map,
and assign it an rtl. */
-tree
+static tree
push_jvm_slot (index, decl)
int index;
tree decl;
If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
the name to be called if we can't opencode the function. */
-tree
+static tree
builtin_function (name, type, function_code, library_name)
- char *name;
+ const char *name;
tree type;
enum built_in_function function_code;
- char *library_name;
+ const char *library_name;
{
tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
DECL_EXTERNAL (decl) = 1;
/* Similar to `lookup_name' but look only at current binding level and
the previous one if its the parameter level. */
-tree
+static tree
lookup_name_current_level (name)
tree name;
{
#include "eh-common.h"
#include "toplev.h"
+static void expand_start_java_handler PROTO ((struct eh_range *));
+static void expand_end_java_handler PROTO ((struct eh_range *));
+
extern struct obstack permanent_obstack;
struct eh_range *current_method_handlers;
/* if there are any handlers for this range, issue start of region */
-void
+static void
expand_start_java_handler (range)
struct eh_range *range ATTRIBUTE_UNUSED;
{
/* if there are any handlers for this range, isssue end of range,
and then all handler blocks */
-void
+static void
expand_end_java_handler (range)
struct eh_range *range;
{
#include "toplev.h"
#include "except.h"
+static void flush_quick_stack PROTO ((void));
+static void push_value PROTO ((tree));
+static tree pop_value PROTO ((tree));
+static void java_stack_swap PROTO ((void));
+static void java_stack_dup PROTO ((int, int));
+static tree build_java_athrow PROTO ((tree));
+static void build_java_jsr PROTO ((tree, tree));
+static void build_java_ret PROTO ((tree));
+static void expand_java_multianewarray PROTO ((tree, int));
+static void expand_java_arraystore PROTO ((tree));
+static void expand_java_arrayload PROTO ((tree));
+static void expand_java_array_length PROTO ((void));
+static tree build_java_monitor PROTO ((tree, tree));
+static void expand_java_pushc PROTO ((int, tree));
+static void expand_java_return PROTO ((tree));
+static void expand_java_NEW PROTO ((tree));
+static void expand_java_INSTANCEOF PROTO ((tree));
+static void expand_java_CHECKCAST PROTO ((tree));
+static void expand_iinc PROTO ((unsigned int, int, int));
+static void expand_java_binop PROTO ((tree, enum tree_code));
+static void note_label PROTO ((int, int));
+static void expand_compare PROTO ((enum tree_code, tree, tree, int));
+static void expand_test PROTO ((enum tree_code, tree, int));
+static void expand_cond PROTO ((enum tree_code, tree, int));
+static void expand_java_goto PROTO ((int));
+#if 0
+static void expand_java_call PROTO ((int, int));
+static void expand_java_ret PROTO ((tree));
+#endif
+static tree pop_arguments PROTO ((tree));
+static void expand_invoke PROTO ((int, int, int));
+static void expand_java_field_op PROTO ((int, int, int));
+static void java_push_constant_from_pool PROTO ((struct JCF *, int));
+
static tree operand_type[59];
extern struct obstack permanent_obstack;
that the expression for a slot may contain decls for stack slots with
higher (or the same) index, but not lower. */
-void
+static void
flush_quick_stack ()
{
int stack_index = stack_pointer;
stack_type_map[stack_pointer++] = TYPE_SECOND;
}
-void
+static void
push_value (value)
tree value;
{
}
}
-tree
+static tree
pop_value (type)
tree type;
{
/* Pop and discrad the top COUNT stack slots. */
-void
+static void
java_stack_pop (count)
int count;
{
/* Implement the 'swap' operator (to swap two top stack slots). */
-void
+static void
java_stack_swap ()
{
tree type1, type2;
stack_type_map[stack_pointer - 2] = type1;
}
-void
+static void
java_stack_dup (size, offset)
int size, offset;
{
/* Calls _Jv_Throw. Discard the contents of the value stack. */
-tree
+static tree
build_java_athrow (node)
tree node;
{
/* Implementation for jsr/ret */
-void
+static void
build_java_jsr (where, ret)
tree where;
tree ret;
expand_label (ret);
}
-void
+static void
build_java_ret (location)
tree location;
{
size_int (BITS_PER_UNIT))
tree
-decode_newarray_type (int atype)
+decode_newarray_type (atype)
+ int atype;
{
switch (atype)
{
tree
build_java_arraynull_check (node, expr, type)
- tree node;
- tree expr;
- tree type;
+ tree node ATTRIBUTE_UNUSED;
+ tree expr;
+ tree type ATTRIBUTE_UNUSED;
{
#if 0
static int java_array_access_throws_null_exception = 0;
class pointer, a number of dimensions and the matching number of
dimensions. The argument list is NULL terminated. */
-void
+static void
expand_java_multianewarray (class_type, ndim)
tree class_type;
int ndim;
to make sure that the RHS can be assigned to the array element
type. It is not necessary to generate this code if ARRAY is final. */
-void
+static void
expand_java_arraystore (rhs_type_node)
tree rhs_type_node;
{
BOOLEAN/SHORT, we push a promoted type back to the stack.
*/
-void
+static void
expand_java_arrayload (lhs_type_node )
tree lhs_type_node;
{
/* Expands .length. Makes sure that we deal with and array and may expand
a NULL check on the array object. */
-void
+static void
expand_java_array_length ()
{
tree array = pop_value (ptr_type_node);
/* Emit code for the call to _Jv_Monitor{Enter,Exit}. CALL can be
either soft_monitorenter_node or soft_monitorexit_node. */
-tree
+static tree
build_java_monitor (call, object)
tree call;
tree object;
/* Emit code for one of the PUSHC instructions. */
-void
+static void
expand_java_pushc (ival, type)
int ival;
tree type;
push_value (value);
}
-void
+static void
expand_java_return (type)
tree type;
{
return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (value)), value);
}
-void
+static void
expand_java_NEW (type)
tree type;
{
NULL_TREE));
}
-void
+static void
expand_java_INSTANCEOF (type)
tree type;
{
push_value (value);
}
-void
+static void
expand_java_CHECKCAST (type)
tree type;
{
push_value (value);
}
-void
-expand_iinc (unsigned int local_var_index, int ival, int pc)
+static void
+expand_iinc (local_var_index, ival, pc)
+ unsigned int local_var_index;
+ int ival;
+ int pc;
{
tree local_var, res;
tree constant_value;
return fold (build (op, type, arg1, arg2));
}
-void
+static void
expand_java_binop (type, op)
tree type; enum tree_code op;
{
/* This maps a bytecode offset (PC) to various flags. */
char *instruction_bits;
-void
+static void
note_label (current_pc, target_pc)
- int current_pc, target_pc;
+ int current_pc ATTRIBUTE_UNUSED, target_pc;
{
lookup_label (target_pc);
instruction_bits [target_pc] |= BCODE_JUMP_TARGET;
/* Emit code to jump to TARGET_PC if VALUE1 CONDITION VALUE2,
where CONDITION is one of one the compare operators. */
-void
+static void
expand_compare (condition, value1, value2, target_pc)
enum tree_code condition;
tree value1, value2;
/* Emit code for a TEST-type opcode. */
-void
+static void
expand_test (condition, type, target_pc)
enum tree_code condition;
tree type;
/* Emit code for a COND-type opcode. */
-void
+static void
expand_cond (condition, type, target_pc)
enum tree_code condition;
tree type;
expand_compare (condition, value1, value2, target_pc);
}
-void
+static void
expand_java_goto (target_pc)
int target_pc;
{
expand_goto (target_label);
}
-void
+#if 0
+static void
expand_java_call (target_pc, return_address)
int target_pc, return_address;
{
expand_goto (target_label);
}
-void
+static void
expand_java_ret (return_address)
- tree return_address;
+ tree return_address ATTRIBUTE_UNUSED;
{
warning ("ret instruction not implemented");
#if 0
expand_goto (target_label);
#endif
}
+#endif
/* Recursive helper function to pop argument types during verifiation. */
abort ();
}
-tree
+static tree
pop_arguments (arg_types)
tree arg_types;
{
METHOD_REF_INDEX is an index into the constant pool.
NARGS is the number of arguments, or -1 if not specified. */
-void
+static void
expand_invoke (opcode, method_ref_index, nargs)
int opcode;
int method_ref_index;
IS_PUTTING is 1 for putting into a field; 0 for getting from the field.
FIELD_REF_INDEX is an index into the constant pool. */
-void
+static void
expand_java_field_op (is_static, is_putting, field_ref_index)
int is_static;
int is_putting;
} /* for */
}
-void
+static void
java_push_constant_from_pool (jcf, index)
JCF *jcf;
int index;
extern tree add_field PROTO ((tree, tree, tree, int));
extern tree add_method PROTO ((tree, int, tree, tree));
extern tree add_method_1 PROTO ((tree, int, tree, tree));
-extern tree make_class ();
+extern tree make_class PROTO ((void));
extern tree push_class PROTO ((tree, tree));
extern tree unmangle_classname PROTO ((const char *name, int name_length));
extern tree parse_signature_string PROTO ((const unsigned char *, int));
extern void layout_class PROTO ((tree));
extern tree layout_class_method PROTO ((tree, tree, tree, tree));
extern void layout_class_methods PROTO ((tree));
-extern tree make_class ();
extern tree build_class_ref PROTO ((tree));
extern tree build_dtable_decl PROTO ((tree));
extern tree build_internal_class_name PROTO ((tree));
-extern tree build_constants_constructor ();
+extern tree build_constants_constructor PROTO ((void));
extern tree build_ref_from_constant_pool PROTO ((int));
extern tree build_utf8_ref PROTO ((tree));
extern tree ident_subst PROTO ((const char*, int,
extern tree create_label_decl PROTO ((tree));
extern void push_labeled_block PROTO ((tree));
extern tree prepare_eh_table_type PROTO ((tree));
-extern void java_set_exception_lang_code PROTO (());
+extern void java_set_exception_lang_code PROTO ((void));
extern tree generate_name PROTO ((void));
-extern void pop_labeled_block PROTO (());
+extern void pop_labeled_block PROTO ((void));
extern char *lang_printable_name PROTO ((tree, int));
extern tree maybe_add_interface PROTO ((tree, tree));
extern void set_super_info PROTO ((int, tree, tree, int));
extern int inherits_from_p PROTO ((tree, tree));
extern void complete_start_java_method PROTO ((tree));
extern tree build_result_decl PROTO ((tree));
-extern void emit_handlers PROTO (());
-extern void init_outgoing_cpool PROTO (());
+extern void emit_handlers PROTO ((void));
+extern void init_outgoing_cpool PROTO ((void));
extern void make_class_data PROTO ((tree));
-extern void register_class PROTO (());
+extern void register_class PROTO ((void));
extern int alloc_name_constant PROTO ((int, tree));
-extern void emit_register_classes PROTO (());
+extern void emit_register_classes PROTO ((void));
extern void lang_init_source PROTO ((int));
extern void write_classfile PROTO ((tree));
extern char *print_int_node PROTO ((tree));
extern tree build_primtype_type_ref PROTO ((char *));
extern tree java_get_real_method_name PROTO ((tree));
extern void finish_class PROTO ((tree));
-extern void java_layout_seen_class_methods PROTO (());
+extern void java_layout_seen_class_methods PROTO ((void));
extern void check_for_initialization PROTO ((tree));
extern tree pushdecl_top_level PROTO ((tree));
extern int alloc_class_constant PROTO ((tree));
-extern int unicode_mangling_length PROTO ((char *, int));
+extern int unicode_mangling_length PROTO ((const char *, int));
extern void init_expr_processing PROTO ((void));
extern void push_super_field PROTO ((tree, tree));
extern void init_class_processing PROTO ((void));
extern void push_type PROTO ((tree));
extern void load_type_state PROTO ((tree));
extern void add_interface PROTO ((tree, tree));
-extern void append_gpp_mangled_classtype PROTO ((struct obstack *, char *));
-extern void emit_unicode_mangled_name PROTO ((struct obstack *, char *, int));
+extern void append_gpp_mangled_name PROTO ((struct obstack *, const char *, int));
+extern void append_gpp_mangled_classtype PROTO ((struct obstack *, const char *));
+extern void emit_unicode_mangled_name PROTO ((struct obstack *, const char *, int));
extern tree force_evaluation_order PROTO ((tree));
extern int verify_constant_pool PROTO ((struct JCF *));
extern void start_java_method PROTO ((tree));
extern void write_constant_pool PROTO ((struct CPool *, unsigned char *, int));
extern int count_constant_pool_bytes PROTO ((struct CPool *));
extern int encode_newarray_type PROTO ((tree));
+#ifdef uint64
+extern void format_int PROTO ((char *, jlong, int));
+extern void format_uint PROTO ((char *, uint64, int));
+#endif
+extern void jcf_trim_old_input PROTO ((struct JCF *));
+#ifdef BUFSIZ
+extern void jcf_print_utf8 PROTO ((FILE *, const unsigned char *, int));
+extern void jcf_print_char PROTO ((FILE *, int));
+extern void jcf_print_utf8_replace PROTO ((FILE *, const unsigned char *,
+ int, int, int));
+# if JCF_USE_STDIO
+extern char* open_class PROTO ((char *, struct JCF *, FILE *, const char *));
+# else
+extern char* open_class PROTO ((char *, struct JCF *, int, const char *));
+# endif /* JCF_USE_STDIO */
+#endif
/* Access flags etc for a method (a FUNCTION_DECL): */
*/
-#include <config.h>
+#include "config.h"
#include "system.h"
-#include <stdio.h>
#include "jcf.h"
+#include "tree.h"
+#include "java-tree.h"
/* Outout file. */
FILE *out;
static void disassemble_method PROTO ((JCF*, unsigned char *, int));
static void print_name PROTO ((FILE*, JCF*, int));
static void print_signature PROTO ((FILE*, JCF*, int, int));
+static int utf8_equal_string PROTO ((struct JCF*, int, const char *));
+static int usage PROTO ((void));
+static void process_class PROTO ((struct JCF *));
#define PRINT_SIGNATURE_RESULT_ONLY 1
#define PRINT_SIGNATURE_ARGS_ONLY 2
-extern char* open_class();
-
-int
+static int
DEFUN(utf8_equal_string, (jcf, index, value),
- JCF *jcf AND int index AND char * value)
+ JCF *jcf AND int index AND const char * value)
{
if (CPOOL_INDEX_IN_RANGE (&jcf->cpool, index)
&& JPOOL_TAG (jcf, index) == CONSTANT_Utf8)
this_class_index = 0; \
if (flag_print_class_info) \
fprintf (out, \
- "Magic number: 0x%0x, minor_version: %d, major_version: %d.\n", \
- MAGIC, MINOR, MAJOR)
+ "Magic number: 0x%0lx, minor_version: %ld, major_version: %ld.\n",\
+ (long) MAGIC, (long) MINOR, (long) MAJOR)
#define HANDLE_START_CONSTANT_POOL(COUNT) \
if (flag_print_constant_pool) \
#define HANDLE_CODE_ATTRIBUTE(MAX_STACK, MAX_LOCALS, CODE_LENGTH) \
{ COMMON_HANDLE_ATTRIBUTE(JCF, attribute_name, attribute_length); \
- fprintf (out, ", max_stack:%d, max_locals:%d, code_length:%d\n", \
- MAX_STACK, MAX_LOCALS, CODE_LENGTH); \
+ fprintf (out, ", max_stack:%ld, max_locals:%ld, code_length:%ld\n", \
+ (long) MAX_STACK, (long) MAX_LOCALS, (long) CODE_LENGTH); \
disassemble_method (jcf, jcf->read_ptr, CODE_LENGTH); }
#define HANDLE_EXCEPTION_TABLE(ENTRIES, COUNT) \
/* If the type of the constant at INDEX matches EXPECTED,
print it tersely, otherwise more verbosely. */
-void
+static void
DEFUN(print_constant_terse, (out, jcf, index, expected),
FILE *out AND JCF *jcf AND int index AND int expected)
{
#include "jcf-reader.c"
-int
+static int
DEFUN (usage, (), )
{
fprintf (stderr, "Usage: jcf-dump [-o outputfile] [-c] classname\n");
exit(1);
}
-void
+static void
DEFUN(process_class, (jcf),
JCF *jcf)
{
#define BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
saw_index = 0, INT_temp = (OPERAND_VALUE); \
- fprintf (out, " %d", saw_index ? INT_temp : oldpc + INT_temp)
+ fprintf (out, " %ld", (long) (saw_index ? INT_temp : oldpc + INT_temp))
#define JSR(OPERAND_TYPE, OPERAND_VALUE) \
saw_index = 0, INT_temp = (OPERAND_VALUE); \
- fprintf (out, " %d", saw_index ? INT_temp : oldpc + INT_temp)
+ fprintf (out, " %ld", (long) (saw_index ? INT_temp : oldpc + INT_temp))
#undef RET /* Defined by config/i386/i386.h */
#define RET(OPERAND_TYPE, OPERAND_VALUE) \
INT_temp = saw_wide ? IMMEDIATE_u2 : (OPERAND_VALUE); \
saw_wide = 0; \
- fprintf (out, " %d", INT_temp);
+ fprintf (out, " %ld", (long) INT_temp);
#define SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
PC = (PC + 3) / 4 * 4; TABLE_OR_LOOKUP##_SWITCH
#define LOOKUP_SWITCH \
{ jint default_offset = IMMEDIATE_s4; jint npairs = IMMEDIATE_s4; \
- fprintf (out, " npairs=%d, default=%d", npairs, default_offset+oldpc); \
+ fprintf (out, " npairs=%ld, default=%ld", (long) npairs, (long) default_offset+oldpc); \
while (--npairs >= 0) { \
jint match = IMMEDIATE_s4; jint offset = IMMEDIATE_s4; \
fprintf (out, "\n%10ld: %ld", (long)match, (long)(offset+oldpc)); } \
#define TABLE_SWITCH \
{ jint default_offset = IMMEDIATE_s4; \
jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4; \
- fprintf (out, " low=%d, high=%d, default=%d", \
- low, high, default_offset+oldpc); \
+ fprintf (out, " low=%ld, high=%ld, default=%ld", \
+ (long) low, (long) high, (long) default_offset+oldpc); \
for (; low <= high; low++) { \
jint offset = IMMEDIATE_s4; \
fprintf (out, "\n%10ld: %ld", (long)low, (long)(offset+oldpc)); } \
else
{
saw_wide = 0;
- fprintf (out, " %d", INT_temp);
+ fprintf (out, " %ld", (long) INT_temp);
}
fputc ('\n', out);
break;
#include "system.h"
#include "jcf.h"
+#include "tree.h"
+#include "java-tree.h"
/* DOS brain-damage */
#ifndef O_BINARY
#if JCF_USE_STDIO
char*
DEFUN(open_class, (filename, jcf, stream, dep_name),
- char *filename AND JCF *jcf AND FILE* stream AND char *dep_name)
+ char *filename AND JCF *jcf AND FILE* stream AND const char *dep_name)
{
if (jcf)
{
#else
char*
DEFUN(open_class, (filename, jcf, fd, dep_name),
- char *filename AND JCF *jcf AND int fd AND char *dep_name)
+ char *filename AND JCF *jcf AND int fd AND const char *dep_name)
{
if (jcf)
{
char *
DEFUN(find_classfile, (filename, jcf, dep_name),
- char *filename AND JCF *jcf AND char *dep_name)
+ char *filename AND JCF *jcf AND const char *dep_name)
{
#if JCF_USE_STDIO
FILE *stream = fopen (filename, "rb");
void
DEFUN(jcf_print_utf8, (stream, str, length),
- FILE *stream AND register unsigned char *str AND int length)
+ FILE *stream AND register const unsigned char *str AND int length)
{
- unsigned char* limit = str + length;
+ const unsigned char * limit = str + length;
while (str < limit)
{
int ch = UTF8_GET (str, limit);
void
DEFUN(jcf_print_utf8_replace, (stream, str, length, in_char, out_char),
- FILE *stream AND unsigned char *str AND int length
+ FILE *stream AND const unsigned char *str AND int length
AND int in_char AND int out_char)
{
/* Declarations of some functions used here. */
static tree give_name_to_class PROTO ((JCF *jcf, int index));
-void parse_zip_file_entries PROTO (());
-void process_zip_dir PROTO (());
+static void parse_zip_file_entries PROTO ((void));
+static void process_zip_dir PROTO ((void));
static void parse_source_file PROTO ((tree));
static void jcf_parse_source PROTO ((void));
static int jcf_figure_file_type PROTO ((JCF *));
static int find_in_current_zip PROTO ((char *, struct JCF **));
+static void parse_class_file PROTO ((void));
/* Handle "SourceFile" attribute. */
}
}
-void
+static void
parse_class_file ()
{
tree method;
static struct ZipFileCache *localToFile;
/* Process all class entries found in the zip file. */
-void
+static void
parse_zip_file_entries (void)
{
struct ZipDirectory *zdir;
/* Read all the entries of the zip file, creates a class and a JCF. Sets the
jcf up for further processing and link it to the created class. */
-void process_zip_dir()
+static void process_zip_dir()
{
int i;
ZipDirectory *zdir;
/* Lookup class NAME and figure whether is a class already found in the current
zip file. */
-int
+static int
DEFUN(find_in_current_zip, (name, length, jcf),
char *name AND JCF **jcf)
{
#include "config.h"
#include "system.h"
+#include "jcf.h"
#include "tree.h"
#include "java-tree.h"
-#include "jcf.h"
#include "obstack.h"
#undef AND
#include "rtl.h"
};
static void generate_bytecode_insns PROTO ((tree, int, struct jcf_partial *));
+static struct chunk * alloc_chunk PROTO ((struct chunk *, unsigned char *,
+ int, struct obstack *));
+static unsigned char * append_chunk PROTO ((unsigned char *, int,
+ struct jcf_partial *));
+static void append_chunk_copy PROTO ((unsigned char *, int,
+ struct jcf_partial *));
+static struct jcf_block * gen_jcf_label PROTO ((struct jcf_partial *));
+static void finish_jcf_block PROTO ((struct jcf_partial *));
+static void define_jcf_label PROTO ((struct jcf_block *,
+ struct jcf_partial *));
+static struct jcf_block * get_jcf_label_here PROTO ((struct jcf_partial *));
+static void put_linenumber PROTO ((int, struct jcf_partial *));
+static void localvar_alloc PROTO ((tree, struct jcf_partial *));
+static int localvar_free PROTO ((tree, struct jcf_partial *));
+static int get_access_flags PROTO ((tree));
+static void write_chunks PROTO ((FILE *, struct chunk *));
+static int adjust_typed_op PROTO ((tree, int));
+static void generate_bytecode_conditional PROTO ((tree, struct jcf_block *,
+ struct jcf_block *, int,
+ struct jcf_partial *));
+static void generate_bytecode_return PROTO ((tree, struct jcf_partial *));
+static void perform_relocations PROTO ((struct jcf_partial *));
+static void init_jcf_state PROTO ((struct jcf_partial *, struct obstack *));
+static void init_jcf_method PROTO ((struct jcf_partial *, tree));
+static void release_jcf_state PROTO ((struct jcf_partial *));
+static struct chunk * generate_classfile PROTO ((tree, struct jcf_partial *));
+
/* Utility macros for appending (big-endian) data to a buffer.
We assume a local variable 'ptr' points into where we want to
Set the data and size fields to DATA and SIZE, respectively.
However, if DATA is NULL and SIZE>0, allocate a buffer as well. */
-struct chunk *
+static struct chunk *
alloc_chunk (last, data, size, work)
struct chunk *last;
unsigned char *data;
#define CHECK_OP(STATE) ((void)0)
#endif
-unsigned char *
+static unsigned char *
append_chunk (data, size, state)
unsigned char *data;
int size;
return state->chunk->data;
}
-void
+static void
append_chunk_copy (data, size, state)
unsigned char *data;
int size;
memcpy (ptr, data, size);
}
\f
-struct jcf_block *
+static struct jcf_block *
gen_jcf_label (state)
struct jcf_partial *state;
{
return block;
}
-void
+static void
finish_jcf_block (state)
struct jcf_partial *state;
{
state->code_length = pc;
}
-void
+static void
define_jcf_label (label, state)
struct jcf_block *label;
struct jcf_partial *state;
label->u.relocations = NULL;
}
-struct jcf_block *
+static struct jcf_block *
get_jcf_label_here (state)
struct jcf_partial *state;
{
/* Note a line number entry for the current PC and given LINE. */
-void
+static void
put_linenumber (line, state)
int line;
struct jcf_partial *state;
#define localvar_max \
((struct localvar_info**) state->localvars.ptr - localvar_buffer)
-void
+static void
localvar_alloc (decl, state)
tree decl;
struct jcf_partial *state;
}
}
-int
+static int
localvar_free (decl, state)
tree decl;
struct jcf_partial *state;
/* Get the access flags of a class (TYPE_DECL), a method (FUNCTION_DECL), or
a field (FIELD_DECL or VAR_DECL, if static), as encoded in a .class file. */
-int
+static int
get_access_flags (decl)
tree decl;
{
/* Write the list of segments starting at CHUNKS to STREAM. */
-void
+static void
write_chunks (stream, chunks)
FILE* stream;
struct chunk *chunks;
reference) to 7 (for 'short') which matches the pattern of how JVM
opcodes typically depend on the operand type. */
-int
+static int
adjust_typed_op (type, max)
tree type;
int max;
static void
emit_unop (opcode, type, state)
enum java_opcode opcode;
- tree type;
+ tree type ATTRIBUTE_UNUSED;
struct jcf_partial *state;
{
RESERVE(1);
TRUE_LABEL may follow right after this. (The idea is that we
may be able to optimize away GOTO TRUE_LABEL; TRUE_LABEL:) */
-void
+static void
generate_bytecode_conditional (exp, true_label, false_label,
true_branch_first, state)
tree exp;
}
}
-void
+static void
generate_bytecode_return (exp, state)
tree exp;
struct jcf_partial *state;
}
}
-void
+static void
perform_relocations (state)
struct jcf_partial *state;
{
state->code_length = pc;
}
-void
+static void
init_jcf_state (state, work)
struct jcf_partial *state;
struct obstack *work;
BUFFER_INIT (&state->bytecode);
}
-void
+static void
init_jcf_method (state, method)
struct jcf_partial *state;
tree method;
state->return_value_decl = NULL_TREE;
}
-void
+static void
release_jcf_state (state)
struct jcf_partial *state;
{
in the .class file representation. The list can be written to a
.class file using write_chunks. Allocate chunks from obstack WORK. */
-struct chunk *
+static struct chunk *
generate_classfile (clas, state)
tree clas;
struct jcf_partial *state;
make_class_file_name (clas)
tree clas;
{
- char *cname, *dname, *slash, *r;
+ const char *dname, *slash;
+ char *cname, *r;
struct stat sb;
cname = IDENTIFIER_POINTER (identifier_subst (DECL_NAME (TYPE_NAME (clas)),
#define DEFAULT_CLASS_PATH "."
extern char *find_class PROTO ((const char *, int, JCF*, int));
-extern char *find_classfile PROTO ((char *, JCF*, char *));
+extern char *find_classfile PROTO ((char *, JCF*, const char *));
extern int jcf_filbuf_from_stdio PROTO ((JCF *jcf, int count));
extern void jcf_out_of_synch PROTO((JCF *));
extern int jcf_unexpected_eof PROTO ((JCF*, int));
void fatal VPROTO((const char *s, ...)) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
void warning VPROTO((const char *s, ...)) ATTRIBUTE_PRINTF_1;
void gcc_obstack_init PROTO ((struct obstack *obstack));
-extern void reset_report PROTO ((void));
#define JC1_LITE
#include "parse.h"
#include "system.h"
#include "obstack.h"
#include "gansidecl.h"
+#include "jcf.h"
+#include "tree.h"
+#include "java-tree.h"
const char main_method_prefix[] = "main__";
const char main_method_suffix[] = "Pt6JArray1ZPQ34java4lang6String";
struct obstack name_obstack;
+extern void error PVPROTO ((const char *, ...))
+ ATTRIBUTE_PRINTF_1;
+
void
-error (const char *str)
+error VPROTO((const char *msgid, ...))
{
- fprintf (stderr, "%s\n", str);
- exit (-1);
+#ifndef ANSI_PROTOTYPES
+ const char *msgid;
+#endif
+ va_list ap;
+
+ VA_START (ap, msgid);
+
+#ifndef ANSI_PROTOTYPES
+ msgid = va_arg (ap, const char *);
+#endif
+
+ vfprintf (stderr, msgid, ap);
+ va_end (ap);
}
void
if `-fSTRING' is seen as an option.
(If `-fno-STRING' is seen as an option, the opposite value is stored.) */
-static struct { char *string; int *variable; int on_value;} lang_f_options[] =
+static struct { const char *string; int *variable; int on_value;}
+lang_f_options[] =
{
{"bounds-check", &flag_bounds_check, 1},
{"assume-compiled", &flag_assume_compiled, 1},
static int java_is_eol PROTO ((FILE *, int));
#endif
static void java_store_unicode PROTO ((struct java_line *, unicode_t, int));
-static unicode_t java_parse_escape_sequence PROTO (());
+static unicode_t java_parse_escape_sequence PROTO ((void));
static int java_letter_or_digit_p PROTO ((unicode_t));
static int java_parse_doc_section PROTO ((unicode_t));
static void java_parse_end_comment PROTO ((unicode_t));
ctxp->c_line->char_col -= JAVA_COLUMN_DELTA (0);
}
-void
+static void
java_allocate_new_line ()
{
unicode_t ahead = (ctxp->c_line ? ctxp->c_line->ahead[0] : '\0');
#include "config.h"
#include "system.h"
#include "jcf.h"
+#include "tree.h"
+#include "java-tree.h"
#include "obstack.h"
#include "toplev.h"
int
unicode_mangling_length (name, len)
- char *name;
+ const char *name;
int len;
{
- unsigned char *ptr;
- unsigned char *limit = (unsigned char *)name + len;
+ const unsigned char *ptr;
+ const unsigned char *limit = (const unsigned char *)name + len;
int need_escapes = 0;
int num_chars = 0;
int underscores = 0;
- for (ptr = (unsigned char *) name; ptr < limit; )
+ for (ptr = (const unsigned char *) name; ptr < limit; )
{
int ch = UTF8_GET(ptr, limit);
if (ch < 0)
void
emit_unicode_mangled_name (obstack, name, len)
struct obstack *obstack;
- char *name;
+ const char *name;
int len;
{
- unsigned char *ptr;
- unsigned char *limit = (unsigned char *)name + len;
- for (ptr = (unsigned char *) name; ptr < limit; )
+ const unsigned char *ptr;
+ const unsigned char *limit = (const unsigned char *)name + len;
+ for (ptr = (const unsigned char *) name; ptr < limit; )
{
int ch = UTF8_GET(ptr, limit);
int emit_escape;
void
append_gpp_mangled_name (obstack, name, len)
struct obstack *obstack;
- char *name;
+ const char *name;
int len;
{
int encoded_len = unicode_mangling_length (name, len);
void
append_gpp_mangled_classtype (obstack, class_name)
struct obstack *obstack;
- char *class_name;
+ const char *class_name;
{
- char *ptr;
+ const char *ptr;
int qualifications = 0;
for (ptr = class_name; *ptr != '\0'; ptr++)
INVOKE_NONVIRTUAL,
INVOKE_SUPER,
INVOKE_INTERFACE,
- INVOKE_VIRTUAL,
+ INVOKE_VIRTUAL
};
/* We need the resolution stuff only if we compile jc1 */
JDEP_TYPE, /* Patch a random tree node type,
without the need for any specific
actions */
- JDEP_EXCEPTION, /* Patch exceptions specified by `throws' */
+ JDEP_EXCEPTION /* Patch exceptions specified by `throws' */
};
typedef struct _jdep {
void java_check_final PROTO ((void));
void java_layout_classes PROTO ((void));
tree java_method_add_stmt PROTO ((tree, tree));
-char *java_get_line_col PROTO ((char *, int, int));
void java_expand_switch PROTO ((tree));
int java_report_errors PROTO (());
extern tree do_resolve_class PROTO ((tree, tree, tree));
#endif
+char *java_get_line_col PROTO ((char *, int, int));
+extern void reset_report PROTO ((void));
/* Always in use, no matter what you compile */
void java_push_parser_context PROTO ((void));
#include "java-except.h"
#include "toplev.h"
+static void push_pending_label PROTO ((tree));
+static tree merge_types PROTO ((tree, tree));
+
extern int stack_pointer;
/* During verification, start of the current subroutine (jsr target). */
/* Append TARGET_LABEL to the pending_block stack unless already in it. */
-void
+static void
push_pending_label (target_label)
tree target_label;
{
For reference types, return the common super-class.
Return TYPE_UNKNOWN if the types cannot be merged. */
-tree
+static tree
merge_types (type1, type2)
tree type1, type2;
{
((ZipDirectory*)((char*)(ZIPD)+(ZIPD)->direntry_size))
#define ZIPMAGIC 0x504b0304
-extern ZipFile * opendir_in_zip ();
+extern ZipFile * opendir_in_zip PROTO ((const char *, int));
extern int read_zip_archive PROTO ((ZipFile *));
+#ifdef JCF_ZIP
+extern int open_in_zip PROTO ((struct JCF *, const char *,
+ const char *, int));
+#endif
projects / gcc.git / commitdiff