+1999-08-10 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
+
+ * check-init.c (check_bool2_init, done_alternative): Add static
+ prototypes.
+
+ * class.c (add_interface_do, maybe_layout_super_class): Likewise.
+ (add_method, build_utf8_ref, build_class_ref,
+ append_gpp_mangled_type, layout_class_method): Constify a char*.
+
+ * decl.c (push_promoted_type, make_binding_level): Add static
+ prototypes.
+ (push_promoted_type, pushdecl): Constify a char*.
+
+ * except.c (find_handler_in_range, link_handler,
+ check_start_handlers): Add static prototypes.
+
+ * expr.c (process_jvm_instruction): Constify a char*.
+
+ * gjavah.c (main): Constify a char*.
+
+ * java-tree.h (verify_jvm_instructions, process_jvm_instruction):
+ Constify a char*.
+
+ * jcf-depend.c (free_entry, add_entry, munge, print_ents): Add
+ static prototypes.
+ (add_entry, jcf_dependency_set_target, jcf_dependency_add_target,
+ munge, print_ents): Constify a char*.
+
+ * jcf-dump.c (disassemble_method): Constify a char*.
+ (print_constant_pool, print_exception_table): Add static prototypes.
+ (print_constant, print_exception_table, main, disassemble_method):
+ Constify a char*.
+
+ * jcf-io.c (find_classfile, find_class): Likewise.
+
+ * jcf-parse.c (JPOOL_UTF_DATA, find_in_current_zip): Likewise.
+ (set_source_filename, predefined_filename_p): Add static prototypes.
+ (set_source_filename, get_constant, get_class_constant,
+ find_in_current_zip): Constify a char*.
+
+ * jcf-path.c (free_entry, append_entry, add_entry, add_path): Add
+ static prototypes.
+ (add_entry, add_path, jcf_path_classpath_arg,
+ jcf_path_CLASSPATH_arg, jcf_path_include_arg): Constify a char*.
+
+ * jcf-reader.c (get_attribute, jcf_parse_preamble,
+ jcf_parse_constant_pool, jcf_parse_class, jcf_parse_fields,
+ jcf_parse_one_method, jcf_parse_methods,
+ jcf_parse_final_attributes): Add static prototypes.
+ (get_attribute): Constify a char*.
+
+ * jcf.h (find_class, find_classfile, jcf_dependency_set_target,
+ jcf_dependency_add_target, jcf_path_classpath_arg,
+ jcf_path_CLASSPATH_arg, jcf_path_include_arg): Constify a char*.
+
+ * jv-scan.c (main): Constify a char*.
+ (gcc_obstack_init): Add prototype arguments.
+
+ * jvgenmain.c (gcc_obstack_init): Likewise.
+ (main): Constify a char*.
+
+ * lang.c (put_decl_string, put_decl_node, java_dummy_print): Add
+ static prototypes.
+ (put_decl_string, lang_print_error): Constify a char*.
+ (lang_init): Remove redundant extern prototype.
+
+ * mangle.c (emit_unicode_mangled_name): Constify a char*.
+
+ * typeck.c (convert_ieee_real_to_integer, parse_signature_type):
+ Add static prototypes.
+ (get_type_from_signature): Constify a char*.
+
+ * verify.c (check_pending_block, type_stack_dup, start_pc_cmp ):
+ Add static prototypes.
+ (start_pc_cmp): Prefer PTR over GENERIC_PTR.
+ (verify_jvm_instructions): Constify a char*.
+
+ * xref.c (xref_flag_value): Likewise.
+
+ * xref.h (xref_flag_value): Likewise.
+
+ * zextract.c (makeword, makelong): Add static prototypes.
+ (makeword, makelong): Constify a uch*.
+
1999-08-09 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* lang.c (java_dummy_print): Constify a char*.
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));
+static void check_bool2_init PROTO ((enum tree_code, tree, tree, words, words, words));
+struct alternatives;
+static void done_alternative PROTO ((words, struct alternatives *));
#if 0
#define ALLOC_WORDS(NUM) ((word*) xmalloc ((NUM) * sizeof (word)))
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 void add_interface_do PROTO ((tree, tree, int));
+static tree maybe_layout_super_class PROTO ((tree, tree));
static rtx registerClass_libfunc;
{
tree handle_class = CLASS_TO_HANDLE_TYPE (this_class);
tree function_type, fndecl;
- unsigned char *sig = (unsigned char*)IDENTIFIER_POINTER (method_sig);
+ const unsigned char *sig = (const unsigned char*)IDENTIFIER_POINTER (method_sig);
push_obstacks (&permanent_obstack, &permanent_obstack);
if (sig[0] != '(')
fatal ("bad method signature");
build_utf8_ref (name)
tree name;
{
- char* name_ptr = IDENTIFIER_POINTER(name);
+ const char * name_ptr = IDENTIFIER_POINTER(name);
int name_len = IDENTIFIER_LENGTH(name);
char buf[60];
char *buf_ptr;
}
else
{
- char *name;
+ const char *name;
char buffer[25];
if (flag_emit_class_files)
{
}
else
{
- char *class_name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
+ const char *class_name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
append_gpp_mangled_classtype (obstack, class_name);
}
break;
layout_class_method (this_class, super_class, method_decl, dtable_count)
tree this_class, super_class, method_decl, dtable_count;
{
- char *ptr;
+ const char *ptr;
char *asm_name;
tree arg, arglist, t;
int method_name_needs_escapes = 0;
if (method_name == init_identifier_node)
{
- char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
+ const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
for (ptr = p; *ptr; )
{
if (*ptr++ == '.')
static tree builtin_function PROTO ((const char *, tree,
enum built_in_function, const char *));
static tree lookup_name_current_level PROTO ((tree));
+static tree push_promoted_type PROTO ((const char *, tree));
+static struct binding_level *make_binding_level PROTO ((void));
#ifndef INT_TYPE_SIZE
#define INT_TYPE_SIZE BITS_PER_WORD
static tree
push_promoted_type (name, actual_type)
- char *name;
+ const char *name;
tree actual_type;
{
tree type = make_node (TREE_CODE (actual_type));
DECL_CONTEXT (x) = current_function_decl;
if (name)
{
- char *file;
+ const char *file;
int line;
t = lookup_name_current_level (name);
/* No shadow warnings for vars made for inlining. */
&& ! DECL_FROM_INLINE (x))
{
- char *warnstring = 0;
+ const char *warnstring = 0;
if (TREE_CODE (x) == PARM_DECL
&& current_binding_level->level_chain->parm_flag)
static void expand_start_java_handler PROTO ((struct eh_range *));
static void expand_end_java_handler PROTO ((struct eh_range *));
+static struct eh_range *find_handler_in_range PROTO ((int, struct eh_range *,
+ struct eh_range *));
+static void link_handler PROTO ((struct eh_range *, struct eh_range *));
+static void check_start_handlers PROTO ((struct eh_range *, int));
extern struct obstack permanent_obstack;
int
process_jvm_instruction (PC, byte_ops, length)
int PC;
- unsigned char* byte_ops;
+ const unsigned char* byte_ops;
long length ATTRIBUTE_UNUSED;
{
const char *opname; /* Temporary ??? */
for (; argi < argc; argi++)
{
char *classname = argv[argi];
- char *classfile_name, *current_output_file;
+ char *current_output_file;
+ const char *classfile_name;
if (verbose)
fprintf (stderr, "Processing %s\n", classname);
extern void init_class_processing PROTO ((void));
extern int can_widen_reference_to PROTO ((tree, tree));
extern int class_depth PROTO ((tree));
-extern int verify_jvm_instructions PROTO ((struct JCF *, unsigned char *, long));
+extern int verify_jvm_instructions PROTO ((struct JCF *, const unsigned char *, long));
extern void maybe_pushlevels PROTO ((int));
extern void maybe_poplevels PROTO ((int));
-extern int process_jvm_instruction PROTO ((int, unsigned char *, long));
+extern int process_jvm_instruction PROTO ((int, const unsigned char *, long));
extern void set_local_type PROTO ((int, tree));
extern int merge_type_state PROTO ((tree));
extern void push_type PROTO ((tree));
struct entry *next;
};
+static void free_entry PROTO ((struct entry **));
+static void add_entry PROTO ((struct entry **, const char *));
+static const char *munge PROTO ((const char *));
+static int print_ents PROTO ((struct entry *, int));
+
/* List of files. */
static struct entry *dependencies = NULL;
static void
add_entry (entp, name)
struct entry **entp;
- char *name;
+ const char *name;
{
struct entry *ent;
void
jcf_dependency_set_target (name)
- char *name;
+ const char *name;
{
free_entry (&targets);
if (name != NULL)
void
jcf_dependency_add_target (name)
- char *name;
+ const char *name;
{
add_entry (&targets, name);
}
/* FIXME: this is taken almost directly from cccp.c. Such duplication
is bad. */
-static char *
+static const char *
munge (filename)
- char *filename;
+ const char *filename;
{
static char *buffer = NULL;
static int buflen = 0;
int len = 2 * strlen (filename) + 1;
- char *p, *dst;
+ const char *p;
+ char *dst;
if (buflen < len)
{
preceded by 2N backslashes represents N backslashes at
the end of a file name; and backslashes in other
contexts should not be doubled. */
- char *q;
+ const char *q;
for (q = p - 1; filename < q && q[-1] == '\\'; q--)
*dst++ = '\\';
}
for (; ent != NULL; ent = ent->next)
{
- char *depname = munge (ent->file);
+ const char *depname = munge (ent->file);
int len = strlen (depname);
if (column + len + 2 > MAX_OUTPUT_COLUMNS)
static void print_constant_terse PROTO ((FILE*, JCF*, int, int));
static void print_constant PROTO ((FILE *, JCF *, int, int));
static void print_constant_ref PROTO ((FILE *, JCF *, int));
-static void disassemble_method PROTO ((JCF*, unsigned char *, int));
+static void disassemble_method PROTO ((JCF*, const 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 *));
+static void print_constant_pool PROTO ((struct JCF *));
+static void print_exception_table PROTO ((struct JCF *,
+ const unsigned char *entries, int));
#define PRINT_SIGNATURE_RESULT_ONLY 1
#define PRINT_SIGNATURE_ARGS_ONLY 2
break;
case CONSTANT_Utf8:
{
- register unsigned char *str = JPOOL_UTF_DATA (jcf, index);
+ register const unsigned char *str = JPOOL_UTF_DATA (jcf, index);
int length = JPOOL_UTF_LENGTH (jcf, index);
if (verbosity > 0)
{ /* Print as 8-bit bytes. */
}
}
-void
+static void
DEFUN(print_constant_pool, (jcf),
JCF *jcf)
{
static void
DEFUN(print_exception_table, (jcf, entries, count),
- JCF *jcf AND unsigned char *entries AND int count)
+ JCF *jcf AND const unsigned char *entries AND int count)
{
/* Print exception table. */
int i = count;
if (i > 0)
{
- unsigned char *ptr = entries;
+ const unsigned char *ptr = entries;
fprintf (out, "Exceptions (count: %d):\n", i);
for (; --i >= 0; ptr+= 8)
{
for (argi = 1; argi < argc; argi++)
{
- char *arg = argv[argi];
+ const char *arg = argv[argi];
if (arg[0] != '-' || ! strcmp (arg, "--"))
break;
for (; argi < argc; argi++)
{
char *arg = argv[argi];
- char* class_filename = find_class (arg, strlen (arg), jcf, 0);
+ const char *class_filename = find_class (arg, strlen (arg), jcf, 0);
if (class_filename == NULL)
class_filename = find_classfile (arg, jcf, NULL);
if (class_filename == NULL)
long compressed_size, member_size;
int compression_method, filename_length, extra_length;
int general_purpose_bits;
- char *filename;
+ const char *filename;
int total_length;
if (flag_print_class_info)
fprintf (out, "Reading classes from archive %s.\n",
static void
DEFUN(disassemble_method, (jcf, byte_ops, len),
- JCF* jcf AND unsigned char *byte_ops AND int len)
+ JCF* jcf AND const unsigned char *byte_ops AND int len)
{
#undef AND /* Causes problems with opcodes for iand and land. */
#undef PTR
#define ARRAY_NEW(TYPE) ARRAY_NEW_##TYPE
#define ARRAY_NEW_NUM \
INT_temp = IMMEDIATE_u1; \
- { char *str; \
+ { const char *str; \
switch (INT_temp) { \
case 4: str = "boolean"; break; \
case 5: str = "char"; break; \
#endif
-char *
+const char *
DEFUN(find_classfile, (filename, jcf, dep_name),
char *filename AND JCF *jcf AND const char *dep_name)
{
failure. If JCF != NULL, it is suitably initialized.
SOURCE_OK is true if we should also look for .java file. */
-char *
+const char *
DEFUN(find_class, (classname, classname_length, jcf, source_ok),
const char *classname AND int classname_length AND JCF *jcf AND int source_ok)
for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
{
- char *path_name = jcf_path_name (entry);
+ const char *path_name = jcf_path_name (entry);
if (class != 0)
{
int dir_len;
#define JPOOL_UTF(JCF, INDEX) CPOOL_UTF(&(JCF)->cpool, INDEX)
#define JPOOL_UTF_LENGTH(JCF, INDEX) IDENTIFIER_LENGTH (JPOOL_UTF (JCF, INDEX))
#define JPOOL_UTF_DATA(JCF, INDEX) \
- ((unsigned char*) IDENTIFIER_POINTER (JPOOL_UTF (JCF, INDEX)))
+ ((const unsigned char *) IDENTIFIER_POINTER (JPOOL_UTF (JCF, INDEX)))
#define HANDLE_CONSTANT_Utf8(JCF, INDEX, LENGTH) \
do { \
unsigned char save; unsigned char *text; \
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 int find_in_current_zip PROTO ((const char *, struct JCF **));
static void parse_class_file PROTO ((void));
+static void set_source_filename PROTO ((JCF *, int));
+static int predefined_filename_p PROTO ((tree));
/* Handle "SourceFile" attribute. */
-void
+static void
set_source_filename (jcf, index)
JCF *jcf;
int index;
{
extern struct obstack *expression_obstack;
tree name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index));
- char *utf8_ptr = IDENTIFIER_POINTER (name);
+ const char *utf8_ptr = IDENTIFIER_POINTER (name);
unsigned char *str_ptr;
int utf8_len = IDENTIFIER_LENGTH (name);
- unsigned char *str = (unsigned char*)utf8_ptr;
+ const unsigned char *str = (const unsigned char *)utf8_ptr;
int i = utf8_len;
int str_len;
TREE_STRING_POINTER (value)
= obstack_alloc (expression_obstack, 2 * str_len);
str_ptr = (unsigned char *) TREE_STRING_POINTER (value);
- str = (unsigned char*)utf8_ptr;
+ str = (const unsigned char *)utf8_ptr;
for (i = 0; i < str_len; i++)
{
int char_value;
{
int name_index = JPOOL_USHORT1 (jcf, i);
/* verify_constant_pool confirmed that name_index is a CONSTANT_Utf8. */
- char *name = JPOOL_UTF_DATA (jcf, name_index);
+ const char *name = JPOOL_UTF_DATA (jcf, name_index);
int nlength = JPOOL_UTF_LENGTH (jcf, name_index);
if (name[0] == '[') /* Handle array "classes". */
type = TREE_TYPE (parse_signature_string (name, nlength));
zip file. */
static int
DEFUN(find_in_current_zip, (name, length, jcf),
- char *name AND JCF **jcf)
+ const char *name AND JCF **jcf)
{
JCF *local_jcf;
tree class_name = maybe_get_identifier (name), class, icv;
struct entry *next;
};
+static void free_entry PROTO ((struct entry **));
+static void append_entry PROTO ((struct entry **, struct entry *));
+static void add_entry PROTO ((struct entry **, const char *, int));
+static void add_path PROTO ((struct entry **, const char *, int));
+
/* We support several different ways to set the class path.
built-in system directory (only libgcj.zip)
static void
add_entry (entp, filename, is_system)
struct entry **entp;
- char *filename;
+ const char *filename;
int is_system;
{
int len;
static void
add_path (entp, cp, is_system)
struct entry **entp;
- char *cp;
+ const char *cp;
int is_system;
{
- char *startp, *endp;
+ const char *startp, *endp;
if (cp)
{
/* Call this when -classpath is seen on the command line. */
void
jcf_path_classpath_arg (path)
- char *path;
+ const char *path;
{
free_entry (&classpath_l);
add_path (&classpath_l, path, 0);
/* Call this when -CLASSPATH is seen on the command line. */
void
jcf_path_CLASSPATH_arg (path)
- char *path;
+ const char *path;
{
free_entry (&classpath_u);
add_path (&classpath_u, path, 0);
/* Call this when -I is seen on the command line. */
void
jcf_path_include_arg (path)
- char *path;
+ const char *path;
{
add_entry (&include_dirs, path, 0);
}
#include "jcf.h"
#include "zipfile.h"
-int
+static int get_attribute PROTO((JCF *));
+static int jcf_parse_preamble PROTO((JCF *));
+static int jcf_parse_constant_pool PROTO((JCF *));
+static void jcf_parse_class PROTO((JCF *));
+static int jcf_parse_fields PROTO((JCF *));
+static int jcf_parse_one_method PROTO((JCF *));
+static int jcf_parse_methods PROTO((JCF *));
+static int jcf_parse_final_attributes PROTO((JCF *));
+
+static int
DEFUN(get_attribute, (jcf),
JCF *jcf)
{
uint32 attribute_length = JCF_readu4 (jcf);
uint32 start_pos = JCF_TELL(jcf);
int name_length;
- unsigned char *name_data;
+ const unsigned char *name_data;
JCF_FILL (jcf, (long) attribute_length);
if (attribute_name <= 0 || attribute_name >= JPOOL_SIZE(jcf))
return -2;
}
/* Read and handle the pre-amble. */
-int
+static int
DEFUN(jcf_parse_preamble, (jcf),
JCF* jcf)
{
Return 0 if OK.
Return -2 if a bad cross-reference (index of other constant) was seen.
*/
-int
+static int
DEFUN(jcf_parse_constant_pool, (jcf),
JCF* jcf)
{
/* Read various class flags and numbers. */
-void
+static void
DEFUN(jcf_parse_class, (jcf),
JCF* jcf)
{
}
/* Read fields. */
-int
+static int
DEFUN(jcf_parse_fields, (jcf),
JCF* jcf)
{
/* Read methods. */
-int
+static int
DEFUN(jcf_parse_one_method, (jcf),
JCF* jcf)
{
return 0;
}
-int
+static int
DEFUN(jcf_parse_methods, (jcf),
JCF* jcf)
{
}
/* Read attributes. */
-int
+static int
DEFUN(jcf_parse_final_attributes, (jcf),
JCF *jcf)
{
#define DEFAULT_CLASS_PATH "."
-extern char *find_class PROTO ((const char *, int, JCF*, int));
-extern char *find_classfile PROTO ((char *, JCF*, const char *));
+extern const char *find_class PROTO ((const char *, int, JCF*, int));
+extern const 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));
/* Declarations for dependency code. */
extern void jcf_dependency_reset PROTO ((void));
-extern void jcf_dependency_set_target PROTO ((char *));
-extern void jcf_dependency_add_target PROTO ((char *));
+extern void jcf_dependency_set_target PROTO ((const char *));
+extern void jcf_dependency_add_target PROTO ((const char *));
extern void jcf_dependency_set_dep_file PROTO ((const char *));
extern void jcf_dependency_add_file PROTO ((const char *, int));
extern void jcf_dependency_write PROTO ((void));
/* Declarations for path handling code. */
extern void jcf_path_init PROTO ((void));
-extern void jcf_path_classpath_arg PROTO ((char *));
-extern void jcf_path_CLASSPATH_arg PROTO ((char *));
-extern void jcf_path_include_arg PROTO ((char *));
+extern void jcf_path_classpath_arg PROTO ((const char *));
+extern void jcf_path_CLASSPATH_arg PROTO ((const char *));
+extern void jcf_path_include_arg PROTO ((const char *));
extern void jcf_path_seal PROTO ((void));
extern void *jcf_path_start PROTO ((void));
extern void *jcf_path_next PROTO ((void *));
char **argv;
{
int i = 1;
- char *output_file = NULL;
+ const char *output_file = NULL;
long ft;
exec_name = argv[0];
#define OBSTACK_CHUNK_FREE free
#endif
_obstack_begin (obstack, OBSTACK_CHUNK_SIZE, 0,
- (void *(*) ()) OBSTACK_CHUNK_ALLOC,
- (void (*) ()) OBSTACK_CHUNK_FREE);
+ (void *(*) (long)) OBSTACK_CHUNK_ALLOC,
+ (void (*) (void *)) OBSTACK_CHUNK_FREE);
}
PTR
#define OBSTACK_CHUNK_FREE free
#endif
_obstack_begin (obstack, OBSTACK_CHUNK_SIZE, 0,
- (void *(*) ()) OBSTACK_CHUNK_ALLOC,
- (void (*) ()) OBSTACK_CHUNK_FREE);
+ (void *(*) PROTO((long))) OBSTACK_CHUNK_ALLOC,
+ (void (*) PROTO((void *))) OBSTACK_CHUNK_FREE);
}
int
{
const char *classname;
FILE *stream;
- char *mangled_classname;
+ const char *mangled_classname;
if (argc < 2 || argc > 3)
{
#include "flags.h"
#include "xref.h"
+static void put_decl_string PROTO ((const char *, int));
+static void put_decl_node PROTO ((tree));
+static void java_dummy_print PROTO ((const char *));
+
#ifndef OBJECT_SUFFIX
# define OBJECT_SUFFIX ".o"
#endif
static void
put_decl_string (str, len)
- char *str;
+ const char *str;
int len;
{
if (len < 0)
fprintf (stderr, "At top level:\n");
else
{
- char *name = lang_printable_name (current_function_decl, 2);
+ const char *name = lang_printable_name (current_function_decl, 2);
fprintf (stderr, "In method `%s':\n", name);
}
void
lang_init ()
{
- extern struct rtx_def * (*lang_expand_expr) ();
#if 0
extern int flag_minimal_debug;
flag_minimal_debug = 0;
break;
}
if (ch >= '0' && ch <= '9')
- emit_escape = (ptr == (unsigned char*) name);
+ emit_escape = (ptr == (const unsigned char *) name);
else
emit_escape = (ch < 'a' || ch > 'z') && (ch < 'A' || ch > 'Z');
if (emit_escape)
#include "convert.h"
#include "toplev.h"
+static tree convert_ieee_real_to_integer PROTO ((tree, tree));
+static tree parse_signature_type PROTO ((const unsigned char **,
+ const unsigned char *));
+
tree * type_map;
extern struct obstack permanent_obstack;
tree
get_type_from_signature (tree signature)
{
- unsigned char *sig = (unsigned char *) IDENTIFIER_POINTER (signature);
+ const unsigned char *sig = (const unsigned char *) IDENTIFIER_POINTER (signature);
int len = IDENTIFIER_LENGTH (signature);
tree type;
/* Primitive types aren't cached. */
static void push_pending_label PROTO ((tree));
static tree merge_types PROTO ((tree, tree));
+static const char *check_pending_block PROTO ((tree));
+static void type_stack_dup PROTO ((int, int));
+static int start_pc_cmp PROTO ((const PTR, const PTR));
extern int stack_pointer;
/* A helper that is used when sorting exception ranges. */
static int
start_pc_cmp (xp, yp)
- const GENERIC_PTR xp;
- const GENERIC_PTR yp;
+ const PTR xp;
+ const PTR yp;
{
struct pc_index *x = (struct pc_index *) xp;
struct pc_index *y = (struct pc_index *) yp;
int
verify_jvm_instructions (jcf, byte_ops, length)
JCF* jcf;
- unsigned char* byte_ops;
+ const unsigned char *byte_ops;
long length;
{
tree label;
int
xref_flag_value (flag)
- char *flag;
+ const char *flag;
{
int i;
for (i = 0; xref_table [i].key; i++)
The Free Software Foundation is independent of Sun Microsystems, Inc. */
/* Exported functions. */
-int xref_flag_value PROTO ((char *));
+int xref_flag_value PROTO ((const char *));
void expand_xref PROTO ((tree));
void xref_set_data PROTO ((int, void *));
void *xref_get_data PROTO ((int));
#endif
+/***********************/
+/* Prototypes */
+/***********************/
+
+static ush makeword PROTO ((const uch *));
+static ulg makelong PROTO ((const uch *));
+
/***********************/
/* Function makeword() */
/***********************/
static ush makeword(b)
- uch *b;
+ const uch *b;
{
/*
* Convert Intel style 'short' integer to non-Intel non-16-bit
/***********************/
static ulg makelong(sig)
- uch *sig;
+ const uch *sig;
{
/*
* Convert intel style 'long' variable to non-Intel non-16-bit
projects / gcc.git / commitdiff