1 /* Program to write C++-suitable header files from a Java(TM) .class
2 file. This is similar to SUN's javah.
4 Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004
5 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA.
24 Java and all Java-based marks are trademarks or registered trademarks
25 of Sun Microsystems, Inc. in the United States and other countries.
26 The Free Software Foundation is independent of Sun Microsystems, Inc. */
28 /* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
32 #include "coretypes.h"
40 #include "java-tree.h"
41 #include "java-opcodes.h"
50 /* The output file. */
53 /* Nonzero on failure. */
54 static int found_error
= 0;
56 /* Nonzero if we're generating JNI output. */
59 /* When nonzero, warn when source file is newer than matching class
63 /* Directory to place resulting files in. Set by -d option. */
64 const char *output_directory
= "";
66 /* Directory to place temporary file. Set by -td option. Currently unused. */
67 const char *temp_directory
= "/tmp";
69 /* Number of friend functions we have to declare. */
70 static int friend_count
;
72 /* A class can optionally have a `friend' function declared. If
73 non-NULL, this is that function. */
74 static char **friend_specs
= NULL
;
76 /* Number of lines we are prepending before the class. */
77 static int prepend_count
;
79 /* We can prepend extra lines before the class's start. */
80 static char **prepend_specs
= NULL
;
82 /* Number of lines we are appending at the end of the class. */
85 /* We can append extra lines just before the class's end. */
86 static char **add_specs
= NULL
;
88 /* Number of lines we are appending after the class. */
89 static int append_count
;
91 /* We can append extra lines after the class's end. */
92 static char **append_specs
= NULL
;
98 struct JCF
*current_jcf
;
100 /* This holds access information for the last field we examined. They
101 let us generate "private:", "public:", and "protected:" properly.
102 If 0 then we haven't previously examined any field. */
103 static JCF_u2 last_access
;
105 /* Pass this macro the flags for a class and for a method. It will
106 return true if the method should be considered `final'. */
107 #define METHOD_IS_FINAL(Class, Method) \
108 (((Class) & ACC_FINAL) || ((Method) & (ACC_FINAL | ACC_PRIVATE)))
110 /* Pass this macro the flags for a method. It will return true if the
112 #define METHOD_IS_NATIVE(Method) \
113 ((Method) & ACC_NATIVE)
115 /* We keep a linked list of all method names we have seen. This lets
116 us determine if a method name and a field name are in conflict. */
121 unsigned char *signature
;
124 struct method_name
*next
;
127 /* List of method names we've seen. */
128 static struct method_name
*method_name_list
;
130 static void print_field_info (FILE*, JCF
*, int, int, JCF_u2
);
131 static void print_mangled_classname (FILE*, JCF
*, const char*, int);
132 static int print_cxx_classname (FILE*, const char*, JCF
*, int, int);
133 static void print_method_info (FILE*, JCF
*, int, int, JCF_u2
);
134 static void print_c_decl (FILE*, JCF
*, int, int, int, const char *, int);
135 static void print_stub_or_jni (FILE*, JCF
*, int, int, int, const char *, int);
136 static void print_full_cxx_name (FILE*, JCF
*, int, int, int, const char *, int);
137 static void decompile_method (FILE*, JCF
*, int);
138 static void add_class_decl (FILE*, JCF
*, JCF_u2
);
140 static void print_name (FILE *, JCF
*, int);
141 static void print_base_classname (FILE *, JCF
*, int);
142 static int utf8_cmp (const unsigned char *, int, const char *);
143 static char *cxx_keyword_subst (const unsigned char *, int);
144 static void generate_access (FILE *, JCF_u2
);
145 static int name_is_method_p (const unsigned char *, int);
146 static char *get_field_name (JCF
*, int, JCF_u2
);
147 static void print_field_name (FILE *, JCF
*, int, JCF_u2
);
148 static const unsigned char *super_class_name (JCF
*, int *);
149 static void print_include (FILE *, const unsigned char *, int);
150 static int gcjh_streq (const void *p1
, const void *p2
);
151 static int throwable_p (const unsigned char *signature
);
152 static const unsigned char *
153 decode_signature_piece (FILE *, const unsigned char *,
154 const unsigned char *, int *);
155 static void print_class_decls (FILE *, JCF
*, int);
156 static void error (const char *msgid
, ...);
157 static void usage (void) ATTRIBUTE_NORETURN
;
158 static void help (void) ATTRIBUTE_NORETURN
;
159 static void version (void) ATTRIBUTE_NORETURN
;
160 static int overloaded_jni_method_exists_p (const unsigned char *, int,
162 static void jni_print_char (FILE *, int);
163 static void jni_print_float (FILE *, jfloat
);
164 static void jni_print_double (FILE *, jdouble
);
165 static void decompile_return_statement (FILE *, JCF
*, int, int, int);
167 static void handle_inner_classes (int);
169 JCF_u2 current_field_name
;
170 JCF_u2 current_field_value
;
171 JCF_u2 current_field_signature
;
172 JCF_u2 current_field_flags
;
174 #define HANDLE_START_FIELD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
175 ( current_field_name = (NAME), current_field_signature = (SIGNATURE), \
176 current_field_flags = (ACCESS_FLAGS), current_field_value = 0)
178 /* We pass over fields twice. The first time we just note the types
179 of the fields and then the start of the methods. Then we go back
180 and parse the fields for real. This is ugly. */
181 static int field_pass
;
182 /* Likewise we pass over methods twice. The first time we generate
183 class decl information; the second time we generate actual method
185 static int method_pass
;
187 #define HANDLE_END_FIELD() \
190 if (out && ! stubs && ! flag_jni) \
191 print_field_info (out, jcf, current_field_name, \
192 current_field_signature, \
193 current_field_flags); \
195 else if (! stubs && ! flag_jni) \
196 add_class_decl (out, jcf, current_field_signature);
198 #define HANDLE_CONSTANTVALUE(VALUEINDEX) current_field_value = (VALUEINDEX)
200 static int method_declared
= 0;
201 static int method_access
= 0;
202 static int method_printed
= 0;
203 static int method_synthetic
= 0;
204 static int method_signature
= 0;
206 /* Set to 1 while the very first data member of a class is being handled. */
207 static int is_first_data_member
= 0;
209 #define HANDLE_METHOD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
211 method_synthetic = 0; \
212 method_printed = 0; \
214 method_signature = SIGNATURE; \
215 if (ATTRIBUTE_COUNT) \
216 method_synthetic = peek_attribute (jcf, ATTRIBUTE_COUNT, \
217 (const char *)"Synthetic", 9); \
218 /* If a synthetic methods have been declared, its attribute aren't \
219 worth reading (and triggering side-effects). We skip them an \
220 set ATTRIBUTE_COUNT to zero so that they'll be skipped in \
221 jcf_parse_one_method. */ \
222 if (method_synthetic) \
224 skip_attribute (jcf, ATTRIBUTE_COUNT); \
225 ATTRIBUTE_COUNT = 0; \
227 if (method_pass && !method_synthetic) \
230 print_method_info (out, jcf, NAME, SIGNATURE, \
233 else if (!method_synthetic) \
235 print_method_info (NULL, jcf, NAME, SIGNATURE, \
237 if (! stubs && ! flag_jni) \
238 add_class_decl (out, jcf, SIGNATURE); \
242 #define HANDLE_CODE_ATTRIBUTE(MAX_STACK, MAX_LOCALS, CODE_LENGTH) \
243 if (out && method_declared) decompile_method (out, jcf, CODE_LENGTH);
245 static int decompiled
= 0;
246 #define HANDLE_END_METHOD() \
247 if (out && method_printed && !method_synthetic) \
248 fputs (decompiled || stubs ? "\n" : ";\n", out);
250 #define HANDLE_INNERCLASSES_ATTRIBUTE(COUNT) handle_inner_classes (COUNT)
252 /* We're going to need {peek,skip}_attribute, enable their definition. */
253 #define NEED_PEEK_ATTRIBUTE
254 #define NEED_SKIP_ATTRIBUTE
256 #include "jcf-reader.c"
258 /* Print an error message and set found_error. */
260 error (const char *msgid
, ...)
264 va_start (ap
, msgid
);
266 fprintf (stderr
, "gcjh: ");
267 vfprintf (stderr
, _(msgid
), ap
);
269 fprintf (stderr
, "\n");
273 /* Print a single-precision float, suitable for parsing by g++. */
275 jni_print_float (FILE *stream
, jfloat f
)
277 /* It'd be nice to use __builtin_nan/__builtin_inf here but they don't
278 work in data initializers. FIXME. */
279 if (JFLOAT_FINITE (f
))
281 fputs (" = ", stream
);
285 fprintf (stream
, "0x1.%.6xp%+df",
286 ((unsigned int)f
.mantissa
) << 1,
287 f
.exponent
- JFLOAT_EXP_BIAS
);
289 /* Exponent of 0x01 is -125; exponent of 0x00 is *also* -125,
290 because the implicit leading 1 bit is no longer present. */
291 fprintf (stream
, "0x0.%.6xp%+df",
292 ((unsigned int)f
.mantissa
) << 1,
293 f
.exponent
+ 1 - JFLOAT_EXP_BIAS
);
295 fputs (";\n", stream
);
298 /* Print a double-precision float, suitable for parsing by g++. */
300 jni_print_double (FILE *stream
, jdouble f
)
302 /* It'd be nice to use __builtin_nan/__builtin_inf here but they don't
303 work in data initializers. FIXME. */
304 if (JDOUBLE_FINITE (f
))
306 fputs (" = ", stream
);
310 fprintf (stream
, "0x1.%.5x%.8xp%+d",
311 f
.mantissa0
, f
.mantissa1
,
312 f
.exponent
- JDOUBLE_EXP_BIAS
);
314 /* Exponent of 0x001 is -1022; exponent of 0x000 is *also* -1022,
315 because the implicit leading 1 bit is no longer present. */
316 fprintf (stream
, "0x0.%.5x%.8xp%+d",
317 f
.mantissa0
, f
.mantissa1
,
318 f
.exponent
+ 1 - JDOUBLE_EXP_BIAS
);
320 fputs (";\n", stream
);
323 /* Print a character, appropriately mangled for JNI. */
326 jni_print_char (FILE *stream
, int ch
)
329 jcf_print_char (stream
, ch
);
330 else if (ch
== '(' || ch
== ')')
335 fputs ("_1", stream
);
337 fputs ("_2", stream
);
339 fputs ("_3", stream
);
342 else if (ISALNUM (ch
))
346 /* "Unicode" character. */
347 fprintf (stream
, "_0%04x", ch
);
351 /* Print a name from the class data. If the index does not point to a
352 string, an error results. */
355 print_name (FILE* stream
, JCF
* jcf
, int name_index
)
357 if (JPOOL_TAG (jcf
, name_index
) != CONSTANT_Utf8
)
359 fprintf (stream
, "<not a UTF8 constant>");
363 jcf_print_utf8 (stream
, JPOOL_UTF_DATA (jcf
, name_index
),
364 JPOOL_UTF_LENGTH (jcf
, name_index
));
367 /* For JNI we must correctly quote each character. */
368 const unsigned char *str
= JPOOL_UTF_DATA (jcf
, name_index
);
369 int length
= JPOOL_UTF_LENGTH (jcf
, name_index
);
370 const unsigned char *limit
= str
+ length
;
373 int ch
= UTF8_GET (str
, limit
);
376 fprintf (stream
, "\\<invalid>");
379 jni_print_char (stream
, ch
);
384 /* Print base name of class. The base name is everything after the
388 print_base_classname (FILE *stream
, JCF
*jcf
, int index
)
390 int name_index
= JPOOL_USHORT1 (jcf
, index
);
392 const unsigned char *s
, *p
, *limit
;
394 s
= JPOOL_UTF_DATA (jcf
, name_index
);
395 len
= JPOOL_UTF_LENGTH (jcf
, name_index
);
400 int c
= UTF8_GET (s
, limit
);
407 int ch
= UTF8_GET (p
, limit
);
409 fputs ("::", stream
);
411 jcf_print_char (stream
, ch
);
415 /* Return 0 if NAME is equal to STR, -1 if STR is "less" than NAME,
416 and 1 if STR is "greater" than NAME. */
419 utf8_cmp (const unsigned char *str
, int length
, const char *name
)
421 const unsigned char *limit
= str
+ length
;
424 for (i
= 0; name
[i
]; ++i
)
426 int ch
= UTF8_GET (str
, limit
);
431 return str
== limit
? 0 : 1;
434 /* This is a sorted list of all C++ keywords. */
436 static const char *const cxx_keywords
[] =
545 /* If NAME is the name of a C++ keyword, then return an override name.
546 This is a name that can be used in place of the keyword.
547 Otherwise, return NULL. The return value is malloc()d. */
550 cxx_keyword_subst (const unsigned char *str
, int length
)
552 int last
= ARRAY_SIZE (cxx_keywords
);
554 int mid
= (last
+ first
) / 2;
557 for (mid
= (last
+ first
) / 2;
559 old
= mid
, mid
= (last
+ first
) / 2)
561 int kwl
= strlen (cxx_keywords
[mid
]);
562 int min_length
= kwl
> length
? length
: kwl
;
563 int r
= utf8_cmp (str
, min_length
, cxx_keywords
[mid
]);
569 /* Skip all trailing `$'. */
570 for (i
= min_length
; i
< length
&& str
[i
] == '$'; ++i
)
572 /* We've only found a match if all the remaining characters
576 char *dup
= xmalloc (2 + length
- min_length
+ kwl
);
577 strcpy (dup
, cxx_keywords
[mid
]);
578 for (i
= kwl
; i
< length
+ 1; ++i
)
594 /* Generate an access control keyword based on FLAGS. */
597 generate_access (FILE *stream
, JCF_u2 flags
)
599 if ((flags
& ACC_VISIBILITY
) == last_access
)
601 last_access
= (flags
& ACC_VISIBILITY
);
606 fputs ("public: // actually package-private\n", stream
);
609 fputs ("public:\n", stream
);
612 fputs ("private:\n", stream
);
615 fputs ("public: // actually protected\n", stream
);
619 fprintf (stream
, "#error unrecognized visibility %d\n",
620 (flags
& ACC_VISIBILITY
));
625 /* See if NAME is already the name of a method. */
627 name_is_method_p (const unsigned char *name
, int length
)
629 struct method_name
*p
;
631 for (p
= method_name_list
; p
!= NULL
; p
= p
->next
)
633 if (p
->length
== length
&& ! memcmp (p
->name
, name
, length
))
639 /* If there is already a native method named NAME, whose signature is not
640 SIGNATURE, then return true. Otherwise return false. */
642 overloaded_jni_method_exists_p (const unsigned char *name
, int length
,
643 const char *signature
, int sig_length
)
645 struct method_name
*p
;
647 for (p
= method_name_list
; p
!= NULL
; p
= p
->next
)
650 && p
->length
== length
651 && ! memcmp (p
->name
, name
, length
)
652 && (p
->sig_length
!= sig_length
653 || memcmp (p
->signature
, signature
, sig_length
)))
659 /* Get name of a field. This handles renamings due to C++ clash. */
661 get_field_name (JCF
*jcf
, int name_index
, JCF_u2 flags
)
663 unsigned char *name
= JPOOL_UTF_DATA (jcf
, name_index
);
664 int length
= JPOOL_UTF_LENGTH (jcf
, name_index
);
667 if (name_is_method_p (name
, length
))
669 /* This field name matches a method. So override the name with
670 a dummy name. This is yucky, but it isn't clear what else to
671 do. FIXME: if the field is static, then we'll be in real
673 if ((flags
& ACC_STATIC
))
675 error ("static field has same name as method");
679 override
= xmalloc (length
+ 3);
680 memcpy (override
, name
, length
);
681 strcpy (override
+ length
, "__");
684 override
= cxx_keyword_subst (name
, length
);
689 /* Print a field name. Convenience function for use with
692 print_field_name (FILE *stream
, JCF
*jcf
, int name_index
, JCF_u2 flags
)
694 char *override
= get_field_name (jcf
, name_index
, flags
);
698 fputs (override
, stream
);
702 jcf_print_utf8 (stream
, JPOOL_UTF_DATA (jcf
, name_index
),
703 JPOOL_UTF_LENGTH (jcf
, name_index
));
707 print_field_info (FILE *stream
, JCF
* jcf
, int name_index
, int sig_index
,
710 char *override
= NULL
;
712 generate_access (stream
, flags
);
713 if (JPOOL_TAG (jcf
, name_index
) != CONSTANT_Utf8
)
715 fprintf (stream
, "<not a UTF8 constant>");
721 if ((flags
& ACC_STATIC
))
723 fputs ("static ", out
);
725 if ((flags
& ACC_FINAL
) && current_field_value
> 0)
730 switch (JPOOL_TAG (jcf
, current_field_value
))
732 case CONSTANT_Integer
:
735 int most_negative
= 0;
736 fputs ("const jint ", out
);
737 print_field_name (out
, jcf
, name_index
, 0);
739 num
= JPOOL_INT (jcf
, current_field_value
);
740 /* We single out the most negative number to print
741 specially. This avoids later warnings from g++. */
742 if (num
== (jint
) 0x80000000)
747 format_int (buffer
, (jlong
) num
, 10);
748 fprintf (out
, "%sL%s;\n", buffer
, most_negative
? " - 1" : "");
754 int most_negative
= 0;
755 fputs ("const jlong ", out
);
756 print_field_name (out
, jcf
, name_index
, 0);
758 num
= JPOOL_LONG (jcf
, current_field_value
);
759 /* We single out the most negative number to print
760 specially.. This avoids later warnings from g++. */
761 if (num
== (jlong
) 0x8000000000000000LL
)
766 format_int (buffer
, num
, 10);
767 fprintf (out
, "%sLL%s;\n", buffer
, most_negative
? " - 1" :"");
772 jfloat fnum
= JPOOL_FLOAT (jcf
, current_field_value
);
773 fputs ("const jfloat ", out
);
774 print_field_name (out
, jcf
, name_index
, 0);
775 jni_print_float (out
, fnum
);
778 case CONSTANT_Double
:
780 jdouble dnum
= JPOOL_DOUBLE (jcf
, current_field_value
);
781 fputs ("const jdouble ", out
);
782 print_field_name (out
, jcf
, name_index
, 0);
783 jni_print_double (out
, dnum
);
787 /* We can't print this as a constant, but we can still
788 print something sensible. */
798 override
= get_field_name (jcf
, name_index
, flags
);
799 print_c_decl (out
, jcf
, name_index
, sig_index
, 0, override
, flags
);
808 print_method_info (FILE *stream
, JCF
* jcf
, int name_index
, int sig_index
,
811 const unsigned char *str
;
812 int length
, is_init
= 0;
813 char *override
= NULL
;
816 method_access
= flags
;
817 if (stream
&& JPOOL_TAG (jcf
, name_index
) != CONSTANT_Utf8
)
818 fprintf (stream
, "<not a UTF8 constant>");
819 str
= JPOOL_UTF_DATA (jcf
, name_index
);
820 length
= JPOOL_UTF_LENGTH (jcf
, name_index
);
824 /* Ignore the internally generated method <clinit>. However,
825 treat <init> as a constructor. */
826 if (! utf8_cmp (str
, length
, "<init>"))
828 else if (! METHOD_IS_FINAL (jcf
->access_flags
, flags
)
829 && ! (flags
& ACC_STATIC
))
831 /* FIXME: i18n bug here. Order of prints should not be
833 fprintf (stderr
, _("ignored method `"));
834 jcf_print_utf8 (stderr
, str
, length
);
835 fprintf (stderr
, _("' marked virtual\n"));
843 /* During the first method pass, build a list of method names. This will
844 be used to determine if field names conflict with method names. */
847 struct method_name
*nn
;
849 nn
= xmalloc (sizeof (struct method_name
));
850 nn
->name
= xmalloc (length
);
851 memcpy (nn
->name
, str
, length
);
853 nn
->next
= method_name_list
;
854 nn
->sig_length
= JPOOL_UTF_LENGTH (jcf
, sig_index
);
855 nn
->signature
= xmalloc (nn
->sig_length
);
856 nn
->is_native
= METHOD_IS_NATIVE (flags
);
857 memcpy (nn
->signature
, JPOOL_UTF_DATA (jcf
, sig_index
),
859 method_name_list
= nn
;
861 /* The rest of this function doesn't matter. */
865 /* We don't worry about overrides in JNI mode. */
868 /* We can't generate a method whose name is a C++ reserved word.
869 We can't just ignore the function, because that will cause
870 incorrect code to be generated if the function is virtual
871 (not only for calls to this function for for other functions
872 after it in the vtbl). So we give it a dummy name instead. */
873 override
= cxx_keyword_subst (str
, length
);
876 if (! stubs
&& ! flag_jni
)
880 generate_access (stream
, flags
);
883 if ((flags
& ACC_STATIC
))
884 fputs ("static ", out
);
885 else if (! METHOD_IS_FINAL (jcf
->access_flags
, flags
))
887 /* Don't print `virtual' if we have a constructor. */
889 fputs ("virtual ", out
);
891 print_c_decl (out
, jcf
, name_index
, sig_index
, is_init
, override
, flags
);
893 if ((flags
& ACC_ABSTRACT
))
900 if (METHOD_IS_NATIVE (flags
))
903 print_stub_or_jni (out
, jcf
, name_index
, sig_index
,
904 is_init
, override
, flags
);
912 /* A helper for the decompiler which prints a `return' statement where
913 the type is a reference type. If METHODTYPE and OBJECTTYPE are not
914 identical, we emit a cast. We do this because the C++ compiler
915 doesn't know that a reference can be cast to the type of an
916 interface it implements. METHODTYPE is the index of the method's
917 signature. NAMEINDEX is the index of the field name; -1 for
918 `this'. OBJECTTYPE is the index of the object's type. */
920 decompile_return_statement (FILE *out
, JCF
*jcf
, int methodtype
,
921 int nameindex
, int objecttype
)
924 int obj_name_len
, method_name_len
;
925 const unsigned char *obj_data
, *method_data
;
927 obj_name_len
= JPOOL_UTF_LENGTH (jcf
, objecttype
);
928 obj_data
= JPOOL_UTF_DATA (jcf
, objecttype
);
930 method_name_len
= JPOOL_UTF_LENGTH (jcf
, methodtype
);
931 method_data
= JPOOL_UTF_DATA (jcf
, methodtype
);
933 /* Skip forward to return type part of method. */
934 while (*method_data
!= ')')
943 /* If we see an `L', skip it and the trailing `;'. */
944 if (method_data
[0] == 'L' && method_data
[method_name_len
- 1] == ';')
947 method_name_len
-= 2;
949 if (obj_data
[0] == 'L' && obj_data
[obj_name_len
- 1] == ';')
955 /* FIXME: if METHODTYPE is a superclass of OBJECTTYPE then we don't
956 need a cast. Right now there is no way to determine if this is
958 if (method_name_len
!= obj_name_len
)
963 for (i
= 0; i
< method_name_len
; ++i
)
965 if (method_data
[i
] != obj_data
[i
])
973 fputs (" { return ", out
);
978 const unsigned char *limit
;
980 fputs ("reinterpret_cast<", out
);
982 while (*method_data
== '[')
987 fputs ("JArray<", out
);
990 /* Leading space to avoid C++ digraphs. */
993 /* If we see an `L', skip it and the trailing `;'. Only do this
994 if we've seen an array specification. If we don't have an
995 array then the `L' was stripped earlier. */
996 if (array_depth
&& method_data
[0] == 'L'
997 && method_data
[method_name_len
- 1] == ';')
1000 method_name_len
-= 2;
1003 limit
= method_data
+ method_name_len
;
1004 while (method_data
< limit
)
1006 int ch
= UTF8_GET (method_data
, limit
);
1010 jcf_print_char (out
, ch
);
1014 /* Close each array. */
1015 while (array_depth
> 0)
1021 /* Close the cast. */
1025 if (nameindex
== -1)
1026 fputs ("this", out
);
1028 print_field_name (out
, jcf
, nameindex
, 0);
1037 /* Try to decompile a method body. Right now we just try to handle a
1038 simple case that we can do. Expand as desired. */
1040 decompile_method (FILE *out
, JCF
*jcf
, int code_len
)
1042 const unsigned char *codes
= jcf
->read_ptr
;
1044 uint16 name_and_type
, name
;
1046 /* If the method is synchronized, don't touch it. */
1047 if ((method_access
& ACC_SYNCHRONIZED
))
1051 && codes
[0] == OPCODE_aload_0
1052 && codes
[1] == OPCODE_getfield
1053 && (codes
[4] == OPCODE_areturn
1054 || codes
[4] == OPCODE_dreturn
1055 || codes
[4] == OPCODE_freturn
1056 || codes
[4] == OPCODE_ireturn
1057 || codes
[4] == OPCODE_lreturn
))
1059 /* Found code like `return FIELD'. */
1060 index
= (codes
[2] << 8) | codes
[3];
1061 /* FIXME: ensure that tag is CONSTANT_Fieldref. */
1062 name_and_type
= JPOOL_USHORT2 (jcf
, index
);
1063 /* FIXME: ensure that tag is CONSTANT_NameAndType. */
1064 name
= JPOOL_USHORT1 (jcf
, name_and_type
);
1065 if (codes
[4] == OPCODE_areturn
)
1066 decompile_return_statement (out
, jcf
, method_signature
,
1067 name
, JPOOL_USHORT2 (jcf
, name_and_type
));
1070 fputs (" { return ", out
);
1072 print_field_name (out
, jcf
, name
, 0);
1077 else if (code_len
== 2
1078 && codes
[0] == OPCODE_aload_0
1079 && codes
[1] == OPCODE_areturn
1080 /* We're going to generate `return this'. This only makes
1081 sense for non-static methods. */
1082 && ! (method_access
& ACC_STATIC
))
1084 decompile_return_statement (out
, jcf
, method_signature
, -1,
1085 JPOOL_USHORT1 (jcf
, jcf
->this_class
));
1088 else if (code_len
== 1 && codes
[0] == OPCODE_return
)
1090 /* Found plain `return'. */
1091 fputs (" { }", out
);
1094 else if (code_len
== 2
1095 && codes
[0] == OPCODE_aconst_null
1096 && codes
[1] == OPCODE_areturn
)
1098 /* Found `return null'. We don't want to depend on NULL being
1100 fputs (" { return 0; }", out
);
1105 /* Like strcmp, but invert the return result for the hash table. This
1106 should probably be in hashtab.c to complement the existing string
1109 gcjh_streq (const void *p1
, const void *p2
)
1111 return ! strcmp ((char *) p1
, (char *) p2
);
1114 /* Return 1 if the initial part of CLNAME names a subclass of throwable,
1115 or 0 if not. CLNAME may be extracted from a signature, and can be
1116 terminated with either `;' or NULL. */
1118 throwable_p (const unsigned char *clname
)
1121 unsigned char *current
;
1125 /* We keep two hash tables of class names. In one we list all the
1126 classes which are subclasses of Throwable. In the other we will
1127 all other classes. We keep two tables to make the code a bit
1128 simpler; we don't have to have a structure mapping class name to
1129 a `throwable?' bit. */
1130 static htab_t throw_hash
;
1131 static htab_t non_throw_hash
;
1132 static int init_done
= 0;
1139 /* Self-initializing. The cost of this really doesn't matter.
1140 We also don't care about freeing these, either. */
1141 throw_hash
= htab_create (10, htab_hash_string
, gcjh_streq
,
1143 non_throw_hash
= htab_create (10, htab_hash_string
, gcjh_streq
,
1146 /* Make sure the root classes show up in the tables. */
1147 str
= xstrdup ("java.lang.Throwable");
1148 slot
= htab_find_slot (throw_hash
, str
, INSERT
);
1151 str
= xstrdup ("java.lang.Object");
1152 slot
= htab_find_slot (non_throw_hash
, str
, INSERT
);
1158 for (length
= 0; clname
[length
] != ';' && clname
[length
] != '\0'; ++length
)
1160 current
= ALLOC (length
+ 1);
1161 for (i
= 0; i
< length
; ++i
)
1162 current
[i
] = clname
[i
] == '/' ? '.' : clname
[i
];
1163 current
[length
] = '\0';
1165 /* We don't compute the hash slot here because the table might be
1166 modified by the recursion. In that case the slot could be
1168 if (htab_find (throw_hash
, current
))
1170 else if (htab_find (non_throw_hash
, current
))
1176 unsigned char *super
, *tmp
;
1177 int super_length
= -1;
1178 const char *classfile_name
= find_class (current
, strlen (current
),
1181 if (! classfile_name
)
1183 error ("couldn't find class %s", current
);
1186 if (jcf_parse_preamble (&jcf
) != 0
1187 || jcf_parse_constant_pool (&jcf
) != 0
1188 || verify_constant_pool (&jcf
) > 0)
1190 error ("parse error while reading %s", classfile_name
);
1193 jcf_parse_class (&jcf
);
1195 tmp
= (unsigned char *) super_class_name (&jcf
, &super_length
);
1196 super
= ALLOC (super_length
+ 1);
1197 memcpy (super
, tmp
, super_length
);
1198 super
[super_length
] = '\0';
1200 result
= throwable_p (super
);
1201 slot
= htab_find_slot (result
? throw_hash
: non_throw_hash
,
1212 /* Print one piece of a signature. Returns pointer to next parseable
1213 character on success, NULL on error. */
1214 static const unsigned char *
1215 decode_signature_piece (FILE *stream
, const unsigned char *signature
,
1216 const unsigned char *limit
, int *need_space
)
1219 int array_depth
= 0;
1221 switch (signature
[0])
1224 /* More spaghetti. */
1227 for (signature
++; (signature
< limit
1228 && ISDIGIT (*signature
)); signature
++)
1233 ctype
= "jbyteArray";
1236 ctype
= "jcharArray";
1239 ctype
= "jdoubleArray";
1242 ctype
= "jfloatArray";
1245 ctype
= "jintArray";
1248 ctype
= "jshortArray";
1251 ctype
= "jlongArray";
1254 ctype
= "jbooleanArray";
1257 /* We have a nested array. */
1260 fputs ("JArray<", stream
);
1264 /* We have to generate a reference to JArray here, so that
1265 our output matches what the compiler does. */
1267 /* Space between `<' and `:' to avoid C++ digraphs. */
1269 fputs ("JArray< ::", stream
);
1270 while (signature
< limit
&& *signature
!= ';')
1272 int ch
= UTF8_GET (signature
, limit
);
1276 fputs ("::", stream
);
1278 jcf_print_char (stream
, ch
);
1282 fputs (" *> *", stream
);
1287 /* Unparseable signature. */
1291 /* If the previous iterations left us with something to print,
1292 print it. For JNI, we always print `jobjectArray' in the
1294 if (flag_jni
&& (ctype
== NULL
|| array_depth
> 0))
1296 ctype
= "jobjectArray";
1299 /* The `printit' case will advance SIGNATURE for us. If we
1300 don't go there, we must advance past the `;' ourselves. */
1308 /* This shouldn't happen. */
1311 case 'B': ctype
= "jbyte"; goto printit
;
1312 case 'C': ctype
= "jchar"; goto printit
;
1313 case 'D': ctype
= "jdouble"; goto printit
;
1314 case 'F': ctype
= "jfloat"; goto printit
;
1315 case 'I': ctype
= "jint"; goto printit
;
1316 case 'J': ctype
= "jlong"; goto printit
;
1317 case 'S': ctype
= "jshort"; goto printit
;
1318 case 'Z': ctype
= "jboolean"; goto printit
;
1319 case 'V': ctype
= "void"; goto printit
;
1323 /* We know about certain types and special-case their names. */
1324 if (! strncmp (signature
, "Ljava/lang/String;",
1325 sizeof ("Ljava/lang/String;") -1))
1327 else if (! strncmp (signature
, "Ljava/lang/Class;",
1328 sizeof ("Ljava/lang/Class;") - 1))
1330 /* Skip leading 'L' for throwable_p call. */
1331 else if (throwable_p (signature
+ 1))
1332 ctype
= "jthrowable";
1336 while (*signature
&& *signature
!= ';')
1341 /* Print a leading "::" so we look in the right namespace. */
1342 fputs ("::", stream
);
1344 while (*signature
&& *signature
!= ';')
1346 int ch
= UTF8_GET (signature
, limit
);
1348 fputs ("::", stream
);
1350 jcf_print_char (stream
, ch
);
1352 fputs (" *", stream
);
1353 if (*signature
== ';')
1359 jni_print_char (stream
, *signature
++);
1364 fputs (ctype
, stream
);
1370 while (array_depth
-- > 0)
1371 fputs ("> *", stream
);
1378 print_c_decl (FILE* stream
, JCF
* jcf
, int name_index
, int signature_index
,
1379 int is_init
, const char *name_override
, int flags
)
1381 if (JPOOL_TAG (jcf
, signature_index
) != CONSTANT_Utf8
)
1383 fprintf (stream
, "<not a UTF8 constant>");
1388 int length
= JPOOL_UTF_LENGTH (jcf
, signature_index
);
1389 const unsigned char *str0
= JPOOL_UTF_DATA (jcf
, signature_index
);
1390 const unsigned char *str
= str0
;
1391 const unsigned char *limit
= str
+ length
;
1393 int is_method
= str
[0] == '(';
1394 const unsigned char *next
;
1396 /* If printing a method, skip to the return signature and print
1397 that first. However, there is no return value if this is a
1399 if (is_method
&& ! is_init
)
1409 /* If printing a field or an ordinary method, then print the
1410 "return value" now. */
1411 if (! is_method
|| ! is_init
)
1413 next
= decode_signature_piece (stream
, str
, limit
, &need_space
);
1416 error ("unparseable signature: `%s'", str0
);
1421 /* Force the alignment of the first data member. This is
1422 because the "new" C++ ABI changed the alignment of non-POD
1423 classes. gcj, however, still uses the "old" alignment. */
1424 if (is_first_data_member
&& ! (flags
& ACC_STATIC
) && ! is_method
)
1426 is_first_data_member
= 0;
1427 print_cxx_classname (out
, " __attribute__((aligned(__alignof__( ",
1428 jcf
, jcf
->super_class
, 1);
1429 fputs (" )))) ", stream
);
1432 /* Now print the name of the thing. */
1434 fputs (" ", stream
);
1435 print_full_cxx_name (stream
, jcf
, name_index
,
1436 signature_index
, is_init
, name_override
,
1441 /* Print the unqualified method name followed by the signature. */
1443 print_full_cxx_name (FILE* stream
, JCF
* jcf
, int name_index
,
1444 int signature_index
, int is_init
,
1445 const char *name_override
, int flags
)
1447 int length
= JPOOL_UTF_LENGTH (jcf
, signature_index
);
1448 const unsigned char *str0
= JPOOL_UTF_DATA (jcf
, signature_index
);
1449 const unsigned char *str
= str0
;
1450 const unsigned char *limit
= str
+ length
;
1452 int is_method
= str
[0] == '(';
1453 const unsigned char *next
;
1456 fputs (name_override
, stream
);
1457 else if (name_index
)
1459 /* Declare constructors specially. */
1461 print_base_classname (stream
, jcf
, jcf
->this_class
);
1463 print_name (stream
, jcf
, name_index
);
1468 unsigned char *signature
= JPOOL_UTF_DATA (jcf
, signature_index
);
1469 int sig_len
= JPOOL_UTF_LENGTH (jcf
, signature_index
);
1470 if (overloaded_jni_method_exists_p (JPOOL_UTF_DATA (jcf
, name_index
),
1471 JPOOL_UTF_LENGTH (jcf
, name_index
),
1472 signature
, sig_len
))
1474 /* If this method is overloaded by another native method,
1475 then include the argument information in the mangled
1477 unsigned char *limit
= signature
+ sig_len
;
1478 fputs ("__", stream
);
1479 while (signature
< limit
)
1481 int ch
= UTF8_GET (signature
, limit
);
1482 jni_print_char (stream
, ch
);
1494 /* Have a method or a constructor. Print signature pieces
1496 fputs (" (", stream
);
1500 /* In JNI mode, add extra arguments. */
1503 /* FIXME: it would be nice to know if we are printing a decl
1504 or a definition, and only print `env' for the latter. */
1505 fputs ("JNIEnv *env", stream
);
1507 fputs ((flags
& ACC_STATIC
) ? ", jclass" : ", jobject", stream
);
1510 fputs (", ", stream
);
1513 while (str
< limit
&& *str
!= ')')
1515 next
= decode_signature_piece (stream
, str
, limit
, &need_space
);
1518 error ("unparseable signature: `%s'", str0
);
1522 if (next
< limit
&& *next
!= ')')
1523 fputs (", ", stream
);
1527 fputs (")", stream
);
1531 /* This is a helper for print_stub_or_jni. */
1533 print_name_for_stub_or_jni (FILE *stream
, JCF
*jcf
, int name_index
,
1534 int signature_index
, int is_init
,
1535 const char *name_override
, int flags
)
1537 const char *const prefix
= flag_jni
? "Java_" : "";
1538 print_cxx_classname (stream
, prefix
, jcf
, jcf
->this_class
, 1);
1539 fputs (flag_jni
? "_" : "::", stream
);
1540 print_full_cxx_name (stream
, jcf
, name_index
,
1541 signature_index
, is_init
, name_override
,
1546 print_stub_or_jni (FILE* stream
, JCF
* jcf
, int name_index
,
1547 int signature_index
, int is_init
,
1548 const char *name_override
, int flags
)
1550 if (JPOOL_TAG (jcf
, signature_index
) != CONSTANT_Utf8
)
1552 fprintf (stream
, "<not a UTF8 constant>");
1557 int length
= JPOOL_UTF_LENGTH (jcf
, signature_index
);
1558 const unsigned char *str0
= JPOOL_UTF_DATA (jcf
, signature_index
);
1559 const unsigned char *str
= str0
;
1560 const unsigned char *limit
= str
+ length
;
1562 int is_method
= str
[0] == '(';
1563 const unsigned char *next
;
1565 /* Don't print fields in the JNI case. */
1566 if (! is_method
&& flag_jni
)
1569 if (flag_jni
&& ! stubs
)
1570 fputs ("JNIEXPORT ", stream
);
1572 /* If printing a method, skip to the return signature and print
1573 that first. However, there is no return value if this is a
1575 if (is_method
&& ! is_init
)
1585 /* If printing a field or an ordinary method, then print the
1586 "return value" now. Note that a constructor can't be native,
1587 so we don't bother checking this in the JNI case. */
1588 if (! is_method
|| ! is_init
)
1590 next
= decode_signature_piece (stream
, str
, limit
, &need_space
);
1593 error ("unparseable signature: `%s'", str0
);
1598 /* When printing a JNI header we need to respect the space. In
1599 other cases we're just going to insert a newline anyway. */
1600 fputs (need_space
&& ! stubs
? " " : "\n", stream
);
1602 if (flag_jni
&& ! stubs
)
1603 fputs ("JNICALL ", stream
);
1605 /* Now print the name of the thing. */
1606 print_name_for_stub_or_jni (stream
, jcf
, name_index
,
1607 signature_index
, is_init
, name_override
,
1610 /* Print the body. */
1614 fputs ("\n{\n (*env)->FatalError (env, \"", stream
);
1616 fputs ("\n{\n throw new ::java::lang::UnsupportedOperationException (JvNewStringLatin1 (\"", stream
);
1617 print_name_for_stub_or_jni (stream
, jcf
, name_index
,
1618 signature_index
, is_init
,
1621 fprintf (stream
, " not implemented\")%s;\n}\n\n",
1622 flag_jni
? "" : ")");
1628 print_mangled_classname (FILE *stream
, JCF
*jcf
, const char *prefix
, int index
)
1630 int name_index
= JPOOL_USHORT1 (jcf
, index
);
1631 fputs (prefix
, stream
);
1632 jcf_print_utf8_replace (out
,
1633 JPOOL_UTF_DATA (jcf
, name_index
),
1634 JPOOL_UTF_LENGTH (jcf
, name_index
),
1638 /* Print PREFIX, then a class name in C++ format. If the name refers
1639 to an array, ignore it and don't print PREFIX. Returns 1 if
1640 something was printed, 0 otherwise. */
1642 print_cxx_classname (FILE *stream
, const char *prefix
,
1643 JCF
*jcf
, int index
, int add_scope
)
1645 int name_index
= JPOOL_USHORT1 (jcf
, index
);
1647 const unsigned char *s
, *p
, *limit
;
1649 s
= JPOOL_UTF_DATA (jcf
, name_index
);
1650 len
= JPOOL_UTF_LENGTH (jcf
, name_index
);
1653 /* Explicitly omit arrays here. */
1655 c
= UTF8_GET (p
, limit
);
1659 fputs (prefix
, stream
);
1661 /* Print a leading "::" so we look in the right namespace. */
1662 if (! flag_jni
&& ! stubs
&& add_scope
)
1663 fputs ("::", stream
);
1667 c
= UTF8_GET (s
, limit
);
1669 fputs (flag_jni
? "_" : "::", stream
);
1671 jni_print_char (stream
, c
);
1677 int written_class_count
= 0;
1679 /* Return name of superclass. If LEN is not NULL, fill it with length
1681 static const unsigned char *
1682 super_class_name (JCF
*derived_jcf
, int *len
)
1684 int supername_index
= JPOOL_USHORT1 (derived_jcf
, derived_jcf
->super_class
);
1685 int supername_length
= JPOOL_UTF_LENGTH (derived_jcf
, supername_index
);
1686 const unsigned char *supername
=
1687 JPOOL_UTF_DATA (derived_jcf
, supername_index
);
1690 *len
= supername_length
;
1696 handle_inner_classes (int count
)
1700 if (out
&& ! flag_jni
&& ! stubs
&& count
> 0)
1701 fprintf (out
, "\n");
1703 for (i
= 0; i
< count
; ++i
)
1705 JCF_u2 inner_info_index
= JCF_readu2 (current_jcf
);
1707 /* There are a few more values here, but we don't care about
1708 them. The (void) cast is apparently the only way to avoid a
1710 (void) JCF_readu2 (current_jcf
);
1711 (void) JCF_readu2 (current_jcf
);
1712 (void) JCF_readu2 (current_jcf
);
1714 if (out
&& ! flag_jni
&& ! stubs
)
1716 print_mangled_classname (out
, current_jcf
, " friend class ",
1718 fprintf (out
, ";\n");
1725 /* We keep track of all the `#include's we generate, so we can avoid
1730 struct include
*next
;
1733 /* List of all includes. */
1734 static struct include
*all_includes
= NULL
;
1736 /* Generate a #include. */
1738 print_include (FILE *out
, const unsigned char *utf8
, int len
)
1740 struct include
*incl
;
1746 len
= strlen (utf8
);
1748 for (incl
= all_includes
; incl
; incl
= incl
->next
)
1750 /* We check the length because we might have a proper prefix. */
1751 if (len
== (int) strlen (incl
->name
)
1752 && ! strncmp (incl
->name
, utf8
, len
))
1756 incl
= xmalloc (sizeof (struct include
));
1757 incl
->name
= xmalloc (len
+ 1);
1758 strncpy (incl
->name
, utf8
, len
);
1759 incl
->name
[len
] = '\0';
1760 incl
->next
= all_includes
;
1761 all_includes
= incl
;
1763 fputs ("#include <", out
);
1764 jcf_print_utf8_replace (out
, utf8
, len
,
1766 flag_jni
? '_' : '/');
1767 fputs (".h>\n", out
);
1772 /* This is used to represent part of a package or class name. */
1775 /* The text of this part of the name. */
1777 /* True if this represents a class. */
1779 /* Linked list of all classes and packages inside this one. */
1780 struct namelet
*subnamelets
;
1781 /* Pointer to next sibling. */
1782 struct namelet
*next
;
1785 static void add_namelet (const unsigned char *, const unsigned char *,
1787 static void print_namelet (FILE *, struct namelet
*, int);
1789 /* The special root namelet. */
1790 static struct namelet root
=
1798 /* This extracts the next name segment from the full UTF-8 encoded
1799 package or class name and links it into the tree. It does this
1802 add_namelet (const unsigned char *name
, const unsigned char *name_limit
,
1803 struct namelet
*parent
)
1805 const unsigned char *p
;
1806 struct namelet
*n
= NULL
, *np
;
1808 /* We want to skip the standard namespaces that we assume the
1809 runtime already knows about. We only do this at the top level,
1810 though, hence the check for `root'. */
1811 if (parent
== &root
)
1813 #define JAVALANG "java/lang/"
1814 #define JAVAIO "java/io/"
1815 #define JAVAUTIL "java/util/"
1816 if ((name_limit
- name
>= (int) sizeof (JAVALANG
) - 1
1817 && ! strncmp (name
, JAVALANG
, sizeof (JAVALANG
) - 1))
1818 || (name_limit
- name
>= (int) sizeof (JAVAUTIL
) - 1
1819 && ! strncmp (name
, JAVAUTIL
, sizeof (JAVAUTIL
) - 1))
1820 || (name_limit
- name
>= (int) sizeof (JAVAIO
) - 1
1821 && ! strncmp (name
, JAVAIO
, sizeof (JAVAIO
) - 1)))
1825 for (p
= name
; p
< name_limit
&& *p
!= '/'; ++p
)
1828 /* Search for this name beneath the PARENT node. */
1829 for (np
= parent
->subnamelets
; np
!= NULL
; np
= np
->next
)
1831 /* We check the length because we might have a proper prefix. */
1832 if ((int) strlen (np
->name
) == p
- name
&&
1833 ! strncmp (name
, np
->name
, p
- name
))
1842 n
= xmalloc (sizeof (struct namelet
));
1843 n
->name
= xmalloc (p
- name
+ 1);
1844 strncpy (n
->name
, name
, p
- name
);
1845 n
->name
[p
- name
] = '\0';
1846 n
->is_class
= (p
== name_limit
);
1847 n
->subnamelets
= NULL
;
1848 n
->next
= parent
->subnamelets
;
1849 parent
->subnamelets
= n
;
1852 /* We recurse if there is more text, and if the trailing piece does
1853 not represent an inner class. */
1855 add_namelet (p
+ 1, name_limit
, n
);
1858 /* Print a single namelet. Destroys namelets while printing. */
1860 print_namelet (FILE *out
, struct namelet
*name
, int depth
)
1867 for (i
= 0; i
< depth
; ++i
)
1869 fprintf (out
, "%s %s", name
->is_class
? "class" : "namespace",
1871 if (name
->is_class
&& name
->subnamelets
== NULL
)
1877 for (i
= 0; i
< depth
; ++i
)
1883 c
= name
->subnamelets
;
1886 struct namelet
*next
= c
->next
;
1887 print_namelet (out
, c
, depth
+ 2);
1890 name
->subnamelets
= NULL
;
1896 for (i
= 0; i
< depth
; ++i
)
1899 /* Only print a `;' when printing a class. C++ is evil. */
1909 /* This is called to add some classes to the list of classes for which
1910 we need decls. The signature argument can be a function
1913 add_class_decl (FILE *out
, JCF
*jcf
, JCF_u2 signature
)
1915 const unsigned char *s
= JPOOL_UTF_DATA (jcf
, signature
);
1916 int len
= JPOOL_UTF_LENGTH (jcf
, signature
);
1919 for (i
= 0; i
< len
; ++i
)
1923 /* If we see an array, then we include the array header. */
1926 print_include (out
, "gcj/array", -1);
1930 /* We're looking for `L<stuff>;' -- everything else is
1935 for (start
= ++i
; i
< len
&& s
[i
] != ';'; ++i
)
1938 add_namelet (&s
[start
], &s
[i
], &root
);
1942 /* Print declarations for all classes required by this class. Any
1943 class or package in the `java' package is assumed to be handled
1944 statically in libjava; we don't generate declarations for these.
1945 This makes the generated headers a bit easier to read. */
1947 print_class_decls (FILE *out
, JCF
*jcf
, int self
)
1949 /* Make sure to always add the current class to the list of things
1950 that should be declared. */
1951 int name_index
= JPOOL_USHORT1 (jcf
, self
);
1953 const unsigned char *s
;
1955 s
= JPOOL_UTF_DATA (jcf
, name_index
);
1956 len
= JPOOL_UTF_LENGTH (jcf
, name_index
);
1957 add_namelet (s
, s
+ len
, &root
);
1959 if (root
.subnamelets
)
1961 fputs ("extern \"Java\"\n{\n", out
);
1962 /* We use an initial offset of 0 because the root namelet
1963 doesn't cause anything to print. */
1964 print_namelet (out
, &root
, 0);
1965 fputs ("}\n\n", out
);
1972 process_file (JCF
*jcf
, FILE *out
)
1975 uint32 field_start
, method_end
, method_start
;
1981 if (jcf_parse_preamble (jcf
) != 0)
1983 error ("Not a valid Java .class file.");
1987 /* Parse and possibly print constant pool */
1988 code
= jcf_parse_constant_pool (jcf
);
1991 error ("error while parsing constant pool");
1994 code
= verify_constant_pool (jcf
);
1997 error ("error in constant pool entry #%d", code
);
2001 jcf_parse_class (jcf
);
2003 if (written_class_count
++ == 0 && out
)
2005 const char *cstart
, *cstart2
, *mode
, *cend
, *what
, *jflag
;
2020 mode
= " -*- c++ -*-";
2026 fprintf (out
, "%s DO NOT EDIT THIS FILE - it is machine generated%s%s\n\n",
2027 cstart
, mode
, cend
);
2030 fprintf (out
, "%s This file was created by `gcjh -stubs%s'.%s\n\
2032 %s This file is intended to give you a head start on implementing native\n\
2033 %s methods using %s.\n\
2034 %s Be aware: running `gcjh -stubs %s' once more for this class may\n\
2035 %s overwrite any edits you have made to this file.%s\n\n",
2036 cstart
, jflag
, mode
,
2052 print_mangled_classname (out
, jcf
, "#ifndef __", jcf
->this_class
);
2053 fprintf (out
, "__\n");
2055 print_mangled_classname (out
, jcf
, "#define __", jcf
->this_class
);
2056 fprintf (out
, "__\n\n");
2060 fprintf (out
, "#include <jni.h>\n\n");
2061 fprintf (out
, "#ifdef __cplusplus\n");
2062 fprintf (out
, "extern \"C\"\n");
2063 fprintf (out
, "{\n");
2064 fprintf (out
, "#endif\n");
2068 /* We do this to ensure that inline methods won't be
2069 `outlined' by g++. This works as long as method and
2070 fields are not added by the user. */
2071 fprintf (out
, "#pragma interface\n");
2073 if (jcf
->super_class
)
2076 const unsigned char *supername
=
2077 super_class_name (jcf
, &super_length
);
2080 print_include (out
, supername
, super_length
);
2086 /* Strip off the ".class" portion of the name when printing
2087 the include file name. */
2089 int i
, len
= strlen (jcf
->classname
);
2090 if (len
> 6 && ! strcmp (&jcf
->classname
[len
- 6], ".class"))
2092 /* Turn the class name into a file name. */
2093 name
= xmalloc (len
+ 1);
2094 for (i
= 0; i
< len
; ++i
)
2095 name
[i
] = jcf
->classname
[i
] == '.' ? '/' : jcf
->classname
[i
];
2097 print_include (out
, name
, len
);
2102 print_include (out
, "gcj/cni", -1);
2103 print_include (out
, "java/lang/UnsupportedOperationException",
2109 /* We want to parse the methods first. But we need to find where
2110 they start. So first we skip the fields, then parse the methods.
2111 Then we parse the fields and skip the methods. This is ugly, but
2112 not too bad since we need two full passes to get class decl
2113 information anyway. */
2115 field_start
= JCF_TELL (jcf
);
2116 jcf_parse_fields (jcf
);
2118 method_start
= JCF_TELL (jcf
);
2120 jcf_parse_methods (jcf
);
2125 if (out
&& ! flag_jni
)
2128 print_class_decls (out
, jcf
, jcf
->this_class
);
2130 for (i
= 0; i
< prepend_count
; ++i
)
2131 fprintf (out
, "%s\n", prepend_specs
[i
]);
2132 if (prepend_count
> 0)
2137 if (! print_cxx_classname (out
, "class ", jcf
,
2138 jcf
->this_class
, 0))
2140 error ("class is of array type\n");
2143 if (jcf
->super_class
)
2145 if (! print_cxx_classname (out
, " : public ",
2146 jcf
, jcf
->super_class
, 1))
2148 error ("base class is of array type");
2153 fputs ("\n{\n", out
);
2157 /* Now go back for second pass over methods and fields. */
2158 is_first_data_member
= 1;
2160 JCF_SEEK (jcf
, method_start
);
2162 jcf_parse_methods (jcf
);
2163 method_end
= JCF_TELL (jcf
);
2166 JCF_SEEK (jcf
, field_start
);
2167 jcf_parse_fields (jcf
);
2168 JCF_SEEK (jcf
, method_end
);
2170 jcf_parse_final_attributes (jcf
);
2176 fprintf (out
, "\n#ifdef __cplusplus\n");
2177 fprintf (out
, "}\n");
2178 fprintf (out
, "#endif\n");
2182 /* Generate friend decl if we still must. */
2183 for (i
= 0; i
< friend_count
; ++i
)
2184 fprintf (out
, " friend %s\n", friend_specs
[i
]);
2186 /* Generate extra declarations. */
2189 for (i
= 0; i
< add_count
; ++i
)
2190 fprintf (out
, " %s\n", add_specs
[i
]);
2192 /* Generate an entry for the class object. */
2193 generate_access (out
, ACC_PUBLIC
);
2194 fprintf (out
, "\n static ::java::lang::Class class$;\n");
2198 if (jcf
->access_flags
& ACC_INTERFACE
)
2199 fputs (" __attribute__ ((java_interface))", out
);
2203 if (append_count
> 0)
2205 for (i
= 0; i
< append_count
; ++i
)
2206 fprintf (out
, "%s\n", append_specs
[i
]);
2209 print_mangled_classname (out
, jcf
,
2210 "\n#endif /* __", jcf
->this_class
);
2211 fprintf (out
, "__ */\n");
2217 /* This is used to mark options with no short value. */
2218 #define LONG_OPT(Num) ((Num) + 128)
2220 #define OPT_classpath LONG_OPT (0)
2221 #define OPT_CLASSPATH OPT_classpath
2222 #define OPT_bootclasspath LONG_OPT (1)
2223 #define OPT_extdirs LONG_OPT (2)
2224 #define OPT_HELP LONG_OPT (3)
2225 #define OPT_TEMP LONG_OPT (4)
2226 #define OPT_VERSION LONG_OPT (5)
2227 #define OPT_PREPEND LONG_OPT (6)
2228 #define OPT_FRIEND LONG_OPT (7)
2229 #define OPT_ADD LONG_OPT (8)
2230 #define OPT_APPEND LONG_OPT (9)
2231 #define OPT_M LONG_OPT (10)
2232 #define OPT_MM LONG_OPT (11)
2233 #define OPT_MG LONG_OPT (12)
2234 #define OPT_MD LONG_OPT (13)
2235 #define OPT_MMD LONG_OPT (14)
2237 static const struct option options
[] =
2239 { "classpath", required_argument
, NULL
, OPT_classpath
},
2240 { "bootclasspath", required_argument
, NULL
, OPT_bootclasspath
},
2241 { "extdirs", required_argument
, NULL
, OPT_extdirs
},
2242 { "CLASSPATH", required_argument
, NULL
, OPT_CLASSPATH
},
2243 { "help", no_argument
, NULL
, OPT_HELP
},
2244 { "stubs", no_argument
, &stubs
, 1 },
2245 { "td", required_argument
, NULL
, OPT_TEMP
},
2246 { "verbose", no_argument
, NULL
, 'v' },
2247 { "version", no_argument
, NULL
, OPT_VERSION
},
2248 { "prepend", required_argument
, NULL
, OPT_PREPEND
},
2249 { "friend", required_argument
, NULL
, OPT_FRIEND
},
2250 { "add", required_argument
, NULL
, OPT_ADD
},
2251 { "append", required_argument
, NULL
, OPT_APPEND
},
2252 { "M", no_argument
, NULL
, OPT_M
},
2253 { "MM", no_argument
, NULL
, OPT_MM
},
2254 { "MG", no_argument
, NULL
, OPT_MG
},
2255 { "MD", no_argument
, NULL
, OPT_MD
},
2256 { "MMD", no_argument
, NULL
, OPT_MMD
},
2257 { "jni", no_argument
, &flag_jni
, 1 },
2258 { NULL
, no_argument
, NULL
, 0 }
2264 fprintf (stderr
, _("Try `gcjh --help' for more information.\n"));
2271 printf (_("Usage: gcjh [OPTION]... CLASS...\n\n"));
2272 printf (_("Generate C++ header files from .class files\n\n"));
2273 printf (_(" -stubs Generate an implementation stub file\n"));
2274 printf (_(" -jni Generate a JNI header or stub\n"));
2276 printf (_(" -add TEXT Insert TEXT into class body\n"));
2277 printf (_(" -append TEXT Insert TEXT after class declaration\n"));
2278 printf (_(" -friend TEXT Insert TEXT as `friend' declaration\n"));
2279 printf (_(" -prepend TEXT Insert TEXT before start of class\n"));
2281 printf (_(" --classpath PATH Set path to find .class files\n"));
2282 printf (_(" -IDIR Append directory to class path\n"));
2283 printf (_(" --bootclasspath PATH Override built-in class path\n"));
2284 printf (_(" --extdirs PATH Set extensions directory path\n"));
2285 printf (_(" -d DIRECTORY Set output directory name\n"));
2286 printf (_(" -o FILE Set output file name\n"));
2287 printf (_(" -td DIRECTORY Set temporary directory name\n"));
2289 printf (_(" --help Print this help, then exit\n"));
2290 printf (_(" --version Print version number, then exit\n"));
2291 printf (_(" -v, --verbose Print extra information while running\n"));
2293 printf (_(" -M Print all dependencies to stdout;\n"
2294 " suppress ordinary output\n"));
2295 printf (_(" -MM Print non-system dependencies to stdout;\n"
2296 " suppress ordinary output\n"));
2297 printf (_(" -MD Print all dependencies to stdout\n"));
2298 printf (_(" -MMD Print non-system dependencies to stdout\n"));
2299 /* We omit -MG until it is implemented. */
2301 printf (_("For bug reporting instructions, please see:\n"
2302 "%s.\n"), bug_report_url
);
2309 printf ("gcjh (GCC) %s\n\n", version_string
);
2310 printf ("Copyright %s 2004 Free Software Foundation, Inc.\n", _("(C)"));
2311 printf (_("This is free software; see the source for copying conditions. There is NO\n"
2312 "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"));
2317 main (int argc
, char** argv
)
2321 char *output_file
= NULL
;
2322 int emit_dependencies
= 0, suppress_output
= 0;
2325 gcc_init_libintl ();
2329 error ("no classes specified");
2335 /* We use getopt_long_only to allow single `-' long options. For
2336 some of our options this is more natural. */
2337 while ((opt
= getopt_long_only (argc
, argv
, "I:d:o:v", options
, NULL
)) != -1)
2342 /* Already handled. */
2346 output_file
= optarg
;
2350 output_directory
= optarg
;
2354 jcf_path_include_arg (optarg
);
2362 jcf_path_classpath_arg (optarg
);
2365 case OPT_bootclasspath
:
2366 jcf_path_bootclasspath_arg (optarg
);
2370 jcf_path_extdirs_arg (optarg
);
2378 temp_directory
= optarg
;
2386 if (prepend_count
== 0)
2387 prepend_specs
= ALLOC (argc
* sizeof (char*));
2388 prepend_specs
[prepend_count
++] = optarg
;
2392 if (friend_count
== 0)
2393 friend_specs
= ALLOC (argc
* sizeof (char*));
2394 friend_specs
[friend_count
++] = optarg
;
2399 add_specs
= ALLOC (argc
* sizeof (char*));
2400 add_specs
[add_count
++] = optarg
;
2404 if (append_count
== 0)
2405 append_specs
= ALLOC (argc
* sizeof (char*));
2406 append_specs
[append_count
++] = optarg
;
2410 emit_dependencies
= 1;
2411 suppress_output
= 1;
2412 jcf_dependency_init (1);
2416 emit_dependencies
= 1;
2417 suppress_output
= 1;
2418 jcf_dependency_init (0);
2422 error ("`-MG' option is unimplemented");
2426 emit_dependencies
= 1;
2427 jcf_dependency_init (1);
2431 emit_dependencies
= 1;
2432 jcf_dependency_init (0);
2443 error ("no classes specified");
2447 jcf_path_seal (verbose
);
2449 if (output_file
&& emit_dependencies
)
2451 error ("can't specify both -o and -MD");
2455 for (argi
= optind
; argi
< argc
; argi
++)
2457 char *classname
= argv
[argi
];
2458 char *current_output_file
;
2459 const char *classfile_name
;
2462 printf (_("Processing %s\n"), classname
);
2464 jcf_dependency_reset ();
2465 classfile_name
= find_class (classname
, strlen (classname
), &jcf
, 0);
2466 if (classfile_name
== NULL
)
2468 error ("%s: no such class", classname
);
2472 printf (_("Found in %s\n"), classfile_name
);
2475 if (strcmp (output_file
, "-") == 0)
2477 else if (out
== NULL
)
2479 out
= fopen (output_file
, "w");
2483 perror (output_file
);
2486 current_output_file
= output_file
;
2490 int dir_len
= strlen (output_directory
);
2491 int i
, classname_length
= strlen (classname
);
2492 current_output_file
= ALLOC (dir_len
+ classname_length
+ 5);
2493 strcpy (current_output_file
, output_directory
);
2494 if (dir_len
> 0 && output_directory
[dir_len
-1] != '/')
2495 current_output_file
[dir_len
++] = '/';
2496 for (i
= 0; classname
[i
] != '\0'; i
++)
2498 char ch
= classname
[i
];
2501 if (flag_jni
&& ch
== '/')
2503 current_output_file
[dir_len
++] = ch
;
2505 if (emit_dependencies
)
2507 if (suppress_output
)
2509 jcf_dependency_set_dep_file ("-");
2514 /* We use `.hd' and not `.d' to avoid clashes with
2515 dependency tracking from straight compilation. */
2516 strcpy (current_output_file
+ dir_len
, ".hd");
2517 jcf_dependency_set_dep_file (current_output_file
);
2520 strcpy (current_output_file
+ dir_len
,
2521 stubs
? (flag_jni
? ".c" : ".cc") : ".h");
2522 jcf_dependency_set_target (current_output_file
);
2523 if (! suppress_output
)
2525 out
= fopen (current_output_file
, "w");
2528 perror (current_output_file
);
2533 process_file (&jcf
, out
);
2535 if (current_output_file
!= output_file
)
2536 free (current_output_file
);
2537 jcf_dependency_write ();
2540 if (out
!= NULL
&& out
!= stdout
)